Erreurs dans les opérations flottantes

Avec la leçon précédente, nous savons maintenant que seul un sous-ensemble fini des réels peut être stocké exactement et nous connaissons la structure IEEE 754. Cette leçon explore les conséquences pratiques de cette limitation : comment les erreurs apparaissent lors des calculs et comment elles se propagent à travers les opérations arithmétiques.

Troncature versus arrondissement

Lorsqu'un nombre réel possède plus de chiffres significatifs que le système ne peut en stocker, il faut le projeter sur l'ensemble des nombres machine. Deux stratégies principales existent.

Notation

Soit $\mathbb{F}(b, s, m, M)$ un système flottant avec :

• $b$ : la base
• $s$ : le nombre de chiffres significatifs (précision)
• $m, M$ : les bornes de l'exposant

Tout nombre réel $x \neq 0$ peut s'écrire en notation flottante normalisée :

On note $\text{fl}(x)$ la représentation flottante de $x$ dans le système.

Troncature (arrondi vers zéro)

La troncature consiste à ignorer les chiffres au-delà de la position $s$. C'est équivalent à un arrondi vers zéro.

Définition formelle : Soit $x = \pm d_1{,}d_2 \cdots d_s d_{s+1} \cdots \times b^e$. La troncature est :

Borne d'erreur absolue : L'erreur de troncature est bornée par :

Borne d'erreur relative : Pour $x \neq 0$ :

Cette borne $b^{1-s}$ est l'epsilon machine $\varepsilon$.

Démonstration appliquée : troncature

Exemple 1 : Tronquer $x = 1237$ dans un système $(b=10, s=3)$.

Étape 1 : Écrire en notation flottante normalisée.

Étape 2 : Identifier les chiffres de la mantisse.

Étape 3 : Conserver uniquement les $s = 3$ premiers chiffres.

Étape 4 : Calculer l'erreur et vérifier la borne.

Vérifions la borne : $b^{1-s} = 10^{1-3} = 10^{-2} = 1\%$. Notre erreur de 0,566% est bien inférieure.

Exemple 2 : Tronquer $x = 0{,}0098765$ dans un système $(b=10, s=3)$.

Étape 1 : Normaliser.

Étape 2 : Identifier les chiffres.

Étape 3 : Tronquer à $s=3$ chiffres.

Étape 4 : Calculer l'erreur.

Propriété fondamentale : La troncature est biaisée puisque :

En d'autres termes, la troncature rapproche toujours vers zéro.

Arrondissement au plus proche (round to nearest)

L'arrondissement au plus proche projette un nombre réel sur le nombre machine le plus proche, minimisant ainsi l'erreur.

Définition formelle : Soit $x$ un réel et $x_-, x_+$ les deux nombres machine encadrant $x$ (avec $x_- < x < x_+$). L'arrondi au plus proche est :

Borne d'erreur relative : Pour l'arrondissement au plus proche :

où $\varepsilon = b^{1-s}$ est l'epsilon machine. Cette borne est deux fois plus petite que pour la troncature.

Procédure pratique (ajout de demi-unité) :

Soit $x = \pm d_1{,}d_2 \cdots d_s d_{s+1} \cdots \times b^e$ en notation normalisée (avec $1 \leq d_1 < b$).

Méthode 1 — Sur la mantisse : Ajouter $\frac{1}{2} b^{1-s}$ à la mantisse, puis tronquer :

Méthode 2 — Sur le nombre : Ajouter $\frac{1}{2} b^{e-s+1}$ au nombre, puis tronquer :

Démonstration appliquée : arrondissement

Exemple 1 : Arrondir $x = 1237$ dans un système $(b=10, s=3)$.

Étape 1 : Normaliser.

Étape 2 : Identifier les nombres machine encadrants.

Avec $s = 3$ chiffres significatifs, les nombres machine autour de 1237 sont :

L'écart entre eux est $x_+ - x_- = 10$, donc la demi-unité est $5$.

Étape 3 : Appliquer la méthode d'ajout de demi-unité.

Étape 4 : Tronquer.

