python-docs-fr/library/decimal.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-01-15 22:33+0100\n"
"PO-Revision-Date: 2022-10-18 15:52+0200\n"
"Last-Translator: \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.4.1\n"

#: library/decimal.rst:2
msgid ":mod:`decimal` --- Decimal fixed point and floating point arithmetic"
msgstr ":mod:`decimal` — Arithmétique décimale en virgule fixe et flottante"

#: library/decimal.rst:15
msgid "**Source code:** :source:`Lib/decimal.py`"
msgstr "**Code source :** :source:`Lib/decimal.py`"

#: library/decimal.rst:33
#, fuzzy
msgid ""
"The :mod:`decimal` module provides support for fast correctly rounded "
"decimal floating point arithmetic. It offers several advantages over the :"
"class:`float` datatype:"
msgstr ""
"Le module :mod:`decimal` fournit une arithmétique en virgule flottante "
"rapide et produisant des arrondis mathématiquement corrects. Il possède "
"plusieurs avantages en comparaison au type :class:`float` :"

#: library/decimal.rst:37
msgid ""
"Decimal \"is based on a floating-point model which was designed with people "
"in mind, and necessarily has a paramount guiding principle -- computers must "
"provide an arithmetic that works in the same way as the arithmetic that "
"people learn at school.\" -- excerpt from the decimal arithmetic "
"specification."
msgstr ""
"Le module ``decimal`` « est basé sur un modèle en virgule flottante conçu "
"pour les humains, qui suit ce principe directeur : l'ordinateur doit fournir "
"un modèle de calcul qui fonctionne de la même manière que le calcul qu'on "
"apprend à l'école » -- extrait (traduit) de la spécification de "
"l'arithmétique décimale."

#: library/decimal.rst:42
msgid ""
"Decimal numbers can be represented exactly.  In contrast, numbers like :"
"const:`1.1` and :const:`2.2` do not have exact representations in binary "
"floating point. End users typically would not expect ``1.1 + 2.2`` to "
"display as :const:`3.3000000000000003` as it does with binary floating point."
msgstr ""
"Les nombres décimaux peuvent être représentés exactement en base décimale "
"flottante. En revanche, des nombres tels que :const:`1.1` ou :const:`1.2` "
"n'ont pas de représentation exacte en base binaire flottante. L'utilisateur "
"final ne s'attend typiquement pas à obtenir :const:`3.3000000000000003` "
"lorsqu'il saisit ``1.1 + 2.2``, ce qui se passe en arithmétique binaire à "
"virgule flottante."

#: library/decimal.rst:47
msgid ""
"The exactness carries over into arithmetic.  In decimal floating point, "
"``0.1 + 0.1 + 0.1 - 0.3`` is exactly equal to zero.  In binary floating "
"point, the result is :const:`5.5511151231257827e-017`.  While near to zero, "
"the differences prevent reliable equality testing and differences can "
"accumulate. For this reason, decimal is preferred in accounting applications "
"which have strict equality invariants."
msgstr ""
"Ces inexactitudes ont des conséquences en arithmétique. En base décimale à "
"virgule flottante, ``0.1 + 0.1 + 0.1 - 0.3`` est exactement égal à zéro. En "
"virgule flottante binaire, l'ordinateur l'évalue à :const:"
"`5.5511151231257827e-017`. Bien que très proche de zéro, cette différence "
"induit des erreurs lors des tests d'égalité, erreurs qui peuvent "
"s'accumuler. Pour ces raisons ``decimal`` est le module utilisé pour des "
"applications comptables ayant des contraintes strictes de fiabilité."

#: library/decimal.rst:54
msgid ""
"The decimal module incorporates a notion of significant places so that "
"``1.30 + 1.20`` is :const:`2.50`.  The trailing zero is kept to indicate "
"significance. This is the customary presentation for monetary applications. "
"For multiplication, the \"schoolbook\" approach uses all the figures in the "
"multiplicands.  For instance, ``1.3 * 1.2`` gives :const:`1.56` while ``1.30 "
"* 1.20`` gives :const:`1.5600`."
msgstr ""
"Le module ``decimal`` incorpore la notion de chiffres significatifs, tels "
"que ``1.30 + 1.20`` est égal à :const:`2.50`. Le dernier zéro n'est conservé "
"que pour respecter le nombre de chiffres significatifs. C'est également "
"l'affichage préféré pour représenter des sommes d'argent. Pour la "
"multiplication, l'approche « scolaire » utilise tout les chiffres présents "
"dans les facteurs. Par exemple, ``1.3 * 1.2`` donnerait :const:`1.56` tandis "
"que ``1.30 * 1.20`` donnerait :const:`1.5600`."

#: library/decimal.rst:61
msgid ""
"Unlike hardware based binary floating point, the decimal module has a user "
"alterable precision (defaulting to 28 places) which can be as large as "
"needed for a given problem:"
msgstr ""
"Contrairement à l'arithmétique en virgule flottante binaire, le module "
"``decimal`` possède un paramètre de précision ajustable (par défaut à 28 "
"chiffres significatifs) qui peut être aussi élevée que nécessaire pour un "
"problème donné :"

#: library/decimal.rst:73
msgid ""
"Both binary and decimal floating point are implemented in terms of published "
"standards.  While the built-in float type exposes only a modest portion of "
"its capabilities, the decimal module exposes all required parts of the "
"standard. When needed, the programmer has full control over rounding and "
"signal handling. This includes an option to enforce exact arithmetic by "
"using exceptions to block any inexact operations."
msgstr ""
"L'arithmétique binaire et décimale en virgule flottante sont implémentées "
"selon des standards publiés. Alors que le type ``float`` n'expose qu'une "
"faible portion de ses capacités, le module ``decimal`` expose tous les "
"composants nécessaires du standard. Lorsque nécessaire, le développeur a un "
"contrôle total de la gestion de signal et de l'arrondi. Cela inclut la "
"possibilité de forcer une arithmétique exacte en utilisant des exceptions "
"pour bloquer toute opération inexacte."

#: library/decimal.rst:80
msgid ""
"The decimal module was designed to support \"without prejudice, both exact "
"unrounded decimal arithmetic (sometimes called fixed-point arithmetic) and "
"rounded floating-point arithmetic.\"  -- excerpt from the decimal arithmetic "
"specification."
msgstr ""
"Le module ``decimal`` a été conçu pour gérer « sans préjugé, à la fois une "
"arithmétique décimale non-arrondie (aussi appelée arithmétique en virgule "
"fixe) et à la fois une arithmétique en virgule flottante. » (extrait traduit "
"de la spécification de l'arithmétique décimale)."

#: library/decimal.rst:85
msgid ""
"The module design is centered around three concepts:  the decimal number, "
"the context for arithmetic, and signals."
msgstr ""
"Le module est conçu autour de trois concepts : le nombre décimal, le "
"contexte arithmétique et les signaux."

#: library/decimal.rst:88
msgid ""
"A decimal number is immutable.  It has a sign, coefficient digits, and an "
"exponent.  To preserve significance, the coefficient digits do not truncate "
"trailing zeros.  Decimals also include special values such as :const:"
"`Infinity`, :const:`-Infinity`, and :const:`NaN`.  The standard also "
"differentiates :const:`-0` from :const:`+0`."
msgstr ""
"Un ``Decimal`` est immuable. Il a un signe, un coefficient, et un exposant. "
"Pour préserver le nombre de chiffres significatifs, les zéros en fin de "
"chaîne ne sont pas tronqués. Les décimaux incluent aussi des valeurs "
"spéciales telles que :const:`Infinity`, :const:`-Infinity`, et :const:`NaN`. "
"Le standard fait également la différence entre :const:`-0` et :const:`+0`."

#: library/decimal.rst:94
msgid ""
"The context for arithmetic is an environment specifying precision, rounding "
"rules, limits on exponents, flags indicating the results of operations, and "
"trap enablers which determine whether signals are treated as exceptions.  "
"Rounding options include :const:`ROUND_CEILING`, :const:`ROUND_DOWN`, :const:"
"`ROUND_FLOOR`, :const:`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :const:"
"`ROUND_HALF_UP`, :const:`ROUND_UP`, and :const:`ROUND_05UP`."
msgstr ""
"Le contexte de l'arithmétique est un environnement qui permet de configurer "
"une précision, une règle pour l'arrondi, des limites sur l'exposant, des "
"options indiquant le résultat des opérations et si les signaux (remontés "
"lors d'opérations illégales) sont traités comme des exceptions Python. Les "
"options d'arrondi incluent :const:`ROUND_CEILING`, :const:`ROUND_DOWN`, :"
"const:`ROUND_FLOOR`, :const:`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :"
"const:`ROUND_HALF_UP`, :const:`ROUND_UP`, et :const:`ROUND_05UP`."

#: library/decimal.rst:101
msgid ""
"Signals are groups of exceptional conditions arising during the course of "
"computation.  Depending on the needs of the application, signals may be "
"ignored, considered as informational, or treated as exceptions. The signals "
"in the decimal module are: :const:`Clamped`, :const:`InvalidOperation`, :"
"const:`DivisionByZero`, :const:`Inexact`, :const:`Rounded`, :const:"
"`Subnormal`, :const:`Overflow`, :const:`Underflow` and :const:"
"`FloatOperation`."
msgstr ""
"Les signaux sont des groupes de conditions exceptionnelles qui surviennent "
"durant le calcul. Selon les besoins de l'application, les signaux peuvent "
"être ignorés, considérés comme de l'information, ou bien traités comme des "
"exceptions. Les signaux dans le module ``decimal`` sont : :const:`Clamped`, :"
"const:`InvalidOperation`, :const:`DivisionByZero`, :const:`Inexact`, :const:"
"`Rounded`, :const:`Subnormal`, :const:`Overflow`, :const:`Underflow` et :"
"const:`FloatOperation`."

#: library/decimal.rst:108
msgid ""
"For each signal there is a flag and a trap enabler.  When a signal is "
"encountered, its flag is set to one, then, if the trap enabler is set to "
"one, an exception is raised.  Flags are sticky, so the user needs to reset "
"them before monitoring a calculation."
msgstr ""
"Chaque signal est configurable indépendamment. Quand une opération illégale "
"survient, le signal est mis à ``1``, puis s'il est configuré pour, une "
"exception est levée. La mise à ``1`` est persistante, l'utilisateur doit "
"donc les remettre à zéro avant de commencer un calcul qu'il souhaite "
"surveiller."

#: library/decimal.rst:116
#, fuzzy
msgid ""
"IBM's General Decimal Arithmetic Specification, `The General Decimal "
"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."
msgstr ""
"La spécification d'IBM sur l'arithmétique décimale : `The General Decimal "
"Arithmetic Specification <http://speleotrove.com/decimal/decarith.html>`_."

