python-docs-fr/library/math.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-01-15 22:33+0100\n"
"PO-Revision-Date: 2022-10-18 12:28+0200\n"
"Last-Translator: Antoine Wecxsteen\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\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.2.1\n"

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

#: library/math.rst:13
msgid ""
"This module provides access to the mathematical functions defined by the C "
"standard."
msgstr ""
"Ce module fournit l'accès aux fonctions mathématiques définies par la norme "
"C."

#: 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 pas être utilisées avec les nombres complexes ; si "
"vous avez besoin de la prise en charge des nombres complexes, utilisez les "
"fonctions du même nom du module :mod:`cmath`. La séparation entre les "
"fonctions qui gèrent les nombres complexes et les autres vient du constat "
"que tous les utilisateurs ne souhaitent pas acquérir le niveau mathématique "
"nécessaire à la compréhension des nombres complexes. Recevoir une exception "
"plutôt qu'un nombre complexe en retour d'une fonction permet au programmeur "
"de déterminer immédiatement comment et pourquoi ce nombre a été généré, "
"avant que celui-ci ne soit passé involontairement en paramètre d'une autre "
"fonction."

#: 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."

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

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

#: library/math.rst:41
msgid ""
"Return the number of ways to choose *k* items from *n* items without "
"repetition and without order."
msgstr ""
"Renvoie le nombre de façons de choisir *k* éléments parmi *n* de manière non-"
"ordonnée et sans répétition."

#: library/math.rst:44
msgid ""
"Evaluates to ``n! / (k! * (n - k)!)`` when ``k <= n`` and evaluates to zero "
"when ``k > n``."
msgstr ""
"Vaut ``n! / (k! * (n - k)!)`` quand ``k <= n`` et zéro quand ``k > n``."

#: library/math.rst:47
#, fuzzy
msgid ""
"Also called the binomial coefficient because it is equivalent to the "
"coefficient of k-th term in polynomial expansion of ``(1 + x)ⁿ``."
msgstr ""
"Aussi connue sous le nom de « coefficient binomial » car c'est la valeur du "
"coefficient du *k*\\ :sup:`e` terme dans le développement polynomial de "
"l'expression ``(1+x) ** n``."

#: library/math.rst:260
msgid ""
"Raises :exc:`TypeError` if either of the arguments are not integers. Raises :"
"exc:`ValueError` if either of the arguments are negative."
msgstr ""
"Lève une :exc:`TypeError` si un des paramètres n'est pas un entier. Lève "
"une :exc:`ValueError` si un des paramètres est négatif."

#: library/math.rst:59
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 plates-formes prenant en charge les zéros signés, "
"``copysign(1.0, -0.0)`` renvoie ``-1.0``."

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

#: library/math.rst:71
#, fuzzy
msgid ""
"Return *n* factorial as an integer.  Raises :exc:`ValueError` if *n* is not "
"integral or is negative."
msgstr ""
"Renvoie la factorielle de *x* sous forme d'entier. Lève une :exc:"
"`ValueError` si *x* n'est pas entier ou s'il est négatif."

#: library/math.rst:74
msgid "Accepting floats with integral values (like ``5.0``) is deprecated."
msgstr ""

#: library/math.rst:80
#, fuzzy
msgid ""
"Return the floor of *x*, the largest integer less than or equal to *x*.  If "
"*x* is not a float, delegates to :meth:`x.__floor__ <object.__floor__>`, "
"which should return an :class:`~numbers.Integral` value."
msgstr ""
"Renvoie la partie entière (par défaut) de *x*, le plus grand entier "
"inférieur ou égal à *x*. Si *x* n'est pas un flottant, délègue à ``x."
"__floor()__``, qui doit renvoyer une valeur :class:`~numbers.Integral`."

#: library/math.rst:87
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 privilégiée quand des flottants sont manipulés, alors que "
"l'expression Python ``x % y`` est privilégiée quand des entiers sont "
"manipulés."

#: library/math.rst:102
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."

#: library/math.rst:110
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 ::"

#: library/math.rst:118
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 ""
"La précision de cet algorithme dépend des garanties arithmétiques de "
"IEEE-754 et des cas standards 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."

