Ph. Depondt - Physique Numérique

La boı̂te à outils
de la
PHYSIQUE NUMÉRIQUE
Licence de physique L3
Physique fondamentale et PHYTEM
Université Pierre et Marie Curie Paris-6 — ENS-Cachan
Ph. Depondt1
Année 2008-2009
1
INSP (Institut des NanoSciences de Paris), CNRS UMR 7588 & Université P. et M. Curie Paris-6.
Contact : [email protected]
2 Licence de physique L3 : Physique Fondamentale & PHYTEM, Université Pierre et Marie Curie Paris-6 & ENS-Cachan
Table des matières
1 Introduction 7
1.1 Des méthodes numériques, pour quoi faire ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.1.1 Quelques jalons. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.1.2 . . . et quelques exemples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Plan succinct. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 Notions pratiques de FORTRAN95. 15

2.1 Qu’est-ce qu’un langage de programmation ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Notions élémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.1 Instructions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.2 Déclarations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2.3 Opérations élémentaires sur les nombres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3 Premières boucles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.1 Pour quoi faire ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.2 Pratiquement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3.3 Boucles imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3.4 Boucles munies d’un nom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4 Conditions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5 Entrées-sorties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.5.1 Écran et clavier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.5.2 Les fichiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.5.3 Les formats. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.6 Les fonctions intrinsèques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7 Autres boucles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7.1 do while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7.2 Boucles infinies : exit et cycle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7.3 Boucles implicites. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.8 Tableaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.8.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.8.2 Manipulation globale de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.8.3 Fonctions intrinsèques et tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.8.4 Allocation dynamique de mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.9 Fonctions et sous-programmes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.9.1 Les function. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.9.2 Et les subroutine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.9.3 L’intention . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.9.4 La mise en commun de variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.9.5 Mettre un nom de sous-programme comme argument. . . . . . . . . . . . . . . . . . . . . . . . 32
2.9.6 Les bibliothèques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.10 Les commentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.11 Une instruction sur plusieurs lignes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.12 Les chaı̂nes de caractères. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.12.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.12.2 Opérations sur les chaı̂nes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.12.3 Conversion chaı̂ne ⇔ nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.13 Détection de fin de fichier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.14 FORTRAN77-90-95 : filiation et différences. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.14.1 kind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.14.2 Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.14.3 Objets de type dérivé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.14.4 Pointeurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3
2.14.5 Récursivité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3 Un prototype de TP 41
3.1 Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2 L’équation logistique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.1 De la multiplication des insectes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.2 Étude préalable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.3 Étude numérique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4 Méthodes numériques. 45
4.1 Recherche des zéros d’une fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.1.1 Méthode de la dichotomie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.1.2 Méthode de Newton. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.1.3 Comment s’y prendre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.2 Représentation des nombres dans un ordinateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.2.1 Les nombres entiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.2.2 Les nombres réels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.2.3 Conséquence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.3 Suites et séries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.3.1 Généralités et premières difficultés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.3.2 Calcul des intégrales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.4 Échantillonnages, interpolation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.4.1 Interpolation linéaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.4.2 Approximation parabolique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.4.3 Polynômes de Lagrange. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.4.4 Dérivées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.5 Algèbre linéaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.5.1 Un exemple : la diffusion de la chaleur à une dimension. . . . . . . . . . . . . . . . . . . . . . . 55
4.5.2 Systèmes d’équations linéaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.5.3 Une généralisation de la méthode de Newton à plusieurs dimensions. . . . . . . . . . . . . . . . 58
4.5.4 Problèmes de vecteurs propres et de valeurs propres ou eigenproblems. . . . . . . . . . . . . . . 59
4.6 Problèmes autocohérents. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.6.1 Qu’est-ce donc ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.6.2 Formulation générale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.6.3 Est-ce que ça converge ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.7 Recherche des minima d’une fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.7.1 Du mouvement des amibes (méthode du simplex). . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.7.2 Méthode de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.7.3 Recherche à une dimension : interpolation parabolique. . . . . . . . . . . . . . . . . . . . . . . 63
4.7.4 Méthode du gradient conjugué. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.7.5 Minimisation avec contrainte : les multiplicateurs de Lagrange. . . . . . . . . . . . . . . . . . . 65
4.8 Modélisation de données expérimentales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.8.1 Données et moindres carrés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.8.2 Ajustement d’une fonction linéaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.8.3 Ajustement d’un polynôme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.8.4 Dérivée locale d’une courbe expérimentale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.8.5 Lissage : a dirty trick ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.8.6 Ajustement non-linéaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.9 Systèmes d’équations différentielles ordinaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.9.1 Un exemple : les lignes de champ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.9.2 La méthode d’Euler. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
4.9.3 La méthode d’Euler « améliorée » ou méthode de Heun. . . . . . . . . . . . . . . . . . . . . . . 72
4.9.4 La méthode de Runge-Kutta d’ordre 4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.9.5 La méthode de Cranck et Nicholson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.9.6 Équations d’ordre supérieur à 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.9.7 Méthode de Verlet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.9.8 Le problème du pas d’intégration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.9.9 Quelle méthode choisir ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.10 Transformées de Fourier rapides. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.10.1 La transformée de Fourier en physique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.10.2 La transformée de Fourier discrète. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
4.10.3 Filtrage de données expérimentales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.11 Les méthodes de Monte-Carlo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Physique numérique, Philippe Depondt 5
4.11.1 Processus stochastiques et chaı̂nes de Markov. . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

4.11.2 Les vicissitudes de π. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.11.3 La production de nombres « aléatoires ». . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.11.4 Obtenir une distribution autre qu’uniforme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
4.11.5 Intégration multidimensionnelle sur des domaines compliqués. . . . . . . . . . . . . . . . . . . . 89
4.11.6 Simulation de Monte-Carlo-Metropolis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
4.11.7 Recherche du minimum d’une fonction : le recuit simulé. . . . . . . . . . . . . . . . . . . . . . . 94
4.12 Le tri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5 Introduction à la simulation numérique 97

5.1 Pourquoi la Simulation numérique ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.2 La matière considérée comme un milieu continu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.2.1 Quels types de questions se pose-t-on ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.2.2 La méthode des différences finies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
5.2.3 Les méthodes spectrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
5.2.4 Introduction aux éléments finis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
5.3 La matière comme une collection de particules. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
5.3.1 Matrice dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
5.3.2 Simulations Monte-Carlo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
5.3.3 Simulations de dynamique moléculaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
5.3.4 Simulations ab-initio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
6 Optimisation de code. 115

6.1 Éviter les calculs inutiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
6.2 Utiliser les symétries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
6.3 Stocker des résultats intermédiaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
6.4 Utilisation des caches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
6.5 Eviter les interruptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
6.6 Ne pas réinventer ce qui existe déjà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
7 Calculs très lourds : vectorisation et parallélisation 119

7.1 L’architecture vectorielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.2 Parallèlisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.2.1 Mémoire partagée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
7.2.2 Mémoire distribuée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
8 Quelques éléments de C++ 121

8.1 Avant même de commencer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
8.2 Déclarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.3 Structures de base diverses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.3.1 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.3.2 Conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.3.3 Sauvegardes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.4 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.4.1 Tableaux de taille fixe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.4.2 Les pointeurs : premiers pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.4.3 Tableaux dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.5 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.5.1 Une fonction très simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.5.2 Prototype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.5.3 Passage d’arguments par valeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.5.4 Passage d’arguments par référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.6 Les classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
9 La question du calcul formel. 127

9.1 Calcul formel, calcul numérique : quelle différence ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.2 Quelques exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.2.1 ax + b = 0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.2.2 Le gaz de Van der Waals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
9.2.3 Modèle de Brillouin-Weiss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
9.2.4 Le projectile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
9.2.5 Une « grosse » simulation : les anneaux de Saturne. . . . . . . . . . . . . . . . . . . . . . . . . 131
9.3 Que peut-on en conclure ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
10 Bibliographie. 135
Chapitre 1
Introduction
« Si vous pensez que le calcul numérique, c’est l’af- tion d’irradiation de matériaux divers ou régulation
faire des autres, c’est qu’il est temps de vous recycler » : de la distribution d’électricité ; les fabriquants de tur-
cette affirmation péremptoire, et volontairement provoca- bines qui cherchent à optimiser leur fonctionnement
trice1 , est à comprendre dans un contexte où le CEA, simulent les phénomènes très complexes liés aux in-
le CNRS, la Communauté Européene et les grands in- stabilités dans les chambres de combustion.
dustriels s’équipent résolument de moyens de calcul tou- Il n’y a guère de domaine qui échappe : même la finance
jours plus considérables. Le sigle HPC (High Performance recrute des scientifiques capables de modéliser sur ordina-
Computing) jaillit un peu partout. . . On parle volon- teur ! Un(e) physicien(e) de formation, que ce soit dans un
tier, et le plus sérieusement du monde, de PetaFlops 2 environnement recherche ou industriel peut difficilement
(sans forcément toujours très bien comprendre de quoi il ignorer ce domaine dont l’importance est de plus en plus
s’agit. . .). C’est sans doute que l’enjeu en paraı̂t impor- massive, même si il/elle n’est pas directement impliqué(e)
tant aux décideurs (et aux payeurs) à la fois pour la re- dans des calculs légers ou lourds.
cherche scientifique et pour la recherche et développement L’évolution fulgurante de la capacité de calcul dispo-
(R & D) industriel. Les demandeurs de ce genre de calculs nible ne peut toutefois être utile et profitable que s’il y a
lourds voire très lourds sont divers ; par exemple et dans des personnes compétentes pour s’en servir de façon per-
le désordre : tinente et donc convenablement formées : il s’agit là d’une
– La météorologie est l’un des utilisateurs civils les plus double compétence à la fois scientifique dans la discipline
importants : les prévisions au quotidien bien sûr, mais d’origine (physique, chimie, mathématiques, science de la
aussi les recherches sur le réchauffement climatique, vie, etc.) et de simulation : « Some jog along with the
essayer d’en prévoir les conséquences, voire trouver technology while others lag behind 3 . . . ». Ce monde évolue
des remèdes requièrent des simulations très élaborées rapidement et le but de ce cours est de fournir les bases et
des mouvements atmosphériques et des échanges chi- les démarches permettant de s’y repérer.
miques et énergétiques.
– La matière condensée, les matériaux et les nanos- L’expérience tend à montrer que ce cours de Physique
ciences en physique et en chimie offrent une variété numérique surprend parfois un peu ceux à qui il s’adresse.
incroyable de problèmes mettant en jeu un grand Il commence, en effet, par de la programmation et quelques
nombre (entre quelques dizaines et le nombre d’Avo- notions d’Unix : serait-ce alors un « cours d’info », comme
gadro !) d’atomes : des calculs classiques ou quan- on l’entend souvent appeler ? Très rapidement toutefois,
tiques, parfois assez simples, parfois très lourds, sont après quelques semaines, on ne parle plus, ou presque plus,
mis en œuvre pour tenter de comprendre ou de prédire d’informatique ou de programmation : c’est supposé ac-
leurs propriétés. quis ; on parle de physique principalement, parfois ornée
– Les sciences de la vie se préoccupent, au niveau micro- d’un peu de mathématiques appliquées. En outre, cette
scopique, de molécules énormes, extraordinairement physique ne paraı̂t, parfois, guère familière à des étudiants
complexes. Des efforts considérables sont faits pour habitués à résoudre des problèmes dont la solution analy-
tenter de modéliser ces objets, avec des enjeux impor- tique est connue : c’est qu’ici, justement, l’objectif est de
tants : repliement de proteines, conséquences pour la résoudre des problèmes pour lesquels il n’y a pas de solu-
maladie d’Alzheimer ou celle de Parkinson, drug de- tion analytique, c’est-à-dire l’immense majorité. . . L’infor-
sign, etc. La génomique, de son côté, doit utiliser des matique est alors pour nous un outil - qu’il faut bien sûr
bases de données colossales en utilisant des méthodes maı̂triser - pour s’attaquer à des problèmes de physiques
qui doivent être efficaces et n’ont rien de trivial. variés. Le charme de cet enseignement, pour les ensei-
– Les sciences de l’ingénieur sont aussi très deman- gnants mais aussi souhaitons-le pour ceux qui le reçoivent,
deuses. Les simulations aérodynamiques permettent une fois - répétons-le - l’outil acquis, est qu’il ne se can-
de prévoir et d’optimiser les caractèristiques d’un tonne pas à tel ou tel domaine de la physique, mais qu’il
avion avant même son premier vol ; un industriel pioche ses exemples dans des champs aussi variés que pos-
comme EDF développe des calculs souvent très lourds sible, dans des questions souvent très contemporaines, avec
dans des domaines d’une grande diversité : simula- des approches parfois inattendues.
1 faite par un professeur de mathématiques à l’UPMC en intro- Le présent polycopié déborde assez largement le strict
duction à un colloque intitulé Penser PetaFlops en mai 2008. minimum nécessaire à la réussite à l’examen. . . c’est vo-
2 1015 floating point operations per second. La première machine
« pétaflopique » a fonctionné au printemps 2008. L’étape suivante 3 « Certains accompagnent le peloton tandis que d’autres traı̂nent
est l’ExaFlops : 1018 flops. . . derrière. »
7
lontaire : à chacun de sélectionner ce qui lui paraı̂t utile, Un autre exemple, moins célèbre sans doute, est
les séances de travaux dirigés et de travaux pratiques étant l’ensemble des opérations qui, pendant la Révolution
de bons guides en la matière4 . Française, ont abouti à la définition du mètre, en rem-
placement du maquis d’unités de l’Ancien Régime, par un
système uniforme et rationnel. On voulait que le mètre fût
1.1 Des méthodes numériques, universel (on aurait certes put choisir comme référence
les unités en vigueur à Paris, mais l’idéal universaliste
pour quoi faire ? des révolutionnaires l’interdisait) et l’on choisit ainsi une
référence qui pût être commune à toute l’humanité : la dix-
À titre de provocation, on pourrait dire que l’objet de ce
millionième partie du quart du méridien terrestre. Encore
cours est de faire aussi peu d’informatique que possible. Il
fallait-il en mesurer la longueur. . . On envoya donc deux
s’agit plutôt d’utiliser les ressources fournies par les ordi-
mathématiciens-astronomes réputés pour leur précision et
nateurs pour tenter de traiter des problèmes de physique
le soin avec lequel ils menaient leurs observations (Jean-
aussi variés que possible, afin, soit de se simplifier la vie
Baptiste-Joseph Delambre (1749-1822) et Pierre-François-
et gagner du temps en faisant faire par un ordinateur des
André Méchain (1744-1804)) équipés des instruments de
calculs fastidieux que l’on pourrait sans doute faire soi-
visée les plus élaborés, mesurer entre Dunkerque et Bar-
même, soit au contraire de s’attaquer à des questions que
celone la longueur de l’arc de méridien de Paris : en
l’on ne pourrait en aucun cas traiter avec une feuille de
déterminant très précisément la latitude des deux villes
papier et un crayon. . . Nous chercherons ainsi dans divers
(à partir de la hauteur de l’Étoile Polaire et de quelques
domaines de la physique des problèmes, de préférence peu
autres) on en déduirait aisément la longueur du méridien
susceptibles d’une solution analytique, afin de les traiter
complet.
numériquement à l’aide d’un calcul sur ordinateur, l’ob-
jectif étant d’apprendre comment aborder une question de Il fallait donc établir un réseau de triangles qui recouvre
façon qu’un calcul permette d’y répondre de manière sa- complétement l’arc de méridien compris entre les deux
tisfaisante, quitte à la reformuler au passage pour la faire villes, mesurer avec une précision méticuleuse les angles
entrer dans un cadre propice à ce genre de traitement. aux sommets de tous ces triangles afin d’en calculer la
longueur des côtés, puis par trigonométrie, la longueur de
l’arc. Cette épopée (racontée par Ken Alder dans The mea-
1.1.1 Quelques jalons. . . sure of all things, Free Press (2002)) dura sept ans (1792-
1799) dans une France en proie à toutes sortes de vio-
Il ne faut cependant pas croire que les calculs numé- lences (les invasions, les guerres révolutionnaires, la Ter-
riques aient attendu l’invention de l’ordinateur pour voir
reur, Thermidor. . .) : dans les jours qui suivirent la fuite
le jour. Au XVIIe siècle déjà, l’invention des logarithmes de Louis XVI à Varennes, Delambre avec son attirail de
par John Napier (1550-1616) fut une révolution (Miri- longue-vues et d’instruments, et, pire encore, son ordre de
fici logarithmorum canoni descriptio, Edimbourg (1614)) : mission signé par le roi fugitif, fut arrêté à plusieurs re-
une multiplication se transformait en addition -beaucoup prises comme « espion » ; un peu plus tard, Méchain resta
plus aisée-, une extraction de racine carrée en division bloqué en Catalogne quand l’Espagne bourbonnienne et
par deux ! L’astronome Johannes Kepler (1571-1630) qui la France républicaine se trouvèrent en guerre ; Méchain
découvrit l’ellipticité des orbes planétaires, se livra à dut aussi lutter en permanence contre un état psycholo-
des calculs numériques vertigineux dans, par exemple, gique dépressif lié à son inquiétude quant à la qualité de
son œuvre principale, l’Astronomie Nouvelle (Astronomia ses mesures. Les deux hommes revinrent enfin à Paris en
Nova, (1609) ). Ainsi, par exemple, pour évaluer les posi- 1799 pour présenter leurs résultats : une conférence inter-
tions au cours du temps d’une planète alors qu’elle par-
nationale de mathématiciens devait : 1o vérifier et valider
court ce qui n’est encore qu’un « ovoı̈de » avec une vitesse la cohérence de leurs observations, et 2o en déduire la lon-
variable5 , il divise la trajectoire en 360 petits segments gueur du mètre.
et additionne les résultats obtenus pour chaque segment :
c’est ce que l’on appelle maintenant une discrétisation. Il fallait donc, pour la deuxième partie de ce travail, faire
Kepler, lui, appelait cela un « morcellement numérique » des calculs de trigonométrie sur une surface sphérique.
et se plaignait de ce que ce calcul fût « mécanique et en- On savait cependant qu’outre les montagnes dont il fal-
nuyeux » : comme son employeur, l’empereur Rudolf II., lait bien sûr tenir compte, la Terre n’était pas une sphère
ne payait son salaire qu’occasionnellement, il n’avait pas parfaite mais plutôt un ellipsoı̈de de révolution légèrement
les moyens d’employer lui-même un assistant pour l’ai- applati aux pôles : toutefois, le choix d’un arc de méridien
der. . . Il connaissait d’ailleurs les tables de logarithmes de situé à des latitudes intermédiaires (le 45˚ parallèle passe
Napier et en établit lui-même dans ses Tables Rodolphines à Bordeaux et donc coupe l’arc Dunkerque-Barcelone non
(Tabulæ Rudolphinæ, (1627) ). loin de son milieu) permettait d’espérer obtenir une va-
leur moyenne qui pût servir de référence. On fit alors une
4 Le chapitre 5, en particulier doit être considéré comme la suite découverte complétement inattendue : le géoı̈de n’était pas
logique du cours, mais n’en fait à proprement parler partie. régulier mais recouvert de bosses et de creux. La valeur
5 Jusqu’alors, on croyait, Copernic, Tycho Brahe et Galilée y com-
du rayon de courbure de la surface terrestre dépendait de
pris, que les mouvements planétaires étaient des mouvements cir-
culaires uniformes, ou des combinaisons de mouvements circulaires l’endroit où il était mesuré, or la précision magnifique des
uniformes, ce qui permettait un calcul facile des positions planétaires observations de Delambre et Méchain, le soin méticuleux
futures. Kepler, comme on le sait, introduisit, à cause d’un désaccord -voire obsessionnel dans le cas de Méchain- avec lequel
de 8 minutes d’angle dans la position de Mars, les orbes, d’abord
elles avaient été réalisées ne permettaient pas de mettre ce
ovoı̈des puis elliptiques, parcourues à vitesse variable ; les prédictions
en devenaient beaucoup plus difficiles : il fallut attendre Newton pour résultat sur le compte d’erreurs ou d’imprécisions de me-
voir la résolution de ce problème. sure. Après de longues tergiversations, on finit néanmoins
Curseur transparent
Réglette
a b
Graduations logarithmiques
a.b
Fig. 1.1 – La règle à calcul, héritière des tables de logarithmes de John Napier, en usage jusqu’à la fin des années 1970.
La réglette pouvait coulisser dans une gorge aménagée dans la règle et le curseur pouvait glisser sur l’ensemble. Pour
faire le produit de deux nombres a et b (par exemple pour convertir des calories en joules), on déplaçait la réglette
de telle façon que son origine se trouve en face de la graduation a de la règle, puis on déplaçait le curseur jusqu’à la
graduation b de la réglette pour lire le résultat : comme les graduations étaient logarithmiques, on additionnait ainsi
deux logarithmes pour obtenir le produit de leurs arguments.
par fixer la valeur du mètre à 443,296 lignes (une unité en de celle de Pascal et un système de cartes perforées issu
vigueur à Paris alors) et l’on fondit le fameux mètre-étalon des métiers à tisser Jacquard. Malheureusement, malgré
en platine irridié du pavillon de Breteuil. un financement public conséquent, et une « communica-
Au-delà de l’histoire plus ou moins anecdotique, on tion » - comme on dirait maintenant - efficace assurée par
devine en arrière-plan les prodigieux calculs numériques Ada Byron6 , les réalisations pratiques ne donnèrent jamais
que les mathématiciens de la conférence ont dû faire satisfaction, à cause semble-t-il des frottements excessifs
(outre les travaux de dégrossissage réalisés par De- des mécanismes.
lambre et Méchain : corrections pour l’altitude, la La première réalisation pratique de calculs massifs au-
réfraction atmosphèrique, la température, etc.) armés tomatisés est due à Herman Hollerith qui inventa une ma-
d’une plume pour écrire et d’une table de logarithmes. chine pour traiter les données du recensement américain
Il ne se répartirent même pas la tâche, car pour plus de de 1890 à l’aide de cartes perforées. Le résultat (62 622
sûreté, chaque participant devait faire indépendamment 250 habitants) fut obtenu en six semaines au lieu de sept
l’intégralité des calculs en utilisant ses propres méthodes ! ans pour le recensement précédent. Fort de ce succès, Hol-
On reste pantois devant la dextérité et l’acharnement cal- lerith fonda en 1896 la Tabulating Machine Company qui
culatoires que cela représente. . . changea de nom en 1924 pour devenir International Busi-
ness Machines : ibm. . . spécialisée dans la fabrication de
Un peu plus tard, au XIXe siècle, Urbain Le Verrier
calculatrices mécaniques de bureau, parfois mûes par des
étudia les perturbations observées dans l’orbite d’Uranus
moteurs électriques, ou utilisant des cartes perforées.
et postula l’existence d’une autre planète jusqu’alors in-
Un effort de recherche important sur le calcul automa-
connue. Il calcula la position de cette planète et le direc-
tique fut mené aux États-Unis pendant la deuxième guerre
teur de l’observatoire de Berlin, Johann Galle, vit à l’en-
mondiale poussé en grande partie par le Ballistic Research
droit indiqué, le 23 septembre 1846, la nouvelle planète,
Laboratory. Il fallait calculer les trajectoires des projectiles
Neptune : un triomphe pour le valeureux calculateur !
tirés par divers armements afin de fournir des tables de
On imagine sans peine cependant l’énorme labeur que
pointage aux artilleurs. Pour chaque nouvelle munition, il
représentèrent, pour Le Verrier, ces calculs, entièrement
fallait produire une nouvelle table. Une armée d’employés,
faits à la main. . .
dotés de calculatrices mécaniques de bureau, faisait ces
Cependant, l’idée d’automatiser des calculs ennuyeux calculs, mais à la fin de la guerre, était littéralement sub-
est ancienne. Le baron Gaspard de Prony était chargé mergée par l’afflux de munitions de tous types et de tous
pendant le Premier Empire d’établir des tables pour le calibres produits par une industrie de guerre en plein ef-
calcul de l’impôt foncier : pour cela, il divisa le tra- fort. . . La première calculatrice électronique, l’ENIAC en
vail en trois grands blocs. La première partie, la plus 1945, était un monstre de 30 tonnes comportant 17 468
noble, était confiée à des mathématiciens : il s’agis- tubes à vide7 et consommant 150 kW. La panne d’un seul
sait de décomposer tous les calculs nécessaires en séries tube arrêtait la machine qui occupait un bâtiment à elle
d’opérations élémentaires. La deuxième tâche consistait à toute seule et nécessitait un système de refroidissement
organiser le travail et à compiler les résultats. La troisième, puissant pour évacuer la chaleur produite ! Les premiers
faire les calculs réduits à des opérations très simples, fut ordinateurs virent le jour à la fin des années 1940, trop
confiée à une armée de calculateurs humains dont la seule tard pour participer à l’effort de guerre.
qualification était d’être capable de faire des additions. Rapidement, les banques, les compagnies d’assurance8
L’étape suivante fut franchie par Charles Babbage, un 6 la fille du poète.
gentleman philosopher britannique du début du XIXe 7 il n’y avait pas encore de transistors et encore moins de circuits
siècle qui eut l’idée d’associer cette décomposition des cal- intégrés.
culs en tâches élémentaires avec une calculatrice du type 8 Du point de vue des constructeurs d’ordinateurs, ce genre de
et toutes les entreprises astreintes à une comptabilité la fin de la décennie. Un livre de « mathématiques com-
lourde comprirent l’usage qu’elles pouvaient faire de ces putationelles9 » régulièrement réédité jusqu’à la fin des
nouvelles machines et constituèrent un marché important années 80 explique, dans un chapitre d’introduction inti-
pour les constructeurs. Cependant, la demande de calculs tulé « General rules of computation work », que si l’on
toujours plus importants venant des scientifiques, physi- veut construire une table des valeurs de la fonction :
ciens et astronomes en tête, n’a jamais cessé d’être pres- ex + cos x p
sante, toujours de quelques ordres de grandeur au-delà de y= + 1 + sin2 x
1 + x2
ce que pouvaient fournir les ordinateurs les plus puissants
du moment : cette histoire se poursuit actuellement, cer- il faut faire sur une feuille de papier un tableau à 12 co-
tains calculs quantiques, par exemple, se chargeant, par lonnes donnant, pour la première la liste des valeurs de x,
leurs exigences en termes de puissance de calcul, de rame- la deuxième celles de x2 , la troisième ex , etc., la douzième
ner à une saine modestie les fabriquants des processeurs donnant enfin la liste des valeurs de y (voir la table 1.1) :
les plus éblouissants ! il n’est pas inutile de réaliser que tous les calculs scienti-
fiques étaient réalisés de la sorte jusqu’à un passé somme
toute récent à l’échelle d’une vie humaine10 .
Sur l’histoire de l’informatique, on se reportera avec

profit aux ouvrages suivants :
Ph. Breton Histoire de l’informatique, La

Découverte (1987)
M. Campbell-Kelly & Computer. A history of the
W. Aspray information machine, Basic Books
(1996)
Ph. Breton Le premier ordinateur copiait le
cerveau humain, La Recherche
290 (1996) p. 80
1.1.2 . . . et quelques exemples.

Au début du XXe siècle, le mathématicien Henri Poin-
caré, étudiant le problème dit « à N corps » par
exemple N − 1 planètes et leur soleil, découvrit la « sen-
siblité aux conditions initiales » qui interdit de trou-
ver des solutions générales aux systèmes d’équations
différentielles produites par ces problèmes : une infime
différence dans les conditions initiales suffit à induire
un comportement radicalement différent du système. Au-
tant dire que, malgré le déterminisme intrinsèque de la
mécanique newtonienne, un tel système devient rapide-
ment imprévisible11 . Toutefois, malgré cette découverte
fondamentale, Poincaré ne put guère aller plus loin et
l’on en resta là jusque vers les années 1960. C’est
alors que le mathématicien-météorologue américain Ed-
ward Lorenz12 se mit à résoudre sur ordinateur des
équations différentielles qui visaient à simuler le compor-
tement de l’atmosphère terrestre : il redécouvrit alors
des systèmes au comportement irrégulier similaire à
ce qu’avait prédit Poincaré. Le triangle simulation-sur-
Fig. 1.2 – Page de garde de la table de logarithmes Bou- ordinateur/théorie/expérience donna naissance à un do-
vart et Ratinet (édition 1957) en usage dans les classes maine de recherches nouveau et toujours actif de nos
scientifiques des lycées jusque dans les années 1970. jours : le chaos, la turbulence, les fractals. . ., tout ce qui a
trait à la dynamique des systèmes non-linéaires. Il fallait
À titre de témoignage de la rapidité avec laquelle la vie évidemment pour cela que l’on pût faire des simulations
des scientifiques a changé, rappelons qu’encore au début sur ordinateur, car le calcul analytique est insuffisant :
des années soixante-dix, les élèves des classes préparatoires d’ailleurs maintenant, la météorologie nationale est un des
passaient plusieurs heures par semaine à remplir des co-
9 Voir la référence [2] dans la bibliographie. Il s’agit certes d’un
lonnes de chiffres, stylo d’une main, table de logarithmes
livre soviétique et l’informatique est sans doute l’un des domaines
(figures 1.2 et 1.3) de l’autre, un entraı̂nement jugé in- dans lequel le retard de l’Union soviétique était sensible.
dispensable à leur dextérité calculatoire. . . les calculettes 10 Pour fixer les idées, précisons que l’espèce Tyranosaurus Rex
électroniques n’ayant détrôné l’invention de Napier qu’à était déjà éteinte depuis quelques années. . .
11 Voir par exemple : David Ruelle, Hasard et chaos, Odile Jacob
clients avait l’avantage d’être largement solvable, un encouragement (1991).

fort à faire les investissements nécessaires à la production de calcu- 12 À ne pas confondre avec l’éthologiste autrichien Konrad Lorentz
latrices rapides et fiables ! et ses oies.

Fig. 1.3 – Une page de la table de logarithmes Bouvart et Ratinet. Admettons que l’on cherche le produit 0,1263×18,17 ;
une calculette donne 2,2949. Avec la table, il faut d’abord chercher 1263, soit 120 puis la sixième ligne pour 126 et
enfin la colonne 3 : on y trouve 10140. La même opération pour 1817 donne 25935. La somme de ces deux nombres est
36075. En cherchant dans la table, on trouve que 39078 correspond à 2295, reste à décaler la virgule convenablement
pour obtenir le résultat. Si l’on veut avoir 5 chiffres significatifs, il faut utiliser les tables de multiplication fournies
dans la marge pour faire des interpolations linéaires. Avec un peu d’habitude, ça va assez vite, plus vite en tous cas
que la multiplication à la main !
plus gros consomateurs civils de calcul sur les ordinateurs cile, la « modélisation de données d’expérience » qui
les plus puissants. consiste à ajuster un modèle théorique aux données expéri-
Dans un autre domaine, les expériences faites par mentales connues, en tenant compte des barres d’erreur
exemple à l’aide du rayonnement synchrotron produit expérimentales. Il s’agit en général de minimiser autant
dans des laboratoires tels que SOLEIL à Orsay et l’ESRF que possible l’écart entre les données empiriques et les
à Grenoble, produisent une grande quantité de données prédictions du modèle théorique : cette minimisation, une
numériques qui ne se traduisent pas immédiatement par optimisation du modèle si l’on préfère, est établie en ajus-
des informations de type physique : par exemple, les tant un nombre souvent élevé de paramètres (les positions
positions des atomes d’une protéine, qui en comporte atomiques, la caractérisation de l’agitation thermique) et
des centaines voire des milliers, destinée à soigner telle ne peut pratiquement se faire qu’à l’aide d’un ordinateur.
ou telle maladie. Survient alors une tâche assez diffi- L’étude des systèmes désordonnés est aussi grosse
1 2 3 4 5 6 7 8 9 10 p 11 12
ex +cos x
x x2 ex sin x cos x x
e + cos x 1 + x2 sin2 x 1 + sin2 x 1 + sin2 x y
1+x2 p
(1)2 (3) + (5) 1 + (2) (6)/(7) (4)2 1 + (9) (10) (8) + (11)
0
0.1
0.2
0.3
0.4
...
ex + cos x p
Tab. 1.1 – Feuille de calcul pour la fonction y = + 1 + sin2 x, à remplir, colonne par colonne, à l’aide
1 + x2
d’une machine à calculer mécanique ou électro-mécanique. . .
Tab. 1.2 – Un article du journal Le Monde en 1957, les m′ réparties aléatoirement, le problème devient beaucoup
derniers progrès de la prévision météorologique, il y a un plus difficile à résoudre. On montre cependant sans grande
demi-siècle : difficulté que la solution est donnée par la recherche des
Une machine à prédire le temps valeurs propres et vecteurs propres d’une énorme ma-
Quel temps fera-t-il demain ? Vieille question à laquelle les of- trice n × n, appelée « matrice dynamique » où n est le
fices météorologiques s’efforcent de répondre. Mais voici que la nombre d’atomes de la chaı̂ne. Le problème est très facile
machine électronique vient à leur secours. On connaı̂t les ap- à résoudre numériquement à l’aide d’un sous-programme
titudes extraordinaires de ces ordinateurs, véritables cerveaux de bibliothèque, alors que le désespoir guette quiconque
de remplacement, doués de raisonnement et d’une fabuleuse tenterait de le résoudre à la main. . .
mémoire, qui peuvent aujourd’hui répondre en quelques se-
condes à des questions qui embarasseraient plus d’un auditoire
savant. On pourrait objecter à ce qui précède qu’un problème
C’est à des machines semblables que le Bureau météorologique
de physique qui nécessite plus qu’une règle de trois pour
américain demande de travailler pour lui, au moins pour un cer-
tain nombre de calculs. Ce bureau centralise des milliers d’ob-
être résolu est un problème mal posé. L’art du physicien
servations qu’une armée de savants, de ballons-sondes, toute théoricien n’est-il pas justement de faire des approxima-
une flotille de bateaux, tout un réseau de postes et de stations tions adroites de façon à rendre résolubles ces problèmes
disséminés aux quatre coins du monde, glanent quotidienne- tout en isolant les principes importants ? L’intérêt n’est-il
ment et à chaque instant sur terre, sur mer et dans le ciel. pas plutôt dans les concepts que dans les techniques de
Rien n’a changé dans le système, si ce n’est qu’une grande par- calcul plus ou moins laborieuses ?
tie des opérations mathématiques, la plus dure, la plus longue,
est confiée à l’ordinateur. A chaque instant on introduit dans Cette objection est parfaitement recevable et c’est tou-
la machine, sous forme de bandes magnétiques, de nouvelles jours une bonne démarche que de tenter de réfléchir à
observations, de nouveaux chiffres, qui sont la nourriture de une question avant de se lancer dans des calculs effrénés.
ce cerveau surhumain, et les savants n’ont plus qu’à tirer leurs
Il y a cependant des limites qui souvent arrivent très
conclusions. Ils peuvent ainsi annoncer, avec une plus grande
sûreté de diagnostic, l’évolution du temps pour des périodes de
vite : imaginons un pendule simple qui subit un frotte-
vingt-quatre, quarante-huit et même soixante-douze heures. ment aérodynamique. Il pend verticalement et on le lance
(Le Monde, le 25 juillet 1957, reproduit le 25/07/2007). avec une vitesse initiale donnée, suffisamment fort pour
qu’il passe à la verticale au dessus de son point d’équilibre
pour retomber de l’autre coté. Combien de tours fera-t-
consommatrice de moyens de calcul. Par exemple, une il autour de son axe avant de se mettre à osciller ? Il est
chaı̂ne linéaire harmonique d’atomes, tous de masse m, clair qu’on est fort loin des conditions où l’on peut faire
est parcourue de vibrations de type onde plane xℓ = les approximations usuelles (angle petit). En attendant de
u ei(ωt−kℓa) , où xℓ est le dépacement de l’atome ℓ par rap- trouver le concept adéquat, il n’est peut-être pas stupide
port à sa position d’équilibre et a est la distance inter- de faire une petite simulation numérique sur un ordina-
atomique. Un calcul classique13 à partir des équations du teur : cela ne représente guère plus que quelques dizaines
mouvement : de lignes de programme et quelques secondes de simulation
sur une machine même de puissance médiocre. . .
m ẍℓ = C(xℓ+1 − 2xℓ + xℓ−1 )
Il ne faut pas croire non plus que le calcul numérique
donne la pulsation ω en fonction du vecteur d’onde k, c’est- sur ordinateur se limite à la physique : les prévisions
à-dire la relation de dispersion : météorologiques (voir la table 1.2) sont évidemment un
r cas bien connu, mais aussi les simulateurs de vol per-
C ka mettent à des pilotes d’essais de tester le comportement
ω(k) = 2 sin
m 2 d’un nouvel avion sans risquer leurs vies et des simulateurs
d’opérations permettent à des chirurgiens de s’entraı̂ner
où C est la constante de force entre deux atomes. Main- sans risquer celles de leurs patients ! Le dossier de la revue
tenant, si la chaı̂ne comporte des impuretés de masse Pour la Science (voir la bibliographie, ref. (20)) consacré
13 Voir, par exemple : Charles Kittel, Introduction to Solid State- à la modélisation informatique parcourt quelques thèmes
Physics, New York : Wiley, (1986). « à la mode ». . .
1.2 Plan succinct.

La première étape est l’apprentissage d’un langage de
programmation. Il faut pouvoir « dire » à l’ordinateur ce
que l’on veut qu’il fasse. Le langage le plus adapté au cal-
cul scientifique est le fortran95. Son concurrent, le lan-
gage C, plus généraliste et plus adapté à la programmation
système -le système d’exploitation unix est programmé en
C-, nécessiterait un apprentissage plus long, qui n’apporte-
rait rien de plus à notre objectif, sans apporter la puissance
qu’offre fortran95 en particulier dans la manipulation
des tableaux. Afin d’illustrer l’objectif de ce cours, cette
première partie est suivie d’un chapitre dont le but est de
montrer sur un exemple la façon dont on procède pour
aborder un problème et en particulier essayer d’expliciter
ce qui est attendu lors des séances de travaux pratiques.
La deuxième étape consistera à passer en revue les
méthodes les plus utilisées par les physiciens, autant que
possible à l’aide d’exemples tirés de la physique. L’accent
ne sera pas forcément mis sur les détails les plus intimes
des algorithmes, car des mathématiciens seraient sûrement
plus à même de le faire que des physiciens dont ce n’est
pas le centre d’intérêt principal : de fait, la pratique des
physiciens est souvent d’utiliser des sous-programmes de
bibliothèque existants et éprouvés que l’on « appelle » à
partir d’un programme spécifique à un problème donné.
L’effort portera donc plutôt sur les contraintes que ces al-
gorithmes peuvent exercer sur les problèmes que se posent
les physiciens, éventuellement sur les pièges qu’ils recèlent.
En gros, il s’agit d’essayer de répondre à trois questions :
« comment ça marche ? », « quelles conséquences cela
peut-il avoir pour moi, physicien ? » et bien sûr : « qu’est-
ce que je peux faire avec ? ». Une ouverture est donnée sur
la simulation numérique.
La troisième étape consistera à utiliser un logiciel de cal-
cul formel pour tenter de résoudre les mêmes problèmes
que précédemment. Dans certains cas, le caractère convi-
vial et automatique du logiciel tout fait fera des miracles,
dans d’autres en revanche, ça sera moins convaincant. . .
mieux vaut savoir se repérer, d’autant que, là encore, des
pièges subsistent.
Ainsi ce cours se veut, non pas un cours d’« informatique
pour physiciens » mais un cours pratique de « Physique
numérique » c’est-à-dire des méthodes qu’utilisent les phy-
siciens pour résoudre un grand nombre de problèmes de
physique.
Chapitre 2
Notions pratiques de FORTRAN95.
Les notes ci-dessous ont pour but de donner rapidement la mémoire est aussi désigné par une adresse binaire.
au lecteur la capacité d’écrire des programmes ; elles ne C’est ce qu’on appelle le langage machine. Réaliser un
remplacent pas, bien sûr, un cours systématique1. Il s’agit programme consiste donc à fournir à l’ordinateur une
ici d’un outil dont la maı̂trise est un préalable indispen- séquence d’instructions de ce type pour qu’il la place
sable à tout travail de calcul numérique : il n’est pas utile dans sa mémoire pour exécution ; or il est rapidement
de connaı̂tre toutes les subtilités du Fortran95, mais fastidieux d’aligner des listes fort longues de 1 et de 0,
sans compter les risques d’erreurs que cela comporte ! Un
il faut impérativement être capable d’écrire rapidement
premier progrès fut de remplacer le code binaire d’une
des programmes simples « qui marchent » car, sinon, les instruction par un mot-clef, par exemple load (pour
séances de travaux pratiques destinées à faire de la phy- charger en mémoire), et d’écrire les adresses en décimal
sique que l’on espère intéressante avec cet outil, en devien- (ou en hexadécimal) plutôt qu’en binaire. Cela donne
draient suprêmement ennuyeuses pour tous, enseignants quelque chose qui peut ressembler à :
compris. . . load 150 aller chercher un nombre à l’adresse 150
add 200 additionner avec le contenu de l’adr. 200
store 220 ranger le résultat a l’adresse 220
2.1 Qu’est-ce qu’un langage de C’est nettement plus lisible que :
programmation ? 0011010100101100011111100100001001110101...
Un ordinateur, lorsqu’il exécute un programme, lit Un programme spécial, en général fourni avec l’ordinateur
l’une après l’autre dans sa mémoire des instructions et appelé assembleur traduit alors toutes ces instructions
élémentaires, par exemple : « aller chercher un nombre en binaire ou langage machine, puis on peut faire exécuter
à tel emplacement dans la mémoire » ou « multiplier tel le programme (voir les tables 2.1 et 2.2).
nombre par tel autre ». Ce schéma correspond à la célèbre L’assembleur permet de faire beaucoup de choses,
« machine de Turing » qui sert de modèle théorique à presque tout, à vrai dire : à une époque (les années
l’immense majorité des ordinateurs (figure 2.1) : instruc- 80) où les mémoires disponibles n’étaient pas ce qu’elles
tions et données sont inscrites sur un même support ap- sont devenues, la programmation en assembleur permet-
pelé mémoire2. La mémoire est constituée d’emplacements tait d’écrire des programmes efficaces et peu encombrants,
correspondant chacun à une adresse et contenant chacun au détriment évidemment de la facilité et du temps passé
une instruction ou une donnée : on peut se représenter à la programmation, car tout cela reste très « proche de
cette mémoire comme une espèce de long ruban divisé en la machine » et certainement assez peu convivial4 .
cases, chacune d’entre elles ayant un numéro, comme les L’étape suivante fut donc de créer des langages dits
maisons le long d’une rue, chaque numéro constituant une « évolués » avec lesquels on puisse faire aisément
« adresse ». des instructions beaucoup plus compliquées comme, par
exemple :
La « machine » lit dans la mémoire les instructions et
les exécute l’une après l’autre séquentiellement3 . Une ins- x = a*exp(i*(omega*t+phi))
truction peut être l’ordre d’aller lire une donnée à l’adresse
en mémoire indiquée par cette instruction, ou de modifier qui ressemble beaucoup à l’expression mathématique :
une donnée ou encore d’inscrire une donnée à une autre x = a ei(ωt+ϕ)
adresse dans la mémoire : on peut donc modifier le contenu
de la mémoire. et où x et i sont des nombres complexes, les autres va-
Chaque instruction est désignée par un code binaire riables étant réelles, exp désignant évidemment l’expo-
constitué de 0 et de 1, et chaque emplacement dans nentielle et * la multiplication. Un autre programme ap-
1 voir par exemple J. F. Kerrigan, réf. [6] dans la bibliographie, pelé compilateur doit alors décomposer ces instructions
ou, plus récent et plus complet M. Metcalf et al., réf. [18]. évoluées en instructions élémentaires, les coder en bi-
2 Le terme mémoire date des années 1940, lorsque John Von Neu- naire et affecter des adresses en mémoire à toutes les va-
mann s’est préoccupé de réalisations pratiques de la machine de Tu- riables pour produire un programme exécutable : cette
ring qui dans son esprit devaient être des cerveaux artificiels. Avant,
on parlait, plus prosaı̈quement, de storage en anglais, soit stockage. 4 J’ai, personnellement, quelques souvenirs cuisants à ce titre :
3 d’où l’expression « machine séquentielle » que l’on retrouve à la suite -entre autres- d’une erreur dans le calcul d’une adresse,
fréquemment : il s’agit simplement d’une machine qui exécute les un programme pouvait très bien écrire une donnée à un emplace-
instructions l’une après l’autre, par opposition aux machines dites ment réservé à une fonctionalité de base du système, ce qui était
« parallèles ». évidemment plutôt catastrophique !
15
1 2 3 4 150 151 200 201 220

charger add. ranger aller retour
16
58
4
41
14
64
150 200 220 en 10 en 1
1.
3.
2.
Fig. 2.1 – La machine théorique de Turing. Le curseur lit les instructions les unes après les autres et la machine les
exécute. Par exemple : aller lire une donnée à un emplacement de la mémoire vive, ou sauter à une autre instruction,
etc.
Tab. 2.2 – Suite de la table 2.1

Tab. 2.1 – Pour comprendre comment « ça marche » : Un autre registre très important est le « compteur ordinal » :
quelques éléments d’assembleur il contient l’adresse de la prochaine instruction qui doit être
L’unité centrale (CPU ou Central Processing Unit) d’un ordi- lue. Le contenu de ce registre est incrémenté automatique-
nateur ne travaille pas directement dans la mémoire vive : elle ment chaque fois qu’une instruction est lue, sauf si l’instruction
a ses propres emplacements mémoires appelés « registres ». précédente est une instruction dite « de branchement ». Ainsi,
Elle doit donc aller chercher en mémoire vive les grandeurs le CPU lit une instruction, incrémente le compteur ordinal,
nécessaires à un calcul, les copier dans ses registres, faire les exécute l’instruction, puis lit l’instruction suivante, incrémente
opérations requises et stoker les résultats dans la mémoire. le compteur, exécute l’instruction, etc. C’est ce qu’on appelle
Pourquoi toutes ces complications, pourquoi ne pas tout sto- une « architecture séquentielle ».
cker d’emblée dans les registres de l’unité centrale ? Tout sim- Cependant, si l’instruction lue est une instruction de branche-
plement parce qu’ils sont très peu nombreux, de l’ordre de la ment, celle-ci modifie le contenu du compteur afin de forcer la
dizaine. . . Certains ordinateurs très puissants -et extrêmement lecture d’une autre instruction que la suivante. Ce branchement
coûteux- possèdent des registres en grand nombre ce qui est en général soumis au contenu d’un registre « d’état » qui dit
accélère considérablement les calculs mais suppose un budget si une grandeur dernièrement traitée et positive ou négative,
conséquent ! s’il y a eu un dépassement de capacité, etc. On peut modifier
Mettons que l’ordinateur utilisé possède deux registres à usage le registre d’état à l’aide d’instructions de comparaison, par
général appelés « accumulateurs », désignés par A et B dans exemple :
lesquels on peut placer des nombres, par exemple. L’instruc- CMPB $310F
tion pour charger le contenu d’un emplacement mémoire dans compare le contenu du registre B avec celui de l’emplacement
le registre A est LDA et celle pour B est LDB (les syntaxes sont $310F et modifie le registre d’état en conséquence, puis
données ici à titre indicatif : cela dépend du processeur). On BGE $11DA
peut donc écrire, par exemple : nous expédie à l’adresse mémoire $11DA, si le résultat de la
LDA $40B6 comparaison est positif (B veut dire branch et GE signifie Grea-
ce qui signifie « charger le contenu de $40B6 dans le registre A, ter or Equal ), pour y lire une instruction. On obtient ainsi la
le symbole $ indiquant que l’adresse est donnée en hexadécimal possibilité d’instructions soumises à condition ; reste toutefois
(en base 16), soit : $40B6= 4 × 163 + 0 × 162 + 11 × 16 + 6 soit à espérer que l’emplacement en question contient bien une ins-
16566.De même : truction, c’est une source de « plantages » spectaculaires, mais
ADDA $B003 là réside une grande part du charme désuet de l’assembleur !
additionne le contenu du registre A avec le contenu de l’empla- Si l’on souhaite un plat un peu plus corsé encore, on peut pla-
cement $B003 et place le résultat dans A. (Suite : table 2.2) cer un nombre désignant une adresse dans un emplacement de
la mémoire. Par exemple :
LDA #$0114
traduction, ce programme exécutable est généralement place le nombre (et non le contenu de l’adresse) dans le registre
A,
stocké sur le disque dur de l’ordinateur dans un fichier
STA $041E
dit « exécutable » qu’il suffit d’invoquer (en général en place ce nombre à l’emplacement $041E
tapant son nom sur le clavier) pour qu’il s’exécute. Ainsi, LDB [$041E]
lorsqu’on écrit un programme, que ce soit en fortran, charge dans B, non pas le contenu de $041E, mais le contenu
C, pascal ou autre, on doit d’abord créer, à l’aide d’un de l’adresse elle-même contenue dans $041E. Ainsi
éditeur de texte5 comme emacs, xedit, kedit, vi (pour les INC $041E
amateurs), voire ed, un fichier que l’on appelle le « fichier incrémente le contenu de cette adresse, et
source » qui contient les instructions que l’on a écrites LDB [$041E]
en langage évolué. Ce fichier source n’est pas exécutable : permet d’aller chercher ce qui se trouve à l’emplacement sui-
il ne contient que des caractères, a priori inutilisables en vant : en accroissant pas à pas le contenu de l’emplacement
l’état par l’unité centrale. On doit alors compiler le pro- $041E on peut parcourir l’un après l’autre toute une série d’em-
placements successifs dans la mémoire. Les amateurs de lan-
gramme pour obtenir un fichier exécutable, et enfin lancer
gage C auront reconnu ici un embryon de pointeur. En for-
l’exécution de celui-ci. Bien, évidemment, à chaque mo- tran ce genre de situation est géré par les tableaux.
dification du fichier source, il faut re-compiler et relancer
5 et non un traitement de texte, dont les fonctionnalités (mise en
page, correction orthographiques, effets divers) sont infiniment plus l’exécution6 !

riches qu’un simple éditeur qui se borne à enregistrer les caractères
que l’on tape au clavier pour les inscrire dans un fichier texte sur le 6 il existe des environnements intégrés, en particulier sous Win-
disque dur. dows, dans lesquels ces étapes sont plus ou moins automatiques et
Le fortran est le premier de ces langages évolués à commencent à être disponibles en libre diffusion et il n’y
avoir vu le jour, mais beaucoup d’autres ont suivi : algol, a donc guère de raison de s’en priver. Des « nouvelles
cobol, pl1, basic, pascal, forth, C, ada, occam. . . du front » ainsi que des compilateurs téléchargeables,
Pour ce qui est de la programmation scientifique, outre peuvent être obtenus via le site :
fortran, seul le langage C semble survivre. http ://programming.ccp14.ac.uk/fortran-resources/~
Le sigle fortran signifie « formula translator » (tra- cgp/fortran.html
ducteur de formules) : l’idée est donc de coder des formules Dans les notes qui suivent, nous suivrons le « format
de façon aussi proche que possible de ce que l’on fait lors- libre » (ou free form) qui permet de s’affranchir de l’obliga-
qu’on écrit des équations à la main et de traduire ceci en tion de s’en tenir aux colonnes 7 à 72 comme au bon vieux
instructions exécutables par l’ordinateur. C’est à première temps des cartes perforées. . . Les compilateurs s’en acco-
vue une gageure, mais, en fait, fortran est un langage modent en principe sans problème encore que quelques
simple, bien adapté au calcul scientifique. Mis au point facéties soient possible : on peut alors tenter d’utiliser
dans sa première version par John Backus en 1956, il n’a l’option de compilation -ffree-form, voire lire le manuel
pas cessé d’évoluer depuis et ses variantes sont nombreuses d’utilisation du compilateur. . .
tant les façons de programmer ont évolué. En effet, les La compilation s’effectue par la commande :
moins jeunes de vos enseignants ont appris le fortra- g95 monboprog.f90 -o monboprog
nIV et ont travaillé avec des cartes perforées : ils ont bien monboprog.f90 (ou tout autre nom se terminant par
sûr des anecdotes à raconter sur des paquets de cartes .f90) est le fichier, dit « fichier source » créé avec un
s’échappant de leur carton et se répandant sur le sol ou de éditeur comme emacs, qui contient toutes les instruc-
cartes abı̂mées après de nombreux usages (après tout, il ne tions écrites en fortran10 . L’option -o (pour output )
s’agissait que de morceaux de papier bristol) se coinçant indique au compilateur où il doit placer le résultat de
dans le lecteur et dont il fallait aller chercher les débris son travail, ainsi le fichier monboprog contient le pro-
avec une pince à épiler ! Le bruit des machines à perfo- gramme exécutable, c’est-à-dire sa traduction en langage
rer7 a marqué un certain nombre de générations de pro- machine11 . Evidemment, si l’on utilise un autre com-
grammeurs. . . À la fin des années soixante-dix et au début pilateur que g95 (par exemple gfortran12, pgf9013 ou
des années quatre-vingt, les cartes perforées disparurent, xlf9014 ), il faut remplacer g95 par le nom du compila-
remplacées d’abord par des télétypes puis par l’ensemble teur.
écran-clavier que nous connaissons maintenant. Le résultat de la compilation est donc, quand tout s’est
Le fortranIV avait bien des défauts. Il comportait bien passé, un programme exécutable qu’il reste à faire
des instructions (go to et if « arithmétique ») capables travailler, mais en général, au premier essai, il reste des er-
de produire des logiques échevelées, bondissant d’un bout reurs de programmation que le compilateur détecte : il faut
à l’autre du programme en des itinéraires dignes d’un alors corriger le programme-source en tenant compte des
plat de spaghettis : autant dire que ce n’était pas très diagnostics fournis par le compilateurs et re-compiler. . .
lisible et générateur d’erreurs retorses. Entre-temps, les jusqu’à ce que ça marche ! (figure 2.2).
idées liées à la programmation dite « structurée » s’étaient
développées, incarnées entre autres par le langage pascal,
et le fortran a intégré une bonne part de ces concepts. 2.2 Notions élémentaires.
Deux normes officielles de fortran coexistent actuel-
lement : fortran77 qui reste assez classique et for-
2.2.1 Instructions.
tran90 (ou fortran95 quasiment identique), beaucoup Une instruction très simple de fortran peut être par
plus évolué, qui est appelé à le remplacer progressivement exemple :
et qui constitue la norme sur les gros calculateurs dédiés
a = b + c
aux calculs lourds.
Nous utiliserons ici la norme fortran95, principa- elle signifie :
lement pour sa capacité à travailler sur des tableaux 1. que l’on désigne par a, b et c trois emplacements dans
de nombres de façon très confortable et efficace8 . Le la mémoire vive de l’ordinateur,
compilateur g77 qui fait partie de toutes les distributions
2. que l’on prend le contenu des emplacements b et c,
Linux, librement diffusé par gnu (Le mot anglais gnu
désigne le gnou, une espèce de buffle, et le sigle gnu 3. que l’on en fait la somme (cela suppose qu’il s’agit de
signifie : GNU’s Not Unix, un exemple d’autoréférence nombres)
typique d’un certain humour informatique), est basé Linux (Debian et Fedora au moment où ces lignes sont écrites) et,
sur fortran77, mais il intègre un grand nombre de convenablement installé, il paraı̂t plutôt plus efficace à condition
caractéristiques de fortran90 ce qui en fait un outil d’utiliser l’option -ffast-math.
10 certains compilateurs fortran90 exigent que le nom du fichier
puissant tout en gardant une grande simplicité. Toutefois,
source se termine par .f. Pour d’autres, la terminaison .f signifie
de bons compilateurs fortran95 (g95 et gfortran9) « format fixe » et la terminaison .f90, « format libre »
11 On peut fabriquer une commande personnelle de compilation,
donc quasiment invisibles. par exemple en créant un fichier appelé gf95 dans lequel on met la
7 Il y eut aussi l’étape ruban perforé qui permettait, avant les ligne : g95 $1.f90 -o $1. Ce fichier peut alors être rendu exécutable
bandes, disquettes et autres supports magnétiques, d’enregistrer des par la commande : chmod +x gf95. Pour compiler un programme, il
données : cet engin était -justement- surnommé « la mitrailleuse » ! suffira dorénavant de taper : gf95 monboprog. Selon les besoins, gf95
8 Les programmes écrits en fortran77 peuvent être compilés avec peut être modifié ensuite pour inclure d’autres options de compila-
un compilateur fortran95. tion comme -O3 (optimisation) ou des bibliothèques de calcul.
9 Le 12 version gnu.
compilateur g95 est aisément téléchargeable sur
http ://g95.org/. Le compilateur gnu gfortran commence à 13 compilateur commercial de Portland Group.
être disponible comme faisant partie de certaines distributions 14 compilateur ibm.

Edition : emacs monboprog.f90 & Tab. 2.3 – Qu’est-ce qu’un système d’exploitation ?
On doit, on l’a vu, mettre dans la mémoire vive de l’ordinateur
le ou les programmes que l’on utilise ainsi que les données cor-
respondantes. C’est une des tâches du système d’exploitation :
quand, sous unix, on tape le nom d’un programme, un autre
Compilation : g95 monboprog.f90 −o monboprog programme (ou plusieurs autres programmes) qui fait partie du
système d’exploitation, lit les caractères que l’on tape sur le cla-
vier, au passage reproduit ces caractères sur l’écran, puis va lire
le fichier exécutable au bon endroit sur le disque dur, l’installe
en mémoire et lance son exécution. Éventuellement, il fera ap-
paraı̂tre un message du genre file not found ou toute autre
Exécution : ./monboprog
chose de ce style. . . Si plusieurs programmes doivent s’éxécuter
en même temps, ou si plusieurs utilisateurs travaillent en même
temps sur le même ordinateur, c’est le système d’exploitation
qui répartira les ressources (mémoire, processeur, disque dur,
imprimantes, etc.) entre les programmes et les utilisateurs.
Fig. 2.2 – Le cycle de mise au point d’un programme : C’est aussi au système d’exploitation que l’on a à faire lorsqu’il
faut s’identifier comme utilisateur (login et mot de passe).
édition du fichier-source, compilation, exécution. La com-
Le système d’exploitation unix date du début des années 1970 ;
pilation permet de détecter les erreurs de syntaxe que l’on il a d’abord été installé sur des stations de travail « moyennes »
corrige par un retour à l’étape d’édition. À l’exécution, la mais il a rapidement envahi le monde des ordinateurs des-
prudence impose de tester le programme, en général en tiné au calcul scientifique. Le premier système d’exploitation
faisant des calculs dont on connait le résultat : les erreurs de Microsoft, dos (1981), est une version extrêmement sim-
ainsi détectées renvoient aussi à l’édition. En principe, le plifiée d’unix, en particulier, il est mono-utilisateur, alors
cycle converge assez vite. . . qu’Unix est multi-utilisateur, c’est-à-dire que plusieurs per-
sonnes peuvent utiliser simultanément le même ordinateur :
c’est particulièrement important sur les grosses machines et
4. que l’on met le résultat dans l’emplacement a. les serveurs. En 1991, Linus Torvalds créa linux, une version,
complète cette fois-ci, d’unix utilisable sur des ordinateurs per-
sonnels. Les machines utilisées pour les travaux pratiques de
a = b + c ce module tournent sous linux.

Un grosse partie de la tâche du système d’exploitation est de
gérer les périphériques, en particulier, les disques (d’ailleurs
le nom dos signifie disk operating system), car c’est là que
se trouvent les données et les programmes. Un disque dur
est en général structuré en répertoires : une partie du disque
est réservée au système d’exploitation, une autre aux utilisa-
teurs (en général home). Chaque utilisateur a son propre sous-
répertoire et souvent les utilisateurs sont organisés en groupes
(par exemple phys, math, chim,. . .). Si vous tapez par exemple
la commande pwd (print working directory), vous obtiendrez
quelque chose qui peut ressembler à :
/home/phys/enseign/depondt
c’est-à-dire que le répertoire de travail courant depondt est en
fait un sous-répertoire d’enseign, lui-même un sous-répertoire
de phys, etc. La commande ls (list) donne la liste des fichiers et
Ceci n’est pas un = sous-répertoires présents dans un répertoire. On peut créer un

répertoire (que l’on choisit d’appeler par exemple td1) par la
commande mkdir td1 (make directory) par exemple et chan-
ger de répertoire par cd td1 (change directory) : pwd donnera
Fig. 2.3 – Le signe = dans une instruction n’est pas une alors /home/phys/enseign/depondt/td1.
égalité mathématique ! Depuis le milieu des années 1980, les systèmes d’exploita-
tion comportent également les icônes et fenêtres devenues cou-
Il ne faut surtout pas s’imaginer que le signe = ci-dessus tumières : quand on clique sur une icône, on « dit » au système
soit une égalité mathématique ! Il s’agit d’une instruction, de lancer le programme correspondant au lieu de taper son nom
d’un ordre que l’on donne à l’ordinateur : on lui « dit » de sur le clavier. gnome ou kde sont des systèmes de fenêtrage
calculer la valeur numérique de ce qui se trouve à droite qui viennent se greffer sur linux, mais on peut très bien tra-
du signe égal et de le placer dans l’emplacement de la vailler sur des machines qui en sont dépourvues : c’est un peu
mémoire désigné par le symbole qui se trouve à sa gauche. moins convivial. . . mais parfois plus robuste !
On peut considérer le signe égal comme une affectation ou
une flèche :
a = b
a = b
(mettre b dans a) et
peut être compris comme
b = a
a ← b
on met b dans a. Cela a quelques conséquences pratiques, (mettre a dans b) ne signifient pas la même chose et les
ainsi deux instructions :
a = b
Tab. 2.4 – Quelques commandes Unix de base
Beaucoup de choses peuvent être faites sous Unix en cliquant alors, a, b et c contiennent la valeur 3. . . Il s’agit donc bien
sur des icônes : les gestionnaires de fenêtre tels que kde ou de deux instructions exécutées l’une après l’autre dans
gnome sont devenus très similaires à Windows ou MacOS. l’ordre donné dans le programme. Finalement, l’instruc-
Il est bon cependant de connaı̂tre les commandes de base tion :
d’Unix, d’une part parce que les icônes sont loin d’être ca-
pables de tout faire et de l’autre, il est souvent sensible- i = i + 1
ment plus rapide de taper une commande dans un ter- n’a rien d’absurde : il s’agit simplement de l’ordre d’aug-
minal que de déployer tout l’arsenal, graphique en par- menter la valeur de i de 1 (on prend i, on lui ajoute 1 et
ticulier, qui accompagne les gestionnaires de fenêtres et on met de résultat dans i). En revanche :
d’icônes et qui est généralement gourmand en ressources.
mkdir make directory créer un répertoire a + b = 3*x + c ! ATTENTION, CECI N’A AUCUN SENS
pwd print working directory nom du répertoire courant
cd change directory changer de répertoire est totalement dépourvu de sens pour l’ordinateur car l’ex-
cp copy copier des fichiers, pression a + b à gauche du signe = ne désigne pas un em-
rm remove effacer des fichiers placement dans la mémoire. . . pire encore :
mv move déplacer un fichier
more more voir le contenu d’un a = b = c ! CA NE PLAIRA PAS DU TOUT AU COMPILATEUR
fichier texte.
lpr line printer imprimer à droite du premier signe =, il y a une expression b = c qui
a2ps ASCII to postscript imprimer un fichier texte ne peut pas être évaluée, puisque ce n’est pas une valeur,
emacs éditeur de texte c’est une instruction !
g95 compilateur fortran
man manual manuel en ligne
Par exemple : cp machin nouveau machin crée un fichier qui
2.2.2 Déclarations.
est la copie de machin. On peut déplacer ou copier d’un Tout ceci suppose cependant que l’on ait déjà « dit »
répertoire à un autre : mv td1/prog.f td2 déplacera le fichier à l’ordinateur que a, b et c sont des emplacements de
prog.f du répertoire td1 au répertoire td2. la mémoire destinés à contenir des nombres, par exemple
La plupart des commande ont des options marquées par un des nombres réels : c’est ce qu’on appelle une déclaration.
tiret -, par exemple : g95 prog.f90 -O3 -o prog utilise deux Ainsi la déclaration :
options (optimisation, et nom du fichier de sortie), ou : lpr
-Ppr1 figure.ps précise sur quelle imprimante l’impression real :: a, b, c
doit se faire. Pour trouver les possibilités d’une commande et
les options qu’elle peut utiliser : man nom de commande. déclare que l’on va occuper trois emplacements mémoire
Finalement, le répertoire courant est marqué par un point : . dorénavant appelés a, b et c et que l’on mettra des nombres
et le répertoire situé au-dessus du courant par deux points : réels dedans15 . Comme on peut changer la valeur du
.., ainsi cd . ne fait rien, mais cd .. remonte d’un cran dans contenu de ces emplacements, on les appelle variables. Un
la hierarchie des fichiers. Si l’on veut copier un fichier d’un nom de variable peut être simplement une lettre comme
autre répertoire vers le répertoire courant, on peut faire, par a ou x, ou alors une combinaison de lettres et de chiffres
exemple, un cp /home/machin/truc/fichier origine . , où à condition de commencer par une lettre, par exemple :
le point “.” est la destination de la copie. agecpt, y2, zmax, mais pas : 2pi ou s*3 (* est un ca-
ractère spécial désignant la multiplication). Le caractère
Tab. 2.5 – Le BIOS ou Basic Input/Output System. “ ” « blanc souligné » ou underscore est également auto-
Le BIOS est un programme qui est directement installé par le risé : pere ubu ou nbr pas. La longueur peut aller jusqu’à
constructeur sur la carte-mère (c’est-à-dire la carte qui com- 31 caractères : age du capitaine. Il ne faut pas utiliser
porte le processeur, la mémoire vive, etc.) de l’ordinateur et les lettres accentuées, cédilles, trémas, et autres signes dia-
qui peut donc démarrer dès la mise sous tension alors qu’au- critiques. Enfin, fortran ne fait pas la distinction entre
cun périphérique n’est encore opérationnel. C’est lui qui, après lettres majuscules et minuscules (Zmin est identique à
avoir identifié les périphériques disponibles, charge le système zmin) alors que le système d’exploitation unix le fait (les
d’exploitation qui se trouve, lui, généralement sur le disque fichiers resultats et Resultats sont distincts).
dur, un CD, voire une disquette ou une autre machine acces- On peut déclarer des nombres entiers, par exemple :
sible par réseau.
integer :: i, m, nbrpas
a = b ou des nombres complexes :

b = c
complex :: z, s
ne signifient pas que les trois nombres a, b et c soient
égaux ! Cela signifie : « prendre le contenu de l’emplace- Toutes les déclarations doivent figurer au
ment désigné par la lettre b et le mettre dans a, puis mo- début du programme, avant les instructions dites
difer le contenu de b en y mettant le contenu de c ». Donc, « exécutables ». Une instruction du type a = 3*b - c
après coup, a et b peuvent être différents. De même, l’ordre avec laquelle on « dit » à l’ordinateur de faire quelque
des instructions a une importance : mettons que l’on ait chose est exécutable, une déclaration où l’on réserve de
affecté les valeurs, respectivement, 1, 2 et 3 à a, b et c. Les l’espace pour des variables ne l’est pas.
deux instructions ci-dessus aboutiront à avoir 2 dans a et
3 dans b et c. Mais si l’on intervertit les instructions : 15 On utilise ici la forme fortran90 destinée à prendre assez rapi-
dement le relais de la forme fortran77 : real a, b, c, également

b = c acceptée par g95.
L’affectation de valeurs initiales à certaines variables

Tab. 2.6 – Liste des types de variables : peut être faite directement dans la déclaration :
déclaration type des variables
integer entier program addition
real réel implicit none
double precision réel en double précision real :: a, b = 1.414, c = 1.732
a = b + c
complex complexe
write(*,*) a
double complex complexe en double précision end
character chaı̂ne de caractères
logical variable logique L’instruction end marque la fin du programme. L’ins-
truction program donne un nom au programme qui peut
être distinct du nom du fichier-source qui le contient.
En fortran, il existe ce que l’on appelle des
déclarations implicites, survivance des anciennes versions
de ce langage de programmation, qu’il est formellement Tab. 2.7 – Liste des opérations sur les nombres :
déconseillé d’utiliser16 . Pour les rendre inopérantes, on uti-
lise l’instruction : L’addition s’écrit : + e.g. : a + b
La soustraction s’écrit : - e.g. : 3. - x
implicit none La multiplication s’écrit : * e.g. : a*b
La division s’écrit : / e.g. : p/q
2.2.3 Opérations élémentaires sur les La mise à la puissance s’écrit : ** e.g. : x**p
nombres.
Un programme élémentaire pourrait donc être : On peut mélanger les types integer, real, double
precision, complex et double complex au sein de la
program addition ! DEBUT DU PROGRAMME
même expression. Ainsi :
implicit none ! PAS DE DECLARATIONS IMPLICITES
real :: a, b, c ! DECLARATION DE 3 VARIABLES REELLES complex :: z, t
! DEBUT DES INSTRUCTIONS EXECUTABLES integer :: k = 392
b = 1.414 ! PLACER LA VALEUR 1.414 DANS b real :: x = 1.03 , y = 0.707
c = 1.732 ! PLACER LA VALEUR 1.732 DANS c z = (3.7,9.03)
a = b + c ! SOMMER & PLACER LE RESULTAT DANS a t = x**2 + (k-1)/z**y
write(*,*) a ! IMPRIMER LE CONTENU DE a
end ! FIN DU PROGRAMME calcule x2 + k −y 1 . Le résultat est un nombre complexe.
z
Noter qu’un nombre complexe s’écrit en donnant parties
qui calcule la somme de 1,414 et 1,732 et imprime le
résultat (instruction write). Il faut noter que le passage réelle et imaginaire entre parenthèses et séparées par une
à la ligne signifie la fin d’une instruction, à la différence virgule.
d’autres langages comme pascal ou C. On peut cepen-
dant écrire plusieurs instructions par ligne en les séparant
par un point-virgule, ainsi : 2.3 Premières boucles.
program addition 2.3.1 Pour quoi faire ?
implicit none
real :: a, b, c L’une des grandes qualités des ordinateurs est leur ca-
b = 1.414 ; c = 1.732 ; a = b + c pacité à effectuer des calculs répétitifs avec des valeurs
write(*,*) a numériques différentes. Imaginons par exemple que l’on
end veuille calculer x3 pour x variant de -10 à +10 par pas de
0,1. On pourrait bien sûr écrire :
La décimale des constantes réelles est marquée par
implicit none
un point et non une virgule (1.414 et non 1,414). Une
real :: x = -10.0, y
constante réelle doit comporter un point : 1. est une y = x**3
constante réelle, mais 1 est une constante entière, 2./3. x = x + 0.1 ; y = x**3
est une constante réelle qui vaut 0,666667, alors que 2/3 x = x + 0.1 ; y = x**3
est une constante entière, résultat de la division du nombre x = x + 0.1 ; y = x**3
entier 2 par le nombre entier 3, elle vaut donc zéro ! x = x + 0.1 ; y = x**3
On peut aussi utiliser la notation dite « scientifique » x = x + 0.1 ; y = x**3
(comme avec une calculette) pour les nombres réels, ...
1, 6 10−19 s’écrit : 1.6e-19, c’est plus économique qu’ali- etc. L’instruction x = x + 0.1 prend la valeur de x en
gner de nombreux zéros. . . La lettre e ne désigne pas ici mémoire, lui rajoute 0,1 et écrit le résultat dans le même
une variable mais indique l’exposant17 . emplacement : le contenu de x est donc augmenté de 0,1.
16 La raison en est que si l’on fait une faute de frappe en tapant le Donc, x commence par valoir -10, puis −10 + 0, 1 = −9, 9
nom d’une variable (par exemple nb pas au lieu de nbr pas), l’ordi- et l’on calcule y, puis 9,8 avec un nouveau calcul de y, etc.
nateur créera simplement une nouvelle variable, avec des résultats. . . On remarque cependant que la séquence :
imprévisibles ! Si l’on rend obligatoire la déclarations de toutes les
variables, alors le compilateur détectera en principe une variable x = x + 0.1 ; y = x**3
non-déclarée et produira un message d’erreur approprié.
17 on peut parfaitement écrire une instruction du type : e = doit être répétée autant de fois que l’on veut faire le calcul
1.6e-19, il n’y a aucune confusion possible. (ici, 201 fois).
2.3.2 Pratiquement. . . 2.3.3 Boucles imbriquées

Une façon plus élégante de procéder consiste à utiliser Les boucles peuvent être imbriquées les unes dans les
une boucle afin de répéter un grand nombre de fois le même autres :
calcul en faisant varier un paramètre, ainsi :
implicit none
integer :: i do k = kmin, kmax
real :: x, y ...
do i = -100, 100 do ix = ixmin, ixmax
x = 0.1*i ...
y = x**3 enddo
enddo ...
enddo
signifie que l’instruction y = x**3 doit être répétée pour
toutes les valeurs de l’indice i allant de -100 à 100 :
ainsi, la boucle interne sur x s’exécutera pour chaque va-
ainsi x prend successivement les valeurs -10., -9.9, . . .-
leur de k et les instructions qu’elle comporte se répéteront
0.1, 0., 0.1,. . .9.9, 10.18 et l’on doit calculer y pour cha-
donc (kmax-kmin+1)*(ixmax-ixmin+1) fois : cela peut
cune de ces valeurs. L’instruction enddo marque la fin du
faire beaucoup. Par exemple, si kmax=1000, kmin=1,
« bloc » : toutes les instructions comprises entre do et
ixmax=10000, ixmin=1, la boucle interne s’exécutera 107
enddo font partie du même ensemble qui doit être exécuté
fois, et si elle prend 10−3 seconde à l’exécution, le pro-
pour chaque valeur de i.
gramme, lui, prendra 104 s soit 2h45mn ! Si maintenant, la
Il faut remarquer au passage qu’à chaque tour de la
boucle la variable y est modifiée et que donc les anciennes boucle externe est elle-même imbriquée dans une autre
valeurs sont oubliées : à la fin, seule la dernière valeur boucle, on obtient très facilement un programme très
calculée reste. Il faut donc penser à faire quelque chose lourd. . .
des valeurs intermédiaires si on en a besoin : les écrire par
exemple. Ainsi,
implicit none 2.3.4 Boucles munies d’un nom
complex :: z, zim=(0.0,1.0)
integer :: i Quand plusieurs boucles sont imbriquées, il est parfois
real :: omega = 6.283185, t utile de leur donner un nom afin de clarifier le début et la
do i = 0, 1000 fin de chacune :
t = 0.1*i
z = exp(zim*omega*t) ; write(*,*) t, z
enddo boucle1 : do k = kmin, kmax
...
va calculer z = eiωt pour t variant de 0 à 100, par pas de ...
0, 1 et écrire les résultats sur l’écran. Noter la déclaration boucle2 : do i = imin, imax
du nombre imaginaire i dans la variable zim, dont la partie ...
réelle est nulle et la partie imaginaire égale à 1. ...
Un autre exemple : enddo boucle2
...
implicit none
...
integer :: k, s2 = 0
enddo boucle1
do k = 1, 10
s2 = s2 + k**2
enddo
calcule la somme des 10 premiers carrés. 2.4 Conditions.
Le pas de la boucle est implicitement égal à 1, mais on
peut le choisir explicitement :
Il arrive que l’on veuille que certaines instructions ne
do k = 1, 10, 2 s’exécutent que dans certaines conditions. Par exemple, si
s2 = s2 + k**2 l’on a calculé une quantité y, on peut en vouloir la racine
enddo carrée uniquement si y est positif :
calcule la somme 12 + 32 + 52 + 72 + 92 , et :
do k = 10, 1, -1 if( y > 0.0 ) then
... z = sqrt(y)
enddo endif
descend de 10 à 1.
Note « esthétique » : les instructions du bloc compris La fonction sqrt qui calcule la racine carrée (square root)
dans la boucle sont décalées d’une ou plusieurs colonnes, est dite « intrinsèque » parce qu’elle fait partie des fonc-
c’est l’indentation. Cela ne présente aucun caractère obli- tions que tout compilateur fortran doit fournir.
gatoire et ne fait pas partie des règles du langage, mais L’expression y > 0.0 est du type logique, cela signifie
c’est une bonne habitude qui rend la lecture des pro- qu’elle ne peut prendre que deux valeurs : .TRUE. (vrai)
grammes nettement plus facile. si y > 0 et .FALSE. (faux) si y ≤ 0.
18 On note au passage que l’expression 0.1*i mélange une Deux écritures sont possibles pour les opérateurs lo-
constante réelle et un entier : le résultat est réel. giques, première et deuxième colonnes ci-dessous :
> .gt. > (greater than) if( y < 0.0 ) write(*,*) ’y est negatif !’
< .lt. < (less than) z = sqrt(y)
>= .ge. ≥ (greater or equal )
<= .le. ≤ (less or equal ) Ici, on se borne à mettre un message d’avertissement, mais
== .eq. = (equal ) l’instruction suivante s’exécutera de toutes façons et le
/= .ne. 6 = (not equal ) programme donnera la valeur NaN (Not a Number ) à z.
.and. et On peut aligner autant de else if que l’on souhaite19 .
Cependant si l’on a une série de possibilités à envisager,
.or. ou
l’instruction select case20 peut être plus commode. Par
.not. contraire d’une expression logique exemple :
Ne pas oublier les points de part et d’autre des implicit none
opérateurs logiques de la deuxième colonne. L’opérateur integer :: a
logique == qui est une comparaison, est distinct du signe write(*,*) ’entrer un nombre’; read(*,*) a
« d’égalité » = qui signifie en fait « mettre quelque chose select case( a )
dans une variable ». L’expression : case( : 1 )
write(*,*) ’a est plus petit ou egal a 1’
a == b
case( 10 : )
est une expression logique qui prend une valeur, soit vraie write(*,*) ’a est plus grand ou egal a 10’
soit fausse, et case (2 : 3 )
write(*,*) ’a est entre 2 et 3’
a = b case default
write(*,*) ’a est entre 4 et 9’
est une instruction qui place la valeur de b dans a. . ., ainsi, end select
end
integer :: a, b
logical :: ok Un autre exemple, pour convertir des unités anglo-
ok = a == b saxonnes en unités métriques :
signifie que la variable logique ok prend la valeur .TRUE. program metre
si a et b sont égaux et .FALSE. sinon. implicit none
On peut aussi utiliser des variables logiques de façon real, parameter :: c = 0.3048, kt = 1.852, &
plus compliquée : mph = 1.609, &
gallon = 3.7854118, lbs = 0.45455
logical :: ok real :: l
real :: x, y character(len=10) :: unit
...
... ! le premier argument de la ligne de commande est la
ok = y > 0.0 .and. x <= y ! quantite, le deuxieme l’unite.
if (.not. ok ) then ! s’il n’y a pas deux arguments, poser la question
write(*,*) ’Il y a un probleme quelque part’ ! explicitement
stop if ( command_argument_count() >= 2 ) then
endif call get_command_argument(1,unit)
read(unit,*) l ! convertir la chaine de caracteres
L’instruction stop arrête l’exécution du programme. ! en reel (cf ’chaines de caracteres’)
On peut prévoir une alternative : si une condition est call get_command_argument(2,unit)
vérifiée, on fait une chose, sinon on fait autre chose : else
if( y >= 0.0 ) then write(*,’("Entrer la longueur et l’’unite ",$)’)
z = sqrt(y) read(*,*) l, unit
else endif
write(*,*) ’y est negatif’ select case(trim(unit))
stop case (’ft’,’feet’,’foot’,’pieds’,’pied’)
endif write(*,*) l*c,’ metres’
case (’in’,’inch’,’inches’,’pouces’,’pouce’)
Le deuxième volet de l’alternative peut être lui-même sou- write(*,*) 1000.*l*c/12.,’ mm’
mis à condition : 19 Pour bien apprécier le confort (et la sécurité) qu’apporte la
if( y >= 0.0 ) then structure if(...) then, il faut rappeler le fonctionnement du if
arithmétique en usage dans les premières version du langage for-
z = sqrt(y) tran :
else if ( y > -0.0001 ) then if(k) 100,101,102
write(*,*) ’y est compris entre -0.0001 et 0.0 :’ 100 ....
write(*,*) ’on le considere comme presque nul’ go to 103
z = 0. 101 ....
else go to 103
102 ...
write(*,*) ’y est franchement negatif’
103 ...
stop ce qui signifie que si k est négatif, l’on va à l’étiquette 100, si k est
endif nul, alors on va en 101 et sinon en 102, après quoi, l’instruction située
en 103 est exécutée. Bien évidemment, rien n’empêche, par exemple,
Si l’on n’a qu’une instruction à exécuter dans le if, on un go to 101 n’importe où ailleurs dans le programme. . .
peut la fusionner dans l’instruction if : 20 héritière du go to calculé d’antan.
case(’m’,’metres’) program racines

write(*,*) l/c,’ ft’ implicit none
case(’kt’,’kts’,’knots’,’noeuds’) real :: xmin, xmax, dx, x, y
write(*,*) l*kt,’ km/h’ integer :: i, imin, imax
case(’nm’) write(*,*) ’** Ce programme calcule **’
write(*,*) l*kt,’ km’ write(*,*) ’** une serie de racines carres **’
case(’mph’) write(*,*) ’Tapez sur le clavier’
write(*,*) l*mph,’ km/h’ write(*,*) ’les valeurs de xmin et xmax :’
case(’mile’,’miles’) read(*,*) xmin, xmax
write(*,*) l*mph,’ km’ write(*,*) ’Donnez egalement le pas :’
case( ’gal’, ’gallon’, ’gallons’) read(*,*) dx
write(*,*) l*gallon, ’l’ imin = xmin/dx ; imax = xmax/dx
case(’lbs’, ’lb’, ’pound’, ’pounds’,’livre’, ’livres’)do i = imin, imax
write(*,*) l*lbs, ’kg’ x = i*dx
case default if( x < 0.0 ) then
write(*,*) ’unite inconnue’ write(*,*) ’x est negatif : x=’, x
end select else
end y = sqrt(x)
write(*,*) ’la racine carree de ’,x, ’ est ’, y
de sorte que l’on obtient, par exemple : endif
~$ metres 175 lbs enddo
79.54625 kg end
2.5 Entrées-sorties. 2.5.2 Les fichiers.

2.5.2.1 Fichier texte
Il s’agit des instructions d’écriture et de lecture.
Ce que l’on écrit sur l’écran disparaı̂t assez rapidement.
Si l’on veut conserver des résultats de calcul afin de les
2.5.1 Écran et clavier. relire ou les traiter avec un autre programme ou encore
L’instruction : les utiliser pour tracer une courbe, il faut les écrire dans
un fichier du disque dur de l’ordinateur. Pour cela, il faut
write(*,*) x commencer par « dire » que l’on veut écrire dans un fichier
avec l’instruction open :
écrit sur l’écran du terminal la valeur de x. Si x vaut
3,14159, on obtiendra 3.14159. En revanche : open(1,file=’resultats’)
write(*,*) ’x’ Ainsi, on fait le lien entre le fichier resultats et l’unité

1 : maintenant, si l’on écrit dans cette unité, cela revient
écrira la lettre x sur l’écran, puisque ’x’ désigne une à écrire dans ce fichier, par exemple :
chaı̂ne de caractères. Par exemple :
open(1,file=’resultats’)
write(*,*) ’x=’, x write(1,*) x, y
write(1,*) ’Age du capitaine = ’, agdcpt
donnera : x= 3.14159, l’ordinateur commence par écrire
la chaı̂ne de caractères x=, puis la valeur de la variable x. écrit dans le fichier resultats.
L’instruction : Lorsqu’on a fini d’écrire on « ferme » le fichier à l’aide
de
read(*,*) x
close(1)
lit sur le clavier du terminal la valeur de x. Ainsi :
Ce que l’on obtient est un fichier texte que l’on peut
read(*,*) x lire et modifier (sous unix et non dans le programme
write(*,*) ’Vous venez de taper x=’, x lui-même) à l’aide d’un éditeur comme emacs ou vi, par
exemple :
a pour effet que le programme arrivant à l’instruction read
s’interrompt pour attendre que l’on tape quelque chose sur emacs resultats &
le clavier, puis repart pour exécuter l’instruction suivante.
Le premier * dans (*,*) après read et write représente ou bien, si l’on souhaite seulement le lire sans en modifier
l’unité d’écriture ou de lecture, c’est à dire l’endroit où le contenu :
l’on écrit ou où l’on lit : il s’agit du clavier à la lecture et more resultats
de l’écran à l’écriture. Le deuxième représente le format,
c’est-à-dire, par exemple pour un nombre réel, le nombre Si, dans un même programme, l’on fait plusieurs
de colonnes qu’il doit occuper et le nombre de chiffres après écritures à la suite les unes des autres, elles se placeront
la décimale : on peut le préciser explicitement, mais en les unes derrière les autres dans le fichier tant que l’on ne
général le format * (list directed format en anglais ou : ferme pas le fichier avec un close. Mais, si après un close,
format contrôlé par la liste [des arguments]), où l’ordina- l’on refait un open sur le même fichier, on se retrouve au
teur doit se débrouiller avec ce qu’on lui fournit, convient début de celui-ci et une nouvelle écriture va donc écraser
très bien. ce qui s’y trouvait déjà : prudence !
Voici donc un programme qui résume ce qui précède : La lecture dans un fichier se fait de la même façon :
open(10, file=’donnees’) 2.5.3 Les formats.

read(10,*) a, b, c
close(10)
Pour une écriture en mode texte, fichier ou écran, on
peut préciser la façon dont on veut que les choses soient
On peut ouvrir plusieurs fichiers simultanément à condi- écrites. Ainsi,
tion de leur donner des numéros d’unité différents :
write(*,’(i5)’) k
open(10, file=’coefficients’) écrira le nombre entier (i pour integer ) k avec 5 chiffres.
open(11, file=’bornes’) On notera la syntaxe : la deuxième * du write est rem-
open(12, file=’polynome’) placée par : ’(...)’ où les trois points désignent la des-
read(10,*) a, b, c cription du format. De même :
read(11,*) xmin, xmax, dx
imin = xmin/dx ; imax = xmax/dx write(*,’(f10.3)’) r
do i = imin, imax
doit écrire le nombre réel (f pour float, c’est-à-dire à
x = i*dx
décimale flottante) r avec 10 caractères (y compris le point
y = (a*x + b)*x + c
de la décimale) dont 3 après la « virgule » : 123456.789 ou
write(12,*) x, y
1.414 (avec 5 espaces, représentés ici par le symbole
enddo
, pour compléter). Si l’on doit écrire plusieurs nombres
close(10) ; close(11) ; close(12)
à la suite de la même façon, il n’est pas utile de répéter
end
explicitement le format, il suffit de le faire précéder du
Caveat ! Imaginons que l’on ait écrit un programme nombre de fois que l’on veut l’utiliser :
dans un fichier-source calcul.f90. On compile avec la write(*,’(3f12.4)’) x,y,z
commande habituelle et on lance l’exécution. . ., or dans le
programme, il y a les instructions : écrira trois nombres réels sur 12 caractères (soit 36 co-
lonnes en tout, sachant qu’une feuille de papier ou un ter-
open(10,file=’calcul.f90’)
write(10,*) x, y, z minal font en général 80 colonnes) avec chacun 4 chiffres
close(10) après la décimale, par exemple :
1234567.8912 3.14161048576.4321
Question : qu’arrivera-t-il au programme-source ? attention, dans cet exemple, il y a bien trois nombres,
Ce sont des choses que l’on voit régulièrement arriver, mais le dernier occupe les 12 colonnes, et donc, il n’y a
au grand désarrois des victimes, car il ne reste plus alors pas d’espace qui le sépare du précédent.
qu’à tout retaper même si calcul.f90 comportait des cen- On peut mettre des chaı̂nes de caractères dans un for-
taines de lignes ! Un homme - ou une femme - prévenu(e) mat :
en vaut deux. . . write(*,’("L’’age du capitaine est : ")’)
write(*,’(i2," ans")’) age_captain
2.5.2.2 Fichier binaire
Dans ce cas, il vaut mieux, bien sûr, que le capitaine ne
L’écriture d’un fichier texte suppose que les nombres soit pas centenaire. . . Noter que l’apostrophe doit être re-
qui sont stockés en binaire dans la mémoire vive de l’or- doublée (sinon le compilateur interprête cela comme la fin
dinateur soient traduits du binaire en caractères alpha- de la chaı̂ne de caractères).
numériques : par exemple le nombre entier 19 s’écrit 10011 Le format exponentiel ( ou « notation scientifique ») est
en binaire et doit être converti en un caractère 1 suivi du une autre possibilité pour les réels, par exemple :
caractère 9 avant d’être écrit comme du texte. Il arrive ev =1.6e-19
que l’on ait à produire un très grand nombre de nombres write(*,’("eV=",e13.5)’) ev
et que cette conversion prenne un temps de calcul non
négligeable, sans compter la taille du fichier résultat. Dans donne : eV= 0.16000E-18, soit 13 caractères, dont 5
ce cas, on peut avoir intérêt à écrire directement du code après la virgule. Le format g (général) combine f et e
binaire dans le fichier. Evidemment, dans ces conditions on x = 1. ; ev = 1.6e-9
ne peut plus lire ce fichier avec un éditeur ou l’imprimer write(*,’("x=",g13.5," eV = ",g13.5)’) x, ev
sur une imprimante, mais cet inconvénient n’est pas très
important dans le cas présent : qui irait lire directement un donne : x= 1.00000 eV = 0.16000E-08. C’est assez
fichier de plusieurs centaines de kilo-octets de nombres ? commode lorsqu’on veut écrire des nombres dont on ne
Le but ici est de stocker des données en vue d’une utilisa- connait pas a priori l’ordre de grandeur, tout en contrôlant
tion ultérieure à l’aide d’un autre programme21. la place qu’ils prendront pour une mise en page.
La lettre x dans un format signifie un espace, le symbole
Lors de l’ouverture, il suffit de spécifier que le fichier
/ un passage à la ligne. Au contraire, $ inhibe le passage
doit être « non-formatté » : à la ligne après un write. Par exemple :
open(1,file=’nfich binaire’,form=’unformatted’)
Les instruction d’écriture et de lecture se passent alors write(*,’("Donnez l’’age du capitaine : ",$)’)
de spécification de format : read(*,*) agecpt
write(1) x, y, z Lors de l’exécution du programme, la question et la
read(1) a, b, c réponse apparaı̂tront sur la même ligne du terminal.
21 Il faut aussi signaler qu’un tel fichier est moins transportable Les chaı̂nes de caractères peuvent s’écrire avec le format
qu’un fichier texte : le codage binaire dépend du processeur et si l’on a:
veut utiliser des données sur une autre machine que celle où elles ont
été produites (par exemple un gros calculateur vers un PC linux), salut = "Bonjour"
alors il est parfois indispensable de passer par l’étape texte. write(*,’(a7)’) salut
2.6 Les fonctions intrinsèques. 2.7 Autres boucles.

fortran fournit un grand nombre de fonctions in- 2.7.1 do while
trinsèques comme sqrt déjà vu et qui permet de calculer
la racine carrée de son argument. La boucle do while permet des logiques plus com-
En voici quelques unes : pliquées que celles qu’on a déjà vues, par exemple :
sqrt racine carrée open(1,file=’donnees’)
abs valeur absolue read(1,*) x
exp exponentielle do while ( x > 0. )
log logarithme write(*,*) ’La racine de’,x,’ est’, sqrt(x)
log10 logarithme décimal read(1,*) x
sin sinus enddo
asin arcsinus close(1)
cos cosinus
acos arccosinus va lire des valeurs de x dans le fichier tant que la dernière
tan tangente valeur de x reste positive, et à la première valeur négative
atan arctangente trouvée, l’on passera à l’instruction close.
int troncature d’un réel en entier –Exercice : trouver pourquoi l’on a mis le write avant
nint arrondi d’un réel (nearest integer ) le read.
real partie réelle d’un nombre complexe L’avantage de ce type de boucle est que l’on peut faire
aimag partie imaginaire d’un nombre complexe des choses assez sophistiquées ; c’est séduisant, souvent ef-
ficace, mais parfois dangereux, ainsi :
conjg conjugué d’un nombre complexe
trim troncature d’une chaı̂ne de caractères implicit none
après le dernier non-blanc real :: x, dx = 0.1
len trim nombre de caractères de la chaı̂ne tronquée ....
Par exemple : x = 1.0
do while ( x > 0.0 )
implicit none ...
real :: e0, t, omega, tfin, dt x = x + dx
integer :: it, itfin ..
... enddo
itfin = tfin/dt
do it = 0, itfin –Exercice : montrer pourquoi cette boucle va tourner
t = it*dt ; write(1,*) t, e0*cos(omega*t) indéfiniment. . .
enddo
Les arguments des fonctions trigonométriques sont en ra-
dians, donc si l’on veut travailler en degrés, il faut faire la 2.7.2 Boucles infinies : exit et cycle.
conversion :
On peut aussi faire des boucles « infinies » dont on ne
real :: pi, angle sort que grâce à exit :
pi = acos(-1.0)
write(*, ’("Donnez un angle en degres : ",$)’) do
read(*,*) angle write(*,’("Entrer un nombre positif : ",$)’)
write(*,*) ’le sinus de ’, angle,’ degres’ read(*,*) x
write(*,*) ’est ’, sin(pi*angle/180.) if ( x >= 0. ) exit
write(*,*) "Apprenez a lire !"
La différence entre int et nint est que si x vaut, par enddo
exemple 1,6, alors int(x) donne 1 alors que nint(x) y = sqrt(x)
donne 2.
On peut utiliser une fonction comme argument d’une Tant que l’on entrera des nombres négatifs, on aura droit à
autre, ainsi, par exemple, le module d’un nombre com- l’aimable invitation d’apprendre à lire, mais dès le premier
plexe z s’écrit
√ : sqrt(z*conjg(z)), la transcription de nombre positif, le programme en calculera la racine carrée.
l’expression zz ∗ . L’instruction cycle permet de répéter une boucle par-
La commande info g77 permet d’accéder, après tiellement :
quelques manipulations, à la liste des fonctions in-
trinsèques connues par g77 (il y en a beaucoup) ainsi qu’à do
leur mode d’emploi. Ces renseignements sont donnés en write(*,’("Entrer un nombre positif : ",$)’)
anglais, mais il n’est pas mauvais de se frotter de temps read(*,*) x
if ( x < 0 ) cycle
en temps à ce genre de documentation. Ces informations
y = sqrt(x)
ne sont évidemment valides en toute rigueur que pour g77,
write(*,*) ’La racine carree de’,x,’ est ’, y
toutefois les fonctions les plus usuelles sont communes ; si if( x == 0. ) exit
le compilateur utilisé ne reconnait pas une fonction sup- enddo
posée intrinsèque22 , il faut alors consulter une documenta-
tion spécifique (Fortran95/2003 explained par exemple). type réel, et realpart(z), partie réelle d’un complexe, alors que la
norme fortran95 prévoit que real prenne justement la partie réelle
22 Par exemple, g77 fait la distinction entre real(z), conversion en si son argument est complexe si bien que realpart n’existe pas.
à chaque fois que l’on tape un nombre négatif, l’on obtien- 2.7.3 Boucles implicites.
dra la requête d’un nombre positif sans que le calcul de la
Plutôt qu’écrire :
racine ne soit fait ; en revanche, si l’on entre un nombre
positif, on en obtiendra la racine, et enfin si ce nombre est do i = 1, n
nul (strictement : on verra un peu plus loin ce que cela write(1,*) x(i)
signifie) on sort de la boucle. enddo
Autre exemple : vérifier qu’un fichier existe déjà avant on peut écrire :
de tenter de l’ouvrir en lecture,
write(1,*) ( x(i), i = 1, n )
! declaration d’une chaine de 40 caracteres La différence est que dans le deuxième cas tous les éléments
! qui devra contenir le nom du fichier du tableau24 sont écrits sur la même ligne, sauf si on le
character (len=40) :: n_fic ! nom de fichier précise par format. Plus concis encore, si x est un tableau :
logical :: ok ! variable logique
write(1,*) x
do écrit tout le tableau.
write(*,’(‘‘Nom du fichier de donnees : ‘‘,$)’) On peut faire la même chose avec read.
read(*,*) n_fic ! lire au clavier le nom du fichier
! inquire est une commande FORTRAN permettant de
! verifier l’existence du fichier 2.8 Tableaux.
inquire(file=n_fic,exist=ok) ! existe: ok = .TRUE.
if ( ok ) exit ! et on n’insiste pas Les tableaux de nombres sont l’équivalent informatique
! sinon, il faut recommencer des vecteurs et des matrices : on peut ainsi désigner plu-
write(*,’(‘‘Fichier non trouve’’)’)
sieurs nombres par une seule variable ; le vecteur V de
enddo
open(10,file=n_fic) ! ouverture du fichier
dimension n désigne l’ensemble de ses n éléments vi , i ∈
... [1, n], la matrice A de dimension (n, m) désigne tous les
n × m éléments aij , le tenseur T de rang 3 désigne tous les
Les boucles infinies, assorties de exit et cycle, tendent éléments tijk , et ainsi de suite. Comme dans ces exemples,
à remplacer le do while, souvent considéré comme ob- un ou plusieurs indices entiers servent à indiquer l’élément
solète. Le until du pascal n’existe pas en fortran : voulu du tableau. Avec les tableaux, on acquiert la capa-
de fait, exit et cycle sont beaucoup plus riches, puis- cité à traiter, comme s’il s’agissait d’une seule entité, un
qu’ils peuvent être placés n’importe où dans la boucle, et grand nombre de données, pour ainsi dire « d’un coup » !
non seulement au début comme while ou à la fin comme
until23. 2.8.1 Déclaration
Si les boucles ont un nom, exit et cycle en tiennent
compte : La déclaration d’un tableau est faite en indiquant les
valeurs extrêmes des indices de chacune des dimensions
l1 : do du tableau, par exemple :
...
real, dimension(1:100) :: x
l2 : do
... déclare un tableau à un seul indice qui va de 1 à 100, c’est-
if ( age_du_capitaine < 0 ) exit l1 à-dire un tableau unidimensionnel de réels à 100 éléments
... ou un vecteur à 100 coordonnées si l’on préfère. Le i-ème
if ( ok ) cycle l2 élément est désigné par x(i) ; i est bien entendu un entier.
... Par exemple :
enddo l2 real, dimension(0:100) :: x
... real :: pi = acos(-1.0)
enddo l1 integer :: i
Le exit l1 fait sortir de la boucle l1, la plus externe, alors
do i = 0, 100
que l’instruction se trouve dans la boucle la plus interne : x(i) = cos(i*pi/100.)
ça permet de sauter par dessus un niveau d’imbrication. enddo
23 L’intérêt de ces structures est réel, toutefois pour relativiser, no-
remplit un tableau de 101 éléments avec les valeurs prises
tons qu’en fortranIV, on pouvait très bien fabriquer des logiques si-
par cos θ avec θ ∈ [0, π] par pas de π/100.
milaires à ce que permettent exit et cycle, l’esprit était simplement
moins orienté « programmation par bloc » et il fallait s’astreindre à On peut faire des déclarations du genre :
un minimum de discipline, par exemple : real, dimension(-100:100) :: x
do 100 i = 1, 1000000
... ce qui donne dans ce cas un tableau à 201 éléments dont
c ici l’equivalent d’un ‘‘cycle’’ l’indice varie de -100 à 100, et alors, on peut accéder à des
if ( x .gt. y ) go to 100
... éléments comme par exemple x(-20).
c ici l’equivalent d’un ‘‘exit’’ La déclaration real, dimension(100) :: x est
if ( z .le. 0. ) go to 200 équivalente à real, dimension(1:100) :: x25 .
... Pour les tableaux à plusieurs dimensions, il faut spécifier
100 continue
200 ...
les valeurs extrêmes de chacun des indices :
Il était prudent d’éviter de placer l’étiquette 200 à l’autre bout du 24 voir les tableaux dans la section suivante.
programme, du moins si l’on avait l’ambition d’écrire un code « main- 25 à
la différence du langage C pour lequel les tableaux commencent
tenable ». . . avec l’élément 0.
integer, dimension(1:25,-2:2) :: a integer :: i

real, dimension(-2:2) :: x=(/ (2*i, i=-2,2) /)
déclare un tableau à deux dimensions d’entiers de 25 × 5.
Le premier indice va de 1 à 25, le deuxième de -2 à 2.
Un élément est donc désigné, par exemple, par a(i,j) ou 2.8.2 Manipulation globale de tableaux
a(12,-1).
L’exemple suivant : 2.8.2.1 n d’un coup ! (mieux que le petit tailleur)
integer :: i On peut faire des calculs en manipulant les éléments
complex, dimension(200) :: s de tableaux un à un dans des boucles comme dans les
complex :: im = (0.,1.)
exemples ci-dessus ; c’est d’ailleurs ce que l’on faisait jus-
real :: omega, t
qu’à l’apparition de fortran9026 . La manipulation glo-
omega = 2*acos(-1.0)
do i = 1, 200 bale de tableaux est sans doute l’apport le plus important
t = (i-1)*0.005 ; s(i) = exp(im*omega*t) de fortran90 par rapport aux langages qui l’ont précédé ;
enddo c’est aussi un ingrédient qui facilite beaucoup les calculs
numériques dès qu’ils deviennent un peu lourds.
déclare un tableau complexe de 200 éléments et le remplit. Admettons que les éléments du tableau c doivent être
Il peut être commode de remplacer une dimen-
la somme des éléments correspondants des tableaux a et
sion explicitement fixée à une certaine valeur, du type
dimension(100), par dimension(n) où n est un nombre b :
entier. Il faut alors déclarer n comme un paramètre, c’est-
à-dire un nombre dont on ne peut pas changer la valeur integer, parameter :: n = 1000
en cours d’exécution du programme. Ainsi : integer :: i
real, dimension(n) :: a, b, c
integer, parameter :: l = 20, m = 100, n = 30
!....
real, dimension(l,m) :: x
! il faudrait lire les elements de a et b
real, dimension(m,n) :: y
! dans un fichier par exemple.
real, dimension(l,n) :: z
do i = 1, n
integer :: i, j, k
c(i) = a(i) + b(i)
enddo
open(10,file=’fichier.x’) ! lecture x
do j = 1, m
do i = 1, l En fortran90, la boucle peut se résumer en une seule
read(10,*) x(i,j) instruction :
enddo
enddo c = a + b ! ici on fait n additions.
close(10)
open(10,file=’fichier.y’) ! lecture y le compilateur se chargeant de vérifier que tous les ta-
do j = 1, n bleaux concernés ont bien la même dimension. . . On peut
do i = 1, m donner explicitement les bornes :
read(10,*) y(i,j)
enddo c(1:n) = a(1:n) + b(1:n)
enddo
close(10) ce qui a le même résultat que ci-dessus : ça n’a au-
do j = 1, n ! produit matriciel cun intérêt dans cet exemple, mais imaginons que l’on
do i = 1, l veuille additionner la première moitié du tableau a avec la
z(i,j) = 0. deuxième moitié du tableau b et inversement, la deuxième
do k = 1, m moitié de a avec la première de b :
z(i,j) = z(i,j) + x(i,k)*y(k,j)
enddo c(1:n/2) = a(1:n/2) + b(n/2+1:n)
enddo c(n/2+1:n) = a(n/2+1:n) + b(1:n/2)
enddo
ou bien que l’on ne s’intéresse qu’aux éléments impairs :
déclare 3 tableaux de 20 × 100, 100 × 30 et 20 × 30, lit les
valeurs des éléments de x et y dans des fichiers et fait le c = 0. ! initialisation de c
produit des deux matrices dans z (attention à la différence c(1:n:2) = a(1:n:2) + b(1:n:2)
entre le chiffre 1 et la lettre l).
Malgré son apparente complexité, l’avantage de cette le dernier indice étant le pas, comme pour une boucle do27 .
façon de déclarer les tableaux est que si l’on veut, dans une
26 Plus précisément, certains constructeurs d’ordinateurs à capa-
nouvelle version du programme, changer une dimension
cité vectorielle avaient commencé à produire dans les années 1980 des
d’un tableau, il suffit de changer la valeur du paramètre
compilateurs fortran8X spécifiques à leurs machines : fortran90
correspondant et toutes les boucles s’adaptent automati- est l’héritier de ces innovations.
quement. 27 Il faut toutefois faire un peu attention car la norme ne garan-
Finalement, il est possible d’initialiser un tableau dans tit pas que les opérations effectuées dans un traitement global de
la déclaration, comme un scalaire : tableau se fassent dans l’ordre des indices de sorte que si un calcul
dépend d’un résultat obtenu précédemment sur un élément d’indice
real, dimension(-2:2) :: x=(/-4,-2,0,2,4/) inférieur, il faut écrire explicitement une boucle. En revanche, cer-
tains ordinateurs sont optimisés pour ce genre de calcul et un trai-
ici, x(-2) = -4, x(-1) = -2, etc. Une boucle implicite tement global, quand il est possible, peut se traduire par un gain de
peut aussi être utilisée pour le même résultat : temps sensible.
2.8.2.2 where c’est, encore une fois, l’équivalent d’une boucle car x et y
ne sont pas des scalaires mais des tableaux de nombres et,
Finalement, les conditions s’expriment à l’aide de where
avec une syntaxe très proche du if, sauf qu’évidemment en une ligne, est concentré un calcul de 5000 sinus. . .
il s’agit maintenant de tableaux pris globalement : fortran90 offre en outre une panoplie de fonctions
intrinsèques spécialement destinées aux opérations sur
integer, parameter :: n = 5000 les tableaux, par exemple, pour obtenir la somme des
real, dimension(n) :: x, y éléments d’un tableau :
! ....
where ( x >= 0.) integer, parameter :: n = 2048
y = sqrt(x) real, dimension(n) :: x
else where real :: y
y = 0. ! ....
end where y = sum(x)
on calcule donc les racines carrées de tous les éléments ou de façon plus sophistiquée, la somme des éléments po-
positifs du tableau x, et l’on annule y pour les éléments sitifs d’un tableau :
négatifs de x : c’est l’équivalent de la boucle :
integer, parameter :: n = 6723
real, dimension(n) :: x
real, dimension(n) :: x, y
real :: y
integer :: i
! ....
! ....
y = sum(x, mask = x >= 0.)
do i = 1, n
if ( x(i) >= 0.) then ce qui suit mask devant être un tableau logique de la bonne
y(i) = sqrt(x(i)) dimension. La moyenne des racines carrées donnerait :
else
y(i) = 0. y = sum(sqrt(x), mask = x >= 0.)/count(x >= 0.)
endif
enddo La fonction intrinsèque count compte le nombre de fois
où la condition est vraie.
2.8.2.3 forall Si le tableau est multidimensionnel, on spécifie la di-
mension sur laquelle la somme doit être faite :
Imaginons toutefois que l’on veuille, par exemple, créer
la matrice identité d’ordre n : integer, parameter :: n = 237, m = 53
  real, dimension(n,m) :: x
1 0 0 ... 0 0 real, dimension(m) :: y
 0 1 0 ... 0 0  ! ....
 
 0 0 1 ... 0 0  y = sum(x, dim = 1, mask = x >= 0.)
 
I= . . . . 
 .. .. .. . . ... ..
. n
  X
 0 0 0 ... 1 0  donne : yj = xi,j , ∀j ∈ [1, m], le résultat est donc
0 0 0 ... 0 1 i=1
xi,j ≥ 0
il faut pouvoir accéder aux termes diagonaux de la ma- évidemment un tableau. On peut écrire de façon plus suc-
trice : une boucle do peut faire l’affaire, mais celle- cinte :
ci impose que les opérations demandées soient ef-
fectuées séquentiellement dans l’ordre indiqué par l’indice ; y = sum(x, 1, x >= 0.)
sur certains ordinateurs cela peut sensiblement ralentir
l’exécution. L’instruction forall est très similaire à do La fonction product, d’usage similaire, fait le produit
mais lève cette contrainte, ainsi : des éléments d’un tableau.
Xn
real, dimension(n,n) :: id ! matrice identite Le produit scalaire z = xi yi s’obtient avec
... i=1
id = 0. ! mise a zero des n*n termes dot product :
forall ( i = 1:n ) id(i,i) = 1.0 ! n termes diagonaux
Noter que la syntaxe est un peu différente que celle de do. real, dimension(n) :: x, y
On a aussi : real :: z
! ....
forall ( i = 1:n ) z = dot_product(x,y)
...
end forall m
X
et le produit de deux matrices ci,j = ai,k bk,j avec
k=1
2.8.3 Fonctions intrinsèques et tableaux matmul :
Les fonctions intrinsèques du fortran s’accommodent
integer, parameter :: n = 100, m = 50, p = 32
très bien de tableaux, par exemple :
real, dimension(n,m) :: a ! attention au
integer, parameter :: n = 5000 real, dimension(m,p) :: b ! dimensionnement
real, dimension(n) :: x, y real, dimension(n,p) :: c ! des tableaux
! .... ! ....
y = sin(x) c = matmul(a,b)
Nom Type Description

Fonctions mathématiques
count(l,mask,dim) entier nombre de fois où le tableau logique l est vrai, selon la
dimension dim quand mask est vrai
dot product(a,b) numérique, même type que a et b produit scalaire des tableaux unidimensionnels a et b
matmul(a,b) numérique, même type que a et b produit des deux matrices a et b
maxloc(a,dim,mask) entier position du plus grand élément du tableau a selon la
dimension dim quand mask est vrai.
maxval(a,dim,mask) entier ou réel valeur du plus grand élément du tableau a selon la
minloc(a,dim,mask) entier position du plus petit élément du tableau a selon la
minval(a,dim,mask) entier ou réel valeur du plus petit élément du tableau a selon la
product(a,dim,mask) numérique, du même type que a produit des éléments du tableau a selon la dimension dim
quand mask est vrai
sum(a,dim,mask) numérique, du même type que a somme des éléments du tableau a selon la dimension dim
quand mask est vrai
Transformations de tableaux
cshift(a,shift,dim) indifférent permutation circulaire des éléments du tableau a selon la
dimension dim. Si shift est positif, déplacement de
shift positions à gauche, sinon à droite
eoshift(a,shift, indifférent décalage des éléments du tableau a selon la dimension dim.
boundary,dim) Si shift est positif, déplacement de shift positions à gauche,
sinon à droite. Les éléments manquants à l’extrémité sont
remplacés par ceux de boundary, ou zéro si boundary absent.
pack(a,mask, indifférent transforme le tableau multidimensionnel a en un tableau
vector) unidimensionnel quand mask est vrai, les éléments filtrés
par mask étant remplacés par ceux du vecteur vector
unpack(a,mask, indifférent transforme le tableau unidimensionnel a en un tableau
missing) multidimensionnel quand mask est vrai, les éléments filtrés
par mask étant remplacés par ceux de missing. La forme
du tableau résultant est celle de mask
Tab. 2.8 – Quelques fonctions de manipulation globale de tableaux.
Noter que le résultat fourni par cette fonction est lui-même quelles on aimerait pouvoir modifier la taille d’un tableau
une matrice. en cours d’exécution : par exemple, si l’on a écrit un pro-
Un résumé (non exhaustif) de quelques fonctions que gramme qui calcule la moyenne des éléments d’un tableau
l’on est amené à utiliser assez souvent est donné dans la de nombres de longueur quelconque, il serait agréable de
table 2.828 . pouvoir entrer la taille du tableau, puis le dimensionner,
puis faire le calcul sans avoir à recompiler le programme
à chaque fois que le nombre de nombres dont on veut la
2.8.4 Allocation dynamique de mémoire moyenne a changé !
Une déclaration est, comme on l’a déjà vu, une L’allocation dynamique de mémoire permet de déclarer
un tableau sans en donner la taille, puis de lui donner
réservation d’espace dans la mémoire vive de l’ordinateur.
une taille en cours d’exécution, de le supprimer puis de lui
Ainsi, real :: x déclare une variable réelle x et, de ce donner une autre taille, etc. Par exemple :
fait, réserve 4 octets (ou 32 bits) en mémoire, parce que
c’est la place qu’occupe un réel en simple précision29 : ces ! declaration d’un tableau unidimensionnel
4 octets sont donc affectés à cette variable et ne peuvent ! sans taille fixe
pas être utilisés à autre chose. De même, lorsqu’on déclare real, dimension(:), allocatable :: x
un tableau, par exemple real, dimension(n) :: x, on integer :: n
réserve n fois 4 octets. On comprend donc que cette !...
réservation doive être faite avant l’exécution du pro- write(*,’(‘‘Entrer le nombre d’elements ‘‘,$)’)
gramme : si l’on veut changer la taille d’un tableau, cela read(*,*) n
! affectation d’une taille donnee au tableau
revient à modifier la taille de l’espace qu’il occupe en
allocate(x(n))
mémoire ; il faut arrêter l’exécution du programme, mo- !... ici on fait des calculs
30
difier le code source, recompiler et relancer l’exécution . deallocate(x) ! desaffectation
Il existe cependant des quantités de situations dans les- ! on recommence avec un tableau plus petit
28 NE
! qui commence en zero au lieu de un
PAS apprendre ce tableau par cœur !
29 pour la plupart des ordinateurs courants. L’usage de mots de 64 allocate(x(0:n/2-1))
bits commence toutefois à se répandre assez rapidement. !...
30 ou alors, en fortran77, en l’absence d’allocation dynamique deallocate(x)
de mémoire, on prévoyait large : on réservait par exemple 1 000 000
d’emplacements pour n’en utiliser finalement que quelques uns. On gère ainsi la mémoire occupée pour ainsi dire
« au vol », ou plutôt, dynamiquement dans le jargon real :: s

consacré. . . s = 0.
do i = 1, m
s = s + i*z(i)
2.9 Fonctions et sous-program- enddo
bsom = s/sum(z)
mes. end ! fin de la function bsom
Rien n’oblige à écrire tous les calculs que l’on veut faire La première partie est ce qu’on appelle le « programme
dans un même programme : c’est même assez déconseillé ! principal », la seconde, la fonction32 . L’appel de la fonction
Pour des raisons, ne serait-ce que de lisibilité, on a très dans le programme principal est fait normalement, ici dans
souvent intérêt à découper un gros problème en plusieurs une instruction
petits pour lesquels les possibilités de se tromper sont plus write(*,*) bsom(x,n)
faibles31 . De plus, si le même type de calcul doit être
mais cela pourrait être dans une expression comme
répété à plusieurs endroits du programme (par exemple
un calcul d’intégrale), ce n’est pas la peine de le repro- r = sqrt(2.0)*bsom(x,n) - k
grammer plusieurs fois. Si, enfin, on a déjà écrit (et testé)
un programme qui sait faire un certain type de calcul (par l’usage d’une fonction est donc très similaire à celle des
exemple, calculer une intégrale numérique ou résoudre un fonctions intrinsèques du fortran, comme sin, exp, etc.
système linéaire d’équations), il est utile de pouvoir le Dans la définition de la fonction, on doit écrire expli-
récupérer et l’insérer dans le programme que l’on est en citement l’expression donnant la valeur de la fonction :
train de faire sans avoir à le reécrire. Il existe en outre, et si l’on oublie l’instruction bsom = s/sum(z), il n’y aura
l’on verra dans ce cours un certain nombre d’exemples de pas d’erreur détectée, le calcul sera fait normalement, mais
leur utilisation, des bibliothèques de sous-programmes et le résultat ne sera pas transmis au programme appelant.
de fonctions extrêmement riches, telles linpack, lapack, La fonction doit se terminer par l’instruction end qui en
nag, imsl. . ., dans lesquelles on peut puiser sans vergogne marque la fin, comme le programme principal.
et ainsi éviter de réinventer la roue.
Fonctions et sous-programmes sont donc des ingrédients 2.9.1.2 Les arguments et les variables d’une
essentiels ! function.
Dans cet exemple, la fonction réelle bsom calcule le ba-
2.9.1 Les function. rycentre des éléments de z. Le tableau z est un argument
de la fonction ( function bsom(z,m) ). Dans l’appel de
2.9.1.1 Définir une function. bsom, le premier argument est le tableau x qui doit avoir
On peut écrire ses propres fonctions en plus des fonc- le même type et le même nombre d’éléments que z dans la
tions intrinsèques. On les utilise de la même façon que définition de la fonction : la correspondance entre les va-
les fonctions intrinsèques mais évidemment, il faut aussi riables du programme principal et celles de la fonction est
les définir, alors que les fonctions intrinsèques sont bien donnée par l’ordre dans lequel elles apparaissent dans l’ap-
sûr prédéfinies. Pour cela, on place les instructions corres- pel et la définition de la fonction. En effet x est la première
pondantes, par exemple dans le même fichier-source que variable qui apparaı̂t dans l’appel de bsom(x,n) dans le
le programme lui-même, mais en dehors de celui-ci (avant programme principal et z est la première dans la définition
program ou après end. Par exemple, supposons que l’on
real function bsom(z,m). Ainsi, x dans le programme
veuille calculer le barycentre, à une dimension, d’un en-
semble de nombres lus dans un fichier : principal et z dans la fonction désignent la même variable ;
de même pour n et m.
program calcul ! debut du programme principal
implicit none 1er, 2e argument
integer, parameter :: n = 100 write(*,*) bsom( x, n) appel, dans p. princ.
real, dimension (1:n) :: x
real :: bsom
ll
← correspondance
real function bsom( z, m) définition
open (1, file=’machin’)
read(1,*) x Attention ! Ce n’est pas parce qu’une variable a le même
close(1) nom dans une fonction qu’une autre dans le programme
write(*,*) ’Le barycentre des elements de X est : ’ principal qu’il s’agit de la même chose ; au contraire, ces
write(*,*) bsom(x,n) ! appel de bsom deux variables même si elles ont le même nom n’ont au-
end ! fin du programme principal cun rapport ! En revanche, une variable du programme
principal représente strictement la même chose qu’une
real function bsom(z,m) ! debut de la function bsom autre, même de nom différent, dans la fonction à condi-
implicit none tion d’avoir été transmise comme argument dans l’appel
integer :: i, m et la définition de la fonction comme dans l’exemple ci-
real, dimension(1:m) :: z
dessus33 .
31 c’est ce que l’on appelle avec quelque pédanterie « l’analyse Ainsi, la variable x du programme principal est iden-
descendante », c’est-à-dire que l’on divise un problème P a priori tique à la variable z de la fonction, mais la variable s de
compliqué en plusieurs sous-problèmes P1 , P2 , . . ., puis chaque sous-
problème est redivisé en P1,1 , P1,2 , . . . , P2,1 , . . ., etc. On arrête quand 32 ouplus précisèment la définition de la function.
tous les sous-sous-sous-. . .-problèmes sont tellement élémentaires 33 Laseule chose qui soit transmise est l’adresse du premier élément
qu’il n’y a plus de problème ! du tableau x. C’est en fait un pointeur masqué !
la fonction bsom est complètement indépendante de ce qui end

peut être déclaré dans le programme principal : il pourrait
très bien y avoir une autre variable s dans le programme Le sous-programme baryc utilise les données rx, ry, rz,
principal sans qu’il y ait la moindre interaction entre les et masse, ainsi que le nombre de masses impliquées, pour
deux. rendre les coordonnées du centre de masse et la masse
Lorsqu’on apprend à programmer, c’est une source d’er- totale.
reur classique et cela paraı̂t inutilement compliqué, mais à Noter la différence avec une fonction : on peut
l’usage c’est un grand avantage car ainsi la fonction bsom, insérer l’appel d’une fonction dans une expression,
une fois écrite et testée, est indépendante du cadre dans le- écrire : write(*,*) bsom(x,n)/pi ou bien : xtot =
quel elle est utilisée, on peut donc s’en servir dans un grand 3.*bsom(x,n) + w, mais un sous-programme doit être
nombre de circonstances sans se préoccuper du détail de la appelé par un call. Par ailleurs, une fonction doit être
façon dont elle est écrite. Par exemple, on peut très bien
déclarées car elle a un type : entier, réel, double précision,
avoir oublié qu’il y a des variables s et z dans bsom, et
faire dans le programme principal un appel du type : logique. . . en revanche, un sous-programme ne doit pas
être déclaré mais bien sûr, ses arguments, eux, doivent
z = bsom(s,m) l’être, car un sous-programme ne prend pas de valeur, mais
se borne à modifier certains de ses arguments.
sans conséquence dramatique, à condition que, dans le pro-
Les autres remarques concernant l’indépendance des va-
gramme principal, s soit un tableau de m éléments et z un
riables d’une fonction vis-à-vis de celles du programme
scalaire réel.
principal et le dimensionnement des tableaux transmis
Il faut donc se rappeler qu’en fortran, il n’y a pas de
comme argument sont aussi valables dans le cas d’un sous-
variables globales, toutes les variables doivent être explici-
programme.
tement transmises de programme appelant à fonction ou
sous-programme.
2.9.3 L’intention
2.9.2 Et les subroutine. On voit, dans l’exemple ci-dessus par exemple, que cer-
tains arguments sont des données que la subroutine doit
Une fonction souffre de la limitation qu’elle ne peut pro- utiliser pour faire ses calculs (m, x, y, z, n), d’autres (mt,
duire qu’une seule valeur comme résultat : ainsi, si l’on gx, gy, gz) des résultats qu’elle doit calculer : les premiers
veut calculer plusieurs choses, il faut faire un sous-pro- sont donc « en entrée », les autres « en sortie », sans que
gramme (subroutine). Par exemple, si l’on veut calculer, rien dans la syntaxe n’indique cette différence. C’est ici
dans l’espace à trois dimensions, le barycentre d’un en- qu’intervient l’idée « d’intention » ou intent en anglais.
semble de masses (donc trois nombres) ainsi que la masse On spécifie, dans les déclaration du sous-programme, si
totale (un quatrième nombre), on peut procéder comme un argument est en entrée ou en sortie, ainsi :
suit : subroutine baryc( gx, gy, gz, mt, x, y, z, m, n )
implicit none
program cmasse
integer, intent(in) :: n
implicit none
real,intent(out) :: gx, gy, gz, mt
real, dimension(1:n), intent(in) :: m, x, y, z
real, dimension(1:n) :: masse, rx, ry, rz
real :: ogx, ogy, ogz, mtot
mt = sum(m)
integer :: i
gx = dot_product(x,m)/mt
gy = dot_product(y,m)/mt
open(1, file=’masses’)
gz = dot_product(z,m)/mt
do i = 1, n
read(1,*) rx(i), ry(i), rz(i), masse(i)
end
enddo
close(1) Cela a deux conséquences : 1o c’est plus clair pour le pro-
grammeur, 2o le compilateur détectera une erreur si, par
call baryc (ogx,ogy,ogz,mtot,rx,ry,rz,masse,n)
exemple, on essaie de modifier un argument déclaré in.
write(*,*) ’Masse totale : ’, mtot L’intent(inout) existe aussi, pour les arguments dont
write(*,*) ’Coordonnees du centre de masse : ’ on doit utiliser la valeur en entrée, mais que l’on doit
write(*,*) ogx, ogy, ogz également modifier.
end
2.9.4 La mise en commun de variables.
subroutine baryc( gx, gy, gz, mt, x, y, z, m, n ) On a vu que fonctions et sous-programmes étaient à
implicit none peu près étanches vis-à-vis du monde extérieur, à l’excep-
integer :: n tion, évidemment, des variables transmises comme argu-
real :: gx, gy, gz, mt ments : c’est un avantage, mais, c’est parfois un peu rigide.
real, dimension(1:n) :: m, x, y, z On peut alors mettre en commun des variables entre pro-
gramme et sous-programme ou entre sous-programmes ou
mt = sum(m) fonctions différents, à l’aide de modules. Imaginons, par
gx = dot_product(x,m)/mt exemple, un code comprenant un programme principal et
gy = dot_product(y,m)/mt des sous-programmes qui utilisent tous la grandeur π et
gz = dot_product(z,m)/mt les conversions entre degrés et radians. Plutôt que redéfinir
ces grandeurs dans chaque programme et sous-programme,
on peut commencer par faire un module, placé au début (si c’est un programme compliqué surtout si on ne l’a pas
du fichier source : écrit soi-même, c’est toujours un peu dangereux), il suffit
de faire un module pour mettre ces variables en commun
module trig_consts
entre le programme principal et B : on saute, pour ainsi
! definition de constantes trigonometriques
implicit none dire, par-dessus A !
real, parameter :: pi = acos(-1.0)
real, parameter :: deg_rad = pi/180. 2.9.5 Mettre un nom de sous-programme
real, parameter :: rad_deg = 180./pi
comme argument.
end
Admettons que l’on ait écrit une fonction somdef qui
il s’agit simplement de déclarations (ici de paramètres, sache calculer une intégrale définie : il faut lui trans-
mais ce n’est pas obligatoire) et, le cas échéant, d’affecta- mettre comme argument, outre les bornes xmin et xmax
tions de valeurs. Dans un programme ou sous-programme de l’intégrale et la précision eps souhaitée, le nom de la
dans lequel on veut utiliser ces variables, il faut spécifier fonction à intégrer. Par exemple :
au début des déclarations
xmin = 0. ; xmax = acos(-1.0)
use trig_consts write(*,*) somdef( xmin, xmax, eps, sin )
et les variables pi, deg rad et rad deg sont utilisables sans si l’on veut calculer l’intégrale de 0 à π de sin x. Cepen-
autre forme de procès ; ainsi, si theta est un angle donné dant, si l’on procède sans précaution, le compilateur diag-
en degrés : nostiquera que la variable sin n’est pas déclarée, et dira
quelque chose qui peut ressembler à : Error : Symbol
sin_theta = sin(deg_rad*theta)
’sin’ at (1) has no IMPLICIT type, ce qui est ab-
est correct même si deg rad n’a pas été déclaré dans le surde puisqu’il s’agit d’une fonction intrinsèque. . . C’est
programme. Quand on fait cela, il faut faire un peu atten- que dans ce contexte là, il ne reconnait pas sin comme
tion, puisque si l’on a une autre variable pi dans un des une fonction : il faut donc le préciser dans les déclarations
programmes qui utilisent ce module, il y aura un conflit avec intrinsic.
détecté par le compilateur. Cependant, comme il faut faire
real :: xmin, xmax, eps, somdef
appel explicitement par use aux modules dont on a besoin
intrinsic :: sin
dans chaque sous-programme qui l’utilise, les dégats po-
34 ...
tentiels restent limités : on peut très bien imaginer des
xmin = 0. ; xmax = acos(-1.0)
structures comme :
write(*,*) somdef( xmin, xmax, eps, sin )
module blabla
De même, s’il s’agit d’une fonction mafct que l’on a écrite
! acceleration de la pesanteur terrestre
soi-même, il faut la déclarer par external
real, parameter :: g=9.81
end real :: xmin, xmax, eps, somdef
external :: mafct
program truc ...
use blabla ! rappel du module blabla xmin = .. ; xmax = ..
implicit none write(*,*) somdef( xmin, xmax, eps, mafct )
real :: p, m = 75
p = m*g Les mêmes règles s’appliquent pour les sous-
write(*,*)’Poids =’,p programmes35.
call machin(p) Ce sont là les seuls cas d’utilisation de intrinsic et
end external : quand on ne transmet pas comme argument le
nom d’un sous-programme ou d’une fonction à un autre
subroutine machin(poids)
sous-programme ou fonction, il est complètement inutile
implicit none ! ici pas de module blabla
real, intent(in) :: poids d’utiliser ces déclarations36.
real :: g= 2.
write(*,*) ’Poids a’,g ,’ g =’, poids*g 2.9.6 Les bibliothèques.
end
2.9.6.1 Pour quoi faire ?
La variable g de machin n’a rien à voir avec celle du mo-
dule et du programme principal, puisque machin n’utilise Imaginons que l’on ait écrit une série de sous-
pas le module blabla (il n’y a pas use blabla). programmes, par exemple des calculs d’intégrale, dont le
Outre la définition de constantes, un des usages les plus code-source, c’est-à-dire écrit en Fortran, est placé pour
courants des modules est quand un programme principal chaque sous-programme dans un fichier dont le nom se ter-
appelle un sous-programme A qui lui-même en appelle un mine par .f90. Pour réutiliser ces sous-programmes dans
autre B. A priori, les seules variables connues du sous- d’autres programmes, on peut bien sûr simplement inclure
programme B sont celles que lui a transmises A, or il se les fichiers correspondants à l’aide de directives include
peut très bien qu’il ait besoin d’autres grandeurs utilisées 35 Certains compilateurs plus anciens n’acceptent que l’ancienne
par le programme principal. Si l’on ne veut pas modifier A syntaxe external mafct (sans les ::).
36 Cette affirmation est en fait un peu péremptoire. . ., on peut
34 De ce point de vue, on reste assez loin des variables globales du imaginer des situations où cela peut être nécessaire, par exemple
C dont les auteurs du langage disent eux-mêmes que ce n’est pas si l’on a écrit soi-même un sous-programme dot product qui risque
ce qu’ils ont fait de mieux ! (B. W. Kernighan, D. M. Ritchie, Le d’entrer en conflit avec la fonction intrinsèque de même nom ; la
langage C, Masson (1997), p. 33.) déclaration external résout alors le problème.
’nom de fichier.f90’, c’est d’ailleurs ce que l’on fait d’invoquer à la compilation par :
souvent. g95 mon big prog.f90 -llapack -o mon big prog
Toutefois, il arrive que ces sous-programmes aient eux- Cela suppose évidemment que l’on ait la documentation
même besoin d’autres sous-programmes pour fonction- qui va avec, mais c’est généralement facile à obtenir via
ner. Par exemple, les programmes de calcul de tran- Internet. C’est très souvent ainsi que l’on travaille dans
formée de Fourier vont tous utiliser le même algorithme, « le monde réel de la simulation » : pour résoudre un
mais vont différer selon que l’on veut une transformée problème, on identifie une méthode de résolution dont
directe ou inverse : ainsi le programme que l’on ap- le noyau réside dans un algorithme connu (inversion de
pelle ne fait qu’appeler un autre programme en modifiant matrice, transformée de Fourier, valeurs propres, . . .) et
éventuellement un signe ; il faudrait alors inclure explici- l’on trouve le programme de bibliothèque convenable, on
tement les deux sous-programmes, ce qui suppose que l’on l’appelle et on compile l’ensemble avec l’invocaton de la
connaisse spécifiquement comment tout cela est organisé : bibliothèque idoine : un appréciable gain de temps !
autant dire que c’est rarement le cas quelques années après
l’écriture initiale. Une bonne solution est alors de consti-
tuer une bibliothèque (library en anglais37 ). 2.10 Les commentaires.
Une bibliothèque est un fichier dans lequel sont re-
On peut, et c’est même conseillé, commenter ses pro-
groupés un ensemble se sous-programmes déjà compilés grammes, d’ailleurs les exemples donnés ci-dessus com-
et dans lequel le compilateur peut aller pêcher ce dont portent des commentaires. Pour cela, il suffit d’utiliser
il a besoin, par exemple un sous-programme de calcul de le symbole ! qui marque le début d’un commentaire qui
transformée de Fourier et tous les sous-programmes aux- ne sera donc pas interprété comme une instruction à
quels celui-ci fait appel : dans le programme principal, il exécuter :
suffira de faire un call du sous-programme voulu.
! ceci est un commentaire, mais la ligne
! qui suit est une instruction
2.9.6.2 Créer une bibliothèque personnelle. read(*,*) x
On a donc écrit un certain nombre de sous-programmes C’est très utile quand on veut pouvoir s’y retrouver dans
et de fonction (dûment testés, bien sûr. . .) placés dans des un programme écrit quelques temps avant, par exemple :
fichiers machin 01.f90, machin 02.f90, truc real.f90,
truc dbl prec.f90, etc. Si on compile tout cela par g95 !-----------------------------------------------
*.f90, le compilateur refusera de la faire parce qu’il n’y a ! Ceci est un programme ecrit le 06-11-98
! par Tycho Brahe
pas de programme principal : il faut donc inhiber l’éditeur
! Il comporte trois boucles imbriquees
de lien38 avec l’option -c et pendant qu’on y est, on peut !
demander une optimisation du code avec l’option -O3. ! Mise a jour (adaptation free form) le 18-12-01
Cela donne : ! par Johannes Kepler
g95 -c -O3 *.f90 !-----------------------------------------------
on obtiendra alors une série de fichiers machin 01.o, ....
machin 02.o, truc real.o, truc dbl prec.o, etc. Ces ! debut de la grande boucle
fichiers doivent alors être inclus dans un fichier d’archive : do i = 1, n
ar rv libmabib.a *.o ......
Le fichier libmabib.a contient la bibliothèque mabib. On ......
peut alors supprimer tous les fichiers intermédiaires : ! debut de la moyenne boucle
do j = 1, m
rm -f *.o
........
Pour utiliser cela, il suffit de compiler normalement ........
son programme principal, dans lequel il y a des call ! debut de la petite boucle
machin 01(arg1, arg2), avec la commande : do k = 1, l
g95 big prog.f90 -Lrepertoire de mabib -lmabib ......
-o big prog ......
où repertoire de mabib est le répertoire où se trouve ......
le fichier libmabib.a. Si l’on peut placer le fichier enddo
libmabib.a dans le répertoire /usr/local/lib39, ! fin de la petite boucle
l’option -L n’est plus nécessaire. ......
......
enddo
2.9.6.3 Utiliser une bibliothèque existante. ! fin de la moyenne boucle
.....
Il est toutefois assez rare que l’on ait à créer une
.....
bibliothèque de toutes pièces : l’essentiel des algorithmes enddo
courants a déjà été programmé, compilé, testé, etc., il ! fin de la grande boucle
est inutile -voire nocif- de les refaire ! Pour l’algèbre
linéaire, il y a par exemple lapack qu’en général, il suffit Si chaque série de points (.....) représente plusieurs cen-
37 attention aux faux amis : en anglais, library signifie bibliothèque
taines d’instructions, les commentaires qui en marquent le
(l’endroit où l’on emprunte des livres) alors que librairie (l’endroit
début et la fin ne sont pas de trop. . .
où l’on achète des livres) se dit bookstore. . . Le point d’exclamation placé ailleurs qu’en colonne 1,
38 c’est ce qui fait le lien entre programmes et sous-programmes. transforme la fin de la ligne en commentaire, sans en af-
39 il faut pour cela les droits de super-utilisateur. fecter le début :
x = a + b ! a partir d’ici c’est un 2.12.2 Opérations sur les chaı̂nes

z = (x/p)**1.5 ! commentaire, mais le debut de
k = mod(j,6) ! ces lignes s’execute normalement On peut faire quelques opérations sur les chaı̂nes de ca-
ractères, par exemple :
Les déclarations de variables sont souvent un bon en-
droit pour mettre des commentaires : i = len_trim(salut)
program capitaine donne le nombre de caractères remplis de la chaı̂ne (4 dans
implicit none le cas Ciao même si la chaı̂ne est déclarée avec 7 cha-
! ce programme calcule l’age du capitaine ractères).
integer, parameter :: n = 100 ! nbr de points de
! discretisation character (len=7) :: salut = ’Bonjour’
real :: age_captain ! age du capitaine character (len=3) :: c
real, dimension(n) :: work ! zone de travail c=salut(1:3)
donnera Bon dans c puisque l’on prend les caractères de

2.11 Une instruction sur plusieurs 1 à 3. Il est aussi possible d’ajouter des caractères à une
chaı̂ne en utilisant l’opération // :
lignes.
integer l
Il arrive qu’une instruction soit trop longue pour tenir character (len=40) :: nfichier1
sur une ligne : il faut donc la prolonger sur la ligne sui- character (len=20) :: nfichier2
vante. Pour cela, il suffit de placer le caractère & à la fin
de la ligne pour indiquer que la ligne suivante en est la write(*,’("Entrer un nom de fichier : ",$)’)
suite : read(*,*) nfichier1
write(*,*) ’L’’age du capitaine est ’, ag_cpt, &
’ mais on manque un peu de place ’, & l = len_trim(nfichier1) ! l = longueur reelle
’: d’’ailleurs, on est oblige’, & ! du nom de fichier
’ de s’’etaler sur plusieurs lignes’ nfichier2=nfichier1(1:l)//’.res’
! on prend la partie de la chaine nfichier1
Ici, l’instruction prend quatre lignes. Si l’on interrompt ! qui est remplie et on ajoute ’.res’ apres
une chaı̂ne de caractère, il faut mettre & à la fin de la ligne
et au début de la ligne suivante : write(*,*) "Fichier resultat : ", nfichier2
write(*,*) ’L’’age du capitaine est ’, ag_cpt, & open(1,file=nfichier1) ; open(2,file=nfichier2)
’ mais on manque un peu de place &
Ainsi, si l’on répond à la question « Entrer un nom de
&: d’’ailleurs, on est oblige &
&de s’’etaler sur plusieurs lignes’ fichier » par : machin, on obtiendra :
Fichier resultat : machin.res
comparer avec l’exemple précédent. . .
2.12.3 Conversion chaı̂ne ⇔ nombres
2.12 Les chaı̂nes de caractères. On peut donc fabriquer automatiquement des
noms de fichiers ; toutefois, il est utile de pouvoir
2.12.1 Déclaration insérer des nombres dans ces noms, par exemple
Une variable de type chaı̂ne de charactères doit être res calc dt0.001.dat pour signifier que ce calcul a été
déclarée avec le nombre de caractères qu’elle peut conte- fait avec dt=0.001. Il faut donc convertir ce nombre en
nir, par exemple : chaı̂ne de caractères. Il existe une fonction intrinsèque
char qui permet de partir du code ASCII d’un caractère
character (len=7):: salut pour écrire ce caractère : c’est assez lourd, car il faut
indique que salut peut faire 7 caractères. Par exemple : décomposer le nombre en dizaines, centaines, connaı̂tre
les codes ASCII. . . Il est beaucoup plus simple d’utiliser
salut=’Bonjour’ les instructions d’entrée-sortie qui font aussi ce genre de
conversion par le biais de ce qu’on appelle un « fichier
Mais rien n’empêche :
interne », qui consiste à remplacer l’unité d’écriture par
salut=’Ciao’ une chaı̂ne de caractères :
où seuls les quatre premiers caractères sont remplis. En integer :: i
revanche, character (len=21) :: nom_fich
salut=’Guten Tag’ ! initialisation de la cha^
ıne de caracteres
nom_fich = ’res_calc_dt_0.000.dat’
risque d’être un peu décevant, il serait judicieux de do i = 1, 8
déclarer salut avec 9 caractères au moins. . . ! completer les caracteres numeriques
On peut, dans un sous-programme ou une fonction, write(nom_fich(12:16),’(f5.3)’) 0.001*i
déclarer une chaı̂ne de caractères sans longueur définie, ...
à condition qu’elle soit transmise comme argument : enddo
subroutine char_process(str,a,b,c,d)
Evidemment, cela suppose un certain soin et il est pru-
character (len=*) :: str
dent de vérifier que le nom de fichier obtenu est bien ce
le sous-programme se débrouillera avec la chaı̂ne str que l’on attendait ! Ensuite, il est aisé de produire auto-
quelle qu’en soit la longueur. matiquement des noms de fichiers explicites.
Les fichiers internes fonctionnent aussi pour l’écriture, 2.13 Détection de fin de fichier.
par exemple, le programme metres ci-dessous lit les ar-
guments de la commande qui l’invoque, ainsi quand on Il arrive que l’on lise un fichier dont la longueur est
tape : inconnue : ainsi, on ne sait pas la longueur de la boucle de
lecture :
$ metres 6500 pieds
open(1,file=nfichier)
on obtient do i = 1, n ! mais quelle valeur donner a n ?
read(1,*) x
1981.200 metres
...
Le programme est aussi une illustration de select case : enddo
program metres Une bonne solution est de faire une boucle infinie dont on
implicit none sort quand une condition de fin de fichier est rencontrée :
real, parameter :: c = 0.3048 ! conversion
real :: l open(1,file=nfichier)
character (len=10) :: unite do
read(1,*,iostat=i) x
! si le nombre d’arguments est >= 2, lire les deux if( i < 0 ) exit
! premiers, sinon, lire classiquement au clavier ...
if ( command_argument_count() >= 2 ) then enddo
call get_command_argument(1,unite) ! 1er argument
la spécification iostat=i où i est une variable entière
! Le 1er argument est la longueur que l’on veut
! convertir, c’est donc un nombre, or on a une chaine place dans i un diagnostic du résultat de l’opération
! de caracteres qu’il faut convertir en reel par d’entrée-sortie. Tant que i reste positif ou nul, la lecture
! unite interne se poursuit. La fin du fichier ou une erreur de lecture pro-
read(unite,*) l ! on lit la chaine pour obtenir l duira une valeur négative, et la lecture s’arrête.
call get_command_argument(2,unite) ! 2eme argument
! le 2eme argument est le nom de l’unite qui reste
! une chaine de caracteres : donc pas de conversion. 2.14 FORTRAN77-90-95 : filiation
else
write(*,’("Entrer la longueur et l’’unite ",$)’)
et différences.
read(*,*) l, unite
Le langage fortran ne cesse d’évoluer : la première
endif
norme officielle et indépendante d’un constructeur, for-
! trim est une fonction intrinseque qui reduit une tran66 ou fortranIV, date de 1966. fortran77, en
! chaine de caracteres a sa partie utile (sans espaces) 1977, introduisait des structures comme if-then-else,
select case(trim(unite)) les chaı̂nes de caractères et des instructions d’entrée-sortie
case (’ft’,’feet’,’foot’,’pieds’,’pied’) élaborées comme open. En 1991, la norme fortran90 fut
write(*,*) l*c,’ metres’ définie et les premiers compilateurs cray et ibm sont ap-
case (’in’,’inch’,’inches’,’pouces’,’pouce’) parus en 1994. Enfin, la norme fortran95 est devenue
write(*,*) 1000.*l*c/12.,’ mm’ ! 1 ft = 12 in opérationnelle en 1999 sur des gros calculateurs de type
case(’m’,’metres’) cray et ibm. . . en attendant fortran2003 !
write(*,*) l/c,’ ft’ Si fortran95 apporte surtout des modifications de
case default
détail par rapport à fortran90, celui-ci constitue
write(*,*) ’unite inconnue’
end select
une évolution significative. Certaines structures (comme
end do-if(...) exit-enddo) étaient déjà intégrées dans g77
mais pas toutes : la manipulation globale de tableaux, les
–Exercice : adapter ce programme pour pouvoir faire modules, l’intention, l’allocation dynamique de mémoire
des conversions du type metres 5 ft 10 in pour obte- n’en faisaient pas partie.
nir 1.778 m. Cette capacité à manipuler des tableaux est probable-
Une autre application est la création de formats au- ment l’apport principal de fortran90 au calcul scienti-
tomatiques : imaginons que l’on ait déclaré un tableau fique ; la logique des programmes peut en être modifiée :
« allocatable » : combien d’éléments doit-on mettre un exemple pourrait être un calcul d’énergie potentielle
dans le format d’écriture ? A priori, on ne peut pas le savoir
d’interaction entre n atomes, à partir de l’énergie de paire
avant l’exécution : c’est le but de l’allocation dynamique
de mémoire. . . On peut s’en sortir en se rappelant qu’un de chaque couple d’atomes, donnée par une expression du
format est une chaı̂ne de caractères que l’on peut modifier, type 12 6 !
ainsi : σ σ
V (rij ) = ε −2
rij rij
integer :: n
real, dimension(:), allocatable :: s et
character (len=9) :: form=’(00f11.5)’ n−1
X n
X
write(*,’("Donnez la dimension du tableau : ",$)’) Ep = V (rij )
read(*,*) n i=1 j=i+1
allocate(s(n)) en fortran77 :
...
write(form(2:3),’(i2.2)’) n ! modification du format do i = 1, n-1
write(*,form) s ! ecriture do j = i+1, n
rij2 = (x(i)-x(j))**2 + (y(i)-y(j))**2 + & On peut faire la même chose avec des entiers :
(z(i)-z(j))**2 integer :: l
sigr6 = (sigma2/rij2)**3 code l sur 4 octets et permet d’utiliser des nombres entiers
epot = epot + sigr6*( sigr6 - 2.0 ) jusqu’à 109 , alors que
enddo integer (kind=8) :: l
enddo
travaille sur 8 octets et permet d’aller jusqu’à 1010 .
epot = epsilon*epot
Toutefois, tout ceci dépend du processeur utilisé : ce qui
en fortran90 : est cité ci-dessus n’est vrai que pour les processeurs les
plus communément utilisés sur PC ; le programme suivant
do i = 1, n-1 permet de tester tout cela en cas de doute :
rij2(i+1:n) = (x(i)-x(i+1:n))**2 + & program inquire_kind
(y(i)-y(i+1:n))**2 + & implicit none
(z(i)-z(i+1:n))**2
integer :: p
sigr6(i+1:n) = (sigma2/rij2(i+1:n))**3 ! l’exposant est celui de la puissance de 10 accessible
epot = epot + sum(sigr6(i+1:n)*(sigr6(i+1:n) - 2.0)) write(*,’("Nombres entiers :")’)
enddo
write(*,’("exposant, kind")’)
epot = epsilon*epot do p = 1,10
write(*,’(2i6)’) p, selected_int_kind(p)
où maintenant rij2 et sigr6 sont des tableaux : la boucle enddo
interne est implicitement décomposée en trois boucles plus ! la precision est le nombres de chiffres significatifs
simples. Le résultat est que l’on occupe plus de mémoire write(*,’("Nombres reels :")’)
vive (plus de tableaux) mais que la logique du calcul s’en write(*,’("precision, kind")’)
trouve décomposée en éléments plus simples. do p = 1, 20
Il y a cependant d’autres innovations, plus « informa- write(*,’(2i7)’), p, selected_real_kind(p)
tiques » qui seront décrites ici car elles ont un attrait cer- enddo
tain, mais elles sont d’un intérêt moins immédiat pour le end
calcul scientifique pur et dur.
On peut aussi utiliser kind avec des caractères pour
écrire avec des caractères non-latins.
2.14.1 kind
Le type double precision est considéré comme ob- 2.14.2 Interfaces.
solète et disparaı̂tra probablement dans une version Supposons qu’une équipe de programmeurs travaille
ultérieure de Fortran. Son intérêt est de faire des cal- collectivement sur un même (gros) programme en se
culs avec un plus grand nombre de chiffres significatifs, ce répartissant les tâches. Chaque programmeur n’est pas
qui est parfois utile, sinon indispensable. Il est remplacé forcément toujours au courant du détail des arguments
par le concept plus général de kind40 qui s’applique aux utilisés par ses collègues dans tel ou tel sous-programme
entiers, aux réels et aux caractères. Dans la plupart des cas enfoui dans des dizaines de milliers de lignes de code ; il n’a
(ça dépend du processeur) un kind=4 codera un nombre pas forcément le temps ou le courage de relire tout le code
sur 4 octets (c’est en général ce qui se passe quand on existant pour retrouver la liste d’arguments et leurs types
ne précise rien et cela donne 6 chiffres significatifs) et un de la subroutine lfpz atis13102twr11800 écrite deux
kind=8 sur 8 octets, soit la double precision ( 15 chiffres ans auparavant par quelqu’un qui a entre-temps changé
significatifs). d’affectation !
Ainsi : Il peut être alors utile de résumer au début du pro-
real :: x gramme principal, dans une interface, tout ce qu’il faut
et savoir sur tous les sous-programmes :
real (kind=4) :: x
program yepee
sont (sur la plupart des ordinateurs) équivalents. De
même : interface
double precision :: x
et subroutine lfpz_atis13102twr11800(x,y,n)
real (kind=8) :: x integer, intent(in) :: n ! nombre
De la même façon, on peut faire des double complex par real, dimension(n), intent(in) :: x ! annees
complex (kind=8) :: z real, dimension(n), intent(inout) :: y ! mvts
Quel intérêt tout cela peut-il avoir ? La déclaration real end subroutine lfpz_atis13102twr11800(x,y,n)
est un peu ambigüe parce que, sur un processeur à 32 bits,
subroutine cp301_phln(a,h)
le réel est bien codé sur 4 octets, alors que sur un proces-
real, intent(in) :: a ! annee
seur à 64 bits (qui deviennent de plus en plus fréquents)
real, intent(out) :: h ! heures
il est codé sur 8 octets, ce qui en fait l’équivalent d’un end subroutine cp301_phln
double precision. . . La notion de kind a pour but de
clarifier les choses. end interface
40 Sorte ou espèce. Par exemple : the American bald eagle is a kind
of eagle found in Northern America. En américain « conversation- ! declarations du programme principal
nel », It’s kind of neat (prononcer : It’s kinda neat) : c’est super implicit none
chouette ; he’s kind of weird : il est assez bizarre. ...
Toutes les déclarations de tous les arguments de tous opérations sur les rationnels qui tiennent compte, en par-
les sous-programmes sont ainsi répétées au début du ticulier, de la réduction au même dénominateur :
programme principal (ou du programme appelant), avec
éventuellement des commentaires : le compilateur peut module rat
ainsi vérifer au passage la cohérence des appels de sous- ! definition du type rationnel dans un module pour
programmes et signaler d’éventuelles erreurs. ! eviter d’avoir a le refaire dans tous les
L’interface ne sert cependant pas uniquement à se rap- ! sous-programmes
peler la syntaxe d’appel d’un sous-programme, elle permet type rationnel
de résoudre un certain nombre de problèmes de déclaration integer :: n, d
de variables. Admettons que l’on cherche à faire une fonc- end type rationnel
! le type rationnel est compose de deux nombres
tion qui fasse un produit vectoriel ~a ∧ ~b. Le résultat est
! entiers : n = numerateur et d = denominateur
un vecteur à trois éléments : comment déclarer une telle
end module rat
fonction ? La réponse est de faire une interface, ainsi :
program prod_test program ratio ! programme principal

use rat
implicit none
implicit none
! -- interface pour declarer une fonction-vecteur --
interface operator (*)
interface
! definition de l’operateur * (multiplication)
function cross_product(a,b) result(c)
! result permet de definir une variable qui contient ! il s’agit ici simplemement de faire le lien
! entre le symbole ’*’ et la fonction ’ratmul’
! le resultat de la fonction. Ici cette variable est
function ratmul(q1,q2) result(q3)
! un vecteur a trois elements
real, dimension(3), intent(in) :: a, b use rat
real, dimension(3) :: c type(rationnel), intent(in) :: q1, q2
type(rationnel) :: q3
end
end interface end function ratmul
end interface operator (*)
! ---
real, dimension(3) :: x, y, z interface operator (+)
! meme chose pour l’addition
function ratadd(q1,q2) result(q3)
write(*,’("Entrer X ",$)’) ; read(*,*) x
write(*,’("Entrer Y ",$)’) ; read(*,*) y use rat
type(rationnel), intent(in) :: q1, q2
type(rationnel) :: q3
! appel de la fonction (ce sont des tableaux!)
z = cross_product(x,y) end function ratadd
write(*,*) "X x Y = ", z end interface operator (+)
! test pour verifier que le resultat est bien ! declaration de deux nombres rationnels p et q
! perpendiculaire aux deux vecteurs initiaux ! le numerateur de q s’ecrit q%n et
! son denominateur q%d
write(*,*) "Produit scalaire X.Z", dot_product(x,z)
write(*,*) "Produit scalaire Y.Z", dot_product(y,z) ! meme chose pour p
type (rationnel) :: q, p
end
write(*,’("Num, denom 1: ",$)’)
!----- definition de la fonction ----- read(*,*) q%n, q%d
write(*,’("Num, denom 2: ",$)’)
function cross_product(a,b) result(c)
read(*,*) p%n, p%d
implicit none
real, dimension(3),intent(in) :: a, b
! utilisation des deux nouveaux operateurs
real, dimension(3) :: c
write(*,*) "produit ", q*p
c = cshift(a,1)*cshift(b,-1)-cshift(b,1)*cshift(a,-1) write(*,*) "somme ", q+p
end
end
-Exercice : étudier le fonctionnement des cshift dans function ratmul(q1,q2) result(q3)

! ratmul est une fonction de type rationnel
la fonction cross product en comparant avec la définition
! mais ce type n’est pas encore defini pour
du produit vectoriel. . . ! cette fonction, d’ou la syntaxe result
use rat
2.14.3 Objets de type dérivé. implicit none
type(rationnel), intent(in) :: q1, q2
En fortran, il y a les types integer, real, etc. On type(rationnel) :: q3
peut aussi fabriquer dans un programme des types nou- q3%n = q1%n*q2%n
veaux en combinant des types existants, par exemple, q3%d = q1%d*q2%d
character et real, et définir des opérations (addition, call simplify(q3)
multiplication) s’effectuant sur ces nouveaux types. Par end function ratmul
exemple, un rationnel est composé de deux nombres en-
tiers, numérateur et dénominateur, et l’on peut définir des function ratadd(q1,q2) result(q3)
use rat doute les scientifiques eux-mêmes qui sont frappés d’obso-
implicit none lescence ! En attendant, l’un des reproches essentiels que
type(rationnel), intent(in) :: q1, q2 l’on fai(sai)t au fortran est l’absence de pointeurs.
type(rationnel) :: q3 Un pointeur est une variable qui contient l’adresse d’une
q3%n = q1%n*q2%d + q2%n*q1%d variable : si l’on modifie un pointeur, on ne modifie pas la
q3%d = q1%d*q2%d
valeur de la variable, mais on « pointe » vers une autre
call simplify(q3)
end function ratadd
adresse et donc une autre variable. A priori, un pointeur
est donc juste une variable entière qui contient une adresse
subroutine simplify(q) et l’on peut faire les opérations que l’on veut sur cette
use rat adresse, aux risques et périls de l’utilisateur. C’est ainsi
implicit none en assembleur et en langage C qui est très proche de la
type(rationnel) :: q machine. En assembleur en particulier, il n’y a pas de ta-
integer :: i, m bleaux, mais on peut accéder à des grandeurs stockées
à la suite les unes des autres en mémoire simplement
! si a la fois numerateur et denominateur sont en incrémentant un pointeur, ce qui revient au même,
! divisibles par le meme nombre, le faire : si ce n’est que c’est d’un maniement sensiblement plus
! c’est pedestre, mais ca marche...
délicat. . .
m = min(abs(q%n),abs(q%d))
l1 : do i = 2, m
Les pointeurs sont importants en informatique parce
l2 : do ! il faut parfois recommencer que c’est le point de départ de l’allocation dynamique
if (mod(q%n,i) == 0 .and. mod(q%d,i) == 0 ) then de mémoire, puisqu’on accède ainsi librement à toute
q%n = q%n/i la mémoire sans en réserver des morceaux à telle ou
q%d = q%d/i telle variable. fortran90 gère l’allocation dynamique de
else mémoire autrement, comme on l’a vu, et -opinion qui n’en-
exit l2 gage que son auteur- de façon nettement plus prudente.
endif Autant dire que pour l’essentiel du calcul scientifique,
enddo l2 la capacité à utiliser des tableaux efficacement est beau-
enddo l1 coup plus importante. Toutefois, fortran90 introduit les
end subroutine simplify
pointeurs avec un certain nombre de garde-fous.
Ça donne par exemple : Un pointeur doit être déclaré avec le type de la variable
vers lequel il pointe : un pointeur donné ne peut pas avoir
$ ratio
pour cible un entier à un moment et un réel un peu plus
Num, denom 1: 5 2
tard :
Num, denom 2: 4 5
produit 2 1 ! declaration d’un pointeur vers un entier
somme 33 10 integer, pointer :: a
5 4 20 2 5 4 ! declaration d’un pointeur vers un tableau reel
ce qui est correct : × = = et + = real, dimension(:), pointer :: b
2 5 10 1 2 5
5×5+2×4 33
= . Il faut aussi déclarer explicitement des variables comme
2×5 10 cible (target en anglais) :
On peut, sans difficulté majeure, ajouter à cela les
deux autres opérations et l’on aura créé un type nou- integer, target :: n, m
veau et les opérations associées. Les types dérivés et les real, dimension(150), target :: x, y
opérations associées constituent un pas important du for-
Si l’on veut que a pointe vers m et b vers x, cela donne :
tran en direction de la programmation orientée « objet »
au détriment, sans doute, de la simplicité originelle du a => m
langage : la norme fortran2003 la développe d’ailleurs b => x
encore davantage. Quel intérêt ? On peut, par exemple, faire pointer un poin-
-Exercice : définir un type temps composé d’heures, teur vers un morceau de tableau
minutes, secondes et une addition et une soustraction
permettant de calculer en sexagécimal (par exemple : b => x(100:150)
1h32mn24s + 2h42mn39s = 4h15mn3s). ce qui permet d’optimiser des transferts de données d’un
-Exercice : définir un type triangle défini par les co- morceau de tableau à un autre : dans certains cas on
ordonnées de ses trois sommets et une opération * d’ho- économise ainsi de l’espace mémoire.
mothétie permettant de le dilater d’un facteur réel sans
déplacer son centre de gravité.
2.14.5 Récursivité.
2.14.4 Pointeurs. fortran90 l’autorise. . . c’est parfois commode, rare-
ment efficace, du moins pour le calcul scientifique pur et
« Le fortran est un langage dépassé, vieillot, ob- dur. L’exemple que l’on donne toujours est le calcul de
solète. . . » : ce sont des propos que l’on entend depuis factorielles : la définition de n! est,
plus de vingt ans41 , or le fortran continue à être lar-
gement employé en calcul scientifique ; ce sont donc sans n! = n(n − 1)!
41 Dans les années 1980, il advint un jour que le laboratoire où productions et demandèrent quel langage on utilisait afin d’inclure
je travaillais dut acquérir une station de travail ; les représentants le compilateur dans leur devis. Quand la réponse fut : « fortran »,
d’un des fournisseurs pressentis vinrent vanter les mérites de leurs nous eûmes droit à des regards pour le moins. . . incrédules !
Cela se programme sans difficulté à condition de spécifier les bases doivent être impérativement
que la function est récursive : apprises et maı̂trisées, car sans cela, on
s’expose à patauger sans grand profit
program factorielle dans un bourbier de détails informa-
implicit none tiques sans intérêt !
integer :: n, fact
write(*,’("Entrer un entier : ",$)’) ; read(*,*) n
write(*,*)"Factorielle", n," vaut ",fact(n)
end Ces remarques achèvent la partie langage de ce cours.
Dans la suite, les exemples seront donnés en fortran,
recursive function fact(n) result(f)
mais les algorithmes étudiés ne dépendent évidemment
implicit none
pas du langage de programmation choisi.
integer :: f
if ( n > 1 ) then
f = n*fact(n-1) ! ici la fonction s’appelle
! elle-meme, c’est recursif
else
f = 1
endif
end function fact
Cinq minutes de réflexion permettent cependant de

reécrire la fonction :
integer function fact(n)

implicit none
integer :: f = 1
if ( n > 1 ) then
do i = 2, n
f = f*i ! ici, ca n’a rien de recursif
enddo
endif
fact = f
end function fact
La deuxième version est plus efficace parce que la première

devra stocker tous les résultats intermédiaires en mémoire
de façon parfaitement inutile, ce que la deuxième ne fait
évidemment pas.
La récursivité est une question importante pour
les informaticiens dans la mesure où elle leur faci-
lite considérablement la tâche dans, par exemple, des
problèmes de logique tournant autour de la décidabilité
(Entscheidungsproblem quand on veut montrer que l’on
a de l’éducation. . .). Pour un physicien qui se borne en
général à utiliser des algorithmes standards, cela reste as-
sez marginal.
Après cette première partie, on constate donc que le

langage fortran90 est très riche et que l’on peut faire
avec ce langage des choses plutôt élaborées. Il n’est bien
sûr pas utile d’apprendre tous les détails du langage en
quelques semaines, mais il est indispensable d’en avoir
une pratique suffisante pour ne pas être gêné par des
détails de programmation pendant les séances de travaux
pratiques, au cours desquelles, très rapidement, on se
préoccupera plus de physique que de langage ! Il est
recommandé d’être capable, assez rapidement, d’écrire
sans trop hésiter des programmes comportant conditions,
boucles, tableaux, sous-programmes et entrées-sorties : le
reste viendra avec la pratique, mais,
Chapitre 3
Un prototype de TP
3.1 Introduction. 3.2.1 De la multiplication des insectes.

Imaginons une population, par exemple, d’insectes,
La physique numérique requiert sans doute quelques
comportant à la génération p, zp individus. Si chaque
connaissances dont le présent cours a pour but de four-
individu donne lieu, en moyenne, à α insectes (par
nir l’essentiel. Il s’agit toutefois d’une activité essentiel-
exemple en pondant α œufs, pour mourir ensuite) à la
lement pratique : il faut écrire des programmes qui, non
génération suivante, celle-ci comportera zp+1 = α zp in-
seulement « marchent », mais aussi répondent aux ques-
tions posées de sorte que la physique du problème soit dividus. Évidemment, si α > 1, la population d’insectes
traitée de façon satisfaisante ; il faut pour cela un mini- diverge exponentiellement, une perspective sans doute
mum d’expérience pour, bien sûr, maı̂triser le langage, quelque peu effrayante mais qui ne tient pas compte des
mais en outre avoir une familiarité suffisante avec l’en- ressources disponibles, la nourriture en particulier : plus
vironnement et les méthodes afin que ceux-ci deviennent les insectes sont nombreux, plus les ressources deviennent
l’aide puissante qu’ils doivent être et non plus la gêne. . . rares pour chaque insecte qui aura donc plus de difficultés
qu’ils constituent sans conteste au début ! C’est la raison à s’assurer une descendance. Le coefficient α doit alors
pour laquelle cet enseignement comporte une part impor- décroı̂tre lorsque le nombre d’insecte augmente ; on peut
tante de travaux pratiques. alors prendre l’expression linéairement décroissante (c’est
Chacune de ces séances de TP est consacrée à un le plus simple) suivante :
problème de physique qui illustre l’usage que l’on peut zp
faire de telle ou telle méthode. Elle est précédée d’une α = r(1 − )
ζ
séance de travaux dirigés au cours de laquelle on présente
le problème, éventuellement on montre les limites du cal- où ζ est le nombre d’insectes qui épuise toutes les res-
cul analytique et on décrit les méthodes numériques qui sources au point de ne pas pouvoir donner lieu à une
seront utilisées pour le traiter. Si le problème présente des génération suivante. . . Cela donne :
difficultés particulières de programmation, celles-ci seront zp
également abordées. zp+1 = r zp (1 − )
ζ
Il est attendu des étudiants qu’ils arrivent en séance
de TP en ayant 1o pris connaissance du problème et On peut reécrire cette équation en prenant comme va-
2o avec une bonne idée de comment le résoudre et qu’ils riable
zp
en partent en rendant un compte-rendu qui compte pour xp =
ζ
la note de contrôle continu.
de sorte que 0 < xp < 1, et :
La question est évidemment : « que doit-il y avoir dans
un compte-rendu de TP ? » Comme il s’agit d’un exercice xp+1 = r xp (1 − xp )
un peu particulier, on traite ci-dessous, à titre d’exemple,
la question de l’équation logistique « à la manière » d’un ce qui constitue l’équation logistique. Il s’agit donc de
TP. . . déterminer comment se comportera la population d’in-
sectes en fonction du paramètre r.
3.2 L’équation logistique. 3.2.2 Étude préalable.

Il s’agit d’un grand classique de la physique du chaos1 , 3.2.2.1 Les points fixes.
c’est un problème qui ne nécessite pas de connaissances Existe-t-il des solutions stationnaires telles que xp+1 =
particulières en méthodes numériques et qui présente un x ? Si oui, elles doivent obeir à :
p
certain aspect ludique2 ce qui en fait un bon exemple d’une
façon de procéder. x = r x(1 − x)
1 Voir par exemple : Edward Ott, Chaos in dynamical systems, soit :
Cambridge University Press (1993), p. 31. 1
2 On pourra certes objecter que le caractère « ludique » de cette x=0 ou x=1−
r
activité dépend un peu des goûts. . . mais on postulera ici que le
public de physiciens auquel ce cours s’adresse sera sensible à ses On admettra que la solution nulle n’a guère d’intérêt
charmes. puisque dans ce cas il n’y a pas d’insectes. La solution
41
non-nulle, elle, n’existe que si r > 1 car on ne considère r = 4 n’a pas de comportement aisément caractérisable à
que les valeurs de x positives, s’agissant d’un nombre d’in- première vue.
sectes. Imaginons que l’on se trouve en xp à une distance δ,
Par ailleurs, comme xp+1 doit, comme xp , par définition, 1
petite, d’un point fixe 1 − tel que :
être inférieur à un, le maximum de la fonction f (xp ) = r
r xp (1 − xp ) doit être également inférieur à un. Il est situé 1
1 r xp = 1 − +δ
en xp = et vaut , autrement dit, r ≤ 4. Ainsi, on se r
2 4
restreindra à l’intervalle 1 < r ≤ 4 et les points fixes vont alors, en appliquant à xp l’équation logistique :
3
de 0 pour r = 1 à pour r = 4 (figure 3.1).
4 1 1
xp+1 = r (1 − ) + δ 1 − (1 − ) − δ
0.8 r r
0.7 1
= (1 − ) + δ (2 − r(1 + δ))
0.6
r
0.5 Le point xp+1 est-il plus proche du point fixe que xp ?
Point fixe
0.4
L’écart s’écrit :
0.3 1
xp+1 − (1 − ) = δ (2 − r(1 + δ))
0.2 r
≃ δ(2 − r)
0.1
0
1 1.5 2 2.5 3 3.5 4
puisqu’a priori δ est petit devant 1. Alors :
r – si r = 2, on obtient un écart nul, le système a
convergé,
Fig. 3.1 – Point fixe de l’équation logistique. – si r = 3, on obtient −δ, l’écart n’a pas diminué mais
change de signe
– si r = 4, on obtient −2δ, l’écart a augmenté en valeur
3.2.2.2 Y a-t-il convergence ? absolue et l’on peut donc s’attendre à des ennuis !
Plus généralement, si 1 < r < 3, l’écart diminue en va-
L’existence de points fixes ne signifie pas automati- leur absolue près du point fixe, et donc on s’attend à une
quement que le système doive converger vers l’un d’eux. convergence sans problème, mais si r > 3, l’écart tend à
Un façon de s’en convaincre est de faire quelques essais augmenter.
comme sur la figure 3.2 sur laquelle on a tracé les fonc- Voici donc un premier tour d’horizon sur ce problème :
tions f (x) = r x(1 − x) pour plusieurs valeurs de r et cela peut constituer la matière du TD qui précède le
g(x) = x : les points fixes sont donnés par l’intersection TP. S’il doit y avoir des subtilités de programmation à
des deux fonctions. connaı̂tre ou des algorithmes particuliers à appliquer (ce
1
r=1
qui n’est pas vraiment le cas ici), ils seront également
r=2
r=3
traités en TD.
0.8
r=4
x
Rien de ce qui précède ne doit obligatoirement figurer
dans votre compte-rendu, sinon pour vos propres ar-
0.6 chives : l’idée est qu’une séance de TP de 4 heures est
bien courte pour perdre du temps à recopier des notes
x(p+1)
0.4 prises en travaux dirigés, mieux vaut faire cela chez soi !
0.2
3.2.3 Étude numérique.
0
0 0.2 0.4 0.6 0.8 1 En revanche, le programme utilisé pour résoudre le
x(p)
problème doit impérativement être fourni, de préférence
avec des commentaires, éventuellement manuscrits, qui
Fig. 3.2 – Étude graphique de l’équation logistique. Voir permettent de savoir ce que ce programme est censé faire
le texte. et comment il le fait.
Prenons, par exemple, le cas r = 2 et partons de x0 = program logistic

0, 2. Alors, x1 = 2 × 0, 2(1 − 0, 2) = 0, 32 est donné sur la implicit none
figure par l’intersection de la ligne verticale bleue avec la ! equation logistique
parabole correspondant à r = 2. Ce x1 doit être reporté en ! evolution de la population en fonction des
! generations
abscisse pour servir de nouveau point de départ : il suffit
real :: r, x, x0 = 0.01 ! condition initiale
de tirer une ligne horizontale jusqu’à l’intersection avec
integer :: p, n=1000 ! nombre de generations
la droite g(x) = x, puis de nouveau une verticale pour !
obtenir x2 , etc. La figure paraı̂t montrer une convergence write(*,’(" R : ",$)’) ; read(*,*) r ! lecture de r
vers x = 0, 5, ce qui est bien ce que l’on attendait pour open(1, file=’logistic.res’) ! fichier de resultats
r = 2. Pour r = 3, il semble que le système ne converge do p = 1, n ! calcul et ecriture de x(p)
pas, mais suive un cycle autour du point fixe, et finalement x = r*x0*(1.-x0)
write(1,*) p, x 0.5
r=2
x0 = x
enddo 0.4
close(1)
end 0.3
x(p)
Si le résultat du calcul est juste un nombre, ce nombre 0.2
doit être fourni dans le compte-rendu et ce résultat dis-
cuté. Si le programme sert à une mise au point ou à 0.1
un essai, la comparaison avec ce qu’on attend doit être

donnée. Quand le résultat est une figure, les axes de 0
0 5 10 15 20 25 30 35 40 45 50
celle-ci doivent être identifiés (on trace quoi en fonction 0.676
p
de quoi ?) et les conditions du calcul précisées (ici la r=3

0.674
valeur de r et de la condition initiale). Des commen-
0.672
taires sur le résultat obtenu (quelle est sa signification
0.67
physique ?) sont non seulement bienvenus mais attendus
car le but n’est pas simplement d’écrire un programme 0.668
x(p)
mais de faire de la physique à l’aide de ce programme. . . 0.666
0.664
La figure 3.3 montre l’évolution de la population d’in- 0.662
sectes pour quatre valeurs de r. 0.66

– pour r = 2 le système converge rapidement vers le 0.658
950 955 960 965 970 975 980 985 990 995 1000
point fixe x = 0, 5 comme prévu (on a supprimé la fin p
du graphe pour p > 50 car il ne s’y passe rien). 0.9
r=3.5
0.85
– pour r = 3 le système oscille périodiquement (on n’a
0.8
gardé que la fin du graphe (p > 950) correspondant 0.75
à ce qui s’apparente à un régime stationnaire) autour 0.7
1
du point fixe 1 − ≃ 0, 667 : cela paraı̂t compatible 0.65
x(p)
3 0.6
avec l’intuition que l’on en avait. 0.55
– pour r = 3, 5, le système est encore périodique, mais 0.5
deux « périodes » successives sont différentes, autre- 0.45
ment dit, la période est deux fois plus longue. 0.4
– pour r = 4 le système semble se comporter de 0.35

950 955 960 965 970 975 980 985 990 995 1000
façon irrégulière : on est dans une situation de chaos p
1
déterministe. 0.9
r=4
0.8
Lorqu’on modifie un programme, il faut expliquer ce que
0.7
l’on est en train de faire, et évidemment fournir le pro-
0.6
gramme modifié agrémenté des commentaires adéquats.
x(p)
0.5
0.4
On aimerait étudier le comportement de la population
0.3
d’insectes de façon plus systématique : pour cela, il suffit
0.2
d’ajouter au programme une boucle sur r et de tracer xp
0.1
non plus en fonction de p mais en fonction de r. On prend
0
soin de ne garder que la fin du calcul pour chaque valeur 950 955 960 965 970 975 980 985 990 995 1000
p
de r afin d’éliminer un éventuel transitoire.
Fig. 3.3 – Évolution de la population d’insectes pour r =
program logistic
2, 3, 3, 5 et 4. Condition initiale x0 = 0, 01.
implicit none
! equation logistique
! diagramme de bifurcations
real :: r, x, x0
integer :: i, p, n=2000, nsav
open(1,file=’logistic2.out’) do p = 1, n
! x = r*x0*(1.-x0)
do i = 200, 400 ! boucle sur r ! le calcul est identique au precedent, mais on
r = 0.01*i ! ecrit maintenant x en fonction de r
x0 = 0.01 ! reinitialisation de x0 if ( p > n-nsav ) write(1,*) r, x
! pour chaque nouvel r x0 = x
if ( r < 3 ) then ! quand le systeme enddo
nsav = 10 ! converge, on ne garde que !
else ! quelques pas mais quand ca enddo
nsav = 1000 ! devient irregulier, on doit !
endif ! en garder davantage close(1)
! end
1
Eq. logistique
0.9 Pt fixe
0.8
0.7
0.6
x(p)
0.5
0.4
0.3
0.2
0.1
0
2 2.5 3 3.5 4
r
Fig. 3.4 – Diagramme de bifurcations pour l’équation logistique. En bleu est représentée la courbe des points fixes
théoriques.
On obtient ce qu’on appelle un diagramme de bifurca- On constatera les poids respectifs de l’informatique et de
tions (figure 3.4). la physique (il est vrai qu’en l’occurence, il s’agit plutôt
d’éco-zoologie, mais peu importe) dans ce qui précède :
En premier lieu, on constate que pour r < 3 le résultat la balance penche fortement du côté de cette dernière et
coincide parfaitement avec la courbe des points fixes c’est ainsi qu’il doit en être. Parfois au cours d’un TP, on
théoriques, ce qui est rassurant quant au bon fonction- pourra rencontrer des aspects techniques plus délicats
nement du programme (mais ne démontre en aucun cas que dans cet exemple et il faudra s’assurer avec autant
qu’il est dépourvu d’erreur !). de soin que possible que la méthode utilisée est digne de
confiance, mais le principe de base reste : « n’oublions
jamais que nous sommes des physiciens ! »
On observe ensuite qu’à partir de r = 3 la courbe se di-
vise en deux : cela signifie que pour chaque valeur de r, xp
Toutefois, après cette belle déclaration de principes, il
oscille entre deux valeurs comme sur la deuxième courbe
faut quand même s’occuper des méthodes elle-mêmes. . .
de la figure 3.3. Puis, un peu avant r = 3, 5, on a un nou-
veau dédoublement et xp prend quatre valeurs distinctes.
On observe encore un autre dédoublement pour huit va-
leurs avant de tomber dans un continuum qui signifie que
xp prend toutes les valeurs entre 0 et 1. Au-delà, on ob-
serve quelques « fenêtres d’ordre » dans les zones moins
sombres qui correspondent au fait que xp n’explore pas
toutes les valeurs du domaine.
Une étude plus poussée permettrait peut-être de vérifier

si la séquence des dédoublements suit une suite de Feigen-
baum ou d’étudier l’invariance par changement d’échelle
en calculant les dimensions fractales des domaines explorés
par xp en fonction de r.
On peut aussi préférer, à une étude du chaos d’un point

de vue mathématique, se poser la question de la validité du
modèle en introduisant des ingrédients supplémentaires,
par exemple, le fait que les ressources ne se trouvent pas
forcément à proximité des insectes et que donc leurs façons
de rechercher ces ressources (leurs « stratégies ») n’est pas
sans effet. D’éventuels prédateurs peuvent également jouer
un rôle.
Chapitre 4
Méthodes numériques.
Ce chapitre développe les principales méthodes On obtient après quelques lignes de calcul :
numériques utilisées par les physiciens : afin d’éviter
d’en faire un manuel de mathématiques appliquées, que qq ′ xq cos θ + (yq − ℓ) sin θ
sin θ + 3
d’autres seraient sans doute mieux à même de réaliser, 4πε 0 mg [(ℓ sin θ − xq )2 + (ℓ(1 − cos θ) − yq )2 ] 2
chaque méthode est illustrée par un exemple de phy-
sique puisé dans la mesure du possible dans le bagage =0 (4.1)
d’un étudiant de licence de physique, quitte à anticiper ce qui n’est pas évident à résoudre analytiquement1 .
légèrement sur certains cours (en physique quantique ou Il s’agit d’un cas particulier du problème de la recherche
en thermodynamique statistique en particulier). du ou des zéro(s) d’une fonction, c’est-à-dire trouver le ou
les x tel(s) que
f (x) = 0
4.1 Recherche des zéros d’une
Il existe deux méthodes principales pour résoudre
fonction. numériquement ce genre de problème.
Partons d’un exemple complétement académique mais
très simple : un pendule simple de masse m porte à son 4.1.1 Méthode de la dichotomie.
extrémité une charge q. On place à proximité une autre
Comme son nom l’indique, il s’agit d’une recherche dans
charge q ′ (figure 4.1). Trouver l’angle d’équilibre θ du pen-
un intervalle que l’on découpe en sous-intervalles (fig. 4.2).
dule en fonction de la valeur de q ′ .
θ
f(a)
ε
q’
q
f(b)
Fig. 4.1 – Le pendule chargé
a x b
L’énergie potentielle de gravitation du pendule peut Fig. 4.2 – Recherche de zéro par dichotomie. Les zones
s’écrire : grisées sont éliminées par la recherche. Le rectangle allongé
Vg = mgz = −mgℓ cos θ horizontalement délimite la précision ε requise.
où ℓ est la longueur du pendule et θ l’angle qu’il fait avec
la verticale ; de même, l’énergie potentielle électrostatique Admettons que sur l’intervalle [a, b] la fonction f ait un
des charges s’écrit : zéro et un seul : elle change de signe sur l’intervalle et donc
le produit f (a)f (b) est négatif. Coupons alors l’intervalle
1 qq ′ a+b
Ve = p [a, b] en deux, ce qui nous donne le point x = . Si
4πε0 (ℓ sin θ − xq )2 + (ℓ(1 − cos θ) − yq )2 2
le produit f (a)f (x) est négatif, c’est que le zéro recherché
se trouve dans l’intervalle [a, x], sinon il se trouve dans
où xq et yq sont les coordonnées de la charge q ′ . L’équilibre l’intervalle [x, b]. Il reste à rediviser en deux l’intervalle
est, comme d’habitude, donné par :
1 On pourrait tenter de poser par exemple x = sin θ et y = cos θ,
d(Vg + Ve ) avec x2 + y 2 = 1. On tomberait alors sur un polynôme de degré 8

=0 en x et y. . .
dθ
45
où se trouve le zéro et à refaire la même recherche. On

répète encore la même opération plusieurs fois jusqu’à ce xq = .1 ; yq = 0.
que la précision requise soit atteinte. Comme on répète la a = -1.57 ; b = 1.57 ; eps = 0.00001
même procédure plusieurs fois de suite, on appelle cela un
processus itératif. open(1,file=’zero.out’) ! fichier ou l’on mettra
! les resultats
Deux critères différents sont possibles pour choisir
c = 0.
d’arrêter ou non la recherche : do ! boucle pour faire varier c
– soit l’on désire une certaine précision sur la valeur de x = dicho(pendule, a, b, eps)
x et, donc, on arrête la recherche quand la longueur write(1,*) c, x
de l’intervalle devient inférieure à une valeur ε choisie c = c + 0.01
à l’avance, if ( c > 2.0 ) exit
– soit l’on veut que f (x) soit proche de zéro avec une enddo
certaine précision comme sur la figure 4.2, c’est-à-dire
|f (x)| < ε. close(1)
Une fonction informatique qui fasse cela pourrait s’écrire : end
!
real function dicho(f, a, b, epsilon) !---------------------------
! recherche de zero par dichotomie real function pendule(theta)
! f = fonction reelle dont on cherche le zero use pendu
! a et b = bornes de l’intervalle de recherche implicit none
! epsilon = precision recherchee sur la valeur de f real :: theta
! ! l = 1
! les variables y, y1, et y2 servent a conserver ! c = q*qprime/(4*pi*eps0*m*g)
! les valeurs prises par f afin d’eviter les
! calculs inutiles si f est longue a calculer pendule = sin(theta) & ! la formule occupe 3 lignes
+ c*( xq*cos(theta)-(1.-yq)*sin(theta))/ &
implicit none ((sin(theta)-xq)**2+((1.-cos(theta))-yq)**2)**1.5
real :: a, b, f, epsilon, y, y1, y2, x, x1, x2 end
La fin est bien sûr constituée de la fonction dicho. Le
x1 = a ; x2 = b ! initialisation de l’algorithme
y1 = f(a) ; y2 = f(b) résultat du calcul est donné figure 4.3.
0
! verification de l’intervalle
if( y1*y2 > 0. ) then −0.2
write(*,*) ’Intervalle mal choisi’ −0.4

stop
endif −0.6
freq_eq
−0.8
do ! *** debut de la boucle ***
x = 0.5*(x1+x2) ; y = f(x) ! dichotomie −1
if ( abs(y) < epsilon ) exit ! critere d’arret
−1.2
! de quel cote le zero se trouve-t-il ?
if ( y1*y < 0 ) then −1.4
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
x2 = x ; y2 = y ! a gauche [x1,x] C
else
x1 = x ; y1 = y ! a droite [x,x2] Fig. 4.3 – Solution du problème du pendule en fonction
endif ′
de c = 4πεqq0 mg pour ℓ = 1.
enddo ! *** fin de la boucle ***
dicho = x On constate, sans véritable surprise, que plus c (ou la

end charge) augmente, plus le pendule s’écarte de la verti-
cale. . .
L’équation (4.1) devient aisée à résoudre numéri- La méthode de la dichotomie est assez pédestre, elle
quement à l’aide d’un programme qui aurait l’allure sui- est sûre, sans surprise. Elle nécessite une connaissance
vante : préalable de la fonction puisqu’elle suppose qu’il y ait un
et un seul zéro dans l’intervalle de recherche : il faut donc
module pendu pouvoir choisir celui-ci judicieusement.
! mise en commun de variables pour
! << sauter >> par-dessus dicho
! valeur et position de la charge 4.1.2 Méthode de Newton.
real :: c, xq, yq
La méthode de Newton est à la fois plus efficace et plus
end
dangereuse. Il s’agit, à partir d’un point de départ x0 judi-
program zero cieusement choisi, d’approcher la fonction par sa tangente
use pendu et de chercher l’intersection de celle-ci avec l’axe des x.
implicit none Comme la fonction n’est pas a priori linéaire le résultat
real :: a, b, eps, dicho, x est faux, mais il constitue le point de départ d’une nou-
external pendule velle recherche (figure 4.4).
et un peu de trigonométrie élémentaire donne

a+x a−x
i1 = arctan , i2 = arctan
y y
y1 ainsi nous avons a rechercher la racine de la fonction

a+x a−x
f = n1 sin arctan − n2 sin arctan
y2 y y
x0
où x est l’inconnue. Si nous voulons utiliser la méthode de
x1 x2
Newton, nous avons besoin de la dérivée de f par rapport
y0 à x :
df n1 1 n2 1
= cos 2 + cos 2
dx y a+x y a−x
1+ y 1+ y
Fig. 4.4 – La méthode de Newton.
Le programme suivant fait exactement cela :
Si l’on part d’un point d’abscisse x0 , on doit pouvoir module params ! definition des parametres du probleme
calculer f (x0 ) et la pente de la tangente f ′ (x0 ). L’inter- implicit none
section de la tangente avec l’axe des x est donnée par real, parameter :: n1 =1.0, n2 = 1.5, a = 1., y = 1.
end module params
f (x0 )
x1 = x0 − ′
f (x0 ) program decartes
use params
Il suffit de répéter l’opération pour x1 , x2 ,. . . implicit none
real, parameter :: eps = 1.e-5 ! precision requise
f (xn )
xn+1 = xn − real :: newton
f ′ (xn ) external :: trajet
real :: x = 0. ! condition initiale
jusqu’à ce que le critère de convergence que l’on aura choisi
! ce programme ne comporte qu’une instruction
soit vérifié.
write(*,*) newton(x,trajet,eps), &
Imaginons, par exemple, que l’on veuille chercher la n1*sin(atan((a+x)/y)) - n2*sin(atan((a-x)/y))
point d’intersection d’un rayon lumineux avec un dioptre end
en utilisant la loi de Descartes (figure
4.5) : le rayon part
−a subroutine trajet(x, f, df ) ! calcul de la fonction
d’un point de coordonnées dans un milieu d’in-
y use params ! et de sa derivee
a implicit none
dice n1 pour arriver en un point de coordonnées real, intent(in) :: x
−y
dans un milieu d’indice real, intent(out) :: f, df
n2 , en passant par le dioptre au
real :: r1, r2
x
point de coordonnées . L’inconnue du problème est r1 = (a + x)/y ; r2 = (a - x)/y
0
x. f = n1*sin(atan(r1)) - n2*sin(atan(r2))
df = n1*cos(1./(1.+r1**2))/y + &
n2*cos(1./(1.+r2**2))/y
end
n1
y real function newton(x,f,eps) ! methode de Newton
implicit none
i1 integer :: i, imax = 100 ! nombre max d’iterations
real :: x, eps, xp, y, d
do i = 1, imax
a a
call f(x, y, d)
xp = x - y/d
if (abs(xp-x) < eps ) exit
i2
x y x = xp
enddo
n2
newton = xp
end
Fig. 4.5 – Loi de Descartes : notations pour utiliser la Cela donne : 0.36264408 -0.000014537249. On laissera
méthode de Newton le soin au lecteur de vérifier que c’est correct. . .
La méthode de Newton a plusieurs avantages par rap-
La loi de Descartes s’écrit évidemment port à la méthode de la dichotomie. Elle est en général
beaucoup plus rapide, ce qui dans certains cas peut
n1 sin i1 = n2 sin i2 s’avérer décisif. Elle a par ailleurs le très gros avantage
0.8
de pouvoir se généraliser aisément à plusieurs dimensions tanh(x)−0.3*x
tanh(x)/x−0.3
comme on le verra dans la suite. Elle a l’inconvénient 0.6
qu’il faut pouvoir calculer, ou au moins estimer la dérivée
de la fonction, ce qui est parfois un peu laborieux (voir 0.4
l’équation (4.1) par exemple).
Elle recèle toutefois quelques pièges parfois redoutables. 0.2
Si par exemple, l’un des points xn est tel que f ′ (xn ) ∼ 0,
0
le point xn+1 risque de se trouver projeté fort loin du
point de départ2 , un résultat contrariant alors qu’il s’agit −0.2
d’une recherche en principe locale puisque basée sur une
approximation linéaire. Un deuxième piège est que si la −0.4
fonction étudiée possède plusieurs zéros, rien ne permet
de choisir à coup sûr celui que l’on veut puisqu’il n’y a −0.6
−4 −2 0 2 4
pas d’intervalle de recherche pré-défini : on peut certes
forcer le résultat à rester dans un intervalle donné. Parfois, tanh(x)
Fig. 4.6 – Les courbes de tanh(x) − 0.3x et de −
enfin, l’algorithme ne converge pas, même si une solution x
existe, en cas de changement de courbure malencontreux 0.3 montrant que la deuxième permet d’éliminer la racine
par exemple : un choix plus judicieux du point de départ triviale pour x = 0 alors que les deux autres racines ne
peut régler le problème. sont pas affectées.
4.1.3 Comment s’y prendre ? 1. l’algorithme lui-même peut-être plus ou moins précis
Les paragraphes précécents décrivent deux méthodes 2. les nombres avec lesquels travaille l’ordinateur sont
différentes pour résoudre le même type de problème, cha- eux-mêmes définis avec une certaine précision.
cune avec ses qualités et ses défauts. En consultant des Par exemple, la méthode de la dichotomie, détermine un
ouvrages spécialisés, on s’apercevra rapidement qu’il en zéro en l’encadrant par un intervalle d’étendue b − a, puis
existe d’autres. Comment procéder, alors ? b−a b−a
La première étape est de tenter de dégrossir qualita- , . . ., . Comme le nombre d’itérations est fini,
2 2n
tivement le problème par des résolutions graphiques par cela donne la précision du calcul intrinsèque à la méthode.
exemple, soit à l’aide de programmes de tracé de courbes Toutefois, même un algorithme parfait, s’il existait, ne
comme gnuplot, soit avec une calculette graphique, soit. . . pourrait pas donner des résultats infiniment précis à cause
à la main, ce qui est parfois le plus efficace car programmes du caractère fini de l’ordinateur lui-même qui ne peut pas
et calculettes travaillent toujours dans un intervalle défini représenter un nombre de façon parfaite.
a priori et ne disent rien sur ce qui se passe à l’extérieur
de cet intervalle, en particulier les asymptotes.
La deuxième étape est souvent de tenter de reformuler 4.2.1 Les nombres entiers.
le problème de façon qu’il n’y ait qu’un seul zéro dans le Il a été mentionné que les nombres avaient une
domaine « utile ». Par exemple, rechercher le zéro de représentation binaire, c’est-à-dire constituée de 0 et de
tanh x − ax = 0 1. Ainsi pour les nombres entiers, on obtient la correspon-
dance habituelle entre représentation décimale (1ère ligne)
pour a < 1 donne trois solutions dont une solution triviale et binaire (2ème ligne) :
pour x = 0 (figure 4.6) ; or l’ordinateur ne « sait » pas 0 1 2 3 4 5 6 7 8 ...
qu’elle est sans intérêt. Il peut être habile alors de chercher 0 1 10 11 100 101 110 111 1000 ...
plutôt les solutions de Une case contenant un 0 ou un 1 s’appelle un bit.
Dans l’immense majorité des ordinateurs, les bits sont re-
tanh(x) groupés par groupes de huit, les octets, ou bytes en an-
−a=0
x glais. Un octet constitue généralement un emplacement
qui élimine la solution triviale si a 6= 1, puisque correspondant à une adresse dans la mémoire vive de l’or-
dinateur. Le tableau ci-dessus devrait donc se reécrire :
tanh(x) 0 1 2 3 4
lim =1 00000000 00000001 00000010 00000011 00000100
x→0 x
5 6 7 8 ...
C’est alors qu’on peut choisir une méthode, Newton si 00000101 00000110 00000111 00001000 ...
le problème s’avère assez « civilisé » dichotomie sinon. Avec un octet on peut donc représenter les nombres
entiers allant de 0 à 28 − 1 = 255 : c’est un peu limité, car
4.2 Représentation des nombres on aimerait pouvoir utiliser, d’une part, des nombres plus
grands et, de l’autre, des nombres négatifs.
dans un ordinateur. Pour pouvoir représenter les nombres négatifs, on doit
changer la convention et l’on prend le complément à
Dans ce qui précède, on a introduit, sans trop insister, deux, soit, toujours sur un octet : 00000001 = 1 et
la notion de précision du résultat. Cette précision n’est 11111110 = −1 au lieu de 254. Ainsi de 00000000 = 0
jamais absolue pour plusieurs raisons. à 01111111 = 127 on code des nombres positifs et pour
2 Shot off to outer space comme disent joliment nos collègues les nombres négatifs, 11111110 = −1, 11111101 = −2,
américains. . . ., jusqu’à 11111111 = −128. On peut vérifier qu’avec
cette convention l’addition suivante est correcte : précision machine, vaut 1000 : peu importe que l’on répète
−4 11111011 l’opération un milliard de fois ! Finalement 1000 − 1000 =
+2 00000010 0. . . En déclarant s en double precision on obtient :
= −2 11111101 0.9999894254
Afin d’avoir une plage de nombres accessibles plus Il faut donc être assez méfiant lorsqu’on traite des
grande, les octets sont généralement regroupés par en- nombres qui prennent des valeurs très différentes. Il est
sembles de quatre (appelés mots), soit 32 bits3 . Ainsi les aussi prudent de se rappeler que lorsqu’on fait des calculs
nombres entiers peuvent aller de −231 = −2 147 483 648 à itératifs, ce qui est très souvent le cas, les erreurs peuvent
231 − 1 = 2 147 483 647, ce qui est largement suffisant pour s’ajouter les unes aux autres pour ne plus être négligeables
la plupart des applications, mais, évidemment, pas infini. du tout !
Un deuxième cas de figure classique est le suivant :
4.2.2 Les nombres réels. if( a == 0. ) then
où a est un réel. Le résultat d’une telle instruction est
Parler de nombres réels est un abus de langage puisque
aléatoire à cause des erreurs d’arrondi ! En effet, si a est le
l’on
√ ne peut traiter que les nombres rationnels. Ainsi, résultat de calculs longs et compliqués, va-t-il tomber pile
2 sera approximé par, par exemple, 1,414213562. De
sur zéro ou sur 0.1234567E-35 ? Il vaut bien mieux définir
plus, on est obligé de se restreindre encore davantage aux
a priori la précision souhaitée et donner l’instruction :
nombres rationnels à un nombre fini de chiffres : 1/3 de-
if( abs(a) < epsilon ) then
vient par exemple 0,3333333333. Un tel nombre rationnel,
si la valeur absolue de a est plus petite que ε, alors. . .
si l’on supprime la virgule, est un nombre entier : il suf-
fit de préciser l’emplacement de la virgule, par une puis-
Ainsi, une règle d’or à ne jamais oublier lors-
sance de 10, par exemple. Ainsi, 1,414213562 peut s’écrire
qu’on fait des calculs numériques est de vérifier
1414213562 10−9 . Une autre façon de s’y prendre serait :
sur des cas dont on connait la solution que les
0, 1414213562 101 . L’avantage de la deuxième est que l’ex-
programmes que l’on a écrits donnent bien la so-
pression des chiffres composant le nombre est comprise
lution attendue. . . tout en sachant qu’il ne s’agit
entre 0 et 1, chaque chiffre correspondant non plus à une
en aucun cas d’une garantie !
puissance positive de 10 mais à une puissance négative.
Il faut donc trois choses : le signe, la position de la vir-
gule (ou l’exposant), et les chiffres (la mantisse). Le raison- 4.3 Suites et séries.
nement mené jusqu’à présent avec une notation décimale
peut-être tout aussi bien fait en binaire. 4.3.1 Généralités et premières difficultés.
Ainsi un nombre réel s’écrit, en général sur quatre oc-
tets, soit 32 bits : 1 bit pour le signe, 8 bits pour l’exposant Une suite est définie par une relation de récurrence du
qui donne une puissance de 2 puisqu’il s’agit de nombres type :
binaires, 23 bits pour la mantisse ; or le premier bit de la un = f (un−1 , un−2 , . . . , un−p )
mantisse est toujours 1 (sinon, il faudrait diminuer l’expo-
sant de 1), donc on l’omet ce qui permet de gagner un bit où un est une fonction de l’élément de la suite précédent
significatif. ou de plusieurs éléments précédents. Par exemple, la fac-
Dans ces conditions, les nombres réels peuvent s’étendre torielle :
de ±1, 175494 10−38 à ±3, 402823 1038 avec sept chiffres n! = n(n − 1)! avec 1! = 1
significatifs. Si cela ne suffit pas, on peut utiliser la double
Une série s’écrit comme :
precision sur 8 octets qui donne 15 chiffres significatifs
de 2, 225074 10−308 à 1, 797693 10308 . Certaines machines n
X
acceptent aussi les real*16 sur 16 octets. . . sn = ui ou bien sn = sn−1 + un
i=1
4.2.3 Conséquence. Il n’est pas utile de faire un tableau contenant tous les
La conséquence de tout ceci est que les calculs se font termes de la suite ou de la série, car on n’a en général
avec une certaine précision intrinsèque (qui est a priori besoin que du dernier terme : c’est le reproche que l’on
bonne : sept chiffres significatifs. . .). Imaginons toutefois faisait à la récursivité. Dans le cas de la factorielle, il suffit
le programme, certes stupide, suivant : d’écrire quelque chose qui ressemble à
implicit none f = 1
integer :: i do i = 2, n ; f = f*i ; enddo
real :: s
s = 1000. en faisant croı̂tre i dans une boucle. Pour une série, cela
do i = 1, 1000000000 deviendrait :
s = s + 1e-9
enddo s = ... ! expression du premier terme
write(*,*) s-1000. do i = 2, n
end s = s + .... ! expression du terme general
enddo
Le résultat obtenu est 0. et non 1. ! La raison en est
4 Le résultat précis dépend du type de la machine utilisée, du
que l’on ajoute 1000 + 1 10−9 ce qui, compte tenu de la
compilateur : ici, il s’agit d’une machine Linux avec g77. Parfois il
3 Certaines machines, comme les Cray ou certaines stations de peut être judicieux d’essayer le même programme sur deux machines
travail, utilisent des mots de huit octets, soit 64 bits. différentes avec deux compilateurs différents.
4.3.1.1 Précision. désastreuses6. Ce serait d’autant plus impardonnable qu’il

existe une solution très simple au problème :
Il faut être prudent lors du calcul d’une suite car la
remarque du paragraphe 4.2.3 s’applique tout à fait et Pn (x) = (. . . ((an x + an−1 )x + an−2 )x + . . .)x + a0
l’on a parfois des surprises. Par exemple, la série :
et cela se programme sans difficulté à l’aide d’une boucle
x 2n−1 décroissante :
sn (x) = sn−1 (x) + (−1)n−1 , avec s1 (x) = x
(2n − 1)! real function polyn(x,a,n) ! schema de Horner
integer :: i, n
est simplement le développement de la fonction sinus li- real, dimension(0:n) :: a
mité à l’ordre 2n − 1. Le programme suivant est l’applica- real :: x, pn
tion directe de cette formule : pn = a(n)
do i = n-1, 0, -1
implicit none pn = pn*x + a(i)
real :: x, s enddo
integer :: n, i, p, f, l polyn = pn
n = 17 ! indice du dernier terme end
x = acos(-1.0)/2 ! calcul de pi/2
f = 1 ; s = x ; l = 1 ! initialisations
On aurait tort de se priver !
do i = 2, n
p = 2*i-1 ! exposant 4.3.2 Calcul des intégrales.
f = f*(p-1)*p ! factorielle
l = -l ! changement de signe Toutes les intégrales ne sont pas calculables analyti-
s = s + l*x**p/f quement malgré les tables et les programmes de calcul
enddo formel, et c’est parfois bien utile de pouvoir les évaluer
write(*,*) sin(x), s, s-sin(x) ! comparaison numériquement.
end Par exemple, admettons que l’on ait un fil chargé. Le fil
est décrit par trois coordonées en fonction d’une abscisse
À l’ordre n = 17, ce qui correspond en fait à un curviligne s : (x(s), y(s), z(s)) et sa charge par une densité
développement limité à l’ordre 33 en x, on obtient pour linéique σ(s). Le potentiel électrostatique en un point de
x = π2 , le résultat s=0.9964 au lieu de un, un résultat coordonnées (x0 , y0 , z0 ) s’écrit :
un peu décevant pour un ordre aussi élevé. Pire, si l’on
tente d’aller plus loin, n = 18, on obtient -INF. . . C’est V (x0 , y0 , z0 ) =
simplement que l’on est en train d’additionner des termes Z s1
1 σ(s) ds
de signes opposés et que la différence des valeurs absolues p
est petite, donc ils se compensent en grande partie deux à 4πε0 s0 (x(s) − x0 ) + (y(s) − y0 )2 + (z(s) − z0 )2
2
deux ; le résultat est entaché d’une erreur relative impor-

tante. Si l’on essaye d’aller trop loin pour réduire l’erreur,
les factorielles se mettent à produire des nombres gigan-
tesques ! Il se trouve que pour ce genre de calcul, ce n’est
pas la bonne méthode : il vaut mieux utiliser les polynômes
dits « de Tchebytchev »5 .
On peut en tirer deux conclusions. La première est que
sommer des termes sans prendre de précautions est par-
fois dangereux. La deuxième est que, lorsqu’on peut le
faire, il est bon de classer les termes que l’on doit som-
mer par ordre croissant de telle façon à éviter autant que
possible les additions de termes d’ordre de grandeurs très
différents. Fig. 4.7 – Un fil chargé.
Si l’allure du fil ressemble à celui de la figure 4.7, une

4.3.1.2 Polynômes : le schéma de Horner. intégration numérique sur ordinateur peut être une solu-
tion de bon goût !
Le calcul d’un polynôme est un bon exemple de ce qui
a été dit ci-dessus. Soit : 4.3.2.1 Méthode des rectangles.
n
X C’est la plus simple : il s’agit de remplacer une intégrale
Pn (x) = aℓ xℓ par une somme finie (voir la figure 4.8) :
ℓ=0
Z b n−1
X b−a
Ne pas tenter de faire la somme ci-dessus directe- f (x) dx ∼ f (a + iδx )δx avec δx =
ment ! En effet les puissances successives de x produi- a i=0
n
ront sans aucun doute des termes dont les ordres gran- 6 Numerical Recipes (voir bibliographie, référence [3]), qui n’y va
deurs seront extrêmement variables, avec des conséquences pas avec le dos de la cuillère, va jusqu’à menacer : « Come the (com-
puter) revolution, all persons found guilty of such criminal behaviour
5 Voir par exemple dans les Numerical Recipes, référence [3] dans will be summarily executed » ! L’humour est sans doute douteux,
la bibliographie. mais le message est clair.
on remplace le calcul de la surface par une approximation soit en regroupant les termes identiques :
constituée d’une somme de surfaces de rectangles. !
Z b n−1
X
1 1
f (x) dx ∼ δx f (a) + f (a + iδx ) + f (b)
a 2 i=1
2
on retrouve une formule très similaire à celle de la méthode

des rectangles, mais elle est symétrisée et les termes
extrêmes sont divisés par deux : en fait, il s’agit d’une
méthode des rectangles centrée dans laquelle les points
extrêmes « pèsent » moitié moins (figure 4.10).
Methode des rectangles a gauche Methode des rectangles a droite
Fig. 4.8 – Les deux variantes de la méthode des rectangles.
Une autre approximation tout aussi légitime serait :

Z b n
X
f (x) dx ∼ f (a + iδx )δx
a i=1
La seule différence est dans les bornes de la somme qui

maintenant démarre en i = 1 au lieu de zéro. Cela revient
à évaluer la valeur de la fonction à droite de l’intervalle au Fig. 4.10 – Schéma équivalent à la méthode des trapèzes.
lieu de l’évaluer à gauche. C’est pour cela que ces méthodes
sont appelées méthodes des rectangles à gauche pour l’une, Le résultat en est un gain d’un ordre de grandeur sur
à droite pour l’autre. En principe, plus n est grand, plus les l’incertitude du résultat.
deux résultats doivent être proches : gare aux problèmes
d’arrondis numériques toutefois si n est trop grand !
4.3.2.3 Recherche du pas d’intégration.
4.3.2.2 Méthode des trapèzes. La grosse différence entre une intégration numérique et
l’expression mathématique est que le pas d’intégration δx
Une méthode moins primitive et à peine plus compliquée ne tend pas vers zéro, dans un calcul numérique, il prend
est la méthode des trapèzes (figure 4.9). une valeur finie non nulle : c’est une approximation, il
reste à choisir cette valeur de la façon la moins arbitraire
possible.
Une première méthode serait de choisir δx arbitraire-
ment, faire le calcul d’intégrale, puis choisir une autre va-
leur et refaire le calcul. Si les deux résultats diffèrent d’une
quantité moindre que la précision souhaitée, c’est que le
calcul est « indépendant » de δx .
Il n’est pas interdit d’essayer de systématiser un peu ce
genre de recherche. Commençons par choisir δx = b − a,
alors une première estimation de l’intégrale par la méthode
des trapèzes serait :
f (a) + f (b)
S0 = (b − a)
2
Pour une deuxième estimation, on peut alors diviser δx
Fig. 4.9 – La méthode des trapèzes. par deux, on obtient alors :

(b − a) f (a) a+b f (b)
La surface du i-ième trapèze s’écrit : S1 = +f +
2 2 2 2
1 S0
si = (f (a + (i − 1)δx ) + f (a + iδx )) δx = + R1
2 2
et donc : avec, en posant h = b − a :
Z b Xn
1 h a+b
f (x) dx ∼ (f (a + (i − 1)δx ) + f (a + iδx )) δx R1 = f
a i=1
2 2 2
ce qui évite d’avoir à recalculer les deux points extrêmes. sp = s/2 + r*hm
On redivise le pas par deux, puis de nouveau encore, ! ---> le test force au moins quatre iterations
etc. Un calcul simple donne alors le terme général de la if( abs(s-sp) < eps .and. n > 3 ) exit
récurrence : s = sp
enddo
Sn−1 trapeze = sp
Sn = + Rn
2 end
2n−1
h X h
Rn = f a + (2i − 1) n 4.3.2.4 Un exemple : le principe de Fermat
2n i=1 2
Imaginons un rayon lumineux qui circule dans une fibre
On arrête le calcul lorsque l’écart entre deux résultats suc- optique cylindrique, parallèle à x, dont l’indice dépend de
cessifs est inférieur à la précision requise : la distance à l’axe :

|Sn − Sn−1 | < ε r2
n = n0 1 − 2
2ρ
C’est cependant une méthode qui n’est totalement dénuée
où n0 et ρ sont des constantes. Il s’agit d’une fibre à gra-
de danger : soit par exemple la fonction suivante (figure
dient d’indice qui permet de piéger, pour ainsi dire, le
4.11),
rayon lumineux au centre de la fibre. Si l’on se place dans
le plan xOy, r2 se ramène à y 2 et chercher le trajet du
1 rayon lumineux revient à chercher la fonction y(x). Une
incursion dans le cours d’optique fournit l’équation de pro-
0.8 pagation d’un rayon lumineux :

0.6
d~r
d n
ds ~ n
= grad (4.2)
0.4 ds
où s est l’abscisse curviligne sur le rayon du point ~r. Ceci
0.2
se résoud analytiquement assez aisément à condition de se
placer dans l’approximation où le rayon ne s’éloigne pas
0
−2 −1.5 −1 −0.5 0 0.5 1 1.5 2 trop de l’axe de la fibre, de façon que sa pente par rapport
à l’axe reste faible, de sorte que l’on puisse identifier ds à
Fig. 4.11 – Si l’on ne prend pas de précautions, l’intégrale dx. On obtient :
de cette fonction sera nulle !  
d~r ∂n
d n = 0
dx  ∂x 
=
si x < 0, 5 ou si x > 1, 5 f (x) = 0 dx ∂n n0 y 
= − 2
sinon f (x) = 1 ∂y ρ
que l’on souhaite intégrer de a = −2 à b = 2. La première soit, après quelques manipulations simples,
étape donne zéro, et . . . la deuxième aussi. L’écart est nul d2 y n0 y
et donc inférieur à ε : le programme s’arrêtera. La même n 2 =− 2
dx ρ
mésaventure arrive si l’on cherche
Z π Il reste à approximer n par n0 , puisqu’on ne s’éloigne pas
sin(x)dx de l’axe de la fibre, et à chercher des solutions du type :
−π
2π
y(x) = a sin x
on trouve le résultat correct (soit 0), mais complètement λ
par hasard ! Il vaut mieux restreindre le calcul de 0 à π.
pour obtenir :
Comme souvent dans ce genre d’activités, un minimum de
λ = 2πρ
circonspection s’impose.
Un sous-programme pourrait donner quelque chose qui On obtient alors une trajectoire sinusoı̈dale de période
ressemble à : 2πρ indépendante de l’amplitude des oscillations : c’est
intéressant pratiquement, car ainsi le rayon, même si, ini-
double precision function trapeze(f, a, b, eps)
tialement, il n’est pas parfaitement dans l’axe, se bornera
implicit none
double precision :: f, a, b, eps, s, h, r, sp, hm
à osciller autour de celui-ci au cours de sa propagation.
integer :: n, m, i Tout ceci reste cependant un peu formel et entaché d’ap-
proximations.
h = b-a ; m = 1 Un cours d’optique normalement constitué affirme
s = h*(f(a)+f(b))*0.5d0 généralement -voire même démontre- que l’équation 4.2
do n = 1, 20 ! 20 iterations max est une conséquence du principe de Fermat qui veut que
m = 2*m ! 2**n le chemin optique ne dépende pas d’un petit changement
hm = h/m ; r =0. de trajectoire, soit :
do i = 1, m/2 ! de 1 a 2**(n-1) Z l
r = r + f(a+(2*i-1)*hm)
enddo L = n ds est un extremum
0
L
Pour le vérifier, calculons dans le cas de la trajectoire 4.3.2.5 Intégrales indéfinies.
λ
sinusoı̈dale ci-dessus : Dans toutes les discussions ci-dessus, seules les
Z λ 2
intégrales définies ont été abordées. On ne peut pas calcu-
L n0 y
= 1 − 2 ds ler par ces méthodes des intégrales du type :
λ λ 0 2ρ
or Z ∞
s 2 f (x)dx
dy
ds2 = dx2 + dy 2 ⇒ ds = dx 1 + −∞
dx
On a essentiellement deux solutions :
soit l’intégrale suivante à calculer :
1. la fonction f (x) doit tendre vers zéro lorsque x →
L
= ±∞, sinon le résultat est infini, alors on peut faire
λ l’approximation :
Z λ !s 2
2 2 2πx
n0 a sin λ 2π 2πx Z ∞ Z b
1− 1 + a2 cos2 dx
λ 0 2ρ2 λ λ f (x)dx ∼ f (x)dx
−∞ a
(4.3)
Choisissons de nous intéresser au cas où a est petit par avec a et b suffisamment grands en valeur absolue
rapport à λ : on peut alors développer la racine carrée : pour que l’erreur soit négligeable. Par exemple,
L Z ∞ Z 5σ
∼ x2 x2
λ e− σ2 dx ∼ e− σ2 dx
Z ! 2 ! −∞ −5σ
n0 λ a2 sin2 2πx
λ a2 2π 2 2πx
1− 1+ cos dx n’est pas une mauvaise approximation.
λ 0 2ρ2 2 λ λ
peut ensuiteR éliminer le terme en a4 et sachant que 2. une méthode plus élégante est de découper l’intégrale
ROn2π 2 2π 2 Z ∞ Z a Z b Z ∞
0
sin x dx = 0 cos x dx = π, on finit par avoir :
f (x)dx = f (x)dx + f (x)dx + f (x)dx
L a2 a2 π 2 −∞ −∞ a b
∼ n0 1 − 2 + 2
λ 4ρ λ
et de faire des approximations pour les extrémités,
La condition pour que L ne dépende pas de a est que : sur la base d’un développement limité par exemple.
λ = 2πρ Une illustration physique simple pourrait être une dis-
tribution linéique de charges sur une pelote de ficelle
ce qu’on avait déjà trouvé auparavent : l’intérêt du se-
de forme compliquée mais dont les extrémités vont à
cond calcul étant de montrer que le chemin optique ne
l’infini. Le potentiel créé à l’origine pourrait s’écrire :
dépendant pas de a, une source de lumière cohérente
placée à l’entrée de la fibre sur son axe, et produisant Z ∞
1 σ(s)
un faisceau non totalement parallèle, donnera, en sortie V = p ds
4πε0 −∞ x2 (s) + y 2 (s) + z 2 (s)
de la fibre, un faisceau qui n’aura pas perdu sa cohérence,
malgré la divergence. où, σ, x, y et z sont des fonctions connues de l’abs-
0
cisse curviligne s. Admettons qu’une approximation
serait que lorsque s > b alors σ ∼ sς et que
−0.01 p
−0.02 x (s) + y 2 (s) + z 2 (s) ∼ s. On obtient alors,
2
−0.03 Z ∞ Z ∞
σ(s) ς ς
L/lambda − n0
−0.04 p ds ∼ 2
ds =
−0.05 b
2 2
x (s) + y (s) + z (s)2
b s b
−0.06
La même approximation pour s < a donnerait en fin
−0.07
de compte :
−0.08
" Z b #
−0.09
1 ς σ(s) ς
−0.1 V = − + p ds +
0 0.2 0.4 0.6 0.8 1 4πε0 a a x2 (s) + y 2 (s) + z 2 (s) b
a
Fig. 4.12 – L’intégrale L où la partie centrale serait calculée par la méthode
λ − n0 en fonction de a calculée
numériquement par la méthode des trapèzes. des trapèzes.
On peut également utiliser des méthodes similaires autour
On est toutefois en droit de se demander quelle est de points singuliers à condition de les avoir identifiés au
la validité des approximations que l’on a faites : pour préalable.
cela, il suffit d’intégrer numériquement l’équation (4.3)
(Exercice : le faire ! 7 ) en faisant varier a pour λ = 2πρ :
cela donne la figure 4.12 ; on constate que tant que a < 4.4 Échantillonnages, interpola-
0.5ρ, l’erreur reste inférieure à 0.01, (pour L ∼ 1.5) ce tion.
qu’on n’aurait probablement pas deviné sinon.
7 prendre par exemple ρ = 1 et n = 1.5. On calculera en double
0
On a vu, pour le problème de l’intégration, l’impor-
precision. tance du pas d’intégration : c’est déjà une première forme
d’échantillonnage puisqu’une fonction définie sur un mor- 4.4.1 Interpolation linéaire.

ceau de l’axe réel se trouve réduite à un ensemble discret
C’est la plus simple : si x est compris entre xℓ et xℓ+1 ,
de points.
on écrit la fonction approchée pℓ (x),
De même, lorsqu’on demande à un logiciel comme
gnuplot (ou à une calculette graphique, d’ailleurs) de tra- f (xℓ+1 ) − f (xℓ )
cer le graphe d’une fonction, sin x par exemple, il cal- pℓ (x) = f (xℓ ) + (x − xℓ ) (4.4)
xℓ+1 − xℓ
cule les valeurs de la fonction en un certain nombre de
points, reliés ensuite par des lignes droites ; en général, ce qui revient à considérer la fonction comme localement
les « options par défaut » permettent d’éviter de préciser linéaire. L’erreur est évidemment d’autant plus grande que
comment on veut que ce choix de points soit fait, ce la courbure de la fonction est grande.
qui donne une fausse impression d’évidence au choix de
l’échantillonnage. 4.4.2 Approximation parabolique.
1
0.8
0.6
0.4
0.2
0
−0.2
−0.4
−0.6
−0.8
−1
−10 −5 0 5 10
Fig. 4.13 – Le graphe de la fonction sin(100x) tracé sans

précaution particulière.
Fig. 4.14 – Approximation linéaire et approximation pa-
Il arrive toutefois, comme on peut le constater sur la rabolique autour du point situé en x=0.5.
figure 4.13, que le résultat ne soit pas à la hauteur des
espérances ! Dans cet exemple, en effet, on a tenté de tra- Pour tenir compte de la courbure, on peut remplacer
2π
cer une fonction périodique de période 100 à l’aide d’un l’approximation linéaire par une parabole qui, cette fois
échantillonnage de 100 points sur un intervalle de longueur doit passer par trois points. Ainsi :
20, soit un pas d’échantillonnage de 0, 2 plus grand que la
période de la fonction. . . échec assuré, encore fallait-il le pℓ (x) = aℓ x2 + bℓ x + cℓ
prévoir8.
de façon que :
Ainsi, une fonction9 y = f (x) pour un ordinateur est
toujours représentée en fin de compte par un nombre pℓ (xℓ−1 ) = f (xℓ−1 )
fini de points, c’est-à-dire par un nombre fini de couples
(xi , yi ). Dans le cas du sinus, bien sûr, on peut toujours pℓ (xℓ ) = f (xℓ )
calculer des points supplémentaires si l’aspect de la courbe pℓ (xℓ+1 ) = f (xℓ+1 )
n’est pas convenable. Cependant, ce n’est pas toujours
possible, soit parce que le temps de calcul à investir se- On obtient aisément :
rait trop long, soit parce qu’il s’agit de données obtenues (x − xℓ )(x − xℓ+1 )
autrement, expérimentalement par exemple, et qu’il n’est pℓ (x) = f (xℓ−1 )
(xℓ−1 − xℓ )(xℓ−1 − xℓ+1 )
pas question de refaire l’expérience avec, mettons, cent fois
plus de points. . . or il peut arriver que l’on ait besoin de (x − xℓ+1 )(x − xℓ−1 )
+ f (xℓ )
connaı̂tre la valeur de la fonction entre deux points. (xℓ − xℓ+1 )(xℓ − xℓ−1 )
On peut, bien souvent, s’en sortir quand même à l’aide (x − xℓ−1 )(x − xℓ )
+ f (xℓ+1 )
d’approximations moyennant quelques hypothèses. (xℓ+1 − xℓ−1 )(xℓ+1 − xℓ )
ceci est valable dans l’intervalle [xℓ − h2 , xℓ + h2 ] où, bien

8 le
logiciel gnuplot permet de définir le nombre de points que l’on sûr, h est l’intervalle entre deux points successifs.
veut sur un intervalle : par exemple set samples 1000 indique que
A priori cette approximation est meilleure que la
dorénavent l’intervalle sera décrit pas 1000 points (au lieu de 100,
la valeur par défaut). Cependant, tenter de résoudre le problème précédente, permettant une bonne description de la fonc-
de cette façon serait dans ce cas décevant parce qu’on obtiendra tion avec un nombre de points plus faible ; il y cependant
selon toute vraisemblance un écran tout noir. . . Il est vrai que vou- une hypothèse importante derrière cela, c’est que la fonc-
loir tracer une courbe de période 2π/100 ≃ 0,0628 sur un intervalle
[−10, 10], c’est chercher la difficulté.
tion ne se livre pas à des excentricités entre deux points
9 Au sens mathématique, bien sûr, il ne s’agit pas de la function successifs, par exemple, qu’il n’y ait pas de point singulier
fortran. ou de variations énormes entre deux points connus.
4.4.3 Polynômes de Lagrange.

Il est aisé quoique rapidement fastidieux de généraliser
la méthode ci-dessus à un polynôme de degré n quel-
conque. On obtient un polynôme passant par les n + 1
points (x0 , f (x0 )), . . ., (xℓ , f (xℓ )) . . ., (xn , f (xn )) :
pn (x) =
n
X (x − x0 ) . . . (x − xℓ−1 )(x − xℓ+1 ) . . . (x − xn )
f (xℓ )
(xℓ − x0 ) . . . (xℓ − xℓ−1 )(xℓ − xℓ+1 ) . . . (xℓ − xn )
ℓ=0
dans les produits du numérateur et du dénominateur de la

fraction ci-dessus, manquent évidemment les termes x−xℓ
et . . . xℓ − xℓ !
Le choix du degré le plus approprié pour le polynôme
n’est pas facile. Une bonne règle est de ne pas essayer de Fig. 4.15 – Derivée d’un sinus affecté d’un léger bruit. La
trop bien faire ! En effet le choix d’un degré trop élevé, bien dérivée, elle, est affectée d’un fort bruit, même si l’allure
loin d’améliorer l’interpolation, risque de produire des os- générale est convenable.
cillations complétement erratiques de l’interpolation entre
les points connus. Il est bien rare qu’un degré supérieur
à 3 se justifie vraiment, c’est en général le signe que l’on
4.5 Algèbre linéaire.
commence à manquer de données de références : peut-être
4.5.1 Un exemple : la diffusion de la cha-
est-il temps alors d’envisager de faire quelques points de
mesure expérimentaux supplémentaires. . . L’informatique, leur à une dimension.
contrairement à la magie, ne peut pas tout faire, en par- La loi de Fourier de diffusion de la chaleur dit simple-
ticulier inventer des données numériques manquantes ! ment que le flux de chaleur en un point est proportionnel
au gradient de température :
4.4.4 Dérivées. ~ r ) = −κ(~r) grad
φ(~ ~ T (~r)
Les mêmes méthodes permettent en principe une où κ(~r) est la conductivité thermique qui dépend de la
évaluation des dérivées successives d’une fonction puis- nature du milieu. Si celui-ci est homogène, κ est une
qu’à partir de l’expression d’un polynôme de Lagrange de constante, sinon κ dépend de la position ~r.
degré n on peut facilement obtenir des expressions pour
Si l’on produit de la chaleur en un point ~r donné (par
les dérivées jusqu’à la dérivée n-ième. effet Joule ou par un apport quelconque, ou encore au
Par exemple, une expression de la dérivée première peut contraire par une perte dans l’atmosphère), cette chaleur
être obtenue à partir de l’approximation linéaire, éq. (4.4) : doit diffuser et cette chaleur diffusée par unité de temps
doit être égale à la quantité Q̇(~r) de chaleur produite par
f (xℓ+1 ) − f (xℓ )
p′ℓ = unité de temps, ce qui donne :
xℓ+1 − xℓ
~ r ) = Q̇(~r)
div φ(~
En fait, il s’agirait plutôt d’un calcul de la dérivée en
xℓ+1 +xℓ
2 , au milieu de l’intervalle, et non en xℓ . Si l’on En combinant ces deux équations, on obtient facilement :
préfère une expression plus symétrique qui donne une
autre estimation plus précisément en xℓ : ~ κ(~r) · grad
grad ~ T (~r) + κ(~r) ∆T (~r) = −Q̇(~r) (4.5)
f (xℓ+1 ) − f (xℓ−1 ) Cette équation, alliée à d’éventuelles conditions aux

p′ℓ = limites, permet, en principe, de calculer la distribution
xℓ+1 − xℓ−1
de température en régime stationnaire dans un objet,
On montre d’ailleurs aisément que cette dernière expres- connaissant Q̇(~r) et κ(~r). Autant dire que ce n’est pas
sion vient de la dérivation de l’approximation parabolique. toujours facile : que faudrait-il faire pour une résolution
Il faut cependant être assez prudent. Outre la remarque numérique ?
ci-dessus concernant la limite pratique sur le degré du Pour simplifier, on se restreindra ici à une dimension,
polynôme utilisé, il faut être conscient qu’un calcul de mais le problème n’est pas très différent à trois dimensions,
dérivée va tendre à amplifier le bruit (figure 4.15). En ef- du moins dans des géométries simples. L’équation (4.5) se
fet, des fluctuations locales, de point à point, de la fonction réduit alors à :
peuvent donner des valeurs numériques importantes pour,
mettons, la dérivée première, et ces valeurs risquent de dκ dT d2 T
+ κ 2 = −Q̇(x)
changer brutalement d’un point à un autre. En pratique, dx dx dx
on se limite donc à des dérivées d’ordre faible, un voire Le première étape est de discrétiser le problème : on
deux, sur des données de très bonne qualité intrinsèque. pose,
On verra dans le chapitre 4.8 d’autres méthodes plus sûres
en présence de bruit. x = i δx
où i est un entier et δx un pas d’intégration, similaire à ce d’invoquer la bibliothèque lors de la compilation : c’est en
qui a déjà été vu dans le chapitre 4.3.2. On note alors : général une option de compilation11 : le compilateur ira
puiser dans la bibliothèque ce dont il a besoin. . .
T (x) = T (i δx ) = Ti Il n’y a donc aucune raison de réinventer la roue ! C’est
en fait une démarche très courante en calcul scientifique :
dT
La dérivée peut être approchée par : on se pose un problème de physique, puis on se demande
dx comment le traduire de façon à le traiter avec un pro-
dT Ti+1 − Ti gramme de bibliothèque déjà existant.
∼ Dans le cas présent, un système d’équations linéaires se
dx δx
présente de la façon suivante :
ou bien 
dT Ti − Ti−1 
 a11 x1 + a12 x2 + a13 x3 + · · · + a1n xn = b1
∼ 

dx δx 
 a 21 x1 + a22 x2 + a23 x3 + · · · + a2n xn = b2

a31 x1 + a32 x2 + a33 x3 + · · · + a3n xn = b3
ou encore :
dT Ti+1 − Ti−1 
 a41 x1 + a42 x2 + a43 x3 + · · · + a4n xn = b4
∼ 

dx 2δx 
 ···

an1 x1 + an2 x2 + an3 x3 + · · · + ann xn = bn
On préfèrera la troisième forme plus symétrique. La
dérivée seconde, la dérivée de la dérivée, s’écrit : où l’on cherche les xi . Le problème peut se reformuler en
termes matriciels :
Ti+1 − Ti Ti − Ti−1 A·x=b
−
d2 T δx δx Ti+1 − 2Ti + Ti−1
∼ = avec  
dx2 δx δx2 a11 a12 a13 · · · a1n
 a21 a22 a23 · · · a2n 
Cela donne donc, avec des notations évidentes :  
 a31 a32 a33 · · · a3n 
A=  

dκ Ti+1 − Ti−1 Ti+1 − 2Ti + Ti−1  a41 a42 a43 · · · a4n 
+ κi = − Q̇ i (4.6)  · · · 
dx i 2δx δx2
an1 an2 an3 · · · ann
Si L est la longueur du barreau, alors n = δLx est le nombre et    
de segments sur le barreau : c’est a priori un nombre qui x1 b1
 x2   b2 
peut être grand, quelques centaines, milliers, voire plus ;    
 x3   b3 
or, l’équation (4.6) se reécrit aisément : x=   b=  
 x4 
  b4 

 ···   ··· 
1 dκ κi κi
+ Ti+1 − 2 2 Ti + xn bn
2δx dx i δx2 δx
Pour ce qui est de la matrice A, il faut savoir que
1 dκ κi fortran stocke les matrices multicolonnes colonne par
− + Ti−1 = −Q̇i colonne : une colonne, puis une autre, puis une autre.
2δx dx i δx2
En mémoire, se succèdent ainsi : a11 , a21 , a31 , · · · an1
ou bien (première colonne), a12 , a22 ,. . .(deuxième colonne),. . . etc.,
c’est-à-dire que le premier indice « va le plus vite » (en
ai,i+1 Ti+1 + ai,i Ti + ai,i−1 Ti−1 = bi ∀i C, c’est l’inverse). Si l’on veut écrire des programmes effi-
caces, il faut tenter de privilégier les appels à des éléments
où les ai,j sont connus et où l’on cherche à calculer les successifs en mémoire12 , et donc dans les boucles im-
Ti . On vient de reformuler le problème comme un système briquées, mettre autant que possible, le premier indice
linéaire de n équations à n inconnues (les Ti ) : si on peut dans la boucle la plus interne. Par exemple :
trouver des méthodes pour résoudre de très gros systèmes do j = 1, n ! boucles dans le bon ordre
d’équations linéaires, alors le problème ci-dessus peut être a(1:n,j) = ...
considéré comme résolu. enddo
et non l’inverse :
4.5.2 Systèmes d’équations linéaires. do i = 1, n ! boucles dans le mauvais ordre
Au delà de n = 2 ou 3, il ne faut surtout pas tenter de a(i,1:n) = ...
enddo
résoudre le système linéaire en procédant par élimination
comme on le fait d’habitude pour une résolution à la main : Pour résoudre le système d’équations, on pourrait ima-
les problèmes de stabilité numérique deviennent très vite giner qu’il suffise de calculer l’inverse de la matrice A et
cruciaux. Il vaut bien mieux utiliser des sous-programmes faire le produit :
de bibliothèque : ce sont des programmes déjà écrits, sou- x = A−1 · b
vent depuis longtemps, éprouvés, dont les qualités et les mais il se trouve que les algorithmes de résolution directe
défauts sont connus, compilés et rassemblés dans des bi- du système d’équations sont plus efficaces.
bliothèques. Il suffit d’appeller le sous-programme choisi 11 généralement,l’option -l (pour library=bibliothèque), par
par un call dans le programme que l’on a écrit comme exemple avec la bibliothèque linpack : g95 machin.f90 -llinpack
n’importe quel autre sous-programme, en suivant toute- -o machin.
fois les indications fournies dans la documentation10 puis 12 Parce que le compilateur gère mieux les transferts entre mémoire
et processeur de paquets de nombres connexes que des nombres pris

10 Souvent en ligne. dans n’importe quel ordre.
4.5.2.1 La méthode LU n(n + 1)

Il y a n2 équations, or L comporte éléments a
2
C’est le véritable cheval de bataille de tous ces priori non nuls, ainsi que U, soit n + n inconnues, et donc
2
problèmes (voir réf. [3] pour une discussion plus appro- n de trop. On fixe alors :
fondies des qualités et défauts des différentes méthodes,
par exemple Gauss-Jordan). lii = 1, ∀i
Imaginons que l’on ait décomposé la matrice A en un
produit de deux matrices : Pour i ≤ j, on obtient aisément :
i−1
X
A= L·U
uij = aij − lik ukj (4.8)
où L est une matrice triangulaire inférieure (L = lower ) k=1
qui n’a des éléments que sur et sous la diagonale :
Enfin, pour i > j :
 
l11 0 0 0 !
j−1
X
 l21 l22 0 0  1
L=  l31 l32 l33 0 
 lij = aij − lik ukj (4.9)
ujj
k=1
l41 l42 l43 l44
Tous les termes dans les sommes des équations (4.8) et
dans le cas où n = 4, et U est une matrice triangulaire
(4.9) sont déjà calculés à condition d’appliquer les deux
supérieure (U = upper ) qui n’a des éléments que sur et au équations par i croissants pour un j donné, puis changer
dessus de la diagonale :
de j. Il ne s’agit finalement que d’un réordonancement très
  simple du problème.
u11 u12 u13 u14
 0 u22 u23 u24  En général, les programmes qui appliquent cet algo-
U=  0
 rithmes détruisent le contenu de la matrice A en rangeant
0 u33 u34 
0 0 0 u44 les éléments de L dans la partie inférieure de A, et les
éléments de U dans la partie supérieure, sachant que les
Le système initial se reécrit : lii ne sont pas conservés, puisqu’ils valent 1. En outre,
afin de limiter les dégâts lors des divisions par ujj dans
L · (U · x) = b l’équation (4.9), un certain réarrangement des lignes et co-
lonnes du système d’équations doit être fait pour commen-
il reste à chercher y tel que :
cer par les éléments pour lesquels ujj est grand (une divi-
L·y =b sion par un nombre très petit donne parfois des résultats
imprévisibles). Les programmes de bibliothèque font cela
puis x tel que : et souvent fournissent en prime des diagnostics lorsque A
U·x =y est singulière, ou trop proche d’une matrice singulière.
L’avantage de procéder ainsi est que maintenant le système
est trivial à cause de la forme triangulaire des deux ma- 4.5.2.2 Amélioration itérative de la précision.
trices : Il faut néanmoins faire un peu attention à la précision du
1 1
b1 résultat obtenu, car les termes du type et dans les
y1 = lii uii
l11 équations (4.7) et (4.9) peuvent donner lieu à des surprises
1 si les diviseurs sont petits. Il y a plusieurs façons de s’en
y2 = [b2 − l21 y1 ]
l22 sortir. La première consiste à utiliser un sous-programme
1 de bibliothèque capable de détecter ce genre de problème :
y3 = [b3 − (l31 y1 + l32 y2 )]
l33 pratiquement toutes les bibliothèques en proposent. Un
··· (4.7) autre test possible est de comparer les résultats obtenus
en simple et en double précision.
puis, en procédant de même à l’envers : Une cure possible est de partir d’une solution approchée
′
yn x , et donc fausse, obtenue par, mettons, la méthode LU
xn = et de chercher à l’améliorer.
unn
··· Soit :
A · x′ = b + δb
Reste à faire la décomposition proprement dite.
Il s’agit d’un algorithme typique de ceux dont sont où δb est l’erreur qu’il faut réduire ; or :
friands les amateurs. Nous le détaillons ici pour le plai-
sir de ce genre de tourisme13 ! Cela s’appelle l’algorithme x′ = x + δx, et A · x = b
de Crout.
donc :
Le problème est de trouver lij et uij tels que :
A · δx = δb = A · x′ − b
min(i,j)
X qui est un système que l’on peut résoudre pour obtenir δx.
lik ukj = aij On peut alors corriger x′ et recommencer jusqu’à obtenir
k=1
la précision voulue, à condition évidemment que l’algo-
13 Et surtout pas pour l’apprendre par cœur. . . rithme converge. . .
Il faut savoir cependant que les bibliothèques pro- nuls. On écrit plutôt
posent généralement un très grand nombre de sous-  
d1 f1 0 0 0 ··· 0
programmes prévus pour des cas très divers : il est
donc conseillé de choisir le programme adapté. Toutefois,  e2 d2 f2 0 0 ··· 0 
 0 e3 d3 f3 0 0 
pour la plupart des problèmes « standards » du physi-  ··· 
 ··· ··· ··· ··· ··· · · · · ·· 
cien, la méthode LU est très satisfaisante, mais pour les A=  
 ··· 0 ei di fi 0 ··· 
problèmes exigeant d’énormes matrices creuses tels que les  ··· ··· ··· ··· ··· ··· ··· 
méthodes d’éléments finis (pour la résolution de problèmes  
0 0 · · · 0 en−1 dn−1 fn−1
de mécanique des fluides par exemple), des méthodes 0 0 ··· 0 0 en dn
spécialement prévues à cet effet doivent être utilisées.
qui ne nécessite que trois tableaux de n éléments, d pour
la diagonale, e pour la sous-diagonale et f pour la sur-
4.5.2.3 Matrice inverse. diagonale. Noter que e1 et fn ne sont pas définis.
Les équations (4.8) et (4.9) se réduisent à :
Une fois la décomposition achevée, il est facile de rem-
placer b par : i = j − 1 uj−1j = ej
  i=j ujj = dj − ljj−1 uj−1j
1
 0  fj
  i = j + 1 lj+1j =
 0  ujj
 
 .. 
 .  Les équations ci-dessus ne constituent pas en elles-même
0 l’intérêt principal de ce paragraphe : le but est ici d’atti-
rer l’attention sur le fait que pour un type de matrice,
ce qui donne la première colonne de A−1 dans x, puis on la méthode de résolution que l’on choisira n’est pas tou-
procède colonne par colonne en posant : jours la même que pour un autre type de matrice. Les
  bibliothèques sont parfois fort riches et il est de bon
0 ton de chercher un peu dans la documentation quel peut
 ..  être le sous-programme le plus adapté au cas particu-
 . 
  lier envisagé. Il existe des solutions pour des matrices
b=  1 

 .  « bande-diagonales » ou des solutions itératives par ap-
 ..  proximations successives pour des problèmes difficiles, des
0 décompositions en valeurs singulières quand le problème
se pose. . ., les ressources sont abondantes, parfois un peu
en plaçant le nombre 1 sur la i-ème ligne de b pour obtenir trop, même !
la i-ème colonne de A−1 .
4.5.3 Une généralisation de la méthode de
Newton à plusieurs dimensions.
4.5.2.4 Déterminant d’une matrice.
Au chapitre 4.1.2, on a mentionné le fait que la méthode
C’est encore plus simple : de Newton de recherche de zéro pouvait se généraliser à
plusieurs dimensions. Cela peut être utile, si par exemple,
Y n
au lieu d’un seul pendule comme dans l’exemple, on en
det A = ujj avait plusieurs couplés entre eux et non plus astreints à se
j=1
déplacer dans un plan : on aurait alors deux angles polaires
par pendule à trouver et donc un système de 2N variables
à rechercher.
4.5.2.5 Matrice tridiagonale.
C’est le moment de s’y attaquer. Soit donc n fonctions
Si l’on étudie l’équation (4.6), on s’aperçoit vite que de n variables
seuls les termes en i − 1, i et i + 1 sont non nuls. La
fj (x1 , . . . , xi , . . . , xn ), ∀j ∈ [1, n]
matrice A ne comporte alors que des termes diagonaux,
sous-diagonaux et sur-diagonaux : elle est donc tridiago- dont on suppose qu’elles possèdent un zéro et qu’elles sont
nale : raisonnablement « civilisées »14 : ces fonctions ne sont
  toutefois évidemment pas linéaires.
a11 a12 0 0 0 ··· 0
a21 a22 a23 0 0 0
On démarre la recherche comme avant à partir d’un
 ··· 
 0 a32 a33 a34 0 0  point de départ :
 ··· 
 ··· ··· ··· ··· ··· ··· ··· 
A=



(0) (0)
x1 , . . . , xi , . . . , x(0)
 ··· 0 aii−1 aii aii+1 0 ···  n
 ··· ··· ··· ··· ··· ··· ··· 
  on linéarise alors les fonctions localement :
0 0 ··· 0 an−1n−2 an−1n−1 an−1n
0 0 ··· 0 0 ann−1 ann
fj (x1 , . . . , xi , . . . , xn )
Dans ce cas, il n’est nul besoin de stocker toute la matrice 14 Le terme civilisé pour une fonction signifie en gros que l’algo-
A avec ses n2 éléments puisque, pour la plupart, ils sont rithme que l’on va utiliser marche. . .
= ce qui donne :
(0) (0)
fj (x1 , . . . , xi , . . . , x(0) 
n )+  g C
 2
 ω a1 = a1 + (a1 − a2 )
∂fj ∂fj ∂fj ℓ1 m1 ℓ 1
dx1 + . . . + dxi + . . . + dxn
∂x1 ∂xi ∂xn 
 g C
 ω 2 a2 = a2 + (a2 − a1 )
où dxi = xi −
(0)
xi . On cherche le point {xi } tel que ℓ2 m2 ℓ 2
fj (x1 , . . . , xi , . . . , xn ) = 0, ∀j, donc les équations ci- et :
dessus se reécrivent : 
 g C 2 C
∂fj ∂fj ∂fj 
 + − ω a1 − a2 = 0
dx1 + . . . + dxi + . . . + dxn ℓ1 m1 ℓ 1 m1 ℓ 1
∂x1 ∂xi ∂xn

 C g C
=  − a1 + + − ω 2 a2 = 0
m2 ℓ 2 ℓ2 m2 ℓ 2
(0) (0)
−fj (x1 , . . . , xi , . . . , x(0)
n )
ce qui se résout aisément en écrivant que le déterminant
C’est un système d’équations linéaires dont les inconnues du système est nul, etc.15
sont les {dxi } : Cependant, on peut reécrire le problème matricielle-
J · dx(1) = −f (0) ment :
avec des notations sans surprise. La matrice J des dérivées D · a = ω2a
∂fj
partielles, Jij = , s’appelle la matrice jacobienne. avec évidemment :
∂xi
On résout donc le système, ce qui permet de calculer les  
g C C
(1)
{xi } puis on recommence jusqu’à convergence, comme + −
 ℓ1 m1 ℓ 1 m1 ℓ 1  a1
dans le cas à une dimension. D=  
, a =
C g C a2
− +
m2 ℓ 2 ℓ2 m2 ℓ 2
4.5.4 Problèmes de vecteurs propres et de
valeurs propres ou eigenproblems. La matrice D s’appelle la matrice dynamique du système
et l’on s’aperçoit donc que ω 2 est une valeur propre de
Il s’agit de résoudre l’équation :
la matrice dynamique et que a en est un vecteur propre.
A · x = λx Pour un système 2 × 2 comme celui-ci, l’intérêt d’une telle
remarque n’est pas évident, mais pour un système 100 ×
où connaissant A, on en cherche les valeurs propres λ et 100 ? Par exemple, une molécule qui comporte ne serait-
les vecteurs propres x. ce que quelques dizaines d’atomes. . . il suffit alors d’écrire
la matrice dynamique du système, une matrice n × n où
4.5.4.1 Un exemple : les modes propres d’un n est le nombre de degrés de liberté du système, et d’en
ensemble d’oscillateurs harmoniques chercher valeurs et vecteurs propres.
couplés. Il se trouve qu’il y a des algorithmes très efficaces pour
calculer numériquement les valeurs propres et les vecteurs
Prenons un cas très simple : deux pendules simples propres de très grosses matrices.
couplés par un fil de torsion. L’énergie potentielle du Ici encore, la façon de procéder dépend du type de ma-
système s’écrit : trice que l’on veut étudier, et ici encore, il faut faire appel
1 à des programmes de bibliothèque.
V = −m1 g cos θ1 − m2 g cos θ2 + C(θ1 − θ2 )2
2
4.5.4.2 Matrices tridiagonales symétriques : la
avec des notations évidentes. Les équations du mouvement
méthode QL.
s’en déduisent sans difficulté :
 La matrice dynamique du paragraphe 4.5.4.1 peut être
 g C √

 θ̈1 = − ℓ sin θ1 − m ℓ (θ1 − θ2 ) symétrisée √ en remplaçant a1 par α1 = m1 ℓ1 a1 et a2
1 1 1
par α2 = m1 ℓ2 a2 . De plus, si le nombre de pendules

 g C
 θ̈2 = − sin θ2 − (θ2 − θ1 ) est plus grand que deux, si les pendules sont alignés et
ℓ2 m2 ℓ 2 chaque pendule n’interagit qu’avec ses deux voisins les plus
Puisque l’on s’intéresse ici à un problème linéaire, on peut proches, la matrice D est tridiagonale symétrique. Il se
se restreindre à des oscillations de petite amplitude, et trouve que beaucoup de problèmes peuvent être ramenés
avec l’approximation habituelle, on obtient : au calcul des valeurs propres d’une matrice tridiagonale
 symétrique qui est justement le cas le plus simple.
 g C La plupart des programmes de bibliothèque utilise la

 θ̈1 = − ℓ θ1 − m ℓ (θ1 − θ2 )
1 1 1 méthode QL qui consiste à faire une série de transforma-

 g C tions orthogonales :
 θ̈2 = − θ2 − (θ2 − θ1 )
ℓ2 m2 ℓ 2 15 C’est d’ailleurs un exercice conseillé : le déterminant donne une
équation bicarrée en ω, on trouve donc deux solutions positives et

un système pour lequel on cherche des solutions station- donc deux fréquences propres ; à chaque fréquence propre correspond
naires périodiques du type : un couple (a1 , a2 ) d’amplitudes pour les deux pendules, c’est-à-dire
un mode propre. Le mouvement des pendules est une combinaison
θ1 = a1 eiωt , θ2 = a2 eiωt linéaire de ces deux modes.
l’équation stationnaire et l’on tentera une résolution en

As+1 = Ls · Qs développant la fonction d’onde ψ sur une base de fonc-
tions connues : c’est, a priori, une approximation car rien
où Ls est une matrice triangulaire inférieure et Qs une
ne dit que la « vraie » solution puisse être correctement
matrice orthogonale, c’est-à-dire que :
développée sur la base choisie, surtout si celle-ci est réduite
−1
Qs = Qs t à un nombre fini, voire un petit nombre, de fonctions.
La consultation d’un cours de physique quantique
Une série de théorèmes, que nous n’étudierons pas ici, montre que l’on peut poser le problème de la façon sui-
montrent que l’on peut décomposer Ls de la façon suivante : R ∗
vante ψ (X)H(X)ψ(X)dX
E = R (4.11)
t
Ls = Qs · As ψ ∗ (X)ψ(X)dX
écrire Qs comme un produit de rotations planes et que la où H est le Hamiltonien (connu) du système considéré,
séquence X désigne l’ensemble des variables du problème, ψ(X)
As+1 = Qts · As · Qs la fonction d’onde que l’on cherche et E l’énergie (que
l’on cherche également). Pour simplifier les notations, il
fera apparaı̂tre les valeurs propres sur la diagonale. est d’usage d’écrire la même équation comme suit :
Pour l’utilisateur, il suffit de fournir deux tableaux uni-
dimensionnels contenant la diagonale et la sous-diagonale < ψ|H|ψ >
de la matrice initiale A ou A0 . Au retour, on obtient les va- E=
< ψ|ψ >
leurs propres à la place de la diagonale en général classées
par ordre de valeur décroissante. Si l’on veut aussi les vec- L’énergie E dépend évidemment de la fonction d’onde et
teurs propres, il faut également fournir un tableau n × n l’on montre que si l’on modifie légèrement ψ, E doit être
et. . . bien lire la documentation pour déterminer si un vec- minimum par rapport à ce changement, si toutefois E et
teur propre donné occupe une ligne ou une colonne de la ψ sont solutions du problème.
dite matrice ! En général, les vecteurs propres obtenus sont On développe alors la fonction d’onde sur une base de
normalisés à 1, soit, pour un vecteur propre ai donné : fonctions connues χℓ :
X X
a2i,ℓ = 1 ψ= c ℓ χℓ
ℓ ℓ
où ai,ℓ est la ℓ-ième composante du vecteur propre ai . en espérant que la base choisie « marchera ». Le principe
variationnel ci-dessus dit que le meilleur jeu de coefficients
4.5.4.3 Rendre une matrice tridiagonale. cℓ est celui pour lequel E est minimum, donc pour un δck
quelconque, le δE doit être nul au premier ordre. Avec ces
Quand la matrice n’a pas la forme requise, il faut la notations, l’équation (4.11) s’écrit :
transformer d’abord, par exemple, lorsque les pendules
X
couplés de notre exemple « voient » leurs seconds voisins, c∗ℓ cm Hℓm
ou bien lorsque l’objet étudié est une molécule en vibra-
tion dont les atomes sont couplés les uns aux autres en E = ℓmX (4.12)
c∗ℓ cℓ
trois dimensions.
ℓ
La méthode tourne toujours autour du même genre
d’opérations : on fait une séquence du type : où
Hℓm =< χℓ |H|χm >
As+1 = Rts · As · Rs
à condition toutefois que la base de fonctions soit ortho-
où Rs est une rotation plane judicieusement choisie et là normée, soit :
encore une batterie de théorèmes appropriés montre que < χℓ |χm >= δℓm
l’on doit converger vers une matrice tridiagonale.
Si l’on impose une variation δck au coefficient ck dans
l’équation (4.12), on obtient alors :
4.5.4.4 Problèmes aux valeurs propres généra-
lisés. δE = !
Ce sont des problèmes du type : X X X
δc∗k cm Hkm + c∗ℓ δck Hℓk c∗ℓ cℓ
A · x = λB · x (4.10) m X ℓ ℓ
− c∗ℓ cm Hℓm (δc∗k ck + c∗k δck )
où l’on cherche les valeurs propres λ et les vecteurs propres ℓm
x, A et B étant des matrices connues : voyons un exemple.
or δE doit être nul ∀k, ∀δck , ce qui donne, après avoir
ré-injecté l’équation (4.11) dans l’expression ci-dessus :
4.5.4.4.1 L’équation de Schrödinger. La résolu-
tion numérique de l’équation de Schrödinger est un X
cm Hkm = E ck ∀k
problème particulièrement difficile et, outre qu’un tome m
entier ne suffirait pas à le traiter complètement (voir,
par exemple, la référence [12]), c’est un domaine où autrement dit
la recherche est active ! Ici, nous nous contenterons de H·c =Ec
avec des notations sans surprise. On reconnait là une 4.6 Problèmes autocohérents.
équation aux valeurs propres : la résoudre donne à la fois
les énergies propres et les coefficients correspondants du ou self-consistent problems en anglais.
développement de la fonction d’onde.
Pour des raisons diverses, il peut arriver cependant que 4.6.1 Qu’est-ce donc ?
la base de fonctions utilisée ne soit pas orthonormée : par
exemple, si l’on cherche des fonctions d’onde électroniques Imaginons, par exemple, un diélectrique constitué d’un
dans le champ d’un ensemble de noyaux, on peut vouloir ensemble d’atomes polarisables qui, lorsqu’ils sont sou-
utiliser des fonctions d’onde localisées sur les noyaux ato- mis à un champ électrique, voient leur nuage électronique
miques avec un certain recouvrement. Les produits sca- déformé. Ils portent alors un moment dipolaire dont on
laires : supposera ici selon l’approximation d’usage qu’il est pro-
< χℓ |χm >= sℓm portionnel au champ :
deviennent alors les éléments d’une matrice S qui n’est ~ ri )

p~i = α E(~
plus la matrice unité. Le problème se reformule légèrement
pour donner après le même genre de calcul, le résultat où p~i est le moment dipolaire porté par l’atome i et ~ri est
suivant : la position de celui-ci.
H·c =ES·c Chaque atome est donc soumis au champ extérieur E ~ ext
que l’on applique et au champ dû à tous les autres dipôles :
un problème aux valeurs propres généralisé similaire à
(4.10). X
~ ri ) = E
E(~ ~ ext + E~ dipj (~ri )
j, j6=i
4.5.4.4.2 Résolution. La méthode est en général très
simple : il suffit de remplacer (4.10) par : où E~ dipj (~ri ) est le champ produit en ~ri par le dipôle porté
par l’atome j. Donc :
B−1 · A · x = λ x
 
−1 X
La matrice B · A n’est généralement pas symétrique ~pi = α E ~ ext + ~ dipj (~ri )
E (4.13)
même si A et B le sont. Les sous-programmes de bi- j, j6=i
bliothèque font alors une décomposition de B en
ainsi, pour calculer les valeurs des moments dipolaires p~i ,
B = L · Lt il faut connaı̂tre les champs dipolaires mais pour obtenir
les champs dipolaires, il faut connaı̂tre les moments dipo-
et le problème se re-écrit : laires : on tourne en rond.
t
t
On peut, certes, tenter de remplacer E ~ dipj (~ri ) par son
C· L ·x =λ L ·x
expression en fonction de ~pj et résoudre, par exemple, par
avec : la méthode de Newton le système d’équations :
−1

−1 t
C= L ·A· L
~pi − f~i ({~
pj , j ∈ [1, n]}) = 0 i ∈ [1, n]
La matrice C a les mêmes valeurs propres que le problème
initial et ses vecteurs propres sont Lt · x. En principe, cela suppose cependant de calculer toutes les dérivées
toutes ces transformations sont transparentes pour l’utili-
sateur. ∂ f~i
∂~pj
4.5.4.5 Conclusion
une entreprise parfois un peu laborieuse, surtout si n est
Tous ces algorithmes sont efficaces et rapides : il ne faut grand.
[0]
surtout pas se priver de les utiliser quand le problème On peut toutefois partir d’une solution d’essai ~pi , cal-
s’y prête, même si l’on ne maı̂trise pas absolument leur culer les champs dipolaires correspondants, puis, à l’aide
fonctionnement, car ils sont dans l’ensemble assez ro- [1]
de l’équation (4.13), de nouvelles valeurs ~pi , puis de nou-
bustes16 . En revanche, les bibliothèques de programmes [2]
veaux champs et p~i et ainsi de suite. La solution sera
sont souvent extrêmement riches et l’on a parfois du mal obtenue quand on aura atteint un « point fixe » tel que :
à déterminer quel est le sous-programme qui répondra le
mieux à la question posée : il faut prendre le temps de ~pi
[k+1]
≃ p~i
[k]
réfléchir, de lire la documentation disponible, hélas pas
toujours limpide, voire se poser la question si une refor- avec une précision suffisante.
mulation du problème de façon légèrement différente ne
permettrait pas, par exemple, de symétriser la matrice
étudiée ou si une écriture avec des termes complexes ne
4.6.2 Formulation générale.
pourrait pas simplifier considérablement la vie de celui qui On cherche donc la solution du système d’équations :
écrit le programme !
16
xi = fi (x1 , x2 , . . . , xn ), i ∈ [1, n]
ce qui ne dispense pas bien sûr de vérifier sur des problèmes dont
la solution est connue que les programmes marchent convenablement,
et, comme d’habitude, ne pas oublier d’user de l’esprit critique du ou
physicien. . . x = f (x)
où les lettres en caractères gras représentent des vecteurs de notre fonction tend vers 1 lorsque x tend vers zéro :
de n éléments. On part d’une solution d’essai x[0] et l’on on est à la limite de la condition de convergence |a| < 1,
construit la séquence : ainsi, dans ce cas, plus on s’approche de la solution, plus la
convergence devient difficile. On en concluera néanmoins
x[k+1] = f (x[k] ) que le critère ci-dessus, a priori valable pour une fonction
linéaire, l’est également pour une fonction non-linéaire à
Le point fixe sera considéré comme atteint quand les
condition d’en connaı̂tre la dérivée au point fixe, ou du
x[k] n’évolueront plus de façon significative à chaque
moins d’être capable d’estimer si elle est, en valeur abso-
génération.
lue, inférieure à 117 .
Ce genre de raisonnement est généralisable à des
4.6.3 Est-ce que ça converge ? systèmes linéaires du type :
Rien n’est moins sûr ! Prenons un cas très simple pour x = Ax + b
lequel n = 1 et :
f (x) = ax On obtient évidemment que :
La solution est évidemment x = 0. Si l’on veut résoudre
[0] x[k] = Ak x[0] + I + A + A2 + . . . + Ak−1 b
ce problème par la méthode ci-dessus, on part d’un x
choisi arbitrairement et Pour que cela converge, on montre18 qu’il suffit que :
x[1] = a x[0] , x[2] = a x[1] = a2 x[0] ||A|| < 1
et bien sûr : où ||A|| est l’une des normes de A :
x[k] = ak x[0]
n
X
Si |a| < 1, la convergence est acquise, mais sinon ça di-
||A||m = max |aij |
verge ! i
j=1
Étudions maintenant le cas :
ou bien
f (x) = tanh x n
X
||A||l = max |aij |
j
là encore la solution x = 0 est connue. Le programme pour i=1
résoudre celà est d’une grande simplicité : ou encore v
uX
program autoco u n X
n
||A||k = t |aij |2
implicit none
i=1 j=1
real :: x=1. ! point de depart de la recherche
integer :: k, kmax=100000 En particulier, si l’on a :
open(1,file=’autoco.res’)
write(1,*) 0, x 1
aij < , ∀ i, j ∈ [1, n]
do k = 1, kmax n
x = tanh(x)
if( mod(k, 10) == 0 ) write(1,*) k, x la suite converge.
enddo Pour un système non-linéaire, la matrice A devient la
close(1) matrice jacobienne J à proximité du point fixe : cela sup-
end pose que l’on soit capable d’évaluer cette matrice au point
fixe qui est justement ce que l’on cherche !
1 Afin de tempérer cette note apparemment pessimiste,
l’on mentionnera -et le lecteur est chaleureusement in-
vité à le vérifier- que le problème du diélectrique converge
0.1 de façon très satisfaisante en moins de 10 pas de cal-
cul à la suite d’un effort de programmation modeste. Ces
méthodes peuvent ainsi se révéler extrêmement précieuses
x
dans bien des cas, même si l’évaluation a priori de leurs

0.01
chances de succès relève parfois plus de l’astrologie que de
la science. . .
0.001
10 100 1000 10000 100000
k 4.7 Recherche des minima d’une
Fig. 4.16 – Convergence plus que médiocre de la recherche fonction.
autocohérente de la solution de l’équation x = tanh x (les
Il arrive bien souvent que l’on ait besoin, par exemple,
échelles sont logarithmiques).
du minimum de l’énergie potentielle d’un système qui
17 C’est un problème similaire à celui que l’on avait recontré à
Le résultat est malheureusement assez décevant (figure
propos de l’équation logistique (§ 3.2.2, la recherche des points fixes
4.16) : après 105 pas, on en est encore à quelques millièmes est en fait une recherche de zéros) où l’on avait vu qu’un système non-
de la solution ! On était habitué à mieux. . . Si l’on essaie linéaire pouvait être susceptible d’un comportement chaotique. . .
d’appliquer le critère ci-dessus, on s’aperçoit que la dérivée 18 Voir par exemple la référence [2], p. 322.
dépend d’une ou plusieurs variables pour en obtenir f (x) une fonction d’un ensemble de n variables désignées
l’équilibre stable : mettons, un ensemble d’atomes qui par x = (x1 , . . . , xn ). Un extremum est donné par :
composent une molécule dont on veut la conformation à
l’équilibre compte tenu des potentiels d’interaction atome- ∂f
di (x) = =0 ∀i
atome. ∂xi
Un autre exemple, qui sera étudié plus en détail dans le cela donne un système de n équations dont on cherche les
chapitre 4.8, est celui de la recherche du minimum d’écart zéros, or la variation δdi (x) de di pour des variations δxi
possible entre des données expérimentales et les prévisions s’écrit :
d’un modèle théorique qui dépend lui-même d’un certain
nombre de paramètres : il faut donc chercher les valeurs X ∂di X ∂2f
δdi (x) = δxj = δxj (4.14)
de ces paramètres qui donne l’écart le plus faible possible. ∂xj ∂xi ∂xj
j j
On pourrait aussi, dans un autre ordre d’idées, chercher
le chemin optique le plus court pour un rayon lumineux, La matrice H telle que
encore que la résolution d’une équation différentielle or-
dinaire selon les méthodes du chapitre 4.9 paraisse plus ∂2f
Hij =
facile dans un bon nombre de cas. ∂xi ∂xj
s’appelle la matrice Hessienne. C’est cette matrice qui

4.7.1 Du mouvement des amibes (mé- intervient dans le système linéaire (4.14) que l’on doit
thode du simplex). résoudre en δxi en suivant la méthode de Newton déjà
vue :
4.7.1.1 À une dimension H · δx = −d
On cherche donc le minimum d’une fonction f (x). On avec des notations évidentes. Le vecteur d donne les va-
pourrait imaginer quelques chose qui s’apparente à la riations qu’il faudrait imposer aux variables x (ou xi ∀i)
méthode de la dichotomie : on choisit un intervalle, on pour annuler l’écart dans l’approximation linéaire. Comme
prend le milieu, on regarde s’il est plus bas que les bords, la fonction f (x) n’est pas a priori linéaire, il faut recom-
etc. En fait, il suffit, dans un espace unidimensionnel, de mencer l’opération jusqu’à convergence.
prendre deux points : a et b. Mettons que f (a) < f (b), C’est souvent efficace et c’est extrêmement simple à
alors on cherchera un point c symétrique de b par rapport mettre en œuvre (à condition de pouvoir calculer les
à a : on va dans le sens où ça décroı̂t et cela s’appelle une dérivées secondes qui composent la matrice hessienne),
réflexion. Si f (c) < f (a) c’est sans doute qu’on pouvait al- mais il faut être conscient qu’on ne se donne, alors, pas
ler plus loin : on double alors le déplacement dans le même tous les moyens pour réussir. En effet, la méthode de
sens (dilatation) ; sinon, c’est qu’on est allé trop loin, alors Newton recherche les zéros d’un ensemble de fonctions
on divise le déplacement par deux (contraction). Puis on complètement indépendantes, alors que les dérivées d’une
recommence l’opération jusqu’à ce que l’intervalle entre les fonction ne le sont pas. En outre, la matrice Hessienne
deux derniers points soit plus petit que la précision voulue. n’est pas toujours disponible aisément.
4.7.1.2 À N dimensions. 4.7.3 Recherche à une dimension : inter-

Le principe est le même : si l’on est dans un espace à N
polation parabolique.
dimension, on part de N + 1 points de l’espace : la figure Admettons que l’on connaisse trois points x = a, b et c
obtenue s’appelle un simplex, par exemple, si N = 2, c’est avec a < c < b d’une part, et f (c) < f (a) et f (c) < f (b)
un triangle. On remplace alors le point du simplex qui de l’autre. La deuxième condition impose qu’il doit y avoir
donne la valeur la plus élevée de la fonction par un autre un minimum au moins dans l’intervalle [a, b].
obtenu en faisant une réflexion par rapport au centre de On assimile alors localement la fonction à une parabole
gravité du simplex, puis des dilatations ou des contractions passant par les trois points (figure 4.17) :
à la demande. Ainsi, le simplex se déplace en se déformant,
telle une amibe, en cherchant toujours à se concentrer sur (x − c)(x − b)
f (x) ∼ p(x) = f (a) +
point le plus bas. Quand il devient assez petit, le problème (a − c)(a − b)
est résolu.
La méthode du simplex a le mérite de ne nécessiter au- (x − a)(x − c) (x − a)(x − b)
f (b) + f (c)
cun calcul de dérivée et d’être simple à mettre en œuvre. (b − a)(b − c) (c − a)(c − b)
Autant dire, cependant, qu’elle est assez inefficace : elle est dont on cherche le minimum :
à réserver aux problèmes pas trop lourds numériquement
pour lesquels on n’a pas de raison de faire d’effort parti- p′ (x) = 0
culier.
soit :
4.7.2 Méthode de Newton 1 f (a)(c2 − b2 ) + f (b)(a2 − c2 ) + f (c)(b2 − a2 )

x=
2 f (a)(c − b) + f (b)(a − c) + f (c)(b − a)
Il y a une méthode évidente : puisque l’on peut cher-
cher les zéros d’un ensemble de fonctions par la méthode puis on recommence avec une procédure similaire à celle de
de Newton, il suffit, lorsqu’on cherche les minima d’une la dichotomie : si x ∈]a, c[ on prend les points a, x et c, si-
fonction, de chercher les zéros de ses dérivées. Soit donc non, on prend c, x et b et l’on calcule par la même méthode
f(b)
1X ∂2f X ∂f
f (x) ∼ xi xj + xi + f0 (4.16)
2 i,j ∂xi ∂xj i
∂xi
f(a) où l’on peut introduire la matrice Hessienne H et le gra-

f(c) dient g de f tel que
∂f
gi =
∂xi
L’équation (4.16) se reécrit en notations matricielles :
1
f (x) ∼ x · H · x + g · x + f0 (4.17)
2
et
f ′ (x) ∼ H · x + g = r
où r est le résidu qui devrait être nul si l’on était au point
a c x b x solution. C’est aussi le vecteur qui indique la direction
de plus grande pente, direction de recherche.
Fig. 4.17 – Recherche de minimum parabolique à une di- Mettons que l’on démarre la recherche d’un point x0
mension. avec une direction de recherche r0 , l’on écrira donc :
x1 = x0 + α0 r0
une nouvelle estimation x′ et ainsi de suite jusqu’à obtenir
il faut chercher α0 tel que f soit minimum sur la direction
la précision voulue. Il reste cependant la question de savoir
r0 , or en développant (4.17) et en écrivant la dérivée par
si le minimum de la parabole est bien un minimum et non
rapport à α0 , on doit chercher α0 tel que :
un maximum ! On peut vérifier si par exemple, f (x) est
bien inférieur à f (c) ; s’il ne l’est pas on peut prendre par α0 r0 · H · r0 + x0 · H · r0 + g · r0 = 0
exemple le point milieu de c et de x.
où l’on a tenu compte du fait que H est une matrice
symétrique19 , ce qui donne une expression de α0 :
4.7.4 Méthode du gradient conjugué. r0 · r0
α0 = −
Soit de nouveau une fonction f (x) où x est un vecteur r 0 · H · r0
dans un espace de dimension quelconque n. On cherche le Si l’on répète la même séquence, la nouvelle direction de
minimum de cette fonction. recherche r1 doit être orthogonale à r0 parce que justement
Une première idée qui pourrait venir à l’esprit serait de nous sommes déjà sur un minimum de la fonction dans la
suivre la ligne de plus grande pente (steepest descent ) : on direction r0 , donc :
suit une droite parallèle au gradient local de la fonction :
r1 · r0 = 0
~
grad(f )
δx = −α (4.15) ce que l’on vérifie facilement par le calcul.
~
kgrad(f )k À deux dimensions, l’on obtient donc les zizags de la
où α est un scalaire obtenu par exemple par la méthode figure 4.18 et avec un plus grand nombre de dimensions,
du paragraphe 4.7.3. ça doit être, a priori, pire. . . On remarque cependant que
si les courbes de niveaux de la figure 4.18 avaient été des
cercles, la convergence aurait été obtenue en un pas, à
condition de choisir une direction de recherche parallèle
au gradient !
Il serait donc habile de tenter de faire entrer en ligne
de compte la géométrie des courbes de niveaux et d’intro-
duire non pas le produit scalaire ordinaire x · y, qui est
bien adapté à une symétrie sphérique, mais le H-produit
scalaire adapté à la géométrie de H :
Fig. 4.18 – La « ligne de plus grande pente » dans une
vallée étroite. Il faut un grand nombre de pas pour at- x·H·y
teindre le fond de la vallée. Sans entrer dans les démonstrations20 ni dans le détail de
l’algorithme, il suffit alors de chercher une série de direc-
Il se trouve que c’est souvent assez peu efficace même
tions de recherches di qui soient H-orthogonales entre elles
si cela peut donner de bons résultats dans certains cas :
de telle façon que :
en effet, si l’on cherche un minimum au fond d’une vallée
étroite et si l’on part d’un bord de la vallée, on va partir xi+1 = xi + αi di
dans une série de zigzags plutôt inutiles (figure 4.18). 19 Parce que H ∂2 f ∂2 f
i,j = ∂x ∂x = ∂x ∂x = Hj,i , donc on se convainc
Pour trouver une meilleure solution, il faut étudier d’un i j j i
peu plus près la méthode de la plus grande pente : il s’agit aisément que x0 · H · r0 = r0 · H · x0 .
20 Volontiers confuses dans la littérature, en tous cas guère pas-
en fait d’une approximation de f par une fonction quadra- sionnantes. . . mais ce n’est qu’une opinion qu’il n’est pas obligatoire
tique : de partager ! On se reportera éventuellement à la référence [7].
en choisissant αi pour que la recherche donne un minimum or les dxi ne sont pas indépendants à cause de l’équation
sur la direction di , et (4.18) ; mais cette équation dit que g est une constante et
que donc sa différentielle doit être nulle :
di · H · dj = 0, ∀i 6= j
Xn
∂g
Il se trouve que contrairement aux apparences, on peut dxi = 0
i=1
∂xi
très bien se passer de la connaissance (et de l’espace
mémoire correspondant) de la matrice Hessienne en uti- ce qui introduit un lien entre les dx . Il suffit d’addition-
i
lisant le fait que les résidus ri doivent être justement les ner ces deux relations en multipliant la deuxième par un
gradients de f ! « multiplicateur de Lagrange » λ :
Moralité : une fois encore, ne pas chercher à réinventer
ce qui existe déjà, utiliser des sous-programmes de bi- X n
∂f ∂g
bliothèque ! Ce qu’il faut retenir de ces méthodes, c’est +λ dxi = 0 (4.19)
i=1
∂xi ∂xi
qu’elles sont proches de la méthode de Newton déjà étudiée
pour la recherche de zéros et qu’elles ont les mêmes Choisissons alors, par exemple, λ pour que :
défauts. Ainsi, il s’agit toujours d’une recherche locale d’un
minimum d’une fonction assimilée à une fonction quadra- ∂f ∂g
+λ =0
tique qui ne possède qu’un seul minimum. La « vraie » ∂xn ∂xn
fonction n’est en général pas quadratique et si elle possède
plusieurs minima, on en trouvera au mieux un, sans savoir alors les n − 1 variables x1 , . . . , xn−1 sont indépendantes.
s’il n’y en a pas un nettement plus profond juste à côté ! La relation (4.19) est donc vraie pour tout jeu de variables
La méfiance et la circonspection sont les deux mamelles x1 , . . . , xn−1 , en particulier, si
du calcul numérique. . .
On verra toutefois, dans le chapitre 4.11, des façons dxi = 0, ∀i 6= k
d’éviter ces défauts lorsque le paysage du potentiel est
ce qui donne puisque dxk 6= 0 :
compliqué et que le nombre de paramètres est élevé.
∂f ∂g
+λ =0
4.7.5 Minimisation avec contrainte : les ∂xk ∂xk
multiplicateurs de Lagrange. une relation vraie pour tout k, puisqu’il a été choisi arbi-
Imaginons que l’on doive chercher comme auparavent trairement. C’est aussi vrai pour k = n puisqu’on a choisi
un minimum d’une fonction de n variables : λ ainsi : on retrouve ainsi la symétrie un instant perdue. . .
Le résultat de tout ceci est que si l’on définit la fonction :
min(f (x))
Q = f (x) + λg(x)
mais que les variables représentées par x ne soient pas
indépendantes mais reliées par une relation : le problème revient à chercher le minimum de Q avec
la contrainte (4.18), mais ce qui est nouveau par rap-
g(x) = 0 (4.18) port au problème précédent, c’est que les n variables sont
indépendantes et que l’on peut utiliser les méthodes clas-
c’est ce que l’on appelle une contrainte. Imaginons par siques.
exemple que l’on cherche la configuration d’équilibre d’un Prenons, par exemple, un système de pendules couplés
ensemble d’atomes mais que deux atomes donnés soient dont l’énergie potentielle s’écrit :
liés par une liaison très rigide, covalente par exemple, et
X 1 X
que la distance entre ces deux atomes soit connue. On a V =− mi gℓi cos θi + Cij (θi − θj )
2
ainsi un système de n − 1 variables indépendantes et l’on i
2 i,j>i
pourrait reécrire l’équation (4.18) :
avec des notations standards. Admettons que l’on cherche
xn = g̃(x1 , . . . , xn−1 ) l’équilibre d’un tel système (en dehors évidemment de la
solution triviale : certains angles peuvent être supérieurs
et l’on rechercherait le minimum d’une fonction à n − 1 à π) avec la contrainte que la somme des angles soit nulle
variables : (mettons qu’un système d’engrenages plus ou moins com-
plexe impose cela) :
min(f (x1 , . . . , xn−1 , g̃(x1 , . . . , xn−1 )))
X
Outre le fait que la recherche de la fonction g̃ n’est pas θi = 0
i
toujours facile, cette méthode est discutable en ce sens que
l’on a choisi d’éliminer la variable xn , mais pourquoi pas L’on écrira donc :
plutôt xn−1 ou xi ? Dans certains cas le choix est évident, X
dans d’autres non. Q=V +λ θi
Si l’on est à un extremum de f , alors pour tout ensemble i
de variations infinitésimales des xi on doit avoir :
et en exprimant les dérivées :
X n
∂f ∂Q
dxi = 0 =0
i=1
∂xi ∂xk
on obtient : Ainsi, cette théorie, si elle est juste, donne potentiellement

X également une information de type microscopique sur
λ = −mk gℓk sin θk − Ckk′ (θk − θk′ ), ∀k l’échantillon étudié : on aimerait bien savoir évidemment
k′ 6=k quelle est la valeur de ∆E qui est la plus en accord avec les
résultats expérimentaux : ∆E (ainsi que P0 ) est donc un
soit en sommant :
  paramètre ajustable de la théorie parce qu’on n’en connait
pas la valeur a priori et l’on tentera donc d’ajuster ∆E aux
1 X X
λ=− mk gℓk sin θk − Ckk′ (θk − θk′ ) données expérimentales.
n Ainsi, il est important de comprendre que l’on est en
k k′ 6=k
train de poser, non pas une, mais deux questions dis-
que l’on peut réinjecter dans l’expression de Q pour faire tinctes :
ensuite une minimisation par l’une des méthodes habi-
1. est-ce la théorie marche ?
tuelles.
Tout ceci se généralise évidemment à un nombre quel- 2. quelles sont les valeurs (et les incertitudes) des pa-
conque de contraintes gℓ = 0, il suffit d’introduire autant ramètres ajustables ?
de multiplicateurs de Lagrange que de contraintes : Il se trouve que les logiciels courants répondent prati-
X quement toujours à la seconde question, mais pas à la
Q=f+ λℓ gℓ première : cela vaut donc la peine de regarder d’un peu
ℓ plus près comment ça marche !
4.8 Modélisation de données 4.8.1.2 L’hypothèse de départ.

expérimentales. En pratique, l’on relève, pour n points de mesures
{xi , i = 1, n}, les n valeurs {yi , i = 1, n} correspon-
Lorsqu’on fait des expériences, il est bien rare que dantes. Mettons que l’on ait une théorie qui donne y en
l’on n’utilise pas un logiciel d’acquisition et de traite- fonction de x et d’un certain nombre de paramètres ajus-
ment des données expérimentales. Ces logiciels proposent tables p1 , . . . , pm :
généralement des options intitulées par exemple smoo-
thing 21 ou curve fitting 22 ou least square fit 23 . L’objectif de y = f (x, p1 , . . . , pm ) = f (x, {pj })
ce chapitre est d’expliquer ce que font au juste ces options,
comment ça marche, et quelles sont leurs limites. En effet, Ce qui nous intéresse, ce sont les écarts entre les yi mesurés
il ne s’agit pas de magie, contrairement parfois à ce qu’il et les f (xi , {pj }) calculés à l’aide de la théorie. On définit
paraı̂t, mais de bons vieux algorithmes bien pédestres, fa- ainsi : n
X
ciles à comprendre et dont il vaut mieux connaı̂tre les hy- χ2 ({pj }) = (f (xi , {pj }) − yi )2
pothèses sous-jacentes et les petites manies, faute de quoi i=1
on a vite fait de faire dire à peu près n’importe quoi aux
On cherchera alors l’ensemble de paramètres {pj } qui
résultats d’expérience !
rendra χ2 le plus petit possible : c’est pour cela que
la méthode s’appelle « méthode de moindres carrés »,
4.8.1 Données et moindres carrés. puisque χ2 est la somme des carrés des écarts entre théorie
4.8.1.1 Quel est le problème ? et mesures.
On aurait pu choisir autre chose que la somme des carrés
Lorsqu’on fait une expérience, on mesure une grandeur des écarts, par exemple la somme des valeurs absolues ou
y en fonction d’une autre grandeur x, par exemple la pres- le sup des carrés. . . Le choix fait ici, ainsi que dans la
sion en fonction de la température p(T ), l’intensité lumi- quasi-totalité des programmes, repose sur une hypothèse
neuse en fonction de sa fréquence ou de sa pulsation I(ω), qu’il faut expliciter.
la position d’un objet en fonction du temps r(t). . . On peut Imaginons que l’on fasse un grand nombre de fois la
aussi bâtir une théorie qui prédise la loi y = f (x) et l’on mesure de y pour une même valeur de x : on ne trouvera
veut savoir si la théorie est juste : cette théorie repose sur pas la même valeur de y pour toutes les mesures mais
des hypothèses physiques qui sont ainsi validées ou non. une distribution parce que la mesure n’est pas parfaite, il
C’est ce qu’on appelle la modélisation, on fait entrer une y a des incertitudes, il y a des vibrations dans le sol, le
expérience dans le cadre d’un modèle. détecteur utilisé produit du bruit, l’électronique produit
En général, la loi issue de la théorie dépend aussi de également du bruit. . .
paramètres dits « ajustables ». Par exemple, on peut ima- L’hypothèse qui mène à l’expression de χ2 ci-dessus est
giner que si l’on mesure une pression de vapeur saturante, que cette distribution est gaussienne, centrée autour de y0
la pression puisse s’écrire en fonction de la température de avec un écart-type σ :
la façon suivante :
(y−y0 )2
∆E p(y) = e− 2σ2
P (T ) = P0 e− kT
à un coefficient de normalisation près24 . Il se trouve que
une loi d’Arrhenius où ∆E est l’énergie qu’il faut four-
pour un très grand nombre d’expériences, le théorème de la
nir pour arracher un atome à la surface de l’échantillon.
limite centrale (valable pour les grands nombres) impose
21 Lissage.
que cette condition soit vérifiée. Toutefois, il faut faire
22 Ajustement de courbe.
23 Ajustement de moindre carré. 24 √1 .
σ 2π
attention que des détecteurs très sensibles peuvent être On peut alors introduire le « facteur de confiance
capables de répondre à un nombre de « coups » très faible pondéré » ou weighed reliability factor :
pour lequel ce genre de théorème n’est plus valable. Les v
u
méthodes décrites ici ne sont alors plus en toute rigueur u χ2
directement utilisables. R w = u n
u X (f (xi , {pj }))2
t
i=1
σi2
4.8.2 Ajustement d’une fonction linéaire.
4.8.2.1 Sans les incertitudes. c’est un écart quadratique ramené à la moyenne des carrés
de la fonction. Il s’exprime en général en % : si Rw vaut par
Prenons pour commencer le cas le plus simple : y = exemple 10%, cela signifie en gros que la fonction théorique
ax + b où les deux paramètres ajustables sont a et b. On est éloignée de 10% des valeurs expérimentales, en unités
cherche donc a et b tels que de σ.
Xn Ce que l’on aimerait avoir, c’est l’incertitude sur a et b
2
χ2 = (axi + b − yi ) puisque ce sont les résultats de tous ces calculs. Posons :
i=1
ei = f (xi , {pj }) − yi
soit minimum. Il faut donc que les dérivées de χ2 par rap-
port aux deux paramètres soient nulles : c’est l’écart entre théorie et expérience pour le point i. Si
 n l’on estime que cet écart est entièrement dû au paramètre

 ∂χ
2 X
 2xi (axi + b − yi ) = 0 n˚ 1, on obtient
 ∂a =

i=1
Xn ∂ei ∂f (xi , {pj })

 ∂χ 2
ei = δp1 = δp1

 = 2 (axi + b − y i ) = 0 ∂p ∂p1
 ∂b 1
i=1
une majoration de l’incertitude δp1 sur le premier pa-
Quelques lignes de calculs sans difficulté donnent : ramètre, or
 n n n

 X X X n
X n
X 2

 n x y − x yi 2 ∂f (xi , {pj }


i i i χ = e2i = )δp1

 i=1 i=1 i=1 ∂p1

 a = !2 i=1 i=1

 X n Xn

 2

 n xi − xi et en généralisant ceci à tous les paramètres pj :
i=1 i=1
Xn Xn Xn Xn v

 u


2
xi yi − xi yi xi u χ2

 δpj = u n

 i=1 i=1 i=1 i=1 u X ∂f (xi , {pj })

 b = !2 t

 X n X n
∂pj

 2

 n xi − xi i=1
i=1 i=1
C’est ce que l’on appelle « déviations standards estimées »
Lire dans un fichier les n valeurs de x et de y et faire ce (estimated standard deviations ou esd ) et ce sont des esti-
calcul pour obtenir l’équation de la droite est extrêmement mations de majorants aux incertitudes sur les paramètres.
simple (c’est d’ailleurs un petit exercice de programmation Dans le cas d’une fonction linéaire, évidemment, ces for-
conseillé25) : on comprend que les éditeurs de logiciels ne mules se simplifient aisément, mais elles s’appliquent26 aux
se privent pas de l’inclure dans leurs productions. autres cas aussi.
4.8.2.2 Avec les incertitudes. 4.8.2.3 Exercice pratique et divertissant.

Il y a une faiblesse criante dans ce que nous avons fait -Étape n˚1 : remplir une coupelle en plastique ou un pot
jusqu’à présent : on ne voit nulle part d’incertitude ! Ad- de yaourt ou de petit suisse vide avec un peu d’eau.
mettons donc que chaque mesure (xi , yi ) soit affectée d’une -Étape n˚2 : poser la coupelle ou le pot de yaourt sur un
incertitude σi . On doit alors redéfinir χ2 de façon qu’une pèse-lettres et l’ensemble (précautionneusement) sur un
mesure « compte » d’autant plus que son incertitude est radiateur.
petite : -Étape n˚3 : pendant une semaine ou plus, relever plusieurs
n
X (f (xi , {pj }) − yi )2 fois par jour le temps écoulé depuis le début de l’expérience
2 et la masse indiquée par le pèse-lettre. Mettre ces données
χ ({pj }) = 2
i=1
σ i expérimentales dans un fichier.
-Étape n˚4 : faire une hypothèse physique. Puisque la
Dans le cas de la fonction linéaire cela s’écrit évidemment :
température du radiateur peut être considérée en première
Xn 2
(axi + b − yi ) approximation comme constante, la vitesse d’évaporation
χ2 = 2 de l’eau peut être considérée comme constante et donc
i=1
σi
la masse d’eau restante s’exprimer comme une fonction
Un calcul à peine plus compliqué que précédemment donne linéaire du temps :
de la même façon les expressions de a et de b.
m(t) = ṁ t + m0
25 Il est prudent de travailler en double précision à cause des
dénominateurs. 26 On n’ose parler de validité !

où, donc, ṁ et m0 sont des constantes. Ces nombres n’ont, bien sûr, aucun sens.
-Étape n˚5 : déterminer ṁ et m0 selon les méthodes Moralité : ce n’est pas parce qu’un programme d’ajuste-
ci-dessus, ainsi que les déviations standards. Tracer ment donne un résultat que le modèle est validé et que les
les courbes expérimentale et théorique sur un même paramètres qu’il donne sont bons.
graphe ainsi que les écarts entre courbe théorique et Il ne faut pas oublier d’être physicien : quand on ajuste
expérimentale. un modèle, c’est qu’on pense qu’il est adapté, puis on
-Étape n˚6 : s’interroger sur les résultats obtenus. doit discuter les valeurs obtenues pour les paramètres
-Étape n˚7 : changer la valeur affichée sur le thermostat et
en les considérant comme des grandeurs physiques et
recommencer l’expérience. en se posant par exemple la question des conséquences
-Étape n˚8 : tracer la courbe ṁ(T ) pour 253 < T < 333K. qu’entraı̂nent les valeurs obtenues. Si, par exemple, dans
le cas de la loi d’Arrhenius, on trouve ∆E ∼ 106 joules
4.8.2.4 Une généralisation possible. (au lieu de quelques eV), on est en droit de se demander
si l’on a bien mesuré de la sorte l’énergie pour arracher
Ces méthodes qui ont le grand mérite d’être simples et
un atome d’une surface comme on le pensait initialement.
faciles à programmer ne sont pas limitées strictement aux
fonctions linéaires. Reprenons l’exemple de la loi d’Arrhe-
nius : 4.8.3 Ajustement d’un polynôme.
∆E
P = P0 e− kT On peut généraliser facilement les équations du para-
Si l’on fait les changements de variable : graphe 4.8.2.1 au cas d’un polynôme de degré p :
p
X
1
y = ln P x=− P (x) = c0 + c1 x + c2 x2 + . . . + cp xp = cj xj
kT
j=0
on obtient
y = ∆E x + ln P0 On cherche, bien sûr, les p + 1 coefficients cj , et donc,
 !2 
où ∆E et ln P0 tiennent le rôle de a et b dans le problème p
X
précédent. Ainsi, si l’on peut exprimer le problème de la  n ck xki − yi 
∂χ2 ∂ X 
façon suivante :  k=0 
=  =0
g(y) = a h(x) + b ∂cj ∂cj  σi2 
 i=1 
où g et h sont des fonctions connues sans paramètre ajus-
table (ici, k est la constante de Boltzmann, connue), tout
ce qui est ci-dessus est utilisable sans difficulté. Il est aisé de se rendre compte que si l’on pose :
 Xn
4.8.2.5 Un caveat. 
 xj+k
i

 Ajk = 2
i=1
σ i
n
X yi xj



 Bj = 2
i
i=1
σ i
le problème se ramène à la résolution d’un système linéaire

(p + 1) × (p + 1) :
A·C=B
avec des notations évidentes. De plus :
v
u
u χ2
Rw = u n
u X P (xi )2
t
i=1
σ2
et : s
χ2
δck =
Akk
Les généralisations du type :
Fig. 4.19 – L’ajustement d’une fonction linéaire à des
données aléatoires donne un résultat. Ici : 0.79875 − g(y) = P (h(x))
0.24841 × x. Quel sens donner à ces nombres ? Aucun !
où g et h sont des fonctions connues sont évidemment
Malheureusement, tout ceci est un peu trop beau. En possibles.
effet il suffit de considérer les équations de ce chapitre À condition de disposer d’un sous-programme de
pour constater que ces méthodes donneront toujours un résolution de systèmes linéaires, tout ceci est très simple à
résultat, si absurde soit-il. La figure 4.19 montre l’ajuste- programmer, ça marche très bien et c’est rapide car il n’y
ment d’une droite sur un nuage de points aléatoires. a pas à converger plus ou moins laborieusement vers une
On obtient des nombres. solution.
Alors, s’agit-il du programme « résout tout problème,

marche à tout coup » ? Poser la question est évidemment
un début de réponse.
Revenons au pot de yaourt du paragraphe 4.8.2.3.
Il est probable que l’ajustement d’une fonction linéaire
laissera des écarts entre cette fonction et les données
expérimentales : faut-il alors prendre un polynôme de
degré plus élevé ? Il est clair que l’ajustement en sera
meilleur : à la limite, si l’on prend un degré égal au nombre
de points moins un, p = n − 1, on obtiendra un polynôme
passant par tous les points expérimentaux ! Mais les coef-
ficients ainsi introduits ont-ils un sens physique ? Non !
Il faut d’abord se poser des questions physiques. Par
exemple, y a-t-il une raison pour laquelle le modèle choisi
ne conviendrait pas ? Comme le thermostat a un cycle de
24 heures car on chauffe moins la nuit, ne pourrait-on pas
plutôt introduire cette périodicité dans le problème ? On Fig. 4.20 – Un cosinus bruité, sa dérivée calculée avec
pourrait tenter quelque chose comme q = 3 et avec q = 10.
¯ + µ sin 2π t
ṁ = ṁ
τ Exercice : essayer de calculer ṁ(t) à partir des données
de mesure. On constatera qu’il faut choisir un intervalle
Évidemment, c’est plus difficile parce qu’il ne s’agit plus
de mesure sensiblement plus court que la durée des va-
d’un polynôme et il faudra recourir aux méthodes du para-
¯ riations quotidiennes de la température : l’idéal étant un
graphe 4.8.6, mais c’est peut-être plus réaliste, puisque ṁ
enregistrement toutes les heures par exemple.
devient alors la vitesse moyenne d’évaporation et µ l’am-
plitude des variations périodiques. On peut même aller un
peu plus loin en remarquant que ṁ est sans doute propor- 4.8.5 Lissage : a dirty trick !
tionnel à la pression laquelle obéit probablement à une loi Il arrive que les informations intéressantes d’une
d’Arrhenius en fonction de la température. . . expérience soient difficilement visibles sur la courbe
expérimentale obtenue à cause du bruit. La plupart des
4.8.4 Dérivée locale d’une courbe logiciels d’acquisition offrent des options de smoothing ou
expérimentale. lissage visant à réduire le bruit. Il s’agit d’ajuster locale-
ment un polynôme comme précédemment, par exemple un
On peut aussi prendre la question différemment : l’in- polynôme d’ordre 2 :
connue « intéressante » de l’expérience est la vitesse
d’évaporation ṁ : c’est cela que l’on cherche à mesurer. Lij = c2i δx2 j 2 + c1i δxj + c0i
On voudrait calculer la dérivée locale de la mesure et c’est
à cette grandeur là que l’on tentera d’appliquer quelque mais seul la valeur en xi de l’ajustement local nous
théorie. intéresse :
Il suffit d’ajuster localement une fonction linéaire : Li0 = c0i
f (x) = c1i x + c0i car on remplacera les xi par les valeurs lissées Li0 . À la
suite de calculs sans difficulté, on obtient, toujours par les
à condition de rester proche de xi . Le χ2 devient local mêmes méthodes :
autour du point xi : q
X
+q
X J y
4 i + (J4 − J2 k 2 )(yi+k + yi−k )
2
χ2i = (c1i xk+i + c0i − yi+k ) Li0 = c0i = k=1
(4.20)
k=−q J0 J4 − J22
où q détermine la largeur de l’intervalle autour de xi où ce où q
calcul est fait. Le coefficient c1i est donc la dérivée locale X
Jℓ = jℓ
recherchée : un calcul sans difficulté donne :
j=−q
+q
X
3 soit :
c1i = k yi+k q(q + 1)(2q + 1)
δx q(q + 1)(2q + 1) J0 = 2q + 1, J2 = ,
k=−q
3
dans le cas où xi = x0 + iδx 27 . Évidemment, le résultat q(q + 1)(2q + 1)(3q 2 + 3q − 1)
J4 =
que l’on trouve dépend de q : si l’on choisit une valeur 15
de q petite, le résultat risque d’être sensible au bruit, en (les Jℓ pour ℓ impair sont bien sûr tous nuls) et
revanche, si q est trop grand, on perdra les fluctuations
rapides (voir la figure 4.20). Il faut choisir autant que pos- q(q + 1)(2q + 1)2 (4q 2 + 4q − 3)
J0 J4 − J22 =
sible qδx < ∆x l’ordre de grandeur des variations que l’on 45
cherche à détecter. C’est encore extrêmement facile à programmer et ra-
P+q 2 q(q+1)(2q+1)
27 Il faut se rappeler au passage que
−q
k = 3
. pide à l’exécution. Il faut cependant réaliser que 1˚ le
résultat dépend de q et 2˚ il ne s’agit en fait que d’une que ces méthodes deviennent infaillibles, elles conservent
moyenne pondérée de points voisins. Il y a ici une hy- les défauts déjà vus. Si le point de départ de la recherche,
pothèse sous-jacente très importante : c’est que les varia- les paramètres initiaux, est trop éloigné d’une solution, le
tions intéressantes sont de longueur d’onde ou de dimen- résultat obtenu risque d’être absurde, si le modèle com-
sion caractéristique grande par rapport aux fluctuations porte un trop grand nombre de paramètres ajustables
dues au bruit et donc à l’intervalle balayé dans l’équation (chaque paramètre ajoute une dimension à l’espace de re-
(4.20). C’est pour cela qu’il vaut généralement mieux, sauf cherche) la signification du résultat final risque d’être assez
pour des raisons « cosmétiques » ne pas faire de lissage, et, discutable. . .
au contraire, ajuster une fonction physiquement justifiée Ainsi, lorsqu’on ajuste un modèle théorique à une
aux résultats non lissés : si l’information intéressante est expérience, on est donc confronté à deux types de diffi-
là et si le modèle choisi est susceptible de la révéler, l’ajus- cultés :
tement devrait la faire apparaı̂tre. – la recherche du minimum de χ2 , il est parfois difficile
de se convaincre que le minimum trouvé est bien le
4.8.6 Ajustement non-linéaire. minimum de la fonction
– le fait que d’avoir trouvé le minimum de χ2 ne valide
Ce qui rend l’ajustement de polynômes si simple, c’est en aucun cas le modèle utilisé.
que la dépendance d’un polynôme par rapport aux pa-
Ces mises en garde ne doivent toutefois pas être vues
ramètres, c’est-à-dire aux coefficients, est linéaire : ax2 +
comme devant dissuader d’utiliser ces outils : il faut les
bx + c est une fonction linéaire de a, b et c, même si ce
utiliser, ils sont d’une grande puissance ! Parfois, un ajus-
n’est pas une fonction linéaire de x. En revanche, on peut
tement difficile ou qui paraı̂t donner des résultats douteux
vouloir chercher à ajuster une fonction comme :
est une indication qu’un autre modèle (pas forcément plus
L0 compliqué, d’ailleurs) serait peut-être meilleur. Il faut sim-
L(x) = 2 plement se rappeler que l’ordinateur qui fait le calcul est
x − x0
1+ un serviteur puissant mais. . . stupide ! Au physicien de
γ
faire son métier et de garder un regard critique.
C’est une lorentzienne comme sur la figure 4.21 où, comme Il existe, au reste, de bonnes habitudes qui peuvent ai-
le montre une analyse élémentaire, L0 est la hauteur de der à éviter des mésaventures. La première est de tracer
la courbe, x0 la position de son maximum et γ sa demi- sur un même graphe la courbe théorique et les résultats
largeur à mi-hauteur. Il est facile de montrer que la lo- expérimentaux pour voir si ça ressemble ! L’œil humain
rentzienne est le module au carré de la transformée de est un bon juge en la matière. On peut pousser un peu
t
Fourier de eiωt− τ et donc la réponse spectrale des oscilla- plus loin en traçant la courbe des écarts entre fonction
tions amorties, ce qui en fait une courbe très répandue en théorique et expérience : en principe, on ne devrait voir
spectroscopie, par exemple optique : la position du som- que du bruit, c’est-à-dire un signal aléatoire, symétrique
met de la courbe donne la fréquence de l’oscillateur et sa par rapport à l’axe des abscisses. Si des zones où les écarts
largeur, l’amortissement. sont systématiquement positifs ou négatifs apparaissent,
c’est peut être le signe qu’il y a là à chercher davan-
1
tage. On peut aussi refaire l’ajustement à partir de jeux
0.9 de paramètres initiaux différents : il vaudrait mieux que
0.8 le résultat final n’en dépende pas trop ! Si certains pa-
0.7 ramètres se retrouvent affectés d’une déviation standard
estimée très élevée (par exemple d’un ordre de grandeur
0.6
comparable au paramètre lui-même), on se demander s’il
0.5 est vraiment utile de le garder : ne pourrait-on pas ima-
0.4 giner un modèle dont il est absent ? Si oui, est-ce que le
0.3 résultat obtenu est très différent du précédent ?
0.2 Voici un exemple authentique : il s’agissait d’une
expérience de diffusion Raman, c’est-à-dire de diffusion
0.1
inélastique de la lumière. On éclairait un échantillon avec
0
−5 0 5 10 de la lumière monochromatique de longueur d’onde connue
5145Å, et on analysait la lumière diffusée par l’échantillon
Fig. 4.21 – Lorentzienne avec L0 = 1, γ = 0.5 et x0 = 2. à l’aide d’un ensemble de réseaux. Le résultat expérimental
était l’intensité lumineuse en fonction de la pulsation
Les paramètres que l’on veut ajuster sont L0 , x0 et γ, I(ω) et la courbe obtenue ressemblait à la figure 4.21
or L n’est linéaire ni en x0 ni en γ ; alors on linéarise le avec du bruit. On connaissait les propriétés du disposi-
problème en sachant que le résultat ne sera pas correct tif expérimental et la théorie disait que le résultat devait
mais en espérant qu’il sera moins mauvais que le point être le produit de convolution d’une lorentzienne par une
de départ et l’on répète l’opération jusqu’à ce qu’une so- « fonction d’appareil » qui reproduisait les caractéristiques
lution acceptable soit trouvée. Il s’agit donc, une fois de du dispositif. L’ajustement donna, sans surprise, hauteur,
plus, de rechercher un minimum de χ2 en fonction de ses position et largeur de la lorentzienne. On traça alors la
paramètres, seulement, il n’y a plus de solution simple, courbe des écarts pour s’apercevoir qu’il y avait une bosse
il faut utiliser une méthode du type Newton ou gradient systématiquement positive au pied de cette lorentzienne.
conjugué avec les précautions qu’imposent ces méthodes : On tenta alors de reprendre l’ajustement avec d’autres pa-
ce n’est pas parce que cela fait partie d’un logiciel tout fait ramètres initiaux, et/ou en bloquant à des valeurs « rai-
sonnables » l’un ou l’autre paramètre sans jamais réussir Il suffit d’ajouter une deuxième lorentzienne :
à réduire cette bosse. . . Finalement, l’on décida d’intro- f(x) = l1/(1+((x-x1)/g1)**2)+l2/(1+((x-x2)/g2)**2)
duire dans le modèle une deuxième lorentzienne, toujours x1 = 940 ; x2 = 950 ; l = 1000
convoluée avec la fonction d’appareil : le résultat devint fit f(x) ’lorentz.out’ u 1 :2 :(1) via l1, l2, x1,
excellent ! La lumière diffusée comportait donc deux pics x2, g1, g2
à deux fréquences différentes et non un : le premier était et l’on obtient :
2500
celui que l’on voyait à l’œil nu, le deuxième, beaucoup plus f(x)
’lo2’
faible en intensité, à une fréquence légèrement supérieure,
était caché dans le pied du premier : l’analyse attentive du 2000
résultat de l’ajustement avait seule permis de le détecter.

Restait évidemment à expliquer d’où il venait, ce deuxième
1500
pic. . . : il s’avéra qu’en fait le premier pic était dû à des im-
perfections du dispositif expérimental et que l’information
physique résidait dans le deuxième. 1000
500
Comme beaucoup d’autres programmes, le logiciel de tracé

de courbe gnuplot comporte une fonction fit qui permet de 0
900 920 940 960 980 1000
faire toutes sortes d’ajustements de fonctions à des données
sans avoir à écrire soi-même un programme. La syntaxe en avec les valeurs :
est assez simple, par exemple : l1 = 2019.76 +/- 8.07 ; l2 = 112.795 +/- 6.978 ; x1
fit a*x**2+b*x+c ’fichier’ via a,b,c = 940.013 +/- 0.02164 ; x2 = 953.61 +/- 0.4528 ; g1
permet d’ajuster un polynôme du deuxième degré aux = 4.96645 +/- 0.03408 ; g2 = 5.86099 +/- 0.7297
valeurs contenues dans un fichier. Implicitement, la première On peut même tracer les écarts entre la fonction théorique
colonne du fichier contient les valeurs de x, la deuxième et les données :
celles de y et la troisième celles des incertitudes sur y. Si ces plot "lorentz.out" using 1 :($2-f($1))
dernières sont inconnues ou constantes, on peut taper : 60
fit a*x**2+b*x+c ’fichier’ using 1 :2 :(1) via

50
a,b,c
ce qui fixe la valeur de cette incertitude uniformément à 1. 40
Le résultat de l’opération est la valeur de a, b et c. 30
On peut faire des choses plus sophistiquées :

20
f(x) = l/(1+((x-x0)/g)**2)
x0 = 940 ; l = 1000 10
fit f(x) ’lorentz.out’ u 1 :2 :(1) via l, x0, g 0

On ajuste alors une lorentzienne à des valeurs contenues dans
-10
un fichier, en donnant des valeurs initiales à plusieurs va-
riables pour « aider » le programme. Pour tracer le résultat : -20
plot f(x), ’lorentz.out’ -30

ce qui donne la figure ci-dessous.
-40
l = 2007.89 +/- 14.49; x0 = 940.12 +/- 0.03819 ; g = 5.26853 +/- 0.05383 900 920 940 960 980 1000
2500
fonction
donnees
2000 Tab. 4.2 – Fit avec gnuplot (suite de la table 4.1).
1500
4.9 Systèmes d’équations diffé-

1000 rentielles ordinaires.
Les physiciens sont extrêmement prolifiques lorsqu’il
500
s’agit de produire, à partir de problèmes divers, des
équations différentielles ordinaires (par exemple, les
0
900 920 940 960 980 1000
équations du mouvement de la mécanique newtonienne).
Malheureusement, l’inspiration manque parfois lorsqu’il
On observe une petite « bosse ». . . qu’à cela ne tienne ! Voir
la table 4.2.
s’agit de les résoudre, en particulier quand elles ne sont
pas linéaires : un petit programme de résolution numérique
Tab. 4.1 – Fit avec gnuplot peut alors s’avérer précieux.
4.9.1 Un exemple : les lignes de champ.

Admettons que l’on puisse calculer en chaque point ~r le
~ r ) dû à une distribution de charges et
Cette anecdote n’a rien d’exceptionnel : pratiquement champ électrique E(~
tout expérimentateur en a d’autres du même style à ra- que l’on en veuille tracer les lignes de champ. Une ligne
conter, ce genre d’aventure fait partie du métier ! de champ est définie par le fait qu’elle est en chaque point
parallèle au champ : 4.9.2 La méthode d’Euler.

~ r)
d~s // E(~ Soit donc, pour généraliser, un système de n équations
différentielles du premier ordre du type :
où le vecteur d~s est le vecteur élémentaire tangeant au
dyℓ
point ~r à la ligne de champ (figure 4.22) et s est l’abscisse = fℓ (x, {yp }), ∀ℓ ∈ [1, n]
curviligne sur la ligne de champ. dx
et l’on cherche à calculer numériquement les valeurs
ds des yℓ (x) en connaissant les expressions des dérivées
fℓ (x, {yp }) en fonction de x et de l’ensemble des yp (dans
l’exemple précédent, on avait les dérivées des coordonnées
d’un point sur la ligne de champ par rapport à l’abs-
cisse curviligne en fonction du champ, lui-même dépendant
de la position). Il faut alors fixer des conditions initiales
(0)
yℓ (x0 ) et un pas d’intégration fini dx et procéder pas à
Ligne de champ pas :
(k) (k−1)
yℓ = yℓ + fℓ (xk−1 , {yp(k−1) })dx
Il s’agit simplement d’une approximation linéaire des fonc-
tions yℓ pour chaque pas d’intégration k où la pente des
Fig. 4.22 – Une ligne de champ fonctions est estimée à partir du résultat précédent (figure
4.23).
Si les coordonnées de d~s sont (dx, dy, dz), on obtient
évidemment en chaque point ~r :
dx dy dz ds
= = =
Ex Ey Ez E y (2) (3)
(1) (2) f
y f
(1) f
~ et E = kEk.
où, bien sûr, ds = kdsk ~ On aboutit alors
(0)
à un système de trois équations différentielles du premier f
(0)
ordre : y
dx Ex (~r)
=
ds E(~r) dx
dy Ey (~r)
=
ds E(~r)
dz Ez (~r)
=
ds E(~r)
dont la résolution doit donner les équations paramétriques

x(s), y(s) et z(s) en fonction de l’abscisse curviligne s de
la ligne champ considérée. x0 x1 x2
Pour résoudre numériquement ce système, on part d’un
point donné (x0 , y0 , z0 ) (les conditions initiales pour une Fig. 4.23 – La méthode d’Euler (ici à une dimension,
ligne donnée), et l’on choisit un pas d’intégration fini ds, c’est-à-dire une seule équation différentielle) : on cal-
comme pour les intégrations numériques du chapitre 4.3.2. cule les dérivées en un point, on prolonge les fonctions
Il reste alors à intégrer pas à pas : linéairement en ce point en utilisant les dérivées sur un
pas d’intégration fini dx ce qui donne un nouveau point
xn = xn−1 + dx de départ d’où l’on peut recommencer.
yn = yn−1 + dy
zn = zn−1 + dz Comme pour les problèmes d’intégrales, la difficulté est
évidemment le choix du pas d’intégration : la première
avec règle est évidemment qu’il doit être petit par rapport à une
distance de variation significative des fonctions étudiées.
Ex (xn−1 , yn−1 , zn−1 ) Ici, une fois de plus, il ne faut pas oublier que l’on est
dx = ds
E(xn−1 , yn−1 , zn−1 ) physicien : par exemple dans le cas des lignes de champ,
Ey (xn−1 , yn−1 , zn−1 ) on peut tenter de tracer deux lignes très proches et vérifier
dy = ds
E(xn−1 , yn−1 , zn−1 ) qu’elles ne se croisent pas. . .
Ez (xn−1 , yn−1 , zn−1 )
dz = ds
E(xn−1 , yn−1 , zn−1 ) 4.9.3 La méthode d’Euler « améliorée »
ou méthode de Heun.
c’est ce que l’on appelle la méthode d’Euler. Pour tracer
d’autres lignes de champ, il suffit de partir d’autres condi- La méthode d’Euler donne souvent des résultats satisfai-
tions initiales et de recommencer. sants, mais elle a le défaut que les dérivées sont évaluées au
début de l’intervalle dx : il y a là une dissymétrie génante, d’Euler et obtenir de nouvelles valeurs des yp : on ne trou-
car il n’y a pas de raison d’évaluer les dérivées au début vera pas le même résultat puisqu’on n’utilise pas les mêmes
plutôt qu’à la fin ou au milieu de l’intervalle. On retrouve dérivées, il ne s’agit toujours que d’estimations. Cela per-
les questions abordées pour l’intégration dans le chapitre met d’obtenir une troisième estimation de dérivées. Cette
4.3.2 par la méthode des rectangles, à gauche, à droite troisième estimation est utilisée pour faire un pas complet,
ou centrés. La différence est qu’alors, on pouvait calculer cette fois-ci, d’Euler, toujours à partir du même point de
la fonction à intégrer n’importe où : ce n’est plus le cas départ : quatrième estimation des yp et des dérivées. . .
puisque les valeurs des fonctions sont les réponses que l’on
cherche justement. On ne connait que les dérivées en fonc-
tion des valeurs prises par ce que l’on cherche, puisque les
(4)
fℓ dépendent des yp : on tourne en rond !
(2) (3)
(1)
(3)
y(x) première estimation de la dérivée (2)
deuxième estimation
y(x+dx)
moyenne des 2 dérivées

dx/2
x x+dx dx
Fig. 4.24 – Méthode d’Euler améliorée

Fig. 4.25 – Les quatre évaluations de la dérivée dans la
Ce que l’on aimerait faire, c’est une estimation de la méthode de Runge-Kutta d’ordre 4.
dérivée au milieu de l’intervalle dx (au demi-pas) en faisant
une moyenne entre les valeurs des dérivées au début et à Il reste alors à faire une moyenne pondérée de ces
la fin de l’intervalle : quatre estimations en faisant compter celles du milieu
deux fois plus et faire enfin un pas de longueur dx. Le
(k−1) (k)
f ℓ (xk−1 , {y p }) + f ℓ (xk , {y p }) sous-programme correspondant est très simple :
fℓ (xk−1/2 , {yp(k−1/2) }) =
2
(4.21) subroutine rk4(x,y,dx,n,deriv)
(k) !--------------------------------------------!
Comme la valeur de yp est inconnue, on peut faire
! sous programme de resolution d’equations !
une première estimation à l’aide de la méthode d’Euler ! differentielles du premier ordre par la !
précédente ; puis on applique l’équation (4.21) pour ob- ! methode de Runge-Kutta !
tenir la dérivée au demi-pas et enfin on peut utiliser de ! x = abscisse !
nouveau la méthode d’Euler avec cette dérivée corrigée ! y = valeurs des fonctions !
(figure 4.24). ! dx = pas !
Le coût de cette amélioration est évidemment que ! n = nombre d’equations differentielles !
l’on doit faire deux estimation des dérivées par pas ! deriv = variable contenant le nom du !
d’intégration, mais évidemment, ce coût peut être com- ! sous-programme qui calcule les derivees !
pensé si l’on peut obtenir la même précision, voire !--------------------------------------------!
mieux, qu’avec la méthode d’Euler en prenant un pas implicit none
integer , intent(in) :: n
d’intégration deux fois plus grand.
real, dimension(n), intent(inout) :: y
real , intent(in) :: x, dx
4.9.4 La méthode de Runge-Kutta ! d1, d2, d3, d4 = estimations des derivees
d’ordre 4. ! yp = estimations intermediaires des fonctions
real, dimension(n) :: d1, d2, d3, d4, yp
Il se trouve que la méthode de Heun est assez peu uti- real :: ddx, c = 1.0/6.0
lisée car, la méthode de Runge-Kutta d’ordre 4 est un
pas supplémentaire dans cette direction qui offre souvent ddx = dx/2
un très bon compromis : elle tente de faire une meilleure call deriv(x ,y ,d1,n); yp=y+d1*ddx
call deriv(x+ddx,yp,d2,n); yp=y+d2*ddx
estimation des dérivées à l’aide d’une moyenne de 4 esti-
call deriv(x+ddx,yp,d3,n); yp=y+d3*dx
mations (d’où l’ordre 4). call deriv(x+dx ,yp,d4,n); y =y+c*(d1+2*d2+2*d3+d4)*dx
La première estimation est celle d’Euler : on calcule les
dérivées au point x connaissant les yp (x) déjà calculés au end
pas précédent. On fait alors un demi-pas de longueur dx 2
par la méthode d’Euler pour évaluer les valeurs des yp -Exercice : vérifier que le programme ci-dessus fait bien
au demi-pas : cela permet de calculer de nouvelles valeurs ce qui est annoncé. . .
des dérivées (figure 4.25). On revient au point de départ et Pour utiliser ce sous-programme, il faut un programme
l’on utilise ces nouvelles dérivées pour refaire un demi-pas principal qui fasse une boucle sur x et qui gère les entrée-
sorties et un autre sous-programme qui contient la phy- Un autre exemple célèbre est l’équation de Schrödinger
sique du problème, soit le calcul des dérivées : dans le cas dépendant du temps : si l’on ne fait pas très attention, on
des lignes de champ, il doit calculer les composantes du obtient que la norme de la fonction d’onde diverge expo-
champ, sa norme et faire les rapports. nentiellement avec le temps, ce qui est fâcheux !
Cela ressemble certes à une recette de cuisine, mais Dans les deux cas, la méthode de Cranck et Nicholson
c’est un des chevaux de bataille des physiciens : c’est une peut être une solution.
méthode remarquablement efficace ! Une illustration en est Si l’on revient à la méthode d’Euler, la critique qui en
donnée figure 4.26. avait été faite était qu’elle est dissymétrique :
(k+1) (k) (k)
yℓ = yℓ + fℓ (xk , {yℓ′ })dx
la variation des fonctions étant entièrement calculée à par-
tir des valeurs des dérivées au début de l’intervalle : on
pourrait tout aussi bien faire le même calcul en utilisant
les dérivées à la fin de l’intervalle :
(k+1) (k) (k+1)
yℓ = yℓ + fℓ (xk+1 , {yℓ′ })dx
La méthode de Heun faisait une estimation des dérivées
en fin de l’intervalle par la méthode d’Euler, mais il y a
là encore une part d’arbitraire : on peut remarquer tou-
tefois que l’équation ci-dessus est une équation implicite,
(k+1)
les inconnues yℓ figurant dans le deuxième membre ;
il faut donc résoudre un système d’équations (en général
non-linéaires) :
(k+1) (k) (k+1)
yℓ − yℓ − fℓ (xk+1 , {yℓ′ })dx = 0
c’est une recherche de zéro qui peut être faite par la

méthode de Newton déjà vue (§4.5.3). Cette méthode est
appelée la méthode d’Euler implicite mais elle n’apporte
guère par rapport à la méthode d’Euler explicite déjà vue
Fig. 4.26 – Lignes de champ d’un système de trois charges -elle est tout aussi dissymétrique- sinon qu’elle est sensi-
calculées à l’aide de la méthode de Runge-Kutta d’ordre blement plus compliquée !
4. La méthode de Cranck et Nicholson est une moyenne
entre la méthode d’Euler explicite et la méthode d’Euler
implicite, qui rétablit ainsi la symétrie à la manière de la
méthode de Heun, mais de façon plus rigoureuse :
4.9.5 La méthode de Cranck et Nicholson
(k) (k+1)
Même la méthode de Runge-Kutta, malgré toutes f ℓ (x k , {y ℓ ′ }) + f ℓ (xk+1 , {y ℓ ′ })
(k+1) (k)
yℓ = yℓ + dx
ses qualités, ne donne pas toujours entière satisfaction. 2
Un exemple classique et le modèle proies-prédateurs de (k+1)
Volterra-Lotka28. Le nombre x de proies croı̂t au cours du ce qui donne à résoudre en yℓ′ :
temps d’un coefficient a mais diminue proportionnellement
(k) (k+1)
au nombre de prédateurs y : f ℓ (xk , {y ℓ ′ }) + f ℓ (x k+1 , {y ℓ ′ })
(k+1) (k)
yℓ − yℓ − dx = 0
2
dx (4.22)
= x (a − by)
dt C’est une méthode assez lourde puisqu’il faut résoudre
un système non-linéaire d’équations (4.22) par la méthode
De même, le nombre de prédateurs décroı̂t d’un taux c à de Newton, ce qui suppose de calculer la matrice ja-
cause de la mortalité, mais croı̂t proportionnellement aux cobienne des dérivées partielles et un programme de
ressources disponibles en proies, soit : résolution de systèmes linéaires appelé itérativement en
dy espérant que les solutions trouvées accepteront de conver-
= y (−c + d x) ger. Il s’agit cependant d’un moyen puissant pour se tirer
dt
de situations délicates, à garder donc dans ses archives au
On démontre que les solutions de ce système d’équations cas où !
sont périodiques au cours du temps : un bon test est donc
de vérifier la périodicité du résultat numérique obtenu en 4.9.6 Équations d’ordre supérieur à 1.
traçant, par exemple, y en fonction de x afin de voir si
la trajectoire obtenue repasse toujours au mêmes endroits Pour le moment, on s’en est tenu à des systèmes
(voir la figure 4.27). . . ce qui n’est, bien sûr, jamais par- d’équations d’ordre un : en fait, c’est beaucoup moins res-
faitement obtenu ! trictif que cela en a l’air. Soit par exemple, une équation
28
du deuxième ordre :
voir par exemple :
http ://perso.univ-rennes1.fr/gregory.vial/agreg/cplt/ d2 y dy
volterra.pdf. +a =f
dx2 dx
temps dans le sous-programme de calcul des forces ; il est

vital d’optimiser ces calculs là. Or, ce n’est sans doute pas
une très bonne idée, dans ce cas là, d’utiliser un algorithme
comme Runge-Kutta30 qui exige quatre estimations des
forces par pas de calcul !
L’algorithme de Verlet est une réponse très simple à ce
problème :

 dt dt f ({~r ′ (t)})
 ~vℓ (t + ) = vℓ (t − ) + ℓ ℓ dt
2 2 mℓ

 ~r (t + dt) = ~r (t) + ~v (t + dt )dt
ℓ ℓ ℓ
2
Les vitesses sont évaluées au demi-pas, alors que les posi-
tions et les forces sont évaluées au pas entier, ce qui sup-
prime la dissymétrie qui était génante dans la méthode
d’Euler.
Fig. 4.27 – Vérification de la périodicité du problème de Cette méthode est fort utilisée sous des formes diverses
Volterra-Lotka résolu par la méthode de Cranck et Nichol- dès que l’on s’intéresse à la dynamique de systèmes com-
son. portant un grand nombre de particules (de quelques di-
zaines à quelques dizaines de milliers. . .).
où a peut être une constante ou une fonction de y. Si l’on
introduit une variable supplémentaire z qui est la dérivée 4.9.8 Le problème du pas d’intégration.
première de y, on obtient :
Dans tout ces problèmes d’équations différentielles, on

 dy l’a vu, le pas d’intégration est non-nul, il est petit, certes,
 =z
dx mais il n’est pas nul. « Il n’y a qu’à » le choisir as-
 dz = f − az
 sez petit. . . Ce n’est, hélas, pas toujours aussi simple :
dx si on le choisit trop petit, on multiplie le nombre des
itérations, ce qui allonge inutilement la durée du calcul,
deux équations différentielles du premier ordre. On peut mais aussi multiplie les erreurs d’arrondi ; trop diminuer
donc toujours décomposer des équations différentielles le pas d’intégration diminue la précision du calcul, on perd
d’ordre supérieur à un en plusieurs équations d’ordre un à sur tous les tableaux ! Un compromis s’impose alors, mais
condition d’introduire des variables supplémentaires qui selon quel critère ?
sont les dérivées successives des fonctions. Ainsi, trois Il appartient à chacun de se poser cette question et de
équations du deuxième ordre se transforment aisément en tenter d’y répondre par une étude a priori du problème.
six équations du premier ordre, une équation du troisième Par exemple, s’il s’agit d’un système mécanique isolé non-
ordre devient trois du premier ordre, etc. dissipatif, la somme de l’énergie potentielle et de l’énergie
cinétique doit rester constante au cours du calcul, c’est la
4.9.7 Méthode de Verlet. physique qui le dit ! La périodicité attendue du problème
de Volterra-Lotka est aussi un bon critère, la conserva-
Les systèmes d’équations différentielles du deuxième
tion de la norme de la fonction d’onde pour l’équation de
ordre sont d’un intérêt particulier en physique puisque les
Schrödinger également. Bien souvent, on peut résoudre le
équations du mouvement d’un ensemble de n mobiles en
système d’équations différentielles dans un cas proche de
interaction s’écrivent :
celui qui nous intéresse mais dont on connait la solution
d2~rℓ d~rp analytique (un système linéaire, par exemple) et vérifier
2
= f~ℓ ({~rp , }), ∀ℓ ∈ [1, n] que le calcul numérique donne bien le même résultat, ou
dt dt
un résultat très proche du calcul analytique.
Cela se résout sans difficulté majeure par la méthode Ces questions ne sont pas à négliger : revenons à
de Runge-Kutta, voire par Cranck-Nicholson, puisque l’équation logistique de la section 3.2. Si on la considère
cela donne 3n équations du deuxième ordre et donc 6n comme une équation différentielle, implicitement, puisque
équations du premier ordre. la population d’insecte de la génération n + 1 est calculée
Si l’on se restreint à des interactions de paire, les forces un an après celle de la génération n, le pas d’intégration
s’écrivent : est de un an. On pourrait imaginer d’intégrer analytique-
Xn
f~ℓ = f~ℓℓ′ ment cette équation et considérant le temps comme une
ℓ′ =1,ℓ′ 6=ℓ
variable continue et donc un pas d’intégration qui tend
vers zéro :
soit, en tenant compte du principe de l’action et de la
réaction29, n(n−1)
2 forces à calculer. Si l’on est en train x(t + dt) = r x(t) (1 − x(t)) dt
de s’intéresser à un système composé d’un grand nombre
d’atomes, ou à une galaxie comportant beaucoup d’étoiles, soit :
cela fait vite un nombre prodigieux de forces à calculer et dx x(t + dt) − x(t)
l’expérience prouve que le programme va passer 99% du = = x (r(1 − x) − 1)
dt dt
29 f~ ′ = −f~ℓℓ′ . 30 sans parler de Cranck-Nicholson. . .
ℓ ℓ
Il s’agit d’une équation différentielle qui se résoud analyti- Heun et Runge-Kutta, l’application est facile : il suf-
quement à la main avec un peu de travail31 , ou alors grâce fit de décomposer l’équation du deuxième ordre en deux
à un logiciel de calcul formel, et l’on obtient : équations du premier ordre, en introduisant une variable
supplémentaire v :
(r − 1)x0
x(t) =
rx0 + (r(1 − x0 ) − 1) e−(r−1)t ẋ = v
v̇ = − sin x
où x0 = x(t = 0). Pour r > 1, cette expression converge
exponentiellement vers son point fixe : plus de chaos ! Pour Cranck-Nicholson, il y a un peu plus de travail ;
On obtient donc un énorme changement qualitatif (figure soient, pour simplifier les notations, x = x(t) et v = v(t)
4.28)32 . x+ = x(t + δt) et v + = v(t + δt). Cela s’écrit :
1
v + v+
x+
dt=1
0.9 continu = x+ δt
2
0.8
sin x + sin x+
0.7 v+ = v− δt
0.6
2
0.5 où x+ et v + sont les inconnues. On a donc deux fonction
x
0.4 dont on doit chercher le zéro par une méthode de Newton :

0.3
0.2 v + v+
f (x+ , v + ) = x − x+ + δt
0.1 2
0 sin x + sin x+
0 5 10 15 20 25 30 35 40 45 50 g(x+ , v + ) = v − v+ − δt
t 2
Fig. 4.28 – Résolution numérique avec dt = 1 et résolution On doit appliquer à x+ et v + des variations dx+ et dv + de
analytique de l’équation logistique pour r = 4 : qui a rai- façons à ce que ces fonctions s’annulent, c’est-à-dire que
son ? df = −f et dg = −g ; or, en linéarisant, comme d’habitude
Le calcul numérique est-il donc faux ? Cela dépend du ∂f ∂f

df = +
dx+ + + dv +
modèle. Si l’on considère qu’il n’y a pas de saison et que le ∂x ∂v
taux de reproduction des insectes dépend instantanément ∂g ∂g
dg = dx + + dv +
+
de la population à l’instant t, alors c’est le calcul avec le ∂x+ ∂v
temps continu qui est correct. Si, au contraire, on considère ∂f ∂g
que le taux de reproduction des insectes dépend de l’état Les dérivées sont aisées à calculer : +
= = −1,
∂x ∂v +
de la génération précédente au moment de la ponte et donc ∂f δt ∂g + δt
de la façon dont elle a pu se nourrir l’année précédente, ∂v + = 2 et ∂x+ = − cos x 2 . Cela donne, tous calculs
alors c’est le pas d’intégration d’un an qui est correct. faits :
Au physicien - averti, bien sûr -, donc, de choisir son
modèle en connaissance de cause et de faire ses choix en f + g δt
dx+ = 2
2
conséquence ! 1 + cos x+ δt 2
dx+ − f
dv + =
4.9.9 Quelle méthode choisir ? δt
2
Comme chaque fois que l’on dispose de plusieurs Le programme qui fait tout cela et calcule la variance de
méthodes pour résoudre un problème se pose la question : l’énergie en fonction du pas de temps peut s’écrire :
laquelle choisir ? Il serait bien sûr tellement agréable de
pouvoir répondre de façon univoque et définitive ! C’est, program pendule
hélas, trop demander. implicit none
À titre indicatif, on a tenté de comparer les méthodes
real, dimension(n) :: theta
exposées ci-dessus dans le cas d’un pendule simple, dont real :: t, dt, tmax
l’équation du mouvement s’écrit : double precision :: e, em, e2m, e0
integer :: nstep, step, it
ẍ = − sin x character (len=1) :: ode
external :: d
où x est l’angle que fait le pendule avec la verticale.
Comme il s’agit d’un système non-dissipatif (sans force write(*,’("Runge-Kutta, Euler, Heun, Verlet, &
de frottement), l’énergie doit rester constante ; ainsi la & Cranck-Nicholson ? ")’,advance=’no’)
variance de l’énergie au cours d’une simulation devrait read(*,*) ode
être nulle : voilà donc un test pour mettre ces algo- open(1, file = ’pendule.var’)
rithmes à l’épreuve. Pour les méthodes d’Euler, Verlet, tmax = 157. ! 25 periodes
do it = -24, 4 ! boucle sur la valeur du
31 On a dt = 10.**(0.25*it) ! pas de temps
peut faire le changement de variable x(t) = b+cy(t) où a, b
et c sont des coefficients à déterminer et y(t) la nouvelle variable. nstep = nint(tmax/dt)
32 Voir H. Krivine, J. Treiner, A. Lesne, soumis Am. J. Phys. em = 0. ; e2m = 0.
theta(1) = 1.5 ; theta(2) = 0. ! cond. init. real, dimension(n), intent(inout) :: y

e0 = theta(2)**2*0.5 - cos(theta(1)) real :: ddx, c= 1.0/6.0
do step = 1, nstep ! boucle sur le temps real, dimension(n) :: yp, k1, k2, k3, k4
t = step*dt ddx = 0.5*dx
select case (ode) call deriv(x ,y ,k1,n) ; yp = y+ddx*k1
case(’R’) call deriv(x+ddx,yp,k2,n) ; yp = y+ddx*k2
call rk4(t, theta, dt, n, d) call deriv(x+ddx,yp,k3,n) ; yp = y+dx*k3
case (’E’) call deriv(x+dx ,yp,k4,n)
call euler(t, theta, dt, n, d) y = y+dx*( k1 + 2.0*k2 + 2.0*k3 + k4 )*c
case (’H’) end
call heun(t, theta, dt, n, d)
case(’V’) subroutine cranck(t,y,dt,n,deriv)
call verlet(t, theta, dt, n, d) implicit none
case(’C’) integer , intent(in) :: n
call cranck(t, theta, dt, n, d) real , intent(in) :: t, dt
case default real, dimension(n), intent(inout) :: y
stop double precision :: x, v, xp, vp, dx, dv, f, g, &
end select dth, eps = 1.e-8
e = theta(2)**2*0.5 - cos(theta(1)) - e0 ! energie external :: deriv
em = em + e ; e2m = e2m + e*e integer :: count
enddo dth = dt/2.d0
em = em/nstep ; e2m = e2m/nstep x = y(1) ; v = y(2)
write(1,*) dt, e2m -em*em ! variance de l’energie xp = x + v*dt ; vp = v - sin(x)*dt ! Euler
enddo do count = 1, 100 ! Newton
close(1) f = x - xp + (v + vp)*dth
end g = v - vp -(sin(x) + sin(xp))*dth
dx = (f+g*dth)/(1+cos(xp)*dth**2)
subroutine d(t,theta,dtheta,n) ! derivees dv = (dx-f)/dth
implicit none if ( abs(dx) < eps .and. abs(dv) < eps ) exit
integer, intent(in) :: n xp = xp + dx ; vp = vp + dv
real, intent(in) :: t enddo
real, dimension(n), intent(in) :: theta y(1) = xp ; y(2) = vp
real, dimension(n), intent(out) :: dtheta end
dtheta(1) = theta(2) ; dtheta(2) = -sin(theta(1))
end
La figure 4.29 montre le résultat de ces calculs et la table
4.3 donne le temps que cela prend. Le meilleur algorithme
subroutine heun(x,y,dx,n,deriv) est bien sûr celui qui donne la variance la plus faible pour
implicit none le pas de temps le plus grand et la durée d’exécution la
integer :: i, n, nmax plus courte. . .
100000
real, dimension(n), intent(inout) :: y Euler
Verlet
real, dimension(n) :: yp, k1, k2 Heun
Runge−Kutta 4
call deriv(x,y,k1,n) ; yp = y + dx*k1 Cranck−Nicholson
1
call deriv(x,yp,k2,n) ; y = y + dx*0.5*(k1 + k2)
end
Variance
subroutine euler(x,y,dx,n,deriv) 1e−05

implicit none
integer , intent(in) :: n
real , intent(in) :: x, dx 1e−10
real, dimension(n) :: k1
call deriv(x,y,k1,n) ; y = y + dx*k1 1e−15
1e−06 1e−05 1e−04 0.001 0.01 0.1 1 10
end dt
subroutine verlet(x,y,dx,n,deriv) Fig. 4.29 – Variance de l’énergie d’un pendule simple

implicit none en fonction du pas de temps pour plusieurs méthodes
integer , intent(in) :: n d’intégration (échelles logarithmiques).
On constate d’abord que la méthode de Verlet, pour
real, dimension(n) :: dy
une durée d’exécution identique à celle d’Euler et un effort
call deriv(x,y,dy,n)
y(2) = y(2) + dy(2)*dx ; y(1) = y(1) + y(2)*dx de programmation mineur, permet de gagner un ordre de
end grandeur dans le pas d’intégration et plusieurs ordres de
grandeur de précision : Euler paraı̂t donc à rejetter sans
subroutine rk4(x,y,dx,n,deriv) hésitation ! La méthode de Heun permet une amélioration
implicit none sensible des résultats par rapport au deux précédentes,
integer , intent(in) :: n mais Runge-Kutta fait encore nettement mieux puisqu’on
real , intent(in) :: x, dx gagne à peu près un ordre de grandeur pour le pas de
Euler 2mn 8s 4.10.1 La transformée de Fourier en phy-

Verlet 2mn 10s sique.
Heun 3mn 2s
Runge-Kutta 5mn 34s Au début du XIXe siècle, en 1822, le baron Joseph
Cranck-Nicholson 2mn 57s Fourier34 , dans sa Théorie analytique de la chaleur, uti-
lisa pour résoudre la relation qui porte son nom (φ ~ =
Tab. 4.3 – Durées d’exécution du programme ci-dessus −κ grad ~ T , le flux de chaleur est proportionnel au gra-
pour les différentes méthodes (sur un PC). dient de température) des développements sur une base
de sinus et de cosinus : les séries de Fourier. En notations
complexes35 : X
temps pour une durée d’exécution à peine deux fois plus f (t) = cℓ e−2πiℓνt (4.23)
grande. Quant à Cranck & Nicholson, elle se situe à peu de ℓ
choses près dans la même gamme de qualité que Heun, au
ou en développant l’exponentielle :
prix d’un effort de programmation nettement supérieur.
X
Ainsi, la méthode de Runge-Kutta offre un rapport qua- f (t) = aℓ cos(−2πℓνt) + ibℓ sin(−2πℓνt)
lité-prix excellent ce qui explique son succès auprès des ℓ
physiciens !
Il convient toutefois de nuancer assez nettement ce où les coefficients aℓ et bℓ sont complexes, ou encore en
verdict : dans le problème ci-dessus, l’amplitude des os- décomposant les coefficients cℓ en module et phase :
cillations a été choisie forte. Si l’on choisit de faire le X
même calcul pour des amplitudes plus faibles, les résultats f (t) = kcℓ k eiϕℓ e−2πiℓνt
ℓ
changent : en particulier, Cranck & Nicholson ne fait alors X
guère mieux qu’Euler (ce qui confirme que cette méthode = kcℓ k ei(−2πℓνt+ϕℓ )
est à réserver aux cas difficiles) ! Si, au lieu d’un pendule, ℓ
on en avait eu 1000, couplés entre eux, il est fort probable
que la méthode de Verlet aurait sensiblement amélioré son Ce genre de développement1 est limité aux fonctions
score. . . périodiques de période τ = ν , mais on peut généraliser
en considérant que la fréquence, au lieu d’être limitée à ν
La conclusion de tout ceci est que, sauf raison contraire et à ses harmoniques 2ν, 3ν, . . ., ℓν,. . ., varie continûment,
a priori, dans la plupart des cas, la méthode de Runge- ainsi la somme de l’équation (4.23) devient une intégrale :
Kutta est un excellent point de départ, mais pour des
Z ∞
systèmes du second ordre sans frottement pour lesquels
les temps de calcul des dérivées est grand (typiquement f (t) = F (ν) e−2πiνt dν (4.24)
−∞
quelques milliers d’atomes en interaction), Verlet est sans
doute un meilleur choix. Ces remarques ne doivent tou- et inversement :
tefois en aucun cas servir de prétexte pour se dispenser Z ∞
de tests sérieux pour chaque tentative particulière : caveat F (ν) = f (t) e2πiνt dt
33
emptor . −∞
où la fonction F (ν) est la transformée de Fourier de f (t),

L’imagination des numériciens et des mathématiciens
f (t) est la transformée de Fourier inverse de F (ν). La fonc-
appliqués concernant la résolution d’équations différen-
tion f (t) n’a plus de raison d’être périodique.
tielles ordinaires paraı̂t infinie : la littérature sur la
Dans l’équation (4.23), le coefficient complexe cℓ donne
question est surabondante. En particulier, toutes les
le poids et la phase du terme d’ordre ℓ du développement,
méthodes à pas variable qui permettent d’adapter en
c’est-à-dire de la contribution de fréquence ℓν : la même
cours de calcul la longueur du pas d’intégration sont
note (c’est-à-dire un son de même fréquence fondamentale)
complètement ignorées ici. Se reporter au besoin à la
jouée sur un clavecin et sur un piano ne produit pas le
littérature, par exemple, la référence [19] dans la biblio-
même son, c’est que la suite des cℓ n’est pas la même.
graphie.
Dans l’équation (4.24), le terme F (ν) donne de la même
façon le poids et la phase de la contribution de fréquence
ν du signal temporel : il s’agit d’une décomposition en
4.10 Transformées de Fourier ra- fréquences.
pides. 4.10.1.1 Un exemple : le paquet d’ondes.
Dans ce chapitre, nous verrons de façon aussi concrète Imaginons, par exemple, que l’on allume une lumière
que possible ce qu’est une transformée de Fourier pour à l’aide d’un interrupteur à un instant t0 − τ2 et que la
un physicien, sans que cela remplace un cours plus for- maintienne allumée pendant un temps τ , puis on l’éteint.
mel, puis l’on étudiera ce qu’en font les logiciels et sous- 34 À ne pas confondre avec Charles Fourier, philosophe, auteur de
programmes de transformée rapide afin de tenter de saisir l’utopie sociale fouriériste et des phalanstères.
la puissance mais aussi les limites de cet outil extraordi- 35 On peut considérer, pour se fixer les idées, t comme un temps
naire. et ν comme une fréquence, mais les relations données ici sont plus
générales : coordonnées spatiales et vecteur d’onde, par exemple,
sont susceptibles du même traitement, c’est d’ailleurs le cas pour la
33 « Que l’acheteur ouvre l’œil ». relation de Fourier.
Mettons, pour simplifier, que la lumière soit monochroma- durée du paquet d’onde devient petite, la distribution des
tique de fréquence ν0 . On a ainsi produit une onde plane fréquences s’élargit jusqu’à devenir infinie.
interrompue, pour ainsi dire de durée finie, dont l’ampli- Concrètement, si en actionnant à la main un inter-
tude peut s’écrire, au point ~r = 0 : rupteur, l’on allume une lumière ou un laser, puis on
l’éteint une seconde plus tard, la largeur de la distribu-
E(t) = E0 e−2πiν0 t si t0 − τ2 < t < t0 + τ2 tion de fréquences sera de l’ordre de 1Hz ; or la fréquence
E(t) = 0 sinon de la lumière visible est plutôt dans le domaine des
1014 Hz : l’élargissement en fréquences est complétement
La transformée de Fourier d’un tel signal donne, à la négligeable, le paquet d’ondes peut être considéré comme
suite d’un petit calcul : infini sans inconvénient, c’est d’ailleurs l’approximation
Z t0 + τ2 habituelle en optique. En revanche, si l’on choisit d’utiliser
E0 e2πi(ν−ν0 )t dt = un laser à impulsions, chaque impulsion37 durant quelques
t0 − τ2 centaines de femtosecondes38 (ça s’achète dans le com-
merce), la largeur spectrale est de l’ordre de 1013 Hz ce
E0 τ e2πi(ν−ν0 )t0 sinc π(ν − ν0 )τ (4.25) qui n’est plus du tout négligeable comme le montrera le
donc, essentiellement un sinus cardinal36 représenté sur la cours d’optique.
figure 4.30. Ces considérations ne se limitent bien sûr pas à l’op-
tique : un instrument de musique capable de « tenir »
1 une note, comme un orgue, un violon ou une trompette,
0.8 produira un son dont la hauteur ou la fréquence est bien
0.6 définie, alors que pour une percussion, timbale ou tam-
0.4 bour, dont le son est très court dans le temps, la hauteur de
la note est beaucoup moins facile à définir (même s’il existe
0.2
des timbales de hauteurs différentes). De même, dans le do-
0
maine des communications, en général, on utilise une onde
−0.2 porteuse d’une certaine fréquence : il faut que la durée
−0.4 des impulsions qui codent l’information soit relativement
−0.6 longue par rapport à la période de la porteuse afin d’éviter
−0.8 un élargissement trop grand du spectre de fréquence ce qui
−1 se traduit généralement par une dégradation de la qualité
0 2 4 6 8 10 de la transmission.
frequences
1
0.9 4.10.1.2 Quelques propriétés importantes.
0.8 4.10.1.2.1 Notations. La notation utilisée jusqu’ici
0.7 prend la convention temps-fréquence, or on pourrait tout
0.6 aussi bien éviter le facteur 2π grâce à la pulsation ω =
0.5 2πν : Z ∞
0.4 F (ω) = f (t) eiωt dt
−∞
0.3
et Z ∞
0.2 1
f (t) = F (ω) e−iωt dω
0.1 2π −∞
0
0 2 4 6 8 10 Évidemment, le changement de variable introduit le fac-
frequences teur de 1/2π dans la transformée inverse. Les notations
sont parfois diverses : il arrive de√trouver ce facteur réparti
Fig. 4.30 – Transformée de Fourier d’une onde plane in- équitablement sous forme de 1/ 2π dans les expressions
terrompue : en haut partie réelle de l’équation (4.25) pour de la transformée directe et inverse, ou purement et sim-
ν0 = 5, τ = 1 et t0 = 10. En bas, module au carré (i.e. plement supprimé. . . Il est vrai que cela n’a guère d’impor-
produit par son complexe conjugué) de la même chose : tance puisqu’il ne s’agit « que » d’un facteur multiplicatif !
c’est ce que l’on appelle le « spectre ». On a raisonné ici en termes de temps et de fréquence
mais rien n’oblige à ce que t soit un temps : il peut très bien
On constate que l’onde plane interrompue, au lieu de s’agir d’une coordonnée spatiale z et dans ce cas, on rem-
n’avoir qu’une fréquence bien définie ν0 comme une onde placera la pulsation par le vecteur d’onde k = 2π λ où λ peut
plane infinie, s’étale sur tout un spectre de fréquences. Ce être considéré comme une longueur d’onde, par exemple,
spectre est centré sur ν0 , la fréquence de l’onde plane de si ρ(z) est la densité électronique dans un matériau :
départ. Le premier zéro du sinus cardinal donne une esti- Z ∞
mation de la largeur du spectre : on trouve ν − ν0 = ± τ1 . S(k) = ρ(z) eikz dz
Ainsi, si la durée τ du paquet d’ondes devient grande jus- −∞
qu’à tendre vers l’infini, le spectre de fréquence se resserre la quantité S(k) s’appelle le facteur de structure et c’est
autour de ν0 jusqu’à ne plus comporter que la fréquence ce que l’on mesure (ou du moins son module au carré)
ν0 : on retrouve l’onde plane infinie. Au contraire, si la
37 Ou pulse en bon franglais.
36 sinc x sin x 38 1fs=10−15 s.
= x
.
lors d’expériences de diffraction de rayons X : c’est une c’est que l’onde plane infinie a une distribution spectrale
grandeur d’une considérable importance en physique de la qui ne comporte qu’une seule fréquence.
matière condensée : à partir de la connaissance du facteur La distribution de Dirac est parfois fort utile, si , par
de structure, on peut remonter39 à la densité électronique, exemple, on a une distribution de charge ρ(z) qui ne com-
et en admettant que les électrons se situent à proximité porte qu’une charge ponctuelle q située en z0 , on peut
des noyaux, la structure atomique du matériau considéré. écrire :
C’est donc un moyen très puissant d’investigation de la ρ(z) = q δ(z − z0 )
matière.
De façon plus générale, les mathématiciens ne se et introduire ceci sans arrière-pensée dans les intégrales
préoccupent pas toujours du sens physique des variables et transformées de Fourier que l’on choisira afin d’utiliser
utilisées pour s’intéresser à l’objet mathématique « trans- tous les théorèmes habituels.
formée de Fourier » qui peut s’écrire : La distribution de Dirac permet également de vérifier
Z ∞ que l’expression de la transformée de Fourier inverse
ϕ(u) = f (x) eiux dx donnée au début de ce chapitre est correcte : il suffit d’in-
−∞ jecter l’expression :
et la transformée inverse : Z ∞
Z ∞ F (ν) = f (t) e2πiνt dt
1
f (x) = ϕ(u) e−iux du −∞
2π −∞
dans l’équation (4.24) :
4.10.1.2.2 La distribution de Dirac. Intuitive- Z ∞ Z ∞
ment, il s’agit d’une « fonction »40 δ(x) qui vaut zéro par- f (t) =
′
f (t′ ) e2πiνt dt′ e−2πiνt dν
tout sauf en x = 0 où. . . elle est infinie. Soit une fonction −∞ −∞
Z ∞ Z ∞
f (x), alors, la propriété fondamentale de la distribution ′
de Dirac est : = f (t ′
) e2πiν(t −t) dν dt′
−∞ −∞
Z ∞
f (x) δ(x) dx = f (0) après inversion de l’ordre des intégrations. L’intégrale sur
−∞ ν donne δ(t′ − t) et finalement :
ou bien à l’aide d’un changement de variable trivial : Z ∞
Z ∞ f (t) = f (t′ ) δ(t′ − t) dt′
−∞
f (x) δ(x − x0 ) dx = f (x0 )
−∞
ce qui est vrai.
Si l’on applique ceci à la transformée de Fourier, on
obtient : Z ∞ 4.10.1.2.3 Linéarité. La transformée de Fourier est
δ(x) eiux dx = 1 une transformation linéaire : il est facile de se convaincre
−∞
que la transformée de Fourier d’une somme est la somme
la transformée de Fourier d’une Dirac est une constante des transformées de Fourier et que la transformée de Fou-
(un, en l’occurence) : c’est le cas extrême du paquet rier d’une fonction multipliée par une constante est le pro-
d’ondes infiniment court : sa largeur spectrale est infinie, duit de la transformée de Fourier par cette constante,
sa transformée de Fourier non seulement infiniment large Z Z ∞ Z ∞
∞
mais constante.
(f (x) + g(x)) eiux dx = f (x) eiux dx + g(x) eiux dx
Inversement, −∞ −∞ −∞
Z ∞
1 et
C e−iux dx = C δ(x) Z ∞ Z ∞
2π −∞
Cf (x) eiux dx = C f (x) eiux dx
−∞ −∞
la transformée de Fourier d’une constante est la distribu-
tion de Dirac. On peut s’en convaincre en remarquant que, Cela est vrai bien sûr aussi pour les transformées in-
tant que x est non nul, l’intégrale s’effectue sur un nombre verses. Les propriétés suivantes sont tout aussi faciles à
infini de périodes des cosinus et sinus de l’exponentielle démontrer :
complexe, or, bien évidemment : Si. . . alors. . .
Z 2π Z 2π f (x) est réel ϕ(−u) = [ϕ(u)]∗
f (x) est imaginaire pur ϕ(−u) = −[ϕ(u)]∗
sin x dx = cos x dx = 0
0 0 f (x) est paire ϕ(u) est paire
f (x) est impaire ϕ(u) est impaire
et le résultat final est nul. En revanche, quand x = 0, f (x) est réelle et paire ϕ(u) est réelle et paire
l’exponentielle vaut 1 et le résultat est infini. Si donc, la f (x) est réelle et impaire ϕ(u) est imag. et impaire
transformée de Fourier d’une constante donne une Dirac, f (x) est imag. et paire ϕ(u) est imag. et paire
39 En principe. . . toutefois, la grosse difficulté vient de ce qu’on f (x) est imag. et impaire ϕ(u) est réelle et impaire
mesure le module de S(k) seulement et donc on perd la phase de la
fonction complexe.
Par ailleurs, si ϕ(u) est la transformée de Fourier de
40 Ce n’est pas une fonction au sens mathématique, mais une dis- f (x), celle de f (ax) est a1 ϕ( ua ) et celle de f (x − x0 ) s’écrit
tribution. La nuance sera explicitée en mathématiques. ϕ(u) eiux0 .
4.10.1.2.4 Produit de convolution. Imaginons que La transformée de Fourier d’un produit de convolution
l’on fasse une expérience pour mesurer une grandeur y en est le produit des transformées de Fourier.
fonction d’une autre grandeur x, mais l’appareil de me-
sure n’est évidemment pas parfait : si on le règle sur une Le produit des transformées de Fourier est souvent
certaine valeur x = x0 , il « bave » un peu et le résultat beaucoup plus facile à faire que le produit de convolution
obtenu sera une superposition de contributions issues de lui-même, et quand on verra l’efficacité des transformées
points voisins de x0 : de Fourier rapides numériques. . .
Z
ymesure (x0 ) = y(x) a(x0 − x) dx (4.26) 4.10.1.2.5 Quelques transformées de Fourier
« célèbres ». On a déjà vu que la transformée de Fou-
où a(x) est la « fonction d’appareil » dont on peut espérer rier d’une fonction créneau donnait un sinus cardinal et
qu’elle a un maximum relativement marqué en x = 0. . . Le que la distribution de Dirac donnait une constante.
cas arrive, par exemple, si l’on fait une mesure de disper- -La gaussienne. La fonction de Gauss s’écrit :
sion de la lumière à l’aide d’un prisme avec un faisceau de
lumière incident qui ne serait pas parfaitement fin (figure C (x−x0 )2
√ e− 2σ2
4.31). 2π
ν1 où x0 est l’emplacement du sommet et σ sa variance.
ν2 0.4
0.35
0.3
0.25
A 0.2
0.15
0.1
0.05
Fig. 4.31 – Au point A, on reçoit une superposition de
0
lumière de deux fréquences différentes ν1 et ν2 parce que −2 −1 0 1 2 3 4
le faisceau incident n’est pas parfaitement fin. En fait, on
reçoit aussi toutes les fréquences intermédiaires ce qui fait Fig. 4.32 – Gaussienne pour C = 1, x0 = 1 et σ = 0.5.
que le résultat est la superposition de toutes ces contribu-
tions comme dans l’équation (4.26). C’est une courbe (figure 4.32) qui ressemble beaucoup à
la lorentzienne si ce n’est que les « pieds » en sont moins
L’équation (4.26) est un produit de convolution de la large à cause de l’exponentielle qui décroı̂t plus vite que
fonction y par la fonction a. C’est un objet que l’on re- la fraction rationnelle. Si l’on en calcule la transformée de
trouve fréquemment, dans les problèmes de fonction d’ap- Fourier dans le cas le plus simple (x0 = 0, σ = 1), l’on
pareil comme on l’a vu, mais aussi par exemple lorsqu’un obtient :
système répond avec retard à une sollicitation et que son Z ∞ Z ∞
état est le produit de convolution de la sollicitation aux 1 x2 1 x2
ϕ(u) = √ e− 2 eiux dx = √ e− 2 cos ux dx
instants précédents par une « fonction mémoire ». −∞ 2π π −∞
Le produit de convolution d’une fonction f par une fonc-
parce que le sinus de la partie imaginaire de l’exponen-
tion g se note par un astérisque :
Z ∞ tielle est impair et donc l’intégrale correspondante nulle.
f ∗g = ′ ′
f (x ) g(x − x ) dx′ En supposant que tous les théorèmes de convergence sou-
−∞ haitables s’appliquent ici, une dérivation par rapport à u
et c’est une fonction de x. Par un changement de variable, sous le signe intégral donne :
il est facile de montrer que : Z ∞
1 x2
ϕ′ (u) = − √ x e− 2 sin ux dx
g∗f =f ∗g 2π −∞
Si l’on calcule la transformée de Fourier du produit de En intégrant cette expression par parties (par rapport à
convolution f ∗ g, on obtient : x), on a :
Z ∞ Z ∞Z ∞
′ ′ h i∞ Z ∞
[f ∗ g](x′ ) eiux dx′ = f (x)g(x′ − x) eiux dxdx′ 1 x2 x2
−∞ −∞ −∞ ϕ′ (u) = √ e− 2 sin ux −u e− 2 cos ux dx
Z ∞Z ∞ 2π −∞ −∞
= f (x)g(X) eiu(X+x) dxdX
−∞ −∞ soit :
Z ∞ Z ∞
ϕ′ (u) = −uϕ(u)
= f (x) eiux dx g(X) eiuX dX
−∞ −∞ une équation différentielle qui donne :
soit le produit des transformées de Fourier. C’est un
u2
théorème important : ϕ(u) = K e− 2
où K est une constante d’intégration qui, via l’expression

de la transformée inverse, vaut 1. Donc :
ondes de choc
Z ∞
1 x2 u2
√ e− 2 eiux dx = e− 2 (4.27)
2π −∞
v 0000000000000000
1111111111111111
0000000000000000
1111111111111111
Le résultat final est que la transformée de Fourier d’une 0000000000000000
1111111111111111
1111111111111111
0000000000000000
0000000000000000
1111111111111111
0000000000000000
1111111111111111
gaussienne est une gaussienne.
En posant u = 0 dans l’équation (4.27), on obtient :
Z ∞ √
x2 L
e− 2 dx = 2π
−∞ l
x
l’intégrale de Gauss.
Des changements de variables ad hoc permettent de
généraliser l’équation (4.27) en une relation utile pour bien t
t1 t2
des calculs :
Z ∞ r
π β2 Fig. 4.33 – Modélisation des ondes de chocs produites
−αx2 −βx
e dx = e 4α (4.28) par un objet qui se déplace à vitesse supersonique. L’axe
−∞ α
horizontal supérieur donne une allure de la pression en
où α et β peuvent être complexes à condition que ℜe (α) > fonction de la position et l’axe inférieur en fonction du
0 : ces relations expliquent que de nombreux modèles temps pour un auditeur immobile au sol.
théoriques partent de distributions gaussiennes alors qu’il
n’y a pas forcément toujours d’hypothèse physique très
Ainsi, un objet qui se déplace dans l’air avec une vitesse
convaincante pour le justifier41 . . .
supersonique (un avion, par exemple) produit le fameux
-L’oscillateur harmonique amorti. Le mouvement
double « bang » : il s’agit de la succession de deux ondes
d’un oscillateur harmonique amorti peut s’écrire :
de choc que l’on peut être tenté de modéliser de façon

z(t) = z0 e−iω0 t−αt si t > 0 simple. Il suffit de se rappeler les vagues d’étrave d’un ba-
z(t) = z0 si t ≤ 0 teau (qui lui aussi se déplace plus vite que les ondes -les
vagues- qu’il produit : les bateaux sont pratiquement tou-
où ω0 et α sont réels. La transformée de Fourier de ceci jours supersoniques !) pour considérer que l’objet traı̂nera
donne : avec lui une onde de surpression initiée à l’avant et une
Z 0 Z ∞ onde de dépression initiée à l’arrière (figure 4.33). L’audi-
z0
z0 eiωt dt + z0 ei(ω−ω0 )t−αt dt = z0 δ(ω) + teur, immobile au sol, percevra la première à l’instant t1
−∞ 0 α − i(ω − ω0 )
et la seconde à l’instant t2 avec
Si l’on en prend le module au carré, c’est-à-dire la densité L
spectrale, on obtient : ∆t = t2 − t1 =
v
!
2α 1/α2 où L est la longueur de l’avion et v sa vitesse.
I(ω) = z02 δ 2 (ω) + δ(ω) 2 2 + 2 La durée de chacune de ces impulsions peut s’évaluer
α + ω0 1+ ω−ω 0
α approximativement comme :
soit une lorentzienne centrée en ω0 , la fréquence de l’os- ℓ
cillateur, et de demi-largeur à mi-hauteur α, le coeffi- δt =
v
cient d’amortissement (à condition d’ignorer les Dirac sans
grand intérêt et dues à la partie t < 0 lorsque l’oscillateur où ℓ est une dimension caractéristique des extrémités de
ne bouge pas). Comme l’oscillateur amorti est un objet as- l’objet (rayon de courbure de la pointe avant par exemple).
sez répandu dans le monde des physiciens, cela montre que Pour simplifier, on considérera l’objet comme symétrique
la lorentzienne est un objet mathématique d’usage plutôt et chaque onde de choc comme gaussienne : c’est un
courant : c’est bien souvent le premier candidat plausible modèle, il est fort probable que le profil des variations de
comme modèle à ajuster à quelque expérience. . . pression ne soit pas gaussien ; toutefois on peut espérer
que quelques propriétés physiques importantes puissent
4.10.1.3 Un exemple : le bang supersonique. être mises en évidence malgré cette simplification. La sur-
pression ressentie au sol et due aux ondes de choc s’écrit
L’intérêt des transformées de Fourier par rapport aux alors :
(t−t1 )2 (t−t2 )2
séries du même nom est de pouvoir traiter des fonctions
p(t) = p0 e− 2δt2 − e− 2δt2
qui ne sont pas périodiques. Bien sûr, tout ce qui est
détonation, percussion, etc., entre dans ce cas. Il s’agit de calculer maintenant la dépendance en fréquence
41 Un peu loin de la physique, les calculs boursiers se basent en car l’oreille humaine perçoit la hauteur des sons, autre-
général sur des distributions « normales » ou gaussiennes des fluc- ment dit leur fréquence : il s’agit donc de faire une trans-
tuations des cours, tout simplement parce que là s’appliquent des formée de Fourier en utilisant les relations ci-dessus.
théories d’intégration bien établies. . . alors qu’on sait très bien que
dans bien des cas les cours de la bourse ne suivent pas des distri- L’équation (4.28) permet d’écrire de façon générale,
butions de fluctuations gaussiennes : c’est un peu l’histoire du type Z ∞ Z ∞ r
qui cherche ses clefs sous le réverbère parce qu’au moins là, il voit t−t 2
−( τ 0 ) iωt iωt0
2
−( τt ) iωt iωt0 π − ω2 τ 2
quelque chose !
e e dt = e e e dt = e 2
e 4
−∞ −∞ τ
et, donc, la transformée de Fourier de p(t) s’écrit facile- Si l’on s’intéresse maintenant à une hélice superso-
ment42 : nique45 pour laquelle L = 0, 2m et ℓ = 1mm, on obtient
Z ∞ ∆ν ∼ 35 000Hz et ν0 ∼ 850Hz.
(t−t )2 (t−t )2
p̃(ω) = p0 e − 2δt1
−e − 2δt2 iωt
e dt Les choses deviennent alors qualitativement assez
−∞ différentes : l’enveloppe du spectre s’étend largement au-
r r delà de la limite perceptible, mais la fréquence fonda-
π ω2 2δt2 π ω2 2δt2 mentale (850Hz) est parfaitement audible puisqu’elle est
= p0 eiωt1 e− 4 − eiωt2 e− 4
2δt 2 2δt 2 proche du La situé une octave au-dessus du diapason
r (880Hz). Ainsi, on percevra un son dont la fréquence est
π iωt1 − ω2 δt2 relativement bien définie et toutes ses harmoniques. On
= p0 e e 2 1 − e−iω∆t
δt 2 peut évidemment ajouter à cela le fait qu’une hélice tourne
et donc ce signal est répété à chaque passage d’une pale
La densité spectrale correspondante s’écrit : et le son sera donc perçu comme continu (la fréquence de
π 2 2 passage des pales est de l’ordre de 100Hz).
I(ω) = p̃(ω)p̃∗ (ω) = p20 2 e−ω δt (1 − cos ω∆t) (4.29) Ce modèle est bien sûr simpliste et les valeurs
δt
numériques sont à prendre comme des ordres grandeur,
tout au plus, mais il montre assez bien la puissance d’une
2
analyse en transformée de Fourier d’un phénomène somme
ν 0 toute assez compliqué.
1.5
enveloppe gaussienne
4.10.1.4 Un deuxième exemple : résolution de
l’équation de Poisson.
1 ∆ν
Il peut arriver que l’on ait intérêt à résoudre un
problème en passant par les transformées de Fourier plutôt
0.5
que directement.
Ainsi, l’équation de Poisson de l’électrostatique s’écrit :
0
0 5 10 15 20 25 ∂2V ∂2V ∂2V ρ(x, y, z)
freq ∇2 V = + + =−
∂x2 ∂y 2 ∂z 2 ε0
Fig. 4.34 – Densité spectrale du double bang, eq.(4.29). En où ρ est une distribution de charges et V (x, y, z) le poten-
noir, l’enveloppe gaussienne, en bleu la courbe complète. tiel électrostatique associé. En général, on est confronté
Les unités sont arbitraires. au problème qui consiste à calculer V connaissant ρ. On
peut utiliser des méthodes similaires à celle décrite au pa-
La figure 4.34 montre l’allure de cette courbe. L’enve- ragraphe 4.5.1, mais celles-ci ont souvent l’inconvénient
1
loppe gaussienne a une largeur en fréquence ∆ω = √ , d’être assez consommatrices de ressources de calcul, au-
2δt delà parfois de celles dont on dispose. On peut également
1
soit en fréquence ∆ν = √ . La pulsation ω0 qui tenter l’intégration directe :
2π 2δt
correspond au premier maximum de la partie périodique 1
π V (x, y, z) = ×
(cos ω∆t = −1 ⇒ ω∆t = π) est donnée par ω0 = ou 4πε0
∆t Z ∞Z ∞Z ∞
1 ρ(x′ , y ′ , z ′ )
la fréquence correspondante ν0 = . p dx′ dy ′ dz ′
2∆t ′ )2 + (y − y ′ )2 + (z − z ′ )2
Que signifient ces résultats ? Admettons qu’il s’agisse −∞ −∞ −∞ (x − x
d’un avion assez gros (Concorde peut-être) avec L = 100m Si, toutefois, on discrétise l’espace par n points dans
et ℓ = 0, 1m qui se déplace à peu près à la vitesse du son, chaque direction, V (x, y, z) sera représenté par n3 valeurs
soit v = 300m/s (ce sont des ordres de grandeurs, sans qu’il faudra calculer en sommant sur n3 valeurs de ρ, soit
plus). Cela donne ∆t = 0, 3s, ν0 ∼ 1, 7Hz et ∆ν ∼ 380Hz. n6 termes. . . le processus risque de se révéler laborieux si
La gamme de fréquences auxquelles l’oreille humaine43 est n est grand !
sensible s’étend de 20Hz à 20 000Hz, le La du diapason se Une autre façon de procédre consiste à utiliser une triple
situant à 440Hz. transformée de Fourier, ainsi, V (x, y, z) est la transformée
L’intervalle de temps ∆t est assez long pour que les de Fourier inverse de Ṽ (kx , ky , kz ) :
deux chocs soient perçus séparément. La largeur totale du
1
spectre présentant une intensité audible s’étend en gros V (x, y, z) = ×
(2π) 3
jusque vers 500Hz et l’écart entre les harmoniques est
très faible (1,7Hz) : on percevra donc deux détonations Z ∞ Z ∞ Z ∞
séparées assez graves dont le spectre est essentiellement un Ṽ (kx , ky , kz ) e−i(kx x+ky y+kz z) dkx dky dkz
44 −∞ −∞ −∞
continuum qui va du seuil inférieur de 20Hz à quelques
45 pendant la deuxième guerre mondiale, alors que les moteurs à
centaines de Hertz.
réaction offraient des performances très médiocres au prix d’une
42 C’est le gros avantage des gaussiennes ! consommation de carburant gargantuesque et d’une fiabilité catas-
43 jeune et en bonne santé. . . trophique, l’option de fabriquer des hélices supersoniques pour ga-
44 les fréquences plus basses que 20Hz sont également perçues par gner en vitesse ne paraissait pas absurde. Les ingénieurs s’aperçurent
le corps humain, mais par l’intermédiaire de la cage thoracique et toutefois assez rapidement qu’ils avaient fabriqué là un dispositif très
non les oreilles. efficace pour, disaient-ils, « transformer de l’énergie en bruit » !
Comme Ṽ ne dépend pas de x, y et z et en supposant 4.10.2 La transformée de Fourier discrète.

que l’on puisse dériver sous le signe somme, une dérivée
Il existe des méthodes numériques très efficaces pour
partielle s’écrit :
calculer des transformées de Fourier ; elle reposent toutes
∂2V 1 cependant sur une même approximation :
= ×
∂x2 (2π)3
Z ∞ n−1
X
ZZZ f (x) eiux dx ∼ f (xℓ ) eiuxℓ δx
2 −i(kx x+ky y+kz z)
Ṽ (kx , ky , kz ) × −kx e dkx dky dkz −∞ ℓ=0
avec :
avec évidemment des expressions similaires pour y et z. xℓ = xmin + ℓ δx
On définit ρ̃ de la même façon :
et
xmax − xmin
ρ(x, y, z) = δx =
n
ZZZ ainsi, x0 = xmin et xn−1 = xmax − δx , on est dans la
1 même situation que celle de l’intégration par la méthode
ρ̃(kx , ky , kz ) e−i(kx x+ky y+kz z) dkx dky dkz
(2π)3 des rectangles.
On remplace donc l’intégrale de −∞ à ∞ par une série
En appliquant l’équation de Poisson, on obtient alors :
discrète sur un échantillonnage de points pris sur un in-
ZZZ tervalle borné.
Ṽ (kx , ky , kz ) k 2 e−i(kx x+ky y+kz z) dkx dky dkz = En fait pour des raisons de généralité des programmes,
on se borne à calculer la série :
ZZZ n−1
1 X
ρ̃(kx , ky , kz ) e−i(kx x+ky y+kz z) dkx dky dkz Fk = fℓ e
2πikℓ
n (4.30)
ε0
ℓ=0
où k 2 = kx2 + ky2 + kz2 . Si on choisit Ṽ tel que :
où fℓ = f (xℓ ) et Fk = ϕ(uk ). À l’utilisateur de faire les
adaptations nécessaires !
ρ̃(kx , ky , kz )
Ṽ (kx , ky , kz ) = L’expression (4.30) est celle de la transformée de Fou-
ε0 k 2 rier discrète ou Discrete Fourier Transform ou encore
DFT. La transformée de Fourier discrète inverse s’écrit
alors la relation de Poisson est vérifiée.
évidemment :
Cette méthode est donc de calculer la transformée de n−1
X 2πikℓ
Fourier de ρ(x, y, z) puis la transformée de Fourier in- fℓ = Fk e− n
ρ̃(kx , ky , kz ) k=0
verse de pour obtenir V (x, y, z). Le calcul du
k2
~
champ E(x, y, z) est aisé, car on obtient facilement que : 4.10.2.1 Conséquences.
~ V
~ = −grad L’approximation ci-dessus n’est pas anodine : il faut
E
donc faire un peu attention lorsqu’on utilise ces outils,
pourtant extrêmement courants et indéniablement très
donne en transformée de Fourier :
utiles.
Ẽx (kx , ky , kz ) = ikx Ṽ (kx , ky , kz )
4.10.2.1.1 Périodicité. La première remarque que
Ẽy (kx , ky , kz ) = iky Ṽ (kx , ky , kz ) l’on puisse faire est que l’on remplace en fait une trans-
Ẽz (kx , ky , kz ) = ikz Ṽ (kx , ky , kz ) formée de Fourier par une série de Fourier : autrement
dit, on postule que la fonction considérée est périodique.
ce qui est évidemment très aisé à calculer.
1
On risque bien sûr de rencontrer quelques difficultés
0.9
quand k = 0, mais il suffit de noter que :
0.8
ZZZ
0.7
Ṽ (k = 0) = V (x, y, z) dx dy dz
0.6
0.5
pour voir que le choix de la valeur de Ṽ (k = 0) n’est qu’un 0.4
choix de la constante arbitraire du potentiel : Ṽ (k = 0) = 0.3
0 peut être une bonne option.
0.2
La méthode peut paraı̂tre assez lourde, mais en fait, la
grande rapidité des transformées de Fourier numériques 0.1
permet de résoudre ainsi bien des problèmes qui n’au- 0
0 1 2 3 4 5 6 7 8 9
raient pas de solution sinon. Il faut cependant maintenant
se préoccuper de ce que font réellement les transformées Fig. 4.35 – Une gaussienne « périodique » et mal coupée !
de Fourier numériques proposées dans les bibliothèques de
calcul car il s’agit bien sûr d’approximations et cela peut En principe, ce n’est pas bien grave parce qu’on peut
avoir des conséquences, parfois imprévues. choisir une très grande période, « infinie » en pratique par
rapport aux dimensions ce que l’on veut étudier : c’est Ainsi, la longueur de l’intervalle dans l’espace de la
d’ailleurs généralement ce que l’on fait. Toutefois, il y a transformée de Fourier est l’inverse du pas dans l’espace
parfois des choix maladroits : par exemple, si l’on veut cal- direct.
culer la transformée de Fourier d’une gaussienne centrée Ces deux théorèmes qui ont l’air, il est vrai, tri-
en zéro, on sait que la partie imaginaire doit être nulle viaux, sont très importants car c’est ainsi que l’on choi-
puisque la gaussienne est paire ; or, si par malheur, on a sit l’intervalle d’intégration en fonction, par exemple, de
choisit pour faire le calcul, l’intervalle [0, X], X > 0 et la résolution fréquentielle voulue ou de l’intervalle de
grand par rapport à la variance, on est en train de cou- fréquences désiré. Ainsi, si l’on s’intéresse à un système
per en deux la gaussienne à son maximum en x = 0 et à d’oscillateurs pour lesquels les phénomènes intéressants se
l’autre extrémité de l’intervalle, la valeur de la gaussienne
produisent aux environs de 10Hz, on peut vouloir un in-
sera presque nulle (figure 4.35). Mais, en x = X, subite- tervalle de fréquences qui va de 0 à 20Hz : cela signifie que
ment à cause de la périodicité, la fonction retrouvera une le pas de temps doit être obligatoirement de l’ordre de
valeur non négligeable : une variation rapide qui donnera 1/20=0,05s (ici, l’on raisonne en temps-fréquence, donc
des contributions de haute fréquence. De plus, notre fonc- le facteur 2π disparaı̂t). De plus, si l’on veut pouvoir
tion n’est plus paire : la partie imaginaire n’a plus de raison
distinguer des phénomènes dont les fréquences diffèrent
d’être nulle ! Un intervalle [−X, X] serait plus judicieux. . .
de 0,1Hz, cela entraı̂ne que la longueur de l’intervalle de
temps est au minimum de 1/0,1=10s. Donc, n, le nombre
On peut certes tenter d’être habile, mais alors, il faut être
sûr de soi : on peut garder l’intervalle [0, X] (et donc di- de pas est égal, au minimum à 10s/0,05s = 200. Quitte à
viser par deux le nombre de points nécessaires), et forcer se répéter, ces relations très simples entre pas de temps
la partie imaginaire à zéro. On perdra alors toutefois une et fréquence sont fondamentales dès que l’on faire un
possibilité de détecter des erreurs ! usage pratique de cet outil, en particulier, quand (comme
expérimentateur, par exemple) on a affaire au monde réel
4.10.2.1.2 Pas de calcul. La discrétisation de qui a pour défaut principal que l’on ne peut pas considérer
l’équation (4.30) a aussi des conséquences. Pour faire la toutes les constantes comme valant 1 (m = e = c = h̄ =
correspondance entre l’intégrale et la somme discrète, on kB = 1) !
doit faire l’égalité :
4.10.2.1.3 Une « fausse » symétrie. Calculons le
2πikℓ
eiuk xℓ = e n terme Fn−k de la DFT, c’est-à-dire le symétrique de Fk
par rapport au milieu de l’intervalle :
sachant que :
n−1
X n−1
X
xℓ = xmin + ℓ δx 2πiℓ(n−k) 2πiℓk
Fn−k = fℓ e n = fℓ e2πiℓ e− n
et en posant : ℓ=0 ℓ=0
uk = umin + k δu
or e2πiℓ = 1, et donc :
soit :
n−1
X
2πikℓ 2πiℓk
ei(umin +k δu )(xmin +ℓδx ) = e n Fn−k = fℓ e− n = F−k
2πikℓ
ei(umin xmin +umin ℓδx +xmin k δu ) eikℓδx δu = e n ℓ=0
ce qui est cohérent avec la périodicité mais si la suite fℓ

Une chose au moins paraı̂t claire : ça ne marche pas ! On est réelle, ce qui arrive très souvent, on obtient :
doit donc supprimer xmin et umin .
Ainsi, la DFT postule que l’intervalle commence en zéro. Fn−k = Fk∗
Il faut donc utiliser la propriété que la transformée de
Fourier de f (x − x0 ) est ϕ(u) eiux0 : si l’on ne s’intéresse et pour le spectre,
pas à la phase, c’est sans importance, mais dans le cas
∗
contraire, il faut y penser. In−k = Fn−k Fn−k = Ik
La correspondance entre intégrale et somme discrète se
ramène donc maintenant à : seule la première moitié des points est utile : c’est à ne
pas oublier lorsque l’on voudra déterminer l’intervalle de
2πikℓ
e ikℓδx δu
=e n définition de f . . .
soit : 4.10.2.2 Fast fourier Transform = FFT.

2π
δu = Quand on veut calculer une transformée de Fourier
n δx
numérique, il y a une chose à ne pas faire : c’est program-
or n δx est la longueur de l’intervalle choisi.
mer directement l’équation (4.30) ! Cela revient à calculer
Ainsi, la résolution, c’est-à-dire l’intervalle de fréquence
un grand nombre d’exponentielles complexes inutilement.
le plus petit que l’on puisse atteindre, de la transformée de
Certes, quand le nombre de points dans l’échantillonnage
Fourier est (à 2π près) l’inverse de la longueur de l’inter-
est réduit, il peut parfois être plus rapide de programmer
valle.
rapidement une telle « Slow Fourier Transform » que de
Inversement n δu est la longueur de l’intervalle dans l’es-
passer du temps à essayer de comprendre les documenta-
pace de la tranformée de Fourier et l’on obtient :
tions des bibliothèques de programmes, hélas, pas toujours
2π limpides. Cependant, la transformée de Fourier est d’un
n δu = usage tellement courant en physique que, généralement,
δx
1
on a déjà utilisé une FFT de bibliothèque et que l’on a
déjà déchiffré la documentation correspondante, et donc 0.9
il devient aussi aisé de l’utiliser que de reprogrammer soi- 0.8

même quelque chose, si simple cela soit-il ! 0.7
Toutefois, l’argument massif est que l’algorithme FFT 0.6
est très efficace dès que le nombre de points considéré 0.5
devient important, et l’on a vu que des questions 0.4
d’échantillonnage de fréquences pouvaient imposer de tra-
0.3
vailler avec beaucoup de points.
0.2
Une première remarque est que l’équation (4.30) peut
se reécrire : 0.1
0
n−1 0 2 4 6 8 10
X 2πi
Fk = fℓ wnkℓ , si : wn = e n
ℓ=0 Fig. 4.36 – La fonction 12 (1 − tanh ν−ν

γ ) avec ν0 = 5 et
0
γ = 1 que l’on peut utiliser pour faire un filtre passe-bas.

Découpons la somme ci-dessus en deux moitiés, l’une com-
prenant les termes pairs et l’autre les termes impairs :
La méthode, si elle est souvent employée avec succés,
(n−1)/2 (n−1)/2
X X peut être considérée comme un peu brutale. Une autre
Fk = f2ℓ wn2kℓ + f2ℓ+1 wnk(2ℓ+1) possibilité est alors de multiplier la transformée de Fourier
ℓ=0 ℓ=1 par un fonction qui vaille 1 à basse fréquence et zéro à
(n−1)/2 (n−1)/2 haute. Le choix est au goût de chacun : un bon candidat
X X
kℓ
= f2ℓ wn/2 + wnk kℓ
f2ℓ+1 wn/2 est cependant 12 (1 − tanh ν−ν γ ) où ν0 est le seuil et γ la
0
ℓ=0 ℓ=1 largeur du domaine où la fonction de filtrage décroı̂t (figure

On peut rediviser l’intervalle en deux et ainsi de suite : à 4.36)46 .
terme, l’on n’aura plus à calculer que des termes du type La remarque faite précédemment (§ 4.8.5) selon la-
w2kp . Reste à faire un tri pour repérer quels termes fℓ inter- quelle il vaut mieux faire l’ajustement d’un modèle sur les
viennent dans quelle somme. . . toujours est-il qu’il s’agit données bruitées puis étudier les écarts qu’essayer « d’em-
d’un processus dont le coût est proportionnel à n ln2 n bellir » les expériences en enlevant le bruit reste per-
opérations au lieu de n2 . La différence peut être énorme : si tinente. Le filtrage proposé ici est toutefois sans doute
par exemple n = 210 = 1024, ce qui n’a rien d’exeptionnel, meilleur que la méthode proposée précédemment car on
alors n2 = 1 048 576 mais, n ln2 n = 1024 × 10 = 10240 : peut contrôler précisément ce que l’on supprime, bien
un gain d’un facteur 100 ! mieux qu’avant en tous cas. Il faut reconnaı̂tre qu’il est
Certes, il y a la restriction que n doit être une puissance parfois utile, lors de phases intermédiaires, lors du réglage
de deux, et un bon nombre de sous-programmes courants d’une expérience, ou bien avant que l’on sache réellement
l’exige, mais, 1o il est bien rare que l’on ne puisse pas en où l’on en est au point de vue modèle, de nettoyer ainsi
tenir compte a priori dans la préparation des données ini- les données expérimentales afin de déterminer « s’il y a
tiales et 2o on peut toujours compléter si nécessaire l’in- quelque chose à voir ». . . La règle générale est toutefois
tervalle avec des zéros ! Il existe des programmes qui, au que ces méthodes restent en principe à éviter quand on en
lieu de découper l’intervalle en moitiés, commencent par arrive à l’étape ultime de publication : le minimum est de
faire une décomposition de n en produit de nombres pre- le signaler clairement quand on le fait.
miers, puis effectuent les découpages à partir de là : cela
permet d’utiliser autre chose que des puissances de deux,
mais il est clair que si n lui-même est un nombre premier,
4.11 Les méthodes de Monte-
l’efficacité en sera plus que douteuse. . . Carlo.
On regroupe sous le nom de méthodes de « Monte-
4.10.3 Filtrage de données expérimen-
Carlo » (à cause du célèbre casino) les méthodes qui re-
tales. posent sur des tirages au sort : vaste monde dont nous
Dans le paragraphe 4.8.5 décrivant une méthode de lis- n’explorerons ici que quelques régions frontalières.
sage de données expérimentales, la conclusion était que
c’était sans doute une méthode assez peu recommen- 4.11.1 Processus stochastiques et chaı̂nes
dable. Une autre approche est de faire un filtre passe-bas
de Markov.
numérique.
Il s’agit de supprimer ou, du moins, de réduire le bruit On appelle « stochastique » (du grec stokhastês, devin)
considéré comme un signal non-corrélé d’un point à un un processus dont le résultat est soumis au hasard : quand
autre : autrement dit, il s’agit de retirer ou de réduire on lance un dé, on ne peut pas - en principe - prédire le
une contribution de haute fréquence. Ainsi, une première nombre qui en sortira. En revanche, le mouvement d’un
idée est de faire une transformée de Fourier des données satellite autour de la terre n’est pas stochastique, puisque,
expérimentales, puis fixer les termes de haute fréquence à 46 Il est vrai que, parfois, les méthodes numériques font penser à la
zéro, puis faire une transformée de Fourier inverse : on aura
recette de la pâte feuilletée vue par Fernand Raynaud ; en particulier,
donc ainsi purement et simplement supprimé les hautes le choix de γ, ici, paraı̂t être de l’ordre de la fameuse « chaleur
fréquences ! patissière » indispensable à la réussite de ladite recette !
connaissant sa position et sa vitesse à un instant donné, de rayon a2 vaut π4 , on peut lancer des flèches, cailloux ou
on peut prédire sa trajectoire dans le futur. tout autre projectile et compter le nombre de fois où le
Une chaı̂ne de Markov est une séquence d’événements projectile tombe dans le cercle et le diviser par le nombre
soumis au hasard comme ci-dessus, mais sans mémoire : le total de tirs. Cela donne des estimations successives de
π
dé ne se rappelle pas le nombre sorti lors du jet précédent, 4 (figure 4.37). Evidemment, plus les tirs sont nombreux,
ce n’est pas parce que j’ai obtenu un six au coup précédent meilleure est l’estimation.
que je peux dire quoi que ce soit sur le résultat du coup sui- Même si l’on peut imaginer d’autres méthodes plus
vant (si le dé se rappelait le six et interdisait par exemple économiques pour déterminer π, ces remarques montrent
d’obtenir deux fois de suite le même résultat, le processus que l’on peut tenter de résoudre des problèmes qui ne
serait stochastique mais non-Markovien). comportent a priori aucun caractère aléatoire à l’aide
En physique, il y a bien sûr des processus imprévisibles de méthodes probabilistes. On notera que pour que les
(les trajectoires individuelles de chaque atome d’un gaz en théorèmes probabilistes, comme la limite centrale, puissent
thermodynamique statistique, par exemple) mais on peut s’appliquer, il faut un grand nombre de tirages au sort,
aussi avoir intérêt à utiliser des méthodes de tirage au sort comme dans la figure 4.37, et que donc la capacité des or-
pour calculer des grandeurs qui n’ont rien d’aléatoire. dinateurs à répéter de nombreuses fois la même opération
sans se lasser n’est pas à négliger.
4.11.2 Les vicissitudes de π.
Le chapitre « Nombres aléatoires » des Numerical Re- 4.11.3 La production de nombres
cipes (ref. [3]) commence par la remarque (p. 266) : « aléatoires ».
« Il peut paraı̂tre pervers d’utiliser un ordinateur, la
plus précise et la plus déterministe de toutes les ma- Mais comment une machine déterministe comme un or-
chines conçues par l’esprit humain pour produire des dinateur peut-elle produire des nombres aléatoires ?
nombres “aléatoires”. » En effet, mais nous nous gar- En fait, un ordinateur est incapable de produire des
derons d’affirmer que la perversité n’a jamais fait re- nombres aléatoires et donc il n’en produit pas. . .
culer un mathématicien appliqué. . . Toujours est-il que Un ordinateur produit des séquences de nombres arbi-
bien avant l’invention des ordinateurs, au XVIIIe siècle, traires dont on espère qu’ils sont non-corrélés au problème
Georges Louis Leclerc comte de Buffon, un individu par que l’on souhaite résoudre. C’est que l’on appelle sou-
ailleurs honorablement connu, calcula que, si on lance au vent des « nombres pseudo-aléatoires ». Pour illustrer
hasard une aiguille de longueur ℓ sur un réseau de droites ceci, imaginons qu’un touriste un peu obsessionnel décide
parallèles distantes d’une distance a, la probabilité que de visiter les musées parisiens par ordre alphabétique :
l’aiguille rencontre une droite s’écrit : c’est un ordre parfaitement déterminé, et si l’on recom-
mence un peu plus tard, en appliquant la même règle,
2ℓ l’ordre sera strictement le même48 . Cependant, si l’on
p=
aπ s’intéresse aux thématiques de ces musées, on tombera sur
une méthode probabiliste de détermination expérimentale une séquence du type : Musée de l’Arc de Triomphe, Musée
du nombre π. En effet, plusieurs tentatives de ce genre des Armées, Musées des Arts Africains et Océaniens, etc. :
eurent lieu au XIXe siècle malgré le caractère quelque une séquence complètement arbitraire et qui peut être
peu fastidieux de l’opération consistant à lancer un grand considérée pratiquement comme. . . aléatoire car les arts
nombre de fois une aiguille et à compter le nombre de fois africains et océaniens n’ont pas grand-chose à voir avec
qu’elle recontre une droite47 . les armées49. Bien sûr, l’ordre alphabétique introduit des
corrélations parasites : tous les Musées des Arts xxx se
4
suivent ! Ce sont des choses dont il faudra se méfier aussi
3.8 dans l’usage de générateurs de nombres « aléatoires » des
ordinateurs.
3.6
Comment cela fonctionne-t-il ? Un générateur de
3.4 nombres pseudo-aléatoires produit une séquence de
nombres entiers I1 , I2 , I3 ,. . ., compris entre 0 et m − 1 par
3.2 la réccurence :
3
Ij+1 = aIj + b, modulo m
2.8
où m est un nombre entier « grand » et a et b des entiers
2.6
1 10 100 1000 10000 100000 positifs appelés « multiplicateur » et « incrément ».
1e+06
A priori, cette séquence se répète puisqu’il n’y a que m
Fig. 4.37 – Calcul du nombre π par tirage au sort. En abs- valeurs possibles pour les Ij , ainsi, si l’on a plus que m
cisse le nombre de tirages en échelle logarithmique. En or- tirages, on doit retomber sur les mêmes nombres : c’est
donnée, les estimations de π correspondantes. Le résultat un système périodique. On note qu’il faut initialiser la
obtenu pour un million de tirages est 3,1428721 séquence avec une « graine » I0 50 . Finalement, si l’on fait
48 À condition, évidemment, que la liste des musées n’ait pas
Plus simplement encore, on peut remarquer que comme
le rapport des surfaces d’un carré de coté a et d’un cercle changé entre-temps.
49 Sauf, bien sûr, si l’on se rappelle qu’il s’agit de l’ancien Musée
47 Ainsi, l’expérience faite en 1901 par Lazzerini, en jetant une des Colonies, héritage des conquêtes militaires du XIXe siècle.
aiguille 3407 fois, donna : π = 3,1415929 (au lieu de 3,14159265). 50 seed en anglais.
I
le rapport mj on obtiendra une séquence de nombres réels i est un entier permet de le faire : il suffit d’une instruction
dans l’intervalle [0, 1[. call srand(i) avant le premier appel à rand(). Quelle
On a clairement intérêt à choisir m aussi grand que pos- valeur donner à i ? Soit l’on veut en garder la maı̂trise,
sible, soit, compte tenu de la représentation des nombres alors, il faut prévoir de lire au clavier la valeur de i, soit,
entiers sur quatre octets : m = 231 − 1 = 2 147 483 647. on peut choisir la fonction time qui donne l’heure sous
Le choix de a et b (par exemple a = 75 = 16 807 et forme d’un nombre entier : call srand(time()) don-
b = 0) fait l’objet de débats infinis et dépend parfois de nera. . . n’importe quoi, ce qui est ce qu’on voulait !
la machine utilisée. Dans la grande majorité des cas, on a
intérêt à se servir du générateur fourni avec l’ordinateur
que l’on utilise plutôt que de tenter d’écrire quelque chose ?
soi-même : il se trouve que le langage fortran fourni une
fonction intrinsèque rand()51 qui en général donne satis-
faction. Si la variable x est déclarée en real, l’instruction x
= rand() donnera un nombre pseudo-aléatoire. Si l’on fait
plusieurs tirages, on obtiendra une séquence de nombres
compris entre 0 et 1 avec une distribution uniforme (figure
4.38). Il existe aussi le sous-programme random number :
call random number(x) remplira le tableau x de nombres
pseudo-aléatoires. 60
seed=1
seed=2
50 seed=3
1
0.9 40
0.8 30
0.7 20
0.6 10
0.5 0
0.4 −10
0.3 −20
0.2 −30
0 500 1000 1500 2000 2500 3000 3500 4000 4500 5000
0.1
0 Fig. 4.39 – Marche au hasard ou drunkard’s walk (marche
0 10 20 30 40 50 60 70 80 90 100
1.03 de l’ivrogne) avec trois graines différentes.
1.02 La figure 4.39 montre une marche au hasard : un ivrogne

a une probabilité égale de faire un pas à gauche ou à
1.01
droite de longueur quelconque, en-dessous d’une certaine
valeur (liée à la longueur des jambes dudit ivrogne). Ainsi,
1
à chaque pas, on doit ajouter à la position actuelle un
nombre (pseudo)aléatoire compris entre −0, 5 et 0, 5 (c’est-
0.99
à-dire x = x + rand()-0.5). Trois graines différentes
0.98
donnent trois trajectoires différentes. Ce type de simu-
lation peut concerner, outre les errances53 éthyliques, le
0.97 mouvement brownien ou le cours d’une action en bourse !
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Il faut donc retenir de tout ceci que l’ordinateur ne
produit pas de nombres aléatoires et qu’il est bon de
Fig. 4.38 – En haut, une séquence de 100 nombres pseudo-
se méfier un peu : faire le même calcul avec plusieurs
aléatoires et en bas, distribution des valeurs fournies par
graines différentes, essayer plusieurs générateurs différents
la même fonction intrinsèque rand() après 1 000 000 de
si possible, voire utiliser des machines d’architectures
tirages : on obtient une distribution uniforme.
différentes. . . Certains algorithmes sont très sensibles aux
imperfections des séquences de nombres pseudo-aléatoires,
Le problème de la graine est un peu plus délicat : si on d’autres beaucoup moins : cet avertissement ne se veut pas
ne la fixe pas, la séquence de nombre produits par rand() dissuasif, comme les précédents, il vise à rappeler au mi-
sera la même d’un usage à l’autre : si on arrête l’exécution nimum de prudence !
du programme, l’ordinateur « oublie » où il en était et
si l’on relance l’exécution, il repart au premier point et
refait la même séquence. Dans certains cas, cela n’a au- 4.11.4 Obtenir une distribution autre
cune espèce d’importance, mais si, par exemple, on veut qu’uniforme.
comparer des moyennes effectuées sur des échantillonnages
différents, alors évidemment, il vaut mieux pouvoir chan- Dans le paragraphe précédent, il a été montré com-
ger d’échantillonnage. Le sous-programme srand(i)52 où ment obtenir une séquence de nombres pseudo-aléatoires
avec une distribution uniforme entre 0 et un, c’est à dire
51 pour random.
52 le s de srand est pour seed, évidemment. . . 53 sinon les errements. . .
0.45
des nombres qui ont une probabilité p0 (x)dx d’apparaı̂tre Generated distribution
Normal distribution
0.4
entre x et x + dx qui s’écrit :
0.35
dx si 0 ≤ x < 1
p0 (x)dx = 0.3
0 sinon
0.25
p(x)
ce qui respecte la condition de normalisation : 0.2
Z ∞
0.15
p0 (x) dx = 1
−∞ 0.1
Mais si l’on veut autre chose qu’une telle distribution uni- 0.05
forme ? Soit une fonction y(x). On produit des nombres qui 0

−4 −2 0 2 4
ont une probabilité p0 (x)dx de tomber entre x et x + dx. x
Si on leur fait subir la transformation y(x), on obtient une

deuxième séquence de nombres dont la probabilité de tom- Fig. 4.40 – Comparaison d’une distribution obtenue par
ber entre y et y + dy est p(y)dy, mais c’est aussi celle de l’algorithme donné 2dans le texte et d’une distribution
1 x
tomber entre x et x + dx pour la première séquence, soit : gaussienne √ e− 2 . Le calcul a été fait avec 20000 ti-
2π
|p(y)dy| = |p0 (x)dx| rages au sort.
Comme une densité de probabilité est positive, cela donne,

dx 4.11.5 Intégration multidimensionnelle
p(y) = p0 (x)
dy sur des domaines compliqués.
Sachant que p0 (x) vaut un, le problème est donc 4.11.5.1 Principes
connaissant p(y), la distribution voulue, trouver la fonc-
tion y telle que : Au chapitre 4.3.2, on a vu des méthodes d’intégrations
dx à une dimension comme la méthode des trapèzes. Celle-ci
p(y) = se généralise sans difficulté à des intégrales multidimen-
dy
sionnelles du type :
donc, y(x) est la fonction réciproque d’une primitive de
p(y). Z b1 Z b2 Z bn
Par exemple, si l’on voulait p(y) = e−y , alors, y(x) = ... f (x1 , x2 , . . . , xn ) dxn . . . dx2 dx1
− ln x ; ou encore une distribution lorentzienne p(y) = a1 a2 an
1 1
, cela donne y = tan πx (exercice : le vérifier). Ce type d’intégrale correspond en fait à des domaines
π 1 + y2 d’intégration de géométrie simple (rectangle à deux di-
Malheureusement, ce n’est pas toujours aussi simple.
mensions, parallélépipède à trois dimensions, etc.) ; on
Si, par exemple, on veut une distribution gaussienne (ou
peut dans une certaine mesure, par des changements
normale) :
1 y2
de variables appropriés (coordonnées cylindriques ou
p(y) = √ e− 2 sphériques) adapter l’intégration à d’autres géométries. Il
2π
y a toutefois des limites.
le calcul de la fonction réciproque de la primitive n’a rien
d’évident. . . En fait les choses s’arrangent si l’on passe en
coordonnées polaires à deux dimensions en pensant à la
distribution de Maxwell-Boltzman :
v2
P (v) = v e− 2
avec
P (vx , vy ) dvx dvy = P (v) dv dϕ
Donc, si l’on fait deux tirages au sort√ avec ϕ ∈ [0, 2π[
avec une distribution uniforme et v = −2 ln x et x avec
également une distribution uniforme comprise entre 0 et
1, on obtient deux nombres aléatoires (vx = v cos ϕ et
vy = v sin ϕ) avec une distribution gaussienne : la figure
4.40 en est une illustration. Un exemple de subroutine
très simple capable de produire de tels nombres est donné
ci-dessous :
subroutine gauss_d(x1,x2)
implicit none
real :: x1, x2, v, phi, tpi = 6.28318531 Fig. 4.41 – Un domaine d’intégration un peu compliqué. . .
v = sqrt(-2.*log(rand()))
phi = tpi*rand() Imaginons, par exemple, que l’on veuille calculer la fi-
x1 = v*cos(phi) ; x2 = v*sin(phi) gure d’interférences donnée par deux fentes d’Young, mais
end la source lumineuse, au lieu d’être ponctuelle, est un fila-
C’est, certes, de l’ordre de la recette de cuisine et c’est ment d’ampoule électrique épais, torsadé et courbé (figure
bien pour cela qu’il existe des ouvrages spécialisés et des 4.41), ou, pire, une galaxie vue à travers un télescope :
bibliothèques de programmes tous faits ! comme la source est incohérente, il faut donc intégrer les
intensités lumineuses issues de chaque point de la source. 2 1

Le domaine d’intégration est donc la source : il n’y a guère 1.5 0.8
d’habile changement de variable qui saute aux yeux ! 0.6
Il existe une première solution qui consiste à intégrer sur 1 0.4
un volume de géométrie simple qui englobe la source, en
0.2
0.5 0.0
fixant la valeur de l’intensité lumineuse à zéro en dehors
de la source. 0 −0.2
−0.4
−0.5−0.6
−0.8
−1 −1
−1.5
−2
−2 −1.5 −1 −0.5 0 0.5 1 1.5 2
d Fig. 4.43 – Le domaine d’intégration D défini par
l’équation (4.31) est délimité par la courbe continue
rouge. . .
c’est nettement plus compliqué ! Il suffit toutefois de tirer

au sort des nombres x et y dans l’intervalle [−2, 2], et, si
la condition de l’équation (4.31) est vérifiée, additionner
la quantité sin(xy) à toutes celles déjà obtenues. Il faut
alors normaliser le résultat en multipliant cette somme S
d VD
par où VD est le volume (ici, avec deux variables seule-
nc
ment, c’est en fait une surface) de D et nc est le nombre de
Fig. 4.42 – Si l’on veut calculer l’intégrale d’une fonction
« coups au but » c’est-à-dire le nombre de fois où l’on est
dans un espace compliqué, on peut englober cet espace
tombé dans D. Que vaut alors VD ? Il suffit de reprendre
dans un (hyper)cube, ici un carré d × d, tirer au sort des
le raisonnement utilisé pour calculer π par le rapport de la
points dans ce carré, c’est-à-dire, pour chaque point, tirer
surface du cercle à celle du carré : c’est le volume total Vt
deux nombres compris entre 0 et d et n’ajouter la valeur
dans lequel on a fait des tirages multiplié par la proportion
de la fonction en ce point que s’il se trouve dans l’espace
de coups au but :
d’intégration. Sinon, on l’ignore et on fait un nouveau ti-
nc
rage. VD = Vt
nt
L’autre solution consiste à tirer au sort des points dans où nt est le nombre total de tirages. Ainsi, en fin de
ce volume (figure 4.42), d’ignorer les points qui sont en compte,
dehors de la source et de ne compter que ceux qui sont sur Vt
la source. Cette deuxième solution, si elle peut paraı̂tre ID = S
nt
un peu absurde, a au moins deux mérites : 1o elle est
simple à mettre en œuvre, et 2o elle permet de tracer le Le programme qui fait cela est extrêmement simple :
graphe du résultat en fonction du nombre de tirages au
sort, de sorte que lorsque le résultat ne fluctue que d’une program integr
valeur inférieure à un certain seuil, on peut considérer que implicit none
l’intégrale est calculée avec cette précision (c’est un peu real :: x, y, s
comme sur la figure 4.37 où l’on peut considérer que π integer :: i, imax = 100000000, n
est calculé à partir du moment où les fluctuations sont s = 0. ; n = 0
inférieures à la précision souhaitée). open(10,file=’integr_sin.out’)
do i = 1, imax
x = 4*(rand()-0.5) ; y = 4*(rand()-0.5) ! [-2,2]
4.11.5.2 Tentative « naı̈ve ». if ( 4*tanh(x-y)*exp(-(x**2 + y**2)) > 0.4 ) &
s = s + sin(x*y)
Prenons un autre exemple : on veut calculer,
if ( mod(i,5000) == 0 ) write(10,*) i, 4*s/i
Z enddo
ID = sin(xy) dx dy write(*,*) 4*s/imax
D end
où D est le domaine d’intégration. Si
Ça donne -8.9420289E-02 pour 108 tirages et quelques
2 2 secondes de calcul. Le résultat en fonction du nombre de
D = {(x, y), tels que x + y < π}
tirages est representé sur la figure 4.44. Les huit chiffres
c’est facile : ID = 0 ; mais si (figure 4.43) « significatifs » du résultat ci-dessus ne sont évidemment
2 2
pas tous significatifs ! On constate aisément sur la figure
D = {(x, y), tels que 4 tanh(x − y) e−(x +y ) > 0.4} qu’avec tous ces tirages, on en a au plus 3, soit ID ≃
(4.31) −0.0894. . . Peut-on être plus efficace ?
-0.0885 -0.088
-0.08875
-0.0882
-0.089
-0.08925 -0.0884
-0.0895 -0.0886
-0.08975
-0.0888
-0.09
-0.09025 -0.089
-0.0905
-0.0892
-0.09075
-0.091 -0.0894
-0.09125 -0.0896
-0.0915
-0.0898
-0.09175
-0.092 -0.09
100000 1e+06 1e+07 1e+08 1e+07 2e+07 4e+07 8e+07
n_t n
Fig. 4.44 – Valeurs obtenues pour ID avec le domaine Fig. 4.45 – Valeurs obtenues pour ID avec le domaine
(4.31) en fonction du nombre de tirages (l’axe des x a une (4.31) en fonction du nombre de tirages (l’axe des x a une
échelle logarithmique). échelle logarithmique) comme dans la figure 4.44, mais
cette fois-ci par une marche au hasard dans le domaine
d’intégration D.
4.11.5.3 Marche au hasard dans D
4.11.5.4 Échantillonnage par l’importance (im-
portance sampling )
Dans le calcul précédent, on a tiré au sort des nombres
dans un domaine plus grand que le domaine d’intégration Pourrait-on, pour ainsi dire, « guider » le hasard ? Il
D et on a simplement éliminé tous les tirages qui tom- faudrait pouvoir « dire » au hasard quand ça vaut le coup
baient en-dehors de D. On est en droit de se dire que c’est de faire le calcul, car calculer l’intégrale d’une fonction en
inefficace et qu’il vaudrait mieux tenter de ne tirer des sommant au hasard partout, y compris là où elle est nulle
nombres que dans le bon domaine : c’est en toute rigueur ou presque n’a pas grand intérêt. Autrement dit, il serait
impossible, mais, si, partant d’un point choisi dans D (par peut-être habile d’utiliser des tirages au sort, non pas avec
exemple (0.5, −0.5) dans la figure 4.43), au lieu de tirer des distributions uniformes comme jusqu’à présent, mais
d’autres nombres de façon indépendante, on se borne à se avec des distributions qui favorisent les endroits où la fonc-
déplacer au hasard dans le domaine, soit tirer au sort, non tion a des contributions non négligeables. Formellement,
pas un point, mais un petit déplacement (dx, dy), quitte cela donne, avec l’exemple du calcul « naı̈f » ci-dessus (§
à rejetter les déplacements qui font sortir du domaine, on 4.11.5.2) :
devrait passer l’essentiel du temps (ou plutôt des tirages
au sort) dans le bon domaine. Z Z
sin(xy)
ID = sin(xy) dx dy = p(x, y) dx dy
Ainsi, on peut commencer par fixer un point de départ D D p(x, y)
dans D :
x0 = 0.5 ; y0 = -0.5 dans l’exemple ci-dessus, puis où p(x, y) est une densité de probabilité choisie de façon
calculer des déplacements −δx < dx < δx et −δy < dy < à avoir des valeurs plus importantes là où la fonction a
δy : elle-même des valeurs plus importantes.On sommera alors
sin(xy)
dx = 2*delta_x*(rand()-0.5) les valeurs prises par , où maintenant x et y sont
dy = 2*delta_y*(rand()-0.5) p(x, y)
et ajouter cela aux anciennes valeurs de x et y. Si le nou- choisis avec la densité de probabilité p(x, y). On pourrait
veau point obtenu est dans D le déplacement est conservé, évidemment choisir comme distribution la fonction elle-
sinon, il est rejetté (c’est-à-dire que l’on revient à la po- même, toutefois produire des nombres aléatoires avec une
sition précédente). Dans tous les cas (voir une discussion distribution de probabilité sin(xy) comme ici n’est peut-
détaillée de ce point dans la réf. [21]), on ajoute la valeur être pas si facile que cela. Une approximation de la fonc-
de la fonction à la somme que l’on aura déjà initiée. tion peut suffire : ici, il suffit de poser,
En divisant cette somme par le nombre de tirages, on ob- p(x, y) ∝ |xy|

tient la valeur moyenne de la fonction dans le domaine : il
puisqu’une approximation de sin(xy) quand x et y ne sont
« suffit » de multiplier par le volume du domaine VD pour
pas trop grands est xy (on prend la valeur absolue, puis-
obtenir le résultat. Si on connait ce volume, c’est en effet
qu’une densité de probabilité est toujours positive). En
assez facile, sinon, par exemple dans le cas de l’équation
utilisant la méthode du § 4.11.4, supposons que l’on tire
(4.31), il faut le calculer. . . par une méthode Monte-Carlo !
au sort des nombres X et Y avec des distributions uni-
C’est ce qui est fait fig. 4.45 et l’on obtient des résultats
formes, on a alors
assez similaires à ce qu’on avait précédemment.
Qu’a-t-on gagné en faisant tout cela ? Pas grand-chose, p(x, y) dx dy = dX dY
il faut le reconnaı̂tre, en termes de performances de calcul ; soit, en séparant
toutefois, on est rassuré que cela « marche », ce qui sera
précieux quand on n’aura plus le choix. . . x dx = dX et y dy = dY
et √ √ On sait qu’en thermodynamique statistique, pour un

x = 2X y = 2Y système donné, un grand nombre d’états microsco-
où l’on a oublié les problèmes de signe. . . On peut s’ar- piques correspondent à un même état macroscopique :
ranger pour que X et Y soient dans l’intervalle [−1, 1] et par exemple, la connaissance de la pression et de la
remultiplier par le coefficient qui va bien pour que x et température d’un gaz suffisent à définir son état macrosco-
y soient dans l’intervalle [−2, 2] comme auparavent. C’est pique qui correspond à un nombre gigantesque d’états mi-
plus simple que ça en a l’air : crosopiques possibles, définis, eux, par la position et la vi-
program importance tesse de chacun des atomes qui composent le gaz. A priori,
implicit none dans l’ensemble canonique, quand on connait la fonction
double precision :: x, y, xx, yy, s, z de partition du système
integer :: i, imax = 10000000 X − Ei
Z= e kB T
s = 0. ; n = 0 i
open(10,file=’import_sampling.out’)
do i = 1, imax on peut calculer toutes les grandeurs que l’on veut (T étant
xx = 2.*rand()-1. ; yy = 2.*rand()-1. la température du thermostat et kB la constante de Boltz-
x = 2.*sign(sqrt(abs(xx)),xx) mann). Le seul petit détail contrariant dans cette histoire
y = 2.*sign(sqrt(abs(yy)),yy) est que la somme sur i dans l’équation ci-dessus est une
if ( 4*tanh(x-y)*exp(-(x**2+y**2)) > 0.4 ) then somme sur tous les états microscopiques acccessibles au
z = x*y système 54 : autrement dit, sauf dans quelques cas55 , on ne
if ( abs(z) > 1.e-10 ) then ! no zero divide
sait pas calculer la fonction de partition.
s = s + sin(z)/abs(z)
else
Dans la formulation de Gibbs, quand on veut calcu-
s = s + 1. ler une grandeur macroscopique, par exemple l’aimanta-
endif tion d’un système magnétique, on doit prendre un grand
endif nombre de systèmes identiques, placés dans le même
if ( mod(i,10000) == 0 ) write(10,*) i, 4.*s/i état macroscopique, mais dans des états microscopiques
enddo différents. La moyenne thermodynamique d’une grandeur
close(10) (notée hM i pour une aimantation, par exemple) est la
write(*,*) 4.*s/imax moyenne de toutes les valeurs prises par cette gran-
end deur dans tous ces systèmes. C’est donc une très grosse
On obtient la courbe de la figure 4.46. Pour des résultats intégrale très compliquée et le rapport avec les para-
graphes précédents devrait commencer à poindre. . .
-0.085
-0.0855
-0.086
4.11.6.1 Faire de la thermodynamique statistique
-0.0865
avec un ordinateur.
-0.087
Soit donc un système dans l’ensemble canonique (c’est-
-0.0875
-0.088
à-dire en interaction avec un thermostat à température
-0.0885
T ) et une grandeur A dont on veut calculer la valeur
-0.089
moyenne :
-0.0895 Z E(q1 ,q2 ,...,qn )
−
-0.09 A(q1 , q2 , . . . , qn ) e kB T
dq1 dq2 . . . dqn
-0.0905
hAi = Z E(q1 ,q2 ,...,qn )
-0.091 −
e kB T
dq1 dq2 . . . dqn
-0.0915
-0.092
100000 1e+06 1e+07
(4.32)
n Les q1 . . . qn sont les variables microscopiques du système
(typiquement les positions, vitesses, etc., de tous les
Fig. 4.46 – Valeurs obtenues pour ID avec le domaine atomes ; n est, on l’aura compris, très grand et les
(4.31) en fonction du nombre de tirages (l’axe des x a une intégrales très multidimensionnelles) ; E(q1 , q2 , . . . , qn ) est
échelle logarithmique) par une méthode d’échantillonnage l’énergie du système dans l’état microscopique défini par
par l’importance. L’échelle de l’axe des y est la même que les valeurs de ces variables, A(q1 , q2 , . . . , qn ) la valeur de
pour la figure 4.44. la grandeur A dans les mêmes conditions. La probabilité
d’atteindre un état d’énergie E est proportionnelle à l’ex-
très comparables, voire meilleurs que ceux de la figure 4.44, ponentielle (dans une statistique de Maxwell-Boltzmann)
on a fait dix fois moins de tirages au sort (107 au lieu de et le dénominateur de l’expression est la fonction de par-
108 ) : on a gagné un ordre de grandeur en temps de calcul ! tition qui sert ici à la normalisation.
Ça méritait un petit effort. . . Il est bien sûr hors de question de calculer directement
l’expression (4.32), mais nous avons vu qu’il existe des
4.11.6 Simulation de Monte-Carlo- chemins de traverse plus ou moins tortueux pour ce genre
Metropolis. de situations.
54 la somme discrète ci-dessus, peut être remplacée par une
À quoi tous les calculs d’intégrale plus ou moins com- intégrale multiple sur toutes les variables microscopiques du système,
pliqués ci-dessus peuvent-ils bien servir à part meubler la si celles-ci varient continûment.
conversation d’un vieil enseignant ? 55 voir à ce sujet le cours de thermodynamique statistique.
Imaginons de faire une marche au hasard dans l’espace 4.11.6.2 Concrètement.

des états accessibles au système : partons donc d’un état
Admettons, par exemple, que l’on s’intéresse à un
dont on peut calculer l’énergie E1 . La probabilité que cet
ensemble d’atomes susceptibles de constituer un so-
état soit réalisé est :
lide et que l’on puisse calculer l’énergie potentielle du
E
− k 1T système connaissant les positions atomiques : V ({~rℓ }), par
e B
p1 = exemple :
Z
12 6 !
1X σℓm σℓm
En général, on ne peut pas calculer cette probabilité V = εℓm −2
puisque Z est inconnu. Faisons alors un pas au hasard 2 rℓm rℓm
ℓ,m
dans cet espace, on change alors d’état et l’énergie devient
si les interactions interatomiques sont des interactions de
E2 . La probabilité de ce nouvel état est
paire du type Lennard-Jones (figure 4.47), mais il existe
E
− k 2T de nombreuses autres possibilités.
e B
p2 = 2
Z
qui n’est pas plus calculable que p1 , mais Z, qui est une 1.5
intégrale sur tous les états, n’a pas changé.

1
La probabilité π1→2 de transiter de l’état 1 vers l’état 2
est simplement la probabilité p1 d’être dans l’état 1 mul- 0.5
V
tipliée par la probabilité conditionnelle p1→2 de transiter
de l’état 1 vers l’état 2, alors que le système est déjà dans 0
l’état 1 :
−0.5
π1→2 = p1 p1→2
−1
De même, en sens inverse : 1 1.2 1.4 1.6 1.8 2
r
π2→1 = p2 p2→1
Fig. 4.47 – Le potentiel de Lennard-Jones, pour ε = 1
Le principe dit « de la balance détaillée » stipule que et σ = 1. Le potentiel est fortement répulsif pour r < σ
ce qui correspond à la répulsion dite de « cœur dur »,
π1→2 = π2→1 ⇒ p1 p1→2 = p2 p2→1 attractif dans le cas contraire.
Cela signifie que si, par exemple, l’état 1 est très probable Appliquons la méthode ci-dessus : à partir d’une confi-
et l’état 2 très improbable, le système étant déjà dans l’état guration initiale qui est, soit choisie, soit prise au hasard,
2 aura une forte probabilité d’aller dans l’état 1, alors que on tire au sort un déplacement atomique, et l’on calcule
s’il est dans l’état 1, il aura une faible probabilité d’aller la variation d’énergie correspondante ∆V . Si ∆V < 0,
dans l’état 2. En revanche, si l’on regarde le système « de p1→2 = 1, on garde la nouvelle configuration et l’on reo-
loin », d’un point de vue macroscopique, on ne sait pas commence. Si, en revanche ∆V > 0,
dans quel état microscopique il est, et les probabilités de p1→2 = e
− k∆VT
B
transition dans un sens ou dans l’autre sont égales.
On arrive ainsi à la relation suivante : il faut donc garder cette nouvelle configuration avec cette
p2 probabiité.
p1→2 = p2→1 On compare alors un nombre s, tiré au sort dans l’in-
p1
tervalle [0, 1], avec cette probabilité de transition (figure
soit 4.48). La probabilité que p1→2 > s est justement. . . p1→2 !
(E2 −E1 )
−
p1→2 = e kB T
p2→1
s
une expression précieuse en ce sens que la fonction de par-
tition, justement redoutée, en a disparu !
L’algorithme de Monte-Carlo-Metropolis dit ceci : « si
E2 < E1 , le système qui se trouve dans l’état 1 transitera
vers l’état 2 avec une probabilité 1 : p1→2 = 1. Si au 0 1
(E2 −E1 )
− p = exp(dE/kT)
contraire, E2 > E1 , alors, p2→1 = 1 et p1→2 = e kB T
.
Ainsi si l’on choisit :
dE
(E2 −E1 ) Fig. 4.48 – On calcule p = e− kT et on compare avec un
−
p1→2 = min(1, e ) kB T
nombre s tiré au sort dans l’intervalle [0, 1]. Plus p est
grand, plus on a de chances que s < p : donc p est la
la marche au hasard ainsi produite obéira à la statistique probabilité de garder la nouvelle configuration.
de Maxwell-Boltzmann, ce que l’on voulait ».
En effet, nous sommes maintenant en train de faire une Donc, si p1→2 > s, on conserve la nouvelle configuration,
marche au hasard dans le domaine d’intégration avec une sinon on la rejette. Puis on recommence. . . À chaque pas,
probabilité qui est justement celle que l’on attend, on fait on calcule la grandeur dont on veut la valeur moyenne et
donc pour ainsi dire « spontanément » un échantillonnage l’on fait cette moyenne.
selon l’importance. Une écriture possible de cet algorithme serait
−0.4
i = n*rand() + 1 ! tirage au sort d’un atome 5x5
10x10
! i est dans l’intervalle [1,n], or 0 <= rand() < 1 −0.6 20x20
30x30
! −0.8 40x40
50x50
! conserver l’ancienne configuration au cas ou il 70x70
−1
! faudrait rejeter la nouvelle
x_old = x(i) ; e_old = e −1.2
Energie
! −1.4
! deplacer l’atome i
x(i) = x(i) + dx*(rand()-0.5) −1.6
! −1.8
! calcul de la nouvelle energie
−2
e = energie(x,n)
de = e - e_old −2.2
0 1 2 3 4 5
! T
1.1
if ( de > 0 ) then ! si l’energie a augmente 5x5
1 10x10
! plus exp(-de/kt) est grand, plus la condition 20x20
30x30
! ci-dessous est difficile a remplir 0.9
40x40
50x50
if ( rand() > exp(-de/kt) ) then 0.8 70x70
! rejet de la nouvelle configuration 0.7
Aimantation
x(i) = x_old ; e = e_old 0.6
endif ! sinon on garde 0.5
endif
0.4
0.3
C’est un algorithme très simple que l’on peut optimiser de
0.2
multiples façons, en particulier de calculer directement la
0.1
variation d’énergie (la variation ne dépend que de l’atome
0
déplacé et de ceux avec lesquels il est en interaction, alors 0 1 2 3 4 5
que l’énergie concerne tous les atomes) peut représenter T
un gain significatif de temps.

On fait alors de nouveaux tirages au sort. L’énergie Fig. 4.49 – Le résultat d’une simulation Monte-Carlo Me-
du système tend à évoluer (puisque le point de départ tropolis sur un ensemble de spins de tailles variables de
n’est sans doute pas bien choisi car on ne connait pas au 5 × 5 à 70 × 70, placés sur un réseau bidimensionnel
départ quelles sont les « bonnes » configurations) jusqu’à carré, avec des conditions aux limites périodiques et des
ce que l’on aboutisse à une situation où l’ont obtient au fil interactions ferromagnétiques entre premiers voisins du
des tirages autant d’augmentations que de diminutions de type −Si Sj tendant à aligner les spins ; chaque spin peut
l’énergie : le système se met à fluctuer autour d’une même prendre les valeurs +1 ou −1. Pour plusieurs températures
énergie. Si l’on poursuit néanmoins les tirages au sort, on différentes, on a fait quelques centaines de milliers ti-
produit une succession de configurations possédant une rages au sort, et calculé l’énergie moyenne par spin (en
énergie dont les fluctuations sont de l’ordre de kB T . Les haut) et l’aimantation moyenne, également par spin (en
configurations obtenues sont les configurations que par- bas). On constate qu’à basse température, l’aimantation
court le système à cette température : on peut faire des vaut 1 : tous les spins sont orientés dans le même sens
moyennes des grandeurs physiques pertinentes, étudier la ce qui correspond à l’énergie potentielle la plus faible.
structure, etc. Puis l’aimantation diminue brusquement vers T = 2, 5
quand le désordre thermique prend le dessus. Si les courbes
Si l’on change la température, on peut étudier comment
d’énergie se superposent (sauf pour 5 × 5) on observe,
les grandeurs évoluent, en particulier s’intéresser aux chan-
sur les courbes d’aimantation, que la transition est mieux
gements de structure : les transitions de phase. Les simula-
marquée pour le système le plus gros : l’aimantation ne
tions de Monte-Carlo sont l’une des grandes méthodes de
devient véritablement nulle au-dessus de la transition que
simulation en matière condensée et les applications en sont
pour un système infini pour lequel les fluctuations sont
multiples. Elle s’applique, comme on l’a vu, à des systèmes
négligeables.
classiques dont les variables (ici, les positions atomiques)
peuvent varier continûment, mais aussi à des systèmes de
spins dans le cadre du célèbre « modèle d’Ising » (voir la tion, même s’il ne s’agit pas d’une énergie ?
figure 4.49). Les méthodes de recherche de minima de fonctions vues
au chapitre 4.7 ont en effet toutes le défaut de reposer
sur une analyse locale des dérivées de cette fonction, que
4.11.7 Recherche du minimum d’une
ce soit la méthode de la plus grande pente ou celle du
fonction : le recuit simulé. gradient conjugué. Rien ne garantit avec ces méthodes
La méthode de Monte-Carlo-Metropolis, on l’a vu, per- que l’on a atteint le minimum absolu de la fonction :
met de parcourir des états d’un système, même si l’état le minimum trouvé peut n’être qu’un minimum local (fi-
initial que l’on avait choisi était inadapté : le système tend gure 4.50), un autre plus profond se trouvant ailleurs. La
à converger vers des états compatibles avec la température méthode du recuit simulé est une tentative pour s’attaquer
choisie, et l’on imagine volontiers que si l’on fait diminuer à ce problème. Soit, donc, une fonction :
la température jusqu’à la faire tendre vers zéro, l’on tende f (x1 , . . . , xn ) = f (X)
vers le minimum de l’énergie. Peut-on alors généraliser ce
genre de méthodes à la recherche du minimum d’une fonc- où X désigne l’ensemble des {xℓ }, et l’on cherche le mini-
120
100
80
60
40 A
20
−20
−10 −5 0 5 10
Fig. 4.50 – Comment, à partir d’une analyse locale de la

dérivée de cette fonction peut-on être sûr d’aboutir sur
son minimum absolu ?
mum de cette fonction.

On démarre la recherche comme d’habitude par un point Fig. 4.51 – Le problème du voyageur de commerce : quel
[0] [0]
de départ, X [0] = (x1 , . . . , xn ), mais en général, il est tiré est l’itinéraire le plus court qui permette au voyageur de
au sort. Puis on modifie l’un des xℓ aléatoirement ce qui commerce de visister toutes les villes ?
donne X [1] . On fait alors une hypothèse « thermodyna-
mique » que la probabilité de transiter de l’état X [0] à parcourue finale soit la plus courte possible. Le recuit si-
l’état X [1] est : mulé est probablement la meilleure méthode pour trouver
un ordre optimal, sachant que le nombre de choix est vite
p0→1 = e−β0 ∆f , avec ∆f = f (X [1] ) − f (X [0] ) immense ((n − 1)! si la première et dernière ville est fixée),
dès que le nombre de villes commence à croı̂tre un peu :
On est en train d’assimiler la fonction f à une énergie avec
une recherche systématique, seule susceptible de fournir le
β0 = 1/kB T0 , l’inverse d’une température fictive. On tire
minimum absolu, serait trop coûteuse (fig. 4.52). Ce genre
alors au sort un autre nombre s compris entre zéro et un
de méthode est bien adapté à des problèmes comportant
avec une distribution uniforme. Si f a diminué en passant
un grand nombre de variables et converge vers un ensemble
de l’état X [0] à l’état X [1] , alors p0→1 > 1 > s. Si en
de solutions acceptables, à défaut de la meilleure solution ;
revanche, f a augmenté, alors p0→1 < 1 et donc peut être
en revanche il est peu efficace dans le cas où il existe une,
soit supérieur ou inférieur à s ; or, plus f a augmenté, plus
ou un très petit nombre de solutions, bien définies (fig.
p0→1 est petit, et plus sa probabilité d’être plus petit que
4.53).
s est grande.
Une autre application parfois intéressante est ce que l’on
Si on se donne alors la règle : si p0→1 > s, on conserve
appelle le « Monte-Carlo inverse » pour laquelle la fonction
la nouvelle configuration, sinon on la rejette, alors p0→1
dont on cherche le minimum est le χ2 correspondant à
joue bien le rôle d’une probabilité de transition de l’état
une expérience ou un ensemble d’expériences. Pour une
X [0] vers l’état X [1] . Ainsi, de tirage au sort en tirage
expérience de diffraction de rayons X, par exemple, χ2
au sort, on privilégie les cas ou f diminue, mais pas
est une fonction d’un grand nombre de paramètres : les
systématiquement : si β0 est petit un certain nombre de cas
positions atomiques. Un recuit simulé peut être parfois une
où f augmente seront conservés, ce qui permet d’espérer
bonne solution pour en chercher le ( ou les ) minimum.
sortir d’un éventuel minimum secondaire.
On modifie alors un autre xℓ et l’on recommence un
grand nombre de fois jusqu’à ce que les valeurs prises par 4.12 Le tri.
f ne fassent plus que fluctuer autour d’une même valeur.
Puis on diminue la température (en écrivant par exemple On ne dira pas grand-chose ici sur les algorithmes de tri
βn = βn−1 B, B > 1) et l’on recommence et ainsi de suite, à proprement parler, sinon pour une mise en garde, car
jusqu’à ce que les variations de β ne modifient plus les cela sort un peu du domaine de la physique numérique
valeurs prises par f . stricto sensu.
L’appellation « recuit simulé » se justifie donc, puisque Il peut arriver que l’on ait à trier des nombres par va-
l’on a « chauffé » le « système » pour lui permettre leurs croissantes ou décroissantes : par exemple, si l’on
d’explorer un grand nombre de configurations (si la a calculé les positions d’un certain nombre d’atomes et
température est élevée, la probabilité p0→1 est plus fa- si l’on souhaite les représenter sur une figure, il est sou-
cilement proche de un), puis on l’a « refroidi » progressi- haitable de tracer d’abord les atomes les plus éloignés de
vement afin de le laisser chercher la configuration de plus l’observateur (ou les plus au fond de la figure) de telle
bas f . façon que les atomes les plus proches soient tracés ensuite
Une application classique de cette méthode est le et puissent éventuellement les masquer. La méthode que
problème dit « du voyageur de commerce » (figure 4.51) : l’on imaginerait au premier abord consiste à comparer les
un voyageur de commerce doit explorer, pour y faire ses nombres deux à deux et à les permuter si nécessaire : c’est
affaires, un certain nombre de villes, mais pour gagner du très inefficace et extrêmement coûteux en temps machine
temps, il doit les visiter dans un ordre tel que la distance dès que le nombre d’éléments dans le problème dépasse
1 1
Random
0.9
0.8
0.8
0.6
0.7
0.6 0.4
0.5 0.2
0.4
Y 0
0.3
−0.2
0.2
−0.4
START 0.1
0 −0.6
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
1 1
T=1 T=0.5 −0.8
0.9 0.9
0.8 0.8 −1
−1 −0.8 −0.6 −0.4 −0.2 0 0.2 0.4 0.6 0.8 1
0.7 0.7 X
0.6 0.6
0.5 0.5
Fig. 4.53 – Le problème du voyageur de commerce, traité
0.4 0.4
0.3 0.3
par recuit simulé comme dans la figure 4.52, mais dans
0.2 0.2 un cas -des villes réparties sur un cercle- où la meilleure
0.1 0.1 solution est facile à deviner : ici la méthode par recherche
0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 au hasard aboutit à un résultat assez peu convaincant, le
1 1
0.9
T=0.25
0.9
T=0.125 voyageur serait amené à faire plusieurs tours sur le cercle,
0.8 0.8
avec des retours en arrière, alors qu’un seul tour suffirait ;
0.7 0.7 la méthode n’est pas universelle. . .
0.6 0.6
0.5 0.5
0.4 0.4 et de l’utiliser sans plus poser de question : c’est proba-

0.3 0.3
blement la meilleure façon de gagner du temps ! Si un tel
0.2 0.2
programme n’est pas disponible, on peut tenter d’utili-
0.1 0.1
0 0
ser la commande Unix sort sur un fichier, c’est efficace
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
1
T=0.0625
1
T=0.03125
mais pas toujours très souple d’emploi. Sinon, en général,
0.9 0.9 un algorithme du type Quicksort devrait donner satisfac-
0.8 0.8
tion : on partitionne en un endroit donné le tableau que
0.7 0.7
0.6 0.6
l’on veut trier et l’on en permute les éléments de telle
0.5 0.5
façon que tous les éléments précédents la partition soient
0.4 0.4 inférieurs à la valeur de l’élément frontière, et tous les
0.3 0.3 suivants supérieurs. On trie alors chaque sous-tableau en
0.2 0.2
refaisant une autre partition dans chacun d’eux, etc. : c’est
0.1 0.1
une logique qui ressemble un peu à celle des FFT et elle
0 0
1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
en partage l’efficacité. Voir à ce sujet Numerical Recipes
T=0.015625 T=0.0078125
0.9 0.9 ref. [3] dans la bibliographie.
0.8 0.8
0.7 0.7
0.6 0.6
0.5 0.5
0.4 0.4
0.3 0.3
0.2 0.2
0.1 0.1
0 0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Fig. 4.52 – Itinéraires obtenus par recuit simulé pour 100

villes placées au hasard dans un carré de coté 1. En haut,
un itinéraire pris au hasard : la distance que le voyageur
de commerce doit parcourir est de l’ordre de 55. Puis la
« température » fictive est progressivement diminuée tout
en faisant des tirages au sort pour permuter les villes à visi-
ter. La dernière figure propose un itinéraire correspondant
à une distance de 15 : le gain est significatif. Chaque figure
fait suite à plusieurs dizaines de millions de tirages, mais
le temps d’exécution sur un PC standard est de quelques
minutes. . .
une dizaine ! À éviter donc dans la plupart des cas. . .

Le plus simple est évidemment d’aller chercher dans
une bibliothèque de programme une subroutine de tri
Chapitre 5
Introduction à la simulation numérique
5.1 Pourquoi la Simulation numé- 2. La matière comme une collection de particules.

rique ?
Les chapitres précédents montrent comment la plupart 5.2 La matière considérée comme
des problèmes physiques sont susceptibles de donner lieu à un milieu continu.
des calculs sur ordinateur dès que les solutions analytiques
n’en sont pas triviales. Les méthodes de base (résolution de 5.2.1 Quels types de questions se pose-t-
systèmes linéaires, transformées de Fourier rapides, etc.) on ?
qui font partie de la culture générale des physiciens y sont
exposées : ce sont les briques élémentaires que l’on utilise Lorsqu’on s’intéresse à la matière comme un milieu
pour bâtir des édifices plus imposants. continu c’est, en général qu’on se place à une échelle telle
La simulation numérique est en effet simplement un pas que la structure atomique de la matière ne joue pas.
de plus dans cette direction : faute de pouvoir calculer ana- Par exemple, si l’on veut étudier la propagation d’une
lytiquement le comportement d’un système physique, on le onde électromagnétique en optique alors que la longueur
simule sur ordinateur. Il s’agit de résoudre numériquement d’onde de la lumière visible λ ∼ 0, 5µm est beaucoup plus
les équations qui régissent par exemple son évolution tem- grande que les distances inter-atomiques dans un solide
porelle, ou, plus simplement, calculer son état dans telles ou un liquide (∼ 1nm), alors on peut écrire l’équation de
ou telles conditions. propagation (ici, à une dimension) :
En revanche, les problèmes « sérieux », tels qu’on peut
les rencontrer dans un laboratoire de recherches ou dans un ∂2E 1 ∂2E
= 2 (5.1)
environnement de développement industriel, nécessitent ∂x2 vϕ ∂t2
souvent des calculs dont le volume dépasse assez large-
ment les quelques minutes de temps de calcul sur un PC ! où E est le champ électrique et vϕ la vitesse de phase
Là commence ce que l’on peut appeler « le monde du cal- qui peut dépendre de x afin de traiter des systèmes
cul scientifique intensif » : voila certes une définition plutôt comportant plusieurs matériaux d’indices différents ou
qualitative. . . Cependant, il s’agit d’un domaine qui combien des matériaux inhomogènes dont l’indice peut va-
porte ses méthodes spécifiques dont le but est d’obtenir rier continûment. Dans des cas plus compliqués, on pourra
des résultats physiquement significatifs dans des délais rai- plutôt écrire :
sonnables ; l’appréciation de ce qui est « significatif » et 2~
∆E~ = ∂ D
« raisonnable » n’est certes pas universel, certains calculs ∂t2
pouvant prendre plusieurs mois !
avec une relation entre D~ et E~ qui peut ne pas être triviale
Ces méthodes peuvent se regrouper grossièrement en
deux grandes catégories : (anisotrope ou non-linéaire par exemple).
1. Les méthodes de programmation efficaces qui per- Un autre exemple, que l’on a déjà mentionné à pro-
mettent d’utiliser au mieux l’architecture et les capa- pos des sytèmes linéaires (voir le paragraphe 4.5.1) est la
cités de calcul de nos machines : c’est un volet plutôt propagation de la chaleur dans un milieu qui peut être
« informatique ». hétérogène. On peut alors appliquer la loi de Fourier, tou-
jours à condition de se placer dans des conditions où celle-
2. Le volet plus « physique » comporte les questions ci s’applique (temps caractéristiques longs par rapport aux
physiques à proprement parler : le milieu étudié doit- vibrations atomiques, échelles grandes par rapport aux
il être considéré comme continu ou composé d’atomes distances inter-atomiques, . . .) :
et de molécules, quelles sont les approximations que
l’on peut faire, pour quels types de problèmes, quelles ~ r ) = −κ(~r) grad
~ T (~r)
φ(~ (5.2)
informations physiques sur le système étudié peut-on
en attendre, que faire des résultats ? ~ r ) est pro-
qui exprime que le flux de chaleur local φ(~
Le premier volet est abordé dans le chapitre 6. Le présent portionnel au gradient de température local, le coeffi-
chapitre tente d’aborder le deuxième ; il ne prétend bien cient de proportionnalité κ(~r) étant la conductivité ther-
sûr en aucun cas à l’exhaustivité tant le domaine est vaste ! mique : celle-ci, comme le milieu peut être inhomogène,
On parlera donc principalement de : dépend de l’endroit où l’on se trouve. . . Une hypothèse
1. La matière considérée comme un milieu continu. supplémentaire possible est celle du régime permanent : la
97
conservation de la quantité de chaleur (premier principe ainsi, l’indice entier i représente l’espace et l’indice entier
de la thermodynamique en l’absence de travail) donne, j le temps, et :
~ r ) = Q̇(~r)
div φ(~ (5.3) E(x, t) = E(i δx , j δt ) = Ei,j
la divergence du flux est en chaque point la création ou De même la vitesse de phase se réécrit :
l’apport local (venant du monde extérieur) de chaleur.
D’autres exemples pourraient venir de l’hydrodyna- vϕ (i δx ) = vi
mique où l’on applique les équations d’écoulement d’un
L’équation (5.4) des différences finies permet d’écrire :
fluide, en tenant compte ou non de la viscosité, de la
mécanique des milieux continus où l’on déforme un so- ∂E(x, t) Ei+1,j − Ei,j
lide plus ou moins compliqué par des contraintes ( e.g. un ≃ (5.5)
∂x δx
système constitué de deux solides collés avec des coeffi-
cients de dilatation différents soumis à un accroissement ou
∂E(x, t) Ei,j − Ei−1,j
de température. . .), etc. ≃ (5.6)
∂x δx
Tous ces problèmes ont pour ingrédient commun
qu’il s’agit d’équations aux dérivées partielles, c’est-à- ce sont deux approximations possibles, équivalentes mais
dire d’équations différentielles de plusieurs variables qui qui n’ont pas exactement la même valeur. . . en fait, il fau-
contiennent des dérivées partielles comme : drait pouvoir prendre la valeur du champ au demi-pas :
c’est parfois possible, parfois, non. Ce qui a été écrit ici,
∂ ∂ ∂ ∂ c’est plutôt :
, , ,
∂x ∂y ∂z ∂t
δx δx
Les systèmes macroscopiques ne sont pas les seuls suscep- ∂E(x + , t) ∂E(x − , t)
2 et 2
tibles de ce genre de traitement : l’équation de Schrödinger ∂x ∂x
pour une particule dans un potentiel est aussi une équation
c’est-à-dire les dérivées au demi-pas ; or ce sont les
aux dérivées partielles,
dérivées secondes, et non les dérivées premières, qui nous
2 intéressent dans ce problème :
∂ h̄
ih̄ ψ(~r, t) = − ∆ + V (~r) ψ(~r, t)
∂t 2m δx δx
∂E(x + , t) ∂E(x − , t)
ainsi que bien sûr les équations de Maxwell de 2 − 2
∂ 2 E(x, t) ∂x ∂x
l’électromagnétisme. ≃
∂x2 δx
Ces questions ne sont pas forcément faciles à traiter, et,
parfois même dans certaines conditions et pour des rai- et en remplaçant les dérivées premières par les expressions
sons diverses, on ne sait pas les résoudre. Cependant, il (5.5) et (5.6), on obtient aisément l’approximation :
existe deux classes principales de méthodes pour s’y atta-
quer : les méthodes de différences finies et les méthodes ∂ 2 E(x, t) Ei+1,j + Ei−1,j − 2Ei,j
≃
d’éléments finis. L’on mentionnera également les méthodes ∂x2 δx2
dites spectrales.
La même opération peut être effectuée pour la dérivée
temporelle, sauf que c’est maintenant l’indice j qui est
5.2.2 La méthode des différences finies affecté, et en fin de compte, l’équation de propagation (5.1)
Si f est une fonction de plusieurs variables x1 , x2 ,. . ., se réécrit :
xn , on peut approximer la dérivée partielle par rapport à Ei+1,j + Ei−1,j − 2Ei,j 1 Ei,j+1 + Ei,j−1 − 2Ei,j
xi par : = 2
∂f
2
δx vi δt2
≃
∂xi Ce que l’on cherche, c’est le champ E en tous points à
f (x1 , . . . , xi + δxi
, . . . , xn ) − f (x1 , . . . , xi − δxi
, . . . , xn ) l’instant t + δt , le connaissant aux instant t et t − δt , ainsi :
2 2
δxi Ei,j+1 =
(5.4)
c’est la définition de la dérivée partielle, mais on ne passe 2
vi δt
pas à la limite : δxi prend une valeur petite mais finie, (Ei+1,j + Ei−1,j − 2Ei,j ) + Ei,j − Ei,j−1 ∀i
δx
c’est là que réside l’approximation et c’est de là que vient
(5.7)
l’expression différences finies.
ce qui se programme fort aisément en quelques lignes.
Dans les paragraphes qui suivent, différentes variantes
On appelle cela un schéma explicite puisque la solution
de la méthode sont montrées à l’aide d’exemples.
apparaı̂t explicitement : on doit connaı̂tre les conditions
initiales et calculer pas à pas les résultats au cours du
5.2.2.1 Le schéma explicite temps.
Prenons par exemple l’équation de propagation d’une La figure 5.1 montre un exemple simple de propagation
onde électromagnétique dans un milieux unidimensionnel à travers une lame transparente d’un paquet d’ondes gaus-
(eq. (5.1) ) : il faut d’abord discrétiser le temps et l’espace, sien avec les réflexions sur les dioptres. On y voit bien sûr
le ralentissement du paquet dans le diélectrique (la pente
x = i δx t = j δt est plus forte, autrement dit, il faut plus de temps pour
30
2
25 1.5
1
20 0.5
0
−0.5
15 −1
t
−1.5
−2
10
0
0 5 10 15 20
x
Fig. 5.1 – Propagation d’une onde à travers une lame transparente obtenue par l’équation (5.7). En abscisse, la
coordonnée spatiale x, en ordonnée le temps. La condition initiale est donnée par un paquet d’ondes gaussien se
déplaçant dans le sens des x croissants, puisque l’on doit définir les deux premiers pas de temps pour initialiser
l’équation (5.7).
parcourir la même distance) et les interférences entre les et :

ondes incidentes et réfléchies.
On pourrait, par exemple, compliquer le problème en − κi+1 − κi−1 + 4κi Ti+1 +2κi Ti − −κi+1 + κi−1 + 4κi Ti−1
considérant : 4 4

D = ε0 (1 + χ1 )E + χ2 E 2 = −Q̇i δx2
soit une dépendance non-linéaire de D en fonction
Le résultat important ici est que l’on obtient un système
du champ électrique (ici un développement limité au
d’équations linéaires dont les inconnues sont les Ti : la
deuxième ordre, χ1 étant la susceptibilité du premier ordre
température en chaque point, or, le nombre d’équations et
habituelle et χ2 le terme du deuxième ordre), ce qui
d’inconnues est donné par la discrétisation :
permet de sortir du domaine habituel des diélectriques
linéaires.
L
n=
δx
5.2.2.2 Le schéma implicite
Si l’on combine l’équation de Fourier (5.2) et la conser- où L est la longueur de l’échantillon. Autrement dit, le
vation de la chaleur (5.3), on obtient : nombre d’équations peut être énorme et il est donc exclu
de tenter de le résoudre à la main !
~
div κ(~r) gradT (~r) = −Q̇(~r) Il suffit alors de poser :
soit, si l’on se restreint à un problème à une dimension : AT = Q (5.9)

∂κ(x) ∂T (x) ∂ 2 T (x)
+ κ(x) = −Q̇(x) (5.8) avec :
∂x ∂x ∂x2
A=
Comme dans le cas précédent, on peut discrétiser le
 
problème : .. ..
 . . 0 0 0 0 0 
Ti = T (i δx) κi = κ(i δx ) Q̇i = Q̇(i δx )  .. .. 
 0 . . 0 0 0 0 
 
On a de nouveau le problème que l’on ne connaı̂t pas les  . . .. 
 0 0 . . 0 0 0 
valeurs des fonctions au demi-pas pour calculer les dérivées  
 κi+1 − κi−1 + 4κi −κi+1 + κi−1 + 4κi 
premières : on peut s’en sortir néanmoins en considérant  0 0 − 2κi − 0 0 
 4 4 
des intervalles de 2δx , et donc le demi-pas devient main-  .. .. 
 0 0 0 . . 0 0 
tenant δx . . . Cela donne, ainsi :  
 .. .. 
 0 0 0 0 . . 0 
κi+1 − κi−1 Ti+1 − Ti−1 Ti+1 + Ti−1 − 2Ti  
+ κi = −Q̇i .. ..
2δx 2δx δx2 0 0 0 0 0 . .
une très grosse matrice n × n, et deux matrices colonne : renumérotant : m = 3(i − 1) + α où α prend les valeurs 1,
    2, 3. La même opération est évidemment faite pour ℓ.
T1 −Q̇1 δx2 On conçoit aisément que la matrice A peut facilement
 ..   .. 
 .   .  devenir énorme à tel point qu’il faut parfois recourir à des
   

T =  Ti   Q =  −Q̇i δx 
 2 méthodes sophistiquées pour résoudre le système linéaire !

 .   .. 
 ..   . 
5.2.2.3 Contourner le schéma implicite
Tn 2
−Q̇n δx
Une façon d’éviter le schéma implicite pour retrouver un
Il reste à régler la question des conditions aux limites schéma explicite est d’écrire une équation d’évolution tem-
qui, dans ce cas ci, se réduisent à peu de choses, par porelle du système au lieu de tenter de calculer d’emblée
exemple : une situation d’équilibre où tous les points dépendent les
uns des autres. Avec une équation d’évolution, on part
T0 = Ta et Tn+1 = Tb
d’une situation initiale et l’état au pas suivant dépend ex-
on introduit des points qui n’interviennent pas dans le plicitement de l’état initial : le système, si tout se passe
système (5.9), i = 0 et i = n + 1 qui représentent les bien, doit évoluer vers l’équilibre que l’on cherchait. Par
extrémités de l’échantillon et on fixe leurs températures à exemple, l’équation stationnaire (5.3) peut être remplacée
Ta et Tb . Cela oblige à modifier la première et la dernière par une équation hors d’équilibre :
ligne de A et de Q. ∂T (~r)
On peut aussi laisser les conditions aux limites libres, la C = Q̇(~r) − divφ
∂t
seule contrainte étant alors Q̇(x).
c’est-à-dire que la variation temporelle locale de
On fait appel alors à un sous-programme de bi-
température (multipliée par la capacité calorifique C d’une
bliothèque, ou bien pris dans un manuel de « recettes
cellule) est la production locale de chaleur diminuée de la
numériques », capable de résoudre le système (5.9). Si n
est grand, le système est parfois lourd à résoudre, cepen- chaleur qui s’écoule hors de la cellule. En combinant cela
avec la loi de Fourier (5.2), on obtient :
dant, la matrice A comporte principalement des zéros (on
dit qu’elle est creuse), et dans le cas présent elle est tridia- ∂T (~r)
C ~ T (~r)
= Q̇(~r) − div κ(~r) grad
gonale ce qui facilite souvent la résolution numérique du ∂t
système d’équations. On tombe ainsi sur un schéma explicite similaire à celui
Le résultat d’un exemple simple est montré sur la figure de la propagation d’une onde du paragraphe 5.2.2.1. Le
5.2. même problème que pour la figure 5.2 est ainsi traité sur
la figure 5.3.
Fig. 5.2 – Une solution numérique de l’équation (5.9)

en fixant des conditions de température fixes aux deux Fig. 5.3 – Évolution temporelle de la distribution de
extrémités (T (x = 0) = 2 et T (x = 1) = 0) et sans la température dans le cas représenté par la figure 5.2.
production de chaleur. La conductivité κ dépend de x. L’état initial est donné par T = 0 sur tout le barreau
On retrouve le résultat connu que la température varie sauf à la deuxième extrémité où elle vaut 2. Le système
linéairement tant que κ est constant, un changement de évolue spontanément vers la situation d’équilibre trouvée
pente ayant lieu à chaque changement de valeur de la précédemment.
conductivité.
L’avantage d’une telle procédure est d’éviter les risques
Ce schéma est appelé implicite puisqu’on n’ob- d’instabilité numérique liés à la résolution du système
tient pas d’expression du type Ti = . . ., comme d’équations, mais l’inconvénient en est un coût en res-
précédemment, mais un système d’équations qu’il faut sources de calcul qui peut s’avérer prohibitif.
résoudre numériquement.
Si l’on veut résoudre un problème à trois dimensions, la
5.2.2.4 Questions de stabilité
méthode est la même dans le principe, la mise un œuvre
étant un peu plus lourde. Les indices (ℓ, m) de A de- Même les schémas explicites peuvent parfois réserver
viennent composites : m ↔ (i, α) ; α ∈ {x, y, z} et en des surprises. . . Reprenons, par exemple, l’équation de
Schrödinger à une dimension et dépendante du temps On est dans la même situation que pour la méthode de
d’une particule dans un potentiel : Cranck et Nicholson (paragraphe 4.9.5). L’inconnue dans
2
ce problème est ψ ℓ+1 puisqu’on cherche la fonction d’onde
2
∂ψ(x, t) h̄ ∂ ψ(x, t) à l’instant t + δt , la connaissant à l’instant t. Ainsi :
ih̄ =− + V (x)ψ(x, t)
∂t 2m ∂x2
δi δi
Il est coutumier, dans ce genre de problème, de se placer 1 + i HD ψ ℓ+1 = 1 − i HD ψ ℓ (5.11)
h̄ 2 2
dans un système d’unités où h̄ = 1 et = 1. On peut
2m peut se résoudre à partir d’un système linéaire du type :
discrétiser le problème comme précédemment :
ψjℓ = ψ(j δx , ℓ δt ) Vj = V (j δt ) Aψ ℓ+1 = B
où j et ℓ sont des indices entiers, j pour l’espace et ℓ pour où A est une matrice tridiagonale n × n et B un vecteur
le temps. Soit : de n éléments :
∂ 2 ψ(x, t) ℓ
ψj+1 ℓ
+ ψj−1 − 2ψjℓ δi
≃ A = 1 + i HD
∂x2 δx2 2
δi
et : B = 1 − i HD ψ ℓ
2
∂ψ(x, t) ψjℓ+1− ψjℓ
≃
∂t δt Un tel problème -qui suit le schéma implicite- se résout
Cela donne aisément : aisément à l’aide d’un sous-programme de bibliothèque
! adéquat (il s’agit d’une matrice triadiagonale, ce qui sim-
ℓ ℓ
ψj+1 + ψj−1 − 2ψjℓ plifie les choses), en prenant soin toutefois de travailler
ψjℓ+1 = ψjℓ + iδt − Vj ψjℓ
δx2 avec des nombres complexes (figures 5.4, 5.5 et 5.6). Un
des charmes de cette méthode est que la norme de la fonc-
que l’on peut écrire matriciellement : tion d’onde est conservée. . .
ψ ℓ+1 = (1 − iδt HD ) ψ ℓ (5.10) 10

3.16
1
où HD est l’Hamiltonien discrétisé : 1 0.316
0.1
0.9
HD = 0.8
  0.7
.. .. .. 0.6
. . . 0 0 0 0
 1 2 1
 0.5 X
 0 + Vj−1 0 0 0  0.4
 − 2
δx δx2
− 2
δx 
  0.3
 1 2 1 
 0 0 − 2 + Vj − 2 0 0  0.2
 δx δx2 δx 
 1 2 1  0.1
 0 0 0 − 2 + Vj+1 − 2 0  0
 δx δx2 δx 
.. .. .. 0 0.005 0.01 0.015 0.02
0 0 0 0 . . .
time
et :  
..
.  Fig. 5.4 – Solution de l’équation (5.11) dans le cas d’une

 ..  barrière de potentiel qui va de x = 0.5 à x = 0.75. La
 . 
  condition initiale pour la fonction d’onde est un paquet
ψ =
ℓ
 ψjℓ   gaussien centré en x = 0.5. Cette figure montre les pre-
 .. 
 .  miers pas de la simulation : on voit la la densité de probabi-
 
.. lité de présence s’élargir de préférence du côté du puits de
. potentiel, mais une partie continue à passer de l’autre côté.
Tout cela est fort beau. . . mais le défaut d’une telle On voit également les réflexions sur les parois (l’échelle des
méthode est qu’elle est instable ! On peut tenter de la courbes de niveaux est logarithmique).
stabiliser en la symétrisant un peu mieux. En effet, on
a appliqué l’Hamiltonien discrétisé à la fonction d’onde à
l’instant t ; on aurait pu tout aussi bien l’appliquer à la 5.2.2.5 Critères de stabilité
fonction d’onde à l’instant t + δt :
Évidemment, la question est de savoir s’il existe des
ψ ℓ+1 = ψ ℓ − iδt HD ψ ℓ+1 critères permettant de savoir a priori si un algorithme est
stable ou non. Il s’agit malheureusement là d’un très vaste
Il s’agit de la même équation que (5.10), seulement HD
programme ! Les spécialistes de mathématiques appliquées
est appliqué à ψ ℓ+1 et non à ψ ℓ . Ni l’une, ni l’autre de ces
et ceux de mécanique démontrent de nombreux et fort
équations n’est entièrement satisfaisante, alors, on peut
beaux théorèmes de convergence ou de non-convergence :
faire un compromis en faisant une moyenne :
c’est hélas pour un physicien essentiellement préoccupé de
ψ ℓ+1
+ψ ℓ savoir si « ça marche » ou « comment faire pour que ça
ψ ℓ+1 = ψ ℓ − iδt HD marche », un monde quelque peu labyrinthique. . .
2
10 où z(x, t) est le déplacement de la poutre à l’abscisse

3.16
1 x et à l’instant t, ρ sa masse volumique, E le module
1 0.316 d’Young du matériau dont elle est constituée et e(x) son
0.1
0.90.0316
épaisseur qui peut être soit constante soit variable le long
0.8
0.7 de la poutre1 . On peut tenter de résoudre directement
0.6 l’équation ci-dessus à partir de conditions initiales ad hoc
0.5 X en utilisant les méthodes déjà exposées, mais on peut aussi
0.4 ne chercher que les mouvements périodiques en fonction du
0.3 temps. Dans ce cas, on cherche des solutions du type :
0.2
0.1 z(x, t) = u(x) eiωt
0
0 0.005 0.01 0.015 0.02
ce qui donne :
time
∂4u
− c(x)ω 2 u(x) = 0
Fig. 5.5 – Même chose que la figure 5.4, seulement le ∂x4
paquet initial est centré en x = 0.35. On en voit passer avec des notations évidentes.
néanmoins une partie de l’autre côté par effet tunnel. En discrétisant de la façon habituelle, on obtient sans
difficulté, au bout de quelques lignes de calcul :
uℓ+2 − 4uℓ+1 + 6uℓ − 4uℓ−1 + uℓ−2
− δx4 ω 2 uℓ = 0
cℓ
Posons :
 
.. .. .. .. ..
 . . . . . 0 0 0 0 
10  
 0 .. .. .. .. ..
1
 . . . . . 0 0 0 
0.1  
+1 −4 6 −4 +1
0.01 A=
 0 0 0 0 
 cℓ cℓ cℓ cℓ cℓ 
0  .. .. .. .. .. 
0.002  0 0 0 . . . . . 0 
 
0.004 .. .. .. .. ..
0.006 0 0 0 0 . . . . .
1
0.008 0.9
time 0.7
0.8  
0.01
0.5
0.6 u1
0.012 0.4  .. 
0.3
0.014 0.1
0.2 X  . 
 
U= 
 uℓ 
Fig. 5.6 – Même chose que la figure 5.5 en 3-D (l’échelle  . 
 .. 
verticale est logarithmique).
un
Les valeurs propres λp de A donnent :
Il arrive cependant qu’il faille en passer par là, quitte
à solliciter l’aide d’un spécialiste. Cependant, souvent un λp = ωp2 δx4
peu de flair suffit : on a vu avec l’équation de Schrödin-
ger que tenter d’écrire des équations aussi symétriques que soit, au coefficient δx4 près, les carrés des pulsations propres
possible pouvait arranger des choses. Une autre précaution ωp du système harmonique, c’est-à-dire les pulsations aux-
à prendre est d’essayer de faire que l’énorme matrice que quelles le système peut vibrer. Les vecteurs propres Up
l’on cherche à inverser ou diagonaliser soit « aussi diago- donnent les déplacements de la poutre pour chaque « mode
nale que possible » : autrement dit s’efforcer de rendre les propre » de pulsation propre ωp .
termes les plus éloignés de la diagonale aussi faibles que À l’aide d’un programme de bibliothèque approprié, rien
possible par rapport aux termes diagonaux, ou bien trou- de tout cela ne doit poser de gros problème. . . si ce n’est
ver des structures du type « tridiagonale par blocs » que que ce genre de programme « préfère » quand la matrice
certains algorithmes sont capables de traiter efficacement. est symétrique ! Il suffit de poser alors :
ζ(x) iωt
5.2.2.6 Systèmes harmoniques z(x, t) = p e
c(x)
Des systèmes harmoniques en mouvement oscillant ce qui donne :
peuvent obéir à des systèmes similaires. Si l’on étudie, par
exemple, les oscillations harmoniques d’une poutre de sec- ζℓ+2 4ζℓ+1 6ζℓ 4ζℓ−1 ζℓ−2
√ −√ + −√ +√ −δ 4 ω 2 ζℓ = 0
tion variable, on doit résoudre l’équation suivante (ici l’on cℓ+2 cℓ cℓ+1 cℓ cℓ cℓ−1 cℓ cℓ−2 cℓ x
ne tient compte ni du champ de pesanteur, ni d’aucune
autre force extérieure) : Posons comme précédemment :
∂4z ρ ∂2z D=
+ =0 1 Voir par exemple G. Bruhat, Mécanique, Masson (1967) p. 653.
∂x4 Ee2 (x) ∂t2
 
.. .. .. .. et évidemment, les transformées inverses :
. . . . 0 0 0
  Z
 .. .. .. .. 
 0 . . . . 0 0  V (~r) = Ṽ (~q) e−i~q.~r d3 ~q
 +1 6 +1 
 0 −4 −4
0 
 √
cℓ−2 cℓ
√
cℓ−1 cℓ cℓ
√
cℓ+1 cℓ
√
cℓ+2 cℓ  Z
 
 
 0 .. .. .. .. ρ(~r) = ρ̃(~q) e−i~q.~r d3 ~q
 0 . . . . 0 

.. .. .. ..
0 0 0 . . . . En utilisant les transformées inverses, l’équation de Pois-
  son se reécrit :
ζ1 Z Z
 ..  2 q.~
r 3
 .  ∇ Ṽ e −i~
d ~r = − ρ̃ e−i~q.~r d3~r
 
Z=
 ζℓ  
 ..  soit après une dérivation sous l’intégrale :
 .  Z Z
ζn
−|~q|2 Ṽ e−i~q.~r d3~r = − ρ̃ e−i~q.~r d3~r
Il suffit d’écrire explicitement quelques termes pour mon-
trer que D est symétrique. Cela ne change rien pour les et :
valeurs propres, celles de D sont les mêmes que celles de A, ρ̃(~q)
Ṽ (~q) =
seulement les vecteurs propres donnent les déplacements |~q|2
pondérés par c(x) : il suffit d’en tenir compte (voir par extrêmement facile à résoudre. . . La méthode consiste
exemple la figure 5.7). donc à calculer d’abord la transformée de Fourier de ρ(~r),
diviser le résultat par |~q|2 puis retransformer par Fourier
0.1
1 inverse pour obtenir le potentiel V (~r). Tout ceci est très
0.08 2
3
4 efficace et rapide. En ~q = 0, on a :
0.06 5
6 Z
0.04
Ṽ (~q = 0) = V (~r)d3~r
0.02
0
il s’agit simplement de définir la constante arbitraire qui
−0.02
intervient dans le potentiel.
−0.04 Malheureusement, les choses sont parfois un peu re-
−0.06 torses comme on peut le constater sur la figure 5.8 puisque
−0.08 les deux charges placées sur un axe horizontal donnent un
−0.1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
potentiel qui n’a pas la même symétrie, ce qui est fâcheux !
Fig. 5.7 – Les six premiers modes propres de vibration

d’une poutre homogène fixée à une extrémité (à gauche)
et libre à l’autre, calculés avec 500 points de discrétisation.
5.2.3 Les méthodes spectrales

Les méthodes dites « spectrales » visent à profiter de
la remarquable efficacité des transformées de Fourier ra-
pides ou FFT. Elles seront donc utilisées pour des calculs
particulièrement lourds car elles ont aussi des défauts.
5.2.3.1 Un premier exemple simple

Prenons, par exemple, l’équation de Poisson de
l’électrostatique :
∇2 V (~r) = −ρ(~r)
où bien sûr, ρ(~r) est une densité de charges et V (~r) le po-
tentiel électrostatique correspondant. On peut introduire
les transformées de Fourier spatiales de ces quantités : Fig. 5.8 – Calcul par une méthode spectrale à deux dimen-
Z sions du potentiel électostatique produit par deux charges.
i~
q .~
r 3
Ṽ (~
q ) = V (~r) e d ~r
En revanche, le même calcul par différences finies (figure
5.9), bien qu’exigeant sensiblement plus de temps calcul
où le symbole d3~r indique qu’il s’agit d’un intégration sur
(c’est un schéma implicite qui requiert la résolution d’un
les trois coordonnées d’espace. De même :
système linéaire 4096 × 4096, puisque le carré de 64 × 64
Z
donne 642 = 4096 mailles) fournit un résultat bien plus
q ) = ρ(~r) ei~q.~r d3~r
ρ̃(~ satisfaisant.
comme indiqué à la fin du paragraphe 5.2.2.2. Il faut tou-

tefois noter que cela suppose, en pratique, un découpage
de l’espace en petits parallélépipèdes rectangles de cotés
δx , δy , δz . On peut imaginer de réécrire les équations dans
un autre système de coordonnées, mais cela reste relati-
vement limité. Beaucoup de problèmes peuvent être ainsi
résolus, mais quid, par exemple, de l’écoulement de l’air
autour d’une aile d’avion, de la recherche des modes de
vibration d’une carrosserie de voiture ou du refroidisse-
ment d’une bouteille en verre moulée au sortir du moule ?
Les géométries complexes de ces problèmes risquent de mal
s’accomoder du découpage, très rigide, en petits cubes ou
en éléments très simples.
Dans les problèmes de géométrie compliquée, la
méthode des éléments finis est plus adaptée, ce qui en fait
un outil très répandu dans le monde industriel.
Fig. 5.9 – Calcul par une méthode de différences finies du

même potentiel électostatique que dans la figure 5.8.
L’on retiendra de cet exemple que les hypothèses

inhérentes à la tranformée de Fourier discrète (périodicité,
etc.) peuvent jouer des tours comme on le sait. Il reste des
cas pour lesquels, à cause, par exemple, du volume des
calculs mis en œuvre, l’on n’a guère le choix que d’utiliser
la vitesse de la FFT : des précautions s’imposeront alors !
5.2.3.2 L’équation de Schrödinger (encore !)

Celle-ci s’écrit une fois de plus :
∂ψ(~r, t) h̄2 2
ih̄ − ∇ ψ(~r, t) + V (~r)ψ(~r, t)
∂t 2m
Si l’on applique la même méthode que ci-dessus, on ob-
Fig. 5.10 – Un exemple de maillage à deux dimen-
tient après quelques calculs sans difficulté bien qu’un peu
sions pour le calcul des caractéristiques d’une aile d’avion
laborieux (on a trois transformées de Fourier spatiales et (http ://fun3d.larc.nasa.gov/example-20.html).
une temporelle) :
Z Au lieu d’approximer les dérivées partielles comme dans
h̄2 ψ̃(ω, ~
q)
−h̄ω ψ̃(ω, ~q) = − 2
+ q′ − ~
Ṽ (~ q )ψ̃(ω, ~q′ )d~
q′ l’équation (5.4), on approxime la fonction f (x, y, z) re-
2m q cherchée par un développement local sur une base de fonc-
avec des notations similaires à ce qui précède. On obtient tions. On fait ainsi un maillage de l’espace (voir la figure
sans grande surprise un produit de convolution. Celui-ci 5.10), en général avec de petits tétraèdres de tailles va-
peut être très rapide à calculer si Ṽ (~ q ) est bien localisé riables de telle façon que la géométrie du maillage suive
(i.e. V (~r) varie lentement) et donc l’intégrale aisée à cal- d’assez près celle du problème : dans le cas de l’aile d’avion,
culer ; au contraire, si V (~r) est localisé, avec des variations par exemple, les « mailles » seront plus petites et plus res-
rapides, le produit de convolution dans l’espace réciproque serrées près du bord d’attaque de l’aile, là où le flux d’air
sera extrêmement laborieux à obtenir. . . on retrouve ici la subit les déviations les plus brutales, les champs de vitesse
bonne vieille propriété des transformées de Fourier : avec et de pression présentent des variations importantes.
des fonctions localisées, on a généralement intérêt à tra- Dans chaque maille Mp , la fonction recherchée fait
vailler dans l’espace direct (l’espace de ~r), au contraire, l’objet d’un développement sur une base de fonctions
s’il s’agit de fonctions « proches » d’ondes planes, l’espace ϕj (x, y, z) :
réciproque (l’espace des ~ q ) est plus efficace. X p
f (x, y, z) ≃ vj ϕj (x, y, z), (x, y, z) ∈ Mp
j
5.2.4 Introduction aux éléments finis
les vjp étant les coefficients du développement dans cette
Pratiquement tous les exemples ci-dessus sont unidi- maille.
mensionnels pour des raisons de simplification évidente. Le Comme les fonctions ϕj sont connues, choisies par l’uti-
passage à trois dimensions peut se faire dans tous les cas lisateur, leurs dérivées partielles sont calculables et les
dérivées partielles de f s’écrivent : à une échelle suffisamment grande pour que la structure
atomique de la matière n’intervienne pas. Lorsqu’on se
∂f (x, y, z) X p ∂ϕj (x, y, z)
≃ vj préoccupe de question se situant à une échelle plus petite,
∂x j
∂x il faut bien sûr adopter une modélisation appropriée où la
matière est considérée comme constituée d’atomes.
Très souvent, les fonctions ϕj sont tout simplement des
polynômes de telle façon que leurs dérivées soient faciles
à obtenir. 5.3.1 Matrice dynamique
En général, on se retrouve avec un très grand système On a vu, à propos des problèmes de valeurs propres (§
d’équations à résoudre dont les inconnues sont les coeffi- 4.5.4), que beaucoup de questions pouvaient se ramener à
cients vjp . un problème de matrice dynamique dont on cherche les va-
A titre d’exemple, le problème du paragraphe 5.4 est leurs propres et les vecteurs propres. Pratiquement tous les
traité ici, bien qu’il soit absurde d’utiliser les éléments fi- problèmes d’oscillateurs harmoniques couplés peuvent être
nis dans ce cas qui se résout facilement par différences avantageusement abordés de la sorte. Plusieurs problèmes
finies ! Il s’agit simplement de montrer ici le principe de la de cet ordre, suffisamment différents pour montrer la force
méthode. Dans ce cas, les mailles sont de nouveaux des pe- de cette approche, sont décrits ci-dessous.
tits intervalles d’indice p. Sur un intervalle, la température
s’écrit : 5.3.1.1 La chaı̂ne unidimensionnelle désordonnée
T (x) = ap x2 + bp x + cp
Considérons d’abord la dynamique d’une chaı̂ne uni-
si
δx δx dimensionnelle harmonique d’atomes : le problème est
xp − p < x < xp + p , δxp = xp − xp−1 mathématiquement assez proche de celui du paragraphe
2 2
5.2.2.6. La chaı̂ne est représentée en figure 5.11 ; l’équation
où xp est le milieu du p-ième intervalle. La température
du mouvement en est bien connue :
n’est donc pas considérée comme une constante dans
l’intervalle comme c’était le cas avec la méthode des
mẍℓ = κ(xℓ+1 − xℓ ) + κ(xℓ−1 − xℓ )
différences finies. La base de fonctions est ici limitée à trois
monômes de degrés 0, 1 et 2. Les inconnues sont les coeffi- où m est la masse des atomes tous identiques, κ la rai-
cients ap , bp et cp . Dans le p-ième intervalle, l’équation de deur des «ressorts » et xℓ le déplacement par rapport à
diffusion de la chaleur (5.8) s’écrit en tenant compte des sa position d’équilibre de l’atome ℓ. La distance entre les
expressions des dérivées : positions d’équilibre des atomes est a.
∂κ(xp )
(2ap x + bp ) + κ(xp )2ap = −Q̇(xp )
∂x m κ
Cependant, la température doit être continue aux jonc-
tions des intervalles, soit : Fig. 5.11 – La chaı̂ne linéaire unidimensionnelle d’atomes
identiques
ap (xp + δxp+1 )2 + bp (xp + δxp+1 ) + cp =
Dans ce genre de problème, on cherche des solutions de
ap+1 (xp + δxp+1 )2 + bp+1 (xp + δxp+1 ) + cp+1 type onde plane où ω est la pulsation de l’onde, q son
De même les dérivées premières : vecteur d’onde :
2ap (xp + δxp+1 ) + bp = 2ap+1 (xp + δxp+1 ) + bp+1 xℓ = x0 ei(ωt−qℓa)
On obtient ainsi un système de 3n équations à 3n incon- et l’on obtient l’équation de dispersion habituelle :
nues (puisque l’on à une base de 3 fonctions, cela n’a rien r
à voir avec la dimensionnalité) que l’on peut résoudre par κ qa
ω=2 sin
les méthodes habituelles. m 2
Si le principe en est simple, l’écriture de programmes Mais si le système présente du désordre, par exemple
d’éléments finis est assez lourde. Le maillage à lui seul si l’on introduit des impuretés, c’est-à-dire des atomes de
n’est pas simple. Il s’agit cependant d’un problème assez types différents, κ et m dépendent du site ℓ : κ doit être
modulaire sur le plan informatique : le choix du maillage, remplacé par κℓ,ℓ+1 (la raideur entre les sites ℓ et ℓ + 1)
par exemple, est pratiquement indépendant du traitement et m par mℓ ,
à proprement parler des équations aux dérivées partielles.
Ainsi, les utilisateurs semblent préférer utiliser des pro- mℓ ẍℓ = κℓ,ℓ+1 (xℓ+1 − xℓ ) + κℓ−1,ℓ (xℓ−1 − xℓ )
grammes déjà existants qui, en général, s’adaptent assez
bien à chaque problème particulier. Point n’est besoin de On peut tenter une résolution analytique par des
réinventer ce qui existe déjà ! méthodes perturbatives, mais le cas d’un fort désordre
paraı̂t difficile à traiter et la généralisation à trois dimen-
sions problématique (car le problème est en général traité
5.3 La matière comme une collec- à l’aide d’une méthode dite de « matrice de transfert »
intrinsèquement unidimensionnelle.)
tion de particules. Toutefois, on peut aussi poser :
Tous les problèmes ci-dessus, à l’exception bien sûr de uℓ
l’équation de Schrödinger, reposent sur une modélisation xℓ = √ eiωt
mℓ
on se débarrasse alors de la dépendance temporelle, de structure dynamique » dont les maxima fournissent ce
mais on ne postule plus la périodicité spatiale comme qui tient lieu de « courbe de dispersion » (figure 5.12) qui
précédemment, puisque uℓ dépend de ℓ, c’est-à-dire du ressemble à ce que pourrait donner une expérience, par
site. On obtient le système d’équations suivant : exemple, de diffusion inélastique de neutrons.
On peut également regarder, ce qui paraı̂t pour le moins
κℓ,ℓ−1 difficile à réaliser expérimentalement, les mouvements cor-
ω 2 uℓ = −√ uℓ−1 respondants à différents points de la figure 5.12 : par
mℓ−1 mℓ
κℓ+1,ℓ + κℓ,ℓ−1 κℓ+1,ℓ exemple, en figure 5.13.
+ uℓ − √ uℓ+1
mℓ mℓ mℓ+1
La matrice dynamique D de dimension n × n composées

des coefficients du système s’écrit :
D=
 
.. ..
. . 0 0 0
 
 .. .. .. 
 . . . 0 0 
 κℓ,ℓ−1 κℓ+1,ℓ + κℓ,ℓ−1 κℓ+1,ℓ 
 0 0 
 −√
mℓ−1 mℓ mℓ
−√
mℓ mℓ+1 
 
 .. .. .. 
 0 0 . . . 
 
.. ..
0 0 0 . .
et le problème revient à chercher
 les  valeurs propres ω 2 ,
u1
 u2 
 
 .. 
 . 
et les vecteurs propres U =  
 uℓ  de cette matrice
 
 . 
 .. 
un
dynamique.
Comme pour l’exemple de la poutre 5.2.2.6, il y a des
programmes de bibliothèque qui font cela très bien ! (sur-
tout si la matrice est creuse, ce qui est toujours le cas –à
1-D, elle est même tridiagonale–).
40
20
10
3 5
Fig. 5.13 – Deux vecteurs propres. En haut, un vecteur
2.5 propre du début de la courbe de dispersion (ω ≃ 0,6), peu
affecté par le désordre. En bas, un vecteur propre non-
2
propagatif, localisé sur des impuretés (ω ≃ 2,2).
1.5 freq
1 Ainsi, l’on peut directement établir une relation entre
0.5 des résultats « expérimentaux » et des processus qui ont
lieu au niveau microscopique.
0
0 0.5 1 1.5 2 2.5 3 .
q
5.3.1.2 Dynamique d’une molécule
Fig. 5.12 – Facteur de structure dynamique d’une chaı̂ne
désordonnée de 100 atomes. Cela revient à la courbe de La dynamique d’une molécule unidimensionnelle à trois
dispersion d’une onde acoustique dans la chaı̂ne. On ob- atomes sera d’abord décrite pour préciser les principes de
serve une branche « normale » pour les basses fréquences la méthode de façon schématique, puis on généralisera à
et une composante à haute fréquence due au désordre (les des cas plus généraux.
impuretés dans cet exemple étant plus légères).
5.3.1.2.1 À une dimension, trois atomes. Soient
La matrice U donne les déplacements atomiques en
donc trois atomes alignés, de masses m1 , m2 et m3 . Ils
fonction du numéro du site, autrement dit de la position
sont liés par un potentiel harmonique, de telle façon que
ri = a×i : une transformée de Fourier spatiale des vecteurs
l’énergie potentielle d’interaction entre 1 et 2 s’écrive
propres doit donc donner quelque chose qui dépend du vec-
teur d’onde q, or il y a également dépendance en fonction 1
de la pulsation ω. On obtient alors S(q, ω), le « facteur V12 = k(x1 − x2 )2
2
où x1 et x2 sont les déplacements des atomes 1 et 2 par 5.3.1.2.2 À trois dimensions, N atomes. On
rapport à leur position d’équilibre. De même, réalise, à la lumière de l’exemple ci-dessus, que dès que
la matrice dynamique a une dimension qui dépasse 3,
1 ′ 2 le calcul devient inextricable, or la dimension de D est
V23 = k (x2 − x3 )
2 le nombre de degrés de liberté du système : pratique-
ment toutes les molécules échappent à cette analyse !
k k’
Évidemment, comme cela a déjà été montré, la résolution
numérique est beaucoup plus aisée.
Essayons de poser le problème de façon plus générale :
m1 m2 m3 soit une molécule de N atomes de masses mℓ situées
On néglige l’interaction entre 1 et 3. Les équations du aux coordonnées ~rℓ . On suppose que l’on est capable de
mouvement s’écrivent simplement : calculer l’énergie potentielle du système V ({~rℓ )}, ℓ ∈
[1, N ]. On suppose également que l’on connait les positions
(0)
m1 ẍ1 = k(x2 − x1) d’équilibre des atomes ~rℓ . Afin de simplifier les notations,
m2 ẍ2 = k(x1 − x2) + k ′ (x3 − x2 ) on pose que :
m3 ẍ3 = k(x2 − x3)
qk = rℓ,α ℓ ∈ [1, N ], α ∈ [1, 3], k = 3(ℓ − 1) + α
De la même façon que pour la chaı̂ne linéaire d’atomes, on
où α indice les trois coordonnées de l’espace. L’indice k
pose :
varie de 1 à 3N , c’est-à-dire le nombre de degrés de liberté
u1 iωt du système. Les équations du mouvement2 s’écrivent :
x1 = √ e
m1
∂V
u2 iωt mk q̈k = − ∀k ∈ [1, 3N ]
x2 = √ e ∂qk
m2
u3 Les dérivées sont prises en {qk } : comme on s’intéresse à
x3 = √ eiωt
m3 un système harmonique, on peut faire un développement
(0)
limité autour de la position d’équilibre {qk },
ainsi :
√ u2 u1 ∂V ∂V (0)
X ∂2V (0)
− m1 ω 2 u1 = k( √ −√ ) ({qk′ }) = ({qk′ }) + ′′ ({qk′ })(qk − qk )
′′
m2 m1 ∂qk ∂qk ∂q k ∂qk
k′′
√ u1 u2 u3 u2
− m2 ω 2 u2 = k( √ − √ ) + k′ ( √ −√ )
m1 m2 m3 m2 Les dérivées de l’énergie potentielle à l’équilibre
√ u 2 u 3 ∂V (0)
− m3 ω 2 u3 = k( √ −√ ) ({qk′ }) sont nulles, et les équations du mouvement
m2 m3 ∂qk
se reécrivent :
En termes matriciels : X ∂2V (0) (0)
   k  m k q̈k = ′ ({qk′′ })(qk − qk′ )
′
− √ k 0 ∂q k ∂q
u1 m 1 m 1 m 2 k ′ k
 k+k′
− √mk2 m3 
′
U =  u2  D =  − √mk1 m2 m2 
(0)
u3 0
′
− √mk2 m3 k′ En posant xk = (qk − qk ) (les déplacements par rapport
m3
à l’équilibre), on obtient :
et X
ω 2 U = DU mk ẍk = − Ck,k′ xk′ (5.12)
k′
La recherche des valeurs propres revient à la recherche
des racines de |D − ω 2 I| = 0 : a priori, cela donne un où Ck,k′ est la matrice des dérivées secondes de l’énergie
polynôme en ω 6 , mais compte tenu de la solution ω = 0 potentielle, ce qui nous ramène à une forme familière : il
correspondant à la translation d’ensemble de la molécule reste à appliquer la procédure habituelle,
(car |D| = 0), on obtient une équation bicarrée en ω : uk
xk = √ eiωt
mk
′
k(m 1 + m 2 ) + k (m 2 + m 3 ) m 1 + m 2 + m 3
ω4− ω 2 +kk ′ = 0 et
m1 m2 m3 m1 m2 m3 X Ck,k′
ω 2 uk = √ uk ′
soit mk mk ′
k′
1 k(m1 + m2 ) + k ′ (m2 + m3 )
ω2 = × soit, comme avant :
2 m1 m2 m3
s ! ω 2 U = DU
m 1 m 2 m 3 (m 1 + m 2 + m 3 )
1 ± 1 − 4kk ′
k(m1 + m2 ) + k ′ (m2 + m3 ) Il est aisé de vérifier que la matrice D est symétrique.
Il « suffit » de réinjecter ces solutions dans l’équation aux 2 Ici, les variables sont des variables spatiales (x, y, z), mais, fort
valeurs propres pour obtenir les vecteurs propres et les souvent dans les systèmes mécaniques comportant par exemple des
contraintes, la situation est plus complexe : on a alors souvent intérêt
déplacements atomiques correspondant à chaque valeur d ∂L ∂L
propre. à utiliser les notations Lagrangiennes : L = K − V et = .
dt ∂ q̇ℓ ∂qℓ
Si le formalisme est nettemement plus lourd que X ∂2V ∂Sℓ ∂Sℓ′

=
précédemment, la physique est sensiblement la même ; ce- ∂Sℓ ∂Sℓ′ ∂xk ∂xk′
ℓ,ℓ′
pendant la méthode qui vient d’être exposée a le mérite X
d’être d’utilisation quasiment automatique, à partir de la ∂2V
= gk,ℓ gk′ ,ℓ′ (5.13)
connaissance des potentiels d’interaction et des positions ∂Sℓ ∂Sℓ′
ℓ,ℓ′
d’équilibre3 .
La matrice G nous donne ainsi, non seulement le lien entre
les coordonnées cartésiennes (pour lesquelles les équations
sont simples) et les coordonnées internes (pour lesquelles
1 le calcul de l’énergie et de ses dérivées et « naturelle »),
mais aussi celui entre les coefficients de couplage dans les
2 deux systèmes.
0 Il reste à définir les Sℓ .
Il y a déjà 4 variables internes évidentes : les élongations
3 des quatre liaisons radiales :
S1 = ρ1 − ρ
(~ ~0 ) · ~e1
S2 = ρ2 − ρ
(~ ~0 ) · ~e2
4 S3 = ρ3 − ρ
(~ ~0 ) · ~e3
S4 = ρ4 − ρ
(~ ~0 ) · ~e4
Fig. 5.14 – Une molécule tétraédrique, par exemple CH4
ou C Cl4 . L’atome central est numéroté 0 et les quatre où les vecteurs ~ei sont les vecteurs unitaires le longs des
autres : 1, 2, 3, 4. liaisons (0, i) : ~ei = (~ri − ~r0 ) /|~ri − ~r0 |. On obtient alors
assez aisément :
5.3.1.2.3 Calcul pour une molécule tétraèdrique. ~si,ℓ = ~eℓ si i = ℓ ℓ ∈ [1, 4]
Imaginons, par exemple, une molécule tétraèdrique ~s0,ℓ = −~eℓ ℓ ∈ [1, 4]
(fig. 5.14) : a priori, comme on a 5 atomes et trois degrés ~si,ℓ = 0 sinon.
de liberté par atomes, soit quinze degrés de liberté en  x 
tout, la matrice dynamique est (15 × 15). Toutefois la si,ℓ
translation et la rotation d’ensemble de la molécule ne où ~si,ℓ =  syi,ℓ .
nous intéressent pas : 3 degrés de liberté translationnels szi,ℓ
et 3 degrés de liberté rotationnels (pour une molécule tri- Les angles entre les liaisons paraissent aussi être des va-
dimensionnelle) ne sont pas pertinents ; de façon générale, riables assez naturelles, mais c’est un peu plus compliqué
pour une molécule à N atomes, on doit aboutir à 3N −6 va- puisqu’un simple dénombrement donne θ12 (l’angle 102 d de
riables internes et une matrice dynamique (3N − 6 × 3N − sommet l’atome 0 qui se situe entre les liaisons 0 − 1 et
6), soit (9 × 9) ici. Comme nous sommes dans une approxi- 0 − 2), θ13 , θ14 , θ23 , θ24 , θ34 , c’est-à-dire six angles, or il
mation harmonique, on considère que les déplacements n’en faut que cinq puisqu’on a déjà quatre variables S1 à
~i , ∀i ∈ [1, N ] des atomes par rapport à leurs positions S4 et qu’on en attend 9 en tout : c’est que ces angles ne
ρ
d’équilibre ~ri sont petits, ainsi on peut écrire une relation sont pas indépendants. On peut poser
linéaire entre les variables internes Sℓ , ℓ ∈ [1, 3N − 6] et
~i − ~r0 − ρ
~ri + ρ ~0 ~hi
les déplacements atomiques : ~εi = =
|~ri + ρ
~i − ~r0 − ρ ~0 | |~hi |
XN X
Sℓ = sα α
i,ℓ ρi La différence entre ~εi et ~ei est que le premier comprend les
i=1 α=x,y,z déplacements ρ ~i : à l’équilibre ces vecteurs sont identiques.
On a :
où α représente les trois directions de l’espace et les sα i,ℓ cos θi,j = ~εi · ~εj
sont les coefficients de ce développement au premier ordre.
Si l’on écrit comme précédemment k = 3(i − 1) + α et On peut différencier cette expression :
xk = ρα i , alors d (cos θi,j ) = − sin θi,j dθi,j = d~εi · ~εj + ~εi · d~εj
X
Sℓ = gℓ,k xk avec gℓ,k = sα où
i,ℓ
k
d~hi |~hi | − ~hi d|~hi |
d~εi =
|~hi |2
ou q
S =G·x 1 2~hi · d~hi
or d~hi = ρ~i − ρ~0 , et d|hi | = d |~hi |2 = =
2 |~hi |
en notations matricielles. A priori, la matrice G n’est pas
carrée puisqu’elle est (3N − 6 × 3N ). ~ei · (~
ρi − ρ~0 ) = Si , ainsi :
Ainsi les ceofficients qui apparaissent dans l’équation ~i − ρ
ρ ~0 Si
(5.12) peuvent s’écrire : d~εi = − ~ei
|~ri − ~r0 | |~ri − ~r0 |
∂2V En posant que les éléments différenciels dθi,j = ηi,j sont les
Ck,k′ = variations angulaires correspondant au mouvements dits
∂xk ∂xk′
« de libration », on obtient après quelques lignes de calcul :
3 Voir par exemple : E. B. Wilson Jr., J. C. Decius, P. C. Cross,
Molecular vibrations (1955) reéd. Dover (1980), chap. 4. |~ei ∧ ~ej | ηi,j =

ρ~0 − ρ~i ~0 − ρ~j
ρ Si Sj s’écrivent alors
· ~ej + · ~ei + + ~ei · ~ej
|~ri − ~r0 | |~rj − ~r0 | |~ri − ~r0 | |~rj − ~r0 |
m1 ẍ1,ℓ = cp,1 (xp,ℓ−1 − x1,ℓ ) + c2,1 (x2,ℓ − x1,ℓ )
Si l’on pose, par exemple :
mk ẍk,ℓ = ck−1,k (xk−1,ℓ − xk,ℓ ) + ck+1,k (xk+1,ℓ − xk,ℓ )
S5 = η12 , S6 = η13 , S7 = η14 , S8 = η23 , S9 = η24 , S10 = η34 mp ẍp,ℓ = cp−1,p (xp−1,ℓ − xp,ℓ ) + c1,p (x1,ℓ+1 − xp,ℓ )
cela permet d’obtenir, où mk est la masse de l’atome de type k et les ck,k′ les
constantes d’interaction entre les atomes k et k ′ . On s’est
~e1 − ~e2 1 1 limité ici aux interactions entre premiers voisins, mais
~s05 = −
|~e1 ∧ ~e2 | |~r2 − ~r0 | |~r1 − ~r0 | on peut généraliser sans difficultés. . . autres que « tech-
niques » !
etc. Comme les mailles se succèdent en restant identiques
L’énergie potentielle de la molécule peut s’écrire en fonc- les unes aux autres, notre système est périodique et nous
tion des variables internes : pouvons chercher des solutions de type onde plane :
1X
4
1X uk
ρk }) =
V ({~ ~0 ) 2 +
ρi − ρ
ki (~ 2
cij ηij (5.14) xk,ℓ = √ ei(ωt−q(ℓa+Xk ))
2 i=1 2 mk
i = 1, 3
où q est le vecteur d’onde de l’onde plane. Jusqu’ici, nous
j = i + 1, 4
10
X n’avons rien fait de nouveau par rapport à la chaı̂ne unidi-
1 mensionnelle à un type d’atomes, sinon des aménagements
= ki Si2
2 i=1 pour tenir compte du nombre d’atomes par maille, ce qui
ne fait qu’alourdir les notations sans apporter grand-chose
Dans l’équation (5.14), le premier terme correspond à de nouveau. . . Si l’on poursuit dans la même voie, on doit
l’allongement des liaisons et le deuxième aux oscillations injecter ces expressions d’ondes planes dans les équations
latérales, les mouvements de libration. Les coefficients ki du mouvement ; on obtient :
et cij correspondent aux dérivées secondes de l’équation
2 −iqX1 up −iq(Xp −a) u1 −iqX1
(5.13). −ω u1 e = cp,1 √ e − e +
m1 mp m1
On constate que, dans cet exemple, la difficulté ne tient
u2 u1 −iqX1
pas tant à la méthode elle-même qui n’a rien de parti- c2,1 √ e−iqX2 − e
m1 m2 m1
culièrement nouveau par rapport à ce que l’on a déjà vu
dans les paragraphes précédents, mais dans une mise en 2 −iqXk uk−1 −iqXk−1 uk −iqXk
−ω uk e = ck−1,k √ e − e +
œuvre de la géométrie de la molécule. mk mk−1 mk

uk+1 uk −iqXk
ck+1,k √ e−iqXk−1 − e
5.3.1.3 Dynamique de réseau mk mk+1 mk

Cette technique qui utilise la matrice dynamique est −ω 2 up e−iqXp = cp−1,p √ up−1 e−iqXp−1 − up e−iqXp +
extensible à un réseau périodique d’atomes, c’est-à-dire mp mp−1 mp

un cristal. Elle recouvre que qu’on appelle la « dyna- u1 −iq(Xp +a) up −iqXp
c1,p √ e − e
mique de réseau » et elle est très utilisée pour interpréter mp m1 mp
des expériences de spectroscopie optique ou neutronique
qui servent à déterminer les modes de vibrations présents Après quelques manipulations simples, cela donne :
dans des systèmes qui peuvent être assez compliqués. cp,1 e−iq(Xp −X1 −a) cp,1 + c2,1
Sa limite cependant est que les interactions entre les ω 2 u1 = − √ up + u1
m1 mp m1
atomes doivent pouvoir être traités dans l’approxima-
tion harmonique ce qui impose plusieurs contraintes : c2,1 e−iq(X2 −X1 )
− √ u2
que les positions d’équilibre soient déjà connues, donc la m1 m2
structure microscopique du matériau établie et que les ck−1,k e−iq(Xk−1 −Xk ) ck−1,k ck+1,k
déplacements atomiques restent suffisamment petits pour ω 2 uk = − √ uk−1 + uk
mk mk−1 mk
qu’un développement limité au premier ordre des forces
soit possible. ck+1,k e−iq(Xk−1 −Xk )
− √ uk+1
Prenons, pour simplifier les notations, le cas unidimen- mk mk+1
sionnel : nous avons une chaı̂ne unidimensionnelle infinie cp−1,p e−iq(Xp−1 −Xp ) cp−1,p + c1,p
(et non finie comme dans le § 5.3.1.2.1) avec p atomes ω 2 up = − √ up−1 + up
mp mp−1 mp
par maille, ces mailles étant indéfiniment répétées. Chaque
atome est en principe repéré par 2 indices, ℓ le numéro de c1,p e−iq(X1 −Xp +a)
− √ u1
la maille (qui va de −∞ à +∞) et k le numéro de l’atome mp m1
dans la maille ℓ (k ∈ [1, p]). La position d’équilibre de
l’atome k, ℓ est donc On constate qu’une fois de plus on tombe sur un
problème aux valeurs propres, la matrice dynamique étant
Xk,ℓ = ℓa + Xk maintenant p × p, donc a priori moins grosse qu’avant. . .
toutefois, comme le vecteur d’onde apparaı̂t dans la ma-
où a est le paramètre de maille et Xk la position dans la trice, il faudra résoudre le problème un grand nombre de
maille. Les déplacements des atomes par rapport à ces po- fois, soit une fois pour chaque valeur souhaitée du vec-
sitions d’équilibre sont xk,ℓ ; les équations du mouvement teur d’onde. La matrice dynamique elle-même est devenue
complexe à cause des termes en eiqx , toutefois les termes Il existe cependant une solution : les tirages au sort ou
symétriques par rapport à la diagonale sont conjugués Monte-Carlo comme on l’a vu au paragraphe 4.11.6.
l’une de l’autre : la matrice est hermitique et il suffira
de choisir un sous-programme de bibliothèque approprié.
5.3.2 Simulations Monte-Carlo.

Dans un autre ordre d’idées, on peut ne pas connaı̂tre
la structure microscopique d’un matériau et donc la
chercher sans se préoccuper de la dynamique. Si l’on
connait les constituants de ce matériau, on peut recher-
cher l’état d’équilibre de ce système d’atomes à condition
de connaı̂tre les potentiels d’interaction atome-atome :
V ({~ri })
où V est l’énergie potentielle de l’ensemble des atomes

du système considéré en fonction des distances inter-
atomiques ~ri . On écrit souvent V comme une somme de
potentiels à deux corps :
X
V ({~ri }) = vi,j (ri,j ) (5.15)
<i,j>
X
où le symbole désigne une somme sur toutes les paires
<i,j>
d’atomes (i, j) (il y en a n(n−1)
2 ) et vi,j (ri,j ) est l’énergie Fig. 5.16 – Système de spins posés sur un réseau triangu-
potentielle de deux atomes i et j connaissant leur distance laire, par simulation Monte-Carlo. Une structuration com-
ri,j , mais il arrive que l’on doive faire des choses plus complexe en vortex s’établit (E. Yu. Vedmedenko, A. Ghazali,
pliquées pour tenir compte du fait, par exemple, que l’in- J.-C.S. Lévy Phys. Rev. B 59 (1999) 3329).
teraction entre deux atomes puisse être perturbée par la
présence d’un troisième.
Les applications en sont nombreuses, voir par exemple la
f figure 5.16. Comme le résultat dépend de la température,
on peut étudier l’évolution du système en fonction de la
température, ses éventuels changement de structure, les
transitions de phase. On peut également introduire dans
l’énergie potentielle des contraintes comme la pression
extérieure et faire des études en fonction de cela.
Contrairement à ce que l’on pourrait penser, cette
méthode est relativement rapide par rapport à d’autres
méthodes microscopiques. On est, certes, dans le domaine
du calcul lourd, les temps de calcul se chiffrent en heures
ou en jours, mais on a, avec un ordinateur moyennement
puissant, la possibilité de traiter des « gros » systèmes, jus-
qu’à environ un million d’atomes, ce qui est largement suf-
fisant pour un nombre incroyablement élevé de problèmes.
La restriction principale vient de ce qu’on n’a pas accès
aux mouvements atomiques en fonction du temps ou aux
x fréquences des modes de vibration, ou seulement de façon
très indirecte.
Fig. 5.15 – Quand on recherche numériquement le mi-
nimum d’une fonction, on part d’un point de départ et
l’on fait une analyse locale de la fonction afin de trou-
ver un point –meilleur– qui peut servir de nouveau point
de départ (flèche pleine). La plupart des algorithmes est 5.3.3 Simulations de dynamique molé-
incapable de suivre la trajectoire indiquée par la flèche culaire.
tiretée. . .
Si l’on veut étudier la dynamique d’un système
C’est un problème de recherche du minimum d’une fonc-
d’atomes, le plus simple est de s’attaquer à la résolution
tion d’un grand nombre de variables, les positions ato-
numérique des équations du mouvement (classiques) de ce
miques ; il existe des méthodes pour faire cela (e.g. gra-
système :
dient conjugué), mais lorsqu’elles convergent vers un mini-
mum, il est très difficile de savoir s’il s’agit d’un minimum
local ou DU minimum de la fonction (figure 5.15) ! mℓ ~r̈ ℓ = f~ℓ (~r1 . . . ~rℓ′ . . . ~rN ), ∀ℓ ∈ [1, N ]
où :   vants (voir par exemple les figures 5.18 et 5.19) :

∂V nombre d’atomes : N ≃ 104
 ∂xℓ  longueurs d’onde accessibles : λ ≤ 10nm
 
 
f~ℓ = −grad~ V = −  ∂V  pas de temps d’intégration : δt ≃ 10−3 ps
ℓ  ∂yℓ  durée accessible : τ ≃ 103 ps
 
 ∂V  fréquences accessibles : 10−2 tHz ≤ ν ≤ 10tHz
∂zℓ A priori, on travaille à E = K + V = Cste et à volume
et, par exemple avec un potentiel d’interaction de paire de constant, mais on peut aussi fixer P et T . Maintenir la
type Lennard-Jones (figure 5.17) : pression constante, plutôt que le volume est utile pour si-
muler des transitions de phase ou des changements struc-
12 6 ! turaux, voire simplement tenir compte de la dilatation.
1X 1X σij σij
V = V (~rij ) = εij −2 Maintenir la température constante permet de traiter par
2 i,j 2 i,j rij rij
exemple des phénomènes dissipatifs, tels que diffusion de
(5.16) la chaleur à l’échelle microscopique.
On a perdu, par rapport à la méthode de Monte-Carlo,
1 deux ordres de grandeur pour le nombre d’atomes maxi-
mum que l’on peut inclure dans le système, mais en
contrepartie, comme on a la dynamique, on peut suivre
0.5
l’évolution temporelle du système, étudier les vibrations
(la gamme de fréquence accessible est celle des vibrations
0 acoustiques dans la matière condensée).
Le même type de simulation peut servir pour l’étude
−0.5 de systèmes fort différents et très divers comme les grains
d’un tas de sable ou les étoiles dans une galaxie !
−1
0 1 2 3 4 5 5.3.4 Simulations ab-initio.

Toutefois, la faiblesse des méthodes ci-dessus, simula-
Fig. 5.17 – Le potentiel de Lennard-Jones de l’équation
tion Monte-Carlo ou dynamique moléculaire, est qu’elles
(5.16), pour σij = 1 et εij = 1. Le potentiel est attractif
supposent que les potentiels d’interaction soient connus
pour rij > σij , répulsif dans le cas contraire, la distance
et modélisables avec une précision suffisante. Les expres-
d’équilibre étant σij .
sions de type Lennard-Jones ou analogues ne sont que des
modèles dont on espère qu’ils rendent compte de la réalité
Il s’agit d’un très gros système d’équations
de manière satisfaisante. Il arrive que ce ne soit pas le
différentielles dépendantes du temps que l’on peut
cas, simplement parce que l’on ne dispose pas d’expression
résoudre numériquement par les méthodes habituelles (en
analytique valide dans un domaine suffisant de distances
général Verlet). Cela suppose toutefois que l’on dispose
interatomique, ou bien que l’interaction soit modifiée par
de modèles d’interaction entre les atomes, par exemple
l’environnement :
Lennard-Jones comme ci-dessus.
– quand on simule une surface, le nombre de voisins
PBC d’un type d’atome donné n’est pas le même selon que
l’atome considéré est dans le cœur de l’échantillon ou
en surface : la forme de l’interaction de cet atome avec
Substrate Adsorbate ces voisins peut en être affectée
– des atomes ou des molécules dont les nuages
électroniques sont fortement modifiés par la présence
ou non d’autres atomes,
PB
– si l’on comprime le milieu de façon que les noyaux

C
se rapprochent suffisemment pour modifier les nuages

électroniques
– ...
On peut introduire des potentiels à trois corps, voire
Fig. 5.18 – Un exemple de simulation de dynamique plus, afin de tenir compte de l’effet que la présence d’un
moléculaire pour étudier le frottement d’un adsorbat sur troisième atome peut avoir sur l’interaction entre deux
un substrat. La substrat est constitué de 18×18×4 mailles autres atomes, on peut également introduire des charges
cubiques à faces centrées. Chacune des deux surfaces libres qui peuvent se déplacer dans certaines conditions : tous
est recouverte d’une monocouche de 288 atomes d’un autre ces modèles restent cependant assez phénoménologiques.
type (soit un total de 5760 atomes). L’on exerce des forces Toutefois, dès que l’on s’intéresse, par exemple, aux liens
extérieures opposées sur l’adsorbat et le substrat afin de entre propriétés structurales et propriétés électroniques
les faire glisser l’un sur l’autre (Ph. Depondt, A. Ghazali, d’un matériau, on peut aussi tenter de revenir aux prin-
J.-C. S. Lévy, Surf. Science 419 (1998) 29). cipes fondamentaux et faire ce que l’on appelle des si-
mulations ab-initio (à partir du début). Dans ce cas,
Avec un ordinateur « raisonnablement » puissant, l’on on ne fait pas d’hypothèse sur la forme des interactions
atteint sans difficulté majeure les ordres de grandeurs sui- mais on considère un ensemble de noyaux avec leurs
Fig. 5.19 – Vue de dessus de l’adsorbat (gris sombre) et d’une couche du substrat (gris clair) de la figure 5.18, à gauche
avant glissement, à droite après.
nuages électroniques. En principe, on doit alors résoudre et l’équation de Schrödinger se reécrit comme avant
l’équation de Schrödinger de n noyaux de numéro ato-
Xn ψi+1,j,k − 2ψi,j,k + ψi−1,j,k
mique Zi et Zi électrons en interaction. −
δx2
i=1 ψi,j+1,k − 2ψi,j,k + ψi,j−1,k
−
δy 2
5.3.4.1 Une petite contrariété
ψi,j,k+1 − 2ψi,j,k + ψi,j,k−1
−
Malheureusement, on ne peut pas attaquer le problème δz 2
avec des méthodes comme celle étudiée dans le paragraphe +Vi,j,k ψi,j,k = E ψi,j,k
5.2.2.4 : il n’existe pas au monde d’ordinateur assez puis-
sant pour le faire ! Pour illustrer ce propos, revenons à Le triplet (i, j, k) prend alors n3 valeurs5 , ainsi la ma-
l’équation de Schrödinger indépendante du temps à une trice dont on cherche les valeurs propres est de dimension
dimension et à une particule dans un potentiel : c’est le n3 × n3 , soit 106 ×106 si n = 100 : le problème s’est brutale-
cas le plus simple. La fonction d’onde ψ qui décrit l’état du ment amplifié de façon démesurée. . ., et nous n’en sommes
système est une fonction à une variable, et l’on obtient4 : encore qu’à une seule particule ! Passons à un problème a
priori simple, l’atome d’hydrogène : un proton et un neu-
∂ 2 ψ(x) tron, soit deux particules en interaction, à trois dimen-
Hψ = Eψ ≡ − + V (x)ψ(x) = Eψ(x)
∂x2 sions, soit 6 variables. Le même raisonnement nous mène
à estimer l’ordre de grandeur du problème à 1012 × 1012
En discrétisant le problème de la façon habituelle,
(toujours avec 100 points par variable) : même avec un
xi = i δx, Vi = V (xi ), ψi = ψ(xi ) ordinateur très puissant, c’est sans espoir !
Conclusion : il ne suffit pas, pour résoudre un problème,
l’équation se reécrit : de « le mettre dans l’ordinateur » et d’attendre que la force
brute de la machine fasse son œuvre. Il faut donc faire des
ψi+1 − 2ψi + ψi−1 approximations.
− + Vi ψi = Eψi
δx2
Il est aisé de se convaincre que, chercher E et ψi , i ∈ 5.3.4.2 L’approximation de Born-Oppenheimer
[1, n], revient à chercher les valeurs propres et les vecteurs
propres d’une matrice (n × n) : si n est de l’ordre de 100, La première étape consiste à découpler les mouvements
voire davantage, il n’y a rien de bien extraordinaire à cela. des électrons de ceux des noyaux beaucoup plus lourds
Imaginons maintenant le même problème à trois dimen- et beaucoup plus lents (c’est l’approximation de Born-
sions : la discrétisation implique un triplet d’indices (i, j, k) Oppenheimer). Pour le mouvement des noyaux, on se
contente en général d’une dynamique classique. Cette dy-
xi = i δx, yj = j δy, zk = k δk namique est lente par rapport à celle des électrons, ainsi,
on fait l’hypothèse que le nuage électronique est toujours
ψi,j,k = ψ(xi , yj , zk ) Vi,j,k = V (xi , yj , zk ) 5 en général, on renumérote les sites pour n’avoir qu’un seul indice
2 ℓ = i + n(j − 1) + n2 (k − 1) dont on vérifie aisément qu’il varie de 1

4 en posant h̄ = 1. à n3 .
2m
en équilibre, qu’il s’adapte instantanément à un chan- C’est ce qu’on appelle la méthode de Hartree. Elle
gement de configuration des noyaux. D’un point de vue présente un énorme défaut : a priori, les électrons sont
quantique, il ne reste plus qu’à résoudre l’équation de des fermions et leur fonction d’onde devrait être anti-
Schrödinger électronique : pour l’hydrogène, on revient à symétrique, c’est-à-dire changer de signe par permutation
un problème à une particule. Le problème reste cependant de deux électrons :
entier dès lors que l’on s’intéresse à, ne serait-ce qu’un
atome d’hélium isolé. Il faut donc encore aller quelques ψ(~r1 , . . . , ~ri , ~rj , . . . , ~rn ) = −ψ(~r1 , . . . , ~rj , ~ri , . . . , ~rn )
pas plus loin : il existe à ce titre plusieurs approches pos-
Si l’on choisit de remplacer cette fonction d’onde par un
sibles. simple produit de fonctions mono-électroniques, il est clair
que cette propriété ne sera pas remplie. Pour régler cette
5.3.4.3 Les méthodes de Hartree et Hartree-Fock question, on remplace ce produit pas un déterminant, ap-
Imaginons d’abord, pour simplifier, une fonction à deux pelé déterminant de Slater :

variables ψ(x1 , x2 ) : on peut en faire un développement χ1 (~r1 ) χ2 (~r1 ) . . . χn (~r1 )

à un ordre quelconque par rapport à x2 , sur une base de χ1 (~r2 ) χ2 (~r2 ) . . . χn (~r2 )
ψ(~r , ~
r , . . . , ~
r ) ∼
fonctions appropriées ϕℓ2 (x2 ) : 1 2 n ... ... ... . . .

X χ1 (~rn ) χ2 (~rn ) . . . χn (~rn )
ψ(x1 , x2 ) = cℓ2 ϕℓ2 (x2 )
ℓ2 qui assure la propriété d’antisymétrie : si l’on permute
deux électrons, cela revient à permuter deux lignes et
mais, évidemment, les coefficients du développement cℓ2
donc à changer le signe du déterminant. Ainsi corrigée,
sont des fonctions de x1 , suscptibles d’un développement
la méthode s’appelle la méthode de Hartree-Fock : bien
analogue : X qu’assez lourde et nécessitant un travail non-trivial de
cℓ2 (x1 ) = aℓ1 ,ℓ2 φℓ1 (x2 ) modélisation des fonctions χℓ , elle est très utilisée, no-
ℓ1
tamment par les chimistes théoriciens, pour des calculs de
et : X fonctions d’onde moléculaires.
ψ(x1 , x2 ) = aℓ1 ,ℓ2 φℓ1 (x1 )ϕℓ2 (x2 )
ℓ1 ,ℓ2
5.3.4.4 Théorie de la fonctionnelle densité
On peut, bien sûr généraliser ce genre de raisonnement
à un nombre quelconque de variables. Maintenant, l’ap- La théorie de la fonctionnelle densité (Density func-
tional theory ou DFT7 ) est, elle, une théorie, au départ,
proximation est faite d’entrée de jeu et elle est massive :
on remplace la fonction d’onde poly-électronique par un exacte, mais dont la mise en œuvre pratique oblige à des
approximations.
produit de fonctions d’onde mono-électroniques, ce qui re-
vient à se limiter au premier ordre du développement : L’idée qui sous-tend la méthode est que le détail des
fonctions d’onde de tous les électrons n’est pas ce dont on a
ψ(~r1 , ~r2 , ~r3 . . . , ~rn ) ∼ ϕ1 (~r1 ) ϕ2 (~r2 ) ϕ3 (~r3 ) . . . ϕn (~rn ) réellement besoin : la densité électronique ρ(~r) suffit bien.
Le résultat de cela, si c’était possible, serait de substituer à
On montre après quelques calculs6 que le problème s’écrit : une fonction compliquée de 3n variables ψ(~r1 , ~r2 , . . . , ~rn ),
  une fonction de trois variables, ρ(~r) telle que
XN X
− ∆ i Z i 1 Z
+ < ϕj | |ϕj > ϕi (~ri )
2
I=1 |~ ri − RI | ~
j
|~
r i − ~
rj | ρ(~r) = n |ψ(~r, ~r2 , . . . , ~rn )|2 d~r2 . . . d~rn
= εi ϕi (~ri ) ∀i Il n’est pas évident a priori qu’une telle opération soit

où ∆i est l’opérateur laplacien relatif à l’électron i : possible, car en considérant l’équation de Schrödinger, si
on essaye d’intégrer, en multipliant à gauche par ψ ∗ , sur
∂2 ∂2 ∂2 toutes les positions, sauf une, pour faire apparaı̂tre la den-
∆i = + 2+ 2
∂x2i ∂yi ∂zi sité électronique,
Z Z
~ I la position du noyau I, ~ri celle de l’électron i
R ψ Hψ d~r2 . . . d~rn = ψ ∗ Eψ d~r2 . . . d~rn = E ρ(~r)
∗
et εi l’énergie de l’état ϕi . On obtient un système

d’équations couplées par l’intermédiaire du terme d’in- le deuxième membre ne pose pas de problème parce que
1
teraction électron-électron Ji,j =< ϕj | |ϕj > qui E est un nombre scalaire, et la densité électronique vient
|~ri − ~rj | naturellement. En revanche, le premier membre comporte
mélange les termes liés à i et j. On résout alors ce système un opérateur (avec des dérivées, etc.) que l’on ne peut pas
de manière auto-cohérente : on choisit d’abord un en- commuter avec la fonction d’onde8 .
[0]
semble de fonctions d’onde d’essai ϕi (~ri ) qui permettent Des théorèmes dûs à Hohenberg et Kohn montrent que
de calculer les termes Ji,j . Cela permet de résoudre le si, dans l’approximation de Born-Oppenheimer, on écrit
système d’équations qui donne de nouvelles fonctions l’Hamiltonien comme
[1] [1]
ϕi (~ri ) et des valeurs des énergies εi . De nouvelles va-
leurs de Ji,j sont alors calculées puis de nouvelles fonc- H = Te + Vee + Vext
[2]
tions ϕi (~ri ) et ainsi de suite jusqu’à ce que les solutions 7 à ne pas confondre avec l’autre DFT, la discrete Fourier trans-
trouvées n’évoluent plus. form.

8 Parce que l’opérateur dérivation, par exemple, s’applique à ce
6 il
n’est pas question ici de détailler ces méthodes, mais seulement qui se trouve à sa droite et non à ce qui se trouve à sa gauche :
∂ ∂ ∂
d’en donner a flavor, un parfum, comme disent les anglo-saxons. f ∗ (x) ∂x f (x) 6= f ∗ (x)f (x) ∂x = |f (x)|2 ∂x .
où l’on a décomposé en énergie cinétique des électrons en tenant compte, par exemple, de la déformabilité des
(Te ), énergie potentielle d’interaction électron-électron nuages électroniques en fonction des positions de noyaux.
(Vee ) et interaction électrons-noyaux (Vext ), les deux pre- Leur gros défaut est que, même s’il existe des méthodes
miers termes ne dépendent que du nombre d’électrons, ils de calcul efficaces, ces méthodes sont terriblement voraces
sont pour ainsi dire universels. Le dernier terme dépend en temps de calcul !
des noyaux et donc du système étudié. L’énergie de l’état Ainsi des ordres de grandeurs réalistes seraient :
fondamental peut alors s’écrire comme une fonctionnelle9
<
de la densité électronique N ∼ 300
Z
E(ρ) = F (ρ) + ρ(~r)Vext (~r)d~r τ ≃ 1ps
Malgré ces défauts, elles ont leurs lettres de noblesse,
où F (ρ) regroupe les deux premiers termes universels et ρ par exemple, les phases à haute pression de la glace (liai-
son hydrogène) ou la silice vitreuse. Ces méthodes font
est la densité électronique -que l’on cherche- de l’état fon-
damental. Pour obtenir ρ, il faut alors chercher la fonction l’objet de programmes, soit commerciaux, soit libres, qui
ρ qui rend E(ρ) minimum avec, bien sûr, la contrainte que se répandent assez rapidement dans les laboratoires pour
Z devenir des outils relativement standards.
ρ(~r)d~r = N Cependant, comme on l’a vu, ces méthodes se limitent
à l’état électronique fondamental. . . lorsqu’on veut s’atta-
le nombre d’électrons dans le système. quer à des états excités, pour comparer les calculs avec des
La petite difficulté qui subsiste et que l’expression de expériences de spectroscopies diverses, il existe d’autres
F (ρ), bien qu’universelle, est inconnue ! (c’est quelque méthodes plus complexes et plus coûteuses encore en res-
chose comme < ψ|Te + Vee |ψ > mais le but de l’opération sources de calcul ! Autant dire que c’est un domaine dans
était justement d’ignorer les fonctions d’ondes). lequel la recherche est active en ce début du XXIe siècle. . .
La méthode de Kohn et Sham10 consiste à réaliser que,
puisque ce qui nous intéresse est la densité électronique
et non les fonctions d’onde, n’importe quel jeu de fonc-
tions d’onde qui donne la même densité électronique
est acceptable ! Ainsi, on remplace un système de N
électrons en interaction par N autres particules fictives
mais indépendantes ; chacune de ces particules fictives est
soumise à un potentiel effectif qui contient le potentiel
extérieur Vext et l’effet des électrons. On en arrive à une
théorie similaire à celle de Hartree-Fock, mais elle n’est
pas le résultat d’une approximation, elle est, jusqu’à ce
point au moins, exacte.
Z
E(ρ) = Ts (ρ) + EH (ρ) + ρ(~r)V (~r)d~r + Exc (ρ)
où Ts est l’énergie d’un système sans interaction, EH

l’énergie de Hartree,
Z Z
1 ρ(~r)ρ(~r′ )
EH (ρ) = d~r d~r′
2 |~r − ~r′ |
Les trois premiers termes peuvent être calculés sans
problème particulier ; toutes les difficultés résident dans le
terme Exc , dit « d’échange et corrélation ». Si on l’oublie,
ce sont les effets quantiques qui disparaissent de la théorie !
En effet, la densité électronique ne fait pas apparaı̂tre ex-
plicitement ces effets11 , il faut les introduire explicitement
« à la main » pour ainsi dire. . . C’est ici que se situent les
approximations de cette théorie : les différentes variantes
(qui s’appellent pour les plus répandues LDA et GGA)
partent en général de l’approximation que ρ(~r) est essen-
tiellement homogène, ou du moins, varie lentement.
Les méthodes ab-initio ne sont donc pas des méthodes
sans hypothèse mais elle permettent néanmoins d’at-
teindre les interactions interatomiques très précisément
9 Une fonctionnelle est une fonction dont la variable est une autre
fonction, E est une fonction de ρ, elle-même une fonction de ~ r.
10 Ces théories datent des années 1960.
11 comme le principe d’exclusion qui rend la fonction d’onde an-
tisymétrique par permutation de deux atomes : cela n’apparaı̂t

évidemment pas explicitement dans la densité électronique.
Chapitre 6
Optimisation de code.
L’optimisation de code n’est certes pas un sujet très ! les constantes sont calculees hors de la boucle
exaltant, surtout que les calculs décrits ci-dessus sont en pi = acos(-1.0)
général rapidement exécutés même sur un PC de puis- iomega = 2*pi*freq*(0.,1.) ! nbr complexe
sance médiocre. Il faut cependant être prudent : si l’on do it = itmin, itmax
ne fait pas attention, on arrive facilement à fabriquer des x = exp(iomega*it*dt)
problèmes très lourds ! Imaginons par exemple que l’on enddo
cherche, par Monte-Carlo-Metropolis, la structure d’un en-
semble de quelques dizaines de milliers d’atomes (un tout on imagine aisément que la seconde sera plus rapide !
petit échantillon) en interaction à diverses température
afin d’obtenir un diagramme de phase : la figure 4.49, 6.2 Utiliser les symétries.
par exemple, représente des journées de calcul. . . Les
méthodes ab-initio décrites dans le paragraphe précédent Le deuxième exemple est un peu plus élaboré : on doit
sont évidemment redoutablement voraces ! Il faut donc uti- calculer, par exemple pour une simulation Monte-Carlo
liser des méthodes de programmation efficaces afin d’en l’énergie potentielle d’un ensemble d’atomes en interac-
réduire autant que possible le coût en ressources information :
tiques. Par exemple, si l’on arrive à optimiser un calcul de 1 X
V = vij (rij )
telle façon qu’au lieu de 24 heures, il n’en prenne que 15, 2
i,j,(j6=i)
non seulement le gain est appéciable dans l’absolu, mais
on peut espérer démarrer un calcul le soir avant de ren- soit sous forme de programme :
trer chez soi pour en récuperer les résultats le lendemain
v = 0.
matin : les ordinateurs sont des machines qui peuvent tra-
do i = 1, n
vailler la nuit sans inconvénient, leurs utilisateurs des hu-
do j = 1, n
mains qui préfèrent dormir. . .
if ( i /= j ) then
Une première précaution à prendre est d’utiliser les op-
rij = sqrt( (x(i)-x(j))**2 + &
tions d’optimisation du compilateur, par exemple avec
(y(i)-y(j))**2 + (z(i)-z(j))**2 )
g95 :
v = v + energie(rij)
g95 -O3 simul.f90 -o simul
endif
où l’option -O3 dit au compilateur de chercher à optimiser
enddo
le code proposé1. Le compilateur néanmoins, même s’il est
enddo
parfois étonnament efficace, ne peut pas tout faire et il est
v = v/2
prudent d’appliquer soi-même quelques règles simples.
ce qui donne n(n − 1) calculs d’énergie à faire. Or, on cal-
cule ici la même énergie deux fois : vij et vji , c’est inutile.
6.1 Éviter les calculs inutiles n(n − 1)
Si l’on s’y prend un peu mieux, il n’y a que paires
2
C’est une consigne qui paraı̂t stupide à première vue, (i, j) : en pratique, le programme ci-dessus fait deux fois
cependant, si l’on compare les deux séquences suivantes : trop de calculs !
Celui qui est donné ci-dessous est nettement meilleur :
! les constantes sont calculees dans la boucle
do it = itmin, itmax do i = 1, n-1
t = i*dt ; pi = acos(-1.0) do j = i+1, n
omega = 2*pi*freq rij = sqrt( (x(i)-x(j))**2 + &
x = exp((0.,1.)*omega*t) ! exp complexe (y(i)-y(j))**2 + (z(i)-z(j))**2 )
enddo v = v + energie(rij)
enddo
et enddo
1 il y a en général plusieurs degrés d’optimisation : -O1, -O2,
Ainsi donc, la simple étude préalable de la symétrie d’un
-O3. Sur un PC avec un processeur Pentium, on peut tenter aussi :
problème permet parfois des gains considérables : point
-mtune=pentium4. Chaque compilateur a ses propres options, plus
ou moins adaptées à tel ou tel processeur : c’est parfois un peu la- n’est besoin de refaire plusieurs fois un calcul qui donnera
byrinthique. . . toujours, pour des raisons de symétrie, le même résultat.
115
6.3 Stocker des résultats intermé- 6.4 Utilisation des caches

diaires. Dit ainsi, cela paraı̂t très savant, toutefois l’idée sous-
jacente est très simple. Un des goulets d’étranglement
Imaginons que nous devions faire le produit de trois
principaux d’un ordinateur est l’échange d’information
matrices n × n :
entre la mémoire vive où est stockée l’information, pro-
D=A·B·C gramme et données, et le processeur où s’effectuent les
soit : calculs. Sur certaines machines, cette communication est
X
di,j = ai,k bk,l cl,j améliorée grâce à du matériel performant, mais ce sont
k,l des technologies coûteuses. Sur la plupart des ordinateur
d’usage courant pour le calcul scientifique, les construc-
ce qui se programme aisément : teurs préfèrent utiliser une « mémoire cache », c’est-à-
do i = 1, n dire un espace mémoire, de plus petite dimension que la
do j = 1, n mémoire vive, très rapide et installée de façon que le pro-
d(i,j) = 0. cesseur n’ait pas besoin de passer par les moyens normaux
do k = 1, n de communication pour y accéder. Ainsi, pour optimiser
do l = 1, n les transferts, au lieu de transmettre les données une à
d(i,j) = d(i,j) + a(i,k)*b(k,l)*c(l,j) une, lorsque le processeur a besoin de quelque chose dans
enddo la mémoire vive, tout un bloc lui est transmis. De cette
enddo façon, les données contigües en mémoire de celle qui est
enddo requise sont également transmises au processeur.
enddo
La conséquence en est que si, idéalement, toutes les
Cela représente quatre boucles de n éléments, soit n4 cal- données nécessaires à l’exécution du programme se trou-
culs à faire. Si n vaut ne serait-ce que 100, on obtient vaient dans ce bloc, il n’y aurait plus besoin que d’une
la bagatelle de 108 (cent millions) de calculs. . . On peut requête au début et une autre à la fin du travail, résultant
cependant prévoir un tableau intermédiaire e(n,n) pour en une accélération considérable du calcul.
stocker le produit B · C. Le produit des trois matrices est Il est évidemment très difficile de faire que toutes
alors décomposé en deux : les données nécessaires soient rangées dans la mémoire
cache, cependant, on peut retenir de ceci qu’il est bon
E = B·C que les données nécessaires soient contigües en mémoire
vive : elle seront ainsi transférées par bloc au processeur
D = A·E
au lieu d’être transférées une à une. Pour faire cela, il
On obtient alors le morceau de programme suivant : suffit de se rappeler que les éléments des tableaux sont
rangés l’un à côté de l’autre en mémoire et que donc
do i = 1, n les transferts de tableaux sont plus efficaces que ceux
do j = 1, n de scalaires : cependant il est très rare que l’on ait à
e(i,j) = 0. transférer des scalaires en très grand nombre et le gain
do k = 1, n est faible : il n’est pas utile de fabriquer artificiellement
e(i,j) = e(i,j) + b(i,k)*c(k,j)
des tableaux pour regrouper des éléments disparates. En
enddo
enddo
revanche, cela a une conséquence très importante pour les
enddo tableaux multi-dimensionnels. Par exemple, en fortran,
do i = 1, n un tableau bidimensionnel x(m,n) est stoké comme suit :
do j = 1, n x(1,1),x(2,1),...,x(m,1),x(1,2),x(2,2),...,
d(i,j) = 0. x(m,2),x(1,3),x(2,3),...,x(m,n)
do k = 1, n c’est-à-dire que « le premier indice va plus vite » (c’est le
d(i,j) = d(i,j) + a(i,k)*e(k,j) contraire en langage C). Donc la séquence :
enddo
enddo do j = 1, n
enddo x(:,j) = .....
enddo
C’est un peu plus compliqué, ça prend plus de mémoire,
mais il n’y a plus que 2 × n3 opérations à faire (soit, dans sera sans doute plus rapide que :
le cas de n = 100, 2 × 106 , deux millions d’opérations, un
gain d’un facteur 50 par rapport au cas précédent !) Si l’on do i = 1, m
regarde d’un peu plus près le premier calcul, on s’aperçoit x(i,:) = .....
que le produit b(k,l)*c(l,j) ne dépend pas de i : or on enddo
refait le même calcul pour toutes les valeurs de i, n fois
puisque, dans le premier cas, le processeur va travailler sur
trop souvent. . . les données dans l’ordre où elles sont rangées en mémoire
En fait, la version qui utilise les tableaux globalement
et le compilateur n’aura aucun mal à optimiser les trans-
s’écrit beaucoup plus facilement : ferts de blocs.
d = matmul(a,matmul(b,c)) Exercice : dans le cas du produit de trois matrices ci-
dessus, constater que l’on ne peut pas appliquer directe-
qui est transparent de ce point de vue, bien que compre- ment ce principe. Introduire un tableau supplémentaire
nant le même nombre de calculs. s(k) qui permette de le faire (pour chaque i, copier
b(i,k) dans s(k) et utiliser s dans le produit, puis faire 6.6 Ne pas réinventer ce qui existe
la même chose pour a).
Évidemment, tout ceci suppose d’entrer un peu dans
déjà
l’architecture de l’ordinateur que l’on utilise, mais l’essen- En général, les bibliothèques de calcul scientifique,
tiel des machines en service actuellement suit peu ou prou quand il y en a, implantées sur un ordinateur donné sont
la même logique et un programme efficace sur un PC a de optimisées pour l’architecture de cette machine. Donc,
bonnes chances de l’être également sur d’autres machines sauf cas particulier, il est souvent plus efficace en termes
(j’ai écrit et optimisé des programmes sur un PC 486 - de temps de calcul (pour ne pas parler du temps de pro-
déjà périmé à l’époque - sous DOS qui se sont révélés très grammation) d’utiliser un sous-programme pris dans une
efficaces sur. . . CRAY, une machine vectorielle de concep- bonne bibliothèque installée par un professionnel que de
tion très différente : seulement l’une et l’autre travaillaient chercher à réinventer la roue. . . De même, en dehors de
efficacement sur les tableaux de nombres contigus). toute considération d’optimisation suivant une architec-
Ce qui est vrai des données l’est aussi pour les instruc- ture donnée, il existe un bagage énorme d’algorithmes ef-
tions du programme. Les instructions qui se suivent dans ficaces qu’il serait stupide de ne pas utiliser : ainsi la FFT
un programme se suivent également en mémoire, mais l’ap- est considérablement plus rapide que :
pel à un sous-programme ou à une fonction brise souvent
cette séquence ce qui produit en général un appel à la do k = 1, n
mémoire vive et donc un ralentissement. Afin de conserver s(k) = (0.,0.)
l’avantage considérable de la programmation structurée do l = 1, n
permise par les sous-programmes et fonctions, les compi- s(k) = s(k) + f(l)*exp((2*pi*i*k*l)/n)
lateurs permettent en général ce que l’on appelle l’« in- enddo
lining », c’est-à-dire qu’ils recopient un sous-programme enddo
beaucoup utilisé directement dans le programme appelant
et un programme de tri suivant un algorithme éprouvé sera
de façon que les instructions se succèdent en mémoire.
vraisemblablement plus efficace, parfois de plusieurs ordres
Donc, si l’on a écrit une structure qui ressemble à :
de grandeur, que ce que l’on aura pu inventer soi-même.
Il est vrai qu’il faut alors enquêter pour savoir ce qui est
do i = 1, beaucoup
disponible sur une machine donnée, les syntaxes d’appel
call machin(arg1,arg2,...)
(nature, type des arguments, etc.). Il faut généralement
enddo
aussi indiquer lors de la compilation que l’on utilise telle
il peut être habile de consulter le manuel du compilateur ou telle bibliothèque : la plupart des compilateurs utilise
utilisé afin de chercher à invoquer l’in-lining. l’option -lnom de la bibliothèque. Par exemple, pour lin-
pack (qui contient des FFT entre autres) :
g95 -O3 machin.f90 -llinpack -o machin
—
6.5 Eviter les interruptions En fin de compte, si malgré tous ses efforts, un pro-
gramme prend à l’exécution un temps prohibitif, il reste
Imaginons un calcul du champ magnétique subi par un
deux possibilités : 1o limiter ses ambitions ou 2o utiliser
spin, dû à tous les autres spins :
une machine plus puissante, ce qui signifie en général
X s’adresser à un centre de calcul disposant d’ordinateurs
~i =
H ~ ij
H puissants et s’attaquer à de la programmation parallèle,
j
j6=i c’est-à-dire utiliser plusieurs processeurs simultanément.
Il faut évidemment éviter le terme i = j qui donnerait

l’infini. On peut imaginer une structure comme :
do i = 1, n
hij(:) = (expression)
h(i) = sum(hij(1:i-1)) + sum(hij(i+1:n))
enddo
ou quelque chose avec where. Toutefois, il est souvent plus

efficace d’écrire :
do i = 1, n
hij(:) = (expression)
hij(i) = 0.
h(i) = sum(hij)
enddo
la somme des hij se fait sans interruption ce qui fait ga-

gner plus de temps que n’en fait perdre l’introduction du
terme nul inutile. Cela dépend parfois du compilateur, du
(ou des) processeur(s), de l’adaptation de l’un et de(s)
l’autre(s) : il vaut parfois la peine de faire quelques essais.
Chapitre 7
Calculs très lourds : vectorisation et

parallélisation
High performance computing ! Calcul scientifique in- avec quatre processeurs en pipe-line, s’exécutera de la
tensif ! Teraflops ! Petaflops ! Exaflops ! Ce sont des façon suivante :
expressions-clefs que l’on voit apparaı̂tre de façon cycle proc 1 proc 2 proc 3 proc 4
récurrente pour dire que l’on calcule toujours plus, sur 1 lit b(1) . . .
des problèmes toujours plus gros. . . Or, si les puissances 2 lit b(2) lit c(1) . .
de calcul des processeurs croissent à une vitesse qui donne 3 lit b(3) lit c(2) b(1)+c(1) .
4 lit b(4) lit c(3) b(2)+c(2) écrit a(1)
le vertige, les besoins en calculs lourds croissent encore
- - - - -
plus vite. De plus, bien des raisons portent à croire que i b(i) c(i-1) b(i-2)+c(i-2) a(i-3)
la limite de ce que l’on peut faire en la matière n’est pas - - - - -
très loin : bien sûr, ce genre de prédiction est vouée à être De cette manière, au i-ième cycle, le premier processeur
démentie d’une façon ou d’une autre, toutefois, l’évolution va chercher en mémoire le i-ième élément de b, le deuxième
des stratégies d’équipement des centres de calcul semble le i-1-ième élémént de c, le troisième fera l’addition des
montrer que cette préoccupation est partagée. i-2-ièmes et le quatrième processeur écrira en mémoire
Une option séduisante est alors d’associer plusieurs le i-3-ième résultat : les quatre processeurs travaillent à
unités de calcul dans un même ordinateur ou de lier 100% ! On réalise aisément que le démarrage et la fin de ce
plusieurs ordinateurs pour qu’ils puissent joindre leurs processus ne seront pas optimum, ce qui fait que ceci n’a
forces sur un problème donné. Par exemple, la plupart des aucun intérêt sur des tableaux de, mettons, 3 éléments. . .
processeurs comportent des unités distinctes spécialisées mais avec des tableaux de quelques milliers d’éléments, on
dans les additions et multiplications de nombres réels. En a quasiment gagné un facteur 4.
général, lorsqu’on soumet une instruction complexe asso- On appelle cela une machine « vectorielle ».
ciant additions et multiplications, ces unités peuvent tra-
Pour tirer partie efficacement d’une telle architecture,
vailler simultanément sur des morceaux différents de l’ins-
l’effort n’est pas énorme : il faut travailler sur des tableaux
truction. On peut toutefois aller beaucoup plus loin.
avec des logiques assez simples, pour ne pas interrompre
le pipe-line. C’est assez similaire à ce qui a été dit du
bon usage des caches. L’expérience prouve qu’en général,
7.1 L’architecture vectorielle un code efficace sur une machine classique, donnera de
L’architecture dite « pipe-line » permet d’associer, pour bonnes perforances sur une machine vectorielle.
ainsi dire « en tuyau » plusieurs processeurs à la suite les La facilité de programmation de ces machines a fait leur
uns des autres qui travaillent en suivant le principe « je succès : certains CRAY des années 1990 en particulier
fais ma petite part de travail et je passe à mon voisin ». avaient des registres de très grande taille capable de sto-
Un exemple élémentaire est tout simplement l’existence de cker un grand nombre d’éléments de tableau afin de tirer
mémoires-tampon : si l’on envoie un texte ou une image parti de la rapidité d’accès aux registres et l’on obtenait
en impression sur une imprimante, celle-ci est très lente aisément ainsi de très bonnes performances de calcul pour
par rapport au processeur de l’ordinateur ; donc en pra-
l’époque.
tique, on envoie la tâche d’impression dans une mémoire
dite « tampon »(ou buffer ) de telle façon que le processeur Ce sont toutefois des technologies coûteuses dont les li-
puisse s’occuper d’autre chose pendant l’impression. Plus mites sont assez vite apparues : on verra ce que l’avenir
sérieusement, lorsqu’on travaille dans une boucle avec des réserve, mais il ne semble plus que cette voie continue à
instructions composites sur des tableaux, chaque proces- être activement explorée par les constructeurs, même si
seur fera quelque chose (une addition par exemple) sur un des ordinateurs comportent une part de vectorisation.
élément du tableau et passera le résultat à son voisin, et
sans attendre que ledit voisin ait fini son travail, passera
à l’élément suivant du tableau. Ainsi, tous les processeurs 7.2 Parallèlisme
travaillent en même temps sur des éléments différents du
tableau. Par exemple, la boucle :
Le parallèlisme consiste à tenter de répartir un cal-
do i = 1, n cul sur plusieurs processeurs différents de façon que les
a(i) = b(i) + c(i) données sur lesquelles ils travaillent soient différentes mais
enddo les instructions exécutées peuvent être identiques (Single
119
Instructions Multiple Data) ou différentes (Multiple Ins- d’autant que les centres de calculs se mettent à en propo-
tructions Multiple Data). En pratique, les problèmes sont ser des centaines, voire des milliers (on commence à parler
différents selon que l’on travaille avec un petit nombre de calculs répartis sur des dizaines de milliers de proces-
de processeurs (ou plutôt de cœurs ; en gros 4 ou 8) qui seurs).
partagent le même espace mémoire (mémoire partagée ou
shared memory) ou un grand nombre de processeurs qui 7.2.2 Mémoire distribuée
utilisent chacun un espace mémoire propre (mémoire dis-
tribuée ou distributed memory) : dans ce cas la commu- Une autre solution consiste à répartir explicitement le
nication entre processeurs se fait par un réseau qui est travail sur les processeurs, tel processeur devant faire tel
généralement optimisé pour ralentir le moins possible les morceau du programme sur telles données, tel autre pro-
calculs. cesseur faisant autre chose sur d’autres données. En an-
glais, on appelle cela Multiple Instructions Multiple Data
ou MIMD. Chaque processeur fait son travail spécifique
7.2.1 Mémoire partagée sur ses données. La difficulté est la synchronisation de
C’est une situation assez fréquente et qui le devient de ce beau monde, car il arrive que ce que doit faire un
plus en plus : un ordinateur contient plusieurs proces- processeur dépende du résultat d’un calcul fait par un
seurs, parfois multi-cœurs qui partagent le même espace autre, sinon, il suffirait de prendre plusieurs ordinateurs
mémoire. On peut alors donner des directives de compila- indépendants qui feraient les calculs séparément. Il existe
tion, c’est-à-dire des instructions au compilateur, du type des bibliothèques de programmes de passage de messages
« parallélise-moi ce morceau de programme », et le com- (comme MPI pour Message Passing Interface) qui per-
pilateur, si on lui donne les bonnes options, parallélise. . . mettent de faire communiquer les processeurs entre eux et
presqu’automatiquement. les forcer à s’attendre les uns les autres pour s’échanger
En pratique on utilise généralement OpenMP (pour les données dont ils ont besoin. Ainsi, dans un pro-
Open MultiProcessing) qui est librement distribué : en gramme, on appelle des sous-programmes de bibliothèque,
fortran cela apparaı̂t comme des commentaires du type : par exemple :
!$OMP PARALLEL call MPI_SEND(....)
ou pour envoyer des données d’un processeur à un autre. En
!$OMP END PARALLEL effet, mettons que l’on soit en train de faire un calcul de
de telle sorte qu’un compilateur « non averti » (c’est-à- type Monte-Carlo-Metropolis, il faut calculer toutes les
dire qui ne connait pas OpenMP ou auquel on n’a pas
interactions i-j, or il faut répartir les atomes entre les
fourni l’option de compilation appropriée) puisse compi-
ler le programme sans tenir compte de ces directives. Au processeurs : un processeur donné doit donc disposer des
contraire, le compilateur qui connait OpenMP va tenir positions de tous les atomes, et non seulement de ceux dont
compte de tout ce qui commence par !$OMP. On écrira il a la charge. En fin de course, il faut additionner toutes
alors des choses comme : les énergies et donc concentrer sur un processeur toutes
les énergies partielles calculées sur tous les processseurs :
!$OMP PARALLEL encore des communications entre processeurs.
do i = 1, n La gestion de ceci par l’utilisateur est plus difficile car il
...
faut gérer explicitement par programme tous ces échanges,
enddo
et équilibrer les charges de travail des processeurs de façon
!$OMP END PARALLEL
à ne pas perdre trop de temps dans les attentes.
et le compilateur répartit la boucle sur les processeurs dis-
ponibles, chacun prenant sa part de données. Il faut ce-
pendant être assez prudent : tous les processeurs utilisent
la même mémoire, il y a donc le risque qu’ils écrasent le
travail de leurs voisins ! Certaines variables peuvent donc
être déclarées comme privées, c’est-à-dire qu’elles sont du-
pliquées en autant d’exemplaires qu’il y a de processeurs,
afin qu’elles soient utilisées indépendamment par chacun :
!$OMP PARALLEL PRIVATE(X, Y, Z)
do i = 1, n
...
enddo
!$OMP END PARALLEL
Cette façon de procéder a l’immense avantage d’être très

simple à mettre en œuvre : très souvent, il suffit de repérer
les quelques boucles du programme qui prennent pratique-
ment tout le temps de calcul, mettre quelques directives
au bon endroit, compiler. . . et on fait travailler huit pro-
cesseurs au lieu d’un : division par huit du temps de res-
titution !
Malheureusement, le monde réel est parfois contrariant :
certains algorithmes s’accomodent mal de ce genre de trai-
tement et l’on peut avoir besoin de plus que 8 processeurs,
Chapitre 8
Quelques éléments de C++
Le langage fortran est « LE » langage de programma-

tion scientifique par excellence : il a été fait pour cela et il // inclure les cha^
ınes de caractères
a constamment évolué depuis les années 1950 pour s’adap- #include <string>
ter. La version actuellement la plus utilisée a été définie
en 1990 et légèrement modifiée en 1995. Les compilateurs // inclure les fonctions mathématiques
#include <cmath>
correspondants sont progressivement apparus à la fin des
années 1990. Une norme 2003 a été définie et de nouveaux Les symboles // indiquent les commentaires sur la fin de
compilateurs devront voir le jour également dans quelques la ligne ; si on veut mettre un commentaire sur plusieurs
années (g95 commence à inclure des aspects 2003 en plus lignes : /* ... */.
de la norme fortran95) : ainsi l’évolution se poursuit. Toujours dans le cadre du « je ne sais rien faire », C++
Toutefois, il y a une maxime importante qui est que : prévoit que l’on puisse avoir envie d’utiliser des noms
« le meilleur outil est celui que l’on maı̂trise bien ». Pour génériques de fonctions pour des usages particuliers, d’où
des raisons diverses, le langage C est largement répandu risque de conflit. On peut donc définir un namespace (ou
et enseigné : or tout ce qui est dit et fait dans le présent espace de noms) particulier pour éviter cela. Sinon (ce qui
polycopié peut être traité en C ; il faut bien sûr lui re- est le cas général), on doit préciser que l’on veut utiliser
connaı̂tre ses lettres de noblesse car le système Unix (et l’espace de noms standard : using namespace std ; (ne
par conséquent Linux) est écrit en C et c’est un succès pas oublier le point-virgule).
remarquable. Le C en tant que langage de programma- Avant donc le début du programme, de toute fonction,
tion scientifique date des années soixante-dix et peut être ou de déclarations, il faut ces directives et cet espace de
considéré comme largement obsolète : le C++ a pris la noms.
suite. Ce développement ne répond cependant pas ou mal S’il n’y a pas de variables globales ou de fonctions, on
aux limitations du C pour ce qui est du calcul scienti- peut alors attaquer le programme principal. Celui-ci s’ap-
fique et fortran95 reste plus commode à l’usage1 , mais pelle toujours main( ) et n’a pas de type ; en fait, on peut
en vertu de la maxime ci-dessus, ceux qui ont une bonne aussi le mettre en int (entier). Le début du programme
maı̂trise du C peuvent vouloir rester dans un monde fa- est marqué par une accolade ouvrante et sa fin par une ac-
milier, d’où les présents Éléments de C++ (qui ne rem- colade fermante. On obtient donc quelque chose qui peut
ressembler à :
placent pas un vrai cours). Ce langage ne manque pas de
charme : il permet des exercices de voltige informatique #include <iostream>
admirables d’élégance quoique souvent. . . périlleux ! #include <fstream>
#include <string>
#include <cmath>
8.1 Avant même de commencer
using namespace std ; // espace de noms standard
Il faut savoir qu’a priori C++ « ne sait rien faire » :
c’est un choix explicite, il faut lui indiquer que l’on a be- // programme principal
main( )
soin de choses aussi élémentaires que les entrées-sorties, les
// accolade : debut du ’bloc’ du programme principal
chaı̂nes de caractères et les fonctions mathématiques stan-
{
dards ! En pratique, tout programme commence donc par cout << "Hello world" << endl ;
des directives au préprocesseur marquées par un # (dièze) : } // accolade : fin du bloc du programme principal
// Directives au préprocesseur
// inclure les entrées-sorties d’écran On notera l’instruction cout d’écriture et sa syntaxe très
#include <iostream> différente de celle du langage C (pour ne pas parler du
fortran. . .). endl signifie end of line (fin de ligne) : il
// inclure les entrées-sorties par fichiers s’agit de passer à la ligne à la fin de l’écriture, ce qui n’est
#include <fstream> pas le mode par défaut, il faut le préciser.
1 Lors d’un colloque, quelqu’un qui simulait des problèmes de com- On notera que toutes les instructions se terminent par
bustion complexe dans des turbines aéronautiques, à qui on deman- un point-virgule ; : C++ ignore les espaces et les sauts
dait si ses programmes étaient en C++, répondit non parce que :
de lignes. Non seulement une même instruction peut être
1o « C++, ça rame ! » (je cite) et 2o on pouvait laisser un nouveau
chercheur intervenir sur un code en fortran au bout de quelques répartie sur plusieurs lignes, mais on peut mettre autant
semaines de formation, ce qui était totalement exclu en C++. . . de sauts de ligne que l’on veut au milieu de l’instruction. . .
121
Ceci se compile de façon très classique par la com- while(condition) {instructions. . .}

mande : et
c++ hello.cpp -o hello do {instructions. . .} while(condition)
le suffixe cpp indiquant qu’il s’agit bien d’un programme
en C++. 8.3.2 Conditions
On a évidemment :
8.2 Déclarations if ( condition ) { instructions. . . } else { instruc-
tions. . . }
Les variables doivent être déclarées : les types de base Attention, pour les habitués du fortran, il n’y a pas de
sont int (entier), float (réel), double (double précision), then. . .
char (caractère) et bool (booléen). En C++ comme Il y a une variante :
en C, le type complexe n’existe pas. Les noms z = ( condition ) ? x : y ;
de variables obéissent aux règles habituelles, seulement, qui équivaut à
C++ distingue entre les lettres majuscules et minuscules if ( condition ) z = x ; else z = y ;
(Resultat est différent de resultat, les mots-clefs du lan- Les conditions s’écrivent sans grande origina-
gage étant en lettres minuscules : float et non FLOAT ou lité : x >= y, y != z (différent de), a == b ou
Float) a < b && y <= u où && signifie et, et ou s’écrit
En revanche les déclarations peuvent être faites n’im- ||.
porte où dans le programme à condition que ce soit
1o avant la première utilisation et 2o dans le même bloc.
Ainsi, dans le programme suivant qui comporte une boucle 8.3.3 Sauvegardes
faisant varier la variable entière step de 1 à 100 :
Si l’on veut écrire des résultats dans un fichier, il faut
#include <iostream> l’ouvrir, écrire, puis le fermer : ce n’est pas bien original,
#include <fstream> par exemple,
#include <string>
// ouverture du fichier Calcul.res
#include <cmath>
ofstream fichier("Calcul.res") ;
using namespace std ;
for( int i = 0 ; i < i_max ; i++)
fichier << i<< " " << x[i] << endl ; // écriture
main( )
fichier.close() // fermeture
{
/* déclaration de 2 nombres réels
pour tout le programme */
float t, dt=0.1 ;
8.4 Tableaux
// boucle et déclaration de step 8.4.1 Tableaux de taille fixe
for ( int step = 1; step <= 100; step++ ) Il n’y a ici rien de très original :
{ t = step*dt ; cout << t << endl ; }
// fin de la boucle et fin du ’bloc’ où step est défini #include <iostream>
#include <fstream>
/* si on met ici une référence à step, #include <string>
ça ne marchera pas ! */ #include <cmath>
// cout << step << endl ; // donc, NE PAS décommenter ! using namespace std ;
}
int main( )
la variable step n’est déclarée que pour la boucle qui /* la taille du tableau doit ^etre définie
constitue le bloc pour lequel elle est déclarée. Si on es- par une constante entière */
saie de compléter le programme en ajoutant la ligne { int const n=100 ;
cout << step << endl ; entre l’accolade qui termine float x[n] ; // déclaration du tableau
la boucle et l’accolade finale, on obtiendra une erreur
à la compilation. Le début et la fin de la boucle sont for ( int step = 0; step < n; step++ )
évidemment marqués par les accolades. { x[step] = step ; cout << x[step] << endl ; }
}
On notera néanmoins quelques points importants : 1o on

8.3 Structures de base diverses ne peut pas délimiter les tableaux comme on veut (par
exemple x[-5:5] n’est pas permis), car on se borne à
8.3.1 Boucles donner le nombre d’éléments du tableau, et 2o le premier
On a déjà vu : élément du tableau est l’élément zéro (les bornes de la
for ( int i = debut ; i < fin ; i++ ) {instruc- boucle sont, dans l’exemple ci-dessus, 0 et 99, soit n-1).
tions. . .} Les tableaux à plusieurs dimensions existent, ce
où debut et fin sont des entiers. sont simplement des tableaux de tableaux (on omettra
dorénavent dans les exemples les préliminaires #include
On peut aussi écrire des choses comme
et using) :
for ( float x=x_min ; x<=x_max ; x=x+dx ) { ins-
tructions. . .} int main( )
ou encore { int const n = 10, m = 5 ;
float x[n][m] ; // tableau de tableau où, pour gagner de l’espace mémoire, on programmait par-
fois en assembleur, des souvenirs d’écrans devenus soudai-
for ( int step = 0; step < n; step++ ) nement tous noirs, ou d’ordinateurs qu’il fallait débrancher
{ du secteur pour les redémarrer ensuite, tout simplement
for ( int i = 0 ; i < m ; i++ ) parce qu’un pointeur dans un de mes programmes était
{
allé écraser une adresse mémoire réservée au système d’ex-
x[step][i] = step+pow(i,3.2) ;
cout << step << " " << i << " "
ploitation. . . La chasse à l’erreur, dans ces conditions, était
<< x[step][i] << endl ; un exercice requérant une acuité intellectuelle supérieure
} et dans lequel la fameuse loupe de Sherlock Holmes était
} un ustensile indispensable !
} C’est à ce genre de délices que C++ nous convie. . . Il
est sans doute inutile de préciser que, quand on a le choix
Noter au passage 1o les deux boucles imbriquées, entre utiliser un tableau comme ci-dessus, et un pointeur,
2o l’usage correspondant des accolades ainsi que 3o la on a tout intérêt à utiliser le tableau. Il arrive toutefois
façon d’éviter qu’à l’écriture tous les chiffres soient ac- bien souvent que l’on n’ait pas le choix.
colés, en insérant des espaces et enfin 4o que la mise à la Concrétement, imaginons que nous ayons déclaré une
puissance du fortran (x**y) n’existe pas plus en C++ variable, scalaire pour commencer, par exemple, par :
qu’en C : il faut utiliser la fonction pow. float x ;
Finalement, C++ ne connait pas la manipulation Son adresse dans la mémoire vive s’écrit alors : & x
globale de tableaux : toutes les boucles doivent être Déclarons alors une variable de type pointeur à l’aide de
écrites explicitement, et les fonctions intrinsèques du type l’astérisque * :
sum, dot product ou matmul sont absentes. float * px ; // déclaration d’un pointeur
On note que le type de la variable vers laquelle on pointe2
est fourni, afin de donner le nombre d’octets qu’elle va oc-
8.4.2 Les pointeurs : premiers pas cuper dans la mémoire. On peut alors écrire :
Les pointeurs font le charme sulfureux du langage C : px = & x ;
ils permettent d’éblouissantes acrobaties et autorisent l’ar- L’adresse de x est stockée dans le pointeur px. Pour don-
tiste à donner libre cours à toute sa virtuosité. . . Ils sont ner la valeur 1.414 à x, il y a maintenant deux façons de
aussi la source de bugs particulièrement retors ! À mani- procéder :
puler avec une certaine prudence, donc. x = 1.414 ; // méthode classique
ou alors on stocke 1.414 à l’adresse pointée par px
Dans le principe, cependant, c’est assez simple.
*px = 1.414 ;
Il faut savoir qu’un tableau -dans n’importe quel lan-
Évidemment, dans le cas simple montré ici, la première
gage, y compris fortran- est un pointeur masqué. Un lan-
est de loin préférable. Imaginons cependant la séquence
gage comme le fortran est fait de telle sorte que l’usage suivante :
explicite de pointeurs est en général inutile, dans le but
évident de simplifier la vie de celui (ou celle) qui écrit les float x; // variable réelle
programmes. En C et C++, au contraire, tout est fait float * px ; // pointeur vers une variable réelle
pour que toutes les potentialités de ces objets puissent
px = & x ; /* initialisation du pointeur sur
être utilisées.
l’adresse de x */
Les pointeurs, c’est une vieille histoire, du moins à px = px + 1 ; /* incrémentation du pointeur de quatre
l’échelle de l’histoire de l’informatique. En assembleur, octets : variable suivante */
il n’y a pas de tableau, or un tableau, c’est simplement *px = 1.414 ;
un ensemble de cases dans la mémoire vive, rangées les
unes derrière les autres dans l’ordre. Ainsi, pour définir un on a placé la valeur 1.414 dans une nouvelle case mémoire
tableau, on doit fournir 1o l’adresse du premier élément, située 4 octets (soit un réel) après x : il vallait mieux être
2o le type de variable, c’est à dire en pratique le nombre sûr qu’il n’y avait là rien de vital ! On réalise alors que l’on
d’octets occupé par un élément (4, 8 voire 16) et 3o le peut, en quelque sorte, se promener en toute liberté dans
nombre d’éléments. C’est ce que l’on fait quand on déclare la mémoire vive de son ordinateur et y faire toutes sortes
un tableau. L’adresse du p-ième élément du tableau est de choses exaltantes. . .
donnée par :
8.4.3 Tableaux dynamiques
adresse du premier element+ On a vu précédemment que pour déclarer un ta-
bleau statique, il fallait que la taille du tableau soit une
(p − 1)(nombre d’octets par element) constante : cela signifie que cette valeur ne peut pas être
modifiée à l’exécution du programme ; en fait elle doit
En assembleur, alors qu’on ne dispose pas de tableau, pouvoir être établie à la compilation. Ainsi, même si la
c’est exactement cela qu’on fait : on définit une variable déclaration du tableau est faite au milieu des instructions
spéciale, appelée pointeur qui contient l’adresse du pre- exécutables (c’est permis), sa taille est prédéterminée lors
mier élément du tableau, variable que l’on incrémente de de l’écriture du programme, on ne peut pas, par exemple,
la quantité voulue pour accéder aux éléments du tableau. l’entrer au clavier. En fortran, on répond à cette ques-
Quand ça marche, ça marche très bien : j’en témoigne tion par des tableaux allocatable ; en C++, on utilise
bien volontier ! Quand ça ne marche pas. . . c’est une autre un pointeur-tableau :
histoire ! J’ai des souvenirs douloureux datant de l’époque 2 ça, c’est un progrès sensible par rapport à l’assembleur. . .
int main( )
{ int main( )
// variable qui doit contenir la taille du tableau {
int n ; cout << machin(5) << endl ;
// saisie de n }
cout << " Entrer la taille du tableau : " ; cin >> n ;
// déclaration du tableau dynamique // définition de la fonction après son appel
float * x = new float[n] ; int machin(int i)
for ( int i = 0; i < n; i++) {
{ return 3*i+1 ;
x[i] = i*i ; cout << x[i] << endl ; }
}
}
8.5.3 Passage d’arguments par valeur
Ici, la taille n du tableau est une vraie variable que l’on Imaginons que l’on tente de modifier la valeur de l’ar-
entre au clavier à la demande (voir au passage la syntaxe gument i dans la fonction :
de la saisie au clavier). Le tableau disparaı̂t dès que l’on
sort du bloc où il a été défini (dans cet exemple, c’est le #include <iostream>
programme principal, donc il ne disparaı̂t qu’au moment #include <fstream>
de la fin du programme). #include <string>
#include <cmath>
8.5 Fonctions
int machin(int) ;
C++ n’a pas le concept de subroutine, il faudra donc int main( )
utiliser quelques astuces ; de plus, les fonctions doivent être { int j = 5 ;
cout << j << " " << machin(j) << " " << j << endl ;
définies avant d’être utilisées sauf si l’on définit un proto-
}
type.
int machin(int i)
8.5.1 Une fonction très simple {
i = 3*i+1 ; // ici, la variable i est modifiée
Voici un exemple élémentaire : return i ;
#include <iostream> }
#include <fstream>
ce programme répond : 5 16 5, autrement dit, la variable
#include <string>
#include <cmath> j du programme principal n’est pas modifiée par la fonc-
using namespace std ; tion machin, alors que le calcul s’effectue bien dans la fonc-
tion. C’est que l’argument j est passé « par valeur » : la
/* début de la fonction entière machin valeur de j est transmise à la fonction, mais j n’est pas
avec un argument entier */ modifiée.
int machin(int i)
{
return 3*i+1 ; // calcul de la valeur de la fonction 8.5.4 Passage d’arguments par référence
} // fin de la fonction Le passage par référence consiste à passer la variable
comme une valeur de pointeur, c’est-à-dire une adresse
int main( ) // programme principal qu’on ne peut pas modifier, alors que la la valeur vers
{ laquelle on pointe peut, elle, être modifiée :
cout << machin(5) << endl ; // appel de la fonction
} //prototype avec passage par référence
int machin( int &) ;
La fonction est définie avant le programme principal qui
l’appelle. int main( )
{ int j = 5 ;
cout << j << endl ; // écriture de j initial
8.5.2 Prototype
cout << machin(j) << endl ; /* écriture de la valeur
Le prototype permet de ne définir la fonction qu’après de la fonction */
son appel, il consiste simplement en une déclaration du cout << j << endl ; } // écriture de j modifié
type de la fonction et des types de ses arguments, ainsi :
// fonction avec passage par référence
#include <iostream> int machin(int & i)
#include <fstream> {
#include <string> i = 3*i+1 ;
#include <cmath> return i ;
using namespace std ; }
/* prototype de la fonction machin : Cet exemple répond

elle est de type entier et a un argument entier */
int machin(int) ; 5
16 Babar : 120.32
16 Céleste : 180.25
La variable j a bien été modifiée. L’intérêt est bien sûr de Définissons maintenant une fonction dans la classe :
généraliser ceci à plusieurs variables afin d’obtenir quelque
chose qui ressemble à une subroutine : class client
{
// prototype (type void) public :
void machin( float &, float &, float &) ; string nom ;
float montant ;
int main( ) void client_print() ; // fonction dans la classe
{ float p = 5, q =6, r ; } ;
cout << p << " " << q << endl ;
machin(p,q,r) ; // p, q, et r sont modifiés void client :: client_print() /* définition de la
cout << p << " " << q << " " << r << endl ; fonction : elle est de type void et se réfère à la
} classe client. Noter le :: */
{
// fonction de type void (c’est-à-dire, sans type) cout << nom << " : " << montant << endl ;
void machin(float & a, float & b, float & c) } ;
{ //---------------------------------------
a = a/2 ; b = 3*a- b ; c = a + b ; int main()
} {
client a, b ;
a.nom = "Babar" ; a.montant = 120.32 ;
8.6 Les classes b.nom = "Céleste" ; b.montant = 180.25 ;
C’est la grande nouveauté introduite par C++ par rap- // l’impression est devenue plus simple
port à C et c’est ce qui ouvre la voie vers la programmation a.client_print() ;
orientée objet. En pratique, l’idée est très proche de celle b.client_print() ; // noter la syntaxe
des types dérivés du fortran95, mais c’est conçu assez }
différemment. Les classes peuvent contenir des fonctions
et des opérateurs, ce qui les différencient des structures Puisque le type complex n’existe pas en C++,
(struct) du C. Voici une classe élémentaire : fabriquons-le. Il faut à la fois définir le type (c’est un objet
composé de deux nombres réels, les parties réelle et ima-
#include <iostream> ginaire), des fonctions spécifiques (extraire la partie réelle
#include <fstream> ou la partie imaginaire, par exemple) et des opérations
#include <cmath> (addition, produit, etc.). Pour commencer, quelque chose
#include <string> de simple :
class complex // Definition de la classe complex
class client // définition de la classe {
{ public :
/* ces variables sont publiques // parties réelles et imaginaires
et donc accessibles de l’extérieur */ float RealPart, ImagPart ;
public : void Zprint() ; // fonction
string nom ; } ;
float montant ; /* client comporte donc
une chaine et un réel */ void complex :: Zprint() // fonction pour imprimer
} ; // attention, ici il y a un point-virgule {
cout << "(" << RealPart << "," << ImagPart << ")" ;
//-------------------------------------------- }
int main() //--------------------------------------------------
{ int main()
// déclaration de deux variables de type client {
client a, b ; complex z1 ;
// initalisation du nom du client a z1.RealPart = 1. ; z1.ImagPart = 2. ;
a.nom = "Babar" ; z1.Zprint(); cout << endl ;
/* initialisation du montant de la transaction }
pour le client a */
Il n’y a ici rien de nouveau. D’ailleurs ça répond :
a.montant = 120.32 ;
b.nom = "Céleste" ; // idem pour b (1,2)
b.montant = 180.25 ;
Maintenant, il faut définir des opérateurs d’addition et de
cout << a.nom << " : " << a.montant << endl ; multiplication :
cout << b.nom << " : " << b.montant << endl ;
} class complex
{
public :
Noter comment on accède aux composantes des variables. float RealPart, ImagPart ;
Après exécution, ce programme répond : void Zprint() ;
// Définition des opérateurs

complex operator + (const complex & a) // Addition
{
complex z ;
z.RealPart = RealPart+a.RealPart ;
z.ImagPart = ImagPart+a.ImagPart ;
return z ;}
complex operator * (const complex & a) // Multiplication

{
complex z ;
z.RealPart = RealPart*a.RealPart-ImagPart*a.ImagPart;
z.ImagPart = RealPart*a.ImagPart+ImagPart*a.RealPart;
return z ;}
} ;
void complex :: Zprint() // fonction pour imprimer

{
cout << "(" << RealPart << "," << ImagPart << ")" ;
}
//---------------------------------------------------
int main()
{
complex z1, z2, z3 ;
z1.RealPart = 0. ; z1.ImagPart = 1 ;
z2.RealPart = 0. ; z2.ImagPart = 2 ;
z3 = z1+z2 ; // somme de deux complexes

cout << "Somme : " ; z1.Zprint() ;
cout << "+" ; z2.Zprint() ; cout << "=" ;
z3.Zprint(); cout << endl ;
z3 = z1*z2 ; // produit de deux complexes

cout << "Produit : " ; z1.Zprint() ;
cout << "*" ; z2.Zprint() ; cout << "=" ;
z3.Zprint(); cout << endl ;
}
C’est assez subtil : les opérateurs (a priori binaires) ne

prennent qu’un argument. Ainsi par exemple, quand on
veut faire la somme des parties réelles, on fait la somme
de RealPart qui est considéré comme déjà résident en
mémoire et de a.RealPart qui est la partie réelle de l’argu-
ment. C’est un peu comme en assembleur, quand on écrit
ADDA $10C3, soit « additionner le contenu du registre A
(déjà chargé) avec le contenu de la mémoire $10C3 ».
Ça répond :
Somme : (0,1)+(0,2)=(0,3)
Produit : (0,1)*(0,2)=(-2,0)
Il « ne reste plus qu’à » définir soustraction et division, et

les fonctions complexes diverses (norme, conjugué, expo-
nentielle, etc.)
Le langage C++ est évidemment beaucoup plus riche

que ce qui est indiqué ici : le but de ce chapitre n’est
évidemment que de montrer la « philosophie » du lan-
gage. . .
Chapitre 9
La question du calcul formel.
Des logiciels comme Maple ou Mathematica sont des a*x+b=0

20
2
outils très puissants permettant de faire du calcul formel 0
−2
à l’aide d’un ordinateur. Quelle place ces outils tiennent-ils 60 −20
par rapport au calcul numérique tel qu’il a été développé 40
20
dans ce cours ? La réponse évidente est que l’on entreprend 0
un calcul numérique lorsque le calcul formel ne donne pas −20
−40
les résultats escomptés, cependant comme les démarches −60
de l’un et de l’autre sont assez différentes, il est bon de 4
préciser ce que l’on entend par là. 2
−4 0
−2 −2 b
0
a 2 −4
4
9.1 Calcul formel, calcul numé-
Fig. 9.1 – Résultat de la résolution numérique de
rique : quelle différence ? l’équation ax + b = 0 par la méthode de la dichotomie.
Imaginons un exemple simpliste où l’on cherche à
résoudre l’équation :
la plus marquante du résultat. L’allure du graphe obtenu
ax + b = 0 dépend aussi fortement du pas de l’échantillonnage choisi.
Les points singuliers ne sont d’ailleurs pas repérés expli-
N’importe quel élève de 4ème sait (en principe) comment citement -on se demande comment- mais simplement sont
il faut procéder : entourés de zones où x prend, en valeur absolue, des va-
leurs « grandes ». Le résultat formel montre sans am-
ax + b = 0
biguı̈té que la divergence est en 1/a ce qui n’a aucun ca-
ax + b − b = −b ractère d’évidence dans le cas des résultats numériques ; on
ax + 0 = −b peut toutefois avoir l’idée de tracer, non pas x(a, b) mais
ax b le produit a × x(a, b), qui donnerait une constante ce qui
= − permet de dire, de même, que ça diverge comme 1/a1 .
a a
b Ainsi, résolution formelle et résolution numérique d’un
x = −
a même problème donnent des résultats assez différents. . .
Autrement dit, il faut faire quelques manipulations for-
melles de l’expression (retrancher b des deux cotés du signe
égal, diviser des deux cotés par a, faire les simplifications 9.2 Quelques exemples
qui s’imposent) pour obtenir la solution qui s’écrit : x =
une expression. Les logiciels de calcul formel font cela : ils 9.2.1 ax + b = 0
manipulent des symboles en appliquant les règles formelles
de l’algèbre. Des logiciels de calculs formels comme Maple ou Mathe-
La force de cette façon de procéder est qu’elle est matica sont souvent capables de faire les deux ; avec Maple
générale : la solution obtenue de la sorte est valable pour par exemple :
n’importe quel couple de nombres a et b. solve(a*x+b=0,x) ;
Si l’on cherche à résoudre la même équation b
−
numériquement, par la méthode de la dichotomie ou par la a
méthode de Newton, le résultat sera un tableau de valeurs est la résolution formelle de l’équation, alors que :
de x pour un échantillonnage de valeurs prises par a et b, f := (a,b)->fsolve(a*x+b=0,x) ;
que l’on peut représenter sur un graphe comme la figure
9.1. f := (a, b) → fsolve(a x + b = 0, x)
Même si le graphe a des vertus esthétiques que n’a pas
la formule, on retrouve toutes les difficultés déjà évoquées plot3d(f,-5..5,-5..5) ;
au chapitre 4.4 : si l’intervalle de recherche choisi pour a et
b n’est pas bien choisi, on risque de ne pas voir les points 1 La simplicité de notre exemple est un peu trompeuse, car il fau-
singuliers pour a = 0, ce qui est pourtant la caractéristique drait supposer que l’on ne connait pas la solution analytique.
127
Ce n’est pas très digeste, alors essayons d’arranger un

peu le résultat :
expand(%) ;
(1/3)
%1 4ab 4 a2 2a
− (1/3)
+ (1/3)
+
3RT %1 3 R T %1 3 RT
2 2 2 2 3
%1 :=
r −36 a b R T + 27 a b R T + 8 a +
24 a b
3ab − + 81 b2 R2 T 2
RT
en est la résolution numérique2. On notera au passage la on n’a pris que la dernière des trois solutions, et :
différence (subtile) entre les commandes solve et fsolve simplify(%) ;
qui est illustrée ci-dessous :
solve(cos(x)=0,x) ; %1(2/3) − 12 a b R T + 4 a2 + 2 a %1(1/3)
1
π 3 R T %1
(1/3)
2
fsolve(cos(x)=0,x) ; %1 := a − 36 a b R T + 27 b2 R2 T 2 + 8 a2 +
r !
1.570796327 √ b (8 a − 27 b R T ) 2 2
3b 3 − R T
dans le premier cas, Maple « sait » que la solution3 de RT
l’équation cos x = 0 est l’ensemble de symboles 12 π, alors
que dans le deuxième, il calcule la valeur numérique de la même remarque.
solution : ce n’est pas du tout la même opération, car il On a ici un pur produit du calcul formel automatique :
est probable qu’alors (même si Maple n’explicite pas ses le temps de calcul est très rapide, et la résolution de
méthodes) une méthode du type dichotomie est utilisée. l’équation de degré trois sans difficulté, mais le plus délicat
est d’obtenir des expressions utilisables par un humain ;
dans notre cas particulier, on a du mal à choisir parmi
9.2.2 Le gaz de Van der Waals les trois solutions, les deux qui donnent l’allure classique
Un gaz de Van der Waals est défini par l’équation d’état des isothermes de Van der Waals que l’on trouve dans
suivante tous les livres de thermodynamique. Si l’on veut travailler
a
(p + 2 )(v − b) = RT numériquement avec les expressions ci-dessus, Maple peut
v les traduire en fortran pour être introduites dans un
Imaginons que l’on cherche les extrema de la pression en programme sans avoir à tout recopier à la main !
fonction du volume. On entre donc l’expression de la pres-
sion :
p := R*T/(v-b)-a/v**2 ; 9.2.3 Modèle de Brillouin-Weiss
RT a Voyons maintenant un exemple plus sophistiqué :
p := − 2 on montre que l’aimantation d’une substance ferro-
v−b v
magnétique (dans l’approximation du modèle de Brillouin-
que l’on dérive par rapport au volume :
Weiss) est donnée par l’équation :
diff(p,v) ;
RT 2a Tc M M
− + 3 tanh( )=
(v − b)2 v T M s M s
et l’on veut que cette dérivée soit nulle : où Ms est l’aimantation à température nulle et Tc la
solve(%,v) ; température au-dessus de laquelle l’aimantation est nulle.
(1/3) On peut tenter de résoudre cette équation à l’aide de
%1 4 a (−3 b R T + a) 2a Maple, afin d’obtenir une expression de l’aimantation M
+ (1/3)
+ ,
3RT 3 R T %1 3 RT en fonction de la température T . Cela donne :
(1/3)
%1 2 a (−3 b R T + a) 2a solve(tanh(Tc/T*M/Ms)=M/Ms,M)
− − (1/3)
+ +
6RT 3 R T %1 3 RT
! 2
(1/3) RootOf( Z T (e Z )2 + Z T −Tc (e Z )2 +Tc)
1 √ %1 4 a (−3 b R T + a) Ms e −1
I 3 − (1/3)
,
2 3RT 3 R T %1 2
(1/3) eRootOf( Z T (e Z )2 + Z T −Tc (e Z )2 +Tc) + 1
%1 2 a (−3 b R T + a) 2a
− − (1/3)
+
6RT 3 R T %1 3 RT! On n’est guère plus avancé : « RootOf » signifie « ra-
√ (1/3)
1 %1 4 a (−3 b R T + a) cine de » autrement dit, Maple ne sait pas répondre à la
− I 3 −
2 3RT 3 R T %1(1/3) question. Tentons donc une résolution numérique, en nous
%1r := a (−36 a b R T + 27 b2 R2 T 2 + 8 a2 + plaçant pour simplifier dans un système d’unités dans le-
3 b (8 a − 27 b R T ) 2 2 quel Ms = 1 et Tc = 1 :
3b − R T ) f :=T->fsolve(tanh(M/T)=M,M) ;
RT
2 On a commencé par définir une fonction de deux variables M
f := T → fsolve(tanh( ) = M, M )
f (a, b), puis on a demandé un graphe tri-dimensionnel. T
3 Au passage, on notera qu’il ne donne qu’une solution, alors qu’il
y en a une infinité. . . plot(f,0..1) ;

9.2.4 Le projectile
1
0.5 Imaginons un projectile se déplaçant dans l’air et

soumis, outre à son poids, à une force de trainée
0 0.2 0.4 0.6 0.8 1
aérodynamique proportionnelle à v 2 :
f~traine = −Kv 2 v̂ = −Kv~v

–0.5
où v̂ est le vecteur unitaire parallèle à ~v . Les équations du

–1
mouvement s’écrivent :
On obtient la solution nulle. . . C’est exactement comme
mẍ = −Kvvx
lorsqu’on cherche à résoudre un problème à l’aide de la
mz̈ = −mg − Kvvz
méthode de la dichotomie ou Newton ! Reformulons alors
le problème pour éliminer cette solution nulle : soit : 
g :=T->fsolve(tanh(M/T)/M=1,M) ; 
 K p
ẍ = − ẋ ẋ2 + ż 2
m
   K p
M  z̈ = −g − ż ẋ2 + ż 2
tanh( ) m
 T = 1, M
g := T → fsolve  
M
9.2.4.1 Maple
Ceci se traduit en Maple par :
plot(g,0..1) ; eq1 := diff(x(t),t$2)=-k/m*diff(x(t),t)
sqrt(diff(x(t),t)**2+diff(z(t),t)**2) ;
–0.2
q
∂ ∂ ∂
∂2 k ( ∂t x(t)) ( ∂t x(t))2 + ( ∂t z(t))2
–0.4
eq1 := 2 x(t) = −
∂t m
–0.6
eq2 := diff(z(t),t$2)=-g-k/m*diff(z(t),t)
–0.8
sqrt(diff(x(t),t)**2+diff(z(t),t)**2) ;
q
∂ ∂ ∂
–1
0 0.2 0.4 0.6 0.8 1 ∂2 k ( ∂t z(t)) ( ∂t x(t))2 + ( ∂t z(t))2
eq2 := 2 z(t) = −g −
C’est mieux, mais on préfèrerait une solution positive ; im- ∂t m
posons alors le domaine de recherche des solutions (entre
dsolve({eq1,eq2},{x(t),z(t)}) ;
0 et 1) :

h :=T->fsolve(tanh(M/T)/M=1,M,0..1) ;  Z Z Z
2
z(t) = RootOf t− 1/RootOf − f m
  
M
tanh( ) Z
 T = 1, M, 0..1 Z
f m2 (3 m2 c 3 + 9 m2 g c 2 − 2 f 4 g k2 + 2 m2 g3 + 8 m2 g2 c)
h := T → fsolve   − d c Z2
M c 3 (5 m2 g c 2 − f 4 g k2 + m2 g3 + 4 m2 g2 c + 2 m2 c 3 )
 (
!

− C1 Z 2 d f + C2 dt + C3 ,
plot(h,0..1) ; 
1 Z p
(m g + %1 − k ( ∂ z(t))2 ) (m g + %1 + k ( ∂ z(t))2 )
∂t ∂t
x(t) = dt + C1 ,
( ∂ z(t)) k
0.8
Z p ∂t )
(m g + %1 − k ( ∂ z(t))2 ) (m g + %1 + k ( ∂ z(t))2 )
∂t ∂t
x(t) = − dt + C1
0.6 ( ∂ z(t)) k
∂t
2
%1 := m ( ∂ z(t))
0.4 ∂t2
0.2
C’est plutôt indigeste (même réduit), mais on retrouve
le célèbre « RootOf » qui signifie que Maple ne sait pas
0 0.2 0.4 0.6 0.8 1
résoudre le problème !
Essayons numériquement :
Cela a bien l’allure attendue de l’aimantation en fonction
g :=9.81 ;
de la température avec la transition de phase pour T = Tc .
g := 9.81
En revanche, on constate deux choses : 1o Maple ne sait
résoudre formellement que les problèmes qui ont une solu- k := 1 ;
tion analytique, 2o le calcul numérique effectué par le logi- k := 1
ciel n’est pas magique : la procédure suivie et les difficultés
rencontrées sont les mêmes que lors du calcul numérique m := 1 ;
fait avec un programme personnel, Maple apporte simple- m := 1
ment le fait qu’il n’est pas besoin de programmer soi-même inc :={x(t),z(t)} ;
la recherche de zéro, ainsi que la convivialité de l’interface
graphique incorporée. inc := {x(t), z(t)}
0.9
condini :=x(0)=0,z(0)=0,D(x)(0)=10,D(z)(0)=10 ;
0.8
condini := x(0) = 0, z(0) = 0, D(x)(0) = 10, D(z)(0) = 10 0.7
0.6
s :=dsolve({eq1,eq2,condini },inc,type=
numeric) ; 0.5
z
0.4
s := proc(rkf45 x ) . . . end 0.3
0.2
fx := u->subs(s(u),x(t)) ;
0.1
fx := u → subs(s(u), x(t)) 0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8
x
fy := u->subs(s(u),z(t)) ;
fy := u → subs(s(u), z(t)) Fig. 9.2 – Trajectoire du projectile z(x).
plot(’[fx(t),fy(t),t=0..10]’,x=0..2,y=-0.01..1) ;
est le pas de temps utilisé, 3o la syntaxe (les subs en par-
1
ticulier) n’est pas particulièrement limpide. On admettra

0.8 sans grande difficulté que pour un problème simple comme
celui-ci, ces défauts ne sont sans doute pas rédhibitoires.
0.6
0.4 9.2.4.3 Octave
On notera que l’on n’a utilisé finalement que les

0.2
capacités numériques de Maple et non les propriétés
de calcul symbolique. Ainsi, un logiciel comme Oc-
0 0.2 0.4 0.6 0.8 1 1.2 tave (sensiblement moins coûteux, puisque gratuit. . . voir
1.4 1.6 1.8 2
x
http ://www.octave.org) ferait parfaitement l’affaire.
On obtient sans surprise que le projectile n’a pas une Les commandes (placées dans un fichier de commandes
trajectoire parabolique (qui serait symétrique par rapport exécutable) ci-dessous permettent de résoudre le même
à l’apogée). problème :
9.2.4.2 Fortran
#! /usr/bin/octave -qf
Il est aisé de vérifier à l’aide de quelques lignes de pro-
function proj = f(x,t)
gramme que l’on obtient la même chose par les moyens
habituels : k = 1 ; m = 1 ; g = 9.81 ;
proj(1)=x(3); # 2 eqs du 2nd ordre
program projecti proj(2)=x(4); # donnent 4 eqs du 1er
implicit none proj(3)=-k/m*x(3)*sqrt(x(3)**2+x(4)**2);
real :: t, dt, vx, vz, x, z, w, c, gdt proj(4)=-k/m*x(4)*sqrt(x(3)**2+x(4)**2)-g;
real :: k = 1., m = 1., g = 9.81 ! parametres endfunction
integer :: step, nstep x0=[0;0;10;10]; # conditions initiales
dt = 0.001 ! pas de temps
t = linspace(0,2,200);# intervalle de temps
nstep = 10./dt ! nombre de pas
c = k/m*dt ; gdt = g*dt ! constantes
# et nbr de pas
x=0.; z=0.; vx = 10.; vz = 10.; t = 0. ! cond. init. x=lsode("f",x0,t); # resolution
open(1,file=’project.res’) gset nokey; # commandes gnuplot
write(1,*) t, x, z, vx, vz gset yrange[0:1]; gset xrange[0:2];
do step = 1, nstep ! verlet gset xlabel ’x’; gset ylabel ’z’;
t = step*dt gset title ’fait avec Octave’
w = 1.-c*sqrt(vx*vx+vz*vz) plot(x(:,1),x(:,2));
vx = vx*w ; vz = vz*w-gdt pause ;
x = x + vx*dt ; z = z + vz*dt gset term post color ; # fichier postscript
write(1,*) t, x, z, vx, vz
gset output ’projectile_oct.ps’ ;
if ( z < 0. ) exit
replot ;
enddo
close(1)
end
On obtient, évidemment, une fois de plus la même figure
Ce qui donne la figure 9.2. (fig. 9.3).
En termes de convivialité, Maple s’en sort plutôt bien Les commentaires en termes d’absence de choix de l’al-
grâce au graphisme intégré. Il a toutefois des défauts de gorithme seraient les mêmes qu’avec Maple. L’avantage
plusieurs ordres : 1o on n’a pas la maı̂trise de l’algorithme par rapport au programme fortran est la possibilité d’in-
utilisé (probablement Runge-Kutta), 2o on ne sait pas quel clure dans la liste des commandes graphiques.
fait avec Octave

1
! programme pour calculer les trajectoires de n
! asteroides qui tournent autour d’une planete,
! par exemple, Saturne
0.8
!
implicit none
0.6
integer :: n, i, j, step, nstep, iprint
z
parameter( n = 500 ) ! nombre d’asteroides

0.4 ! positions, vitesses & masses
double precision :: r(n,3), vr(n,3), m(n)
0.2 logical :: ok ! variable logique multi-usage
double precision :: xij, yij, zij, rijsq, fijr, &
0 fijx, fijy, fijz, f(n,3), fij, g, v, k, ms, dt, rij
0 0.5 1 1.5 2
x
!
parameter( g = 1.0, ms = 1.0 ) ! constante de
! gravitation & masse de la planete
Fig. 9.3 – Trajectoire du projectile z(x) obtenu à l’aide
!
d’Octave.
! initialisations
!
9.2.5 Une « grosse » simulation : les an- ! verifier le fichier de config
inquire(file=’saturn.cnf’,exist=ok)
neaux de Saturne. if( .not. ok ) stop &
Les sondes interplanétaires américaines Voyager ’Il faut d’’abord creer le fichier de configuration’
(http://voyager.jpl.nasa.gov/) ont pris des pho- !
! lire la configuration initiale
tos magnifiques des anneaux de Saturne montrant des
open(1,file=’saturn.cnf’)
structurations complexes qui ont plongé les astronomes
read(1,*) r, vr, m
(et les non-astronomes aussi) dans l’émerveillement close(1)
(voir, par exemple http://pds.jpl.nasa.gov/planets/ !
welcome/saturn.htm ). Le problème physique sous-jacent ! verifier le fichier de parametres
est, du moins dans le principe, d’une simplicité biblique ! inquire(file=’saturn.inp’,exist=ok)
Il y a n astéroı̈des en interaction gravitationnelle avec if( .not. ok ) stop &
Saturne et entre eux. En supposant que Saturne est ’Il faut d’’abord creer le fichier de parametres’
beaucoup plus lourd que les astéroı̈des, les équations du !
mouvement s’écrivent sans complication majeure : ! lire les parametres de simulation
open(1,file=’saturn.inp’)
Gms mi X Gmi mj ! nombre de pas, intervalle d’impression
mi~r̈ i = − 2 r̂i − 2 r̂ij , i, j ∈ [1, n] read(1,*) nstep, iprint
ri rij
j (j6=i) read(1,*) dt ! pas de temps
close(1)
avec des notations banales4 , et où l’on n’a introduit
que des interactions gravitationnelles. Ce système n’est Il faut ensuite prévoir des fichiers pour stocker les résultats
évidemment pas aisé à résoudre analytiquement : il s’agit de la simulation : un fichier de positions où seront inscrits
de 3n équations différentielles du second ordre, non- les ~ri (t), la liste des positions des astéroı̈des au cours du
linéaires, couplées. . . mais l’algorithme de Verlet peut trai- temps ; c’est a priori un fichier qui risque de se révéler assez
ter ce genre de problème sans difficulté. volumineux, donc pour gagner du temps il sera binaire5 .
Un autre fichier sert à garder l’énergie : celle-ci étant un
invariant du mouvement, il sera prudent de vérifier après
9.2.5.1 Un programme de simulation. coup qu’il en est bien ainsi !
Dans l’exemple de programme qui suit (écrit en for-
!
tran77) on a considéré 500 astéroı̈des dans le champ de ! fichier de positions (binaire)
gravitation de Saturne (considéré comme beaucoup plus open(1,file=’saturn.pos’,form=’unformatted’)
lourd que les astéroı̈des et immobile). Les conditions ini- !
tiales sont fixées dans un fichier dit « de configuration open(2,file=’saturn.ener’) ! fichier d’energie
initiale » produit par un autre programme d’initialisa-
tion ; on a d’ailleurs prévu de tester l’existence de ce fichier puis on démarre la simulation à proprement parler. Il y a
(instruction inquire). De même, un fichier de paramètres une boucle sur le temps, évidemment, et à chaque pas de
de simulation (nombre de pas d’intégration, intervalle temps, on doit calculer les forces qui s’appliquent à chaque
astéroı̈de : d’abord la force exercée par Saturne, puis les
d’écriture des résultats, valeurs du pas d’intégration) est
forces exercées par tous les autres astéroı̈des, compte tenu,
également lu : on n’a aucune information à fournir au cla- bien sûr, du principe de l’action et de la réaction ! On no-
vier ; pour un programme susceptible de tourner plusieurs tera au passage, l’introduction d’une interaction répulsive
heures d’affilée, voire plusieurs jours, il n’est pas inutile en r−12 à très courte portée destinée à tenir compte très
de conserver sous forme de fichiers, une mémoire des pa- approximativement des collisions entre astéroı̈des : ces col-
ramètres de la simulation. lisions sont considérées comme élastiques dans ce cas, ce
qui est d’un réalisme douteux, mais on pourrait choisir
program saturn autre chose.
! 5 cela fait gagner le temps de conversion binaire (en machine) vers
4 la notation r̂ désigne le vecteur unitaire parallèle à ~
r. ASCII et réciproquement à la lecture.
! ! ecrire tous les IPRINT pas les positions

! simulation ! et l’energie du systeme
! if (mod(step,iprint) == 0 ) then
! la grande boucle commence ici write(1) r
do step = 1, nstep ! pour pouvoir verifier l’invariance de l’energie
! forces & energie potentielle write(2,*) step*dt, v, k, v+k
! endif
v = 0. ! initialisation de l’energie potentielle enddo
! ! la grande boucle s’arrete ici
! d’abord s’occuper de Saturne !
do i = 1, n close(1); close(2)
xij = r(i,1); yij = r(i,2) ; zij = r(i,3) end
rijsq = xij*xij + yij*yij + zij*zij
! fijr est fij/rij Il n’y a rien de bien exotique dans ce programme. . . et l’on
fijr = -g*m(i)*ms/(rijsq*sqrt(rijsq)) notera qu’il suffit de changer une instruction pour aug-
f(i,1) = fijr*xij menter ou diminuer le nombres d’astéroı̈des concernés :
f(i,2) = fijr*yij ça ne changera guère que le temps d’exécution et le vo-
f(i,3) = fijr*zij lume occupé par les fichiers de résultats ! Comme il s’agit
v = v + fijr*rijsq d’un programme très simple, il n’est pas divisé en sous-
enddo programmes : l’usage en la matière est plutôt d’isoler la
!
partie « Verlet » dans un sous-programme, le calcul des
! calculer les forces inter-asteroide et sommer
! les bornes des boucles tiennent compte de ce
forces et de l’énergie potentielle dans un autre, etc.
! que fji = -fij (action et reaction), donc
! on ne prend que les j > i 9.2.5.2 La conservation de l’énergie.
do i = 1, n-1
do j = i+1, n La figure 9.4 montre l’intérêt qu’il peut y avoir à sur-
xij = r(i,1)-r(j,1) veiller l’énergie du système. . . qui ne se conserve pas,
yij = r(i,2)-r(j,2) contrairement à ce que voudraient les lois de la mécanique
zij = r(i,3)-r(j,3) newtonienne !
rijsq = xij*xij + yij*yij + zij*zij
rij = sqrt(rijsq)
! forces gravitationnelles & terme repulsif
fij = -g*m(i)*m(j)/rijsq + 1.e-30*rij**-13
fijr = fij/rij
fijx = fijr*xij
fijy = fijr*yij
fijz = fijr*zij
!
f(i,1) = f(i,1) + fijx
f(i,2) = f(i,2) + fijy
f(i,3) = f(i,3) + fijz
! le principe d’action et de reaction s’applique
f(j,1) = f(j,1) - fijx ! ici
f(j,2) = f(j,2) - fijy
f(j,3) = f(j,3) - fijz
! energie potentielle
v = v - g*m(i)*m(j)/rij &
Fig. 9.4 – Energies potentielle (en rouge), cinétique (en
+ 0.083333333333333d-30*rij**-12
vert) et totale (en bleu) dans la simulation des anneaux
enddo
enddo de Saturne.
!
! fin du calcul des forces et Les unités de temps et d’énergie de cette figure sont des
! de l’energie potentielle unités « réduites » données par le choix de G et de la masse
! de Saturne, l’un et l’autre fixés à un. Dans ce système
! verlet commence ici d’unités, le pas d’intégration temporel est de δt = 10−4 ,
do j = 1, 3 et il y a 10000 pas pour ce « run » d’essai. La durée
do i = 1, n d’exécution dépend évidemment de la puissance de l’ordi-
vr(i,j) = vr(i,j) + f(i,j)*dt/m(i) nateur utilisé : sur un PC à 500MHz, il a fallu 15mn, or le
r(i,j) = r(i,j) + vr(i,j)*dt
système n’a guère eu le temps, dans ses unités de temps à
enddo
lui, d’évoluer sensiblement (on le voit par la faible varia-
enddo
! verlet finit ici tion de l’énergie potentielle), il faudra faire des simulations
k = 0. ! energie cinetique beaucoup plus longues. . . (voir la table 9.1).
do i = 1, n Il faut toutefois d’abord régler cette question de la
k = k + & (non)conservation de l’énergie : une simulation qui viole
m(i)*(vr(i,1)**2 + vr(i,2)**2 + vr(i,3)**2) ainsi un principe fondamental de la physique doit obli-
enddo gatoirement avoir une raison valable pour le faire ! La
k = 0.5*k première hypothèse qui vient à l’esprit est que le pas
verge pour r → 0 et que donc, lorsque deux objets s’ap-

Tab. 9.1 – Comment faire tourner des programmes qui prochent de très près, on peut s’attendre à une brusque
durent longtemps ? accélération de leur mouvement nécessitant alors un pas
— d’intégration sensiblement plus court. On a déjà par-
Lorsqu’on fait de grosses simulations, il peut être gênant de mo- tiellement traité cette difficulté en ajoutant un poten-
biliser un ordinateur plusieurs heures, voire plusieurs jours d’af- tiel répulsif en 1 qui représente le « cœur dur » des
r 12
filée : on peut avoir envie de consulter son courier électronique,
astéroı̈des (figure 9.5). Reste donc à traiter de la même
éditer un texte, tracer une courbe. . . Le système Unix/Linux
façon les interactions entre la planète Saturne elle-même
permet de faire tourner des programmes longs en tâche de fond,
sans gêne pour les autres activités. Il s’agit de lancer une tâche et les astéroı̈des, compte tenu du fait que la planète est
avec une faible priorité tout en « gardant la main » pour faire beaucoup plus grosse.
autre chose en même temps ; or Unix est un système d’exploi-
tation multitâche, c’est-à-dire que le temps du processeur est
hâché en petites séquences très courtes et les différents pro-
grammes en cours d’exécution se partagent ce temps. Ainsi,
par exemple, lorsqu’un programme mouline tranquillement des
nombres en tâche de fond, si on appuie sur une touche du cla-
vier, le programme est interrompu afin que le processeur puisse
traiter ce nouvel événement, puis redémarre ensuite.
Il y a plusieurs façons de d’y prendre :
1. mogroprog &
où le symbole & rend la main sur la fenêtre concernée.
C’est exactement comme lorsqu’on tape une instruction
comme emacs machin.f &, la fenêtre n’est pas monopo-
lisée par emacs.
2. nohup mogroprog &
donne le même résultat sinon que nohup (no hang up)
empêche l’arrêt de l’exécution du programme si l’on se
déloggue. Ainsi, on peut lancer le programme, puis clore la Fig. 9.5 – Energie potentielle gravitationnelle en − r1 (en
session, rentrer chez soi et revenir le lendemain pour voir −30
ce que le programme a fait pendant ce temps. . . Un autre rouge), et celle en − 1r + 10r12 (en vert). Il est aisé de calculer
utilisateur qui aurait ouvert une autre session entre-temps qu’avec 500 astéroı̈des et un rayon d’orbite moyen r = 1,
peut très bien ne pas s’apercevoir qu’il y a quelque chose la distance moyenne entre deux astéroı̈des est un peu plus
qui tourne en même temps que ses propres applications ! grande que la distance à laquelle le terme répulsif com-
3. at 2 mence à intervenir : les astéroı̈des sont donc « presque »
mongroprog au contact, du moins au début de la simulation si on les
^D place sur un cercle.
c’est l’exécution différée : dans l’exemple ci-dessus, le pro-
gramme mongroprog démarrera à 2 heures du matin. Le
symbole ^D représente la touche contrôle (Ctrl) mainte- On obtient ainsi un résultat assez satisfaisant (figure
nue enfoncée en même temps que la touche d : cela permet 9.6) : les énergies potentielles et cinétiques varient en sens
de marquer la fin de la séquence d’instructions concernées opposés, la somme restant constante. Il faudrait ensuite
par le lancement différé. bien sûr optimiser le pas d’intégration afin de conserver la
4. batch constance de l’énergie totale tout en réduisant autant que
mongroprog possible le nombre de pas d’intégration nécessaire pour
^D obtenir les événements recherchés.
le résultat est similaire à nohup, mais c’est plus commode
si l’on veut faire faire plusieurs choses à la suite :
batch
mongroprog
traite result
rm -f temp junk file*
grocalcul
^D
d’intégration choisi est trop grand : il faudrait donc

le réduire. Cependant, réduire le pas d’intégration est
coûteux en temps de calcul (puisque, plus le pas est pe-
tit, plus il faut faire de pas pour une même longueur de
simulation) et les variations de l’énergie n’interviennent
que de temps en temps : quelques événements rares per-
turbent le déroulement de la simulation et il paraı̂t dom-
Fig. 9.6 – Évolution temporelle des énergies après intro-
mage d’augmenter sensiblement le temps de calcul pour
duction du terme répulsif.
quelques événements indisciplinés.
Il faut se rappeler que l’interaction gravitationnelle di-
9.2.5.3 Utilisation des résultats.

Lorsqu’on a fait une simulation comme celle-ci et que
l’on a vérifié qu’elle se comportait de telle façon que l’on
puisse être raisonnablement convaincu que « ça marche »,
le plus gros travail reste à faire. Il faut en effet commen-
cer à faire de la physique avec l’outil que l’on a fabriqué :
la première idée est de faire un film, représenter à l’aide
d’outils graphiques appropriés l’évolution temporelle du
système, les trajectoires des particules au cours du temps.
Mais comment suivre 500 trajectoires (ou plus) simul-
tanément ? Il y a alors un travail de réflexion théorique à
faire du type « dans ce problème quelles sont les grandeurs
physiques pertinentes ? ». Ici, on peut, par exemple, calcu-
ler la distribution des distances des astéroı̈des à Saturne,
ceci en fonction du temps. Si des anneaux se forment,
cette distribution doit présenter des pics marqués pour
les rayons des anneaux.
De fait, dans la simulation présentée ici, cette distribu-
tion devient très rapidement continue sans aspérité remar-
quable : pas d’anneaux, donc. Que faudrait-il faire pour
en obtenir ? Il semblerait qu’à ce jour (chercher le mot-
clef saturn sur internet ou voir J. Burns, D. Hamilton et
M. Showalter, Pour la science, Avril 2002, p. 78) la dy-
namique des anneaux reste encore un peu mystérieuse :
on invoque l’effet des satellites plus massifs de Saturne
ou celui des chocs inélastiques entre astéroı̈des et encore
le champ magnétique de la planète. . . Il y a donc là des
découvertes à faire !
9.3 Que peut-on en conclure ?

La diversité des problèmes que l’on peut traiter par
des moyens numériques est énorme, il n’y a donc pas de
réponse unique à cette question. En outre les habitudes des
chercheurs sont très variables : deux personnes différentes
attaqueront sans doute le même problème différemment,
sans que l’on puisse toujours dire a priori lequel a rai-
son. Le meilleur outil est d’abord celui que l’on maı̂trise
et dans bien des cas, fortran, C, Maple ou Octave sont
interchangeables, autant utiliser alors le plus simple.
Les cas extrêmes sont d’une part le calcul qui a une so-
lution analytique : le logiciel de calcul formel est alors
irremplaçable ; de l’autre, la grosse simulation du type
« anneaux de Saturne » lourdement consommatrice de
temps de calcul : les logiciels sophistiqués (et gourmands
en ressources, CPU et mémoire) ne feront que rendre le
problème infaisable, alors qu’un langage de programma-
tion simple permet de limiter les dégâts. Entre les deux,
règne un continuum : à chacun de tenter de s’y retrouver !
—
Le but du présent cours est donc de donner quelques
points de repères pour tenter de permettre à chacun de
faire des choix informés : joyeuses computations à tous. . .
Chapitre 10
Bibliographie.
1. J. Bass, Cours de mathématiques, Masson (1956)

2. B. P. Demidovich, I. A. Maron, Computational Ma-
thematics, MIR (1973), trad. angl. G. Yankovsky,
MIR (1987)
3. W. H. Press, S. A. Teukolsky, W. T. Vetterling,
B. P. Flannery, Numerical Recipes in Fortran Cam-
bridge University Press (1986, 1992, . . .)
4. D. Taupin, Probabilities data reduction and error ana-
lysis in the physical sciences, les Editions de Physique
(1988)
5. M.P. Allen, D.J. Tildesley, Computer simulation of
liquids Oxford (1990)
6. J. F. Kerrigan, Migrating to Fortran90, O’Reilly
(1993)
7. J. R. Shewchuk, An Introduction to the conju-
gate gradient method without the agonizing pain,
www.cs.cmu.edu/~jrs/jrspapers.html (1994)
8. L. Sainsaulieu, Calcul scientifique Masson (1996)
9. T. Pang, An introduction to Computational Physics,
Cambridge University Press (1997)
10. B. W. Kernighan, D. M. Ritchie, Le langage C, Mas-
son (1997)
11. Ph. Depondt, Physique numérique, Vuibert (1998)
12. J. M. Thijssen, Computational Physics, Cambridge
University Press (1999)
13. Ch. Guilpin, Manuel de calcul numérique appliqué,
EDP Sciences (1999)
14. Y. Epelboin, Cours de méthodes numériques pour la
physique, http://physp6www.cicrp.jussieu.fr (2001)
15. J.-J. Chattot, Computational Aerodynamics and
Fluid Dynamics, Springer (2002)
16. K. Protassov, Analyse statistique des données
expérimentales, EDP Sciences (2002)
17. I. Danaila, F. Hecht, O. Pironneau, Simulation
numérique en C++, Dunod (2003)
18. M. Metcalf, J. Reid, M. Cohen, Fortran 95/2003 ex-
plained, Oxford University Press (2004)
19. J.-P. Demailly, Analyse numérique et équations diffé-
rentielles, EDP Sciences (2006)
20. Collectif, Dossier Pour la Science La modélisation in-
formatique, exploration du réel, (juillet/septembre
2006), voir également http://interstices.fr
21. W. Krauth Statistical mechanics : Algorithms and
Computations, Oxford University Press (2006)
135

Ph. Depondt - Physique Numérique

Transféré par

Droits d'auteur :

Formats disponibles

Ph. Depondt - Physique Numérique

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Ph. Depondt - Physique Numérique

Transféré par

Droits d'auteur :

Formats disponibles

La boı̂te à outils

2 Notions pratiques de FORTRAN95. 15

4.11.1 Processus stochastiques et chaı̂nes de Markov. . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

5 Introduction à la simulation numérique 97

6 Optimisation de code. 115

7 Calculs très lourds : vectorisation et parallélisation 119

8 Quelques éléments de C++ 121

9 La question du calcul formel. 127

est l’ExaFlops : 1018 flops. . . derrière. »

Sur l’histoire de l’informatique, on se reportera avec

Ph. Breton Histoire de l’informatique, La

1.1.2 . . . et quelques exemples.

clients avait l’avantage d’être largement solvable, un encouragement (1991).

latrices rapides et fiables ! et ses oies.

1.2 Plan succinct.

Notions pratiques de FORTRAN95.

1 2 3 4 150 151 200 201 220

Tab. 2.2 – Suite de la table 2.1

5 et non un traitement de texte, dont les fonctionnalités (mise en

page, correction orthographiques, effets divers) sont infiniment plus l’exécution6 !

être disponible comme faisant partie de certaines distributions 14 compilateur ibm.

a = b + c ce module tournent sous linux.

Ceci n’est pas un = sous-répertoires présents dans un répertoire. On peut créer un

a = b ou des nombres complexes :

dement le relais de la forme fortran77 : real a, b, c, également

L’affectation de valeurs initiales à certaines variables

2.3.2 Pratiquement. . . 2.3.3 Boucles imbriquées

case(’m’,’metres’) program racines

2.5 Entrées-sorties. 2.5.2 Les fichiers.

write(*,*) ’x’ Ainsi, on fait le lien entre le fichier resultats et l’unité

open(10, file=’donnees’) 2.5.3 Les formats.

2.6 Les fonctions intrinsèques. 2.7 Autres boucles.

integer, dimension(1:25,-2:2) :: a integer :: i

Nom Type Description

Tab. 2.8 – Quelques fonctions de manipulation globale de tableaux.

« au vol », ou plutôt, dynamiquement dans le jargon real :: s

la fonction bsom est complètement indépendante de ce qui end

x = a + b ! a partir d’ici c’est un 2.12.2 Opérations sur les chaı̂nes

donnera Bon dans c puisque l’on prend les caractères de

program prod_test program ratio ! programme principal

-Exercice : étudier le fonctionnement des cshift dans function ratmul(q1,q2) result(q3)

Cinq minutes de réflexion permettent cependant de

integer function fact(n)

La deuxième version est plus efficace parce que la première

Après cette première partie, on constate donc que le

3.1 Introduction. 3.2.1 De la multiplication des insectes.

3.2 L’équation logistique. 3.2.2 Étude préalable.

Prenons, par exemple, le cas r = 2 et partons de x0 = program logistic

un essai, la comparaison avec ce qu’on attend doit être

de quoi ?) et les conditions du calcul précisées (ici la r=3

La figure 3.3 montre l’évolution de la population d’in- 0.662

sectes pour quatre valeurs de r. 0.66

– pour r = 4 le système semble se comporter de 0.35

Une étude plus poussée permettrait peut-être de vérifier

On peut aussi préférer, à une étude du chaos d’un point

d(Vg + Ve ) avec x2 + y 2 = 1. On tomberait alors sur un polynôme de degré 8

où se trouve le zéro et à refaire la même recherche. On

write(*,*) ’Intervalle mal choisi’ −0.4

dicho = x On constate, sans véritable surprise, que plus c (ou la

write(,) ’x’ Ainsi, on fait le lien entre le fichier resultats et l’unité

write(,) ’Intervalle mal choisi’ −0.4