Sources d'erreurs en analyse numérique

Avant de concevoir ou d'utiliser un algorithme numérique, il est essentiel de comprendre d'où proviennent les erreurs. Cette compréhension permet d'anticiper les problèmes, de choisir des méthodes appropriées et d'interpréter correctement les résultats obtenus.

Pourquoi s'intéresser aux erreurs ?

Considérons un exemple simple : vous développez un logiciel de navigation GPS. Le système doit calculer en temps réel la position d'un véhicule à partir de signaux satellitaires. Chaque calcul implique des approximations, et ces approximations s'accumulent. Si vous ne comprenez pas la nature des erreurs en jeu, votre véhicule pourrait se retrouver « dans le lac » selon le GPS alors qu'il roule sur l'autoroute.

En analyse numérique, les erreurs ne sont pas des accidents : elles sont inévitables. Notre objectif n'est pas de les éliminer complètement, mais de les comprendre, les quantifier et les contrôler.

Classification des erreurs

Les erreurs en calcul numérique se divisent en deux grandes familles : les erreurs de données, qui existent avant même que l'ordinateur n'intervienne, et les erreurs numériques, qui apparaissent lors du traitement informatique.

Erreurs de données

Les erreurs de données proviennent de l'écart entre le monde réel et le modèle mathématique que nous utilisons pour le représenter. Elles se subdivisent en deux catégories.

Erreurs de modélisation

Un modèle mathématique est toujours une simplification de la réalité. Cette simplification est nécessaire pour rendre le problème traitable, mais elle introduit des erreurs.

Exemple 1 : La loi de Hooke pour un ressort

En physique élémentaire, on modélise la force exercée par un ressort par la relation linéaire :

où est la constante de raideur et le déplacement. Cette loi suppose que le ressort se comporte de manière parfaitement linéaire.

En réalité, pour de grandes déformations, le comportement devient non linéaire :

où dépend maintenant du déplacement. En utilisant le modèle linéaire simple, nous introduisons une erreur de modélisation qui peut devenir significative lorsque le ressort est fortement comprimé ou étiré.

Exemple 2 : Mécanique des fluides

Dans de nombreuses simulations aérodynamiques, on néglige la viscosité de l'air pour simplifier les équations de Navier-Stokes. Cette hypothèse, valide pour certains régimes d'écoulement, devient problématique près des surfaces où les effets visqueux dominent. Ignorer la viscosité dans la simulation d'une aile d'avion conduirait à sous-estimer la traînée et à surestimer la portance.

Exemple 3 : Physique atomique

Utiliser la mécanique classique de Newton pour décrire le comportement d'électrons dans un atome introduit des erreurs fondamentales. Les phénomènes quantiques, comme l'effet tunnel ou la quantification des niveaux d'énergie, ne peuvent simplement pas être capturés par un modèle classique.

Erreurs de mesure

Même si notre modèle est correct, les données d'entrée proviennent de mesures physiques, et toute mesure est entachée d'incertitude.

Exemple : Mesure de température

Un thermomètre numérique affiche « 23,4 °C ». Que signifie ce chiffre ? Le fabricant indique une précision de °C. La vraie température se situe donc quelque part entre 22,9 °C et 23,9 °C. Si nous utilisons cette valeur dans un calcul de dilatation thermique, cette incertitude se propagera au résultat final.

Exemple : Mesure de tension électrique

Un voltmètre de laboratoire offre une précision de V. Pour un circuit électronique de précision, cette incertitude peut être acceptable. Pour un circuit de puissance où les tensions sont de l'ordre de centaines de volts, cette même incertitude devient négligeable.

Erreurs numériques

Les erreurs numériques apparaissent lors du traitement informatique des données. Elles découlent de la nature finie des représentations et des calculs dans un ordinateur.

Erreurs de troncature

Une erreur de troncature survient lorsqu'un processus mathématiquement infini est remplacé par un processus fini.

Exemple fondamental : La fonction exponentielle

La fonction exponentielle peut être définie par une série infinie :

En pratique, nous ne pouvons pas calculer une somme infinie. Nous devons nous arrêter après un certain nombre de termes :

