floatingpoint.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-11-01 00:16+0100\n"
"PO-Revision-Date: 2022-11-16 22:33+0100\n"
"Last-Translator: Mathieu Dupuy <deronnax@gmail.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.4.2\n"

#: tutorial/floatingpoint.rst:10
#, fuzzy
msgid "Floating-Point Arithmetic:  Issues and Limitations"
msgstr "Arithmétique en nombres à virgule flottante : problèmes et limites"

#: tutorial/floatingpoint.rst:16
#, fuzzy
msgid ""
"Floating-point numbers are represented in computer hardware as base 2 "
"(binary) fractions.  For example, the **decimal** fraction ``0.625`` has "
"value 6/10 + 2/100 + 5/1000, and in the same way the **binary** fraction "
"``0.101`` has value 1/2 + 0/4 + 1/8. These two fractions have identical "
"values, the only real difference being that the first is written in base 10 "
"fractional notation, and the second in base 2."
msgstr ""
"Les nombres à virgule flottante sont représentés, au niveau matériel, en "
"fractions de nombres binaires (base 2). Par exemple, en représentation "
"**décimale** le nombre ``0.125`` exprime 1/10 + 2/100 + 5/1000. De la même "
"manière, en représentation **binaire** le nombre ``0.001`` exprime 0/2 + 0/4 "
"+ 1/8. Ces deux fractions de l'unité ont une valeur identique, la seule "
"différence est que la première est une fraction dont la notation est en base "
"10, la seconde est une fraction dont la notation est en base 2."

#: tutorial/floatingpoint.rst:23
msgid ""
"Unfortunately, most decimal fractions cannot be represented exactly as "
"binary fractions.  A consequence is that, in general, the decimal floating-"
"point numbers you enter are only approximated by the binary floating-point "
"numbers actually stored in the machine."
msgstr ""
"Malheureusement, la plupart des fractions décimales ne peuvent pas avoir de "
"représentation exacte en fractions binaires. Par conséquent, en général, les "
"nombres à virgule flottante que vous donnez sont seulement approximés en "
"fractions binaires pour être stockés dans la machine."

#: tutorial/floatingpoint.rst:28
msgid ""
"The problem is easier to understand at first in base 10.  Consider the "
"fraction 1/3.  You can approximate that as a base 10 fraction::"
msgstr ""
"Le problème est plus simple à aborder en base 10. Prenons par exemple, la "
"fraction 1/3. Vous pouvez l'approximer en une fraction décimale ::"

#: tutorial/floatingpoint.rst:37
msgid "or, better, ::"
msgstr "ou, mieux ::"

#: tutorial/floatingpoint.rst:41
msgid ""
"and so on.  No matter how many digits you're willing to write down, the "
"result will never be exactly 1/3, but will be an increasingly better "
"approximation of 1/3."
msgstr ""
"etc. Peu importe le nombre de décimales que vous écrivez, le résultat ne "
"vaut jamais exactement 1/3, mais c'est une estimation s'en approchant "
"toujours mieux."

#: tutorial/floatingpoint.rst:45
msgid ""
"In the same way, no matter how many base 2 digits you're willing to use, the "
"decimal value 0.1 cannot be represented exactly as a base 2 fraction.  In "
"base 2, 1/10 is the infinitely repeating fraction ::"
msgstr ""
"De la même manière, peu importe combien de décimales en base 2 vous "
"utilisez, la valeur décimale 0.1 ne peut pas être représentée exactement en "
"fraction binaire. En base 2, 1/10 est le nombre périodique suivant ::"

#: tutorial/floatingpoint.rst:51
msgid ""
"Stop at any finite number of bits, and you get an approximation.  On most "
"machines today, floats are approximated using a binary fraction with the "
"numerator using the first 53 bits starting with the most significant bit and "
"with the denominator as a power of two.  In the case of 1/10, the binary "
"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly "
"equal to the true value of 1/10."
msgstr ""
"En se limitant à une quantité finie de bits, on ne peut obtenir qu'une "
"approximation. Sur la majorité des machines aujourd'hui, les nombres à "
"virgule flottante sont approximés par une fraction binaire avec les 53 "
"premiers bits comme numérateur et une puissance de deux au dénominateur. "
"Dans le cas de 1/10, la fraction binaire est ``3602879701896397 / 2 ** 55`` "
"qui est proche mais ne vaut pas exactement 1/10."