#: library/decimal.rst:125
msgid "Quick-start Tutorial"
msgstr "Introduction pratique"

#: library/decimal.rst:127
msgid ""
"The usual start to using decimals is importing the module, viewing the "
"current context with :func:`getcontext` and, if necessary, setting new "
"values for precision, rounding, or enabled traps::"
msgstr ""
"Commençons par importer le module, regarder le contexte actuel avec :func:"
"`getcontext`, et si nécessaire configurer la précision, l'arrondi, et la "
"gestion des signaux ::"

#: library/decimal.rst:139
msgid ""
"Decimal instances can be constructed from integers, strings, floats, or "
"tuples. Construction from an integer or a float performs an exact conversion "
"of the value of that integer or float.  Decimal numbers include special "
"values such as :const:`NaN` which stands for \"Not a number\", positive and "
"negative :const:`Infinity`, and :const:`-0`::"
msgstr ""
"Les instances de ``Decimal`` peuvent être construites avec des ``int``, des "
"``str``, des ``floats`` ou des ``tuples``. La construction depuis un entier "
"ou un ``float`` effectue la conversion exacte de cet entier ou de ce "
"``float``. Les nombres décimaux incluent des valeurs spéciales telles que :"
"const:`NaN` qui signifie en anglais « *Not a number* », en français « pas un "
"nombre », des :const:`Infinity` positifs ou négatifs et :const:`-0` ::"

#: library/decimal.rst:163
msgid ""
"If the :exc:`FloatOperation` signal is trapped, accidental mixing of "
"decimals and floats in constructors or ordering comparisons raises an "
"exception::"
msgstr ""
"Si un signal :exc:`FloatOperation` est détecté, un mélange accidentel "
"d'objets ``Decimal`` et de ``float`` dans les constructeurs ou des "
"opérations de comparaisons, une exception est levée ::"

#: library/decimal.rst:182
msgid ""
"The significance of a new Decimal is determined solely by the number of "
"digits input.  Context precision and rounding only come into play during "
"arithmetic operations."
msgstr ""
"Le nombre de chiffres significatifs d'un nouvel objet ``Decimal`` est "
"déterminé entièrement par le nombre de chiffres saisis. La précision et les "
"règles d'arrondis n'interviennent que lors d'opérations arithmétiques."

#: library/decimal.rst:199
msgid ""
"If the internal limits of the C version are exceeded, constructing a decimal "
"raises :class:`InvalidOperation`::"
msgstr ""
"Si les limites internes de la version en C sont dépassées, la construction "
"d'un objet décimal lève l'exception :class:`InvalidOperation` ::"

#: library/decimal.rst:209
msgid ""
"Decimals interact well with much of the rest of Python.  Here is a small "
"decimal floating point flying circus:"
msgstr ""
"Les objets ``Decimal`` interagissent très bien avec le reste de Python. "
"Voici quelques exemple d'opérations avec des décimaux :"

#: library/decimal.rst:241
msgid "And some mathematical functions are also available to Decimal:"
msgstr ""
"Et certaines fonctions mathématiques sont également disponibles sur des "
"instances de ``Decimal`` :"

#: library/decimal.rst:253
msgid ""
"The :meth:`quantize` method rounds a number to a fixed exponent.  This "
"method is useful for monetary applications that often round results to a "
"fixed number of places:"
msgstr ""
"La méthode :meth:`quantize` arrondit un nombre à un exposant fixe. Cette "
"méthode est utile pour des applications monétaires qui arrondissent souvent "
"un résultat à un nombre de chiffres significatifs exact :"

#: library/decimal.rst:262
msgid ""
"As shown above, the :func:`getcontext` function accesses the current context "
"and allows the settings to be changed.  This approach meets the needs of "
"most applications."
msgstr ""
"Comme montré plus haut, la fonction :func:`getcontext` accède au contexte "
"actuel et permet de modifier les paramètres. Cette approche répond aux "
"besoins de la plupart des applications."

#: library/decimal.rst:266
msgid ""
"For more advanced work, it may be useful to create alternate contexts using "
"the Context() constructor.  To make an alternate active, use the :func:"
"`setcontext` function."
msgstr ""
"Pour un travail plus avancé, il peut être utile de créer des contextes "
"alternatifs en utilisant le constructeur de ``Context``. Pour activer cet "
"objet ``Context``, utilisez la fonction :func:`setcontext`."

#: library/decimal.rst:270
msgid ""
"In accordance with the standard, the :mod:`decimal` module provides two "
"ready to use standard contexts, :const:`BasicContext` and :const:"
"`ExtendedContext`. The former is especially useful for debugging because "
"many of the traps are enabled:"
msgstr ""
"En accord avec le standard, le module :mod:`decimal` fournit des objets "
"Context standards, :const:`BasicContext` et :const:`ExtendedContext`. Le "
"premier est particulièrement utile pour le débogage car beaucoup des pièges "
"sont activés dans cet objet :"

#: library/decimal.rst:299
msgid ""
"Contexts also have signal flags for monitoring exceptional conditions "
"encountered during computations.  The flags remain set until explicitly "
"cleared, so it is best to clear the flags before each set of monitored "
"computations by using the :meth:`clear_flags` method. ::"
msgstr ""
"Les objets ``Context`` ont aussi des options pour détecter des opérations "
"illégales lors des calculs. Ces options restent activées jusqu'à ce qu'elles "
"soit remises à zéro de manière explicite. Il convient donc de remettre à "
"zéro ces options avant chaque inspection de chaque calcul, avec la méthode :"
"meth:`clear_flags`. ::"

#: library/decimal.rst:312
msgid ""
"The *flags* entry shows that the rational approximation to :const:`Pi` was "
"rounded (digits beyond the context precision were thrown away) and that the "
"result is inexact (some of the discarded digits were non-zero)."
msgstr ""
"Les options montrent que l'approximation de :const:`Pi` par une fraction a "
"été arrondie (les chiffres au delà de la précision spécifiée par l'objet "
"Context ont été tronqués) et que le résultat est différent (certains des "
"chiffres tronqués étaient différents de zéro)."

#: library/decimal.rst:316
msgid ""
"Individual traps are set using the dictionary in the :attr:`traps` field of "
"a context:"
msgstr ""
"L'activation des pièges se fait en utilisant un dictionnaire dans "
"l'attribut :attr:`traps` de l'objet Context :"

#: library/decimal.rst:331
msgid ""
"Most programs adjust the current context only once, at the beginning of the "
"program.  And, in many applications, data is converted to :class:`Decimal` "
"with a single cast inside a loop.  With context set and decimals created, "
"the bulk of the program manipulates the data no differently than with other "
"Python numeric types."
msgstr ""
"La plupart des applications n'ajustent l'objet ``Context`` qu'une seule "
"fois, au démarrage. Et, dans beaucoup d'applications, les données sont "
"convertie une fois pour toutes en :class:`Decimal`. Une fois le ``Context`` "
"initialisé, et les objets ``Decimal`` créés, l'essentiel du programme "
"manipule la donnée de la même manière qu'avec les autres types numériques "
"Python."

#: library/decimal.rst:343
msgid "Decimal objects"
msgstr "Les objets Decimal"

#: library/decimal.rst:348
msgid "Construct a new :class:`Decimal` object based from *value*."
msgstr "Construire un nouvel objet :class:`Decimal` à partir de *value*."

#: library/decimal.rst:350
msgid ""
"*value* can be an integer, string, tuple, :class:`float`, or another :class:"
"`Decimal` object. If no *value* is given, returns ``Decimal('0')``.  If "
"*value* is a string, it should conform to the decimal numeric string syntax "
"after leading and trailing whitespace characters, as well as underscores "
"throughout, are removed::"
msgstr ""
"*value* peut être un entier, une chaîne de caractères, un *n*-uplet, :class:"
"`float`, ou une autre instance de :class:`Decimal`. Si *value* n'est pas "
"fourni, le constructeur renvoie ``Decimal('0')``. Si *value* est une chaîne "
"de caractère, elle doit correspondre à la syntaxe décimale en dehors des "
"espaces de début et de fin, ou des tirets bas, qui sont enlevés ::"

#: library/decimal.rst:366
msgid ""
"Other Unicode decimal digits are also permitted where ``digit`` appears "
"above.  These include decimal digits from various other alphabets (for "
"example, Arabic-Indic and Devanāgarī digits) along with the fullwidth digits "
"``'\\uff10'`` through ``'\\uff19'``."
msgstr ""
"Les chiffres codés en Unicode sont aussi autorisés, là ou ``digit`` "
"apparaît. Cela inclut des chiffres décimaux venant d'autres alphabets (par "
"exemple les chiffres indo-arabes ou Devanagari) ainsi que les chiffres de "
"pleine largeur ``'\\uff10'`` jusqu'à ``'\\uff19'``."

#: library/decimal.rst:371
msgid ""
"If *value* is a :class:`tuple`, it should have three components, a sign (:"
"const:`0` for positive or :const:`1` for negative), a :class:`tuple` of "
"digits, and an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), "
"-3))`` returns ``Decimal('1.414')``."
msgstr ""
"Si *value* est un :class:`tuple`, il doit avoir 3 éléments, le signe (:const:"
"`0` pour positif ou :const:`1` pour négatif), un :class:`tuple` de chiffres, "
"et un entier représentant l'exposant. Par exemple, ``Decimal((0, (1, 4, 1, "
"4), -3))`` construit l'objet ``Decimal('1.414')``."

#: library/decimal.rst:376
msgid ""
"If *value* is a :class:`float`, the binary floating point value is "
"losslessly converted to its exact decimal equivalent.  This conversion can "
"often require 53 or more digits of precision.  For example, "
"``Decimal(float('1.1'))`` converts to "
"``Decimal('1.100000000000000088817841970012523233890533447265625')``."
msgstr ""
"Si *value* est un :class:`float`, la valeur en binaire flottant est "
"convertie exactement à son équivalent décimal. Cette conversion peut parfois "
"nécessiter 53 chiffres significatifs ou plus. Par exemple, "
"``Decimal(float('1.1'))`` devient "
"``Decimal('1.100000000000000088817841970012523233890533447265625')``."

#: library/decimal.rst:382
msgid ""
"The *context* precision does not affect how many digits are stored. That is "
"determined exclusively by the number of digits in *value*. For example, "
"``Decimal('3.00000')`` records all five zeros even if the context precision "
"is only three."
msgstr ""
"La précision spécifiée dans Context n'affecte pas le nombre de chiffres "
"stockés. Cette valeur est déterminée exclusivement par le nombre de chiffres "
"dans *value*. Par exemple, ``Decimal('3.00000')`` enregistre les 5 zéros "
"même si la précision du contexte est de 3."

