"math" --- Funções matemáticas
******************************

======================================================================

Este módulo fornece acesso à constantes e funções matemáticas comuns,
incluindo aquelas definidas pelo padrão C.

Essas funções não podem ser usadas com números complexos; use as
funções de mesmo nome do módulo "cmath" se você precisar de suporte
para números complexos. A distinção entre funções que suportam números
complexos e aquelas que não suportam é feita uma vez que a maioria dos
usuários não quer aprender a matemática necessária para entender
números complexos. Receber uma exceção em vez de um resultado complexo
permite a detecção antecipada do número complexo inesperado usado como
parâmetro, para que o programador possa determinar como e por que ele
foi gerado em primeiro lugar.

As funções a seguir são fornecidas por este módulo. Exceto quando
explicitamente indicado de outra forma, todos os valores de retorno
são pontos flutuantes.

+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Arimética de ponto flutuante**                                                                                                                                              |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "ceil(x)"                                            | Teto de *x*, o menor número inteiro maior ou igual a *x*                                                               |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "fabs(x)"                                            | Valor absoluto de *x*                                                                                                  |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "floor(x)"                                           | Piso de *x*, o maior inteiro menor ou igual a *x*                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "fma(x, y, z)"                                       | Operação de multiplicação e adição combinadas: "(x * y) + z"                                                           |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "fmax(x, y)"                                         | Maximum of two floating-point values                                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "fmin(x, y)"                                         | Minimum of two floating-point values                                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "fmod(x, y)"                                         | Resto da divisão "x / y"                                                                                               |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "modf(x)"                                            | Partes fracionárias e inteiras de *x*                                                                                  |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "remainder(x, y)"                                    | Resto de *x* em relação a *y*                                                                                          |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "trunc(x)"                                           | Parte inteira de *x*                                                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Funções de manipulação de ponto flutuante**                                                                                                                                 |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "copysign(x, y)"                                     | Magnitude (valor absoluto) de *x* com o sinal de *y*                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "frexp(x)"                                           | Mantissa e expoente de *x*                                                                                             |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "isclose(a, b, rel_tol, abs_tol)"                    | Verifica se os valores *a* e *b* estão próximos um do outro                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "isfinite(x)"                                        | Verifica se *x* não é infinito e nem um NaN                                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "isnormal(x)"                                        | Check if *x* is a normal number                                                                                        |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "issubnormal(x)"                                     | Check if *x* is a subnormal number                                                                                     |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "isinf(x)"                                           | Verifica se *x* é um infinito positivo ou negativo                                                                     |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "isnan(x)"                                           | Verifica se *x* é um NaN (não um número)                                                                               |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "ldexp(x, i)"                                        | "x * (2**i)", inverso da função "frexp()"                                                                              |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "nextafter(x, y, steps)"                             | Valor de ponto flutuante de *steps* passos depois de *x* em direção a *y*                                              |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "signbit(x)"                                         | Check if *x* is a negative number                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "ulp(x)"                                             | Valor do bit menos significativo de *x*                                                                                |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Funções de potências, exponenciais e logarítmicas**                                                                                                                         |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "cbrt(x)"                                            | Raiz cúbica de *x*                                                                                                     |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "exp(x)"                                             | *e* elevado à potência *x*                                                                                             |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "exp2(x)"                                            | *2* elevado a potência de *x*                                                                                          |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "expm1(x)"                                           | *e* elevado a potência de *x*, menos 1                                                                                 |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "log(x, base)"                                       | Logaritmo de *x* para a base fornecida (*e* por padrão)                                                                |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "log1p(x)"                                           | Logaritmo natural de *1+x* (base *e*)                                                                                  |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "log2(x)"                                            | Logaritmo de base 2 de *x*                                                                                             |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "log10(x)"                                           | Logaritmo de base 10 de *x*                                                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "pow(x, y)"                                          | *x* elevado à potência *y*                                                                                             |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "sqrt(x)"                                            | Raiz quadrada de *x*                                                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Funções de soma e produto**                                                                                                                                                 |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "dist(p, q)"                                         | Distância euclidiana entre dois pontos *p* e *q* dada como um iterável de coordenadas                                  |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "fsum(iterable)"                                     | Soma dos valores na entrada *iterable*                                                                                 |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "hypot(*coordinates)"                                | Norma euclidiana de um iterável de coordenadas                                                                         |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "prod(iterable, start)"                              | Produto de elementos da entrada *iterable* com um valor *start*                                                        |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "sumprod(p, q)"                                      | Soma dos produtos de dois iteráveis *p* e *q*                                                                          |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Conversão angular**                                                                                                                                                         |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "degrees(x)"                                         | Converte o ângulo *x* de radianos para graus                                                                           |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "radians(x)"                                         | Converte o ângulo *x* de graus para radianos                                                                           |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Funções trigonométricas**                                                                                                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "acos(x)"                                            | Arco cosseno de *x*                                                                                                    |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "asin(x)"                                            | Arco seno de *x*/                                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "atan(x)"                                            | Arco tangente de *x*                                                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "atan2(y, x)"                                        | "atan(y / x)"                                                                                                          |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "cos(x)"                                             | Cosseno de *x*                                                                                                         |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "sin(x)"                                             | Seno de *x*                                                                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "tan(x)"                                             | Tangente de *x*                                                                                                        |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Funções hiperbólicas**                                                                                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "acosh(x)"                                           | Cosseno hiperbólico inverso de *x*                                                                                     |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "asinh(x)"                                           | Seno hiperbólico inverso de *x*                                                                                        |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "atanh(x)"                                           | Tangente hiperbólico inverso de *x*                                                                                    |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "cosh(x)"                                            | Cosseno hiperbólico de *x*                                                                                             |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "sinh(x)"                                            | Seno hiperbólico de *x*                                                                                                |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "tanh(x)"                                            | Tangente hiperbólico de *x*                                                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Funções especiais**                                                                                                                                                         |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "erf(x)"                                             | Função erro em *x*                                                                                                     |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "erfc(x)"                                            | Função erro complementar em *x*                                                                                        |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "gamma(x)"                                           | Função gama em *x*                                                                                                     |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "lgamma(x)"                                          | Logaritmo natural do valor absoluto da função gama em *x*                                                              |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Constantes**                                                                                                                                                                |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "pi"                                                 | *π* = 3.141592...                                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "e"                                                  | *e* = 2.718281...                                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "tau"                                                | *τ* = 2*π* = 6.283185...                                                                                               |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "inf"                                                | Infinito positivo                                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "nan"                                                | "Not a number" (NaN)                                                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+


