# 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-07-23 14:38+0200\n"

"PO-Revision-Date: 2024-12-13 23:59+0100\n"

"Last-Translator: Christophe Nanteuil <christophe.nanteuil@gmail.com>\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 3.2.2\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

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 par rapport 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 "

"``1.1`` and ``2.2`` do not have exact representations in binary floating "

"point. End users typically would not expect ``1.1 + 2.2`` to display as "

"``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 ``1.1`` ou ``1.2`` n'ont pas de "

"représentation exacte en base binaire flottante. L'utilisateur final ne "

"s'attend typiquement pas à obtenir ``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 ``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 à "

"``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 ``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 ``1.56`` while ``1.30 * "

"1.20`` gives ``1.5600``."

msgstr ""

"Le module ``decimal`` incorpore la notion de chiffres significatifs, de "

"façon à ce que ``1.30 + 1.20`` égale ``2.50``. Le dernier zéro est conservé "

"pour respecter le nombre de chiffres significatifs. C'est l'affichage "

"préféré pour représenter des sommes d'argent. Pour la multiplication, "

"l'approche « scolaire » utilise tous les chiffres présents dans les "

"facteurs. Par exemple, ``1.3 * 1.2`` donne ``1.56`` tandis que ``1.30 * "

"1.20`` donne ``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 des signaux 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 ``Infinity``, "

"``-Infinity``, and ``NaN``. The standard also differentiates ``-0`` from "

"``+0``."

msgstr ""

"Un ``Decimal`` est immuable. Il a un signe, une mantisse 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 ``Infinity``, ``-Infinity`` et ``NaN``. Le standard "

"fait également la différence entre ``-0`` et ``+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 correspondent à des états exceptionnels 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, à travers un drapeau (ou "

"option) et une surveillance. Quand une opération illégale survient, le "

"drapeau du signal est mis à ``1`` puis, s'il est surveillé, une exception "

"est levée. La mise à ``1`` du drapeau est persistante, l'utilisateur doit "

"donc remettre les drapeaux à zéro avant de commencer un calcul qu'il "

"souhaite surveiller."

#: library/decimal.rst:116

msgid ""

"IBM's General Decimal Arithmetic Specification, `The General Decimal "

"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."

msgstr ""

"Spécification d'IBM sur l'arithmétique décimale : `The General Decimal "

"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_ "

"(article en anglais)."

#: 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 ``NaN`` which stands for \"Not a number\", positive and "

"negative ``Infinity``, and ``-0``::"

msgstr ""

"Les instances de ``Decimal`` peuvent être construites avec des entiers, des "

"chaînes de caractères, des ``floats`` ou des *n*-uplets. 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 ``NaN`` qui signifie en anglais « *Not a number* », en français "

"« pas un nombre », des ``Infinity`` positifs ou négatifs et ``-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 le signal :exc:`FloatOperation` est surveillé, un mélange accidentel "

"d'objets ``Decimal`` et de ``float`` dans les constructeurs ou des "

"opérations de comparaison lève une exception ::"

#: 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 exemples 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:`~Decimal.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:`~Decimal.quantize` arrondit un nombre à un exposant "

"déterminé. Cette méthode est utile pour des applications monétaires qui "

"arrondissent souvent un résultat à un nombre déterminé de chiffres après la "

"virgule :"

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

"sont surveillés :"

#: 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:`~Context.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:`~Context.clear_flags`. ::"

#: library/decimal.rst:312

msgid ""

"The *flags* entry shows that the rational approximation to 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 π 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:`~Context.traps` "

"attribute of a context:"

msgstr ""

"La surveillance est activée en utilisant un dictionnaire dans l'attribut :"

"attr:`~Context.traps` du contexte :"

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

"converties une fois pour toutes en :class:`Decimal`. Une fois le ``Context`` "

"initialisé et les objets ``Decimal`` créés, la majeure partie du programme "