#: library/decimal.rst:387
msgid ""
"The purpose of the *context* argument is determining what to do if *value* "
"is a malformed string.  If the context traps :const:`InvalidOperation`, an "
"exception is raised; otherwise, the constructor returns a new Decimal with "
"the value of :const:`NaN`."
msgstr ""
"L'objectif de l'argument *context* est de déterminer ce que Python doit "
"faire si *value* est une chaîne avec un mauvais format. Si l'option :const:"
"`InvalidOperation` est activée, une exception est levée, sinon le "
"constructeur renvoie un objet ``Decimal`` avec la valeur :const:`NaN`."

#: library/decimal.rst:392
msgid "Once constructed, :class:`Decimal` objects are immutable."
msgstr "Une fois construit, les objets :class:`Decimal` sont immuables."

#: library/decimal.rst:394
msgid ""
"The argument to the constructor is now permitted to be a :class:`float` "
"instance."
msgstr ""
"L'argument du constructeur peut désormais être un objet :class:`float`."

#: library/decimal.rst:398
msgid ""
":class:`float` arguments raise an exception if the :exc:`FloatOperation` "
"trap is set. By default the trap is off."
msgstr ""
"Un argument :class:`float` lève une exception si l'option :exc:"
"`FloatOperation` est activé. Par défaut l'option ne l'est pas."

#: library/decimal.rst:402
msgid ""
"Underscores are allowed for grouping, as with integral and floating-point "
"literals in code."
msgstr ""
"Les tirets bas sont autorisés pour regrouper, tout comme pour l'arithmétique "
"en virgule fixe et flottante."

#: library/decimal.rst:406
msgid ""
"Decimal floating point objects share many properties with the other built-in "
"numeric types such as :class:`float` and :class:`int`.  All of the usual "
"math operations and special methods apply.  Likewise, decimal objects can be "
"copied, pickled, printed, used as dictionary keys, used as set elements, "
"compared, sorted, and coerced to another type (such as :class:`float` or :"
"class:`int`)."
msgstr ""
"Les objets ``Decimal`` partagent beaucoup de propriétés avec les autres "
"types numériques natifs tels que :class:`float` et :class:`int`. Toutes les "
"opérations mathématiques et méthodes sont conservées. De même les objets "
"``Decimal`` peuvent être copiés, sérialisés via le module ``pickle``, "
"affichés, utilisés comme clé de dictionnaire, éléments d'ensembles, "
"comparés, classés, et convertis vers un autre type (tel que :class:`float` "
"ou :class:`int`)."

#: library/decimal.rst:413
msgid ""
"There are some small differences between arithmetic on Decimal objects and "
"arithmetic on integers and floats.  When the remainder operator ``%`` is "
"applied to Decimal objects, the sign of the result is the sign of the "
"*dividend* rather than the sign of the divisor::"
msgstr ""
"Il existe quelques différences mineures entre l'arithmétique entre les "
"objets décimaux et l'arithmétique avec les entiers et les ``float``. Quand "
"l'opérateur modulo ``%`` est appliqué sur des objets décimaux, le signe du "
"résultat est le signe du *dividend* plutôt que le signe du diviseur ::"

#: library/decimal.rst:423
msgid ""
"The integer division operator ``//`` behaves analogously, returning the "
"integer part of the true quotient (truncating towards zero) rather than its "
"floor, so as to preserve the usual identity ``x == (x // y) * y + x % y``::"
msgstr ""
"L'opérateur division entière, ``//`` se comporte de la même manière, "
"retournant la partie entière du quotient, plutôt que son arrondi, de manière "
"à préserver l'identité d'Euclide ``x == (x // y) * y + x % y`` ::"

#: library/decimal.rst:432
msgid ""
"The ``%`` and ``//`` operators implement the ``remainder`` and ``divide-"
"integer`` operations (respectively) as described in the specification."
msgstr ""
"Les opérateurs ``//`` et ``%`` implémentent la division entière et le reste "
"(ou modulo), respectivement, tel que décrit dans la spécification."

#: library/decimal.rst:436
msgid ""
"Decimal objects cannot generally be combined with floats or instances of :"
"class:`fractions.Fraction` in arithmetic operations: an attempt to add a :"
"class:`Decimal` to a :class:`float`, for example, will raise a :exc:"
"`TypeError`.  However, it is possible to use Python's comparison operators "
"to compare a :class:`Decimal` instance ``x`` with another number ``y``.  "
"This avoids confusing results when doing equality comparisons between "
"numbers of different types."
msgstr ""
"Les objets ``Decimal`` ne peuvent généralement pas être combinés avec des "
"``float`` ou des objets :class:`fractions.Fraction` lors d'opérations "
"arithmétiques : tout addition entre un :class:`Decimal` avec un :class:"
"`float`, par exemple, lève une exception :exc:`TypeError`. Cependant, il est "
"possible d'utiliser les opérateurs de comparaison entre instances de :class:"
"`Decimal` avec les autres types numériques. Cela évite d'avoir des résultats "
"absurdes lors des tests d'égalité entre différents types."

#: library/decimal.rst:444
msgid ""
"Mixed-type comparisons between :class:`Decimal` instances and other numeric "
"types are now fully supported."
msgstr ""
"Les comparaisons inter-types entre :class:`Decimal` et les autres types "
"numériques sont désormais intégralement gérés."

#: library/decimal.rst:448
msgid ""
"In addition to the standard numeric properties, decimal floating point "
"objects also have a number of specialized methods:"
msgstr ""

#: library/decimal.rst:454
msgid ""
"Return the adjusted exponent after shifting out the coefficient's rightmost "
"digits until only the lead digit remains: ``Decimal('321e+5').adjusted()`` "
"returns seven.  Used for determining the position of the most significant "
"digit with respect to the decimal point."
msgstr ""

#: library/decimal.rst:461
msgid ""
"Return a pair ``(n, d)`` of integers that represent the given :class:"
"`Decimal` instance as a fraction, in lowest terms and with a positive "
"denominator::"
msgstr ""

#: library/decimal.rst:468
msgid ""
"The conversion is exact.  Raise OverflowError on infinities and ValueError "
"on NaNs."
msgstr ""
"La conversion est exacte. Lève une ``OverflowError`` sur l'infini et "
"``ValueError`` sur les ``Nan``'s."

#: library/decimal.rst:475
msgid ""
"Return a :term:`named tuple` representation of the number: "
"``DecimalTuple(sign, digits, exponent)``."
msgstr ""

#: library/decimal.rst:481
msgid ""
"Return the canonical encoding of the argument.  Currently, the encoding of "
"a :class:`Decimal` instance is always canonical, so this operation returns "
"its argument unchanged."
msgstr ""

#: library/decimal.rst:487
msgid ""
"Compare the values of two Decimal instances.  :meth:`compare` returns a "
"Decimal instance, and if either operand is a NaN then the result is a NaN::"
msgstr ""

#: library/decimal.rst:498
msgid ""
"This operation is identical to the :meth:`compare` method, except that all "
"NaNs signal.  That is, if neither operand is a signaling NaN then any quiet "
"NaN operand is treated as though it were a signaling NaN."
msgstr ""

#: library/decimal.rst:504
msgid ""
"Compare two operands using their abstract representation rather than their "
"numerical value.  Similar to the :meth:`compare` method, but the result "
"gives a total ordering on :class:`Decimal` instances.  Two :class:`Decimal` "
"instances with the same numeric value but different representations compare "
"unequal in this ordering:"
msgstr ""

#: library/decimal.rst:513
msgid ""
"Quiet and signaling NaNs are also included in the total ordering.  The "
"result of this function is ``Decimal('0')`` if both operands have the same "
"representation, ``Decimal('-1')`` if the first operand is lower in the total "
"order than the second, and ``Decimal('1')`` if the first operand is higher "
"in the total order than the second operand.  See the specification for "
"details of the total order."
msgstr ""

#: library/decimal.rst:531 library/decimal.rst:835
msgid ""
"This operation is unaffected by context and is quiet: no flags are changed "
"and no rounding is performed.  As an exception, the C version may raise "
"InvalidOperation if the second operand cannot be converted exactly."
msgstr ""

#: library/decimal.rst:526
msgid ""
"Compare two operands using their abstract representation rather than their "
"value as in :meth:`compare_total`, but ignoring the sign of each operand. "
"``x.compare_total_mag(y)`` is equivalent to ``x.copy_abs().compare_total(y."
"copy_abs())``."
msgstr ""

#: library/decimal.rst:537
msgid ""
"Just returns self, this method is only to comply with the Decimal "
"Specification."
msgstr ""

#: library/decimal.rst:542
msgid ""
"Return the absolute value of the argument.  This operation is unaffected by "
"the context and is quiet: no flags are changed and no rounding is performed."
msgstr ""

#: library/decimal.rst:548
msgid ""
"Return the negation of the argument.  This operation is unaffected by the "
"context and is quiet: no flags are changed and no rounding is performed."
msgstr ""

#: library/decimal.rst:553
msgid ""
"Return a copy of the first operand with the sign set to be the same as the "
"sign of the second operand.  For example:"
msgstr ""

#: library/decimal.rst:565
msgid ""
"Return the value of the (natural) exponential function ``e**x`` at the given "
"number.  The result is correctly rounded using the :const:`ROUND_HALF_EVEN` "
"rounding mode."
msgstr ""

#: library/decimal.rst:576
msgid ""
"Alternative constructor that only accepts instances of :class:`float` or :"
"class:`int`."
msgstr ""

#: library/decimal.rst:579
msgid ""
"Note ``Decimal.from_float(0.1)`` is not the same as ``Decimal('0.1')``. "
"Since 0.1 is not exactly representable in binary floating point, the value "
"is stored as the nearest representable value which is "
"``0x1.999999999999ap-4``.  That equivalent value in decimal is "
"``0.1000000000000000055511151231257827021181583404541015625``."
msgstr ""

#: library/decimal.rst:585
msgid ""
"From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed "
"directly from a :class:`float`."
msgstr ""

#: library/decimal.rst:603
msgid ""
"Fused multiply-add.  Return self*other+third with no rounding of the "
"intermediate product self*other."
msgstr ""

#: library/decimal.rst:611
msgid ""
"Return :const:`True` if the argument is canonical and :const:`False` "
"otherwise.  Currently, a :class:`Decimal` instance is always canonical, so "
"this operation always returns :const:`True`."
msgstr ""
"Renvoie :const:`True` si l'argument est sous forme canonique et :const:"
"`False` sinon. Actuellement, une instance :class:`Decimal` est toujours "
"canonique, donc cette opération renvoie toujours :const:`True`."

