python-docs-fr/library/math.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2016, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-03-23 09:03+0100\n"
"PO-Revision-Date: 2017-09-24 20:20+0200\n"
"Last-Translator: Julien Palard <julien@palard.fr>\n"
"Language-Team: \n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.0.4\n"

#: ../Doc/library/math.rst:2
msgid ":mod:`math` --- Mathematical functions"
msgstr "Fonctions mathématiques --- :mod:`math`"

#: ../Doc/library/math.rst:13
msgid ""
"This module is always available.  It provides access to the mathematical "
"functions defined by the C standard."
msgstr ""
"Ce module est toujours disponible. Il fournit l'accès aux fonctions "
"mathématiques définies par le standard C."

#: ../Doc/library/math.rst:16
msgid ""
"These functions cannot be used with complex numbers; use the functions of "
"the same name from the :mod:`cmath` module if you require support for "
"complex numbers.  The distinction between functions which support complex "
"numbers and those which don't is made since most users do not want to learn "
"quite as much mathematics as required to understand complex numbers.  "
"Receiving an exception instead of a complex result allows earlier detection "
"of the unexpected complex number used as a parameter, so that the programmer "
"can determine how and why it was generated in the first place."
msgstr ""
"Ces fonctions ne peuvent être utilisées avec les nombres complexes, utilisez "
"les fonctions du même nom du module :mod:`cmath` si vous souhaitez un "
"support des nombres complexes. La distinction entre les fonctions supportant "
"les nombres complexes et celles ne les supportant pas set née du fait que "
"tous les utilisateurs ne désirent pas acquérir le niveau mathématique "
"suffisant pour comprendre les nombres complexes. Recevoir une exception à la "
"place d'un nombre complexe permet de détecter un nombre complexe non désiré "
"en paramètre, ainsi le programmeur peut déterminer comment et pourquoi il a "
"été généré."

#: ../Doc/library/math.rst:25
msgid ""
"The following functions are provided by this module.  Except when explicitly "
"noted otherwise, all return values are floats."
msgstr ""
"Les fonctions suivantes sont fournies dans ce module. Sauf mention contraire "
"explicite, toutes les valeurs de retour sont des flottants."

#: ../Doc/library/math.rst:30
msgid "Number-theoretic and representation functions"
msgstr "Fonctions arithmétiques et de représentation"

#: ../Doc/library/math.rst:34
msgid ""
"Return the ceiling of *x*, the smallest integer greater than or equal to "
"*x*. If *x* is not a float, delegates to ``x.__ceil__()``, which should "
"return an :class:`~numbers.Integral` value."
msgstr ""
"Renvoie la fonction *plafond* de *x*, le plus petit entier plus grand ou "
"égal à *x*. Si *x* est un flottant, délègue à ``x.__ceil()__``, qui doit "
"renvoyer une valeur :class:`~numbers.Integral`."

#: ../Doc/library/math.rst:41
msgid ""
"Return a float with the magnitude (absolute value) of *x* but the sign of "
"*y*.  On platforms that support signed zeros, ``copysign(1.0, -0.0)`` "
"returns *-1.0*."
msgstr ""
"Renvoie un flottant contenant la magnitude (valeur absolue) de *x* mais avec "
"le signe de *y*. Sur les plate-formes supportant les zéros signés, "
"``copysign(1.0, -0.0)`` renvoie *-1.0*."

#: ../Doc/library/math.rst:47
msgid "Return the absolute value of *x*."
msgstr "Renvoie la valeur absolue de *x*."

#: ../Doc/library/math.rst:51
msgid ""
"Return *x* factorial.  Raises :exc:`ValueError` if *x* is not integral or is "
"negative."
msgstr ""
"Renvoie la factorielle de *x*. Lève une :exc:`ValueError` si *x* n'est pas "
"entier ou s'il est négatif."

