python-docs-fr/library/math.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2016, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2016-10-30 10:44+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

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

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

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

#: ../Doc/library/math.rst:24
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:29
msgid "Number-theoretic and representation functions"
msgstr "Fonctions arithmétiques et de représentation"

#: ../Doc/library/math.rst:33
msgid ""
"Return the ceiling of *x* as a float, the smallest integer value greater "
"than or equal to *x*."
msgstr ""

#: ../Doc/library/math.rst:39
msgid ""
"Return *x* with the sign of *y*.  On a platform that supports signed zeros, "
"``copysign(1.0, -0.0)`` returns *-1.0*."
msgstr ""

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

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

#: ../Doc/library/math.rst:60
msgid ""
"Return the floor of *x* as a float, the largest integer value less than or "
"equal to *x*."
msgstr ""

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

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

#: ../Doc/library/math.rst:103
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:112
msgid "Check if the float *x* is positive or negative infinity."
msgstr ""

#: ../Doc/library/math.rst:119
msgid ""
"Check if the float *x* is a NaN (not a number).  For more information on "
"NaNs, see the IEEE 754 standards."
msgstr ""

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

#: ../Doc/library/math.rst:139
msgid ""
"Return the :class:`~numbers.Real` value *x* truncated to an :class:`~numbers."
"Integral` (usually a long integer).  Uses the ``__trunc__`` method."
msgstr ""

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

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

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

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

#: ../Doc/library/math.rst:168
msgid ""
"Return ``e**x - 1``.  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 ""

#: ../Doc/library/math.rst:184
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:186
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:189
msgid "*base* argument added."
msgstr ""

#: ../Doc/library/math.rst:195
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:203
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:209
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:216
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:220
msgid "The outcome of ``1**nan`` and ``nan**0`` was undefined."
msgstr ""

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

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

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

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

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

#: ../Doc/library/math.rst:249
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:259
msgid "Return the cosine of *x* radians."
msgstr "Renvoie le cosinus de *x* radians."

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../Doc/library/math.rst:335
msgid "Return the error function at *x*."
msgstr ""

#: ../Doc/library/math.rst:342
msgid "Return the complementary error function at *x*."
msgstr ""

#: ../Doc/library/math.rst:349
msgid "Return the Gamma function at *x*."
msgstr ""

#: ../Doc/library/math.rst:356
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:363
msgid "Constants"
msgstr "Constantes"

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

#: ../Doc/library/math.rst:372
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:377
msgid ""
"The :mod:`math` module consists mostly of thin wrappers around the platform "
"C math library functions.  Behavior in exceptional cases follows Annex F of "
"the C99 standard where appropriate.  The current implementation will raise :"
"exc:`ValueError` for invalid operations like ``sqrt(-1.0)`` or ``log(0.0)`` "
"(where C99 Annex F recommends signaling invalid operation or divide-by-"
"zero), and :exc:`OverflowError` for results that overflow (for example, "
"``exp(1000.0)``).  A NaN will not be returned from any of the functions "
"above unless one or more of the input arguments was a NaN; in that case, "
"most functions will return a NaN, but (again following C99 Annex F) there "
"are some exceptions to this rule, for example ``pow(float('nan'), 0.0)`` or "
"``hypot(float('nan'), float('inf'))``."
msgstr ""
"Le module :mod:`math` consiste majoritairement en un conteneur pour les "
"fonctions mathématiques de la bibliothèque C de la plate-forme. Le "
"comportement dans les cas spéciaux suit l'annexe 'F' du standard C99 quand "
"c'est approprié. L'implémentation actuelle lève une :exc:`ValueError` pour "
"les opérations invalides telles que ``sqrt(-1.0)`` ou ``log(0.0)`` (où le "
"standard C99 recommande de signaler que l'opération est invalide ou qu'il y "
"a division par zéro), et une :exc:`OverflowError` pour les résultats qui "
"débordent (par exemple ``exp(1000.0)``). *NaN* ne sera renvoyé pour toute "
"les fonctions ci-dessus sauf si au moins un des arguments de la fonction "
"vaut *NaN*. Dans ce cas, la plupart des fonctions 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:389
msgid ""
"Note that Python makes no effort to distinguish signaling NaNs from quiet "
"NaNs, and behavior for signaling NaNs remains unspecified. Typical behavior "
"is to treat all NaNs as though they were quiet."
msgstr ""
"Notez que Python ne fait aucun effort pour distinguer les NaNs signalétiques "
"des NaNs silencieux, et le comportement de signalement des NaNs reste non-"
"spécifié. le comportement typique est de traiter tous les NaNs comme s'ils "
"étaient silencieux."

#: ../Doc/library/math.rst:393
msgid ""
"Behavior in special cases now aims to follow C99 Annex F.  In earlier "
"versions of Python the behavior in special cases was loosely specified."
msgstr ""

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

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