|
Original |
Translation |
|
13
|
>>> 1.2 - 1.0 0.199999999999999996
|
>>> 1.2 - 1.0 0.199999999999999996
|
|
14
|
and think it is a bug in Python. It's not. This has nothing to do with Python, but with how the underlying C platform handles floating point numbers, and ultimately with the inaccuracies introduced when writing down numbers as a string of a fixed number of digits.
|
et pensent que c'est un bogue dans Python. Ça ne l'est pas. Ceci n'a rien à voir avec Python, mais avec la manière dont la plateforme C sous-jacente gère les nombres à virgule flottante et enfin, les imprécisions introduites lors de l'écriture des nombres en chaînes de caractères d'un nombre fixe de chiffres.
|
|
15
|
The internal representation of floating point numbers uses a fixed number of binary digits to represent a decimal number. Some decimal numbers can't be represented exactly in binary, resulting in small roundoff errors.
|
La représentation interne des nombres à virgule flottante utilise un nombre fixe de chiffres binaires pour représenter un nombre décimal. Certains nombres décimaux ne peuvent être représentés exactement en binaire, résultant ainsi à de petites erreurs d'arrondi.
|
|
16
|
In decimal math, there are many numbers that can't be represented with a fixed number of decimal digits, e.g. 1/3 = 0.3333333333.......
|
En mathématiques, beaucoup de nombre ne peuvent être représentés par un nombre fixe de chiffres, par exemple 1/3 = 0.3333333333.......
|
|
17
|
In base 2, 1/2 = 0.1, 1/4 = 0.01, 1/8 = 0.001, etc. .2 equals 2/10 equals 1/5, resulting in the binary fractional number 0.001100110011001...
|
En base 2, 1/2 = 0.1, 1/4 = 0.01, 1/8 = 0.001, etc. .2 est égale à 2/10 qui est égale à 1/5, ayant pour résultat le nombre fractionnel binaire 0.001100110011001...
|
|
18
|
|
19
|
A floating point number's ``repr()`` function prints as many digits are necessary to make ``eval(repr(f)) == f`` true for any float f. The ``str()`` function prints fewer digits and this often results in the more sensible number that was probably intended::
|
La fonction ``repr()`` d'un nombre décimal affiche autant de chiffres que nécessaire pour rendre l'expression ``eval(repr(f)) == f`` vraie pour tout nombre décimal f. La fonction ``str()`` affiche moins de chiffres et correspond généralement plus au nombre attendu ::
|
|
20
|
>>> 1.1 - 0.9 0.20000000000000007 >>> print(1.1 - 0.9) 0.2
|
>>> 1.1 - 0.9 0.20000000000000007 >>> print(1.1 - 0.9) 0.2
|
|
21
|
One of the consequences of this is that it is error-prone to compare the result of some computation to a float with ``==``. Tiny inaccuracies may mean that ``==`` fails. Instead, you have to check that the difference between the two numbers is less than a certain threshold::
|
En conséquence comparer le résultat d'un calcul avec un nombre flottant avec l'opérateur '==' est propice à l'obtention d'erreurs. D'infimes imprécisions peuvent faire qu'un test d'égalité avec "==" échoue. Au lieu de cela, vous devez vérifier que la différence entre les deux chiffres est inférieure à un certain seuil ::
|
|
22
|
epsilon = 0.0000000000001 # Tiny allowed error expected_result = 0.4 if expected_result-epsilon <= computation() <= expected_result+epsilon: ...
|
|