• 3.2.1-Déterministe :
• 3.2.2-Non Déterministe :

• Représentation tridimensionnelle d'une variété quadridimensionnelle de Calabi-Yau : la théorie des supercordes est actuellement la solution la plus prometteuse en ce qui concerne l'unification de la Mécanique Quantique (les interactions fortes et électrofaibles) et de la Relativité Générale (interaction gravitationnelle). Elle demande pour cela sept dimensions supplémentaires "à côté" des quatre dimensions (trois d'espace et une de temps) que nous percevons. Ces sept dimensions, auxquelles nous ne sommes pas sensibles, seraient organisées selon des variétés de Calabi-Yau, dont la "forme" et la topologie conditionneraient notre Physique (nombre de familles de particules élémentaires -3- et leurs propriétés, en particulier).



• Structure en quarks et gluons du nucléon : le nucléon (proton ou neutron) n'est pas une particule élémentaire. Il est constitué de trois quarks dits de valence (de saveur UUD et UDD pour le proton et le neutron respectivement) et d'une mer de particules virtuelles (quarks et gluons) en interaction. Interrogeons nous, dès à présent, sur la signification des formes et des couleurs utilisées dans cette image : quel sens ont-elles à cette échelle (1.0E-15 mètre) ?



• Visualisation tridimensionnelle de la superposition linéaire de 6 états propres de l'atome d'Hydrogène (calcul tridimensionnel). L'hydrogène, le plus simple des atomes, bien qu'il soit parfaitement connu dans le cadre de la Mécanique Quantique, peut encore nous révéler bien des choses. Cette image est extraite d'une séquence représentant l'évolution au cours du temps, dans certaines conditions qu'il n'est pas utile de préciser ici, de la densité de probabilité de présence de l'électron dans l'espace physique. Celle-ci est codée à l'aide de la luminance de chacun des points de l'image : plus un point est lumineux, plus l'électron à de chance de se trouver sur la ligne de visée joignant l'oeil de l'observateur à ce point. Cette animation a une vocation pédagogique et fut realisée en collaboration avec Jean-Louis Basdevant pour le cours de Mécanique Quantique qu'il enseigne à l'Ecole Polytechnique.

3.2.1-La Géométrie Fractale Déterministe :

Pour ces objets, le hasard n'intervient pas.


• Les deux premières itérations de la construction de la courbe de von Koch. Il s'agit là du plus simple des objets fractals. Malgré cela, il en possède toutes les propriétés : d'une part l'autosimilarité (l'objet est invariant par homothétie) et d'autre part le fini et l'infini s'y cotoie (bien que cette courbe réside dans un domaine fini, à chaque itération sa longueur est multipliée par 4/3 et tend donc vers l'infini ; par exemple, partant d'un segment -bleu- d'un mètre de long, au bout de 90 itérations la longueur est supérieure à la distance de la Terre au Soleil !).



• Le long de la frontière de l'ensemble de Mandelbrot. L'ensemble de Mandelbrot et les ensembles de Julia sont ici définis dans le plan Complexe.



• L'ensemble de Julia dans le corps des quaternions calculé pour A=(0,1,0,0) -ou 'la danseuse d'Yr'-. Les itérations dans le plan Complexe peuvent être étendues sans difficultés au corps des Quaternions. La difficulté est alors plus au niveau de la représentation, puisqu'il s'agit alors d'objets quadrimensionnels.



• Ensembles de Julia dans le corps des quaternions lors d'une promenade autour de l'ensemble de Mandelbrot.



• Rotation de 2.pi autour des axes Y et Z d'un ensemble de Julia dans le corps des quaternions. La visualisation d'un ensemble de Julia calculé dans le corps des Quaternions présente donc des difficultés considérables. Il n'est évidemment pas question ici de représenter directement ses quatre dimensions, puisque nous évoluons dans un espace aux apparences tridimensionnelles. Un ou plusieurs artifices doivent donc être utilisés : dans ce cas précis, seules sont visualisées seize sections tridimensionnelles obtenues au cours d'une rotation de 2 pi autour de l'un de ses axes. Cette opération, difficile à imaginer, peut être mieux comprise en l'appliquant à un objet de notre espace physique : prenons, par exemple, un cylindre que nous représenterions par une coupe effectuée à l'aide d'un plan arbitraire. Si nous observons l'image de celle-ci alors que le cylindre est en rotation, nous verrons une figure géométrique bidimensionnelle se déformer et présenter alternativement l'apparence d'un rectangle et d'une ellipse, suivant l'orientation du plan de coupe par rapport à l'axe du cylindre. C'est ce qui est montré ici, le cylindre étant remplacé par un objet fractal à quatre dimensions, et le plan par un hyperplan tridimensionnel...





