9.3. Funções e operadores matemáticos

9.3. Funções e operadores matemáticos
Anterior	Acima	Capítulo 9. Funções e operadores	Principal	Próxima

9.3. Funções e operadores matemáticos #

São fornecidos operadores matemáticos para muitos tipos de dados do PostgreSQL. Para os tipos de dados sem convenção matemática padronizada (por exemplo, tipos de dados de data e hora), o comportamento real está descrito nas próximas seções.

A Tabela 9.4 descreve os operadores matemáticos disponíveis para os tipos de dados numéricos padrão. Salvo indicação em contrário, os operadores mostrados como aceitando tipo_numérico estão disponíveis para os tipos de dados smallint, integer, bigint, numeric, real e double precision. Os operadores mostrados como aceitando tipo_inteiro estão disponíveis para os tipos de dados smallint, integer e bigint. Exceto onde indicado, cada forma do operador retorna o mesmo tipo de dados do(s) seu(s) argumento(s). Chamadas envolvendo tipos de dados diferentes como argumentos, tais como integer + numeric, são resolvidas usando o tipo de dados que aparece por último nestas listas.

Tabela 9.4. Operadores matemáticos

Operador Descrição Exemplo(s)
`tipo_numérico` `+` `tipo_numérico` → `tipo_numérico` Adição `2 + 3` → `5`
`+` `tipo_numérico` → `tipo_numérico` Mais unário (sem operação) `+ 3.5` → `3.5`
`tipo_numérico` `-` `tipo_numérico` → `tipo_numérico` Subtração `2 - 3` → `-1`
`-` `tipo_numérico` → `tipo_numérico` Negação `- (-4)` → `4`
`tipo_numérico` `` `tipo_numérico`* → `tipo_numérico` Multiplicação `2 * 3` → `6`
`tipo_numérico` `/` `tipo_numérico` → `tipo_numérico` Divisão (para tipos de dados inteiros, a divisão trunca o resultado em direção ao zero) `5.0 / 2` → `2.5000000000000000` `5 / 2` → `2` `(-5) / 2` → `-2`
`tipo_numérico` `%` `tipo_numérico` → `tipo_numérico` Módulo (resto da divisão); disponível para os tipos de dados `smallint`, `integer`, `bigint` e `numeric` `5 % 4` → `1` `35 % 4` → `3`
`numeric` `^` `numeric` → `numeric` `double precision` `^` `double precision` → `double precision` Exponenciação `2 ^ 3` → `8` Ao contrário da prática matemática usual, múltiplos `^` fazem uma associação da esquerda para a direita por padrão: `2 ^ 3 ^ 3` → `512` `2 ^ (3 ^ 3)` → `134217728`
`\|/` `double precision` → `double precision` Raiz quadrada `\|/ 25.0` → `5`
`\|\|/` `double precision` → `double precision` Raiz cúbica `\|\|/ 64.0` → `4`
`@` `tipo_numérico` → `tipo_numérico` Valor absoluto `@ -5.0` → `5.0`
`tipo_inteiro` `&` `tipo_inteiro` → `tipo_inteiro` AND bit a bit `91 & 15` → `11`
`tipo_inteiro` `\|` `tipo_inteiro` → `tipo_inteiro` OR bit a bit `32 \| 3` → `35`
`tipo_inteiro` `#` `tipo_inteiro` → `tipo_inteiro` OR exclusivo bit a bit `17 # 5` → `20`
`~` `tipo_inteiro` → `tipo_inteiro` NOT bit a bit `~1` → `-2`
`tipo_inteiro` `<<` `integer` → `tipo_inteiro` Deslocamento para a esquerda bit a bit `1 << 4` → `16`
`tipo_inteiro` `>>` `integer` → `tipo_inteiro` Deslocamento para a direita bit a bit `8 >> 2` → `2`

Operador

Descrição

Exemplo(s)

tipo_numérico + tipo_numérico → tipo_numérico

