Trois divergences flottantes

0.1 + 0.2 == 0.3
1e16 + 1.0 == 1e16
(0.1 + 0.2) + 0.3 == 0.1 + (0.2 + 0.3)

0.1 + 0.2         = 0.30000000000000004   ==  0.3   ? non
1e16 + 1.0        = 10000000000000000     == 1e16   ? OUI
(0.1 + 0.2) + 0.3 = 0.60000000000000009
0.1 + (0.2 + 0.3) = 0.59999999999999998   egaux ?    non
tours de « while (y < 1.0) y += 0.1 » : 11, y final = 1.0999999999999999

(1) L'exactitude de l'écriture décimale est perdue. Ni $0,1$ ni $0,2$ ne s'écrivent en base $2$ avec un nombre fini de bits — comme $1/3$ en base $10$. Chacun est arrondi, et les deux erreurs se cumulent.

(2) L'absorption : $a+b=a$ avec $b\ne 0$. Un double porte $53$ bits de mantisse. À côté de $10^{16}\approx 2^{53,15}$, l'écart entre deux flottants consécutifs vaut $2$ : le nombre $10^{16}+1$ n'existe pas, et l'addition le ramène à $10^{16}$. Toute somme où de petits termes s'ajoutent à un grand total en souffre — le problème 3.4 en fait la mesure.

(3) L'associativité de l'addition est perdue. C'est le plus déroutant, et le plus lourd de conséquences : deux programmes qui ne diffèrent que par le parenthésage — ou par l'ordre de sommation, ou par la répartition d'un calcul sur plusieurs c{œ}urs — ne donnent pas le même résultat. En arithmétique flottante, $(a+b)+c$ et $a+(b+c)$ sont deux expressions différentes.

Les onze tours. On en attendait dix : $10\times 0,1=1$. Mais chaque addition arrondit, et la somme de dix fois $0,1$ vaut $0,99999999999999989$, strictement inférieure à $1$ : la boucle repart pour un tour de plus et sort à $1,0999999999999999$. Le compte de tours d'une boucle ne se confie jamais à un flottant. On écrit

for (int k = 0; k < 10; k = k + 1) { y = y + 0.1; }

et l'on compte sur un entier, quitte à calculer $y$ à partir de $k$. C'est la règle du chapitre : « l'on compte les tours de boucle sur un entier, jamais sur un flottant qu'on incrémente ».