Échos de la recherche Retour à la rubrique

Un ordinateur est-il une parfaite machine à calculer ?

Piste rouge Le 28 avril 2010 - Ecrit par Jean-François Colonna Voir les commentaires (8)

Les ordinateurs sont partout et lorsque l’on voit leurs performances, par exemple, dans le domaine des jeux vidéos on a trop tendance à oublier que fondamentalement ils ne « savent » faire que les quatre opérations arithmétiques élémentaires (addition, soustraction, multiplication et division). Face donc à leur omniprésence, il est essentiel de savoir s’ils effectuent correctement ces calculs de base auxquels tout doit se ramener.

Toutes les valeurs numériques que nous utilisons, en particulier dans la vie courante, sont exprimées en base 10. Rappelons que, par exemple, l’écriture $5039.28$ signifie :
\[5\times10^3 + 0\times10^2 + 3\times10^1 + 9\times10^0 + 2\times10^{-1} + 8\times10^{-2}\]

Malheureusement, la base 10 ne peut être utilisée dans un ordinateur car pour ce faire il faudrait pouvoir disposer de systèmes physiques à dix états d’équilibre or ceux-ci seraient très difficiles à concevoir et à réaliser. Par contre, nombreux sont les systèmes à deux états d’équilibre et par exemple un interrupteur électrique qui est soit ouvert soit fermé. C’est donc la base 2 qui sera utilisée dans les ordinateurs.

Pour entrer un nombre décimal (base 10) dans un ordinateur, il faudra donc le convertir en binaire (base 2) et inversement pour sortir une valeur binaire d’un ordinateur, il conviendra de la convertir en décimal. A l’intérieur d’un ordinateur, il y a deux types principaux de nombres :

