3.5/library.po: Translate math.rst

library.po

@@ -8,7 +8,7 @@ msgstr ""
 "Project-Id-Version: Python 3.5\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2016-03-12 23:41+0100\n"
-"PO-Revision-Date: 2016-04-15 00:36+0100\n"
+"PO-Revision-Date: 2016-04-15 10:56+0100\n"
 "Last-Translator: Robin Petit <robpetit@ulb.ac.be>\n"
 "Language-Team: \n"
 "Language: fr\n"
@@ -70236,13 +70236,15 @@ msgstr ""
 
 #: ../Doc/library/math.rst:2
 msgid ":mod:`math` --- Mathematical functions"
-msgstr ""
+msgstr "Fonctions mathématiques --- :mod:`math`"
 
 #: ../Doc/library/math.rst:11
 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:14
 msgid ""
@@ -70255,16 +70257,27 @@ msgid ""
 "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:23
 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:28
 msgid "Number-theoretic and representation functions"
-msgstr ""
+msgstr "Fonctions arithmétiques et de représentation"
 
 #: ../Doc/library/math.rst:32
 msgid ""
@@ -70272,6 +70285,9 @@ msgid ""
 "*x*. If *x* is not a float, delegates to ``x.__ceil__()``, which should "
 "return an :class:`~numbers.Integral` value."
 msgstr ""
+"Retourne 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 "
+"retourner une valeur :class:`~numbers.Integral`."
 
 #: ../Doc/library/math.rst:39
 msgid ""
@@ -70279,16 +70295,21 @@ msgid ""
 "*y*.  On platforms that support signed zeros, ``copysign(1.0, -0.0)`` "
 "returns *-1.0*."
 msgstr ""
+"Retourne 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)`` retourne *-1.0*."
 
 #: ../Doc/library/math.rst:45
 msgid "Return the absolute value of *x*."
-msgstr ""
+msgstr "Retourne la valeur absolue de *x*."
 
 #: ../Doc/library/math.rst:49
 msgid ""
 "Return *x* factorial.  Raises :exc:`ValueError` if *x* is not integral or is "
 "negative."
 msgstr ""
+"Retourne 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:54
 msgid ""
@@ -70296,6 +70317,9 @@ msgid ""
 "*x* is not a float, delegates to ``x.__floor__()``, which should return an :"
 "class:`~numbers.Integral` value."
 msgstr ""
+"Retourne 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 "
+"retourner une valeur :class:`~numbers.Integral`."
 
 #: ../Doc/library/math.rst:61
 msgid ""
@@ -70312,6 +70336,19 @@ msgid ""
 "generally preferred when working with floats, while Python's ``x % y`` is "
 "preferred when working with integers."
 msgstr ""
+"Retourne ``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 retourner 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`` retourne 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:76
 msgid ""
@@ -70320,12 +70357,19 @@ msgid ""
 "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 ""
+"Retourne 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, retourne ``(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:84
 msgid ""
 "Return an accurate floating point sum of values in the iterable.  Avoids "
 "loss of precision by tracking multiple intermediate partial sums::"
 msgstr ""
+"Retourne 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:92
 msgid ""
@@ -70335,6 +70379,12 @@ msgid ""
 "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:98
 msgid ""
@@ -70342,6 +70392,9 @@ msgid ""
 "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:105
 msgid ""
@@ -70349,41 +70402,56 @@ msgid ""
 "*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 ""
+"Retourne le plus grand commun diviseur 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)`` retourne ``0``."
 
 #: ../Doc/library/math.rst:147
 msgid ""
 "Return ``True`` if *x* is neither an infinity nor a NaN, and ``False`` "
 "otherwise.  (Note that ``0.0`` *is* considered finite.)"
 msgstr ""
+"Retourne ``True`` si *n* n'est ni infini, ni NaN, et ``False`` sinon. (Notez "
+"que ``0.0`` *est* considéré fini.)"
 
 #: ../Doc/library/math.rst:155
 msgid ""
 "Return ``True`` if *x* is a positive or negative infinity, and ``False`` "
 "otherwise."
 msgstr ""
+"Retourne ``True`` si *x* vaut l'infini positif ou négatif, et ``False`` "
+"sinon."
 
 #: ../Doc/library/math.rst:161
 msgid ""
 "Return ``True`` if *x* is a NaN (not a number), and ``False`` otherwise."
 msgstr ""