#: ../Doc/library/math.rst:56
msgid ""
"Return the floor of *x*, the largest integer less than or equal to *x*. If "
"*x* is not a float, delegates to ``x.__floor__()``, which should return an :"
"class:`~numbers.Integral` value."
msgstr ""
"Renvoie le plancher de *x*, le plus grand entier plus petit ou égal à *x*. "
"Si *x* n'est pas un flottant, délègue à ``x.__floor()__``, qui doit renvoyer "
"une valeur :class:`~numbers.Integral`."

#: ../Doc/library/math.rst:63
msgid ""
"Return ``fmod(x, y)``, as defined by the platform C library. Note that the "
"Python expression ``x % y`` may not return the same result.  The intent of "
"the C standard is that ``fmod(x, y)`` be exactly (mathematically; to "
"infinite precision) equal to ``x - n*y`` for some integer *n* such that the "
"result has the same sign as *x* and magnitude less than ``abs(y)``.  "
"Python's ``x % y`` returns a result with the sign of *y* instead, and may "
"not be exactly computable for float arguments. For example, ``fmod(-1e-100, "
"1e100)`` is ``-1e-100``, but the result of Python's ``-1e-100 % 1e100`` is "
"``1e100-1e-100``, which cannot be represented exactly as a float, and rounds "
"to the surprising ``1e100``.  For this reason, function :func:`fmod` is "
"generally preferred when working with floats, while Python's ``x % y`` is "
"preferred when working with integers."
msgstr ""
"Renvoie ``fmod(x, y)``, tel que défini par la bibliothèque C de la plate-"
"forme. Notez que l'expression Python ``x % y`` peut ne pas renvoyer le même "
"résultat. Le sens du standard C pour ``fmod(x, y)`` est d'être exactement "
"(mathématiquement, à une précision infinie) égal à ``x - n*y`` pour un "
"entier *n* tel que le résultat a le signe de *x* et une magnitude inférieure "
"à ``abs(y)``. L'expression Python ``x % y`` renvoie un résultat avec le "
"signe de *y*, et peut ne pas être calculable exactement pour des arguments "
"flottants. Par exemple : ``fmod(-1e-100, 1e100)`` est ``-1e-100``, mais le "
"résultat de l'expression Python ``-1e-100 % 1e100`` est ``1e100-1e-100``, "
"qui ne peut pas être représenté exactement par un flottant et donc qui est "
"arrondi à ``1e100``. Pour cette raison, la fonction :func:`fmod` est "
"généralement préférée quand des flottants sont manipulés, alors que "
"l'expression Python ``x % y`` est préféré quand des entiers sont manipulés."

#: ../Doc/library/math.rst:78
msgid ""
"Return the mantissa and exponent of *x* as the pair ``(m, e)``.  *m* is a "
"float and *e* is an integer such that ``x == m * 2**e`` exactly. If *x* is "
"zero, returns ``(0.0, 0)``, otherwise ``0.5 <= abs(m) < 1``.  This is used "
"to \"pick apart\" the internal representation of a float in a portable way."
msgstr ""
"Renvoie la mantisse et l'exposant de *x* dans un couple ``(m, e)``. *m* est "
"un flottant et *e* est un entier tels que ``x == m * 2**e`` exactement. Si "
"*x* vaut zéro, renvoie ``(0, 0)``, sinon ``0.5 <= abs(m) < 1``. Ceci est "
"utilisé pour « extraire » la représentation interne d'un flottant de manière "
"portable."

#: ../Doc/library/math.rst:86
msgid ""
"Return an accurate floating point sum of values in the iterable.  Avoids "
"loss of precision by tracking multiple intermediate partial sums::"
msgstr ""
"Renvoie une somme flottante exacte des valeurs dans l'itérable. Évite la "
"perte de précision en gardant plusieurs sommes partielles intermédiaires : ::"

#: ../Doc/library/math.rst:94
msgid ""
"The algorithm's accuracy depends on IEEE-754 arithmetic guarantees and the "
"typical case where the rounding mode is half-even.  On some non-Windows "
"builds, the underlying C library uses extended precision addition and may "
"occasionally double-round an intermediate sum causing it to be off in its "
"least significant bit."
msgstr ""
"L'exactitude de cet algorithme dépend des garanties arithmétiques de "
"IEEE-754 et des cas typiques où le mode d'arrondi est *half-even*. Sur "
"certaines versions non-Windows, la bibliothèque C sous-jacente utilise une "
"addition par précision étendue et peut occasionnellement effectuer un double-"
"arrondi sur une somme intermédiaire causant la prise d'une mauvaise valeur "
"du bit de poids faible."