Vérification : 1237 est à distance 7 de 1230 et à distance 3 de 1240. Le plus proche est bien 1240. ✓

Étape 5 : Calculer l'erreur et vérifier la borne.

Vérifions la borne : $\frac{1}{2}b^{1-s} = \frac{1}{2} \times 10^{-2} = 0{,}5\%$. Notre erreur de 0,243% est bien inférieure. ✓

Exemple 2 : Arrondir $x = 1234$ dans un système $(b=10, s=3)$.

Étape 1 : Normaliser.

Les nombres machine encadrants sont toujours 1230 et 1240.

Étape 2 : Ajouter la demi-unité (5).

Étape 3 : Tronquer.

Vérification : 1234 est à distance 4 de 1230 et à distance 6 de 1240. Le plus proche est bien 1230. ✓

Étape 4 : L'erreur est de 4, soit $0{,}324\%$ (toujours sous la borne de 0,5%).

Comparaison des méthodes

Observations :

• La troncature produit toujours une erreur de signe opposé à celui de $x$ (le résultat est ramené vers zéro), avec la convention erreur = valeur approchée − valeur exacte utilisée dans le tableau
• L'arrondissement produit des erreurs positives ou négatives selon le cas
• L'erreur maximale par arrondissement est environ la moitié de celle par troncature

Récapitulatif des bornes d'erreur

En pratique : les modes d'arrondi IEEE 754

Tous les processeurs modernes implémentent la norme IEEE 754. Cette norme définit 5 modes d'arrondi :

Le mode par défaut est l'arrondi au plus proche (« round to nearest, ties to even »). C'est ce qu'utilisent votre ordinateur, votre téléphone, et pratiquement tout appareil numérique pour les opérations flottantes.

Pourquoi l'arrondi par défaut et pas la troncature ? La troncature introduit un biais systématique : les résultats sont toujours décalés vers zéro. Sur des millions d'opérations, ce biais s'accumule et fausse les résultats. L'arrondi au plus proche n'a pas ce biais — les erreurs positives et négatives se compensent statistiquement.

Quand la troncature est-elle utilisée ? La troncature (« round toward 0 ») n'est pas utilisée pour les opérations flottantes standard, mais elle intervient généralement dans deux cas :

• Conversion float → entier : int(3.7) en Python ou (int)3.7 en C donne 3. La partie fractionnaire est supprimée.
• Mode explicitement activé : le programmeur peut changer le mode d'arrondi pour des besoins spécifiques (arithmétique d'intervalles, etc.).

Comportement des quatre opérations

En arithmétique flottante, les opérations classiques ne donnent généralement pas le résultat mathématiquement exact. La norme IEEE 754 exige cependant que chaque opération soit correctement arrondie : le résultat doit être celui qu'on obtiendrait en calculant avec une précision infinie, puis en arrondissant.

Notation et modèle d'erreur

Soit $\circ \in \{+, -, \times, \div\}$ une opération arithmétique. On note :

• $x \circ y$ : le résultat exact (réel)
• $\text{fl}(x \circ y)$ : le résultat flottant calculé

Modèle standard (IEEE 754) : Pour toute opération $\circ$ entre deux nombres flottants $x$ et $y$ :

où $\varepsilon = b^{1-s}$ est l'epsilon machine.

Bornes d'erreur par opération

Les symboles $\oplus, \ominus, \otimes, \oslash$ représentent les opérations flottantes (calculées), par opposition aux opérations exactes $+, -, \times, \div$.

Démonstration appliquée : Addition

Calculons $1{,}37 \oplus 0{,}0269$ dans un système $(b=10, s=3)$.

Étape 1 : Représenter les opérandes en notation flottante normalisée

Étape 2 : Aligner les exposants

Pour additionner, on exprime les deux nombres avec le même exposant (le plus grand) :

Étape 3 : Effectuer l'addition exacte

Étape 4 : Arrondir à $s=3$ chiffres

Le résultat exact $1{,}3969$ doit être arrondi. En notation normalisée : $1{,}3969 \times 10^0$.

Par troncature :

Par arrondissement (demi-unité = 0,005) :

