Les nombres à virgule

Une difficulté qui existe déjà en base dix

Personne n'est choqué d'apprendre qu'un tiers ne s'écrit pas exactement en base dix. On écrit 0,333 et on sait que ce n'est pas tout à fait un tiers. La suite des chiffres ne s'arrête jamais, alors il faut bien couper quelque part, et couper veut dire perdre.

La raison tient en une phrase : en base dix, une fraction s'écrit avec un nombre fini de chiffres si, et seulement si, son dénominateur ne contient que des facteurs 2 et 5, les diviseurs de dix. Un demi s'écrit 0,5. Un quart, 0,25. Un cinquième, 0,2. Un tiers, jamais, parce que 3 ne divise aucune puissance de dix.

En base deux, la même règle s'applique avec un seul facteur autorisé : le 2. Un demi s'écrit 0,1. Un quart, 0,01. Un huitième, 0,001. Mais un dixième demande un facteur 5 au dénominateur, et il n'y a pas de 5 dans les puissances de deux. Un dixième est donc, en base deux, exactement ce qu'un tiers est en base dix : une suite infinie et périodique.

Le programme ci-dessous développe plusieurs fractions en base deux, sans passer par les nombres à virgule de Python. Il travaille sur des fractions exactes, et s'arrête tout seul quand le développement se termine.

Les quatre premières fractions se terminent. Les trois dernières tournent en rond pour toujours. Un dixième donne 0,000110011001100110011001 et le motif 0011 se répète indéfiniment.

Ce qui est réellement rangé

Voici ce que la mémoire contient quand un programme écrit 0.1. Les bits se retournent au clic, et la valeur au-dessous suit.

La ligne à lire est celle qui s'appelle « valeur exacte en mémoire ». Elle ne vaut pas 0,1 : elle vaut

0,1000000000000000055511151231257827021181583404541015625

et ces cinquante-cinq chiffres ne sont pas une approximation de l'approximation. C'est la valeur exacte du nombre qui est dans la mémoire, écrite en entier. Elle se termine, parce qu'un nombre fait de puissances de deux a toujours une écriture décimale finie, et elle est plus longue que ce que l'on imagine, ce qui est précisément la raison pour laquelle aucun langage ne l'imprime.

Python sait la montrer, à condition de la demander.

Trois écritures du même nombre. La première est courte et trompeuse, la deuxième est tronquée, la troisième est exacte.

Trois champs, et rien d'autre

Un nombre à virgule est rangé comme la notation scientifique de l'école, mais en base deux. Il tient en trois morceaux :

La valeur vaut alors, pour un nombre ordinaire :

$(-1)^{signe} \times 1{,}mantisse \times 2^{exposant - 1023}$

Sur la figure précédente, l'exposant affiché se lit 1019 − 1023 = −4, ce qui place la valeur entre $2^{-4}$ et $2^{-3}$, c'est-à-dire entre 0,0625 et 0,125. C'est bien l'intervalle où se trouve 0,1.

Trois manipulations valent mieux qu'un paragraphe. Sur la figure ci-dessus :

• Retourner le bit de signe, tout à gauche. Seul le signe change, la suite des chiffres reste identique.
• Retourner le bit de poids faible de l'exposant. La valeur est multipliée ou divisée par deux.
• Retourner le tout dernier bit de mantisse, à l'extrême droite. La valeur bouge du plus petit écart possible à cet endroit de la droite des nombres.

Ce dernier écart porte un nom, et il est la clé de tout ce qui suit : c'est le pas entre deux nombres représentables voisins. Il n'est pas constant. Près de zéro les nombres représentables sont serrés, et loin de zéro ils sont très espacés.

Autour de $10^{16}$, le pas dépasse 1 : il n'y a plus un seul nombre représentable entre deux entiers consécutifs. Cela se vérifie directement.

Ajouter 1 à $10^{16}$ ne change rien, parce que le résultat n'existe pas et que le plus proche voisin est le point de départ.

Ce qui se range exactement, et ce qui ne se range pas

La règle énoncée plus haut se vérifie d'un coup d'œil. La colonne de droite dit si la valeur écrite dans le programme est celle qui se retrouve en mémoire.

Un demi, un quart, trois quarts et un huitième passent intacts. Un dixième, deux dixièmes et trois dixièmes ne passent pas. Et il faut noter que 0,3 est rangé en dessous de sa valeur, alors que 0,1 et 0,2 sont rangés au-dessus : c'est déjà la moitié de l'explication de la section suivante.

Pourquoi 0,1 + 0,2 ne fait pas 0,3

Voici l'addition, décomposée.

Il faut lire cette figure de haut en bas, parce qu'elle sépare deux pertes que tout le monde confond.

La première perte a déjà eu lieu avant la moindre addition. Ni 0,1 ni 0,2 n'ont été rangés tels qu'écrits. Leur somme exacte, celle des deux valeurs réellement en mémoire, ne vaut donc déjà pas 0,3.

La seconde perte est celle du rangement du résultat. Cette somme exacte n'est elle-même pas représentable, et elle doit être arrondie au voisin le plus proche.

Le point intéressant, et contraire à l'intuition, est l'ordre de grandeur des deux : pour cette addition-là, c'est la seconde qui pèse le plus, environ une fois et demie la première. Aucune des deux ne suffit à expliquer le phénomène, et c'est pour cela que l'explication courte, celle qui parle seulement d'un « 0,1 approximatif », laisse toujours un doute.

L'addition, elle, est parfaitement exacte : elle donne le nombre représentable le plus proche de la somme vraie de ses deux entrées. C'est ce qu'on peut demander de mieux à une machine, et c'est exactement ce que la norme lui impose.