#: ../Doc/library/math.rst:100
msgid ""
"For further discussion and two alternative approaches, see the `ASPN "
"cookbook recipes for accurate floating point summation <https://code."
"activestate.com/recipes/393090/>`_\\."
msgstr ""
"Pour de plus amples discussions et deux approches alternatives, voir `ASPN "
"cookbook recipes for accurate floating point summation <https://code."
"activestate.com/recipes/393090/>`_\\."

#: ../Doc/library/math.rst:107
msgid ""
"Return the greatest common divisor of the integers *a* and *b*.  If either "
"*a* or *b* is nonzero, then the value of ``gcd(a, b)`` is the largest "
"positive integer that divides both *a* and *b*.  ``gcd(0, 0)`` returns ``0``."
msgstr ""
"Renvoie le plus grand divisteur commun des entiers *a* et *b*. Si soit *a* "
"ou *b* est différent de zéro, la valeur de ``gcd(a, b)`` est le plus grand "
"entier positif qui divise à la fois *a* et *b*. ``gcd(0, 0)`` renvoie ``0``."

#: ../Doc/library/math.rst:117
msgid ""
"Return ``True`` if the values *a* and *b* are close to each other and "
"``False`` otherwise."
msgstr ""
"Renvoie ``True`` si les valeurs *a* et *b* sont proches l'une de l'autre, et "
"``False`` sinon."

#: ../Doc/library/math.rst:120
msgid ""
"Whether or not two values are considered close is determined according to "
"given absolute and relative tolerances."
msgstr ""
"Déterminer si deux valeurs sont proches se fait à l'aide des tolérances "
"absolues et relatives données en paramètres."

#: ../Doc/library/math.rst:123
msgid ""
"*rel_tol* is the relative tolerance -- it is the maximum allowed difference "
"between *a* and *b*, relative to the larger absolute value of *a* or *b*. "
"For example, to set a tolerance of 5%, pass ``rel_tol=0.05``.  The default "
"tolerance is ``1e-09``, which assures that the two values are the same "
"within about 9 decimal digits.  *rel_tol* must be greater than zero."
msgstr ""
"*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ème décimale. *rel_tol* doit être supérieur à zéro."

#: ../Doc/library/math.rst:129
msgid ""
"*abs_tol* is the minimum absolute tolerance -- useful for comparisons near "
"zero. *abs_tol* must be at least zero."
msgstr ""
"*abs_tol* est la tolérance absolue minimale -- utile pour les comparaisons "
"proches de zéro. *abs_tol* doit valoir au moins zéro."

#: ../Doc/library/math.rst:132
msgid ""
"If no errors occur, the result will be: ``abs(a-b) <= max(rel_tol * "
"max(abs(a), abs(b)), abs_tol)``."
msgstr ""
"Si aucune erreur n'est rencontrée, le résultat sera : ``abs(a-b) <= "
"max(rel_tol * max(abs(a), abs(b)), abs_tol)``."

#: ../Doc/library/math.rst:135
msgid ""
"The IEEE 754 special values of ``NaN``, ``inf``, and ``-inf`` will be "
"handled according to IEEE rules.  Specifically, ``NaN`` is not considered "
"close to any other value, including ``NaN``.  ``inf`` and ``-inf`` are only "
"considered close to themselves."
msgstr ""
"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."

#: ../Doc/library/math.rst:144
msgid ":pep:`485` -- A function for testing approximate equality"
msgstr ":pep:`485` -- Une fonction pour tester des égalités approximées"