Adição

2 + 3 → 5

+ tipo_numérico → tipo_numérico

Mais unário (sem operação)

+ 3.5 → 3.5

tipo_numérico - tipo_numérico → tipo_numérico

Subtração

2 - 3 → -1

- tipo_numérico → tipo_numérico

Negação

- (-4) → 4

tipo_numérico * tipo_numérico → tipo_numérico

Multiplicação

2 * 3 → 6

tipo_numérico / tipo_numérico → tipo_numérico

Divisão (para tipos de dados inteiros, a divisão trunca o resultado em direção ao zero)

5.0 / 2 → 2.5000000000000000

5 / 2 → 2

(-5) / 2 → -2

tipo_numérico % tipo_numérico → tipo_numérico

Módulo (resto da divisão); disponível para os tipos de dados smallint, integer, bigint e numeric

5 % 4 → 1

35 % 4 → 3

numeric ^ numeric → numeric

double precision ^ double precision → double precision

Exponenciação

2 ^ 3 → 8

Ao contrário da prática matemática usual, múltiplos ^ fazem uma associação da esquerda para a direita por padrão:

2 ^ 3 ^ 3 → 512

2 ^ (3 ^ 3) → 134217728

|/ double precision → double precision

Raiz quadrada

|/ 25.0 → 5

||/ double precision → double precision

Raiz cúbica

||/ 64.0 → 4

@ tipo_numérico → tipo_numérico

Valor absoluto

@ -5.0 → 5.0

tipo_inteiro & tipo_inteiro → tipo_inteiro

AND bit a bit

91 & 15 → 11

tipo_inteiro | tipo_inteiro → tipo_inteiro

OR bit a bit

32 | 3 → 35

tipo_inteiro # tipo_inteiro → tipo_inteiro

OR exclusivo bit a bit

17 # 5 → 20

~ tipo_inteiro → tipo_inteiro

NOT bit a bit

~1 → -2

tipo_inteiro << integer → tipo_inteiro

Deslocamento para a esquerda bit a bit

1 << 4 → 16

tipo_inteiro >> integer → tipo_inteiro

Deslocamento para a direita bit a bit

8 >> 2 → 2

A Tabela 9.5 descreve as funções matemáticas disponíveis. Muitas destas funções são fornecidas em várias formas com diferentes tipos de dados de argumentos. Exceto onde indicado, qualquer forma da função retorna o mesmo tipo de dados de seu(s) argumento(s); os casos de tipo-cruzado são resolvidos da mesma forma explicada acima para os operadores. As funções que trabalham com dados de precisão dupla são implementadas principalmente em cima da biblioteca C do sistema operacional hospedeiro; em casos limite, a precisão e o comportamento podem, portanto, variar dependendo do sistema operacional hospedeiro.

Tabela 9.5. Funções matemáticas