3.2.2-La Géométrie Fractale Non Déterministe :

De nombreux objets de la nature possèdent (approximativement) la propriéte d'autosimilarité ; c'est le cas des côtes maritimes, des montagnes, des nuages, de certaines plantes,... Ils peuvent donc être modélisés à l'aide de la géométrie fractale, à condition d'y introduire de l'aléatoire.


• Le processus itératif de génération de champs fractals bidimensionels (16 itérations). Il consiste à rajouter, à chaque nouvelle itération, des détails, identiques statistiquement à ceux ajoutés aux itérations précédentes, mais à une échelle inférieure [pour plus d'informations...].



• Le processus itératif de génération de montagnes fractales (16 itérations).



• Montagnes au lever du Soleil.



• Montagnes et dynamique de nuages légers -cette séquence etant périodique-. Toutes ces images sont en fait des coupes tridimensionnelles dans des objets fractals quadrimensionnels ; cela permet d'envisager divers types d'animations.



• L'érosion de la Tour de Babel.



• Tremblement de terre sur des montagnes multi-fractales.



• Monument Valley au lever du Soleil. Des contraintes diverses peuvent être appliquées ; cela permet ainsi de reproduire des reliefs connus (dans le cas présent, il n'y a quasiment que des basses et des hautes altitudes).



• Monument Valley dansante.



• L'anomalie de Botticelli sur la Lune. En exploitant plusieurs fois le modèle simultanément, il est possible de reconstituer les trois types de relief présents à la surface de la Lune (les montagnes, les failles dans les mers et les cratères). Afin de "signer" la nature synthétique de cette image, un relief anthropomorphique (le visage de Flore dans le Printemps de Botticelli) a été ajouté au centre et à droite du relief.



• Structure fractale tridimensionnelle. Il est intéressant de noter au sujet de cette image qu'elle est issue des mêmes valeurs numériques que la plupart des images précédentes, l'apparence visuelle très différente venant d'un autre choix de mode de représentation. Il s'agit là d'un problème très général, sur lequel nous reviendrons plus tard : en toute généralité, il y a de très nombreuses façons de représenter un même ensemble de valeurs numériques.


Pourquoi de nombreux objets naturels sont-ils fractals ? Il semblerait qu'une réponse possible (la réponse ?) vienne de cette "cohabitation" du fini et de l'infini qu'ils permettent. A titre d'exemple, les poumons, situés à l'intérieur du volume réduit de la cage thoracique, assurent ainsi des échanges gazeux (nous aurons l'occasion d'en présenter des images ultérieurement...) sur une surface supérieure à cent mètres carrés alors qu'une géométrie plus euclidienne (une sphère par exemple) donnerait un dispositif gigantesque, instable et non viable !

• Marche aléatoire isotrope de 4 particules sur un réseau carré bidimensionnel avec visualisation de leur centre de gravite -particule blanche-. Les six expériences qui vont suivre constituent l'ossature d'un film pédagogique portant sur la Loi des Grands Nombres. Dans ce premier cas, avec peu de particules, le système global est difficile à prévoir, ce que le déplacement erratique du centre de gravité montre parfaitement bien. Que se passe-t-il avec beaucoup plus de particules ?



• Marche aléatoire isotrope de 256 particules sur un réseau carré bidimensionnel avec visualisation de leur centre de gravite -particule blanche-. Avec beaucoup de particules, le système global est est beaucoup plus facile à prévoir, ce que la quasi-immobilité du centre de gravité montre. Que se passe-t-il en remplaçant la marche aléatoire sur réseau carré par des déplacements libres dans un billiard avec collisions ?



• Billard bidimensionnel rectangulaire avec 4 particules aléatoires en collision et visualisation de leur centre de gravite -particule blanche-. Le système est difficile à prévoir, comme pour la marche aléatoire sur réseau carré.



• Billard bidimensionnel rectangulaire avec 256 particules aléatoires en collision et visualisation de leur centre de gravite -particule blanche-. Le système est facile à prévoir, comme pour la marche aléatoire sur réseau carré. Que se passe-t-il avec un billiard de forme plus complexe ?



• Billard bidimensionnel de Sierpinski avec 4 particules aléatoires en collision et visualisation de leur centre de gravite -particule blanche-. Les résultats précédents semblent indépendants de la forme du billiard.



• Billard bidimensionnel de Sierpinski avec 256 particules aléatoires en collision et visualisation de leur centre de gravite -particule blanche-. De même ici...



• Diffusion entre deux boîtes (conditions initiales : la boîte de gauche est vide alors que la boîte de droite contient 256 particules), avec collisions et une géométrie variable. Examinons maintenant une application à la thermodynamique. Deux enceintes bidimensionnelles (l'une vide à gauche et l'autre pleine à droite) communiquent par l'intermédiaire d'un orifice de diamètre variable. Les pressions à l'intérieur des deux enceintes s'équilibrent lentement en présence d'un faible diamètre et rapidement avec un grand diamètre. Il convient de remarquer que, même si la bidimensionnalité du système est peu physique, elle présente l'avantage de produire des images plus "faciles à lire". Cette facilité sera souvent exploitée dans un but pédagogique.



• Front fractal de diffusion dans un milieu bidimensionnel obtenu grâce à des particules identiques en interaction. La diffusion est un phénomène naturel fondamental. Ici, deux familles de particules strictement identiques (l'une rouge et l'autre bleue, cette différence de couleur ne correspondant à aucune propriété pouvant affecter le comportement des particules) sont initialement separées l'une de l'autre. Rapidement, elles diffusent l'une dans l'autre et la frontière entre les deux familles devient rapidement fractale.



• L'effet domino bidimensionnel. Par le respect des lois fondamentales de conservation, toutes les particules sont finalement mises en mouvement à la suite d'un simple choc sur une unique particule centrale.



• Mouvement brownien de quelques particules lourdes dans un gaz de particules légères et rapides.



• Mouvement brownien de quelques particules lourdes et lumineuses dans un gaz de particules légères et rapides, avec un rapport croissant des rapports de masse (lourdes/légères=1,10,100,1000). Plus les sept particules lumineuses sont lourdes, plus leur mise en mouvement est difficile...



• Particules en collision sans perte d'énergie dans un espace bidimensionnel avec visualisation de l'histogramme des modules des vitesses. Les conditions initiales choisies ne sont pas "physiques" (les particules sont alors sur un réseau carré alors que leurs vitesses sont les mêmes en module et aléatoires en direction). Malgré cela, très rapidement, l'équilibre thermodynamique est atteint grâce à des chocs parfaitement élastiques, ce que montre l'enveloppe de l'histogramme de distribution des modules des vecteurs vitesse en x.exp(-(x.x)) dans cette simulation bidimensionnelle.



• Particules en collision sans perte d'énergie dans un espace tridimensionnel avec visualisation de l'histogramme des modules des vitesses. Dans le cas tridimensionnel, le comportement est le même (l'enveloppe de l'histogramme de distribution des modules des vecteurs vitesse étant cette fois en (x.x).exp(-(x.x))).



• Détente d'un gaz dans une boîte circulaire bidimensionnelle avec avec visualisation de l'histogramme des modules des vitesses. Dans cet exemple, un gaz bidimensionnel est à l'intérieur d'une enceinte circulaire de volume croissant sans apport d'énergie. L'enveloppe de l'histogramme de distribution des modules des vecteurs vitesse se conservant au cours du temps, cette détente est donc isotherme.



• Billard bidimensionnel de Sierpinski avec 326 particules isotropes soumises à un fort champ de gravitation vertical. Un gaz bidimensionnel est à l'intérieur d'une enceinte de forme complexe et est soumis à un fort potentiel gravitationnel "vertical". Les particules sont donc entrainées vers le bas ; malgré cela, un gradient vertical de densité apparait du à la pression élevée régnant dans les compartiments inférieurs.



• Un piston bidimensionnel parfait avec les conditions initiales suivantes : piston immobîle, particules chaudes à gauche et froides à droite, le tout dans une boîte bidimensionnelle soumise à un champ de gravitation vertical. Un piston bidimensionnel parfait (sans frottement) à l'intérieur d'une boîte bidimensionnelle immergée dans un fort potentiel gravitationnel "vertical". A sa gauche se trouve un gaz chaud (de couleur rouge), tandis qu'a sa droite se trouve un gaz froid (de couleur verte). Le gaz chaud se détend et comprime le gaz froid ; le piston subit ensuite des oscillations amorties. Enfin, le gaz froid se solidifie selon un réseau cristallin hexagonal, alors qu'à gauche les trois phases solide, liquide et gazeuse peuvent être observées.



• Un fluide bidimensionnel périodique avec des vitesses strictement identiques initialement et un obstacle central très légèrement décale verticalement, avec visualisation de l'histogramme des modules des vitesses. Passage rapide de l'ordre parfait au désordre grâce à un obstacle central immobile (blanc) légèrement décalé verticalement, introduisant ainsi une légère dissymétrie lors des premiers chocs qu'il subit. Celui-ci gène la progression d'un fluide de particules strictement identiques initialement (tous les vecteurs vitesse sont égaux -même module et même direction horizontale-).



• Agrégats fractals bidimensionnels obtenus par collage de 100% des particules lors de leurs collisions, dans un champ de gravitation central attractif. Dans tous les exemples précédents, les chocs étaient parfaitement élastiques. Dans le cas présent, les particules, lors d'une collision, se collent les unes aux autres. Par l'intermédiaire d'un potentiel gravitationnel dit central (c'est-à-dire dont la source est située au centre de la boite rectangulaire contenant les particules), des agrégats de plus un plus importants se constituent. A la fin l'objet obtenu est un agrégat fractal très filamenteux. Que se passerait-il si toutes les particules ne se collaient pas les unes aux autres ?



• Agrégats fractals bidimensionnels obtenus par collage de 50% des particules lors de leurs collisions, dans un champ de gravitation central attractif. Lorsque seulement une partie des particules sont "collantes" (50% dans cet exemple), ces particules continuent à former un agrégat fractal (de couleur blanche) qui peut sembler plus trapu car il piège en fait de nombreuses particules non collantes.



• Agrégats fractals bidimensionnels obtenus par collage de 100% des particules lors de leurs collisions, dans un champ de gravitation vertical. Refaisons l'expérience avec 100% de particules collantes et un potentiel gravitationnel "vertical".



• Agrégats fractals bidimensionnels obtenus par collage de 50% des particules lors de leurs collisions, dans un champ de gravitation vertical. Refaisons l'experience avec 50% de particules collantes et un potentiel gravitationnel "vertical". Que se passe-t-il si toutes ces expériences étaient effectuées dans un espace tridimensionnel ?



• Agrégat fractal tridimensionnel obtenu par collage de 100% des particules lors de leurs collisions, dans un champ de gravitation central. Là-aussi, l'expérience aboutit à un agrégat fractal, mais dont la forme est beaucoup plus difficile à saisir car il réside dans un espace tridimensionnel ; une rotation de cet "objet" sous les yeux de l'observateur est donc introduite afin d'en faciliter la compréhension.



• Agrégat fractal tridimensionnel obtenu par collage de 50% des particules lors de leurs collisions, dans un champ de gravitation central.



• Agrégats fractals tridimensionnels obtenus par collage de 100% des particules lors de leurs collisions, dans un champ de gravitation vertical.



• Agrégats fractals tridimensionnels obtenus par collage de 50% des particules lors de leurs collisions, dans un champ de gravitation vertical.



• La marche aléatoire des photons produits au coeur du Soleil. La lumière qui éclaire et réchauffe notre Terre est produite par des réactions nucléaires au coeur du Soleil. Huit minutes lui suffisent pour nous arriver. Mais, par contre, pour sortir du Soleil, chaque photon est l'objet d'une marche aléatoire d'une durée moyenne de 100.000 ans ! Il convient d'une part de noter que la sortie de chacun d'eux se fait selon une direction arbitraire relativement au vecteur normal ; c'est cela qui explique la luminosité uniforme du disque solaire (il n'apparait pas comme une sphère...). D'autre part, cette expérience est un exemple caractéristique d'une difficulté rencontrée fréquemment lors de la visualisation de systèmes physiques : l'impossibilité de respecter les échelles spatiales et/ou temporelles...



• Diffusion de particules à l'intérieur du modèle de l'acinus pulmonaire humain du à Hiroko Kitaoka. Les poumons forment une structure fractale assurant les échanges gazeux entre l'air et le sang. Ces expériences montrent la diffusion des gaz dans les alvéoles (ou acinus pulmonaire). Ici les particules blanches situées à l'origine de l'arborescence diffusent mieux que les particules colorées car ces dernières sont situées (et donc "piégées") aux extrémités.



• Diffusion de particules à l'intérieur du modèle de l'acinus pulmonaire humain du à Hiroko Kitaoka avec perméabilité de la membrane. Le mélange gazeux est composé approximativement de 80% d'azote et de 20% d'oxygène. La densité de ce dernier décroit en s'éloignant de l'origine de l'arborescence. L'une des difficultés rencontrées lors de ces expériences virtuelles résident dans la complexité de la géométrie du système. Que faire donc pour en faciliter la compréhension ? La solution adoptée ici consiste à faire tourner le système sous les yeux de l'observateur.



• Diffusion de particules à l'intérieur du modèle de l'acinus pulmonaire humain du à Hiroko Kitaoka avec perméabilité de la membrane. Pour faciliter la compréhension de la géométrie de ce système, une autre solution consiste à le déplier et à le mettre à plat tout en conservant, évidemment, la tridimensionnalité de ses conduits.

• Visualisation de l'inclinaison de deux trajectoires elliptiques. Cette expérience à caractère didactique est destinée à montrer la notion d'inclinaison. Dans ce système à trois corps, deux planètes orbitent autour d'une étoile dans des plans différents. Au cours du mouvement de l'observateur autour du système, il est possible de voir la ligne des noeuds (ligne d'intersection des plans de deux trajectoires qui passe évidemment par leur foyer commun).



• Intégration du problème des N-corps (N=10) montrant le véritable système solaire avec une rotation simultanée de 2.pi. En injectant dans le modèle du problème des N-corps les coordonnées et les vitesses des neuf planètes connues (a la date du 26/10/2002) du système solaire à une date donnée, il est possible de calculer leurs trajectoires ultérieures. Au cours de cette expérience, l'observateur tourne autour du système afin de bien noter le cas particulier de Pluton dont la trajectoire n'est pas dans le plan des autres planètes (dit plan de l'ecliptique). Il est important de noter l'aspect "mensonger" de cette représentation. En effet, le système solaire ne peut être représenté à l'échelle ; le Soleil, dans ce cas, serait plus petit qu'un point d'image et son diamètre doit donc être démesurément exagéré. De même, les planètes apparaissent comme ayant une taille du même ordre de grandeur que celle du Soleil, ce qui n'est évidemment pas le cas en réalité. Enfin, étant donné le diamètre de la sphère matérialisant le Soleil, les trajectoires des quatre premières planètes devraient être cachées par celle-ci. Ainsi, il est nécessaire, après des calculs respectant les échelles réelles, de procéder à des dilatations non linéaires des trajectoires de façon à pouvoir les distinguer.



• Intégration du problème des N-corps (N=10) montrant le véritable système solaire avec une rotation simultanée de 2.pi, notre Terre etant choisie comme origine des coordonnées. Quel est le ciel que voyaient nos ancêtres et que nous voyons encore en le regardant "naïvement". Cette expérience place donc la Terre au centre du système solaire (par un simple changement de référentiel). Le Soleil tourne alors autour de la Terre, alors que les huit autres planètes décrivent des boucles de rétrogradation qui furent longtemps expliquées à grand coup d'épicycles (du moins jusqu'à Copernic...).



• Du Soleil à Pluton (échelles non linéaires). Alors comment serait perçu notre système solaire depuis un point de vue quelconque ? C'est ce que montre cette expérience dans laquelle une dixième planète n'interagissant pas avec les autres (mais uniquement avec le Soleil) et dont quelques trajectoires possibles sont étudiées depuis le voisinage du Soleil jusqu'à l'orbite de Pluton. Le ciel perçu par ses habitants (virtuels) serait très régulier à proximit/ du Soleil et progressivement deviendrait d'une telle complexité qu'aucun système d'épicycles ne saurait l'expliquer. La leçon à tirer de cela est double : d'une part un système peut présenter un "visage" complexe, voire chaotique, alors qu'en fait, à condition de trouver le bon point de vue, il peut se simplifier considérablement (mais comment trouver le "bon point de vue" pour un système quelconque ?). Ce phénomene nous permet d'introduire la notion de Chaos Virtuel ou Subjectif [pour plus d'informations...]. D'autre part, si notre humanité s'était developpée plus loin du Soleil et en dehors du plan de l'ecliptique (si tant est que la chose fut possible), nos astronomes, nos mathématiciens, mais aussi nos prêtres des temps passés auraient observé un ciel beaucoup plus irrégulier ; les conséquences en auraient été certainement considérables en ce qui concerne la science, la philosophie et certainement les religions...



• Simulation de 'du Soleil à Pluton' avec de purs mouvements circulaires uniformes (échelles linéaires). Notons au passage que ce Chaos Virtuel (ou Subjectif) n'est pas lié au caractère approximativement elliptique des trajectoires, mais uniquement à la notion de mouvement relatif ainsi que l'illustre cette expérience qui n'utilise que des mouvements circulaires concentriques et uniformes (ou encore plus simplement lors de l'observation de la pluie qui tombe...).



• Du Soleil à Pluton -extrapolation 1- (échelles non linéaires). Enfin, dans cette dernière expérience, la planète fictive conserve une trajectoire de taille fixe, mais son plan tourne de 360 degrés dans l'espace.

                     0
                    ---
                     x

                      1
                    -----
                     2.x

                     0
                    2  = 1


                     1
                    2  = 2


                     2
                    2  = 4


                     3
                    2  = 363031686155.84345


                     4
                    2  = -2194234532479271.8

                    S  = 0
                     0


                    S  = S    + 1
                     n    n-1

                    S  = n
                     n

                    #define   N         "une certaine valeur positive et entière..."


                    main()
                              {
                              int       n;
                              float     sigma=0;


                              for       (n=1 ; n <= N ; n++)
                                        {
                                        sigma = sigma + 1.0;
                                        }


                              printf("\n somme calculee = %f",sigma);
                              }

                    float     MUL(x,y)
                    float     x,y;
                              {
                              return(x*y);
                              }


                    main()
                              {
                              float     A=3.1,B=2.3,C=1.5;
                              float     X,Y;


                              X=MUL(MUL(A,B),C);
                              Y=MUL(A,MUL(B,C));


                              printf("\n (%f x %f) x %f = %f",A,B,C,X);
                              printf("\n %f x (%f x %f) = %f",A,B,C,Y);
                              }

                    (3.10 * 2.30) * 1.50 = 10.695000 = 0x412B1EB8
                                                ####            #

                    3.10 * (2.30 * 1.50) = 10.694999 = 0x412B1EB7
                                                ####            #

                    main()
                              {
                              float     A=3.1,B=2.3,C=1.5;
                              float     X,Y;


                              X=(A*B)*C;
                              Y=A*(B*C);


                              printf("\n (%f x %f) x %f = %f",A,B,C,X);
                              printf("\n %f x (%f x %f) = %f",A,B,C,Y);
                              }

• le compilateur utilisé transforme la simple simple précision 32 bits en double précision 64 bits à l'insu de l'utilisateur,
• le compilateur utilisé compile de façon similaire les expressions (AxB)xC et Ax(BxC), supposant la propriété d'associativité satisfaite.

                    float     ADD(x,y)
                    float     x,y;
                              {
                              return(x+y);
                              }


                    main()
                              {
                              float     A=1.1,B=3.3,C=5.5;
                              float     X,Y;


                              X=ADD(ADD(A,B),C);
                              Y=ADD(A,ADD(B,C));


                              printf("\n (%f x %f) x %f = %f",A,B,C,X);
                              printf("\n %f x (%f x %f) = %f",A,B,C,Y);
                              }

                    (1.10 + 3.30) + 5.50 = 9.900000 = 0x411E6666
                                                  #            #

                    1.10 + (3.30 + 5.50) = 9.900001 = 0x411E6667
                                                  #            #

                                       2
                    X  = (R+1)X    - RX
                     n         n-1     n-1

                    X
                     0


                    |
                     ---------------
                              |     |
                             \|/   \|/
                              '     '


                                     2
                    X  = (R+1)X  - RX
                     1         0     0


                    |
                     ---------------
                              |     |
                             \|/   \|/
                              '     '


                                     2
                    X  = (R+1)X  - RX
                     2         1     1


                    |
                     ---------------
                              |     |
                             \|/   \|/
                              '     '


                                     2
                    X  = (R+1)X  - RX
                     3         2     2


                    |
                     ---------------
                              |     |
                             \|/   \|/
                              '     '


                    etc...

                    main()
                              {
                              double    R=3.0;
                              double    X=0.5;
                              int       n;


                              for       (n=0 ; n <= 80 ; n++)
                                        {
                                        if        ((n%10) == 0)
                                                  {
                                                  printf("\n iteration(%04d) = %9.6f",n,X);
                                                  }
                                        else
                                                  {
                                                  }


                                        X = (R+1)*X - R*X*X;
                                        }
                              }

                    O200 Silicon Graphics (R10000, IRIX 6.5.5m, cc 7.2.1) :

                              option '-O2'   option '-O3'

                    X(00)   = 0.500000       0.500000
                    X(10)   = 0.384631       0.384631
                    X(20)   = 0.418895       0.418895
                    X(30)   = 0.046399       0.046399
                    X(40)   = 0.320184       0.320192
                    X(50)   = 0.063747       0.059988
                    X(60)   = 0.271115       1.000531
                    X(70)   = 1.328462       1.329692
                    X(80)   = 0.817163       0.021952

                      16         16
                    10   + 1 = 10

                                        O200 Silicon Graphics (processeur R10000, IRIX 6.5.5m, Java) :

                              (R+1)X-R(XX)         (R+1)X-(RX)X         ((R+1)-(RX))X        RX+(1-(RX))X         X+R(X-(XX))

                    X(0000) = 0.5                  0.5                  0.5                  0.5                  0.5
                    X(0500) = 1.288736212247168    0.007057813075738616 1.2767485100695732   1.246534177059494    0.03910723014701789
                    X(1000) = 1.3327294162589722   0.916560711983132    1.207710752523091    0.27770146115891703  0.26663342726567785
                    X(1500) = 1.1448646685382955   0.4481000759915065   0.3102077001456977   0.015374092695375374 0.9841637252962943
                    X(2000) = 1.0548628914440754   0.896126931497168    0.6851138190159249   0.009229885271816535 0.3860923315999224
                    X(2500) = 1.292802584458599    0.06063433547953646  1.174118726001978    0.6922411856638806   0.020878761210912034
                    X(3000) = 1.0497821908090537   0.0219606878364607   1.3287403237319588   0.11354602472378028  0.13270749449424302
                    X(3500) = 0.8115039383609847   1.3213031319440816   0.6545151597367076   0.5760786099237328   1.324039473116061
                    X(4000) = 0.04922223042798102  1.3203298564077224   0.09243804931690679  0.9496284087750142   1.316597313359563
                    X(4500) = 0.4745896653599724   0.32865616721789603  0.018965010461877246 0.25384661313701296  0.18512853535354462

                                        PC (processeur Pentium II, LINUX Mandrake 7.0, Java) :

                              (R+1)X-R(XX)         (R+1)X-(RX)X         ((R+1)-(RX))X        RX+(1-(RX))X         X+R(X-(XX))

                    X(0000) = 0.5                  0.5                  0.5                  0.5                  0.5
                    X(0500) = 1.2887362122471679   0.00705781307573862  1.2767485100695732   1.2465341770675666   0.03910723014701789
                    X(1000) = 1.3327294162589722   0.91656071198313205  1.207710752523091    0.6676224369769922   0.26663342726567785
                    X(1500) = 1.1448646685382955   0.44810007599150647  0.31020770014569771  0.41049165176544455  0.98416372529629426
                    X(2000) = 1.0548628914440754   0.89612693149716804  0.68511381901592494  1.0026346845706315   0.3860923315999224
                    X(2500) = 1.3328681064703032   0.06063433547953646  1.1741187260019781   0.0154001182074282   0.02087876121091203
                    X(3000) = 1.2956769824648844   0.0219606878364607   1.3287403237319588   0.50504896336548377  0.13270749449424302
                    X(3500) = 0.19193027175727995  0.37986077053509781  0.6545151597367076   0.38299434265835819  1.324039473116061
                    X(4000) = 1.2491385720940165   0.96017143401896088  0.09243804931690679  0.6565274346305322   1.316597313359563
                    X(4500) = 0.00644889182443986  1.3185465795235045   0.01896501046187725  0.94966313327336349  0.18512853535354462

                    scale   = 010  020  030  040  050  060  070  080  090  100
                    n       = 035  070  105  136  169  199  230  265  303  335

                    main()
                              {
                              double    B=4095.1;
                              double    A=B+1;


                              double    x=1;


                              int       n;


                              printf("initialisation      x=%.16f\n",x);


                              for       (n=1 ; n <= 9 ; n++)
                                        {
                                        x = (A*x) - B;


                                        printf("iteration %01d         x=%+.16f\n",n,x);
                                        }
                              }

                    initialisation      x=                +1.0000000000000000
                    iteration 1         x=                +1.0000000000004547
                    iteration 2         x=                +1.0000000018631452
                    iteration 3         x=                +1.0000076316294826
                    iteration 4         x=                +1.0312599175240718
                    iteration 5         x=              +129.0437481703507956
                    iteration 6         x=           +524480.9968805739190429
                    iteration 7         x=       +2148322516.2225189208984375
                    iteration 8         x=    +8799743854603.9609375000000000
                    iteration 9         x=+36044630802839192.0000000000000000

                    x = 1

                    A-B = 1 (mathématiquement parlant...)

                    
                    B       = 4095.1                 = {0x40affe33,33333333}
                    A = B+1 = 4096.1                 = {0x40b00019,9999999a}


                    A-B     = 1.0000000000004547     = {0x3ff00000,00000800}
                    1.0                              = {0x3ff00000,00000000}

• de la syntaxe utilisée pour formuler le modele numérique (ainsi que le montre cette "expérience"),
• du compilateur employé, ainsi évidemment que de sa version et des options utilisées (ainsi que le montre cette autre "expérience"),
• du processeur sur lequel sont effectués les calculs,
• de l'hétérogénéité des systèmes,...

• Soient deux nombres flottants 'A' et 'B' calculés égaux à l'instant présent et stockés dans les registres flottants internes 80 bits de l'unité flottante (ou 'FPU') du processeur (de type x86). Etant tous les deux représentés par 80 bits significatifs, ils sont "compatibles" entre-eux ce qui signifie que l'on peut les combiner arithmétiquement et les comparer sans ambiguité (en particulier, ils sont présentement égaux : A = B).
• Supposons qu'un manque de ressources flottantes contraigne le transfert du nombre 'A' en mémoire. A partir de cet instant 'A' n'est plus représenté que par 64 bits significatifs. Imaginons alors que l'optimiseur ignore ce déplacement (et c'est bien le cas malheureusement...).
• Supposons ensuite que quelques instructions plus tard la comparaison de 'A' (stocké sur 64 bits en mémoire) et de 'B' (toujours stocké sur 80 bits dans un registre) soit demandée. Le nombre 'A' est donc retransféré dans un registre 80 bits et donc 80-64=26 bits (nuls très certainement) lui sont ajoutés. A partir de cet instant-là les deux nombres 'A' et 'B' ne sont plus "compatibles" (sauf le cas exceptionnel ou les 26 derniers bits de 'B' sont nuls) et leur comparaison n'a plus de sens...

                    double    f(x)
                    double    x;
                              {
                              return(1/x);
                              }


                    main()
                              {
                              double              x1=f(3.0);
                              volatile  double    x2;


                              x2=x1;


                              if        (x2 != x1)
                                        {
                                        printf("DIFFERENT\n");
                                        }
                              }

                    A > B

                    fIFGT(A,B)

                    unsigned  int       fIFGT(x,y)
                    double              x;
                    double              y;
                                        {
                                        return(x > y);
                                        }

                    F.G # G.F