#: library/decimal.rst:617
msgid ""
"Return :const:`True` if the argument is a finite number, and :const:`False` "
"if the argument is an infinity or a NaN."
msgstr ""
"Renvoie :const:`True` si l'argument est un nombre fini et :const:`False` si "
"l'argument est un infini ou NaN."

#: library/decimal.rst:622
msgid ""
"Return :const:`True` if the argument is either positive or negative infinity "
"and :const:`False` otherwise."
msgstr ""
"Renvoie :const:`True` si l'argument est un infini positif ou négatif et :"
"const:`False` sinon."

#: library/decimal.rst:627
msgid ""
"Return :const:`True` if the argument is a (quiet or signaling) NaN and :"
"const:`False` otherwise."
msgstr ""
"Renvoie :const:`True` si l'argument est un NaN (signalétique ou silencieux) "
"et :const:`False` sinon."

#: library/decimal.rst:632
msgid ""
"Return :const:`True` if the argument is a *normal* finite number.  Return :"
"const:`False` if the argument is zero, subnormal, infinite or a NaN."
msgstr ""

#: library/decimal.rst:637
msgid ""
"Return :const:`True` if the argument is a quiet NaN, and :const:`False` "
"otherwise."
msgstr ""
"Renvoie :const:`True` si l'argument est un NaN silencieux et :const:`False` "
"sinon."

#: library/decimal.rst:642
msgid ""
"Return :const:`True` if the argument has a negative sign and :const:`False` "
"otherwise.  Note that zeros and NaNs can both carry signs."
msgstr ""
"Renvoie :const:`True` si l'argument est négatif et :const:`False` sinon. "
"Notez que les zéros et les NaNs peuvent être signés."

#: library/decimal.rst:647
msgid ""
"Return :const:`True` if the argument is a signaling NaN and :const:`False` "
"otherwise."
msgstr ""
"Renvoie :const:`True` si l'argument est un NaN signalétique et :const:"
"`False` sinon."

#: library/decimal.rst:652
msgid ""
"Return :const:`True` if the argument is subnormal, and :const:`False` "
"otherwise."
msgstr ""

#: library/decimal.rst:657
msgid ""
"Return :const:`True` if the argument is a (positive or negative) zero and :"
"const:`False` otherwise."
msgstr ""
"Renvoie :const:`True` si l'argument est un zéro (positif ou négatif) et :"
"const:`False` sinon."

#: library/decimal.rst:662
msgid ""
"Return the natural (base e) logarithm of the operand.  The result is "
"correctly rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr ""
"Renvoie le logarithme naturel (base e) de l'opérande. Le résultat est "
"arrondi avec le mode :const:`ROUND_HALF_EVEN`."

#: library/decimal.rst:667
msgid ""
"Return the base ten logarithm of the operand.  The result is correctly "
"rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr ""
"Renvoie le logarithme en base 10 de l'opérande. Le résultat est arrondi avec "
"le mode :const:`ROUND_HALF_EVEN`."

#: library/decimal.rst:672
msgid ""
"For a nonzero number, return the adjusted exponent of its operand as a :"
"class:`Decimal` instance.  If the operand is a zero then ``Decimal('-"
"Infinity')`` is returned and the :const:`DivisionByZero` flag is raised.  If "
"the operand is an infinity then ``Decimal('Infinity')`` is returned."
msgstr ""

#: library/decimal.rst:680
msgid ""
":meth:`logical_and` is a logical operation which takes two *logical "
"operands* (see :ref:`logical_operands_label`).  The result is the digit-wise "
"``and`` of the two operands."
msgstr ""

#: library/decimal.rst:686
msgid ""
":meth:`logical_invert` is a logical operation.  The result is the digit-wise "
"inversion of the operand."
msgstr ""

#: library/decimal.rst:691
msgid ""
":meth:`logical_or` is a logical operation which takes two *logical operands* "
"(see :ref:`logical_operands_label`).  The result is the digit-wise ``or`` of "
"the two operands."
msgstr ""

#: library/decimal.rst:697
msgid ""
":meth:`logical_xor` is a logical operation which takes two *logical "
"operands* (see :ref:`logical_operands_label`).  The result is the digit-wise "
"exclusive or of the two operands."
msgstr ""

#: library/decimal.rst:703
msgid ""
"Like ``max(self, other)`` except that the context rounding rule is applied "
"before returning and that :const:`NaN` values are either signaled or ignored "
"(depending on the context and whether they are signaling or quiet)."
msgstr ""

#: library/decimal.rst:710
msgid ""
"Similar to the :meth:`.max` method, but the comparison is done using the "
"absolute values of the operands."
msgstr ""

#: library/decimal.rst:715
msgid ""
"Like ``min(self, other)`` except that the context rounding rule is applied "
"before returning and that :const:`NaN` values are either signaled or ignored "
"(depending on the context and whether they are signaling or quiet)."
msgstr ""

#: library/decimal.rst:722
msgid ""
"Similar to the :meth:`.min` method, but the comparison is done using the "
"absolute values of the operands."
msgstr ""

#: library/decimal.rst:727
msgid ""
"Return the largest number representable in the given context (or in the "
"current thread's context if no context is given) that is smaller than the "
"given operand."
msgstr ""

#: library/decimal.rst:733
msgid ""
"Return the smallest number representable in the given context (or in the "
"current thread's context if no context is given) that is larger than the "
"given operand."
msgstr ""

#: library/decimal.rst:739
msgid ""
"If the two operands are unequal, return the number closest to the first "
"operand in the direction of the second operand.  If both operands are "
"numerically equal, return a copy of the first operand with the sign set to "
"be the same as the sign of the second operand."
msgstr ""

#: library/decimal.rst:746
msgid ""
"Normalize the number by stripping the rightmost trailing zeros and "
"converting any result equal to :const:`Decimal('0')` to :const:"
"`Decimal('0e0')`. Used for producing canonical values for attributes of an "
"equivalence class. For example, ``Decimal('32.100')`` and "
"``Decimal('0.321000e+2')`` both normalize to the equivalent value "
"``Decimal('32.1')``."
msgstr ""

#: library/decimal.rst:755
msgid ""
"Return a string describing the *class* of the operand.  The returned value "
"is one of the following ten strings."
msgstr ""

# Élément d'une liste, d'où le ; final
#: library/decimal.rst:758
msgid "``\"-Infinity\"``, indicating that the operand is negative infinity."
msgstr "``\"-Infinity\"``, indiquant que l'opérande est l'infini négatif ;"

#: library/decimal.rst:759
msgid ""
"``\"-Normal\"``, indicating that the operand is a negative normal number."
msgstr ""

#: library/decimal.rst:760
msgid ""
"``\"-Subnormal\"``, indicating that the operand is negative and subnormal."
msgstr ""

# Élément d'une liste, d'où le ; final
#: library/decimal.rst:761
msgid "``\"-Zero\"``, indicating that the operand is a negative zero."
msgstr "``\"-Zero\"``, indiquant que l'opérande est un zéro négatif ;"

# Élément d'une liste, d'où le ; final
#: library/decimal.rst:762
msgid "``\"+Zero\"``, indicating that the operand is a positive zero."
msgstr "``\"+Zero\"``, indiquant que l'opérande est un zéro positif ;"

#: library/decimal.rst:763
msgid ""
"``\"+Subnormal\"``, indicating that the operand is positive and subnormal."
msgstr ""

#: library/decimal.rst:764
msgid ""
"``\"+Normal\"``, indicating that the operand is a positive normal number."
msgstr ""

# Élément d'une liste, d'où le ; final
#: library/decimal.rst:765
msgid "``\"+Infinity\"``, indicating that the operand is positive infinity."
msgstr "``\"+Infinity\"``, indiquant que l'opérande est l'infini positif ;"

# Élément d'une liste, d'où le ; final
#: library/decimal.rst:766
msgid "``\"NaN\"``, indicating that the operand is a quiet NaN (Not a Number)."
msgstr ""
"``\"NaN\"``, indiquant que l'opérande est un NaN (*Not a Number*, pas un "
"nombre) silencieux ;"

#: library/decimal.rst:767
msgid "``\"sNaN\"``, indicating that the operand is a signaling NaN."
msgstr ""
"``\"sNaN\"``, indiquant que l'opérande est un NaN (*Not a Number*, pas un "
"nombre) signalétique."

#: library/decimal.rst:771
msgid ""
"Return a value equal to the first operand after rounding and having the "
"exponent of the second operand."
msgstr ""

#: library/decimal.rst:777
msgid ""
"Unlike other operations, if the length of the coefficient after the quantize "
"operation would be greater than precision, then an :const:`InvalidOperation` "
"is signaled. This guarantees that, unless there is an error condition, the "
"quantized exponent is always equal to that of the right-hand operand."
msgstr ""

#: library/decimal.rst:783
msgid ""
"Also unlike other operations, quantize never signals Underflow, even if the "
"result is subnormal and inexact."
msgstr ""

#: library/decimal.rst:786
msgid ""
"If the exponent of the second operand is larger than that of the first then "
"rounding may be necessary.  In this case, the rounding mode is determined by "
"the ``rounding`` argument if given, else by the given ``context`` argument; "
"if neither argument is given the rounding mode of the current thread's "
"context is used."
msgstr ""

#: library/decimal.rst:792
msgid ""
"An error is returned whenever the resulting exponent is greater than :attr:"
"`Emax` or less than :attr:`Etiny`."
msgstr ""

#: library/decimal.rst:797
msgid ""
"Return ``Decimal(10)``, the radix (base) in which the :class:`Decimal` class "
"does all its arithmetic.  Included for compatibility with the specification."
msgstr ""

#: library/decimal.rst:803
msgid ""
"Return the remainder from dividing *self* by *other*.  This differs from "
"``self % other`` in that the sign of the remainder is chosen so as to "
"minimize its absolute value.  More precisely, the return value is ``self - n "
"* other`` where ``n`` is the integer nearest to the exact value of ``self / "
"other``, and if two integers are equally near then the even one is chosen."
msgstr ""

#: library/decimal.rst:810
msgid "If the result is zero then its sign will be the sign of *self*."
msgstr ""

#: library/decimal.rst:821
msgid ""
"Return the result of rotating the digits of the first operand by an amount "
"specified by the second operand.  The second operand must be an integer in "
"the range -precision through precision.  The absolute value of the second "
"operand gives the number of places to rotate.  If the second operand is "
"positive then rotation is to the left; otherwise rotation is to the right. "
"The coefficient of the first operand is padded on the left with zeros to "
"length precision if necessary.  The sign and exponent of the first operand "
"are unchanged."
msgstr ""

#: library/decimal.rst:832
msgid ""
"Test whether self and other have the same exponent or whether both are :"
"const:`NaN`."
msgstr ""

#: library/decimal.rst:841
msgid ""
"Return the first operand with exponent adjusted by the second. Equivalently, "
"return the first operand multiplied by ``10**other``.  The second operand "
"must be an integer."
msgstr ""

