# 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 \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__ `, 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__ `, " "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 `_\\." msgstr "" "Pour de plus amples discussions et deux approches alternatives, voir `ASPN " "cookbook recipes for accurate floating point summation `_\\." #: 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__ `, 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 `)." 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 `." 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 `_\\; 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 `_\\ ; 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 `_ " "are analogs of trigonometric functions that are based on hyperbolas instead " "of circles." msgstr "" "`Les fonctions hyperboliques `_ 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 `_ " "at *x*." msgstr "" "Renvoie la `fonction d'erreur `_ 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 `_::" msgstr "" "La fonction :func:`erf` peut être utilisée pour calculer des fonctions " "statistiques usuelles telles que la `répartition de la loi normale `_ ::" #: library/math.rst:592 msgid "" "Return the complementary error function at *x*. The `complementary 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 `_\\." msgstr "" "Renvoie la fonction d'erreur complémentaire en *x*. La `fonction d'erreur " "complémentaire `_ 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 `_\\." #: library/math.rst:603 msgid "" "Return the `Gamma function `_ " "at *x*." msgstr "" "Renvoie la `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 `_, and start " "celebrating `Tau day `_ 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 `_, et profitez-en pour célébrer le `Jour de Tau `_ 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 `_, ``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__() `." #~ msgstr "" #~ "Renvoie la valeur :class:`~numbers.Real` *x* tronquée en un :class:" #~ "`~numbers.Integral` (habituellement un entier). Délègue à :meth:`x." #~ "__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')``."