forked from AFPy/python-docs-fr
1953 lines
71 KiB
Plaintext
1953 lines
71 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
||
# Copyright (C) 1990-2016, Python Software Foundation
|
||
# This file is distributed under the same license as the Python package.
|
||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
#
|
||
#, fuzzy
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 2.7\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2016-10-30 10:44+0100\n"
|
||
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||
"Language-Team: LANGUAGE <LL@li.org>\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
|
||
#: ../Doc/library/decimal.rst:3
|
||
msgid ":mod:`decimal` --- Decimal fixed point and floating point arithmetic"
|
||
msgstr ":mod:`decimal` --- Arithmétique décimale en virgule fixe et flottante"
|
||
|
||
#: ../Doc/library/decimal.rst:29
|
||
msgid ""
|
||
"The :mod:`decimal` module provides support for decimal floating point "
|
||
"arithmetic. It offers several advantages over the :class:`float` datatype:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:32
|
||
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."
|
||
|
||
#: ../Doc/library/decimal.rst:37
|
||
msgid ""
|
||
"Decimal numbers can be represented exactly. In contrast, numbers like :"
|
||
"const:`1.1` and :const:`2.2` do not have exact representations in binary "
|
||
"floating point. End users typically would not expect ``1.1 + 2.2`` to "
|
||
"display as :const:`3.3000000000000003` as it does with binary floating point."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:42
|
||
msgid ""
|
||
"The exactness carries over into arithmetic. In decimal floating point, "
|
||
"``0.1 + 0.1 + 0.1 - 0.3`` is exactly equal to zero. In binary floating "
|
||
"point, the result is :const:`5.5511151231257827e-017`. While near to zero, "
|
||
"the differences prevent reliable equality testing and differences can "
|
||
"accumulate. For this reason, decimal is preferred in accounting applications "
|
||
"which have strict equality invariants."
|
||
msgstr ""
|
||
"Ces inexactitudes ont des conséquences en arithmétique. En base décimale à "
|
||
"virgule flottante, ``0.1 + 0.1 + 0.1 - 0.3`` est exactement égal à zéro. En "
|
||
"virgule flottante binaire, l'ordinateur l'évalue à :const:"
|
||
"`5.5511151231257827e-017`. Bien que très proche de zéro, cette différence "
|
||
"induit des erreurs lors des tests d'égalité, erreurs qui peuvent "
|
||
"s'accumuler. Pour ces raisons ``decimal`` est le module utilisé pour des "
|
||
"applications comptables ayant des contraintes strictes de fiabilité."
|
||
|
||
#: ../Doc/library/decimal.rst:49
|
||
msgid ""
|
||
"The decimal module incorporates a notion of significant places so that "
|
||
"``1.30 + 1.20`` is :const:`2.50`. The trailing zero is kept to indicate "
|
||
"significance. This is the customary presentation for monetary applications. "
|
||
"For multiplication, the \"schoolbook\" approach uses all the figures in the "
|
||
"multiplicands. For instance, ``1.3 * 1.2`` gives :const:`1.56` while ``1.30 "
|
||
"* 1.20`` gives :const:`1.5600`."
|
||
msgstr ""
|
||
"Le module ``decimal`` incorpore la notion de chiffres significatifs, tels "
|
||
"que ``1.30 + 1.20`` est égal à :const:`2.50`. Le dernier zéro n'est conservé "
|
||
"que pour respecter le nombre de chiffres significatifs. C'est également "
|
||
"l'affichage préféré pour représenter des sommes d'argent. Pour la "
|
||
"multiplication, l'approche « scolaire » utilise tout les chiffres présents "
|
||
"dans les facteurs. Par exemple, ``1.3 * 1.2`` donnerait :const:`1.56` tandis "
|
||
"que ``1.30 * 1.20`` donnerait :const:`1.5600`."
|
||
|
||
#: ../Doc/library/decimal.rst:56
|
||
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é :"
|
||
|
||
#: ../Doc/library/decimal.rst:68
|
||
msgid ""
|
||
"Both binary and decimal floating point are implemented in terms of published "
|
||
"standards. While the built-in float type exposes only a modest portion of "
|
||
"its capabilities, the decimal module exposes all required parts of the "
|
||
"standard. When needed, the programmer has full control over rounding and "
|
||
"signal handling. This includes an option to enforce exact arithmetic by "
|
||
"using exceptions to block any inexact operations."
|
||
msgstr ""
|
||
"L'arithmétique binaire et décimale en virgule flottante sont implémentées "
|
||
"selon des standards publiés. Alors que le type ``float`` n'expose qu'une "
|
||
"faible portion de ses capacités, le module ``decimal`` expose tous les "
|
||
"composants nécessaires du standard. Lorsque nécessaire, le développeur a un "
|
||
"contrôle total de la gestion de signal et de l'arrondi. Cela inclut la "
|
||
"possibilité de forcer une arithmétique exacte en utilisant des exceptions "
|
||
"pour bloquer toute opération inexacte."
|
||
|
||
#: ../Doc/library/decimal.rst:75
|
||
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)."
|
||
|
||
#: ../Doc/library/decimal.rst:80
|
||
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."
|
||
|
||
#: ../Doc/library/decimal.rst:83
|
||
msgid ""
|
||
"A decimal number is immutable. It has a sign, coefficient digits, and an "
|
||
"exponent. To preserve significance, the coefficient digits do not truncate "
|
||
"trailing zeros. Decimals also include special values such as :const:"
|
||
"`Infinity`, :const:`-Infinity`, and :const:`NaN`. The standard also "
|
||
"differentiates :const:`-0` from :const:`+0`."
|
||
msgstr ""
|
||
"Un ``Decimal`` est immuable. Il a un signe, un coefficient, et un exposant. "
|
||
"Pour préserver le nombre de chiffres significatifs, les zéros en fin de "
|
||
"chaîne ne sont pas tronqués. Les décimaux incluent aussi des valeurs "
|
||
"spéciales telles que :const:`Infinity`, :const:`-Infinity`, et :const:`NaN`. "
|
||
"Le standard fait également la différence entre :const:`-0` et :const:`+0`."
|
||
|
||
#: ../Doc/library/decimal.rst:89
|
||
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`."
|
||
|
||
#: ../Doc/library/decimal.rst:96
|
||
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`, and :const:`Underflow`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:103
|
||
msgid ""
|
||
"For each signal there is a flag and a trap enabler. When a signal is "
|
||
"encountered, its flag is set to one, then, if the trap enabler is set to "
|
||
"one, an exception is raised. Flags are sticky, so the user needs to reset "
|
||
"them before monitoring a calculation."
|
||
msgstr ""
|
||
"Chaque signal est configurable indépendamment. Quand une opération illégale "
|
||
"survient, le signal est mis à ``1``, puis s'il est configuré pour, une "
|
||
"exception est levée. La mise à ``1`` est persistante, l'utilisateur doit "
|
||
"donc les remettre à zéro avant de commencer un calcul qu'il souhaite "
|
||
"surveiller."
|
||
|
||
#: ../Doc/library/decimal.rst:111
|
||
msgid ""
|
||
"IBM's General Decimal Arithmetic Specification, `The General Decimal "
|
||
"Arithmetic Specification <http://speleotrove.com/decimal/>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:120
|
||
msgid "Quick-start Tutorial"
|
||
msgstr "Introduction pratique"
|
||
|
||
#: ../Doc/library/decimal.rst:122
|
||
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 ::"
|
||
|
||
#: ../Doc/library/decimal.rst:134
|
||
msgid ""
|
||
"Decimal instances can be constructed from integers, strings, floats, or "
|
||
"tuples. Construction from an integer or a float performs an exact conversion "
|
||
"of the value of that integer or float. Decimal numbers include special "
|
||
"values such as :const:`NaN` which stands for \"Not a number\", positive and "
|
||
"negative :const:`Infinity`, and :const:`-0`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:158
|
||
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."
|
||
|
||
#: ../Doc/library/decimal.rst:175
|
||
msgid ""
|
||
"Decimals interact well with much of the rest of Python. Here is a small "
|
||
"decimal floating point flying circus:"
|
||
msgstr ""
|
||
"Les objets ``Decimal`` interagissent très bien avec le reste de Python. "
|
||
"Voici quelques exemple d'opérations avec des décimaux :"
|
||
|
||
#: ../Doc/library/decimal.rst:207
|
||
msgid "And some mathematical functions are also available to Decimal:"
|
||
msgstr ""
|
||
"Et certaines fonctions mathématiques sont également disponibles sur des "
|
||
"instances de ``Decimal`` :"
|
||
|
||
#: ../Doc/library/decimal.rst:219
|
||
msgid ""
|
||
"The :meth:`quantize` method rounds a number to a fixed exponent. This "
|
||
"method is useful for monetary applications that often round results to a "
|
||
"fixed number of places:"
|
||
msgstr ""
|
||
"La méthode :meth:`quantize` arrondit un nombre à un exposant fixe. Cette "
|
||
"méthode est utile pour des applications monétaires qui arrondissent souvent "
|
||
"un résultat à un nombre de chiffres significatifs exact :"
|
||
|
||
#: ../Doc/library/decimal.rst:228
|
||
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."
|
||
|
||
#: ../Doc/library/decimal.rst:232
|
||
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`."
|
||
|
||
#: ../Doc/library/decimal.rst:236
|
||
msgid ""
|
||
"In accordance with the standard, the :mod:`decimal` module provides two "
|
||
"ready to use standard contexts, :const:`BasicContext` and :const:"
|
||
"`ExtendedContext`. The former is especially useful for debugging because "
|
||
"many of the traps are enabled:"
|
||
msgstr ""
|
||
"En accord avec le standard, le module :mod:`decimal` fournit des objets "
|
||
"Context standards, :const:`BasicContext` et :const:`ExtendedContext`. Le "
|
||
"premier est particulièrement utile pour le débogage car beaucoup des pièges "
|
||
"sont activés dans cet objet."
|
||
|
||
#: ../Doc/library/decimal.rst:265
|
||
msgid ""
|
||
"Contexts also have signal flags for monitoring exceptional conditions "
|
||
"encountered during computations. The flags remain set until explicitly "
|
||
"cleared, so it is best to clear the flags before each set of monitored "
|
||
"computations by using the :meth:`clear_flags` method. ::"
|
||
msgstr ""
|
||
"Les objets ``Context`` ont aussi des options pour détecter des opérations "
|
||
"illégales lors des calculs. Ces options restent activées jusqu'à ce qu'elles "
|
||
"soit remises à zéro de manière explicite. Il convient donc de remettre à "
|
||
"zéro ces options avant chaque inspection de chaque calcul, avec la méthode :"
|
||
"meth:`clear_flags`. ::"
|
||
|
||
#: ../Doc/library/decimal.rst:278
|
||
msgid ""
|
||
"The *flags* entry shows that the rational approximation to :const:`Pi` was "
|
||
"rounded (digits beyond the context precision were thrown away) and that the "
|
||
"result is inexact (some of the discarded digits were non-zero)."
|
||
msgstr ""
|
||
"Les options montrent que l'approximation de :const:`Pi` par une fraction a "
|
||
"été arrondie (les chiffres au delà de la précision spécifiée par l'objet "
|
||
"Context ont été tronqués) et que le résultat est différent (certains des "
|
||
"chiffres tronqués étaient différents de zéro)."
|
||
|
||
#: ../Doc/library/decimal.rst:282
|
||
msgid ""
|
||
"Individual traps are set using the dictionary in the :attr:`traps` field of "
|
||
"a context:"
|
||
msgstr ""
|
||
"L'activation des pièges se fait en utilisant un dictionnaire dans "
|
||
"l'attribut :attr:`traps` de l'objet Context :"
|
||
|
||
#: ../Doc/library/decimal.rst:297
|
||
msgid ""
|
||
"Most programs adjust the current context only once, at the beginning of the "
|
||
"program. And, in many applications, data is converted to :class:`Decimal` "
|
||
"with a single cast inside a loop. With context set and decimals created, "
|
||
"the bulk of the program manipulates the data no differently than with other "
|
||
"Python numeric types."
|
||
msgstr ""
|
||
"La plupart des applications n'ajustent l'objet ``Context`` qu'une seule "
|
||
"fois, au démarrage. Et, dans beaucoup d'applications, les données sont "
|
||
"convertie une fois pour toutes en :class:`Decimal`. Une fois le ``Context`` "
|
||
"initialisé, et les objets ``Decimal`` créés, l'essentiel du programme "
|
||
"manipule la donnée de la même manière qu'avec les autres types numériques "
|
||
"Python."
|
||
|
||
#: ../Doc/library/decimal.rst:309
|
||
msgid "Decimal objects"
|
||
msgstr "Les objets Decimal"
|
||
|
||
#: ../Doc/library/decimal.rst:314
|
||
msgid "Construct a new :class:`Decimal` object based from *value*."
|
||
msgstr "Construire un nouvel objet :class:`Decimal` à partir de *value*."
|
||
|
||
#: ../Doc/library/decimal.rst:316
|
||
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 are removed::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:332
|
||
msgid ""
|
||
"If *value* is a unicode string then 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 ``u'\\uff10'`` through ``u'\\uff19'``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:338
|
||
msgid ""
|
||
"If *value* is a :class:`tuple`, it should have three components, a sign (:"
|
||
"const:`0` for positive or :const:`1` for negative), a :class:`tuple` of "
|
||
"digits, and an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), "
|
||
"-3))`` returns ``Decimal('1.414')``."
|
||
msgstr ""
|
||
"Si *value* est un :class:`tuple`, il doit avoir 3 éléments, le signe (:const:"
|
||
"`0` pour positif ou :const:`1` pour négatif), un :class:`tuple` de chiffres, "
|
||
"et un entier représentant l'exposant. Par exemple, ``Decimal((0, (1, 4, 1, "
|
||
"4), -3))`` construit l'objet ``Decimal('1.414')``."
|
||
|
||
#: ../Doc/library/decimal.rst:343
|
||
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')``."
|
||
|
||
#: ../Doc/library/decimal.rst:349
|
||
msgid ""
|
||
"The *context* precision does not affect how many digits are stored. That is "
|
||
"determined exclusively by the number of digits in *value*. For example, "
|
||
"``Decimal('3.00000')`` records all five zeros even if the context precision "
|
||
"is only three."
|
||
msgstr ""
|
||
"La précision spécifiée dans Context n'affecte pas le nombre de chiffres "
|
||
"stockés. Cette valeur est déterminée exclusivement par le nombre de chiffres "
|
||
"dans *value*. Par exemple, ``Decimal('3.00000')`` enregistre les 5 zéros "
|
||
"même si la précision du contexte est de 3."
|
||
|
||
#: ../Doc/library/decimal.rst:354
|
||
msgid ""
|
||
"The purpose of the *context* argument is determining what to do if *value* "
|
||
"is a malformed string. If the context traps :const:`InvalidOperation`, an "
|
||
"exception is raised; otherwise, the constructor returns a new Decimal with "
|
||
"the value of :const:`NaN`."
|
||
msgstr ""
|
||
"L'objectif de l'argument *context* est de déterminer ce que Python doit "
|
||
"faire si *value* est une chaîne avec un mauvais format. Si l'option :const:"
|
||
"`InvalidOperation` est activée, une exception est levée, sinon le "
|
||
"constructeur renvoie un objet ``Decimal`` avec la valeur :const:`NaN`."
|
||
|
||
#: ../Doc/library/decimal.rst:359
|
||
msgid "Once constructed, :class:`Decimal` objects are immutable."
|
||
msgstr "Une fois construit, les objets :class:`Decimal` sont immuables."
|
||
|
||
#: ../Doc/library/decimal.rst:361
|
||
msgid ""
|
||
"leading and trailing whitespace characters are permitted when creating a "
|
||
"Decimal instance from a string."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:365
|
||
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`."
|
||
|
||
#: ../Doc/library/decimal.rst:368
|
||
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:`long`)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:375
|
||
msgid ""
|
||
"There are some small differences between arithmetic on Decimal objects and "
|
||
"arithmetic on integers and floats. When the remainder operator ``%`` is "
|
||
"applied to Decimal objects, the sign of the result is the sign of the "
|
||
"*dividend* rather than the sign of the divisor::"
|
||
msgstr ""
|
||
"Il existe quelques différences mineures entre l'arithmétique entre les "
|
||
"objets décimaux et l'arithmétique avec les entiers et les ``float``. Quand "
|
||
"l'opérateur modulo ``%`` est appliqué sur des objets décimaux, le signe du "
|
||
"résultat est le signe du *dividend* plutôt que le signe du diviseur::"
|
||
|
||
#: ../Doc/library/decimal.rst:385
|
||
msgid ""
|
||
"The integer division operator ``//`` behaves analogously, returning the "
|
||
"integer part of the true quotient (truncating towards zero) rather than its "
|
||
"floor, so as to preserve the usual identity ``x == (x // y) * y + x % y``::"
|
||
msgstr ""
|
||
"L'opérateur division entière, ``//`` se comporte de la même manière, "
|
||
"retournant la partie entière du quotient, plutôt que son arrondi, de manière "
|
||
"à préserver l'identité d'Euclide ``x == (x // y) * y + x % y``::"
|
||
|
||
#: ../Doc/library/decimal.rst:394
|
||
msgid ""
|
||
"The ``%`` and ``//`` operators implement the ``remainder`` and ``divide-"
|
||
"integer`` operations (respectively) as described in the specification."
|
||
msgstr ""
|
||
"Les opérateurs ``//`` et ``%`` implémentent la division entière et le reste "
|
||
"(ou modulo), respectivement, tel que décrit dans la spécification."
|
||
|
||
#: ../Doc/library/decimal.rst:398
|
||
msgid ""
|
||
"Decimal objects cannot generally be combined with floats in arithmetic "
|
||
"operations: an attempt to add a :class:`Decimal` to a :class:`float`, for "
|
||
"example, will raise a :exc:`TypeError`. There's one exception to this rule: "
|
||
"it's possible to use Python's comparison operators to compare a :class:"
|
||
"`float` instance ``x`` with a :class:`Decimal` instance ``y``. Without this "
|
||
"exception, comparisons between :class:`Decimal` and :class:`float` instances "
|
||
"would follow the general rules for comparing objects of different types "
|
||
"described in the :ref:`expressions` section of the reference manual, leading "
|
||
"to confusing results."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:409
|
||
msgid ""
|
||
"A comparison between a :class:`float` instance ``x`` and a :class:`Decimal` "
|
||
"instance ``y`` now returns a result based on the values of ``x`` and ``y``. "
|
||
"In earlier versions ``x < y`` returned the same (arbitrary) result for any :"
|
||
"class:`Decimal` instance ``x`` and any :class:`float` instance ``y``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:416
|
||
msgid ""
|
||
"In addition to the standard numeric properties, decimal floating point "
|
||
"objects also have a number of specialized methods:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:422
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:430
|
||
msgid ""
|
||
"Return a :term:`named tuple` representation of the number: "
|
||
"``DecimalTuple(sign, digits, exponent)``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:433
|
||
msgid "Use a named tuple."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:439
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:447
|
||
msgid ""
|
||
"Compare the values of two Decimal instances. This operation behaves in the "
|
||
"same way as the usual comparison method :meth:`__cmp__`, except that :meth:"
|
||
"`compare` returns a Decimal instance rather than an integer, and if either "
|
||
"operand is a NaN then the result is a NaN::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:459
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:467
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:476
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:487
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:496
|
||
msgid ""
|
||
"Just returns self, this method is only to comply with the Decimal "
|
||
"Specification."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:503
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:511
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:518
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:524
|
||
msgid ""
|
||
"This operation is unaffected by the context and is quiet: no flags are "
|
||
"changed and no rounding is performed."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:531
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:544
|
||
msgid "Classmethod that converts a float to a decimal number, exactly."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:546
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:552
|
||
msgid ""
|
||
"From Python 2.7 onwards, a :class:`Decimal` instance can also be constructed "
|
||
"directly from a :class:`float`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:570
|
||
msgid ""
|
||
"Fused multiply-add. Return self*other+third with no rounding of the "
|
||
"intermediate product self*other."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:580
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:588
|
||
msgid ""
|
||
"Return :const:`True` if the argument is a finite number, and :const:`False` "
|
||
"if the argument is an infinity or a NaN."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:595
|
||
msgid ""
|
||
"Return :const:`True` if the argument is either positive or negative infinity "
|
||
"and :const:`False` otherwise."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:602
|
||
msgid ""
|
||
"Return :const:`True` if the argument is a (quiet or signaling) NaN and :"
|
||
"const:`False` otherwise."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:609
|
||
msgid ""
|
||
"Return :const:`True` if the argument is a *normal* finite non-zero number "
|
||
"with an adjusted exponent greater than or equal to *Emin*. Return :const:"
|
||
"`False` if the argument is zero, subnormal, infinite or a NaN. Note, the "
|
||
"term *normal* is used here in a different sense with the :meth:`normalize` "
|
||
"method which is used to create canonical values."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:619
|
||
msgid ""
|
||
"Return :const:`True` if the argument is a quiet NaN, and :const:`False` "
|
||
"otherwise."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:626
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:633
|
||
msgid ""
|
||
"Return :const:`True` if the argument is a signaling NaN and :const:`False` "
|
||
"otherwise."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:640
|
||
msgid ""
|
||
"Return :const:`True` if the argument is subnormal, and :const:`False` "
|
||
"otherwise. A number is subnormal is if it is nonzero, finite, and has an "
|
||
"adjusted exponent less than *Emin*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:648
|
||
msgid ""
|
||
"Return :const:`True` if the argument is a (positive or negative) zero and :"
|
||
"const:`False` otherwise."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:655
|
||
msgid ""
|
||
"Return the natural (base e) logarithm of the operand. The result is "
|
||
"correctly rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:662
|
||
msgid ""
|
||
"Return the base ten logarithm of the operand. The result is correctly "
|
||
"rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:669
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:679
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:687
|
||
msgid ""
|
||
":meth:`logical_invert` is a logical operation. The result is the digit-wise "
|
||
"inversion of the operand."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:694
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:702
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:710
|
||
msgid ""
|
||
"Like ``max(self, other)`` except that the context rounding rule is applied "
|
||
"before returning and that :const:`NaN` values are either signaled or ignored "
|
||
"(depending on the context and whether they are signaling or quiet)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:717
|
||
msgid ""
|
||
"Similar to the :meth:`.max` method, but the comparison is done using the "
|
||
"absolute values of the operands."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:724
|
||
msgid ""
|
||
"Like ``min(self, other)`` except that the context rounding rule is applied "
|
||
"before returning and that :const:`NaN` values are either signaled or ignored "
|
||
"(depending on the context and whether they are signaling or quiet)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:731
|
||
msgid ""
|
||
"Similar to the :meth:`.min` method, but the comparison is done using the "
|
||
"absolute values of the operands."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:738
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:746
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:754
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:763
|
||
msgid ""
|
||
"Normalize the number by stripping the rightmost trailing zeros and "
|
||
"converting any result equal to :const:`Decimal('0')` to :const:"
|
||
"`Decimal('0e0')`. Used for producing canonical values for attributes of an "
|
||
"equivalence class. For example, ``Decimal('32.100')`` and "
|
||
"``Decimal('0.321000e+2')`` both normalize to the equivalent value "
|
||
"``Decimal('32.1')``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:772
|
||
msgid ""
|
||
"Return a string describing the *class* of the operand. The returned value "
|
||
"is one of the following ten strings."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:775
|
||
msgid "``\"-Infinity\"``, indicating that the operand is negative infinity."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:776
|
||
msgid ""
|
||
"``\"-Normal\"``, indicating that the operand is a negative normal number."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:777
|
||
msgid ""
|
||
"``\"-Subnormal\"``, indicating that the operand is negative and subnormal."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:778
|
||
msgid "``\"-Zero\"``, indicating that the operand is a negative zero."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:779
|
||
msgid "``\"+Zero\"``, indicating that the operand is a positive zero."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:780
|
||
msgid ""
|
||
"``\"+Subnormal\"``, indicating that the operand is positive and subnormal."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:781
|
||
msgid ""
|
||
"``\"+Normal\"``, indicating that the operand is a positive normal number."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:782
|
||
msgid "``\"+Infinity\"``, indicating that the operand is positive infinity."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:783
|
||
msgid "``\"NaN\"``, indicating that the operand is a quiet NaN (Not a Number)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:784
|
||
msgid "``\"sNaN\"``, indicating that the operand is a signaling NaN."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:790
|
||
msgid ""
|
||
"Return a value equal to the first operand after rounding and having the "
|
||
"exponent of the second operand."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:796
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:802
|
||
msgid ""
|
||
"Also unlike other operations, quantize never signals Underflow, even if the "
|
||
"result is subnormal and inexact."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:805
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:811
|
||
msgid ""
|
||
"If *watchexp* is set (default), then an error is returned whenever the "
|
||
"resulting exponent is greater than :attr:`Emax` or less than :attr:`Etiny`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:817
|
||
msgid ""
|
||
"Return ``Decimal(10)``, the radix (base) in which the :class:`Decimal` class "
|
||
"does all its arithmetic. Included for compatibility with the specification."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:825
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:832
|
||
msgid "If the result is zero then its sign will be the sign of *self*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:843
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:856
|
||
msgid ""
|
||
"Test whether self and other have the same exponent or whether both are :"
|
||
"const:`NaN`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:861
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:869
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:881
|
||
msgid "Return the square root of the argument to full precision."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:886 ../Doc/library/decimal.rst:1458
|
||
msgid ""
|
||
"Convert to a string, using engineering notation if an exponent is needed."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:888 ../Doc/library/decimal.rst:1460
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:892
|
||
msgid ""
|
||
"For example, this converts ``Decimal('123E+1')`` to ``Decimal('1.23E+3')``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:896
|
||
msgid ""
|
||
"Identical to the :meth:`to_integral_value` method. The ``to_integral`` name "
|
||
"has been kept for compatibility with older versions."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:901
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:911
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:915
|
||
msgid ""
|
||
"renamed from ``to_integral`` to ``to_integral_value``. The old name remains "
|
||
"valid for compatibility."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:922
|
||
msgid "Logical operands"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:924
|
||
msgid ""
|
||
"The :meth:`logical_and`, :meth:`logical_invert`, :meth:`logical_or`, and :"
|
||
"meth:`logical_xor` methods expect their arguments to be *logical operands*. "
|
||
"A *logical operand* is a :class:`Decimal` instance whose exponent and sign "
|
||
"are both zero, and whose digits are all either :const:`0` or :const:`1`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:936
|
||
msgid "Context objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:938
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:942
|
||
msgid ""
|
||
"Each thread has its own current context which is accessed or changed using "
|
||
"the :func:`getcontext` and :func:`setcontext` functions:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:948
|
||
msgid "Return the current context for the active thread."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:953
|
||
msgid "Set the current context for the active thread to *c*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:955
|
||
msgid ""
|
||
"Beginning with Python 2.5, you can also use the :keyword:`with` statement "
|
||
"and the :func:`localcontext` function to temporarily change the active "
|
||
"context."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:961
|
||
msgid ""
|
||
"Return a context manager that will set the current context for the active "
|
||
"thread to a copy of *c* 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."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:968
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:982
|
||
msgid ""
|
||
"New contexts can also be created using the :class:`Context` constructor "
|
||
"described below. In addition, the module provides three pre-made contexts:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:988
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:994
|
||
msgid ""
|
||
"Because many of the traps are enabled, this context is useful for debugging."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:999
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1004
|
||
msgid ""
|
||
"Because the traps are disabled, this context is useful for applications that "
|
||
"prefer to have result value of :const:`NaN` or :const:`Infinity` instead of "
|
||
"raising exceptions. This allows an application to complete a run in the "
|
||
"presence of conditions that would otherwise halt the program."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1012
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1016
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1021
|
||
msgid ""
|
||
"In single threaded environments, it is preferable to not use this context at "
|
||
"all. Instead, simply create contexts explicitly as described below."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1024
|
||
msgid ""
|
||
"The default values are precision=28, rounding=ROUND_HALF_EVEN, and enabled "
|
||
"traps for Overflow, InvalidOperation, and DivisionByZero."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1027
|
||
msgid ""
|
||
"In addition to the three supplied contexts, new contexts can be created with "
|
||
"the :class:`Context` constructor."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1033
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1037
|
||
msgid ""
|
||
"The *prec* field is a positive integer that sets the precision for "
|
||
"arithmetic operations in the context."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1040
|
||
msgid "The *rounding* option is one of:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1042
|
||
msgid ":const:`ROUND_CEILING` (towards :const:`Infinity`),"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1043
|
||
msgid ":const:`ROUND_DOWN` (towards zero),"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1044
|
||
msgid ":const:`ROUND_FLOOR` (towards :const:`-Infinity`),"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1045
|
||
msgid ":const:`ROUND_HALF_DOWN` (to nearest with ties going towards zero),"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1046
|
||
msgid ""
|
||
":const:`ROUND_HALF_EVEN` (to nearest with ties going to nearest even "
|
||
"integer),"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1047
|
||
msgid ":const:`ROUND_HALF_UP` (to nearest with ties going away from zero), or"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1048
|
||
msgid ":const:`ROUND_UP` (away from zero)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1049
|
||
msgid ""
|
||
":const:`ROUND_05UP` (away from zero if last digit after rounding towards "
|
||
"zero would have been 0 or 5; otherwise towards zero)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1052
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1055
|
||
msgid ""
|
||
"The *Emin* and *Emax* fields are integers specifying the outer limits "
|
||
"allowable for exponents."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1058
|
||
msgid ""
|
||
"The *capitals* field is either :const:`0` or :const:`1` (the default). If "
|
||
"set to :const:`1`, exponents are printed with a capital :const:`E`; "
|
||
"otherwise, a lowercase :const:`e` is used: :const:`Decimal('6.02e+23')`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1062
|
||
msgid "The :const:`ROUND_05UP` rounding mode was added."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1065
|
||
msgid ""
|
||
"The :class:`Context` class defines several general purpose methods as well "
|
||
"as a large number of methods for doing arithmetic directly in a given "
|
||
"context. In addition, for each of the :class:`Decimal` methods described "
|
||
"above (with the exception of the :meth:`adjusted` and :meth:`as_tuple` "
|
||
"methods) there is a corresponding :class:`Context` method. For example, for "
|
||
"a :class:`Context` instance ``C`` and :class:`Decimal` instance ``x``, ``C."
|
||
"exp(x)`` is equivalent to ``x.exp(context=C)``. Each :class:`Context` "
|
||
"method accepts a Python integer (an instance of :class:`int` or :class:"
|
||
"`long`) anywhere that a Decimal instance is accepted."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1078
|
||
msgid "Resets all of the flags to :const:`0`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1082
|
||
msgid "Return a duplicate of the context."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1086
|
||
msgid "Return a copy of the Decimal instance num."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1090
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1094
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1108
|
||
msgid ""
|
||
"This method implements the to-number operation of the IBM specification. If "
|
||
"the argument is a string, no leading or trailing whitespace is permitted."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1114
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1134
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1141
|
||
msgid "Returns a value equal to ``Emax - prec + 1``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1143
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1153
|
||
msgid "Returns the absolute value of *x*."
|
||
msgstr "Renvoie la valeur absolue de *x*."
|
||
|
||
#: ../Doc/library/decimal.rst:1158
|
||
msgid "Return the sum of *x* and *y*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1163
|
||
msgid "Returns the same Decimal object *x*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1168
|
||
msgid "Compares *x* and *y* numerically."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1173
|
||
msgid "Compares the values of the two operands numerically."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1178
|
||
msgid "Compares two operands using their abstract representation."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1183
|
||
msgid ""
|
||
"Compares two operands using their abstract representation, ignoring sign."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1188
|
||
msgid "Returns a copy of *x* with the sign set to 0."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1193
|
||
msgid "Returns a copy of *x* with the sign inverted."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1198
|
||
msgid "Copies the sign from *y* to *x*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1203
|
||
msgid "Return *x* divided by *y*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1208
|
||
msgid "Return *x* divided by *y*, truncated to an integer."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1213
|
||
msgid "Divides two numbers and returns the integer part of the result."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1218
|
||
msgid "Returns `e ** x`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1223
|
||
msgid "Returns *x* multiplied by *y*, plus *z*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1228
|
||
msgid "Returns ``True`` if *x* is canonical; otherwise returns ``False``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1233
|
||
msgid "Returns ``True`` if *x* is finite; otherwise returns ``False``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1238
|
||
msgid "Returns ``True`` if *x* is infinite; otherwise returns ``False``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1243
|
||
msgid "Returns ``True`` if *x* is a qNaN or sNaN; otherwise returns ``False``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1248
|
||
msgid ""
|
||
"Returns ``True`` if *x* is a normal number; otherwise returns ``False``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1253
|
||
msgid "Returns ``True`` if *x* is a quiet NaN; otherwise returns ``False``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1258
|
||
msgid "Returns ``True`` if *x* is negative; otherwise returns ``False``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1263
|
||
msgid ""
|
||
"Returns ``True`` if *x* is a signaling NaN; otherwise returns ``False``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1268
|
||
msgid "Returns ``True`` if *x* is subnormal; otherwise returns ``False``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1273
|
||
msgid "Returns ``True`` if *x* is a zero; otherwise returns ``False``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1278
|
||
msgid "Returns the natural (base e) logarithm of *x*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1283
|
||
msgid "Returns the base 10 logarithm of *x*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1288
|
||
msgid "Returns the exponent of the magnitude of the operand's MSD."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1293
|
||
msgid "Applies the logical operation *and* between each operand's digits."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1298
|
||
msgid "Invert all the digits in *x*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1303
|
||
msgid "Applies the logical operation *or* between each operand's digits."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1308
|
||
msgid "Applies the logical operation *xor* between each operand's digits."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1313
|
||
msgid "Compares two values numerically and returns the maximum."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1318 ../Doc/library/decimal.rst:1328
|
||
msgid "Compares the values numerically with their sign ignored."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1323
|
||
msgid "Compares two values numerically and returns the minimum."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1333
|
||
msgid "Minus corresponds to the unary prefix minus operator in Python."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1338
|
||
msgid "Return the product of *x* and *y*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1343
|
||
msgid "Returns the largest representable number smaller than *x*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1348
|
||
msgid "Returns the smallest representable number larger than *x*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1353
|
||
msgid "Returns the number closest to *x*, in direction towards *y*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1358
|
||
msgid "Reduces *x* to its simplest form."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1363
|
||
msgid "Returns an indication of the class of *x*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1368
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1375
|
||
msgid "Return ``x`` to the power of ``y``, reduced modulo ``modulo`` if given."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1377
|
||
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 "
|
||
"result should always be correctly rounded, using the rounding mode of the "
|
||
"current thread's context."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1383
|
||
msgid ""
|
||
"With three arguments, compute ``(x**y) % modulo``. For the three argument "
|
||
"form, the following restrictions on the arguments hold:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1386
|
||
msgid "all three arguments must be integral"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1387
|
||
msgid "``y`` must be nonnegative"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1388
|
||
msgid "at least one of ``x`` or ``y`` must be nonzero"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1389
|
||
msgid "``modulo`` must be nonzero and have at most 'precision' digits"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1391
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1398
|
||
msgid ""
|
||
"``y`` may now be nonintegral in ``x**y``. Stricter requirements for the "
|
||
"three-argument version."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1405
|
||
msgid "Returns a value equal to *x* (rounded), having the exponent of *y*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1410
|
||
msgid "Just returns 10, as this is Decimal, :)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1415
|
||
msgid "Returns the remainder from integer division."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1417
|
||
msgid ""
|
||
"The sign of the result, if non-zero, is the same as that of the original "
|
||
"dividend."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1422
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1428
|
||
msgid "Returns a rotated copy of *x*, *y* times."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1433
|
||
msgid "Returns ``True`` if the two operands have the same exponent."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1438
|
||
msgid "Returns the first operand after adding the second value its exp."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1443
|
||
msgid "Returns a shifted copy of *x*, *y* times."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1448
|
||
msgid "Square root of a non-negative number to context precision."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1453
|
||
msgid "Return the difference between *x* and *y*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1467
|
||
msgid "Rounds to an integer."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1472
|
||
msgid "Converts a number to a string using scientific notation."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1480
|
||
msgid "Signals"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1482
|
||
msgid ""
|
||
"Signals represent conditions that arise during computation. Each corresponds "
|
||
"to one context flag and one context trap enabler."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1485
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1490
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1498
|
||
msgid "Altered an exponent to fit representation constraints."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1500
|
||
msgid ""
|
||
"Typically, clamping occurs when an exponent falls outside the context's :"
|
||
"attr:`Emin` and :attr:`Emax` limits. If possible, the exponent is reduced "
|
||
"to fit by adding zeros to the coefficient."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1507
|
||
msgid "Base class for other signals and a subclass of :exc:`ArithmeticError`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1512
|
||
msgid "Signals the division of a non-infinite number by zero."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1514
|
||
msgid ""
|
||
"Can occur with division, modulo division, or when raising a number to a "
|
||
"negative power. If this signal is not trapped, returns :const:`Infinity` "
|
||
"or :const:`-Infinity` with the sign determined by the inputs to the "
|
||
"calculation."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1521
|
||
msgid "Indicates that rounding occurred and the result is not exact."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1523
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1530
|
||
msgid "An invalid operation was performed."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1532
|
||
msgid ""
|
||
"Indicates that an operation was requested that does not make sense. If not "
|
||
"trapped, returns :const:`NaN`. Possible causes include::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1549
|
||
msgid "Numerical overflow."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1551
|
||
msgid ""
|
||
"Indicates the exponent is larger than :attr:`Emax` after rounding has "
|
||
"occurred. If not trapped, the result depends on the rounding mode, either "
|
||
"pulling inward to the largest representable finite number or rounding "
|
||
"outward to :const:`Infinity`. In either case, :class:`Inexact` and :class:"
|
||
"`Rounded` are also signaled."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1560
|
||
msgid "Rounding occurred though possibly no information was lost."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1562
|
||
msgid ""
|
||
"Signaled whenever rounding discards digits; even if those digits are zero "
|
||
"(such as rounding :const:`5.00` to :const:`5.0`). If not trapped, returns "
|
||
"the result unchanged. This signal is used to detect loss of significant "
|
||
"digits."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1570
|
||
msgid "Exponent was lower than :attr:`Emin` prior to rounding."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1572
|
||
msgid ""
|
||
"Occurs when an operation result is subnormal (the exponent is too small). If "
|
||
"not trapped, returns the result unchanged."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1578
|
||
msgid "Numerical underflow with result rounded to zero."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1580
|
||
msgid ""
|
||
"Occurs when a subnormal result is pushed to zero by rounding. :class:"
|
||
"`Inexact` and :class:`Subnormal` are also signaled."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1583
|
||
msgid "The following table summarizes the hierarchy of signals::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1602
|
||
msgid "Floating Point Notes"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1606
|
||
msgid "Mitigating round-off error with increased precision"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1608
|
||
msgid ""
|
||
"The use of decimal floating point eliminates decimal representation error "
|
||
"(making it possible to represent :const:`0.1` exactly); however, some "
|
||
"operations can still incur round-off error when non-zero digits exceed the "
|
||
"fixed precision."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1612
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1636
|
||
msgid ""
|
||
"The :mod:`decimal` module makes it possible to restore the identities by "
|
||
"expanding the precision sufficiently to avoid loss of significance:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1656
|
||
msgid "Special values"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1658
|
||
msgid ""
|
||
"The number system for the :mod:`decimal` module provides special values "
|
||
"including :const:`NaN`, :const:`sNaN`, :const:`-Infinity`, :const:"
|
||
"`Infinity`, and two zeros, :const:`+0` and :const:`-0`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1662
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1667
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1671
|
||
msgid ""
|
||
"Some operations are indeterminate and return :const:`NaN`, or if the :exc:"
|
||
"`InvalidOperation` signal is trapped, raise an exception. For example, "
|
||
"``0/0`` returns :const:`NaN` which means \"not a number\". This variety of :"
|
||
"const:`NaN` is quiet and, once created, will flow through other computations "
|
||
"always resulting in another :const:`NaN`. This behavior can be useful for a "
|
||
"series of computations that occasionally have missing inputs --- it allows "
|
||
"the calculation to proceed while flagging specific results as invalid."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1679
|
||
msgid ""
|
||
"A variant is :const:`sNaN` which signals rather than remaining quiet after "
|
||
"every operation. This is a useful return value when an invalid result needs "
|
||
"to interrupt a calculation for special handling."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1683
|
||
msgid ""
|
||
"The behavior of Python's comparison operators can be a little surprising "
|
||
"where a :const:`NaN` is involved. A test for equality where one of the "
|
||
"operands is a quiet or signaling :const:`NaN` always returns :const:`False` "
|
||
"(even when doing ``Decimal('NaN')==Decimal('NaN')``), while a test for "
|
||
"inequality always returns :const:`True`. An attempt to compare two Decimals "
|
||
"using any of the ``<``, ``<=``, ``>`` or ``>=`` operators will raise the :"
|
||
"exc:`InvalidOperation` signal if either operand is a :const:`NaN`, and "
|
||
"return :const:`False` if this signal is not trapped. Note that the General "
|
||
"Decimal Arithmetic specification does not specify the behavior of direct "
|
||
"comparisons; these rules for comparisons involving a :const:`NaN` were taken "
|
||
"from the IEEE 854 standard (see Table 3 in section 5.7). To ensure strict "
|
||
"standards-compliance, use the :meth:`compare` and :meth:`compare-signal` "
|
||
"methods instead."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1696
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1701
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1716
|
||
msgid "Working with threads"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1718
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1722
|
||
msgid ""
|
||
"Likewise, the :func:`setcontext` function automatically assigns its target "
|
||
"to the current thread."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1725
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1729
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1754
|
||
msgid "Recipes"
|
||
msgstr "Cas pratiques"
|
||
|
||
#: ../Doc/library/decimal.rst:1756
|
||
msgid ""
|
||
"Here are a few recipes that serve as utility functions and that demonstrate "
|
||
"ways to work with the :class:`Decimal` class::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1904
|
||
msgid "Decimal FAQ"
|
||
msgstr "FAQ *decimal*"
|
||
|
||
#: ../Doc/library/decimal.rst:1906
|
||
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 ?"
|
||
|
||
#: ../Doc/library/decimal.rst:1909
|
||
msgid "A. Some users abbreviate the constructor to just a single letter:"
|
||
msgstr ""
|
||
"R. Certains utilisateurs abrègent le constructeur en une seule lettre :"
|
||
|
||
#: ../Doc/library/decimal.rst:1915
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:1919
|
||
msgid ""
|
||
"A. The :meth:`quantize` method rounds to a fixed number of decimal places. "
|
||
"If the :const:`Inexact` trap is set, it is also useful for validation:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1937
|
||
msgid ""
|
||
"Q. Once I have valid two place inputs, how do I maintain that invariant "
|
||
"throughout an application?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1940
|
||
msgid ""
|
||
"A. Some operations like addition, subtraction, and multiplication by an "
|
||
"integer will automatically preserve fixed point. Others operations, like "
|
||
"division and non-integer multiplication, will change the number of decimal "
|
||
"places and need to be followed-up with a :meth:`quantize` step:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1958
|
||
msgid ""
|
||
"In developing fixed-point applications, it is convenient to define functions "
|
||
"to handle the :meth:`quantize` step:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1971
|
||
msgid ""
|
||
"Q. There are many ways to express the same value. The numbers :const:"
|
||
"`200`, :const:`200.000`, :const:`2E2`, and :const:`.02E+4` all have the same "
|
||
"value at various precisions. Is there a way to transform them to a single "
|
||
"recognizable canonical value?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1976
|
||
msgid ""
|
||
"A. The :meth:`normalize` method maps all equivalent values to a single "
|
||
"representative:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1983
|
||
msgid ""
|
||
"Q. Some decimal values always print with exponential notation. Is there a "
|
||
"way to get a non-exponential representation?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1986
|
||
msgid ""
|
||
"A. For some values, exponential notation is the only way to express the "
|
||
"number of significant places in the coefficient. For example, expressing :"
|
||
"const:`5.0E+3` as :const:`5000` keeps the value constant but cannot show the "
|
||
"original's two-place significance."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:1991
|
||
msgid ""
|
||
"If an application does not care about tracking significance, it is easy to "
|
||
"remove the exponent and trailing zeros, losing significance, but keeping the "
|
||
"value unchanged::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:2004
|
||
msgid "Q. Is there a way to convert a regular float to a :class:`Decimal`?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:2006
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:2015
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:2018
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:2023
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:2027
|
||
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 ""
|
||
|
||
#: ../Doc/library/decimal.rst:2040
|
||
msgid ""
|
||
"The solution is either to increase precision or to force rounding of inputs "
|
||
"using the unary plus operation:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/decimal.rst:2049
|
||
msgid ""
|
||
"Alternatively, inputs can be rounded upon creation using the :meth:`Context."
|
||
"create_decimal` method:"
|
||
msgstr ""
|