#: library/decimal.rst:847
msgid ""
"Return the result of shifting the digits of the first operand by an amount "
"specified by the second operand.  The second operand must be an integer in "
"the range -precision through precision.  The absolute value of the second "
"operand gives the number of places to shift.  If the second operand is "
"positive then the shift is to the left; otherwise the shift is to the "
"right.  Digits shifted into the coefficient are zeros.  The sign and "
"exponent of the first operand are unchanged."
msgstr ""

#: library/decimal.rst:857
msgid "Return the square root of the argument to full precision."
msgstr ""

#: library/decimal.rst:1457
msgid ""
"Convert to a string, using engineering notation if an exponent is needed."
msgstr ""

#: library/decimal.rst:1459
msgid ""
"Engineering notation has an exponent which is a multiple of 3.  This can "
"leave up to 3 digits to the left of the decimal place and may require the "
"addition of either one or two trailing zeros."
msgstr ""

#: library/decimal.rst:868
msgid ""
"For example, this converts ``Decimal('123E+1')`` to ``Decimal('1.23E+3')``."
msgstr ""

#: library/decimal.rst:872
msgid ""
"Identical to the :meth:`to_integral_value` method.  The ``to_integral`` name "
"has been kept for compatibility with older versions."
msgstr ""

#: library/decimal.rst:877
msgid ""
"Round to the nearest integer, signaling :const:`Inexact` or :const:`Rounded` "
"as appropriate if rounding occurs.  The rounding mode is determined by the "
"``rounding`` parameter if given, else by the given ``context``.  If neither "
"parameter is given then the rounding mode of the current context is used."
msgstr ""

#: library/decimal.rst:885
msgid ""
"Round to the nearest integer without signaling :const:`Inexact` or :const:"
"`Rounded`.  If given, applies *rounding*; otherwise, uses the rounding "
"method in either the supplied *context* or the current context."
msgstr ""

#: library/decimal.rst:893
msgid "Logical operands"
msgstr ""

#: library/decimal.rst:895
msgid ""
"The :meth:`logical_and`, :meth:`logical_invert`, :meth:`logical_or`, and :"
"meth:`logical_xor` methods expect their arguments to be *logical operands*.  "
"A *logical operand* is a :class:`Decimal` instance whose exponent and sign "
"are both zero, and whose digits are all either :const:`0` or :const:`1`."
msgstr ""

#: library/decimal.rst:907
msgid "Context objects"
msgstr ""

#: library/decimal.rst:909
msgid ""
"Contexts are environments for arithmetic operations.  They govern precision, "
"set rules for rounding, determine which signals are treated as exceptions, "
"and limit the range for exponents."
msgstr ""

#: library/decimal.rst:913
msgid ""
"Each thread has its own current context which is accessed or changed using "
"the :func:`getcontext` and :func:`setcontext` functions:"
msgstr ""

#: library/decimal.rst:919
msgid "Return the current context for the active thread."
msgstr ""

#: library/decimal.rst:924
msgid "Set the current context for the active thread to *c*."
msgstr ""

#: library/decimal.rst:926
msgid ""
"You can also use the :keyword:`with` statement and the :func:`localcontext` "
"function to temporarily change the active context."
msgstr ""

#: library/decimal.rst:931
msgid ""
"Return a context manager that will set the current context for the active "
"thread to a copy of *ctx* on entry to the with-statement and restore the "
"previous context when exiting the with-statement. If no context is "
"specified, a copy of the current context is used.  The *kwargs* argument is "
"used to set the attributes of the new context."
msgstr ""

#: library/decimal.rst:937
msgid ""
"For example, the following code sets the current decimal precision to 42 "
"places, performs a calculation, and then automatically restores the previous "
"context::"
msgstr ""

#: library/decimal.rst:947
msgid "Using keyword arguments, the code would be the following::"
msgstr ""

#: library/decimal.rst:955
msgid ""
"Raises :exc:`TypeError` if *kwargs* supplies an attribute that :class:"
"`Context` doesn't support.  Raises either :exc:`TypeError` or :exc:"
"`ValueError` if *kwargs* supplies an invalid value for an attribute."
msgstr ""

#: library/decimal.rst:959
msgid ""
":meth:`localcontext` now supports setting context attributes through the use "
"of keyword arguments."
msgstr ""

#: library/decimal.rst:962
msgid ""
"New contexts can also be created using the :class:`Context` constructor "
"described below. In addition, the module provides three pre-made contexts:"
msgstr ""

#: library/decimal.rst:968
msgid ""
"This is a standard context defined by the General Decimal Arithmetic "
"Specification.  Precision is set to nine.  Rounding is set to :const:"
"`ROUND_HALF_UP`.  All flags are cleared.  All traps are enabled (treated as "
"exceptions) except :const:`Inexact`, :const:`Rounded`, and :const:"
"`Subnormal`."
msgstr ""

#: library/decimal.rst:974
msgid ""
"Because many of the traps are enabled, this context is useful for debugging."
msgstr ""

#: library/decimal.rst:979
msgid ""
"This is a standard context defined by the General Decimal Arithmetic "
"Specification.  Precision is set to nine.  Rounding is set to :const:"
"`ROUND_HALF_EVEN`.  All flags are cleared.  No traps are enabled (so that "
"exceptions are not raised during computations)."
msgstr ""

#: library/decimal.rst:984
msgid ""
"Because the traps are disabled, this context is useful for applications that "
"prefer to have result value of :const:`NaN` or :const:`Infinity` instead of "
"raising exceptions.  This allows an application to complete a run in the "
"presence of conditions that would otherwise halt the program."
msgstr ""

#: library/decimal.rst:992
msgid ""
"This context is used by the :class:`Context` constructor as a prototype for "
"new contexts.  Changing a field (such a precision) has the effect of "
"changing the default for new contexts created by the :class:`Context` "
"constructor."
msgstr ""

#: library/decimal.rst:996
msgid ""
"This context is most useful in multi-threaded environments.  Changing one of "
"the fields before threads are started has the effect of setting system-wide "
"defaults.  Changing the fields after threads have started is not recommended "
"as it would require thread synchronization to prevent race conditions."
msgstr ""

#: library/decimal.rst:1001
msgid ""
"In single threaded environments, it is preferable to not use this context at "
"all.  Instead, simply create contexts explicitly as described below."
msgstr ""

#: library/decimal.rst:1004
msgid ""
"The default values are :attr:`prec`\\ =\\ :const:`28`, :attr:`rounding`\\ "
"=\\ :const:`ROUND_HALF_EVEN`, and enabled traps for :class:`Overflow`, :"
"class:`InvalidOperation`, and :class:`DivisionByZero`."
msgstr ""

#: library/decimal.rst:1009
msgid ""
"In addition to the three supplied contexts, new contexts can be created with "
"the :class:`Context` constructor."
msgstr ""

#: library/decimal.rst:1015
msgid ""
"Creates a new context.  If a field is not specified or is :const:`None`, the "
"default values are copied from the :const:`DefaultContext`.  If the *flags* "
"field is not specified or is :const:`None`, all flags are cleared."
msgstr ""

#: library/decimal.rst:1019
msgid ""
"*prec* is an integer in the range [:const:`1`, :const:`MAX_PREC`] that sets "
"the precision for arithmetic operations in the context."
msgstr ""

#: library/decimal.rst:1022
msgid ""
"The *rounding* option is one of the constants listed in the section "
"`Rounding Modes`_."
msgstr ""

#: library/decimal.rst:1025
msgid ""
"The *traps* and *flags* fields list any signals to be set. Generally, new "
"contexts should only set traps and leave the flags clear."
msgstr ""

#: library/decimal.rst:1028
msgid ""
"The *Emin* and *Emax* fields are integers specifying the outer limits "
"allowable for exponents. *Emin* must be in the range [:const:`MIN_EMIN`, :"
"const:`0`], *Emax* in the range [:const:`0`, :const:`MAX_EMAX`]."
msgstr ""

#: library/decimal.rst:1032
msgid ""
"The *capitals* field is either :const:`0` or :const:`1` (the default). If "
"set to :const:`1`, exponents are printed with a capital :const:`E`; "
"otherwise, a lowercase :const:`e` is used: :const:`Decimal('6.02e+23')`."
msgstr ""

#: library/decimal.rst:1036
msgid ""
"The *clamp* field is either :const:`0` (the default) or :const:`1`. If set "
"to :const:`1`, the exponent ``e`` of a :class:`Decimal` instance "
"representable in this context is strictly limited to the range ``Emin - prec "
"+ 1 <= e <= Emax - prec + 1``.  If *clamp* is :const:`0` then a weaker "
"condition holds: the adjusted exponent of the :class:`Decimal` instance is "
"at most ``Emax``.  When *clamp* is :const:`1`, a large normal number will, "
"where possible, have its exponent reduced and a corresponding number of "
"zeros added to its coefficient, in order to fit the exponent constraints; "
"this preserves the value of the number but loses information about "
"significant trailing zeros.  For example::"
msgstr ""

#: library/decimal.rst:1051
msgid ""
"A *clamp* value of :const:`1` allows compatibility with the fixed-width "
"decimal interchange formats specified in IEEE 754."
msgstr ""

#: library/decimal.rst:1054
msgid ""
"The :class:`Context` class defines several general purpose methods as well "
"as a large number of methods for doing arithmetic directly in a given "
"context. In addition, for each of the :class:`Decimal` methods described "
"above (with the exception of the :meth:`adjusted` and :meth:`as_tuple` "
"methods) there is a corresponding :class:`Context` method.  For example, for "
"a :class:`Context` instance ``C`` and :class:`Decimal` instance ``x``, ``C."
"exp(x)`` is equivalent to ``x.exp(context=C)``.  Each :class:`Context` "
"method accepts a Python integer (an instance of :class:`int`) anywhere that "
"a Decimal instance is accepted."
msgstr ""

#: library/decimal.rst:1067
msgid "Resets all of the flags to :const:`0`."
msgstr ""

#: library/decimal.rst:1071
msgid "Resets all of the traps to :const:`0`."
msgstr ""

#: library/decimal.rst:1077
msgid "Return a duplicate of the context."
msgstr ""

#: library/decimal.rst:1081
msgid "Return a copy of the Decimal instance num."
msgstr ""

#: library/decimal.rst:1085
msgid ""
"Creates a new Decimal instance from *num* but using *self* as context. "
"Unlike the :class:`Decimal` constructor, the context precision, rounding "
"method, flags, and traps are applied to the conversion."
msgstr ""

