Nombres flottants et virgule flottante

Introduction

Les entiers, c'est bien — mais comment représente-t-on $3{,}14$ ou $\frac{1}{3}$ ? Les nombres réels posent un problème fondamental : il en existe une infinité entre deux entiers consécutifs, alors qu'une machine ne dispose que d'un nombre fini de bits. Il faudra donc approximer. C'est ce que fait la représentation en virgule flottante, normalisée par le standard IEEE 754 et utilisée par tous les processeurs modernes. [PB02]

Cette approximation a un effet déroutant : en Python, 0.1 + 0.2 ne vaut pas exactement 0.3. Comprendre pourquoi vous évitera bien des bugs.

L'analogie avec la notation scientifique

En mathématiques, on note souvent un grand ou un petit nombre en notation scientifique :

Trois éléments structurent cette écriture :

• une mantisse : ici $6{,}022$ ou $1{,}6$,
• une base : ici 10,
• un exposant : ici $23$ ou $-19$.

La virgule flottante reprend exactement cette idée, en base 2. Un flottant s'écrit alors comme :

où $s$ est le bit de signe, $m$ la mantisse (en binaire, entre 1 et 2 environ), et $e$ l'exposant (un entier signé).

La norme IEEE 754, vue simplifiée

La norme IEEE 754 fixe la répartition des bits. En simple précision (32 bits) :

En double précision (64 bits, le float Python par défaut) :

Pourquoi $0{,}1$ pose problème

En base 10, $\frac{1}{10}$ s'écrit simplement 0,1. Mais en base 2, $\frac{1}{10}$ a un développement infini périodique :

Comme la mantisse a une taille bornée (52 bits en double précision), la machine tronque ce développement infini. Le résultat est une approximation très proche de $0{,}1$, mais pas exactement $0{,}1$.

La preuve par Python

print(0.1 + 0.2)       # 0.30000000000000004
print(0.1 + 0.2 == 0.3)  # False

L'écart est minuscule — de l'ordre de $10^{-17}$ — mais il est non nul, et il suffit à faire échouer un test d'égalité strict. Ce comportement n'est pas un bug de Python : c'est la conséquence directe de la représentation binaire des flottants.

Sortie attendue (extrait) :

0.1000000000000000055511151231257827021181583404541015625
0.200000000000000011102230246251565404236316680908203125
0.3000000000000000166533453694

Les deux premières lignes affichent la valeur binaire exacte des floats 0.1 et 0.2 (le constructeur Decimal(float) n'arrondit pas). La 3ᵉ ligne correspond à l'addition : Python repasse alors par le contexte Decimal de précision par défaut, qui arrondit à 28 chiffres significatifs. La valeur reste différente de 0.3 exact — ce qui confirme l'erreur de représentation binaire.

Comment comparer deux flottants

La règle d'or est simple : on ne teste jamais l'égalité stricte de deux flottants. À la place, on vérifie qu'ils sont suffisamment proches, à une tolérance $\varepsilon$ près.

def proche(a, b, eps=1e-9):
    return abs(a - b) < eps

print(proche(0.1 + 0.2, 0.3))  # True

Python fournit aussi math.isclose pour cette comparaison, plus robuste :

import math
print(math.isclose(0.1 + 0.2, 0.3))  # True

Valeurs spéciales — inf, -inf, nan

IEEE 754 prévoit quelques valeurs particulières :

• inf (infini positif) : résultat d'un dépassement ou d'une division par zéro positive.
• -inf (infini négatif).
• nan (Not a Number) : résultat d'une opération invalide, comme $0/0$ ou $\sqrt{-1}$.

import math
print(math.inf)              # inf — constante du module math
print(1 / 0.0)               # ZeroDivisionError en Python pur (et non inf)
print(float('nan') == float('nan'))  # False — un nan n'est jamais égal à lui-même !

Pièges courants

Pour aller plus loin

Pour des calculs financiers ou scientifiques exigeants, Python fournit deux alternatives :

• Le module decimal (calcul en base 10, à précision arbitraire) — bien adapté aux montants monétaires.
• Le module fractions (rationnels exacts $\frac{p}{q}$) — utile pour les calculs symboliques où les approximations sont interdites.

from fractions import Fraction
print(Fraction(1, 10) + Fraction(2, 10))  # 3/10

Ces alternatives sont plus lentes, mais elles fournissent le résultat exact.