"cmath" --- Funções matemáticas para números complexos
******************************************************

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

This module provides access to mathematical functions for complex
numbers.  The functions in this module accept integers, floating-point
numbers or complex numbers as arguments. They will also accept any
Python object that has either a "__complex__()" or a "__float__()"
method: these methods are used to convert the object to a complex or
floating-point number, respectively, and the function is then applied
to the result of the conversion.

Nota:

  On platforms with hardware and system-level support for signed
  zeros, functions involving branch cuts are continuous on *both*
  sides of the branch cut: the sign of the zero distinguishes one side
  of the branch cut from the other.  On platforms that do not support
  signed zeros the continuity is as specified below.


Conversões de e para coordenadas polares
========================================

A Python complex number "z" is stored internally using *rectangular*
or *Cartesian* coordinates.  It is completely determined by its *real
part* "z.real" and its *imaginary part* "z.imag".  In other words:

   z == z.real + z.imag*1j

*Coordenadas polares* fornecem uma forma alternativa de representar um
número complexo. Em coordenadas polares, um número complexo *z* é
definido pelo módulo *r* e pelo ângulo de fase *phi*. O módulo *r* é a
distância de *z* à origem, enquanto a fase *phi* é o ângulo anti-
horário, medido em radianos, do eixo x positivo ao segmento de reta
que une a origem a *z*.

As funções a seguir podem ser usadas para converter coordenadas
retangulares nativas em coordenadas polares e vice-versa.

cmath.phase(x)

   Return the phase of *x* (also known as the *argument* of *x*), as a
   float.  "phase(x)" is equivalent to "math.atan2(x.imag, x.real)".
   The result lies in the range [-*π*, *π*], and the branch cut for
   this operation lies along the negative real axis, continuous from
   above.  On systems with support for signed zeros (which includes
   most systems in current use), this means that the sign of the
   result is the same as the sign of "x.imag", even when "x.imag" is
   zero:

      >>> phase(complex(-1.0, 0.0))
      3.141592653589793
      >>> phase(complex(-1.0, -0.0))
      -3.141592653589793

Nota:

  O módulo (valor absoluto) de um número complexo *x* pode ser
  calculado usando a função embutida "abs()". Não há função do módulo
  "cmath" separada para esta operação.

cmath.polar(x)

   Retorna a representação de *x* em coordenadas polares. Retorna um
   par "(r, phi)" onde *r* é o módulo de *x* e phi é a fase de *x*.
   "polar(x)" é equivalente a "(abs(x), phase(x))".

cmath.rect(r, phi)

   Return the complex number *x* with polar coordinates *r* and *phi*.
   Equivalent to "r * (math.cos(phi) + math.sin(phi)*1j)".


Funções de potência e logarítmicas
==================================

cmath.exp(x)

   Retorna *e* elevado à potência *x*, onde *e* é a base de logaritmos
   naturais.

cmath.log(x[, base])

   Returns the logarithm of *x* to the given *base*. If the *base* is
   not specified, returns the natural logarithm of *x*. There is one
   branch cut, from 0 along the negative real axis to -∞, continuous
   from above.

cmath.log10(x)

   Retorna o logaritmo de *x* na base 10. Este tem o mesmo corte de
   ramificação que "log()".

cmath.sqrt(x)

   Retorna a raiz quadrada de *x*. Este tem o mesmo corte de
   ramificação que "log()".


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

cmath.acos(x)

   Return the arc cosine of *x*. There are two branch cuts: One
   extends right from 1 along the real axis to ∞, continuous from
   below. The other extends left from -1 along the real axis to -∞,
   continuous from above.

cmath.asin(x)

   Retorna o arco seno de *x*. Tem os mesmos cortes de ramificação que
   "acos()".

cmath.atan(x)

   Return the arc tangent of *x*. There are two branch cuts: One
   extends from "1j" along the imaginary axis to "∞j", continuous from
   the right. The other extends from "-1j" along the imaginary axis to
   "-∞j", continuous from the left.

cmath.cos(x)

   Retorna o cosseno de *x*.

cmath.sin(x)

   Retorna o seno de *x*.