Função Descrição Exemplo(s)
`abs` ( `tipo_numérico` ) → `tipo_numérico` Valor absoluto `abs(-17.4)` → `17.4`
`cbrt` ( `double precision` ) → `double precision` Raiz cúbica `cbrt(64.0)` → `4`
`ceil` ( `numeric` ) → `numeric` `ceil` ( `double precision` ) → `double precision` Inteiro mais próximo maior ou igual ao argumento `ceil(42.2)` → `43` `ceil(-42.8)` → `-42`
`ceiling` ( `numeric` ) → `numeric` `ceiling` ( `double precision` ) → `double precision` Inteiro mais próximo maior ou igual ao argumento (idêntica à função `ceil`) `ceiling(95.3)` → `96`
`degrees` ( `double precision` ) → `double precision` Converte radianos em graus `degrees(0.5)` → `28.64788975654116`
`div` ( `y` `numeric`, `x` `numeric` ) → `numeric` Quociente inteiro de `y` / `x` (trunca em direção ao zero) `div(9, 4)` → `2`
`erf` ( `double precision` ) → `double precision` Função de erro `erf(1.0)` → `0.8427007929497149`
`erfc` ( `double precision` ) → `double precision` Função complementar de erro (`1 - erf(x)`, sem perda de precisão para entradas grandes) `erfc(1.0)` → `0.15729920705028513`
`exp` ( `numeric` ) → `numeric` `exp` ( `double precision` ) → `double precision` Exponencial (`e` elevado à potência dada) `exp(1.0)` → `2.7182818284590452`
`factorial` ( `bigint` ) → `numeric` Fatorial `factorial(5)` → `120`
`floor` ( `numeric` ) → `numeric` `floor` ( `double precision` ) → `double precision` Inteiro mais próximo menor ou igual ao argumento `floor(42.8)` → `42` `floor(-42.8)` → `-43`
`gamma` ( `double precision` ) → `double precision` Função gama `gamma(0.5)` → `1.772453850905516` `gamma(6)` → `120`
`gcd` ( `tipo_numérico`, `tipo_numérico` ) → `tipo_numérico` Máximo divisor comum - MDC (Greatest common divisor - GCD) (o maior número positivo que divide as duas entradas sem resto); retorna `0` se as duas entradas forem iguais a zero; disponível para os tipos de dados `integer`, `bigint` e `numeric` `gcd(1071, 462)` → `21`
`lcm` ( `tipo_numérico`, `tipo_numérico` ) → `tipo_numérico` Mínimo múltiplo comum - MMC (Least common multiple - LCM) (o menor número inteiro positivo que é múltiplo das duas entradas); retorna `0` se qualquer uma das entradas for igual a zero; disponível para os tipos de dados `integer`, `bigint` e `numeric` `lcm(1071, 462)` → `23562`
`lgamma` ( `double precision` ) → `double precision` Logaritmo natural do valor absoluto da função gama `lgamma(1000)` → `5905.220423209181`
`ln` ( `numeric` ) → `numeric` `ln` ( `double precision` ) → `double precision` Logaritmo natural (neperiano) `ln(2.0)` → `0.6931471805599453`
`log` ( `numeric` ) → `numeric` `log` ( `double precision` ) → `double precision` Logaritmo na base 10 `log(100)` → `2`
`log10` ( `numeric` ) → `numeric` `log10` ( `double precision` ) → `double precision` Logaritmo na base 10 (idêntica à função `log`) `log10(1000)` → `3`
`log` ( `b` `numeric`, `x` `numeric` ) → `numeric` Logaritmo de `x` na base `b` `log(2.0, 64.0)` → `6.0000000000000000`
`min_scale` ( `numeric` ) → `integer` Escala mínima (número de dígitos decimais fracionários) necessária para representar o valor fornecido com precisão `min_scale(8.4100)` → `2`
`mod` ( `y` `tipo_numérico`, `x` `tipo_numérico` ) → `tipo_numérico` Resto de `y` / `x`; disponível para os tipos de dados `smallint`, `integer`, `bigint` e `numeric` `mod(9, 4)` → `1`
`pi` ( ) → `double precision` Valor aproximado de π `pi()` → `3.141592653589793`
`power` ( `a` `numeric`, `b` `numeric` ) → `numeric` `power` ( `a` `double precision`, `b` `double precision` ) → `double precision` `a` elevado a `b` `power(9, 3)` → `729`
`radians` ( `double precision` ) → `double precision` Converte graus em radianos `radians(45.0)` → `0.7853981633974483`
`round` ( `numeric` ) → `numeric` `round` ( `double precision` ) → `double precision` Arredonda para o número inteiro mais próximo. Para o tipo de dados `numeric`, em caso de empate os desempates são resolvidos arredondando para longe de zero. Para o tipo de dados `double precision`, o comportamento do desempate é dependente da plataforma, mas “arredondar para o número inteiro mais próximo” é a regra mais comum. `round(42.4)` → `42`
`round` ( `v` `numeric`, `s` `integer` ) → `numeric` Arredonda `v` com `s` casas decimais. Em caso de empate, o desempate é feito arredondando o valor para longe de zero. `round(42.4382, 2)` → `42.44` `round(1234.56, -1)` → `1230`
`scale` ( `numeric` ) → `integer` Escala do argumento (número de dígitos decimais na parte fracionária) `scale(8.4100)` → `4`
`sign` ( `numeric` ) → `numeric` `sign` ( `double precision` ) → `double precision` Sinal do argumento (-1, 0, ou +1) `sign(-8.4)` → `-1`
`sqrt` ( `numeric` ) → `numeric` `sqrt` ( `double precision` ) → `double precision` Raiz quadrada `sqrt(2)` → `1.4142135623730951`
`trim_scale` ( `numeric` ) → `numeric` Reduz a escala do valor (número de dígitos decimais fracionários) removendo os zeros à direita `trim_scale(8.4100)` → `8.41`
`trunc` ( `numeric` ) → `numeric` `trunc` ( `double precision` ) → `double precision` Trunca para inteiro (em direção ao zero) `trunc(42.8)` → `42` `trunc(-42.8)` → `-42`
`trunc` ( `v` `numeric`, `s` `integer` ) → `numeric` Trunca `v` para `s` casas decimais `trunc(42.4382, 2)` → `42.43`
`width_bucket` ( `operando` `numeric`, `low` `numeric`, `high` `numeric`, `contador` `integer` ) → `integer` `width_bucket` ( `operando` `double precision`, `low` `double precision`, `high` `double precision`, `contador` `integer` ) → `integer` Retorna o número do intervalo (bucket) onde o `operando` estaria em um histograma que possui `contador` intervalos de larguras iguais abrangendo o intervalo de `low` a `high`. Os intervalos possuem limites inferiores inclusivos e limites superiores exclusivos. Retorna `0` para uma entrada menor que `low` ou `contador+1` para uma entrada maior ou igual a `high`. Se `low` > `high`, o comportamento é espelhado ao contrário, com o intervalo `1` agora sendo aquele logo abaixo de `low`, e os limites inclusivos agora estão no lado superior. `width_bucket(5.35, 0.024, 10.06, 5)` → `3` `width_bucket(9, 10, 0, 10)` → `2`
`width_bucket` ( `operando` `anycompatible`, `thresholds` `anycompatiblearray` ) → `integer` Retorna o número do intervalo (bucket) em que `operando` estaria, dada uma matriz contendo os limites inferiores inclusivos dos intervalos. Retorna `0` para uma entrada menor que o primeiro limite inferior. O `operando` e os elementos da matriz podem ser de quaisquer tipo de dados que possua operadores de comparação padrão. A matriz dos limites (`thresholds`) deverá estar ordenada, com o valor menor primeiro, senão serão obtidos resultados inesperadps. `width_bucket(now(), array['yesterday', 'today', 'tomorrow']::timestamptz[])` → `2` `width_bucket(CURRENT_DATE - INTERVAL '1 day', array['yesterday', 'today', 'tomorrow']::timestamptz[])` → `1` `width_bucket(CURRENT_DATE + INTERVAL '1 day', array['yesterday', 'today', 'tomorrow']::timestamptz[])` → `3`