"manipule les données de la même manière qu'avec d'autres types numériques "

"Python."

#: library/decimal.rst:343

msgid "Decimal objects"

msgstr "Les objets :class:`!Decimal`"

#: library/decimal.rst:348

msgid "Construct a new :class:`Decimal` object based from *value*."

msgstr "Construit 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, un :"

"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ères, 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, dans les emplacements "

"``digit`` ci-dessus. 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 "

"(``0`` for positive or ``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:`n-uplet <tuple>`, il doit avoir trois éléments, le "

"signe (``0`` pour positif ou ``1`` pour négatif), un :class:`n-uplet "

"<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 le contexte 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 ``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 :const:"

"`InvalidOperation` est surveillé, une exception est levée, sinon le "

"constructeur renvoie un objet ``Decimal`` de valeur ``NaN``."

#: library/decimal.rst:392

msgid "Once constructed, :class:`Decimal` objects are immutable."

msgstr "Une fois construit, un objet :class:`Decimal` est immuable."

# suit un :

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

# suit un :

#: 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 :exc:`FloatOperation` est "

"surveillé. Par défaut la surveillance n'est pas activée."

# suit un :

#: 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 grouper des chiffres, 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 *dividende* 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, "

"renvoyant 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, tels que décrits 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 : toute addition entre un :class:`Decimal` et 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` et les autres types numériques. Cela évite d'avoir des résultats "

"absurdes lors des tests d'égalité entre différents types."

# suit un :

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

#: library/decimal.rst:448

msgid ""

"In addition to the standard numeric properties, decimal floating point "

"objects also have a number of specialized methods:"

msgstr ""

"En plus des propriétés numériques standard, les objets décimaux à virgule "

"flottante ont également un certain nombre de méthodes spécialisées :"

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

"Renvoie l'exposant ajusté après avoir décalé les chiffres les plus à droite "

"de la mantisse jusqu'à ce qu'il ne reste que le premier chiffre : "

"``Decimal('321e+5').adjusted()`` renvoie sept. Utilisée pour déterminer la "

"position du chiffre le plus significatif par rapport à la virgule."

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

"Renvoie un couple d'entiers ``(n, d)`` qui représentent l'instance :class:"

"`Decimal` donnée sous la forme d'une fraction, avec les termes les plus "

"petits possibles et avec un dénominateur positif ::"

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

#: library/decimal.rst:475

msgid ""

"Return a :term:`named tuple` representation of the number: "

"``DecimalTuple(sign, digits, exponent)``."

msgstr ""

"Renvoie une représentation sous la forme d'un :term:`n-uplet nommé <named "

"tuple>` du nombre ``DecimalTuple(sign, digits, exponent)``."

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

"Renvoie la forme canonique de l'argument. Actuellement, la forme d'une "

"instance :class:`Decimal` est toujours canonique, donc cette opération "

"renvoie son argument inchangé."

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

"Compare les valeurs de deux instances :class:`!Decimal`. :meth:`compare` "

"renvoie une instance :class:`!Decimal` et, si l'un des opérandes est un "

"*NaN*, alors le résultat est un *NaN* ::"

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

"Cette opération est identique à la méthode :meth:`compare`, sauf que tous "

"les *NaN* sont surveillés. Autrement dit, si aucun des opérandes n'est un "

"*NaN* de signalisation, alors tout opérande *NaN* silencieux est traité "

"comme s'il s'agissait d'un *NaN* de signalisation."

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

"Compare deux opérandes en utilisant leur représentation abstraite plutôt que "

"leur valeur numérique. Similaire à la méthode :meth:`compare`, mais le "

"résultat donne un ordre total sur les instances :class:`Decimal`. Deux "

"instances de :class:`Decimal` avec la même valeur numérique mais des "

"représentations différentes se comparent de manière inégale dans cet ordre :"

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

"Les *NaN* silencieux et de signalisation sont également inclus dans l'ordre "