Arimética de ponto flutuante
============================

math.ceil(x)

   Retorna o teto de *x*, o menor inteiro maior ou igual que *x*. Se
   *x* não é um float, delega para "x.__ceil__", que deve retornar um
   valor do tipo "Integral".

math.fabs(x)

   Retorna o valor absoluto de *x*.

math.floor(x)

   Retorna o chão de *x*, o maior inteiro menor ou igual a *x*. Se *x*
   não é um ponto flutuante, delega para "x.__floor__", que deve
   retornar um valor do tipo "Integral"

math.fma(x, y, z)

   Operação de multiplicação-adição combinada. Retorna "(x * y) + z",
   calculado de forma a obter o mesmo resultado que seria obtido se o
   cálculo desfrutasse de precisão e limites infinitos, seguido de um
   único arredondamento para o formato "float". Esta operação
   frequentemente oferece acurácia melhor do que a expressão direta
   "(x * y) + z" ofereceria.

   Esta função segue a especificação da operação fusedMultiplyAdd
   descrita no padrão IEEE 754. O padrão deixa um caso a ser definido
   pela implementação, que são os resultados de "fma(0, inf, nan)" e
   "fma(inf, 0, nan)". Nestes casos, "math.fma" retorna NaN, e não
   levanta nenhuma exceção.

   Adicionado na versão 3.13.

