Fonctions mathématiques pour nombres complexes — "cmath"
********************************************************

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

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.

Note:

  For functions involving branch cuts, we have the problem of deciding
  how to define those functions on the cut itself. Following Kahan's
  "Branch cuts for complex elementary functions" paper, as well as
  Annex G of C99 and later C standards, we use the sign of zero to
  distinguish one side of the branch cut from the other: for a branch
  cut along (a portion of) the real axis we look at the sign of the
  imaginary part, while for a branch cut along the imaginary axis we
  look at the sign of the real part.For example, the "cmath.sqrt()"
  function has a branch cut along the negative real axis. An argument
  of "complex(-2.0, -0.0)" is treated as though it lies *below* the
  branch cut, and so gives a result on the negative imaginary axis:

     >>> cmath.sqrt(complex(-2.0, -0.0))
     -1.4142135623730951j

  But an argument of "complex(-2.0, 0.0)" is treated as though it lies
  above the branch cut:

     >>> cmath.sqrt(complex(-2.0, 0.0))
     1.4142135623730951j


Conversion vers et à partir de coordonnées polaires
===================================================

Un nombre complexe Python "z" est stocké de manière interne en
coordonnées *cartésiennes*. Il est entièrement défini par sa *partie
réelle* "z.real" et sa *partie complexe* "z.imag". En d'autres termes
:

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

Les *coordonnées polaires* donnent une manière alternative de
représenter un nombre complexe. En coordonnées polaires, un nombre
complexe *z* est défini par son module *r* et par son argument (*angle
de phase*) *phi*. Le module *r* est la distance entre *z* et
l'origine, alors que l'argument *phi* est l'angle (dans le sens
inverse des aiguilles d'une montre, ou sens trigonométrique), mesuré
en radians, à partir de l'axe X positif, et vers le segment de droite
joignant *z* à l'origine.

Les fonctions suivantes peuvent être utilisées pour convertir à partir
des coordonnées rectangulaires natives vers les coordonnées polaires,
et 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.  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

Note:

  Le module (valeur absolue) d'un nombre complexe *x* peut être
  calculé en utilisant la primitive "abs()". Il n'y a pas de fonction
  spéciale du module "cmath" pour cette opération.

cmath.polar(x)

   Renvoie la représentation de *x* en coordonnées polaires. Renvoie
   une paire "(r, phi)" où *r* est le module de *x* et phi est
   l'argument de *x*. "polar(x)" est équivalent à "(abs(x),
   phase(x))".

cmath.rect(r, phi)

   Renvoie le nombre complexe *x* dont les coordonnées polaires sont
   *r* et *phi*. Équivalent à "r * (math.cos(phi) +
   math.sin(phi)*1j)".


Fonctions logarithme et exponentielle
=====================================

cmath.exp(x)

   Renvoie *e* élevé à la puissance *x*, où *e* est la base des
   logarithmes naturels.

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 -∞.

cmath.log10(x)

   Renvoie le logarithme en base 10 de *x*. Elle a la même coupure que
   "log()".

cmath.sqrt(x)

   Renvoie la racine carrée de *x*. Elle a la même coupure que
   "log()".


Fonctions trigonométriques
==========================

cmath.acos(x)

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

cmath.asin(x)

   Renvoie l'arc sinus de *x*. Elle a les mêmes coupures 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". The other
   extends from "-1j" along the imaginary axis to "-∞j".

cmath.cos(x)

   Renvoie le cosinus de *x*.

cmath.sin(x)

   Renvoie le sinus de *x*.

cmath.tan(x)

   Renvoie la tangente de *x*.


Fonctions hyperboliques
=======================

cmath.acosh(x)

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

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".  The
   other extends from "-1j" along the imaginary axis to "-∞j".

cmath.atanh(x)

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

cmath.cosh(x)

   Renvoie le cosinus hyperbolique de *x*.

cmath.sinh(x)

   Renvoie le sinus hyperbolique de *x*.

cmath.tanh(x)

   Renvoie la tangente hyperbolique de *x*.


Fonctions de classifications
============================