Les nombres entiers $\{...,-2,-1,0,+1,+2,...\}$.
Les nombres flottants dont le principe, pour simplifier, consiste à ramener la valeur absolue de tout nombre dans $[1,10[$ grâce à une multiplication par une puissance de 10 appropriée (négative, nulle ou positive). Ainsi, par exemple : $-5039.28=-5.03928x10^3$. Un nombre flottant sera donc défini par un petit nombre décimal (appelé mantisse) et un exposant (respectivement $-5.03928$ et $+3$ dans l’exemple précédent).

La mémoire des ordinateurs contiendra donc des chiffres binaires 0 et 1 (ou bits contraction de l’anglais binary digits). Leur capacité pourra être énorme (par exemple mille milliards de bits), mais, et cela est très important à retenir, elle sera toujours finie.

En général, les nombres entiers sont définis à l’aide de 32 bits : un bit pour le signe (0 et 1 signifiant respectivement ’+’ et ’-’) et 31 bits pour la valeur absolue. Ainsi, seuls les nombres entiers de $-2147483648$ à $+2147483647$ seront représentables et manipulables. La représentation binaire des entiers est exacte ; ainsi, par exemple le nombre 25 s’écrira avec 32 bits :

\[00000000000000000000000000011001\]

car :
\[25 = 16 + 8 + 1 = 1\times2^4 + 1\times2^3 + 0\times2^2 + 0\times2^1 + 1\times2^0 = 11001\]

En ce qui concerne les nombres flottants, 64 bits leurs sont réservés (il convient d’ajouter qu’il existe aussi une représentation n’utilisant que 32 bits, mais que celle-ci sera ignorée par soucis de simplicité). L’inventaire exhaustif des nombres alors accessibles est délicat à réaliser mais de toute évidence leur nombre est fini. A titre d’exemple le nombre pi (dont 2.699.999.990.000 décimales sont connues à la date de rédaction de cet article) ne peut donc être représenté exactement dans un ordinateur. La représentation flottante des nombres décimaux sera plus compliquée que celle des entiers, mais surtout elle sera en général approximative ; ainsi, par exemple le nombre décimal 0.3 s’écrira avec 64 bits (sans plus d’explications...) :
\[0011001100110011001100110011001100111111110100110011001100110011\]

dont la valeur est très proche de 0.3 sans toute fois l’égaler car, en effet, la somme d’un nombre fini d’inverses de puissances de 2 ne peut être égale à 0.3 !

Intéressons-nous à quelques conséquences malheureuses de cela lors de calculs utilisant les nombres flottants.

Les nombres flottants ne sont pas des nombres au sens mathématique du terme car, en effet, les propriétés d’associativité (de l’addition et de la multiplication) et de distributivité de la multiplication par rapport à l’addition sont perdues. Rappelons qu’elles signifient respectivement :

\[(AB)C = A(BC)\]
\[(A+B)+C = A+(B+C)\]
\[A(B+C)=AB+AC\]

pour tout triplet de nombres $A$, $B$ et $C$. Vérifions-le pour l’associativité en essayant les deux petits programmes suivant écrits dans le langage C (ces programmes élémentaires sont communiqués au lecteur afin de permettre à tout un chacun de reproduire le phénomène [1]) :

double   addition(x,y)                                     double    multiplication(x,y)

double   x;                                                double    x;   

double   y;                                                double    y;   

          {                                                           {    

          return(x+y);                                                return(x*y);

          }                                                           }

main()                                                      main()

          {                                                           {    

          double    a=1.1;                                            double    a=1.5;

          double    b=3.7;                                            double    b=2.3;

          double    c=5.5;                                            double    c=3.7;



          double    x1,x2;                                            double    x1,x2;



          x1 = addition(addition(a,b),c);                             x1 = multiplication(multiplication(a,b),c);

          x2 = addition(a,addition(b,c));                             x2 = multiplication(a,multiplication(b,c));



          printf("(%.6f + %.6f) + %.6f = %.15f\n",a,b,c,x1);          printf("(%.6f * %.6f) * %.6f = %.15f\n",a,b,c,x1);

          printf("%.6f + (%.6f + %.6f) = %.15f\n",a,b,c,x2);          printf("%.6f * (%.6f * %.6f) = %.15f\n",a,b,c,x2);

          }                                                           }





(1.100000 + 3.700000) + 5.500000 = 10.300000000000001       (1.500000 * 2.300000) * 3.700000 = 12.764999999999999

1.100000 + (3.700000 + 5.500000) = 10.299999999999999       1.500000 * (2.300000 * 3.700000) = 12.765000000000001

Les résultats obtenus sont différents mais malgré tout proches l’un de l’autre. Mais en est-il toujours ainsi ? Exploitons cet autre petit programme [2] dans lequel nous allons calculer successivement les valeurs de $x_0$, $x_1$, etc qui dépendent les unes des autres, puis imprimer [3] celles-ci :

                   

main()

          {

          double    A,B,x0,x1,x2,x3,x4,x5,x6,x7;



          B=4095.1;

          A=B+1;



          x0 = 1;

          x1 = (A*x0) - B;

          x2 = (A*x1) - B;

          x3 = (A*x2) - B;

          x4 = (A*x3) - B;

          x5 = (A*x4) - B;

          x6 = (A*x5) - B;

          x7 = (A*x6) - B;



          printf("x0=%+.16f\n",x0);

          printf("x1=%+.16f\n",x1);

          printf("x2=%+.16f\n",x2);

          printf("x3=%+.16f\n",x3);

          printf("x4=%+.16f\n",x4);

          printf("x5=%+.16f\n",x5);

          printf("x6=%+.16f\n",x6);

          printf("x7=%+.16f\n",x7);

          }



x0=         +1.0000000000000000

x1=         +1.0000000000004547

x2=         +1.0000000018631452

x3=         +1.0000076316294826

x4=         +1.0312599175240718

x5=       +129.0437481703507956

x6=    +524480.9968805739190429

x7=+2148322516.2225189208984375

Notons au préalable que ce programme très simple ne contient pas (ne peut pas contenir...) d’erreur de conception, ne fait pas appel à des méthodes d’approximation [4] et qu’enfin les réponses attendues (=1) sont connues a priori (ce qui est exceptionnel !). En effet, la propriété suivante est vraie :
\[A=B+1 ==> A-B=1 ==> x7=x6=x5=x4=x3=x2=x1=x0=1\]

Malheureusement ce programme ne donne pas du tout des valeurs égales à $1$ (sauf évidemment la première). Où est le problème ? En fait, $A-B$ n’est pas égale à $1$ ; $A-B$ est égale à $1$ plus ou moins $\epsilon$ (un simple bit), tout simplement parce que $4095.1$ et $4096.1$ ne sont pas représentables exactement dans un ordinateur en utilisant la représentation flottante ! Evidemment, il est possible d’imaginer (et il en existe) d’autres façons de représenter les nombres qui permettraient de résoudre ce problème particulier : on pourrait, par exemple, manipuler $4095.1$ et $4096.1$ comme deux fractions $40951/10$ et $40961/10$ et travailler ainsi uniquement avec des nombres entiers. On pourrait aussi imaginer que le compilateur (programme traduisant en instructions élémentaires les instructions données par l’utilisateur) se rende compte, par des manipulations « formelles », que tous les $x_i$ sont égaux exactement à $1$ et remplace alors les expressions $x_{i+1}=(A x_i)-B$ par $x_{i+1}=1$. Mais cela ne serait que répondre à des cas particuliers et ne résoudrait pas le problème général qui encore une fois vient de la capacité finie des ordinateurs.

L’intérêt de ce programme est donc d’une part de révéler de façon tout à fait violente un problème général d’exactitude des calculs dans un ordinateur. D’autre part il montre qu’une erreur infime (le simple bit qui faisait que A-B n’était pas égal à 1) peut s’amplifier de manière « explosive » ! Enfin, il fait référence à un processus appelé calcul itératif omniprésent, en particulier, en physique mathématique où une grandeur est transformée et retransformée suivant certaines lois. Cela sera le cas dans le dernier exemple avec les coordonnées tridimensionnelles des quatre corps (deux étoiles et deux planètes). En effet, ces dernières seront données a priori à l’instant initial puis transformées ensuite d’instants en instants selon les lois de Newton de la Physique classique.

Ces deux expériences « simplistes » démontrent qu’un ordinateur, quel qu’il soit, n’est pas une machine à calculer parfaite. La cause en est donc l’impossibilité de représenter exactement tous les nombres dont nous avons besoin.

Malheureusement, la plupart des calculs « utiles » qui sont effectués dans les ordinateurs font référence aux nombres réels. D’après ce qui précède, ces derniers ne pourront pas être ni représentés, ni manipulés exactement dans un ordinateur (sauf cas très particuliers, comme les petits nombres entiers...).

Rappelons d’abord qu’un ordinateur est fait de matériel (le hardware) et de programmes -ou logiciels- (le software). En général deux ordinateurs quelconques ne seront pas strictement identiques ; il en sera ainsi, en particulier, en ce qui concerne l’interprétation des expressions mathématiques avec les programmes appelés compilateurs. Par exemple, l’expression suivante :
\[(A+B)(C+D)\]

pourra être « comprise » de plusieurs façons différentes :
\[(A+B)(C+D)\]

\[A(C+D) + B(C+D)\]

\[AC + AD + BC + BD\]

\[etc...\]

qui sont équivalentes mathématiquement parlant. Mais ceci n’est plus vrai dans un ordinateur, à cause de la perte des propriétés d’associativité et de distributivité. Alors, dans ces conditions, un programme unique pourra produire des résultats non identiques s’il est exécuté sur plusieurs ordinateurs différents.

Cette expérience montre le calcul des trajectoires de deux planètes en orbite autour d’une étoile binaire. Le calcul est effectué sur trois ordinateurs différents à l’aide d’un seul et même programme aussi bien en ce qui concerne les instructions que les conditions initiales. Les résultats du premier sont coloriés en rouge, ceux du second en vert et enfin ceux du troisième en bleu. L’état initial est représenté dans l’image numérotée $01$. Au début du calcul (jusqu’à environ l’image 04) les trois ordinateurs donnent pratiquement les mêmes résultats qui se superposent donc et apparaissent en blanc (puisque, suivant le principe de la synthèse additive des couleurs utilisé pour les écrans d’ordinateur, un point qui possède le même niveau de rouge, de vert et de bleu apparait gris). Au-dela de l’image 04, les trajectoires blanches semblent se subdiviser en trois, visualisant ainsi la divergence entre les trois machines qui sont alors bien loin d’être d’accord entre-elles et évidemment toutes les trois se trompent ! Une remarque s’impose alors : le calcul ici présenté repose sur les principes de la mécanique newtonienne et des méthodes dites d’intégration numérique, mais cela importe peu : en effet, ce qui est mis en évidence c’est qu’un programme peut donner des résultats différents suivant la machine sur laquelle il s’exécute.

Fort heureusement, tous les programmes ne sont pas sensibles à ce phénomène !

On pourra trouver ici d’autres exemples d’anomalies concernant, par exemple, l’influence du style du programmeur ou encore la difficulté de pratiquer le calcul dit parallèle sur des systèmes hétérogènes (c’est-à-dire non strictement identiques aussi bien au niveau du matériel que du logiciel) ou enfin la pérennité et la reproductibilité des résultats numériques.

Il est incontestable que l’ordinateur est une machine aux possibilités quasiment infinies, aussi bien dans la vie courante que dans la recherche scientifique la plus fondamentale. Mais il convient de na pas oublier qu’il n’est pas infaillible et que, comme tout outil, il n’est pas neutre. Connaître et maîtriser ses limites c’est pouvoir en tirer le meilleur parti, mais tout en restant vigilant.

Article édité par Jacques Istas

Notes

[1] Dans ces programmes deux fonctions $addition(x,y)$ et $multiplication(x,y)$ sont définies afin de faire respectivement l’addition et la multiplication de deux nombres flottants 64 bits (dits double) $x$ et $y$. Ces deux fonctions sont destinées à imposer l’ordre des opérations dans le programme principal (ou main) : puisque l’on veut comparer les valeurs de $(AB)C$ et de $A(BC)$ il faut être sûr que l’on calcule bien ces deux expressions. Sinon, imposer l’ordre des opérations est très difficile, voire impossible, même à l’aide de parenthèses, lorsqu’il y a plusieurs possibilités mathématiquement équivalentes.

[2] Pour des raisons de simplicité et de compréhension, la notion d’itération n’y est pas utilisée, alors qu’il pourrait être évidemment rédigé de façon beaucoup plus compacte

[3] à l’aide la fonction $printf$.

[4] Contrairement à l’exemple du calcul de trajectoires décrit à la fin de cet article.

Commentaire sur l'article

Un ordinateur est-il une parfaite machine à calculer ?

le 28 avril 2010 à 21:05, par Vincent Hugerot

Amusez-vous à faire boguer Excel :
tapez -0,009 en A1, -0,008 en A2,
sélectionnez ces deux cellules et copiez jusqu’en A10.
On s’attend à obtenir 0 dans cette cellule, on y trouve -8,6736E-18 ! (version 2007 en ce qui me concerne).
Répondre à ce message
Un ordinateur est-il une parfaite machine à calculer ?

le 1er mai 2010 à 12:29, par arnolix

Très intéressant ce programme simple qui dérive de façon vertigineuse dès les premières itérations.
J’avais réagi à un article similaire en proposant des bogues de la calculatrice de l’iphone/ipodtouch. C’est une calculatrice d’une instabilité extraordinaire : selon le contexte (en début d’utilisation, après qqs calculs, etc.) le simple fait de taper 4096,1 et d’appuyer plusieurs fois sur la touche = produit une suite non-constante divergente !!!!
Répondre à ce message
Un ordinateur est-il une parfaite machine à calculer ?

le 3 mai 2010 à 08:46, par Pierre Lescanne

Dans votre article, il y a deux phrases qui me paraissent un peu
simplificatrices.

* Fondamentalement [les ordinateurs] ne « savent » faire que les
quatre opérations arithmétiques élémentaires.

* La plupart des calculs « utiles » qui sont effectués dans les ordinateurs font référence aux nombres réels.

En fait, les ordinateurs dont je me sers tous les jours, à savoir mon
ordinateur portable, mon téléphone portable, les serveurs de bases de
données (par exemple celles de mon fournisseur de mél, de mon
fournisseur Internet, de la SNCF, de Google, de Wikipédia) utilisent
assez peu les quatre opérations et, s’ils le font, ils le font
presqu’essentiellement sur les entiers. En fait, les principales
opérations que fait un ordinateur sont des opérations de transferts,
de lecture et d’écriture, de contrôle de l’agencement des opérations
et très peu d’additions, de soustractions, de multiplications et de
divisions et la plupart de ces opérations sont faites, comme je le
disais, sur des entiers qui représentent des adresses mémoires de
l’ordinateur, des heures, des numéros divers (de train, d’article, des
notes d’étudiants etc.) et ce sont ces opérations non arithmétiques
qui donnent à l’ordinateur le caractère universel qu’on lui connaît.
Quant à l’utilité, j’espère que, comme moi, vous pensez que les calculs
que font votre ordinateur portable et votre téléphone portable sont « utiles ».

Je pense que ce que vous vouliez dire, c’est que les opérations
fondamentales d’un ordinateur sont des opérations extrêmement simples,
parmi lesquelles figurent les quatre opérations. D’autre part, vous
vouliez peut-être aussi dire que les opérations sur les réels ne
servent pas uniquement dans les consoles de jeux ou la simulation et peuvent être des
opérations « critiques », c’est-à-dire que la vie humaine peut en
dépendre, quand il s’agit, par exemple, de l’aide au pilotage d’un
avion ou du contrôle d’un appareil chirurgical. C’est pourquoi nous ne pouvons
pas nous contenter d’un calcul vaguement approchant, mais que seul le
calcul exact doit être accepté, j’entends par là qu’il n’est
pas acceptable qu’un ordinateur nous rende un flottant approximant une
valeur qu’on lui demande de calculer sans nous garantir que tous les
chiffres qu’il rend sont exacts et s’il y a un arrondi qu’il omette de nous dire comment il est obtenu, c’est à dire que tous ces chiffres
sont effectivement les premiers chiffres du développement infini de la
valeur calculée, sauf le dernier et que celui-ci est arrondi comme
on l’attend. C’est ce qu’exige pour les quatre opérations et la racine carrée la norme IEEE 754. Je recommande à nos lecteurs de lire à ce sujet
l’article Le « dilemme du fabricant de tables » ou comment calculer
juste de la revue en ligne Interstices. Je pense que les anomalies révélées par vous et vos lecteurs se réfèrent à des ordinateurs qui ne respectent pas la norme IEEE 754.
Répondre à ce message

Un ordinateur est-il une parfaite machine à calculer ?

le 24 mai 2010 à 14:27, par Jean-François Colonna

Permettez-moi les quelques remarques et suggestions suivantes :

1-Contrairement à ce que vous laissez entendre, les opérations sur les entiers ne sont pas à l’abri, elles-aussi, de problèmes liés à la nature finie des ordinateurs et par exemple, il est évidemment impossible de faire n=n+1 ad vitam aeternam ou encore de multiplier deux entiers « un peu trop grands » (ce qui interdit pratiquement de faire des calculs « utiles » en simulant les rationnels). Or, bien souvent, l’usage des entiers est fait, dans les programmes, sans se soucier de leurs limitations (de nombreux exemples bien réels sont là pour le confirmer).

2-Vous évoquez les « opérations sur les réels », mais malheureusement les réels n’existent pas dans un ordinateur et leur substitut, les « nombres flottants » ne forment pas un corps, d’où des difficultés possibles, par exemple, lors de l’optimisation automatique des programmes qui fait, en particulier, l’hypothèse de l’associativité de l’addition et de la multiplication.

3-Enfin, je ne peux que vous suggérer d’essayer les quelques petits programmes que je donne en exemple et pour lesquels les problèmes décrits ne peuvent être résolus par le simple respect de la norme IEEE 754 (respectée évidemment sur nos ordinateurs...) et par exemple le fait que la différence A-B ne soit pas égale à 1 en utilisant la représentation 64 bits (au passage A-B est bien égale à 1 en 32 bits, mais « un peu par hasard »...).
Répondre à ce message

Un ordinateur est-il une parfaite machine à calculer ?

le 18 octobre 2010 à 07:19, par Marc JAMBON

Votre affirmation : la base dix ne peut être utilisée par un ordinateur est une contre vérité, en effet, en utilisant 4 bits, vous pouvez représenter 16 caractères, rien ne vous empêche de n’en conserver que dix qui fournissent les dix chiffres de la base dix, les 6 caractères restants sont les bienvenus pour servir, en cas de besoin, de séparation, signe +, signe -, point décimal, parenthèses. Ainsi avec 32 bits vous représentez un nombre entier de 8 chiffres décimaux et même un nombre décimal précédé d’un signe avec le point décimal et 8 chiffres au total.
Il est possible que certains ordinateurs transforment toutes les représentations en base deux comme vous l’indiquez, mais ce n’est pas ou plus le cas usuel. J’ai essayé sur ma calculatrice de poche « Canon », on trouve dans tous les cas le résultat exact, même chose avec le logiciel « Mathematica ». Ceci me laisse à penser que la représentation utilisée est du type de celle que je propose ci-dessus.
Ceci dit, il est parfaitement vrai que la distributivité est en défaut dès qu’on fait des calculs approchés, mais vos exemples ne sont pas convaincants.
Répondre à ce message
Un ordinateur est-il une parfaite machine à calculer ?

le 18 octobre 2010 à 10:05, par Jean-François Colonna

Concernant l’utilisation de la base 10 dans les ordinateurs, je n’ai pas écrit que cela était impossible, mais tout simplement beaucoup plus difficile à réaliser sur les plans technologique et économique. Votre idée de représenter les chiffres décimaux à l’aide 4 bits a longtemps été utilisée dans les années soixante : c’était le DCB (Décimal Codé Binaire) très utilisé en Cobol ; il a été abandonné depuis bien longtemps...

Il convient de noter que le problème que je décris dans l’article n’est pas lié fondamentalement à la base 2 (toute autre base aurait les mêmes conséquences et donc le DCB ne résoudrait rien), mais celui de la « finitude » des ordinateurs : quelle que soit leur capacité, elle ne permet pas de stocker et encore moins de manipuler une infinité de chiffres, d’où l’impossibilité de travailler avec les nombres réels en toute généralité (qui sont « non calculables » je le rappelle).

En ce qui concerne vos expériences « positives », il peut
s’agir soit d’un coup de chance (notez par exemple que le petit programme C donne bien x0=x1=x2=...=x7=1 en simple précision -32 bits-, parce qu’alors A-B=1, un peu « par hasard »), soit d’un calcul effectué de manière formelle (c’est certainement le cas avec Mathematica pour cet exemple).
Répondre à ce message

Un ordinateur est-il une parfaite machine à calculer ?

le 18 octobre 2010 à 14:19, par Marc JAMBON

Non, ce ne peut être dû au hasard. J’ai essayé de nombreux exemples autres que les vôtres. Je m’intéresse à ces questions depuis des decennies en tant que mathématicien enseignant chercheur et accessoirement utilisateur des ordinateurs. Toutes les fois que les calculs sont exacts avec des nombres décimaux par les méthodes « manuelles », ils le sont avec l’ordinateur ou la calculatrice pourvu qu’il n’y ait pas de dépassement de capacité en écriture décimale. En particulier l’utilisation de nombres décimaux tels 0.2, 0.3 qui n’ont pas de représentation finie en binaire ne pose aucun problème.
Bien sûr, les ordinateurs sont finis, je le sais depuis longtemps, et les nombres « réels » au sens mathématique ne sont jamais rentrés dans aucun ordinateur, il serait plus pertinent d’appeler ces nombres tels, pi, e, racine de 2, des nombres infinitisimaux, le mot « réel » est trompeur, je soupçonne qu’il a été introduit par opposition aux nombres complexes. Le programme de mathématique des collèges et lycées ne donne aucune idée de ce qu’est un « nombre réel mathématique » et entretient la confusion avec les nombres qualifiés de « réel » dans certains programmes d’ordinateurs, de toute façon, il faudrait utiliser deux mots différents.
Que ce soit à partir de l’idée que je propose que vous qualifier de DCB (qui serait historiquement la première) ou d’une méthode plus sophistiquée, peu importe, je reste totalement convaincu que les calculs tels que additions, soustractions et multiplications sont effectués dans la base dix, il ne s’introduit aucune erreur tant qu’il n’y a pas de dépassement de capacité en écriture décimale, c’est compatible avec la finitude des ordinateurs, à la condition expresse qu’ils calculent en base dix. Au delà, il y a des arrondis ou des troncatures qui peuvent dépendre du logiciel de l’ordinateur utilisé et dont on aimerait bien connaitre les règles, elles ne sont jamais données !
Répondre à ce message

Un ordinateur est-il une parfaite machine à calculer ?

le 18 octobre 2010 à 17:54, par Jean-François Colonna

Il me semble d’abord que le choix de la base de numération n’a aucune importance ici (d’ailleurs, votre idée, celle du DCB depuis longtemps abandonnée, se transposerait à toute base en utilisant des « paquets » de bits de tailles suffisantes), mais il est vrai que la base 10 est plus « naturelle », les bases 2 et 3 étant les plus « économiques » en terme d’information. D’autre part, quelle que soit la base, il est évident qu’il n’y a pas de problèmes tant qu’il n’y pas de débordements or dans les calculs, tels ceux que l’on rencontre en physique mathématique, ces débordements me semblent inévitables (c’est le cas, en particulier, des calculs itératifs qui de plus, mathématiquement, utilisent en général les nombres réels). Enfin, j’ajouterai que la connaissance parfaite (ce qui n’est en général pas le cas comme vous le soulignez) des règles d’arrondis ne résoudrait pas tous les problèmes : je pense évidemment aux systèmes sensibles aux conditions initiales. En effet, dans leur cas, tout résultat intermédiaire X est la condition initiale du calcul suivant et donc toute imprécision concernant X se répercute dramatiquement sur la suite (voir les expériences que j’ai faites sur la dynamique de Verhulst ou encore l’attracteur de Lorenz : http://www.lactamme.polytechnique.f...)...
Répondre à ce message

Laisser un commentaire

Forum sur abonnement

Pour participer à ce forum, vous devez vous enregistrer au préalable. Merci d’indiquer ci-dessous l’identifiant personnel qui vous a été fourni. Si vous n’êtes pas enregistré, vous devez vous inscrire.

Connexion | s’inscrire | mot de passe oublié ?

L'auteur

Jean-François Colonna

CMAP (Centre de Mathématiques Appliquées), Ecole Polytechnique, CNRS

Un ordinateur est-il une parfaite machine à calculer ?

Notes

Commentaire sur l'article