#: tutorial/floatingpoint.rst:58
#, fuzzy
msgid ""
"Many users are not aware of the approximation because of the way values are "
"displayed.  Python only prints a decimal approximation to the true decimal "
"value of the binary approximation stored by the machine.  On most machines, "
"if Python were to print the true decimal value of the binary approximation "
"stored for 0.1, it would have to display::"
msgstr ""
"Du fait de la manière dont les flottants sont affichés par l'interpréteur, "
"il est facile d'oublier que la valeur stockée est une approximation de la "
"fraction décimale d'origine. Python n'affiche qu'une approximation décimale "
"de la valeur stockée en binaire. Si Python devait afficher la vraie valeur "
"décimale de l'approximation binaire stockée pour 0,1, il afficherait ::"

#: tutorial/floatingpoint.rst:67
#, fuzzy
msgid ""
"That is more digits than most people find useful, so Python keeps the number "
"of digits manageable by displaying a rounded value instead:"
msgstr ""
"C'est bien plus de décimales que ce qu'attendent la plupart des "
"utilisateurs, donc Python affiche une valeur arrondie afin d'améliorer la "
"lisibilité ::"

#: tutorial/floatingpoint.rst:75
msgid ""
"Just remember, even though the printed result looks like the exact value of "
"1/10, the actual stored value is the nearest representable binary fraction."
msgstr ""
"Rappelez-vous simplement que, bien que la valeur affichée ressemble à la "
"valeur exacte de 1/10, la valeur stockée est la représentation la plus "
"proche en fraction binaire."

#: tutorial/floatingpoint.rst:78
msgid ""
"Interestingly, there are many different decimal numbers that share the same "
"nearest approximate binary fraction.  For example, the numbers ``0.1`` and "
"``0.10000000000000001`` and "
"``0.1000000000000000055511151231257827021181583404541015625`` are all "
"approximated by ``3602879701896397 / 2 ** 55``.  Since all of these decimal "
"values share the same approximation, any one of them could be displayed "
"while still preserving the invariant ``eval(repr(x)) == x``."
msgstr ""
"Il existe beaucoup de nombres décimaux qui partagent une même approximation "
"en fraction binaire. Par exemple, ``0.1``, ``0.10000000000000001`` et "
"``0.1000000000000000055511151231257827021181583404541015625`` ont tous pour "
"approximation ``3602879701896397 / 2 ** 55``. Puisque toutes ces valeurs "
"décimales partagent la même approximation, chacune peut être affichée tout "
"en respectant ``eval(repr(x)) == x``."

#: tutorial/floatingpoint.rst:86
msgid ""
"Historically, the Python prompt and built-in :func:`repr` function would "
"choose the one with 17 significant digits, ``0.10000000000000001``.   "
"Starting with Python 3.1, Python (on most systems) is now able to choose the "
"shortest of these and simply display ``0.1``."
msgstr ""
"Historiquement, le mode interactif de Python et la primitive :func:`repr` "
"choisissaient la version avec 17 décimales significatives, "
"``0.10000000000000001``. Python, depuis la version 3.1 (sur la majorité des "
"systèmes) est maintenant capable de choisir la plus courte représentation et "
"n'affiche que ``0.1``."

#: tutorial/floatingpoint.rst:91
#, fuzzy
msgid ""
"Note that this is in the very nature of binary floating point: this is not a "
"bug in Python, and it is not a bug in your code either.  You'll see the same "
"kind of thing in all languages that support your hardware's floating-point "
"arithmetic (although some languages may not *display* the difference by "
"default, or in all output modes)."
msgstr ""
"Ce comportement est inhérent à la nature même de la représentation des "
"nombres à virgule flottante dans la machine : ce n'est pas un bogue dans "
"Python et ce n'est pas non plus un bogue dans votre code. Vous pouvez "
"observer le même type de comportement dans tous les autres langages "
"utilisant le support matériel pour le calcul des nombres à virgule flottante "
"(bien que certains langages ne rendent pas visible la différence par défaut, "
"ou pas dans tous les modes d'affichage)."