cmath.isfinite(x)

   Renvoie "True" si la partie réelle *et* la partie imaginaire de *x*
   sont finies, et "False" sinon.

   Added in version 3.2.

cmath.isinf(x)

   Renvoie "True" si soit la partie réelle *ou* la partie imaginaire
   de *x* est infinie, et "False" sinon.

cmath.isnan(x)

   Renvoie "True" si soit la partie réelle *ou* la partie imaginaire
   de *x* est NaN, et "False" sinon.

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

   Renvoie "True" si les valeurs *a* et *b* sont proches l'une de
   l'autre, et "False" sinon.

   Déterminer si deux valeurs sont proches se fait à l'aide des
   tolérances absolues et relatives données en paramètres.

   *rel_tol* est la tolérance relative -- c'est la différence maximale
   permise entre *a* et *b*, relativement à la plus grande valeur de
   *a* ou de *b*. Par exemple, pour définir une tolérance de 5%,,
   précisez "rel_tol=0.05". La tolérance par défaut est "1e-09", ce
   qui assure que deux valeurs sont les mêmes à partir de la 9^e
   décimale. *rel_tol* doit être supérieur à zéro.

   *abs_tol* est la tolérance absolue minimale -- utile pour les
   comparaisons proches de zéro. *abs_tol* doit valoir au moins zéro.

   Si aucune erreur n'est rencontrée, le résultat sera : "abs(a-b) <=
   max(rel_tol * max(abs(a), abs(b)), abs_tol)".

   Les valeurs spécifiques suivantes : "NaN", "inf", et "-inf"
   définies dans la norme IEEE 754  seront manipulées selon les règles
   du standard IEEE. En particulier, "NaN" n'est considéré proche
   d'aucune autre valeur, "NaN" inclus. "inf" et "-inf" ne sont
   considérés proches que d'eux-mêmes.

   Added in version 3.5.

   Voir aussi:

     **PEP 485** -- Une fonction pour tester des égalités approximées


Constantes
==========

cmath.pi

   La constante mathématique *π*, en tant que flottant.

cmath.e

   La constante mathématique *e*, en tant que flottant.

cmath.tau

   La constante mathématique *τ*, sous forme de flottant.

   Added in version 3.6.

cmath.inf

   Nombre à virgule flottante positif infini. Équivaut à
   "float('inf')".

   Added in version 3.6.

cmath.infj

   Nombre complexe dont la partie réelle vaut zéro et la partie
   imaginaire un infini positif. Équivalent à "complex(0.0,
   float('inf'))".

   Added in version 3.6.

cmath.nan

   Un nombre à virgule flottante *NaN* (*Not a number*). Équivalent à
   "float('nan')".

   Added in version 3.6.

cmath.nanj

   Nombre complexe dont la partie réelle vaut zéro et la partie
   imaginaire vaut un *NaN*. Équivalent à "complex(0.0,
   float('nan'))".

   Added in version 3.6.

Notez que la sélection de fonctions est similaire, mais pas identique,
à celles du module "math". La raison d'avoir deux modules est que
certains utilisateurs ne sont pas intéressés par les nombres
complexes, et peut-être ne savent même pas ce qu'ils sont. Ils
préféreraient alors que "math.sqrt(-1)" lève une exception au lieu de
renvoyer un nombre complexe. Également, notez que les fonctions
définies dans "cmath" renvoient toujours un nombre complexe, même si
le résultat peut être exprimé à l'aide d'un nombre réel (en quel cas
la partie imaginaire du complexe vaut zéro).

Une note sur les *coupures* : ce sont des courbes sur lesquelles la
fonction n'est pas continue. Ce sont des caractéristiques nécessaires
de beaucoup de fonctions complexes. Il est supposé que si vous avez
besoin d'utiliser des fonctions complexes, vous comprendrez ce que
sont les coupures. Consultez n'importe quel livre (pas trop
élémentaire) sur les variables complexes pour plus d'informations.
Pour des informations sur les choix des coupures à des fins
numériques, voici une bonne référence :

Voir aussi:

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