#: ../Doc/library/math.rst:149
msgid ""
"Return ``True`` if *x* is neither an infinity nor a NaN, and ``False`` "
"otherwise.  (Note that ``0.0`` *is* considered finite.)"
msgstr ""
"Renvoie ``True`` si *n* n'est ni infini, ni NaN, et ``False`` sinon. (Notez "
"que ``0.0`` *est* considéré fini.)"

#: ../Doc/library/math.rst:157
msgid ""
"Return ``True`` if *x* is a positive or negative infinity, and ``False`` "
"otherwise."
msgstr ""
"Renvoie ``True`` si *x* vaut l'infini positif ou négatif, et ``False`` sinon."

#: ../Doc/library/math.rst:163
msgid ""
"Return ``True`` if *x* is a NaN (not a number), and ``False`` otherwise."
msgstr ""
"Renvoie ``True`` si *x* est NaN (*Not a Number*, ou *Pas un Nombre* en "
"français), et ``False`` sinon."

#: ../Doc/library/math.rst:168
msgid ""
"Return ``x * (2**i)``.  This is essentially the inverse of function :func:"
"`frexp`."
msgstr ""
"Renvoie ``x * (2**i)``. C'est essentiellement l'inverse de la fonction :func:"
"`frexp`."

#: ../Doc/library/math.rst:174
msgid ""
"Return the fractional and integer parts of *x*.  Both results carry the sign "
"of *x* and are floats."
msgstr ""
"Renvoie les parties entières et fractionnelle de *x*. Les deux résultats ont "
"le signe de *x* et sont flottants."

#: ../Doc/library/math.rst:180
#, fuzzy
msgid ""
"Return the :class:`~numbers.Real` value *x* truncated to an :class:`~numbers."
"Integral` (usually an integer). Delegates to :meth:`x.__trunc__() <object."
"__trunc__>`."
msgstr ""
"Renvoie la valeur :class:`~numbers.Real` *x* tronquée en un :class:`~numbers."
"Integral` (habituellement un entier). Délègue à ``x.__trunc()__``."

#: ../Doc/library/math.rst:185
msgid ""
"Note that :func:`frexp` and :func:`modf` have a different call/return "
"pattern than their C equivalents: they take a single argument and return a "
"pair of values, rather than returning their second return value through an "
"'output parameter' (there is no such thing in Python)."
msgstr ""
"Notez que les fonctions :func:`frexp` et :func:`modf` ont un système d'appel "
"différent de leur homologue C : elles prennent un simple argument et "
"renvoient une paire de valeurs au lieu de renvoyer leur seconde valeur de "
"retour dans un 'paramètre de sortie' (il n'y a pas de telle possibilité en "
"Python)."

#: ../Doc/library/math.rst:190
msgid ""
"For the :func:`ceil`, :func:`floor`, and :func:`modf` functions, note that "
"*all* floating-point numbers of sufficiently large magnitude are exact "
"integers. Python floats typically carry no more than 53 bits of precision "
"(the same as the platform C double type), in which case any float *x* with "
"``abs(x) >= 2**52`` necessarily has no fractional bits."
msgstr ""
"Pour les fonctions :func:`ceil`, :func:`floor`, et :func:`modf`, notez que "
"*tous* les nombres flottants de magnitude suffisamment grande sont des "
"entiers exacts. Les flottants de Python n'ont typiquement pas plus de 53 "
"*bits* de précision (tels que le type C ``double`` de la plate-forme), en "
"quel cas tout flottant *x* tel que ``abs(x) >= 2**52`` n'a aucun *bit* "
"fractionnel."

#: ../Doc/library/math.rst:198
msgid "Power and logarithmic functions"
msgstr "Fonctions logarithme et exponentielle"

#: ../Doc/library/math.rst:202
msgid "Return ``e**x``."
msgstr "Renvoie ``e**x``."