Função

Descrição

Exemplo(s)

abs ( tipo_numérico ) → tipo_numérico

Valor absoluto

abs(-17.4) → 17.4

cbrt ( double precision ) → double precision

Raiz cúbica

cbrt(64.0) → 4

ceil ( numeric ) → numeric

ceil ( double precision ) → double precision

Inteiro mais próximo maior ou igual ao argumento

ceil(42.2) → 43

ceil(-42.8) → -42

ceiling ( numeric ) → numeric

ceiling ( double precision ) → double precision

Inteiro mais próximo maior ou igual ao argumento (idêntica à função ceil)

ceiling(95.3) → 96

degrees ( double precision ) → double precision

Converte radianos em graus

degrees(0.5) → 28.64788975654116

div ( y numeric, x numeric ) → numeric

Quociente inteiro de y / x (trunca em direção ao zero)

div(9, 4) → 2

erf ( double precision ) → double precision

Função de erro

erf(1.0) → 0.8427007929497149

erfc ( double precision ) → double precision

Função complementar de erro (1 - erf(x), sem perda de precisão para entradas grandes)

erfc(1.0) → 0.15729920705028513

exp ( numeric ) → numeric

exp ( double precision ) → double precision

Exponencial (e elevado à potência dada)

exp(1.0) → 2.7182818284590452