math.fmax(x, y)

   Get the larger of two floating-point values, treating NaNs as
   missing data.

   When both operands are (signed) NaNs or zeroes, return "nan" and
   "0" respectively and the sign of the result is implementation-
   defined, that is, "fmax()" is not required to be sensitive to the
   sign of such operands (see Annex F of the C11 standard, §F.10.0.3
   and §F.10.9.2).

   Adicionado na versão 3.15.

math.fmin(x, y)

   Get the smaller of two floating-point values, treating NaNs as
   missing data.

   When both operands are (signed) NaNs or zeroes, return "nan" and
   "0" respectively and the sign of the result is implementation-
   defined, that is, "fmin()" is not required to be sensitive to the
   sign of such operands (see Annex F of the C11 standard, §F.10.0.3
   and §F.10.9.3).

   Adicionado na versão 3.15.

math.fmod(x, y)

   Retorna o resto ponto flutuante de "x / y", conforme definido pela
   função "fmod(x, y)" da biblioteca C da plataforma. Observe que a
   expressão Python "x % y" pode não retornar o mesmo resultado. A
   intenção do padrão C é que "fmod(x, y)" seja exatamente
   (matematicamente; com precisão infinita) igual a "x - n*y" para
   algum inteiro *n* de modo que o resultado tenha o mesmo sinal que
   *x* e magnitude menor que "abs(y)". O "x % y" do Python retorna um
   resultado com o sinal de *y*, e pode não ser exatamente computável
   para argumentos de ponto flutuante. Por exemplo, "fmod(-1e-100,
   1e100)" é "-1e-100", mas o resultado de "-1e-100 % 1e100" do Python
   é "1e100-1e-100", que não pode ser representado exatamente como um
   ponto flutuante, e é arredondado para o surpreendente "1e100". Por
   esta razão, a função "fmod()" é geralmente preferida ao trabalhar
   com pontos flutuantes, enquanto o "x % y" do Python é preferido ao
   trabalhar com inteiros.

math.modf(x)

   Retorna as partes fracionárias e inteiras de *x*. Ambos os
   resultados carregam o sinal de *x* e são pontos flutuantes.

   Observe que "modf()" tem um padrão de chamada/retorno diferente de
   seu equivalente C: elas pegam um único argumento e retornam um par
   de valores, ao invés de retornar seu segundo valor de retorno por
   meio de um "parâmetro de saída" (não existe tal coisa em Python).

math.remainder(x, y)

   Retorna o resto no estilo IEEE 754 de *x* em relação a *y*. Para o
   finito *x* e o finito diferente de zero *y*, esta é a diferença "x
   - n*y", onde "n" é o número inteiro mais próximo do valor exato do
   quociente "x / y" . Se "x / y" está exatamente no meio do caminho
   entre dois inteiros consecutivos, o inteiro *par* mais próximo é
   usado para "n". O resto "r = remainder(x, y)" assim sempre satisfaz
   "abs(r) <= 0.5 * abs(y)".

   Casos especiais seguem IEEE 754: em particular, "remainder(x,
   math.inf)" é *x* para qualquer *x* finito, e "remainder(x, 0)" e
   "remainder(math.inf, x)" levantam "ValueError" para qualquer *x*
   não NaN. Se o resultado da operação "remainder" for zero, esse zero
   terá o mesmo sinal de *x*.

   Em plataformas que usam ponto flutuante binário do IEEE 754, o
   resultado dessa operação é sempre exatamente representável: nenhum
   erro de arredondamento é introduzido.

   Adicionado na versão 3.7.