Une conséquence à laquelle personne ne s'attend

Si chaque opération arrondit, alors changer l'ordre des opérations change le résultat. L'addition des nombres à virgule n'est pas associative.

Les mêmes trois nombres, la même opération, deux résultats différents. Ce n'est pas un bogue : chaque somme partielle est arrondie, et les arrondis ne tombent pas au même endroit selon l'ordre.

La même cause produit une dérive quand on additionne longtemps.

Dix mille additions font dériver le total d'environ $1{,}6 \times 10^{-10}$, alors qu'une seule multiplication tombe juste. Moins il y a d'opérations, moins il y a d'arrondis. C'est la première règle pratique du chapitre, et elle vaut pour tous les calculs longs : sommer un million de mesures accumule un million d'arrondis.

Comparer sans le signe égal

De tout ce qui précède découle une consigne simple : ne jamais tester l'égalité de deux nombres à virgule issus de calculs différents.

math.isclose compare à une tolérance relative, dont la valeur par défaut est $10^{-9}$, soit environ un milliardième de la taille des nombres comparés. Une tolérance relative est presque toujours ce qu'il faut, parce que le pas entre représentables grandit avec les nombres : un écart acceptable près de 1 est ridicule près de $10^{16}$.

Une exception compte : au voisinage de zéro, une tolérance relative ne veut plus rien dire, puisque tout est relativement loin de zéro. Il faut alors une tolérance absolue, que isclose accepte séparément.

Sur 32 bits, tout se dégrade plus vite

Le format présenté jusqu'ici occupe 64 bits, et c'est celui que Python emploie toujours. Il en existe un autre, sur 32 bits, que l'on rencontre sur les cartes électroniques, dans les images et dans les réseaux de neurones, là où la place et la vitesse comptent plus que la précision.

La mantisse tombe de 52 bits à 23, et l'écriture exacte raccourcit d'autant : il reste environ sept chiffres décimaux fiables, contre seize sur 64 bits. Le phénomène est le même, l'échelle change.

Quand il ne faut pas de nombres à virgule

Tous les problèmes de ce chapitre disparaissent en changeant d'outil, et le choix dépend de ce que l'on compte.

Pour de l'argent, compter en entiers. Un prix en centimes est un entier, un entier se range exactement, et rien ne dérive.

Pour une arithmétique décimale exacte, le type Decimal. Il calcule en base dix, donc 0,1 y est exactement 0,1. Il est plus lent, et c'est un prix que toute comptabilité accepte.

Pour des fractions exactes, le type Fraction. Il garde un numérateur et un dénominateur entiers, et ne perd jamais rien, y compris sur un tiers.

Pour des mesures physiques, garder les nombres à virgule. Une température connue à un dixième de degré près n'a que faire d'une précision au millionième : l'erreur de mesure dépasse de très loin l'erreur de représentation. C'est le cas d'usage pour lequel ce format a été conçu, et il y est excellent.

Exercices type

Trouver la valeur exacte rangée pour 0,7. Utiliser Decimal, puis dire si elle est au-dessus ou en dessous de 0,7.

Compter, parmi les dixièmes de 0,1 à 0,9, combien se rangent exactement. La réponse se déduit de la règle du dénominateur, et le programme la confirme.

Mesurer la dérive d'une somme selon l'ordre des termes. Additionner mille petites valeurs et une grande, dans les deux ordres.

Quand le grand nombre vient en premier, chaque petite valeur est absorbée sans laisser de trace, parce qu'elle tombe sous le pas. Quand les petites valeurs s'additionnent entre elles d'abord, elles finissent par peser assez pour compter. Sommer du plus petit au plus grand perd moins.

Vérification

La méthode

Devant un résultat numérique surprenant, dérouler dans cet ordre.

1. Afficher la valeur exacte avec Decimal(x), et non l'affichage par défaut. La moitié des surprises s'expliquent à cette seule ligne.
2. Chercher les dénominateurs. Toute fraction dont le dénominateur n'est pas une puissance de deux entre abîmée.
3. Compter les opérations. Chacune arrondit. Une boucle qui additionne dix mille fois accumule dix mille arrondis.
4. Remplacer toute égalité entre nombres à virgule par une comparaison à tolérance.
5. Changer d'outil si le domaine l'exige. Entiers pour de l'argent, Decimal pour du décimal exact, Fraction pour du rationnel exact, nombres à virgule pour des mesures.

Synthèse

• Une fraction s'écrit avec un nombre fini de chiffres en base deux seulement si son dénominateur est une puissance de deux. 0,1 n'en est pas une, et n'existe donc pas en machine.
• Ce qui est rangé à la place est le représentable le plus proche, dont l'écriture décimale exacte est finie mais longue : 55 chiffres pour 0,1.
• Un nombre à virgule tient en trois champs : signe, exposant biaisé, mantisse avec un 1 implicite.
• L'affichage par défaut est la plus courte écriture qui se relit à l'identique. Il cache la valeur réelle. Decimal(x) la montre.
• Dans un calcul, la précision se perd à l'écriture des opérandes et à l'arrondi du résultat. Les deux pèsent, et l'opération elle-même est exacte.
• Le pas entre représentables grandit avec les nombres : au-delà de $10^{16}$, ajouter 1 ne change plus rien.
• L'addition n'est pas associative : changer l'ordre change le résultat. Sommer du plus petit au plus grand perd moins.
• Ne jamais comparer avec ==. Employer math.isclose, relative loin de zéro, absolue près de zéro.
• Pour de l'argent, compter en entiers ou employer Decimal. Pour du rationnel exact, Fraction. Pour des mesures physiques, les nombres à virgule conviennent parfaitement.