#: library/math.rst:124
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/>`_\\."

#: library/math.rst:131
#, fuzzy
msgid ""
"Return the greatest common divisor of the specified integer arguments. If "
"any of the arguments is nonzero, then the returned value is the largest "
"positive integer that is a divisor of all arguments.  If all arguments are "
"zero, then the returned value is ``0``.  ``gcd()`` without arguments returns "
"``0``."
msgstr ""
"Renvoie le plus grand diviseur commun des entiers *a* et *b*. Si *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``."

#: library/math.rst:139
#, fuzzy
msgid ""
"Added support for an arbitrary number of arguments. Formerly, only two "
"arguments were supported."
msgstr ""
"Ajout de la gestion des points à n-dimensions. Auparavant seuls les points "
"bi-dimensionnels étaient gérés."

#: library/math.rst:146
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."

#: library/math.rst:149
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 considérées comme « proches » se fait à "
"l'aide des tolérances absolues et relatives passées en paramètres."

#: library/math.rst:152
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\\ :sup:`e` décimale. *rel_tol* doit être supérieur à "
"zéro."

#: library/math.rst:158
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."

#: library/math.rst:161
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)``."

#: library/math.rst:164
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ées proches que d'elles-"
"mêmes."

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

#: library/math.rst:178
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é comme fini.)"

#: library/math.rst:186
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."

#: library/math.rst:192
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."

#: library/math.rst:197
msgid ""
"Return the integer square root of the nonnegative integer *n*. This is the "
"floor of the exact square root of *n*, or equivalently the greatest integer "
"*a* such that *a*\\ ² |nbsp| ≤ |nbsp| *n*."
msgstr ""
"Renvoie la racine carrée entière du nombre positif *n*. C'est la partie "
"entière de la valeur exacte de la racine carrée de *n* ou, de manière "
"équivalente, le plus grand entier *a* tel que a*\\ ² ≤ *n*."

#: library/math.rst:201
msgid ""
"For some applications, it may be more convenient to have the least integer "
"*a* such that *n* |nbsp| ≤ |nbsp| *a*\\ ², or in other words the ceiling of "
"the exact square root of *n*. For positive *n*, this can be computed using "
"``a = 1 + isqrt(n - 1)``."
msgstr ""
"Pour certaines applications, il est plus pratique d'avoir le plus petit "
"entier *a* tel que *n* ≤ *a*\\ ² ou, en d'autres termes, la partie entière "
"de la valeur exacte de la racine carrée de *n*. Pour *n* positif, on peut le "
"calculer avec ``a = 1 + isqrt(n - 1)``."

#: library/math.rst:211
msgid ""
"Return the least common multiple of the specified integer arguments. If all "
"arguments are nonzero, then the returned value is the smallest positive "
"integer that is a multiple of all arguments.  If any of the arguments is "
"zero, then the returned value is ``0``.  ``lcm()`` without arguments returns "
"``1``."
msgstr ""

#: library/math.rst:222
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`."

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

#: library/math.rst:234
msgid "Return the next floating-point value after *x* towards *y*."
msgstr ""
"Renvoie la valeur flottante consécutive à *x*, dans la direction de *y*."

#: library/math.rst:236
msgid "If *x* is equal to *y*, return *y*."
msgstr "Si *x* est égal à *y*, renvoie *y*."

#: library/math.rst:238
msgid "Examples:"
msgstr "Exemples :"

#: library/math.rst:240
msgid "``math.nextafter(x, math.inf)`` goes up: towards positive infinity."
msgstr ""
"``math.nextafter(x, math.inf)`` augmente de valeur : vers l'infini positif."

#: library/math.rst:241
msgid "``math.nextafter(x, -math.inf)`` goes down: towards minus infinity."
msgstr ""
"``math.nextafter(x, -math.inf)`` baisse de valeur : vers l'infini négatif."

#: library/math.rst:242
msgid "``math.nextafter(x, 0.0)`` goes towards zero."
msgstr "``math.nextafter(x, 0.0)`` augmente ou baisse de valeur, vers zéro."

#: library/math.rst:243
msgid "``math.nextafter(x, math.copysign(math.inf, x))`` goes away from zero."
msgstr ""
"``math.nextafter(x, math.copysign(math.inf, x))`` augmente ou baisse de "
"valeur, en s'éloignant de zéro."

#: library/math.rst:245
msgid "See also :func:`math.ulp`."
msgstr "Voir aussi : :func:`math.ulp`."

