# 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-04-14 13:19+0200\n" "PO-Revision-Date: 2023-05-20 20:21+0200\n" "Last-Translator: Christophe Nanteuil \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 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, 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 ``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 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, à travers un drapeau (ou " "option) et un activateur de déroutement. Quand une opération illégale " "survient, le drapeau du signal est mis à ``1`` puis, si l'activateur est " "configuré, 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 `_." msgstr "" "Spécification d'IBM sur l'arithmétique décimale : `The General Decimal " "Arithmetic Specification `_ " "(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 activé pour déroutement, 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 " "ont leur déroutement activé :" #: 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 "" "L'activation du déroutement se fait 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 *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 `, il doit avoir trois éléments, le " "signe (``0`` pour positif ou ``1`` pour négatif), un :class:`n-uplet " "` 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 le déroutement " "est activé pour :const:`InvalidOperation`, 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 le déroutement est activé " "pour :exc:`FloatOperation`. Par défaut le déroutement n'est pas activé." # 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 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 *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 " "du coefficient 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é ` du nombre ``DecimalTuple(sign, digits, exposant)``." #: 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 *Decimal*. :meth:`compare` renvoie une " "instance *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* activent un déroutement. 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: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 "" "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 la négation 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* (signalétique 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, résultat d'un dépassement par " "valeur inférieure 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* signalétique, :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 que les valeurs ``NaN`` sont signalées ou " "ignorées (selon le contexte et si elles sont signalétiques 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 que les valeurs ``NaN`` sont signalées ou " "ignorées (selon le contexte et si elles sont signalétiques 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 "" "Normalize the number by stripping the rightmost trailing zeros and " "converting any result equal to ``Decimal('0')`` to ``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 "" "Normalise le nombre en supprimant les zéros de fin les plus à droite et en " "convertissant tout résultat égal à ``Decimal('0')`` en ``Decimal('0e0')``. " "Utilisé pour produire des valeurs canoniques pour les attributs d'une classe " "d'équivalence. Par exemple, ``Decimal('32.100')`` et ``Decimal('0.321000e" "+2')`` sont tous deux normalisés à la valeur équivalente ``Decimal('32.1')``." #: 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 "" "Renvoie une chaîne décrivant la *classe* de l'opérande. La valeur renvoyée " "est l'une des dix chaînes suivantes." # É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 ;" # Élément d'une liste, d'où le ; final #: library/decimal.rst:759 msgid "" "``\"-Normal\"``, indicating that the operand is a negative normal number." msgstr "" "``\"-Normal\"``, indiquant que l'opérande est un nombre négatif normal ;" # Élément d'une liste, d'où le ; final #: library/decimal.rst:760 msgid "" "``\"-Subnormal\"``, indicating that the operand is negative and subnormal." msgstr "" "``\"-Subnormal\"``, indiquant que l'opérande est négatif et qu'il est le " "résultat d'un dépassement par valeur inférieure ;" # É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 ;" # Élément d'une liste, d'où le ; final #: library/decimal.rst:763 msgid "" "``\"+Subnormal\"``, indicating that the operand is positive and subnormal." msgstr "" "``\"+Subnormal\"``, indiquant que l'opérande est positif et qu'il est le " "résultat un dépassement par valeur inférieure ;" #: library/decimal.rst:764 msgid "" "``\"+Normal\"``, indicating that the operand is a positive normal number." msgstr "" "``\"+Normal\"``, indiquant que l'opérande est un nombre positif normal ;" # É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 "" "Renvoie une valeur égale au premier opérande après arrondi et ayant " "l'exposant du second opérande." #: 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 "" "Contrairement aux autres opérations, si la longueur du coefficient après " "l'opération de quantification est supérieure à la précision, alors une :" "const:`InvalidOperation` est signalée. Ceci garantit que, sauf condition " "d'erreur, l'exposant quantifié est toujours égal à celui de l'opérande de " "droite." #: library/decimal.rst:783 msgid "" "Also unlike other operations, quantize never signals Underflow, even if the " "result is subnormal and inexact." msgstr "" "Contrairement aux autres opérations, la quantification ne signale jamais de " "dépassement par valeur inférieure, même si le résultat est inférieur à la " "valeur minimale représentable et inexact." #: 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 "" "Si l'exposant du deuxième opérande est supérieur à celui du premier, un " "arrondi peut être nécessaire. Dans ce cas, le mode d'arrondi est déterminé " "par l'argument ``rounding`` s'il est donné, sinon par l'argument ``context`` " "donné ; si aucun argument n'est donné, le mode d'arrondi du contexte du fil " "d'exécution courant est utilisé." #: library/decimal.rst:792 msgid "" "An error is returned whenever the resulting exponent is greater than :attr:" "`~Context.Emax` or less than :meth:`~Context.Etiny`." msgstr "" "Une erreur est renvoyée chaque fois que l'exposant résultant est supérieur " "à :attr:`~Context.Emax` ou inférieur à :meth:`~Context.Etiny`." #: 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 "" "Renvoie ``Decimal(10)``, la base (base) dans laquelle la classe :class:" "`Decimal` fait toute son arithmétique. Inclus pour la compatibilité avec la " "spécification." #: 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 "" "Renvoie le reste de la division de *self* par *other*. La différence avec " "``self % other`` réside dans le signe du reste, qui est choisi de manière à " "minimiser sa valeur absolue. Plus précisément, la valeur de retour est " "``self - n * other`` où ``n`` est l'entier le plus proche de la valeur " "exacte de ``self / other`` et, si deux entiers sont également proches, alors " "l'entier pair est choisi." #: library/decimal.rst:810 msgid "If the result is zero then its sign will be the sign of *self*." msgstr "Si le résultat est zéro, alors son signe est le signe de *self*." #: 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 "" "Renvoie le résultat de la rotation des chiffres du premier opérande d'une " "quantité spécifiée par le deuxième opérande. Le deuxième opérande doit être " "un entier compris dans la plage -précision à précision. La valeur absolue du " "deuxième opérande donne le nombre de rotations unitaires à faire. Si le " "deuxième opérande est positif alors la rotation se fait vers la gauche ; " "sinon la rotation se fait vers la droite. Le coefficient du premier opérande " "est complété à gauche avec des zéros à la précision de la longueur si " "nécessaire. Le signe et l'exposant du premier opérande sont inchangés." #: library/decimal.rst:832 msgid "" "Test whether self and other have the same exponent or whether both are " "``NaN``." msgstr "" "Teste si *self* et *other* ont le même exposant ou si les deux sont ``NaN``." #: 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 "" "Renvoie le premier opérande avec l'exposant ajusté par le second. De manière " "équivalente, renvoie le premier opérande multiplié par ``10**other``. Le " "deuxième opérande doit être entier." #: 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 "" "Renvoie le résultat du décalage des chiffres du premier opérande d'une " "quantité spécifiée par le deuxième opérande. Le deuxième opérande doit être " "un entier compris dans la plage -précision à précision. La valeur absolue du " "deuxième opérande donne le nombre de décalages unitaires à effectuer. Si le " "deuxième opérande est positif alors le décalage est vers la gauche ; sinon " "le décalage est vers la droite. Les chiffres insérés dans le nombre par le " "décalage sont des zéros. Le signe et l'exposant du premier opérande sont " "inchangés." #: library/decimal.rst:857 msgid "Return the square root of the argument to full precision." msgstr "Renvoie la racine carrée de l'argument avec une précision maximale." #: library/decimal.rst:1457 msgid "" "Convert to a string, using engineering notation if an exponent is needed." msgstr "" "Convertir en chaîne, en utilisant la notation ingénieur si un exposant est " "nécessaire." #: 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 "" "La notation ingénieur possède un exposant qui est un multiple de 3. Cela " "peut laisser jusqu'à 3 chiffres à gauche de la décimale et peut nécessiter " "l'ajout d'un ou de deux zéros à la fin." #: library/decimal.rst:868 msgid "" "For example, this converts ``Decimal('123E+1')`` to ``Decimal('1.23E+3')``." msgstr "" "Par exemple, ``Decimal('123E+1')`` est converti en ``Decimal('1.23E+3')``." #: 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 "" "Identique à la méthode :meth:`to_integral_value`. Le nom ``to_integral`` a " "été conservé pour la compatibilité avec les anciennes versions." #: 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 "" "Arrondit à l'entier le plus proche, en signalant :const:`Inexact` ou :const:" "`Rounded` selon le cas si l'arrondi se produit. Le mode d'arrondi est " "déterminé par le paramètre ``rounding`` s'il est donné, sinon par le " "``context`` donné. Si aucun paramètre n'est donné, le mode d'arrondi du " "contexte courant est utilisé." #: 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 "" "Arrondit à l'entier le plus proche sans signaler :const:`Inexact` ou :const:" "`Rounded`. Si donné, applique *rounding* ; sinon, utilise la méthode " "d'arrondi dans le *context* fourni ou dans le contexte actuel." #: library/decimal.rst:893 msgid "Logical operands" msgstr "Opérandes logiques" #: library/decimal.rst:895 msgid "" "The :meth:`~Decimal.logical_and`, :meth:`~Decimal.logical_invert`, :meth:" "`~Decimal.logical_or`, and :meth:`~Decimal.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 ``0`` or ``1``." msgstr "" "Les méthodes :meth:`~Decimal.logical_and`, :meth:`~Decimal.logical_invert`, :" "meth:`~Decimal.logical_or` et :meth:`~Decimal.logical_xor` s'attendent à ce " "que leurs arguments soient des *opérandes logiques*. Un *opérande logique* " "est une instance :class:`Decimal` dont l'exposant et le signe sont tous les " "deux zéro et dont les chiffres sont tous ``0`` ou ``1``." #: library/decimal.rst:907 msgid "Context objects" msgstr "Objets de contexte" #: 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 "" "Les contextes sont des environnements pour les opérations arithmétiques. Ils " "régissent la précision, établissent des règles d'arrondi, déterminent quels " "signaux sont traités comme des exceptions et limitent la plage des exposants." #: 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 "" "Chaque fil d'exécution a son propre contexte actuel qui est accessible ou " "modifié à l'aide des fonctions :func:`getcontext` et :func:`setcontext` :" #: library/decimal.rst:919 msgid "Return the current context for the active thread." msgstr "Renvoie le contexte actuel du fil d'exécution courant." #: library/decimal.rst:924 msgid "Set the current context for the active thread to *c*." msgstr "Définit le contexte du fil d'exécution courant à *c*." #: 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 "" "Vous pouvez également utiliser l'instruction :keyword:`with` et la fonction :" "func:`localcontext` pour modifier temporairement le contexte actif." #: 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 "" "Renvoie un gestionnaire de contexte qui définira le contexte actuel du fil " "d'exécution actif sur une copie de *ctx* à l'entrée de l'instruction *with* " "et restaurera le contexte précédent lors de la sortie de l'instruction " "*with*. Si aucun contexte n'est spécifié, une copie du contexte actuel est " "utilisée. L'argument *kwargs* est utilisé pour définir les attributs du " "nouveau contexte." #: 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 "" "Par exemple, le code suivant définit la précision décimale actuelle à 42 " "chiffres, effectue un calcul, puis restaure automatiquement le contexte " "précédent ::" #: library/decimal.rst:947 msgid "Using keyword arguments, the code would be the following::" msgstr "En utilisant des arguments nommés, le code serait le suivant ::" #: 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 "" "Lève :exc:`TypeError` si *kwargs* fournit un attribut que :class:`Context` " "ne prend pas en charge. Lève soit :exc:`TypeError` ou :exc:`ValueError` si " "*kwargs* fournit une valeur invalide pour un attribut." #: library/decimal.rst:959 msgid "" ":meth:`localcontext` now supports setting context attributes through the use " "of keyword arguments." msgstr "" ":meth:`localcontext` prend désormais en charge la définition des attributs " "de contexte grâce à l'utilisation d'arguments nommés." #: 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 "" "De nouveaux contextes peuvent également être créés à l'aide du constructeur :" "class:`Context` décrit ci-dessous. De plus, le module fournit trois " "contextes prédéfinis :" #: 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 "" "Il s'agit d'un contexte standard défini par la *General Decimal Arithmetic " "Specification*. La précision est fixée à neuf. L'arrondi est défini sur :" "const:`ROUND_HALF_UP`. Tous les drapeaux sont effacés. Tous les déroutements " "sont activés (ils lèvent des exceptions) sauf :const:`Inexact`, :const:" "`Rounded` et :const:`Subnormal`." #: library/decimal.rst:974 msgid "" "Because many of the traps are enabled, this context is useful for debugging." msgstr "" "Étant donné que de nombreuses options de déroutement sont activées, ce " "contexte est utile pour le débogage." #: 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 "" "Il s'agit d'un contexte standard défini par la *General Decimal Arithmetic " "Specification*. La précision est fixée à neuf. L'arrondi est défini sur :" "const:`ROUND_HALF_EVEN`. Toutes les options de déroutement sont désactivées " "(afin que les exceptions ne soient pas levées pendant les calculs)." #: library/decimal.rst:984 msgid "" "Because the traps are disabled, this context is useful for applications that " "prefer to have result value of ``NaN`` or ``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 "" "Comme les interruptions sont désactivées, ce contexte est utile pour les " "applications qui préfèrent avoir une valeur de résultat ``NaN`` ou " "``Infinity`` au lieu de lever des exceptions. Cela permet à une application " "de terminer une exécution en présence de conditions qui, autrement, " "arrêteraient le programme." #: 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 "" "Ce contexte est utilisé par le constructeur :class:`Context` comme prototype " "pour de nouveaux contextes. Changer un champ (par exemple la précision) a " "pour effet de changer la valeur par défaut pour les nouveaux contextes créés " "par le constructeur :class:`Context`." #: 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 "" "Ce contexte est particulièrement utile dans les environnements à plusieurs " "fils d'exécution. La modification de l'un des champs avant le démarrage des " "fils a pour effet de définir des valeurs par défaut à l'échelle du système. " "La modification des champs après le démarrage des fils d'exécution n'est pas " "recommandée car cela nécessiterait une synchronisation des fils d'exécution " "pour éviter des conditions de concurrence." #: 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 "" "Dans les environnements à fil d'exécution unique, il est préférable de ne " "pas utiliser ce contexte du tout. Créez plutôt simplement des contextes " "explicitement comme décrit ci-dessous." #: library/decimal.rst:1004 msgid "" "The default values are :attr:`Context.prec`\\ =\\ ``28``, :attr:`Context." "rounding`\\ =\\ :const:`ROUND_HALF_EVEN`, and enabled traps for :class:" "`Overflow`, :class:`InvalidOperation`, and :class:`DivisionByZero`." msgstr "" "Les valeurs par défaut sont :attr:`Context.prec`\\ =\\ ``28``, :attr:" "`Context.rounding`\\ =\\ :const:`ROUND_HALF_EVEN` et les interruptions sont " "activées pour :class:`Overflow`, :class:`InvalidOperation` et :class:" "`DivisionByZero`." #: library/decimal.rst:1009 msgid "" "In addition to the three supplied contexts, new contexts can be created with " "the :class:`Context` constructor." msgstr "" "En plus des trois contextes fournis, de nouveaux contextes peuvent être " "créés avec le constructeur :class:`Context`." #: 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 [``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`, " "``0``], *Emax* in the range [``0``, :const:`MAX_EMAX`]." msgstr "" #: library/decimal.rst:1032 msgid "" "The *capitals* field is either ``0`` or ``1`` (the default). If set to " "``1``, exponents are printed with a capital ``E``; otherwise, a lowercase " "``e`` is used: ``Decimal('6.02e+23')``." msgstr "" #: library/decimal.rst:1036 msgid "" "The *clamp* field is either ``0`` (the default) or ``1``. If set to ``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 ``0`` then a weaker condition holds: the adjusted " "exponent of the :class:`Decimal` instance is at most :attr:`~Context.Emax`. " "When *clamp* is ``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 ``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:`~Decimal.adjusted` and :meth:" "`~Decimal.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 ``0``." msgstr "" #: library/decimal.rst:1071 msgid "Resets all of the traps to ``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 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), ``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, ``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, ``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 "Renvoie 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 la 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 "``425000000``" msgstr "``425000000``" #: library/decimal.rst:1488 msgid "``999999999999999999``" msgstr "``999999999999999999``" #: library/decimal.rst:1490 msgid "``-425000000``" msgstr "``-425000000``" #: library/decimal.rst:1490 msgid "``-999999999999999999``" msgstr "``-999999999999999999``" #: library/decimal.rst:1492 msgid "``-849999999``" msgstr "``-849999999``" #: library/decimal.rst:1492 msgid "``-1999999999999999997``" msgstr "``-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 ``Infinity``." msgstr "" #: library/decimal.rst:1521 msgid "Round towards zero." msgstr "" #: library/decimal.rst:1525 msgid "Round towards ``-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:`~Context.Emin` and :attr:`~Context.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 ``Infinity`` or ``-" "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 ``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:`Context.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 ``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 ``5.00`` to ``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:`~Context.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 ``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 ``NaN``, ``sNaN``, ``-Infinity``, ``Infinity``, and two zeros, ``" "+0`` and ``-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 ``NaN``, or if the :exc:" "`InvalidOperation` signal is trapped, raise an exception. For example, " "``0/0`` returns ``NaN`` which means \"not a number\". This variety of " "``NaN`` is quiet and, once created, will flow through other computations " "always resulting in another ``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 ``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 ``NaN`` is involved. A test for equality where one of the operands " "is a quiet or signaling ``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 ``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 ``NaN`` were taken from " "the IEEE 854 standard (see Table 3 in section 5.7). To ensure strict " "standards-compliance, use the :meth:`~Decimal.compare` and :meth:`~Decimal." "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:`~Decimal.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:`~Decimal.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:`~Decimal.quantize` :" #: library/decimal.rst:2055 msgid "" "In developing fixed-point applications, it is convenient to define functions " "to handle the :meth:`~Decimal.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:" "`~Decimal.quantize` :" #: library/decimal.rst:2068 msgid "" "Q. There are many ways to express the same value. The numbers ``200``, " "``200.000``, ``2E2``, and ``.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:`~Decimal.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 " "``5.0E+3`` as ``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 `_ library for arbitrary precision " "correctly rounded decimal floating point arithmetic [#]_. ``libmpdec`` uses " "`Karatsuba multiplication `_ for medium-sized numbers and the `Number Theoretic " "Transform `_ for very " "large numbers." msgstr "" #: library/decimal.rst:2161 msgid "" "The context must be adapted for exact arbitrary precision arithmetic. :attr:" "`~Context.Emin` and :attr:`~Context.Emax` should always be set to the " "maximum values, :attr:`~Context.clamp` should always be 0 (the default). " "Setting :attr:`~Context.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:`~Context.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:`~Context.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 ""