forked from AFPy/python-docs-fr
511 lines
23 KiB
Plaintext
511 lines
23 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
|
# Copyright (C) 2001-2016, Python Software Foundation
|
|
# This file is distributed under the same license as the Python package.
|
|
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
|
#
|
|
#, fuzzy
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Python 3.6\n"
|
|
"Report-Msgid-Bugs-To: \n"
|
|
"POT-Creation-Date: 2017-04-02 22:11+0200\n"
|
|
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
|
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
|
"Language-Team: LANGUAGE <LL@li.org>\n"
|
|
"Language: \n"
|
|
"MIME-Version: 1.0\n"
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
"Content-Transfer-Encoding: 8bit\n"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:9
|
|
msgid "Floating Point Arithmetic: Issues and Limitations"
|
|
msgstr "Arithmétique en Nombre à Virgule Flottante : Problèmes et Limites"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:14
|
|
msgid ""
|
|
"Floating-point numbers are represented in computer hardware as base 2 "
|
|
"(binary) fractions. For example, the decimal fraction ::"
|
|
msgstr ""
|
|
"Les nombres à virgule flottante sont représentés, au niveau matériel, en "
|
|
"fractions de nombres binaires (base 2). Par exemple, la fraction "
|
|
"décimale : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:19
|
|
msgid ""
|
|
"has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction ::"
|
|
msgstr ""
|
|
"a la valeur 1/10 + 2/100 + 5/1000, et de la même manière, la fraction "
|
|
"binaire : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:23
|
|
msgid ""
|
|
"has value 0/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 ""
|
|
"a la valeur 0/2 + 0/4 + 1/8. Ces deux fractions ont une valeur identique, la "
|
|
"seule différence est que la première est une fraction décimale, la seconde "
|
|
"binaire."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:27
|
|
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 n'ont pas 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 "
|
|
"fraction binaire pour être stocké dans la machine."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:32
|
|
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::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:37 ../Doc/tutorial/floatingpoint.rst:41
|
|
msgid "or, better, ::"
|
|
msgstr "ou, mieux, ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:45
|
|
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 écrirez, le résultat ne "
|
|
"sera jamais exactement 1/3, mais une estimation s'en approchant toujours "
|
|
"mieux."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:49
|
|
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 "
|
|
"utiliserez, la valeur décimale 0.1 ne peut être représentée exactement en "
|
|
"fraction binaire. En base 2, 1/10 est le nombre périodique suivant : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:55
|
|
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 pas exactement 1/10."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:62
|
|
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 ""
|
|
"Il est facile d'oublier que la valeur stockée est une approximation de la "
|
|
"fraction décimale d'origine, du fait de la manière dont les flottants sont "
|
|
"affichés dans l'interpréteur. 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 : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:71
|
|
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 nécessaire, donc Python affiche une valeur "
|
|
"arrondie afin d'améliorer la lisibilité : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:77
|
|
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 ""
|
|
"Il faut se rappeler, bien que la valeur affichée ressemble à la valeur "
|
|
"exacte de 1/10, que la valeur stockée est la représentation la plus proche "
|
|
"en fraction binaire."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:80
|
|
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``. Puisques toutes ces valeurs "
|
|
"décimales partagent la même approximation, chacune peut être affichée tout "
|
|
"en respectant ``eval(repr(x)) == x``."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:88
|
|
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` "
|
|
"auraient choisi 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'afficher que ``0.1``."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:93
|
|
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 au comportement des nombres à virgule "
|
|
"flottante : ce n'est pas un bug dans Python, et ce n'est pas non plus un bug "
|
|
"dans votre code. Vous verrez le même type de comportement dans tous les "
|
|
"autres langages utilisant le support matériel pour le calcul des nombres à "
|
|
"virgules flottante (bien que certains langages ne rendent pas visible la "
|
|
"différence par défaut, ou pas dans tous les modes d'affichage)."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:99
|
|
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::"
|
|
|
|
#: ../Doc/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 qu'en réalité, c'est une illusion : Python "
|
|
"arrondit simplement, la vraie valeur stockée, à *l'affichage*."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:114
|
|
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 : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:120
|
|
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 avec la fonction :func:`round` n'aide en "
|
|
"rien : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:127
|
|
msgid ""
|
|
"Though the numbers cannot be made closer to their intended exact values, "
|
|
"the :func:`round` function can be useful for post-rounding so that results "
|
|
"with inexact values become comparable to one another::"
|
|
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 à posteriori pour "
|
|
"arrondir deux valeurs inexactes et les rendre comparables : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:134
|
|
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 `The Perils of Floating Point <http://"
|
|
"www.lahey.com/float.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-"
|
|
"desous, dans la section \"Représentation d'Erreur\". Voir `The Perils of "
|
|
"Floating Point <http://www.lahey.com/float.htm>`_ pour une liste plus "
|
|
"complète de ce genre de surprises."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:139
|
|
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 ""
|
|
"Il est vrai qu'il n'existe pas de réponse simple, cependant ne vous méfiez "
|
|
"pas trop des nombres à virtule 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 ne sont pas plus importantes que 1 sur 2\\*"
|
|
"\\*53 par opération. C'est plus que nécessaire 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."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:146
|
|
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 et 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 "
|
|
"formattage de la méthode :meth:`str.format`."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:152
|
|
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."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:156
|
|
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 nombre rationnels (donc 1/3 peut y être "
|
|
"représenté exactement)."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:160
|
|
msgid ""
|
|
"If you are a heavy user of floating point operations you should take a look "
|
|
"at the Numerical Python 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, vous devriez regarder le paquet *Numerical Python* et une "
|
|
"série d'autres paquets pour les opérations statistiques et mathématiques "
|
|
"fournis par le projet SciPy. Voir <https://scipy.org>."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:164
|
|
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 utils dans les rares occasions ou "
|
|
"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 : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:173
|
|
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 dans perte : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:179
|
|
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 : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:185
|
|
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* ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:191
|
|
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 version de Python (indépendamment de la machine) "
|
|
"ou d'autres langages qui comprennent ce format (tel que Java et C99)."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:195
|
|
msgid ""
|
|
"Another helpful tool is the :func:`math.fsum` function which helps mitigate "
|
|
"loss-of-precision during summation. It tracks \"lost digits\" 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`, qui 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 car cela empêche "
|
|
"les erreurs de s'accumuler jusqu'au point ou le résultat final est affecté:"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:209
|
|
msgid "Representation Error"
|
|
msgstr "Erreurs de représentation"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:211
|
|
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. Il "
|
|
"est supposé que vous êtes déjà familier de la représentation binaire des "
|
|
"nombres flottants."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:215
|
|
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:`Representation error` 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 "
|
|
"beuacoup d'autres) n'affiche habituellement pas le résultat exact en décimal."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:220
|
|
msgid ""
|
|
"Why is that? 1/10 is not exactly representable as a binary fraction. Almost "
|
|
"all machines today (November 2000) use IEEE-754 floating point arithmetic, "
|
|
"and almost all platforms map Python floats to IEEE-754 \"double precision"
|
|
"\". 754 doubles 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 fractions "
|
|
"binaires. Cependant, toutes les machines d'aujourd'hui (Juillet 2010) "
|
|
"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 precision\" pour représenter les floats de Python. Les \"IEEE-754 "
|
|
"double precision\" utilisent 53 bits de précision, donc a 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. Réecrire : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:229
|
|
msgid "as ::"
|
|
msgstr "en : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:233
|
|
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 meilleur valeur possible pour *N* est 56::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:239
|
|
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::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:246
|
|
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:"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:252
|
|
msgid ""
|
|
"Therefore the best possible approximation to 1/10 in 754 double precision "
|
|
"is::"
|
|
msgstr ""
|
|
"Par conséquent la meilleure approximation possible pour 1/10 en \"IEEE-754 "
|
|
"double precision\" est cette au desus de 2\\*\\*56, soit : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:256
|
|
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 à : ::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:260
|
|
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 !"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:264
|
|
msgid ""
|
|
"So the computer never \"sees\" 1/10: what it sees is the exact fraction "
|
|
"given above, the best 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\""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:270
|
|
msgid ""
|
|
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
|
|
"decimal digits::"
|
|
msgstr ""
|
|
"Si on multiplie cette fraction par 10\\*\\*30, on peut observer les valeurs "
|
|
"de ses 55 décimales de poid fort::"
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:276
|
|
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 "
|
|
"version de Python) arrondissent le résultat à la 17eme décimale "
|
|
"significative."
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:284
|
|
msgid ""
|
|
"The :mod:`fractions` and :mod:`decimal` modules make these calculations "
|
|
"easy::"
|
|
msgstr ""
|
|
"Les modules :mod:`fractions` et :mod:`decimal` rendent simples ces "
|
|
"calculs : ::"
|