#: library/decimal.rst:1089
msgid ""
"This is useful because constants are often given to a greater precision than "
"is needed by the application.  Another benefit is that rounding immediately "
"eliminates unintended effects from digits beyond the current precision. In "
"the following example, using unrounded inputs means that adding zero to a "
"sum can change the result:"
msgstr ""

#: library/decimal.rst:1103
msgid ""
"This method implements the to-number operation of the IBM specification. If "
"the argument is a string, no leading or trailing whitespace or underscores "
"are permitted."
msgstr ""

#: library/decimal.rst:1109
msgid ""
"Creates a new Decimal instance from a float *f* but rounding using *self* as "
"the context.  Unlike the :meth:`Decimal.from_float` class method, the "
"context precision, rounding method, flags, and traps are applied to the "
"conversion."
msgstr ""

#: library/decimal.rst:1129
msgid ""
"Returns a value equal to ``Emin - prec + 1`` which is the minimum exponent "
"value for subnormal results.  When underflow occurs, the exponent is set to :"
"const:`Etiny`."
msgstr ""

#: library/decimal.rst:1135
msgid "Returns a value equal to ``Emax - prec + 1``."
msgstr ""

#: library/decimal.rst:1137
msgid ""
"The usual approach to working with decimals is to create :class:`Decimal` "
"instances and then apply arithmetic operations which take place within the "
"current context for the active thread.  An alternative approach is to use "
"context methods for calculating within a specific context.  The methods are "
"similar to those for the :class:`Decimal` class and are only briefly "
"recounted here."
msgstr ""

#: library/decimal.rst:1147
msgid "Returns the absolute value of *x*."
msgstr "Renvoie la valeur absolue de *x*."

#: library/decimal.rst:1152
msgid "Return the sum of *x* and *y*."
msgstr "Renvoie la somme de *x* et *y*."

#: library/decimal.rst:1157
msgid "Returns the same Decimal object *x*."
msgstr ""

#: library/decimal.rst:1162
msgid "Compares *x* and *y* numerically."
msgstr ""

#: library/decimal.rst:1167
msgid "Compares the values of the two operands numerically."
msgstr ""

#: library/decimal.rst:1172
msgid "Compares two operands using their abstract representation."
msgstr ""

#: library/decimal.rst:1177
msgid ""
"Compares two operands using their abstract representation, ignoring sign."
msgstr ""

#: library/decimal.rst:1182
msgid "Returns a copy of *x* with the sign set to 0."
msgstr ""

#: library/decimal.rst:1187
msgid "Returns a copy of *x* with the sign inverted."
msgstr "Renvoie une copie de *x* mais de signe opposé."

#: library/decimal.rst:1192
msgid "Copies the sign from *y* to *x*."
msgstr "Copie le signe de *y* vers *x*."

#: library/decimal.rst:1197
msgid "Return *x* divided by *y*."
msgstr "Renvoie *x* divisé par *y*."

#: library/decimal.rst:1202
msgid "Return *x* divided by *y*, truncated to an integer."
msgstr "Renvoie *x* divisé par *y*, tronqué comme entier."

#: library/decimal.rst:1207
msgid "Divides two numbers and returns the integer part of the result."
msgstr "Renvoie la partie entière de la division entre deux nombres."

#: library/decimal.rst:1212
#, fuzzy
msgid "Returns ``e ** x``."
msgstr "Renvoie ``e ** x``."

#: library/decimal.rst:1217
msgid "Returns *x* multiplied by *y*, plus *z*."
msgstr "Renvoie *x* multiplié par *y*, plus *z*."

#: library/decimal.rst:1222
msgid "Returns ``True`` if *x* is canonical; otherwise returns ``False``."
msgstr ""

#: library/decimal.rst:1227
msgid "Returns ``True`` if *x* is finite; otherwise returns ``False``."
msgstr ""

#: library/decimal.rst:1232
msgid "Returns ``True`` if *x* is infinite; otherwise returns ``False``."
msgstr "Renvoie ``True`` si *x* est infini et ``False`` sinon."

#: library/decimal.rst:1237
msgid "Returns ``True`` if *x* is a qNaN or sNaN; otherwise returns ``False``."
msgstr ""
"Renvoie ``True`` si *x* est un NaN (silencieux ou signalétique) et ``False`` "
"sinon."

#: library/decimal.rst:1242
msgid ""
"Returns ``True`` if *x* is a normal number; otherwise returns ``False``."
msgstr ""

#: library/decimal.rst:1247
msgid "Returns ``True`` if *x* is a quiet NaN; otherwise returns ``False``."
msgstr "Renvoie ``True`` si *x* est un NaN silencieux et ``False`` sinon."

#: library/decimal.rst:1252
msgid "Returns ``True`` if *x* is negative; otherwise returns ``False``."
msgstr "Renvoie ``True`` si *x* est négatif et ``False`` sinon."

#: library/decimal.rst:1257
msgid ""
"Returns ``True`` if *x* is a signaling NaN; otherwise returns ``False``."
msgstr "Renvoie ``True`` si *x* est un NaN signalétique et ``False`` sinon."

#: library/decimal.rst:1262
msgid "Returns ``True`` if *x* is subnormal; otherwise returns ``False``."
msgstr ""

#: library/decimal.rst:1267
msgid "Returns ``True`` if *x* is a zero; otherwise returns ``False``."
msgstr "Renvoie ``True`` si *x* est un zéro et ``False`` sinon."

#: library/decimal.rst:1272
msgid "Returns the natural (base e) logarithm of *x*."
msgstr "Renvoie le logarithme naturel (en base e) de *x*."

#: library/decimal.rst:1277
msgid "Returns the base 10 logarithm of *x*."
msgstr "Renvoie le logarithme en base 10 de *x*."

#: library/decimal.rst:1282
msgid "Returns the exponent of the magnitude of the operand's MSD."
msgstr ""

#: library/decimal.rst:1287
msgid "Applies the logical operation *and* between each operand's digits."
msgstr ""

#: library/decimal.rst:1292
msgid "Invert all the digits in *x*."
msgstr ""

#: library/decimal.rst:1297
msgid "Applies the logical operation *or* between each operand's digits."
msgstr ""

#: library/decimal.rst:1302
msgid "Applies the logical operation *xor* between each operand's digits."
msgstr ""

#: library/decimal.rst:1307
msgid "Compares two values numerically and returns the maximum."
msgstr "Renvoie le maximum entre les deux valeurs numériques."

#: library/decimal.rst:1322
msgid "Compares the values numerically with their sign ignored."
msgstr ""

#: library/decimal.rst:1317
msgid "Compares two values numerically and returns the minimum."
msgstr ""

#: library/decimal.rst:1327
msgid "Minus corresponds to the unary prefix minus operator in Python."
msgstr ""

#: library/decimal.rst:1332
msgid "Return the product of *x* and *y*."
msgstr "Renvoie la multiplication de *x* avec *y*."

#: library/decimal.rst:1337
msgid "Returns the largest representable number smaller than *x*."
msgstr ""

#: library/decimal.rst:1342
msgid "Returns the smallest representable number larger than *x*."
msgstr ""

#: library/decimal.rst:1347
msgid "Returns the number closest to *x*, in direction towards *y*."
msgstr ""

#: library/decimal.rst:1352
msgid "Reduces *x* to its simplest form."
msgstr "Réduit *x* à sa forme la plus simple."

#: library/decimal.rst:1357
msgid "Returns an indication of the class of *x*."
msgstr ""

#: library/decimal.rst:1362
msgid ""
"Plus corresponds to the unary prefix plus operator in Python.  This "
"operation applies the context precision and rounding, so it is *not* an "
"identity operation."
msgstr ""

#: library/decimal.rst:1369
msgid "Return ``x`` to the power of ``y``, reduced modulo ``modulo`` if given."
msgstr ""

#: library/decimal.rst:1371
msgid ""
"With two arguments, compute ``x**y``.  If ``x`` is negative then ``y`` must "
"be integral.  The result will be inexact unless ``y`` is integral and the "
"result is finite and can be expressed exactly in 'precision' digits. The "
"rounding mode of the context is used. Results are always correctly rounded "
"in the Python version."
msgstr ""

#: library/decimal.rst:1377
msgid ""
"``Decimal(0) ** Decimal(0)`` results in ``InvalidOperation``, and if "
"``InvalidOperation`` is not trapped, then results in ``Decimal('NaN')``."
msgstr ""

#: library/decimal.rst:1380
msgid ""
"The C module computes :meth:`power` in terms of the correctly rounded :meth:"
"`exp` and :meth:`ln` functions. The result is well-defined but only \"almost "
"always correctly rounded\"."
msgstr ""

#: library/decimal.rst:1385
msgid ""
"With three arguments, compute ``(x**y) % modulo``.  For the three argument "
"form, the following restrictions on the arguments hold:"
msgstr ""

#: library/decimal.rst:1388
msgid "all three arguments must be integral"
msgstr ""

# Élément d'une liste, d'où le ; final
#: library/decimal.rst:1389
msgid "``y`` must be nonnegative"
msgstr "``y`` ne doit pas être négatif ;"

# Élément d'une liste, d'où le ; final
#: library/decimal.rst:1390
msgid "at least one of ``x`` or ``y`` must be nonzero"
msgstr "au moins l'un de ``x`` ou ``y`` doit être différent de zéro ;"

#: library/decimal.rst:1391
msgid "``modulo`` must be nonzero and have at most 'precision' digits"
msgstr ""

#: library/decimal.rst:1393
msgid ""
"The value resulting from ``Context.power(x, y, modulo)`` is equal to the "
"value that would be obtained by computing ``(x**y) % modulo`` with unbounded "
"precision, but is computed more efficiently.  The exponent of the result is "
"zero, regardless of the exponents of ``x``, ``y`` and ``modulo``.  The "
"result is always exact."
msgstr ""

#: library/decimal.rst:1403
msgid "Returns a value equal to *x* (rounded), having the exponent of *y*."
msgstr ""

#: library/decimal.rst:1408
msgid "Just returns 10, as this is Decimal, :)"
msgstr "Renvoie 10 car c'est Decimal, :)"

#: library/decimal.rst:1413
msgid "Returns the remainder from integer division."
msgstr "Donne le reste de la division entière."

#: library/decimal.rst:1415
msgid ""
"The sign of the result, if non-zero, is the same as that of the original "
"dividend."
msgstr ""

#: library/decimal.rst:1421
msgid ""
"Returns ``x - y * n``, where *n* is the integer nearest the exact value of "
"``x / y`` (if the result is 0 then its sign will be the sign of *x*)."
msgstr ""

#: library/decimal.rst:1427
msgid "Returns a rotated copy of *x*, *y* times."
msgstr ""

#: library/decimal.rst:1432
msgid "Returns ``True`` if the two operands have the same exponent."
msgstr "Renvoie ``True`` si les deux opérandes ont le même exposant."