cmath.tan(x)

   Retorna a tangente de *x*.


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

cmath.acosh(x)

   Return the inverse hyperbolic cosine of *x*. There is one branch
   cut, extending left from 1 along the real axis to -∞, continuous
   from above.

cmath.asinh(x)

   Return the inverse hyperbolic sine of *x*. There are two branch
   cuts: One extends from "1j" along the imaginary axis to "∞j",
   continuous from the right.  The other extends from "-1j" along the
   imaginary axis to "-∞j", continuous from the left.

cmath.atanh(x)

   Return the inverse hyperbolic tangent of *x*. There are two branch
   cuts: One extends from "1" along the real axis to "∞", continuous
   from below. The other extends from "-1" along the real axis to
   "-∞", continuous from above.

cmath.cosh(x)

   Retorna o cosseno hiperbólico de *x*.

cmath.sinh(x)

   Retorna o seno hiperbólico de *x*.

cmath.tanh(x)

   Retorna a tangente hiperbólica de *x*.


Funções de classificação
========================

cmath.isfinite(x)

   Retorna "True" se ambas as partes real e imaginária de *x* forem
   finitas, e "False" caso contrário.

   Novo na versão 3.2.

cmath.isinf(x)

   Retorna "True" se ou a parte real ou a imaginária de *x* for
   infinita, e "False" caso contrário.

cmath.isnan(x)

   Retorna "True" se ou a parte real ou a imaginária de *x* for NaN, e
   "False" caso contrário.

cmath.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 ou não considerados próximos, é determinado de
   acordo com as tolerâncias absolutas e relativas fornecidas.

   *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 maior que zero.

   *abs_tol* é a tolerância absoluta mínima -- útil para comparações
   próximas a zero. *abs_tol* deve ser pelo menos zero.

   Se nenhum erro ocorrer, o resultado será: "abs(a-b) <= max(rel_tol
   * max(abs(a), abs(b)), abs_tol)".

   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.

   Novo na versão 3.5.

   Ver também:

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


Constantes
==========

cmath.pi

   A constante matemática *π*, como um ponto flutuante.

cmath.e

   A constante matemática *e*, como um ponto flutuante.

cmath.tau

   A constante matemática *τ*, como um ponto flutuante.

   Novo na versão 3.6.

cmath.inf

   Infinito positivo de ponto flutuante. Equivalente a "float('inf')".

   Novo na versão 3.6.

cmath.infj

   Número complexo com parte real zero e parte imaginária infinita
   positiva. Equivalente a "complex(0.0, float('inf'))".

   Novo na versão 3.6.

cmath.nan

   Um valor de ponto flutuante "não um número" (NaN). Equivalente a
   "float('nan')".

   Novo na versão 3.6.

cmath.nanj

   Número complexo com parte real zero e parte imaginária NaN.
   Equivalente a "complex(0.0, float('nan'))".

   Novo na versão 3.6.

Observe que a seleção de funções é semelhante, mas não idêntica,
àquela no módulo "math". A razão para ter dois módulos é que alguns
usuários não estão interessados ​​em números complexos e talvez nem
saibam o que são. Eles preferem que "math.sqrt(-1)" gere uma exceção
do que retorne um número complexo. Observe também que as funções
definidas em "cmath" sempre retornam um número complexo, mesmo que a
resposta possa ser expressa como um número real (nesse caso o número
complexo tem uma parte imaginária de zero).

Uma nota sobre cortes de ramificação: são curvas ao longo das quais a
função dada não é contínua. Eles são um recurso necessário de muitas
funções complexas. Presume-se que se você precisar calcular com
funções complexas, você entenderá sobre cortes de ramificação.
Consulte quase qualquer livro (não muito elementar) sobre variáveis
​​complexas para obter esclarecimento. Para informações sobre a
escolha adequada dos cortes de ramificação para fins numéricos, uma
boa referência deve ser a seguinte:

Ver também:

  Kahan, W:  Branch cuts for complex elementary functions; or, Much
  ado about nothing's sign bit.  Em Iserles, A. e Powell, M. (eds.),
  The state of the art in numerical analysis. Clarendon Press (1987)
  pp165--211.
