ChronoMath, une chronologie des MATHÉMATIQUES
à l'usage des professeurs de mathématiques, des étudiants et des élèves des lycées & collèges

Arrondis des ordinateurs, erreurs de mesure    arrondi d'une somme , d'un produit , d'une racine carrée
      
La notion élémentaire d'arrondi et de troncature | numération binaire, codage et arrondis | exemple d'accumulation d'erreurs d'arrondi

On aborde ici l'aspect mathématique des erreurs d'arrondi engendrées par les ordinateurs (ou les calculatrices), ce qui revient également à étudier les conséquences des erreurs de mesures en physique ou en astronomie.

Soit x un nombre entré ou calculé. Suivant sa valeur, l'ordinateur va l'arrondir par excès ou par défaut. La valeur machine de x sera alors :

x' = x ± e avec 0 e << 1      (<< 1 signifiant ici "très petit" devant 1)

Plus précisément :

x' = x(1 + ex) avec 0 | ex | <<1.

Il suit que les erreurs absolues et relatives commises sur x sont respectivement :

Δx = x - x' = xex  et  Δx / x = ex

 Nous allons étudier trois cas démontrant la difficulté d'apprécier les erreurs d'arrondi d'un calculateur électronique.

Soit z = f(x,y) le résultat d'une opération élémentaire : un produit, une somme, etc. En notant f 'x(x,y) et f 'y(x,y) les dérivées partielles de f par rapport à x et y, on a :

dz = f 'x(x,y).dx + f 'y(x,y).dy

soit, sensiblement, en passant aux valeurs absolues :

Δz | f 'x(x,y) | . |Δx| + | f 'y(x,y) | . |Δy|

A chaque mise en mémoire d'une donnée ou d'un résultat intermédiaire z, l'ordinateur (resp. l'observateur dans le cas d'une mesure physique) peut commettre une erreur es dépendant de sa capacité de stockage (resp. de la précision de ses calculs) induisant une erreur complémentaire zes : par exemple, le produit de deux entiers n'engendrant pas d'erreur de stockage peut en produire une sur le résultat. L'erreur absolue commise sur z vérifiera alors :

Δz | f 'x(x,y) | . |Δx| + | f 'y(x,y) | . |Δy| + |zes|

et l'erreur relative sera :


Cas d'un produit xy :

On a ici f 'x(x,y) = y et f 'y(x,y) = x. On obtient alors :

| ez | |ex| + |ey| + |es|.

On voit là que l'erreur est la somme des erreurs relatives, ce qui est parfaitement naturel et acceptable. Notons que si x et y sont des données entières ne dépassant pas la capacité de traitement de la machine, on a ex = ey = 0 et la seule erreur possible est l'erreur es de stockage du produit. Cette erreur peut se produire si x et y sont grands : perte de chiffres significatifs par arrondi.

Exemple :

100009 * 100009 = 10001800081  : le calcul avec certaines calculatrices fournit 1.000180008E+10, soit 10001800080 : l'erreur absolue sur ce produit semble être 1 et l'erreur relative de 10-10. Pour le calcul de 100009 * 100009 - 10001800081, la machine répond 1 : il faut toujours distinguer l'affichage et le résultat effectivement en mémoire. Sur ces machines, les ennuis commencent véritablement dès que le résultat possède plus de 10 ou 12 chiffres significatifs.

Cas d'une somme x + y ou d'une différence x - y :

On a ici f 'x(x,y) = f 'y(x,y) = 1. On obtient :

L'erreur dépend là, non seulement des valeurs de x et y, mais aussi du résultat théorique de l'opération. Si x + y est petit, deux nombres quasiment opposés par exemple, ou bien, dans le cas x - y, si x est sensiblement égal à y, l'erreur peut être considérable.

On voit donc avec quelle méfiance il faut regarder un résultat affiché par l'ordinateur ou un résultat d'opérations sur des mesures entachées d'erreurs.

 

 Donnons l'exemple d'une "bête" résolution de l'équation du second degré : x2 - 10x - 1/4 = 0. Les solutions sont :

x1 = (10 - 101)/2 et x2 = (10 + 101)/2

et considérons le petit programme JavaScript suivant calculant les solutions x1 et x2 de l'équation donnée au moyen des formules usuelles rappelées ci-dessus.

On les affiche à l'écran. On calcule le produit des racines (en principe -0,25) et on vérifie si les solutions calculées par l'ordinateur annulent effectivement le trinôme.

La seconde méthode évite l'addition de nombres "presque opposés" par la formule bien connue x'.x" = c/a et on affiche les mêmes tests que dans la première méthode.



<SCRIPT LANGUAGE=JavaScript>
function go()
{
wdow=open("","calculs","height=140,width=300","scrollbars=yes")
wdow.document.write("<PRE>")
x1=(10-Math.sqrt(101))/2;
x2=(10+Math.sqrt(101))/2;
wdow.document.writeln(x1+" , "+x2)
p=x1*x2;
wdow.document.writeln(p)
p1=x1*x1-10*x1-0.25;
p2=x2*x2-10*x2-0.25;
wdow.document.writeln(p1);
wdow.document.writeln(p2);
wdow.document.writeln("------------------------")
x1=0.25/x2;
wdow.document.writeln(x1+" , "+x2)
p=x1*x2;wdow.document.writeln(p)
p1=x1*x1-10*x1-0.25;
p2=x2*x2-10*x2-0.25;
wdow.document.writeln(p1);
wdow.document.writeln(p2);
}
</SCRIPT>


La seconde méthode (séparée par les pointillés) s'avère clairement plus efficace : nos deux valeurs x1 et x2 annulent effectivement le trinôme.
 
 fonctions mathématiques usuelles de JavaScript
 
Cas de la racine carrée d'un produit :

Avec x et y positifs : on a ici f(x,y) = , donc  f 'x(x,y) = y/2 et f 'y(x,y) = x/2

Dans un problème d'arithmétique, si x et y sont donnés entiers, et ne dépassant pas la capacité de l'ordinateur, leur produit peut provoquer un dépassement de capacité.

Supposons cependant ici x < 100 et y < 100 : les erreurs commises sur x, y et xy sont alors nulles. S'il s'agit de vérifier que xy est un carré parfait, en admettant que l'algorithme de recherche de la racine carrée de la machine soit efficace (i.e. dont la précision est supérieure à la capacité de stockage), alors on peut être assuré que xy est un carré parfait si l'on a (en JavaScript) :

sqrt(x*y) = floor(sqrt(x*y))

En effet, si xy est entier, sa racine carrée sera calculée comme étant de la forme :

(n) , 0000... | 000…      ou bien      (n - 1),9999... | 999…

de sorte que la valeur machine sera dans tous les cas l'entier n (la barre symbolisant la limite de la capacité de stockage).

Voyage au bout de l'horreur... ... ou les arrondis fatals...


© Serge Mehl - www.chronomath.com