#: library/math.rst:251
msgid ""
"Return the number of ways to choose *k* items from *n* items without "
"repetition and with order."
msgstr ""
"Renvoie le nombre de façons de choisir *k* éléments parmi *n* de manière "
"ordonnée sans répétition."

#: library/math.rst:254
msgid ""
"Evaluates to ``n! / (n - k)!`` when ``k <= n`` and evaluates to zero when "
"``k > n``."
msgstr "Vaut ``n! / (n - k)!`` quand ``k <= n`` et vaut zéro quand ``k > n``."

#: library/math.rst:257
msgid ""
"If *k* is not specified or is None, then *k* defaults to *n* and the "
"function returns ``n!``."
msgstr ""
"Si *k* n'est pas défini ou vaut *None*, *k* prend par défaut la valeur *n* "
"et la fonction renvoie alors ``n!``."

#: library/math.rst:268
msgid ""
"Calculate the product of all the elements in the input *iterable*. The "
"default *start* value for the product is ``1``."
msgstr ""
"Calcule le produit de tous les éléments passés dans l'entrée *iterable*. La "
"valeur de *départ* par défaut du produit vaut ``1``."

#: library/math.rst:271
msgid ""
"When the iterable is empty, return the start value.  This function is "
"intended specifically for use with numeric values and may reject non-numeric "
"types."
msgstr ""
"Quand l'itérable est vide, renvoie la valeur de départ. Cette fonction ne "
"doit être utilisée qu'avec des valeurs numériques et peut rejeter les types "
"non-numériques."

#: library/math.rst:280
msgid ""
"Return the IEEE 754-style remainder of *x* with respect to *y*.  For finite "
"*x* and finite nonzero *y*, this is the difference ``x - n*y``, where ``n`` "
"is the closest integer to the exact value of the quotient ``x / y``.  If "
"``x / y`` is exactly halfway between two consecutive integers, the nearest "
"*even* integer is used for ``n``.  The remainder ``r = remainder(x, y)`` "
"thus always satisfies ``abs(r) <= 0.5 * abs(y)``."
msgstr ""
"Renvoie le reste selon la norme IEEE 754 de *x* par rapport à *y*. Pour *x* "
"fini et *y* fini non nul, il s'agit de la différence ``x - n*y``, où ``n`` "
"est l'entier le plus proche de la valeur exacte du quotient ``x / y``. Si "
"``x / y`` est exactement à mi-chemin de deux entiers consécutifs, le plus "
"proche entier *pair* est utilisé pour ``n``. Ainsi, le reste ``r = "
"remainder(x, y)`` vérifie toujours ``abs(r) <= 0.5 * abs(y)``."

#: library/math.rst:287
msgid ""
"Special cases follow IEEE 754: in particular, ``remainder(x, math.inf)`` is "
"*x* for any finite *x*, and ``remainder(x, 0)`` and ``remainder(math.inf, "
"x)`` raise :exc:`ValueError` for any non-NaN *x*. If the result of the "
"remainder operation is zero, that zero will have the same sign as *x*."
msgstr ""
"Les cas spéciaux suivent la norme IEEE 754 : en particulier, ``remainder(x, "
"math.inf)`` vaut *x* pour tout *x* fini,  et ``remainder(x, 0)`` et "
"``remainder(math.inf, x)`` lèvent :exc:`ValueError` pour tout *x* *non-NaN*. "
"Si le résultat de l'opération *remainder* est zéro, alors  ce zéro aura le "
"même signe que *x*."

#: library/math.rst:293
msgid ""
"On platforms using IEEE 754 binary floating-point, the result of this "
"operation is always exactly representable: no rounding error is introduced."
msgstr ""
"Sur les plates-formes utilisant la norme IEEE 754 pour les nombres à virgule "
"flottante en binaire, le résultat de cette opération est toujours exactement "
"représentable : aucune erreur d'arrondi n'est introduite."

#: library/math.rst:301
#, fuzzy
msgid ""
"Return *x* with the fractional part removed, leaving the integer part.  This "
"rounds toward 0: ``trunc()`` is equivalent to :func:`floor` for positive "
"*x*, and equivalent to :func:`ceil` for negative *x*. If *x* is not a float, "
"delegates to :meth:`x.__trunc__ <object.__trunc__>`, which should return an :"
"class:`~numbers.Integral` value."
msgstr ""
"Renvoie la partie entière (par défaut) de *x*, le plus grand entier "
"inférieur ou égal à *x*. Si *x* n'est pas un flottant, délègue à ``x."
"__floor()__``, qui doit renvoyer une valeur :class:`~numbers.Integral`."