• L'irréversibilité numérique du billard bidimensionnel. Un système réversible peut perdre cette proprieté s'il est sensible aux erreurs d'arrondi. Dans cet exemple, au "milieu temporel" du calcul, tous les vecteurs vitesses sont "inversés". L'état final obtenu est malheureusement très différent de l'état initial.



• Visualisation bidimensionnelle des erreurs d'arrondi dans le calcul de la dynamique de Verhulst [plus d'informations]. De la façon d'écrire un programme (et en particulier de la façon de parenthéser) peuvent dépendre les résultats.



• Rotation autour de l'axe X de l'attracteur de Lorenz (uniquement afin de mieux comprendre les images suivantes).



• L'attracteur de Lorenz -sensibilité aux conditions initiales (la Rouge, la Verte et la Bleue)-.



• L'attracteur de Lorenz -sensibilité à la méthode d'intégration utilisée (Rouge=Euler, Vert=Runge-Kutta/second ordre, Bleu=Runge-Kutta/quatrième ordre)-.



• Calcul de l'attracteur de Lorenz sur 3 ordinateurs différents (le Rouge, le Vert et le Bleu : sensibilité aux erreurs d'arrondi). Ainsi un système sensible aux conditions initiales (comme l'est l'attracteur de Lorenz) est sensible aux erreurs d'arrondi (et réciproquement ?).