#: ../Doc/library/math.rst:207
msgid ""
"Return ``e**x - 1``.  For small floats *x*, the subtraction in ``exp(x) - "
"1`` can result in a `significant loss of precision <https://en.wikipedia.org/"
"wiki/Loss_of_significance>`_\\; the :func:`expm1` function provides a way to "
"compute this quantity to full precision::"
msgstr ""
"Renvoie ``e**x - 1``. Pour de petits flottants, la soustraction ``exp(x) - "
"1`` peut résulter en une `perte significative de précision <https://en."
"wikipedia.org/wiki/Loss_of_significance>`_\\ ; la fonction :func:`expm1` "
"fournit un moyen de calculer cette quantité en précision complète : ::"

#: ../Doc/library/math.rst:223
msgid "With one argument, return the natural logarithm of *x* (to base *e*)."
msgstr "Avec un argument, renvoie le logarithme naturel de *x* (en base *e*)."

#: ../Doc/library/math.rst:225
msgid ""
"With two arguments, return the logarithm of *x* to the given *base*, "
"calculated as ``log(x)/log(base)``."
msgstr ""
"Avec deux arguments, renvoie le logarithme de *x* en la *base* donnée, "
"calculé par ``log(x)/log(base)``."

#: ../Doc/library/math.rst:231
msgid ""
"Return the natural logarithm of *1+x* (base *e*). The result is calculated "
"in a way which is accurate for *x* near zero."
msgstr ""
"Renvoie le logarithme naturel de *1+x* (en base *e*). Le résultat est "
"calculé par un moyen qui reste exact pour *x* proche de zéro."

#: ../Doc/library/math.rst:237
msgid ""
"Return the base-2 logarithm of *x*. This is usually more accurate than "
"``log(x, 2)``."
msgstr ""
"Renvoie le logarithme en base 2 de *x*. C'est habituellement plus exact que "
"``log(x, 2)``."

#: ../Doc/library/math.rst:244
msgid ""
":meth:`int.bit_length` returns the number of bits necessary to represent an "
"integer in binary, excluding the sign and leading zeros."
msgstr ""
":meth:`int.bit_length` renvoie le nombre de bits nécessaires pour "
"représenter un entier en binaire, en excluant le signe et les zéros de début."

#: ../Doc/library/math.rst:250
msgid ""
"Return the base-10 logarithm of *x*.  This is usually more accurate than "
"``log(x, 10)``."
msgstr ""
"Renvoie le logarithme de *x* en base 10. C'est habituellement plus exact que "
"``log(x, 10)``."

#: ../Doc/library/math.rst:256
msgid ""
"Return ``x`` raised to the power ``y``.  Exceptional cases follow Annex 'F' "
"of the C99 standard as far as possible.  In particular, ``pow(1.0, x)`` and "
"``pow(x, 0.0)`` always return ``1.0``, even when ``x`` is a zero or a NaN.  "
"If both ``x`` and ``y`` are finite, ``x`` is negative, and ``y`` is not an "
"integer then ``pow(x, y)`` is undefined, and raises :exc:`ValueError`."
msgstr ""
"Renvoie ``x`` élevé à la puissance ``y``. Les cas exceptionnels suivent "
"l'annexe 'F' du standard C99 autant que possible. En particulier, ``pow(1.0, "
"x)`` et ``pow(x, 0.0)`` renvoient toujours ``1.0``, même si ``x`` est zéro "
"ou NaN. Si à la fois ``x`` *et* ``y`` sont finis, ``x`` est négatif et ``y`` "
"n'est pas entier, alors ``pow(x, y)`` est non défini et lève une :exc:"
"`ValueError`."

#: ../Doc/library/math.rst:263
msgid ""
"Unlike the built-in ``**`` operator, :func:`math.pow` converts both its "
"arguments to type :class:`float`.  Use ``**`` or the built-in :func:`pow` "
"function for computing exact integer powers."
msgstr ""
"À l'inverse de l'opérateur interne ``**``, la fonction :func:`math.pow` "
"convertit ses deux arguments en :class:`float`. Utilisez ``**`` ou la "
"primitive :func:`pow` pour calculer des puissances exactes d'entiers."

#: ../Doc/library/math.rst:270
msgid "Return the square root of *x*."
msgstr "Renvoie la racine carrée de *x*."

#: ../Doc/library/math.rst:273
msgid "Trigonometric functions"
msgstr "Fonctions trigonométriques"