factorial ( bigint ) → numeric

Fatorial

factorial(5) → 120

floor ( numeric ) → numeric

floor ( double precision ) → double precision

Inteiro mais próximo menor ou igual ao argumento

floor(42.8) → 42

floor(-42.8) → -43

gamma ( double precision ) → double precision

Função gama

gamma(0.5) → 1.772453850905516

gamma(6) → 120

gcd ( tipo_numérico, tipo_numérico ) → tipo_numérico

Máximo divisor comum - MDC (Greatest common divisor - GCD) (o maior número positivo que divide as duas entradas sem resto); retorna 0 se as duas entradas forem iguais a zero; disponível para os tipos de dados integer, bigint e numeric

gcd(1071, 462) → 21

lcm ( tipo_numérico, tipo_numérico ) → tipo_numérico

Mínimo múltiplo comum - MMC (Least common multiple - LCM) (o menor número inteiro positivo que é múltiplo das duas entradas); retorna 0 se qualquer uma das entradas for igual a zero; disponível para os tipos de dados integer, bigint e numeric

lcm(1071, 462) → 23562

lgamma ( double precision ) → double precision

Logaritmo natural do valor absoluto da função gama

lgamma(1000) → 5905.220423209181

ln ( numeric ) → numeric

ln ( double precision ) → double precision

Logaritmo natural (neperiano)

ln(2.0) → 0.6931471805599453

log ( numeric ) → numeric

log ( double precision ) → double precision

Logaritmo na base 10

log(100) → 2

log10 ( numeric ) → numeric

log10 ( double precision ) → double precision

Logaritmo na base 10 (idêntica à função log)

log10(1000) → 3

log ( b numeric, x numeric ) → numeric

Logaritmo de x na base b

log(2.0, 64.0) → 6.0000000000000000

min_scale ( numeric ) → integer

Escala mínima (número de dígitos decimais fracionários) necessária para representar o valor fornecido com precisão

min_scale(8.4100) → 2

mod ( y tipo_numérico, x tipo_numérico ) → tipo_numérico

Resto de y / x; disponível para os tipos de dados smallint, integer, bigint e numeric

mod(9, 4) → 1

pi ( ) → double precision

Valor aproximado de π

pi() → 3.141592653589793

power ( a numeric, b numeric ) → numeric

power ( a double precision, b double precision ) → double precision

a elevado a b

power(9, 3) → 729

radians ( double precision ) → double precision

Converte graus em radianos

radians(45.0) → 0.7853981633974483

round ( numeric ) → numeric

round ( double precision ) → double precision

Arredonda para o número inteiro mais próximo. Para o tipo de dados numeric, em caso de empate os desempates são resolvidos arredondando para longe de zero. Para o tipo de dados double precision, o comportamento do desempate é dependente da plataforma, mas “arredondar para o número inteiro mais próximo” é a regra mais comum.

round(42.4) → 42

round ( v numeric, s integer ) → numeric

Arredonda v com s casas decimais. Em caso de empate, o desempate é feito arredondando o valor para longe de zero.

round(42.4382, 2) → 42.44

round(1234.56, -1) → 1230

scale ( numeric ) → integer

Escala do argumento (número de dígitos decimais na parte fracionária)

scale(8.4100) → 4

sign ( numeric ) → numeric