#: library/math.rst:309
msgid "Return the value of the least significant bit of the float *x*:"
msgstr ""

#: library/math.rst:311
#, fuzzy
msgid "If *x* is a NaN (not a number), return *x*."
msgstr ""
"Renvoie ``True`` si *x* est NaN (*Not a Number*, ou *Pas un Nombre* en "
"français), et ``False`` sinon."

#: library/math.rst:312
msgid "If *x* is negative, return ``ulp(-x)``."
msgstr ""

#: library/math.rst:313
msgid "If *x* is a positive infinity, return *x*."
msgstr ""

#: library/math.rst:314
msgid ""
"If *x* is equal to zero, return the smallest positive *denormalized* "
"representable float (smaller than the minimum positive *normalized* float, :"
"data:`sys.float_info.min <sys.float_info>`)."
msgstr ""

#: library/math.rst:317
msgid ""
"If *x* is equal to the largest positive representable float, return the "
"value of the least significant bit of *x*, such that the first float smaller "
"than *x* is ``x - ulp(x)``."
msgstr ""

#: library/math.rst:320
msgid ""
"Otherwise (*x* is a positive finite number), return the value of the least "
"significant bit of *x*, such that the first float bigger than *x* is ``x + "
"ulp(x)``."
msgstr ""

#: library/math.rst:324
msgid "ULP stands for \"Unit in the Last Place\"."
msgstr ""

#: library/math.rst:326
msgid ""
"See also :func:`math.nextafter` and :data:`sys.float_info.epsilon <sys."
"float_info>`."
msgstr ""

#: library/math.rst:332
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 seul argument et renvoient "
"une paire de valeurs au lieu de placer la seconde valeur de retour dans un "
"*paramètre de sortie* (cela n'existe pas en Python)."

#: library/math.rst:337
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 généralement 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."

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

#: library/math.rst:349
#, fuzzy
msgid "Return the cube root of *x*."
msgstr "Renvoie la racine carrée de *x*."

#: library/math.rst:356
msgid ""
"Return *e* raised to the power *x*, where *e* = 2.718281... is the base of "
"natural logarithms.  This is usually more accurate than ``math.e ** x`` or "
"``pow(math.e, x)``."
msgstr ""
"Renvoie *e* à la puissance *x*, où *e* = 2.718281… est la base des "
"logarithmes naturels. Cela est en général plus précis que ``math.e ** x`` ou "
"``pow(math.e, x)``."

#: library/math.rst:363
#, fuzzy
msgid "Return *2* raised to the power *x*."
msgstr "Renvoie la racine carrée de *x*."

#: library/math.rst:370
msgid ""
"Return *e* raised to the power *x*, minus 1.  Here *e* is the base of "
"natural logarithms.  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* à la puissance *x*, moins 1. Ici, *e* est la base des "
"logarithmes naturels. Pour de petits flottants *x*, 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 ::"

#: library/math.rst:387
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*)."

#: library/math.rst:389
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)``."

#: library/math.rst:395
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."

#: library/math.rst:401
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 en général plus précis que "
"``log(x, 2)``."

#: library/math.rst:408
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."

#: library/math.rst:414
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)``."

#: library/math.rst:420
#, fuzzy
msgid ""
"Return ``x`` raised to the power ``y``.  Exceptional cases follow the IEEE "
"754 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`."

#: library/math.rst:427
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."

#: library/math.rst:431
msgid ""
"The special cases ``pow(0.0, -inf)`` and ``pow(-0.0, -inf)`` were changed to "
"return ``inf`` instead of raising :exc:`ValueError`, for consistency with "
"IEEE 754."
msgstr ""

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

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

#: library/math.rst:447
#, fuzzy
msgid ""
"Return the arc cosine of *x*, in radians. The result is between ``0`` and "
"``pi``."
msgstr "Renvoie l'arc cosinus de *x*, en radians."

#: library/math.rst:453
#, fuzzy
msgid ""
"Return the arc sine of *x*, in radians. The result is between ``-pi/2`` and "
"``pi/2``."
msgstr "Renvoie l'arc sinus de *x*, en radians."