#: ../Doc/library/math.rst:278
msgid "Return the arc cosine of *x*, in radians."
msgstr "Renvoie l'arc cosinus de *x*, en radians."

#: ../Doc/library/math.rst:283
msgid "Return the arc sine of *x*, in radians."
msgstr "Renvoie l'arc sinus de *x*, en radians."

#: ../Doc/library/math.rst:288
msgid "Return the arc tangent of *x*, in radians."
msgstr "Renvoie l'arc tangente de *x*, en radians."

#: ../Doc/library/math.rst:293
msgid ""
"Return ``atan(y / x)``, in radians. The result is between ``-pi`` and "
"``pi``. The vector in the plane from the origin to point ``(x, y)`` makes "
"this angle with the positive X axis. The point of :func:`atan2` is that the "
"signs of both inputs are known to it, so it can compute the correct quadrant "
"for the angle. For example, ``atan(1)`` and ``atan2(1, 1)`` are both "
"``pi/4``, but ``atan2(-1, -1)`` is ``-3*pi/4``."
msgstr ""
"Renvoie ``atan(y / x)``, en radians. Le résultat est entre ``-pi`` et "
"``pi``. Le vecteur du plan allant de l'origine vers le point ``(x, y)`` "
"forme cet angle avec l'axe X positif. L'intérêt de :func:`atan2` est que le "
"signe des deux entrées est connu. Donc elle peut calculer le bon quadrant "
"pour l'angle. par exemple ``atan(1)`` et ``atan2(1, 1)`` donnent tous deux "
"``pi/4``, mais ``atan2(-1, -1)`` donne ``-3*pi/4``."

#: ../Doc/library/math.rst:303
msgid "Return the cosine of *x* radians."
msgstr "Renvoie le cosinus de *x* radians."

#: ../Doc/library/math.rst:308
msgid ""
"Return the Euclidean norm, ``sqrt(x*x + y*y)``. This is the length of the "
"vector from the origin to point ``(x, y)``."
msgstr ""
"Renvoie la norme euclidienne ``sqrt(x*x + y*y)``. C'est la longueur du "
"vecteur allant de l'origine au point ``(x, y)``."

#: ../Doc/library/math.rst:314
msgid "Return the sine of *x* radians."
msgstr "Renvoie le sinus de*x* radians."

#: ../Doc/library/math.rst:319
msgid "Return the tangent of *x* radians."
msgstr "Renvoie la tangente de *x* radians."

#: ../Doc/library/math.rst:322
msgid "Angular conversion"
msgstr "Conversion angulaire"

#: ../Doc/library/math.rst:327
msgid "Convert angle *x* from radians to degrees."
msgstr "Convertit l'angle *x* de radians en degrés."

#: ../Doc/library/math.rst:332
msgid "Convert angle *x* from degrees to radians."
msgstr "Convertit l'ange *x* de degrés en radians."

#: ../Doc/library/math.rst:335
msgid "Hyperbolic functions"
msgstr "Fonctions hyperboliques"

#: ../Doc/library/math.rst:337
msgid ""
"`Hyperbolic functions <https://en.wikipedia.org/wiki/Hyperbolic_function>`_ "
"are analogs of trigonometric functions that are based on hyperbolas instead "
"of circles."
msgstr ""
"`Hyperbolic functions <https://en.wikipedia.org/wiki/Hyperbolic_function>`_ "
"sont analogues à des fonctions trigonométriques qui sont basés sur des "
"hyperboles au lieu de cercles."

#: ../Doc/library/math.rst:343
msgid "Return the inverse hyperbolic cosine of *x*."
msgstr "Renvoie l'arc cosinus hyperbolique de *x*."

#: ../Doc/library/math.rst:348
msgid "Return the inverse hyperbolic sine of *x*."
msgstr "Renvoie l'arc sinus hyperbolique de *x*."

#: ../Doc/library/math.rst:353
msgid "Return the inverse hyperbolic tangent of *x*."
msgstr "Renvoie l'arc tangente hyperbolique de *x*."