Bilan et vérification du modèle :

• Valeur exacte : $1{,}3969$
• Par arrondissement : $1{,}40$
• Erreur relative : $\delta = \frac{1{,}40 - 1{,}3969}{1{,}3969} \approx 0{,}22\%$
• Borne théorique : $\frac{\varepsilon}{2} = \frac{10^{-2}}{2} = 0{,}5\%$

L'erreur respecte bien la borne du modèle IEEE 754.

Démonstration appliquée : Multiplication

Calculons $\text{fl}\left(\frac{1}{3}\right) \otimes 3$ dans un système $(b=10, s=3)$.

Étape 1 : Représenter les opérandes

Note : $\frac{1}{3}$ n'est pas représentable exactement ; on a déjà une erreur d'entrée.

Étape 2 : Multiplier les mantisses

Étape 3 : Additionner les exposants

Résultat intermédiaire : $9{,}99 \times 10^{-1} = 0{,}999$

Étape 4 : Normaliser et arrondir

Le résultat $9{,}99 \times 10^{-1}$ est déjà normalisé et a exactement 3 chiffres. Pas d'arrondi supplémentaire.

Bilan : Le résultat mathématique devrait être $\frac{1}{3} \times 3 = 1$, mais l'arithmétique flottante donne $0{,}999$. L'erreur provient de la représentation initiale de $\frac{1}{3}$, pas de l'opération de multiplication elle-même.

Perte de précision

Certaines configurations de calcul amplifient dramatiquement les erreurs.

Le phénomène d'absorption

L'epsilon machine explique pourquoi certains calculs semblent « ignorer » de petites quantités :

# Phénomène d'absorption
grand = 1e16
petit = 1.0

resultat = grand + petit - grand
print(f"(1e16 + 1) - 1e16 = {resultat}")  # Devrait être 1, mais...

# Explication : 1.0 est trop petit par rapport à 1e16
# pour affecter sa représentation flottante
print(f"1e16 + 1 == 1e16 : {1e16 + 1 == 1e16}")

Ce phénomène s'appelle l'absorption : un petit nombre ajouté à un grand nombre peut être « absorbé » sans modifier le résultat.

Démonstration appliquée : Absorption

Calculons $3780 \ominus 0{,}321$ dans un système $(b=10, s=3)$.

Étape 1 : Représenter les opérandes en notation normalisée

Étape 2 : Aligner les exposants

Pour soustraire, on exprime $y$ avec l'exposant de $x$ :

Étape 3 : Effectuer la soustraction exacte

Résultat exact : $3{,}779679 \times 10^3 = 3779{,}679$

Étape 4 : Arrondir à $s=3$ chiffres

Par troncature :

Par arrondissement :

Observation : Par arrondissement, le résultat est identique à l'opérande initial ! Le petit nombre $y = 0{,}321$ a été complètement « absorbé ». C'est un cas typique où $x \ominus y = x$ alors que $x - y \neq x$.

Perte d'associativité

En mathématiques, l'addition est associative :

En arithmétique flottante, cette propriété n'est plus garantie.

# Démonstration de la perte d'associativité
a = 1e16
b = -1e16
c = 1.0

# Ordre 1 : (a + b) + c
resultat1 = (a + b) + c
print(f"(1e16 + (-1e16)) + 1 = {resultat1}")

# Ordre 2 : a + (b + c)
resultat2 = a + (b + c)
print(f"1e16 + ((-1e16) + 1) = {resultat2}")

print(f"Les résultats sont égaux : {resultat1 == resultat2}")

Dans le premier cas, $a + b = 0$ exactement, puis $0 + c = 1$.

Dans le second cas, $b + c \approx b$ (le 1 est absorbé), puis $a + b = 0$.

Perte d'associativité de la multiplication (dépassement intermédiaire)

La multiplication aussi peut perdre son associativité dans des cas extrêmes :