#: library/math.rst:459
#, fuzzy
msgid ""
"Return the arc tangent of *x*, in radians. The result is between ``-pi/2`` "
"and ``pi/2``."
msgstr "Renvoie l'arc tangente de *x*, en radians."

#: library/math.rst:465
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``."

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

#: library/math.rst:480
msgid ""
"Return the Euclidean distance between two points *p* and *q*, each given as "
"a sequence (or iterable) of coordinates.  The two points must have the same "
"dimension."
msgstr ""
"Renvoie la distance Euclienne entre deux points *p* et *q*, passés comme des "
"séquences (ou des itérables) de coordonnées. Les deux points doivent avoir "
"la même dimension."

#: library/math.rst:484
msgid "Roughly equivalent to::"
msgstr "À peu près équivalent à ::"

#: library/math.rst:493
msgid ""
"Return the Euclidean norm, ``sqrt(sum(x**2 for x in coordinates))``. This is "
"the length of the vector from the origin to the point given by the "
"coordinates."
msgstr ""
"Renvoie la norme Euclidienne, ``sqrt(sum(x**2 for x in coordinates))``. "
"C'est la norme du vecteur entre l'origine et le point donné par les "
"coordonnées."

#: library/math.rst:497
msgid ""
"For a two dimensional point ``(x, y)``, this is equivalent to computing the "
"hypotenuse of a right triangle using the Pythagorean theorem, ``sqrt(x*x + "
"y*y)``."
msgstr ""
"Pour un point bi-dimensionnel ``(x, y)``, c'est équivalent à calculer la "
"valeur de l’hypoténuse d'un triangle rectangle en utilisant le théorème de "
"Pythagore, ``sqrt(x*x + y*y)``."

#: library/math.rst:501
msgid ""
"Added support for n-dimensional points. Formerly, only the two dimensional "
"case was supported."
msgstr ""
"Ajout de la gestion des points à n-dimensions. Auparavant seuls les points "
"bi-dimensionnels étaient gérés."

#: library/math.rst:505
msgid ""
"Improved the algorithm's accuracy so that the maximum error is under 1 ulp "
"(unit in the last place).  More typically, the result is almost always "
"correctly rounded to within 1/2 ulp."
msgstr ""

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: library/math.rst:576
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*."

#: library/math.rst:579
#, fuzzy
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_functions>`_::"
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>`_ ::"

#: library/math.rst:592
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)``. Elle est utilisée pour les grandes valeurs de "
"*x*, où la soustraction en partant de 1,0 entraînerait une `perte de "
"précision <https://en.wikipedia.org/wiki/Loss_of_significance>`_\\."

#: library/math.rst:603
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*."

#: library/math.rst:611
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*."

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

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

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

#: library/math.rst:632
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 <https://tauday.com/>`_ by eating twice as much pie!"
msgstr ""
"La constante mathématique *τ* = 6.283185…, à la précision disponible. Tau "
"est une constante du cercle égale à 2 \\*π*, le rapport de la circonférence "
"d'un cercle à 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 profitez-en pour célébrer le `Jour de Tau <https://"
"tauday.com/>`_ en bavardant comme deux pies !"

#: library/math.rst:643
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')``."

#: library/math.rst:651
msgid ""
"A floating-point \"not a number\" (NaN) value. Equivalent to the output of "
"``float('nan')``. Due to the requirements of the `IEEE-754 standard <https://"
"en.wikipedia.org/wiki/IEEE_754>`_, ``math.nan`` and ``float('nan')`` are not "
"considered to equal to any other numeric value, including themselves. To "
"check whether a number is a NaN, use the :func:`isnan` function to test for "
"NaNs instead of ``is`` or ``==``. Example::"
msgstr ""

#: library/math.rst:669
msgid "It is now always available."
msgstr ""

#: library/math.rst:677
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 aucune "
"des fonctions ci-dessus, sauf si au moins un des arguments de la fonction "
"vaut *NaN*. Dans ce cas, la plupart des fonctions renvoient *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'))``."

#: library/math.rst:689
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 standard est de traiter tous les NaNs comme s'ils "
"étaient silencieux."

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

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

#~ 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 à :meth:`x."
#~ "__trunc__() <object.__trunc__>`."

#~ 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')``."