#: library/decimal.rst:1437
msgid "Returns the first operand after adding the second value its exp."
msgstr ""

#: library/decimal.rst:1442
msgid "Returns a shifted copy of *x*, *y* times."
msgstr ""

#: library/decimal.rst:1447
msgid "Square root of a non-negative number to context precision."
msgstr ""

#: library/decimal.rst:1452
msgid "Return the difference between *x* and *y*."
msgstr ""

#: library/decimal.rst:1466
msgid "Rounds to an integer."
msgstr ""

#: library/decimal.rst:1471
msgid "Converts a number to a string using scientific notation."
msgstr ""

#: library/decimal.rst:1478
msgid "Constants"
msgstr "Constantes"

#: library/decimal.rst:1480
msgid ""
"The constants in this section are only relevant for the C module. They are "
"also included in the pure Python version for compatibility."
msgstr ""
"Les constantes de cette section ne sont pertinentes que pour le module C. "
"Elles sont aussi incluses pour le compatibilité dans la version en Python "
"pur."

#: library/decimal.rst:1484
msgid "32-bit"
msgstr "32-bit"

#: library/decimal.rst:1484
msgid "64-bit"
msgstr "64-bit"

#: library/decimal.rst:1488
msgid ":const:`425000000`"
msgstr ":const:`425000000`"

#: library/decimal.rst:1488
msgid ":const:`999999999999999999`"
msgstr ":const:`999999999999999999`"

#: library/decimal.rst:1490
msgid ":const:`-425000000`"
msgstr ":const:`-425000000`"

#: library/decimal.rst:1490
msgid ":const:`-999999999999999999`"
msgstr ":const:`-999999999999999999`"

#: library/decimal.rst:1492
msgid ":const:`-849999999`"
msgstr ":const:`-849999999`"

#: library/decimal.rst:1492
msgid ":const:`-1999999999999999997`"
msgstr ":const:`-1999999999999999997`"

#: library/decimal.rst:1498
msgid ""
"The value is ``True``.  Deprecated, because Python now always has threads."
msgstr ""
"La valeur est ``True``. Déprécié, parce que maintenant Python possède "
"toujours des fils d'exécution."

#: library/decimal.rst:1504
msgid ""
"The default value is ``True``. If Python is :option:`configured using the --"
"without-decimal-contextvar option <--without-decimal-contextvar>`, the C "
"version uses a thread-local rather than a coroutine-local context and the "
"value is ``False``.  This is slightly faster in some nested context "
"scenarios."
msgstr ""

#: library/decimal.rst:1509
msgid "backported to 3.7 and 3.8."
msgstr ""

#: library/decimal.rst:1513
msgid "Rounding modes"
msgstr "Modes d'arrondi"

#: library/decimal.rst:1517
msgid "Round towards :const:`Infinity`."
msgstr ""

#: library/decimal.rst:1521
msgid "Round towards zero."
msgstr ""

#: library/decimal.rst:1525
msgid "Round towards :const:`-Infinity`."
msgstr ""

#: library/decimal.rst:1529
msgid "Round to nearest with ties going towards zero."
msgstr ""

#: library/decimal.rst:1533
msgid "Round to nearest with ties going to nearest even integer."
msgstr ""

#: library/decimal.rst:1537
msgid "Round to nearest with ties going away from zero."
msgstr ""

#: library/decimal.rst:1541
msgid "Round away from zero."
msgstr ""

#: library/decimal.rst:1545
msgid ""
"Round away from zero if last digit after rounding towards zero would have "
"been 0 or 5; otherwise round towards zero."
msgstr ""

#: library/decimal.rst:1552
msgid "Signals"
msgstr "Signaux"

#: library/decimal.rst:1554
msgid ""
"Signals represent conditions that arise during computation. Each corresponds "
"to one context flag and one context trap enabler."
msgstr ""

#: library/decimal.rst:1557
msgid ""
"The context flag is set whenever the condition is encountered. After the "
"computation, flags may be checked for informational purposes (for instance, "
"to determine whether a computation was exact). After checking the flags, be "
"sure to clear all flags before starting the next computation."
msgstr ""

#: library/decimal.rst:1562
msgid ""
"If the context's trap enabler is set for the signal, then the condition "
"causes a Python exception to be raised.  For example, if the :class:"
"`DivisionByZero` trap is set, then a :exc:`DivisionByZero` exception is "
"raised upon encountering the condition."
msgstr ""

#: library/decimal.rst:1570
msgid "Altered an exponent to fit representation constraints."
msgstr ""

#: library/decimal.rst:1572
msgid ""
"Typically, clamping occurs when an exponent falls outside the context's :"
"attr:`Emin` and :attr:`Emax` limits.  If possible, the exponent is reduced "
"to fit by adding zeros to the coefficient."
msgstr ""

#: library/decimal.rst:1579
msgid "Base class for other signals and a subclass of :exc:`ArithmeticError`."
msgstr ""

#: library/decimal.rst:1584
msgid "Signals the division of a non-infinite number by zero."
msgstr ""

#: library/decimal.rst:1586
msgid ""
"Can occur with division, modulo division, or when raising a number to a "
"negative power.  If this signal is not trapped, returns :const:`Infinity` "
"or :const:`-Infinity` with the sign determined by the inputs to the "
"calculation."
msgstr ""

#: library/decimal.rst:1593
msgid "Indicates that rounding occurred and the result is not exact."
msgstr ""

#: library/decimal.rst:1595
msgid ""
"Signals when non-zero digits were discarded during rounding. The rounded "
"result is returned.  The signal flag or trap is used to detect when results "
"are inexact."
msgstr ""

#: library/decimal.rst:1602
msgid "An invalid operation was performed."
msgstr ""

#: library/decimal.rst:1604
msgid ""
"Indicates that an operation was requested that does not make sense. If not "
"trapped, returns :const:`NaN`.  Possible causes include::"
msgstr ""

#: library/decimal.rst:1620
msgid "Numerical overflow."
msgstr "Débordement numérique."

#: library/decimal.rst:1622
msgid ""
"Indicates the exponent is larger than :attr:`Emax` after rounding has "
"occurred.  If not trapped, the result depends on the rounding mode, either "
"pulling inward to the largest representable finite number or rounding "
"outward to :const:`Infinity`.  In either case, :class:`Inexact` and :class:"
"`Rounded` are also signaled."
msgstr ""

#: library/decimal.rst:1631
msgid "Rounding occurred though possibly no information was lost."
msgstr ""

#: library/decimal.rst:1633
msgid ""
"Signaled whenever rounding discards digits; even if those digits are zero "
"(such as rounding :const:`5.00` to :const:`5.0`).  If not trapped, returns "
"the result unchanged.  This signal is used to detect loss of significant "
"digits."
msgstr ""

#: library/decimal.rst:1641
msgid "Exponent was lower than :attr:`Emin` prior to rounding."
msgstr ""

#: library/decimal.rst:1643
msgid ""
"Occurs when an operation result is subnormal (the exponent is too small). If "
"not trapped, returns the result unchanged."
msgstr ""

#: library/decimal.rst:1649
msgid "Numerical underflow with result rounded to zero."
msgstr ""

#: library/decimal.rst:1651
msgid ""
"Occurs when a subnormal result is pushed to zero by rounding. :class:"
"`Inexact` and :class:`Subnormal` are also signaled."
msgstr ""

#: library/decimal.rst:1657
msgid "Enable stricter semantics for mixing floats and Decimals."
msgstr ""

#: library/decimal.rst:1659
msgid ""
"If the signal is not trapped (default), mixing floats and Decimals is "
"permitted in the :class:`~decimal.Decimal` constructor, :meth:`~decimal."
"Context.create_decimal` and all comparison operators. Both conversion and "
"comparisons are exact. Any occurrence of a mixed operation is silently "
"recorded by setting :exc:`FloatOperation` in the context flags. Explicit "
"conversions with :meth:`~decimal.Decimal.from_float` or :meth:`~decimal."
"Context.create_decimal_from_float` do not set the flag."
msgstr ""

#: library/decimal.rst:1667
msgid ""
"Otherwise (the signal is trapped), only equality comparisons and explicit "
"conversions are silent. All other mixed operations raise :exc:"
"`FloatOperation`."
msgstr ""

#: library/decimal.rst:1671
msgid "The following table summarizes the hierarchy of signals::"
msgstr ""

#: library/decimal.rst:1692
msgid "Floating Point Notes"
msgstr ""

#: library/decimal.rst:1696
msgid "Mitigating round-off error with increased precision"
msgstr ""

#: library/decimal.rst:1698
msgid ""
"The use of decimal floating point eliminates decimal representation error "
"(making it possible to represent :const:`0.1` exactly); however, some "
"operations can still incur round-off error when non-zero digits exceed the "
"fixed precision."
msgstr ""

#: library/decimal.rst:1702
msgid ""
"The effects of round-off error can be amplified by the addition or "
"subtraction of nearly offsetting quantities resulting in loss of "
"significance.  Knuth provides two instructive examples where rounded "
"floating point arithmetic with insufficient precision causes the breakdown "
"of the associative and distributive properties of addition:"
msgstr ""

#: library/decimal.rst:1726
msgid ""
"The :mod:`decimal` module makes it possible to restore the identities by "
"expanding the precision sufficiently to avoid loss of significance:"
msgstr ""

#: library/decimal.rst:1746
msgid "Special values"
msgstr ""

#: library/decimal.rst:1748
msgid ""
"The number system for the :mod:`decimal` module provides special values "
"including :const:`NaN`, :const:`sNaN`, :const:`-Infinity`, :const:"
"`Infinity`, and two zeros, :const:`+0` and :const:`-0`."
msgstr ""

#: library/decimal.rst:1752
msgid ""
"Infinities can be constructed directly with:  ``Decimal('Infinity')``. Also, "
"they can arise from dividing by zero when the :exc:`DivisionByZero` signal "
"is not trapped.  Likewise, when the :exc:`Overflow` signal is not trapped, "
"infinity can result from rounding beyond the limits of the largest "
"representable number."
msgstr ""

#: library/decimal.rst:1757
msgid ""
"The infinities are signed (affine) and can be used in arithmetic operations "
"where they get treated as very large, indeterminate numbers.  For instance, "
"adding a constant to infinity gives another infinite result."
msgstr ""

#: library/decimal.rst:1761
msgid ""
"Some operations are indeterminate and return :const:`NaN`, or if the :exc:"
"`InvalidOperation` signal is trapped, raise an exception.  For example, "
"``0/0`` returns :const:`NaN` which means \"not a number\".  This variety of :"
"const:`NaN` is quiet and, once created, will flow through other computations "
"always resulting in another :const:`NaN`.  This behavior can be useful for a "
"series of computations that occasionally have missing inputs --- it allows "
"the calculation to proceed while flagging specific results as invalid."
msgstr ""

