1-Physique mathématique et calcul itératif :

2-Un premier exemple en C (le même sans itérations en C, en Fortran 95 ou encore en Python :)

3-La perte de l'associativité de l'addition :

4-La perte de l'associativité de la multiplication :

5-La perte de la distributivité de la multiplication sur l'addition :

6-La dynamique de Verhulst (un calcul itératif élémentaire, mais instructif) :

7-Le calcul de la dynamique de Verhulst :

8.1-La sensibilité aux conditions initiales :

8.2-La sensibilité aux erreurs d'arrondi (optimisation et compatibilité) :

8.3-La sensibilité aux conditions initiales entraine la sensibilité aux erreurs d'arrondi :

En effet, dans un calcul itératif (tel celui de la dynamique de Verhulst) tout résultat intermédiaire est la "condition initiale" des calculs suivants :

                    
                    X                             = Condition initiale du calcul de X
                     0                                                               1
                    |                                                               |
                     ---------------                                                |
                              |     |                                               |
                             \|/   \|/                                              |
                              '     '                                               |
                                     2                                              |
                    X  = (R+1)X  - RX             <---------------------------------
                     1         0     0
                    |
                     ---------------
                              |     |
                             \|/   \|/
                              '     '
                                     2
                    X  = (R+1)X  - RX
                     2         1     1
                    |
                     ---------------
                              |     |
                             \|/   \|/
                              '     '


                    (...)


                                       2
                    X  = (R+1)X    - RX           = Condition initiale du calcul de X
                     n         n-1     n-1                                           n+1
                    |                                                               |
                     ---------------                                                |
                              |     |                                               |
                             \|/   \|/                                              |
                              '     '                                               |
                                       2                                            |
                    X    = (R+1)X  - RX           <---------------------------------
                     n+1         n     n
                    |
                     ---------------
                              |     |
                             \|/   \|/
                              '     '


                    (...)

8.4-La réversibilité du temps propre à de très nombreuses équations de la Physique peut être perdue lors de leur traitement numérique :

9.1-De l'influence de la syntaxe utilisée :

9.2-De l'influence du système utilisé :

9.3-De l'influence des options de compilation :

9.4-De la difficulté de faire du parallélisme hétérogène :

9.5-De l'impossibilité de manipuler exactement les constantes mathématiques : le nombre d'or par exemple.

9.6-De la difficulté de garantir la pérennité de certains résultats numériques (l'arithmétique étendue) :

Ainsi, ces erreurs d'arrondis peuvent produire des résultats imprécis, voire complètement faux. Malgré tout, on peut souhaiter pouvoir les reproduire. Or cela peut s'avérer impossible au cours du temps : une mise à jour du système d'exploitation, une simple évolution du compilateur utilisé,... peuvent rendre la reproductibilité impossible à garantir, puisque l'ordre des opérations élémentaires (additions, multiplications,...) ne sera pas nécessairement conservé lors de ces évolutions. Or, les expériences précédentes (en particulier la perte de l'associativité de l'addition et de multiplication) montrent que les résultats issus d'un certain calcul peuvent dépendre de l'ordre de ces opérations élémentaires (par exemple dans le cas d'un modèle sensible aux conditions initiales). Que faire alors ?

J'ai développé un environnement de travail permettant de résoudre ce problème. En effet, il inclut un langage de programmation (le K). En K tout s'exprime par des fonctions, ainsi, par exemple, l'addition et la multiplication s'écriront :

                    ADD2(A,B)           qui calcule la somme de A et de B,
                    MUL2(A,B)           qui calcule le produit de A et de B.

Un programme écrit en K est traduit en C et ainsi les deux fonctions précédentes sont alors réécrites de façon tout à fait naturelle :

                    ADD2(A,B) ==> ((A) + (B))
                    MUL2(A,B) ==> ((A) * (B))

A l'intérieur d'un tel programme il est possible de bloquer localement ces réécritures et faire donc en sorte que les fonctions restent des fonctions. Evidemment les fonctions ADD2(A,B) et MUL2(A,B) renverront respectivement la somme et le produit de A et de B. Or, étant donné qu'en général :

                    F(G(...)) # G(F(...))

(F et G étant deux fonctions quelconques -aux sens mathématique et informatique-) l'ordre des opérations élémentaires devient alors pérenne.

En réalité, ADD2(A,B) et MUL2(A,B) calculent (de façon optimisée...) des combinaisons linéaires du type :

                    ADD2(A,B) = [M  .((A)+(B))] + [M  .((A)*(B))] + [M  .((A)-(B))] + [M  .((A)/(B))] + [M  .min(A,B)] + [M  .max(A,B)] + ...
                                  11                12                13                14                15               16
 
                    MUL2(A,B) = [M  .((A)+(B))] + [M  .((A)*(B))] + [M  .((A)-(B))] + [M  .((A)/(B))] + [M  .min(A,B)] + [M  .max(A,B)] + ...
                                  21                22                23                24                25               26

Evidemment, par défaut, les valeurs des coefficients Mij sont les suivantes :

                    M   = 1 si i=j
                     ij
 
                    M   = 0 si i#j
                     ij

On notera qu'il en est évidemment de même pour tous les opérateurs binaires "de base" (soustraction, division, minimum, maximum,...).

Mais les valeurs des coefficients Mij peuvent être changés dynamiquement lors du lancement de l'exécution d'un programme. S'il est évident que toutes les combinaisons possibles des valeurs des Mij n'ont aucun intérêt, quelques unes en ont un. Donnons en un exemple élémentaire avec le cas d'un programme calculant les dix premiers termes d'une progression géométrique de premier terme égal à 1 et de raison 2 :

                    1 2 4 8 16 32 64 128 256 512

en faisant ensuite :

                    M   = 0     M   = 1
                     22          21

on obtiendra "sans effort" les dix premiers termes d'une progression arithmétique de mêmes premier terme et raison que pour la progression géométrique précédente :

                    1 3 5 7 9 11 13 15 17 19



Voici un cas beaucoup plus intéressant :

                    M   = 0     M   = 1
                     11          16
 
                    M   = 0     M   = 1
                     22          21

les autres Mij conservant leur valeur nulle. Ces valeurs remplacent donc l'addition et la multiplication par le maximum et l'addition respectivement. C'est ce qu'on appelle l'arithmétique tropicale ou encore arithmétique MAX-PLUS (voir cette image ou encore celle-ci à ce propos).

L'un des intérêts de cette possibilité est la réutilisabilité : en effet, un même programme pourra changer dynamiquement de comportement et ainsi assurer, sans avoir à programmer quelque chose, de nouvelles fonctions. Voici un exemple de cela :

                    M   = 0     M   = 1
                     11          15
 
                    M   = 0     M   = 1
                     22          21

les autres Mij conservant là-aussi leur valeur nulle. Ces valeurs remplacent donc l'addition et la multiplication par le minimum et l'addition respectivement : c'est l'arithmétique MIN-PLUS (voir cette image ou encore celle-ci à ce propos). En utilisant ce paramétrage, un programme de produit matriciel devient un outil utile en théorie des graphes pour la recherche des plus courts chemins.

Une petite application de cela est de permettre la transformation de cercles en carrés comme le montre cette tour de Babel devenant une pyramide ...