math.trunc(x)

   Retorna *x* com a parte fracionária removida, deixando a parte
   inteira. Isso arredonda para 0: "trunc()" é equivalente a "floor()"
   para *x* positivos, e equivalentes a "ceil()" para *x* negativos.
   Se *x* não é um ponto flutuante, então delega para "x.__trunc__",
   cujo qual deve retornar um valor do tipo "Integral".

Para as funções "ceil()", "floor()" e "modf()", observe que *todos* os
números de ponto flutuante de magnitude suficientemente grande são
inteiros exatos. Os pontos flutuantes do Python normalmente não
carregam mais do que 53 bits de precisão (o mesmo que o tipo duplo da
plataforma C), caso em que qualquer ponto flutuante *x* com "abs(x) >=
2**52" necessariamente não tem bits fracionários.


Funções de manipulação de ponto flutuante
=========================================

math.copysign(x, y)

   Retorna um ponto flutuante com a magnitude (valor absoluto) de *x*,
   mas o sinal de *y*. Em plataformas que suportam zeros com sinal,
   "copysign(1.0, -0.0)" retorna *-1.0*.

math.frexp(x)

   Retorna a mantissa e o expoente de *x* como o par "(m, e)". *m* é
   um ponto flutuante e *e* é um inteiro tal que "x == m * 2**e"
   exatamente. Se *x* for zero, retorna "(0.0, 0)", caso contrário,
   "0.5 <= abs(m) < 1". Isso é usado para "separar" a representação
   interna de um ponto flutuante de forma portátil.

   Observe que "frexp()" tem um padrão de chamada/retorno diferente de
   seu equivalente C: elas pegam um único argumento e retornam um par
   de valores, ao invés de retornar seu segundo valor de retorno por
   meio de um "parâmetro de saída" (não existe tal coisa em Python).

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

   Retorna "True" se os valores *a* e *b* estiverem próximos e "False"
   caso contrário.

   Se dois valores são considerados próximos ou não é determinado de
   acordo com tolerâncias absolutas e relativas fornecidas. Se nenhum
   erro ocorrer, o resultado será: "abs(a-b) <= max(rel_tol *
   max(abs(a), abs(b)), abs_tol)".

   *rel_tol* é a tolerância relativa -- é a diferença máxima permitida
   entre *a* e *b*, em relação ao maior valor absoluto de *a* ou *b*.
   Por exemplo, para definir uma tolerância de 5%, passe
   "rel_tol=0.05". A tolerância padrão é "1e-09", o que garante que os
   dois valores sejam iguais em cerca de 9 dígitos decimais. *rel_tol*
   deve ser não negativo e menor que "1.0".

   *abs_tol* é a tolerância absoluta; o padrão é "0.0" e deve ser não
   negativo. Ao comparar "x" com "0.0", "isclose(x, 0)" é computado
   como "abs(x) <= rel_tol * abs(x)", que é "False" para qualquer "x"
   não zero e *rel_tol* menor que "1.0". Então adicione um argumento
   *abs_tol* positivo apropriado à chamada.

   Os valores especiais do IEEE 754 de "NaN", "inf" e "-inf" serão
   tratados de acordo com as regras do IEEE. Especificamente, "NaN"
   não é considerado próximo a qualquer outro valor, incluindo "NaN".
   "inf" e "-inf" são considerados apenas próximos a si mesmos.

   Adicionado na versão 3.5.

   Ver também:

     **PEP 485** -- Uma função para testar igualdade aproximada

math.isfinite(x)

   Retorna "True" se *x* não for um infinito nem um NaN, e "False"
   caso contrário.  (Observe que "0.0" *é* considerado finito.)

   Adicionado na versão 3.2.

math.isnormal(x)

   Return "True" if *x* is a normal number, that is a finite nonzero
   number that is not a subnormal (see "issubnormal()"). Return
   "False" otherwise.

   Adicionado na versão 3.15.

math.issubnormal(x)

   Return "True" if *x* is a subnormal number, that is a finite
   nonzero number with a magnitude smaller than "sys.float_info.min".
   Return "False" otherwise.

   Adicionado na versão 3.15.