#: ../Doc/library/math.rst:358
msgid "Return the hyperbolic cosine of *x*."
msgstr "Renvoie le cosinus hyperbolique de *x*."

#: ../Doc/library/math.rst:363
msgid "Return the hyperbolic sine of *x*."
msgstr "Renvoie le sinus hyperbolique de *x*."

#: ../Doc/library/math.rst:368
msgid "Return the hyperbolic tangent of *x*."
msgstr "Renvoie la tangente hyperbolique de *x*."

#: ../Doc/library/math.rst:372
msgid "Special functions"
msgstr "Fonctions spéciales"

#: ../Doc/library/math.rst:376
msgid ""
"Return the `error function <https://en.wikipedia.org/wiki/Error_function>`_ "
"at *x*."
msgstr ""
"Renvoie la `fonction d'erreur <https://en.wikipedia.org/wiki/"
"Error_function>`_ en *x*."

#: ../Doc/library/math.rst:379
msgid ""
"The :func:`erf` function can be used to compute traditional statistical "
"functions such as the `cumulative standard normal distribution <https://en."
"wikipedia.org/wiki/Normal_distribution#Cumulative_distribution_function>`_::"
msgstr ""
"La fonction :func:`erf` peut être utilisée pour calculer des fonctions "
"statistiques usuelles telles que la `répartition de la loi normale <https://"
"fr.wikipedia.org/wiki/Loi_normale#D.C3.A9finition_par_la_fonction_de_r.C3."
"A9partition>`_ : ::"

#: ../Doc/library/math.rst:392
msgid ""
"Return the complementary error function at *x*.  The `complementary error "
"function <https://en.wikipedia.org/wiki/Error_function>`_ is defined as "
"``1.0 - erf(x)``.  It is used for large values of *x* where a subtraction "
"from one would cause a `loss of significance <https://en.wikipedia.org/wiki/"
"Loss_of_significance>`_\\."
msgstr ""
"Renvoie la fonction d'erreur complémentaire en *x*. La `fonction d'erreur "
"complémentaire <https://fr.wikipedia.org/wiki/Fonction_d'erreur>`_ est "
"définie par ``1.0 - erf(x)``. C'est utilisé pour de grandes valeurs de *x* "
"où une soustraction d'un causerait une `perte de précision <https://en."
"wikipedia.org/wiki/Loss_of_significance>`_\\."

#: ../Doc/library/math.rst:403
msgid ""
"Return the `Gamma function <https://en.wikipedia.org/wiki/Gamma_function>`_ "
"at *x*."
msgstr ""
"Renvoie la `fonction Gamma <https://fr.wikipedia.org/wiki/Fonction_gamma>`_ "
"en *x*."

#: ../Doc/library/math.rst:411
msgid ""
"Return the natural logarithm of the absolute value of the Gamma function at "
"*x*."
msgstr ""
"Renvoie le logarithme naturel de la valeur absolue de la fonction gamma en "
"*x*."

#: ../Doc/library/math.rst:418
msgid "Constants"
msgstr "Constantes"

#: ../Doc/library/math.rst:422
msgid "The mathematical constant π = 3.141592..., to available precision."
msgstr "La constante mathématique π = 3.141592..., à la précision disponile."

#: ../Doc/library/math.rst:427
msgid "The mathematical constant e = 2.718281..., to available precision."
msgstr "La constante mathématique e = 2.718281..., à la précision disponible."