sign ( double precision ) → double precision

Sinal do argumento (-1, 0, ou +1)

sign(-8.4) → -1

sqrt ( numeric ) → numeric

sqrt ( double precision ) → double precision

Raiz quadrada

sqrt(2) → 1.4142135623730951

trim_scale ( numeric ) → numeric

Reduz a escala do valor (número de dígitos decimais fracionários) removendo os zeros à direita

trim_scale(8.4100) → 8.41

trunc ( numeric ) → numeric

trunc ( double precision ) → double precision

Trunca para inteiro (em direção ao zero)

trunc(42.8) → 42

trunc(-42.8) → -42

trunc ( v numeric, s integer ) → numeric

Trunca v para s casas decimais

trunc(42.4382, 2) → 42.43

width_bucket ( operando numeric, low numeric, high numeric, contador integer ) → integer

width_bucket ( operando double precision, low double precision, high double precision, contador integer ) → integer

Retorna o número do intervalo (bucket) onde o operando estaria em um histograma que possui contador intervalos de larguras iguais abrangendo o intervalo de low a high. Os intervalos possuem limites inferiores inclusivos e limites superiores exclusivos. Retorna 0 para uma entrada menor que low ou contador+1 para uma entrada maior ou igual a high. Se low > high, o comportamento é espelhado ao contrário, com o intervalo 1 agora sendo aquele logo abaixo de low, e os limites inclusivos agora estão no lado superior.

width_bucket(5.35, 0.024, 10.06, 5) → 3

width_bucket(9, 10, 0, 10) → 2

width_bucket ( operando anycompatible, thresholds anycompatiblearray ) → integer

Retorna o número do intervalo (bucket) em que operando estaria, dada uma matriz contendo os limites inferiores inclusivos dos intervalos. Retorna 0 para uma entrada menor que o primeiro limite inferior. O operando e os elementos da matriz podem ser de quaisquer tipo de dados que possua operadores de comparação padrão. A matriz dos limites (thresholds) deverá estar ordenada, com o valor menor primeiro, senão serão obtidos resultados inesperadps.

width_bucket(now(), array['yesterday', 'today', 'tomorrow']::timestamptz[]) → 2

width_bucket(CURRENT_DATE - INTERVAL '1 day', array['yesterday', 'today', 'tomorrow']::timestamptz[]) → 1

width_bucket(CURRENT_DATE + INTERVAL '1 day', array['yesterday', 'today', 'tomorrow']::timestamptz[]) → 3

A Tabela 9.6 descreve as funções para gerar números aleatórios.

Tabela 9.6. Funções geradoras de número aleatório

Função Descrição Exemplo(s)
`random` ( ) → `double precision` Retorna um valor aleatório no intervalo 0.0 <= x < 1.0 `random()` → `0.897124072839091`
`random` ( `min` `integer`, `max` `integer` ) → `integer` `random` ( `min` `bigint`, `max` `bigint` ) → `bigint` `random` ( `min` `numeric`, `max` `numeric` ) → `numeric` Retorna um valor aleatório no intervalo `min` <= x <= `max`. Para o tipo de dados `numeric` o resultado terá o mesmo número de dígitos decimais fracionários que `min` ou `max`, aquele que tiver mais. `random(1, 10)` → `7` `random(-0.499, 0.499)` → `0.347`
`random_normal` ( [ `mean` `double precision` [, `stddev` `double precision` ]] ) → `double precision` Retorna um valor aleatório da distribuição normal com os parâmetros fornecidos; o valor padrão de `mean` é 0.0 e o valor padrão de `stddev` é 1.0 `random_normal(0.0, 1.0)` → `0.051285419`
`setseed` ( `double precision` ) → `void` Define a raiz para as próximas chamadas de `random()` e `random_normal()`; o argumento deve estar entre -1.0 e 1.0, inclusive. `setseed(0.12345)`

Função

Descrição

Exemplo(s)

random ( ) → double precision