math.isinf(x)

   Retorna "True" se *x* for um infinito positivo ou negativo, e
   "False" caso contrário.

math.isnan(x)

   Retorna "True" se *x* for um NaN (não um número), e "False" caso
   contrário.

math.ldexp(x, i)

   Retorna "x * (2**i)". Este é essencialmente o inverso da função
   "frexp()".

math.nextafter(x, y, steps=1)

   Retorna o valor de ponto flutuante com *steps* passos após *x* em
   direção a *y*.

   Se *x* for igual a *y*, retorna *y*, a menos que *steps* seja zero.

   Exemplos:

   * "math.nextafter(x, math.inf)" sobe: em direção ao infinito
     positivo.

   * "math.nextafter(x, -math.inf)" desce: em direção ao menos
     infinito.

   * "math.nextafter(x, 0.0)" vai em direção a zero.

   * "math.nextafter(x, math.copysign(math.inf, x))" se afasta do
     zero.

   Veja também "math.ulp.()"

   Adicionado na versão 3.9.

   Alterado na versão 3.12: Adicionado o argumento *steps*.

math.signbit(x)

   Return "True" if the sign of *x* is negative and "False" otherwise.

   This is useful to detect the sign bit of zeroes, infinities and
   NaNs.

   Adicionado na versão 3.15.

math.ulp(x)

   Retorna o valor do bit menos significativo do ponto flutuante *x*:

   * Se *x* for um NaN (não um número), retorna *x*.

   * Se *x* for negativo, retorna "ulp(-x)".

   * Se *x* for um infinito positivo, retorna *x*.

   * Se *x* for igual a zero, retorna o menor valor flutuante positivo
     *desnormalizado* representável (menor que o ponto flutuante de
     valor mínimo positivo *normalizado*, "sys.float_info.min").

   * Se *x* for igual ao maior ponto flutuante positivo representável,
     retorna o valor do bit menos significativo de *x*, tal que o
     primeiro ponto flutuante menor que *x* seja "x - ulp(x)".

   * Caso contrário (*x* é um número finito positivo), retorna o valor
     do bit menos significativo de *x*, de modo que o primeiro ponto
     flutuante maior que *x* seja "x + ulp(x)".

   ULP significa "Unit in the Last Place" ou, em português, unidade na
   última posição.

   Veja também "math.nextafter()" e "sys.float_info.epsilon".

   Adicionado na versão 3.9.


Funções de potências, exponenciais e logarítmicas
=================================================

math.cbrt(x)

   Retorna a raiz cúbica de *x*.

   Adicionado na versão 3.11.

math.exp(x)

   Retorna *e* elevado à potência *x*, onde *e* = 2.718281... é a base
   dos logaritmos naturais. Isso geralmente é mais preciso do que
   "math.e ** x" ou "pow(math.e, x)".

math.exp2(x)

   Retorna *2* elevado a *x*

   Adicionado na versão 3.11.

math.expm1(x)

   Retorna *e* elevado à potência *x*, menos 1. Aqui *e* é a base dos
   logaritmos naturais. Para pequenos pontos flutuantes *x*, a
   subtração em "exp(x) - 1" pode resultar em uma perda significativa
   de precisão; a função "expm1()" fornece uma maneira de calcular
   essa quantidade com precisão total:

   >>> from math import exp, expm1
   >>> exp(1e-5) - 1  # gives result accurate to 11 places
   1.0000050000069649e-05
   >>> expm1(1e-5)    # result accurate to full precision
   1.0000050000166668e-05

   Adicionado na versão 3.2.

math.log(x[, base])

   Com um argumento, retorna o logaritmo natural de *x* (para base
   *e*).

   Com dois argumentos, retorna o logaritmo de *x* para a *base*
   fornecida, calculada como "log(x)/log(base)".