• Rotation autour de l'axe X de l'attracteur de Lorenz (1000 itérations), calculée sur deux ordinateurs différents. Ce mouvement de rotation calculé conjointement par deux ordinateurs différents semble correct. En effet, le calcul ne portant que sur 1000 itérations, l'anomalie finale n'est pas encore suffisamment importante pour être visible.



• Rotation autour de l'axe X de l'attracteur de Lorenz (5000 itérations), calculée sur deux ordinateurs différents. Cette fois-ci, le mouvement de rotation semble incorrect (bien observer les saccades entre certains couples d'images). En effet, le calcul porte ici sur 5000 itérations ce qui laisse le temps à l'anomalie de s'amplifier suffisamment pour être visible à la fin de ce processus. Cette expérience, combinée avec la précédente, montre la difficulté de faire du calcul parallèle portant sur des modèles sensibles aux erreurs d'arrondi, à l'aide d'un ensemble de machines hétérogènes (aussi bien au niveau matériel qu'au niveau logiciel -une simple différence de version du compilateur utilisé peut suffire !-).



• Intégration du problème des N-corps (N=4 : une etoîle, une planète lourde et une planète légère avec un satellite) calculé avec 2 options d'optimisation différentes (sensibilité aux erreurs d'arrondi).

• 2 carrés gris identiques se déplaçant au-dessus d'une échelle de gris. L'illusion dite de contraste simultané montre que l'analyse que nous faisons des images n'est pas locale, mais globale...



• Points noirs (a l'intérieur de carrés blancs aléatoires) sur un réseau carré.



• L'illusion de Zollner.



• Tas ou trou (vue aérienne).