From 6e5243e0f599ab1d10346c80b74d13ed8c86a28a Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Thu, 7 Dec 2023 23:03:35 +0100 Subject: [PATCH] fuzzies et traduction de decimal.po - 2/2 --- dict | 1 + library/decimal.po | 275 +++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 254 insertions(+), 22 deletions(-) diff --git a/dict b/dict index 4009fdf8..c80b5204 100644 --- a/dict +++ b/dict @@ -105,6 +105,7 @@ journalisé journalisée journalisés jr. +Knuth kolams kuchling l'allocateur diff --git a/library/decimal.po b/library/decimal.po index 52c4cecd..54793c3b 100644 --- a/library/decimal.po +++ b/library/decimal.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-07-23 14:38+0200\n" -"PO-Revision-Date: 2023-05-20 20:21+0200\n" +"PO-Revision-Date: 2023-12-07 22:56+0100\n" "Last-Translator: Christophe Nanteuil \n" "Language-Team: FRENCH \n" "Language: fr\n" @@ -1985,8 +1985,8 @@ msgstr "``-1999999999999999997``" msgid "" "The value is ``True``. Deprecated, because Python now always has threads." msgstr "" -"La valeur est ``True``. Déprécié, parce que maintenant Python possède " -"toujours des fils d'exécution." +"La valeur est ``True``. C'est obsolète, car maintenant Python gère toujours " +"les fils d'exécution." #: library/decimal.rst:1515 msgid "" @@ -1996,10 +1996,16 @@ msgid "" "value is ``False``. This is slightly faster in some nested context " "scenarios." msgstr "" +"La valeur par défaut est ``True``. Si Python est :option:`configuré à l'aide " +"de l'option --without-decimal-contextvar <--without-decimal-contextvar>`, la " +"version C utilise un contexte particulier au fil d'exécution plutôt qu'un " +"contexte particulier à la coroutine et la valeur est ``False``. Ceci est " +"légèrement plus rapide dans certains scénarios où les contextes sont " +"imbriqués." #: library/decimal.rst:1520 msgid "backported to 3.7 and 3.8." -msgstr "" +msgstr "rétro-porté vers 3.7 et 3.8." #: library/decimal.rst:1524 msgid "Rounding modes" @@ -2007,37 +2013,41 @@ msgstr "Modes d'arrondi" #: library/decimal.rst:1528 msgid "Round towards ``Infinity``." -msgstr "" +msgstr "Arrondit vers ``Infinity``." #: library/decimal.rst:1532 msgid "Round towards zero." -msgstr "" +msgstr "Arrondit vers zéro." #: library/decimal.rst:1536 msgid "Round towards ``-Infinity``." -msgstr "" +msgstr "Arrondit vers ``-Infinity``." #: library/decimal.rst:1540 msgid "Round to nearest with ties going towards zero." -msgstr "" +msgstr "Arrondit au plus proche, en allant vers zéro si l'on est au milieu." #: library/decimal.rst:1544 msgid "Round to nearest with ties going to nearest even integer." msgstr "" +"Arrondit au plus proche, en allant à l'entier pair le plus proche si l'on " +"est au milieu." #: library/decimal.rst:1548 msgid "Round to nearest with ties going away from zero." -msgstr "" +msgstr "Arrondit au plus proche, en s'éloignant de zéro si l'on est au milieu." #: library/decimal.rst:1552 msgid "Round away from zero." -msgstr "" +msgstr "Arrondit en s'éloignant de zéro." #: library/decimal.rst:1556 msgid "" "Round away from zero if last digit after rounding towards zero would have " "been 0 or 5; otherwise round towards zero." msgstr "" +"Arrondit en s'éloignant de zéro si le dernier chiffre après l'arrondi vers " +"zéro aurait été 0 ou 5 ; sinon arrondit en se rapprochant de zéro." #: library/decimal.rst:1563 msgid "Signals" @@ -2048,6 +2058,9 @@ msgid "" "Signals represent conditions that arise during computation. Each corresponds " "to one context flag and one context trap enabler." msgstr "" +"Les signaux représentent les conditions qui surviennent pendant le calcul. " +"Chacun correspond à un indicateur de contexte et à un activateur de " +"surveillance contextuel." #: library/decimal.rst:1568 msgid "" @@ -2056,6 +2069,11 @@ msgid "" "to determine whether a computation was exact). After checking the flags, be " "sure to clear all flags before starting the next computation." msgstr "" +"L'indicateur de contexte est levé chaque fois que la condition est " +"rencontrée. Après le calcul, les indicateurs peuvent être vérifiés à des " +"fins d'information (par exemple, pour déterminer si un calcul était exact). " +"Après avoir vérifié les indicateurs, assurez-vous de tous les effacer avant " +"de commencer le calcul suivant." #: library/decimal.rst:1573 msgid "" @@ -2064,10 +2082,16 @@ msgid "" "`DivisionByZero` trap is set, then a :exc:`DivisionByZero` exception is " "raised upon encountering the condition." msgstr "" +"Si l'activateur de surveillance contextuel est défini pour le signal, la " +"condition provoque le déclenchement d'une exception Python. Par exemple, si " +"l'activateur de surveillance de :class:`DivisionByZero` est défini, alors " +"une exception :exc:`DivisionByZero` est levée lors de la rencontre de la " +"condition." #: library/decimal.rst:1581 msgid "Altered an exponent to fit representation constraints." msgstr "" +"Modification d'un exposant pour l'adapter aux contraintes de représentation." #: library/decimal.rst:1583 msgid "" @@ -2075,14 +2099,20 @@ msgid "" "attr:`~Context.Emin` and :attr:`~Context.Emax` limits. If possible, the " "exponent is reduced to fit by adding zeros to the coefficient." msgstr "" +"En règle générale, cela se produit lorsqu'un exposant se situe en dehors des " +"limites :attr:`~Context.Emin` et :attr:`~Context.Emax` du contexte. Si " +"possible, l'exposant est réduit pour s'adapter en ajoutant des zéros à la " +"mantisse." #: library/decimal.rst:1590 msgid "Base class for other signals and a subclass of :exc:`ArithmeticError`." msgstr "" +"Classe mère pour d'autres signaux et une sous-classe de :exc:" +"`ArithmeticError`." #: library/decimal.rst:1595 msgid "Signals the division of a non-infinite number by zero." -msgstr "" +msgstr "Signale la division d'un nombre non infini par zéro." #: library/decimal.rst:1597 msgid "" @@ -2090,10 +2120,14 @@ msgid "" "negative power. If this signal is not trapped, returns ``Infinity`` or ``-" "Infinity`` with the sign determined by the inputs to the calculation." msgstr "" +"Peut se produire lors d’une division, d’une division modulo ou lors de " +"l’élévation d’un nombre à une puissance négative. Si ce signal n'est pas " +"surveillé, renvoie ``Infinity`` ou ``-Infinity`` avec le signe déterminé par " +"les entrées du calcul." #: library/decimal.rst:1604 msgid "Indicates that rounding occurred and the result is not exact." -msgstr "" +msgstr "Indique qu'un arrondi a eu lieu et que le résultat n'est pas exact." #: library/decimal.rst:1606 msgid "" @@ -2101,16 +2135,22 @@ msgid "" "result is returned. The signal flag or trap is used to detect when results " "are inexact." msgstr "" +"Se produit lorsque des chiffres non nuls ont été supprimés lors de " +"l'arrondi. Le résultat arrondi est renvoyé. Le drapeau de signalisation ou " +"de surveillance est utilisé pour détecter lorsque les résultats sont " +"inexacts." #: library/decimal.rst:1613 msgid "An invalid operation was performed." -msgstr "" +msgstr "Une opération non valide a été effectuée." #: library/decimal.rst:1615 msgid "" "Indicates that an operation was requested that does not make sense. If not " "trapped, returns ``NaN``. Possible causes include::" msgstr "" +"Indique qu'une opération demandée n'a aucun sens. S'il n'est pas surveillé, " +"renvoie ``NaN``. Les causes possibles incluent ::" #: library/decimal.rst:1631 msgid "Numerical overflow." @@ -2124,10 +2164,17 @@ msgid "" "outward to ``Infinity``. In either case, :class:`Inexact` and :class:" "`Rounded` are also signaled." msgstr "" +"Indique que l'exposant est supérieur à :attr:`Context.Emax` après l'arrondi. " +"S'il n'est pas surveillé, le résultat dépend du mode d'arrondi, soit en " +"tirant vers l'intérieur jusqu'au plus grand nombre fini représentable, soit " +"en arrondissant vers l'extérieur à ``Infinity``. Dans les deux cas, :class:" +"`Inexact` et :class:`Rounded` sont également signalés." #: library/decimal.rst:1642 msgid "Rounding occurred though possibly no information was lost." msgstr "" +"Des arrondis ont eu lieu, même s'il est possible qu'aucune information n'ait " +"été perdue." #: library/decimal.rst:1644 msgid "" @@ -2135,30 +2182,41 @@ msgid "" "(such as rounding ``5.00`` to ``5.0``). If not trapped, returns the result " "unchanged. This signal is used to detect loss of significant digits." msgstr "" +"Signalé chaque fois que l'arrondi supprime des chiffres ; même si ces " +"chiffres sont nuls (par exemple en arrondissant ``5.00`` à ``5.0``). S'il " +"n'est pas surveillé, renvoie le résultat inchangé. Ce signal est utilisé " +"pour détecter la perte de chiffres significatifs." #: library/decimal.rst:1652 msgid "Exponent was lower than :attr:`~Context.Emin` prior to rounding." -msgstr "" +msgstr "L'exposant était inférieur à :attr:`~Context.Emin` avant l'arrondi." #: library/decimal.rst:1654 msgid "" "Occurs when an operation result is subnormal (the exponent is too small). If " "not trapped, returns the result unchanged." msgstr "" +"Se produit lorsque le résultat d'une opération est inférieur à la normale " +"(l'exposant est trop petit). S'il n'est pas surveillé, renvoie le résultat " +"inchangé." #: library/decimal.rst:1660 msgid "Numerical underflow with result rounded to zero." -msgstr "" +msgstr "Sous-dépassement numérique avec résultat arrondi à zéro." #: library/decimal.rst:1662 msgid "" "Occurs when a subnormal result is pushed to zero by rounding. :class:" "`Inexact` and :class:`Subnormal` are also signaled." msgstr "" +"Se produit lorsqu'un résultat anormal est ramené à zéro par arrondi. :class:" +"`Inexact` et :class:`Subnormal` sont également signalés." #: library/decimal.rst:1668 msgid "Enable stricter semantics for mixing floats and Decimals." msgstr "" +"Active une sémantique plus stricte pour mélanger les flottants et les " +"décimaux." #: library/decimal.rst:1670 msgid "" @@ -2170,6 +2228,14 @@ msgid "" "conversions with :meth:`~decimal.Decimal.from_float` or :meth:`~decimal." "Context.create_decimal_from_float` do not set the flag." msgstr "" +"Si le signal n'est pas surveillé (par défaut), le mélange de flottants et de " +"décimaux est autorisé dans le constructeur :class:`~decimal.Decimal`, :meth:" +"`~decimal.Context.create_decimal` et tous les opérateurs de comparaison. La " +"conversion et les comparaisons sont exactes. Toute occurrence d'une " +"opération mixte est enregistrée silencieusement en levant :exc:" +"`FloatOperation` dans les indicateurs de contexte. Les conversions " +"explicites avec :meth:`~decimal.Decimal.from_float` ou :meth:`~decimal." +"Context.create_decimal_from_float` ne lèvent pas l'indicateur." #: library/decimal.rst:1678 msgid "" @@ -2177,18 +2243,21 @@ msgid "" "conversions are silent. All other mixed operations raise :exc:" "`FloatOperation`." msgstr "" +"Sinon (le signal est surveillé), seules les comparaisons d'égalité et les " +"conversions explicites sont silencieuses. Toutes les autres opérations " +"mixtes lèvent :exc:`FloatOperation`." #: library/decimal.rst:1682 msgid "The following table summarizes the hierarchy of signals::" -msgstr "" +msgstr "Le tableau suivant résume la hiérarchie des signaux ::" #: library/decimal.rst:1703 msgid "Floating Point Notes" -msgstr "" +msgstr "Notes pour les nombres à virgule flottante" #: library/decimal.rst:1707 msgid "Mitigating round-off error with increased precision" -msgstr "" +msgstr "Atténuation des erreurs d'arrondi avec une précision accrue" #: library/decimal.rst:1709 msgid "" @@ -2197,6 +2266,10 @@ msgid "" "can still incur round-off error when non-zero digits exceed the fixed " "precision." msgstr "" +"L'utilisation de la virgule flottante décimale élimine l'erreur de " +"représentation décimale (ce qui permet de représenter ``0.1`` exactement) ; " +"cependant, certaines opérations peuvent toujours entraîner une erreur " +"d'arrondi lorsque des chiffres non nuls dépassent la précision fixée." #: library/decimal.rst:1713 msgid "" @@ -2206,16 +2279,24 @@ msgid "" "floating point arithmetic with insufficient precision causes the breakdown " "of the associative and distributive properties of addition:" msgstr "" +"Les effets de l’erreur d’arrondi peuvent être amplifiés par l’ajout ou la " +"soustraction de quantités proches de la limite d'arrondi, entraînant une " +"perte de précision. Knuth fournit deux exemples instructifs où " +"l'arithmétique à virgule flottante arrondie avec une précision insuffisante " +"provoque la rupture des propriétés associatives et distributives de " +"l'addition :" #: library/decimal.rst:1737 msgid "" "The :mod:`decimal` module makes it possible to restore the identities by " "expanding the precision sufficiently to avoid loss of significance:" msgstr "" +"Le module :mod:`decimal` permet de rétablir les identités en étendant " +"suffisamment la précision pour éviter la perte de précision :" #: library/decimal.rst:1757 msgid "Special values" -msgstr "" +msgstr "Valeurs spéciales" #: library/decimal.rst:1759 msgid "" @@ -2223,6 +2304,9 @@ msgid "" "including ``NaN``, ``sNaN``, ``-Infinity``, ``Infinity``, and two zeros, " "``+0`` and ``-0``." msgstr "" +"La représentation des nombres du module :mod:`decimal` fournit des valeurs " +"spéciales, notamment ``NaN``, ``sNaN``, ``-Infinity``, ``Infinity`` et deux " +"zéros, ``+0` ` et ``-0``." #: library/decimal.rst:1763 msgid "" @@ -2232,6 +2316,11 @@ msgid "" "infinity can result from rounding beyond the limits of the largest " "representable number." msgstr "" +"Les infinis peuvent être construits directement avec " +"``Decimal('Infinity')``. En outre, ils peuvent résulter d'une division par " +"zéro lorsque le signal :exc:`DivisionByZero` n'est pas surveillé. De même, " +"lorsque le signal :exc:`Overflow` n'est pas surveillé, l'infini peut " +"résulter d'un arrondi au-delà des limites du plus grand nombre représentable." #: library/decimal.rst:1768 msgid "" @@ -2239,6 +2328,10 @@ msgid "" "where they get treated as very large, indeterminate numbers. For instance, " "adding a constant to infinity gives another infinite result." msgstr "" +"Les infinis sont signés (raffinés) et peuvent être utilisés dans des " +"opérations arithmétiques où ils sont traités comme de très grands nombres " +"indéterminés. Par exemple, ajouter une constante à l’infini donne un autre " +"résultat infini." #: library/decimal.rst:1772 msgid "" @@ -2250,6 +2343,14 @@ msgid "" "series of computations that occasionally have missing inputs --- it allows " "the calculation to proceed while flagging specific results as invalid." msgstr "" +"Certaines opérations sont indéterminées et renvoient ``NaN`` ou, si le " +"signal :exc:`InvalidOperation` est surveillé, déclenchent une exception. Par " +"exemple, ``0/0`` renvoie ``NaN`` qui signifie « pas un nombre » (*not a " +"number* en anglais). Cette espèce de ``NaN`` est silencieuse et, une fois " +"créée, elle peut intervenir dans d'autres calculs, aboutissant toujours à un " +"autre ``NaN``. Ce comportement peut être utile pour une série de calculs qui " +"comportent parfois des entrées manquantes : il permet au calcul de se " +"poursuivre tout en indiquant que les résultats ne sont pas valides." #: library/decimal.rst:1780 msgid "" @@ -2257,6 +2358,10 @@ msgid "" "operation. This is a useful return value when an invalid result needs to " "interrupt a calculation for special handling." msgstr "" +"Une variante est ``sNaN`` qui lève un signal plutôt que de rester silencieux " +"après chaque opération. Il s'agit d'une valeur de retour utile lorsqu'un " +"résultat non valide doit interrompre un calcul pour effectuer un traitement " +"spécial." #: library/decimal.rst:1784 msgid "" @@ -2274,6 +2379,20 @@ msgid "" "standards-compliance, use the :meth:`~Decimal.compare` and :meth:`~Decimal." "compare_signal` methods instead." msgstr "" +"Le comportement des opérateurs de comparaison de Python peut être un peu " +"surprenant lorsqu'un ``NaN`` est impliqué. Un test d'égalité où l'un des " +"opérandes est un ``NaN`` silencieux ou de signalisation renvoie toujours :" +"const:`False` (même en faisant ``Decimal('NaN')==Decimal('NaN')``) , tandis " +"qu'un test d'inégalité renvoie toujours :const:`True`. Une tentative de " +"comparaison de deux *Decimals* en utilisant l'un des opérateurs ``<``, " +"``<=``, ``>`` ou ``>=`` lève une :exc:`InvalidOperation` si l'un ou l'autre " +"des opérandes est un ``NaN``, et renvoie :const:`False` si ce signal n'est " +"pas surveillé. Notez que la spécification General Decimal Arithmetic ne " +"spécifie pas le comportement des comparaisons directes ; ces règles de " +"comparaison impliquant un ``NaN`` sont tirées de la norme IEEE 854 (voir " +"tableau 3 dans la section 5.7). Pour garantir une stricte conformité aux " +"normes, utilisez plutôt les méthodes :meth:`~Decimal.compare` et :meth:" +"`~Decimal.compare_signal`." #: library/decimal.rst:1797 msgid "" @@ -2282,6 +2401,10 @@ msgid "" "greater precision. Since their magnitude is zero, both positive and " "negative zeros are treated as equal and their sign is informational." msgstr "" +"Les zéros signés peuvent résulter de calculs qui débordent. Ils gardent le " +"signe qui aurait résulté si le calcul avait été effectué avec plus de " +"précision. Puisque leur grandeur est nulle, les zéros positifs et négatifs " +"sont traités comme égaux et leur signe est informatif." #: library/decimal.rst:1802 msgid "" @@ -2291,10 +2414,15 @@ msgid "" "normalized floating point representations, it is not immediately obvious " "that the following calculation returns a value equal to zero:" msgstr "" +"En plus des deux zéros signés, distincts mais égaux, il existe diverses " +"représentations du zéro avec des précisions différentes mais de valeur " +"équivalente. Cela prend un peu de temps pour s’y habituer. Pour un œil " +"habitué aux représentations normalisées à virgule flottante, il n’est pas " +"immédiatement évident que le calcul suivant renvoie une valeur égale à zéro :" #: library/decimal.rst:1817 msgid "Working with threads" -msgstr "" +msgstr "Travailler avec plusieurs fils d'exécution" #: library/decimal.rst:1819 msgid "" @@ -2303,12 +2431,18 @@ msgid "" "make changes (such as ``getcontext().prec=10``) without interfering with " "other threads." msgstr "" +"La fonction :func:`getcontext` accède à un objet :class:`Context` différent " +"pour chaque fil d'exécution. Avoir des contextes de fil d'exécution séparés " +"signifie que les fils peuvent apporter des modifications (telles que " +"``getcontext().prec=10``) sans interférer avec les autres fils." #: library/decimal.rst:1823 msgid "" "Likewise, the :func:`setcontext` function automatically assigns its target " "to the current thread." msgstr "" +"De même, la fonction :func:`setcontext` assigne automatiquement sa cible au " +"fil d'exécution actuel." #: library/decimal.rst:1826 msgid "" @@ -2316,6 +2450,9 @@ msgid "" "func:`getcontext` will automatically create a new context for use in the " "current thread." msgstr "" +"Si :func:`setcontext` n'a pas été appelé avant :func:`getcontext`, alors :" +"func:`getcontext` crée automatiquement un nouveau contexte à utiliser dans " +"le fil actuel." #: library/decimal.rst:1830 msgid "" @@ -2325,6 +2462,12 @@ msgid "" "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 "" +"Le nouveau contexte est copié à partir d'un contexte prototype appelé " +"*DefaultContext*. Pour contrôler les valeurs par défaut afin que chaque fil " +"utilise les mêmes valeurs dans toute l'application, modifiez directement " +"l'objet *DefaultContext*. Cela doit être fait *avant* que les fil " +"d'exécution ne soient démarrés afin qu'il n'y ait pas de condition de " +"concurrence entre les fils appelant :func:`getcontext`. Par exemple ::" #: library/decimal.rst:1855 msgid "Recipes" @@ -2335,6 +2478,8 @@ msgid "" "Here are a few recipes that serve as utility functions and that demonstrate " "ways to work with the :class:`Decimal` class::" msgstr "" +"Voici quelques exemples de fonctions utilitaires qui montrent comment " +"travailler avec la classe :class:`Decimal` ::" #: library/decimal.rst:2012 msgid "Decimal FAQ" @@ -2345,7 +2490,7 @@ msgid "" "Q. It is cumbersome to type ``decimal.Decimal('1234.5')``. Is there a way " "to minimize typing when using the interactive interpreter?" msgstr "" -"Q. C'est fastidieux de taper ``decimal.Decimal('1234.5')``. Y a-t-il un " +"Q. Il est fastidieux de taper ``decimal.Decimal('1234.5')``. Y a-t-il un " "moyen de réduire la frappe quand on utilise l'interpréteur interactif ?" #: library/decimal.rst:2017 @@ -2359,6 +2504,10 @@ msgid "" "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 "" +"Q. Dans une application à virgule fixe avec deux décimales, certaines " +"entrées comportent plusieurs chiffres excédentaires et doivent être " +"arrondies. D'autres ne sont pas censées avoir de chiffres excédentaires et " +"doivent être validées. Quelles méthodes utiliser ?" #: library/decimal.rst:2027 msgid "" @@ -2366,6 +2515,9 @@ msgid "" "places. If the :const:`Inexact` trap is set, it is also useful for " "validation:" msgstr "" +"R. La méthode :meth:`~Decimal.quantize` arrondit à un nombre fixe de " +"décimales. Si la surveillance de :const:`Inexact` est définie, elle est " +"aussi utile pour la validation :" #: library/decimal.rst:2045 msgid "" @@ -2404,16 +2556,22 @@ msgid "" "precisions. Is there a way to transform them to a single recognizable " "canonical value?" msgstr "" +"Q. Il existe de nombreuses façons d’exprimer la même valeur. Les nombres " +"``200``, ``200.000``, ``2E2`` et ``.02E+4`` ont tous la même valeur à " +"différentes précisions. Existe-t-il un moyen de les transformer en une seule " +"valeur canonique reconnaissable ?" #: library/decimal.rst:2084 msgid "" "A. The :meth:`~Decimal.normalize` method maps all equivalent values to a " "single representative:" msgstr "" +"R. La méthode :meth:`~Decimal.normalize` transforme toutes les valeurs " +"équivalentes en un seul représentant :" #: library/decimal.rst:2091 msgid "Q. When does rounding occur in a computation?" -msgstr "" +msgstr "Q. Quand l’arrondi se produit-il dans un calcul ?" #: library/decimal.rst:2093 msgid "" @@ -2424,12 +2582,21 @@ msgid "" "rounding (or other context operations) is applied to the *result* of the " "computation::" msgstr "" +"R. Il se produit *après* le calcul. La philosophie de la spécification " +"décimale est que les nombres sont considérés comme exacts et sont créés " +"indépendamment du contexte actuel. Ils peuvent même avoir une plus grande " +"précision que le contexte actuel. Le processus effectue les calculs avec ces " +"entrées exactes, puis l'arrondi (ou d'autres opérations contextuelles) est " +"appliqué au *résultat* du calcul ::" #: library/decimal.rst:2111 msgid "" "Q. Some decimal values always print with exponential notation. Is there a " "way to get a non-exponential representation?" msgstr "" +"Q. Certaines valeurs décimales s'impriment toujours avec une notation " +"exponentielle. Existe-t-il un moyen d'obtenir une représentation non " +"exponentielle ?" #: library/decimal.rst:2114 msgid "" @@ -2438,6 +2605,10 @@ msgid "" "``5.0E+3`` as ``5000`` keeps the value constant but cannot show the " "original's two-place significance." msgstr "" +"R. Pour certaines valeurs, la notation exponentielle est la seule façon " +"d'exprimer le nombre de chiffres significatifs dans la mantisse. Par " +"exemple, exprimer ``5.0E+3`` par ``5000`` maintient la valeur constante mais " +"ne peut pas montrer les deux chiffres significatifs de l'original." #: library/decimal.rst:2119 msgid "" @@ -2445,10 +2616,15 @@ msgid "" "remove the exponent and trailing zeroes, losing significance, but keeping " "the value unchanged:" msgstr "" +"Si une application ne se soucie pas du maintien du nombre de chiffres " +"significatifs, il est facile de supprimer l'exposant et les zéros de fin, ce " +"qui modifie le nombre de chiffres significatifs, mais garde la valeur " +"inchangée :" #: library/decimal.rst:2129 msgid "Q. Is there a way to convert a regular float to a :class:`Decimal`?" msgstr "" +"Q. Existe-t-il un moyen de convertir un *float* normal en :class:`Decimal` ?" #: library/decimal.rst:2131 msgid "" @@ -2456,12 +2632,18 @@ msgid "" "Decimal though an exact conversion may take more precision than intuition " "would suggest:" msgstr "" +"R. Oui, tout nombre à virgule flottante *float* peut être exprimé exactement " +"sous forme décimale, bien qu'une conversion exacte puisse nécessiter plus de " +"précision que ne le suggère l'intuition :" #: library/decimal.rst:2140 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 "" +"Q. Dans un calcul complexe, comment puis-je m'assurer que je n'ai pas obtenu " +"de résultat erroné en raison d'un manque de précision ou d'anomalies " +"d'arrondi." #: library/decimal.rst:2143 msgid "" @@ -2470,6 +2652,11 @@ msgid "" "Widely differing results indicate insufficient precision, rounding mode " "issues, ill-conditioned inputs, or a numerically unstable algorithm." msgstr "" +"R. Le module *decimal* facilite le test des résultats. Une bonne pratique " +"consiste à refaire les calculs avec une plus grande précision et avec " +"différents modes d'arrondi. Des résultats très différents indiquent une " +"précision insuffisante, des problèmes de mode d'arrondi, des entrées mal " +"conditionnées ou un algorithme numériquement instable." #: library/decimal.rst:2148 msgid "" @@ -2477,6 +2664,9 @@ msgid "" "but not to the inputs. Is there anything to watch out for when mixing " "values of different precisions?" msgstr "" +"Q. J'ai remarqué que la précision du contexte est appliquée aux résultats " +"des opérations mais pas aux entrées. Y a-t-il quelque chose à surveiller " +"lors du mélange de valeurs de précisions différentes ?" #: library/decimal.rst:2152 msgid "" @@ -2486,22 +2676,32 @@ msgid "" "disadvantage is that the results can look odd if you forget that the inputs " "haven't been rounded:" msgstr "" +"R. Oui. Le principe est que toutes les valeurs sont considérées comme " +"exactes, tout comme l’arithmétique sur ces valeurs. Seuls les résultats sont " +"arrondis. L'avantage des entrées est que « ce que vous tapez est ce que vous " +"obtenez ». Un inconvénient est que les résultats peuvent paraître étranges " +"si vous oubliez que les entrées n'ont pas été arrondies :" #: library/decimal.rst:2165 msgid "" "The solution is either to increase precision or to force rounding of inputs " "using the unary plus operation:" msgstr "" +"La solution consiste soit à augmenter la précision, soit à forcer l'arrondi " +"des entrées à l'aide de l'opération unaire plus :" #: library/decimal.rst:2174 msgid "" "Alternatively, inputs can be rounded upon creation using the :meth:`Context." "create_decimal` method:" msgstr "" +"Autrement, les entrées peuvent être arrondies lors de la création à l'aide " +"de la méthode :meth:`Context.create_decimal` :" #: library/decimal.rst:2180 msgid "Q. Is the CPython implementation fast for large numbers?" msgstr "" +"Q. L'implémentation de CPython est-elle rapide pour les grands nombres ?" #: library/decimal.rst:2182 msgid "" @@ -2515,6 +2715,16 @@ msgid "" "Discrete_Fourier_transform_(general)#Number-theoretic_transform>`_ for very " "large numbers." msgstr "" +"R. Oui. Dans les implémentations CPython et PyPy3, les versions C/CFFI du " +"module décimal intègrent correctement la bibliothèque haute vitesse " +"`libmpdec `_ " +"pour une précision arbitraire en arithmétique à virgule flottante décimale " +"arrondie [#]_. ``libmpdec`` utilise la `multiplication Karatsuba `_ pour les nombres de taille " +"moyenne et la `transformation de Fourier discrète `_ " +"pour les très grands nombres." #: library/decimal.rst:2192 msgid "" @@ -2523,18 +2733,28 @@ msgid "" "maximum values, :attr:`~Context.clamp` should always be 0 (the default). " "Setting :attr:`~Context.prec` requires some care." msgstr "" +"Le contexte doit être adapté pour une arithmétique de précision arbitraire " +"exacte. :attr:`~Context.Emin` et :attr:`~Context.Emax` doivent toujours être " +"définis sur les valeurs maximales, :attr:`~Context.clamp` doit toujours être " +"0 (valeur par défaut). Le réglage de :attr:`~Context.prec` nécessite une " +"certaine prudence." #: library/decimal.rst:2196 msgid "" "The easiest approach for trying out bignum arithmetic is to use the maximum " "value for :attr:`~Context.prec` as well [#]_::" msgstr "" +"L'approche la plus simple pour essayer l'arithmétique sur les grands nombres " +"est d'utiliser également la valeur maximale pour :attr:`~Context.prec` " +"[#]_ ::" #: library/decimal.rst:2205 msgid "" "For inexact results, :attr:`MAX_PREC` is far too large on 64-bit platforms " "and the available memory will be insufficient::" msgstr "" +"Pour des résultats inexacts, :attr:`MAX_PREC` est beaucoup trop volumineux " +"sur les plateformes 64 bits et la mémoire disponible sera insuffisante ::" #: library/decimal.rst:2213 msgid "" @@ -2543,6 +2763,11 @@ msgid "" "that you have 8GB of RAM and expect 10 simultaneous operands using a maximum " "of 500MB each::" msgstr "" +"Sur les systèmes avec mémoire virtuelle (par exemple Linux), une approche " +"plus sophistiquée consiste à ajuster :attr:`~Context.prec` à la quantité de " +"RAM disponible. Supposons que vous disposiez de 8 Go de RAM et que vous " +"voulez traiter 10 opérandes simultanés utilisant un maximum de 500 Mo " +"chacun ::" #: library/decimal.rst:2237 msgid "" @@ -2550,11 +2775,17 @@ msgid "" "recommended to estimate even tighter bounds and set the :attr:`Inexact` trap " "if all calculations are expected to be exact." msgstr "" +"En général (et en particulier sur les systèmes sans mémoire virtuelle), il " +"est recommandé d'estimer des limites encore plus strictes et d'activer la " +"surveillance de :attr:`Inexact` si l'on veut que tous les calculs soient " +"exacts." #: library/decimal.rst:2246 msgid "" "This approach now works for all exact results except for non-integer powers." msgstr "" +"Cette approche fonctionne désormais pour tous les résultats exacts, à " +"l'exception des puissances non entières." #~ msgid "" #~ "Normalize the number by stripping the rightmost trailing zeros and "