Retorna um valor aleatório no intervalo 0.0 <= x < 1.0

random() → 0.897124072839091

random ( min integer, max integer ) → integer

random ( min bigint, max bigint ) → bigint

random ( min numeric, max numeric ) → numeric

Retorna um valor aleatório no intervalo min <= x <= max. Para o tipo de dados numeric o resultado terá o mesmo número de dígitos decimais fracionários que min ou max, aquele que tiver mais.

random(1, 10) → 7

random(-0.499, 0.499) → 0.347

random_normal ( [ mean double precision [, stddev double precision ]] ) → double precision

Retorna um valor aleatório da distribuição normal com os parâmetros fornecidos; o valor padrão de mean é 0.0 e o valor padrão de stddev é 1.0

random_normal(0.0, 1.0) → 0.051285419

setseed ( double precision ) → void

Define a raiz para as próximas chamadas de random() e random_normal(); o argumento deve estar entre -1.0 e 1.0, inclusive.

setseed(0.12345)

As funções random() e random_normal() listadas na Tabela 9.6 usam um gerador de números pseudoaleatórios determinístico, que é rápido mas não é adequado para aplicações de criptografia; deve ser usado o módulo pgcrypto para obter uma alternativa mais segura. Se a função setseed() for chamada, a série de resultados das chamadas subsequentes a estas funções na sessão corrente pode ser repetida chamando novamente setseed() com o mesmo argumento. Sem nenhuma chamada prévia de setseed() na mesma sessão, a primeira chamada a qualquer uma destas funções obtém uma semente de uma fonte de bits aleatórios dependente da plataforma.

A Tabela 9.7 descreve as funções trigonométricas disponíveis. Cada uma destas funções possui duas formas alternativas: uma que mede ângulos em radianos, e outra que mede ângulos em graus.

Tabela 9.7. Funções trigonométricas

Função Descrição Exemplo(s)
`acos` ( `double precision` ) → `double precision` Cosseno inverso (arco cosseno), resultado em radianos `acos(1)` → `0`
`acosd` ( `double precision` ) → `double precision` Cosseno inverso (arco cosseno), resultado em graus `acosd(0.5)` → `60`
`asin` ( `double precision` ) → `double precision` Seno inverso (arco seno), resultado em radianos `asin(1)` → `1.5707963267948966`
`asind` ( `double precision` ) → `double precision` Seno inverso (arco seno), resultado em graus `asind(0.5)` → `30`
`atan` ( `double precision` ) → `double precision` Tangente inversa (arco tangente), resultado em radianos `atan(1)` → `0.7853981633974483`
`atand` ( `double precision` ) → `double precision` Tangente inversa (arco tangente), resultado em graus `atand(1)` → `45`
`atan2` ( `y` `double precision`, `x` `double precision` ) → `double precision` Tangente inversa (arco tangente) de `y` / `x`, resultado em radianos `atan2(1, 0)` → `1.5707963267948966`
`atan2d` ( `y` `double precision`, `x` `double precision` ) → `double precision` Tangente inversa (arco tangente) de `y` / `x`, resultado em graus `atan2d(1, 0)` → `90`
`cos` ( `double precision` ) → `double precision` Cosseno, argumento in radianos `cos(0)` → `1`
`cosd` ( `double precision` ) → `double precision` Cosseno, argumento in graus `cosd(60)` → `0.5`
`cot` ( `double precision` ) → `double precision` Cotangente, argumento in radianos `cot(0.5)` → `1.830487721712452`
`cotd` ( `double precision` ) → `double precision` Cotangente, argumento in graus `cotd(45)` → `1`
`sin` ( `double precision` ) → `double precision` Seno, argumento in radianos `sin(1)` → `0.8414709848078965`
`sind` ( `double precision` ) → `double precision` Seno, argumento in graus `sind(30)` → `0.5`
`tan` ( `double precision` ) → `double precision` Tangente, argumento in radianos `tan(1)` → `1.5574077246549023`
`tand` ( `double precision` ) → `double precision` Tangente, argumento in graus `tand(45)` → `1`