"total. Le résultat de cette fonction est ``Decimal('0')`` si les deux "

"opérandes ont la même représentation, ``Decimal('-1')`` si le premier "

"opérande est inférieur au second, et ``Decimal('1')`` si le premier opérande "

"est supérieur au deuxième opérande. Voir les spécifications pour les détails "

"de l'ordre total."

#: library/decimal.rst:531 library/decimal.rst:846

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 ""

"Cette opération ne dépend pas du contexte et est silencieuse : aucun "

"indicateur n'est modifié et aucun arrondi n'est effectué. "

"Exceptionnellement, la version C peut lever une *InvalidOperation* si le "

"deuxième opérande ne peut pas être converti exactement."

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

"Compare deux opérandes en utilisant leur représentation abstraite plutôt que "

"leur valeur comme dans :meth:`compare_total`, mais en ignorant le signe de "

"chaque opérande. ``x.compare_total_mag(y)`` est équivalent à ``x.copy_abs()."

"compare_total(y.copy_abs())``."

#: library/decimal.rst:537

msgid ""

"Just returns self, this method is only to comply with the Decimal "

"Specification."

msgstr ""

"Ne fait que renvoyer self ; cette méthode existe uniquement pour se "

"conformer à la spécification."

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

"Renvoie la valeur absolue de l'argument. Cette opération ne dépend pas du "

"contexte et est silencieuse : aucun drapeau n'est modifié et aucun arrondi "

"n'est effectué."

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

"Renvoie l'opposé de l'argument. Cette opération ne dépend pas du contexte et "

"est silencieuse : aucun drapeau n'est modifié et aucun arrondi n'est "

"effectué."

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

"Renvoie une copie du premier opérande mais avec le même signe que celui du "

"deuxième opérande. Par exemple :"

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

"Renvoie la valeur ``e**x`` (fonction exponentielle) du nombre donné. Le "

"résultat est correctement arrondi en utilisant le mode d'arrondi :const:"

"`ROUND_HALF_EVEN`."

#: library/decimal.rst:576

msgid ""

"Alternative constructor that only accepts instances of :class:`float` or :"

"class:`int`."

msgstr ""

"Constructeur alternatif qui n'accepte que les instances de :class:`float` "

"ou :class:`int`."

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

"Remarquez que ``Decimal.from_float(0.1)`` est différent de "

"``Decimal('0.1')``. Puisque 0.1 n'est pas exactement représentable en "

"virgule flottante binaire, la valeur est stockée comme la valeur "

"représentable la plus proche qui est ``0x1.999999999999ap-4``. La valeur "

"équivalente en décimal est "

"``0.1000000000000000055511151231257827021181583404541015625``."

# suit un :

#: library/decimal.rst:585

msgid ""

"From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed "

"directly from a :class:`float`."

msgstr ""

"depuis Python 3.2, une instance :class:`Decimal` peut également être "

"construite directement à partir d'un :class:`float`."

#: library/decimal.rst:603

msgid ""

"Fused multiply-add. Return self*other+third with no rounding of the "

"intermediate product self*other."

msgstr ""

"Multiplier-ajouter fusionné. Renvoie ``self*other+third`` sans arrondir le "

"produit intermédiaire ``self*other``."

#: 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 un *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, :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* (signalisé ou silencieux), :"

"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 ""

"Renvoie :const:`True` si l'argument est un nombre fini *normal*. Renvoie :"

"const:`False` si l'argument est zéro, infini, un nombre dénormalisé ou un "

"*NaN*."

#: 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, :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, :const:`False` sinon. "

"Remarquez que les zéros et les *NaN* 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* signalisé, :const:`False` "

"sinon."

#: library/decimal.rst:652

msgid ""

"Return :const:`True` if the argument is subnormal, and :const:`False` "

"otherwise."

msgstr ""

"Renvoie :const:`True` si l'argument est le résultat d'un dépassement par "