math.log1p(x)

   Retorna o logaritmo natural de *1+x* (base *e*). O resultado é
   calculado de forma precisa para *x* próximo a zero.

math.log2(x)

   Retorna o logaritmo de base 2 de *x*. Isso geralmente é mais
   preciso do que "log(x, 2)".

   Adicionado na versão 3.3.

   Ver também:

     "int.bit_length()" retorna o número de bits necessários para
     representar um inteiro em binário, excluindo o sinal e os zeros à
     esquerda.

math.log10(x)

   Retorna o logaritmo de base 10 de *x*. Isso geralmente é mais
   preciso do que "log(x, 10)".

math.pow(x, y)

   Retorna *x* elevado a potência de *y*. Exceções seguem o padrão
   IEEE 754 o máximo possível. "pow(1.0, x)" e "pow(x, 0.0)" em
   particular sempre retornam "1.0", mesmo quando *x* é ZERO ou NaN.
   Se ambos *x* e *y* são números finitos, *x* é negativo, e *y* não é
   um inteiro então "pow(x, y)" é indefinido e levanta "ValueError".

   Ao contrário do operador embutido "**", "math.pow()" converte ambos
   os seus argumentos para o tipo "float". Use "**" ou a função
   embutida "pow()" para calcular potências inteiras exatas.

   Alterado na versão 3.11: Os casos especiais "pow(0.0, -inf)" e
   "pow(-0.0, -inf)" foram alterados para retornar "inf" ao invés de
   levantar "ValueError", para ter consistência com a IEEE 754.

math.sqrt(x)

   Retorna a raiz quadrada de *x*.


Funções de soma e produto
=========================

math.dist(p, q)

   Retorna a distância euclidiana entre dois pontos *p* e *q*, cada um
   dado como uma sequência (ou iterável) de coordenadas. Os dois
   pontos devem ter a mesma dimensão.

   Aproximadamente equivalente a:

      sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q, strict=True)))

   Adicionado na versão 3.8.

math.fsum(iterable)

   Retorna uma soma precisa dos valores de ponto flutuante no
   iterável. Evita perda de precisão rastreando várias somas parciais
   intermediárias.

   A precisão do algoritmo depende das garantias aritméticas do
   IEEE-754 e do caso típico em que o modo de arredondamento é meio
   par. Em algumas compilações que não são do Windows, a biblioteca C
   subjacente usa adição de precisão estendida e pode ocasionalmente
   arredondar uma soma intermediária fazendo com que ela introduza um
   erro no bit menos significativo.

   Para uma discussão mais aprofundada e duas abordagens alternativas,
   consulte o ASPN cookbook recipes for accurate floating point
   summation.

math.hypot(*coordinates)

   Retorna a norma euclidiana, "sqrt(sum(x**2 for x in coordinates))".
   Este é o comprimento do vetor da origem até o ponto dado pelas
   coordenadas.

   Para um ponto bidimensional "(x, y)", isso é equivalente a calcular
   a hipotenusa de um triângulo retângulo usando o teorema de
   Pitágoras, "sqrt(x*x + y*y)".

   Alterado na versão 3.8: Adicionado suporte para pontos
   n-dimensionais. Anteriormente, apenas o caso bidimensional era
   suportado.

   Alterado na versão 3.10: Melhorou a precisão do algoritmo para que
   o erro máximo seja inferior a 1 ulp (unidade no último lugar). Mais
   tipicamente, o resultado é quase sempre arredondado corretamente
   para 1/2 ulp.

math.prod(iterable, *, start=1)

   Calcula o produto de todos os elementos na entrada *iterable*. O
   valor *start* padrão para o produto é "1".

   Quando o iterável estiver vazio, retorna o valor de start. Esta
   função deve ser usada especificamente com valores numéricos e pode
   rejeitar tipos não numéricos.

   Adicionado na versão 3.8.