#: ../Doc/library/math.rst:431
msgid ""
"The mathematical constant τ = 6.283185..., to available precision. Tau is a "
"circle constant equal to 2π, the ratio of a circle's circumference to its "
"radius. To learn more about Tau, check out Vi Hart's video `Pi is (still) "
"Wrong <https://www.youtube.com/watch?v=jG7vhMMXagQ>`_, and start celebrating "
"`Tau day <http://tauday.com/>`_ by eating twice as much pie!"
msgstr ""
"La constante mathématique τ = 6.283185..., à la précision disponnible. Tau "
"est une constante du cercle égale à 2π, le ratio entre la circonférence d'un "
"cercle et son rayon. Pour en apprendre plus sur Tau, regardez la vidéo de Vi "
"Hart, `Pi is (still) Wrong <https://www.youtube.com/watch?v=jG7vhMMXagQ>`_, "
"et proffitez-en (ou pas) pour céléberer (ou pas) le `Jour de Tau <http://"
"tauday.com/>`_ en mangeant (ou pas) deux fois plus camembert. (Y'a un jeu de "
"mot, en anglais, avec le *Tau day*, c'est *eating twice as much pie!* "
"(\"deux fois plus de π\" ?)."

#: ../Doc/library/math.rst:441
msgid ""
"A floating-point positive infinity.  (For negative infinity, use ``-math."
"inf``.)  Equivalent to the output of ``float('inf')``."
msgstr ""
"Un flottant positif infini. (Pour un infini négatif, utilisez ``-math."
"inf``.) Équivalent au résultat de ``float('inf')``."

#: ../Doc/library/math.rst:449
msgid ""
"A floating-point \"not a number\" (NaN) value.  Equivalent to the output of "
"``float('nan')``."
msgstr "Un flottant valant NaN. Équivalent au résultat de ``float('nan')``."

#: ../Doc/library/math.rst:457
msgid ""
"The :mod:`math` module consists mostly of thin wrappers around the platform "
"C math library functions.  Behavior in exceptional cases follows Annex F of "
"the C99 standard where appropriate.  The current implementation will raise :"
"exc:`ValueError` for invalid operations like ``sqrt(-1.0)`` or ``log(0.0)`` "
"(where C99 Annex F recommends signaling invalid operation or divide-by-"
"zero), and :exc:`OverflowError` for results that overflow (for example, "
"``exp(1000.0)``).  A NaN will not be returned from any of the functions "
"above unless one or more of the input arguments was a NaN; in that case, "
"most functions will return a NaN, but (again following C99 Annex F) there "
"are some exceptions to this rule, for example ``pow(float('nan'), 0.0)`` or "
"``hypot(float('nan'), float('inf'))``."
msgstr ""
"Le module :mod:`math` consiste majoritairement en un conteneur pour les "
"fonctions mathématiques de la bibliothèque C de la plate-forme. Le "
"comportement dans les cas spéciaux suit l'annexe 'F' du standard C99 quand "
"c'est approprié. L'implémentation actuelle lève une :exc:`ValueError` pour "
"les opérations invalides telles que ``sqrt(-1.0)`` ou ``log(0.0)`` (où le "
"standard C99 recommande de signaler que l'opération est invalide ou qu'il y "
"a division par zéro), et une :exc:`OverflowError` pour les résultats qui "
"débordent (par exemple ``exp(1000.0)``). NaN ne sera renvoyé pour toute les "
"fonctions ci-dessus sauf si au moins un des arguments de la fonction vaut "
"NaN. Dans ce cas, la plupart des fonctions renvoiera NaN, mais (à nouveau, "
"selon l'annexe 'F' du standard C99) il y a quelques exceptions à cette "
"règle, par exemple ``pow(float('nan'), 0.0)`` ou ``hypot(float('nan'), "
"float('inf'))``."

#: ../Doc/library/math.rst:469
msgid ""
"Note that Python makes no effort to distinguish signaling NaNs from quiet "
"NaNs, and behavior for signaling NaNs remains unspecified. Typical behavior "
"is to treat all NaNs as though they were quiet."
msgstr ""
"Notez que Python ne fait aucun effort pour distinguer les NaNs signalétiques "
"des NaNs silencieux, et le comportement de signalement des NaNs reste non-"
"spécifié. le comportement typique est de traiter tous les NaNs comme s'ils "
"étaient silencieux."

#: ../Doc/library/math.rst:476
msgid "Module :mod:`cmath`"
msgstr "Module :mod:`cmath`"

#: ../Doc/library/math.rst:477
msgid "Complex number versions of many of these functions."
msgstr "Version complexe de beaucoup de ces fonctions."