2018-07-04 09:06:45 +00:00
|
|
|
|
# Copyright (C) 2001-2018, Python Software Foundation
|
2018-07-04 09:08:42 +00:00
|
|
|
|
# For licence information, see README file.
|
2016-10-30 09:46:26 +00:00
|
|
|
|
#
|
|
|
|
|
msgid ""
|
|
|
|
|
msgstr ""
|
2019-12-05 22:15:54 +00:00
|
|
|
|
"Project-Id-Version: Python 3\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"Report-Msgid-Bugs-To: \n"
|
2023-07-23 12:39:39 +00:00
|
|
|
|
"POT-Creation-Date: 2023-07-23 14:38+0200\n"
|
2023-12-07 22:10:56 +00:00
|
|
|
|
"PO-Revision-Date: 2023-12-07 23:09+0100\n"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Last-Translator: Christophe Nanteuil <christophe.nanteuil@gmail.com>\n"
|
2018-07-04 09:14:25 +00:00
|
|
|
|
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
2017-05-23 22:40:56 +00:00
|
|
|
|
"Language: fr\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"MIME-Version: 1.0\n"
|
|
|
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
|
|
|
"Content-Transfer-Encoding: 8bit\n"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"X-Generator: Poedit 3.2.2\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:2
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":mod:`decimal` --- Decimal fixed point and floating point arithmetic"
|
2019-02-03 10:37:05 +00:00
|
|
|
|
msgstr ":mod:`decimal` — Arithmétique décimale en virgule fixe et flottante"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:15
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "**Source code:** :source:`Lib/decimal.py`"
|
2018-10-07 16:44:15 +00:00
|
|
|
|
msgstr "**Code source :** :source:`Lib/decimal.py`"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:33
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-01-15 21:42:07 +00:00
|
|
|
|
"The :mod:`decimal` module provides support for fast correctly rounded "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"decimal floating point arithmetic. It offers several advantages over the :"
|
|
|
|
|
"class:`float` datatype:"
|
|
|
|
|
msgstr ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"Le module :mod:`decimal` fournit une arithmétique en virgule flottante "
|
|
|
|
|
"rapide et produisant des arrondis mathématiquement corrects. Il possède "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"plusieurs avantages par rapport au type :class:`float` :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:37
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"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 "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"apprend à l'école » – extrait (traduit) de la spécification de "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"l'arithmétique décimale."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:42
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"Les nombres décimaux peuvent être représentés exactement en base décimale "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:47
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"point, the result is ``5.5511151231257827e-017``. While near to zero, the "
|
|
|
|
|
"differences prevent reliable equality testing and differences can "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"accumulate. For this reason, decimal is preferred in accounting applications "
|
|
|
|
|
"which have strict equality invariants."
|
|
|
|
|
msgstr ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"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 "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"virgule flottante binaire, l'ordinateur l'évalue à "
|
|
|
|
|
"``5.5511151231257827e-017``. Bien que très proche de zéro, cette différence "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"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é."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:54
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The decimal module incorporates a notion of significant places so that "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"``1.30 + 1.20`` is ``2.50``. The trailing zero is kept to indicate "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"significance. This is the customary presentation for monetary applications. "
|
|
|
|
|
"For multiplication, the \"schoolbook\" approach uses all the figures in the "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"multiplicands. For instance, ``1.3 * 1.2`` gives ``1.56`` while ``1.30 * "
|
|
|
|
|
"1.20`` gives ``1.5600``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:61
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"Contrairement à l'arithmétique en virgule flottante binaire, le module "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"``decimal`` possède un paramètre de précision ajustable (par défaut à 28 "
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"chiffres significatifs) qui peut être aussi élevée que nécessaire pour un "
|
|
|
|
|
"problème donné :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:73
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"L'arithmétique binaire et décimale en virgule flottante sont implémentées "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"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 "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"contrôle total de la gestion des signaux et de l'arrondi. Cela inclut la "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"possibilité de forcer une arithmétique exacte en utilisant des exceptions "
|
|
|
|
|
"pour bloquer toute opération inexacte."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:80
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"Le module ``decimal`` a été conçu pour gérer « sans préjugé, à la fois une "
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"arithmétique décimale non-arrondie (aussi appelée arithmétique en virgule "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"fixe) et à la fois une arithmétique en virgule flottante » (extrait traduit "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"de la spécification de l'arithmétique décimale)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:85
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The module design is centered around three concepts: the decimal number, "
|
|
|
|
|
"the context for arithmetic, and signals."
|
|
|
|
|
msgstr ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"Le module est conçu autour de trois concepts : le nombre décimal, le "
|
|
|
|
|
"contexte arithmétique et les signaux."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:88
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A decimal number is immutable. It has a sign, coefficient digits, and an "
|
|
|
|
|
"exponent. To preserve significance, the coefficient digits do not truncate "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"trailing zeros. Decimals also include special values such as ``Infinity``, "
|
2023-07-23 12:39:39 +00:00
|
|
|
|
"``-Infinity``, and ``NaN``. The standard also differentiates ``-0`` from "
|
|
|
|
|
"``+0``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Un ``Decimal`` est immuable. Il a un signe, une mantisse et un exposant. "
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"Pour préserver le nombre de chiffres significatifs, les zéros en fin de "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"chaîne ne sont pas tronqués. Les décimaux incluent aussi des valeurs "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"spéciales telles que ``Infinity``, ``-Infinity`` et ``NaN``. Le standard "
|
|
|
|
|
"fait également la différence entre ``-0`` et ``+0``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:94
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"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`, :"
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"const:`ROUND_FLOOR`, :const:`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"const:`ROUND_HALF_UP`, :const:`ROUND_UP` et :const:`ROUND_05UP`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:101
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"Les signaux sont des groupes de conditions exceptionnelles qui surviennent "
|
|
|
|
|
"durant le calcul. Selon les besoins de l'application, les signaux peuvent "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"ê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`, :"
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"const:`InvalidOperation`, :const:`DivisionByZero`, :const:`Inexact`, :const:"
|
|
|
|
|
"`Rounded`, :const:`Subnormal`, :const:`Overflow`, :const:`Underflow` et :"
|
|
|
|
|
"const:`FloatOperation`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:108
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Chaque signal est configurable indépendamment, à travers un drapeau (ou "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"option) et un activateur de surveillance. Quand une opération illégale "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:116
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"IBM's General Decimal Arithmetic Specification, `The General Decimal "
|
2023-01-15 21:42:07 +00:00
|
|
|
|
"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Spécification d'IBM sur l'arithmétique décimale : `The General Decimal "
|
|
|
|
|
"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_ "
|
|
|
|
|
"(article en anglais)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:125
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Quick-start Tutorial"
|
2018-10-07 16:44:15 +00:00
|
|
|
|
msgstr "Introduction pratique"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:127
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"Commençons par importer le module, regarder le contexte actuel avec :func:"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"`getcontext` et, si nécessaire, configurer la précision, l'arrondi et la "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"gestion des signaux ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:139
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"values such as ``NaN`` which stands for \"Not a number\", positive and "
|
|
|
|
|
"negative ``Infinity``, and ``-0``::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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`` ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:163
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If the :exc:`FloatOperation` signal is trapped, accidental mixing of "
|
|
|
|
|
"decimals and floats in constructors or ordering comparisons raises an "
|
|
|
|
|
"exception::"
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Si le signal :exc:`FloatOperation` est activé pour la surveillance, un "
|
|
|
|
|
"mélange accidentel d'objets ``Decimal`` et de ``float`` dans les "
|
|
|
|
|
"constructeurs ou des opérations de comparaison lève une exception ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:182
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:199
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If the internal limits of the C version are exceeded, constructing a decimal "
|
|
|
|
|
"raises :class:`InvalidOperation`::"
|
|
|
|
|
msgstr ""
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"Si les limites internes de la version en C sont dépassées, la construction "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"d'un objet décimal lève l'exception :class:`InvalidOperation` ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:209
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Decimals interact well with much of the rest of Python. Here is a small "
|
|
|
|
|
"decimal floating point flying circus:"
|
|
|
|
|
msgstr ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"Les objets ``Decimal`` interagissent très bien avec le reste de Python. "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Voici quelques exemples d'opérations avec des décimaux :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:241
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "And some mathematical functions are also available to Decimal:"
|
|
|
|
|
msgstr ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"Et certaines fonctions mathématiques sont également disponibles sur des "
|
|
|
|
|
"instances de ``Decimal`` :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:253
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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:"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:262
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"Comme montré plus haut, la fonction :func:`getcontext` accède au contexte "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"actuel et permet de modifier les paramètres. Cette approche répond aux "
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"besoins de la plupart des applications."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:266
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"Pour un travail plus avancé, il peut être utile de créer des contextes "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"alternatifs en utilisant le constructeur de ``Context``. Pour activer cet "
|
|
|
|
|
"objet ``Context``, utilisez la fonction :func:`setcontext`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:270
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"En accord avec le standard, le module :mod:`decimal` fournit des objets "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"*Context* standards, :const:`BasicContext` et :const:`ExtendedContext`. Le "
|
|
|
|
|
"premier est particulièrement utile pour le débogage car beaucoup des signaux "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"ont leur surveillance activée :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:299
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"computations by using the :meth:`~Context.clear_flags` method. ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"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 :"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"meth:`~Context.clear_flags`. ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:312
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"chiffres tronqués étaient différents de zéro)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:316
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"Individual traps are set using the dictionary in the :attr:`~Context.traps` "
|
|
|
|
|
"attribute of a context:"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"L'activation de la surveillance se fait en utilisant un dictionnaire dans "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"l'attribut :attr:`~Context.traps` du contexte :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:331
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"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 "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 "
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"Python."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:343
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Decimal objects"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Les objets *Decimal*"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:348
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Construct a new :class:`Decimal` object based from *value*."
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Construit un nouvel objet :class:`Decimal` à partir de *value*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:350
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"*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 ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:366
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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'``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:371
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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')``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Si *value* est un :class:`n-uplet <tuple>`, il doit avoir trois éléments, le "
|
|
|
|
|
"signe (``0`` pour positif ou ``1`` pour négatif), un :class:`n-uplet "
|
|
|
|
|
"<tuple>` de chiffres et un entier représentant l'exposant. Par exemple, "
|
|
|
|
|
"``Decimal((0, (1, 4, 1, 4), -3))`` construit l'objet ``Decimal('1.414')``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:376
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"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')``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:382
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"La précision spécifiée dans le contexte n'affecte pas le nombre de chiffres "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"stockés. Cette valeur est déterminée exclusivement par le nombre de chiffres "
|
2018-10-05 14:04:32 +00:00
|
|
|
|
"dans *value*. Par exemple, ``Decimal('3.00000')`` enregistre les 5 zéros "
|
|
|
|
|
"même si la précision du contexte est de 3."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:387
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"the value of ``NaN``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"L'objectif de l'argument *context* est de déterminer ce que Python doit "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"faire si *value* est une chaîne avec un mauvais format. Si la surveillance "
|
|
|
|
|
"est activée pour :const:`InvalidOperation`, une exception est levée, sinon "
|
|
|
|
|
"le constructeur renvoie un objet ``Decimal`` de valeur ``NaN``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:392
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Once constructed, :class:`Decimal` objects are immutable."
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Une fois construit, un objet :class:`Decimal` est immuable."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-05-23 08:47:51 +00:00
|
|
|
|
# suit un :
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:394
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The argument to the constructor is now permitted to be a :class:`float` "
|
|
|
|
|
"instance."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"l'argument du constructeur peut désormais être un objet :class:`float`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-05-23 08:47:51 +00:00
|
|
|
|
# suit un :
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:398
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":class:`float` arguments raise an exception if the :exc:`FloatOperation` "
|
|
|
|
|
"trap is set. By default the trap is off."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"un argument :class:`float` lève une exception si la surveillance est activée "
|
|
|
|
|
"pour :exc:`FloatOperation`. Par défaut la surveillance n'est pas activée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-05-23 08:47:51 +00:00
|
|
|
|
# suit un :
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:402
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Underscores are allowed for grouping, as with integral and floating-point "
|
|
|
|
|
"literals in code."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"les tirets bas sont autorisés pour grouper des chiffres, tout comme pour "
|
|
|
|
|
"l'arithmétique en virgule fixe et flottante."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:406
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"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, "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"comparés, classés et convertis vers un autre type (tel que :class:`float` "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"ou :class:`int`)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:413
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-05 15:54:59 +00:00
|
|
|
|
"Il existe quelques différences mineures entre l'arithmétique entre les "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"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 "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"résultat est le signe du *dividende* plutôt que le signe du diviseur ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:423
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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`` ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:432
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The ``%`` and ``//`` operators implement the ``remainder`` and ``divide-"
|
|
|
|
|
"integer`` operations (respectively) as described in the specification."
|
|
|
|
|
msgstr ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"Les opérateurs ``//`` et ``%`` implémentent la division entière et le reste "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"(ou modulo), respectivement, tels que décrits dans la spécification."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:436
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"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 "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"arithmétiques : toute addition entre un :class:`Decimal` et un :class:"
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"`float`, par exemple, lève une exception :exc:`TypeError`. Cependant, il est "
|
|
|
|
|
"possible d'utiliser les opérateurs de comparaison entre instances de :class:"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"`Decimal` et les autres types numériques. Cela évite d'avoir des résultats "
|
2018-10-07 16:44:15 +00:00
|
|
|
|
"absurdes lors des tests d'égalité entre différents types."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-05-23 08:47:51 +00:00
|
|
|
|
# suit un :
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:444
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Mixed-type comparisons between :class:`Decimal` instances and other numeric "
|
|
|
|
|
"types are now fully supported."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"les comparaisons inter-types entre :class:`Decimal` et les autres types "
|
|
|
|
|
"numériques sont désormais intégralement gérées."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:448
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In addition to the standard numeric properties, decimal floating point "
|
|
|
|
|
"objects also have a number of specialized methods:"
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:454
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie l'exposant ajusté après avoir décalé les chiffres les plus à droite "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"de la mantisse jusqu'à ce qu'il ne reste que le premier chiffre : "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"``Decimal('321e+5').adjusted()`` renvoie sept. Utilisée pour déterminer la "
|
|
|
|
|
"position du chiffre le plus significatif par rapport à la virgule."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:461
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:468
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The conversion is exact. Raise OverflowError on infinities and ValueError "
|
|
|
|
|
"on NaNs."
|
|
|
|
|
msgstr ""
|
2018-10-05 15:54:59 +00:00
|
|
|
|
"La conversion est exacte. Lève une ``OverflowError`` sur l'infini et "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"``ValueError`` sur les *Nan*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:475
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return a :term:`named tuple` representation of the number: "
|
|
|
|
|
"``DecimalTuple(sign, digits, exponent)``."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie une représentation sous la forme d'un :term:`n-uplet nommé <named "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"tuple>` du nombre ``DecimalTuple(signe, chiffres, exposant)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:481
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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é."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:487
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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* ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:498
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Cette opération est identique à la méthode :meth:`compare`, sauf que tous "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"les *NaN* sont surveillés. Autrement dit, si aucun des opérandes n'est un "
|
|
|
|
|
"*NaN* de signalisation, alors tout opérande *NaN* silencieux est traité "
|
|
|
|
|
"comme s'il s'agissait d'un *NaN* de signalisation."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:504
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:513
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:531 library/decimal.rst:846
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:526
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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())``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:537
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Just returns self, this method is only to comply with the Decimal "
|
|
|
|
|
"Specification."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Ne fait que renvoyer self ; cette méthode existe uniquement pour se "
|
|
|
|
|
"conformer à la spécification."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:542
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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é."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:548
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Renvoie l'opposé de l'argument. Cette opération ne dépend pas du contexte et "
|
|
|
|
|
"est silencieuse : aucun drapeau n'est modifié et aucun arrondi n'est "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"effectué."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:553
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie une copie du premier opérande mais avec le même signe que celui du "
|
|
|
|
|
"deuxième opérande. Par exemple :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:565
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/decimal.rst:576
|
2022-05-22 21:15:02 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Alternative constructor that only accepts instances of :class:`float` or :"
|
|
|
|
|
"class:`int`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Constructeur alternatif qui n'accepte que les instances de :class:`float` "
|
|
|
|
|
"ou :class:`int`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:579
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-01-15 21:42:07 +00:00
|
|
|
|
"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``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-05-23 08:47:51 +00:00
|
|
|
|
# suit un :
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:585
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed "
|
|
|
|
|
"directly from a :class:`float`."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"depuis Python 3.2, une instance :class:`Decimal` peut également être "
|
|
|
|
|
"construite directement à partir d'un :class:`float`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:603
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Fused multiply-add. Return self*other+third with no rounding of the "
|
|
|
|
|
"intermediate product self*other."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Multiplier-ajouter fusionné. Renvoie ``self*other+third`` sans arrondir le "
|
|
|
|
|
"produit intermédiaire ``self*other``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:611
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"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`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:617
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return :const:`True` if the argument is a finite number, and :const:`False` "
|
|
|
|
|
"if the argument is an infinity or a NaN."
|
|
|
|
|
msgstr ""
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"Renvoie :const:`True` si l'argument est un nombre fini et :const:`False` si "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"l'argument est un infini ou un *NaN*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:622
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return :const:`True` if the argument is either positive or negative infinity "
|
|
|
|
|
"and :const:`False` otherwise."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie :const:`True` si l'argument est un infini positif ou négatif, :const:"
|
|
|
|
|
"`False` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:627
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return :const:`True` if the argument is a (quiet or signaling) NaN and :"
|
|
|
|
|
"const:`False` otherwise."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie :const:`True` si l'argument est un *NaN* (signalétique ou "
|
|
|
|
|
"silencieux), :const:`False` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:632
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:637
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return :const:`True` if the argument is a quiet NaN, and :const:`False` "
|
|
|
|
|
"otherwise."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie :const:`True` si l'argument est un *NaN* silencieux, :const:`False` "
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:642
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie :const:`True` si l'argument est négatif, :const:`False` sinon. "
|
|
|
|
|
"Remarquez que les zéros et les *NaN* peuvent être signés."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:647
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return :const:`True` if the argument is a signaling NaN and :const:`False` "
|
|
|
|
|
"otherwise."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie :const:`True` si l'argument est un *NaN* signalétique, :const:"
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"`False` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:652
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return :const:`True` if the argument is subnormal, and :const:`False` "
|
|
|
|
|
"otherwise."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie :const:`True` si l'argument est le résultat d'un dépassement par "
|
|
|
|
|
"valeur inférieure, :const:`False` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:657
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return :const:`True` if the argument is a (positive or negative) zero and :"
|
|
|
|
|
"const:`False` otherwise."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie :const:`True` si l'argument est un zéro (positif ou négatif), :const:"
|
|
|
|
|
"`False` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:662
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return the natural (base e) logarithm of the operand. The result is "
|
|
|
|
|
"correctly rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
|
|
|
|
|
msgstr ""
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"Renvoie le logarithme naturel (base e) de l'opérande. Le résultat est "
|
|
|
|
|
"arrondi avec le mode :const:`ROUND_HALF_EVEN`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:667
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return the base ten logarithm of the operand. The result is correctly "
|
|
|
|
|
"rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
|
|
|
|
|
msgstr ""
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"Renvoie le logarithme en base 10 de l'opérande. Le résultat est arrondi avec "
|
|
|
|
|
"le mode :const:`ROUND_HALF_EVEN`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:672
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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é."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:680
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
":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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:686
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":meth:`logical_invert` is a logical operation. The result is the digit-wise "
|
|
|
|
|
"inversion of the operand."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
":meth:`logical_invert` est une opération logique. Le résultat est "
|
|
|
|
|
"l'inversion de chacun des chiffres de l'opérande."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:691
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
":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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:697
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
":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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:703
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Like ``max(self, other)`` except that the context rounding rule is applied "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"before returning and that ``NaN`` values are either signaled or ignored "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"(depending on the context and whether they are signaling or quiet)."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Comme ``max(self, other)`` sauf que la règle d'arrondi de *context* est "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"appliquée avant le retour et que les valeurs ``NaN`` ne soient signalées ou "
|
|
|
|
|
"ignorées (selon le contexte et suivant qu'elles sont signalétiques ou "
|
|
|
|
|
"silencieuses)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:710
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Similar to the :meth:`.max` method, but the comparison is done using the "
|
|
|
|
|
"absolute values of the operands."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Semblable à la méthode :meth:`.max`, mais la comparaison est effectuée en "
|
|
|
|
|
"utilisant les valeurs absolues des opérandes."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:715
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Like ``min(self, other)`` except that the context rounding rule is applied "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"before returning and that ``NaN`` values are either signaled or ignored "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"(depending on the context and whether they are signaling or quiet)."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Comme ``min(self, other)`` sauf que la règle d'arrondi de *context* est "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"appliquée avant le retour et que les valeurs ``NaN`` ne soient signalées ou "
|
|
|
|
|
"ignorées (selon le contexte et suivant qu'elles sont signalétiques ou "
|
|
|
|
|
"silencieuses)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:722
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Similar to the :meth:`.min` method, but the comparison is done using the "
|
|
|
|
|
"absolute values of the operands."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Semblable à la méthode :meth:`.min`, mais la comparaison est effectuée en "
|
|
|
|
|
"utilisant les valeurs absolues des opérandes."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:727
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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é."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:733
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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é."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:739
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-22 21:15:02 +00:00
|
|
|
|
#: library/decimal.rst:746
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-07-23 12:39:39 +00:00
|
|
|
|
"Used for producing canonical values of an equivalence class within either "
|
|
|
|
|
"the current context or the specified context."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Utilisé pour produire des valeurs canoniques d'une classe d'équivalence dans "
|
|
|
|
|
"le contexte actuel ou dans le contexte spécifié."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:749
|
|
|
|
|
msgid ""
|
|
|
|
|
"This has the same semantics as the unary plus operation, except that if the "
|
|
|
|
|
"final result is finite it is reduced to its simplest form, with all trailing "
|
|
|
|
|
"zeros removed and its sign preserved. That is, while the coefficient is non-"
|
|
|
|
|
"zero and a multiple of ten the coefficient is divided by ten and the "
|
|
|
|
|
"exponent is incremented by 1. Otherwise (the coefficient is zero) the "
|
|
|
|
|
"exponent is set to 0. In all cases the sign is unchanged."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"C'est la même sémantique que l'opération unaire plus, sauf que si le "
|
|
|
|
|
"résultat final est fini, il est réduit à sa forme la plus simple, avec tous "
|
|
|
|
|
"les zéros à droite supprimés et son signe conservé. Autrement dit, tant que "
|
|
|
|
|
"la mantisse est différente de zéro et multiple de dix, la mantisse est "
|
|
|
|
|
"divisée par dix et l'exposant est incrémenté de 1. Sinon (la mantisse est "
|
|
|
|
|
"nulle), l'exposant est mis à 0. Dans tous les cas, le signe est inchangé."
|
2023-07-23 12:39:39 +00:00
|
|
|
|
|
|
|
|
|
#: library/decimal.rst:756
|
|
|
|
|
msgid ""
|
|
|
|
|
"For example, ``Decimal('32.100')`` and ``Decimal('0.321000e+2')`` both "
|
|
|
|
|
"normalize to the equivalent value ``Decimal('32.1')``."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Par exemple, ``Decimal('32.100')`` et ``Decimal('0.321000e+2')`` se "
|
|
|
|
|
"normalisent tous deux à la valeur équivalente ``Decimal('32.1')``."
|
2023-07-23 12:39:39 +00:00
|
|
|
|
|
|
|
|
|
#: library/decimal.rst:759
|
|
|
|
|
msgid "Note that rounding is applied *before* reducing to simplest form."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Notez que l'arrondi est appliqué *avant* la réduction à la forme la plus "
|
|
|
|
|
"simple."
|
2023-07-23 12:39:39 +00:00
|
|
|
|
|
|
|
|
|
#: library/decimal.rst:761
|
|
|
|
|
msgid ""
|
|
|
|
|
"In the latest versions of the specification, this operation is also known as "
|
|
|
|
|
"``reduce``."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Dans les dernières versions de la spécification, cette opération est "
|
|
|
|
|
"également connue sous le nom de ``reduce``."
|
2023-07-23 12:39:39 +00:00
|
|
|
|
|
|
|
|
|
#: library/decimal.rst:766
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return a string describing the *class* of the operand. The returned value "
|
|
|
|
|
"is one of the following ten strings."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie une chaîne décrivant la *classe* de l'opérande. La valeur renvoyée "
|
|
|
|
|
"est l'une des dix chaînes suivantes."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-30 10:13:38 +00:00
|
|
|
|
# Élément d'une liste, d'où le ; final
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:769
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "``\"-Infinity\"``, indicating that the operand is negative infinity."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "``\"-Infinity\"``, indiquant que l'opérande est l'infini négatif ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-05-23 08:47:51 +00:00
|
|
|
|
# Élément d'une liste, d'où le ; final
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:770
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"``\"-Normal\"``, indicating that the operand is a negative normal number."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"``\"-Normal\"``, indiquant que l'opérande est un nombre négatif normal ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-05-23 08:47:51 +00:00
|
|
|
|
# Élément d'une liste, d'où le ; final
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:771
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"``\"-Subnormal\"``, indicating that the operand is negative and subnormal."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"``\"-Subnormal\"``, indiquant que l'opérande est négatif et qu'il est le "
|
|
|
|
|
"résultat d'un dépassement par valeur inférieure ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-30 10:13:38 +00:00
|
|
|
|
# Élément d'une liste, d'où le ; final
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:772
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "``\"-Zero\"``, indicating that the operand is a negative zero."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "``\"-Zero\"``, indiquant que l'opérande est un zéro négatif ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-30 10:13:38 +00:00
|
|
|
|
# Élément d'une liste, d'où le ; final
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:773
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "``\"+Zero\"``, indicating that the operand is a positive zero."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "``\"+Zero\"``, indiquant que l'opérande est un zéro positif ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-05-23 08:47:51 +00:00
|
|
|
|
# Élément d'une liste, d'où le ; final
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:774
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"``\"+Subnormal\"``, indicating that the operand is positive and subnormal."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"``\"+Subnormal\"``, indiquant que l'opérande est positif et qu'il est le "
|
|
|
|
|
"résultat un dépassement par valeur inférieure ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:775
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"``\"+Normal\"``, indicating that the operand is a positive normal number."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"``\"+Normal\"``, indiquant que l'opérande est un nombre positif normal ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-30 10:13:38 +00:00
|
|
|
|
# Élément d'une liste, d'où le ; final
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:776
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "``\"+Infinity\"``, indicating that the operand is positive infinity."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "``\"+Infinity\"``, indiquant que l'opérande est l'infini positif ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-30 10:13:38 +00:00
|
|
|
|
# Élément d'une liste, d'où le ; final
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:777
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "``\"NaN\"``, indicating that the operand is a quiet NaN (Not a Number)."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"``\"NaN\"``, indiquant que l'opérande est un *NaN* (*Not a Number*, pas un "
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"nombre) silencieux ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:778
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "``\"sNaN\"``, indicating that the operand is a signaling NaN."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"``\"sNaN\"``, indiquant que l'opérande est un *NaN* (*Not a Number*, pas un "
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"nombre) signalétique."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:782
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return a value equal to the first operand after rounding and having the "
|
|
|
|
|
"exponent of the second operand."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie une valeur égale au premier opérande après arrondi et ayant "
|
|
|
|
|
"l'exposant du second opérande."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:788
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Contrairement aux autres opérations, si la longueur de la mantisse après "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:794
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Also unlike other operations, quantize never signals Underflow, even if the "
|
|
|
|
|
"result is subnormal and inexact."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"valeur minimale représentable et est inexact."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:797
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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é."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:803
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An error is returned whenever the resulting exponent is greater than :attr:"
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"`~Context.Emax` or less than :meth:`~Context.Etiny`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Une erreur est renvoyée chaque fois que l'exposant résultant est supérieur "
|
|
|
|
|
"à :attr:`~Context.Emax` ou inférieur à :meth:`~Context.Etiny`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:808
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return ``Decimal(10)``, the radix (base) in which the :class:`Decimal` class "
|
|
|
|
|
"does all its arithmetic. Included for compatibility with the specification."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:814
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:821
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "If the result is zero then its sign will be the sign of *self*."
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Si le résultat est zéro, alors son signe est le signe de *self*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:832
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 ; "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"sinon la rotation se fait vers la droite. La mantisse du premier opérande "
|
|
|
|
|
"est complétée à gauche avec des zéros à la précision de la longueur si "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"nécessaire. Le signe et l'exposant du premier opérande sont inchangés."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:843
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"Test whether self and other have the same exponent or whether both are "
|
|
|
|
|
"``NaN``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Teste si *self* et *other* ont le même exposant ou si les deux sont ``NaN``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:852
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:858
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:868
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Return the square root of the argument to full precision."
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Renvoie la racine carrée de l'argument avec une précision maximale."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1468
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Convert to a string, using engineering notation if an exponent is needed."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Convertit en chaîne, en utilisant la notation ingénieur si un exposant est "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"nécessaire."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1470
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"l'ajout d'un ou de deux zéros en fin de mantisse."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:879
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"For example, this converts ``Decimal('123E+1')`` to ``Decimal('1.23E+3')``."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Par exemple, ``Decimal('123E+1')`` est converti en ``Decimal('1.23E+3')``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:883
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Identical to the :meth:`to_integral_value` method. The ``to_integral`` name "
|
|
|
|
|
"has been kept for compatibility with older versions."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Identique à la méthode :meth:`to_integral_value`. Le nom ``to_integral`` a "
|
|
|
|
|
"été conservé pour la compatibilité avec les anciennes versions."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:888
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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é."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:896
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:904
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Logical operands"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Opérandes logiques"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:906
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:918
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Context objects"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Objets de contexte"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:920
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:924
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Each thread has its own current context which is accessed or changed using "
|
|
|
|
|
"the :func:`getcontext` and :func:`setcontext` functions:"
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Chaque fil d'exécution a son propre contexte actuel qui est accessible ou "
|
|
|
|
|
"modifié à l'aide des fonctions :func:`getcontext` et :func:`setcontext` :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:930
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Return the current context for the active thread."
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Renvoie le contexte actuel du fil d'exécution courant."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:935
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Set the current context for the active thread to *c*."
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Définit le contexte du fil d'exécution courant à *c*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:937
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"You can also use the :keyword:`with` statement and the :func:`localcontext` "
|
|
|
|
|
"function to temporarily change the active context."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Vous pouvez également utiliser l'instruction :keyword:`with` et la fonction :"
|
|
|
|
|
"func:`localcontext` pour modifier temporairement le contexte actif."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:942
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 "
|
2022-05-22 21:15:02 +00:00
|
|
|
|
"specified, a copy of the current context is used. The *kwargs* argument is "
|
|
|
|
|
"used to set the attributes of the new context."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:948
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:958
|
2022-05-22 21:15:02 +00:00
|
|
|
|
msgid "Using keyword arguments, the code would be the following::"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "En utilisant des arguments nommés, le code serait le suivant ::"
|
2022-05-22 21:15:02 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:966
|
2022-05-22 21:15:02 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2022-05-22 21:15:02 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:970
|
2022-05-22 21:15:02 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":meth:`localcontext` now supports setting context attributes through the use "
|
|
|
|
|
"of keyword arguments."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
":meth:`localcontext` prend désormais en charge la définition des attributs "
|
|
|
|
|
"de contexte grâce à l'utilisation d'arguments nommés."
|
2022-05-22 21:15:02 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:973
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"New contexts can also be created using the :class:`Context` constructor "
|
|
|
|
|
"described below. In addition, the module provides three pre-made contexts:"
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:979
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 :"
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"const:`ROUND_HALF_UP`. Tous les drapeaux sont effacés. Toutes les "
|
|
|
|
|
"surveillances sont activées (elles lèvent des exceptions) sauf :const:"
|
|
|
|
|
"`Inexact`, :const:`Rounded` et :const:`Subnormal`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:985
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Because many of the traps are enabled, this context is useful for debugging."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Étant donné que de nombreuses options de surveillance sont activées, ce "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"contexte est utile pour le débogage."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:990
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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 :"
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"const:`ROUND_HALF_EVEN`. Toutes les options de surveillance sont désactivées "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"(afin que les exceptions ne soient pas levées pendant les calculs)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:995
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Because the traps are disabled, this context is useful for applications that "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1003
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1007
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1012
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In single threaded environments, it is preferable to not use this context at "
|
|
|
|
|
"all. Instead, simply create contexts explicitly as described below."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1015
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"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`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1020
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In addition to the three supplied contexts, new contexts can be created with "
|
|
|
|
|
"the :class:`Context` constructor."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"En plus des trois contextes fournis, de nouveaux contextes peuvent être "
|
|
|
|
|
"créés avec le constructeur :class:`Context`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1026
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Crée un nouveau contexte. Si un champ n'est pas spécifié ou est :const:"
|
|
|
|
|
"`None`, les valeurs par défaut sont copiées à partir du :const:"
|
|
|
|
|
"`DefaultContext`. Si le champ *flags* n'est pas spécifié ou est :const:"
|
|
|
|
|
"`None`, tous les indicateurs sont effacés."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1030
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"*prec* is an integer in the range [``1``, :const:`MAX_PREC`] that sets the "
|
|
|
|
|
"precision for arithmetic operations in the context."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"*prec* est un entier compris dans la plage [``1``, :const:`MAX_PREC`] qui "
|
|
|
|
|
"définit la précision des opérations arithmétiques dans le contexte."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1033
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The *rounding* option is one of the constants listed in the section "
|
|
|
|
|
"`Rounding Modes`_."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"L'option *rounding* est l'une des constantes répertoriées dans la section "
|
|
|
|
|
"`Modes d'arrondi`_."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1036
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Les champs *traps* et *flags* répertorient tous les signaux à définir. En "
|
|
|
|
|
"général, les nouveaux contextes ne doivent qu'activer des surveillances et "
|
|
|
|
|
"laisser les drapeaux baissés."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1039
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The *Emin* and *Emax* fields are integers specifying the outer limits "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"allowable for exponents. *Emin* must be in the range [:const:`MIN_EMIN`, "
|
|
|
|
|
"``0``], *Emax* in the range [``0``, :const:`MAX_EMAX`]."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Les champs *Emin* et *Emax* sont des entiers spécifiant les valeurs limites "
|
|
|
|
|
"autorisées pour les exposants. *Emin* doit être dans [:const:`MIN_EMIN`, "
|
|
|
|
|
"``0``], *Emax* dans la plage [``0``, :const:`MAX_EMAX`]."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1043
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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')``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Le champ *capitals* est soit ``0`` soit ``1`` (la valeur par défaut). S'il "
|
|
|
|
|
"est défini à ``1``, les exposants sont imprimés avec un ``E`` majuscule ; "
|
|
|
|
|
"sinon, un ``e`` minuscule est utilisé : ``Decimal('6.02e+23')``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1047
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Le champ *clamp* est soit ``0`` (la valeur par défaut), soit ``1``. S'il est "
|
|
|
|
|
"défini à ``1``, l'exposant ``e`` d'une instance :class:`Decimal` "
|
|
|
|
|
"représentable dans ce contexte est strictement limité à la plage ``Emin - "
|
|
|
|
|
"prec + 1 <= e <= Emax - prec + 1``. Si *clamp* est ``0`` alors une condition "
|
|
|
|
|
"plus faible est vraie : l'exposant ajusté de l'instance :class:`Decimal` est "
|
|
|
|
|
"au plus :attr:`~Context.Emax`. Lorsque *clamp* vaut ``1``, un grand nombre "
|
|
|
|
|
"normal voit, si possible, son exposant réduit et un nombre correspondant de "
|
|
|
|
|
"zéros ajouté à sa mantisse, afin de s'adapter aux contraintes d'exposant ; "
|
|
|
|
|
"cela préserve la valeur du nombre mais perd des informations sur les zéros "
|
|
|
|
|
"significatifs. Par exemple ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1062
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"A *clamp* value of ``1`` allows compatibility with the fixed-width decimal "
|
|
|
|
|
"interchange formats specified in IEEE 754."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Une valeur *clamp* de ``1`` permet la compatibilité avec les formats "
|
|
|
|
|
"d'échange décimaux à largeur fixe spécifiés dans la norme IEEE 754."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1065
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"La classe :class:`Context` définit plusieurs méthodes à usage général ainsi "
|
|
|
|
|
"qu'un grand nombre de méthodes permettant de faire de l'arithmétique "
|
|
|
|
|
"directement dans un contexte donné. De plus, pour chacune des méthodes :"
|
|
|
|
|
"class:`Decimal` décrites ci-dessus (à l'exception des méthodes :meth:"
|
2023-12-07 22:10:56 +00:00
|
|
|
|
"`~Decimal.adjusted` et :meth:`~Decimal.as_tuple`), il existe une méthode :"
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"class:`Context` correspondante. Par exemple, pour une instance :class:"
|
|
|
|
|
"`Context` ``C`` et une instance :class:`Decimal` ``x``, ``C.exp(x)`` est "
|
|
|
|
|
"équivalent à ``x.exp(context=C)``. Chaque méthode :class:`Context` accepte "
|
|
|
|
|
"un entier Python (une instance de :class:`int`) partout où une instance "
|
|
|
|
|
"Decimal est acceptée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1078
|
2023-04-14 11:20:40 +00:00
|
|
|
|
msgid "Resets all of the flags to ``0``."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Réinitialise tous les drapeaux à ``0``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1082
|
2023-04-14 11:20:40 +00:00
|
|
|
|
msgid "Resets all of the traps to ``0``."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Réinitialise toutes les surveillances à ``0``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1088
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Return a duplicate of the context."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie une copie du contexte."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1092
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Return a copy of the Decimal instance num."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie une copie du numéro d’instance *Decimal*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1096
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Crée une nouvelle instance Decimal à partir de *num* mais en utilisant "
|
|
|
|
|
"*self* comme contexte. Contrairement au constructeur :class:`Decimal`, la "
|
|
|
|
|
"précision du contexte, la méthode d'arrondi, les indicateurs et les "
|
|
|
|
|
"surveillances sont appliqués à la conversion."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1100
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"C'est utile car les constantes sont souvent données avec une précision "
|
|
|
|
|
"supérieure à celle requise par l'application. Un autre avantage est que "
|
|
|
|
|
"l’arrondi élimine immédiatement les effets involontaires des chiffres au-"
|
|
|
|
|
"delà de la précision actuelle. Dans l'exemple suivant, l'utilisation "
|
|
|
|
|
"d'entrées non arrondies signifie que l'ajout de zéro à une somme peut "
|
|
|
|
|
"modifier le résultat :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1114
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Cette méthode implémente l'opération *to-number* de la spécification IBM. Si "
|
|
|
|
|
"l’argument est une chaîne, aucun espace ou trait de soulignement de début ou "
|
|
|
|
|
"de fin n’est autorisé."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1120
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-07 22:10:56 +00:00
|
|
|
|
"Crée une nouvelle instance Decimal à partir d'un *float* *f* mais en "
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"arrondissant en utilisant *self* comme contexte. Contrairement à la méthode "
|
|
|
|
|
"de classe :meth:`Decimal.from_float`, la précision du contexte, la méthode "
|
|
|
|
|
"d'arrondi, les indicateurs et les surveillances sont appliqués à la "
|
|
|
|
|
"conversion."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1140
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Renvoie une valeur égale à ``Emin - prec + 1`` qui est la valeur minimale de "
|
|
|
|
|
"l'exposant pour les résultats avec dépassement inférieur. Lorsqu'un "
|
|
|
|
|
"dépassement inférieur se produit, l'exposant est défini sur :const:`Etiny`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1146
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns a value equal to ``Emax - prec + 1``."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie une valeur égale à ``Emax - prec + 1``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1148
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"L'approche habituelle pour travailler avec des décimaux consiste à créer des "
|
|
|
|
|
"instances :class:`Decimal`, puis à appliquer des opérations arithmétiques "
|
|
|
|
|
"qui ont lieu dans le contexte actuel du fil d'exécution actif. Une approche "
|
|
|
|
|
"alternative consiste à utiliser des méthodes contextuelles pour calculer "
|
|
|
|
|
"dans un contexte spécifique. Les méthodes sont similaires à celles de la "
|
|
|
|
|
"classe :class:`Decimal` et ne sont décrites que brièvement ici."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1158
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns the absolute value of *x*."
|
|
|
|
|
msgstr "Renvoie la valeur absolue de *x*."
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1163
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Return the sum of *x* and *y*."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie la somme de *x* et *y*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1168
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns the same Decimal object *x*."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie l'objet Decimal *x* lui-même."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1173
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Compares *x* and *y* numerically."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Compare *x* et *y* numériquement."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1178
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Compares the values of the two operands numerically."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Compare numériquement les valeurs des deux opérandes."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1183
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Compares two operands using their abstract representation."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Compare deux opérandes en utilisant leur représentation abstraite."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1188
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Compares two operands using their abstract representation, ignoring sign."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Compare deux opérandes en utilisant leur représentation abstraite, en "
|
|
|
|
|
"ignorant le signe."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1193
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns a copy of *x* with the sign set to 0."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie une copie de *x* avec le signe à 0 (c.-à-d. positif)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1198
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns a copy of *x* with the sign inverted."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie une copie de *x* mais de signe opposé."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1203
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Copies the sign from *y* to *x*."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Copie le signe de *y* vers *x*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1208
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Return *x* divided by *y*."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie *x* divisé par *y*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1213
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Return *x* divided by *y*, truncated to an integer."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie *x* divisé par *y*, tronqué comme entier."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1218
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Divides two numbers and returns the integer part of the result."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie la partie entière de la division entre deux nombres."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1223
|
2023-01-15 21:42:07 +00:00
|
|
|
|
msgid "Returns ``e ** x``."
|
2022-11-14 15:08:57 +00:00
|
|
|
|
msgstr "Renvoie ``e ** x``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1228
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns *x* multiplied by *y*, plus *z*."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie *x* multiplié par *y*, plus *z*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1233
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns ``True`` if *x* is canonical; otherwise returns ``False``."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie ``True`` si *x* est canonique ; ``False`` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1238
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns ``True`` if *x* is finite; otherwise returns ``False``."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie ``True`` si *x* est fini ; ``False`` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1243
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns ``True`` if *x* is infinite; otherwise returns ``False``."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie ``True`` si *x* est infini et ``False`` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1248
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns ``True`` if *x* is a qNaN or sNaN; otherwise returns ``False``."
|
|
|
|
|
msgstr ""
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"Renvoie ``True`` si *x* est un *NaN* (silencieux ou signalétique), ``False`` "
|
2023-01-15 21:42:07 +00:00
|
|
|
|
"sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1253
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Returns ``True`` if *x* is a normal number; otherwise returns ``False``."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie ``True`` si *x* est un nombre normal ; ``False`` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1258
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns ``True`` if *x* is a quiet NaN; otherwise returns ``False``."
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Renvoie ``True`` si *x* est un *NaN* silencieux, ``False`` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1263
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns ``True`` if *x* is negative; otherwise returns ``False``."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie ``True`` si *x* est négatif et ``False`` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1268
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Returns ``True`` if *x* is a signaling NaN; otherwise returns ``False``."
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Renvoie ``True`` si *x* est un *NaN* signalétique, ``False`` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1273
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns ``True`` if *x* is subnormal; otherwise returns ``False``."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie ``True`` si *x* est anormal ; sinon, renvoie ``False``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1278
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns ``True`` if *x* is a zero; otherwise returns ``False``."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie ``True`` si *x* est un zéro et ``False`` sinon."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1283
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns the natural (base e) logarithm of *x*."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie le logarithme naturel (en base e) de *x*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1288
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns the base 10 logarithm of *x*."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie le logarithme en base 10 de *x*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1293
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns the exponent of the magnitude of the operand's MSD."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Renvoie l'exposant correspondant du chiffre de poids fort de la mantisse de "
|
|
|
|
|
"l'opérande."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1298
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Applies the logical operation *and* between each operand's digits."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Applique l'opération logique *ET* entre les chiffres de chaque opérande."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1303
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Invert all the digits in *x*."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Inverse tous les chiffres de *x*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1308
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Applies the logical operation *or* between each operand's digits."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Applique l'opération logique *OU* entre les chiffres de chaque opérande."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1313
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Applies the logical operation *xor* between each operand's digits."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Applique l'opération logique *OU EXCLUSIF* entre les chiffres de chaque "
|
|
|
|
|
"opérande."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1318
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Compares two values numerically and returns the maximum."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie le maximum entre les deux valeurs numériques."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1333
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Compares the values numerically with their sign ignored."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Compare les valeurs numériquement en ignorant leur signe."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1328
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Compares two values numerically and returns the minimum."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Compare numériquement deux valeurs et renvoie le minimum."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1338
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Minus corresponds to the unary prefix minus operator in Python."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Correspond à l’opérateur unaire préfixé « moins » en Python."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1343
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Return the product of *x* and *y*."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie la multiplication de *x* avec *y*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1348
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns the largest representable number smaller than *x*."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie le plus grand nombre représentable inférieur à *x*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1353
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns the smallest representable number larger than *x*."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie le plus petit nombre représentable supérieur à *x*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1358
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns the number closest to *x*, in direction towards *y*."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie le nombre le plus proche de *x*, en direction de *y*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1363
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Reduces *x* to its simplest form."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Réduit *x* à sa forme la plus simple."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1368
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns an indication of the class of *x*."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie une indication de la classe de *x*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1373
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Correspond à l'opérateur unaire préfixé « plus » en Python. Cette opération "
|
|
|
|
|
"applique la précision du contexte et l'arrondi, ce n'est donc *pas* une "
|
|
|
|
|
"opération d'identité."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1380
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Return ``x`` to the power of ``y``, reduced modulo ``modulo`` if given."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Renvoie ``x`` à la puissance ``y``, réduit modulo ``modulo`` si celui-ci est "
|
|
|
|
|
"donné."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1382
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 "
|
2023-01-15 21:42:07 +00:00
|
|
|
|
"rounding mode of the context is used. Results are always correctly rounded "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"in the Python version."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Avec deux arguments, calcule ``x**y``. Si ``x`` est négatif alors ``y`` doit "
|
|
|
|
|
"être entier. Le résultat est inexact à moins que ``y`` soit entier et que le "
|
|
|
|
|
"résultat soit fini et puisse être exprimé exactement en ``precision`` "
|
|
|
|
|
"chiffres. Le mode d'arrondi du contexte est utilisé. Les résultats sont "
|
|
|
|
|
"toujours correctement arrondis à la manière de Python."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1388
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2020-09-11 07:11:46 +00:00
|
|
|
|
"``Decimal(0) ** Decimal(0)`` results in ``InvalidOperation``, and if "
|
|
|
|
|
"``InvalidOperation`` is not trapped, then results in ``Decimal('NaN')``."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"``Decimal(0) ** Decimal(0)`` donne ``InvalidOperation`` et, si "
|
|
|
|
|
"``InvalidOperation`` n'est pas surveillé, cela donne ``Decimal('NaN')``."
|
2020-09-11 07:11:46 +00:00
|
|
|
|
|
2023-12-06 22:58:00 +00:00
|
|
|
|
# suit un :
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1391
|
2020-09-11 07:11:46 +00:00
|
|
|
|
msgid ""
|
2023-01-15 21:42:07 +00:00
|
|
|
|
"The C module computes :meth:`power` in terms of the correctly rounded :meth:"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"`exp` and :meth:`ln` functions. The result is well-defined but only \"almost "
|
2023-01-15 21:42:07 +00:00
|
|
|
|
"always correctly rounded\"."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"le module C calcule :meth:`power` en termes de fonctions :meth:`exp` et :"
|
|
|
|
|
"meth:`ln` correctement arrondies. Le résultat est bien défini mais seulement "
|
|
|
|
|
"« presque toujours correctement arrondi »."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1396
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"With three arguments, compute ``(x**y) % modulo``. For the three argument "
|
|
|
|
|
"form, the following restrictions on the arguments hold:"
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Avec trois arguments, calcule ``(x**y) % modulo``. Pour la forme à trois "
|
|
|
|
|
"arguments, les restrictions suivantes sur les arguments s'appliquent :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1399
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "all three arguments must be integral"
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "les trois arguments doivent être entiers ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-30 10:13:38 +00:00
|
|
|
|
# Élément d'une liste, d'où le ; final
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1400
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "``y`` must be nonnegative"
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "``y`` ne doit pas être négatif ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2022-05-30 10:13:38 +00:00
|
|
|
|
# Élément d'une liste, d'où le ; final
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1401
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "at least one of ``x`` or ``y`` must be nonzero"
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "au moins l'un de ``x`` ou ``y`` doit être différent de zéro ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1402
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "``modulo`` must be nonzero and have at most 'precision' digits"
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"``modulo`` doit être différent de zéro et avoir au plus ``precision`` "
|
|
|
|
|
"chiffres."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1404
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"La valeur résultant de ``Context.power(x, y, modulo)`` est égale à la valeur "
|
|
|
|
|
"qui serait obtenue en calculant ``(x**y) % modulo`` avec une précision "
|
|
|
|
|
"illimitée, mais est calculée plus efficacement. L'exposant du résultat est "
|
|
|
|
|
"zéro, quels que soient les exposants de ``x``, ``y`` et ``modulo``. Le "
|
|
|
|
|
"résultat est toujours exact."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1414
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns a value equal to *x* (rounded), having the exponent of *y*."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie une valeur égale à *x* (arrondie), ayant l'exposant de *y*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1419
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Just returns 10, as this is Decimal, :)"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Renvoie 10 car c'est *Decimal*, :)"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1424
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns the remainder from integer division."
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "Renvoie le reste de la division entière."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1426
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The sign of the result, if non-zero, is the same as that of the original "
|
|
|
|
|
"dividend."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Le signe du résultat, s'il est différent de zéro, est le même que celui du "
|
|
|
|
|
"dividende initial."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1432
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Renvoie ``x - y * n``, où *n* est l'entier le plus proche de la valeur "
|
|
|
|
|
"exacte de ``x / y`` (si le résultat est 0 alors son signe est le signe de "
|
|
|
|
|
"*x*)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1438
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns a rotated copy of *x*, *y* times."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie une copie pivotée de *x*, *y* fois."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1443
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns ``True`` if the two operands have the same exponent."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Renvoie ``True`` si les deux opérandes ont le même exposant."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1448
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns the first operand after adding the second value its exp."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Renvoie le premier opérande après avoir ajouté la deuxième valeur à son "
|
|
|
|
|
"*exp*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1453
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Returns a shifted copy of *x*, *y* times."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie une copie décalée de *x*, *y* fois."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1458
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Square root of a non-negative number to context precision."
|
|
|
|
|
msgstr ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Renvoie la racine carrée d'un nombre non négatif avec la précision donnée "
|
|
|
|
|
"par le contexte."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1463
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Return the difference between *x* and *y*."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Renvoie la différence entre *x* et *y*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1477
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Rounds to an integer."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Arrondit à un entier."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1482
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Converts a number to a string using scientific notation."
|
2023-12-06 22:58:00 +00:00
|
|
|
|
msgstr "Convertit un nombre en chaîne en utilisant la notation scientifique."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1489
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Constants"
|
2017-03-05 09:57:28 +00:00
|
|
|
|
msgstr "Constantes"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1491
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2023-12-06 22:58:00 +00:00
|
|
|
|
"Les constantes de cette section ne sont pertinentes que pour le module "
|
|
|
|
|
"implémenté en C. Elles sont incluses dans la version en Python pur pour "
|
|
|
|
|
"raison de compatibilité ."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1495
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "32-bit"
|
|
|
|
|
msgstr "32-bit"
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1495
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "64-bit"
|
|
|
|
|
msgstr "64-bit"
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1499
|
2023-04-14 11:20:40 +00:00
|
|
|
|
msgid "``425000000``"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "``425000000``"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1499
|
2023-04-14 11:20:40 +00:00
|
|
|
|
msgid "``999999999999999999``"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "``999999999999999999``"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1501
|
2023-04-14 11:20:40 +00:00
|
|
|
|
msgid "``-425000000``"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "``-425000000``"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1501
|
2023-04-14 11:20:40 +00:00
|
|
|
|
msgid "``-999999999999999999``"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "``-999999999999999999``"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1503
|
2023-04-14 11:20:40 +00:00
|
|
|
|
msgid "``-849999999``"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "``-849999999``"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1503
|
2023-04-14 11:20:40 +00:00
|
|
|
|
msgid "``-1999999999999999997``"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
msgstr "``-1999999999999999997``"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1509
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2020-05-24 14:31:50 +00:00
|
|
|
|
"The value is ``True``. Deprecated, because Python now always has threads."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"La valeur est ``True``. Déprécié, parce que maintenant Python possède "
|
|
|
|
|
"toujours des fils d'exécution."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1515
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgid ""
|
2021-09-24 08:20:01 +00:00
|
|
|
|
"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."
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1520
|
2020-07-20 08:56:42 +00:00
|
|
|
|
msgid "backported to 3.7 and 3.8."
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1524
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Rounding modes"
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Modes d'arrondi"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1528
|
2023-04-14 11:20:40 +00:00
|
|
|
|
msgid "Round towards ``Infinity``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1532
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Round towards zero."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1536
|
2023-04-14 11:20:40 +00:00
|
|
|
|
msgid "Round towards ``-Infinity``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1540
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Round to nearest with ties going towards zero."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1544
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Round to nearest with ties going to nearest even integer."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1548
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Round to nearest with ties going away from zero."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1552
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Round away from zero."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1556
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Round away from zero if last digit after rounding towards zero would have "
|
|
|
|
|
"been 0 or 5; otherwise round towards zero."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1563
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Signals"
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Signaux"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1565
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Signals represent conditions that arise during computation. Each corresponds "
|
|
|
|
|
"to one context flag and one context trap enabler."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1568
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1573
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1581
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Altered an exponent to fit representation constraints."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1583
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Typically, clamping occurs when an exponent falls outside the context's :"
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"attr:`~Context.Emin` and :attr:`~Context.Emax` limits. If possible, the "
|
|
|
|
|
"exponent is reduced to fit by adding zeros to the coefficient."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1590
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Base class for other signals and a subclass of :exc:`ArithmeticError`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1595
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Signals the division of a non-infinite number by zero."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1597
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Can occur with division, modulo division, or when raising a number to a "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"negative power. If this signal is not trapped, returns ``Infinity`` or ``-"
|
|
|
|
|
"Infinity`` with the sign determined by the inputs to the calculation."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1604
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Indicates that rounding occurred and the result is not exact."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1606
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1613
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "An invalid operation was performed."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1615
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Indicates that an operation was requested that does not make sense. If not "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"trapped, returns ``NaN``. Possible causes include::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1631
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Numerical overflow."
|
2022-05-30 10:13:38 +00:00
|
|
|
|
msgstr "Débordement numérique."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1633
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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:"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"`Rounded` are also signaled."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1642
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Rounding occurred though possibly no information was lost."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1644
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Signaled whenever rounding discards digits; even if those digits are zero "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"(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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1652
|
2023-04-14 11:20:40 +00:00
|
|
|
|
msgid "Exponent was lower than :attr:`~Context.Emin` prior to rounding."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1654
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Occurs when an operation result is subnormal (the exponent is too small). If "
|
|
|
|
|
"not trapped, returns the result unchanged."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1660
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Numerical underflow with result rounded to zero."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1662
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Occurs when a subnormal result is pushed to zero by rounding. :class:"
|
|
|
|
|
"`Inexact` and :class:`Subnormal` are also signaled."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1668
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Enable stricter semantics for mixing floats and Decimals."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1670
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1678
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Otherwise (the signal is trapped), only equality comparisons and explicit "
|
|
|
|
|
"conversions are silent. All other mixed operations raise :exc:"
|
|
|
|
|
"`FloatOperation`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1682
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "The following table summarizes the hierarchy of signals::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1703
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Floating Point Notes"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1707
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Mitigating round-off error with increased precision"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1709
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The use of decimal floating point eliminates decimal representation error "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"(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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1713
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1737
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The :mod:`decimal` module makes it possible to restore the identities by "
|
|
|
|
|
"expanding the precision sufficiently to avoid loss of significance:"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1757
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Special values"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1759
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The number system for the :mod:`decimal` module provides special values "
|
2023-07-23 12:39:39 +00:00
|
|
|
|
"including ``NaN``, ``sNaN``, ``-Infinity``, ``Infinity``, and two zeros, "
|
|
|
|
|
"``+0`` and ``-0``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1763
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1768
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1772
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"Some operations are indeterminate and return ``NaN``, or if the :exc:"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"`InvalidOperation` signal is trapped, raise an exception. For example, "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"``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 "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"series of computations that occasionally have missing inputs --- it allows "
|
|
|
|
|
"the calculation to proceed while flagging specific results as invalid."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1780
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1784
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The behavior of Python's comparison operators can be a little surprising "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1797
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1802
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1817
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Working with threads"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1819
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1823
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Likewise, the :func:`setcontext` function automatically assigns its target "
|
|
|
|
|
"to the current thread."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1826
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1830
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1855
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Recipes"
|
2018-10-07 16:44:15 +00:00
|
|
|
|
msgstr "Cas pratiques"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:1857
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Here are a few recipes that serve as utility functions and that demonstrate "
|
|
|
|
|
"ways to work with the :class:`Decimal` class::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2012
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Decimal FAQ"
|
2018-10-05 16:34:13 +00:00
|
|
|
|
msgstr "FAQ *decimal*"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2014
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Q. It is cumbersome to type ``decimal.Decimal('1234.5')``. Is there a way "
|
|
|
|
|
"to minimize typing when using the interactive interpreter?"
|
|
|
|
|
msgstr ""
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"Q. C'est fastidieux de taper ``decimal.Decimal('1234.5')``. Y a-t-il un "
|
2018-10-05 16:34:13 +00:00
|
|
|
|
"moyen de réduire la frappe quand on utilise l'interpréteur interactif ?"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2017
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "A. Some users abbreviate the constructor to just a single letter:"
|
|
|
|
|
msgstr ""
|
2018-10-05 16:34:13 +00:00
|
|
|
|
"R. Certains utilisateurs abrègent le constructeur en une seule lettre :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2023
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2027
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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:"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2045
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Q. Once I have valid two place inputs, how do I maintain that invariant "
|
|
|
|
|
"throughout an application?"
|
|
|
|
|
msgstr ""
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"Q. Une fois que mes entrées sont à deux décimales valides, comment maintenir "
|
|
|
|
|
"cet invariant dans l'application ?"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2048
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"places and need to be followed-up with a :meth:`~Decimal.quantize` step:"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"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 "
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"étape :meth:`~Decimal.quantize` :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2066
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In developing fixed-point applications, it is convenient to define functions "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"to handle the :meth:`~Decimal.quantize` step:"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2022-05-30 10:13:38 +00:00
|
|
|
|
"Lors du développement d'applications en virgule fixe, il est pratique de "
|
2023-01-15 21:42:07 +00:00
|
|
|
|
"définir des fonctions pour gérer cette étape de quantification par :meth:"
|
2023-05-23 08:47:51 +00:00
|
|
|
|
"`~Decimal.quantize` :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2079
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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?"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2084
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"A. The :meth:`~Decimal.normalize` method maps all equivalent values to a "
|
|
|
|
|
"single representative:"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2091
|
|
|
|
|
msgid "Q. When does rounding occur in a computation?"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: library/decimal.rst:2093
|
|
|
|
|
msgid ""
|
|
|
|
|
"A. It occurs *after* the computation. The philosophy of the decimal "
|
|
|
|
|
"specification is that numbers are considered exact and are created "
|
|
|
|
|
"independent of the current context. They can even have greater precision "
|
|
|
|
|
"than current context. Computations process with those exact inputs and then "
|
|
|
|
|
"rounding (or other context operations) is applied to the *result* of the "
|
|
|
|
|
"computation::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: library/decimal.rst:2111
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Q. Some decimal values always print with exponential notation. Is there a "
|
|
|
|
|
"way to get a non-exponential representation?"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2114
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A. For some values, exponential notation is the only way to express the "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"number of significant places in the coefficient. For example, expressing "
|
|
|
|
|
"``5.0E+3`` as ``5000`` keeps the value constant but cannot show the "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"original's two-place significance."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2119
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2129
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Q. Is there a way to convert a regular float to a :class:`Decimal`?"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2131
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2140
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2143
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2148
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2152
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2165
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The solution is either to increase precision or to force rounding of inputs "
|
|
|
|
|
"using the unary plus operation:"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2174
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Alternatively, inputs can be rounded upon creation using the :meth:`Context."
|
|
|
|
|
"create_decimal` method:"
|
|
|
|
|
msgstr ""
|
2019-03-20 08:02:55 +00:00
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2180
|
2019-03-20 08:02:55 +00:00
|
|
|
|
msgid "Q. Is the CPython implementation fast for large numbers?"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2182
|
2019-03-20 08:02:55 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A. Yes. In the CPython and PyPy3 implementations, the C/CFFI versions of "
|
|
|
|
|
"the decimal module integrate the high speed `libmpdec <https://www.bytereef."
|
|
|
|
|
"org/mpdecimal/doc/libmpdec/index.html>`_ library for arbitrary precision "
|
2023-01-15 21:42:07 +00:00
|
|
|
|
"correctly rounded decimal floating point arithmetic [#]_. ``libmpdec`` uses "
|
2019-03-20 08:02:55 +00:00
|
|
|
|
"`Karatsuba multiplication <https://en.wikipedia.org/wiki/"
|
|
|
|
|
"Karatsuba_algorithm>`_ for medium-sized numbers and the `Number Theoretic "
|
|
|
|
|
"Transform <https://en.wikipedia.org/wiki/"
|
|
|
|
|
"Discrete_Fourier_transform_(general)#Number-theoretic_transform>`_ for very "
|
2020-05-24 14:31:50 +00:00
|
|
|
|
"large numbers."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2192
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The context must be adapted for exact arbitrary precision arithmetic. :attr:"
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"`~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."
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2196
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The easiest approach for trying out bignum arithmetic is to use the maximum "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"value for :attr:`~Context.prec` as well [#]_::"
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2205
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"For inexact results, :attr:`MAX_PREC` is far too large on 64-bit platforms "
|
|
|
|
|
"and the available memory will be insufficient::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2213
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"On systems with overallocation (e.g. Linux), a more sophisticated approach "
|
2023-04-14 11:20:40 +00:00
|
|
|
|
"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::"
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2237
|
2020-05-24 14:31:50 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2023-07-23 12:39:39 +00:00
|
|
|
|
#: library/decimal.rst:2246
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgid ""
|
2020-07-20 08:56:42 +00:00
|
|
|
|
"This approach now works for all exact results except for non-integer powers."
|
2019-03-20 08:02:55 +00:00
|
|
|
|
msgstr ""
|
2023-07-23 12:39:39 +00:00
|
|
|
|
|
|
|
|
|
#~ 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')``."
|