#: tutorial/floatingpoint.rst:97
#, fuzzy
msgid ""
"For more pleasant output, you may wish to use string formatting to produce a "
"limited number of significant digits:"
msgstr ""
"Pour obtenir un affichage plus plaisant, les fonctions de formatage de "
"chaînes de caractères peuvent limiter le nombre de décimales significatives "
"affichées ::"

#: tutorial/floatingpoint.rst:111
msgid ""
"It's important to realize that this is, in a real sense, an illusion: you're "
"simply rounding the *display* of the true machine value."
msgstr ""
"Il est important de comprendre que tout cela n'est, au sens propre, qu'une "
"illusion : vous demandez simplement à Python d'arrondir la valeur stockée "
"réellement dans la machine à *l'affichage*."

#: tutorial/floatingpoint.rst:114
#, fuzzy
msgid ""
"One illusion may beget another.  For example, since 0.1 is not exactly 1/10, "
"summing three values of 0.1 may not yield exactly 0.3, either:"
msgstr ""
"Une autre conséquence du fait que 0,1 n'est pas exactement stocké 1/10 est "
"que la somme de trois valeurs de 0,1 ne donne pas 0,3 non plus ::"

#: tutorial/floatingpoint.rst:122
#, fuzzy
msgid ""
"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 "
"cannot get any closer to the exact value of 3/10, then pre-rounding with :"
"func:`round` function cannot help:"
msgstr ""
"Aussi, puisque 0,1 ne peut pas être stocké avec une représentation plus "
"proche de sa valeur exacte 1/10, comme 0,3 qui ne peut pas être plus proche "
"de sa valeur exacte 3/10, arrondir au préalable avec la fonction :func:"
"`round` n'aide en rien ::"

#: tutorial/floatingpoint.rst:131
#, fuzzy
msgid ""
"Though the numbers cannot be made closer to their intended exact values, "
"the :func:`math.isclose` function can be useful for comparing inexact values:"
msgstr ""
"Bien que les nombres ne peuvent se rapprocher plus de la valeur qu’on attend "
"qu’ils aient, la fonction :func:`round` peut être utile à postériori pour "
"arrondir deux valeurs inexactes et pouvoir les comparer ::"

#: tutorial/floatingpoint.rst:139
msgid ""
"Alternatively, the :func:`round` function can be used to compare rough "
"approximations:"
msgstr ""

#: tutorial/floatingpoint.rst:147
#, fuzzy
msgid ""
"Binary floating-point arithmetic holds many surprises like this.  The "
"problem with \"0.1\" is explained in precise detail below, in the "
"\"Representation Error\" section.  See `Examples of Floating Point Problems "
"<https://jvns.ca/blog/2023/01/13/examples-of-floating-point-problems/>`_ for "
"a pleasant summary of how binary floating point works and the kinds of "
"problems commonly encountered in practice.  Also see `The Perils of Floating "
"Point <http://www.indowsway.com/floatingpoint.htm>`_ for a more complete "
"account of other common surprises."
msgstr ""
"L'arithmétique des nombres binaires à virgule flottante réserve beaucoup de "
"surprises de ce genre. Le problème avec « 0.1 » est expliqué en détails ci-"
"dessous, dans la section « Erreurs de représentation ». Voir `The Perils of "
"Floating Point <http://www.lahey.com/float.htm>`_ pour une liste plus "
"complète de ce genre de surprises."

#: tutorial/floatingpoint.rst:156
#, fuzzy
msgid ""
"As that says near the end, \"there are no easy answers.\"  Still, don't be "
"unduly wary of floating point!  The errors in Python float operations are "
"inherited from the floating-point hardware, and on most machines are on the "
"order of no more than 1 part in 2\\*\\*53 per operation.  That's more than "
"adequate for most tasks, but you do need to keep in mind that it's not "
"decimal arithmetic and that every float operation can suffer a new rounding "
"error."
msgstr ""
"Même s'il est vrai qu'il n'existe pas de réponse simple, ce n'est pas la "
"peine de vous méfier outre mesure des nombres à virgule flottante ! Les "
"erreurs, en Python, dans les opérations de nombres à virgule flottante sont "
"dues au matériel sous-jacent et, sur la plupart des machines, sont de "
"l'ordre de 1 sur 2\\*\\*53 par opération. C'est plus que suffisant pour la "
"plupart des tâches, mais vous devez garder à l'esprit que ce ne sont pas des "
"opérations décimales et que chaque opération sur des nombres à virgule "
"flottante peut souffrir d'une nouvelle erreur."

