forked from AFPy/python-docs-fr
844 lines
36 KiB
Plaintext
844 lines
36 KiB
Plaintext
# 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: 2019-09-04 11:33+0200\n"
|
||
"PO-Revision-Date: 2019-10-09 21:42+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"
|
||
|
||
#: ../Doc/library/math.rst:2
|
||
msgid ":mod:`math` --- Mathematical functions"
|
||
msgstr "Fonctions mathématiques — :mod:`math`"
|
||
|
||
#: ../Doc/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."
|
||
|
||
#: ../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 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. "
|
||
|
||
#: ../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 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`."
|
||
|
||
#: ../Doc/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."
|
||
|
||
#: ../Doc/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``."
|
||
|
||
#: ../Doc/library/math.rst:47
|
||
msgid ""
|
||
"Also called the binomial coefficient because it is equivalent to the "
|
||
"coefficient of k-th term in polynomial expansion of the expression ``(1 + x) "
|
||
"** n``."
|
||
msgstr ""
|
||
"Aussi connue sous le nom de « coefficient binomial » car c'est la valeur du "
|
||
"coefficient du *k*-ième terme dans le développement polynomial de "
|
||
"l'expression ``(1+x)**n``."
|
||
|
||
#: ../Doc/library/math.rst:51 ../Doc/library/math.rst:224
|
||
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."
|
||
|
||
#: ../Doc/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``."
|
||
|
||
#: ../Doc/library/math.rst:66
|
||
msgid "Return the absolute value of *x*."
|
||
msgstr "Renvoie la valeur absolue de *x*."
|
||
|
||
#: ../Doc/library/math.rst:71
|
||
msgid ""
|
||
"Return *x* factorial as an integer. Raises :exc:`ValueError` if *x* 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."
|
||
|
||
#: ../Doc/library/math.rst:77
|
||
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 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`."
|
||
|
||
#: ../Doc/library/math.rst:84
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:99
|
||
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:107
|
||
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:115
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:121
|
||
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:128
|
||
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 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``."
|
||
|
||
#: ../Doc/library/math.rst:138
|
||
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:141
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:144
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:150
|
||
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:153
|
||
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:156
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:165
|
||
msgid ":pep:`485` -- A function for testing approximate equality"
|
||
msgstr ":pep:`485` — Une fonction pour tester des quasi-égalités"
|
||
|
||
#: ../Doc/library/math.rst:170
|
||
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.)"
|
||
|
||
#: ../Doc/library/math.rst:178
|
||
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:184
|
||
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:189
|
||
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*."
|
||
|
||
#: ../Doc/library/math.rst:193
|
||
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)``."
|
||
|
||
#: ../Doc/library/math.rst:203
|
||
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:209
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:215
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:218
|
||
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``."
|
||
|
||
#: ../Doc/library/math.rst:221
|
||
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!``."
|
||
|
||
#: ../Doc/library/math.rst:232
|
||
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``."
|
||
|
||
#: ../Doc/library/math.rst:235
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:244
|
||
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)``."
|
||
|
||
#: ../Doc/library/math.rst:251
|
||
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*."
|
||
|
||
#: ../Doc/library/math.rst:257
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:265
|
||
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__>`."
|
||
|
||
#: ../Doc/library/math.rst:270
|
||
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)."
|
||
|
||
#: ../Doc/library/math.rst:275
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:283
|
||
msgid "Power and logarithmic functions"
|
||
msgstr "Fonctions logarithme et exponentielle"
|
||
|
||
#: ../Doc/library/math.rst:287
|
||
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)``."
|
||
|
||
#: ../Doc/library/math.rst:294
|
||
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 ::"
|
||
|
||
#: ../Doc/library/math.rst:311
|
||
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:313
|
||
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:319
|
||
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:325
|
||
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)``."
|
||
|
||
#: ../Doc/library/math.rst:332
|
||
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:338
|
||
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:344
|
||
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:351
|
||
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:358
|
||
msgid "Return the square root of *x*."
|
||
msgstr "Renvoie la racine carrée de *x*."
|
||
|
||
#: ../Doc/library/math.rst:362
|
||
msgid "Trigonometric functions"
|
||
msgstr "Fonctions trigonométriques"
|
||
|
||
#: ../Doc/library/math.rst:366
|
||
msgid "Return the arc cosine of *x*, in radians."
|
||
msgstr "Renvoie l'arc cosinus de *x*, en radians."
|
||
|
||
#: ../Doc/library/math.rst:371
|
||
msgid "Return the arc sine of *x*, in radians."
|
||
msgstr "Renvoie l'arc sinus de *x*, en radians."
|
||
|
||
#: ../Doc/library/math.rst:376
|
||
msgid "Return the arc tangent of *x*, in radians."
|
||
msgstr "Renvoie l'arc tangente de *x*, en radians."
|
||
|
||
#: ../Doc/library/math.rst:381
|
||
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:391
|
||
msgid "Return the cosine of *x* radians."
|
||
msgstr "Renvoie le cosinus de *x* radians."
|
||
|
||
#: ../Doc/library/math.rst:396
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:400
|
||
msgid "Roughly equivalent to::"
|
||
msgstr "À peu près équivalent à :"
|
||
|
||
#: ../Doc/library/math.rst:409
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:413
|
||
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)``."
|
||
|
||
#: ../Doc/library/math.rst:417
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:424
|
||
msgid "Return the sine of *x* radians."
|
||
msgstr "Renvoie le sinus de *x* radians."
|
||
|
||
#: ../Doc/library/math.rst:429
|
||
msgid "Return the tangent of *x* radians."
|
||
msgstr "Renvoie la tangente de *x* radians."
|
||
|
||
#: ../Doc/library/math.rst:433
|
||
msgid "Angular conversion"
|
||
msgstr "Conversion angulaire"
|
||
|
||
#: ../Doc/library/math.rst:437
|
||
msgid "Convert angle *x* from radians to degrees."
|
||
msgstr "Convertit l'angle *x* de radians en degrés."
|
||
|
||
#: ../Doc/library/math.rst:442
|
||
msgid "Convert angle *x* from degrees to radians."
|
||
msgstr "Convertit l'ange *x* de degrés en radians."
|
||
|
||
#: ../Doc/library/math.rst:446
|
||
msgid "Hyperbolic functions"
|
||
msgstr "Fonctions hyperboliques"
|
||
|
||
#: ../Doc/library/math.rst:448
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:454
|
||
msgid "Return the inverse hyperbolic cosine of *x*."
|
||
msgstr "Renvoie l'arc cosinus hyperbolique de *x*."
|
||
|
||
#: ../Doc/library/math.rst:459
|
||
msgid "Return the inverse hyperbolic sine of *x*."
|
||
msgstr "Renvoie l'arc sinus hyperbolique de *x*."
|
||
|
||
#: ../Doc/library/math.rst:464
|
||
msgid "Return the inverse hyperbolic tangent of *x*."
|
||
msgstr "Renvoie l'arc tangente hyperbolique de *x*."
|
||
|
||
#: ../Doc/library/math.rst:469
|
||
msgid "Return the hyperbolic cosine of *x*."
|
||
msgstr "Renvoie le cosinus hyperbolique de *x*."
|
||
|
||
#: ../Doc/library/math.rst:474
|
||
msgid "Return the hyperbolic sine of *x*."
|
||
msgstr "Renvoie le sinus hyperbolique de *x*."
|
||
|
||
#: ../Doc/library/math.rst:479
|
||
msgid "Return the hyperbolic tangent of *x*."
|
||
msgstr "Renvoie la tangente hyperbolique de *x*."
|
||
|
||
#: ../Doc/library/math.rst:483
|
||
msgid "Special functions"
|
||
msgstr "Fonctions spéciales"
|
||
|
||
#: ../Doc/library/math.rst:487
|
||
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:490
|
||
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:503
|
||
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>`_\\."
|
||
|
||
#: ../Doc/library/math.rst:514
|
||
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:522
|
||
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:529
|
||
msgid "Constants"
|
||
msgstr "Constantes"
|
||
|
||
#: ../Doc/library/math.rst:533
|
||
msgid "The mathematical constant *π* = 3.141592..., to available precision."
|
||
msgstr "La constante mathématique *π* = 3.141592…, à la précision disponible."
|
||
|
||
#: ../Doc/library/math.rst:538
|
||
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:543
|
||
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 !"
|
||
|
||
#: ../Doc/library/math.rst:554
|
||
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:562
|
||
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:570
|
||
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'))``."
|
||
|
||
#: ../Doc/library/math.rst:582
|
||
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."
|
||
|
||
#: ../Doc/library/math.rst:589
|
||
msgid "Module :mod:`cmath`"
|
||
msgstr "Module :mod:`cmath`"
|
||
|
||
#: ../Doc/library/math.rst:590
|
||
msgid "Complex number versions of many of these functions."
|
||
msgstr "Version complexe de beaucoup de ces fonctions."
|
||
|
||
#~ msgid "Return ``e**x``."
|
||
#~ msgstr "Renvoie ``e**x``."
|