math.sumprod(p, q)

   Retorna a soma dos produtos dos valores de dois iteráveis *p* e
   *q*.

   Levanta "ValueError" se as entradas não tiverem o mesmo
   comprimento.

   Aproximadamente equivalente a:

      sum(map(operator.mul, p, q, strict=True))

   Para entradas float e mistas int/float, os produtos intermediários
   e as somas são calculados com precisão estendida.

   Adicionado na versão 3.12.


Conversão angular
=================

math.degrees(x)

   Converte o ângulo *x* de radianos para graus.

math.radians(x)

   Converte o ângulo *x* de graus para radianos.


Funções trigonométricas
=======================

math.acos(x)

   Retorna o arco cosseno de *x*, em radianos. O resultado está entre
   "0" e "pi".

math.asin(x)

   Retorna o arco seno de *x*, em radianos. O resultado está entre
   "-pi/2" e "pi/2".

math.atan(x)

   Retorna o arco tangente de *x*, em radianos. O resultado está entre
   "-pi/2" e "pi/2".

math.atan2(y, x)

   Retorna "atan(y / x)", em radianos. O resultado está entre "-pi" e
   "pi". O vetor no plano da origem ao ponto "(x, y)" faz este ângulo
   com o eixo X positivo. O ponto de "atan2()" é que os sinais de
   ambas as entradas são conhecidos por ele, então ele pode calcular o
   quadrante correto para o ângulo. Por exemplo, "atan(1)" e "atan2(1,
   1)" são ambos "pi/4", mas "atan2(-1, -1)" é "-3*pi/4".

math.cos(x)

   Retorna o cosseno de *x* radianos.

math.sin(x)

   Retorna o seno de *x* radianos.

math.tan(x)

   Retorna o tangente de *x* radianos.


Funções hiperbólicas
====================

Funções hiperbólicas são análogas às funções trigonométricas baseadas
em hipérboles em vez de círculos.

math.acosh(x)

   Retorna o cosseno hiperbólico inverso de *x*.

math.asinh(x)

   Retorna o seno hiperbólico inverso de *x*.

math.atanh(x)

   Retorna a tangente hiperbólica inversa de *x*.

math.cosh(x)

   Retorna o cosseno hiperbólico de *x*.

math.sinh(x)

   Retorna o seno hiperbólico de *x*.

math.tanh(x)

   Retorna a tangente hiperbólica de *x*.


Funções especiais
=================

math.erf(x)

   Retorna a função erro em *x*.

   A função "erf()" pode ser usada para calcular funções estatísticas
   tradicionais, como a distribuição normal padrão cumulativa:

      def phi(x):
          'Função de distribuição cumulativa para a distribuição normal padrão.'
          return (1.0 + erf(x / sqrt(2.0))) / 2.0

   Adicionado na versão 3.2.

math.erfc(x)

   Retorna a função erro complementar em *x*. A função erro
   complementar é definida como "1.0 - erf(x)". É usado para grandes
   valores de *x* onde uma subtração de um causaria uma perda de
   significância.

   Adicionado na versão 3.2.

math.gamma(x)

   Retorna a função gama em *x*.

   Adicionado na versão 3.2.

math.lgamma(x)

   Retorna o logaritmo natural do valor absoluto da função gama em
   *x*.

   Adicionado na versão 3.2.


Funções de teoria dos números
=============================

For backward compatibility, the "math" module provides also aliases of
the following functions from the "math.integer" module:

+----------------------------------------------------+----------------------------------------------------+
| "comb(n, k)"                                       | Número de maneiras de escolher *k* itens a partir  |
|                                                    | de *n* itens sem repetição e sem ordem             |
+----------------------------------------------------+----------------------------------------------------+
| "factorial(n)"                                     | Fatorial de *n*                                    |
+----------------------------------------------------+----------------------------------------------------+
| "gcd(*integers)"                                   | Máximo divisor comum dos argumentos inteiros       |
+----------------------------------------------------+----------------------------------------------------+
| "isqrt(n)"                                         | Raiz quadrada inteira de um inteiro não negativo   |
|                                                    | *n*                                                |
+----------------------------------------------------+----------------------------------------------------+
| "lcm(*integers)"                                   | Mínimo múltiplo comum dos argumentos inteiros      |
+----------------------------------------------------+----------------------------------------------------+
| "perm(n, k)"                                       | Número de maneiras de escolher *k* itens de *n*    |
|                                                    | itens sem repetição e com ordem                    |
+----------------------------------------------------+----------------------------------------------------+