+"Retourne ``True`` si *x* est NaN (*Not a Number*, ou *Pas un Nombre* en "
+"français), et ``False`` sinon."
 
 #: ../Doc/library/math.rst:166
 msgid ""
 "Return ``x * (2**i)``.  This is essentially the inverse of function :func:"
 "`frexp`."
 msgstr ""
+"Retourne ``x * (2**i)``. C'est essentiellement l'inverse de la fonction :"
+"func:`frexp`."
 
 #: ../Doc/library/math.rst:172
 msgid ""
 "Return the fractional and integer parts of *x*.  Both results carry the sign "
 "of *x* and are floats."
 msgstr ""
+"Retourne les parties entières et fractionnelle de *x*. Les deux résultats "
+"ont le signe de *x* et sont flottants."
 
 #: ../Doc/library/math.rst:178
 msgid ""
 "Return the :class:`~numbers.Real` value *x* truncated to an :class:`~numbers."
 "Integral` (usually an integer). Delegates to ``x.__trunc__()``."
 msgstr ""
+"Retourne 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:183
 msgid ""
@@ -70392,6 +70460,11 @@ msgid ""
 "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 "
+"retournent une paire de valeurs au lieu de retourner 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:188
 msgid ""
@@ -70401,10 +70474,16 @@ msgid ""
 "(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:200
 msgid "Return ``e**x``."
-msgstr ""
+msgstr "Retourne ``e**x``."
 
 #: ../Doc/library/math.rst:205
 msgid ""
@@ -70413,40 +70492,54 @@ msgid ""
 "wiki/Loss_of_significance>`_\\; the :func:`expm1` function provides a way to "
 "compute this quantity to full precision::"
 msgstr ""
+"Retourne ``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:221
 msgid "With one argument, return the natural logarithm of *x* (to base *e*)."
-msgstr ""
+msgstr "Avec un argument, retourne le logarithme naturel de *x* (en base *e*)."
 
 #: ../Doc/library/math.rst:223
 msgid ""
 "With two arguments, return the logarithm of *x* to the given *base*, "
 "calculated as ``log(x)/log(base)``."
 msgstr ""
+"Avec deux arguments, retourne le logarithme de *x* en la *base* donnée, "
+"calculé par ``log(x)/log(base)``."
 
 #: ../Doc/library/math.rst:229
 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 ""
+"Retourne 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:235
 msgid ""
 "Return the base-2 logarithm of *x*. This is usually more accurate than "
 "``log(x, 2)``."
 msgstr ""
+"Retourne le logarithme en base 2 de *x*. C'est habituellement plus exact que "
+"``log(x, 2)``."
 
 #: ../Doc/library/math.rst:242
 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` retourne 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:248
 msgid ""
 "Return the base-10 logarithm of *x*.  This is usually more accurate than "
 "``log(x, 10)``."
 msgstr ""
+"Retourne le logarithme de *x* en base 10. C'est habituellement plus exact "
+"que ``log(x, 10)``."
 
 #: ../Doc/library/math.rst:254
 msgid ""
@@ -70456,6 +70549,12 @@ msgid ""
 "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 ""
+"Retourne ``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)`` retournent 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:261
 msgid ""
@@ -70463,22 +70562,25 @@ msgid ""
 "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:268
 msgid "Return the square root of *x*."
-msgstr ""
+msgstr "Retourne la racine carrée de *x*."
 
 #: ../Doc/library/math.rst:276
 msgid "Return the arc cosine of *x*, in radians."
-msgstr ""
+msgstr "Retourne l'arc cosinus de *x*, en radians."
 
 #: ../Doc/library/math.rst:281
 msgid "Return the arc sine of *x*, in radians."
-msgstr ""
+msgstr "Retourne l'arc sinus de *x*, en radians."
 
 #: ../Doc/library/math.rst:286
 msgid "Return the arc tangent of *x*, in radians."
-msgstr ""
+msgstr "Retourne l'arc tangente de *x*, en radians."
 
 #: ../Doc/library/math.rst:291
 msgid ""
@@ -70489,36 +70591,44 @@ msgid ""
 "for the angle. For example, ``atan(1)`` and ``atan2(1, 1)`` are both "
 "``pi/4``, but ``atan2(-1, -1)`` is ``-3*pi/4``."
 msgstr ""
+"Retourne ``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:301
 msgid "Return the cosine of *x* radians."
-msgstr ""
+msgstr "Retourne le cosinus de *x* radians."
 
 #: ../Doc/library/math.rst:306
 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 ""
+"Retourne 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:312
 msgid "Return the sine of *x* radians."
-msgstr ""
+msgstr "Retourne le sinus de*x* radians."
 
 #: ../Doc/library/math.rst:317
 msgid "Return the tangent of *x* radians."
-msgstr ""
+msgstr "Retourne la tangente de *x* radians."
 
 #: ../Doc/library/math.rst:320
 msgid "Angular conversion"
-msgstr ""
+msgstr "Conversion angulaire"
 
 #: ../Doc/library/math.rst:325
 msgid "Convert angle *x* from radians to degrees."
-msgstr ""
+msgstr "Convertit l'angle *x* de radians en degrés."
 
 #: ../Doc/library/math.rst:330
 msgid "Convert angle *x* from degrees to radians."
-msgstr ""
+msgstr "Convertit l'ange *x* de degrés en radians."
 
 #: ../Doc/library/math.rst:335
 msgid ""
@@ -70526,28 +70636,33 @@ msgid ""
 "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:341
 msgid "Return the inverse hyperbolic cosine of *x*."
-msgstr ""
+msgstr "Retourne l'arc cosinus hyperbolique de *x*."
 
 #: ../Doc/library/math.rst:346
 msgid "Return the inverse hyperbolic sine of *x*."
-msgstr ""
+msgstr "Retourne l'arc sinus hyperbolique de *x*."
 
 #: ../Doc/library/math.rst:351
 msgid "Return the inverse hyperbolic tangent of *x*."
-msgstr ""
+msgstr "Retourne l'arc tangente hyperbolique de *x*."
 
 #: ../Doc/library/math.rst:370
 msgid "Special functions"
-msgstr ""
+msgstr "Fonctions spéciales"
 
 #: ../Doc/library/math.rst:374
 msgid ""
 "Return the `error function <https://en.wikipedia.org/wiki/Error_function>`_ "
 "at *x*."
 msgstr ""