Les termes ignorés (de à l'infini) constituent l'erreur de troncature.

Pour et , calculons l'approximation :

La valeur exacte étant , l'erreur de troncature est d'environ .

Exemple : Dérivée numérique

Mathématiquement, la dérivée d'une fonction en un point est définie comme une limite :

Mais un ordinateur ne peut pas calculer une limite — il ne manipule que des nombres finis. On remplace donc la limite par une approximation avec un petit mais non nul :

Cette approximation « coupe » le développement de Taylor après le premier terme. En effet, , donc . L'erreur de troncature est proportionnelle à : plus est petit, plus l'approximation devrait être précise.

Mais attention : réduire trop drastiquement introduit un autre problème. Quand devient très petit, et deviennent presque égaux, et leur soustraction provoque une perte de précision (nous verrons ce phénomène en détail dans la leçon sur l'annulation catastrophique).

Erreurs d'arrondi

Les erreurs d'arrondi proviennent de l'impossibilité de représenter exactement tous les nombres réels dans un ordinateur.

Le problème fondamental

L'ensemble des nombres réels est continu et infini. L'ordinateur ne peut représenter qu'un ensemble fini et discret de valeurs. Chaque nombre réel doit être approximé par le nombre représentable le plus proche.

Exemple révélateur : Le nombre 0,1 en binaire

Le nombre décimal semble anodin. Pourtant, sa représentation en base 2 est périodique infinie :

Cette représentation ne peut pas être stockée exactement dans un ordinateur. Elle est tronquée, ce qui introduit une petite erreur à chaque fois que est utilisé.

Voici une démonstration concrète de ce phénomène :

# Démonstration de l'erreur d'arrondi
x = 0.0
for i in range(10):
  x = x + 0.1
  print(f"Après {i+1} additions : x = {x:.20f}")

print(f"\nValeur attendue : 1.0")
print(f"Valeur obtenue  : {x:.20f}")
print(f"Différence      : {abs(x - 1.0):.20e}")

Ce code produit une sortie surprenante : après 10 additions de , le résultat n'est pas exactement , mais plutôt quelque chose comme ou .

Conséquence pratique : Boucles infinies

Considérons ce code apparemment simple :

# ATTENTION : Ce code peut ne jamais terminer !
x = 1.0
while x != 0.0:
  print(x)
  x = x - 0.1

En raison des erreurs d'arrondi, la variable pourrait ne jamais atteindre exactement , causant une boucle infinie. C'est pourquoi on ne compare jamais deux nombres à virgule flottante avec l'égalité stricte.

Interaction entre les sources d'erreurs

En pratique, ces erreurs ne sont pas indépendantes. Elles interagissent de manière parfois contre-intuitive, créant des compromis délicats.

La dérivée numérique (suite)

Reprenons l'exemple de la dérivée vu plus haut. On a deux erreurs qui évoluent en sens inverse :

• L'erreur de troncature diminue quand diminue
• L'erreur d'arrondi augmente quand diminue (car )

Il existe donc une valeur optimale de qui minimise l'erreur totale : ni trop grande (troncature dominante), ni trop petite (arrondi dominant).

Le calcul d'intégrales

Même phénomène pour l'intégration numérique : diviser l'intervalle en plus de sous-intervalles réduit l'erreur de troncature, mais multiplie le nombre d'opérations et donc les erreurs d'arrondi accumulées.

Les méthodes itératives

Pour résoudre certaines équations (comme ), on utilise des méthodes itératives qui convergent progressivement vers la solution. Plus on fait d'itérations, plus on se rapproche de la vraie solution. Mais chaque itération accumule des erreurs d'arrondi. Au-delà d'un certain nombre d'itérations, continuer ne sert plus à rien — voire dégrade le résultat.

L'élimination de Gauss

Pour résoudre un système linéaire , l'élimination de Gauss effectue des opérations élémentaires sur les lignes. Si les coefficients de la matrice proviennent de mesures physiques (erreurs de mesure), ces erreurs se propagent à travers chaque opération. De plus, chaque division et soustraction introduit des erreurs d'arrondi. Pour un système mal conditionné, ces erreurs peuvent s'amplifier dramatiquement : une petite incertitude sur les données d'entrée produit une grande erreur sur la solution.

C'est pourquoi on préfère en pratique des méthodes plus stables :

• LU avec pivotage : on échange les lignes pour éviter les divisions par de petits nombres (c'est ce que fait numpy.linalg.solve)
• Décomposition QR : utilise des rotations orthogonales qui n'amplifient pas les erreurs
• Décomposition SVD : la plus robuste, permet aussi de diagnostiquer le conditionnement du système

Pour en savoir plus, voir Gaussian elimination: Numeric instability.

Schéma récapitulatif

Le flux des erreurs dans un calcul numérique peut être visualisé ainsi :

Ce qu'il faut retenir

Les erreurs en analyse numérique sont inévitables et proviennent de sources distinctes. Les erreurs de données (modélisation et mesure) existent indépendamment de l'ordinateur et définissent la limite théorique de précision atteignable. Les erreurs numériques (troncature et arrondi) sont introduites par le processus de calcul lui-même.

La maîtrise de ces concepts est fondamentale pour la suite du cours. Chaque méthode numérique que nous étudierons sera analysée sous l'angle de ses erreurs : quelle est leur nature, comment les quantifier, comment les minimiser ?

Dans les prochaines leçons, nous approfondirons la représentation des nombres en virgule flottante et nous introduirons les outils mathématiques permettant de mesurer et propager les erreurs : les notions d'erreur absolue, d'erreur relative et de chiffres significatifs exacts.

Activités de reflexion

Activité 1 : Classer les erreurs

Pour chacune des situations suivantes, identifiez s'il s'agit d'une erreur de modélisation, de mesure, de troncature ou d'arrondi. Justifiez brièvement.

1. Un ingénieur simule la trajectoire d'une fusée en négligeant la rotation de la Terre.

2. Un capteur de température affiche 21,3 °C alors que la température réelle est 21,287 °C.

3. Un programme calcule en utilisant les 5 premiers termes de la série de Taylor.

4. Python stocke la valeur comme 0.3333333333333333.

5. Un modèle économique suppose que les consommateurs agissent de manière parfaitement rationnelle.

6. On approxime une intégrale par la somme de 100 rectangles.

Activité 2 : Le thermomètre et la dilatation

Un ingénieur doit calculer la dilatation d'une poutre d'acier. La formule utilisée est :

où :

• m (longueur initiale, mesurée avec une précision de m)
• °C⁻¹ (coefficient de dilatation de l'acier)
• est la variation de température

Le thermomètre utilisé a une précision de °C. L'ingénieur mesure °C.

Questions :

1. Calculez avec les valeurs mesurées.

2. Si la vraie température était en réalité °C, quelle serait l'erreur sur due à l'imprécision du thermomètre ?

3. Cette erreur est-elle significative si la tolérance sur la dilatation est de mm ?

4. Quel type d'erreur domine ici : modélisation, mesure, troncature ou arrondi ?

Activité 3 : Expérimentation — La boucle dangereuse

Exécutez le code suivant dans Python ou un environnement en ligne :

# Expérience 1 : Somme de 0.1
somme = 0.0
for i in range(10):
  somme += 0.1
print(f"Somme de 10 fois 0.1 : {somme}")
print(f"Égal à 1.0 ? {somme == 1.0}")

# Expérience 2 : Comparaison
a = 0.1 + 0.2
b = 0.3
print(f"\n0.1 + 0.2 = {a}")
print(f"0.3       = {b}")
print(f"Égaux ? {a == b}")

# Expérience 3 : Visualiser la différence
print(f"\nDifférence : {a - b:.25f}")

Questions de réflexion :

1. Expliquez pourquoi somme == 1.0 retourne False.

2. Comment réécririez-vous le test d'égalité pour qu'il fonctionne correctement ?

3. Un collègue vous montre ce code et dit : « Python a un bogue, il ne sait pas additionner. » Que lui répondez-vous ?

4. Dans quels contextes professionnels ce type d'erreur pourrait-il avoir des conséquences graves ?