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:

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.