Adicionado na versão 3.5: The "gcd()" function.

Adicionado na versão 3.8: The "comb()", "perm()" and "isqrt()"
functions.

Adicionado na versão 3.9: The "lcm()" function.

Alterado na versão 3.9: Added support for an arbitrary number of
arguments in the "gcd()" function. Formerly, only two arguments were
supported.

Alterado na versão 3.10: Floats with integral values (like "5.0") are
no longer accepted in the "factorial()" function.

Suavemente descontinuado desde a versão 3.15: Use the "math.integer"
functions instead of these aliases.


Constantes
==========

math.pi

   A constante matemática *π* = 3.141592..., para a precisão
   disponível.

math.e

   A constante matemática *e* = 2.718281..., para a precisão
   disponível.

math.tau

   A constante matemática *τ* = 6.283185..., para a precisão
   disponível. Tau é uma constante de círculo igual a 2*π*, a razão
   entre a circunferência de um círculo e seu raio. Para saber mais
   sobre Tau, confira o vídeo Pi is (still) Wrong de Vi Hart, e comece
   a comemorar o dia do Tau comendo duas vezes mais torta!

   Adicionado na versão 3.6.

math.inf

   Um infinito positivo de ponto flutuante. (Para infinito negativo,
   use "-math.inf".) Equivalente à saída de "float('inf')".

   Adicionado na versão 3.5.

math.nan

   Um valor de ponto flutuante "não é um número" (NaN). Equivalente à
   saída de "float('nan')". Devido aos requisitos do padrão IEEE-754,
   "math.nan" e "float('nan')" não são considerados para ser igual a
   qualquer outro valor numérico, incluindo eles próprios. Para
   verificar se um número é NaN, use a função "isnan()" para testar
   NaNs em vez de "is" ou "==". Exemplo:

   >>> import math
   >>> math.nan == math.nan
   False
   >>> float('nan') == float('nan')
   False
   >>> math.isnan(math.nan)
   True
   >>> math.isnan(float('nan'))
   True

   Adicionado na versão 3.5.

   Alterado na versão 3.11: Agora está sempre disponível

O módulo "math" consiste principalmente em invólucros finos em torno
das funções da biblioteca matemática C da plataforma. O comportamento
em casos excepcionais segue o Anexo F da norma C99 quando apropriado.
A implementação atual levantará "ValueError" para operações inválidas
como "sqrt(-1.0)" ou "log(0.0)" (onde C99 Anexo F recomenda sinalizar
operação inválida ou divisão por zero), e "OverflowError" para
resultados que estouram (por exemplo, "exp(1000.0)"). Um NaN não será
retornado de nenhuma das funções acima, a menos que um ou mais dos
argumentos de entrada sejam um NaN; nesse caso, a maioria das funções
retornará um NaN, mas (novamente seguindo C99 Anexo F) há algumas
exceções a esta regra, por exemplo, "pow(float('nan'), 0.0)" ou
"hypot(float('nan'), float('inf'))".

Observe que o Python não faz nenhum esforço para distinguir NaNs de
sinalização de NaNs silenciosos, e o comportamento para NaNs de
sinalização permanece não especificado. O comportamento típico é
tratar todos os NaNs como se estivessem quietos.

Ver também:

  Módulo "cmath"
     Versões de números complexos de muitas dessas funções.

  Module "math.integer"
     Integer-specific mathematics functions.