Função

Descrição

Exemplo(s)

acos ( double precision ) → double precision

Cosseno inverso (arco cosseno), resultado em radianos

acos(1) → 0

acosd ( double precision ) → double precision

Cosseno inverso (arco cosseno), resultado em graus

acosd(0.5) → 60

asin ( double precision ) → double precision

Seno inverso (arco seno), resultado em radianos

asin(1) → 1.5707963267948966

asind ( double precision ) → double precision

Seno inverso (arco seno), resultado em graus

asind(0.5) → 30

atan ( double precision ) → double precision

Tangente inversa (arco tangente), resultado em radianos

atan(1) → 0.7853981633974483

atand ( double precision ) → double precision

Tangente inversa (arco tangente), resultado em graus

atand(1) → 45

atan2 ( y double precision, x double precision ) → double precision

Tangente inversa (arco tangente) de y / x, resultado em radianos

atan2(1, 0) → 1.5707963267948966

atan2d ( y double precision, x double precision ) → double precision

Tangente inversa (arco tangente) de y / x, resultado em graus

atan2d(1, 0) → 90

cos ( double precision ) → double precision

Cosseno, argumento in radianos

cos(0) → 1

cosd ( double precision ) → double precision

Cosseno, argumento in graus

cosd(60) → 0.5

cot ( double precision ) → double precision

Cotangente, argumento in radianos

cot(0.5) → 1.830487721712452

cotd ( double precision ) → double precision

Cotangente, argumento in graus

cotd(45) → 1

sin ( double precision ) → double precision

Seno, argumento in radianos

sin(1) → 0.8414709848078965

sind ( double precision ) → double precision

Seno, argumento in graus

sind(30) → 0.5

tan ( double precision ) → double precision

Tangente, argumento in radianos

tan(1) → 1.5574077246549023

tand ( double precision ) → double precision

Tangente, argumento in graus

tand(45) → 1

Nota

Outra maneira de trabalhar com ângulos medidos em graus é usar as funções de transformação de unidade radians() e degrees() vistas anteriormente. Entretanto, é preferível usar as funções trigonométricas baseadas em graus, porque assim são evitados erros de arredondamento para casos especiais como sind(30).

A Tabela 9.8 descreve as funções hiperbólicas disponíveis.

Tabela 9.8. Funções hiperbólicas

Função Descrição Exemplo(s)
`sinh` ( `double precision` ) → `double precision` Seno hiperbólico `sinh(1)` → `1.1752011936438014`
`cosh` ( `double precision` ) → `double precision` Cosseno hiperbólico `cosh(0)` → `1`
`tanh` ( `double precision` ) → `double precision` Tangente hiperbólica `tanh(1)` → `0.7615941559557649`
`asinh` ( `double precision` ) → `double precision` Seno hiperbólico inverso `asinh(1)` → `0.881373587019543`
`acosh` ( `double precision` ) → `double precision` Cosseno hiperbólico inverso `acosh(1)` → `0`
`atanh` ( `double precision` ) → `double precision` Tangente hiperbólica inversa `atanh(0.5)` → `0.5493061443340548`

Função

Descrição

Exemplo(s)

sinh ( double precision ) → double precision

Seno hiperbólico

sinh(1) → 1.1752011936438014

cosh ( double precision ) → double precision

Cosseno hiperbólico

cosh(0) → 1

tanh ( double precision ) → double precision

Tangente hiperbólica

tanh(1) → 0.7615941559557649

asinh ( double precision ) → double precision

Seno hiperbólico inverso

asinh(1) → 0.881373587019543

acosh ( double precision ) → double precision

Cosseno hiperbólico inverso

acosh(1) → 0

atanh ( double precision ) → double precision

Tangente hiperbólica inversa

atanh(0.5) → 0.5493061443340548