#: library/decimal.rst:1769
msgid ""
"A variant is :const:`sNaN` which signals rather than remaining quiet after "
"every operation.  This is a useful return value when an invalid result needs "
"to interrupt a calculation for special handling."
msgstr ""

#: library/decimal.rst:1773
msgid ""
"The behavior of Python's comparison operators can be a little surprising "
"where a :const:`NaN` is involved.  A test for equality where one of the "
"operands is a quiet or signaling :const:`NaN` always returns :const:`False` "
"(even when doing ``Decimal('NaN')==Decimal('NaN')``), while a test for "
"inequality always returns :const:`True`.  An attempt to compare two Decimals "
"using any of the ``<``, ``<=``, ``>`` or ``>=`` operators will raise the :"
"exc:`InvalidOperation` signal if either operand is a :const:`NaN`, and "
"return :const:`False` if this signal is not trapped.  Note that the General "
"Decimal Arithmetic specification does not specify the behavior of direct "
"comparisons; these rules for comparisons involving a :const:`NaN` were taken "
"from the IEEE 854 standard (see Table 3 in section 5.7).  To ensure strict "
"standards-compliance, use the :meth:`compare` and :meth:`compare-signal` "
"methods instead."
msgstr ""

#: library/decimal.rst:1786
msgid ""
"The signed zeros can result from calculations that underflow. They keep the "
"sign that would have resulted if the calculation had been carried out to "
"greater precision.  Since their magnitude is zero, both positive and "
"negative zeros are treated as equal and their sign is informational."
msgstr ""

#: library/decimal.rst:1791
msgid ""
"In addition to the two signed zeros which are distinct yet equal, there are "
"various representations of zero with differing precisions yet equivalent in "
"value.  This takes a bit of getting used to.  For an eye accustomed to "
"normalized floating point representations, it is not immediately obvious "
"that the following calculation returns a value equal to zero:"
msgstr ""

#: library/decimal.rst:1806
msgid "Working with threads"
msgstr ""

#: library/decimal.rst:1808
msgid ""
"The :func:`getcontext` function accesses a different :class:`Context` object "
"for each thread.  Having separate thread contexts means that threads may "
"make changes (such as ``getcontext().prec=10``) without interfering with "
"other threads."
msgstr ""

#: library/decimal.rst:1812
msgid ""
"Likewise, the :func:`setcontext` function automatically assigns its target "
"to the current thread."
msgstr ""

#: library/decimal.rst:1815
msgid ""
"If :func:`setcontext` has not been called before :func:`getcontext`, then :"
"func:`getcontext` will automatically create a new context for use in the "
"current thread."
msgstr ""

#: library/decimal.rst:1819
msgid ""
"The new context is copied from a prototype context called *DefaultContext*. "
"To control the defaults so that each thread will use the same values "
"throughout the application, directly modify the *DefaultContext* object. "
"This should be done *before* any threads are started so that there won't be "
"a race condition between threads calling :func:`getcontext`. For example::"
msgstr ""

#: library/decimal.rst:1844
msgid "Recipes"
msgstr "Cas pratiques"

#: library/decimal.rst:1846
msgid ""
"Here are a few recipes that serve as utility functions and that demonstrate "
"ways to work with the :class:`Decimal` class::"
msgstr ""

#: library/decimal.rst:2001
msgid "Decimal FAQ"
msgstr "FAQ *decimal*"

#: library/decimal.rst:2003
msgid ""
"Q. It is cumbersome to type ``decimal.Decimal('1234.5')``.  Is there a way "
"to minimize typing when using the interactive interpreter?"
msgstr ""
"Q. C'est fastidieux de taper ``decimal.Decimal('1234.5')``. Y a-t-il un "
"moyen de réduire la frappe quand on utilise l'interpréteur interactif ?"

#: library/decimal.rst:2006
msgid "A. Some users abbreviate the constructor to just a single letter:"
msgstr ""
"R. Certains utilisateurs abrègent le constructeur en une seule lettre :"

#: library/decimal.rst:2012
msgid ""
"Q. In a fixed-point application with two decimal places, some inputs have "
"many places and need to be rounded.  Others are not supposed to have excess "
"digits and need to be validated.  What methods should be used?"
msgstr ""

#: library/decimal.rst:2016
msgid ""
"A. The :meth:`quantize` method rounds to a fixed number of decimal places. "
"If the :const:`Inexact` trap is set, it is also useful for validation:"
msgstr ""

#: library/decimal.rst:2034
msgid ""
"Q. Once I have valid two place inputs, how do I maintain that invariant "
"throughout an application?"
msgstr ""
"Q. Une fois que mes entrées sont à deux décimales valides, comment maintenir "
"cet invariant dans l'application ?"

#: library/decimal.rst:2037
msgid ""
"A. Some operations like addition, subtraction, and multiplication by an "
"integer will automatically preserve fixed point.  Others operations, like "
"division and non-integer multiplication, will change the number of decimal "
"places and need to be followed-up with a :meth:`quantize` step:"
msgstr ""
"R. Certaines opérations comme l'addition, la soustraction et la "
"multiplication par un entier préservent automatiquement la virgule fixe. "
"D'autres opérations, comme la division et la multiplication par des non-"
"entiers, changent le nombre de décimales et doivent être suivies d'une "
"étape :meth:`quantize` :"

#: library/decimal.rst:2055
msgid ""
"In developing fixed-point applications, it is convenient to define functions "
"to handle the :meth:`quantize` step:"
msgstr ""
"Lors du développement d'applications en virgule fixe, il est pratique de "
"définir des fonctions pour gérer cette étape de quantification par :meth:"
"`quantize` :"

#: library/decimal.rst:2068
msgid ""
"Q. There are many ways to express the same value.  The numbers :const:"
"`200`, :const:`200.000`, :const:`2E2`, and :const:`.02E+4` all have the same "
"value at various precisions. Is there a way to transform them to a single "
"recognizable canonical value?"
msgstr ""

#: library/decimal.rst:2073
msgid ""
"A. The :meth:`normalize` method maps all equivalent values to a single "
"representative:"
msgstr ""

#: library/decimal.rst:2080
msgid ""
"Q. Some decimal values always print with exponential notation.  Is there a "
"way to get a non-exponential representation?"
msgstr ""

#: library/decimal.rst:2083
msgid ""
"A. For some values, exponential notation is the only way to express the "
"number of significant places in the coefficient.  For example, expressing :"
"const:`5.0E+3` as :const:`5000` keeps the value constant but cannot show the "
"original's two-place significance."
msgstr ""

#: library/decimal.rst:2088
msgid ""
"If an application does not care about tracking significance, it is easy to "
"remove the exponent and trailing zeroes, losing significance, but keeping "
"the value unchanged:"
msgstr ""

#: library/decimal.rst:2098
msgid "Q. Is there a way to convert a regular float to a :class:`Decimal`?"
msgstr ""

#: library/decimal.rst:2100
msgid ""
"A. Yes, any binary floating point number can be exactly expressed as a "
"Decimal though an exact conversion may take more precision than intuition "
"would suggest:"
msgstr ""

#: library/decimal.rst:2109
msgid ""
"Q. Within a complex calculation, how can I make sure that I haven't gotten a "
"spurious result because of insufficient precision or rounding anomalies."
msgstr ""

#: library/decimal.rst:2112
msgid ""
"A. The decimal module makes it easy to test results.  A best practice is to "
"re-run calculations using greater precision and with various rounding modes. "
"Widely differing results indicate insufficient precision, rounding mode "
"issues, ill-conditioned inputs, or a numerically unstable algorithm."
msgstr ""

#: library/decimal.rst:2117
msgid ""
"Q. I noticed that context precision is applied to the results of operations "
"but not to the inputs.  Is there anything to watch out for when mixing "
"values of different precisions?"
msgstr ""

#: library/decimal.rst:2121
msgid ""
"A. Yes.  The principle is that all values are considered to be exact and so "
"is the arithmetic on those values.  Only the results are rounded.  The "
"advantage for inputs is that \"what you type is what you get\".  A "
"disadvantage is that the results can look odd if you forget that the inputs "
"haven't been rounded:"
msgstr ""

#: library/decimal.rst:2134
msgid ""
"The solution is either to increase precision or to force rounding of inputs "
"using the unary plus operation:"
msgstr ""

#: library/decimal.rst:2143
msgid ""
"Alternatively, inputs can be rounded upon creation using the :meth:`Context."
"create_decimal` method:"
msgstr ""

#: library/decimal.rst:2149
msgid "Q. Is the CPython implementation fast for large numbers?"
msgstr ""

#: library/decimal.rst:2151
msgid ""
"A. Yes.  In the CPython and PyPy3 implementations, the C/CFFI versions of "
"the decimal module integrate the high speed `libmpdec <https://www.bytereef."
"org/mpdecimal/doc/libmpdec/index.html>`_ library for arbitrary precision "
"correctly rounded decimal floating point arithmetic [#]_. ``libmpdec`` uses "
"`Karatsuba multiplication <https://en.wikipedia.org/wiki/"
"Karatsuba_algorithm>`_ for medium-sized numbers and the `Number Theoretic "
"Transform <https://en.wikipedia.org/wiki/"
"Discrete_Fourier_transform_(general)#Number-theoretic_transform>`_ for very "
"large numbers."
msgstr ""

#: library/decimal.rst:2161
msgid ""
"The context must be adapted for exact arbitrary precision arithmetic. :attr:"
"`Emin` and :attr:`Emax` should always be set to the maximum values, :attr:"
"`clamp` should always be 0 (the default).  Setting :attr:`prec` requires "
"some care."
msgstr ""

#: library/decimal.rst:2165
msgid ""
"The easiest approach for trying out bignum arithmetic is to use the maximum "
"value for :attr:`prec` as well [#]_::"
msgstr ""

#: library/decimal.rst:2174
msgid ""
"For inexact results, :attr:`MAX_PREC` is far too large on 64-bit platforms "
"and the available memory will be insufficient::"
msgstr ""

#: library/decimal.rst:2182
msgid ""
"On systems with overallocation (e.g. Linux), a more sophisticated approach "
"is to adjust :attr:`prec` to the amount of available RAM.  Suppose that you "
"have 8GB of RAM and expect 10 simultaneous operands using a maximum of 500MB "
"each::"
msgstr ""

#: library/decimal.rst:2206
msgid ""
"In general (and especially on systems without overallocation), it is "
"recommended to estimate even tighter bounds and set the :attr:`Inexact` trap "
"if all calculations are expected to be exact."
msgstr ""

#: library/decimal.rst:2215
msgid ""
"This approach now works for all exact results except for non-integer powers."
msgstr ""