"valeur inférieure, :const:`False` sinon."

#: 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), :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 ""

"Pour un nombre non nul, renvoie l'exposant ajusté de son opérande en tant "

"qu'instance :class:`Decimal`. Si l'opérande est un zéro alors ``Decimal('-"

"Infinity')`` est renvoyé et le drapeau :const:`DivisionByZero` est levé. Si "

"l'opérande est un infini alors ``Decimal('Infinity')`` est renvoyé."

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

":meth:`logical_and` est une opération logique qui prend deux *opérandes "

"logiques* (voir :ref:`logical_operands_label`). Le résultat est le *ET* des "

"chiffres des deux opérandes."

#: library/decimal.rst:686

msgid ""

":meth:`logical_invert` is a logical operation. The result is the digit-wise "

"inversion of the operand."

msgstr ""

":meth:`logical_invert` est une opération logique. Le résultat est "

"l'inversion de chacun des chiffres de l'opérande."

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

":meth:`logical_or` est une opération logique qui prend deux *opérandes "

"logiques* (voir :ref:`logical_operands_label`). Le résultat est le *OU* des "

"chiffres des deux opérandes."

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

":meth:`logical_xor` est une opération logique qui prend deux *opérandes "

"logiques* (voir :ref:`logical_operands_label`). Le résultat est le *OU "

"EXCLUSIF* des chiffres des deux opérandes."

#: library/decimal.rst:703

msgid ""

"Like ``max(self, other)`` except that the context rounding rule is applied "

"before returning and that ``NaN`` values are either signaled or ignored "

"(depending on the context and whether they are signaling or quiet)."

msgstr ""

"Comme ``max(self, other)`` sauf que la règle d'arrondi de *context* est "

"appliquée avant le retour et les valeurs ``NaN`` sont signalées ou ignorées "

"(selon le contexte et suivant qu'elles sont signalisées ou silencieuses)."

#: library/decimal.rst:710

msgid ""

"Similar to the :meth:`.max` method, but the comparison is done using the "

"absolute values of the operands."

msgstr ""

"Semblable à la méthode :meth:`.max`, mais la comparaison est effectuée en "

"utilisant les valeurs absolues des opérandes."

#: library/decimal.rst:715

msgid ""

"Like ``min(self, other)`` except that the context rounding rule is applied "

"before returning and that ``NaN`` values are either signaled or ignored "

"(depending on the context and whether they are signaling or quiet)."

msgstr ""

"Comme ``min(self, other)`` sauf que la règle d'arrondi de *context* est "

"appliquée avant le retour et les valeurs ``NaN`` sont signalées ou ignorées "

"(selon le contexte et suivant qu'elles sont signalisées ou silencieuses)."

#: library/decimal.rst:722

msgid ""

"Similar to the :meth:`.min` method, but the comparison is done using the "

"absolute values of the operands."

msgstr ""

"Semblable à la méthode :meth:`.min`, mais la comparaison est effectuée en "

"utilisant les valeurs absolues des opérandes."

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

"Renvoie le plus grand nombre représentable dans le *context* donné (ou dans "

"le contexte du fil d'exécution actuel si aucun contexte n'est donné) qui est "

"plus petit que l'opérande donné."

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

"Renvoie le plus petit nombre représentable dans le *context* donné (ou dans "

"le contexte du fil d'exécution actuel si aucun contexte n'est donné) qui est "

"supérieur à l'opérande donné."

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

"Si les deux opérandes ne sont pas égaux, renvoie le nombre le plus proche du "

"premier opérande dans la direction du deuxième opérande. Si les deux "

"opérandes sont numériquement égaux, renvoie une copie du premier opérande "

"avec le signe défini comme étant le même que le signe du second opérande."

#: library/decimal.rst:746

msgid ""

"Used for producing canonical values of an equivalence class within either "

"the current context or the specified context."

msgstr ""