#: tutorial/floatingpoint.rst:163
msgid ""
"While pathological cases do exist, for most casual use of floating-point "
"arithmetic you'll see the result you expect in the end if you simply round "
"the display of your final results to the number of decimal digits you "
"expect. :func:`str` usually suffices, and for finer control see the :meth:"
"`str.format` method's format specifiers in :ref:`formatstrings`."
msgstr ""
"Bien que des cas pathologiques existent, pour la plupart des cas "
"d'utilisations courants vous obtiendrez le résultat attendu à la fin en "
"arrondissant simplement au nombre de décimales désirées à l'affichage avec :"
"func:`str`. Pour un contrôle fin sur la manière dont les décimales sont "
"affichées, consultez dans :ref:`formatstrings` les spécifications de "
"formatage de la méthode :meth:`str.format`."

#: tutorial/floatingpoint.rst:169
msgid ""
"For use cases which require exact decimal representation, try using the :mod:"
"`decimal` module which implements decimal arithmetic suitable for accounting "
"applications and high-precision applications."
msgstr ""
"Pour les cas requérant une représentation décimale exacte, le module :mod:"
"`decimal` peut être utile : il implémente l'arithmétique décimale et peut "
"donc être un choix adapté pour des applications nécessitant une grande "
"précision."

#: tutorial/floatingpoint.rst:173
msgid ""
"Another form of exact arithmetic is supported by the :mod:`fractions` module "
"which implements arithmetic based on rational numbers (so the numbers like "
"1/3 can be represented exactly)."
msgstr ""
"Une autre forme d'arithmétique exacte est implémentée dans le module :mod:"
"`fractions` qui se base sur les nombres rationnels (donc 1/3 peut y être "
"représenté exactement)."

#: tutorial/floatingpoint.rst:177
#, fuzzy
msgid ""
"If you are a heavy user of floating-point operations you should take a look "
"at the NumPy package and many other packages for mathematical and "
"statistical operations supplied by the SciPy project. See <https://scipy."
"org>."
msgstr ""
"Si vous êtes un utilisateur intensif des opérations sur les nombres à "
"virgule flottante, nous vous conseillons de considérer le paquet *NumPy* "
"ainsi que les paquets pour les opérations statistiques et mathématiques "
"fournis par le projet SciPy. Consultez <https://scipy.org>."

#: tutorial/floatingpoint.rst:181
#, fuzzy
msgid ""
"Python provides tools that may help on those rare occasions when you really "
"*do* want to know the exact value of a float.  The :meth:`float."
"as_integer_ratio` method expresses the value of a float as a fraction:"
msgstr ""
"Python fournit des outils qui peuvent être utiles dans les rares occasions "
"où vous voulez réellement connaître la valeur exacte d'un nombre à virgule "
"flottante. La méthode :meth:`float.as_integer_ratio` donne la valeur du "
"nombre sous forme de fraction ::"

#: tutorial/floatingpoint.rst:192
#, fuzzy
msgid ""
"Since the ratio is exact, it can be used to losslessly recreate the original "
"value:"
msgstr ""
"Puisque le ratio est exact, il peut être utilisé pour recréer la valeur "
"originale sans perte ::"

#: tutorial/floatingpoint.rst:200
#, fuzzy
msgid ""
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
"again giving the exact value stored by your computer:"
msgstr ""
"La méthode :meth:`float.hex` donne le nombre en hexadécimal (base 16), "
"donnant ici aussi la valeur exacte stockée par la machine ::"

#: tutorial/floatingpoint.rst:208
#, fuzzy
msgid ""
"This precise hexadecimal representation can be used to reconstruct the float "
"value exactly:"
msgstr ""
"Cette représentation hexadécimale petit être utilisée pour reconstruire, "
"sans approximation, le *float* ::"

