Bonsoir,
I/ Des exemples:
Commençons par des exemples magnifiques !
Si on tape dans une console Python:
0.1 + 0.2
On obtient 0.30000000000000004.
somme = 0
for i in range(10):
somme += 0.1
On obtient somme = 0.9999999999999999
Maintenant quelques tests:
0.2 + 0.2 == 0.4 => True
0.2 * 2 == 0.4 => True
0.1 + 0.1 + 0.1 == 0.3 => False #Et bah zut alors !
3 * 0.1 == 0.3 => False #Ouin !!!
On en conclut, que le "a == b" ne sert à rien pour des flottants.
Il est obligatoire de contourner cela en mettant un intervalle de tolérance avec une certaine précision en vérifiant la condition du coup:
|a - b| <= e avec e la précision souhaitée.
On peut encore s'amuser un peu:
(((((1 - 0.2) - 0.2) - 0.2) - 0.2) - 0.2) => 5.551115123125783e-17
Mais, 1 - (5 * 0.2) == (((((1 - 0.2) - 0.2) - 0.2) - 0.2) - 0.2) => False
II/ Représentation des flottants:
Cela s'explique par la monstruosité de représenter les flottants en binaire !
On écrit un nombre flottant de cette manière:
[tex](-1)^s\times m \times b^e[/tex]
Avec s pour le signe, m la mantisse, b la base et e l'exposant.
Il existe plusieurs normes pour la représentation des flottants:
La norme IEEE754 en 32 bits (simple précision):
1 bit pour le signe
8 bits pour l'exposant
23 bits pour la mantisse
La norme IEEE754 en 64 bits (double précision):
1 bit pour le signe
11 bit pour l'exposant
52 bits pou la mantisse
Avec ces deux normes, on travail déjà plus qu'avec une certaine précision. Ainsi dès lors qu'on commence à faire des opérations, la précision n'est pas suffisante pour obtenir un résultat exact à la fin.
III/ Catastrophes !
Il y a eu d'énormes catastrophes à cause de cela !
Missile Patriote (25 février 1991):
Dans la batterie du missile, il y a un ajout de 1/10 tous les dixièmes de seconde. Or 1/10 n'est pas représentable exactement informatiquement.
Ainsi, l'erreur commise pour le tir est d'environ 568 mètres au bout de 100h de mise en route.
Cela a tué 28 morts et une centaine de blessés.
Premier vol d'Ariane 5 (4 juin 1996):
Explosion au bout de 38s à cause d'une erreur de conversion d'un nombre flottant 64 bits en nombre entier 16 bits.
Cela a coûté 500 millions de dollars.
On pourrait continuer la liste (Intel Pentium P5 en 1994...).
Ajouté à cela, il y a le problème d'overflow/underflow (dépassement de capacité), c'est avec toi qu'on en a déjà parlé il me semble.
J'espère que je t'ai suffisamment convaincu du pourquoi il est difficile de comparer 2 nombres décimaux . (et pas qu'en Python)
Bonne soirée.