# Note sur les exposants en Python (double précision IEEE 754):
# - Exposant min (min_exp): -1021 (en base 2), soit environ 10^-307 (min_10_exp)
# - Exposant max (max_exp): 1024 (en base 2), soit environ 10^308 (max_10_exp)
# Le biais est de 1023, donc l'exposant réel va de -1022 à +1023 pour les nombres normalisés.
# Pour voir toutes les infos: import sys; print(sys.float_info)

# La multiplication reste toujours commutative en IEEE 754,
# mais l'ordre des produits peut affecter les résultats intermédiaires

a = 1e-307
b = 1e308  ## essayer aussi avec 1e306, 1e307, 1e308, 1e309
c = 2.0

# Ordre 1
r1 = (a * b) * c
print(f"({a} * {b}) * {c} = {r1}")

# Ordre 2 : risque de dépassement intermédiaire
r2 = (b * c) * a
print(f"({b} * {c}) * {a} = {r2}")

# Ordre 3 : risque de soupassement intermédiaire
r3 = (a * c) * b
print(f"({a} * {c}) * {b} = {r3}")

Résultats intermédiaires

Pour toute suite d'opérations, chaque résultat intermédiaire est arrondi (ou tronqué) avant d'être utilisé dans l'opération suivante. Les erreurs s'accumulent donc à chaque étape.

Résumé des pièges courants

Ce qu'il faut retenir

L'arithmétique flottante n'est pas l'arithmétique des réels. Les propriétés mathématiques fondamentales (associativité, distributivité) ne sont plus garanties. Les phénomènes d'absorption et de décalage peuvent causer des pertes de précision significatives.

Formules essentielles

Bornes d'erreur pour la représentation :

Modèle standard pour les opérations (IEEE 754) :

Points essentiels

• La troncature est biaisée (vers zéro), l'arrondissement minimise l'erreur moyenne
• Chaque opération flottante ($\oplus, \ominus, \otimes, \oslash$) introduit une erreur relative bornée par $\frac{\varepsilon}{2}$
• L'absorption fait disparaître les petites quantités ajoutées aux grandes
• L'ordre des opérations affecte le résultat final (perte d'associativité)
• Les erreurs s'accumulent au fil des calculs

La prochaine leçon introduira les outils pour mesurer ces erreurs : les chiffres significatifs exacts.

Exercices de réflexion

Exercice 1 : Ordre des opérations

Considérez les trois nombres : $a = 10^{20}$, $b = -10^{20}$, $c = 1$.

1. Calculez $(a + b) + c$ à la main en arithmétique exacte.
2. Calculez $a + (b + c)$ à la main en arithmétique exacte.
3. Expliquez pourquoi Python donne des résultats différents pour ces deux expressions.
4. Généralisez : quelle règle devrait-on suivre pour minimiser les erreurs lors de sommations ?

Exercice 2 : Troncature vs arrondissement

Dans un système flottant fictif avec $b = 10$ et $s = 4$ chiffres de mantisse, calculez les représentations par troncature et par arrondissement des nombres suivants :

1. $x = 12{,}3456$
2. $x = 0{,}0098765$
3. $x = 98765{,}4321$

Pour chaque cas :

• Normalisez le nombre sous la forme $d_1{,}d_2d_3\cdots \times 10^e$
• Calculez $\text{tron}(x, s)$ et $\text{arrondi}(x, s)$
• Vérifiez que les erreurs relatives respectent les bornes $\varepsilon$ et $\frac{\varepsilon}{2}$

Exercice 3 : Absorption en pratique

Écrivez un programme Python qui :

1. Calcule la somme $S = 1 + 10^{-16} + 10^{-16} + \cdots$ (un million de termes $10^{-16}$)
2. Compare le résultat avec la valeur théorique $1 + 10^{-10}$
3. Propose une méthode pour obtenir un résultat plus précis

Exercice 4 : Multiplication et précision

Dans un système $(b=10, s=3)$, calculez pas à pas le produit $2{,}34 \times 5{,}67$.

1. Représentez chaque opérande en notation flottante normalisée.
2. Effectuez la multiplication des mantisses.
3. Additionnez les exposants.
4. Renormalisez si nécessaire.
5. Arrondissez à 3 chiffres.
6. Comparez avec le résultat exact.