#: tutorial/floatingpoint.rst:216
msgid ""
"Since the representation is exact, it is useful for reliably porting values "
"across different versions of Python (platform independence) and exchanging "
"data with other languages that support the same format (such as Java and "
"C99)."
msgstr ""
"Puisque cette représentation est exacte, elle est pratique pour échanger des "
"valeurs entre différentes versions de Python (indépendamment de la machine) "
"ou d'autres langages qui comprennent ce format (tels que Java et C99)."

#: tutorial/floatingpoint.rst:220
#, fuzzy
msgid ""
"Another helpful tool is the :func:`sum` function which helps mitigate loss-"
"of-precision during summation.  It uses extended precision for intermediate "
"rounding steps as values are added onto a running total. That can make a "
"difference in overall accuracy so that the errors do not accumulate to the "
"point where they affect the final total:"
msgstr ""
"Une autre fonction utile est :func:`math.fsum`, elle aide à diminuer les "
"pertes de précision lors des additions. Elle surveille les *décimales "
"perdues* au fur et à mesure que les valeurs sont ajoutées au total. Cela "
"peut faire une différence au niveau de la précision globale en empêchant les "
"erreurs de s'accumuler jusqu'à affecter le résultat final :"

#: tutorial/floatingpoint.rst:233
msgid ""
"The :func:`math.fsum` goes further and tracks all of the \"lost digits\" as "
"values are added onto a running total so that the result has only a single "
"rounding.  This is slower than :func:`sum` but will be more accurate in "
"uncommon cases where large magnitude inputs mostly cancel each other out "
"leaving a final sum near zero:"
msgstr ""

#: tutorial/floatingpoint.rst:260
msgid "Representation Error"
msgstr "Erreurs de représentation"

#: tutorial/floatingpoint.rst:262
msgid ""
"This section explains the \"0.1\" example in detail, and shows how you can "
"perform an exact analysis of cases like this yourself.  Basic familiarity "
"with binary floating-point representation is assumed."
msgstr ""
"Cette section explique en détail l'exemple du « 0.1 » et montre comment vous "
"pouvez effectuer une analyse exacte de ce type de cas par vous-même. Nous "
"supposons que la représentation binaire des nombres flottants vous est "
"familière."

#: tutorial/floatingpoint.rst:266
msgid ""
":dfn:`Representation error` refers to the fact that some (most, actually) "
"decimal fractions cannot be represented exactly as binary (base 2) "
"fractions. This is the chief reason why Python (or Perl, C, C++, Java, "
"Fortran, and many others) often won't display the exact decimal number you "
"expect."
msgstr ""
"Le terme :dfn:`Erreur de représentation` (*representation error* en anglais) "
"signifie que la plupart des fractions décimales ne peuvent être représentées "
"exactement en binaire. C'est la principale raison pour laquelle Python (ou "
"Perl, C, C++, Java, Fortran et beaucoup d'autres) n'affiche habituellement "
"pas le résultat exact en décimal."

#: tutorial/floatingpoint.rst:271
#, fuzzy
msgid ""
"Why is that?  1/10 is not exactly representable as a binary fraction.  Since "
"at least 2000, almost all machines use IEEE 754 binary floating-point "
"arithmetic, and almost all platforms map Python floats to IEEE 754 binary64 "
"\"double precision\" values.  IEEE 754 binary64 values contain 53 bits of "
"precision, so on input the computer strives to convert 0.1 to the closest "
"fraction it can of the form *J*/2**\\ *N* where *J* is an integer containing "
"exactly 53 bits. Rewriting ::"
msgstr ""
"Pourquoi ? 1/10 n'est pas représentable de manière exacte en fraction "
"binaire. Cependant, toutes les machines d'aujourd'hui (novembre 2000) "
"suivent la norme IEEE-754 en ce qui concerne l'arithmétique des nombres à "
"virgule flottante et la plupart des plateformes utilisent un « IEEE-754 "
"double précision » pour représenter les *floats* de Python. Les « IEEE-754 "
"double précision » utilisent 53 bits de précision donc, à la lecture, "
"l'ordinateur essaie de convertir 0,1 dans la fraction la plus proche "
"possible de la forme *J*/2**\\ *N* avec *J* un nombre entier d'exactement 53 "
"bits. Pour réécrire ::"