+"Retourne la `fonction d'erreur <https://en.wikipedia.org/wiki/"
+"Error_function>`_ en *x*."
 
 #: ../Doc/library/math.rst:377
 msgid ""
@@ -70555,6 +70670,10 @@ msgid ""
 "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:390
 msgid ""
@@ -70564,38 +70683,49 @@ msgid ""
 "from one would cause a `loss of significance <https://en.wikipedia.org/wiki/"
 "Loss_of_significance>`_\\."
 msgstr ""
+"Retourne 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:401
 msgid ""
 "Return the `Gamma function <https://en.wikipedia.org/wiki/Gamma_function>`_ "
 "at *x*."
 msgstr ""
+"Retourne la `fonction Gamma <https://fr.wikipedia.org/wiki/Fonction_gamma>`_ "
+"en *x*."
 
 #: ../Doc/library/math.rst:409
 msgid ""
 "Return the natural logarithm of the absolute value of the Gamma function at "
 "*x*."
 msgstr ""
+"Retourne le logarithme naturel de la valeur absolue de la fonction gamma en "
+"*x*."
 
 #: ../Doc/library/math.rst:420
 msgid "The mathematical constant π = 3.141592..., to available precision."
-msgstr ""
+msgstr "La constante mathématique π = 3.141592..., à la précision disponile."
 
 #: ../Doc/library/math.rst:425
 msgid "The mathematical constant e = 2.718281..., to available precision."
-msgstr ""
+msgstr "La constante mathématique e = 2.718281..., à la précision disponible."
 
 #: ../Doc/library/math.rst:430
 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:438
 msgid ""
 "A floating-point \"not a number\" (NaN) value.  Equivalent to the output of "
 "``float('nan')``."
-msgstr ""
+msgstr "Un flottant valant NaN. Équivalent au résultat de ``float('nan')``."
 
 #: ../Doc/library/math.rst:446
 msgid ""
@@ -70611,6 +70741,19 @@ msgid ""
 "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 retourné 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 retournera 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:458
 msgid ""
@@ -70618,14 +70761,18 @@ msgid ""
 "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:465
 msgid "Module :mod:`cmath`"
-msgstr ""
+msgstr "Module :mod:`cmath`"
 
 #: ../Doc/library/math.rst:466
 msgid "Complex number versions of many of these functions."
-msgstr ""
+msgstr "Version complexe de beaucoup de ces fonctions."
 
 #: ../Doc/library/mimetypes.rst:2
 msgid ":mod:`mimetypes` --- Map filenames to MIME types"