#: tutorial/floatingpoint.rst:282
msgid "as ::"
msgstr "en ::"

#: tutorial/floatingpoint.rst:286
#, fuzzy
msgid ""
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
"2**53``), the best value for *N* is 56:"
msgstr ""
"en se rappelant que *J* fait exactement 53 bits (donc ``>= 2**52`` mais ``< "
"2**53``), la meilleure valeur possible pour *N* est 56 ::"

#: tutorial/floatingpoint.rst:294
#, fuzzy
msgid ""
"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits.  "
"The best possible value for *J* is then that quotient rounded:"
msgstr ""
"Donc 56 est la seule valeur possible pour *N* qui laisse exactement 53 bits "
"pour *J*. La meilleure valeur possible pour *J* est donc ce quotient, "
"arrondi ::"

#: tutorial/floatingpoint.rst:303
#, fuzzy
msgid ""
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up:"
msgstr ""
"Puisque la retenue est plus grande que la moitié de 10, la meilleure "
"approximation est obtenue en arrondissant par le haut ::"

#: tutorial/floatingpoint.rst:313
#, fuzzy
msgid ""
"Therefore the best possible approximation to 1/10 in IEEE 754 double "
"precision is::"
msgstr ""
"Par conséquent la meilleure approximation possible pour 1/10 en « IEEE-754 "
"double précision » est celle au-dessus de 2\\*\\*56, soit ::"

#: tutorial/floatingpoint.rst:318
msgid ""
"Dividing both the numerator and denominator by two reduces the fraction to::"
msgstr ""
"Diviser le numérateur et le dénominateur par deux réduit la fraction à ::"

#: tutorial/floatingpoint.rst:322
msgid ""
"Note that since we rounded up, this is actually a little bit larger than "
"1/10; if we had not rounded up, the quotient would have been a little bit "
"smaller than 1/10.  But in no case can it be *exactly* 1/10!"
msgstr ""
"Notez que puisque l'arrondi a été fait vers le haut, le résultat est en "
"réalité légèrement plus grand que 1/10 ; si nous n'avions pas arrondi par le "
"haut, le quotient aurait été légèrement plus petit que 1/10. Mais dans aucun "
"cas il ne vaut *exactement* 1/10 !"

#: tutorial/floatingpoint.rst:326
#, fuzzy
msgid ""
"So the computer never \"sees\" 1/10:  what it sees is the exact fraction "
"given above, the best IEEE 754 double approximation it can get:"
msgstr ""
"Donc l'ordinateur ne « voit » jamais 1/10 : ce qu'il voit est la fraction "
"exacte donnée ci-dessus, la meilleure approximation utilisant les nombres à "
"virgule flottante double précision de l'« IEEE-754 » ::"

#: tutorial/floatingpoint.rst:334
#, fuzzy
msgid ""
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
"decimal digits:"
msgstr ""
"Si nous multiplions cette fraction par 10\\*\\*55, nous pouvons observer les "
"valeurs de ses 55 décimales de poids fort ::"

#: tutorial/floatingpoint.rst:342
#, fuzzy
msgid ""
"meaning that the exact number stored in the computer is equal to the decimal "
"value 0.1000000000000000055511151231257827021181583404541015625. Instead of "
"displaying the full decimal value, many languages (including older versions "
"of Python), round the result to 17 significant digits:"
msgstr ""
"La valeur stockée dans l'ordinateur est donc égale à "
"0,1000000000000000055511151231257827021181583404541015625. Au lieu "
"d'afficher toutes les décimales, beaucoup de langages (dont les vieilles "
"versions de Python) arrondissent le résultat à la 17\\ :sup:`e` décimale "
"significative ::"

#: tutorial/floatingpoint.rst:352
#, fuzzy
msgid ""
"The :mod:`fractions` and :mod:`decimal` modules make these calculations easy:"
msgstr ""
"Les modules :mod:`fractions` et :mod:`decimal` rendent simples ces calculs ::"