PHQ405 A4

MÉTHODES NUMÉRIQUES
et SIMULATIONS
PHQ 405
David Sénéchal
Département de physique
Faculté des sciences
Université de Sherbrooke
19 janvier 2014
2
Table des matières
1 Rappels de programmation scientifique 9

1.1 Approche numérique aux problème physiques . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2 Représentation des nombres sur ordinateur . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.1 Nombres entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.2 Nombres à virgule flottante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.3 Erreurs d’arrondi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Programmation par objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3.1 Types fondamentaux en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3.2 Exemple d’objet : vecteurs en trois dimensions . . . . . . . . . . . . . . . . . . . . . 13
1.3.3 Avantages de la programmation par objet . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.4 Foncteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.4 Autres outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.4.1 Environnement de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.4.2 Serveurs de calcul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.4.3 Visualisation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2 Équations différentielles ordinaires 19

2.1 Méthode d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.1.1 Précision de la méthode d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.1.2 Stabilité de la méthode d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.1.3 Méthode prédicteur-correcteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2 Méthode de Runge-Kutta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2.1 Méthode du deuxième ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2.2 Méthode du quatrième ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2.3 Contrôle du pas dans la méthode de Runge-Kutta . . . . . . . . . . . . . . . . . . . 23
2.3 Exemple : Mouvement planétaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.1 Solution du problème de Kepler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.4 Autres méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.4.1 Méthode de Richardson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.4.2 Méthode d’Adams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5 Simulation de particules : méthode de Verlet . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.5.1 Exemple : impact d’un objet sur un solide . . . . . . . . . . . . . . . . . . . . . . . . 30
2.5.2 Complexité algorithmique des simulations de particules . . . . . . . . . . . . . . . 30
2.5.3 Aspects quantiques et statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3 Représentations des fonctions 33

3.1 Différences finies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.1.1 Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.1.2 Cubiques raccordées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.1.3 Intégration suite à une interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.2 Polynômes orthogonaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.2.1 Polynômes orthogonaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3
Table des matières
3.2.2 Quadratures gaussiennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3.2.3 Polynômes orthogonaux classiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.3 Transformées de Fourier rapides . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.3.1 Transformées de Fourier discrètes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.3.2 Algorithme de Danielson et Lanczos (ou Cooley-Tukey) . . . . . . . . . . . . . . . . 47
3.3.3 Cas des dimensions supérieures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.3.4 Fonctions réelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.3.5 Annexe : Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4 Problèmes aux limites 53

4.1 Éléments finis : dimension 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.1.1 Base de fonctions tentes en dimension 1 . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.1.2 Solution d’un problème aux limites en dimension 1 . . . . . . . . . . . . . . . . . . 55
4.1.3 Calcul du laplacien en dimension 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.1.4 Exemple : équation de Helmholtz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.2 Éléments finis : dimension 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.2.1 Triangulations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.2.2 Fonctions tentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2.3 Évaluation du laplacien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.3 Méthodes spectrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.3.1 Bases de polynômes orthogonaux et fonctions cardinales . . . . . . . . . . . . . . . 65
4.3.2 Quadratures de Lobatto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.3.3 Exemple : problème aux limites en dimension 1 . . . . . . . . . . . . . . . . . . . . . 68
4.3.4 Conditions aux limites périodiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5 Équations aux dérivées partielles dépendant du temps 71

5.1 L’équation de diffusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.1.2 Évolution directe en dimension un . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.1.3 Méthode implicite de Crank-Nicholson . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.1.4 Méthode du saute-mouton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
5.1.5 Application basée sur une représentation spectrale . . . . . . . . . . . . . . . . . . 75
5.2 Propagation d’une onde et solitons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.2.1 Équation d’advection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.2.2 Équation de Korteweg-de Vries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
5.2.3 Solitons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5.2.4 Solution numérique de l’équation de Korteweg-de Vries . . . . . . . . . . . . . . . . 80
6 Méthodes stochastiques 83
6.1 Nombres aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.1.1 Distribution uniforme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.1.2 Méthode de transformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.1.3 Méthode du rejet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.1.4 Méthode du rapport des aléatoires uniformes . . . . . . . . . . . . . . . . . . . . . . 87
6.2 Méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.2.1 Motivation : modèle d’Ising . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.2.2 Exemple simple : calcul de l’aire d’un disque . . . . . . . . . . . . . . . . . . . . . . . 91
6.2.3 Intégrales multi-dimensionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
6.2.4 L’algorithme de Metropolis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
6.3 Analyse d’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
6.3.1 Théorème de la limite centrale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
6.3.2 Analyse logarithmique des corrélations . . . . . . . . . . . . . . . . . . . . . . . . . . 96
6.4 Simulation du modèle d’Ising avec l’algorithme de Metropolis . . . . . . . . . . . . . . . . 97
6.4.1 Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.4.2 Changements de phase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
6.5 Simulations de particules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
7 Dynamique des fluides 103
4
Table des matières
7.1 Équations fondamentales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

7.1.1 Équation de Navier-Stokes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
7.1.2 Équation de Boltzmann . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.2 Méthode de Boltzmann sur réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
7.2.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
7.2.2 Le schéma D2Q9 : dimension 2, 9 vitesses . . . . . . . . . . . . . . . . . . . . . . . . 107
7.2.3 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
7.3 Simulation de l’écoulement d’un plasma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
7.3.1 Description de la méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
8 Équations non linéaires et optimisation 115

8.1 Équations non linéaires à une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
8.1.1 Cadrage et bissection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
8.1.2 Méthode de la fausse position . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8.1.3 Méthode de la sécante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8.1.4 Méthode de Newton-Raphson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
8.2 Équations non linéaires à plusieurs variable . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
8.2.2 Méthode itérative directe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.3 Optimisation d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.3.2 Méthode de Powell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
8.3.3 Méthode du simplexe descendant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
8.4 Lissage d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.4.1 Méthode des moindres carrés et maximum de vraisemblance . . . . . . . . . . . . 122
8.4.2 Combinaisons linéaires de fonctions de lissage . . . . . . . . . . . . . . . . . . . . . 123
8.4.3 Lissages non linéaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.5 La méthode du recuit simulé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
A Opérations matricielles 129

A.1 Systèmes d’équations linéaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
A.1.1 Système général et types de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
A.1.2 Élimination gaussienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
A.1.3 Décomposition LU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
A.1.4 Système tridiagonal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
A.1.5 Matrices creuses et méthode du gradient conjugué . . . . . . . . . . . . . . . . . . . 132
A.2 Valeurs et vecteurs propres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
A.2.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
A.2.2 Méthode de Lanczos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
A.3 Décomposition en valeurs singulières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
B Calcul Parallèle 141

B.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
B.1.1 Loi d’Amdahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
B.2 Parallélisation avec openMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
B.3 Parallélisation avec MPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
C Codes 147
C.1 Classe de vecteurs de longueur quelconque . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
C.2 Classe de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
C.3 Autres codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
5
Table des matières
6
Liste des programmes
1.1 Classe de vecteurs en 3D : Vector3D.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.2 Programme principal utilisant la classe Vector3D . . . . . . . . . . . . . . . . . . . . . . . 16
2.1 Méthode de Runge-Kutta : fichier maître pour la solution du problème de Kepler . . . . 25
3.1 Filtre passe-bas (FFT.cpp) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
5.1 Résolution de l’équation de diffusion 1D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
6.1 Générateur de nombres aléatoire : Random.h . . . . . . . . . . . . . . . . . . . . . . . . . . 84
B.1 Exemple élémentaire de parallélisation avec openMP . . . . . . . . . . . . . . . . . . . . . 144
B.2 Exemple élémentaire de parallélisation avec MPI . . . . . . . . . . . . . . . . . . . . . . . 145
C.1 Classe Vector.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
C.2 Classe de matrices Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
C.3 Classe de matrices creuses : SparseMatrix.h . . . . . . . . . . . . . . . . . . . . . . . . . 162
C.4 Méthode de Runge-Kutta : RK.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
C.5 Méthode de Verlet : MD_solver.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
C.6 Programme principal associé : MD.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
C.7 Intégration gaussienne d’ordre 7 : Gauss_Legendre.h . . . . . . . . . . . . . . . . . . . . 178
C.8 Éléments finis en dimension 1 : maillage1D.h . . . . . . . . . . . . . . . . . . . . . . . . . 179
C.9 Programme principal, calcul des premiers modes propres : Helmholtz1D.cpp . . . . . . . 181
C.10 Éléments finis en dimension 2 : maillage2D.h . . . . . . . . . . . . . . . . . . . . . . . . . 183
C.11 Programme principal pour la solution de l’équation de Laplace : Laplace2D.cpp . . . . 188
C.12 Fonctions cardinales collocation.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
C.13 Classe de fonctions cardinales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
C.14 Résolution de l’équation de KdeV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
C.15 Classe d’observables statistiques : observable.h . . . . . . . . . . . . . . . . . . . . . . . . . 195
C.16 Classe de modèle statistique : Ising.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
C.17 Programme principal : Ising.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
C.18 Simulation du plasma 1D (plasma.cpp) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
C.19 Recuit simulé (recuit.cpp) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
7
Table des matières
8
1
Rappels de programmation
scientifique
1.1 Approche numérique aux problème physiques
La description du monde physique repose sur plusieurs concepts représentés par des objets mathé-
matiques dont la définition précise a demandé de longues réflexions aux mathématiciens des siècles
passés : l’infini, les nombres réels et complexes, les fonctions continues, les distributions de probabi-
lités, etc. Les principes de la physique sont généralement exprimés par des relations entre ces objets.
Dans plusieurs cas, ces objets mathématiques peuvent être manipulés symboliquement et les équa-
tions qui les gouvernent résolues analytiquement. Les modèles les plus simples de la physique se
prêtent à ces calculs, et leur solution analytique permet de comprendre l’effet des divers paramètres
impliqués. Notre compréhension de base de la physique doit donc énormément à notre capacité à
résoudre exactement certains modèles simples.
Dans les cas plus réalistes les modèles ne peuvent être résolus analytiquement et tout un attirail de
méthodes d’approximations analytiques a été développé, dans le but de conserver autant que possible
les avantages d’une solution analytique, même approchée. La théorie des perturbations, que ce soit
en mécanique classique ou quantique, est l’exemple le plus évident de méthode de calcul approchée.
Mais ces approches approximatives ont leur limites. Elles reposent généralement sur des hypothèses,
telle la petitesse de certains paramètres, qui ne sont pas respectées en pratique. La vaste majorité
des problèmes d’intérêt dans les sciences physiques se prêtent difficilement à une solution purement
analytique, approximative ou non. On doit alors avoir recours à des méthodes numériques.
Une formation minimale sur les méthodes numériques est donc essentielle à toute personne s’inté-
ressant à la modélisation du monde physique. En fait, l’expression «modélisation» est parfois utilisée
pour signifier la description d’un système physique par un modèle qui ne peut être résolu que par des
méthodes numériques.
Le premier problème rencontré en modélisation numérique est la représentation des objets mathé-
matiques courants (nombres, fonctions, etc.) sur un ordinateur. C’est donc par cet aspect que nous
commencerons.
9
Chapitre 1. Rappels de programmation scientifique
1.2 Représentation des nombres sur ordinateur
Un calculateur électronique représente les données (y compris les instructions visant à les manipuler)
par un ensemble d’états électroniques, chacun ne pouvant prendre que deux valeurs, tel un commu-
tateur qui est soit ouvert ou fermé. Chacun de ces systèmes abrite donc un atome d’information, ou
bit, et l’état de chaque bit peut prendre soit la valeur 0, soit la valeur 1.
Le bit étant l’unité fondamentale d’information, l’octet (angl. Byte) est défini comme un ensemble de 8
bits et sert couramment d’unité pratique d’information. Traditionnellement, le Kilooctet (ko) désigne
210 = 1024 octets, le Mégaoctet (Mo) désigne 1024 ko, le Gigaoctet (Go) 1024 Mo, et ainsi de suite. 1 En
2011, la mémoire d’un ordinateur personnel typique se situe entre 109 et 1010 octets.
1.2.1 Nombres entiers
À partir des états binaires, un nombre entier naturel (l’un des concepts les plus simples, et proba-
blement le plus ancien, des mathématiques) peut être représenté en base 2. Par exemple, on a la
représentation binaire des nombres entiers suivants :
57 = 1110012 2532 = 1001111001002 (1.1)
Les entiers relatifs (Z) sont représentés de la même manière, sauf qu’un bit supplémentaire est requis
pour spécifier le signe (±). Bien évidemment, une quantité donnée d’information (un nombre donné
de bits) ne peut représenter qu’un intervalle fini de nombre entiers. Un entier naturel de 4 octets (32
bits) peut donc prendre les valeurs comprises de 0 à 232 −1 = 4 294 967 295. Un entier relatif peut donc
varier entre −2 147 483 648 et 2 147 483 647.
Les opérations élémentaires sur les entiers (addition, multiplication, etc.) ne sont donc pas fermées
sur ces entiers : ajouter 1 à l’entier naturel maximum redonne la valeur 0. Les opérations sont ef-
fectuées modulo la valeur maximale admissible. Il est donc important se s’assurer que les entiers
manipulés dans un code soient toujours en-deça des bornes maximales permises si on désire qu’ils se
comportent effectivement comme des entiers.
1.2.2 Nombres à virgule flottante
La représentation binaire des nombres réels pose un problème plus complexe. On introduit le concept
de nombre à virgule flottante (NVF) pour représenter de manière approximative un nombre réel. Un
NVF comporte un signe, une mantisse et un exposant, comme suit :
x → ±b p b p−1 . . . b 1 × 2±e q e q−1 ...e 1 (1.2)
où les b i sont les bits de la mantisse et les e i ceux de l’exposant binaire. Au total, p + q + 2 bits sont
requis pour encoder un tel nombre (2 bits pour les signes de la mantisse et de l’exposant).
Il a fallu plusieurs années avant qu’un standard soit développé pour les valeurs de p et q en 1987,
fruit d’une collaboration entre l’Institute of Electrical and Electronics Engineers (IEEE) et l’American
National Standards Institute (ANSI). Ce standard, appelé IEEE 754, prend la forme suivante :
x → ±1. f × 2e−decal. (1.3)
où f est la partie fractionnaire de la mantisse et où un décalage est ajouté à l’exposant e . L’exposant e

comporte 8 bits, de sorte que 0 ≤ e ≤ 255, et le décalage, pour des nombres à 32 bits (précision simple)
1. Le système international (SI) préconise plutôt de réserver ces préfixes aux puissances de 1000, et recommande d’utiliser
le symbole ko pour 1000 octets, et plutôt le symbole kio pour 1024 octets, et pareillement pour les préfixes supérieurs.
10
1.2. Représentation des nombres sur ordinateur
est 127. La mantisse comporte, elle, 23 bits, qui représentent la partie fractionnaire f de la mantisse.
Par exemple, dans l’expression binaire à 32 bits
0 : |01111100
|{z} {z } : 01000000000000000000000
| {z } (1.4)
signe exposant mantisse
le signe est nul (donc +), l’exposant est 124 − 127 = −3 , et la mantisse est 1, 012 = 1, 25. Le nombre
représenté est donc +1.25 × 2−3 = 0.15625.
Signalons que des subtilités se produisent lorsque l’exposant est nul (e = 0) ou maximum (e = 255),
mais nous n’entrerons pas dans ces détails ici. 2
Un NVF de 32 bits peut effectivement représenter des nombres réels compris entre 1.4 × 10−45 et
3.4 × 1038 , avec 6 ou 7 chiffres significatifs (23 × log10 (2) ≈ 6.9). Un tel nombre est qualifié de nombre à
précision simple.
La précision simple est généralement insuffisante pour les applications scientifiques. On utilise plutôt
la précision double, basée sur une représentation à 64 bits (8 octets) des NVF : l’exposant est codé en
11 bits et la mantisse en 52 bits, ce qui permet de représenter effectivement des nombres réels compris
entre
4.9 × 10−324 < double précision < 1.8 × 10308 (1.5)
avec 15 chiffres significatifs en base 10.
Dépassements de capacité
Comme la représentation en virgule flottante ne représente qu’un intervalle de nombres possibles
sur l’ensemble des réels, certaines opérations sur ces nombres produisent des nombres qui sont trop
grands ou trop petits pour être représentés par un NVF. C’est ce qu’on appelle un dépassement de
capacité (overflow ou underflow, en anglais). Un nombre trop grand pour être représenté par un NVF
est plutôt représenté par le symbole nan (pour not a number). Ce symbole est aussi utilisé pour re-
présenter le résultat d’opérations impossibles sur les réels, comme par exemple la racine carrée d’un
nombre négatif. Les nombres trop petits sont généralement remplacés par zéro.
1.2.3 Erreurs d’arrondi
Les NVF représentent exactement un sous-ensemble des réels, en fait un sous-ensemble des nombres
rationnels, ceux qui s’expriment exactement en base 2 par une mantisse de 52 bits et un exposant
de 11 bits (pour une nombre à double précision). Cet ensemble n’est pas fermé sous les opérations
arithmétiques habituelles (addition, multiplication, inversion). L’erreur ainsi générée dans la repré-
sentation des réels et dans les opérations arithmétique est qualifiée d’erreur d’arrondi.
Exemple 1.1 : Erreur d’arrondi dans une addition simple

step
Voyons comment l’erreur d’arrondi se manifeste dans l’opération simple
7 + 1 × 10−7 (1.6)
en précision simple. Chacun des deux termes s’exprime, en binaire, comme suit :
7 = 0 : 10000001 : 11000000000000000000000
−7
(1.7)
1 × 10 = 0 : 01100111 : 101011010111111100101001
Expliquons : l’exposant du nombre 7 est 129, moins le décalage de 127, ce qui donne 2. La mantisse est
1 + 2−1 + 2−2 = 47 , et donc on trouve bien 74 × 22 = 7. Pour le deuxième nombre, l’exposant est 103 − 127 = −24
−1 −3 −5 −6 −24 = 1.0 × 10−7 .
. et la mantisse est 1 + 2 + 2 + 2 + 2 + · · · = 1.6777216, ce qui donne 1.6777216 × 2
2. Voir par exemple les pages sur IEEE 754 dans Wikipedia.
11
Nom type octets

bool logique 1
char caractère 1
short entier 2
int entier 4
long entier 8
float NVF 4
double NVF 8
long double NVF 16
pointeur 8
T 1.1
Types simples en C++, sur une machine à 64 bits
Additionnons maintenant ces deux nombres. Pour ce faire, on doit premièrement les mettre au même ex-
posant, ce qui se fait en déplaçant les bits du deuxième nombre de 26 positions vers la droite, ce qui fait
disparaître toute la mantisse. Le deuxième nombre devient donc effectivement nul, et on trouve
7 + 1.0 × 10−7 = 7 (simple précision) (1.8)

.
On définit la précision-machine comme le nombre le plus grand qui, ajouté à 1, redonne 1. Pour un
nombre à précision simple, précision-machine est de 5.96e-08. Pour un nombre à double précision,
elle est de 1.11e-16.
1.3 Programmation par objets
Le contenu de ce cours est pour l’essentiel indépendant du langage de programmation utilisé pour
réaliser les exemples et les travaux pratiques. Cependant, comme un choix doit être fait, nous utilise-
rons le C++, car il s’agit du langage de haut niveau général le plus utilisé. De plus, il permet d’écrire
des programmes performants sans avoir recours à des modules codés dans un langage différent, à la
différence d’un langage interprété, comme Python par exemple. Par contre, le C++ est plus complexe
et plus strict. Nous supposerons que le lecteur est familier avec les bases du C++. Certaines de ses
caractéristiques «intermédiaires» seront cependant discutées dans ce cours. 3
Le C++ est une extension du langage C, développé entre 1969 et 1973 en même temps que le système
d’exploitation UNIX, écrit justement dans ce langage. Le C++ a été développé à partir de 1979 ; sa
raison d’être est la possibilité de construire des objets, c’est-à-dire des structures de données originales
qui permettent de bien isoler certaines données du reste du programme. Cela facilite énormément la
conception de programmes complexes et de librairies, et surtout la réutilisation et l’extension de ces
programmes par d’autres auteurs.
Dans ce cours, nous appliquerons la programmation par objet au calcul scientifique. L’un des objectifs
du cours est justement d’acquérir un style de programmation plus robuste et plus adapté à notre siècle.
12
1.3. Programmation par objets
1.3.1 Types fondamentaux en C++
Les types de variables fondamentaux en C++ sont indiqués dans le tableau 1.1. Chaque type entier
peut être précédé du mot-clé unsigned, qui définit plutôt un entier naturel, dont le domaine s’étend
de 0 à 2n − 1, n étant le nombre de bits contenu dans le type en question.
Un pointeur est un type général décrivant l’adresse en mémoire d’une donnée quelconque. Par
exemple, pour une variable X, l’expression p = &X représente l’adresse en mémoire de la variable
X ; l’opérateur & est appelé opérateur d’adresse. la valeur de X est alors représentée par l’expression
*p. L’opérateur * placé immédiatement devant un nom de variable de pointeur effectue une indirec-
tion, c’est-à-dire représente les données situées à l’adresse contenue dans le pointeur. La définition et
manipulation des pointeurs est très courante en C, mais moins fréquente en C++, où la tendance est
de passer des objets par référence dans les fonctions ; sous le capot, cependant, passer des références
ou des pointeurs revient au même.
Le langage C++ de base contient aussi la possibilité de définir des tableaux d’objets, en dimension 1,
2 ou plus. Par exemple, un tableau de n double se déclare (et la mémoire requise est allouée en même
temps) par
double X[n];
Il est cependant conseillé de ne pas utiliser ces tableaux simples, mais plutôt des types complexes pour
stocker un ensemble de données. L’avantage des types complexes est qu’on peut encapsuler dans le
type la taille du tableau et surcharger des opérateurs pour effectuer des opérations sur ces structures
(comme l’addition des vecteurs, par exemple). Cela allège le code et diminue les risques d’erreur.
1.3.2 Exemple d’objet : vecteurs en trois dimensions
Les objets en C++ sont généralement définis comme des classes (class). Ces notes de cours ne peuvent
se substituer à un manuel complet de C++. Nous ne donnerons donc, dans ce qui suit, que quelques
explications fragmentaires sur les classes.
Le code ci-dessous est un exemple de définition de classe décrivant des vecteurs en trois dimensions.
Nous allons expliquer ce code en se référant aux numéros de lignes indiquées à gauche.
Dans tous les exemples de code cités dans ces notes, les commentaires apparaissent en bleu,
sans les symboles de commentaires requis en C++ : Dans un code réel, tous les commentaires
doivent suivre le symbole // ou être inscrits entre /* et */. Les codes cités dans ces notes sont
en fait traités par un module LATEX qui présentent les commentaires ainsi, afin d’en faciliter la
lecture.
.
Code 1.1 : Classe de vecteurs en 3D : Vector3D.h
1 #ifndef VECTOR3D_H
2 #define VECTOR3D_H
3 #include <iostream>
4 #include <cmath>
5
6 using namespace std ;

7
8 class Vector3D
9 {
10 public :
. 11 double x ; composante en x
3. Le site http://www.cplusplus.com est une mine extrêmement utile d’information et devrait figurer parmi les signets
de tout programmeur.
13
12 double y ; composante en y
13 double z ; composante en z
14
15 constructeur
16 Vector3D() : x(0), y(0), z(0) {}
17
18 constructeur
19 Vector3D(const double &_x, const double &_y, const double &_z = 0)
20 : x(_x), y(_y), z(_z) {}
21
22 assignation
23 Vector3D& operator=(const Vector3D& q)
24 {x = q.x ; y = q.y ; z = q.z ; return(*this) ;}
25
26 addition
27 Vector3D operator+(const Vector3D& q) {return(Vector3D(x+q.x,y+q.y,z+q.z)) ;}
28
29 addition
30 void operator+=(const Vector3D& q) {x += q.x ; y += q.y ; z += q.z ;}
31
32 soustraction
33 Vector3D operator-(const Vector3D &q) {return(Vector3D(x-q.x,y-q.y,z-q.z)) ;}
34
35 soustraction
36 void operator-=(const Vector3D& q) {x -= q.x ; y -= q.y ; z -= q.z ;}
37
38 multiplication par une constante

39 Vector3D operator*(const double &c) {return(Vector3D(c*x,c*y,c*z)) ;}
40 Vector3D operator*(const int &c) {return(Vector3D(c*x,c*y,c*z)) ;}
41 void operator*=(const double &c) { x *=c ; y *= c ; z *= c ;}
42
43 norme au carré
44 inline double norm2() {return(x*x+y*y+z*z) ;}
45
46 norme
47 inline double norm() {return(sqrt(norm2())) ;}
48
49 friend std ::ostream & operator<<(std ::ostream &flux, const Vector3D &x){
50 flux << x.x << ’\t’ << x.y << ’\t’ << x.z ;
51 return flux ;
52 }
53
54 friend std ::istream & operator>>(std ::istream &flux, Vector3D &x){

55 flux >> x.x >> x.y >> x.z ;
56 return flux ;
57 }
58 };
59
60 produit scalaire
61 double operator*(const Vector3D &A, const Vector3D &B)
62 {
63 return(A.x*B.x + A.y*B.y + A.z*B.z) ;
64 }
65
66 Vector3D vector_product(const Vector3D &A, const Vector3D &B)

67 {
68 return Vector3D(A.y*B.z - A.z*B.y, A.z*B.x - A.x*B.z, A.x*B.y - A.y*B.x) ;
69 }
70
71 Vector3D operator *(double &c, Vector3D &A)

72 {
. 73 return Vector3D(c*A.x,c*A.y,c*A.z) ;
14
74 }
75
76 #endif
.
1. Une classe comporte des membres, qui peuvent être soit des données (des types simples ou
d’autres classes ou structures préalablement définies) ou des fonctions (ou méthodes). Ces
membres sont énumérés (déclarés ou définis) à l’intérieur d’une déclaration de type class
(lignes 8–61 du code).
2. L’objet Vector3D comporte trois données : les trois composantes cartésiennes du vecteur, notées
x, y et z. Chacune est un NVF à double précision (double).
3. Chaque classe comporte un ou plusieurs constructeurs qui, comme le nom l’indique, sont des
méthodes visant à construire l’objet suite à une déclaration. La ligne 16 est le constructeur
par défaut, qui ne prend aucun argument, et qui initialise les membres à zéro. La ligne 19
est un constructeur qui prend comme argument les trois composantes du vecteur. Le nom des
constructeurs est celui de la classe elle-même. Ainsi, si on veut déclarer un objet noté R de type
Vector3D et l’initialiser à la valeur (1, 0, 0), on doit énoncer
Vector3D R(1.0,0,0) ;
4. Les lignes 23-24 définissent une méthode d’assignation, qui permet d’assigner le contenu d’un
objet à un autre. Par exemple :
Vector3D R1, R2(1.0,0.0,0.0) ;
R1 = R2 ;
Notez que le mot-clé this représente un pointeur vers l’objet, et donc *this représente l’objet
lui-même.
5. Les lignes 26-27 définissent une méthode d’addition qui permet de donner son sens naturel à
l’expression R1+R2. L’un des avantages du C++ est la possibilité de surcharger les opérateurs
existants. Ainsi, la définition du symbole + est ici étendue à une fonction effectuant l’addition
des vecteurs. Notez que l’argument est passé en référence (&q et non q). Des méthodes sem-
blables sont définies pour la soustraction et la multiplication par un scalaire. Le fait de définir
ces surcharges dans la classe elle-même permet de considérer que l’une des cibles de l’opérateur
surchargé est l’objet courant, l’autre cible étant donnée en argument. Ainsi, lorsque le compi-
lateur rencontre l’expression R1+R2, il interprète l’opérateur + comme un méthode attachée à
l’objet R1, qui prend comme argument l’objet R2. Il est aussi possible de définir la surcharge de
l’opérateur + en dehors de la définition de classe, avec le même effet, de la manière suivante :
1 Vector3D operator+(const Vector3D &p, const Vector3D &q){

2 return(Vector3D(p.x+q.x,p.y+q.y,p.z+q.z)) ;
3 }
.
6. La fonction norm2() retourne la norme au carré du vecteur. Elle est déclarée inline, de sorte
qu’elle ne sera pas vraiment compilée comme une sous-routine, mais intégré directement au
code, ce qui améliore la performance dans fonctions qui sont rapides à évaluer, en éliminant
le passage de contrôle entre deux routines. La fonction norm() retourne la norme elle-même.
Comme elle invoque la fonction mathématique sqrt(), l’entête <cmath> doit être incluse (ligne
4).
7. Les opérateurs de flux << et >> sont surchargés (lignes 41–50). Ceci permet de lire ou d’écrire
un vecteur comme si c’était un objet simple. Ces définitions nécessitent d’inclure l’entête <
iostream> (ligne 3).
8. En dehors de la définition de la classe, des routines sont définies pour le produit scalaire de
deux vecteurs (lignes 53–56) ainsi que pour le produit vectoriel (lignes 58–61).
9. Notez qu’une condition de pré-compilation est introduite à la ligne 1 pour s’assurer que le fichier
d’entête Vector3D.h ne soit lu qu’une seule fois par compilation, même s’il est inclus dans
plusieurs fichiers source du programme.
15
Nous utiliserons les classes à profusion dans ce cours. Il est donc important de bien comprendre
ces concepts. Comme des exemples seront donnés pour chaque application, il n’est cependant pas
nécessaire de tout comprendre à l’avance.
Test de l’utilisation de la classe Vector3D

Le fichier Vector3D.h ne constitue pas en soit un code utilisable, car il ne comporte pas de programme
principal (main()). Le code ci-dessous, contenu dans un fichier séparé Vector3D.cpp contient le pro-
gramme principal effectuant un test des fonctionnalités de la classe. Notez que le code de la classe est
inclus par l’énoncé
#include ”Vector3D.h”
et que les valeurs des vecteurs sont entrées via le terminal en utilisant la surcharge de l’opérateur de
flux >>.
Code 1.2 : Programme principal utilisant la classe Vector3D
2 #include ”Vector3D.h”
4
5 int main() {
6
7 Vector3D A, B ;
8
9 cout << ”Test de la classe Vector3D” << endl ;

10 cout << ”Inscrire le vecteur A :” ;
11 cin >> A ;
12 cout << ”Inscrire le vecteur B :” ;
13 cin >> B ;
14
15 cout << ”Somme A+B = ” << A+B << endl ;

16 cout << ”Multiplication par un scalaire : 2*A = ” << A*2.0 << endl ;
17 cout << ”Produit scalaire : A . B = ” << A*B << endl ;
18 cout << ”Produit vectoriel : A x B = ” << vector_product(A,B) << endl ;
19 }
.
1.3.3 Avantages de la programmation par objet
Résumons ici les principaux avantages de la programmation par objet. Ces avantages ne sont pas
confinés au monde du génie logiciel, mais servent aussi le calcul scientifique.
1. Un objet bien défini suit la logique interne d’un problème et apparaît donc naturellement. Il
permet de manipuler des concepts dans un code (par exemple, des vecteurs) sans être encombré
des diverses données reliées à l’objet, qui sont dissimulées dans l’objet lui-même.
2. La surcharge des opérateurs permet de manipuler les types complexes (les objets) comme s’ils
étaient des types simples.
3. Le polymorphisme est la capacité de définir plusieurs fonctions du même nom, mais comportant
des types d’arguments différents. Le compilateur reconnaît les fonctions appropriées à leurs
arguments. Cette caractéristique du C++ est étroitement associée aux objets, mais en est en
fait indépendante. Elle permet de désigner par le même nom ou symbole des opérations ou
fonctions analogues. La surcharge d’opérateur en est un cas particulier.
Nous allons adopter un style de programmation dans lequel les fichier d’entêtes (*.h) contiendront
l’essentiel du code, alors que les fichiers *.cpp contiendront surtout des pilotes (angl. drivers) pour
les différentes méthodes définies dans les fichiers d’entête.
16
1.3.4 Foncteurs
Un foncteur est une structure qui permet facilement de passer une fonction en argument à une rou-
tine, tout en contrôlant les paramètres en jeu dans la fonction. Par exemple, supposons qu’on souhaite
introduire une fonction linéaire f (x) = ax + b pour la passer en argument à une autre fonction qui,
par exemple, calcule une intégrale définie. La façon classique de procéder est d’écrire
1 double f(double x, double *params){ return(params[0]*x+params[1]) ;}

2
3 double integrate(double (*F)(double x, double *params), double x1, double x2){

4 intègre la fonction F de x=x1 à x=x2
5 ...
6 }
.
Dans cette façon de faire, on doit passer à la fonction integrate() les paramètres de la fonction F,
ce qui nous oblige à écrire un fonction f qui prend ces paramètres comme argument, mais à l’inté-
rieur d’un tableau de longueur indéfinie : donner une longueur définie à ce tableau nous forcerait à
écrire une routine integrate différente pour chaque cas. En revanche, ne pas inclure les paramètres
comme argument nous forcerait à recompiler la fonction f à chaque fois que les valeur des paramètres
changent, ou à traiter les paramètres comme des variables globales, ce qui laisse à désirer du point
de vue organisation. Notons qu’ici le tableau params contient les deux paramètres a et b en positions
0 et 1, respectivement.
Au lieu de procéder ainsi, on peut introduire une structure comme suit :
1 struct func{
2 double a ;
3 double b ;
4 func(double _a, double _b) : a(_a), b(_b) {} constructeur
5 double operator(double x){return(a*x+b) ;} surcharge de l’opérateur ()
6 }
7
8 template<class T>
9 double integrate(T &f, double x1, double x2){
10 intègre la fonction F de x=x1 à x=x2 en invoquant f(x)
11 ...
12 }
13
14 func F(0.1,3.0) ; instance du foncteur

15 double result = integrate(F,0,10) ; appel de la routine d’intégration
.
Expliquons :
1. la structure func a comme membres les paramètres de la fonction désirée, un constructeur
qui permet d’initialiser ces paramètres, ainsi qu’un surcharge de l’opérateur ( ) qui permet
d’évaluer la fonction à l’aide du nom de l’instance de la structure, comme par exemple f(x).
Généralement, les foncteurs sont à usage unique : une seule instance de la structure est requise
dans le code.
2. Une instance F de la structure est déclarée et initialisée dans la partie principale du code.
3. La routine d’intégration est un modèle de fonction (angl. function template), qui est donc compilé
séparément pour chaque type T utilisé dans le contexte du modèle.
L’avantage d’utiliser un foncteur plutôt que la méthode classique décrite plus haut est la localisation
des données : les paramètres de la fonction n’ont pas besoin d’être introduits soit comme un tableau
auxiliaire de longueur indéterminée, soit comme des variables globales. Notons cependant que les
deux approches peuvent coexister et utiliser la même routine d’intégration integrate(...) si elle
est définie à partir d’un modèle comme ci-haut.
17
Problème 1.1
A Mettez en place le programme Vector3D.cpp dans l’environnement de programmation de votre choix.

Assurez-vous que le code compile correctement et exécutez-le.
B Écrivez une méthode de la classe Vector3D, intitulée ortho(Vector3D &v), qui, étant donné un vecteur
v dont la référence est donnée en argument, modifie l’objet pour lui enlever sa composante le long de v.
C Modifiez le code de la classe et celui du programme principal pour réaliser un modèle de classe qui
puisse représenter des vecteurs dont les composantes sont d’un type quelconque (en fait entier, réel ou
complexe). Apporter une attention particulière à la méthode qui calcule la norme. Vérifiez que le nouveau
code fonctionne comme l’ancien dans le cas des réels.
.
1.4 Autres outils
1.4.1 Environnement de développement
Tout programmeur a avantage à tirer parti d’un gestionnaire de code, communément appelé environ-
nement de développement intégré, ou IDE en anglais. Plusieurs solutions existent pour chaque plate-
forme. 4 Aucune solution ne sera imposée dans ce cours, mais une seule sera supportée : Eclipse. Cet
IDE existe sur Linux, Mac et Windows et est gratuit. Il est relativement complexe, mais stable, ce qui
n’est pas encore le cas de Code ::Blocks sur le Mac, par exemple. Ceci dit, le choix appartient à cha-
cun. L’important est d’utiliser un environnement de développement efficace, ou aucun si on préfère
éditer les fichiers de code avec un éditeur de texte sensible à la syntaxe et compiler les programmes
à l’aide de make.
1.4.2 Serveurs de calcul
Sur un serveur de calcul standard, un code est compilé, exécuté, mais rarement développé. Il est donc
courant qu’un code développé sur un ordinateur personnel, soit ensuite migré vers un serveur de
calcul, où il est compilé et ensuite exécuté. Un serveur de calcul est mis à la disposition des étudiants
inscrits à ce cours :
phq405.physique.usherbrooke.ca
Sur ce serveur, il est possible de compiler de vastes projets à l’aide d’un outil (make) qui permet de
gérer plusieurs fichiers source. Cet outil est utile même pour des codes plus modestes, tels ceux qui
seront réalisé dans le cadre de ce cours. Un modèle de fichier makefile est disponible sur le site du
cours
1.4.3 Visualisation des données
La visualisation des données est un aspect crucial du calcul scientifique, mais dont l’ampleur varie
beaucoup d’une discipline à l’autre. Elle prend plus de place en siences de la Terre et en génie qu’en
physique théorique, par exemple. Dans ce cours, nous nous contenterons d’un outil très modeste, mais
tout de même assez puissant pour nos besoins : gnuplot. 5 En plus d’appliquer gnuplot à des données
pré-calculées, nous l’utiliserons aussi pour visualiser des données en cours de calcul, à l’aide d’une
interface entre gnuplot et les codes que nous développerons : la librairie gnuplot_i 6
4. Voir http://en.wikipedia.org/wiki/Comparison_of_integrated_development_environments
5. http://www.gnuplot.info/
6. http://ndevilla.free.fr/gnuplot/
18
2
Équations différentielles
ordinaires
Ce chapitre est consacré à la solution des systèmes d’équations différentielles ordinaires, c’est-à-dire
aux systèmes d’équations de la forme

∂x
= f(x, t ) (2.1)
∂t

où x(t ) est une collection de N fonctions dépendant d’une variable indépendante t , et f est un ensemble
de N fonctions de x et de t .
Remarques :
1. La variable t joue typiquement le rôle du temps en mécanique, d’où la notation utilisée. Mais
elle peut en général avoir une interprétation différente.
2. La forme (2.1) peut sembler restrictive, car il s’agit d’un système du premier ordre en dérivées
seulement. Cependant tout système d’équations différentielles d’ordre plus élevé peut être ra-
mené à un système du type (2.1) en ajoutant des variables au besoin pour tenir la place des déri-
vées d’ordre sous-dominant. Par exemple, considérons une équation différentielle du deuxième
ordre pour une variable y :
ÿ = f (y, ẏ, t ) (2.2)
En définissant les variables x 1 = y et x 2 = ẏ , cette équation peut être ramenée au système

suivant :
ẋ 2 = f (x 1 , x 2 , t ) ẋ 1 = x 2 (2.3)
qui est bien de la forme (2.1) où f 1 = f et f 2 (x, t ) = x 2 .

3. Le passage d’un système d’équations du deuxième ordre à M variables vers un système du
premier ordre à N = 2M variables est justement ce qui est réalisé en passant de la mécanique
de Lagrange à la mécanique de Hamilton. Les équations du mouvement de Hamilton sont de
la forme (2.1), mais leur structure symplectique est spécifique, alors que la forme (2.1) est plus
générale.
19
Chapitre 2. Équations différentielles ordinaires
2.1 Méthode d’Euler
La méthode la plus élémentaire pour solutionner numériquement l’équation différentielle (2.1) est
la méthode d’Euler. Sa simplicité est cependant contrebalancée par son manque de précision et de
stabilité. Elle consiste à remplacer l’équation (2.1) par une équation aux différences finies : l’axe du
temps est remplacé par une suite d’instants également espacés t → t n = nh , (n = 0, 1, 2 . . . ), où h est
le pas temporel. La fonction x(t ) est alors remplacée par une suite {xn } et la dérivée est estimée par
l’expression 1
xn+1 − xn
ẋ(t ) ≈ (2.4)
h
Le système (2.1) est alors modélisé par l’équation aux différences suivante :

xn+1 = xn + hf(xn , t n ) (2.5)

Cette expression définit une carte explicite xn 7→ xn+1 qui permet, par récurrence, d’obtenir la suite
complète à partir des valeures initiales x0 .
2.1.1 Précision de la méthode d’Euler
La principale source d’erreur de la méthode d’Euler provient du pas temporel h , qui doit être pris
suffisamment petit. Cette erreur est qualifiée d’erreur de troncature. Si nous avions accès aux dérivées
d’ordre arbitraire de la fonction x(t ), nous pourrions envisager le développement de Taylor suivant :
dx ¯¯ 1 d2 x ¯¯ 2
xn+1 = xn + ¯ h+ ¯ h +··· (2.6)
dt tn 2 dt 2 tn
Le remplacement (2.5) revient à négliger les termes en h 2 (ou plus grand) dans ce développement. On
dit alors que la méthode d’Euler est du premier ordre en h .
2.1.2 Stabilité de la méthode d’Euler
Au-delà des considérations de précision, la carte (2.5) est aussi sujette à des erreurs d’arrondi. Suppo-
sons à cet effet qu’une telle erreur produise une déviation δxn de la solution numérique, par rapport à
la solution exacte de l’équation aux différences (2.5). La méthode sera stable si cette déviation décroît
avec le temps et instable dans le cas contraire. Appliquons un développement limité à la carte (2.5) :
∂
δxn+1 = δxn + h f(xn , t n )δx α,n ou δxn+1 = (1 + hM) δxn (2.7)
∂x α
où la matrice M possède les composantes suivantes :
∂ fα
M αβ = (2.8)
∂x β
et est évaluée au temps t n .
De toute évidence, la méthode d’Euler sera instable si la matrice (1 +hM) possède au moins une valeur
propre en dehors de l’intervalle (−1, 1), de manière répétée en fonction du temps. Dans le cas d’une
seule variable (N = 1), la condition de stabilité revient à
¯ ¯
df df ¯df ¯ 2
−1 < 1+h < 1 =⇒ < 0 et ¯¯ ¯< (2.9)
dx dx dx ¯ h
1. Les éléments du vecteur xn sont notés x α,n , où α = 1, 2, . . . , N .
20
2.1. Méthode d’Euler
Exemple 2.1 : Équation linéaire à une variable

step
Considérons l’équation
ẋ = λx (2.10)
dont la solution analytique est x(t ) = x(0) eλt . La méthode d’Euler produit l’équation aux différences sui-
vante :
x n+1 = x n + hλx n = (1 + hλ)x n (2.11)
L’analyse de stabilité produit la relation suivante pour les déviations :
δx n+1 = (1 + hλ)δx n (2.12)
ce qui montre que la méthode d’Euler est stable seulement si λ < 0 (décroissance exponentielle) et instable
dans le cas d’une croissance exponentielle (λ > 0) ou d’une oscillation (λ imaginaire).
.
2.1.3 Méthode prédicteur-correcteur
Une façon simple d’améliorer la méthode d’Euler est de la scinder en deux étapes :
pr.
1. On procède à une prédiction sur la valeur au temps t n+1 : xn+1 = xn + hf(xn , t n ).
2. On procède ensuite à une correction de cette prédiction, en remplaçant la dérivée évaluée à xn

pr.
par la moyenne de la dérivée évaluée à (xn , t n ) et (xn , t n+1 ) :
( pr. )
xn+1 = xn + 12 h f(xn , t n ) + f(xn , t n+1 ) (2.13)
On montre que cette méthode, qui requiert manifestement deux fois plus d’évaluations de f que la
méthode d’Euler simple, est cependant du deuxième ordre en h , c’est-à-dire que l’erreur de troncature
est d’ordre h 3 . Voyons la démonstration : on applique le développement limité
¯ 2 ¯¯
dx ¯¯ 1 2 d x¯
xn+1 = xn + h + h + O (h 3 ) (2.14)
dt ¯tn 2 dt 2 ¯tn
La dérivée première au temps t n est précisément f(xn , t n ). La dérivée seconde au temps t n est, au
premier ordre,
¯
d2 x ¯¯ f(xn+1 , t n+1 ) − f(xn , t n )
= + O (h 2 ) (2.15)
dt 2 ¯tn h
où xn+1 peut être connu au premier ordre seulement. En substituant dans le développement (2.14),
on retrouve effectivement l’équation (2.13), qui est donc d’ordre h 2 .
21
2.2 Méthode de Runge-Kutta
La méthode de Runge-Kutta est une amélioration notable de la méthode d’Euler, et constitue en fait
une généralisation de la méthode prédicteur-correcteur. Elle consiste à évaluer la dérivée f non pas
au temps t n , ni au temps t n+1 , mais entre les deux en général.
2.2.1 Méthode du deuxième ordre
Commençons par démontrer la méthode de Runge-Kutta d’ordre 2. Nous allons supposer qu’une étape
de la méthode prend la forme suivante :
xn+1 = xn + ak1 + bk2
k1 = hf(xn , t n ) (2.16)
k2 = hf(xn + βk1 , t n + αh)
et nous allons chercher à déterminer les constantes a , b , α et β de manière à maximiser la précision
de la méthode.
Pour déterminer ces paramètres, appliquons encore une fois le développement limité (2.14), en tenant
compte du fait que
df ∂f ∂f dx i
= + (2.17)
dt ∂t ∂x i dt
En combinant la règle (2.16) et le développement limité (2.14), on trouve
( )
xn+1 = xn + ahf(xn , t n ) + bhf xn + hβf(xn , t n ), t n + αh + O (h 3 )
∂f ∂x i ∂f (2.18)
= xn + (a + b)hf + bβh 2 + bαh 2 + O (h 3 )
∂x i ∂t ∂t
où toutes les expressions sont évaluées à (xn , t n ) dans la dernière ligne. Pour que cette dernière ex-
pression coïncide avec le développement de Taylor correct de xn+1 , les paramètres a , b , α et β doivent
respecter les contraintes suivantes :
1 1
a +b = 1 bα = 2 bβ = 2 (2.19)
1
La solution à ces contraintes n’est pas unique. En particulier, le choix a = b = 2 et α = β = 1 correpond
à la méthode prédicteur-correcteur !
Un autre choix possible est a = 0, b = 1 et α = β = 21 , qui correspond à ce qui est généralement appelé
la méthode de Runge-Kutta du deuxième ordre :
k1 = hf(xn , t n )
k2 = hf(xn + k1 /2, t n + h/2) (2.20)
3
xn+1 = xn + k2 + O (h )
2.2.2 Méthode du quatrième ordre
La version la plus utilisée de la méthode de Runge-Kutta est celle du quatrième ordre, dans laquelle
l’erreur commise est d’ordre h 5 . La formule aux différences correspondante est la suivante :
k1 = hf(xn , t n )
k2 = hf(xn + k1 /2, t n + h/2)
k3 = hf(xn + k2 /2, t n + h/2) (2.21)
k4 = hf(xn + k3 , t n + h)
xn+1 = xn + 61 k1 + 13 k2 + 13 k3 + 16 k4 + O (h 5 )
Voyons le sens de chacune de ces étapes :
22
2.2. Méthode de Runge-Kutta
1. Pour commencer, on évalue la dérivée k1 /h au point (xn , t n ).

2. On utilise cette dérivée pour obtenir un premier point médian xn + k1 /2.
3. On calcule ensuite la dérivée k2 /h à ce point médian.
4. On calcule une deuxième estimation xn +k2 /2 de ce point médian et on y calcule encore une fois
la dérivée k3 /h .
5. On calcule ensuite la dérivée k4 /h à une première estimation du point final xn + k3 .
6. Enfin, le point final estimé par la méthode est obtenu par une combinaison des quatre dérivées
calculées aux étapes précédentes.
2.2.3 Contrôle du pas dans la méthode de Runge-Kutta
Un solutionneur d’équations différentielles qui procède en suivant un pas temporel h constant est
condamné soit à l’inefficacité (h trop petit), soit à commettre des erreurs de troncature non contrôlées
(h trop grand). Il est impératif que le pas temporel s’adapte à chaque instant à l’erreur de troncature
commise à chaque étape. Cette dernière peut être estimée en procédant à deux étapes de Runge-Kutta
du quatrième ordre, chacune de pas h/2, et en comparant le résultat xn+1 obtenu après la deuxième
étape à celui obtenu en procédant directement à une étape de pas h . Si la différence est inférieure à
une précision demandée à l’avance, on peut alors augmenter la valeur de h pour la prochaine itération,
sinon on peut la réduire.
Des calculs supplémentaires sont bien sûr nécessaires pour évaluer l’erreur de troncature, mais l’al-
gorithme au total demande moins de calculs car son erreur est contrôlée : le pas h peut augmenter
si l’erreur est tolérable, et de cette manière alléger le coût des calculs. D’un autre côté, si h doit être
diminué, c’est que les calculs auraient autrement été erronés à une degré jugé inacceptable.
pas direct
¾
2 pas successifs
F 2.1
Nombre d’évaluation des dérivées dans une étape de la méthode de Runge-Kutta adaptative. Un cercle noir
représente une évaluation des dérivées et un cercle blanc une dérivée qui a été gardée en mémoire.
Une façon élémentaire de procéder au contrôle du pas est la méthode du doublement :

1. On effectue un pas temporel h à l’aide de la méthode du quatrième ordre (RK4). On obtient une
variable mise-à-jour x(1)
n+1 .
2. On effectue deux pas temporels successifs h/2, à partir du même point de départ, pour arriver
à une valeur x(2)
n+1 .
3. La différence |x(2) (1)

n+1 −xn+1 | nous donne une estimation de l’erreur de troncature ∆1 . Nous pouvons
par la suite modifier h (en l’augmentant ou le diminuant) pour viser une erreur de troncature
constante ∆0 . Donc nous devons réajuster h ainsi :
( )1/5
∆0
h→h (2.22)
∆1
car nous savons que l’erreur doit se comporter comme h 5 dans une méthode du 4e ordre. On
peut aussi multiplier par un facteur de sécurité (0.9 dans le code) afin de tempérer quelque peu
l’augmentation de h , sans jamais faire plus que de quadrupler le pas.
23
4. On note que le nombre d’évaluations de la dérivée dans cette procédure est de 11 par étape,
alors que la méthode utilisée avec un pas de h/2 (qui nous donne une précision semblable)
nécessite 8 évaluations. Il y a donc un coût (surcharge) de 118 = 1.375 dans L’estimation de
l’erreur. Cependant, ce coût est largement recouvré par le contrôle accru de la méthode.
Quoique la méthode du doublement soit simple à comprendre, elle est maintenant dépassée par la
méthode dite de Runge-Kutta-Fehlberg, qui effectue une étape du 5e ordre en même temps qu’une
étape du 4e ordre et compare les deux afin d’estimer l’erreur de troncature (la méthode est souvent
désignée par son acronyme RKF45). Au total, le nombre d’évaluation nécessaire par étape est de 6,
soit presque deux fois moins que la méthode de doublement. 2
code : RK.h — page 168
2.3 Exemple : Mouvement planétaire
2.3.1 Solution du problème de Kepler
Considérons premièrement un problème dont nous connaissons la solution analytique : celui du mou-
vement d’un corps de masse m dans le champ gravitationnel d’un objet de masse M , fixe à l’origine.
Nous savons que le problème peut être limité à deux dimensions d’espace, en raison de la conservation
du moment cinétique.
Adoptons les coordonnées cartésiennes (x, y), et soit (v x , v y ) les vitesses correspondantes. Les équa-
tions du mouvement pour ce problème sont, en forme vectorielle,
k
ṙ = v v̇ = − r (2.23)
r3
où nous avons introduit la constante k = G M . Nous pouvons toujours choisir un système d’unités pour
le temps dans lequel cette constante vaut 1 (voir ci-dessous). Le système d’équations se ramène donc
à l’ensemble suivant, si on numérote les variables dans l’ordre suivant : (x, y, v x , v y ) :
x1 x2 def
ẋ 1 = x 3 ẋ 2 = x 4 ẋ 3 = − ẋ 4 = − r = (x 12 + x 22 )1/2 (2.24)
r3 r3
Choix du système d’unités Dans la résolution numérique de problèmes physiques, il est très im-
portant d’utiliser des grandeurs relatives à certaines échelles caractéristiques du problème, de ma-
nière à ce que les nombres à virgules flottantes qui sont manipulés n’aient pas des exposants extrava-
gants. Non seulement cela nous protège-t-il des limites numériques inhérentes à ces nombres, mais
cela permet aussi de donner un sens physique plus évident aux résultats. Manipuler des valeurs re-
latives équivaut bien sûr à choisir un système d’unités particulier, différent d’un système standard,
comme le SI.
Par exemple, supposons que le temps t soit défini en rapport avec un temps caractéristique τ, et les
distances définies en rapport avec une longueur caractéristique a . Le temps mesuré en SI serait alors
τt , où t est maintenant un rapport ‘sans unités’, et pareillement pour la position ar. Remplaçons alors,
dans les équations (2.23), le temps t par t τ, le rayon r par r a et la vitesse v par v a/τ. On trouve alors
les équations suivantes :
G M τ2
ṙ = v v̇ = − 3 3 r (2.25)
a r
La constante k de l’équation (2.23) vaut donc G M τ2 /a 3 , alors que les variables t , r et v sont sans
unités, c’est-à-dire exprimées comme multiples de τ, a et a/τ, respectivement.
2. Voir Numerical Recipes, ou encore les articles de Wikipedia écrits sur le sujet.
24
2.3. Exemple : Mouvement planétaire
Si on choisit a comme étant le demi-grand axe de l’orbite de la Terre autour du soleil (une unité
astronomique) et τ comme étant la période τ⊕ de cette orbite, alors, étant donné la relation connue
pour cette période,
(2π)2
τ2⊕ = a 3 (2.26)
GM
il s’ensuit que k = (2π)2 . Si, au contraire, on insiste pour que k = 1 – le choix que nous avons fait
ci-dessus – alors le temps caractéristique est τ = τ⊕ /2π.
Une analyse d’échelle comme celle-ci doit en principe être faite pour chaque problème résolu de ma-
nière numérique.
2.3.2 Code
Voici le code utilisé pour définir le problème de Kepler perturbé et l’appel aux méthodes de Runge-
Kutta définies plus haut.
Code 2.1 : Méthode de Runge-Kutta : fichier maître pour la solution du problème de

Kepler
1 #include <string>
2 #include ”RK.h”
3 #include ”read_parameter.h”
4

6
7 Foncteur définissant le problème de Kepler perturbé

8 struct func_kepler{
9 int count ; incrément qui compte le nombre d’appels au foncteur
10
11 func_kepler() {count=0;}
12 void operator() (const double t, const Vector<double> &x, Vector<double> &dxdt){
13 double r2 = x[0]*x[0]+x[1]*x[1]; = r 2
14 double r = sqrt(r2) ;
15 double z = 1.0/(r*r2) ;
16 dxdt[0] = x[2]; ẋ = v x
17 dxdt[1] = x[3]; ẏ = v y
18 dxdt[2] = -x[0]*z ; v̇ x = −xz
19 dxdt[3] = -x[1]*z ; v̇ y = −y z
20 count++;
21 }
22 };
23
24 int main(){
25
26 ifstream fin(”para.dat”) ; ouverture du fichier d’entrée

27 double accur ; précision désirée
28 double h ; pas temporel initial
29 double tmax ; temps de simulation
30 string method ; méthode de calcul utilisée
31
32 fin >> ”accur” >> accur ;

33 fin >> ”h” >> h ;
34 fin >> ”tmax” >> tmax ;
35 fin >> ”methode” >> method ;
36
37 func_kepler deriv ;
38 int N=4;
39 ODE_solver<func_kepler> ode(N,deriv,accur,h) ;
. 40
25
41 Vector<double> x(N) ; valeurs initiales

42 fin >> ”x0” >> x ;
43 fin.close() ;
44
45 ofstream fout(”out.dat”) ; ouverture du fichier de sortie

46 if(method==”euler”) ode.solve_euler(tmax,x,fout) ; action selon la méthode choisie
47 else if(method==”RK2”) ode.solve_RK2(tmax,x,fout) ;
48 else if(method==”RK4”) ode.solve_RK4(tmax,x,fout) ;
49 else if(method==”RK_adapt”) ode.solve_RKadapt(tmax,x,fout) ;
50 else{
51 cout << ”Méthode inconnue !” << endl ;
52 exit(1) ;
53 }
54 cout << method << ” : ” << deriv.count << ” évaluations requises\n” ;
55 cout << ”exécution terminée” << endl ;
56 }
.
Explications :
1. On doit au début du code inclure le fichier d’entête RK.h, et ce dernier doit être placé dans un
répertoire accessible (soit le même répertoire que le fichier maître, soit un des répertoire qui
figure dans la liste des fichiers d’inclusion ; voir la documentation de l’IDE à cet effet).
2. Le code fait appel à une routine utilitaire définie dans read_parameter.h utilisée pour lire
des mots-clés à partir d’un fichier d’entrée. L’énoncé
fin >> ”nom_de_variable”>> valeur
effectue la recherche de la chaîne de caractères nom_de_variable dans le fichier d’entrée (ici
in.dat) et, une fois la chaîne trouvée, lit la variable qui suit immédiatement. On peut ainsi fa-
cilement récupérer les valeurs de paramètres à partir d’un fichier d’entrée en lisant des paires
nom/valeur. L’ordre dans lequel ces paires sont inscrites dans le fichier d’entrée n’est pas im-
portant ; ce dernier peut aussi contenir d’autres chaînes de caractères qui ne sont jamais lues
(des commentaires, etc.) sans dommage : c’est la première occurence de la chaîne recherchée
qui compte.
2.4 Autres méthodes
La méthode de Runge-Kutta est couramment utilisée pour résoudre des systèmes d’équations diffé-
rentielles. Peut-être est-elle même la plus souvent utilisée. Par contre, elle n’est pas nécessairement
la plus précise ou la plus performante.
2.4.1 Méthode de Richardson
Une façon ingénieuse d’augmenter la précision d’une méthode est de procéder, sur un intervalle h
donné, à une subdivision en m sous-intervalles équidistants. On traite ensuite le problème pour cha-
cun des sous-intervalles de dimension η = h/m , de manière à obtenir un prédicteur x(t + h) pour
quelques valeurs de m (par exemple m =2, 4, 6) et on extrapole vers m → ∞ (ou η → 0). Cette méthode,
dite de Richardson, suppose que le prédicteur x(t +h) est une fonction analytique de h autour de h = 0,
et qu’une extrapolation, par exemple polynomiale, nous donne accès à cette limite.
On se trouve ici à travailler avec un pas h/m fixe dans un intervalle donné, mais un contrôle de
précision peut aussi être appliqué subséquemment à la valeur de h elle-même, de manière à s’adapter
à une précision requise.
26
2.4. Autres méthodes
Une façon simple de procéder avec m sous-intervalles est la méthode aux différences modifiées (angl.
modified midpoint method), qui évalue la dérivée à partir de l’instant suivant et de l’instant précédent
(sauf aux extrémités) :
xn,0 = xn
def h
xn,1 = xn,0 + ηf(x0 , t ) η =
m
xn,2 = xn,0 + 2ηf(xn,1 , t + η)
... (2.27)
xn, j +1 = xn, j −1 + 2ηf(xn, j , t + j η)

...
1
( )
xn+1 = 2 xn,m + xn,m−1 + ηf(xn,m , t + h)
Notons que nous avons introduit une sous-numérotation des intervalles, xn, j désignant la j me valeur
dans l’intervalle no n . Cette méthode requiert de conserver en mémoire non seulement la valeur cou-
rante de xn, j , mais la valeur précédente xn, j −1 , ce qui n’est pas un problème. Par contre, les permières
et dernières valeurs ( j = 0 et j = m ) requièrent un traitement spécial.
Suite à ce calcul pour différentes valeurs de m , on pourrait procéder à une extrapolation de Richardson
pour obtenir une estimation optimale de xn , et ensuite passer à l’intervalle h suivant. On obtient ainsi
la méthode de Bulirsch-Stoer. Voir Numerical Recipes Pour plus de détails.
2.4.2 Méthode d’Adams
L’idée de base derrière la méthode d’Adams est d’utiliser les s points précédents d’une solution nu-
mérique afin de prédire le prochain point, à l’aide d’une extrapolation polynomiale. Il existe deux
variantes :
1. la méthode d’Adams-Bashforth, qui prédit xn+1 à l’aide des s points xn , xn−1 , xn−s+1 et des déri-
def
vées correspondantes fi = f(xi , t i ). C’est une méthode d’ordre s .
2. La méthode d’Adams-Moulton, qui prédit xn + 1 à l’aide, en plus des s points précédents, d’un
pr.
prédicteur xn+1 sur la valeur de xn+1 . C’est une méthode d’ordre s + 1.
Méthode d’Adams-Balforth
Pour s = 1, la méthode d’Adams-Balforth coïncide avec la méthode d’Euler. Voyons ce qu’elle donne
pour s = 2. Afin de simplifier la notation, posons n = 1, de sorte qu’on vise à prédire x2 à l’aide de x1 ,
x0 , f1 et f0 . On suppose en outre que les temps t i sont disposés uniformément, avec un pas temporel
h . On remplace la fonction f(x(t ), t ), qui est inconnue car x(t ) n’est pas connu explicitement, par une
extrapolation linéaire obtenue des deux points précédents :
t − t1 t − t0 1 1
f (x(t ), t ) → P 1 (t ) = f0 + f1 = [−(t − t 1 )f0 + (t − t 0 )f1 ] = [t (f1 − f0 ) + t 1 f0 − t 0 f1 ] (2.28)
t0 − t1 t1 − t0 h h
Ensuite, on calcule simplement l’intégrale de cette fonction pour obtenir x(t 2 ) :

∫ t2
x2 = x1 + P 1 (t ) dt
t1
1 1
= x1 + (f1 − f0 )(t 22 − t 12 ) + (t 1 f0 − t 0 f1 )(t 2 − t 1 )
2h h
1 (2.29)
= x1 + (f1 − f0 )(t 2 + t 1 ) + t 1 f0 − t 0 f1
2
1 1
= x1 + f1 (t 2 + t 1 − 2t 0 ) + f0 (t 1 − t 2 )
2 2
3 1
= x1 + hf1 − hf0
2 2
27
À l’ordre s = 3, on devrait utiliser les trois derniers points x0,1,2 , et prédire x4 à l’aide du polynôme
d’ordre deux unique qui passe par ces trois points, donné par la formule de Lagrange (éq. (3.8), à la
page 35) :
(t − t 1 )(t 1 − t 2 )(t − t 2 ) (t 0 − t )(t − t 2 )(t 0 − t 2 ) (t 0 − t 1 )(t 1 − t )(t 0 − t )

f (x(t ), t ) → P 2 (t ) = f0 + f1 + f2 (2.30)
(t 0 − t 1 )(t 1 − t 2 )(t 0 − t 2 ) (t 0 − t 1 )(t 1 − t 2 )(t 0 − t 2 ) (t 0 − t 1 )(t 1 − t 2 )(t 0 − t 2 )
et ainsi de suite, pour les ordres supérieurs.
Au total, pour les cinq premiers ordres, on obtient les règles suivantes :
s =1 xn+1 = xn + hfn (Euler) (2.31)

h ( )
s =2 xn+1 = xn + 3fn − fn−1 (2.32)
2
h( )
s =3 xn+1 = xn + 23fn − 16fn−1 + 5fn−2 (2.33)
12
h( )
s =4 xn+1 = xn + 55fn − 59fn−1 + 37fn−2 − 9fn−3 (2.34)
24
Méthode d’Adams-Moulton
La méthode d’Adams-Moulton utilise les s points précédents et le point désiré xn+1 dans l’extrapola-
tion. Considérons par exemple le cas s = 1. Reprenons la formule (2.28) ci-dessus, sauf que cette fois
n = 0 et x1 est inconnu. Dans ce cas,
∫ t1
x1 = x0 + P 1 (t ) dt
t0
1 1
= x0 + (f1 − f0 )(t 12 − t 02 ) + (t 1 f0 − t 0 f1 )(t 1 − t 0 )
2h h (2.35)
1
= x0 + (f1 − f0 )(t 1 + t 0 ) + t 1 f0 − t 0 f1
2
h
= x0 + (f1 + f0 )
2
On reconnait dans cette dernière équation la méthode prédicteur-correcteur (2.13), pourvu que la
valeur de x1 utilisée dans le membre de droite soit un prédicteur, par exemple obtenu par la méthode
d’Euler.
Pour les quatre premiers ordres, on obtient les règles suivantes par cette méthode :
h( )
s =1 xn+1 = xn + fn+1 + fn (2.36)
2
h( )
s =2 xn+1 = xn + 5fn+1 + 8fn − fn−1 (2.37)
12
h( )
s =3 xn+1 = xn + 9fn+1 + 19fn − 5fn−1 + fn−2 (2.38)
24
h ( )
s =4 xn+1 = xn + 241fn+1 + 646fn − 264fn−1 + 106fn−2 − 19fn−3 (2.39)
720
En pratique, la valeur de fn+1 doit être obtenue par une méthode explicite, à l’ordre précédent, soit
par la méthode d’Adams-Bashforth au même s . Ainsi, en substituant (2.31) dans (2.36) pour la valeur
de xn+1 dans fn+1 , on obtient la méthode prédicteur-correcteur (2.13). En substituant plutôt la valeur
(2.34) de xn+1 dans (2.39), on obtient une méthode d’ordre 5 qui ne demande que deux évaluations de
la fonction f par étape ! Cependant, cette méthode demande un pas temporel h constant.
28
2.5. Simulation de particules : méthode de Verlet
2.5 Simulation de particules : méthode de Verlet
L’une des applications les plus répandues du calcul scientifique est la simulation du mouvement d’un
grand nombre de particules sous l’influence de forces mutuelles et externes. L’objectif de ces simu-
lations est typiquement de comprendre le comportement statistique de la matière, d’où le nom dy-
namique moléculaire donné à ce champ d’applications. Même s’il est en principe préférable d’utiliser
la mécanique quantique pour décrire le mouvement des atomes et des molécules, il est acceptable
d’utiliser la mécanique classique pour ce faire si les longueurs d’ondes impliquées sont suffisamment
petites par rapport aux distances inter-moléculaires. D’autres applications de ce genre sont aussi très
éloignées du domaine quantique, par exemple dans le domaine astronomique.
La dynamique moléculaire est un domaine vaste ; il est hors de question de lui rendre justice dans cette
section. Nous allons uniquement décrire l’algorithme de Verlet, utilisé pour résoudre les équations
du mouvement des particules impliquées. Au fond, il s’agit ici de résoudre un sytème d’équations
différentielles, représentant les équations du mouvement de Newton, mais à un nombre plutôt grand
de particules. Pourquoi ne pas simplement utiliser la méthode de Runge-Kutta avec pas contrôlé ?
C’est une possibilité, mais l’algorithme que nous présenterons plus bas est plus simple, du deuxième
ordre, et se compare à la méthode prédicteur-correcteur. La solution ne sera peut-être pas aussi précise
que celle obtenue par Runge-Kutta à pas adapté, mais le calcul sera par contre plus rapide. Par contre,
nous allons quand même utiliser un pas temporel variable : c’est une caractéristique essentielle à toute
méthode alliant précision et rapidité. Notons que l’intérêt de la simulation n’est pas ici de suivre à la
trace chaque particule, mais de dégager le comportement de l’ensemble.
Soit donc un ensemble de N particules, de positions ri et de vitesses vi . Chaque particule ressent

une force Fi qui dépend en principe le la position de toutes les particules, ainsi que de la vitesse vi ,
si on veut tenir compte de processus d’amortissement (par exemple le rayonnement ou la diffusion
de chaleur). Nous avons donc à résoudre le système d’équations différentielles suivant pour les 2N
vecteurs ri et vi :
dri dvi 1
= vi = Fi (r j , vi , t ) (2.40)
dt dt m
La méthode de Verlet est basée sur une formule du deuxième ordre pour l’évaluation des dérivées :

h2
ri (t + h) = ri (t ) + hvi (t ) + Fi (t ) + O (h 4 )
2m i
(2.41)
h [ ]
vi (t + h) = vi (t ) + Fi (t + h) + Fi (t ) + O (h 3 )
2m i

L’important ici est que toutes les positions doivent être mises à jour avant que les vitesses le soient, car
la force Fi (t + h) doit être calculée entretemps. Ceci suppose que la force ne dépend que des positions.
Noter que nous avons supposé que la masse m i peut être différente d’une particule à l’autre.
Si on ajoute à la force une composante qui dépend de la vitesse, dans le but de modéliser un amortis-
sement par exemple, alors il est nécessaire de traiter cette partie au premier ordre seulement, comme
dans la méthode d’Euler ; mais comme l’amortissement est généralement un effet petit, cela ne change
pas de manière appréciable la précision de la méthode. On écrirait dans ce cas, par exemple,
h
vi (t + h) = (1 − hγ)vi (t ) + [Fi (t + h) + Fi (t )] (2.42)
2m i
où γ est la force d’amortissement par unité de masse.
29
2.5.1 Exemple : impact d’un objet sur un solide
Nous allons étudier par la méthode de Verlet un ensemble de particules exerçant les unes sur les
autres une force centrale constante en deça d’un certain domaine. Cette force sera dérivée du potentiel
illustré à la figure 2.2, et aura la forme suivante :

 V − V1
 0
 si r < r0

 r0



F (r ) = V1 (2.43)
 si r0 < r < rm
 rm − r0






0 si r > rm
Cette loi de force est une caricature simple d’une attraction à distances modérées, et d’une répulsion
à courte distance, avec une distance d’équilibre r 0 . Un potentiel d’interaction plus réaliste serait le
V0
V (r )
r0 rm
r
V1
F 2.2
célèbre potentiel de Lennard-Jones :

[( ]
r 0 )12 ( r 0 )6
V (r ) = 4V0 − (2.44)
r r
code : MD_solver.h, MD.cpp — page 171
2.5.2 Complexité algorithmique des simulations de particules
La méthode de Verlet que nous avons présentée a, dans sa version simple, un grave défaut : le temps de
calcul des forces est proportionnel au nombre de paires de particules, soit 12 N (N − 1), qui se comporte
comme O (N 2 ) quand N est grand. Si on désire simuler un très grand nombre de particules, l’évaluation
des forces va simplement devenir trop onéreuse et la simulation impossible.
La solution, bien-sûr, est que les forces décroissent rapidement avec la distance. Donc il n’est pas
nécessaire de calculer tous les détails des forces pour des particules qui sont éloignées l’une de l’autre.
Deux possibilités générales se présentent :
1. Si la force est à courte portée, en particulier si elle décroît plus rapidement que 1/r 2 en di-
mension trois, alors on peut négliger les particules qui sont trop éloignées. Supposons pour
les fins de l’argument qu’on peut négliger toutes les forces mutuelles au-delà d’une certaine
distance R . C’est effectivement ce qui est fait dans le code présenté ci-haut. Cependant, ce code
doit tout-de-même effectuer une boucle sur toutes les paires de particules pour vérifier si les
distances sont inférieures à R , ce qui ne règle pas le problème de la complexité algorithmique
d’ordre N 2 . Pour s’en sortir, il faut une représentation des données différentes, dans laquelle
on peut avoir accès directement aux particules qui sont dans une région donnée, sans avoir
à chercher le tableau contenant les positions des particules. Par exemple, on pourrait diviser
l’espace en un réseau de cellules identiques de taille R , et construire une liste dynamique des
particules qui résident à un instant donné dans chaque cellule. Dans le calcul des forces, nous
30
2.5. Simulation de particules : méthode de Verlet
n’aurions alors qu’à considérer les particules qui résident dans une cellule donnée et les cel-
lules immédiatement voisines. La complexité algorithmique serait réduite à O (Mn 2 ) = O (N n),
M = N /n étant le nombre de cellules et n le nombre de particule par cellule. Un tel schéma
demande bien sûr à garder trace des particules qui passent d’une cellule à l’autre lors d’un pas
temporel. En pratique, on définirait des cellules qui se chevauchent sur une distance égale à la
portée de la force, comportant chacune une région intérieure et une région périphérique : il ne
serait alors pas requis de sortir de la cellule pour calculer les forces et seules les particules de
la région intérieure seraient propagées : celles de la région périphérique étant en même temps
dans la région intérieure d’une cellule voisine, elles ne servent dans la cellule courante qu’au
calcul des forces.
2. Si les forces sont à longue portée, comme la force gravitationnelle, alors on ne peut pas simple-
ment ignorer les particules éloignées. La raison étant que même si la force décroît comme 1/r 2 ,
le nombre de particules situées à une distance d’ordre r d’un point donné croît comme r 2 quand
la densité est du même ordre partout ; donc on commetterait une erreur grave en ignorant les
particules éloignées. Cependant, on peut appliquer dans ce cas le développement multipolaire
et considérer l’influence de groupes de particules et non de particules individuelles. Une façon
de procéder est de construire un réseau de cellules comme au cas précédent, mais en plus de les
organiser en une hiérarchie de super-cellules à plusieurs niveaux : les cellules de taille R sont
contenues dans des super-cellules de taille 3R , elles-mêmes contenues dans des super-cellules
de taille 32 R , et ainsi de suite. Dans le calcul des forces, on calcule quelques multipôles produits
par chaque cellule d’un niveau donné, qui ensuite servent à calculer les multipôles du niveau
supérieur de cellules, etc. De cette manière, la complexité algorithmique du problème passe de
O (N 2 ) à O (N log N ) (le nombre de niveaux de cellules étant d’ordre log(N ). Ce qui présente est
une caricature de ce qui est en fait accompli dans ces algorithmes dits de multipôles rapides,
mais l’idée de base est la même.
2.5.3 Aspects quantiques et statistiques
Dans le domaine microscopique, on peut se demander si la mécanique classique est appropriée pour
décrire le mouvement des molécules. En réalité, seul le mouvement des ions est déterminé classique-
ment ; les forces inter-moléculaires dépendent cependant des configurations électroniques qui, elles,
ne peuvent être déterminées que par la mécanique quantique. Les véritables simulations de dyna-
mique moléculaire tiennent donc compte de la mécanique quantique, à un certain degré d’approxima-
tion, dans le calcul des forces. Une avancée considérable a été accomplie dans ce domaine par Car et
Parinello en 1985 avec l’introduction d’une méthode rapide permettant d’avancer dans les temps les
configurations électroniques en même temps que les positions des ions. Lorsqu’un calcul quantique
– même approximatif – des forces inter-ioniques est effectué, on parle de dynamique moléculaire ab
initio. Sinon, il s’agit de dynamique moléculaire classique.
Les systèmes simples qui sont simulés par le code décrit plus haut sont décrits par l’ensemble micro-
canonique : le nombre de particules et l’énergie du système sont constants (sauf si on inclut un amor-
tissement). Il peut être cependant plus réaliste, en simulant un système complexe, de supposer que
ce système est lui-même un sous-ensemble d’un système encore plus grand, avec lequel il échange
de l’énergie et, à la rigueur, des particules. Autrement dit, on peut simuler le système en le mettant
en contact avec un environnement caractérisé par une température T (ensemble canonique). La si-
mulation doit alors comporter un procédure pour communiquer aux particules qui parviennent à la
frontière du domaine étudié une signature de leur interaction avec l’environnement, par exemple une
variation de l’énergie, caractéristique de l’ensemble canonique. On peut aussi ajouter une force aléa-
toire agissant sur chaque particule qui, combinée à un terme d’amortissement γ, permet de reproduire
une distribution canonique (dynamique de Langevin).
31
32
3
Représentations des fonctions
L’utilisation en physique et en génie de fonctions de l’espace, ou champs, est omniprésente. Dans la

plupart des cas, l’utilisation d’un continuum est elle-même l’approximation d’une réalité sous-jacente
discontinue. Par exemple, la théorie de l’élasticité ou de la propagation des ondes dans les milieux re-
pose sur l’approximation du continuum, alors qu’un traitement plus fondamental devrait tenir compte
de la structure des milieux en question à l’échelle moléculaire. Cette approximation du continuum
est cependant très utile car elle offre une description de ces systèmes indépendante des détails mi-
croscopiques et reposant sur certaines équations différentielles, telles l’équation d’onde, l’équation de
Navier-Stokes en mécanique des fluides, etc.
Ces équations différentielles aux dérivées partielles, quand elles sont à leur tour traitées numéri-
quement, doivent faire l’objet d’une rediscrétisation, car les calculateurs ne peuvent traiter que des
problèmes finis. Il ne s’agit pas bien sûr de retourner, dans ces descriptions disrètes des sytèmes étu-
diés, à une description microscopique exacte du problème. On cherche simplement une formulation
approchée, un problème différent, qui redonne cependant la même théorie continue dans une certaine
limite.
Bref, un problème central du calcul scientifique est la représentation approximative de fonctions

continues et des opérations qu’on effectue sur ces fonctions, comme la différentiation, l’intégration, la
transformation de Fourier, etc. C’est l’objet de ce chapitre.
3.1 Différences finies
L’approche la plus simple, et malheureusement la plus limitée, à la représentation des fonctions est de
considérer une grille uniforme de points et de s’en tenir là ; c’est-à-dire de ne rien supposer sur l’exis-
tence d’une fonction en dehors de ces points. Considérons, pour simplifier les choses, le cas d’une seule
dimension, dans un intervalle fini [0, ℓ] de la coordonnée x . On suppose que la grille est constituée de
N points x i définis comme suit :
ℓ
xi = i a i = 0, 1, . . . , N − 1 a= (3.1)
N −1
Si l’intervalle est périodique, c’est-à-dire si les points x = 0 et x = ℓ sont les mêmes, alors il faut
imposer cette condition périodique et retrancher l’une des extrémités. Une fonction ψ(x) devient alors
un tableau de N valeurs ψi .
Si on veut cependant définir des opérations comme la différentiation ou l’intégration de fonctions, il

est nécessaire de supposer que la grille {x i } n’est qu’un échantillonage d’un intervalle continu et que
le tableau ψi l’échantillonage correspondant d’une fonction ψ(x) qui possède certaines propriétés de
continuité de différentiabilité, etc.
33
Chapitre 3. Représentations des fonctions
L’opération de différentiation D x ψ pourrait être numériquement définie de diverses façon, mais celle
qui converge le plus rapidement quand a → 0 est l’expression du deuxième ordre
ψi +1 − ψi −1
(D x ψ)i = i = 1, 2, . . . , N − 2 (3.2)
2a
Le cas des extrémités demande réflexion. Si les conditions aux limites sont périodiques, le problème
se règle de lui-même de manière évidente. Sinon nous sommes limités à une expression du premier
ordre aux extrémités :
ψ1 − ψ0 ψN −1 − ψN −2
(D x ψ)0 = (D x ψ)N −1 = (3.3)
a a
La dérivée seconde, elle, serait estimée de la manière suivante :
ψi +1 − 2ψi + ψi −1
(D 2x ψ)i = i = 1, 2, . . . , N − 2 (3.4)
a2
les extrémités, encore une fois, nécéssitant un traitement spécial.
De même, l’intégration de la fonction ψ de 0 à ℓ pourrait à première vue se faire strictement par la

sommation de ses valeurs :
∫ ℓ N∑
−1
dx ψ(x) → a ψi (3.5)
0 i =0
Cependant, dans le cas de conditions aux limites non périodiques, chaque point d’extrémité ne compte
que pour la moitié d’un intervalle, de sorte que la formule d’intégration doit alors être
∫ ℓ N∑ −2
a
dx ψ(x) → (ψ0 + ψN −1 ) + a ψi (3.6)
0 2 i =1
Cette formule est la célèbre formule des trapèzes pour l’intégration d’une fonction, illustrée à la figure
3.1.
F 3.1
Illustration de la méthode des trapèzes. Notez que l’aire des rectangles ombragés est la même que l’aire limitée
par les segments linéaires qui forment des trapèzes.
3.1.1 Interpolation
Sachant que la fonction ψ(x) existe, on peut supposer qu’elle est analytique, c’est-à-dire qu’elle peut
être représentée par un développement en série de Taylor
ψ(x + ϵ) = ψ(x) + ϵψ′ (x) + 21 ϵ2 ψ′′ (x) + · · · (3.7)
autour de chaque point de l’intervalle, sauf de possibles exceptions en nombre fini.
Cela entraîne que la fonction, dans un domaine limité autour de chaque point, peut être adéquatement
représentée par un polynôme en tronquant cette série. Nous pourrions donc évaluer approximative-
ment la fonction ψ(x) en tout point, même si elle n’est connue que sur une grille discrète, en procédant
34
3.1. Différences finies
à une interpolation polynomiale. La précision de cette approximation sera en proportion du degré du

polynôme utilisé.
Les polynômes en question se trouvent par la formule de Lagrange. Si on connait la fonction ψi =

ψ(x i ) à M points notés x 0 , . . . , x M −1 (attention : M n’est pas nécessairement égal à N , mais peut ne
représenter qu’un petit sous-ensemble de points contigus) alors le polynôme de degré M − 1 unique
qui passe par tous ces points est
(x − x 1 )(x − x 2 ) · · · (x − x M −1 ) (x − x 0 )(x − x 2 ) · · · (x − x M −1 )
P (x) = ψ0 + ψ1 + · · ·
(x 0 − x 1 )(x 0 − x 2 ) · · · (x 0 − x M −1 ) (x 1 − x 0 )(x 1 − x 2 ) · · · (x 1 − x M −1 )
(x − x 0 )(x − x 1 ) · · · (x − x M −2 )
+ ψM −1
(x M −1 − x 0 )(x M −1 − x 1 ) · · · (x M −1 − x M −2 ) (3.8)
 
M∑−1 M
 ∏ −1 x − x
i 
=  ψj 
j =0 i x j − xi
(i ̸= j )
Il est manifeste que ce polynôme est de degré M − 1, car chaque terme est le produit de M − 1 facteurs
impliquant x . D’autre part, le coefficient du terme de degré M − 1 est
[ ]
M∑ −1 M ∏ −1 1
ψj (3.9)
j =0 i (i ̸= j ) x j − x i
et ce terme est généralement non nul (il peut l’être accidentellement, bien sûr). Ensuite, ce polynôme
passe manifestement par tous les points (x i , ψi ), car si x = x k , seul le terme j = k de la somme est non
nul et la fraction correspondante est alors égale à l’unité, ne laissant que P (x k ) = ψk . La contrainte
que le polynôme passe par M − 1 points donnés fixe complètement les M − 1 paramètres nécessaires
pour spécifier uniquement un polynôme de degré M − 1. La solution de Lagrange est donc unique.
Par exemple, la formule d’interpolation linéaire entre deux points x 0 et x 1 est

x − x1 x − x0
P (x) = ψ0 + ψ1 (3.10)
x0 − x1 x1 − x0
et la formule d’interpolation quadratique entre trois points x 0,1,2 est
(x − x 1 )(x − x 2 ) (x − x 0 )(x − x 2 ) (x − x 0 )(x − x 1 )

P (x) = ψ0 + ψ1 + ψ2 (3.11)
(x 0 − x 1 )(x 0 − x 2 ) (x 1 − x 0 )(x 1 − x 2 ) (x 2 − x 0 )(x 2 − x 1 )
Il est possible de coder directement la formule de Lagrange (3.8), mais un algorithme plus efficace
existe pour cela, et donne accès à l’erreur commise entre les interpolations de degré M − 2 et M − 1. 1
3.1.2 Cubiques raccordées
L’interpolation linéaire d’une fonction, d’un point à l’autre de la grille, produit une fonction approchée
dont la dérivée seconde est nulle partout, sauf aux points de grille où elle est infinie. Pour pallier ce
problème, on a fréquemment recours aux cubiques raccordées (angl. cubic splines) : il s’agit d’une ap-
proximation cubique qui a l’avantage de produire une fonction approchée dont les dérivées premières
et secondes sont continues aux points de grilles.
Étant donnés deux points x i et x i +1 de la grille, le polynôme cubique P i (x) à 4 paramètres doit alors
obéir à 4 conditions :
P i (x i ) = ψ(x i ) P i (x i +1 ) = ψ(x i +1 ) P i′ (x i ) = P i′ −1 (x i ) P i′′ (x i ) = P i′′−1 (x i ) (3.12)
ce qui le détermine uniquement. Notez que les contraintes d’égalité des dérivées première et seconde
au point x i +1 s’appliquent au polynôme P i +1 (x) dans cette convention. Reste l’éternel problème des
extrémités. Plusieurs possibilités existent ;
1. Voir Numerical Recipes, section 3.2.
35
1.2
ψ(x) = sin2 (πx)
1
0.8
0.6
0.4
0.2
0
0 0.5 1 1.5 2
5
4.5 ψ(x)
4 cubiques
3.5 linéaire
3 polynôme
2.5
2
1.5
1 ψ(x) = |x|
0.5
0
-4 -3 -2 -1 0 1 2 3 4
0.6
0.4 ψ(x) = x/(1 + x2 )
0.2
0
-0.2
-0.4
-0.6
-4 -3 -2 -1 0 1 2 3 4
F 3.2
Exemples d’interpolation à l’aide de cubiques raccordées. Remarquons que les cubiques naturelles s’accordent
mal aux extrémités lorsque la dérivée seconde est non négligeable à ces points (graphique du haut) et qu’elles
représentent en général assez mal les points où la dérivée seconde est infinie (graphique du milieu). Les
points de la grille sont indiqués, et sont peu nombreux. L’interpolant de Lagrange basé sur les 9 points de
l’échantillon est aussi illustré ; son comportement est très oscillant par rapport aux cubiques raccordées.
1. On peut imposer une valeur nulle des dérivées secondes aux deux extrémités, et obtenir ce
qu’on appelles des cubiques raccordées naturelles.
2. On peut obéir à des conditions aux limites externes qui fixent les valeurs de la dérivée première
aux deux extrémités, ce qui permet de déterminer les dérivées secondes.
Démontrons maintenant explicitement comment produire le polynôme interpolant. Rappelons que

l’interpolation linéaire a la forme
x − x i +1 x − xi
P (x) = Aψi + B ψi +1 où A= et B = 1 − A = (3.13)
x i − x i +1 x i +1 − x i
Une interpolation cubique peut être mise sous la forme suivante :
P i (x) = a(x − x i ) + c(x − x i )3 + b(x − x i +1 ) + d (x − x i +1 )3 (3.14)
Cette forme contient 4 paramètres à déterminer, donc suffisamment générale pour un polynôme cu-
bique. Pour déterminer ces 4 paramètres, nous allons imposer les valeurs de la fonction aux deux
extrémités de l’intervalle : P (x i ) = ψi et P (x i +1 ) = ψi +1 . Nous allons également supposer connues les
deuxièmes dérivées au mêmes points : P ′′ (x i ) = ψ′′i et P ′′ (x i +1 ) = ψ′′i +1 . Ceci mène aux équations sui-
36
3.1. Différences finies
vantes :
′′
ψi +1 1 1 ψi +1
a= − ψ′′i +1 (x i +1 − x i ) c=
x i +1 − x i 6 6 x i +1 − x i
(3.15)
ψi 1 1 ψ′′i
b= − ψ′′i (x i − x i +1 ) d=
x i − x i +1 6 6 x i − x i +1
ce qui équivaut à la forme suivante pour le polynôme interpolant :
1 1
P i (x) = Aψi + (A 3 − A)ψ′′i (x i − x i +1 )2 + B ψi +1 + (B 3 − B )ψ′′i +1 (x i − x i +1 )2 (3.16)
6 6
A et B étant définis en (3.13). Attention à la notation cependant : les valeurs ψ′′i et ψ′′i +1 ne sont pas né-
cessairement les vraies dérivées secondes de la fonction ψ(x) sous-jacente, alors qu’on suppose que les
valeurs ψi sont véritablement ψ(x i ). Ce sont plutôt les dérivées secondes des polynômes interpolants,
que nous allons raccorder à chaque point.
La condition qui nous manque pour déterminer ψ′′i est la continuité de la dérivée à chaque point. On
calcule à cette fin que
ψi +1 − ψi 1 [ ]
P i′ (x) = − (3A 2 − 1)ψ′′i − (3B 2 − 1)ψ′′i +1 (x i +1 − x i ) (3.17)
x i +1 − x i 6
et donc que
ψi +1 − ψi 1
P i′ (x i ) = − (2ψ′′i + ψ′′i +1 )(x i +1 − x i )
x i +1 − x i 6
(3.18)
′ ψi +1 − ψi 1 ′′
P i (x i +1 ) = + (ψi + 2ψ′′i +1 )(x i +1 − x i )
x i +1 − x i 6
La condition manquante est alors P i′ (x i ) = P i′ −1 (x i ), ou encore
ψi − ψi +1 1 ψi −1 − ψi 1 ′′
− (2ψ′′i + ψ′′i +1 )(x i +1 − x i ) = + (ψi −1 + 2ψ′′i )(x i − x i −1 ) (3.19)
x i +1 − x i 6 x i − x i −1 6
ce qui s’exprime également comme

x i − x i −1 ′′ x i +1 − x i −1 ′′ x i +1 − x i ′′ ψi +1 − ψi ψi − ψi −1
ψi −1 + ψi + ψi +1 = − (3.20)
6 3 6 x i +1 − x i x i − x i −1
Il s’agit d’un système d’équations linéaires qui nous permet de déterminer les dérivées secondes ψ′′i ,
connaissant les points x i et les valeurs ψi de la fonction. Ce système est tridiagonal, ce qui est un
avantage calculatoire : les systèmes tridiagonaux à N variables étant résolus par un algorithme de
complexité O (N ).
3.1.3 Intégration suite à une interpolation
L’interpolation d’une fonction permet d’en définir les intégrales et les dérivées, en fonction de l’inté-
grale et des dérivées de l’interpolant. Par exemple, l’interpolation linéaire d’une fonction ψ(x) nous
mène à l’expression suivante pour son intégrale sur le domaine considéré :
∫ ℓ −2 ∫ x i +1 {
N∑ x − x i +1 x − xi
} N −2
∑ 1
dx ψ(x) → ψi + ψi +1 = (ψi + ψi +1 )(x i +1 − x i ) (3.21)
0 i =0 xi x i − x i +1 x i +1 − x i i =0 2
En considérant comment chaque terme de cette somme se combine avec les termes voisins, on trouve
∫ ℓ
1
[ ]
dx ψ(x) → 2 ψ0 (x 1 − x 0 ) + ψ1 (x 2 − x 0 ) + ψ2 (x 3 − x 1 ) + · · · + ψN −1 (x N −1 − x N −2 ) (3.22)
0
Notez encore une fois que les extrémités sont particulières. Il s’agit manifestement de la méthode des
trapèzes mentionnée plus haut. Pour une grille uniforme où x i +1 − x i = a , ceci devient simplement
∫ ℓ N∑
−2
dx ψ(x) → 12 a(ψ0 + ψN −1 ) + a ψi (3.23)
0 i =1
37
Erreur de troncature dans la formule des trapèzes

La formule des trapèzes se base sur l’intégrale suivante dans un intervalle élémentaire de largeur a :
∫ a 1 [ ]
dx ψ(x) ≈ a ψ(0) + ψ(a) (3.24)
0 2
Nous allons montrer que cette expression s’accompagne d’une erreur de troncature d’ordre O (a 3 ). Pour
ce faire, considérons les deux développements limités suivants, l’un autour de x = 0, l’autre autour de
x=a :
ψ(x) = ψ(0) + ψ′ (0)x + 21 ψ′′ (0)x 2 + O (a 3 )
(3.25)
ψ(x) = ψ(a) + ψ′ (a)(x − a) + 21 ψ′′ (a)(x − a)2 + O (a 3 )
Les intégrales des ces deux développements sur [0, a] donnent respectivement
∫ a
dx ψ(x) = aψ(0) + 12 a 2 ψ′ (0) + 61 a 3 ψ′′ (0) + O (a 4 )
0
∫ a (3.26)
dx ψ(x) = aψ(a) − 12 a 2 ψ′ (a) + 61 a 3 ψ′′ (a) + O (a 4 )
0
La moyenne de ces deux approximations est

∫ a [ ] [ ] 1 3 [ ′′ ]
dx ψ(x) = 12 a ψ(0) + ψ(a) + 14 a 2 ψ′ (0) − ψ′ (a) + 12 a ψ (0) + ψ′′ (a) + O (a 4 ) (3.27)
0
Mais, d’après le théorème de la moyenne,

[ ]
ψ′ (0) − ψ′ (a) = ψ′′ (x̄)a (3.28)
où x̄ est une valeur quelque part entre 0 et a . Donc finalement

∫ a 1 [ ]
dx ψ(x) = a ψ(0) + ψ(a) + O (a 3 ) (3.29)
0 2
En sommant les contributions des différents intervalles, on accumule les erreurs de troncature, com-
mettant une erreur d’ordre O (N a 3 ) = O (a 2 ) = O (1/N 2 ) car a = ℓ/(N − 1).
Formule de Simpson
Procédons maintenant à un ordre supérieur d’approximation et faisons passer une parabole entre
trois points de la grille (disons x 1 , x 2 et x 3 pour simplifier). Le polynôme unique passant pas ces
points est donné à l’équation (3.11). Supposons pour simplifier que la grille soit uniforme, de sorte
que x 3 − x 2 = x 2 − x 1 = a . L’expression (3.11) devient
x ( ) x2
P (x) = ψ1 + 3ψ1 − 4ψ2 + ψ3 + 2 (ψ1 − 2ψ2 + ψ3 ) (3.30)
2a 2a
L’intégrale de cette expression entre x 1 et x 3 est

∫ x3 ( )
1 4 1
dx P (x) = a ψ1 + ψ2 + ψ3 (3.31)
x1 3 3 3
Il s’agit de la règle de Simpson pour un intervalle simple. Appliquons maintenant cette formule à une
grille, en considérant les intervalles successifs [x 0 , x 2 ], [x 2 , x 4 ], etc. On trouve alors la règle de Simpson
étendue :
∫ ℓ ( )
1 4 2 4 2 4 1
dx ψ(x) ≈ a ψ0 + ψ1 + ψ2 + ψ3 + ψ4 + · · · + ψN −2 + ψN −1 (3.32)
0 3 3 3 3 3 3 3
(nous avons supposé que N est pair).
38
3.2. Polynômes orthogonaux
Problème 3.1
Montrez que l’erreur de troncature de la formule de Simpson étendue (3.32) est O (1/N 4 ). Utilisez la même
méthode que pour la méthode des trapèzes, en poussant le développement plus à un ordre plus élevé.
.
Pour ceux qui pourraient croire que l’alternance des 23 et des 43 dans la règle de Simpson étendue cache
une subtile compensation d’erreurs d’un terme à l’autre, signalons une autre formule d’intégration
d’ordre O (1/N 4 ) : 2
∫ ℓ ( )
3 7 23 23 7 3
dx ψ(x) ≈ a ψ0 + ψ1 + ψ2 + ψ3 + ψ4 + · · · + ψN −4 + ψN −3 + ψN −2 + ψN −1 (3.33)
0 8 6 24 24 6 8
3.2 Polynômes orthogonaux
3.2.1 Polynômes orthogonaux
Considérons les fonctions définies en une dimension sur l’intervalle [a, b]. Définissons sur cet inter-
valle un produit scalaire de fonctions par l’expression suivante :
∫ b
〈ψ|ψ′ 〉 = dx w(x)ψ(x)ψ′ (x) (3.34)
a
où w(x) est la fonction poids associée au produit scalaire. Cette fonction est par hypothèse partout
positive dans l’intervalle [a, b]. Nous pouvons toujours construire une base de polynômes p j (x) qui sont
orthogonaux par rapport à ce produit scalaire. En effet, il suffit de commencer par un polynôme de
degré 0, et ensuite d’ajouter à cette base des polynômes de degrés croissants obtenus par la procédure
d’orthogonalisation de Gram-Schmidt. Il n’est pas nécessaire de les normaliser : souvent, on préfère
travailler avec des polynômes dont le coefficient du plus haut degré est l’unité, c’est-à-dire p j (x) =
x j +a j , j −1 x j −1 +. . . (on dit qu’ils sont unitaires (angl. monic)). Ces polynômes ont donc la propriété que
∫ b
〈p i |p j 〉 = δi j γi ou w(x)p i (x)p j (x) = δi j γi (i , j = 0, 1, 2, . . . ) (3.35)
a
Les polynômes orthogonaux unitaires s’obtiennent de la relation de récurrence suivante :
def
p −1 (x) = 0
p 0 (x) = 1 (3.36)
p j +1 (x) = (x − a j )p j (x) − b j p j −1 (x)
où
〈xp j |p j 〉 〈p j |p j 〉
aj = ( j ≥ 0) bj = ( j ≥ 1) (3.37)
〈p j |p j 〉 〈p j −1 |p j −1 〉
Problème 3.2
Démontrez les relations (3.37), en supposant la récurrence (3.36) et l’orthogonalité. La solution trouvée
démontre alors que la relation de récurrence est correcte, ainsi que l’orthogonalité.
.
2. Voir [PTVF07], Section 4.1.3.
39
0.005
0.000
-0.005
-0.010
-1.0 -0.5 0.0 0.5 1.0
x
F 3.3
Polynômes unitaires de Legendre p 10 (x) (en bleu) et p 9 (x) (en rouge), avec leurs racines entrelacées.
Exemple 3.1 : Polynômes de Legendre

step
Les polynômes de Legendre correspondent au cas a = −1, b = 1 et w(x) = 1. En appliquant la relation de
récurrence, on trouve
p 0 (x) = 1 〈p 0 |p 0 〉 = 2 〈xp 0 |p 0 〉 = 0
2
p 1 (x) = x 〈p 1 |p 1 〉 = 〈xp 1 |p 1 〉 = 0
3
1 8 (3.38)
p 2 (x) = x 2 − 〈p 2 |p 2 〉 = 〈xp 2 |p 2 〉 = 0
3 45
3 3
p 3 (x) = x − x ... ...
5
Les polynômes de Legendre proprement dits (notés P n (x)) ne sont pas unitaires, mais sont normalisés par
la condition P n (1) = 1. En multipliant les polynômes unitaires ci-dessus par la constante appropriée, on
trouve alors
3 1 5 3
P 0 (x) = 1 , P 1 (x) = x , P 2 (x) = x 2 − , P 3 (x) = x 3 − , ··· (3.39)
2 2 2 2
.
Théorème 3.1 : Entrelacement des racines

step
Les racines de p j sont réelles et celles de p j −1 s’intercalent entre celles de p j .
Preuve :
Ce théorème se prouve par récurrence. Il est évident pour j = 0 (aucune racine). Supposons qu’il est vrai pour
p j et montrons qu’il doit alors être vrai pour j + 1. Soit x i (i = 1, 2, . . . , j ) les j racines de p j dans l’intervalle
[a, b]. Appliquons la relation de récurrence (3.36) au point x i :
def
p j +1 (x i ) = −b j p j −1 (x i ) p j (x i ) = 0 (3.40)
Comme les racines de p j −1 sont par hypothèse entrelacées avec celles de p j , le signe de p j (x i ) doit être
l’opposé de celui de p j (x i +1 ) (voir figure 3.3), car p j −1 change de signe exactement une fois entre x i et x i +1.
Comme b j est toujours positif, cela entraînes que p j +1 aussi change de signe entre ces deux valeurs, et
qu’il a au moins une racine entre x i et x i + 1. Il reste à montrer qu’en plus, p j +1 possède une racine dans
l’intervalle [x j , b] et une autre dans [a, x 1 ], c’est-à-dire à l’extérieur des racines de p j . Comme p j +1 a au
plus j + 1 racines, cela montrerait aussi qu’il y a exactement une racine de p j +1 entre x i et x i +1 . Or comme
p j −1 est unitaire et que sa dernière racine est plus petite que x j , il doit être positif à x j . Donc p j +1 (x j ) < 0,
alors que p j +1 est lui aussi unitaire ; donc il possède une racine plus élevée que x j car p j +1 (x) > 0 pour x
suffisamment grand. Le même argument s’applique pour x < x 1 , car p j +1 tend vers ±∞ quand x → −∞,
selon que j est impair ou pair.
.
40
Théorème 3.2 : Existence des racines dans l’intervalle d’orthogonalité

step
Le polynôme p j (x) a exactement j racines dans l’intervalle [a, b].
Preuve :
Encore une fois, nous procédons par récurrence, comme dans le théorème d’entrelacement. Par rapport à
la preuve précédente, il nous reste à prouver que les racines extrêmes de p j sont comprise dans l’intervalle
[a, b], si celles de p j −1 le sont. À cette fin, considérons la fonction
∏
s(x) = (x − x i ) (3.41)
x i ∈[a,b]
où le produit est restreint aux racines x i de p j qui sont dans l’intervalle [a, b]. La fonction s(x) est égale à
p j (x) si le théorème est vrai, car il s’agit alors simplement de la factorisation de p j en fonction de toutes
ses racines. Supposons au contraire que le théorème soit faux et montrons qu’on arrive à une contradiction.
La fonction s(x) est alors un polynôme de degré m < j . Ce polynôme peut alors s’exprimer comme une
combinaison linéaire des p k (x), (k = 1, 2, . . . , j − 1). Il est donc orthogonal à p j et
∫ b
w(x)s(x)p j (x) = 0 (3.42)
a
Mais comme s(x) s’annule exactement aux même points que p j (x) dans l’intervalle, il possède toujours le
même signe que p j (x) et donc l’intégrant est stricement positif dans l’intervalle et l’intégrale ne peut être
nulle. Donc s(x) = p j (x).
.
3.2.2 Quadratures gaussiennes
Les polynômes orthogonaux sont à la base d’une technique d’intégration très répandue : la quadrature
def
gaussienne. Supposons qu’on veuille intégrer une fonction y(x) = w(x) ỹ(x) dans l’intervalle [a, b]. En
se basant sur le théorème ci-dessous, on voit que l’estimation de l’intégrale
∫ b ∑
N
dx w(x) ỹ(x) par la somme w i ỹ(x i ) (3.43)
a i =1
est optimale si les n points de grille x i sont les racines du polynôme p N (x) dans [a, b], et les poids w i
la solution du système linéaire (3.44) ci-dessous. Dans ce cas, l’estimation de l’intégrale est exacte si
ỹ est un polynôme de degré 2N − 1 ou moins.
Théorème 3.3 : quadratures gaussiennes

step
Soit x i les N racines du polynôme orthogonal p N (x), et w i la solution du système linéaire suivant :
   
  w1 〈p 0 |p 0 〉
p 0 (x 1 ) p 0 (x 2 ) p 0 (x 3 ) ··· p 0 (x N )    
   w2  
  0 

 p 1 (x 1 ) p 1 (x 2 ) p 1 (x 3 ) ··· p 1 (x N )  
    
  w3  =  0  (3.44)
 .. .. .. ..  .
 
  .


 . . . . ···  .   .. 
 .   
p N −1 (x 1 ) p N −1 (x 2 ) p N −1 (x 3 ) ··· p N −1 (x N )
wN 0
Alors w i > 0 et
∫ b ∑
N
w(x)p(x) = w i p(x i ) (3.45)
a i =1
pour tout polynôme p(x) de degré 2N − 1 ou moins.
41
Preuve :
D’après la référence [SB02]. Considérons la matrice
 
p 0 (x 1 ) ··· p 0 (x N )
 
def  .. .. .. 
A =  . . .  (3.46)
 
p N −1 (x 1 ) ··· p N −1 (x N )
Cette matrice est non singulière, car les polynômes sont linéairement indépendants. Autrement dit, si elle
était singulière, il y aurait un vecteur (c 0 , . . . , c N −1 ) tel que c̃ A = 0 et donc le polynôme
N −1
def ∑
q(x) = c i p i (x) (3.47)
i =0
qui est au plus de degré N −1, aurait N racines distinctes x 1 , x 2 , . . . , x N , ce qui est impossible, à moins qu’il soit
identiquement nul, c’est-à-dire c = 0. Donc A est une matrice non singulière. Par conséquent, les coefficients
w i existent et leur valeur est unique.
Considérons ensuite un polynôme p(x) de degré 2N −1 au plus. Ce polynôme peut donc s’écrire comme p(x) =
p N (x)q(x) + r (x), où q(x) et r (x) sont des polynômes de degré N − 1 au plus. Ceci est vrai par construction
de la division longue des polynômes (comme pour la division des nombres en représentation décimale, qui
sont des polynômes en puissances de la base utilisée, à savoir 10). Le quotient q(x) et le reste r (x) peuvent
donc être développés sur la base des p j :
−1
N∑ −1
N∑
q(x) = α j p j (x) r (x) = β j p j (x) (3.48)
j =0 j =0
Comme p 0 (x) = 1, il s’ensuit que

∫ b
w(x)p(x) = 〈p N |q〉 + 〈r |p 0 〉 = β0 〈p 0 |p 0 〉 (3.49)
a
D’un autre côté,

∑
N ∑
N ∑ −1
N N∑
w i p(x i ) = w i r (x i ) = β j w i p j (x i ) = β0 〈p 0 |p 0 〉 (3.50)
i =1 i =1 i =1 j =0
Donc l’équation (3.45) est satisfaite. Il reste à démontrer que les poids w i sont positifs. À cet effet, considé-
rons le polynôme de degré 2N − 2
def ∏
N
p̄ j (x) = (x − x k )2 j = 1, . . . , N (3.51)
k=1,k̸= j
Ce polynôme est strictement positif, et donc l’intégrale suivante aussi :

∫ b ∑
N ∏
N
0< dx w(x)p̄ j (x) = w i p̄ j (x i ) = w j (x j − x k )2 (3.52)
a i =1 k=1
k̸= j
(seul le terme i = j de la somme survit). Comme le produit est nécessairement positif, w j l’est aussi.
.
Le choix de la classe de polynômes orthogonaux utilisés dépend du type de fonction qu’on veut intégrer.
Si on sait que les fonctions d’intérêt sont bien représentées par des polynômes, alors on choisit w(x) = 1
et les polynômes correspondants sont les polynômes de Legendre. Par contre, si la fonction d’intérêt
y(x) a des singularités ou un comportement tel que ỹ(x) = y(x)/w(x) est doux (ou bien représenté par
un polynôme), alors on choisit les polynômes qui sont orthogonaux par le poids w(x).
On démontre l’expression explicite suivante pour les poids w j :
〈p N −1 |p N −1 〉
wj = ′ (3.53)
p N −1 (x j )p N (x j )
′
où p N (x) est la dérivée de p N (x). Les poids w i et les abscisses x i sont tabulés pour les polynômes les
plus communs, mais on peut également les calculer explicitement.
42
0.1
10-4
D
10-7
10-10
10-13
0 10 20 30 40 50
n
F 3.4 ∫1
Graphique semi-logarithmique de l’erreur effectuée sur l’intégrale −1 dx (1+x)/(1+x 2 ) en fonction du nombre
n d’évaluations de l’intégrant (le résultat exact est π/2 et donc l’erreur est connue exactement). La courbe
supérieure provient de la méthode du trapèze ; la courbe médiane de la méthode de Simpson et la courbe du
bas de l’intégrale gaussienne avec polynômes de Legendre. Notez que dans ce dernier cas, l’erreur diminue
exponentiellement avec n .
Le théorème de la quadrature gaussienne nous permet de définir le produit scalaire suivant :
def ∑
N
〈ψ|ψ′ 〉g = w i ψ(x i )ψ′ (x i ) (3.54)
i =1
En autant que le produit des fonctions impliquées soit un polynôme de degré 2N − 1 ou moins, ce pro-
duit scalaire est identique au produit (3.34). On montre que la précision de la quadrature gaussienne
augmente exponentiellement avec N . C’est là que réside en principe son avantage principal. Notre
pratique sera donc d’utiliser la forme (3.54) du produit scalaire, en supposant qu’elle représente ef-
fectivement le produit (3.34), et nous ne ferons plus de distinction entre les deux du point de vue de
la notation.
3.2.3 Polynômes orthogonaux classiques
Généralement, les polynômes orthogonaux ne sont pas définis comme étant unitaires, mais respectent
plutôt une autre condition de normalisation. Par exemple, les polynômes de Legendre prennent la
valeur +1 à x = 1. Cela ne fait pas de différence sur la position des racines, mais change les coefficients
de la relation de récurrence (3.36). Ce changement de normalisation n’affecte en rien les propriétés
générales que nous avons décrites plus haut, en particulier la relation (3.53). Les propriétés de base
des polynômes les plus courants sont indiquées au tableau 3.1.
Polynômes de Legendre
Les polynômes de Legendre sont utiles dans le cas d’un intervalle fini (tout intervalle fini peut être
rapporté par une transformation affine à l’intervalle [−1, 1]). Les racines de P N (x) dans cet intervalle
doivent être trouvées numériquement, par la méthode de Newton par exemple (voir. la section 8.1.4).
Ceci est généralement vrai pour tous les polynômes orthogonaux (sauf les polynômes de Tchébychev
pour lesquels une expression explicite est connue). Mais la propriété d’entrelacement des racines
simplifie beaucoup cette recherche, car on peut procéder par récurrence et on connaît alors deux points
entre lesquels chaque racine se trouve avec certitude.
On utilise souvent les polynômes de Legendre dans des routines d’intégration numérique, où l’inter-
valle d’intégration est divisé en segments plus petits, de sorte qu’un petit nombre de points est requis
pour calculer l’intégrale sur chaque segment. Les racines et poids des polynômes de Legendre pour
de modestes valeurs de N sont alors requises ; elles sont données au tableau 3.2
43
Nom intervalle w(x) relation de récurrence norme h j
Legendre [−1, 1] 1 ( j + 1)P j +1 = (2 j + 1)xP j − j P j −1 2/(2 j + 1)

1
Tchébychev [−1, 1] (1 − x 2 )−1/2 T j +1 = 2xT j − T j −1 π(1 + δ j 0 )
2
2 p N
Hermite [−∞, ∞] e−x H j +1 = 2x H j − 2 j H j −1 π2 N !
Γ(α + j + 1)
Laguerre [0, ∞] x α e−x ( j + 1)L αj +1 = (−x + 2 j + α + 1)L αj
N!
−( j + α)L αj −1
T 3.1
Propriétés des polynômes orthogonaux les plus courants
N ±x i wi
2 0.5773502691896258 1.0
3 0 0.8888888888888889
0.7745966692414834 0.5555555555555556
4 0.3399810435848563 0.6521451548625462
0.8611363115940526 0.3478548451374539
5 0 0.5688888888888889
0.5384693101056831 0.4786286704993665
0.9061798459386640 0.2369268850561891
6 0.2386191860831969 0.4679139345726910
0.6612093864662645 0.3607615730481386
0.9324695142031520 0.1713244923791703
T 3.2
Racines et poids pour les premiers polynômes de Legendre
44
0.15
N = 18
0.1
wi
0.05
-1 -0.5 0 0.5 1
xi
F 3.5
Les racines et poids du polynôme de Legendre P 18 (x).
code : Gauss_Legendre.h — page 178
1.0
0.5
0.0
-0.5
-1.0
-1.0 -0.5 0.0 0.5 1.0
x
F 3.6
Les 7 premiers polynômes de Tchébychev
Polynômes de Tchébychev
Les polynômes de Tchébychev sont en un sens plus simples que les polynômes de Legendre, en raison
de leur relation avec les fonctions trigonométriques :
T j (x) = cos( j θ) où x = cos θ (3.55)
La relation d’orthogonalité se comprend alors facilement via les fonctions trigonométriques :

∫ ∫ π
1 T j (x)Tk (x) π
dx p = dθ cos( j θ) cos(kθ) = δ j k (1 + δ j 0 ) (3.56)
−1 1 − x2 0 2
La représentation d’une fonction sur la base des polynômes de Tchébychev s’apparente donc à une
série de Fourier ; cependant la fonction n’est pas périodique en x , mais en θ ! Les polynômes de Tché-
bychev sont encore plus utiles que les polynômes de Legendre pour représenter une fonction définie
45
sur un intervalle fini. La relation (3.55) nous indique immédiatement où se trouvent les racines x i de
TN : ( )
π 2i − 1
x i = cos (3.57)
2 N
Les premiers polynômes de Tchébychev sont :
T0 (x) = 1 T1 (x) = x
2
T2 (x) = 2x − 1 T3 (x) = 4x 3 − 3x (3.58)
4 2 5 3
T4 (x) = 8x − 8x + 1 T5 (x) = 16x − 20x + 5x
Problème 3.3
Montrez que si on définit les polynômes de Tchébychev par la relation (3.55), alors la relation de récurrence
T j +1 = 2xT j − T j −1 s’ensuit.
.
3.3 Transformées de Fourier rapides
Une fonction complexe ψ(x) définie sur un intervalle de longueur L peut être représentée par ses
coefficients de Fourier ψ̃k , définis comme suit :

∑ ∫ L/2
1
ψ(x) = e2πi kx/L ψ̃k ψ̃k = dx e−2πi kx/L ψ(x) (3.59)
k∈Z L −L/2

Cette représentation de la fonction ψ(x) est explicitement périodique de période L . Dans la limite L →
∞, on définit une variable continue q = 2πk/L et les relations ci-dessus deviennent la transformation
de Fourier (TdF) :

∫ ∞ ∫ ∞
1 1
ψ(x) = dq e i qx
ψ̃(q) et ψ̃(q) = dx e−i q x ψ(x) où ψ̃n → ψ̃(2πk/L) (3.60)
2π −∞ −∞ L

Bien que la notation utilisée fasse référence à une interprétation spatiale de la transformation, ce qui
suit est bien sûr également valable dans le domaine temps-fréquence ; il suffit d’adapter la notation
en conséquence.
3.3.1 Transformées de Fourier discrètes
Numériquement, une fonction ψ(x) sera représentée par un ensemble de N valeurs ψ j ( j = 0, . . . , N −1)
associées à une grille régulière de pas a et d’étendue L = N a . L’équivalent dans ce cas de la relation
(3.59) est la transformée de Fourier discrète :
1 N∑
−1 N∑
−1
ψj = e2πi j k/N ψ̃k ψ̃k = e−2πi j k/N ψ j (3.61)
N k=0 j =0
def
On peut également exprimer ces relations en fonction de la N me racine complexe de l’unité ω = e−2πi /N :
1 N∑
−1 N∑
−1
def
ψj = ω̄ j k ψ̃k ψ̃k = ωjk ψj ω̄ = ω∗ (3.62)
N k=0 j =0
Remarques :
46
3.3. Transformées de Fourier rapides
1. La quantité ψ j est périodique de période N : ψ j +N doit être identifié à ψ j .

2. Idem pour ψ̃k , aussi périodique de période N .
3. La correspondance avec une fonction continue est la suivante :
2πk L
x → ja q→ ψj → ψ(x) (3.63)
L a
La série de Fourier habituelle se retrouve dans la limite a → 0, N → ∞, en gardant L constant.

La transformée de Fourier habituelle se retrouve en faisant également tendre L → ∞.
La transformée de Fourier discrète peut être vue comme l’application d’une matrice N × N sur le
vecteur ψ :
ψ̃ = U ψ où U j k = ω j k (3.64)
Par exemple, pour N = 8, cette matrice est la suivante (ω4 = −1) :
 
1 1 1 1 1 1 1 1
 
1 ω ω2 ω3 −1 −ω −ω2 −ω3 
 
1 ω2 −1 −ω2 1 ω2 −1 −ω2 
 
 
1 ω 3
−ω 2
ω −1 −ω 3
ω2 −ω 
U =
1
 (3.65)
 −1 1 −1 1 −1 1 −1 
 
1 −ω ω2 −ω3 −1 ω −ω2 ω3 
 
 
1 −ω2 −1 ω2 1 −ω2 −1 ω2 
1 −ω3 −ω2 −ω −1 ω3 ω2 ω
1 ∗
La relation inverse, ψ = N U ψ̃, provient de l’identité suivante :

∑
N ′
U †U = N ou encore ω( j − j )k
= N δj j′ (3.66)
k=0

La preuve de cette relation est très simple, car en général, pour tout complexe z ,
′
N∑
−1 1 − zN N∑
−1 ′ 1 − ω( j − j )N
zk = et donc ω( j − j )k
= ′ (3.67)
k=0 1−z k=0 1 − ω( j − j )
Mais le numérateur de cette expression est toujours nul, car ωN = 1. Le dénominateur n’est nul que
si j = j ′ ; dans ce dernier cas la fraction est indéterminée mais il est trivial d’évaluer directement la
somme, qui donne manifestement N , d’où le résultat (3.66).
3.3.2 Algorithme de Danielson et Lanczos (ou Cooley-Tukey)
À première vue, il semble que le nombre d’opérations impliquées dans une TdF discrète soit d’ordre
O (N 2 ), comme tout produit matrice-vecteur. Or il est possible d’effectuer la TdF discrète à l’aide d’un
nombre d’opérations beaucoup plus petit, d’ordre O (N log N ). 3 Cette différence est considérable : si
un signal est échantilloné à l’aide de 1 000 points, ce qui n’est pas énorme, le rapport entre N 2 et
N log N est de l’ordre de 100. Le gain de performance est énorme. Les méthodes qui tirent parti de
cette réduction dans le nombre d’opérations portent le nom de transformées de Fourier rapides (TdFR,
en anglais fast Fourier transforms, ou FFT). L’algorithme de TdFR est l’un des plus utilisés dans la
vie courante : traitement du son et de l’image, etc. Les téléphones mobiles partout dans le monde
effectuent des TdFR constamment. La TdFR a été reconnue comme l’un des dix algorithmes les plus
importants de l’histoire du calcul. 4
3. Ce fait a été découvert plusieurs fois depuis l’époque de Gauss, en particulier par Danielson et Lanczos en 1942. Ce sont
cependant les noms de Cooley et Tukey qui sont habituellement associés à cette découverte (1965).
4. Par la revue Computing in Science and Engineering, Jan/Feb 2000.
47
La version la plus simple de l’algorithme de TdFR se présente lorsque le nombre de points est une
puissance de deux : N = 2M . C’est ce que nous allons supposer dans la suite. La clé de l’algorithme
est la possibilité d’écrire la deuxième des relations (3.62) comme la somme de deux transformées de
Fourier comportant N /2 points : l’une comportant les termes pairs, l’autre les termes impairs :
N∑
/2−1 N∑
/2−1
ψ̃k = (ω2 ) j k ψ2 j + ωk (ω2 ) j k ψ2 j +1 (3.68)
j =0 j =0
Cela entraîne qu’une TdF à N points est la somme de deux TdF à N /2 points, si on arrange le vecteur ψ
à N composantes en deux vecteurs ψ(0) et ψ(1) de N /2 composantes chacun, contenant respectivement
les composantes paires et impaires de ψ. Dans chacune des deux TdF, la valeur de k doit être prise
modulo N /2, sauf dans l’exposant ωk . Cependant, on peut grouper ψ̃k et ψ̃k+N /2 ensemble et exprimer
la TdF ainsi :
N∑/2−1 N∑
/2−1
ψ̃k = (ω2 ) j k ψ2 j + ωk (ω2 ) j k ψ2 j +1
j =0 j =0
(3.69)
N∑
/2−1 N∑
/2−1
ψ̃k+N /2 = (ω2 ) j k ψ2 j − ωk (ω2 ) j k ψ2 j +1
j =0 j =0
car ωk+N /2 = −ωk .
ψ0 ψ0 + ψ 4 (ψ0 + ψ4 ) + (ψ2 + ψ6 ) ψ̃0 = (ψ0 + ψ4 ) + (ψ2 + ψ6 ) + (ψ1 + ψ5 ) + (ψ3 + ψ7 )

ω0
ψ4 ψ0 − ψ 4 ω0 (ψ0 − ψ4 ) + ω2 (ψ2 − ψ6 ) ψ̃1 = (ψ0 − ψ4 ) + ω2 (ψ2 − ψ6 ) + ω(ψ1 − ψ5 ) + ω3 (ψ3 − ψ7 )
ψ2 ψ2 + ψ 6 ω2 (ψ0 + ψ4 ) − (ψ2 + ψ6 ) ω0 ψ̃2 = (ψ0 + ψ4 ) − (ψ2 + ψ6 ) + ω2 (ψ1 + ψ5 ) − ω2 (ψ3 + ψ7 )

ω0
ψ6 ψ2 − ψ 6 (ψ0 − ψ4 ) − ω2 (ψ2 − ψ6 ) ω1 ψ̃3 = (ψ0 − ψ4 ) − ω2 (ψ2 − ψ6 ) + ω3 (ψ1 − ψ5 ) − ω(ψ3 − ψ7 )
ψ1 ψ1 + ψ 5 (ψ1 + ψ5 ) + (ψ3 + ψ7 ) ω2 ψ̃4 = (ψ0 + ψ4 ) + (ψ2 + ψ6 ) − (ψ1 + ψ5 ) − (ψ3 + ψ7 )

ω0
ψ5 ψ1 − ψ 5 ω0 (ψ1 − ψ5 ) + ω2 (ψ3 − ψ7 ) ω3 ψ̃5 = (ψ0 − ψ4 ) + ω2 (ψ2 − ψ6 ) − ω(ψ1 − ψ5 ) − ω3 (ψ3 − ψ7 )
ψ3 ψ3 + ψ 7 ω2 (ψ1 + ψ5 ) − (ψ3 + ψ7 ) ψ̃6 = (ψ0 + ψ4 ) − (ψ2 + ψ6 ) − ω2 (ψ1 + ψ5 ) + ω2 (ψ3 + ψ7 )

ω0
ψ7 ψ3 − ψ 7 (ψ1 − ψ5 ) − ω2 (ψ3 − ψ7 ) ψ̃7 = (ψ0 − ψ4 ) − ω2 (ψ2 − ψ6 ) − ω3 (ψ1 − ψ5 ) + ω(ψ3 − ψ7 )
F 3.7
Chacun des deux termes de (3.69) peut, à son tour, est séparé en deux TdF à N /4 termes, et ainsi
de suite jusqu’à ce que le problème soit réduit à une somme de N TdFs à 1 terme chacune. À l’étape
2, les quatre sous-vecteurs de longueur N /4 peuvent être notés ψ(00) , ψ(01) , ψ(10) et ψ(11) . Le sous-
vecteur ψ(00) contient les termes pairs de ψ(0) , dont les indices originaux sont 0 modulo 4, alors que
ψ(01) contient les termes impairs de ψ(0) , dont les indices originaux sont 2 modulo 4, et ainsi de suite.
À la dernière étape, chaque sous-vecteur ne contient qu’une seule composante et est indexé par une
représentation binaire à M bits, par exemple ψ(0011001011) = ψ J pour M = 10 et N = 1024. Cet élé-
ment est indexé par un entier J dont la représentation binaire (0011001011 dans notre exemple) est
précisément l’inverse de celle de l’indice j du même élément dans le vecteur original ψ (c’est-à-dire
1101001100 = 844). Si on dispose les éléments de ψ non pas dans leur ordre original (celui des indices
j ), mais dans l’ordre des indices binaires-inversés J , alors les TdF partielles qui doivent être réalisées
à chaque étape sont plus facilement effectuées.
Cet algorithme est illustré dans le cas N = 8 sur la figure 3.7. La dernière colonne contient les 8
valeurs ψ̃k , dans l’ordre des k croissants. Le passage de la dernière colonne à l’avant dernière se
fait en vertu de l’équation (3.69). Les valeurs de k sont groupées en paires séparées de N /2, c’est-à-
dire apparaissent comme ωk et −ωk . La somme (3.69) apparaît donc dans le diagramme comme une
somme de deux termes avec poids relatif ωk (k = 0, 1, 2, 3), ou comme une différence des deux même
48
termes. Cette double combinaison (somme et différence avec poids relatif ωk ) forme graphiquement
ce qu’on appelle un «papillon» (voir fig. 3.8). Les éléments de la troisième colonne de la figure 3.7
forment deux groupes de TdF partielles, et une autre application de l’équation (3.69) sur ces deux
séries nous amène à la deuxième colonne. À cette étape les papillons ne comportent que 4 valeurs de
l’exposant, soit ±ω2 = ±i et ±ω0 = ±1. Il en résulte 4 TdF partielles. Enfin, une dernière application
de l’équation (3.69) nous amène à a première colonne, qui ne comporte que des papillons appliquant
les combinaisons ±ω0 . La première colonne est faite des éléments de la fonction directe dans l’ordre
des indices binaires-inversés J .
A A + zB
z
B A − zB
F 3.8
L’opérateur du «papillon» prend les deux données A et B et les remplace par les combinaisons A ± zB comme
illustré.
Évidemment, l’algorithme de TdFR doit procéder dans l’ordre inverse, c’est-à-dire partir des ψ j pour
aboutir aux ψ̃k . Ceci se fait en procédant aux étapes suivantes :
1. Placer les ψ j dans l’ordre des indices binaires-inversés. Soit I ( j ) l’indice obtenu en inversant
l’ordre des bits de j . Comme le carré de l’inversion est l’opérateur identité, on a I (I ( j )) = j et le
changement d’ordre se fait simplement en appliquant les transpositions
ψ j ↔ ψI ( j ) (3.70)
L’opération ne nécessite pratiquement pas de stockage supplémentaire et le tableau inversé

remplace simplement le tableau original.
2. On effectue ensuite une boucle externe sur les niveau. Au premier niveau, on effectue tous les
«papillons» au sein des paires successives d’éléments du tableau, autrement dit entre les paires
d’indices qui ne diffèrent que par le première bit. Encore une fois le tableau est remplacé par
un nouveau tableau sans besoin d’espace supplémentaire (sauf une valeur transitoire).
3. On continue dans cette boucle en passant à la colonne suivante. Les opérations papillons se font
maintenant en combinant les indices qui ne diffèrent que par leur deuxième bit. Le tableau de
l’itération précédente est remplacé par un nouveau tableau, et ainsi de suite.
4. Quand cette boucle interne est terminée, le tableau original a été remplacé par sa transformée
de Fourier.
5. Chaque papillon comporte le même nombre d’opérations arithmétiques, et le nombre de pa-
pillons est N /2 à chaque étape de la boucle, qui comporte elle-même log2 N étapes ; donc la
complexité algorithmique de la TdFR est O (N log2 N ).
3.3.3 Cas des dimensions supérieures
La TdF peut être appliquée à une fonction de plus d’une variable. Considérons par exemple le cas de
deux dimensions et introduisons les variables discrètes x et y , chacune allant de 0 à N − 1, ainsi que
les indices réciproques correspondants k x et k y . La TdF prend alors la forme suivante :
1 ∑ xk x +yk y ∑
ψx,y = ω̄ ψ̃k x ,k y ψ̃k x ,k y = ωxk x +yk y ψx,y (3.71)
N 2 k x ,k y x,y
La façon la plus directe de procéder à la TdFR est de commencer par effectuer N TdFR sur la variable
y , une pour chaque valeur de x . On obtient alors un objet intermédiaire Ψx,k y qui réside dans l’espace
réciproque en y , mais dans l’espace direct en x . Ensuite on procède à N TdFR sur la variable x , une
pour chaque valeur de k y . Il y a donc 2N TdFR à calculer, chacune de complexité N log2 N , ce qui donne
une complexité totale 2N 2 log2 N = N 2 log2 N 2 , où N 2 est le nombre de points échantillonnés en deux
dimensions.
49
3.3.4 Fonctions réelles
L’algorithme de TdFR peut être appliqué à des fonctions réelles tel quel, mais il entraîne un certain
gaspillage d’espace et de temps de calcul, car une fonction réelle discrétisée ψ j ne comporte que la
moitié des degrés de liberté d’une fonction complexe. D’autre part, sa TdF ψ̃k est toujours complexe,
mais jouit de la symétrie suivante :
ψ̃∗k = ψ̃N −k (3.72)
(en particulier, ψ̃0 et ψ̃N /2 sont réels).
Deux procédures différentes peuvent être utilisées pour rendre le calcul plus efficace :
1. Calculer deux TdFR simultanément. Souvent les TdF doivent être faites en série. Si on combine
deux foncions réelles ψ′ et ψ′′ en une seule fonction complexe ψ = ψ′ +i ψ′′ , appliquer la TdFR sur
ψ nous permet d’obtenir simultanément les TdF des parties réelle et imaginaire, en appliquant
la formule simple
1( ) 1 ( )
ψ̃′k = ψ̃k + ψ̃∗N −k ψ̃′′k = ψ̃k − ψ̃∗N −k (3.73)
2 2i
2. Combiner les partie paire et impaire de la fonction ψ en une seule fonction complexe Ψ de N /2
composantes : Ψ = ψ(0) + i ψ(1) . On montre que
1( ) i ( )
ψ̃k = Ψ̃k + Ψ̃∗N /2−k − Ψ̃k − Ψ̃∗N /2−k e2πi k/N (3.74)
2 2
Problème 3.4
Démontrez les relations (3.73) et (3.74).

.
3.3.5 Annexe : Code
Nous ne présenterons pas de code explicite de la transformée de Fourier rapide. Nous allons plutôt
nous fier aux librairies existantes, en particulier GSL. Le code qui suit donne un exemple d’application
d’une TdFR sur une fonction réelle : Il définit une fonction à travers un foncteur et applique un filtre
passe-bas à cette fonction en appliquant premièrement une TdFR sur la fonction, ensuite en tronquant
la transformée ψ̃, et enfin il calcule la transformée inverse. Les appels à GSL sont particuliers à des
fonctions réelles et mettent en œuvre la deuxième stratégie expliquée ci-dessus pour les fonctions
réelles.
Code 3.1 : Filtre passe-bas (FFT.cpp)
2 #include <fstream>
3 #include <cmath>
4
5 #include <gsl/gsl_fft_real.h>
6 #include <gsl/gsl_fft_halfcomplex.h>
8 #include ”Vector.h”
9

11
12 Foncteur définissant la fonction à filtrer (fonction pas)

13 struct func{
14 double xc ; valeur de x au−delà de laquelle la fonction est nulle
15 func(double _xc) : xc(_xc) {}
. 16 double operator() (double x){ return (x<xc) ? 1.0: 0.0;}
50
17 };
18
19 int main(){
20
21 fstream fin(”para.dat”) ;
22
23 int log2n ; logarithme en base 2 du nombre de points

24 double min, max, L, xc, wc ;
25 fin >> ”log2n” >> log2n ;
26 fin >> ”min” >> min ; borne inférieure du domaine de la fonction
27 fin >> ”max” >> max ; borne supérieure du domaine de la fonction
28 L = max - min ; largeur du domaine
29
30 fin >> ”xc” >> xc ; spécifique à la fonction pas

31 fin >> ”wc” >> wc ;
32 fin.close() ;
33
34 int N = 1 << log2n ; nombre de points = 2^log2N

35 double h = (L*1.0)/N ; pas dans l’espace direct
36
37 ofstream fout(”data.dat”) ;
38
39 func f(xc) ;
40
41 Vector<double> data(N) ; initialisation du tableau contenant la fonction

42 for(int i=0; i<N ; i++){
43 double x = min+i*h ;
44 data[i] = f(x) ;
45 fout << x << ’\t’ << data[i] << endl ;
46 }
47 fout << ”\n\n” ;
48
49 gsl_fft_real_radix2_transform(data.array(), 1, N) ; transformée directe

50 int m = N/2;
51 fout << data[0] << ’\t’ << 0 << endl ;
52 for(int i=1; i<m ; i++) fout << data[i] << ’\t’ << data[N-i] << endl ;
53 fout << data[m] << ’\t’ << 0 << ”\n\n\n” ;
54
55 filtre passe bas

56 int ic = (int)floor(L*wc/(2*M_PI)) ;
57 cout << ”Effacement des composantes d’indice > ” << ic << endl ;
58 if(ic<1) throw(”valeur de wc trop basse !”) ;
59 if(ic>=m) throw(”valeur de wc trop élevée !”) ;
60 for(int i=ic ; i<m ; i++) data[i] = data[N-i] = 0.0;
61 data[m] = 0.0;
62
63 gsl_fft_halfcomplex_radix2_inverse(data.array(),1,N) ; transformée inverse

64 for(int i=0; i<N ; i++) fout << data[i] << endl ;
65
66 fout.close() ;
67 cout << ”Fin normale du programme\n” ;
68 }
.
Quelques remarques :
1. Les appels dans ce code sont spécifique à un nombre de points égal à une puissance de 2. Des
appels différents sont nécessaires si cette condition n’est pas remplie.
2. La TdF est stockée dans le même tableau que la fonction d’entrée : après l’appel à la fonction
gsl_fft_real_radix2_transform(),
data[i] est la partie réelle de la TdF (i = 0, . . . , N /2) alors que data[N-i] est sa partie imagi-
naire. Après l’appel à la transformée inverse
51
gsl_fft_halfcomplex_radix2_inverse(),
le tableau data[] contient la fonction filtrée.
3. Le code écrit sur un fichier de sortie la fonction de départ, sa transformée de Fourier et enfin
la fonction filtrée.
52
4
Problèmes aux limites
Les problèmes de la physique classique et beaucoup de ses applications en génie peuvent être formulés
via des équations différentielles. Souvent ces équations différentielles n’impliquent que des coordon-
nées spatiales, c’est-à-dire sont indépendantes du temps. Dans ce cas, leur solution est la plupart du
temps contrainte par des conditions aux limites : c’est la valeur de la fonction recherchée, ou ses déri-
vées, sur la frontière du domaine qui détermine la solution. On parle alors de problèmes aux limites.
Nous allons nous concentrer sur deux méthodes de solution des problèmes aux limites : la méthode
des éléments finis, et les méthodes spectrales.
Les méthodes décrites dans ce chapitre pourront ensuite être appliquées au cas d’équations différen-
tielles aux dérivées partielles qui dépendent du temps : la dépendance spatiale des fonctions impli-
quées étant alors représentée par éléments finis ou par représentation spectrale, et la dépendance
temporelle faisant l’objet d’une traitement différent, purement séquentiel, comme ce qui a été fait au
chapitre 2.
4.1 Éléments finis : dimension 1
La méthode des éléments finis repose sur le développement d’une fonction ψ(x) sur une base de fonc-
tions localisées. Elle est très utilisée dans la solution des équations aux dérivées partielles, et se
combine habituellement à une discrétisation de l’espace en fonction de simplexes (ou de triangles en
deux dimensions).
4.1.1 Base de fonctions tentes en dimension 1
x
x0 x1 x2 x3 x4 x5
F 4.1
Fonctions-tentes en dimension 1, avec conditions aux limites ouvertes.
53
Chapitre 4. Problèmes aux limites
Commençons par le cas unidimensionnel. Définissons, sur le segment [0, ℓ], en se basant sur une grille
de points {x i } qui n’est pas nécessairement régulière, un ensemble de fonctions u i (x) définies comme
suit : 

0 si x > x i +1 ou x < x i −1



 x − x i −1

si x i −1 ≤ x ≤ x i
u i (x) = x i − x i −1 (4.1)



 x − x i +1


 si x i < x ≤ x i +1
x i − x i +1
Ces fonctions linéaires par morceaux sont appelées fonctions tentes en raison de leur forme. Voir la
figure 4.1 pour un exemple. Le cas des extrémités (i = 0 et i = N −1) est particulier si des conditions aux
limites ouvertes sont utilisées. Dans ce cas, la définition est la même, à la différence que la fonction
s’annule en dehors de l’intervalle [0, ℓ]
Nous allons fréquemment utiliser la notation de Dirac dans cette section et les suivantes. La fonction
u i (x) correspond à alors au produit bilinéaire 〈x|u i 〉 du vecteur abstrait |u i 〉 représentant la fonction
u i , et de la fonction propre de la position au point x ; l’utilisation de cette notation sera tout-à-fait
semblable à ce qui est pratiqué en mécanique quantique, à la différence que nous utiliserons un espace
de fonctions sur les réels et non sur les complexes. Le produit bilinéaire sera, à moins d’avis contraire,
défini par l’intégrale
∫ ℓ
〈 f |g 〉 = dx f (x)g (x) (4.2)
0
La propriété fondamentale des fonctions tentes est qu’elles sont nulles en dehors du domaine
[x i −1 , x i +1 ] et égales à l’unité à x = x i . Ces propriétés entraînent premièrement que
u i (x j ) = δi j ou, en notation de Dirac, 〈x j |u i 〉 = δi j (4.3)
et deuxièmement que
∫ ℓ
def
M i j = 〈u i |u j 〉 = dx u i (x)u j (x) (4.4)
0
n’est non nul que pour les sites i et j qui sont des voisins immédiats. La matrice M i j est appelée
matrice de masse. Comme M i j ̸= δi j , les fonctions tentes me forment pas une base orthonormée.
L’ensemble des fonctions u i (x) génère un sous-espace Vu de l’espace des fonctions définies dans l’in-
tervalle [0, ℓ]. Toute fonction appartenant à ce sous-espace admet par définition le développement
suivant : ∑ ∑
ψ(x) = ψi u i (x) ou, en notation de Dirac, |ψ〉 = ψi |u i 〉 (4.5)
i i
Comme les fonctions tentes ont la propriété u i (x j ) = δi j , on constate immédiatement que
ψi = ψ(x i ) (4.6)
L’approximation que nous ferons dans la résolution de problèmes aux limites ou d’équations différen-
tielles aux dérivées partielles est que les solutions à ces équations appartiendront au sous-espace Vu .
Autrement dit, nous ne procéderons pas à une approximation de l’équation différentielle elle-même
– par exemple en remplaçant les dérivées continues par des dérivées discrètes – mais nous allons
restreindre l’espace de fonctions dans lequel nous chercherons des solutions.
Dans le sous-espace Vu , le produit bilinéaire s’exprime comme suit :

∑
〈ψ|ψ′ 〉 = 〈u i |u j 〉ψi ψ′j = ψM
e ψ′ (4.7)
i,j
e est le transposé du vecteur ψ. Ce produit scalaire étant défini positif, la matrice M est, elle-aussi,
où ψ
définie positive.
Considérons ensuite un opérateur différentiel L , comme ceux qui apparaissent dans une équation
différentielle. Par exemple, L pourrait être une combinaison de dérivées :
L = u(x) + v(x)∂x + w(x)∂2x (4.8)
54
4.1. Éléments finis : dimension 1
L’action de l’opérateur L n’est pas fermée dans Vu , c’est-à-dire que si |ψ〉 ∈ Vu , la fonction L |ψ〉 n’ap-
partient pas complètement à Vu , mais possède un résidu |⊥〉 à l’extérieur de Vu . Que veut-on dire
exactement par là ? Cette affirmation n’a de sens, en fait, que via le produit scalaire : le résidu |⊥〉
doit être orthogonal à Vu : 〈u i |⊥〉 = 0. On peut donc écrire, pour chaque fonction tente,
∑
L |u i 〉 = L cj i |u j 〉 + |⊥〉 (〈u k |⊥〉 = 0) (4.9)
j
où la matrice L c définit l’action de L sur les fonctions tentes. En particulier, sur une fonction quel-
conque de Vu , on a
∑ ∑ def ∑
L |ψ〉 = ψi L |u i 〉 + |⊥〉 = ψi L cj i |u j 〉 + |⊥〉 = ψ′j |u j 〉 + |⊥〉 (4.10)
i i,j j
(notons que |⊥〉 ne désigne pas une fonction en particulier, mais toute fonction orthogonale à Vu ). Donc
l’image de ψ par L est ψ′ = L c ψ (en notation vectorielle) lorsque projeté sur Vu .
Définissons maintenant la matrice L ainsi :

def ∑ ∑
L ki = 〈u k |L |u i 〉 = L cj i 〈u k |u j 〉 = M k j L cj i c
= (M L )ki ou L = M Lc (4.11)
j j
La distinction entre les matrices L et L c provient du fait que les fonctions de base |u i 〉 ne forment pas
une base orthonormée.
Problème 4.1 : matrice de masse (dimension 1)
Montrez que

 16 |x i − x j | si |i − j | = 1 〈0|0〉 = 31 |x 1 − x 0 |
〈u i |u j 〉 = et (4.12)
1 〈N − 1|N − 1〉 = 13 |x N −1 − x N −2 |
3 |x i +1 − x i −1 | si i = j , i ̸= 0, i ̸= N − 1
.
4.1.2 Solution d’un problème aux limites en dimension 1
Appliquons la représentation en éléments finis à la solution d’un problème aux limites, c’est-à-dire
d’une équation différentielle pour la fonction ψ(x), avec des conditions précises sur la valeur de ψ(x)
ou de ses dérivées à x = 0 et x = ℓ.
Nous allons écrire l’équation différentielle sous la forme générale suivante :
L |ψ〉 = |ρ〉 (4.13)
où L est un opérateur différentiel, qu’on peut supposer linéaire pour le moment, et |ρ〉 une fonc-
tion déterminée, souvent appelé fonction de charge ou vecteur de charge. Par exemple, dans le cas de
l’équation de Helmholtz avec des sources émettrices distribuées selon la densité ρ(x),
d2
ψ′′ (x) + k 2 ψ(x) = ρ(x) et donc L= + k2 (4.14)
dx 2
Nous cherchons une solution approchée de l’équation (4.13) sous la forme de valeurs {ψi } définies sur
la grille. Nous allons en fait considérer une forme faible de l’équation différentielle :
∫ ℓ
〈w j |L |ψ〉 = dx w j (x)L ψ = 〈w j |ρ〉 (4.15)
0
où w j (x) est une fonction ou une collection de fonctions qu’il faut spécifier et qui définit précisément
la forme faible utilisée. On qualifie cette forme de faible, parce que toute solution à l’équation (4.13)
est nécessairement une solution à l’équation (4.15), alors que l’inverse n’est pas vrai.
On considère généralement les deux approches suivantes :
55
1. La méthode de collocation : On suppose alors que |w i 〉 = |x i 〉, c’est-à-dire w i (x) = δ(x −x i ). Ceci

équivaut à demander que l’équation différentielle (4.13) soit respectée exactement sur la grille
et mène à la relation suivante :
〈x i |L |ψ〉 = 〈x i |ρ〉 = ρ i (4.16)
où ( )
〈x i |L |ψ〉 = 〈x i | L ck j ψ j |u k 〉 + |⊥〉 = L ci j ψ j + 〈x i |⊥〉 (4.17)
En négligeant le résidu |⊥〉, nous avons donc la relation matricielle

Lc ψ = ρ (4.18)

2. La méthode de Galerkin : On prend plutôt |w i 〉 = |u i 〉, ce qui revient à demander que l’équation
différentielle soit respectée en moyenne sur le domaine de chaque fonction tente. Il s’ensuit que
〈u i |L |ψ〉 = 〈u i |ρ〉 (4.19)
où ( )
〈u i |L |ψ〉 = 〈u i | L ck j ψ j |u k 〉 + |⊥〉 = M i k L ck j ψ j = L i j ψ j (4.20)
On obtient donc la relation

( )
∑ ∑
(Lψ)i = 〈u i |ρ〉 = 〈u i | ρ j |u j 〉 + |⊥〉 = Mi j ρ j ou encore Lψ = M ρ (4.21)
j j
La subtilité ici est que ρ i ne représente pas exactement la valeur ρ(x i ), mais plutôt la valeur à
x i de la projection sur Vu de la fonction ρ .
Comme L = M L c , les deux méthodes semblent superficiellement équivalentes. Cependant une approxi-
mation différente a été faite dans chacune avant d’arriver aux équations matricielles équivalentes
L c ψ = ρ et Lψ = M ρ . Dans la méthode de collocation, nous avons traité ρ(x) exactement mais négligé
le résidu |⊥〉 résultant de l’application de L sur les fonctions tentes. Dans la méthode de Galerkin,
ce résidu disparaît de lui-même, mais par contre seule la projection de ρ(x) sur l’espace Vu est prise
en compte.
Imposition des conditions aux limites de Dirichlet

La discussion qui précède a passé sous silence la question des conditions aux limites. Elle est certai-
nement valable lorsqu’on impose des conditions aux limites périodiques, mais doit être raffinée dans
les autres cas. Nous allons supposer ici qu’on impose à la fonction ψ(x) des valeurs particulières à
x = 0 et x = ℓ (conditions aux limites de type Dirichlet).
Supposons qu’on réordonne les indices vectoriels (et matriciels) de manière à ce que les indices associés
à la frontière F apparaissent avant les indices associés à l’intérieur I . Un vecteur ψ est alors composé
de deux parties : ( )
ψF
ψ= (4.22)
ψI
où ψF est un vecteur à 2 composantes (pour les deux points à la frontière en dimension 1) et ψI un

vecteur à N − 2 composantes, pour les points intérieurs de l’intervalle. Une matrice L serait de même
décomposée comme suit : ( )
LF LF I
L = IF (4.23)
L LI
où L I est une matrice d’ordre N − 2 décrivant l’action de l’opérateur L sur les points intérieurs, L I F
est une matrice (N − 2) × 2 décrivant l’effet des points intérieurs via L sur les 2 extrémités, et ainsi
de suite. L’équation différentielle ne devrait pas être imposée sur les points situés à la frontière du
domaine : ce sont des conditions aux limites qui sont imposées en lieu et place. Donc, en appliquant
l’équation différentielle aux points intérieurs seulement, on trouve l’équation matricielle suivante :
L I ψI + L I F ψF = M I ρ I + M I F ρ F (4.24)
56
La solution se trouve en inversant la matrice intérieure L I , ce qui donne

( )
ψI = (L I )−1 − L I F ψF + M I ρ I + M I F ρ F (4.25)
Ceci suppose bien sûr que la matrice intérieure L I est non singulière.
Si les conditions aux limites sont homogènes (c’est-à-dire si ψF = 0) et que l’équation différentielle
aussi est homogène (ρ = 0), alors la seule possibilité de solution survient lorsque la matrice L I est
singulière. Cela correspond au problème des modes propres (voir ci-dessous).
Dans le cas de conditions aux limites périodiques, il n’existe pas de frontière (F =) et donc L et L I sont
identiques.
4.1.3 Calcul du laplacien en dimension 1
Calculons maintenant les éléments de matrice D i2j de l’opérateur de Laplace en dimension 1, c’est-à-
dire la dérivée seconde. En appliquant la définition de l’élément de matrice, on trouve
∫ ℓ d2
D i2j = 〈u i |∂2x |u j 〉 = dx u i (x) u j (x) (4.26)
0 dx 2
Comme les fonction u i sont linéaires, on pourrait naïvement conclure que leur dérivée seconde est
nulle et donc que D i2j = 0. Cependant, il n’en est rien, car la dérivée seconde n’est pas définie partout
sur la fonction tente : elle est nulle presque partout, et infinie sur les bords et au sommet de la tente.
Il faut donc procéder par limite : supposer que la tente est très légèrement arrondie à ces points, de
manière à ce que la dérivée seconde soit partout bien définie. On procède ensuite à une intégration
par parties :
[ ]ℓ ∫ ℓ
D i2j = u i (x)u ′j (x) − dx u i′ (x)u ′j (x) (4.27)
0 0
On peut maintenant procéder à la limite, car cette expression est bien définie : les dérivées premières
des fonctions tentes sont des constantes à l’intérieur du domaine de chaque fonction. Il est manifeste
que D i2j s’annule si |i − j | > 1 car les fonctions tentes ne se recouvrent pas dans ce cas. Ignorons pour
le moment le problème des extrémités (i = 0 et i = N −1). Commençons par évaluer l’élément diagonal
D i2i : le premier terme est manifestement nul car la fonction u i est nulle aux extrémités ; le deuxième
terme donne, quant à lui,
1 1
D i2i = − − (4.28)
x i +1 − x i x i − x i −1
Supposons ensuite que j = i + 1. On trouve immédiatement que
1
D i2,i +1 = (4.29)
x i +1 − x i
Comme l’opérateur de Laplace est hermitique, c’est-à-dire symétrique, il s’ensuit que D i2+1,i = D i2,i +1 .
4.1.4 Exemple : équation de Helmholtz
Considérons une corde vibrante de longueur ℓ, fixée à ses extrémités. Le déplacement transversal de
la corde, noté ψ, obéit à l’équation d’onde :
∂2 ψ 1 ∂2 ψ
− =0 (4.30)
∂x 2 c 2 ∂t 2
Supposons que la corde vibre à une fréquence ω. L’équation se réduit alors à l’équation de Helmholtz
∂2 ψ def ω
+ k 2ψ = 0 k = (4.31)
∂x 2 c
57
avec les conditions aux limites ψ(0) = ψ(ℓ) = 0.
L’opérateur différentiel pertinent ici est donc L = ∂2x + k 2 . Les éléments de matrice de ∂2x ont été
calculés ci-haut. Les éléments de matrice de la constante k 2 sont donnés par la matrice de masse
M i j = 〈u i |u j 〉. Donc l’équation de Helmholtz sous forme matricielle se réduit à
(D 2 + k 2 M )ψ = 0 (4.32)
Appliquons maintenant la condition aux limites ψ0 = ψN −1 = 0 du problème de la corde vibrante.

L’équation L I ψI = 0 se réduit alors à
D 2I ψ = −k 2 M I ψ ou encore (M I )−1 D 2I ψ = −k 2 ψ (4.33)
L’équation (4.33) est une équation aux valeurs propres : seules les valeurs de k qui sont des valeurs
propres de (M I )−1 D 2I sont admissibles. Ces valeurs propres déterminent alors les fréquences propres
du problème, et les vecteurs propres correspondants sont les modes propres d’oscillation de la corde
vibrante.
En pratique, il n’est pas courant d’inverser la matrice M I , surtout en dimension supérieure à un. On
tente alors de résoudre directement l’équation aux valeurs propres généralisée : Ax = λB x , où B est
une matrice définie positive. Ce problème est plus difficile à résoudre que le problème aux valeurs
propres ordinaire, et la recherche de méthodes efficaces pour ce faire, quand les matrices A et B sont
énormes, est encore un champ actif de recherche.
code : maillage1D.h, Helmholtz1D.cpp — page 179
Problème 4.2 : cas d’une grille uniforme
Considérons l’équation de Helmholtz en dimension 1 :
∂2 ψ
+ k2ψ = 0 ψ(0) = ψ(ℓ) = 0 (4.34)
∂x 2
A Donnez une expression exacte (analytique) des valeurs propres k 2 et des vecteurs propres correspondants
dans ce problème. Portez une attention particulière aux valeurs propres dégénérées.
B Calculez les matrice M I et D 2I dans le cas d’une grille uniforme, pour ℓ = 1 et N = 20 (aidez-vous de
Mathematica ou de l’équivalent ; ne codez pas en C++).
C Comment l’application de la matrice D 2I sur le vecteur ψ se compare-t-elle à la formule (3.4) ? Est-ce
différent ?
D Vérifiez numériquement que, dans ce cas d’une grille uniforme, les matrice D 2I et M I commutent entre
elles. Quelle relation s’ensuit-il entre les vecteurs propres de D 2I et ceux de (M I )−1 D 2I ?
E Comparez les 4 valeurs propres les plus petites (en valeur absolue) de la solution exacte, de D 2I et de
(M I )−1 D 2I . Dressez un tableau de ces valeurs propres et de l’écart relatif avec la valeur exacte.
F Portez les 4 premiers vecteurs propres en graphique, en les comparant aux fonctions propres exactes du
problème (superposez un graphique continu et un graphique discret).
.
58
F 4.2
Triangulation de l’espace autour de deux plaques parallèles d’un condensateur. Le problème est bi-
dimensionnel, mais représente un condensateur 3D beaucoup plus long que large, coupé en son milieu.
4.2 Éléments finis : dimension 2
La théorie générale des éléments finis en dimension supérieure à un n’est pas différente de ce qu’elle
est en dimension 1. En particulier, la discussion de la section 4.1.2 se transpose sans modification en
dimension supérieure, sauf pour le nombre de points à la frontière, qui est bien sûr plus grand que
2. La difficulté principale associée à une dimension supérieure vient de la forme plus complexe des
fonctions tentes. La grille unidimensionnelle est typiquement remplacée, en dimension 2, par une
triangulation (voir par exemple la figure 4.2).
4.2.1 Triangulations
La construction de triangulations est en soi un sujet vaste, qui s’insère dans une champ d’étude appelé
géométrie algorithmique (angl. computational geometry). Partons d’un ensemble de points (les nœuds)
qui forment la grille de points physique d’intérêt en dimension 2. Le problème est de construire un
ensemble de triangles (la triangulation) à partir de ces points. Chaque triangle constitue alors une fa-
cette de l’espace et aucun nœud ne doit se trouver à l’intérieur d’un triangle. La solution à ce problème
n’est pas unique.
Par contre, si on demande que le cercle circonscrit à chaque triangle ne contienne aucun autre nœud
(les nœuds sur la circonférence étant permis), alors la solution devient unique. Les triangulations
qui respectent cette condition sont appelées triangulations de Delaunay. 1 La figure 4.3 illustre une
triangulation de Delaunay avec les cercles circonscrits à chaque triangle. La partie droite de la figure
illustre le diagramme de Voronoï correspondant. L’intérieur de chaque polygone du diagramme de
Voronoï est l’ensemble des points qui sont plus proches de chaque nœud que de tout autre point.
L’avantage des triangulations de Delaunay est que les triangles sont les plus compacts possibles
et qu’un algorithme existe pour les construire. Cet algorithme est basé sur le basculement (voir fi-
1. En fait, Делоне en russe, d’après le nom du mathématicien russe auteur du concept. Curieusement, l’article original
étant publié en français, la translitération française est celle qui a été retenue, même en anglais.
59
F 4.3
À gauche : triangulation de Delaunay. Le cercle circonscrit à chaque triangle ne contient aucun autre nœud.
À gauche : diagramme de Voronoï (en rouge)[source : wikipedia]
F 4.4
Illustration du basculement. Les deux triangles ABD et CBD ne respectent pas la condition de Delaunay. Mais
en remplaçant le segment BD par le segment AC, on obtient deux nouveaux triangles (ABC et ADC) qui, eux,
respectent la condition.[source : wikipedia]
gure 4.4) : les deux triangles ABD et CBD ne respectent pas la condition de Delaunay, comme on
peut le voir à l’image du centre. On montre que la condition est violée à chaque fois que la somme
des angles opposés (ici α et γ) est supérieure à π, ce qui est le cas ici. Par contre, la somme β + δ
est alors forcément inférieure à π, et il suffit donc de remplacer le segment BD par le segment AC
pour obtenir deux nouveaux triangles qui respectent la condition de Delaunay. De cette manière, on
peut progressivement arriver à une triangulation entièrement conforme à la condition de Delaunay.
Chaque paire de triangles opposés (c’est-à-dire partageant une arête) détermine au total 6 angles
intérieurs. L’angle le plus petit, ou angle minimum, est plus grand si les deux triangles respectent la
condition de Delaunay, que dans le cas contraire. En ce sens, les triangulations de Delaunay évitent
plus que toutes les autres les angles petits, c’est-à-dire les triangles effilés. Notons cependant que la
triangulation n’est définie qu’une fois l’ensemble des nœuds spécifié, et que le choix des nœuds peut
entraîner l’existence de triangles effilés, même dans une triangulation de Delaunay.
Une triangulation de Delaunay est dite contrainte si elle se base non seulement sur un ensemble de
nœuds, mais aussi sur un ensemble de segments, par exemple délimitant une région. Ces segments
forment la frontière de la région physique d’intérêt, comme par exemple le bord de la région illustrée
sur la figure 4.2, ainsi que le périmètre de chacune des deux plaques. La triangulation contrainte doit
contenir les segments d’origine parmi les arêtes des triangles, en plus des nœuds.
En pratique, dans la solution d’un problème aux limites, on cherchera à raffiner la triangulation,
60
c’est-à-dire ajouter des nœuds, jusqu’à ce qu’une certaine précision soit atteinte. Le raffinement des
triangulations de Delaunay est un sujet de recherche actif. Nous utiliserons dans les travaux pratiques
un programme utilisant l’algorithme de Ruppert. 2 Le raffinement procède par ajout de nœuds :
1. Chaque triangle est caractérisé par un cercle circonscrit. Si le rayon de ce cercle dépasse une
certain maximum prescrit, un nœud supplémentaire est ajouté en son centre.
2. Des nœuds sont ajoutés sur le périmètre de la région au point milieu de segments, de ma-
nière à conserver un angle minimum prescrit dans tous les triangles. Ces nœuds additionnels
sont appelés points de Steiner. L’ajout de ces nœuds permet d’augmenter la qualité locale des
triangles, c’est-à-dire d’augmenter l’angle minimum.
Il y a naturellement un compromis à atteindre entre la qualité des triangles et le nombre de points :
on doit augmenter le nombre de nœuds afin d’améliorer la qualité minimale des triangles.
Dimension 3
En trois dimensions, les triangles sont remplacés par des simplexes, c’est-à-dire des solides à 4 faces
triangulaires. La notion de cercle circonscrit est remplacée par celle de sphère circonscrite, etc. On
parle encore de triangulation cependant, par abus de langage.
2 7
1
6
4 0
3
F 4.5
Fonctions tentes associées à une triangulation. À gauche : les triangles associés à deux fonctions tentes qui se
recouvrent, centrées aux sites 0 et 1 respectivement. La zone de recouvrement est indiquée en bleu. À droite :
vue 3D des deux fonctions tentes, pour les mêmes triangles.
4.2.2 Fonctions tentes
En deux dimensions, les fonctions tentes ressemblent plus à de véritables tentes, comme illustré à la
figure 4.5. Elle conservent les caractéristiques suivantes :
1. Leur valeur est 1 sur le nœud correspondant.
2. Elles n’ont de recouvrement qu’avec les fonctions des nœuds voisins, c’est-à-dire les nœuds
reliés par un seul segment de la triangulation.
Nous allons utiliser la notation suivante dans ce qui suit :
• Les nœuds seront indexés un indice latin : leurs positions seront notées ri , r j , etc.
• Les triangles (ou faces) seront notés T a (a = 0, 1, . . . , NT − 1), NT étant le nombre de faces.
• La surface de la face T a sera notée A a .
• Les trois nœuds de chaque face seront notés ra1 , ra2 et ra3 ; chacun de ces nœuds étant bien sûr
partagé par plusieurs faces.
2. Voir http://en.wikipedia.org/wiki/Ruppert’s_algorithm
61
• Inversement, le triangle formé par les trois nœuds i , j et k (dans le sens antihoraire) sera noté
Ti j k .
L’expression analytique de chaque fonction tente dépend bien sûr de la face considrée. Considérons à
cet effet trois nœuds r1,2,3 délimitant une face, et trouvons l’expression de la fonction tente centrée à
r1 sur cette face. Définissons d’abord la fonction
γ(r1 , r2 , r3 ) = z · [(r2 − r1 ) ∧ (r3 − r1 )]

(4.35)
= x2 y 3 − x3 y 2 − x1 y 3 + x3 y 1 + x1 y 2 − x2 y 1
D’après les propriétés du produit vectoriel, cette fonction est 2 fois l’aire orientée de la face formée des
trois points en question, si ces points sont pris dans le sens anti-horaire. Elle possède les propriétés
suivantes :
1. Elle est antisymétrique lors de l’échange de deux arguments et inchangée lors d’une permuta-
tion cyclique de ses trois arguments.
2. Elle est linéaire dans chacun de ses arguments
Problème 4.3
Démontrez ces propriétés.

.
La fonction tente centrée à r1 est linéaire en (x, y), s’annule à r = r2 et r = r3 , et est égale à 1 si r = r1 .
la seule possibilité est
γ(r, r2 , r3 )
u 1,2,3 (r) = (4.36)
γ(r1 , r2 , r3 )
Cette expression répond manifestement aux critères, et de plus est unique, car une seule fonction
linéaire (un seul plan) passe par les trois points (x 1 , y 1 , 1), (x 2 , y 2 , 0) et (x 3 , y 3 , 0). Nous utiliserons la
notation abrégée
γi j k = γ(ri , r j , rk ) (4.37)
où il est sous-entendu que les trois points forment une face de la triangulation.
La fonction tente complète centrée en r0 sur la figure 4.5 sera donc



u 012 (r) si r ∈ T012


u (r) si r ∈ T024
024
u 0 (r) = (4.38)

 · · · ···



u 031 (r) si r ∈ T031
Les fonctions tente de deux nœuds voisins partagent deux faces situées de part et d’autre du lien qui
relie les deux nœuds, comme illustré à la figure 4.5.
Problème 4.4 : Matrice de masse
L’objectif de ce problème est de calculer la matrice de masse M i j = 〈u i |u j 〉 des fonctions tentes en dimension
2.
A Montrez que l’élément de matrice diagonal est
1 ∑
〈u i |u i 〉 = Aa (4.39)
6 a,i ∈T
a
où la somme est effectuée sur les faces a qui touchent le site i .

B Montrez que l’élément de matrice entre sites voisins est
1
〈u i |u j 〉 = (A a + A b ) (4.40)
. 12
62
où a et b indexent les triangles situés de part et d’autre du lien i j .

Indice : procéder à un changement de variable pour effectuer les intégrales. Par exemple, pour trois nœuds
1, 2 et 3, il faut paramétrer les points à l’intérieur du triangle par les variables s et t telles que
r = r1 + s(r2 − r1 ) + t (r3 − r1 ) (4.41)
et intégrer dans le domaine approprié du plan (s, t ), après avoir calculé le jacobien associé à ce changement de
variables. Les propriétés de γ(r1 , r2 , r3 ) (linéarité, antisymétrie) contribuent à simplifier considérablement
le calcul.
.
4.2.3 Évaluation du laplacien
Supposons que nous ayons à notre disposition une triangulation de l’ensemble des nœuds ri en deux
dimensions. L’opérateur de Laplace ∇2 intervient dans un grand nombre d’équations différentielles et
il est donc nécessaire dans ces cas d’en calculer une représentation dans la base des fonctions tente.
Le problème est donc de calculer les éléments de matrice
∫
D i j = 〈u i |∇ |u j 〉 = d2 r u i (r)∇2 u j (r)
2 2
(4.42)
L’évaluation se fait encore une fois par intégration par parties, en utilisant l’identité de Green :
∫ I ∫
d2 r f ∇2 g = da · ∇g f − d2 r ∇ f · ∇g (4.43)
R ∂R R
où la première intégrale est menée sur le périmètre ∂R de la région R considérée.
Les fonctions u i (r) étant linéaires, leur gradient est constant et les intégrales ne présentent donc
pas de difficulté, sinon dans l’organisation des différentes faces impliquées. De plus, les fonctions
s’annulant sur le périmètre de leur domaine, le terme de périmètre ne contribue jamais.
Chaque fonction u i est une combinaison des fonctions u i j k définies en (4.36). On calcule sans peine
que
1
∇u i j k (r) = z ∧ (rk − r j ) (4.44)
γi j k
et ensuite que
∫ ℓ2j k
2 2
d r (∇u i j k ) = (4.45)
T (i j k) 4A i j k
où ℓ j k est la longueur du segment reliant j à k . D’autre part,
∫
ri k · r j k
d2 r ∇u i j k · ∇u j i k = − (4.46)
T (i j k) 4A i j k
def
où ri j = ri −r j . Ces relations permettent de calculer les éléments de matrice du laplacien simplement
en sommant les contributions des différentes faces :
1 ∑ ℓi a
2
D i2i = −
4 a,i ∈Ta A a
(4.47)
ℓ2i j − ℓ2i k − ℓ2j k ℓ2i j − ℓ2i k ′ − ℓ2j k ′
D i2j =− −
8A i j k 8A j i k ′
La notation utilisée est la suivante : ℓi j est la longueur du lien reliant les nœuds i et j ; ℓi a , a étant
un indice de face, est la longueur du lien de la face a opposé au site i . Dans la deuxième équation,
k et k ′ sont les nœuds qui complètent les faces (i j k) et ( j i k ′ ) situées de part et d’autres du lien (i j ).
Ainsi, en se référant à la figure 4.5, on a par exemple
( )
2 1 ℓ212 ℓ224 ℓ245 ℓ253 ℓ231
D 00 = − + + + +
4 A 012 A 024 A 045 A 053 A 031
(4.48)
2
ℓ201 − ℓ202 − ℓ212 ℓ201 − ℓ203 − ℓ213
D 01 = − −
8A 012 8A 103
63
code : maillage2D.h, Laplace2D.cpp — page 183
Problème 4.5
Démontrez les relations (4.47).

.
Problème 4.6 : Modes de l’équations de Helmholtz dans un enclos carré
Considérons l’équation de Helmholtz

∇2 ψ + k 2 ψ = 0 (4.49)
à l’intérieur d’un enclos carré de côté ℓ. On suppose que la fonction ψ s’annule sur le périmètre.
A Donnez une expression exacte (analytique) des valeurs propres k 2 et des vecteurs propres correspondants
dans ce problème. Portez une attention particulière aux valeurs propres dégénérées.
B Utilisez le programme triangle de J.R. Shewchuk (disponible sur la page Moodle du cours) pour effec-
tuer une triangulation à l’intérieur de ce carré. Le fichier d’entrée nécessaire (carre.poly) est fourni en
annexe ; utilisez la commande en ligne
triangle -q -a0.01 carre.poly
pour générer les fichiers carre.1.node et carre.1.ele nécessaires au calcul.
C Installez le programme Helmholtz2D.cpp fourni en annexe et appliquez-le aux fichiers produits à l’étape
précédente. Le code permet de résoudre l’équation aux valeurs propres soit à l’aide d’une méthode de Lanc-
zos ou d’une méthode appliquée aux matrices denses. Les valeurs et vecteurs propres sont écrits dans le
fichier de sortie vp.dat. Comment les valeurs propres se comparent-elles aux valeurs exactes ? Appliquez
et comparez les deux approches de calculs des modes propres.
D Portez en graphique les fonctions propres associées aux 4 valeurs propres les plus petites (en valeur
absolue). Produisez des graphiques densité à l’aide de gnuplot (un script gnuplot est fourni en annexe).
.
Problème 4.7 : Condensateur à plaques parallèles finies
Considérons un condensateur à plaques parallèles (ou plutôt une coupe en deux dimensions d’un condensa-
teur dont les plaques ont une extension très grande selon l’axe des z ). Ce système est décrit à la figure 4.2.
On supposera que la tension est ψ = 1 sur une plaque et ψ = −1 sur l’autre plaque, alors qu’elle s’annule au
loin (c’est-à-dire sur la frontière du système). Le potentiel électrique autour des plaques obéit à l’équation
de Laplace : ∇2 ψ = 0.
A Utilisez le programme triangle pour effectuer une triangulation dans cet espace. Le fichier d’entrée
nécessaire (cond.poly) est fourni en annexe ; utilisez la commande en ligne
triangle -q32 -a0.1 cond.poly
pour générer les fichiers cond.1.node et cond.1.ele nécessaires au calcul.
B Installez le programme Laplace2D.cpp fourni en annexe et appliquez-le aux fichiers produits à l’étape
précédente. Le code permet de résoudre le problème aux limites avec les conditions aux limites définies
dans le fichier d’entrée para.dat.
C Portez la solution en graphique à l’aide de gnuplot. Faites un graphique densité et un graphique 3D (un
script gnuplot est fourni en annexe).
.
64
4.3. Méthodes spectrales
4.3 Méthodes spectrales
La méthode des éléments finis est caractérisée par l’utilisation de fonctions de base locales (les fonc-
tions tentes des sections précédentes). Ces fonctions sont bien adaptées aux géométries compliquées,
en raison de la possibilité de faire des triangulations, mais ne constituent pas la meilleure solution
dans le cas des géométries simples. Dans cette section, nous allons expliquer comment utiliser une
base de polynômes afin de représenter les fonctions plus efficacement (c’est-à-dire avec moins de fonc-
tions de base).
4.3.1 Bases de polynômes orthogonaux et fonctions cardinales
Les méthodes spectrales utilisent les polynômes orthogonaux comme fonctions de base, ou encore des
fonctions trigonométriques dans le cas de conditions aux limites périodiques. La discussion qui suit
supposera qu’un interval ouvert (i.e. non périodique) est considéré. Le cas périodique sera traité à la
section 4.3.4 ci-dessous.
Fixons un entier N . Les N racines x i de p N (x) sont utilisées comme points de grille. Définissons aussi
les polynômes orthonormés
1
ϕk (x) = p p k (x) 〈ϕk |ϕm 〉 = δkm k, m = 0, . . . , N − 1 (4.50)
γk
Une fonction ψ(x) admet alors le développement limité suivant :
N∑
−1 ∑
N
def
ψ(x) ≈ ψ̄k ϕk (x) ψ̄k = 〈ϕk |ψ〉 = w i ψi ϕk (x i ) ψi = ψ(x i ) (4.51)
k=0 i =1
1.0
0.8
0.6
0.4
0.2
0.0
-0.2
-1.0 -0.5 0.0 0.5 1.0

x
F 4.6
Les fonctions cardinales associées aux 6 racines du polynôme de Tchébychev T6 (x).
Les polynômes orthogonaux sont des fonctions oscillantes étendues sur tout l’intervalle [a, b]. En ce
sens ils sont l’analogue des ondes planes (fonctions trigonométriques). Il est généralement plus utile
d’avoir recours à des fonctions localisées, comme dans la méthode des éléments finis, mais qui nous
permettent de profiter des excellentes propriétés de convergence des séries définies sur des bases de
polynômes orthogonaux. C’est pour cela qu’on définit les fonctions cardinales :
def ∏
N x −x
j
C i (x) = (4.52)
j =1 xi − x j
j ̸=i
65
La fonction C i (x) est un polynôme de degré N − 1 qui s’annule à tous les points x j de la grille, sauf au
point x i où elle est égale à l’unité : C j (x i ) = δi j .
Problème 4.8
Montrez que
p N (x)
C i (x) = ′ (x ) (4.53)
(x − x i )p N i
′ est la dérivée du polynôme p . Indice : les racines du polynômes C sont presque les mêmes que
où p N N i
celles de p N .
.
Nous avons donc à notre disposion deux bases de fonctions pour l’intervalle [a, b] : les polynômes
orthogonaux normalisés ϕ j (x) (ou |ϕ j 〉) et les fonctions cardinales C j (x) (ou |C j 〉). Ces deux bases sont
toutes les deux polynomiales de même degré, et sont reliées par une transformation de similitude,
qu’on trouve facilement en exprimant les fonctions cardinales sur la base des polynômes orthogonaux :
∑ def ∑
|C j 〉 = M i j |ϕi 〉 où M i j = 〈ϕi |C j 〉 = w k ϕi (x k )C j (x k ) = w j ϕi (x j ) (4.54)
i k
car C j (x k ) = δ j k .
Le développement d’une fonction ψ(x) sur la base des fonctions cardinales est très simple :
N∑
−1 N∑
−1 N∑
−1
ψ(x) ≈ ψ(x i )C i (x) = ψi C i (x) ou encore |ψ〉 ≈ ψi |C i 〉 (4.55)
i =0 i =0 i =0
On démontre ce développement en substituant x = x j ( j = 0, 1, · · · , N −1). Le signe ≈ devient une égalité

si la fonction ψ est un polynôme de degré N − 1 ou moins.
La relation existant entre les coefficients ψ̄i et ψi est

∑ ∑
ψ̄i = 〈ϕi |ψ〉 = 〈ϕi |C j 〉ψ j = Mi j ψ j (4.56)
j j
ou, en notation matricielle : ψ̄ = M ψ. On vérifie d’ailleurs, d’après l’expression ci-dessus de M i j et de

ψ̄i , que
∑ ∑
M k j ψ j = w j ϕk (x j )ψ j = ψ̄k (4.57)
j j
comme démontré plus haut.
Notons que la base des fonctions cardinales est orthogonale, mais pas orthonormée :
∑ ∑
〈C i |C j 〉 = w k C i (x k )C j (x k ) = w k δi k δ j k = w i δi j (4.58)
k k
Opérateur différentiel
Considérons maintenant un opérateur différentiel linéaire L , par exemple le laplacien. Sur la base
des fonctions cardinales, cet opérateur a une forme matricielle L telle que
∑
L |C i 〉 = L j i |C j 〉 (4.59)
j
(notez l’ordre des indices de la matrice L ). L’équation différentielle L ψ(x) = f (x), où f (x) est le vec-
teur de charge (connu) et ψ(x) la fonction recherchée, s’écrit abstraitement de la manière suivante :
L |ψ〉 = | f 〉. L’utilisation des fonctions cardinales est étroitement liée à la méthode de collocation, selon
laquelle l’équation différentielle est imposée aux points de grille, à savoir
〈x i |L |ψ〉 = 〈x i | f 〉 = f (x i ) = f i (4.60)
66
D’après la définition de L i j ci-haut, le membre de gauche de cette équation devient

∑
〈x i |L |ψ〉 = ψ j 〈x i |L |C j 〉
j
∑
= ψ j L k j 〈x i |C k 〉
j ,k
∑ (4.61)
= ψ j L k j δi k
j ,k
∑
= Li j ψ j
j
ce qui s’exprime comme Lψ en notation matricielle, ψ étant le vecteur-colonne des coefficients ψi .

L’équation différentielle devient donc l’équation matricielle
Lψ = f (4.62)
Les matrices associées aux dérivées d’ordre quelconque L = ∂(n) x peuvent être calculées relativement
facilement à l’aide de l’expression explicite (4.52) des fonctions cardinales. L’opérateur de différentia-
tion ∂x a la représentation générale
∑ (1)
∂x C i (x) = D ki C k (x) (4.63)
k
et la matrice D (1)
ji
n’est rien d’autre que la valeur de la dérivée de C i (x) évaluée à x = x j , comme on
peut le voir en posant x = x j dans l’équation ci-dessus :
∑ ∑
C i′ (x j ) = (1)
D ki C k (x j ) = (1)
D ki δk j = D (1)
ji
(4.64)
k k
Les matrices associées aux dérivées d’ordre supérieur peuvent être calculées simplement en prenant
les puissances appropriées de la matrice D (1) . Une routine à cet effet fait partie des codes annexes à
ce cours : c’est la méthode poids() du fichier collocation.h.
4.3.2 Quadratures de Lobatto
La quadrature gaussienne se base sur des abscisses qui sont strictement contenues à l’intérieur du
domaine [a, b]. Cela pose un problème si on veut représenter des fonctions qui ont des valeurs précises
aux frontières de l’intervalle. On peut remédier à ce problème en définissant une approche légèrement
différente basée sur la formule de quadrature de Lobatto qui, elle, inclut les points extrêmes. Cette
formule existe en général pour une fonction poids w(x) quelconque et s’obtient en imposant que les
extrémités de l’intervalle (a et b ) fassent partie de la grille d’intégration, qui comporte alors N − 2
points intérieurs et 2 points sur la frontière. Les poids w i et les nœuds intérieurs forment un en-
semble de 2N −2 paramètres ajustables qui sont déterminés afin de rendre l’intégrale exacte pour des
polynômes du plus haut degré possible, c’est-à-dire 2N − 3.
La formule de Lobatto pour les polynômes de Legendre est

∫ 1 ∑
N
dx f (x) ≈ w i f (x i ) (4.65)
−1 i =1
où
2
x 1 = −1 xN = 1 w1 = w N =
N (N − 1)
(4.66)
2 ′
wi = PN −1 (x i ) = 0 i = 2, . . . , N − 1
N (N − 1)[P N −1 (x i )]2
Autrement dit, les points intérieurs sont les N − 2 racines de la dérivée de P N −1 , qui est un polynôme
d’ordre N − 2.
67
La formule de Lobatto pour les polynôme de Tchébychev est

∫ ∑
1 f (x) N π (i − 1)π
dx p ≈ w i f (x i ) wi = x i = cos (4.67)
−1 1 − x 2 i =1 N N
Notons que la position des abscisses et les poids sont particulièrement simples avec ces polynômes.
Nous ne démontrerons pas les formules de Lobatto ici, comme nous l’avons fait pour la formule d’in-
tégration gaussienne en général. Ces formules fournissent des approximations différentes au produit
scalaire (3.54), qui sont d’ordre plus bas : exactes pour les polynômes de degré 2N −3 au lieu de 2N −1.
Par contre, leur avantage est que les fonctions cardinales associées C i (x) permettent de représenter
les valeurs aux frontières de l’intervalle. En ce sens, ces fonctions sont une alternative aux fonctions
tentes utilisées dans la méthode des éléments finis, et le traitement des conditions aux limites peut
se faire exactement comme dans le section 4.1.2, c’est-à-dire en définissant une représentation L I de
l’opérateur différentiel pour les points intérieurs
code : collocation.h — page 189
4.3.3 Exemple : problème aux limites en dimension 1
Revisitons le problème des valeurs propres de l’équation de Helmholtz étudié à la section 4.1.4. Il
s’agit ici de calculer les valeurs propres du laplacien L = ∂2x , donc de résoudre l’équation aux valeurs
propres
L |ψ〉 = λ|ψ〉 (4.68)
En projetant sur les fonctions 〈x i |, cette équation devient
〈x i |L |ψ〉 = L i j ψ j = λψi ou encore Lψ = λψ (4.69)
en notation matricielle. Il s’agit donc d’une équation aux valeurs propres en fonction de la matrice L .
Il faut cependant tenir compte des conditions aux limites, c’est-à-dire imposer l’annulation de la fonc-
tion aux extrémités de l’intervalle. Dans l’intervalle [−1, 1] associé aux polynômes de Tchébychev, cela
revient à demander ψ(−1) = ψ(1) = 0. Pour appliquer cette contrainte, nous avons besoin de points de
grille aux extrémités, donc de la grille de Gauss-Lobatto. L’équation aux valeurs propres elle-même
n’est valable que pour les points intérieurs de la grille.
Nous devons donc partitionner la matrice L comme expliqué à la fin de la section 4.1.2. L’équation aux
valeurs propres prend alors la forme
( )( ) ( )
LF LF I 0 0
=λ (4.70)
LI F LI ψI ψI
ce qui revient à demander

L I ψI = λψI (4.71)
Autrement dit, nous devons chercher les valeurs propres de la matrice intérieure seulement.
Le tableau 4.1 illustre les résultats obtenus de cette manière et les compare aux résultats exacts et
à ceux obtenus par la méthode des éléments finis. Le fait remarquable est que la méthode spectrale,
avec seulement 12 points (donc 10 points intérieurs) est beaucoup plus précise que la méthode des
éléments finis avec 101 points, du moins pour les valeurs propres les plus basses. En fait, les valeurs
obtenues avec la méthode spectrale cessent d’être fiable après ∼ n/2 valeurs propres, n étant le nombre
de points utilisés. Mais souvent ce sont les valeurs propres les plus basses qui sont recherchées.
68
n exact éléments méthode

finis spectrale
1 2.4674 2.4676 2.4674
2 9.8696 9.8728 9.8696
3 22.206 22.223 22.206
4 39.478 39.530 39.472
5 61.685 61.812 61.900
T 4.1
Les 5 premières valeurs propres de l’opérateur ∂2x dans l’intervalle [−1, 1]. À droite : valeurs exactes λn =
(nπ/2)2 . Au milieu, valeurs obtenues à l’aide de la méthode des éléments finis et N = 101 points de grille. À
gauche, valeurs obtenues à l’aide d’une méthode spectrale et d’une grille de Gauss-Lobatto de N = 12 points.
F 4.7
Fonction cardinale sur une grille périodique de 24 points. Les 24 fonctions sont identiques à celle illustrée ici,
sauf pour une translation. L’espace périodique est ici représenté comme un cercle.
4.3.4 Conditions aux limites périodiques
Lorsqu’on a affaire à des conditions aux limites périodiques, c’est-à-dire lorsque le problème est dé-
fini sur une cercle au lieu d’un segment ouvert, les fonctions spectrales les plus utiles ne sont pas
les polynômes de Legendre ou de Tchébychev, mais plutôt les fonctions trigonométriques qui sont
d’emblée périodiques. Dans cette section nous allons décrire les fonctions cardinales utilisées dans
les problèmes périodiques.
Il est toujours possible, par un changement d’échelle approprié, de fixer la longueur de l’intervalle
périodique à 2π. Nous allons adopter une grille de N points également espacés (N étant pair) 3 :
2π j
xj = j = 0, 2, . . . , N − 1 (4.72)
N
Les fonctions cardinales appropriées à cette grille sont définies comme suit :
(1 )
1 sin 2 N (x i − x) ( )
C i (x) = (1 ) cos 12 (x i − x) (4.73)
N sin 2 (x i − x)
Ces fonctions ne sont pas des polynômes en x (les polynômes ne sont pas périodiques de toute manière).
Par contre, elles ont les propriétés suivantes :
1. Elles sont périodiques, de période 2π, à condition que N soit pair. Voir à cet effet la figure 4.7.
2. C i (x j ) = δi j . Cela se vérifie immédiatement si i ̸= j . Pour i = j , il s’agit d’un processus de limite
standard pour le rapport des sinus. Donc le développement d’une fonction périodique ψ(x) sur
3. il n’y a aucune raison que les points ne soient pas également espacés, étant donnée l’invariance par translation
69
la base des fonctions cardinales s’effectue comme auparavant :

N∑
−1
def
ψ(x) = ψi C i (x) ou ψi = ψ(x i ) (4.74)
i =0
3. En fonction d’exponentielles complexes, la fonction C 0 (x) s’exprime comme
1 ei N x/2 − e−i N x/2 ( i x/2 −i x/2

)
C 0 (x) = e + e
2N ei x/2 − e−i x/2
1 z N /2 − z −N /2 1/2 def
= (z + z −1/2 ) z = ei x
2N z 1/2 − z −1/2
z −N /2 z N − 1 (4.75)
= (z + 1)
2N z − 1
z −N /2
= (1 + z + z 2 + · · · + z N −1 )(z + 1)
2N
1 ( 1 −N /2 )
= 2 z + z −N /2+1 + z −N /2+2 + · · · + z N /2−1 + 12 z N /2
N
Autrement dit, C 0 (x) est un polynôme trigonométrique de degré N /2, c’est-à-dire une combinai-
son des puissances entières de z = ei x , de −N /2 at N /2.
def def
4. La fonction C j (x) s’obtient en remplaçant x par x−x j , ou encore z par w = ω j z , où ω = e−2πi /N :
1 [ 1 −N /2 ]
C j (x) = 2 w + w −N /2+1 + w −N /2+2 + · · · + w N /2−1 + 12 w N /2 (4.76)
N
Les N fonctions cardinales sont toutes des polynômes trigonométriques de degré N /2. Elles sont
linéairement indépendantes. Elles sont aussi réelles, alors que w est complexe, en raison de
leur invariance lors du remplacement w → w −1 . Le nombre de degrés de liberté de l’ensemble
des polynômes respectant cette condition est N + 1. Comme il n’y a que N fonctions cardinales,
l’un de ces polynômes ne peut pas être exprimé comme une combinaison de fonctions cardi-
nales : il s’agit de
( ) Nx
i z −N /2 − z N /2 = 2 sin (4.77)
2
comme on peut le vérifier aisément en vérifiant que les coefficients de développement (4.74)
sont tous nuls.
5. On montre facilement que l’action de la dérivée première sur les fonctions cardinales est la
suivante : {
0 (i = j )
′ (1)
C j (x i ) = D i j = 1 ( x −x ) (4.78)
i+j i j
2 (−1) cot 2 (i ̸= j )
La matrice D (2) représentant la dérivée seconde est simplement le carré de D (1) .
Problème 4.9
Montrez que les N fonctions cardinales (4.76) sont linéairement indépendantes. Indice : exprimer dans la
base des puissances z n , et calculez le déterminant formé des N fonctions cardinales. C’est un déterminant
de Vandermonde.
.
70
5
Équations aux dérivées partielles
dépendant du temps
Nous allons traiter dans ce chapitre de la solution numérique des équations aux dérivées partielles qui
impliquent une évolution temporelle, et donc qui requièrent des conditions initiales. Ce type de pro-
blème est différent des problèmes aux limites statiques, comme par exemple la solution de l’équation
de Laplace, qui sont déterminés par des conditions aux frontières uniquement. Dans les problèmes
dynamiques qui seront étudiés ici, nous aurons à la fois à tenir compte de conditions aux limites et
de conditions initiales.
L’approche sera donc de considérer la représentation disrète d’un champ ψ(r, t ) à un instant donné et
de faire évoluer dans le temps cette représentation discrète. Celle-ci pourra être basée sur l’une des
méthodes décrites au chapitre précédent : soit une grille régulière, une représentation par éléments
finis ou par une méthode spectrale.
5.1 L’équation de diffusion
5.1.1 Introduction
L’équation de diffusion, ou équation de la chaleur, prend la forme suivante :
∂ψ
= κ∇2 ψ (5.1)
∂t
où κ est le coefficient de diffusion. Le champ ψ peut représenter la température locale à l’intérieur

d’un matériau, ou la densité locale d’un soluté dans un solvant, etc. On peut justifier l’équation (5.1)
de manière assez générale en supposant que la quantité ψ représente une quantité conservée (c’est-
à-dire qui n’est pas localement créée) dont la diffusion d’un endroit à l’autre est caractérisée par une
densité de courant j proportionnelle au gradient de ψ :
j = −κ∇ψ (5.2)
où le signe − signidie que la quantité en question a tendance à se répartir là où elle est la plus faible.
En combinant cette relation à l’équation de continuité
∂ψ
+ ∇·j = 0 (5.3)
∂t
qui ne fait que représenter la conservation de la quantité en question, on retrouve bien l’équation de
diffusion.
71
Chapitre 5. Équations aux dérivées partielles dépendant du temps
Dans le cas de la chaleur, l’équation (5.2) est l’expression de la loi de conduction linéaire de la chaleur
(ou loi de Fourier) qui stipule que le courant de chaleur q (en W/m2 ) et proportionnel au gradient de
température :
q = −k∇T k : conductivité thermique, en W/m.K (5.4)
La variation d’énergie interne par unité de volume (∆Q ) est proportionnelle à la variation de tempé-
rature :
∆Q = c p ρ∆T (5.5)
où c p est la chaleur spécifique à pression constante et ρ la densité du milieu. Le courant de chaleur

q étant associé à Q , le courant de température j sera donc proportionnel à q : j = q/(c p ρ). La loi de
Fourier se réduit donc à la relation (5.2), avec κ = k/(c p ρ).
5.1.2 Évolution directe en dimension un
Considérons l’équation de diffusion en une dimension d’espace, entre les frontières x = 0 et x = ℓ.

La méthode la plus simple pour résoudre l’équation numériquement est d’adopter une discrétisation
uniforme de l’intervalle [0, ℓ], et une discrétisation également uniforme du temps, de sorte qu’on doit
traiter l’évolution d’un vecteur ψr , en fait une suite ψr,n , où r est l’indice spatial et n l’indice tempo-
rel. En utilisant la valeur de la dérivée temporelle calculée au temps t n et la méthode d’Euler pour
l’évolution dans le temps, on obtient le système d’équations suivant :
[ ] hκ
ψr,n+1 = ψr,n + η ψr +1,n − 2ψr,n + ψr −1,n η= (5.6)
a2
où h = ∆t est le pas temporel et a = ∆x le pas spatial. On doit appliquer cette relation aux valeurs
intérieures de ψ, et imposer les conditions aux limites en tout temps aux frontières :
ψ0,n = ψgauche ψN ,n = ψdroite (5.7)
Il faut également spécifier les conditions initiales ψr,0 . Une fois cela fait, la solution est immédiate
par récurrence : les valeurs ψr,n+1 sont données de manière explicite en fonction des ψr,n . Pour cette
raison, cette méthode simple est qualifiée d’explicite.
Analyse de stabilité de von Neumann

La méthode explicite décrite ci-dessus cours cependant le danger d’être instable. Von Neumann a
étudié ce problème en supposant que la solution du problème discrétisé, qui est encore un problème
linéaire, serait une combinaison de modes propres. Il a supposé une forme exponentielle pour les
modes propres, qui seraient indexés par un nombre d’onde k , en fonction de la position et du temps
t = nh :
ψr,n = ξ(k)n ei kar (5.8)
où ξ est un nombre complexe qui peut dépendre de k . En substituant cette forme dans l’équation
discrète (5.6), on trouve
ξ(k) = 1 + 2η(cos(ka) − 1) = 1 − 4η sin2 (ka/2) (5.9)
La solution numérique sera stable seulement si toutes les valeurs possible de ξ respectent la condition
|ξ(k)| < 1. Ceci n’est vrai que si la condition suivante est respectée :
1 a2
η< ou κh < (5.10)
2 2
Autrement dit, le pas temporel doit être suffisamment petit en comparaison du pas spatial. Dans le
cas de l’équation de diffusion, le pas temporel doit même varier en raison quadratique du pas spatial.
72
5.1. L’équation de diffusion
Problème 5.1 : Test de la condition de von Neumann
Écrivez un programme très simple qui permet de tester la condition de stabilité de von Neumann pour
l’équation de la diffusion en une dimension. Posez ℓ = 1 et les conditions aux limites ψ(0) = 0 et ψ(ℓ) = 1.
.
5.1.3 Méthode implicite de Crank-Nicholson
Le défaut principal de la méthode simple décrite à la section précédente est que la dérivée temporelle
utilisée pour passer du temps t au temps t + h est évaluée au temps t , c’est-à-dire au début de l’inter-
valle, comme dans la méthode d’Euler. Cette méthode est du premier ordre en h . La précision et la
stabilité de la méthode est grandement améliorée si la dérivée est estimée au milieu de l’intervalle.
Supposons que l’évolution temporelle ait la forme suivante :
∂ψ
=Lψ (5.11)
∂t
où L est un opérateur différentiel linéaire mais qui n’agit que sur la dépendance spatiale de ψ. La
méthode simple décrite plus haut équivaut à la récurrence suivante :
ψ(t + h) = ψ(t ) + hL ψ(t ) (5.12)
Nous allons améliorer cette façon de faire en partant d’une valeur inconnue ψ(t + h/2) évaluée au
milieu de l’intervalle et en la propageant de ∆t = h/2 vers ψ(t + h) et de ∆t = −h/2 vers ψ(t ) :
[ ] [ ]
ψ(t ) = 1 − 12 hL ψ(t + h/2) ψ(t + h) = 1 + 21 hL ψ(t + h/2) (5.13)
La première de ces équations est un système linéaire qui peut être résolu pour ψ(t +h/2), connaissant
ψ(t ). En pratique, nous aurons une version discrète du champ ψ et de l’opérateur L , suite à une
représentation du champ ψ selon l’une des méthodes décrites au chapitre précédent. L’équation ci-
haut devient donc
[ ] [ ]
ψ(t ) = 1 − 12 hL ψ(t + h/2) ψ(t + h) = 1 + 21 hL ψ(t + h/2) (5.14)
où ψ est maintenant un vecteur fini et L une matrice carrée. Une fois ψ(t +h/2) connu par solution de
la première équation, on applique la deuxième équation de manière directe pour obtenir ψ(t + h).
La résolution de la première des équations (5.14) pour ψ(t + h/2) est particulièrement simple en di-
mension 1 si on utilise une représentation par grille simple ou par éléments finis de la fonction ψ,
car la matrice L est alors tridiagonale si L contient des dérivées du deuxième ordre ou moins. Un tel
système s’inverse en un temps d’ordre O (N ), N étant le nombre de points sur la grille. Par contre, une
représentation spectrale demanderait d’inverser une matrice pleine. Si l’équation différentielle est
linéaire et homogène dans le temps, et que le pas h est constant, alors le calcul d’une seule matrice
inverse est suffisant pour tout le calcul. Si l’équation est non linéaire, alors l’opérateur L dépend de
ψ et l’inversion doit être faite à chaque étape t → t + h .
Analyse de stabilité
Supposons pour simplifier les choses que l’équation différentielle soit linéaire et homogène dans le
temps, ce qui revient à dire que la matrice L ci-haut est constante. Dans ce cas, l’évolution du système
du temps t au temps t + h se fait par application d’une matrice d’évolution constante U :
def 1 + 12 hL
ψ(t + h) = U ψ(t ) où U = (5.15)
1 − 12 hL
La stabilité de cette évolution est régie par les valeurs propres de l’opérateur U : si au moins une
valeur u de U est telle que |u| > 1, alors la méthode est instable, car la moindre composante de ψ le
73
long du vecteur-propre correspondant va être amplifiée par l’évolution temporelle. Si λ désigne une
valeur propre de l’opérateur L , alors la valeur propre correspondante de U est simplement
1 + 12 hλ
u= (5.16)
1 − 12 hλ
car U est une fonction directe de la matrice L . La condition de stabilité |u| ≤ 1 se traduit donc par
1 + 12 hλ 1
−1 < < 1 =⇒ 2 hλ < 0 (5.17)
1 − 12 hλ
Dans le cas particulier de l’équation de la chaleur, les valeurs propres λ du laplacien D 2 étant toujours
négatives, la stabilité de la méthode devrait être assurée. Bien sûr, ce sont les valeurs propres de L
qui comptent et non celles de L ; il faut donc que le nombre N de points de grille soit suffisant pour
que la condition λ < 0 soit respectée pour L , ce qui est plausible quand N est suffisamment grand.
5.1.4 Méthode du saute-mouton
Une façon alternative de procéder à l’évolution temporelle sans avoir à résoudre le système implicite
(5.14) tout en conservant une précision du deuxième ordre en h est la méthode dite du «saute-mouton»
(angl. leapfrog). Il s’agit simplement de calculer la dérivée au temps t à l’aide de la fonction (inconnue)
au temps t + h et de la fonction (conservée en mémoire) au temps t − h . Autrement dit :
∂ψ 1 [ ]
L ψ(t ) = ≈ ψ(t + h) − ψ(t − h) (5.18)
∂t 2h
ce qui mène à une expression explicite pour ψ(t + h) :
ψ(t + h) = ψ(t − h) + 2hL ψ(t ) (5.19)
Cette approche requiert de garder en mémoire, à chaque étape, la valeur du champ ψ à trois temps dif-
férents : elle est plus coûteuse en mémoire, mais potentiellement plus rapide qu’une méthode implicite
dans les cas où le système (5.14) doit être résolu à chaque étape, surtout en dimensions supérieures
quand les matrices en jeu ne sont pas tridiagonales.
Appliquons à cette méthode la même analyse de von Neumann que nous avons appliquée à la méthode
directe, c’est-à-dire en nous basant sur les différences finies dans l’espace. On trouve alors la relation
ξ(k) = ξ−1 (k) + 2η(cos(ka) − 1) =⇒ ξ2 − 1 = 2ηξ(cos(ka) − 1) (5.20)
La condition de stabilité ξ2 < 1 revient donc à demander
ηξ(cos(ka) − 1) < 0 (5.21)
ce qui n’est respecté que si ξ > 0. Or, dans les conditions où la méthode directe (5.6) devient instable, ξ
est proche de −1, donc déjà négatif. La méthode du saute-mouton, en dépit d’être du deuxième ordre
en temps, est donc instable, même pour des h très petits !
Donc malgré ses avantages potentiels, la méthode du saute-mouton est pleine de dangers ! Elle n’est
pas toujours à conseiller : cela dépend de l’équation différentielle considérée.
74
5.1. L’équation de diffusion
5.1.5 Application basée sur une représentation spectrale
Le code déployé ci-dessous utilise la représentation spectrale d’une fonction en dimension 1, dans
l’intervalle [−1, 1], et résoud l’équation de diffusion en fonction du temps, en affichant la solution de
manière interactive à l’aide de gnuplot. Le schéma de Crank-Nicholson est utilisé pour propager la
solution d’un temps à l’autre. Un opérateur d’évolution U , indépendant du temps, est construit au
début du calcul et est ensuite appliqué à la solution à chaque instant t pour la propager vers l’instant
suivant (t + h ).
La grille de Gauss-Lobatto est utilisée dans le calcul, mais seuls les points intérieurs doivent être
propagés. Élaborons sur ce point : rappelons que dans la méthode de collocation, l’équation ψ̇ = L ψ
doit être imposée aux points intérieurs seulement. En fonction des sous-vecteurs ψF et ψI représen-
tant respectivement les valeurs aux extrémités et à l’intérieur du domaine, la version discrétisée de
l’équation prend la forme
( ) ( )( )
∂ ψF LF LF I ψF ∂ψI
= ou encore = L I ψI + L I F ψF (5.22)
∂t ψI LI F LI ψI ∂t
où seule la deuxième composante de l’équation matricielle est appliquée, ψF étant fixé par les condi-
tions aux limites, indépendamment du temps.
Supposons maintenant que les conditions aux limites soient homogènes, c’est-à-dire ψF = 0. On re-
trouve alors la même forme que l’équation différentielle originale obtenue sans tenir compte des condi-
tions aux limites, mais pour les points intérieurs seulement. La méthode de Crank-Nicholson implique
donc l’opérateur d’évolution suivant :
1 + 12 hL I
U= (5.23)
1 − 12 hL I
qui doit être construit et appliqué sur le vecteur ψI de manière répétée.
Si les conditions aux limites ne sont pas homogènes, alors on peut sans trop de peine ramener le
problème à celui de conditions aux limites homogènes de la manière suivante : on pose
ψ(x, t ) = ϕ(x, t ) + ψs (x) (5.24)
où par définition ψs (x) est une solution statique (indépendante du temps) à l’équation différentielle,
et qui en plus respecte les bonnes conditions aux limites. Comme l’équation est linéaire, on a donc
∂ϕ
= L ϕ où ϕ(−1) = ϕ(1) = 0
∂t (5.25)
L ψs = 0 où ψs (−1) = ψ(−1) et ψs (1) = ψ(1)
La solution au problème indépendant du temps L ψs = 0 est généralement simple. Dans le cas de

l’équation de diffusion, ∂2x ψs = 0 et donc ψs (x) est une fonction linéaire qui interpole entre les valeurs
aux extrémités de l’intervalle. Cette fonction est en fait la valeur asymptotique de ψ(x, t ) dans la limite
t → ∞. Il nous reste alors à déterminer numériquement ϕ(x, t ), c’est-à-dire à résoudre un problème
aux limites homogènes.
Code 5.1 : Résolution de l’équation de diffusion 1D
4
5 #define GNUPLOT
6
. 7 #ifdef GNUPLOT
75
8 extern ”C”{
9 #include ”gnuplot_i.h”
10 }
11 #endif
12
13 #include ”collocation.h”
15
16 int main(){
17 double kappa ; coefficient de diffusion
18 int np=50; nombre de points sur le graphique
19 double h ; pas temporel
20 double dt_display = 10*h ; intervalle d’affichage
22 int N ; nombre de points de collocation
23 double x1 = -1.0; extrémité gauche
24 double x2 = 1.0; extrémité droite
25
26 ifstream fin(”para.dat”) ;
27 fin >> ”N” >> N ;
28 fin >> ”kappa” >> kappa ;
29 fin >> ”h” >> h ;
30 fin >> ”intervalle_affichage” >> dt_display ;
31 fin >> ”tmax” >> tmax ;
32
33 int Ni = N-2; nombre de points intérieurs

34
35 Vector<double> psi(N) ; champ

36 Matrix<double> U(Ni) ; opérateur d’évolution
37 collocation grille(”gauss_lobatto”, N, 2, np) ; Grille de fonctions cardinales
38
39 Matrix<double> Li(N-2) ; construction de la partie intérieure du laplacien

40 int N1 = N-1;
41 for(int i=1; i<N1 ; i++) for(int j=1; j<N1 ; j++) Li(i-1,j-1) = grille.D[1](i,j) ;
42
43 construction de l’opérateur d’évolution (Crank−Nicholson)

44 Matrix<double> A(Li) ; A *= 0.5*kappa*h ; A.add_to_diagonal(1.0) ; A = 1 + 12 κhL I
45 Matrix<double> B(Li) ; B *= -0.5*kappa*h ; B.add_to_diagonal(1.0) ; B = 1 − 12 κhL I
46 B.Inverse() ;
47 U = B*A ; U = (1 − 21 κhL I )−1 .(1 + 12 κhL I )
48
49 conditions initiales
50 for(int i=0; i<grille.N ; i++) psi[i] = 1.0;
51 psi[0] = 0.0;
52 psi[grille.N-1] = 0.0;
53
54 initialisation de la sortie des données

55 #ifdef GNUPLOT
56 int temps_mort ; temps mort entre affichages, pour gnuplot_i
57 fin >> ”temps_mort” >> temps_mort ;
58 double ymin = 0;
59 double ymax = 1;
60 ofstream gout ;
61 gnuplot_ctrl * GP ;
62 GP = gnuplot_init() ;
63 gnuplot_cmd(GP,(char *)”set term x11”) ;
64 gnuplot_cmd(GP,(char *)”set xr [%g :%g]”,x1,x2) ;
65 gnuplot_cmd(GP,(char *)”set yr [%g :%g]”,ymin,ymax) ;
66 #endif
67
. 68 fin.close() ;
76
5.2. Propagation d’une onde et solitons
69 int output_step=0; compteur des sorties sur fichier

70 for(double t=0.0; t<tmax ; t+= h){
71 if(floor(t/dt_display) >= output_step){
72 output_step++;
73 #ifdef GNUPLOT
74 gout.open(”tmp.dat”) ;
75 grille.plot(gout,psi.array()) ;
76 gout.close() ;
77 gnuplot_cmd(GP,(char *)”set title ’t = %g’”,t) ;
78 gnuplot_cmd(GP,(char *)”plot ’tmp.dat’ u 1:2 w l t ’’”) ;
79 usleep(temps_mort) ; temps mort entre les affichages, en microsecondes
80 #endif
81 }
82 évolution sur un intervalle de temps h
83 Vector<double> tmp(Ni) ;
84 U.mult_add(&psi[1],&tmp[0]) ;
85 memcpy(&psi[1],&tmp[0],Ni*sizeof(double)) ;
86 }
87
88 #ifdef GNUPLOT
89 sleep(3) ; temps mort après le dernier affichage, en secondes
90 gnuplot_close(GP) ;
91 #endif
92
93 cout << ”Programme terminé normalement\n” ;

94 }
.
Problème 5.2 : Résolution de l’équation de diffusion par représentation spectrale
A Installez le programme diffusion1D.cpp et testez-le avec les paramètres suivants figurant dans le
fichier para.dat :
1 N 10
2 kappa 1
3 h 0.001
4 intervalle_affichage 0.01
5 tmax 2
6 temps_mort 100000
B Portez en graphique la solution à t = 0.1 pour les quatre valeurs de N étudiées. Vous pouvez à cette fin
stipuler que le temps de simulation est tmax=0.5.
.
5.2 Propagation d’une onde et solitons
5.2.1 Équation d’advection
L’équation la plus simple décrivant la propagation d’une onde est l’équation d’advection en une di-
mension d’espace :
∂ψ ∂ψ
+v =0 (5.26)
∂t ∂x
Cette équation est un cas particulier de l’équation de continuité
∂ψ
+ ∇·j = 0 où j = (vψ, 0, 0) (5.27)
∂t
77
Le champ ψ représente donc la densité d’une quantité conservée, mais qui ne peut se propager que
vers la droite (si v > 0).
La solution analytique de l’équation d’advection est très simple : on procède au changement de va-
riables
ξ = x + vt η = x − vt (5.28)
de sorte que
∂ ∂ ∂ ∂ ∂ ∂
= + =v −v (5.29)
∂x ∂ξ ∂η ∂t ∂ξ ∂η
L’équation d’advection s’écrit comme suit en fonction des variables (ξ, η) :
∂ψ
=0 et donc ψ(x, t ) = ψ0 u(η) = ψ0 u(x − v t ) (5.30)
∂ξ
où u(η) est une fonction différentiable quelconque, représentant la forme du paquet d’ondes qui se
propage vers la droite.
5.2.2 Équation de Korteweg-de Vries
L’étude de la propagation des vagues – l’archétype des ondes dans l’histoire des sciences – est un sujet
relativement complexe. La vague elle-même est une interface entre deux milieux (le liquide en bas,
l’air ou le vide en haut) dont la forme varie en fonction du temps. La manière dont cette interface se
déplace repose sur une description de l’écoulement du fluide sous-jacent, par les équations standards
de l’hydrodynamique (éq. de Navier-Stokes et de continuité).
L’étude théorique et expérimentale de la propagation des vagues a été motivée en bonne partie par
l’observation en 1834, par l’ingénieur naval John Scott Russell, de la propagation d’une vague singu-
lière dans un canal en Écosse :
I was observing the motion of a boat which was rapidly drawn along a narrow channel by a pair of
horses, when the boat suddenly stopped—not so the mass of water in the channel which it had put
in motion ; it accumulated round the prow of the vessel in a state of violent agitation, then suddenly
leaving it behind, rolled forward with great velocity, assuming the form of a large solitary elevation,
a rounded, smooth and well-defined heap of water, which continued its course along the channel
apparently without change of form or diminution of speed. I followed it on horseback, and overtook
it still rolling on at a rate of some eight or nine miles an hour, preserving its original figure some
thirty feet long and a foot to a foot and a half in height. Its height gradually diminished, and after a
chase of one or two miles I lost it in the windings of the channel. Such, in the month of August 1834,
was my first chance interview with that singular and beautiful phenomenon which I have called the
Wave of Translation.
Russell procéda par la suite à une étude contrôlée de la propagation des vagues dans un petit bassin
artificiel qu’il fit creuser chez lui. L’une des découvertes qualitatives qu’il fit est que la vitesse de
propagation augmente avec la profondeur du bassin (en autant qu’il ne soit pas trop profond). Donc,
si ψ représente la hauteur de la vague, la vitesse est proportionnelle à ψ.
Les calculs théoriques du Français Boussinesq, et ensuite des Hollandais Korteweg et de Vries, on
mené à la forme simplifiée suivante pour l’équation décrivant la propagation d’une onde en une di-
mension, dans un canal étroit et plat :
∂ψ ∂ψ ∂3 ψ
+ ϵψ +µ 3 = 0 (5.31)
∂t ∂x ∂x
C’est l’équation de Korteweg-de Vries (ou KdeV). Elle diffère de l’équation d’advection de deux ma-
nières :
1. La vitesse de propagation dépend de l’amplitude de l’onde : v a été remplacé par ϵψ.
2. Un terme de dispersion a été ajouté, proportionnel à la dérivée troisième de ψ. Ce terme pro-
voque la dispersion – l’étalement d’un paquet d’onde initial – car la vitesse de propagation
dépend alors du nombre d’onde, et donc n’est pas constante pour une onde non sinusoïdale.
78
L’équation d’advection est retrouvée si on néglige la dispersion, et si on linéarise le terme non linéaire :
on pose ψ = ψ0 +δψ, ψ0 étant l’élévation moyenne de la surface, et on néglige les termes quadratiques
en δψ. On retrouve alors l’équation d’advection pour la déviation δψ par rapport à l’élévation moyenne.
Il est pratique de conserver les paramètres ϵ et µ dans l’étude de cette équation, car on peut alors
facilement retrouver diverses limites. Par exemple, en posant µ = 0, on trouve l’équation de Burgers,
qui constitue un modèle simple des ondes de choc. En supposant cependant que ϵ et µ sont non nuls,
il est toujours possible de procéder à un changement d’échelle de x pour fixer µ à l’unité, et à un
changement d’échelle de ψ (l’équation étant non linéaire) pour fixer ϵ = 6. On obtient ainsi une forme
normalisée de l’équation de KdeV :
∂ψ ∂3 ψ ∂ψ
+ + 6ψ =0 (5.32)
∂t ∂x 3 ∂x
5.2.3 Solitons
Nous allons maintenant démontrer que l’équation de KdeV (5.31) admet comme solution particulière
des ondes d’étendue finie qui se propagent sans déformation, ou solitons (parfois aussi appelée ondes
solitaires). Celles-ci correspondent à l’onde de translation (wave of translation) observée par Scott
Russell.
Commençons par supposer une solution de la forme ψ(x, t ) = u(x − v t ) et substituons dans l’équation
de KdeV ; on obtient une équation différentielle ordinaire en fonction de η = x − v t , ou en fonction de
x si on pose t = 0 :
− vu ′ + u ′′′ + 6uu ′ = 0 ou − vu ′ + u ′′′ + 3(u 2 )′ = 0 (5.33)
ce qui peut s’intégrer une fois par rapport à x pour donner
− vu + u ′′ + 3u 2 = A (5.34)
où A est une constante d’intégration. Si on suppose que la solution u tend vers zéro en même temps
que ses dérivées (loin du maximum du paquet d’onde), on doit poser A = 0. En multipliant par u ′ , qui
sert de facteur intégrant, on trouve
[ ]
d 1 1
− vuu ′ + u ′ u ′′ + 3u ′ u 2 = 0 = − vu 2 + (u ′ )2 + u 3 (5.35)
dx 2 2
Donc l’expression entre crochets est indépendante de x , et doit être nulle quand x → ±∞. On peut
alors isoler u ′ :
1 1 du p
− vu 2 + (u ′ )2 + u 3 = 0 =⇒ = u v − 2u (5.36)
2 2 dx
ce qui nous permet d’intégrer :
∫ √
du 2 2u
x= p = p arctanh 1− (5.37)
u v − 2u v v
En isolant u , on trouve
[ ( p )]
v vx v/2
u(x) = 1 − tanh2 = (p ) (5.38)
2 2 2 vx
cosh
2
Nous avons donc trouvé une solution à l’équation de KdeV de la forme suivante :
v/2
ψ(x, t ) = [p ] (5.39)
v
cosh2 (x − v t )
2
Notons que l’amplitude du soliton est proportionnelle à sa vitesse.
79
Problème 5.3 : Mise à l’échelle des solitons
On peut écrire la solution solitonique comme suit :

A
ψ(x, t ) = (5.40)
cosh2 [(x − v t )/σ]
où A est l’amplitude maximale du soliton et σ sa largeur caractéristique. En partant de la solution (5.39) à

l’équation (5.32), écrivez la solution correspondante à l’équation (5.31) sous la forme ci-haut en procédant
aux transformations d’échelle nécessaires. Exprimez A , σ en fonction de ϵ, µ et de la vitesse du soliton.
.
5.2.4 Solution numérique de l’équation de Korteweg-de Vries
Nous allons utiliser des conditions aux limites périodiques et une méthode spectrale pour étudier
la propagation des solitons. À cette fin, la classe collocation_periodic.h a été construite afin de
représenter des fonctions cardinales associées aux séries de Fourier.
code : collocation_periodic.h, KdeV.cpp — page 191
Les options d’entrée du programme principal sont les suivantes :

1. N : le nombre de points de collocation
2. plot_points : le nombre de points utilisés pour le graphique
3. h : le pas temporel
4. temps_de_simulation : le temps de simulation
5. intervalle_affichage : l’intervalle entre les affichages successifs
6. mu : le coefficient µ de l’équation (5.31)
7. epsilon : le coefficient ϵ de l’équation (5.31)
8. sigma : la largeur σ du soliton initial
9. xO : la position x 0 du soliton initial
10. ymin,ymax : le domaine d’affichage selon l’axe vertical
11. temps_mort : le temps d’attente entre deux images (graphiques)
12. deux_solitons : Si ce mot-clé apparaît, deuxp solitons sont mis en condition initiale. Le
deuxième est à x 0 + 2, est deux fois plus petit et 2 fois plus large que le premier.
13. lineaire : Si ce mot-clé apparaît, le problème est modifier pour simuler une équation linéaire :
∂ψ ∂ψ ∂3 ψ
+ϵ +µ 3 = 0 (linéaire) (5.41)
∂t ∂x ∂x
Problème 5.4 : Résolution de l’équation de Korteweg de Vries
A Installez le programme KdeV.cpp. Vérifiez que l’équation d’advection, simulée en posant µ = 0 et en

spécifiant le mot-clé linéaire dans le fichier d’entrée, mène à des paquets d’onde qui se propagent sans
dispersion.
B Posez maintenant µ = 0.001, toujours dans l’équation linéaire, et observez la dispersion.
C Restaurez la non linéarité dans l’équation, c’est-à-dire retournez à l’équation de KdeV, et posez µ = 0
. (équation de Burgers). Le comportement observé est-il crédible ?
80
D Observez maintenant la propagation d’un soliton en posant µ = 0.001, σ = 0.25 et la valeur appropriée de
l’amplitude afin que l’expression (5.40) soit une solution exacte de l’équation. Que se passe-t-il si l’amplitude
est 20% trop élevée ou trop basse par rapport à la bonne valeur ?
E Spécifiez maintenant deux solitons dans les conditions initiales, avec les paramètres originaux de la
partie précédente. Qu’observez-vous ? Quelle différence y a-t-il dans le processus de collision des solitons et
celui de la superposition de deux paquets d’ondes linéaires ?
F En-deça de quelle valeur de N (le nombre de points de collocation) la solution commence-t-elle à se
détériorer de manière perceptible ? Qu’arrive-t-il éventuellement quand N est encore plus bas ?
.
81
82
6
Méthodes stochastiques
6.1 Nombres aléatoires
Les méthodes stochastiques reposent toutes sur la possibilité de générer des nombres de manière
aléatoire, c’est-à-dire des séquences de nombres entiers pris au hasard dans un intervalle donné.
Que veut-on dire par là précisément ? Premièrement, remarquons qu’un nombre n’est pas aléatoire
en soi : le qualificatif s’applique à une suite infinie de nombres, chacun étant compris entre 0 et M
(M peut être très grand, comme par exemple 264 , ou simplement M = 2 pour une production de bits
aléatoires). Le caractère aléatoire est fondamentalement lié à l’impossibilité de prédire quel sera le
nombre suivant de la suite, ou de déceler des corrélations significatives entre les membres différents
de la suite. Par exemple, une suite de nombres aléatoires sera incompressible, au sens informatique
du terme : aucun algorithme de compression ne pourrait y être appliqué avec un gain supérieur à un
dans la limite d’une suite infinie.
La façon idéale de générer une séquence aélatoire est d’avoir recours à un processus physique fonda-
mentalement aléatoire, gouverné par les lois de la mécanique quantique ou statistique. Des dispositifs
qui produisent des bits aléatoires liés à des processus optiques, comme le passage ou non d’un pho-
ton au travers d’un miroir semi-transparent, existent sur le marché 1 . Cependant, ces générateurs
physiques de séquences aléatoires peuvent être chers, et aussi trop lents pour les besoins du calcul.
En fait, il est plus économique et simple de les remplacer par des générateurs de nombres pseudo-
aléatoires.
Un générateur pseudo-aléatoire est une contradiction dans les termes : il s’agit d’une méthode déter-
ministe pour générer une suite de nombres qui se comporte à toutes fins pratiques comme un suite
réellement aléatoire. En particulier, chaque nombre de la suite est déterminé de manière unique par
un ou quelques uns des nombres qui le précèdent dans la suite, mais la loi déterministe est «non natu-
relle» et n’a pratiquement aucune chance d’avoir un effet sur le calcul, si on la compare à un processus
réellement aléatoire.
Générateur à congruence linéaire

La manière classique de générer des entiers aléatoires est la relation de récurrence suivante, dite à
congruence linéaire :
x n+1 = (ax n + c) mod M (6.1)
où les entiers a et c doivent être choisis judicieusement, ainsi qu’un premier entier non nul dans la
séquence. Par exemple, a = 16807, c = 0 et M = 231 − 1 sont un choix courant. La séquence ainsi définie
est périodique de période M : elle se répète exactement après M nombres, car le nombre suivant est
déterminé par le nombre courant, et au plus M possibilités existent. Les générateurs simples de ce
type ont longtemps été la règle. Ils sont à proscrire absolument dans toute application ou la qualité de
la séquence aléatoire est importante. En particulier, sur une machine moderne, la séquence complète
1. Voir par exemple http://www.idquantique.com/
83
Chapitre 6. Méthodes stochastiques
peut être générée en quelques secondes, ce qui démontre clairement son insuffisance pour les calculs
sérieux.
Générateurs de Fibonacci
Cette méthode est basée sur la récurrence suivante :
x n+1 = x n−p + x n−q mod M (6.2)
On doit spécifier les entiers p , q et M et fournir les premiers éléments de la séquence par une autre
méthode (par exemple une congruence linéaire). Parmi les choix acceptables de (p, q), signalons
(607, 273) (2281, 1252) (9689, 5502) (44497, 23463) (6.3)
Des générateurs plus avancés encore sont obtenus en se basant sur la méthode de Fibonacci et en
ajoutant un mélange des bits du nombre à chaque étape.
Générateur de base conseillé

Le code suivant montre comment utiliser deux générateurs de nombres aléatoires. Le premier
(Random) est simplement un appel à GSL, alors que le deuxième (RandomNR) est proposé dans Nu-
merical Recipes. La méthode par défaut utilisée par GSL est une variante de la méthode de Fibonacci
appelée Mersenne twister et proposée par Makoto Matsumoto and Takuji Nishimura en 1997 2 .
Code 6.1 : Générateur de nombres aléatoire : Random.h
1 #ifndef RANDOM_H_
2 #define RANDOM_H_
3
4 #include <gsl/gsl_rng.h>
5
6 class Random{
7 public :
8 Random(){ constructeur par défaut
9 gsl_rng_env_setup() ;
10 T = gsl_rng_default ;
11 r = gsl_rng_alloc(T) ;
12 }
13
14 ~Random(){gsl_rng_free (r) ;}
15
16 inline double uniform(){ return gsl_rng_uniform(r) ;}

17
18 inline unsigned long int integer(){return gsl_rng_get(r) ;}

19
20 private :
21 const gsl_rng_type *T ;
22 gsl_rng *r ;
23 };
24
25 class RandomNR{
26 public :
27 unsigned long int u,v,w ;
28
29 RandomNR(unsigned long int j) : v(4101842887655102017LL), w(1) {

30 u = j ^ v ; int64() ;
. 31 v = u ; int64() ;
2. M. Matsumoto et T. Nishimura, ACM Transactions on Modeling and Computer Simulation (TOMACS) 8, 3–30 (1998).
84
6.1. Nombres aléatoires
32 w = v ; int64() ;
33 }
34 inline unsigned long int int64() {
35 u = u * 2862933555777941757LL + 7046029254386353087LL ;
36 v ^= v >> 17; v ^= v << 31; v ^= v >> 8;
37 w = 4294957665U*(w & 0xffffffff) + (w >> 32) ;
38 unsigned long int x = u ^ (u << 21) ; x ^= x >> 35; x ^= x << 4;
39 return (x + v) ^ w ;
40 }
41 inline double uniform() { return 5.42101086242752217E-20 * int64() ; }
42 inline unsigned int int32() { return (unsigned int)int64() ; }
43 };
44
45 #endif
.
6.1.1 Distribution uniforme
À partir d’un générateur de nombres aléatoires entiers, compris entre 0 et M − 1, on peut générer des
nombres aléatoires à virgule flottante compris entre 0 et 1 simplement en divisant par M (au sens des
NVF). C’est ce qui est fait dans les routines Random ::uniform() et RandomNR ::uniform() listées
ci-dessus. Ces nombres aléatoires suivent une distribution de probabilité uniforme : p(x) = 1 dans
l’intervalle x ∈ [0, 1]. Le fait que la distribution soit uniforme est précisément l’une des conditions qui
caractérisent un bon générateur de nombres aléatoires. Plusieurs tests statistiques de la qualité des
générateurs pseudo-aléatoires peuvent être appliqués pour s’en assurer.
À partir d’une distribution uniforme dans l’intervalle [0, 1], on peut générer une distribution uniforme
dans tout intervalle fini par transformation affine x ′ = ax + b . Plus important : on peut générer des
distributions de probabilité plus complexes, par les méthodes expliquées ci-dessous.
6.1.2 Méthode de transformation
Une méthode simple pour simuler une variable aléatoire y qui suit une distribution de probabilité
non-uniforme est d’appliquer une transformation x 7→ y = f (x) à la variable uniforme x . En général, si
une variable aléatoire x suit une distribution p 1 (x), les aléatoires 3 situés dans l’intervalle dx autour
de x correspondent alors à des valeurs aléatoires de y situées dans un intervalle dy autour de y ,
distribués selon une fonction p 2 (y) telle que
¯ ¯
¯ dx ¯
p 1 (x)| dx| = p 2 (y)| dy| ou encore p 2 (y) = p 1 (x) ¯¯ ¯¯ (6.4)
dy
1
La méthode est illustrée sur la figure 6.1, dans le cas p 1 (x) = 2 sur x ∈ [−1, 1] et p 2 (y) = 12 π sin πy sur
y ∈ [0, 1]. D’après la discussion ci-dessus,
1 dx
p 2 (y) = π sin πy = p 1 (x)
2 dy
∫ x ∫ y
(6.5)
=⇒ dx ′ = π sin πy ′ dy ′
−1 0
=⇒ 1 + x = 1 − cos πy or x = − cos πy
Remarquons, d’après la forme de la relation y = f (x), que si x est distribué uniformément dans l’in-
tervalle [0, 1], alors y sera plus fréquent là où dy/ dx est le plus faible, et vice-versa.
3. Nous désignerons couramment une variable aléatoire par le nom aléatoire, correspondant à l’anglais deviate.
85
0.8
0.6
y y(x)
0.4
0.2
p2 (y)
0
-1 -0.5 0 0.5 1
x
F 6.1
Méthode de transformation.
Autre exemple : y = − ln(x) dans l’intervalle y ∈ [0, ∞] et p 1 (x) = 1 dans x ∈ [0, 1]. Alors
¯ ¯
¯ dx ¯
p 2 (y) = ¯¯ ¯¯ = x = e−y (6.6)
dy
On parvient alors à la distribution exponentielle.
Plus généralement, produire une distribution p 2 quelconque à partir d’une distribution uniforme
requiert la solution analytique de l’équation différentielle suivante :
∫ y
p 2 (y) dy = dx =⇒ dz p 2 (z) = F 2 (y) = x (6.7)
0
(on a supposé dy/ dx > 0), où F 2 (y) est l’intégrale de la distribution p 2 . En pratique, tirer un aléa-
toire selon la distribution p 2 revient à tirer un aléatoire x selon une distribution uniforme, puis à
effectuer la correspondance y = F 2−1 (x) pour obtenir la valeur de y distribuée selon p 2 . La méthode de
transformation est utile et efficace uniquement si F 2 peut être calculé et inversé analytiquement.
6.1.3 Méthode du rejet
Une méthode plus générale pour générer une distribution p(x) est la méthode du rejet, illustrée à
la figure 6.2. Supposons que nous désirions générer un aléatoire x qui suive la distribution p(x) (en
rouge). Sur la figure le domaine de x est fini (de a à b ), mais cela n’est pas nécessaire. Supposons en
outre que nous sachions comment échantilloner une distribution f (x) (en noir sur la figure) définie
sur le même intervalle, et qui a été normalisée de manière à ce qu’elle soit partout plus grande que
p(x). La méthode du rejet procède comme suit :
1. On tire une valeur x ∈ [a, b], distribuée selon f (x). Par exemple, f (x) pourrait être échantilloné
par la méthode de transformation décrite ci-haut.
2. On tire un deuxième nombre y uniformément distribué entre 0 et f (x).
3. Si y < p(x), on accepte la valeur de x ainsi produite. Sinon, on la rejette et on recommence
jusqu’à ce que la valeur de x soit acceptée.
4. L’ensemble des valeurs de x ainsi générées suit la distribution p(x).
On peut comprendre la méthode du rejet géométriquement comme suit : en échantillonant x selon f (x)
et y de manière uniforme entre 0 et f (x), on se trouve à générer des points (x, y) qui sont uniformément
répartis au-dessous de la courbe f (x). En rejetant systématiquement tous les points compris entre
p(x) et f (x), on se trouve à échantilloner la distribution p(x).
86
6.1. Nombres aléatoires
f (x)
refusé
(x, y)
p(x)
second tir
accepté
premier tir
a x 0
b
F 6.2
Méthode du rejet.
Plus la fonction f (x) est proche de p(x), plus la méthode est efficace, c’est-à-dire plus les rejets sont
rares. Le cas particulier d’une distribution f (x) uniforme peut toujours servir en pratique, mais risque
d’être très inefficace si la fonction p(x) est piquée autour d’une valeur en particulier.
6.1.4 Méthode du rapport des aléatoires uniformes
Une méthode puissante pour générer un grand nombre de distributions est la méthode du rapport des
aléatoires uniformes (Kinderman et Monahan), que nous allons maintenant expliquer. La méthode
du rejet peut se représenter ainsi dans le plan (x, p) :
∫ p(x)
p(x) dx = dp ′ dx (6.8)
0
Ce qui revient à dire que si on échantillonne uniformément la région bornée par l’axe des x et par
la courbe p(x) dans le plan (x, p), on se trouve à échantillonner x selon la distribution p(x). Cette
affirmation, toute évidente qu’elle soit, repose sur le fait que l’intégrant de l’intégrale ci-dessus est
l’unité.
Procédons maintenant à un changement de variables :

v
x= p = u2 (6.9)
u
Le jacobien associé est une constante :
¯ ¯
∂(p, x) ¯¯2u −v/u 2 ¯¯
=¯ ¯=2 (6.10)
∂(u, v) ¯ 0 1/u ¯
et donc on peut écrire, sur le plan (u, v),

∫ pp(x) ∫ pp(v/u)
p(x) dx = 2 du dv = 2 du dv (6.11)
0 0
Le domaine d’intégration est défini par la courbe représentant la distribution p(x), d’une part, et
par la droite p = 0, d’autre part, exprimées en fonction de u et v . Comme l’intégrant est encore une
fois constant, un échantillonage uniforme à l’intérieur de cette courbe dans le plan (u, v) revient à
échantilloner x selon la distribution p(x), la valeur de x étant simplement donnée par le rapport v/u .
87
0.6
0.4
0.2
0.0
v
-0.2
-0.4
-0.6
0.0 0.1 0.2 0.3 0.4 0.5 0.6
u
F 6.3
Domaine du plan (u, v) permettant d’échantillonner une distribution gaussienne pour le rapport x = v/u (on
a choisi σ = 1 et µ = 0).
Nous avons ainsi généré x par un rapport de variables aléatoires (u et v ) distribuées uniformément,
avec cependant des conditions de rejet.
Considérons par exemple la distribution gaussienne :
1 (x − µ)2
p(x) = p exp − (6.12)
2πσ 2σ2
où σ est l’écart-type et µ la moyenne. Posons µ = 0, ce que nous pouvons faire sans perte de généralité.
En fonction de u et v , l’équation qui définit la distribution devient
√ (p )
1 v2
u2 = p exp − 2 2 ou v = ±uσ 2 ln 2πσu 2 (6.13)
2πσ 2u σ
Cette équation est représentée par la courbe illustrée à la figure 6.3.
Pour échantillonner efficacement une distribution gaussienne, on doit alors échantilloner de manière
uniforme u et v dans le domaine du graphique, rejeter les points qui tombent à l’extérieur de la
courbe, et ensuite retourner la valeur x = v/u . Pour augmenter l’efficacité de la procédure, on définit
des bornes externe et interne (angl. squeeze) à la courbe, bornes qui sont rapidement calculables en
comparaison de la formule (6.13). On accepte alors les points à l’intérieur de la borne interne et on les
rejette à l’extérieur de la borne externe. Ce n’est que dans les cas plus rares où le point tombe entre
les deux bornes qu’on doit tester la frontière exacte (6.13). On peut ainsi proposer un code qui produit
un aléatoire gaussien au coût moyen de 2.74 aléatoires uniformes.
88
6.2. Méthode de Monte-Carlo
6.2 Méthode de Monte-Carlo
L’épithète «Monte-Carlo» est appliquée généralement à des méthodes de calcul qui reposent sur
l’échantillonnage aléatoire d’un ensemble très vaste. Elle fait bien sûr référence à la célèbre maison
de jeu de Monaco, et a été proposée par J. von Neumann et Stanislaw Ulam lors du développement
des premières applications de ce genre à Los Alamos dans les années 1950. 4 L’idée générale la sui-
vante : plusieurs problèmes d’intérêt requièrent de sommer (ou de faire une moyenne) sur un très
grand nombre d’états. Ceux-ci peuvent être les états possibles d’un gaz ou d’un liquide, d’un système
magnétique, ou les trajectoires d’une particule dans un milieu. Le mot «état» est ici employé au sens
de «configuration», mais peut désigner quelque chose d’aussi simple qu’un point dans un domaine
d’intégration en plusieurs dimensions. Au lieu de sommer systématiquement sur tous les états, ce
qui est pratiquement impossible en raison de leur nombre astronomique, on échantillonne ces états
à l’aide de nombre aléatoires. La difficulté consiste généralement à (1) échantillonner de manière
efficace et (2) bien estimer les erreurs statistiques ainsi commises.
6.2.1 Motivation : modèle d’Ising
Pour motiver la méthode de Monte-Carlo, considérons premièrement le modèle d’Ising, l’une des pre-
mières théories proposées pour tenter de comprendre le ferromagnétisme, et l’un des modèles les plus
simples de la physique statistique.
Wilhelm Lenz a proposé en 1920 un modèle simple pour décrire le changement de phase magnétique
dans un ferroaimant. Ce modèle fut étudié par son étudiant Ernst Ising qui l’a solutionné en 1925 dans
le cas d’une dimension d’espace, et qui lui a laissé son nom. On suppose dans ce modèle que les atomes
du matériau sont disposés régulièrement, par exemple sur un réseau carré ou cubique. Chaque atome
porte un spin, et un moment magnétique associé, représenté par une variable s i pouvant prendre deux
valeurs : +1 et −1 (i étant l’indice de l’atome, ou du site cristallin). On peut se figurer que ces deux
valeurs représentent deux orientations opposées de l’aimantation (ou du spin) de chaque atome. Le
modèle est ensuite défini par l’expression de l’énergie totale du système :
∑
H [s] = −J si s j (6.14)
〈i j 〉
où la somme est effectuée sur les paires de sites qui sont des voisins immédiats sur le réseau, ce qu’on
appelle couramment les premiers voisins (ces paires sont notées 〈i j 〉). Deux spins voisins contribuent
une énergie −J s’ils sont parallèles, et +J s’ils sont antiparallèles. La tendance énergétique est donc de
favoriser les configurations ferromagnétiques (spins alignés), mais celles-ci sont rares en comparaison
des configurations d’aimantation nulle : l’entropie favorise l’état paramagnétique.
Problème 6.1 : Dénombrement des configurations
A Pour un système comportant N sites, combien y a-t-il de configurations d’aimantation M ?
B Tracez le logarithme du nombre de configurations d’aimantation M en fonction de M , pour N = 36.

.
Un système comportant N sites supporte donc 2N configurations de spins différentes (notées s ). Se-
lon la mécanique statistique, les quantités observables (énergie ou aimantation) sont obtenues en
moyennant leur valeur sur toutes les configurations, chacune étant prise avec un poids
1 H [s] 1 def 1 def ∑

W [s] = exp − = exp −βH [s] β = , Z = e−βH [s] (6.15)
Z T Z T s
4. L’oncle de Ulam était, semble-t-il, un joueur compulsif qui empruntait de l’argent pour jouer à la roulette à Monte-Carlo.
89
F 6.4
Configuration aléatoire du modèle d’Ising défini sur un carré de 32×32 sites. Les spins s i = +1 sont indiqués
par un carré gris, et les spins s i = −1 par un carré blanc.
où T est la température absolue, dans des unités telles que k B = 1. L’énergie E et l’aimantation M
moyennes sont alors données par
1∑
〈E 〉 = H [s] e−βH [s]
Z s
(6.16)
1∑ ∑
〈M 〉 = M [s] e−βH [s] où M [s] = s i
Z s i
L’objectif de Lenz et d’Ising était de voir si un modèle aussi simple que celui-ci pouvait expliquer
l’existence d’un changement de phase entre un état ferromagnétique à basse température (T < Tc ),
dans lequel 〈M 〉 ̸= 0, et un état paramagnétique 〈M 〉 = 0 à haute température (T > Tc ). La température
critique Tc correspondrait alors à la température de Curie d’un matériau ferromagnétique.
Ising réussit à résoudre exactement ce modèle en dimension 1 seulement, et observa qu’il n’y avait
pas de changement de phase à température non nulle, autrement dit que la température de Curie Tc
était nulle. 5 Par contre, en 1944, Lars Onsager réussit à résoudre analytiquement le modèle d’Ising
en deux dimensions d’espace, et trouva une température critique non nulle, donnée par
Tc 2
= p = 2.2691853142130221 . . . (6.17)
J ln(1 + 2)
Ce résultat confirma la pertinence du modèle et stimula l’étude de modèles plus réalistes.
Un modèle plus réaliste du magnétisme doit tenir compte plus exactement de la nature vectorielle et
quantique du spin. Par exemple, le modèle de Heisenberg pour le magnétisme est défini à l’aide des
opérateurs du spin : ∑
H = −J Si · S j (6.18)
〈i j 〉
Ce modèle peut être traité de manière classique (les vecteurs Si sont alors de norme constante) ou de
manière quantique (les vecteurs Si sont alors des opérateurs quantiques). Le traitement quantique
est bien sûr plus réaliste. Le couplage spin-spin du modèle de Heisenberg est isotrope, c’est-à-dire
invariant par rotation. Par contre, dans certains matériaux, l’interaction spin-orbite peut mener à un
couplage spin-spin qui n’est pas invariant par rotation dans l’espace des spins :
∑( x x y y
) ∑ z z
H = −J x y Si · S j + Si · S j − J z Si · S j (6.19)
〈i j 〉 〈i j 〉
5. Ising quitta ensuite la recherche académique et fit une carrière de professeur dans un High School américain, alors que
son nom fut ensuite associé au modèle le plus célèbre de la mécanique statistique.
90
Dans les cas où J z > J x y , on peut montrer que le modèle se comporte effectivement comme un modèle
d’Ising proche de la transition ferromagnétique (les composantes S iz ne pouvant prendre que deux
valeurs opposées ± 12 ). Tout cela pour dire que le modèle d’Ising, malgré sa simplicité extrême, n’est
pas tout à fait irréaliste.
Solution numérique du modèle d’Ising

Si la solution numérique du modèle d’Ising était impossible (c’est le cas de la vaste majorité des
modèles étudiés en physique statistique), il faudrait se résigner à le résoudre numériquement. Naï-
vement, il faudrait calculer la fonction de partition Z en procédant à une somme sur toutes les confi-
gurations possibles. Or, pour un petit système 32×32 comme celui illustré sur la figure 6.4, le nombre
de configurations possibles est 21024 ∼ 10308 . Comme on estime le nombre de protons dans l’Univers
à ∼ 1080 , on voit à quel point ce nombre est astronomique et empêche tout calcul systématique de la
fonction de partition.
Une approche plus raisonnable est d’échantilloner les configurations, en suivant leur distribution
de probabilité naturelle, soit la distribution de Boltzmann, et à remplacer les moyennes exactes par
des moyennes partielles, cependant entachées d’erreurs statistiques. C’est ce que vise à accomplir la
méthode de Monte-Carlo.
6.2.2 Exemple simple : calcul de l’aire d’un disque
Au lieu de s’attaquer immédiatement au modèle d’Ising, commençons par un problème élémentaire,

soit le calcul de l’aire d’un disque de rayon 1, c’est-à-dire π. Au lieu de faire l’intégrale analytiquement,
évaluons-la en tirant deux aléatoires uniformes x ∈ [−1, 1] et y ∈ [−1, 1], et en rejetant le couple (x, y)
s’il est en dehors du disque, c’est-à-dire si la condition x 2 + y 2 < 1 n’est pas satisfaite. Le rapport du
nombre de points acceptés sur le nombre total N de points générés devrait tendre vers π/4 quand
N → ∞.
Quel rapport avec le modèle d’Ising ? On peut considérer que chaque point (x, y) à l’intérieur du carré
est une configuration (l’équivalent d’une configuration de spins). Le fait qu’il y ait un continuum de
configurations au lieu d’un ensemble discret n’est pas un obstacle : on pourrait très bien discrétiser
l’ensemble des points en adoptant une grille extrêmement fine, suffisamment fine pour que l’erreur
introduite par cette discrétisation soit négligeable ; de toute façon, représenter un continuum par des
nombres à virgule flottante revient exactement à cela. On peut ensuite supposer que les points (x, y)
sont distribués avec une densité de probabilité égale à 1 à l’intérieur du disque, et nulle à l’extérieur,
comme si l’énergie des points à l’intérieur était nulle, et celle des points à l’extérieur était infinie,
dans le langage de la mécanique statistique.
L’aire du disque est alors reliée à la valeur moyenne de la variable aléatoire suivante :
{
1 si (x 2 + y 2 ) < 1
A= (6.20)
0 sinon
Plus précisément, la variable aléatoire A suit une distribution binomiale avec P (A = 1) = p = π/4 et
P (A = 0) = q = 1 − p . La valeur moyenne de A est 〈A〉 = p = π/4 et sa variance est
π π
Var A = p − 〈A〉2 = p − p 2 = (1 − ) (6.21)
4 4
Le but du calcul Monte-Carlo ici est d’estimer la valeur moyenne de A (en supposant qu’on ne connaisse
pas π autrement) et d’estimer l’erreur statistique commise lors du calcul : c’est un problème d’inférence
statistique.
L’estimation de la valeur de A est donnée par l’espérance mathématique :
1 ∑
Ā = Ai (6.22)
N i
91
N Ā σ erreur/σ
10 2.4 0.52 1.4
2
10 3.12 0.16 0.13
103 3.176 0.052 −0.66
104 3.1148 0.016 1.63
105 3.1498 0.052 −1.6
106 3.1417 0.0016 −0.068
7
10 3.14177 0.00052 −0.35
F 6.5
Calcul de l’aire d’un cercle par la méthode de Monte-Carlo. À gauche : valeur estimée de π en fonction du
nombre de points, écart-type de l’estimation et erreur commise en rapport avec l’écart-type.
La valeur de Ā ainsi calculée (multipliée par 4), dans un exemple de simulation, est illustrée à la
figure 6.5 en fonction du nombre de points tirés.
Comment estimer l’erreur commise lors d’un tel calcul ? On a recours au théorème de la limite cen-
trale, qui stipule essentiellement ce qui suit : Si on somme N variables aléatoires A i indépendantes
qui suivent toutes la même distribution de probabilité avec variance Var A , alors l’écart-type de l’es-
pérance mathématique Ā est √
Var A 1
∆( Ā) = = p ∆(A) (6.23)
N N
et, dans la limite où N est grand, cette espérance mathématique suit une loi normale dont la moyenne
est µ = 〈A〉. Ce théorème est démontré partiellement à la section 6.3.1 ci-dessous. Le fait de tirer N
points aléatoires indépendants dans le carré revient à mesurer l’espérance mathématique Ā défine
en (6.23), dont l’écart-type est √
1 π( π)
σ= 1− (6.24)
N 4 4
Par exemple, si on tire N aléatoires uniformément distribués dans [−1, 1], la moyenne de chaque aléa-
toire est 0, et la variance est 1/3. Chacun des tirs suit la même loi de probabilité, et donc l’espérance
mathématique des résultats, Ā , suivra une loi normale de moyenne 0 et de variance 1/3N . En clair,
cela signifie qu’en générant N “mesures” A i de A , on se trouve
p à générer une instance de la variable
Ā , instance qui tombe à l’intérieur d’un écart-type ∆(A)/ N de la moyenne 〈A〉 68% du temps, et à
l’intérieur de deux écarts-types 95% du temps.
6.2.3 Intégrales multi-dimensionnelles
Supposons qu’on doive intégrer une fonction f (x) de d variables, ou plutôt la moyenne de f dans son
domaine de définition : ∫ d
d x f (x)
〈 f 〉 = Ω∫ d (6.25)
Ωd x
Le principe de l’intégration Monte-Carlo est d’échantilloner l’espace Ω avec N points x i et d’estimer

la moyenne ainsi :
1 ∑
〈f 〉 ≈ f (x i ) (6.26)
N i
On commet alors une erreur

√
Var f def
∆= Var f = 〈 f 2 〉 − 〈 f 〉2 (6.27)
N
92
Si, au contraire, on intègre la même fonction en utilisant une grille fixe de points, avec par exemple
la méthode de Simpson, l’erreur commise sera de l’ordre de 1/n 4 , où n est le nombre de points par
direction, menant à un nombre total de points N = n d (on suppose un nombre de points égal dans
chaque direction de l’espace). L’erreur commise dans la méthode de Simpson est donc
1
∆Simpson ∼ (6.28)
N 4/d
On voit que la méthode Monte-Carlo converge plus rapidement que la méthode de Simpson pour des
dimensions d > 8. Autrement dit, pour les intégrales dans des domaines de grande dimension, le
Monte-Carlo est la meilleure méthode ! Le fait de remplacer la méthode de Simpson par une autre
méthode convergeant plus rapidement ne change pas fondamentalement ce résultat, mais ne fait
que repousser son impact à des dimensions plus grandes. Or, en mécanique statistique classique, on
doit calculer les valeurs moyennes en intégrant sur l’espace des phases Ω de M particules. En trois
dimensions d’espace, la dimension de l’espace Ω est d = 6M (ou d = 4M en deux dimensions d’espace).
Donc quelques particules seulement suffisent à rendre l’intégration Monte-Carlo incontournable.
Dans plusieurs modèles de physique statistique, les configurations du système sont discrètes et non
continues. Par exemple, le modèle d’Ising défini sur M sites comporte 2M états possibles, un nombre
fini, mais qui croît exponentiellement avec M . Là aussi l’échantillonnage Monte-Carlo est la méthode
de choix, car la somme exacte sur toutes les configurations est impossible à réaliser si M est grand,
alors que l’erreur Monte-Carlo, elle, est contrôlable.
6.2.4 L’algorithme de Metropolis
Soit Ω l’espace sur lequel vit une variable aléatoire multidimensionnelle x suivant une distribution
µ(x). Le problème est de calculer la valeur moyenne d’une fonction A(x) dans cet espace :
∫
dx µ(x)A(x)
〈A〉 = Ω∫ (6.29)
Ω dx µ(x)
En mécanique statistique, x représente un état dynamique du système (un point dans l’espace des
phases, par exemple) ; A(x) représente une quantité physique (une fonction dans l’espace des états),
comme l’énergie ou l’aimantation. Enfin la distribution µ(x) est la probabilité relative d’occupation de
l’état x , comme par exemple la loi de Boltzmann µ(x) = exp −E (x)/T , T étant la température absolue
en unités de l’énergie E . Si on suppose que l’espace des configurations Ω forme un ensemble discret
et non continu, l’expression ci-dessus s’écrit plutôt
∑
x µ(x)A(x)
〈A〉 = ∑ (6.30)
x µ(x)
Pour calculer la moyenne (6.30), on doit en pratique générer un ensemble de configurations aléatoires
x , ce qui n’est pas toujours facile et économique dans un espace de grande dimension. En particulier,
la méthode du rejet simple peut dans ces cas devenir très inefficace. L’algorithme de Metropolis vise
à échantilloner l’espace des configurations Ω non pas en produisant des valeurs successives qui sont
absolument indépendantes, mais plutôt à produire une «marche aléatoire» dans Ω, qui puisse traver-
ser Ω en passant plus de temps dans les régions où µ(x) est plus grand, c’est-à-dire en générant une
séquence de points x i qui finit par être distribuée selon µ(x) lorsqu’elle est suffisamment longue.
L’algorithme vise en fait à produire une chaîne de Markov, c’est-à-dire une successsion de valeurs
aléatoires dont chacune provient de la précédente selon une loi de probabilité bien précise :
x 1 → x 2 → x 3 → · · · → x i → x i +1 → · · · (6.31)
Le passage d’une valeur x à un valeur y à chaque étape de la chaîne est effectué avec une probabi-
lité W (x → y), appelée probabilité de transition. Dans tout calcul numérique, le nombre de valeurs
possibles de x est fini (disons M ), et chaque valeur possible de x pourrait alors être étiquetée à l’aide
d’un indice variant de 1 à M . Dans ce cas, les probabilités de transition W forment une matrice finie
93
d’ordre M notée W y x = W (x → y) (noter l’ordre inverse des indices). Afin de simplifier la notation,
nous étiquettons directement les rangées et colonnes de cette matrice par les configurations x et y
et non par les entiers correspondants. Un vecteur X de dimension M représente alors une certaine
distribution de la variable aléatoire x , qui n’est pas nécessairement la distribution recherchée (µx ).
Par exemple, le vecteur X pourrait n’avoir qu’une composante non nulle au départ. Par contre, en
appliquant de manière répétée la matrice W sur ce vecteur, la distribution évolue, et peut tendre vers
une limite stable, ce qui correpond à un vecteur propre de W de valeur propre unité :
WX =X (6.32)
Le vecteur propre X correspond alors à une distribution de probabilité qui n’est pas affectée par la
marche, idéalement celle qu’on désirait générer au départ : X = (µ(x)).
Pour ce faire, les probabilités de transition W (x → y) doivent respecter les contraintes suivantes :
∑ ∑
1. Normalisation : y W (x → y) = 1, ou y W y x = 1, en langage discret. Cette propriété est néces-
saire afin que W soit effectivement une matrice de probabilités. Elle impose M contraintes sur
les M 2 composantes de W .
2. Ergodicité : toute valeur de y doit être éventuellement accessible à partir de toute valeur de x si
on applique la matrice W un nombre suffisant de fois : il existe un entier n tel que W n (x → y) ̸= 0,
ou encore (W n ) y x ̸= 0 ∀x, y . Cette propriété nous assure que toutes les régions de l’espace Ω
seront visitées, quel que soit le point de départ de la chaîne.
3. Le bilan détaillé :
µ(x)W (x → y) = µ(y)W (y → x) ou encore µ(x)W y x = µ(y)Wx y (6.33)
1
où on ne somme pas sur l’indice répété. Cette relation impose 2 M (M −1) contraintes à la matrice
W . Elle suffit cependant à s’assurer que le vecteur µx est un vecteur propre de W de valeur
propre unité. En effet,
∑ ∑ µx ∑
Wx y µ y = W y x µ y = W y x µx = µx (6.34)
y y µ y y
où on a utilisé la condition de normalisation et la condition du bilan détaillé. Ces deux condi-
tions ensemble ne fixent pas W de manière unique, mais seulement 21 M (M + 1) composantes.
Notons cependant qu’il n’est pas nécessaire de connaître précisément la normalisation de la distri-
bution µx . Autrement dit, µx peut être une probabilité relative, dont la somme est la fonction de
partition ∑
Z = µx (6.35)
x
Dans ce cas, la condition de normalisation ci-dessus se ramène à
∑ ∑ ∑ µx ∑
W (x → y) = Z ∀x et Wx y µ y = W y x µ y = W y x µx = Z µx (6.36)
y y y µ y y
ce qui revient à demander que le vecteur X soit un vecteur propre de W avec valeur propre Z :
WX =ZX (6.37)
L’algorithme de Metropolis utilise la forme suivante de la matrice W :

( ) ( )
µ(y) µx
W (x → y) = min 1, ou encore Wx y = min 1, (6.38)
µ(x) µy
ce qui peut également se représenter par le tableau suivant :
W (x → y) W (y → x)
µ(x) > µ(y) µ(y)/µ(x) 1
µ(x) < µ(y) 1 µ(x)/µ(y)
On constate que cette prescription respecte la condition du bilan détaillé. Par contre, elle ne respecte
pas la condition de normalisation stricte, mais il suffit de multiplier W par une constante de norma-
lisation inconnue Z −1 pour régler ce problème. L’avantage de l’algorithme de Metropolis est que la
connaissance préalable de cette constante de normalisation n’est pas requise ; seules les probabilités
relatives µ(x)/µ(y) le sont.
94
6.3. Analyse d’erreur
6.3 Analyse d’erreur
L’aspect le plus subtil de la méthode de Monte-Carlo est l’estimation des résultats et de leur incerti-
tude à partir des données statistiques recueillies. Considérons un ensemble de valeurs mesurées A i
(i = 1, . . . , N ) d’une observable A , lors d’un processus markovien, par exemple basé sur l’algorithme de
Metropolis. On suppose que la variable aléatoire A possède une moyenne exacte 〈A〉 et une variance
exacte Var A définie par
Var A = 〈A 2 〉 − 〈A〉2 (6.39)
L’objectif principale de la simulation Monte-Carlo est d’obtenir une estimation de la valeur moyenne
〈A〉, ainsi que de l’incertitude ∆ A sur cette valeur.
6.3.1 Théorème de la limite centrale
Il est assez évident que la meilleure estimation de la moyenne 〈A〉 est précisément la moyenne statis-
tique des valeurs mesurées :
1 ∑
Ā = Ai (6.40)
N i
Il est cependant intéressant de le démontrer, en considérant l’expression ci-haut de Ā comme une

variable aléatoire dont on doit calculer la valeur moyenne :
1 ∑ 1 ∑
〈 Ā〉 = 〈A i 〉 = 〈A〉 = 〈A〉 (6.41)
N i N i
où on a supposé que chaque mesure A i obéissait à la même loi de probabilité qui régit la variable A ,
de sorte que 〈A i 〉 = 〈A〉.
L’estimation de l’erreur s’obtient ensuite en calculant la variance de Ā :
Var Ā = 〈 Ā 2 〉 − 〈 Ā〉2 = 〈 Ā 2 〉 − 〈A〉2 (6.42)
Or
1 ∑ 1 ∑ 1 ∑
〈 Ā 2 〉 = 〈A i A j 〉 = 2 〈A 2i 〉 + 2 〈A i A j 〉 (6.43)
N 2 i,j N i N i , j (i ̸= j )
Dans l’hypothèse où les mesures successives de A ne sont pas corrélées, alors 〈A i A j 〉 = 〈A i 〉〈A j 〉 = 〈A〉2
si i ̸= j (il y a N (N − 1) termes comme celui-là). On trouve alors
1 2 N −1
〈 Ā 2 〉 = 〈A 〉 + 〈A〉2 (6.44)
N N
Au total, la variance de Ā est

1 2 1 1
Var Ā = 〈A 〉 − 〈A〉2 = Var A (6.45)
N N N
On retrouve donc le théorème de la limite centrale,pque nous venons en p fait de démontrer : l’erreur
∆ A commise sur l’estimation de 〈A〉 est l’écart-type Var A , divisé par N .
Problème 6.2
Montrez que la variance Var A peut être estimée comme suit à partir des valeurs mesurées :
N ( 2 )
def 1 ∑
Var A = A − Ā 2 où A2 = A 2i (6.46)
. N −1 N i
95
6.3.2 Analyse logarithmique des corrélations
Le problème avec l’analyse ci-dessus est que les mesures successives A i dans un processus markovien
non idéal sont corrélées. En pratique, les mesures successives sont corrélées sur une certain «temps»
caractéristique noté τ A et appelé temps d’autocorrélation :
def 1 ∑ ∞
τA = (〈A 1+t A 1 〉 − 〈A〉2 ) (6.47)
Var A t =1
Nous employons le mot «temps» dans le sens markovien, c’est-à-dire désignant la position dans la
chaîne de Markov. On peut supposer généralement que la corrélation chute exponentiellement avec
le temps, de sorte que seuls quelques termes de la somme sur t contribuent de manière appréciable,
et donc la borne supérieure infinie de la somme sur les temps n’est pas réellement importante.
Retournons à l’éq. (6.43), sans toutefois supposer que les mesures sont non corrélées :
1 2 N −1 1 ∑ ( )
〈 Ā 2 〉 = 〈A 〉 + 〈A〉2 + 2 〈A i A j 〉 − 〈A〉2 (6.48)
N N N i , j (i ̸= j )
et donc
1 1 ∑ ( )
Var Ā = Var A + 2 〈A i A j 〉 − 〈A〉2
N N i , j (i ̸= j )
1 2 ∑ N N∑−i ( )
=
Var A + 2 〈A i A i +t 〉 − 〈A〉2
N N i t =1 (6.49)
1 2 ∑∞ ( )
≈ Var A + 〈A 1 A 1+t 〉 − 〈A〉2
N N t =1
1
= Var A(1 + 2τ A )
N
Nous avons donc une estimation corrigée de l’erreur commise sur l’estimation de la valeur moyenne
d’une observable. Il nous faut cependant une méthode efficace pour calculer le temps d’autocorrélation
τ A , car la définition directe de cette quantité ne se prête pas à un calcul pratique.
A1 A2 A3 A4 A5 A6 A7 A8 A9 A 10 A 11 A 12 A 13 A 14 A 15 A 16
A (1)
1 A (1)
2 A (1)
3 A (1)
4 A (1)
5 A (1)
6 A (1)
7 A (1)
8
A (2)
1 A (2)
2 A (2)
3 A (2)
4
A (3)
1 A (3)
2
F 6.6
Schéma de l’analyse logarithmique d’erreurs.
À cette fin, nous allons procéder à une analyse logarithmique des erreurs (angl. binning), dont le
principe est illustré à la figure 6.6. Au fur et à mesure que les mesures A i sont prises, on construit
des séries accessoires de moyennes binaires
( )
A (l ) = 12 A (l2i−1)
−1
+ A (l −1)
2i
(6.50)
96
6.4. Simulation du modèle d’Ising avec l’algorithme de Metropolis
où l est l’indice du niveau de la série accessoire. Chaque série accessoire contient la moitié du nombre
de termes de la série précédente, jusqu’à n’en contenir qu’un seul (voir la figure). Si on procède à 2M
mesures, alors M + 1 séries sont ainsi formées, y compris la série principale (l = 0). Pour chaque série
on peut calculer l’estimation de la moyenne et de la variance :
∑Nl ( )2
1
Var A (l ) = A (li ) − A (l ) (6.51)
Nl (Nl − 1) i =1
−l
où Nl = 2M √ est le nombre de terme dans la série de niveau l . Les erreurs associées à chaque sé-
(l )
rie, ∆ A = Var A (l ) , sont initialement un sous-estimation de l’erreur véritable, mais convergent vers
celle-ci dans la limite l → ∞, car les termes consécutifs des séries accessoires deviennent non corré-
lés dans cette limite. En pratique, on ne construit pas toutes les séries accessoires jusqu’au niveau
maximum possible, car l’estimation de l’erreur requiert un nombre M l de données qui n’est pas trop
petit ; par exemple on peut arrêter de construire les séries accessoires en-deça de M l = 25 = 32. On
doit être en mesure d’observer que l’erreur estimée ∆(lA ) sature en fonction de l , et on peut adopter
cette valeur limite comme estimation de l’erreur véritable ∆(∞) A
, et en même temps estimer le temps
d’autocorrélation en fonction de cette valeur :
( ) 
(∞) 2
1  ∆A
τA = − 1 (6.52)
2 ∆(0) A
En pratique, cette méthode ne requiert pas de stocker toutes les séries accessoires, ni la série prin-
cipale. Le nombre de termes serait beaucoup trop grand. Comme on ne requiert que le calcul des
valeurs moyennes et des variances, il suffit de garder en mémoire la somme courante des valeurs et
la somme courante des valeurs au carré, pour chaque niveau l :
∑ ∑( )2
Σ(l ) = A (li ) T (l ) = A (li ) (6.53)
i i
1. À chaque fois qu’une mesure est effectuée au niveau 0, on met à jour Σ(0) et T (0) .
2. Si le nombre de mesures courant i est impair, on garde en mémoire A i .
3. S’il est pair, alors on forme la valeur courante de A (1) selon l’équation (6.50) et on reprend à
l’étape 1 ci-dessus, cette fois au niveau l = 1, et ainsi de suite.
Cette méthode est mise en œuvre dans les routines collecte et calcul_erreur de la classe
observable listée plus bas.
6.4 Simulation du modèle d’Ising avec l’algorithme de Metro-

polis
6.4.1 Algorithme
Le modèle d’Ising est véritablement le plus simple qu’on puisse imaginer : il comporte un nombre fini
de configurations pour un nombre fini N de sites (ou degrés de liberté), contrairement à un modèle de
gaz basé sur les positions et vitesses continues des particules. Et pourtant le calcul direct des valeurs
moyennes (6.16) est peu pratique, le nombre de configuration étant trop élevé (2N ) pour toute valeur
intéressante de N . À basse température, la très vaste majorité des configurations ont une énergie
trop élevée pour contribuer de manière significative aux valeurs moyennes. En revanche, à très haute
température, les configurations sont toutes à peu près équivalentes, et il n’est pas plus sage alors de
les compter toutes.
Voici comment procède le calcul des valeurs moyennes du modèle d’Ising par l’algorithme de Metro-
polis :
97
1. Choisir une configuration initiale des spins. On peut la choisir de manière aléatoire, ce qui est
alors typique d’une température élevée et demandera un plus long temps d’équilibration (ou
thermalisation) si T < Tc .
2. À l’intérieur d’une boucle :
(a) Effectuer une mise à jour de la configuration, en choisissant un site au hasard et en renver-
sant le spin sur ce site.
(b) Calculer la différence d’énergie ∆E entre cette configuration et la précédente.
(c) Si ∆E < 0 (énergie plus basse), accepter le changement.
(d) Si ∆E > 0 (énergie plus élevée), accepter ce changement avec probabilité e−∆E /T , sinon
conserver l’ancienne configuration.
(e) Mesurer les observables et collecter les statistiques périodiquement (c’est-à-dire à toutes les
R mises à jour), pourvu que le nombre de mises à jour déjà effectuées soit suffisant pour que
le processus markovien ait convergé vers la distribution de Boltzmann – ce qu’on appelle le
temps de thermalisation.
3. Arrêter lorsque L niveaux de séries accessoires ont été complétés. Calculer l’erreur et le temps
d’autocorrélation τ A pour chaque observable. S’assurer que τ A est considérablement plus petit
que 2L (le nombre de mesures effectuées au niveau 0 pour une valeur donnée au niveau L ).
On reconnaît dans l’étape 2 ci-dessus l’algorithme de Metropolis.
0 1 50
-0.5 40
0.5
-1 30
0
M
E
-1.5 20
-0.5 10
-2
-2.5 -1 0
0.5 1 1.5 2 2.5 3 3.5 4 4.5 5
0.5 1 1.5 2 2.5 3 3.5 4
T
T
F 6.7
À gauche : valeurs moyennes de l’énergie E (rouge) et de l’aimantation M (bleu) en fonction de la température
dans le modèle d’Ising 2D, sur un amas 32 × 32. Les barres d’erreur sont affichées pour M . À droite : temps
d’autocorrélation pour les mêmes quantités, avec le même code de couleurs. Le temps τM pour l’aimantation
dépasse les bornes acceptables très proche de la transition ; les valeurs de M ne sont donc pas fiables à cet
endroit.
Les résultats d’une simulation typique réalisée avec le code présenté ci-après sont illustrés à la figure
6.7.
6.4.2 Changements de phase
L’algorithme de Metropolis fonctionne généralement bien, mais des problèmes peuvent survenir à
proximité des changements de phase. Malheureusement, ce sont généralement les changements de
phase qui sont intéressants !
98
6.4. Simulation du modèle d’Ising avec l’algorithme de Metropolis
Longueur de corrélation
L’un des concepts fondamentaux de la physique statistique est celui de longueur de corrélation. Il
s’agit, grosso modo, de la distance caractéristique ξ en-deça de laquelle les spins de sites différents
sont corrélés. On définit la fonction de corrélation χi j entre les sites i et j comme suit :
χi j = 〈s i s j 〉 − 〈s i 〉〈s j 〉 (6.54)
Cette fonction est nulle lorsque les sites i et j sont suffisamment éloignés l’un de l’autre, mais décroît
généralement de manière exponentielle en fonction de la distance :
|ri − r j |
χi j ∝ exp − (6.55)
ξ
ri étant la position du site no i . Cette forme exponentielle définit plus rigoureusement la longueur de
corrélation ξ.
Types de changements de phase

On distingue deux types généraux de changements de phase :
1. Les changements de phase continus, souvent appelés changements de phase du deuxième ordre.
Ceux-ci sont caractérisés par une divergence de la longueur de corrélation ξ à l’approche de
la transition. Les différentes quantités thermodynamiques, comme l’énergie ou l’aimantation,
sont cependant continues à la transition. La transition magnétique du modèle d’Ising est de ce
type.
2. Les changements de phase discontinus, aussi appelés changements de phase du premier ordre.
Ceux-là séparent deux phases dont les énergies libres sont identiques exactement à la transi-
tion ; mais comme dans ce cas la longueur de corrélation ne diverge pas, différentes régions de
l’espace peuvent se retrouver dans des phases différentes : on dit qu’il y a coexistence de phase
à la transition. Sous certaines conditions, il peut aussi y avoir hystérésis : une phase de haute
température peut se prolonger en-deça de la température de transition pendant un certain
temps et se trouver dans un état métastable ; à l’inverse, une phase de basse température peut
se retrouver en équilibre métastable au-delà de la température de transition. L’exemple type
d’une telle transition est l’ébullition de l’eau : les phase liquide et gazeuse sont en coexistence
à la température de transition.
Ralentissement critique
En principe, un véritable changement de phase ne peut exister que dans la limite thermodynamique,
c’est-à-dire la limite de taille infinie du système. En pratique, il suffit que le système soit suffisam-
ment grand pour que toutes les caractéristiques d’un véritable changement de phase se manifestent,
physiquement ou numériquement. L’un des phénomènes physiques qui se manifeste à proximité d’un
changement de phase continu est le ralentissement critique, c’est-à-dire des fluctuations de plus en
plus lentes qui se manifestent par un temps d’autocorrélation qui diverge. Dans le modèle d’Ising, on
observe en fait que, à la transition elle-même (T = Tc ), le temps d’autocorrélation croît comme le carré
de la taille L du système :
τ ∝ L2 (6.56)
On observe aussi que, lors d’une transition du premier ordre qu’on franchit de manière progressive
dans une simulation, le système reste dans la phase métastable, et le temps nécessaire pour plonger
dans la phase de plus basse énergie se comporte comme
τ ∼ exp L d −1 (6.57)
où L est la taille du système et d la dimension de l’espace.
code : observable.h, Ising.h, Ising.cpp — page 195
99
6.5 Simulations de particules
Les méthodes stochastiques sont très utiles dans l’étude des processus faisant intervenir des colli-
sions ou réactions entre particules. La physique des radiations (radiobiologie) met à profit de telles
méthodes afin de modéliser les processus en cours dans un tissu irradié. La physique expérimentale
des particules élémentaires utilise la méthode de Monte Carlo pour simuler les cascades de particules
au sein des détecteurs de particules des grands accélérateurs. Nous allons illustrer ces méthodes à
l’aide d’un exemple simple, tiré de la physique nucléaire.
Supposons qu’un faisceau de neutrons, d’énergie cinétique E , soit incident sur un mur d’épaisseur
h , constitué d’une substance – ci-après appelée le modérateur – pouvant diffuser élastiquement les
neutrons, ou les absorber. Soit dσel / dΩ la section différentielle de diffusion entre un neutron et un
atome de cette substance, dans le repère du centre de masse. Cette section différentielle de diffusion
mène à une section efficace σel . Soit en outre σabs la section efficace pour l’absorption d’un neutron par
le noyau de cette substance. Si ce sont là les deux seuls processus possibles impliquant les neutrons,
la section efficace totale σ = σel +σabs correspond à une certaine distance caractéristique ξ = (nσ)−1 , où
n est la densité volumique des diffuseurs, c’est-à-dire le nombre d’atomes de modérateur par unité de
volume. On montre sans peine que la probabilité qu’un neutron puisse se propager sur une distance
x sans subir de collision ou d’absorption est
p(x) = e−x/ξ = e−ρσx (6.58)
La question qui se pose est la suivante : quelle fraction du faisceau incident a réussi à franchir le mur,
et quelle est l’énergie moyenne des neutrons qui l’ont franchi ?
Pour répondre à cette question, nous pouvons simuler le système de la manière suivante :
1. On suppose qu’un neutron a une position initiale r = (0, 0, 0) et une quantité de mouvement
initiale p = px. Le mur est perpendiculaire à l’axe des x et débute à x = 0 pour se terminer à
x = h.
2. Pour cette paire (r, p), on tire une valeur aléatoire de la distance de propagation d selon la
distribution exponentielle. On Suppose que le neutron se propage librement sur cette distance
d , et on met à jour la position du neutron : r → r + p̂d , où p̂ est le vecteur unitaire dans la
direction de p.
3. Si la nouvelle position r est au-delà du mur (x > h ), on arrête la simulation pour ce neutron
tout en mesurant les quantités physique requises, et on retourne à l’étape 1 pour en simuler un
autre. On procède de même si la nouvelle position est en-deça du mur (x < 0), ce qui ne saurait
se produire lors de la première passe.
4. À cette nouvelle position le neutron doit subir une interaction. La probabilité que le neutron
soit absorbé est Γabs = σabs /σ (ce qu’on appelle dans le jargon le rapport d’embranchement pour
ce processus), alors que la probabilité qu’il soit diffusé de manière élastique est Γel = σel /σ =
1 − Γabs . On tire alors un aléatoire x uniforme dans [0,1], et on suppose que le neutron est
absorbé si x < Γabs ; c’est alors la fin de l’histoire de ce neutron, on collecte la statistique et on
retourne à l’étape 1 ci-dessus pour traiter un autre neutron.
5. Si, au contraire, x > Γabs , on suppose qu’il est diffusé par un noyau au repos. On se déplace alors
dans le repère du centre de masse, dans lequel la quantité de mouvement du neutron devient
mn ma
p̃ = p − m n vcm = p − p= p (6.59)
mn + m a mn + m a
où m n et m a sont les masses du neutron et du noyau, respectivement. On choisit ensuite une

direction aléatoire pour le neutron diffusé dans le référentiel du centre de masse : on suppose
que la section différentielle de diffusion est indépendant de la direction, comme pour la diffusion
de sphères dures (ceci est une approximation, valable quand l’énergie du neutron n’est pas trop
grande). Puisque la mesure de l’angle solide est dΩ = sin θ dθ dφ = d cos θ dφ, cela revient à tirer
un uniforme dans [0, 2π] pour φ, et un autre uniforme dans [−1, 1] pour z = cos θ . Une fois cette
direction choisie, la quantité de mouvement p̃′ du neutron dans le repère du centre de masse
100
6.5. Simulations de particules
est fixée par la conservation de l’énergie : |p̃′ | = |p̃| et la quantité de mouvement du neutron
dans le repère du laboratoire est simplement
mn
p′ = p̃′ + p (6.60)
mn + m a
On met alors à jour la quantité de mouvement p → p′ et on retourne à l’étape 2 ci-dessus. Notons

que comme l’énergie du neutrons est maintenant plus faible (puisqu’il a cédé de l’énergie au
modérateur), la section d’absorption σabs sera généralement différente (cette quantité dépend
de l’énergie E du neutron).
6. On arrête la simulation lorsqu’un nombre prédéfini de neutrons a été traité.
101
102
7
Dynamique des fluides
L’étude du mouvement des fluides est l’une des applications les plus courantes du calcul scientifique.
Elle est particulièrement répandue en génie mécanique, dans la conception de véhicules (automobile,
aéronautique) et de réacteurs. En physique, elle constitue le problème de base de la prévision mé-
téorologique et climatique, et de la dynamique stellaire. Bref, il s’agit d’un problème extrêmement
important à la fois en sciences fondamentales et, surtout, en sciences appliquées.
Le problème du mouvement des fluides va bien au-delà de l’étude de l’écoulement d’un fluide unique
dans une géométrie statique. Dans les problèmes concrets, le fluide comporte plusieurs composantes,
c’est-à-dire plusieurs substances formant un mélange ; ces substances peuvent se transformer l’une
dans l’autre par réactions (chimiques, nucléaires, etc.). Il peut s’agir de phases différentes (liquide
et gaz, ou même liquide et solide). La géométrie dans laquelle le ou les fluides s’écoulent peut aussi
changer dans le temps, les parois solides peuvent être élastiques (par ex. en aéronautique) ou impli-
quer une croissance (ex. propagation d’une frontière de phase liquide-solide). Bref, la richesse et la
complexité des problèmes impliquant l’écoulement des fluides peut être considérable, et nous ne fe-
rons qu’effleurer le sujet dans ce chapitre, en nous concentrant sur une méthode de calcul : la méthode
de Boltzmann sur réseau.
7.1 Équations fondamentales
7.1.1 Équation de Navier-Stokes
Pendant très longtemps, la mécanique des fluides s’est réduite à une tentative de résolution de l’équa-
tion de Navier-Stokes. Cette équation gouverne l’évolution dans le temps d’un champ de vitesse u(r, t ),
qui décrit la vitesse au point r d’un fluide à une composante. La densité du fluide est décrite par un
champ scalaire ρ(r), et le produit ρu définit une densité de courant qui obéit à l’équation de continuité,
reflétant la conservation de la masse :
∂ρ
+ ∇·(ρu) = 0 (7.1)
∂t
L’équation de Navier-Stokes elle-même est
∂u
ρ + ρ(u · ∇)u = −∇P + ρν∇2 u + ρf (7.2)
∂t
où :
1. P est la pression à la position r.
2. ν le coefficient de viscosité cinématique.
3. f est une force externe (par unité de masse) agissant au point r
L’origine des différents termes de l’équation de Navier-Stokes est la suivante :
103
Chapitre 7. Dynamique des fluides
1. l’opérateur
∂
+u·∇ (7.3)
∂t
est une dérivée en co-mouvement, qui calcule la dérivée par rapport au temps d’une quantité
liée à une élément de masse qui se déplace à une vitesse u. Si on suit un élément de fluide
pendant un court instant, la dérivée temporelle d’une quantité relative à cet élément doit tenir
compte du déplacement de cet élément pendant cet instant. La dérivée totale par rapport au
temps est alors
d ∂ dr ∂ ∂
= + · = +u·∇ (7.4)
dt ∂t dt ∂r ∂t
Appliquer une simple dérivée partielle par rapport au temps, à position fixe, serait donc erroné.
Le membre de gauche de l’équation (7.2) représente donc la dérivée temporelle de la quantité
de mouvement par unité de volume.
2. Le membre de droite de l’équation (7.2) contient alors les forces par unité de volume qui agissent
sur l’élément de fluide : la première est le gradient de pression ; la deuxième une force qui
s’oppose aux variations spatiales de la vitesse (la viscosité) et la dernière une force externe
quelconque, comme par exemple la force de gravité.
L’équation (7.2) par elle-même est incomplète : on doit lui ajouter l’équation de continuité (7.1), qui
représente la contrainte de conservation de la masse. On doit également disposer d’une équation
d’état qui détermine la pression P (ρ, T ) en fonction de la densité et d’un paramètre externe comme
la température (en supposant que celle-ci soit uniforme et constante). Si la température n’est pas
uniforme, alors il faut ajouter un champ de température T (r, t ) qui sera gouverné par la conservation
de l’énergie, sous la forme d’une équation de continuité pour l’énergie interne, avec un courant de
chaleur associé.
7.1.2 Équation de Boltzmann
L’équation de Navier-Stokes est valable dans la limite macroscopique, ou hydrodynamique, dans la-
quelle les longueurs caractéristiques du problème (les dimensions des conduits, par exemple) sont très
grandes par rapport au libre parcours moyen des molécules qui forment le fluide, afin que la notion
d’élément de fluide ait un sens physique.
L’équation de Navier-Stokes peut être dérivée d’une équation plus fondamentale, c’est-à-dire plus mi-
croscopique : l’équation de Boltzmann. Cette dernière régit l’évolution dans le temps d’une distribution
de probabilité de positions et de vitesses dans l’espace des phases et est l’équation fondamentale de
la mécanique statistique hors équilibre.
Considérons à cet effet un fluide comportant un très grand nombre N de particules. Si nous avions la
prétention d’étudier la dynamique classique exacte de ce système complexe, nous devrions considérer
l’espace des phases de ce système, qui comporte 6N dimensions, pour les 3N positions et 3N impulsions
du système. L’état classique du système serait alors défini par un point dans cet espace et l’évolution
temporelle du système serait une trajectoire suivie par ce point dans l’espace des phases. Comme il
est irréaliste de procéder ainsi, nous allons plutôt raisonner sur la base de l’espace des phase pour
une seule molécule, en supposant que les N molécules du fluide sont distribuées dans cet espace des
phases. Une telle distribution est définie par une fonction f (r, p, t ) de la position et de l’impulsion ;
la probabilité de trouver une molécule dans un élément de volume d3 r à la position r, possédant
une impulsion contenue dans un élément de volume d3 p autour de p, est alors proportionnelle à
f (r, p) d3 r d3 p . Nous allons normaliser la distribution f par le nombre total N de particules :
∫
d3 r d3 p f (r, p) = N (7.5)
104
7.1. Équations fondamentales
Moments de la distribution
Si on intègre la distribution f sur toutes les valeurs de l’impulsion p à une position donnée r, on génère
des moments partiels de la distribution de probabilité. Les trois premiers moments correspondent à
la densité, la vitesse moyenne et l’énergie cinétique moyenne par unité de volume :
∫
ρ(r) = m d3 p f (r, p)
∫
ρ(r)u(r) = d3 p p f (r, p) (7.6)
∫
1
ρ(r)ϵ = d3 p (p − mu)2 f (r, p)
2
En effet, la première intégrale nous donne naturellement le nombre de particules par unité de volume,
ou encore la densité massique ρ si on multiplie par la masse m de chaque particule. La deuxième ex-
pression est l’impulsion par unité de volume à une position r, soit précisément la densité ρ multipliée
par la vitesse u du fluide à cet endroit. Enfin, la dernière expression est proportionnelle à la variance
de l’impulsion à la position r, ce qui n’est autre que l’énergie cinétique par unité de volume, telle que
définie dans le référentiel qui se déplace à la vitesse moyenne des particules à cet endroit ; c’est donc
l’énergie cinétique interne par unité de volume, ϵ étant l’énergie moyenne d’une particule de fluide
dans ce référentiel.
Équation de Boltzmann
Si les N molécules sont indépendantes les unes des autres et ne répondent qu’à des forces externes,
alors l’évolution dans le temps de la distribution f suit les règles de la mécanique de Hamilton à une
particule : au temps t + dt , la molécule à (r, p) s’est déplacée vers (r+p dt /m, p+f dt ), où f est une force
externe conservative agissant sur chaque particule. Donc
f (r + p dt /m, p + f dt , t + dt ) = f (r, p, t ) (7.7)
ou encore, en développant,
∂f 1 ∂f ∂f
+ p· +f· =0 (7.8)
∂t m ∂r ∂p
Cette équation décrit des particules indépendantes qui se déplacent sans interagir. On peut se figu-
rer la distribution f comme un nuage de probabilité qui se déplace dans l’espace des phases. Selon le
théorème de Liouville, 1 une portion donnée de l’espace des phases évolue dans le temps en se défor-
mant mais en conservant son volume. Le nuage de probabilité associé à f s’écoule donc dans l’espace
des phases en se déformant, mais de manière incompressible.
Ceci n’est plus vrai si on tient compte des collisions entre les particules élémentaires du fluide. À cette
fin, on modifie la relation (7.8) comme suit :
∂f 1 ∂f ∂f δ f ¯¯
+ p· +f· = ¯ (7.9)
∂t m ∂r ∂p δt coll.
où le membre de droite représente tout changement dans f (à un point donné de l’espace des phases)
causé par les interactions entre les particules (ou molécules).
Approximation des collisions moléculaires

Le terme de collision est souvent représenté dans l’approximation des collisions moléculaires, qui
suppose que les molécules collisionnent par paires et que deux molécules incidentes d’impulsions p et
p′ se retrouvent après collision avec des impulsions p + q et p′ − q : q est le transfert d’impulsion entre
les deux particules et la quantité de mouvement totale des deux particules est conservée lors de la
collision. Cette collision se produit avec une densité de probabilité par unité de temps g (p − p′ , q) qui
ne dépend que de deux variables en raison de l’invariance galiléenne : l’une est la vitesse relative des
deux particules, (p − p′ )/m , l’autre le paramètre d’impact de la collision, qui se traduit par un angle
de diffusion θ , ou de manière équivalente par un transfert d’impulsion q.
1. Voir le cours de Mécanique II – PHQ310
105
La variation de la fonction f à p due aux collisions avec des molécules d’impulsion p′ est alors
∫
δ f ¯¯(1)
¯ = − d3 p ′ d3 q g (p − p′ , q) f (r, p, t ) f (r, p′ , t ) (7.10)
δt coll.
Il s’agit bien sûr d’une diminution du nombre de particules d’impulsion p due aux collisions qui dif-
fusent ces particules vers d’autres impulsions. Par contre, les collisions peuvent aussi augmenter f à
p en raison des particules qui diffusent vers l’impulsion p. Cette augmentation s’écrit naturellement
comme ∫
δ f ¯¯(2)
¯ = d3 p ′ d3 q g (p − p′ , q) f (r, p + q, t ) f (r, p′ − q, t ) (7.11)
δt coll.
qu’il faut lire comme suit : les particules d’impulsion p + q diffusent sur les particules d’impulsion
p′ − q, ce qui résulte, après un transfert d’impulsion q, vers les impulsions p et p′ . On intègre sur
toutes les possibilités p′ et q pour obtenir la variation ci-dessus. Au total, l’équation de Boltzmann
dans l’approximation des collision moléculaires (Stosszahl Ansatz) prend la forme suivante :
∫ [ ]
∂f 1 ∂f ∂f
+ p· +f· = d3 p ′ d3 q g (p − p′ , q) f (r, p + q, t ) f (r, p′ − q, t ) − f (r, p, t ) f (r, p′ , t ) (7.12)
∂t m ∂r ∂p
L’équation (7.12) est difficile à résoudre : c’est une équation intégro-différentielle, qui implique une
intégrale double sur les impulsions à chaque évaluation de la dérivée temporelle de f . On peut montrer
(mais nous ne le ferons pas ici, car c’est une proposition assez complexe) que l’équation de Navier-
Stokes est une conséquence de l’équation (7.12).
Remarquons qu’en l’absence de forces externes, l’équation de Boltzmann sans le terme de collisions
entraîne que les distributions partielles f (r, p, t ) associées à des valeurs différentes de p sont indé-
pendantes, c’est-à-dire qu’elles ne s’influencent nullement en fonction du temps. Le terme de collision
se trouve à coupler entre elles des valeurs différentes de p.
Approximation du temps de relaxation

On s’attend naturellement à ce que la distribution f tende vers une distribution d’équilibre f eq. en
raison des collisions. Cette convergence vers f eq. va s’effectuer en général avec un certain temps carac-
téristique τ si la distribution initiale n’est pas trop éloignée de f eq. . Une façon courante de simplifier
considérablement l’équation de Boltzmann est de remplacer le terme de collision par une simple re-
laxation vers la distribution d’équilibre :
∂f 1 ∂f ∂f 1[ eq.
]
+ p· +f· = f (r, p) − f (r, p, t ) (7.13)
∂t m ∂r ∂p τ
La distribution f eq. se calcule, bien sûr, en mécanique statistique des systèmes à l’équilibre. Si la
distribution décrit un fluide qui se déplace à une vitesse u(r), ce sont les déviations par rapport à
cette vitesse qui seront l’objet d’une distribution de Maxwell-Boltzmann :
eq. ρ [p − mu(r)]2
f (r, p) = exp − (7.14)
m(2πmT )d /2 2mT
où d est la dimension de l’espace et T la température absolue (on pose k B = 1). Notez que, dans cette
dernière équation, la vitesse u dépend en général de la position. Cette distribution des impulsions à
l’équilibre respecte les règles de somme décrites à l’éq. (7.6), sauf que dans ce cas la densité d’énergie
cinétique ϵ est donnée par le théorème d’équipartition : ϵ = T d /2.
Notons que l’approximation du temps de relaxation couple effectivement les différentes valeurs de p :
la distribution à l’équilibre f eq. dépend de la vitesse du fluide u à un point donné, et celle-ci à son tour
se calcule par une intégrale sur les différentes impulsions.
106
7.2. Méthode de Boltzmann sur réseau
7.2 Méthode de Boltzmann sur réseau
7.2.1 Généralités
Depuis les années 1990, l’hydrodynamique numérique se tourne de plus en plus vers l’équation de
Boltzmann, au lieu de s’attaquer à l’équation de Navier-Stokes. L’avantage de l’équation de Boltz-
mann est qu’elle permet plus facilement de considérer des géométries complexes (des milieux poreux,
par exemple) et des fluides à plusieurs composantes, en tenant compte des réactions entre ces com-
posantes : le terme de collision peut en effet convertir des espèces de molécules en d’autres espèces,
c’est-à-dire décrire la cinétique des réactions chimiques. Le traitement numérique de l’équation de
Boltzmann dans le but de décrire le mouvement des fluides constitue ce qu’on appelle la méthode de
Boltzmann sur réseau (angl. lattice Boltzmann method ou LBM). Beaucoup de logiciels commerciaux
ou ouverts utilisés en génie ou ailleurs sont maintenant basés sur cette méthode.
Cependant, l’équation (7.12) est encore trop complexe. La méthode LBM est basée plutôt sur la version
simplifiée (7.13) de l’équation de Boltzmann. C’est ce qu’on appelle dans ce contexte le modèle de
Bhatnagar-Gross-Krook (BGK).
La numérisation de l’équation (7.13) passe nécessairement par une discrétisation de l’espace des
phases. En pratique, la partie spatiale a besoin d’une discrétisation fine, car souvent on s’intéresse au
passage des fluides à travers des géométries compliquées. Par contre, la discrétisation de l’espace des
vitesses (ou des impulsions) est extrêmement simplifiée : on considère généralement 9 valeurs de la
vitesse en deux dimensions (schéma D2Q9), 15 ou 27 en dimension 3 (schémas D3Q15 et D3Q27). Il
peut sembler surprenant à première vue qu’un aussi petit nombre de vitesses puisse bien représenter
le mouvement des fluides, mais il faut garder à l’esprit qu’on décrit ici une distribution de probabilité
f , et que la vitesse du fluide qui sera produite par cette approche est la moyenne pondérée des pro-
babilités associées aux 9 (ou 15, ou 27) valeurs formant la grille des vitesses, et donc qu’elle pourra
prendre un continuum de valeurs dans l’espace borné par cette grille.
7.2.2 Le schéma D2Q9 : dimension 2, 9 vitesses
6 2 5
3 0 1
7 4 8
F 7.1
Les 9 vitesses possibles dans le schéma D2Q9 de la méthode de Boltzmann sur réseau, en relation avec les
sites de la grille.
107
Voyons plus précisément comment se formule la méthode dans le schéma D2Q9 (voir fig. 7.1). Les sites
forment un réseau carré de pas a . Définissons les 9 vecteurs sans unités ei (i = 0, . . . , 8) :
e1 = (1, 0) e5 = (1, 1)
e2 = (0, 1) e6 = (−1, 1)
e0 = (0, 0) (7.15)
e3 = (−1, 0) e7 = (−1, −1)
e4 = (0, −1) e8 = (1, −1)
Les 9 déplacements possibles sont aei et sont illustrés par les flèches sur la figure. Les impulsions
correspondantes sont définies de telle manière qu’en un intervalle de temps h (le pas temporel de
la méthode), le déplacement aei soit la différence de deux positions appartenant au réseau : pi =
(ma/h)ei .
La distribution f (r, v) devient dans ce cas un ensemble de 9 distributions f i (r), où les r appartiennent
au réseau. La densité du fluide au point r est alors
∑
ρ(r) = m f i (r) (7.16)
i
alors que la vitesse u du fluide est telle que

ma ∑
ρ(r)u(r) = f i (r)ei (7.17)
h i
La version discrète de l’équation de Boltzmann (7.13) est alors
h[ eq.
]
f i (r + ei h, t + h) = f i (r, t ) − f i (r, t ) − f i (r, t ) (7.18)
τ
Le premier terme du membre de droite effectue l’écoulement du fluide, alors que le deuxième terme
représente l’effet des collisions. Nous avons supposé ici qu’aucune force externe f n’est à l’œuvre.
Notons qu’en l’absence de terme de collision, cette équation revient simplement à déplacer rigidement
la distribution f i sur une distance aei lors d’un pas temporel h : encore une fois il n’y a aucun mélange
des vitesses et les différentes distributions sont indépendantes. Le terme de relaxation va modifier ce
comportement en couplant les distributions partielles f i via le calcul de la vitesse du fluide u.
eq.
Nous allons déterminer la forme de la distribution à l’équilibre f i en nous inspirant de la distribution
de Maxwell-Boltzmann (7.14) et en imposant les règles de somme (7.6), qui deviennent dans ce contexte
∑ eq.
ρ(r) = m f i (r)
i
∑ eq.
ρ(r)u(r) = pi f i
i
(7.19)
1∑ eq.
ρ(r)T = (pi − mu)2 f i
2 i
En principe, ces règles de somme devraient s’appliquer pour toute valeur de u. Malheureusement,
le nombre limité de vitesses (neuf), ne nous permet pas d’y arriver : nous ne pourrons respecter ces
contraintes que pour les termes constants, linéaires et quadratiques en u . Autrement dit, il ne sera
possible d’imposer ces contraintes que dans l’approximation des petites vitesses (petits nombres de
Mach). En développant la distribution (7.14) à cet ordre en u , nous obtenons la forme suivante :
{ }
eq. ma m 2 1 ( ma )2
f i = w i ρ(r) 1 + ei · u − u + (ei · u)2 (7.20)
hT 2T 2 hT
où les constantes w i sont considérées comme ajustables. En raison de la symétrie des 9 vecteurs
ei , il est clair que trois seulement de ces constantes sont indépendantes : w 0 , w 1 = w 2 = w 3 = w 4 et
w 5 = w 6 = w 7 = w 8 . L’imposition des trois règles de somme (7.19) à l’ordre u 2 fixe de manière unique
ces constantes. Pour simplifier les choses, il est de coutume de fixer le pas temporel h de manière à ce
que
ma 2
=3 (7.21)
h2T
On démontre alors que
4 1 1
w0 = w 1,2,3,4 = w 5,6,7,8 = (7.22)
9 9 36
108
7.2. Méthode de Boltzmann sur réseau
Problème 7.1
Obtenez explicitement les valeurs (7.22) à partir des conditions (7.19) et de la distribution à l’équilibre (7.20),
en négligeant les termes d’ordre supérieur à u 2 .
.
On montre que ce modèle spécifique nous ramène, dans la limite continue, à l’équation de Navier-
Stokes pour une fluide incompressible :
∂u
∇·u = 0 ρ + ρ(u · ∇)u = −∇P + ρν∇2 u (7.23)
∂t
où la pression P est reliée à la densité par
1
P = c s2 ρ cs = vitesse du son =p (7.24)
3
et le coefficient de viscosité est relié au temps de relaxation par

τ 1
ν = c s2 ( − ) (7.25)
h 2
Conditions aux limites

Comment traiter les conditions aux limites dans le méthode de Boltzmann sur réseau ? Autrement dit,
quel doit être le comportement du fluide au contact d’une surface ? La façon la plus simple et la plus
courante de traiter une paroi, en fait l’une des forces de la méthode, est la condition de rebond (angl.
no slip condition), qui stipule que la particule qui collisionne avec la paroi est rétrodiffusée (ei → −ei ).
En pratique, cela signifie que l’équation (7.18) ne s’applique pas aux sites du réseau situés sur la
paroi. Au contraire, sur une tel site, la distribution f i (r, t + h) est simplement donnée par f j (r, t ), où
e j = −ei . Cette condition de rebond revient à dire que le fluide ne peut pas glisser le long de la paroi :
celle-ci exerce sur le fluide un frottement statique parfait.
Algorithme
Résumons ici l’algorithme de la méthode LBM :
1. On commence par mettre en place une distribution initiale f i (r) associée à des valeurs initiales
de la densité ρ et de la vitesse u (gardons en tête que r est maintenant un indice discret défini
eq.
sur une grille régulière). À cette fin, on initialise f i = f i (u0 ) en fonction d’une vitesse initiale
spécifiée à l’avance u0 (r).
2. À chaque pas temporel, on propage les distributions selon l’équation (7.18) sur les nœuds inté-
rieurs de la grille, et on applique les conditions de rebond sur les frontières.
3. On calcule ensuite les nouvelles densités et vitesses selon les expressions (7.16) et (7.17), ce qui
nous permet de calculer les nouvelles distributions à l’équilibre.
4. On retourne à l’étape 2 jusqu’à ce que le temps de simulation soit écoulé.
7.2.3 Exemple
Au lieu d’illustrer la méthode de Boltzmann sur réseau à l’aide d’un code maison, nous allons utiliser
l’un des codes libres disponibles : openLB. 2 L’un des exemples inclus dans la distribution illustre
le passage d’un fluide en deux dimensions entre deux parois horizontales, entre lesquelles figure un
obstacle cylindrique – donc à section circulaire. En trois dimensions, cette situation correspondrait au
passage d’un fluide dans un conduit cylindrique au milieu duquel un obstacle sphérique a été inséré.
Un instantanné de la simulation est illustré à la figure 7.2. La grandeur |u| de la vitesse d’écoulement
est représentée en fonction de la position par un code de couleur. La partie inférieure de la figure
représente plutôt le tourbillon (angl. vorticity) ∇∧u associé à la vitesse u. Les deux sections de gauche
2. Voir http://www.numhpc.org/openlb/
109
F 7.2
Simulation du passage d’un fluide 2D entre deux parois, avec un obstacle cylindrique, réalisée à l’aide du
logiciel libre openLB. En haut : profil de la grandeur de la vitesse |u| en fonction de la position. Les vitesses
plus grandes sont en rouge, les plus faibles en bleu. L’écoulement s’effectue de la gauche vers la droite, et
l’obstacle est visible au cinquième de la longueur, à partir de la gauche. En bas, profil du tourbillon ∇∧u
associé au même écoulement. Le tourbillon n’a ici qu’une seule composante (en z ) et le code de couleur va
des valeurs négatives (bleues) à positives (rouge) en passant par les valeurs nulles (vert pâle). À gauche :
écoulement à petit nombre de Reynolds (Re=1), à droite, écoulement turbulent (Re=800).
correspondent à un écoulement caractérisé par un petit nombre de Reynolds (Re=1), alors que les
sections de droite correspondent à un écoulement turbulent, caractérisé par Re=800. Le nombre de
Reynolds, en hydrodynamique, est le rapport des forces d’inertie aux forces visqueuses. Sa définition
pratique est la suivante :
uL
Re = (7.26)
ν
où
1. u est la vitesse moyenne du fluide, ou la vitesse d’un objet dans un fluide au repos.
2. L est la longueur caractéristique du système (la distance entre les deux parois dans notre
exemple).
3. ν est le coefficient de viscosité cinématique (le même qui figure dans l’équation de Navier-Stokes
(7.2)).
Cette définition, comme on le voit, n’est pas universelle : elle dépend du problème étudié. Plus le
nombre de Reynolds est petit, plus la viscosité est importante ; plus il est grand, plus la turbulence a
de chances de s’établir.
On remarque que le tourbillon ∇∧u est important autour de l’obstacle dans les deux cas (Re=1 et
Re=800), ce qui reflète l’existence de la couche limite, c’est-à-dire une couche mince autour des parois
où la vitesse varie de zéro sur la paroi à une valeur non nulle dans un espace assez étroit. Le fait que
le tourbillon ∇∧u soit non nul n’entraîne pas nécessairement l’existence d’un écoulement tourbillon-
naire : il faut pour cela déterminer les lignes d’écoulement, ce qui n’est pas visible sur les graphiques
de la figure 7.2. Cependant, l’écoulement illustré sur la partie droite de la figure est clairement tur-
bulent.
110
7.3. Simulation de l’écoulement d’un plasma
7.3 Simulation de l’écoulement d’un plasma
Nous allons dans cette section procéder à une simulation d’un autre genre, qui se rapproche plus de
la dynamique moléculaire : celle de l’écoulement d’un plasma en dimension 1. Cette simulation va
révéler une instabilité qui se manifeste dans l’interaction de deux faisceaux opposés.
Un plasma est un gaz d’électrons en coexistence avec des ions, de sorte que le système est neutre au
total. Par contre, comme les électrons sont beaucoup plus légers que les ions, les temps caractéris-
tiques associés au mouvement des deux composantes du plasma sont très différents. Nous n’allons
étudier ici que le mouvement des électrons, et supposer que le rôle des ions n’est que de neutraliser
le système dans son entier.
7.3.1 Description de la méthode
Considérons donc un ensemble de N électrons de charge e , positions r i et de vitesses v i en dimension

1. Si nous procédions à une simulation de dynamique moléculaire classique, nous devrions calculer,
à chaque instant de la simulation, la force électrique agissant sur chaque particule, ce qui est un
processus de complexité O (N 2 ). Nous allons réduire la complexité du calcul à O (N ) à l’aide de l’astuce
suivante :
1. Les forces seront représentées par un champ électrique E (x), dérivant du potentiel électrique
ϕ(x) et de la densité de charge eρ(x) (ρ(x) étant la densité volumique de particules). Ces diffé-
rents champs seront représentés sur une grille de M points, où M ≪ N .
2. Les positions r i des particules seront utilisées pour calculer la densité ρ .
3. Le potentiel ϕ(x) sera déterminé par la solution de l’équation de Poisson : d2 ϕ/ dx 2 = −eρ(x)/ε0 ,
à l’aide de transformées de Fourier rapides.
4. Le champ électrique E (x) sera dérivé du potentiel électrique : E (x) = − dϕ/ dx .
C’est l’utilisation de transformées de Fourier rapides (TdFR) qui rend cette méthode plus rapide : sa
complexité sera la moindre de O (N ) et de O (M log M ).
Mise à l’échelle du problème

Il est important lors d’une simulation numérique de rapporter les différentes quantités physiques en
fonction de quantités normalisées dont les grandeurs caractéristiques sont typiques au problème. En
définissant un potentiel normalisé Φ tel que
def e ρ̄
ϕ = Φ (7.27)
ε0
où ρ̄ est la densité moyenne d’électrons, l’équation du mouvement de la particule i est
e e 2 ρ̄ ′ def
v̇ i = E (x i ) = − Φ (x i ) = − ω2p Φ′ (x i ) (7.28)
m mε0
où ωp est la fréquence plasma, soit la fréquence à laquelle un plasma uniforme qui serait déplacé
latéralement par rapport à son fond neutralisant se mettrait à osciller. Parallèlement, l’équation de
Poisson devient alors
ρ
Φ′′ = − = −n (7.29)
ρ̄
où n est la densité normalisée d’électrons. Les équations sont donc particulièrement simples si on les
exprime en fonction de n(x) et du potentiel normalisé Φ(x). La fréquence plasma inverse ω−1p servira
ici d’unité naturelle de temps.
Revoyons donc en détail chaque étape de la méthode :
111
1. La densité normalisée n , le potentiel électrique normalisé Φ et le champ électrique normalisé

F = −Φ′ seront définis sur une grille uniforme périodique de M points et de pas a = L/M . La
présence d’un électron à la position r modifie la densité n uniquement sur les points x j et x j +1
situés de part et d’autre de r .
L L
nj → nj + (x j +1 − r ) n j +1 → n j +1 + (r − x j ) x j < r < x j +1 (7.30)
N a2 N a2
2. En fonction des transformées de Fourier Φ̃(q) et ñ(q), l’équation de Poisson prend la forme
suivante :
1
q 2 Φ̃(q) = ñ(q) et donc Φ̃(q) = 2 ñ(q) (7.31)
q
En pratique, on procède à une TdFR de n et on calcule Φ̃ en divisant par q 2 comme ci-dessus

(q ̸= 0). On met également à zéro la composante q = 0 de ñ , ce qui entraîne que la charge
totale est nulle. Cette étape impose la condition de neutralité et est le seul endroit du calcul où
la présence des ions positifs est prise en compte. Enfin, on procède à une TdFR inverse pour
retrouver Φ j = Φ(x j ).
3. Le champ électrique normalisé est l’opposé de la dérivée du potentiel électrique normalisé :
Φ j +1 − Φ j −1
Fj = − (7.32)
2a
4. La méthode de Verlet sera employée pour évoluer dans le temps les positions et les vitesses,
selon les équations suivantes :
h2 fi f i (t ) + f i (t + h)
r i (t + h) = r i (t ) + v i h + v i (t + h) = v i (t )(1 − γh) + (7.33)
2 2
où γ est un amortissement dû à des causes diverses (rayonnement, etc.). La force f i à un instant

donné sera calculée en interpolant le champ électrique défini sur la grille :
ri − x j x j +1 − r i
fi = Fj + F j +1 (7.34)
a a
où x j est le point no j de la grille périodique (il est implicite que j + M → j , c’est-à-dire que j
est défini modulo M ) et F j est la valeur du champ électrique à ce point. On retourne ensuite à
l’étape 1 (calcul mis à jour de la densité), jusqu’à ce que le temps de simulation soit écoulé.
code : plasma.cpp — page 201
Problème 7.2
Décrivez comment on pourrait appliquer la méthode décrite dans cette section à une force inter-particule
générale qui dérive d’un potentiel central U (r ) en dimension 3, de sorte que l’énergie potentielle d’une
particule à la position ri en présence des autres particules est
∑
V (ri ) = U (|ri − r j |) (7.35)
j ̸=i
A Formulez la méthode en fonction des transformées de Fourier Ũ (q) de U (r) = U (r ) et ρ̃ de la densité

volumique des particules ρ(r).
B Quelle condition le potentiel U (r ) doit-il respecter pour que Ũ soit bien défini ? Comment peut-on modifier
U (r ) au besoin, sans conséquences physiques, afin que cette cette condition soit respectée ? Considérez le
. potentiel de Lennard-Jones comme exemple.
112
7.3. Simulation de l’écoulement d’un plasma
8
6 t = 0.1 t=4
4
2
0
v
-2
-4
-6
-8
8
6 t = 12 t = 24
4
2
0
v
-2
-4
-6
-8
0 20 40 60 80 100 0 20 40 60 80 100
x x
F 7.3
Distribution des positions et des vitesses des électrons du plasma dans l’espace des phases, pour 4 valeurs du
temps t . L’instabilité est visible dès t = 4. Les paramètres utilisés sont v 0 = 1, v T = 0.5, h = 0.001, γ = 0, L = 100,
M = 1024 et N = 20 000.
Les conditions initiales seront les suivantes :

1. Une distribution initiale aléatoire des positions r i dans l’intervalle [0, L].
2. Une distribution gaussienne des vitesses v i autour de deux valeurs ±v 0 , ce qui représente
deux faisceaux contraires de particules. L’écart-type de cette distribution des vitesses est v T =
p
T /m , où T est la température absolue. Cette distribution est donc maxwellienne.
Le problème est véritablement unidimensionnel, ce qui signifie qu’on néglige le rayon R du faisceau
et les effets transversaux en comparaison de la longueur L : R ≪ L .
Outre la fréquence plasma ωp , un échelle caractéristique du plasma est la longueur de Debye λD =

v T /ωp , au-delà de laquelle les particules du plasma démontrent un comportement collectif au lieu
d’un comportement strictement individuel.
Le phénomène observé lors de cette simulation est illustré à la figure 7.3 : une instabilité du mouve-
ment apparaît progressivement. Le mouvement uniforme des particules du plasma se transforme en
une combinaison de mouvement uniforme et d’oscillation, menant à une inhomogénéité de la densité.
113
114
8
Équations non linéaires et
optimisation
8.1 Équations non linéaires à une variable
Le problème traité dans cette section consiste à résoudre une équation non linéaire, ce qui revient à
chercher la ou les racines d’une fonction y(x) :
y(x) = 0 (8.1)
La fonction y(x) peut avoir une forme analytique explicite ou être le résultat d’un autre calcul numé-
rique ne correspondant pas à une forme connue.
8.1.1 Cadrage et bissection
Une méthode simple et robuste pour trouver une racine de f consiste premièrement à cadrer la racine,
c’est-à-dire à trouver deux points x 1 et x 2 entre lesquels au moins une racine existe. Cela ne peut se
faire que si on fait l’hypothèse que la fonction est continue, de sorte que si y 1 = y(x 1 ) < 0 et y 2 =
y(x 2 ) > 0, on a l’assurance qu’une racine x ⋆ existe dans l’intervalle [x 1 , x 2 ]. Nous n’expliquerons pas
ici d’algorithme particulier pour trouver les valeurs x 1 et x 2 ; nous supposons plutôt que, selon la
fonction désirée, ces valeurs peuvent se trouver sans trop de difficulté.
La méthode de bissection consiste à diviser l’intervalle de recherche en deux parties égales, et ce de

manière répétée, jusqu’à ce que la largeur de l’intervalle soit comparable à la précision recherchée ϵ
sur la position de la racine. Plus précisément :
1. On calcule y(x̄), où x̄ = (x 1 + x 2 )/2.
2. Si y(x̄) est du même signe que x 1 , alors on met à jour x 1 ← x̄ , sinon on fait x 2 ← x̄ et on recom-
mence à l’étape 1.
3. On arrête la procédure lorsque x 2 − x 1 < ϵ.
La méthode de bissection est sûre, mais inefficace : elle converge linéairement. Par là on veut dire que
def
la différence δn = x̄ − x ⋆ entre la solution véritable et la meilleure estimation de la solution à l’étape
n de la procédure se comporte comme
1
δn+1 ∼ δn (8.2)
2
En général, le degré de convergence η d’une méthode itérative est défini par
η
δn+1 ∼ Aδn (8.3)
où A est une constante ; plus l’exposant η est élevé, plus la convergence est rapide.
115
Chapitre 8. Équations non linéaires et optimisation
8.1.2 Méthode de la fausse position
y(x)
x1 x2 x
F 8.1
Méthode de la fausse position.
Une amélioration sensible par rapport à la méthode de bissection est la méthode de la fausse position,
qui consiste non pas à adopter la moyenne x̄ = (x 1 + x 2 )/2 comme estimation de la racine à chaque
étape, mais plutôt l’intersection avec l’axe des y de l’interpolant linéaire entre les deux points x 1 et
x2 :
x̄ − x 2 x̄ − x 1 x1 y 2 − x2 y 1
y1 + y 2 = 0 =⇒ x̄ = (8.4)
x1 − x2 x2 − x1 y2 − y1
On met ensuite là jour les valeurs de x 1 et x 2 comme dans la méthode de bissection (voir la figure 8.1).
La méthode de la fausse position est robuste, en ce sens que la racine est toujours cadrée et donc on ne
peut pas la rater. Son degré de convergence n’est pas bien défini, mais la méthode converge en général
plus rapidement que la méthode de bissection, cette dernière n’étant plus rapide que dans quelques
cas pathologiques.
Problème 8.1
Illustrez schématiquement une fonction dont la racine serait trouvée plus rapidement par la méthode de
bissections que par la méthode de la fausse position.
.
8.1.3 Méthode de la sécante
La méthode de la sécante est une variation de la méthode de la fausse position, dans laquelle on
procède à une interpolation ou extrapolation linéaire pour trouver une estimation de la position de la
racine, même si cette nouvelle estimation x n+1 est en dehors de l’intervalle formé par les deux points
précédents :
x n−1 y n − x n y n−1
x n+1 = (8.5)
y n − y n−1

À la différence de la méthode de la fausse position, on base chaque nouvelle estimation x n+1 de la
racine sur les deux estimations précédentes (x n et x n−1 ), au lieu de rejeter l’une des deux frontières
de l’intervalle, qui une fois sur deux en moyenne correspond à x n−1 .
116
8.1. Équations non linéaires à une variable
On montre que le degré de convergence de la méthode de la sécante est le nombre d’or :

p
1+ 5
η= = 1.618034 . . . (8.6)
2
Par contre, sa convergence n’est pas garantie car la racine n’est pas systématiquement cadrée.
8.1.4 Méthode de Newton-Raphson
y(x)
x2 x3 x4 x1
x
F 8.2
Méthode de Newton-Raphson pour la recherche des racines.
L’une des méthodes numériques les plus anciennes a été proposée indépendamment par I. Newton et
J. Raphson à la fin du XVIIe siècle pour trouver les racines d’une fonction. Elle se base sur le calcul
différentiel et non sur un cadrage de la racine (voir la figure 8.2) :
1. On choisit une estimation initiale x 1 de la racine.
2. On calcule la valeur de la fonction y 1 = y(x 1 ) et de sa dérivée y 1′ = y ′ (x 1 ).
3. On trace la droite de pente y 1′ passant par (x 1 , y 1 ) et on trouve l’intersection de cette droite avec
l’axe des x . Il s’agit de la prochaine valeur x 2 de l’estimateur :

y1 yn
x2 = x1 − ′ ou, à l’étape n , x n+1 = x n − (8.7)
y1 y n′

4. On répète jusqu’à convergence.

On montre que le degré de convergence de la méthode de Newton-Raphson est η = 2. Cela signifie qu’à
l’approche de la solution, le nombre de chiffres significatifs de l’estimateur double à chaque résolution !
Par contre, la méthode n’est pas robuste : si on la démarre trop loin de la solution, elle peut facilement
diverger ou rester sur un cycle limite. La dynamique discrète définie par l’équation (8.7) peut être
complexe et intéressante en soi.
117
Problème 8.2
Montrez que le degré de convergenve de la méthode de Newton-Raphson est η = 2.

.
8.2 Équations non linéaires à plusieurs variable
La résolution d’un système d’équations non linéaires couplées est un problème pour lequel il n’existe
pas de méthode sûre et générale. Considérons par exemple le cas de deux variables x et y obéissant à
deux équations non linéaires simultanées qu’on peut toujours mettre sous la forme
f (x, y) = 0 g (x, y) = 0 (8.8)
où f et g sont des fonctions qui définissent le problème.
L’équivalent de ces équations en dimension 1 est une équation unique y(x) = 0 ; si cette fonction est
continue et que deux valeurs y(x 1 ) et y(x 2 ), l’une positive et l’autre négative, sont connues, alors une
racine existe certainement. On ne peut affirmer l’existence d’une solution avec autant de généralité
en dimension 2 : chacune des équations (8.8) définit une certaine courbe de niveau (une pour f , l’autre
pour g ). Une solution existe seulement si ces deux courbes de niveaux se croisent. Il est également
possible que l’une ou l’autre des équations (8.8) n’ait pas de solution, c’est-à-dire que la courbe de
niveau associée à la valeur 0 n’existe pas.
Une façon quelque peu brutale de tenter la solution des équations (8.8) est de les traiter comme
une succession de problèmes unidimensionnels : On résoud la première équation en fonction de x
pour une valeur donnée de y , qui est alors traité comme un paramètre. L’un des algorithmes à une
variable décrits ci-dessus est mis à contribution pour cela. On obtient ainsi une fonction x(y), qu’on
injecte ensuite dans la deuxième équation : g (x(y), y) = 0. Cette dernière équation est alors résolue,
encore une fois par un algorithme à une variable. Cette approche a le mérite de la simplicité, mais est
inefficace car elle ne traite pas les deux variables sur un pied d’égalité, et accordera trop de précision
à des valeurs intermédiaires de y .
Nous allons décrire la méthode de Newton-Raphson appliquée à N équations à N variables, qu’on

écrira comme
f(x) = 0 ou f i (x) = 0 i = 1, . . . , N (8.9)
Commençons par un point de départ x0 . Autour de ce point les fonctions f i admettent un développe-
ment de Taylor : ¯
∑ ∂ fi ¯
f i (x) = f i (x0 ) + ¯ δx j + O (δx2 ) def
δx = x − x0 (8.10)
¯
j ∂x j x 0
On note habituellement la matrice des dérivées premières (le jacobien) comme

def ∂ fi
Ji j = (8.11)
∂x j
et donc l’équation non linéaire peut s’écrire, à cet ordre d’approximation, comme
0 = f i (x0 ) + J i j δx j ou J(x0 )δx = −f(x0 ) (8.12)
ce qui constitue un système linéaire simple qu’on résoud dans le but d’obtenir une nouvelle estimation
de la racine cherchée :
δx = −J−1 (x0 )f(x0 ) (8.13)
Répéter cette prodécure revient à poser la relation de récurrence suivante :
xn+1 = xn − J−1 (xn )f(xn ) (8.14)
Cette relation est la généralisation à plusieurs variables de l’équation unidimensionnelle (8.7).
118
8.3. Optimisation d’une fonction
8.2.2 Méthode itérative directe
Il arrive dans plusieurs applications que les équations non linéaires aient la forme suivante :
x = K(x|α) (8.15)
où α désigne un paramètre ou un ensemble de paramètres. Ceci n’est évidemment pas restrictif, car
tout système non linéaire peut être mis sous cette forme. C’est le cas notamment dans l’approximation
du champ moyen en physique statistique ou dans le problème à N corps en mécanique quantique. Les
paramètres α dans ce cas pourraient être la température, ou encore la force d’une interaction entre
particules. Ces équations pourraient bien sûr être traitées par la méthode de Newton-Raphson, avec la
fonction f(x) = K(x|α)−x. Il est cependant fréquent de leur appliquer une méthode de solution beaucoup
plus simple, qui suppose qu’on connaît à l’avance une solution dans un cas limite (par exemple pour
une valeur précise α0 des paramètres). On suppose alors que, si α n’est pas trop différent de α0 , on
peut adopter comme première approximation la solution correspondante x = x0 et appliquer la relation
de récurrence suivante :
xn+1 = K(xn |α) (8.16)
L’application répétée de cette relation, si elle converge, mène effectivement à la solution recherchée.
En pratique, si la solution est requise pour plusieurs valeurs de α, il est avantageux de procéder par
proximité, en mettant sur pied une boucle sur α qui recycle la solution x(α) de l’étape précédente
comme point de départ de la nouvelle recherche pour la valeur suivante de α.
Cette méthode itérative directe est simple, mais converge moins rapidement que la méthode de
Newton-Raphson.
Problème 8.3
Appliquez cette méthode à la solution de l’équation transcendante x = 14 ex , en adoptant comme point de

départ x = 0 (utilisez une calculatrice ou Mathematica). Quel est le degré de convergence de cette méthode ?
.
Problème 8.4
Supposons qu’on veuille appliquer cette méthode à la solution de l’équation x = λx(1−x), en adoptant comme
point de départ x = 0 en en faisant progresser λ de 0 jusqu’à 4. Quel problème rencontrerions-nous ? L’ap-
plication x 7→ λx(1 − x) porte le nom de carte logistique.
.
8.3 Optimisation d’une fonction
Les problèmes d’optimisation sont parmi les plus fréquents rencontrés en calcul scientifique. Dans
plusieurs cas, il s’agit de trouver le minimum d’une fonction différentiable E (x) à N variables. On
peut alors utiliser notre connaissance des dérivées de cette fonction – ou la calculer numériquement
– dans la recherche du minimum. D’autres problèmes, qui seront traités dans la section suivante,
ne peuvent pas être formulés en fonction d’une ou plusieurs variables continues, mais sont plutôt de
nature discrète.
Dans tous les cas, la difficulté principale de l’optimisation est la recherche d’un minimum global, par
opposition à un minimum local. Il n’y a pas de solution générale et certaine à ce problème.
119
Le minimum d’une fonction E (x) doit respecter la condition de dérivée nulle :
∂E
=0 (i = 1, . . . , N ) (8.17)
∂x i
Le problème de minimisation se ramène dans ce cas à celui de la solution de N équations non linéaires
couplées et peut être traité à l’aide de la méthode de Newton-Raphson. Il suffit de poser f = ∇E (voir
section 8.2.1). Il faut cependant remarquer que cette méthode trouvera aussi bien les maximums et
les points d’inflexion que les minimums. Cela n’est pas trop mal en soi, car souvent c’est précisément
ce qu’on cherche : plusieurs problèmes soi-disant de minimisation sont en réalité des problèmes où un
principe physique nous demande de trouver des solutions à dérivée nulle plutôt que des minimums
véritables. Cependant, si ce ne sont que les minimums qui nous intéressent, il faut alors vérifier, par
calcul de la dérivée seconde, que c’est bien ce que nous avons trouvé.
Lorsque la forme des dérivées de la fonction E n’est pas connue explicitement, la méthode peut quand
même être appliquée à condition de procéder à un calcul numérique des dérivées. Comme la méthode
de Newton-Raphson requiert les dérivées premières de f, les dérivées secondes de E doivent être es-
timées numériquement. Ainsi, une fonction de N variables à un point donné comporte 1 valeur, N
dérivées premières et 12 N (N + 1) dérivées secondes, soit au total 1 + N (N + 3)/2 quantités qui doivent
être estimées à chaque itération de la méthode. Le calcul numérique de ces quantité requiert donc un
nombre égal de valeurs de E calculées au point x et dans son voisinage immédiat : il s’agit en pratique
de lisser une forme quadratique sur ces valeurs de la fonction E .
8.3.2 Méthode de Powell
Lorsqu’elle converge, la méthode de Newton-Raphson le fait rapidement. Cependant, elle n’est pas
robuste et la solution trouvée n’est pas nécessairement un minimum. La méthode de Powell, que nous
allons maintenant décrire, corrige ces deux travers, au prix d’un plus grand nombre d’évaluations de
la fonction E .
Approximation quadratique en dimension 1

La méthode de Powell repose sur la capacité de trouver le minimum d’une fonction E (x) dans une
direction donnée de l’espace, c’est-à-dire de résoudre un problème de minimisation à une variable. Si
on désire minimiser une fonction à une variable y(x), la stratégie générale est la suivante :
1. On doit premièrement cadrer le minimum, c’est-à-dire trouver trois points x 1 < x 2 < x 3 tels que
y(x 1 ) > y(x 2 ) et y(x 3 ) > y(x 2 ).
2. Ensuite on lisse une parabole sur ces trois points (la solution est unique). Le minimum x min.
de cette parabole est alors l’estimation suivante du minimum x ⋆ de la fonction.
3. On doit conserver deux autres points, afin d’itérer la procédure. Si x min. < x 2 , alors x 1 et x 2
servent de cadre au minimum, sinon ce sont x 2 et x 3 : on procède aux substitutions suivantes :
 
x 1 ← x 1
 x 1 ← x 2

x min. < x 2 : x 2 ← x min. x min. > x 2 : x 2 ← x min. (8.18)

 

x3 ← x2 x3 ← x3
On calcule ensuite y(x min. ) et on retourne à l’étape 2, et ainsi de suite jusqu’à convergence.
4. On arrête la procédure lorsque x min. ≈ x ⋆ varie par une valeur inférieure à une précision ϵ.
120
8.3. Optimisation d’une fonction
Directions conjuguées
La méthode de Powell proprement dite comporte les étapes suivantes :
1. Choisir un point de départ x0 et une direction de départ e0 .
2. Minimiser E (x0 + λe0 ) en fonction de λ, en utilisant la méthode décrite ci-dessus. On atteint
ainsi un deuxième point x1 .
3. Autour de ce point x1 , on calcule les dérivées secondes, comme dans la méthode de Newton-
Raphson. Ces dérivées secondes nous permettent de construire une approximation quadratique
à la fonction E dans le voisinage du point x1 :
∑ ∂E 1 ∑ ∂2 E
E (x) ≈ E (x1 ) + (x j − x 1 j ) + (x i − x 1i )(x j − x 1 j ) (8.19)
j ∂x j 2 i j ∂x i ∂x j
On traite ensuite la minimisation de cette fonction quadratique comme dans la méthode du

gradient conjugué : on définit une direction conjuguée e1 à la direction qu’on vient de parcourir,
au sens de la matrice hessienne ∂2 E /∂x i ∂x j .
4. On retourne à l’étape 2, cette fois avec la nouvelle direction e1 , et on itère jusqu’à convergence
sur la position (ou sur la valeur de la fonction, ou les deux).
8.3.3 Méthode du simplexe descendant
S’il n’est pas possible d’utiliser l’expression des dérivées de la fonction E , ou si la forme de la fonction
ne laisse pas espérer qu’une méthode basée sur des dérivées puisse avoir du succès, alors on peut
se rabattre sur la méthode du simplexe descendant (angl. downhill simplex), proposée par Nelder et
Mead.
Un simplexe en d dimensions est une figure géométrique de dimension d bornée par d + 1 simplexes
de dimension d − 1. Par exemple :
1. Un simplexe de dimension 0 est un point.
2. Un simplexe de dimension 1 est un segment, borné par deux points.
3. Un simplexe de dimension 2 est un triangle, c’est-à-dire une portion de R2 bornée par trois
segments.
4. Un simplexe de dimension 3 est un tétrahèdre irrégulier, c’est-à-dire une portion de R3 bornée
par 4 triangles, et ainsi de suite.
(A) (C)
(B) (D)
F 8.3
Différentes transformations d’un simplexe en deux dimensions : (A) le simplexe original ; (B) réflexion par
rapport à une face ; (C) élongation d’un sommet par rapport à la face opposée ; (D) contraction du simplexe
vers un sommet.
L’idée générale de la méthode du simplexe descendant est de faire évoluer un simplexe dans l’es-
pace Rd sur lequel est défini la fonction E (x). Cette évolution se fait via différentes transformations
121
du simplexe, notamment des réflexions et des contractions, qui amène progressivement le simplexe
vers la région où la fonction E (x) comporte un minimum local. Certaines de ces transformations sont
illustrées à la figure 8.3. Il y a plusieurs variantes de la méthode du simplexe. L’une d’entre elles est
décrite ci-dessous :
1. Choisir un simplexe de départ, comportant n = d + 1 sommets en dimension d . Les positions

sont notées x1 , . . . , xn .
2. Trier les sommets dans l’ordre croissant de la fonction f à minimiser : f (x1 ) ≤ f (x2 ) ≤ · · · < f (xn ).
3. Calculer le centre de gravité x0 de tous les points sauf xn .
4. Calculer le point réfléchi xr = x0 + α(x0 − xn ). Ici α est le coefficient de réflexion, habituellement
égal à 1. Si f (x1 ) < f (xr ) < f (xn−1 ), alors remplacer xn → xr et retourner à l’étape 2.
5. Si, au contraire, le point réfléchi est le meilleur à date, c’est-à-dire si f (xr ) < f (x1 ), alors calculer
le point étiré xe = x0 + γ(x0 − xn ), où γ est le coefficient d’élongation, habituellement égal à 2.
Si f (xe ) < f (xr ), alors remplacer xn → xe et retourner à l’étape 2. Sinon remplacer xn → xr et
retourner à l’étape 2.
6. Si le point réfléchi n’est pas meilleur que xn−1 (c’est-à-dire si f (xr ) > f (xn−1 ), alors calculer le
point contracté xe = x0 + ρ(x0 − xn ), où ρ est le coefficient de contraction, habituellement 0.5. Si
f (xc ) < f (xn ), alors remplacer xn → xc et retourner à l’étape 2.
7. Sinon, alors contracter le simplexe en remplaçant xi → x1 + σ(xi − x1 ) pour tous les points sauf
le meilleur (x1 ). Ensuite retourner à l’étape 2. Le coefficient σ (deuxième coefficient de contrac-
tion) est typiquement égal à 0.5.
8. Une condition de convergence est requise. Par exemple, la valeur
| f (xn ) − f (x1 )|
r= (8.20)
| f (xn ) + f (x1 )| + ϵ
peut être calculée à l’étape 2 et le programme terminé si cette valeur est inférieure à ϵ, une
précison choisie à l’avance.
8.4 Lissage d’une fonction
8.4.1 Méthode des moindres carrés et maximum de vraisemblance
Supposons que nous disposions d’une modèle pour décrire une certaine quantité y , qui prend la forme
d’une fonction y(x|a), où x représente une variable sur laquelle nous avons le contrôle et a est un
ensemble de paramètres du modèle qu’on cherche à déterminer. On suppose en outre qu’un ensemble
de mesures entachées d’erreurs a produit N observations (x i , y i ), avec une erreur σi sur la valeur de y i
(i = 1, . . . , N ). Le problème décrit dans cette section consiste à estimer les meilleures valeurs possibles
des paramètres a j ( j = 1, . . . , M ) qui découlent de ces observations.
Le principe de base que nous allons suivre consiste à maximiser la vraisemblance, c’est-à-dire à trou-
ver les valeurs a j les plus probables. Pour cela, nous devons définir une probabilité d’observer les y i ,
étant données des valeurs de a , c’est-à-dire étant donné le modèle. Nous allons supposer que cette
probabilité suit une loi gaussienne, c’est-à-dire qu’elle prend la forme suivante :
[ ( ) ]
∏
N 1 y i − y(x i |a) 2
P (observations|a) = exp − ∆y (8.21)
i =1 2 σi
où σi = σ(x i ) est un écart-type qui dépend de x et qui est lié au processus de mesure lui-même ;
∆y est un intervalle conventionnel de y nécessaire ici parce que nous avons affaire à une densité
de probabilité (cet intervalle doit être petit en comparaison de σi ). L’emploi d’une loi gaussienne
se justifie en supposant que le processus de mesure est perturbé par une suite d’événements non
corrélés et de variances identiques, dont la résultante, en vertu de la loi des grands nombres, suit
une distribution gaussienne.
122
8.4. Lissage d’une fonction
La probabilité (8.21) est une probabilité conditionnelle, c’est-à-dire qu’elle exprime la probabilité d’un
événement A (les observations) étant donné la certitude sur l’événement B (le modèle). Or ce qui nous
intéresse ici est l’inverse : quelle est la probabilité du modèle B étant donnée une certitude sur les
observations A : P (B |A). Ces deux probabilités sont reliées par le théorème de Bayes :
P (B |A)P (A)
P (A ∩ B ) = P (A|B )P (B ) = P (B |A)P (A) ou encore P (A|B ) = (8.22)
P (B )
Autrement dit : la probabilité que A et B se produisent est la probabilité de A étant donné B , fois
la probabilité de B . Ceci est manifestement identique à la probabilité de B étant donné A , fois la
probabilité de A . Ce théorème est donc extrêmement simple, en dépit des apparences.
Donc, appliqué à notre problème, ce théorème stipule que :
P (a|observations) = P (observations|a)P (a)/P (observations) (8.23)
Nous allons supposer ici que la probabilité absolue du modèle est indépendante de a , c’est-à-dire que
toutes les valeurs de a sont a priori équiprobables, en l’absence d’observation. Donc seul le premier
facteur du membre de droite dépend de a . Nous devons chercher les valeurs de a j qui maximisent
cette probabilité, ou qui minimisent l’opposé de son logarithme, ce qui veut dire minimiser l’expression
suivante :
( )
2
∑ y i − y(x i |a) 2
χ = (8.24)
i σi

En conclusion : la méthode du maximum de vraisemblance, alliée à quelques hypothèses générales,
nous dicte la manière d’inférer les paramètres a j : il faut minimiser la somme des écarts au carré
entre les observations et le modèle, somme pondérée par l’erreur σ. Ceci est accompli en annulant les
dérivées premières par rapport à a j , c’est-à-dire en solutionnant les M équations suivantes :
∑ y i − y(x i |a) ∂y(x i |a)

=0 ( j = 1, . . . , M ) (8.25)
i σ2i ∂a j
8.4.2 Combinaisons linéaires de fonctions de lissage
Les équations (8.25) sont en général difficiles à résoudre, car la fonction (8.24) est en général non
linéaire en fonction des paramètres a j . Par contre, le cas linéaire est assez fréquent et simple : le
modèle est une superpositions de fonctions Y j (x), dont les coefficients sont les paramètres a j :
∑
y(x) = a j Y j (x) (8.26)
j
Les équations (8.25) deviennent alors

( )
∑ 1 ∑
y i − a k Yk (x i ) Y j (x i ) = 0 ( j = 1, . . . , M ) (8.27)
i σi
2
k
ce qui peut également s’écrire sous la forme concise suivante :

∑ ∑ 1 ∑ yi
α j k ak = β j où αjk = Y j (x i )Yk (x i ) et β j = Y j (x i ) (8.28)
i σi σ2i
2
k i
L’équation de gauche est un système linéaire qui se résoud par les méthodes matricielles usuelles. On
l’appelle le système des équations normales pour le problème du lissage de la fonction y(x|a). 1
Si on définit la matrice N × M
Y j (x i )
Ai j = (8.29)
σi
1. La solution du système linéaire peut être délicate, cependant, car le problème est souvent proche d’un système singulier
et une méthode du genre SVD (décomposition en valeurs singulières) est recommandée. Voir Numerical Recipes à cet effet.
123
et le vecteur colonne à N composantes b i = y i /σi , alors les quantités α et β s’expriment comme suit :
α = Ae A e
β = Ab (8.30)
La matrice inverse C = α−1 est appelée matrice de covariance et donne accès aux incertitudes sur les
valeurs des paramètres inférés a j . En effet, ces paramètres sont
∑ ∑∑ y i Yk (x i )
aj = C j k βk = C jk (8.31)
k k i σ2i
or la variance σ2 (a j ) se trouve par la propagation normale des erreurs de la variable y i vers la variable
a j (notons que la matrice α est indépendante des y i ) :
( )2
∑ ∂a j
σ2 (a j ) = σ2i
i ∂y i
( )2
∑ ∑ C j k Yk (x i )
= σ2i
i k σ2i
∑∑ 1 (8.32)
= C j k C j l Yk (x i )Yl (x i )
l ,k i σ2i
∑
= C j k C j l αkl
l ,k
∑
= δjl C jl = C j j
l
Nous avons utilisé la relation α−1 = C dans la dernière équation. En somme, l’élément diagonal no
j de la matrice de covariance est la variance associée au paramètre a j , suite à la propagation des
erreurs σ j .
Qu’arrive-t-il si on ne connaît pas les erreurs σi ? Dans ce cas on peut formellement prétendre que
toutes les erreurs σi sont égales à une constante σ. Les valeurs des paramètres tirées de l’équation
(8.31) seront alors manifestement indépendantes de σ : la matrice α comporte un facteur 1/σ2 et la
matrice C comporte donc le facteur inverse, qui annule le 1/σ2 apparaissant dans l’équation.
8.4.3 Lissages non linéaires
Si la fonction à lisser comporte un ou plusieurs paramètres qui apparaissent de manière non linéaire,
le problème est plus difficile, et doit être traité par une méthode de minimisation du χ2 comme celles
décrites plus haut, comme par exemple la méthode de Newton-Raphson. Cependant il est fréquent
dans ce contexte d’utiliser la méthode de Levenberg-Marquardt, que nous expliquons sommairement
dans ce qui suit. Cette méthode requiert la connaissance des premières et deuxièmes dérivées de
la fonction à minimiser (le χ2 de l’éq. (8.24)). Proche du minimum de la fonction χ2 , on peut faire
l’approximation quadratique et écrire
1
χ2 (a) = cte − dea + aD
e a (8.33)
2
où D est la matrice hessienne de χ2 (la matrice des deuxièmes dérivées). Dans cette approximation,
la solution est immédiate :
( )
a → a + D −1 −∇χ2 (a) (8.34)
Par contre, cette approche n’est bonne que si on n’est pas trop loin de la solution. Si on est plus éloigné,
alors il est plus efficace de faire le pas suivant, le long du gradient de la fonction :
a → a − γ∇χ2 (a) (8.35)
124
8.5. La méthode du recuit simulé
où la constante γ est suffisamment petite. Ceci équivaut à adopter un hessien diagonal. La méthode
de Levenberg-Marquardt combine ces deux approches, en utilisant la deuxième initialement, et en se
rapprochant de la première au fur et à mesure qu’on approche de la solution : on définit la matrice
1 ∂2 χ2 1 ∂χ2
αi j = ainsi que βk = − (8.36)
2 ∂a i ∂a j 2 ∂a k
On définit ensuite un matrice modifiée
α′i j = αi j + λδi j (8.37)
où λ est une constante qui est initialement petite (λ ∼ 0.001). La méthode consiste alors à solutionner
le système linéaire
α′ δa = β =⇒ δa = (α′ )−1 β (8.38)
à répétition, en suivant la prescription suivante :
1. Choisir une valeur initiale a des paramètres et calculer χ2 (a).
2. Choisir une petite valeur de λ (ex. 0.001) et calculer α′ .
3. Calculer δa selon l’éq. (8.38). Sortir de la boucle si δa est suffisamment petit.
4. Si χ2 (a+δa) ≥ χ2 (a), augmenter λ d’un facteur important (ex. 10) et retourner à l’étape 3. Sinon,
diminuer λ par un facteur important (ex. 10), mettre à jour a → a + δa et retourner à l’étape 3.
La méthode de Levenberg-Marquardt est utilisée par la plupart des programmes de lissage, incluant
par la commande fit de gnuplot. Dans ce cas aussi, les éléments diagonaux de la matrice de cova-
riance C = α−1 sont les variances des paramètres obtenus, compte tenu des erreurs σi .
8.5 La méthode du recuit simulé
Une grande partie des problèmes d’optimisation vise à minimiser une fonction E (x) définie sur un
espace Ω de configurations discret, sur lequel la notion de continuité n’existe pas. Le problème le
plus connu de ce genre est celui du commis-voyageur : un voyageur de commerce doit visiter N villes
dont les positions sont connues, tout en minimisant le chemin parcouru au total. On peut supposer
pour simplifier l’argument qu’il peut parcourir la distance entre chaque paire de villes selon une
ligne droite, mais cela n’est pas essentiel à la formulation du problème. Le voyageur doit donc choisir
un itinéraire, qui prend la forme d’une permutation p i de la liste des villes (i = 1, . . . , N ), qu’il devra
parcourir dans cet ordre, en commençant et en terminant par la même ville (la trajectoire est fermée).
La figure 8.4 illustre un exemple de chemin minimal reliant N = 36 points.
Ce problème ne peut pas être résolu par les méthode classiques d’optimisation, car la variable sur
laquelle nous devons minimiser est une permutation p , et non une variable continue. D’un autre
côté, la simple énumération de toutes les possibilités est hors de question, car le nombre d’itinéraires
possibles est N !, un nombre qui défie l’imagination même pour une valeur modérée de N , comme 36. 2
La méthode de choix pour résoudre ce type de problème est l’algorithme du recuit simulé (angl. si-
mulated annealing). 3 L’idée générale est d’explorer différentes configurations par l’algorithme de
Métropolis, et de diminuer progressivement la température T jusqu’à un minimum proche de zéro.
Autrement dit, on procède à une marche aléatoire dans l’espace des configurations Ω. Cette marche
favorise les configurations de basse «énergie» E , mais permet tout de même de passer pendant un cer-
tain temps à des configurations d’énergie plus grande, quand la température est suffisamment élevée.
Cet aspect est crucial, car il permet de surmonter les barrières de potentiel qui entourent souvent les
minimums locaux (l’adjectif «local» doit être correctement interprété dans le contexte d’un espace Ω
où la notion de distance n’est pas définie de manière évidente).
La méthode du recuit simulé requiert donc les ingrédients suivants :

2. 36! = 371 993 326 789 901 217 467 999 448 150 835 200 000 000 ∼ 3.1041 .
3. En métallurgie, le recuit est un procédé par lequel un alliage est porté à haute température et ensuite refroidi lentement,
ce qui permet aux défauts cristallins de se propager et d’être évacués, par opposition à la trempe, qui est un refroidissement
soudain du matériau, qui gèle sur place les différents défauts cristallins et augmente la dureté de l’alliage.
125
j +1
i i −1
F 8.4
Le problème du commis-voyageur : comment relier N points (ou «villes») par un chemin qui passe au moins une
fois par chaque ville et minimise la distance totale parcourue. La portion pointillée illustre un changement
local qu’il est possible d’apporter à l’itinéraire dans le recherche d’un minimum de la distance totale.
1. Une définition claire de ce que constitue une configuration. Dans le cas du problème du commis-
voyageur, une configuration est une permutation p de la liste des villes à visiter.
2. Une fonction de type «énergie» E (p), qu’on désire minimiser. Dans le problème du voyageur,
c’est la longueur de l’itinéaire :
N∑
−1
E (p) = d (p i , p i +1 ) (8.39)
i =0
où d ( j , k) est la distance entre les villes j et k , et p i est l’indice no i de la permutation p . Il est

sous-entendu que les indices sont traités de manière périodique, c’est-à-dire modulo N (l’indice
N + i étant considéré synonyme de i ).
3. Une procédure de changement local, l’équivalent du renversement local du spin dans le modèle
d’Ising. Dans le problème du voyageur, une procédure possible est de sélectionner un indice i
au hasard, ainsi qu’un deuxième indice j également au hasard, mais suivant une distribution
exponentielle en fonction de la séparation | j − i |, de sorte que les paires (i , j ) d’indices proches
sont plus probables que les paires éloignées. Ensuite, on sectionne le chemin entre les indices
i − 1 et i , et entre les indices j et j + 1 et on recolle la portion du chemin comprise entre i et
j dans l’autre sens, c’est-à-dire de i − 1 à j , ensuite j − 1, etc. jusqu’à i et ensuite j + 1. Cette
procédure est illustrée par les traits pointillés sur la figure 8.4.
4. Un mode de refroidissement, c’est-à-dire une séquence de températures décroissantes, entre-
coupées d’une série de changements locaux à chaque température. Le mode choisi dans le code
décrit ci-dessous est caractérisé par une température initiale T1 , une température finale T2 ,
un facteur 1 − ϵ par lequel la température est multipliée à chaque étape, et un nombre m de
mises-à-jour de la configuration effectué à chaque valeur de T .
Au total, un code de recuit simulé ressemble beaucoup, mais en plus simple, à un code de simulation de
physique statistique dans l’ensemble canonique. Il n’y a pas lieu, cependant, de procéder à une analyse
d’erreur, car c’est l’état fondamental du système qui nous intéresse et non une moyenne statistique.
Ceci dit, il n’y a aucune garantie que l’algorithme va converger vers le minimum absolu et non vers
un minimum local. Il est cependant très peu probable que ce minimum local soit mauvais, au sens
que son «énergie» E soit élevée. Donc, même si le minimum absolu n’est pas garanti, l’algorithme
est tout de même extrêmement utile car le résultat qu’il produit est toujours intéressant d’un point
de vue pratique. Dans tous les cas, l’algorithme est rapide, mais demande une certaine exploration
126
8.5. La méthode du recuit simulé
des paramètres afin d’optimiser sa convergence vers un minimum de qualité ; plusieurs simulations
répétées (avec des configurations initiales aléatoires différentes) sont à conseiller, afin de valider le
point d’arrivée.
T0
f (x)
Ti
TN
x
F 8.5
Application de la méthode du recuit simulé à la minimisation d’une fonction à une variable f (x) possédant
plusieurs minimums locaux. En rouge : probabilité e− f (x)/T d’une configuration x à la température finale T N .
Application à une fonction ordinaire

Rien n’empêche d’utiliser la méthode du recuit simulé lors de la minimisation d’une fonction définie
sur les réels. Dans ce cas, la mise à jour de la configuration consiste simplement en un déplacement
δx dans une direction aléatoire dont la grandeur est, par exemple, distribuée uniformément dans un
certain invervalle. Le mérite de la méthode dans ce cas est sa capacité à trouver souvent le minimum
global de la fonction et non un minimum local. Voir la figure 8.5 pour un exemple unidimensionnel :
la température initiale T0 est suffisamment élevée pour permettre une exploration de l’espace dans
un domaine large où plusieurs minimums relatifs existent. À mesure que la température diminue,
la distribution de probabilité régissant l’algorithme de Metropolis devient de plus en plus concentrée
autour du minimum global, de sorte que ce minimum est celui qui est atteint le plus souvent à la fin
de la simulation.
code : recuit.cpp — page 204
127
128
Annexe A
Opérations matricielles
L’algèbre linéaire est au cœur des méthodes numériques en science, même dans l’étude des phéno-
mènes non linéaires. Si on pouvait recenser les cycles de calcul sur tous les ordinateurs de la planète,
il est probable qu’une fraction proche de l’unité serait dédiée à des calculs impliquant des matrices.
Il est donc important de survoler les méthodes utilisées pour procéder aux deux opérations les plus
importantes de l’algèbre linéaire : la résolution des systèmes d’équations linéaires, et le calcul des
valeurs et vecteurs propres.
A.1 Systèmes d’équations linéaires
A.1.1 Système général et types de matrices
Le problème de base de l’algèbre linéaire est la solution d’un système d’équations linéaires :
    
a 11 ··· a 1n x1 b1
 . .. ..   .   . 
 .    
 . . .   ..  =  ..  ou encore Ax = b (A.1)
a n1 ··· a nn xn bn
Nous avons supposé que le nombre d’inconnues est égal au nombre d’équations, et donc que la matrice
est carrée. Si ce n’est pas le cas, le système est soit sur déterminé (aucune solution exacte n’existe),
ou sous-déterminé (certaines variables doivent être déterminées autrement).
La méthode indiquée pour résoudre un tel système dépend de la configuration de la matrice A . Par
exemple, on distingue les types suivantes :
matrice pleine La matrice ne comporte aucune catégorie d’éléments ou disposition particulière :
ses éléments sont en général non nuls.
matrice triangulaire supérieure Les éléments situés au dessous de la diagonale sont nuls.
matrice triangulaire inférieure Les éléments situés au dessus de la diagonale sont nuls.
matrice tridiagonale Les éléments non nuls sont situés sur la diagonale et sur les deux diagonales
voisines (la matrice possède donc trois diagonales).
matrice de bande Les éléments non nuls sont situés sur la diagonale ainsi que sur ℓ−1 diagonales
de chaque côté de la diagonale. On dit alors que la matrice de bande est de demi-largeur ℓ.
matrice creuse La vaste majorité des élments sont nuls, mais les éléments non nuls sont dispersés
un peu partout. Une telle matrice doit être stockée de manière à que seuls les éléments non
nuls soient repérés (plusieurs schémas de stockage sont possibles).
129
Annexe A. Opérations matricielles
Système triangulaire
Le système (A.1) est très simple à résoudre si la matrice A est triangulaire. Par exemple, si elle est
triangulaire supérieure, le système se résoud trivialement à partir du bas, par rétro-substitution (ou
substitution vers l’arrière) :
bn
xn =
a nn
1 ( )
x n−1 = b n−1 − a n−1,n x n
a n−1,n−1 (A.2)
1 ( )
x n−2 = b n−2 − a n−2,n−1 x n−1 − a n−2,n x n
a n−2,n−2
etc . . .
La solution n’existe manifestement que si tous les éléments diagonaux a i i sont non nuls.
Si la matrice est triangulaire inférieure, la solution est également simple, par substitution vers l’avant
(c’est-à-dire en commençant par x 1 ), comme on le voit aisément.
A.1.2 Élimination gaussienne
Supposons maintenant que nous ayons affaire à une matrice pleine. L’algorithme de base pour ré-
soudre le système (A.1) est l’élimination gaussienne. Il consiste à soustraire de chaque équation (ran-
gée i ) une combinaison des équations précédentes (rangées < i ) de manière à ramener le système à
une forme triangulaire supérieure. Une fois ceci accompli, la solution est immédiate, comme montré
ci-dessus.
Illustrons l’algorithme d’élimination gaussienne à l’aide d’un exemple. Considérons le système sui-
vant :     
4 8 12 x 1 4
    
3 8 13 x 2  =  5  (A.3)
2 9 18 x 3 11
La première étape consiste à diviser la première rangée du système par 4 afin de ramener la première
valeur diagonale à l’unité :
    
1 2 3 x1 1
    
3 8 13 x 2  =  5  (A.4)
2 9 18 x3 11
Ensuite, on soustrait les multiples appropriés de la première rangée des autres rangées, afin d’annuler
le reste de la première colonne :
    
1 2 3 x1 1
    
=
0 2 4  x 2  2 (A.5)
0 5 12 x3 9
Ensuite, on recommence avec le deuxième élément de la diagonale : on divise par 2 cette fois et il reste
  
 
1 2 3 x1 1
    
0 1 2   x 2  =  1 (A.6)
0 5 12 x3 9
On soustrait de la dernière équation 5 fois la seconde, pour trouver enfin une forme triangulaire
supérieure :
  
 
1 2 3 x1 1
    
0 1 2   x 2  =  1 (A.7)
0 0 2 x3 4
130
A.1. Systèmes d’équations linéaires
Ce système se résoud alors comme expliqué plus haut. Dans ce cas-ci la solution est (x 1 , x 2 , x 3 ) =
(2, −3, 1).
On montre que le nombre d’opérations arithmétiques nécessaires à cet algorithme est
n3 n2 n
+ + (A.8)
3 2 6
ce qui se comporte comme 31 n 3 quand n est grand. Autrement dit, inverser un système 2 fois plus
grand prend 8 fois plus de temps.
Pivotage
L’algorithme de Gauss simple illustré ci-dessus ne fonctionne que si les éléments diagonaux sont
non nuls à chaque étape. Si ce n’est pas le cas, on doit avoir recours au pivotage, c’est-à-dire à une
permutation des rangées de manière à repousser au bas de la matrice la rangée qui pose problème.
Ceci produira toujours une solution, en autant que la matrice est non singulière.
A.1.3 Décomposition LU
La décomposition LU est la représentation d’une matrice A comme produit d’une matrice triangulaire
inférieure L par une matrice triangulaire supérieure U :
    
a 11 a 12 ··· a 1n 1 0 ··· 0 u 11 u 12 ··· u 1n
    
 a 21 a 22 ··· a 2n   ··· 0  0 ··· u 2n 
   l 21 1  u 22 
A = LU ou  . .. .. ..  = . .. .. ..   . .. .. ..  (A.9)
 .. . . .   . . .  . . . 
   . .  . . 
a n1 a n2 ··· a nn l n1 l n2 ··· 1 0 0 ··· u nn
On peut supposer que les éléments diagonaux de la matrice L sont l’unité.
La décomposition LU s’effectue d’une manière analogue à l’élimination de Gauss, par l’algorithme de

Crout, que nous n’expliquerons pas ici (voir les références standards, comme [PTVF07]). Notons ce-
pendant que cet algorithme a en général recours au pivotage des rangées, et qu’il est toujours stable
numériquement (en supposant bien sûr que la matrice A est non singulière). La complexité algorith-
mique de la décomposition LU est la même que celle de la multiplication de deux matrices, soit O (n 3 ).
Une fois la décomposition effectuée, la solution du système linéaire (A.1) s’effectue en deux étapes :
on solutionne premièrement le système triangulaire Ly = b pour y (par substitution vers l’avant), et
ensuite le système triangulaire Ux = y (par substitution vers l’arrière). De plus, la décomposition a
de multiples avantages collatéraux :
1. Une fois effectuée pour une matrice A , elle permet de résoudre le système avec plusieurs vec-
teurs b différents, même si les vecteurs b ne sont pas connus au moment d’effectuer la décom-
position.
2. Elle permet de calculer simplement l’inverse de la matrice, l’inverse d’une matrice se calcule
en solutionnant le système avec n vecteurs b tels que b i = δi j ( j = 1, 2, . . . , n ).
3. Elle permet de calculer facilement le déterminant de A , comme le produit des éléments diago-
naux de la matrice U .
131
A.1.4 Système tridiagonal
Supposons maintenant que la matrice A est tridiagonale. La résolution du système (A.1) ou la décom-
position LU est alors beaucoup simplifiée, et s’effectue par une algorithme de complexité O (n). Nous
n’irons pas dans les détails ici, mais nous contenterons d’insister sur le fait qu’utiliser une routine
standard conçue pour une matrice pleine sur une matrice tridiagonale est extrêmement inefficace
(temps de calcul n 3 au lieu de n ).
Il existe aussi des routines spéciales pour la solution de systèmes de bandes qui sont avantageux si
la largeur de bande ℓ est beaucoup plus petite que l’ordre de la matrice.
A.1.5 Matrices creuses et méthode du gradient conjugué
Supposons maintenant que le système (A.1) est très grand (par exemple n = 105 ) et que la matrice A
est creuse, de sorte qu’il est hors de question d’utiliser l’élimination gaussienne de complexité O (n 3 ),
d’autant plus que la matrice ne peut pas être stockée comme une matrice pleine. En général, un tel
problème ne pourra être résolu. Cependant, si la matrice A est définie positive, c’est-à-dire si le produit
xe Ax est positif pour tout vecteur x , on peut utiliser la méthode du gradient conjugué, qui ne demande
accès qu’à une procédure permettant de multiplier la matrice A par un vecteur quelconque. On sait
généralement a priori, selon la nature du problème étudié, si la matrice A est définie positive ou non.
Stockage d’une matrice creuse

Notons premièrement que si la matrice est creuse, une façon simple de la garder en mémoire est de
n’emmagasiner que les éléments non nuls et leurs positions. Une structure particulièrement simple
consiste en trois tableaux définis comme suit :
1. Un tableau v[N] qui stocke les valeurs des N éléments de matrices non nuls, dans un ordre
quelconque, typiquement l’ordre dans lequel les éléments de matrice sont produits ou calculés.
2. Un tableau I[N] qui stocke les indices de rangée des éléments de matrice contenus dans le
tableau v[N].
3. Un tableau J[N], qui stocke les indices de colonne des éléments de matrice contenus dans le
tableau v[N].
Une routine qui ajoute au vecteur y[] le produit de la matrice A par un autre vecteur x[] contiendrait
la boucle suivante :
1 for(int i=0; i<N ; i++) y[I[i]] += v[i]*x[J[i]];

.
Si on est en mesure de trier les éléments de matrice de A et qu’on sait que chaque rangée compte
en moyenne plus d’un élément non nul, une façon plus économique de stocker la matrice consiste à
modifier le sens d’un des trois tableau, comme suit :
1. Le tableau v[N] stocke les valeurs des N éléments de matrices non nuls, en progressant de
gauche à droite, en ensuite de haut en bas.
2. Le tableau J[N] stocke les indices de colonne des éléments du tableau v[N].
3. On définit ensuite un tableau I[n] (n est la dimension de la matrice), qui stocke les indices
des deux tableaux précédents où une nouvelle rangée commence. Ainsi, I[i] est l’indice du
premier élément de v[] ou de J[] appartenant à la rangée i.
Une routine qui ajoute au vecteur y[] le produit de la matrice A par un autre vecteur x[] contiendrait
cette fois la boucle suivante :
1 for(int i=0; i<n ; i++){

. 2 for(int j=I[i]; j<I[i+1]; j++) y[i] += v[j]*x[J[j]];
132
A.1. Systèmes d’équations linéaires
3 }
.
Directions conjuguées
On dit que deux vecteurs u et v sont conjugués selon A si ue Av = 0. En fait, comme A est défini positif,
on peut définir un produit scalaire 〈u|v〉 A ainsi :
def
〈u|v〉 A = ue Av (A.10)
La conjugaison par rapport à A signifie simplement l’orthogonalité par rapport à ce produit. On peut
donc supposer qu’il existe une base de vecteurs p k (k = 1, . . . , n ) qui sont tous mutuellement conjugués.
La solution recherchée x ⋆ à l’équation Ax = b peut donc en principe s’exprimer sur cette base :
∑
n
x⋆ = αk p k (A.11)
k=1
et les coefficients αk de ce développement se trouvent par projection :

〈p k |x ⋆ 〉 A pek Ax ⋆ pek b
αk = = = (A.12)
〈p k |p k 〉 A pek Ap k pek Ap k
L’utilité des vecteurs conjugués vient précisément de la possibilité de remplacer Ax ⋆ par b dans l’équa-
tion ci-dessus. La stratégie de la méthode sera donc de trouver une séquence de m vecteurs p k qui
nous rapproche le plus possible de la solution x ⋆ , tout en maintenant m ≪ n .
Algorithme du gradient
Commençons par formuler le problème linéaire en tant que problème de minimisation. Étant donné
le système (A.1), on forme la fonction à n variables suivante :
1 e
f (x) = xe Ax − bx (A.13)
2
La solution recherchée est précisément le point x ⋆ qui minimise la fonction f , car la condition de
dérivée nulle donne précisément
∇ f = Ax − b = 0 (A.14)
Afin de converger vers la solution x ⋆ à partir d’un point initial x 0 = 0, une méthode simple consiste à
trouver la position x 1 du minimum de f dans la direction du gradient ∇ f à x 0 . Ensuite, on calcule de
nouveau le gradient r 1 = ∇ f |x1 au point x 1 et on trouve la position x 2 du minimum dans cette nouvelle
direction, et ainsi de suite jusqu’à convergence.
À l’étape k , le gradient au point x k est simplement r k = Ax k −b . On doit ensuite minimiser la fonction

f (x k + αr k ) en fonction du paramètre α, ce qui mène à la condition
[ ]
∂ ∂ 1
0= f (x k + αr k ) = x k + αe
(e r k )A(x k + αr k ) − (e
x k + αe
r k )b
∂α ∂α 2 (A.15)
= αer k Ar k + rek Ax k − rek b = αer k Ar k + rek r k
et donc à la solution
rek r k rek r k
α=− et donc x k+1 = x k − rk (A.16)
rek Ar k rek Ar k
Notons que le signe de r k n’est pas important, puisque seule la direction compte. Il suffit donc, pour
appliquer cette méthode, de construire de manière récurrente les vecteurs suivants :
rek r k
r k = Ax k − b x k+1 = x k − rk (A.17)
rek Ar k
avec la condition initiale x 0 = 0.
Cette méthode itérative est appelée l’algorithme du gradient (angl. steepest descent method). Typique-
ment, même en dimension 2, cette méthode requiert un nombre infini d’itération avant de converger
(voir la figure A.1). Ce n’est donc pas la route à suivre.
133
x?
x1
x0
F A.1
Comparaison entre l’algorithme du gradient (en vert) et la méthode du gradient conjugué (en rouge) dans le
cas n = 2. Les courbes de niveau de la fonction f sont indiquées en gris. La première nécessite une infinité
d’étapes avant de converger, alors que la seconde converge en deux étapes.
Minimisation le long de directions conjuguées

En fait, la direction r k du gradient à un point donné n’est pas conjuguée aux directions précédentes.
Pour que l’algorithme converge rapidement, les directions successives doivent être conjuguées selon A ,
ce qui permet d’épuiser systématiquement, sans répétition, les directions disponibles. L’algorithme du
gradient conjugué construit plutôt des directions p k qui sont les plus proches possibles des gradients
r k , mais mutuellement conjuguées, ce qui se calcule par récurrence comme suit :
r k = Ax k − b
∑ ei Ar k
k p
p k+1 = r k − pi
e
i =1 i Ap i
p (A.18)
pek+1 b
x k+1 = x k + p k+1
pek+1 Ap k+1
La première équation est simplement la direction du gradient au point x k . La deuxième décrit une
direction p k+1 obtenue de r k en soustrayant les composantes de r k qui sont parallèles aux directions
p i antérieures (au sens du produit 〈 | 〉 A défini plus haut). Enfin, la nouvelle position x k+1 corres-
pond au minimum de la fonction f le long de cette nouvelle direction, et coincide avec l’expression
(A.12) pour les approximants successifs de x ⋆ . L’algorithme est interrompu lorsque le résidu r k est
suffisamment petit. La méthode du gradient conjugué converge vers la solution exacte en au plus
n itérations. En particulier, la solution en deux dimensions (voir figure A.1) est atteinte après deux
itérations seulement.
Le mérite principal de la méthode du gradient conjugué est qu’elle permet de résoudre un système
linéaire d’ordre n en m étapes, où m ≪ n , avec un nombre d’opérations de l’ordre O (nm 2 ) ∼ O (n log n).
Bien sûr, si on choisissait les directions p k au hasard, le nombre d’itérations nécessaires pour conver-
ger serait de l’ordre de n et le gain serait nul. C’est le choix judicieux des directions p k en rapport
avec le gradient de f qui permet cette convergence accélérée.
Remarquons en outre que la méthode est la même si la matrice A est définie négative au lieu d’être
définie positive. Il suffit pour cela de changer à la fois le signe de A et celui de b . La nouvelle matrice A
est alors définie positive, mais la solution (A.18) est la même, comme on le constate immédiatement
(c’est-à-dire que changer simultanément les signes de A et b n’y change rien).
code : SparseMatrix.h — page 162
134
A.2. Valeurs et vecteurs propres
A.2 Valeurs et vecteurs propres
A.2.1 Généralités
L’un des problèmes les plus fréquents de l’algèbre linéaire est la recherche des valeurs propres et
vecteurs propres d’une matrice. En physique, ce problème surgit dans plusieurs contextes, le plus
souvent dans la détermination des modes d’oscillations en mécanique, en électromagnétisme ou en
mécanique quantique. Le calcul des niveaux d’énergie d’un système décrit par la mécanique quantique
(atome, molécule, structure de bandes d’un solide, etc.) entre dans cette dernière catégorie.
L’équation aux valeurs propres d’une matrice carrée A est
Ax = λx (A.19)
Étant donné A , le problème est de trouver les valeurs λ pour lesquelles cette équation a une solution
non nulle. Le vecteur propre x correspondant définit en fait un sous-espace propre et peut être multi-
plié par une constante quelconque. La dimension du sous-espace propre est le degré de dégénérescence
de la valeur propre λ.
Si une matrice d’ordre n possède n vecteurs propres linéairement indépendants, on dit qu’elle est
diagonalisable. Cela signifie qu’on peut construire une base de vecteurs propres de A , et que par
conséquent la matrice A est diagonale dans cette base. Spécifiquement, si les n vecteurs propres sont
normalisés et forment les colonnes d’une matrice U , alors
AU = U D =⇒ U −1 AU = D (A.20)
où D est une matrice diagonale dont les éléments sont les valeurs propres de A (dans le même ordre
que les vecteurs propres correspondants).
On montre qu’une condition suffisante pour que les vecteurs propres d’une matrice soient orthogonaux
et qu’ils forment une base complète de dimension n est que la matrice A soit normale, c’est-à-dire
qu’elle commutte avec son conjugué hermitique :
A A† = A† A (matrice normale) (A.21)
Dans ce cas, les vecteurs propres étant orthogonaux, la matrice U est unitaire : U †U = 1. Une matrice
hermitique ( A † = A ) ou symétrique ( Ae = A ) est nécessairement normale. Si, au contraire, la matrice
n’est pas normale, alors elle peut soit avoir un ensemble complet de n vecteurs propres qui ne sont
pas orthogonaux, ou encore un ensemble incomplet de vecteurs propres.
Une littérature très vaste décrit les méthodes de diagonalisation des matrices. Ces méthodes sont
typiquement itératives et visent à rendre la matrice A progressivement diagonale en appliquant une
suite de transformation de similitude. La méthode de Jacobi est la plus ancienne. Une autre méthode
consiste à réduire une matrice symétrique à une matrice tridiagonale (méthode de Householder) et
ensuite à diagonaliser cette matrice tridiagonale, par l’une des méthodes suivantes :
1. On trouve les valeurs propres en trouvant les racines numériques du polynôme caractéristique,
ce dernier s’évaluant rapidement dans le cas d’une matrice tridiagonale. Une fois les valeurs
propres connues, calculer le vecteur propre revient à résoudre le système linéaire (A −λ1)x = 0,
où l’une des composantes de x est arbitraire.
2. Une alternative est de procéder à une décomposition QR , une procédure par laquelle la matrice
tridiagonale T est exprimée sous la forme T = QR , où Q est une matrice orthogonale (Oe = O ) et
R une matrice triangulaire supérieure. Cette transformation peut être itérée jusqu’à ce que la
matrice tridiagonale devienne en fait diagonale (voir [PTVF07]).
En vérité, les méthodes efficaces de diagonalisation complète, par lesquelles toutes les valeurs propres
et tous les vecteurs propres sont calculés, sont relativement complexes. Nous ferons appel aux mé-
thodes pré-programmées de la librairie LAPACK plutôt que de les programmer.
135
Par contre, il est souvent nécessaire de trouver non pas toutes les couples (valeur et vecteur) propres,
mais seulement les couples propres associées à la valeur propre la plus basse (ou la plus élevée), ou du
moins à un petit nombre de valeurs propres extrêmes. Pour ce faire, la méthode de Lanczos est souvent
utilisée, ou encore la méthode du gradient conjuguée, comme nous allons maintenant l’expliquer.
A.2.2 Méthode de Lanczos
La méthode de Lanczos permet de calculer les valeurs et vecteurs propres extrêmes – c’est-à-dire les
plus élevées et les plus basses – d’une matrice de très grande taille. Elle se base sur une application
itérative de la matrice sur des vecteurs : on doit fournir une façon d’appliquer la matrice A sur un
vecteur quelconque, indépendamment de la manière dont cette matrice est emmagasinée, ce qui en
fait une méthode particulièrement adaptée aux matrices creuses de très grande dimension. Certaines
applications calculent même les éléments de matrice au fur et à mesure qu’ils sont requis, sans stocker
la matrice d’aucune façon. 1
L’idée de base derrière la méthode de Lanczos est de construire une projection de la matrice H (de
dimension N ) dont nous voulons les valeurs propres sur un sous-espace de petite dimension, mais qui
contient les vecteurs propres extrêmes avec une assez bonne précision. Ce sous-espace de dimension
M ≪ N , appelé sous-espace de Krylov, est obtenu en appliquant à répétition M − 1 fois la matrice H
sur un vecteur de départ |ϕ0 〉 qui peut être choisi au hasard :
{ }
K (ϕ0 , H , M ) = span |ϕ0 〉, H |ϕ0 〉, H 2 |ϕ0 〉, · · · , H M −1 |ϕ0 〉 (A.22)
Les vecteurs H j |ϕ0 〉 ne sont pas orthogonaux, mais une base de vecteurs orthogonaux du même sous-
espace est obtenue en appliquant la relation de récurrence suivante :
|ϕn+1 〉 = H |ϕn 〉 − a n |ϕn 〉 − b n2 |ϕn−1 〉 (A.23)
avec les coefficients suivants :
〈ϕn |H |ϕn 〉 〈ϕn |ϕn 〉
an = b n2 = (A.24)
〈ϕn |ϕn 〉 〈ϕn−1 |ϕn−1 〉
et les conditions initiales b 0 = 0, |ϕ−1 〉 = 0.
Problème A.1
Démontrez que la relation de récurrence (A.23), qui peut être considérée comme une définition des vecteurs
|ϕn 〉, avec les coefficients donnés en (A.24), entraîne que ces vecteurs sont mutuellement orthogonaux .
.
À chaque étape du calcul, trois vecteurs sont gardés en mémoire (ϕn+1 , ϕn and ϕn−1 ). Ces vecteurs ne
sont pas normalisés, mais on peut définir les vecteurs normalisés suivants :
|ϕn 〉
|n〉 = √ (A.25)
〈ϕn |ϕn 〉
En fonction de ces vecteurs orthonormés, la relation de récurrence (A.23) prend la forme suivante :
b n+1 |n + 1〉 = H |n〉 − a n |n〉 − b n |n − 1〉 ou encore H |n〉 = b n |n − 1〉 + a n |n〉 + b n+1 |n + 1〉 (A.26)
Si on tronque l’espace de Krylov à l’étape M , l’action de la matrice H sur les vecteurs de base (A.25)
peut être représentée par la matrice d’ordre M suivante :
 
a0 b1 0 0 ··· 0
 
b 1 a 1 b 2 0 · · · 0 
 
 
T = 
0 b2 a2 b3 · · · 0 
 (A.27)
. . . . . . 
 .. .. .. .. .. .. 
 
0 0 0 0 ··· a M −1
1. Une référence importante sur les méthodes de solution des problèmes aux valeurs propres, en particulier pour les ma-
trices de grande taille, est disponible en ligne : http://web.eecs.utk.edu/~dongarra/etemplates/book.html
136
A.2. Valeurs et vecteurs propres
Il est alors très simple de diagonaliser cette matrice triadiagonale, dont l’ordre est petit par rapport
à N , et dont les valeurs propres extrêmes convergent rapidement vers les valeurs propres extrêmes
de H .
Convergence vers les valeurs propres extrêmes

Comment peut-on démontrer heuristiquement que les valeurs propres de la matrice T convergent vers
les valeurs propres extrêmes de la matrice H ? Ceci est en fait une propriété de l’espace de Krylov. On
constate sans peine les deux propriétés suivantes du sous-espace de Krylov :
1. K (σϕ0 , τH , M ) = K (ϕ0 , H , M ). Autrement dit, multiplier le vecteur de départ ou la matrice
par une constante ne change pas le sous-espace. C’est une conséquence de la définition d’un
sous-espace vectoriel.
2. K (ϕ0 , H +σ, M ) = K (ϕ0 , H , M ). Autrement dit, ajouter une constante à la matrice H ne change
pas l’espace de Krylov. Ceci est une conséquence immédiate de la définition de l’espace de Kry-
lov : la puissance (H + σ) j est, après développement, une combinaison linéaire des puissances
de H qui sont égales ou inférieures à j , et donc qui font déjà partie de l’espace de Krylov.
En vertu de ces deux propriétés, il n’y a aucune perte de généralité à supposer que les deux valeurs
propres extrêmes de H sont −1 et 1, toutes les autres valeurs propres étant contenues entre ces deux
valeurs. En effet, on peut toujours trouver les constantes σ et τ appropriées afin que les valeurs
propres extrêmes de τH + σ soient ±1, et l’espace de Krylov est le même pour τH + σ que pour H . Soit
maintenant les vecteurs et valeurs propres exacts de la matrice H :
H |e i 〉 = e i |e i 〉 (A.28)
Le vecteur de départ |ϕ0 〉 peut être dévelopé sur une base des vecteurs propres de H :
∑
|ϕ0 〉 = γi |e i 〉 (A.29)
i
et l’application de la puissance H m sur |ϕ0 〉 donne

∑
H m |ϕ0 〉 = γi e im |e i 〉 (A.30)
i
Quand m est suffisamment grand, on constate que H m |ϕ0 〉 est dominé par les deux vecteurs propres
|1〉 et | − 1〉. Donc ces deux vecteurs propres seront bien représentés dans l’espace de Krylov : leur
projection sur ce sous-espace convergera rapidement vers l’unité en fonction du nombre d’itérations
M.
Calcul des vecteurs propres

À chaque itération de la procédure de Lanczos, on doit calculer les valeurs propres et vecteurs propres
de la matrice tridiagonale (A.27). Une procédure efficace de complexité O (M ) est disponible au sein
de LAPACK pour ce type de diagonalisation. On doit ensuite utiliser un critère de convergence pour
arrêter la procédure. Une critère heuristique est que le changement relatif de la valeur propre la plus
basse (ou la plus élevée) d’une itération à l’autre est inférieur à une limite donnée. Un meilleur critère,
que nous ne démontrerons pas ici, est de cesser les itérations quand le résidu de Ritz
def
|R〉 = H |e 0 〉 − e 0 |e 0 〉 (A.31)
est suffisamment petit. Dans cette expression e 0 est la valeur propre la plus petite estimée à l’étape
M , et |e 0 〉 le vecteur propre correspondant. On montre qu’une estimation de la norme de ce résidu est
donnée par la dernière composante du vecteur propre de T associé à la valeur propre la plus basse,
multipliée par b M −1 . Cette estimation est calculée à la l’étape suivante de la méthode Lanczos :
Ritz = abs(evector_tmp(j-1,0)*beta[j]) ;
Une fois la convergence atteinte, on peut obtenir quelques vecteurs propres estimés de H (ceux as-
sociés aux valeurs propres extrêmes et quelques autres qui leur sont proches) à l’aide des vecteurs
propres de la matrice T (qui sont connus dans la base de Lanczos (A.25)) et des vecteurs de cette base.
Dans le code en annexe, ces derniers sont écrits sur disque au fur et à mesure qu’ils sont calculés, et
ensuite relus afin de calculer les vecteurs propres dans la base originale du problème.
137
15
10
-5
-10
-15
0 20 40 60 80 100
F A.2
Illustration de la convergence des valeurs propres dans la procédure de Lanczos, en fonction du nombre d’ité-
rations effectuées, jusqu’à M = 100. La matrice H a une dimension N = 600. On constate que les valeurs propres
extrêmes convergent rapidement. À chaque itération, une valeur propre additionnelle s’ajoute à l’ensemble.
On note aussi qu’à l’itération 72, un valeur propre superflue apparaît, qui se fond avec la valeur propre la plus
basse un peu après ; ceci est la manifestation d’une fuite d’orthogonalité.
Remarques
1. Même si la relation de récurrence (A.23) garantit en principe l’orthogonalité des vecteurs de
Lanczos, les erreurs d’arrondi vont éventuellement briser cette orthogonalité : il y aura des
«fuites d’orthogonalité» et les M vecteurs résultants ne seront pas tous orthogonaux. Il est en
fait assez courant que les états propres extrêmes soient représentés plus d’une fois dans la base
de Lanczos. Ceci n’est pas grave si on ne cherche que les vecteurs propres extrêmes.
2. La méthode de Lanczos ne peut pas déterminer la dégénérescence des valeurs propres : si les
valeurs propres extrêmes sont dégénérées, alors un seul vecteur par sous-espace propre sera
généralement trouvé.
3. La convergence vers les vecteurs propres extrêmes est d’autant plus rapide que la différence
entre ces valeurs propres et les suivantes est grande.
4. La méthode de Lanczos est également valable pour estimer quelques valeurs et vecteurs
propres sous-dominants (c’est-à-dire la deuxième plus grande ou petite, la troisième, etc.), mais
la précision se détériore rapidement quand on s’éloigne des valeurs extrêmes.
138
A.3. Décomposition en valeurs singulières
A.3 Décomposition en valeurs singulières
Soit M une matrice complexe rectangulaire m × n . La décomposition en valeurs singulières (DVS, ou

en angl. singular value decomposition : SVD) de M prend la forme suivante :
M = U ΣV † (A.32)
où U est une matrice unitaire m × m , V une matrice unitaire n × n et Σ une matrice réelle m × n dia-
gonale (les valeurs diagonales de Σ sont notées σi ). Cette décomposition généralise la diagonalisation
d’une matrice normale à tout type de matrice, même rectangulaire. Si la matrice M est réelle et non
complexe, alors les matrices U et V sont orthogonales. De toute manière, V −1 = V † et U −1 = U † .
La matrice M agit sur un espace X (son domaine) vers une espace d’arrivée Y , c’est-à-dire M : X → Y .
Sur un élément x ∈ X , M produit un élément y de Y : y = M x . Si on procède à un changement de base
dans X défini par la matrice V , le vecteur x est dorénavant représenté par x ′ = V −1 x . De même, en
procédant à un changement de base dans Y défini par la matrice U −1 , le vecteur y devient y ′ = U −1 y
et donc la relation y = M x devient
y ′ = U −1 M x = U −1 MV x ′ ou y ′ = Σx ′ (A.33)
La matrice Σ étant diagonale, cette forme fait ressortir clairement les vecteurs singuliers associés à
la matrice M .
Considérons par exemple un système d’équations en apparence sous-déterminé (plus de variables

que d’équations) : M x = y , où m < n et où on cherche les n composantes de x , connaissant les m
composantes de y . Dans sa forme décomposée, ce système s’écrit plutôt y ′ = Σx ′ , ou
 
x 1′
    ′ 
y′ σ1 0 · · · 0 ··· 0   x2 

 1′    . 
 y   0 σ2 · · · 0 · · · 0  . 
 2   . 
 . = . . . .  ′  (A.34)
 ..   .. .. .. .. · · · 0  
    x m 
 . 
ym′
0 0 · · · σm · · · 0  . 
 . 
x n′
La solution à ce système est la suivante :

 ′

 yi
′ si i ≤ m
x i = σi (A.35)

arbitraire si m n ). Dans sa forme décomposée, ce système s’écrit plutôt y ′ = Σx ′ , ou
   
y 1′ σ1 0 · · · 0
 ′   
 y 2   0 σ2 · · · 0  ′
    x1
 .   . .. .. ..   ′ 
 
 ..   .. . . .   x2 
   
 ′ =  .  (A.36)
 yn   0 0 · · · σ   .. 
   m  
 .   . .. .. .. 
 .   .
. 
′
 .   . . .  xn
′
ym 0 0 ··· 0
La solution à ce système n’est possible que si y i′ = 0 (n < i ≤ m ). Dans ce cas, elle est simplement
donnée par
y′
x i′ = i (i = 1, . . . , n) (A.37)
σi
139
On retourne ensuite à x à l’aide de la matrice V : x = V x ′ .
Si la matrice M est carrée (m = n ), la DVS est possible même si la matrice n’est pas diagonalisable. Si
M est diagonalisable, alors on a la relation simple V = U −1 . Si M n’est pas diagonalisable, alors M M †
et M † M le sont. On constate que
M M † = U ΣΣ†U † et M † M = V Σ† ΣV † (A.38)
Donc les valeurs singulières (les éléments de Σ) sont les racines carrées des valeurs propres de M M †
et de M † M . Les colonnes de V sont les vecteurs propres de M † M , alors que les colonnes de U sont les
vecteurs propres de M M † .
La DVS permet aussi d’interpréter une matrice M comme une somme de produits tensoriels de vec-
teurs. En notation indicielle, la DVS s’écrit
∑
M i j = Ui k Σkk V j∗k (A.39)
k
Si la colonne no k de U est notée uk et la colonne no k de V est notée vk , cela signifie que la matrice
M peut s’écrire ainsi : ∑
M = σk uk ⊗ v∗k (A.40)
k
Cette représentation est importante dans le domaine de l’information quantique.
140
Annexe B
Calcul Parallèle
La puissance des ordinateurs basés sur les technologies du silicium et des circuits intégrés progresse
de manière exponentielle depuis 1970. Cette progression est généralement exprimée par la loi de
Moore 1 , qui stipule que le nombre de transistors à effet de champ qu’on peut placer sur un circuit
intégré unique double environ à tous les deux ans. Cette loi industrielle s’applique de manière re-
marquable depuis 40 ans (voir fig. B.1).
109
108
Nombre de transistors
107
106
2(a−1949)/2
105
104
1970 1975 1980 1985 1990 1995 2000 2005 2010 2015
année
F B.1
La loi de Moore. Chaque point représente un processeur mis sur le marché. La droite représente une expo-
nentielle doublant à tous les deux ans (en fait 2(y−1949)/2 , où y est l’année. Notons que le transistor date de
1947).
Cette progression dans la densité des circuits a entraîné une augmentation concommitante de la fré-
quence des horloges internes (cadence), une complexification des processeurs et au total une augmen-
tation de la puissance des microprocesseurs, elle aussi exponentielle. Cependant, cette augmentation
de la cadence s’est à peu près interrompue au milieu des années 2000, en raison de la difficulté à
évacuer la chaleur produite à l’intérieur du microprocesseur, chaleur proportionnelle à sa cadence.
Comme la puissance de calcul des microprocesseurs ne peut plus être augmentée de manière directe
en augmentant la cadence, il reste deux façons de l’augmenter :
1. Optimiser l’architecture interne de ces processeurs, par exemple en améliorant l’efficacité du
1. D’après Gordon Moore, l’un des fondateurs de la compagnie Intel.
141
Annexe B. Calcul Parallèle
pipeline des instructions. Cela est relativement difficile.

2. Multiplier les processeurs sur un même circuit en espérant qu’ils puissent travailler de concert.
C’est l’introduction des cœurs multiples.
C’est évidemment la deuxième voie qui est a été suivie de la manière la plus spectaculaire par les
manufacturiers. Pour le programmeur, elle pose le défi suivant : Comment écrire un programme des-
tiné à être exécuté simultanément par plusieurs processeurs distincts travaillant de concert ? C’est le
problème fondamental du calcul parallèle.
Précisons tout de suite que le calcul parallèle n’est pas né avec les processeurs multi-cœurs. Il se
développe depuis les années 1980, car une façon évidente de multiplier la puissance des ordinateurs a
toujours été le parallélisme. Cependant, le problème est différent depuis quelques années car il s’agit
dorénavant de la seule façon d’y arriver, les cadences des processeurs étant maintenant saturées.
Le calcul scientifique repose dans une large mesure sur la programmation parallèle, et les progrès
futurs dans ce domaine – ainsi que dans les applications “non scientifiques” qui reposent sur un
calcul intensif – dépendent de manière cruciale de la capacité des programmeurs à tirer parti du
calcul parallèle.
B.1 Généralités
On distingue généralement trois schémas d’organisation du traitement des données dans un système
de calcul :
1. SISD (single instruction, single data). C’est le schéma séquentiel. Un seul processus existe, qui
traite une série d’instructions agissant sur une série unique de données.
2. SIMD (single instruction, multiple data). Dans ce schéma, une seule série d’instructions est
exécutée, mais en parallèle sur plusieurs séries de données.
3. MIMD (multiple instruction, multiple data). Enfin, dans ce schéma, des instructions potentiel-
lement différentes sont appliquées à des données différentes. C’est le modèle le plus général.
Jusqu’à la fin des années 1990, les supercalculateurs les plus puissants étaient souvent des ordina-
teurs vectoriels, qui fonctionnent selon le schéma SIMD. Les processeurs des ordinateurs vectoriels
peuvent agir simultanément avec la même instruction sur un vecteur de données d’une certaine lon-
gueur (par exemple 128). Ainsi, l’addition de deux vecteurs de taille inférieure à la taille maximale
dictée par le processeur se fait dans le même nombre de cycles d’horloge que l’addition de deux sca-
laires. Le produit scalaire se fait alors en deux opérations, au lieu de 2N opérations, et ainsi de suite.
Ces ordinateurs ont à toute fin pratique disparu du marché depuis l’arrivée de processeurs génériques
plus puissants, car ils étaient très chers et produits en nombre relativement faible, alors que les pro-
cesseurs génériques bénéficient de la production de masse. De nos jours, les processeurs graphiques
(GPU) jouent ce rôle jusqu’à un certain point, quoiqu’ils soient beaucoup plus flexibles. Un processeur
Intel ou AMD générique contient aussi une série d’instructions (désignées par l’acronyme SSEx, où
x va de 1 à 5) qui mettent en œuvre un schéma SIMD partiel pour des vecteurs relativement courts.
Ces instructions ont été ajoutées dans le but d’accélérer des fonctions fréquemment utilisées dans
le domaine du multimédia, mais peuvent être également utiles dans une programmation générique.
Elles sont mises à contribution par l’utilisation d’options de compilation particulières.
Dans cette annexe, nous nous intéresserons plutôt à une mise en œuvre du schéma MIMD, qui re-
quiert la mise en place de plusieurs processus indépendants qui gèrent chacun leur propre ensemble
de données. Nous devons distinguer deux types principaux de systèmes :
1. Les systèmes à mémoire partagée. Il s’agit d’une collection de processeurs qui ont accès à une
mémoire commune et qui sont coordonnés par un système d’opération unique. Par exemple, un
ordinateur doté d’un processeur multi-cœur appartient à cette catégorie. La parallélisation se
fait à travers la création de processus concurrents (ou tâches, en anglais threads), qui ont accès
au même espace-mémoire.
142
B.2. Parallélisation avec openMP
2. Les systèmes à mémoire distribuée. Il s’agit d’un ensemble d’ordinateurs indépendants ou

nœuds, chacun pouvant être un petit système à mémoire partagée. Les nœuds communiquent
entre eux par l’intermédiaire d’un réseau de communication rapide et la parallélisation se fait
par échange de messages entre les différents nœuds.
B.1.1 Loi d’Amdahl
La loi d’Amdahl est une relation élémentaire qui donne l’accélération A (ou gain parallèle) d’un pro-
gramme exécuté en parallèle en fonction de la fraction f du programme est qui parallélisable et du
nombre N de processus concurrents :
1
A= (B.1)
1 − f + f /N
Expliquons. Soit t 1 le temps d’exécution du programme sur un seul processeur. La partie parallèle
du programme demande un temps d’exécution f t 1 et la partie séquentielle un temps (1 − f )t 1 . Si on
répartit le même programme sur N processeurs, chacun devra séparément exécuter la même partie
séquentielle, en un temps (1 − f )t 1 , mais la partie parallèle, en négligeant les inefficacités liées à la
communication entre les processus, sera exécuté en un temps f t 1 /N . Le temps total d’exécution en
parallèle, t N , sera donc
f t1
t N = (1 − f )t 1 + (B.2)
N
et l’accélération (angl. speedup) sera
def t1 1
A = = (B.3)
t N 1 − f + f /N
Cette relation simple est bien sûr une caricature de la réalité, car souvent les tâches concurrentes
n’ont pas exactement la même durée, les problèmes de communication entre tâches se posent, la
taille en mémoire de chaque tâche dépend de N et cela affecte le temps de calcul, etc. Cependant, la
loi d’Amdahl nous permet de comprendre un aspect fondamental du calcul parallèle : l’accélération
n’est appréciable que si la fraction parallèle f est importante. La règle d’or est qu’il ne faut pas utiliser
ft
plus de processeurs qu’il n’en faut pour diminuer le temps parallèle N1 à un niveau inférieur au temps
séquentiel (1 − f )t 1 ; autrement dit, le nombre raisonnable de processus à utiliser est
f
N∼ (B.4)
1− f
(évidemment, d’autres considérations sont en jeu ici, comme le nombre de processeurs disponibles,
etc.). Le défi du parallélisme massif est donc de diminuer la partie séquentielle du programme, de
manière à pouvoir efficacement augmenter N vers des tailles de plus en plus grandes.
B.2 Parallélisation avec openMP
L’un des outils de programmation parallèle les plus simples est le standard openMP. Il s’agit d’un
ensemble de directives de compilation (qu’on appelle pragma en C++) et de fonctions de librairies
qui permettent de paralléliser un code dans un modèle de mémoire partagée. Cette façon de faire est
adaptée aux processeurs multicœurs, mais ne permet pas de paralléliser vers un système à mémoire
distribuée.
Nous n’expliquerons pas toutes les directives openMP ici ; ce n’est pas l’endroit. Plusieurs références
et tutoriels sont disponibles sur le web. Nous allons simplement commenter un exemple extrêmement
simple de parallélisation effectuée à l’aide de cette technique :
143
Code B.1 : Exemple élémentaire de parallélisation avec openMP
2 #include <iomanip>
3 #include <cmath>
4 #include <omp.h>
5

7
8 int main(){
9 const int n = 200000000;
10 double z=0.0;
11 double h = M_PI/n ;
12 int i ;
13
14 #pragma omp parallel for private(i) reduction(+: z)

15 for(i=0; i<n ; i++) z += h*sin(i*h) ;
16 cout << ”integrale = ” << setprecision(14) << z << endl ;
17 }
.
Explications :
∫π
1. Le code est rudimentaire et calcule l’intégrale 0 dx sin(x) = 2 par la méthode des trapèzes (sans
tenir compte des extrémités) avec un nombre astronomique n de points et un pas d’intégration
h= π/n. Le but du code est d’illustrer la parallélisation, avec la possibilité de mesurer le temps
d’exécution en fonction du nombre de processus.
2. La ligne 4 inclut l’entête nécessaire à l’utilisation de openMP.
3. La ligne 14 est la directive nécessaire à la parallélisation openMP. Elle stipule que la boucle
qui suit sera parallélisée, que la variable i sera privée à chaque tâche et que les variables z
associées aux différentes tâches seront additionnées à la fin (ce qu’on appelle la réduction).
4. Le nombre de tâches pourrait être spécifié dans le code, mais il est généralement préférable
de fixer la variable d’environnement OMP_NUM_THREADS à la valeur désirée, par exemple par la
commande
export OMP_NUM_THREADS=8
avant l’exécution du programme.
5. La compilation du code avec openMP requiert une option, par exemple -openmp dans le com-
pilateur icpc, ou -fopenmp dans le compilateur g++.
4.5
4
3.5
3
A
2.5
2
f = 0.884
1.5
1
1 2 3 4 5 6 7 8
N
F B.2
Illustration de la loi d’Amdahl suite à l’exécution du programme openMP listé ci-dessus sur 1, 2, 4 et 8 cœurs.
La courbe est un lissage de la loi d’Amdahl sur les données, résultant en une fraction parallèle f = 0.884.
144
B.3. Parallélisation avec MPI
La figure B.2 illustre la loi d’Amdahl à l’aide des résultats obtenus par ce code. Le temps d’exécution
a été estimé à l’aide de la commande time, par exemple en invoquant
time ./a.out
B.3 Parallélisation avec MPI
La programmation parallèle en mémoire distribuée ne peut pas se faire à l’aide de openMP. L’outil
généralement utilisé dans ce cas est la librairie MPI (pour Message Passing Interface). La program-
mation MPI est plus complexe que la programmation openMP. Par contre, c’est essentiellement la
seule méthode utilisée de nos jours en mémoire distribuée. On peut aussi l’utiliser sur les systèmes
de mémoire partagée.
Encore une fois, le but de cette section n’est pas d’expliquer toutes les fonctionalités de MPI, mais
simplement de donner un exemple très simple. Il sera basé sur le même code trivial utilisé plus haut
pour openMP :
Code B.2 : Exemple élémentaire de parallélisation avec MPI
2 #include <iomanip>
3 #include <cmath>
4 #include <mpi.h>
5

7
8 int main(int argc, char *argv[]){

9
10 int nproc, rank ;

11 MPI_Init(&argc, &argv) ;
12 MPI_Comm_size(MPI_COMM_WORLD,&nproc) ; nombre de processus
13 MPI_Comm_rank(MPI_COMM_WORLD,&rank) ; rang de chaque processus
14
15 const int n = 200000000;

16 double z=0.0;
17 double h = M_PI/n ;
18 int i ;
19
20 for(i=rank ; i<n ; i+=nproc) z += h*sin(i*h) ; boucle d’intégration

21 double ztot = 0.0;
22 MPI_Reduce(&z,&ztot,1,MPI_DOUBLE ,MPI_SUM,0,MPI_COMM_WORLD) ;
23 cout << ”rang ” << rank << ”\tintegrale = ” << setprecision(14) << ztot << endl ;
24 }
.
Explications :
1. La ligne 4 inclut l’entête nécessaire
2. La ligne 13 initialise MPI.
3. La ligne 14 lance un appel de fonction afin de connaître le nombre de processus nproc utilisé.
4. La ligne 15 lance un appel de fonction afin de connaître le numéro (ou rang) rank du processus
courant. Lire un code MPI correctement demande de se mettre à la place de chaque processus
(tous les processus partagent le même code). La seule différence entre les différents processus
est la valeur de la variable rank, et le code agira différemment selon cette valeur. Le processus
associé à rank=0 est appelé le processus racine (en anglais root process) ; mais cette distinction
n’est pas toujours importante – du moins elle ne l’est pas dans cet exemple.
145
5. La boucle exécutée à la ligne 20 démarre à une valeur différente de i pour chaque processus,
et saute de nproc, afin que chaque valeur de i soit couverte une seule fois, par le processus de
rang i%rank.
6. Une fois à la ligne 22, chaque processus possède une partie de l’intégrale dans sa copie de la va-
riable z. Pour obtenir la somme de ces variables, soit la réponse désirée, il faut que chaque pro-
cessus envoie sa valeur de z au processus racine, qui les additionnera dans un nouvelle variable
ztot. Cette étape est la réduction des données et est effectuée par la fonction MPI_Reduce().
L’avant-dernier argument de la fonction stipule que les données sont réduites vers le rang 0.
7. À la ligne 23, chaque processus imprime sa valeur de ztot. Elles sont toutes nulles, sauf celle
associée au rang 0. Si on ne veut que voir les sortie émanant du rang 0, on n’a qu’à stipuler la
condition
if(rank==0)· · ·
146
Annexe C
Codes
C.1 Classe de vecteurs de longueur quelconque
Nous utiliserons dans ce cours une classe appelée Vector pour stocker des tableaux linéaire d’une
longueur quelconque. Il y a plusieurs façon de définir des tableaux en C++ :
1. La plus élémentaire consiste à utiliser les éléments du langage lui-même. Par exemple, un
tableau de 100 double intitulé X serait déclaré de la manière suivante :
double X[100];
La mémoire nécessaire au tableau sera allouée au début de la portée de l’énoncé (c’est-à-dire
l’ensemble lignes de code contenues entre les délimiteurs { et }) et libérée à la fin de la portée. Le
désavantage de cette méthode est que la longueur du tableau n’est pas contenue dans le tableau
lui-même, et doit être stockée séparément : le tableau n’est pas un objet autonome. Une variante
de cette méthode consiste à définir un pointeur et à en allouer la mémoire dynamiquement
ainsi :
double *X ;
X = new double[100];
Dans ce cas, on ne doit pas oublier de libérer la mémoire lorsqu’elle n’est plus requise :
delete[] X ;
Cette variante n’est utile que si l’existence du tableau est requise à l’extérieur d’une portée
bien définie.
2. On peut utiliser la librairie des modèles standards (Standard Template Library, ou STL). Cette
librairie définit un éventail assez complet de conteneurs, c’est-à-dire de structures souples qui
permettent de stocker des objets selon plusieurs modèles : tableaux linéaires, listes chaînées,
arbres, maps, etc. Pour un tableau simple, on utiliserait le modèle de classe vector<double> :
#include <vector>
vector<double> X(100) ;
L’avantage de cette classe est que la taille du tableau est comprise dans l’objet – accessible par
l’appel à la méthode X.size() – et qu’il est facile d’ajouter des éléments ou d’en retrancher.
Bref, elle se prête bien aux tableaux dont la longueur est incertaine au moment de l’alloca-
tion de la mémoire, ou variable. Un désavantage de cette approche est que la classe modèle
vector est tellement générale, qu’elle ne contient pas des méthodes élémentaires utiles pour
les tableaux de nombres (produit scalaire, multiplication par un scalaire, etc) et qu’elle est
légèrement moins efficace.
3. L’approche que nous suivrons est de définir notre propre classe de vecteurs, comme dans le
code ci-dessous (voir les explications après le listage).
Code C.1 : Classe Vector.h
1 #ifndef Vector_H
. 2 #define Vector_H
147
Annexe C. Codes
4 #include <cstdlib>
5 #include <cstring>
6 #include <cassert>
8 #include <complex>
9

11
12 inline double conjugate(double z) {return z ;}

13 inline complex<double> conjugate(complex<double> z) {return conj(z) ;}
14
15 classe modèle pour un tableau

16 template<class T>
17 class Vector{
18 public :
19 constructeur par défaut
20 Vector() : n(0), v(0L){}
21
22 constructeur d’un vecteur à un nombre donné d’éléments

23 Vector(int the_size){Alloc(the_size) ;}
24
25 constructeur par copie

26 Vector(const Vector<T> &x){
27 Alloc(x.n) ;
28 memcpy(v,x.v,n*sizeof(*v)) ;
29 }
30
31 destructeur
32 ~Vector(){ Free() ;}
33
34 taille
35 inline int size() const {return n ;}
36
37 accès au tableau (utiliser uniquement si on ne peut faire autrement)

38 inline T* array() const {return v ;}
39
40 alloue la mémoire
41 void Alloc(int the_size){
42 n = the_size ;
43 v = (T *)calloc(n,sizeof(T)) ;
44 assert(v) ;
45 }
46
47 opérateur d’assignation
48 const Vector<T>& operator=(const Vector<T> &x){
49 if(this==&x) return *this ; évite les boucles infinies
50 if(n==0) Alloc(x.n) ;
51 int small = (x.n < n) ? x.n : n ;
52 memcpy(v,x.v,small*sizeof(*v)) ; copie de x à *this un maximum de n données
53 return *this ;
54 }
55
56 met à zéro
57 void clear(){ memset(v,0,n*sizeof(*v)) ;}
58
59 accès aux éléments (membre de droite)

60 T& operator[](int i){
61 #ifdef BOUND_CHECK
62 assert(i>=0 and i<n) ;
63 #endif
. 64 return v[i];
148
C.1. Classe de vecteurs de longueur quelconque
65 }
66
67 accès aux éléments (membre de gauche)

68 const T& operator[](int i) const {
70 assert(i>=0 and i<n) ;
71 #endif
72 return v[i];
73 }
74
75 multiplication par un scalaire

76 Vector<T>& operator*=(const T &c)
77 {
78 for(int i=0; i<n ; i++) v[i] *= c ;
79 return *this ;
80 }
81
82 ajoute un vecteur
83 Vector<T>& operator+=(const Vector<T>&x)
84 {
86 assert(n == x.n) ;
87 #endif
88 for(int i=0; i<n ; i++) v[i] += x.v[i];
89 return *this ;
90 }
91
92 soustrait un vecteur
93 Vector<T>& operator-=(const Vector<T>&x)
94 {
96 assert(n == x.n) ;
97 #endif
98 for(int i=0; i<n ; i++) v[i] -= x.v[i];
99 return *this ;
100 }
101
102 ajoute un nombre à toutes les composantes

103 Vector<T>& operator+=(const T x)
104 {
105 for(int i=0; i<n ; i++) v[i] += x ;
106 return *this ;
107 }
108
109 soustrait un nombre de toutes les composantes

110 Vector<T>& operator-=(const T x)
111 {
112 for(int i=0; i<n ; i++) v[i] -= x ;
113 return *this ;
114 }
115
116 ajoute un vecteur fois un nombre

117 Vector<T>& mult_plus(const Vector<T> &x, T a){
118 for(int i=0; i<n ; i++) v[i] += a*x.v[i];
119 return *this ;
120 }
121
122 échange avec un autre vecteur

123 void swap(Vector<T> &x)
124 {
125 assert(x.n == n) ;
. 126 assert(v and x.v) ;
149
Annexe C. Codes
127 T *tmp ;
128 tmp = v ;
129 v = x.v ;
130 x.v = tmp ;
131 }
132
133 retourne la norme au carré

134 double norm2(){
135 double z = 0.0;
136 for(int i=0; i<n ; i++) z += v[i]*v[i];
137 return z ;
138 }
139
140 retourne la norme de la composante maximale du vecteur

141 double max(){
142 double z = 0.0;
143 for(int i=0; i<n ; i++) if(abs(v[i]) > z) z = abs(v[i]) ;
144 return z ;
145 }
146
147 insère un vecteur x à la position o1, à partir de la position o2 de x

148 void insert(const Vector<T> &x, int o1, int o2){
149 int m1 = n-o1 ; place restante dans le vecteur courant
150 int m2 = x.n-o2 ; place restante dans le vecteur x
151 int m = (m1 < m2) ? m1 :m2 ;
152 memcpy(&v[o1],&x.v[o2],m*sizeof(*v)) ;
153 }
154
155 imprime dans un flux de sortie

156 friend std ::ostream & operator << (ostream& flux, const Vector<T>& x){
157 for(int i=0; i<x.size() ; i++) flux << x[i] << ”\t” ;
158 return flux ;
159 }
160
161 Lit à partir d’un flux d’entrée

162 friend std ::istream& operator >> (istream& flux, Vector<T>& x){
163 for(int i=0; i<x.size() ; i++) flux >> x[i];
164 return flux ;
165 }
166
167 soustrait la projection du vecteur courant le long d’un vecteur donné

168 void ortho(Vector<T> &A){
169 T proj = (A*(*this))/(A*A) ;
170 mult_plus(A,-proj) ;
171 }
172
173 soustrait la projection du vecteur courant (X) sur V le long du vecteur W : X −= (X*V)W
174 void ortho(const Vector<T> &V, const Vector<T> &W){
175 T proj = (V*(*this)) ;
176 mult_plus(W,-proj) ;
177 }
178
179 private :
180
181 int n ; nombre de composantes

182 T *v ; pointeur vers le tableau des valeurs
183
184 libère la mémoire

185 void Free(){
186 free(v) ;
187 v = 0;
. 188 n = 0;
150
C.1. Classe de vecteurs de longueur quelconque
189 }
190
191 };
192
193 addition (opérateur binaire)

194 template <class T>
195 inline Vector<T> operator + (const Vector<T>& x, const Vector<T>& y){
196 Vector<T> tmp(x) ;
197 tmp += y ;
198 return tmp ;
199 }
200
201 multiplication par un scalaire (opérateur binaire)

203 inline Vector<T> operator * (const Vector<T>& x, const T &a){
204 Vector<T> tmp(x) ;
205 tmp *= a ;
206 return tmp ;
207 }
208
209 produit scalaire (opérateur binaire)

211 inline T operator * (const Vector<T>& x, const Vector<T>& y){
212 T z(0) ;
213 assert(x.size()==y.size()) ;
214 for(int i=0; i<x.size() ; i++) z += conjugate(x[i])*y[i];
215 return z ;
216 }
217
218 #endif
.
Expliquons maintenant certaines caractéristiques de cette classe :

1. Il s’agit d’un modèle de classe (angl. class template). La ligne 17 signifie que la classe qui suit
n’est pas précisément définie, mais constitue plutôt un modèle ou le caractère T est remplacé
par un type quelconque au moment de la déclaration (ceci s’applique aussi à la STL). Pour
déclarer un vecteur de 100 double, il faut alors écrire Vector<double> X(100) ;
2. Les données de la classe sont la longueur n du tableau et un pointeur v vers les éléments
du tableau. Ces données sont déclarées private, ce qui entraîne qu’elles ne sont accessibles
qu’aux méthodes définies dans la classe elle-même ; en particulier, écrire
Vector<double> X(100) ;
cout << X.n ;
causerait une erreur de compilation. Pour accéder à la taille du vecteur, il faut plutôt écrire X.
size(). Cette précaution empêche les utilisateurs de la classe de modifier les données cruciales
de la classe par accident. Ceci dit, nous ne suivrons généralement pas cette pratique dans les
classes que nous définirons dans ce cours, même si elle est recommandée pour des programmes
plus complexes. Notons aussi qu’on peut avoir accès au pointeur v via la méthode array().
3. Le tableau v[] lui-même est alloué dynamiquement, dans la méthode Alloc(). Cette mé-
thode utilise la routine C standard calloc() déclarée dans l’entête <cstdlib>. Si l’allocation
ne réussit pas, c’est-à-dire si la mémoire est insuffisante, le pointeur retourné par calloc()
est nul. On peut alors vérifier que l’allocation a réussi en invoquant la fonction assert(v),
qui termine le programme si son argument est nul (ou logiquement faux). Nous utiliserons la
fonction assert() à profusion dans ce cours, afin d’effectuer un traitement minimal des ex-
ceptions. Un traitement plus poussé des exceptions utiliserait plutôt les énoncés try, catch
et throw de C++. Lorsque le constructeur Vector<T>(_size) est invoqué, l’allocation de la
mémoire est effectuée.
4. L’accès aux éléments du tableau se fait comme dans un tableau simple : l’opérateur [...] a
été surchargé pour pointer vers la composante désirée du tableau. On peut ainsi accéder à la
composante i du tableau X par l’expression X[i], à la fois pour la lire ou la modifier (c’est-à-dire
151
Annexe C. Codes
à droite ou à gauche de l’opérateur d’assignation = .

5. La classe contient une précaution contre l’accès par erreur au-delà des limites du tableau. Si
le mot-clé BOUND_CHECK est défini (comme dans le cas du listage), alors une vérification est
effectuée avant chaque accès, ce qui certainement nuit à la performance, mais est très utile
lors du développement.
6. La méthode Free() libère la mémoire associée au tableau et remet à zéro la taille du vecteur
ainsi que le pointeur v. Elle est invoquée lors de la destruction de l’objet.
7. Pour déclarer un vecteur de nombres complexes à double précision dans un code, il faut s’assu-
rer d’inclure l’entête <complex>, et ensuite écrire une déclaration du genre
Vector<complex<double> > X(n) (n étant préalablement assigné à une valeur entière). Le
modèle de classe complex s’applique à des entiers et des NVF quelconques. Les fonctions real
(z), imag(z), conj(z) ont leur signification évidente. 1
8. Notons la fonction double conj(double z) définie au début du fichier, qui constitue en fait
la fonction identité, mais qui est nominalement supposée retourner le conjugué complexe d’un
nombre réel. Cette fonction apparemment inutile a été définie afin de surcharger la fonction
complex<double> conj(complex<double> z) afin qu’elle s’applique également aux nombre
réels de type double, afin de pouvoir écrire un modèle de classe applicable à la fois aux nombres
complexes et réels.
9. Les autres méthodes sont assez simples à comprendre.
C.2 Classe de matrices
Description
Le modèle de classe Matrix listé en annexe permet de manipuler des matrices pleines avec surcharge
d’opérateurs pour l’accès aux éléments, l’addition des matrices, la multiplication de deux matrices ou
la multiplication par une constante. L’application sur un vecteur est codée dans la méthode mult_add
(). Les opérations d’inversion ou de solution d’un système linéaire sont effectuées en faisant appel à
la librairie LAPACK (voir ci-dessous).
Les éléments de matrice sont stockés dans un tableau linéaire v[] de dimension r*c, r étant le
nombre de rangées et c le nombre de colonnes. L’élément (i,j) (rangée i et colonne j) de la matrice
est en position i+r*j de ce tableau. L’indice de rangée est celui qui change le plus rapidement dans
le tableau : la matrice est parcourue de haut en bas, en ensuite de gauche à droite : on dit qu’elle est
ordonnée par colonnes (angl. column-major order)). L’opérateur () a été surchargé pour donner accès
aux éléments : on accède à l’élément (i,j) de la matrice A par l’appel A(i,j).
La méthode column(i) produit un vecteur (décrit par le modèle de classe Vector<>) qui contient la
colonne i de la matrice. De même, row(i) produit la rangée i.
Interface avec LAPACK

La méthode Inverse() de la classe remplace la matrice par son inverse, en invoquant la librairie
LAPACK. Cette librairie est très largement utilisée pour un vaste éventail d’opérations matricielles ;
il est fortement conseillé de l’utiliser plutôt que d’écrire soi-même le code nécessaire, ou même de
compiler un code source de tierce partie, car la librairie est optimisée pour le processeur utilisé, parfois
en insérant des portions de code écrites en assembleur au lieu d’un langage de haut niveau.
LAPACK a été initialement écrit en FORTRAN, et le nom des routines est un peu cryptique : le
préfixe de chaque routine dépend du type de nombre à virgule flottante qui constitue la matrice : s
pour les réels en simple précision, d pour les réels en double précision, c pour les complexes en simple
précision et z pour les complexes en double précision. Une nomenclature est également suivie selon
les types de matrices : ge pour les matrices générales, sy pour les matrices symétriques, he pour les
matrices complexes hermitiques, etc. Ainsi, la routine effectuant la factorisation LU d’une matrice
1. Voir http://www.cplusplus.com/reference/std/complex/
152
C.2. Classe de matrices
réelle générale constituée de réels en double précision s’intitule dgetrf_() : le d initial pour les réels
en double précision, le ge suivant pour signifier une matrice générale et le trf suivant indique une
factorisation (f) en matrices triangulaires (tr). Le souligné final est commun à toutes les routines
initialement compilées en FORTRAN et invoquées à partir d’un code C++.
Voyons par exemple comment la routine Inverse() est construite pour une matrice de réels à double
précision. On commence par effectuer une décomposition LU à l’aide de la routine LAPACK dgetrf_
() (voir la section sec :matrices pour une explication de la décomposition LU) :
dgetrf_(&M, &N,(doublereal*)v, &LDA, IPIV,&INFO) ;
où
1. M et N sont les nombres de rangées et de colonnes (identiques ici).
2. v est le tableau des éléments de matrice ordonnée par colonnes.
3. LDA est max(1,M) (c’est-à-dire M dans notre cas).
4. IPIV est un tableau de la position des pivots, de dimension min(M,n), qui doit être préalloué.
5. INFO est un entier contenant un code d’erreur à la sortie de la routine. Si ce code est zéro, c’est
que le calcul s’est effectué sans erreur.
6. En sortie, le tableau v[] contient la factorisation LU, disposée comme une matrice. Les élé-
ments diagonaux de L , qui valent 1, ne sont pas stockés.
Ensuite, on fait appel à la routine dgetri_(), qui procède à l’inversion proprement dite de la facto-
risation LU :
dgetri_(&N,(doublereal*)v,&LDA,IPIV,WORK,&N,&INFO) ;
où
1. N=M est l’ordre de la matrice.
2. v[] est le tableau calculé par dgetrf_().
3. LDA est comme ci-haut.
4. IPIV est le tableau des pivots calculé par dgetrf_().
5. WORK est un espace de travail préalloué, dont la taille est donnée par l’argument suivant (ici N).
6. INFO a le même rôle que dans la routine dgetrf_(), ou que dans toutes les routines LAPACK.
Code C.2 : Classe de matrices Matrix
1 #ifndef Matrix_H
2 #define Matrix_H
3
6
7 extern ”C”{
8 #include ”f2c.h”
9 #include ”clapack.h”
10 }
11

13
15 class Matrix
16 {
17 public :
18
19 constructeur par défaut

20 Matrix() : r(0), c(0), v(0L){}
21
22 constructeur d’une matrice carrée

. 23 Matrix(int _r){
153
Annexe C. Codes
24 r = c = _r ;
25 alloc() ;
26 }
27
28 constructeur d’une matrice rectangulaire

29 Matrix(int _r, int _c){
30 r = _r ;
31 c = _c ;
32 alloc() ;
33 }
34
35 constructeur par copie

36 Matrix(const Matrix<T> &A){
37 r = A.r ;
38 c = A.c ;
39 alloc() ;
40 memcpy(v,A.v,r*c*sizeof(*v)) ;
41 }
42
43 destructeur
44 ~Matrix(){
45 Free() ;
46 }
47
48 taille
49 inline int rows() const {return r ;}
50 inline int columns() const {return c ;}
51
52 accès au tableau (utiliser uniquement si on ne peut faire autrement)

53 inline T* array() const {return v ;}
54
55 allocateur
56 void Alloc(int _r, int _c){
57 Free() ;
58 r = _r ;
59 c = _c ;
60 alloc() ;
61 }
62 void Alloc(int _r){Alloc(_r,_r) ;}
63
64 opérateur d’assignation (si les deux matrices sont de mêmes dimensions)

65 const Matrix<T>& operator=(const Matrix<T> &A){
66 if(this==&A) return *this ;
67 else if(r == 0 or c == 0){
68 Alloc(A.r, A.c) ;
69 memcpy(v,A.v,r*c*sizeof(*v)) ;
70 }
71 else if(r == A.r and c == A.c) memcpy(v,A.v,r*c*sizeof(*v)) ;
72 else{
73 assert(false) ;
74 }
75 return *this ;
76 }
77
78 accès aux éléments (membre de droite)

79 inline const T& operator()(const int &i, const int &j)const{
81 assert(i>=0 and i<r) ;
82 assert(j>=0 and j<c) ;
83 #endif
84 return(v[i+r*j]) ;
. 85 }
154
86
87 accès aux éléments (membre de gauche)

88 T& operator()(const int &i, const int &j){
90 assert(i>=0 and i<r) ;
91 assert(j>=0 and j<c) ;
92 #endif
93 return(v[i+r*j]) ;
94 }
95
96 met à zéro
97 void clear(){
98 memset(v,0,r*c*sizeof(*v)) ;
99 }
100
101 Vérifie l ’ hermiticité

102 bool is_hermitian(){
103 for(int i=0; i<r ; i++){
104 for(int j=0; j<=i ; j++) if(v[i+r*j] != conjugate(v[j+r*i])) return false ;
105 }
106 return true ;
107 }
108
109 addition d’une matrice

110 template <class S>
111 Matrix<T>& operator+=(const Matrix<S> &A){
113 assert(v) ;
114 #endif
115 int rc = r*c ;
116 for(int i=0; i<rc ; i++) v[i] += A.v[i];
117 return *this ;
118 }
119
120 ajoute une constante à la diagonale

121 void add_to_diagonal(T a){
122 for(int i=0; i<r ; i++) v[i+r*i] += a ;
123 }
124
125 ajoute un vecteur à la diagonale

126 void add_to_diagonal(Vector<T> a){
127 for(int i=0; i<r ; i++) v[i+r*i] += a[i];
128 }
129
130 pré−multiplie par une matrice diagonale contenue dans a

131 void mult_diagonal(Vector<T> a){
132 assert(a.size() == r) ;
133 for(int k=0; k<c ; k++) for(int i=0; i<r ; i++) v[i+r*k] *= a[i];
134 }
135
136 extrait une colonne

137 Vector<T> column(int col){
138 assert(col < c and col >= 0) ;
139 Vector<T> x(r) ;
140 for(int i=0; i<r ; i++) x[i] = v[i+r*col];
141 return x ;
142 }
143
144 extrait une rangée

145 Vector<T> row(int row){
146 assert(row < r and row >= 0) ;
. 147 Vector<T> x(c) ;
155
Annexe C. Codes
148 for(int i=0; i<c ; i++) x[i] = v[row+r*i];

149 return x ;
150 }
151
152 ajoute A.x au vecteur y : y += A.x

153 void mult_add(const Vector<T> &x, Vector<T> &y){
154 for(int j=0; j<c ; j++){
155 for(int i=0; i<r ; i++) y[i] += v[i+j*r]*x[j];
156 }
157 }
158
159 ajoute A.x au vecteur y : y += A.x

160 void mult_add(T *x, T *y){
161 for(int j=0; j<c ; j++){
162 for(int i=0; i<r ; i++) y[i] += v[i+j*r]*x[j];
163 }
164 }
165
166 ajoute la matrice B fois une constante c

167 void mult_add(const Matrix<T> &B, T cst){
168 assert(r==B.rows() and c==B.columns()) ;
169 for(int j=0; j<c ; j++){
170 for(int i=0; i<r ; i++) v[i+j*r] += cst*B(i,j) ;
171 }
172 }
173
174 inverse la matrice

175 void Inverse() ;
176
177 solutionne un système linéaire général A.x = u pour x

178 void solve(Vector<T> &x, const Vector<T> &u) ;
179
180 multiplication par un scalaire

181 inline Matrix<T> operator *= (T a){
182 int rc = r*c ;
183 for(int i=0; i<rc ; i++) v[i] *= a ;
184 return *this ;
185 }
186
187 insère une matrice B à la position r1,c1 de A, à partir de la position r2,c2 de B

188 void insert(const Matrix<T> &B, int r1, int c1, int r2, int c2){
189 int r3 = (r-r1 < B.r-r2) ? r-r1 : B.r-r2 ;
190 int c3 = (c-c1 < B.c-c2) ? c-c1 : B.c-c2 ;
191 for(int i=0; i<r3 ; i++){
192 for(int j=0; j<c3 ; j++){
193 (*this)(i+r1,j+c1) = B(i+r2,j+c2) ;
194 }
195 }
196 }
197
198 void eigenvaluesSym(Vector<double> &d) ;

199 void eigensystemSym(Vector<double> &d, Matrix<T> &U) ;
200 void eigenvalues(Vector<complex<double> > &d) ;
201 void eigensystem(Vector<complex<double> > &d, Matrix<T> &U) ;
202 void generalized_eigensystem(Matrix<T> &B, Vector<T> &d, Matrix<T> &U) ;
203
204 private :
205
206 int r ; !< nombre de rangées

207 int c ; !< nombre de colonnes
208 T *v ; !< tableau de valeurs (lues du haut vers le bas)
. 209
156
210 alloue la mémoire

211 void alloc(){
212 v = (T *)calloc(r*c,sizeof(T)) ;
213 assert(v) ;
214 }
215
216 libère la mémoire

217 void Free(){
218 free(v) ;
219 v = 0;
220 r = 0;
221 c = 0;
222 }
223 };
224
225 addition (opérateur binaire)

227 inline Matrix<T> operator + (const Matrix<T>& x, const Matrix<T>& y){
228 Matrix<T> tmp(x) ;
229 tmp += y ;
230 return tmp ;
231 }
232
233 multiplication par un scalaire (opérateur binaire)

235 inline Matrix<T> operator * (const Matrix<T>& x, const T &a){
236 Matrix<T> tmp(x) ;
237 tmp *= a ;
238 return tmp ;
239 }
240
241 multiplication de deux matrices : this = A * B

243 inline Matrix<T> operator * (const Matrix<T>& A, const Matrix<T>& B){
245 assert(A.columns() == B.rows()) ;
246 #endif
247 Matrix<T> C(A.rows(),B.columns()) ;
248 for(int j = 0; j < C.columns() ; j ++){
249 for(int i = 0; i < C.rows() ; i++){
250 T z = 0.0;
251 for(int k = 0; k < A.columns() ; k++) z += A(i,k)*B(k,j) ;
252 C(i,j) = z ;
253 }
254 }
255 return C ;
256 }
257
258 Imprime dans un flux de sortie

260 inline ostream& operator << (ostream& out, const Matrix<T>& x){
261 out << ’{’ ;
262 for(int i=0; i<x.rows() ; i++){
263 out << ’{’ << x(i,0) ;
264 for(int j=1; j<x.columns() ; j++) out << ”, ” << x(i,j) ;
265 out << ”}” ;
266 if(i+1 < x.rows()) out << ”,\n” ;
267 }
268 out << ”}\n” ;
269 return out ;
270 }
. 271
157
Annexe C. Codes
272 Lit à partir d’un flux d’entrée

274 inline istream& operator >> (istream& in, Matrix<T>& x){
275 for(int i=0; i<x.rows() ; i++){
276 for(int j=0; j<x.columns() ; j++) in >> x(i,j) ;
277 }
278 return in ;
279 }
280
281 template<> void Matrix<complex<double> > ::Inverse()

282 {
283 assert(r==c) ;
284 integer INFO, M , N , LDA ;
285 integer *IPIV ;
286 doublecomplex *WORK ;
287
288 IPIV = new integer[r];

289 WORK = new doublecomplex[r];
290
291 N = r;
292 M = r;
293 LDA = r ;
294
295 zgetrf_(&M, &N,(doublecomplex*)v, &LDA, IPIV,&INFO) ;

296 assert((int)INFO==0) ;
297 zgetri_(&N,(doublecomplex*)v,&LDA,IPIV,WORK,&N,&INFO) ;
299
300 delete[] WORK ;

301 delete[] IPIV ;
302 }
303
304 template<> void Matrix<double> ::Inverse()

305 {
306 assert(r==c) ;
307 integer INFO, M , N , LDA ;
308 integer *IPIV ;
309 doublereal *WORK ;
310
311 IPIV = new integer[r];

312 WORK = new doublereal[r];
313
314 N = r;
315 M = r;
316 LDA = r ;
317
318 dgetrf_(&M, &N,(doublereal*)v, &LDA, IPIV,&INFO) ;

320 dgetri_(&N,(doublereal*)v,&LDA,IPIV,WORK,&N,&INFO) ;
322
323 delete[] WORK ;

324 delete[] IPIV ;
325 }
326
327 solutionne le système linéaire A.x = u

328 template<> void Matrix<double> ::solve(Vector<double> &x, const Vector<double> &u)
329 {
330 assert(r==c) ;
331
332 integer N = r ;
. 333 integer NRHS = 1;
158
334 doublereal A[r*c];

335 integer LDA = r ;
336 integer IPIV[r];
337 integer LDB = r ;
338 integer INFO ;
339
340 x = u;
341 memcpy((void *)A,v,r*c*sizeof(*v)) ;
342 dgesv_(&N, &NRHS, A, &LDA, IPIV, (doublereal*)(x.array()), &LDB, &INFO) ;
344
345 }
346
347 /**
348 Méthode de calcul des valeurs propres d’une matrice réelle symétrique
349 d vecteur des valeurs propres
350 U matrice dont les colonnes sont les vecteurs propres correspondants
351 */
352 template<> void Matrix<double> ::eigenvaluesSym(Vector<double> &d)
353 {
354 assert(r==c) ;
355
356 char JOBZ = ’N’ ; calcule les vecteurs propres aussi

357 char UPLO = ’L’ ; le triangle inférieure est stocké
358 integer N = (integer)rows() ;
359
360 Matrix<double> U(*this) ;

361
362 integer INFO=0;

363 integer LDA = (integer)rows() ;
364 integer LWORK = N*(N+2) ;
365 doublereal *WORK = new doublereal[LWORK];
366
367 dsyev_(&JOBZ, &UPLO, &N, (doublereal *)U.array(), &LDA, (doublereal *)d.array(),

WORK, &LWORK, &INFO) ;
368
369 delete [] WORK ;

371 }
372
373 /**
374 Méthode de calcul des valeurs et vecteurs propres d’une matrice réelle symétrique
375 d vecteur des valeurs propres
376 U matrice orthogonale dont les colonnes sont les vecteurs propres correspondants
377 */
378 template<> void Matrix<double> ::eigensystemSym(Vector<double> &d, Matrix<double> &
U)
379 {
380 assert(r==c) ;
381
382 char JOBZ = ’V’ ; calcule les vecteurs propres aussi

385
386 U = *this ;
387 integer INFO=0;
391

. WORK, &LWORK, &INFO) ;
159
Annexe C. Codes
393

396 }
397
398 /**
399 Méthode de calcul des valeurs et vecteurs propres d’une matrice complexe hermitienne
400 d vecteur des valeurs propres (réel)
401 U matrice unitaire (complexe) dont les colonnes sont les vecteurs propres correspondants
402 */
403 template<>
404 void Matrix<complex<double> > ::eigensystemSym(Vector<double> &d, Matrix<complex<
double> > &U)
405 {
406 assert(r == c) ;
407
408 char JOBZ, UPLO ;

409 integer INFO, N , LDA, LWORK ;
410 doublecomplex *WORK ;
411 doublereal *RWORK ;
412
413 JOBZ = ’V’ ; calculates eigenvectors too

414 UPLO = ’L’ ; lower triangle is stored
415 N = (integer)r ;
416 U = *this ;
417 LDA = r ;
418 LWORK = N*(N+2) ;
419 WORK = new doublecomplex[LWORK];
420 RWORK = new doublereal[3*N-2];
421 zheev_(&JOBZ, &UPLO, &N, (doublecomplex *)&U.v[0], &LDA, (doublereal *)&d[0],
WORK, &LWORK, RWORK, &INFO ) ;
423 delete [] RWORK ;
425 }
426
427 /**
428 Méthode de calcul des valeurs propres d’une matrice réelle générale (non nécessairement symétrique)
429 d vecteur des valeurs propres (complexe)
430 */
431 template<> void Matrix<double> ::eigenvalues(Vector<complex<double> >&d)
432 {
433 assert(r==c) ;
434
435 char JOBVR = ’N’ ; calcule les vecteurs propres aussi

436 char JOBVL = ’N’ ; calcule les vecteurs propres aussi
438
439 integer INFO=0;

441 integer LWORK = 10*N ;
443
444 integer LDVL = (integer)rows() ;

445 integer LDVR = (integer)rows() ;
446 doublereal WR[N];
447 doublereal WI[N];
448 doublereal VL[1];
449 doublereal VR[1];
450 doublereal A[N*N];
451 memcpy(A,v,N*N*sizeof(*A)) ;
. 452
160
453 dgeev_(&JOBVL, &JOBVR, &N, A, &LDA, WR, WI, VL, &LDVL, VR, &LDVR, WORK, &LWORK,
&INFO) ;
454 for(int i=0; i<d.size() ; i++) d[i] = complex<double>(WR[i],WI[i]) ;
457 }
458
459 /**
460 Méthode de calcul des valeurs et vecteurs propres d’une matrice réelle générale (non nécessairement
symétrique)
462 U matrice complexe dont les colonnes sont les vecteurs propres correspondants
463 */
464 template<>
465 void Matrix<double> ::eigensystem(Vector<complex<double> >&d, Matrix<double> &U)
466 {
467 assert(r==c) ;
468
469 char JOBVR = ’V’ ; calcule les vecteurs propres droits aussi
470 char JOBVL = ’N’ ; calcule les vecteurs propres gauches aussi
472
473 integer INFO=0;

477

480 doublereal WR[N];
481 doublereal WI[N];
482 doublereal VL[1];
483
484 dgeev_(&JOBVL, &JOBVR, &N, (doublereal *)v, &LDA, WR, WI, VL, &LDVL, (doublereal
*)U.array(), &LDVR, WORK, &LWORK, &INFO) ;
485 for(int i=0; i<d.size() ; i++) d[i] = complex<double>(WR[i],WI[i]) ;
488 }
489
490 /**
491 Méthode de calcul des valeurs et vecteurs propres d’une matrice réelle générale (non nécessairement
symétrique)
493 U matrice complexe dont les colonnes sont les vecteurs propres correspondants
494 */
495 template<>
496 void Matrix<complex<double> > ::eigensystem(Vector<complex<double> >&d, Matrix<
complex<double> > &U)
497 {
498 assert(r==c) ;
499
500 char JOBVR = ’V’ ; calcule les vecteurs propres aussi

501 char JOBVL = ’N’ ; calcule les vecteurs propres aussi
503
504 U = *this ;
505 integer INFO=0;
508 doublecomplex *WORK = new doublecomplex[LWORK];;
. 509 doublereal *RWORK = new doublereal[2*N];
161
Annexe C. Codes
510

513 doublecomplex VL[1];
514
515 zgeev_(&JOBVL, &JOBVR, &N, (doublecomplex *)v, &LDA, (doublecomplex *)d.array(),

VL, &LDVL, (doublecomplex *)U.array(), &LDVR, WORK, &LWORK, RWORK, &INFO) ;
517 delete [] RWORK ;
519 }
520
521 template<> void Matrix<double> ::generalized_eigensystem(Matrix<double> &B, Vector<

double> &d, Matrix<double> &U)
522 {
523 assert(r==c) ;
524
525 char JOBZ = ’V’ ; calcule les vecteurs propres aussi

528
529 U = *this ;
530 integer ITYPE = 1;
531 integer INFO=0;
533 integer LDB = LDA ;
536
537 dpotrf_(&UPLO, &N, (doublereal *)B.array(), &LDA, &INFO) ;

539 dsygst_(&ITYPE, &UPLO, &N, (doublereal *)U.array(), &LDA, (doublereal *)B.array
(), &LDB, &INFO) ;
WORK, &LWORK, &INFO) ;
544 }
545
546 #endif
.
C.3 Autres codes
Code C.3 : Classe de matrices creuses : SparseMatrix.h

Ce code et le suivant utilisent une représentation des matrices creuses définie dans SparseMatrix.h. on y
trouve en particulier :
1. La méthode du gradient conjugué : ConjugateGradient
2. La méthode de Lanczos pour le problème aux valeurs propres Ax = λx : Lanczos
3. La méthode de Lanczos pour le problème aux valeurs propres généralisé Ax = λM x :
Lanczos_generalized
1 #ifndef SPARSEMATRIX_H_
2 #define SPARSEMATRIX_H_
3
. 5 #include <vector>
162
C.3. Autres codes
6 #include <list>
8 #include <cmath>
10 #include <cstdio>
12 #include <unistd.h>
13
14 #include ”Matrix.h”
15
16 extern ”C”{
17 #include ”f2c.h”
18 #include ”clapack.h”
19 }
20
21 #define LANCZOS_ITERMAX 200

22 #define LANCZOS_ACCURACY 1.0e-14
23
24 void EigensystemTridiagonal(int M, const double *alpha, const double *beta, Vector<

double> &evalue, Matrix<double> &evector, bool evector_flag) ;
25 inline double real(double z) {return z ;}
26
27 class matrix_element{
28 public :
29 int c ; indice de colonne
30 double v ; élément de matrice
31 matrix_element(int _c, double _v) : c(_c), v(_v){}
32 };
33 int matrix_element_comparator(const void *m1, const void *m2){ return(((
matrix_element*)m1)->c - ((matrix_element*)m2)->c) ;}
34
35 Classe décrivant une rangée d’une matrice creuse

36 struct compressed_row{
37 public :
38 vector<matrix_element> elem ;
39
40 void insert(int c, double v){

41 unsigned int i ;
42 for(i=0; i<elem.size() ; i++){
43 if(c == elem[i].c){
44 elem[i].v += v ;
45 break ;
46 }
47 }
48 if(i==elem.size()) elem.push_back(matrix_element(c,v)) ;
49 }
50
51 effectue le tri des éléments de matrice dans la rangée

52 void consol(){
53 qsort((void *)&elem[1], elem.size(), sizeof(matrix_element),
matrix_element_comparator) ;
54 }
55 };
56
57 Matrice creuse
58 class SparseMatrix{
59 public :
60 int n_rows ; nombre de rangées
61 int n_cols ; nombre de colonnes
62 Vector<compressed_row> row ; tableau des rangées compressées.
63
. 64 SparseMatrix(int _n_rows, int _n_cols) : n_rows(_n_rows), n_cols(_n_cols) {
163
Annexe C. Codes
65 row.Alloc(n_rows) ;
66 }
67
68 SparseMatrix(int _n_rows) : n_rows(_n_rows), n_cols(_n_rows) {

69 row.Alloc(n_rows) ;
70 }
71
72 insère un nouvel élément de matrice dans la liste

73 inline void Insert(int r, int c, double v){
74 if(abs(v)<1.0e-12) return ;
75 assert(r >= 0 and r < n_rows) ;
76 assert(c >= 0 and c < n_cols) ;
77 row[r].insert(c,v) ;
78 }
79
80 consolide la structure de donnée

81 void consol(){
82 for(int i=0; i<n_rows ; i++) row[i].consol() ;
83 }
84
85 retourne le nombre de rangées

86 inline int rows(){return n_rows ;}
87
88 retourne le nombre de colonnes

89 inline int columns(){return n_cols ;}
90
91 multiplie la matrice par b, et produit le vecteur x

92 void mult(Vector<double> &x, Vector<double> &b){
93 x.clear() ;
94 mult_plus(x,b) ;
95 }
96
97 multiplie la matrice par b et ajoute au vecteur x

98 void mult_plus(Vector<double> &x, Vector<double> &b){
99 assert(x.size() == n_rows and b.size() == n_cols) ;
100 for(int i=0; i<n_rows ; i++){
101 for(unsigned int j=0; j< row[i].elem.size() ; j++){
102 x[i] += b[row[i].elem[j].c]*row[i].elem[j].v ;
103 }
104 }
105 }
106
107 multiplie la matrice par b*z et ajoute au vecteur x

108 void mult_plus(Vector<double> &x, Vector<double> &b, double z){
109 assert(x.size() == n_rows and b.size() == n_cols) ;
110 for(int i=0; i<n_rows ; i++){
112 x[i] += b[row[i].elem[j].c]*row[i].elem[j].v*z ;
113 }
114 }
115 }
116
117 surcharge de l’opérateur de flux d’impression

118 friend std ::ostream & operator<<(std ::ostream &flux, const SparseMatrix &x){
119 if(x.n_rows + x.n_cols > 128) flux << ”Matrice trop grande pour être imprimée\
n” ;
120 else{
121 for(int i=0; i< x.n_rows ; i++){
122 for(unsigned int j=0; j< x.row[i].elem.size() ; j++){
123 cout << i << ’\t’ << x.row[i].elem[j].c << ’\t’ << x.row[i].elem[j].v
<< endl ;
. 124 }
164
C.3. Autres codes
125 }
126 }
127 return flux ;
128 }
129
130 construit une matrice dense M à partir de la représentation creuse

131 void make_dense(Matrix<double> &M){
132 M.clear() ;
133 assert(M.rows() == n_rows and M.columns() == n_cols) ;
134 for(int i=0; i< n_rows ; i++){
136 M(i,row[i].elem[j].c) = row[i].elem[j].v ;
137 }
138 }
139 }
140
141 méthode du gradient conjugué

142 void ConjugateGradient(Vector<double> &b, Vector<double> &x, const double tol){
143
144 Vector<double> r(b) ; initialisation de r

145 mult_plus(r, x, -1.0) ;
146 Vector<double> p(r) ;
147 double res_old = r*r ;
148 for(int i=0; i<x.size() ; i++){
149 Vector<double> Ap(x.size()) ;
150 mult_plus(Ap, p) ;
151 double z = p*Ap ;
152 double alpha = res_old/z ;
153 x.mult_plus(p,alpha) ;
154 r.mult_plus(Ap,-alpha) ;
155 double res_new = r*r ;
156 if(sqrt(res_new) < tol) break ;
157 p *= (res_new/res_old) ;
158 p += r ;
159 res_old=res_new ;
160 }
161 }
162
163 Méthode de Lanczos pour le problème aux valeurs propres généralisé

164 voir http ://web.eecs.utk.edu/~dongarra/etemplates/node103.html
165 nvalue : nombre de vecteurs propres requis
166 eigenvalues : Tableau des valeurs propres
167 eigenvector : Tableau des vecteurs propres
168 highest : vrai si on sélectionne les plus hautes valeurs propres (au lieu des plus basses)
169 void Lanczos(int nvalue, Vector<double> &eigenvalues, vector<Vector<double> > &
eigenvector, bool highest){
170
171 vérifier que les vecteurs propres sont alloués à la bonne taille
172 for(int i=0; i<nvalue ; i++) assert(eigenvector[i].size() == rows()) ;
173
174 vecteur de départ aléatoire

175 for(int i = 0; i < rows() ; i++) eigenvector[0][i] = 2.0*rand()/RAND_MAX-1.0;
176 eigenvector[0] *= 1.0/sqrt(eigenvector[0].norm2()) ;
177
178 int niter = (rows() > LANCZOS_ITERMAX) ? LANCZOS_ITERMAX :rows() ;

179
180 FILE *V_file ; fichier pour le stockage temporaire des vecteurs v i

181 V_file = tmpfile() ;
182 assert(V_file) ;
183
184 assert(nvalue<=n_rows) ;
. 185
165
Annexe C. Codes
186 double Ritz=1.0;

187 Vector<double> beta(niter+1) ;
188 Vector<double> alpha(niter+1) ;
189 Vector<double> evalue(niter) ;
190 Matrix<double> evector ;
191
192 Vector<double> r(eigenvector[0]) ; vecteur de départ

193 Vector<double> v(n_rows) ;
194 Vector<double> q(n_rows) ;
195 beta[0] = sqrt(r*r) ; β0 = q̃r
196
197 int j ;
198 for(j=1; j<=niter ; j++){
199 q = v ; stockage temporaire pour v j −1
200 v = r ; v *= 1.0/beta[j-1]; v j = r /β j −1
201 fwrite(v.array(),v.size(),sizeof(double),V_file) ; écriture de v j sur disque
202 r.clear() ; mult_plus(r,v) ; r = Av j
203 r.mult_plus(q,-beta[j-1]) ; r = r − β j −1 v j −1
204 alpha[j] = v*r ; α j = ṽ j r
205 r.mult_plus(v,-alpha[j]) ;
p
206 beta[j] = sqrt(r*r) ; β j = r˜r
207
208 Matrix<double> evector_tmp(j) ;

209 EigensystemTridiagonal(j, &alpha[1], &beta[1], evalue, evector_tmp, true) ;
210 Ritz = abs(evector_tmp(j-1,0)*beta[j]) ;
211
212 cout << ”itération ” << j << ”\trésidu = ” << Ritz << endl ;
213
214 if(Ritz < LANCZOS_ACCURACY or j== niter){

215 evector.Alloc(j,j) ;
216 evector = evector_tmp ;
217 break ;
218 }
219 }
220 niter = j ;
221
222 if(highest) for(int k=0; k<nvalue ; k++) eigenvalues[k] = evalue[niter-k-1];

223 else for(int k=0; k<nvalue ; k++) eigenvalues[k] = evalue[k];
224
225 Calcul des vecteurs propres

226 rewind(V_file) ;
227 for(int k=0; k<nvalue ; k++) eigenvector[k].clear() ;
228 for(j=0; j<niter ; j++){
229 fread(v.array(),v.size(),sizeof(double),V_file) ; lecture de v j depuis le disque
230 for(int k=0; k<nvalue ; k++){
231 if(highest) eigenvector[k].mult_plus(v,evector(j,niter-k-1)) ;
232 else eigenvector[k].mult_plus(v,evector(j,k)) ;
233 }
234 }
235 fclose(V_file) ;
236 }
237
238 Méthode de Lanczos pour le problème aux valeurs propres généralisé

239 voir http ://web.eecs.utk.edu/~dongarra/etemplates/node170.html
240 nvalue : nombre de vecteurs propres requis
241 eigenvalues : Tableau des valeurs propres
242 eigenvector : Tableau des vecteurs propres
243 highest : vrai si on sélectionne les plus hautes valeurs propres (au lieu des plus basses)
244 M : matrice de masse (problème aux valeurs propres généralisé)
245 void Lanczos_generalized(int nvalue, Vector<double> &eigenvalues, vector<Vector<
. double> > &eigenvector, bool highest, SparseMatrix *M){
166
C.3. Autres codes
246
247 vérifier que les vecteurs propres sont alloués à la bonne taille
248 for(int i=0; i<nvalue ; i++) assert(eigenvector[i].size() == rows()) ;
249
250 vecteur de départ aléatoire

251 for(int i = 0; i < rows() ; i++) eigenvector[0][i] = 2.0*rand()/RAND_MAX-1.0;
252 eigenvector[0] *= 1.0/sqrt(eigenvector[0].norm2()) ;
253
254 int niter = (rows() > LANCZOS_ITERMAX) ? LANCZOS_ITERMAX :rows() ;

255
256 assert(nvalue<=n_rows) ;
257
258 double Ritz=1.0;

259 Vector<double> beta(niter+1) ;
260 Vector<double> alpha(niter+1) ;
261 Vector<double> evalue(niter) ;
262 Matrix<double> evector ;
263
264 Vector<double> r(n_rows) ;

265 vector<Vector<double> > v ;
266 vector<Vector<double> > w ;
267
268 Vector<double> q(eigenvector[0]) ; vecteur de départ

269 M->mult_plus(r,q) ; r = M q
270 beta[0] = sqrt(q*r) ; β0 = q̃r
271
272 int j ;
273 for(j=1; j<=niter ; j++){
274 v.push_back(q) ; v[j-1] *= 1.0/beta[j-1]; v j = q/β j −1
275 w.push_back(r) ; w[j-1] *= 1.0/beta[j-1]; w j = r /β j −1
276 r.clear() ; mult_plus(r,v[j-1]) ; r = Av j
277 if(j>1) r.mult_plus(w[j-2],-beta[j-1]) ; r = r − β j −1 w j −1
278 alpha[j] = v[j-1]*r ; α j = ṽ j r
279 r.mult_plus(w[j-1],-alpha[j]) ;
280
281 reorthogonalization
282 for(int k=0; k< j-1; k++) r.ortho(v[k],w[k]) ;
283
284 M->ConjugateGradient(r, q, 1e-7) ; résoudre M q = r

√
285 beta[j] = sqrt(q*r) ; β j = q̃r
286
287 Matrix<double> evector_tmp(j) ;

288 EigensystemTridiagonal(j, &alpha[1], &beta[1], evalue, evector_tmp, true) ;
289 Ritz = abs(evector_tmp(j-1,0)*beta[j]) ;
290
291 cout << ”itération ” << j << ”\trésidu = ” << Ritz << endl ;
292
293 if(Ritz < LANCZOS_ACCURACY or j== niter){

294 evector.Alloc(j,j) ;
295 evector = evector_tmp ;
296 break ;
297 }
298 }
299 niter = j ;
300
301 if(highest) for(int k=0; k<nvalue ; k++) eigenvalues[k] = evalue[niter-k-1];

302 else for(int k=0; k<nvalue ; k++) eigenvalues[k] = evalue[k];
303
304 Calcul des vecteurs propres

305 for(int k=0; k<nvalue ; k++) eigenvector[k].clear() ;
. 306 for(j=0; j<niter ; j++){
167
Annexe C. Codes
307 for(int k=0; k<nvalue ; k++){

308 if(highest) eigenvector[k].mult_plus(v[j],evector(j,niter-k-1)) ;
309 else eigenvector[k].mult_plus(v[j],evector(j,k)) ;
310 }
311 }
312 }
313 };
314
315 Calcule les valeurs propres et (optionnellement) les vecteurs propres d’une matrice tridiagonale
symétrique.
316 M : taille de la matrice
317 alpha : première diagonale (commence à l’indice 0)
318 beta : deuxième diagonale (commence à l’indice 0)
319 evector : vecteurs propres
320 evector_flag : vrai si les vecteurs propres doivent être calculés aussi
321 void EigensystemTridiagonal(int M, const double *alpha, const double *beta, Vector<
double> &evalue, Matrix<double> &evector, bool evector_flag)
322 {
323 doublereal *d, *e, *work, *z ;
324
325 if(M==1){
326 if(evector_flag) evector(0,0) = 1.0;
327 evalue[0] = alpha[1];
328 return ;
329 }
330
331 work = new doublereal[2*M]; assert(work !=0) ;

332 d = new doublereal[M]; assert(d !=0) ;
333 e = new doublereal[M-1]; assert(e !=0) ;
334 z = (doublereal *)evector.array() ;
335 memcpy(d,alpha,M*sizeof(*d)) ;
336 memcpy(e,beta,(M-1)*sizeof(*e)) ;
337
338 char jobz ;

339
340 if(evector_flag) jobz=’V’ ; else jobz=’N’ ;

341 integer info, ldz, nn ;
342 nn = M ;
343 ldz = M ;
344
345 dstev_(&jobz, &nn, d, e, z, &ldz, work, &info) ; appel à LAPACK

346
347 assert((int)info==0) ;
348
349 for(int i=0; i<M ; i++) evalue[i] = (double)d[i];

350
351 delete[] work ;

352 delete[] d ;
353 delete[] e ;
354 }
355
356 #endif
.
Code C.4 : Méthode de Runge-Kutta : RK.h

La classe ODE_solver implante la méthode de Runge-Kutta au quatrième ordre (méthode RK4) et l’adapta-
tion du pas temporel (méthode RKadapt). Notez que la fonction deriv qui calcule les dérivées est en fait un
foncteur et constitue l’une des données de la classe.
. 3 #include <cmath>
168
C.3. Autres codes
6

8

10 struct ODE_solver{
11
12 int N ; nombre de variables dépendantes

13 T &deriv ; référence à un foncteur
14 double accur ; précision
15 double hnext ; prochain pas
16 double hdid ; pas précédent
17 constexpr static double hmin = 1.0e-8; pas minimal
18
19 ODE_solver(int _N, T &_deriv, double _accur, double _hnext) : N(_N), deriv(

_deriv), accur(_accur), hnext(_hnext) {}
20
21 Effectue un pas adaptatif dans la méthode de Runge−Kutta

22 t : variable indépendante
23 x : variables dépendantes
24 dx : changement dans les variables dépendantes suite au pas temporel
25 bool RKadap(double t, Vector<double> &x, Vector<double> &dx){
26 N = x.size() ; nombre de variables
27 double h,ts,h2,errmax ;
28
29 Vector<double> dxs(N) ; vecteurs temporaires

30 Vector<double> xs(N) ;
31 Vector<double> xt(N) ;
32
33 deriv(t,x,dx) ; calcul des dérivées au temps t

34 ts = t ; copie du temps de départ t
35 xs = x ; copie de la valeur de départ de xn
36 dxs = dx ; copie de la valeur de départ des dérivées
37 h = hnext ; valeur d’essai du pas
38 while(true){
39 h2 = h*0.5;
40 RK4(ts,xs,dxs,xt,h2) ; demi−pas Runge−Kutta au temps t
41 t = ts + h2 ;
42 deriv(t,xt,dx) ; calcul des dérivées au temps t + h/2 et au point xt
43 RK4(t,xt,dx,x,h2) ; demi−pas Runge−Kutta au temps t + h/2
44
45 x est maintenant la valeur prédite par deux demi−pas

46 t = ts + h ; temps final
47 if(h < hmin) return false ; sort de la boucle si h est trop petit
48 RK4(ts,xs,dxs,xt,h) ; pas Runge−Kutta au temps t
49 xt *= -1.0; xt += x ; xt = x − xt, différence des deux résultats
50 errmax = xt.max()/accur ;
51 if(errmax <= 1.0){
52 hdid = h ; valeur du pas effectué, suivie de l’augmentation du pas
53 hnext = (errmax > 0.0006 ? 0.9*h*exp(-0.20*log(errmax)) : 4.0*h) ;
54 break ;
55 }
56 h = 0.9*h*exp(-0.2*log(errmax)) ; h → 0.9h(∆0 /∆1 )1/5
57 }
58
59 correction de x (voir NR 2e edition) : rend l’approximation d’ordre h^5 au lieu de h^4

60 x.mult_plus(xt,0.066666666) ; x += xt/15
61
62 return true ;
63 }
. 64
169
Annexe C. Codes
65 Effectue un pas dans la méthode de Runge−Kutta au 2e ordre.

66 t : variable indépendante t [in]
67 x : xn [in]
68 k1 : k1 [in]
69 xp : xn+1 [out]
70 h : pas temporel h [in]
71 void RK2(double t, Vector<double> &x, Vector<double> &k1, Vector<double> &xp,
double h){
72
73 Vector<double> dxt(N) ; vecteurs temporaires

74
75 double h2 = h*0.5;
76 double th = t + h2 ;
77
78 xp = x + k1*h2 ; = xn + 12 k1
79 deriv(th,xp,dxt) ; dxt = f(xn + 12 k1 , t n + h/2) = k2 /h
80 xp = x + dxt*h ; = xn + 12 k2
81 }
82
83 Effectue un pas dans la méthode de Runge−Kutta au 4e ordre (même arguments que RK2).
84 void RK4(double t, Vector<double> &x, Vector<double> &k1, Vector<double> &xp,
double h){
85
86 Vector<double> xt(N) ; vecteurs temporaires

87 Vector<double> dxt(N) ;
88 Vector<double> dxm(N) ;
89
90 double h2 = h*0.5;
91 double th = t + h2 ;
92
93 xt = x + k1*h2 ; = xn + 12 k1
94 xp = xt*0.3333333333333333;
95 deriv(th,xt,dxt) ; dxt = f(xn + 12 k1 , t n + h/2) = k2 /h
96 xt = x + dxt*h2 ; = xn + 12 k2
97 xp += xt*0.6666666666666667;
98 deriv(th,xt,dxm) ; dxm = f(xn + 12 k2 , t n + h/2) = k3 /h
99 xt = x + dxm*h ; = xn + k3
100 xp += dxm*h*0.3333333333333333;
101 deriv(t+h,xt,dxt) ; dxt = f(xn + k3 , t n + h) = k4 /h
102 xp += dxt*h*0.1666666666666667; xn+1 = xn + 16 k1 + 31 k2 + 31 k3 + 61 k4
103 }
104
105 void solve_euler(double t0, Vector<double> &x, ostream &fout)

106 {
107 fout << 0.0 << ’\t’ << x << endl ;
108 Vector<double> dx(N) ;
109 for(double t=0.0; t<t0 ; t += hnext){
110 deriv(t,x,dx) ;
111 x += dx*hnext ;
112 fout << t << ’\t’ << x << endl ;
113 }
114 }
115
116 void solve_RK2(double t0, Vector<double> &x, ostream &fout)

117 {
118 fout << 0.0 << ’\t’ << x << endl ;
120 Vector<double> xp(N) ;
122 deriv(t,x,dx) ;
. 123 RK2(t,x,dx,xp,hnext) ;
170
C.3. Autres codes
124 x = xp ;
125 fout << t << ’\t’ << x << endl ;
126 }
127 }
128
129 void solve_RK4(double t0, Vector<double> &x, ostream &fout)

130 {
131 fout << 0.0 << ’\t’ << x << endl ;
133 Vector<double> xp(N) ;
135 deriv(t,x,dx) ;
136 RK4(t,x,dx,xp,hnext) ;
137 x = xp ;
138 fout << t << ’\t’ << x << endl ;
139 }
140 }
141
142 void solve_RKadapt(double t0, Vector<double> &x, ostream &fout)

143 {
144 double t=0.0;
145 int nstep=0;
146 const int max_steps=10000;
148
149 deriv(t,x,dx) ;
150 while(RKadap(t,x,dx)){
151 t += hdid ;
152 nstep++;
153 if(nstep > max_steps){
154 cout << ”maximum number of steps exceeded !\n” ;
155 break ;
156 }
157 if(t>t0) break ;
158 fout << t << ’\t’ << x << endl ;
159 }
160 }
161
162 };
.
Quelques explications sur ce code :

1. La classe est en fait un modèle de classe, dont l’argument est un foncteur qui permet de calculer
les dérivées.
2. La classe comporte diverses méthodes-pilotes (commençant par le mot solve) qui mettent en
œuvre les méthodes écrites plus haut qui se chargent de chaque étape. Seule la méthode d’Euler,
la plus simple, est codée entièrement dans solve_euler.
3. Les méthodes RK2 et RK4 ne contiennent pas le premier appel au foncteur qui calcule les déri-
vées. Ceci dans le but d’améliorer l’efficacité des codes adaptatifs qui devraient sinon recalculer
les dérivées au temps t n plusieurs fois. Il est donc nécessaire, dans les méthodes-pilotes, de faire
appel au foncteur explicitement à chaque étape.
Code C.5 : Méthode de Verlet : MD_solver.h

Le code suivant contient la méthode de Verlet, ainsi que des appels permettant de porter la solution en
graphique avec gnuplot, au fur et à mesure qu’elle est calculée.
1 #ifndef MD_H
2 #define MD_H
3
. 4 #include <cmath>
171
Annexe C. Codes
8
9 #define GNUPLOT
10
11 #ifdef GNUPLOT
12 extern ”C”{
14 }
15 #endif
16
17 #ifdef DISLIN
18 #include ”discpp.h”
19 #endif
20
22

24 class MD_solver{
25 public :
26 int N ; nombre de particules
27 T &force ;
28 Vector<Vector2D> r ; positions des particules
29 Vector<Vector2D> v ; vitesses des particules
30 Vector<double> m ; masses des particules
31
32 Vector<Vector2D> F ; forces au temps t

33 Vector<Vector2D> Fh ; forces au temps t + h
34
35 double gamma ; amortissement

36 double pot ; énergie potentielle à un instant donné
37 double K ; énergie cinétique à un instant donné
38 double J ; moment cinétique (composante en z)
39 Vector2D P ; quantité de mouvement totale
40
41 MD_solver(int _N, T &_force, double _gamma) : N(_N), force(_force), gamma(

_gamma){
42 m.Alloc(N) ;
43 r.Alloc(N) ;
44 v.Alloc(N) ;
45 F.Alloc(N) ;
46 Fh.Alloc(N) ;
47 }
48
49 void step(double h, double &max){

50 Vector2D f ;
51
52 calcul des positions au temps t+h

53 for(int i=0; i<N ; i++) r[i] += v[i]*h + F[i]*(0.5*h*h/m[i]) ;
54
55 calcul des forces au temps t+h

56 max = 0.0;
57 double norm ;
58 Fh.clear() ;
59 for(int i=0; i<N ; i++){
60 for(int j=0; j max) max = norm ;
64 Fh[i] += f ;
. 65 Fh[j] -= f ;
172
C.3. Autres codes
66 }
67 }
68
69 calcul des vitesses au temps t+h

70 for(int i=0; i<N ; i++) v[i] += (F[i]+Fh[i])*(0.5*h/m[i]) -v[i]*(h*gamma) ;
71 F.swap(Fh) ; remplacement des force au temps t par celles au temps t+h
72 }
73
74 void energie(){
75 K = 0.0;
76 P = Vector2D(0,0) ;
77 J = 0.0;
78 pot = 0.0;
79 for(int i=0; i<N ; i++){
80 K += m[i]*v[i].norm2() ;
81 P += m[i]*v[i];
82 J += m[i]*vector_product(r[i],v[i]) ;
83 }
84 K *= 0.5;
85 for(int i=0; i<N ; i++){
86 for(int j=0; j> m[i] >> r[i] >> v[i];
96 }
97
98 écrit la configuration sur disque

99 void plot(ostream &fout){
100 assert(fout) ;
101 int N1 = N-1;
102 for(int i=0; i<N1 ; i++) fout << m[i] << ’\t’ << r[i] << ’\t’ << v[i] << ’\n’ ;
103 int i=N1 ; fout << ”\n\n” ;
104 fout << m[i] << ’\t’ << r[i] << v[i] << ’\n’ ; projectile
105 }
106
107 void solve(double tmax, double _h0, double L, double dt_display = 0.0){
108 double h0 = _h0 ;
109 double max_deltav ; force maximale permise avant de diminuer h
110 double min_deltav ; force minimale permise avant d’augmenter h
111 double max_deltar ; vitesse maximale permise avant de diminuer h
112 double min_deltar ; vitesse minimale permise avant d’augmenter h
113
114 max_deltar = 0.005;

115 max_deltav = 0.01;
116 min_deltar = 0.05*max_deltar ;
117 min_deltav = 0.05*max_deltav ;
118
119 if(dt_display == 0.0) dt_display = h0 ;

120

122 #ifdef GNUPLOT
123 ifstream para(”para.dat”) ;
124 int taille ;
125 if(para == ”taille_fenetre”) para >> taille ;
126 else taille = 800;
. 127 if(taille < 200) taille = 200;
173
Annexe C. Codes
128 if(taille > 2000) taille = 2000;

129 para.close() ;
130 ofstream gout ;
133 gnuplot_cmd(GP,(char *)”set term x11 size %d,%d title ’Dynamique moleculaire’”
,taille,taille) ;
134 gnuplot_cmd(GP,(char *)”set xr [-%g :%g]”,L,L) ;
135 gnuplot_cmd(GP,(char *)”set yr [-%g :%g]”,L,L) ;
136 gnuplot_cmd(GP,(char *)”set size ratio -1”) ;
137 gnuplot_cmd(GP,(char *)”set nokey”) ;
138 #endif
139
140 #ifdef DISLIN

141 Dislin g ;
142 int width = 3000;
143 int margin = 150;
144 g.errmod(”ALL”, ”OFF”) ;
145 g.metafl(”cons”) ;
146 g.page(width,width) ;
147 g.scrmod(”revers”) ;
148 g.disini() ;
149 g.pagera() ;
150 g.complx() ;
151 g.height(40) ;
152 g.axspos (margin, width-margin) ;
153 g.axslen (width-2*margin,width-2*margin) ;
154 #endif
155

157
158 double h = h0 ;
159 double max ;
160 for(double t=0.0; t<tmax ; ){
161
162 Vector<Vector2D> r_back(r) ;

163 Vector<Vector2D> v_back(v) ;
164
165 step(h,max) ;
166
167 double h1 = max_deltav/max ;

168 double h2 = sqrt(2*max_deltar/max) ;
169 h1 = (h1<h2) ? h1 :h2 ;
170 if(h > h1){
171 r = r_back ;
172 v = v_back ;
173 h = h1 ;
174 continue ;
175 }
176 t += h ;
177
178 if(h>20*h0) h = 20*h0 ;

179 if(h<0.01*h0) h = 0.01*h0 ;
180
181 if(floor(t/dt_display) > output_step){

182 output_step++;
183 energie() ;
184 #ifdef GNUPLOT
186 plot(gout) ;
187 gout.close() ;
. 188 gnuplot_cmd(GP,(char *)”set title ’t = %2.3f, K=%2.2f, V=%2.2f, E=%2.2f’”,
174
C.3. Autres codes
t,K/N,pot/N,(K+pot)/N) ;
189 gnuplot_cmd(GP,(char *)”plot ’tmp.dat’ i 0 u 2:3 pt 7 ps 2, ’’ i 1 u 2:3
pt 7 lc rgb ’blue’ ps 2”) ;
190 usleep(2000) ;
191 cout << t << ’\t’ << K << ’\t’ << pot << ’\t’ << K+pot << endl ;
192 #endif
193 #ifdef DISLIN
194 double xx[N], yy[N];
195 g.erase() ;
196 g.errmod(”ALL”, ”OFF”) ;
197 g.graf(-L, L, -L, L/2, -L, L, -L, L/2) ;
198 char titre[128];
199 sprintf(titre,”%2.1f, K=%2.4f, V=%2.4f, E=%2.4f, h=%1.1g”,t,K/N,pot/N,(
K+pot)/N,h) ;
200 g.titlin(titre,4) ;
201 g.title() ;
202 g.color(”red”) ;
203 g.incmrk(-1) ;
204 g.marker(21) ;
205 int N1 = N-1;
206 for(int i=0; i<N1 ; i++){
207 xx[i] = r[i].x ;
208 yy[i] = r[i].y ;
209 }
210 g.curve(xx,yy,N) ;
211 double xx1[1], yy1[1];
212 xx1[0] =r[N1].x ;
213 yy1[0] =r[N1].y ;
214 g.marker(21) ;
215 g.color(”blue”) ;
216 g.curve(xx1,yy1,1) ;
217 g.endgrf() ;
218 usleep(2000) ;
219 #endif
220 }
221 }
222
223 #ifdef GNUPLOT

224 sleep(5) ;
226 #endif
227 #ifdef DISLIN
228 sleep(3) ;
229 g.disfin() ;
230 #endif
231 }
232
233 };
234
235 #endif
.
Quelques explications sur le code C.5 :

1. La classe Vector2D est requise. Il s’agit d’une version bi-dimensionnelle de la classe Vector3D
déjà étudiée. En particulier, la routine vector_product() calcule la composante z (donc hors
du plan) du produit vectoriel de deux vecteurs.
2. Ce code utilise une interface avec gnuplot pour afficher les résultats au fur et à mesure qu’ils
sont calculés. En fait cette interface n’est utilisée que si le mot-clé GNUPLOT est défini. Le code
doit être lié à la librairie gnuplot_i et le fichier d’entête gnuplot_i.h doit être inclus.
3. La classe MD_solver est un modèle de classe qui prend comme argument le type de foncteur
utilisé pour calculer les forces.
175
Annexe C. Codes
4. La classe garde en mémoire 5 tableaux de taille N (N étant le nombre de particules) : les

positions, vitesses et masses des particules, ainsi que les forces calculées au temps t et au
temps t +h . Certaines quantités dynamiques sont aussi calculées au besoin : l’énergie cinétique,
l’énergie potentielle, le moment cinétique et la quantité de mouvement.
5. La méthode step effectue un pas temporel h , c’est-à-dire calcule les nouvelles positions ri (t +h),
les forces au temps t + h (stockées dans Fh) et ensuite les nouvelles vitesses vi (t + h). La force
maximale parmi les N (N − 1)/2 forces mutuelles est aussi calculée, afin d’être retournée par
référence. Si cette force est trop grande, le pas ne sera pas utilisé, mais repris avec une valeur
plus petite de h . Par contre, si cette force est suffisamment petite, la valeur de h sera augmentée
pour le prochain pas.
6. La méthode energie() calcule les quantités dynamiques, pour fins d’affichage ou de diagnostic.
Ce calcul n’est pas requis pour la simulation elle-même.
7. La méthode plot() écrit l’ensemble des masses, positions et vitesses dans un flux de sortie,
afin de les porter en graphique.
8. La solution du système d’équations est réalisée par la méthode solve, qui prend comme argu-
ments le temps de simulation, le pas temporel initial, la taille du domaine spatial portée en
graphique et l’intervalle de temps entre les affichages.
Ce code est ensuite appelée par le programme principal suivant, qui contient la définition du foncteur
de force.
Code C.6 : Programme principal associé : MD.cpp
3 #include ”MD_solver.h”
5

7
8 génère un nombre aléatoire uniformément distribué dans l’intervalle [−1,1]

9 double random_double(){
10 return 2.0*rand()/RAND_MAX - 1.0;
11 }
12
13 Foncteur définissant la force inter−particules

14 struct force{
15 double r0 ; position du minimum
16 double rm ; portée
17 double V0 ; potentiel à l’origine
18 double V1 ; potentiel à r0
19 double a0 ;
20 double a1 ;
21 double b0 ;
22 double b1 ;
23 force(double _r0, double _rm, double _V0, double _V1) : r0(_r0), rm(_rm), V0(_V0
), V1(_V1) {
24 a0 = (V1-V0)/r0 ;
25 b0 = V0 ;
26 a1 = V1/(r0-rm) ;
27 b1 = -a1*rm ;
28 }
29
30 double pot(Vector2D &r1, Vector2D &r2){

31 double d = (r1-r2).norm() ;
32 if(d < r0) return a0*d+b0 ;
33 else if(d < rm) return a1*d+b1 ;
34 else return 0.0;
. 35 }
176
C.3. Autres codes
36
37 Vector2D operator() (Vector2D &r1, Vector2D &r2){

38 Vector2D R = r1-r2 ;
39 double d = (r1-r2).norm() ;
40 if(d < 0.001*r0) Vector2D(0.0,0.0) ;
41 else if(d < r0) return R*(-a0/d) ;
42 else if(d < rm) return R*(-a1/d) ;
43 return Vector2D(0.0,0.0) ;
44 }
45 };
46
47 int main(){
48
49 int n, N ;
50 double V0, V1, r0, rm, v0, dt, dt_display, M, a, gamma, L ;
51
53 para >> ”N” >> N ;
54 para >> ”a” >> a ;
55 para >> ”gamma” >> gamma ;
56 para >> ”V0” >> V0 ;
57 para >> ”V1” >> V1 ;
58 para >> ”r0” >> r0 ;
59 para >> ”rm” >> rm ;
60 para >> ”vitesse” >> v0 ;
61 para >> ”pas_temporel” >> dt ;
62 para >> ”L” >> L ;
63 para >> ”intervalle_affichage” >> dt_display ;
64 para >> ”masse_projectile” >> M ;
65 para.close() ;
66
67 ofstream fout(”in.dat”) ;
68 Vector2D e1(a,0) ;
69 Vector2D e2(a*cos(M_PI/3),a*sin(M_PI/3)) ;
70 n = (int)floor(sqrt(1.0*N))/2;
71 N=0;
72 for(int i=-n ; i<n ; i++){
73 for(int j=-n ; j<n ; j++){
74 Vector2D r = e1*(i+0.01*random_double())+e2*(j+0.01*random_double()) ;
75 if(r.norm() > n*a) continue ;
76 fout << 1.0 << ’\t’ << r.x << ’\t’ << r.y << ’\t’ << 0 << ’\t’ << 0 << ’\n’ ;
77 N++;
78 }
79 }
80 fout << M << ’\t’ << -n*a << ’\t’ << 0.2*a << ’\t’ << v0 << ’\t’ << 0 << ’\n’ ;
81 N++;
82 fout.close() ;
83
84 force f(r0,rm,V0,V1) ;
85 MD_solver<force> MD(N,f,gamma) ;
86
87 ifstream fin(”in.dat”) ;
88 MD.set_initial(fin) ;
89 fin.close() ;
90
91 MD.solve(100, dt, L, dt_display) ;

92
93 cout << ”exécution terminée normalement” << endl ;

94 }
.
Quelques explications sur le programme principal :
177
Annexe C. Codes
1. Le constructueur du foncteur force prend comme arguments les paramètres illustrés sur la
figure (2.2).
2. L’opérateur () est surchargé pour retourner la force entre deux particules situées aux positions
r 1 et r 2 . Cette structure suppose que la force ne dépend que de la position des particules. Dans le
cas présent, nous avons ajouté la possibilité d’une particule de masse plus grande (la dernière
du tableau) qui effectue une collision avec le reste des particules. En dépit de cette différence
de masse, cette particule spéciale exerce la même force que les autres.
3. Le programme principal commence par lire les paramètres de la simulation dans le fichier
d’entrée para.dat. Ensuite les positions initiales sont calculées et mises dans le fichier in.
dat, qui est ensuite lu par la méthode set_initial() de la classe MD_solver.
Code C.7 : Intégration gaussienne d’ordre 7 : Gauss_Legendre.h
1 #ifndef GAUSS_LEGENDRE_H
2 #define GAUSS_LEGENDRE_H
3
4 #define GL_N 7
5
6 double GL_w[GL_N] = {
7 0.1294849661688697,
8 0.2797053914892767,
9 0.3818300505051189,
10 0.417959183673469388,
11 0.3818300505051189,
12 0.2797053914892767,
13 0.1294849661688697
14 };
15
16 double GL_x[GL_N] = {
17 -0.9491079123427585,
18 -0.7415311855993944,
19 -0.4058451513773972,
20 0,
21 0.4058451513773972,
22 0.7415311855993944,
23 0.9491079123427585
24 };
25
26 double GL_scale ;
27
28 void Gauss_Legendre_x(Vector<double> &x, double a, double b){

29 assert(x.size()==GL_N) ;
30 GL_scale = 0.5*(b-a) ;
31 for(int i=0; i<GL_N ; i++){
32 x[i] = 0.5*(a+b) + GL_scale*GL_x[i];
33 }
34 }
35
36 double Gauss_Legendre(Vector<double> &F){

37 assert(F.size()==GL_N) ;
38 double res = 0.0;
39 for(int i=0; i<F.size() ; i++) res += GL_w[i]*F[i];
40 return GL_scale*res ;
41 }
42
43 #endif
.
178
C.3. Autres codes
Code C.8 : Éléments finis en dimension 1 : maillage1D.h

Ce code et le suivant utilisent une représentation des matrices creuses définie dans SparseMatrix.h.
1 #ifndef MAILLAGE1D_H_
2 #define MAILLAGE1D_H_
3
6 #include <string>
8
9 #include ”SparseMatrix.h” classe représentant des matrices creuses

10 #include ”Gauss_Legendre.h” quadrature gaussienne (7 points)
11 #define MAX_NODES 10000 nombre maximum de noeuds
12
13 class maillage1D{
14 public :
15 Vector<double> x ; coordonnées des noeuds
16
17 allocation d’une grille uniforme de n points

18 void init(int n, double L){
19 assert(n>1) ;
20 x.Alloc(n) ;
21 double h = L/(n-1) ;
22 for(int i=0; i<n ; i++) x[i] = i*h ;
23 }
24
25 lecture d’une grille à partir d’un fichier

26 void init(string &name){
27 ifstream fin(name.c_str()) ;
28 assert(fin) ;
29 int n ;
30 fin >> n ;
31 assert(n>1 and n<MAX_NODES) ; précaution contre les erreurs d’entrée
32 int tmp ;
33 for(int i=0; i<n ; i++) fin >> tmp >> x[i];
34 fin.close() ;
35 }
36
37 friend std ::ostream & operator<<(std ::ostream &flux, const maillage1D &x){
38 flux << ”Liste des noeuds :\n” ;
39 flux << x.x.size() << endl ;
40 for(int i=0; i<x.x.size() ; i++) flux << i << ’\t’ << x.x[i] << endl ;
41 return flux ;
42 }
43
44 méthode de calcul de la matrice de masse

45 Mi : partie intérieure
46 Mf : partie qui couple les noeuds de frontière aux noeuds intérieurs
47 void mass_matrix(SparseMatrix &Mi, SparseMatrix &Mf){
48 const int n = x.size() ;
49 const int ni = n-2;
50 const double i6 = 1.0/6;
51 const double i3 = 1.0/3;
52
53 assert(Mi.rows() == ni) ;
54 assert(Mf.rows() == ni and Mf.columns() == 2) ;
55 Mf.Insert(0,0,i6*(x[1]-x[0])) ;
56 Mf.Insert(n-3,1,i6*(x[n-1]-x[n-2])) ;
57 Mi.Insert(0,0,i3*(x[2]-x[0])) ;
. 58 for(int i=1; i<ni ; i++){
179
Annexe C. Codes
59 Mi.Insert(i-1,i,i6*(x[i+1]-x[i])) ;
60 Mi.Insert(i,i-1,i6*(x[i+1]-x[i])) ;
61 Mi.Insert(i,i,i3*(x[i+2]-x[i])) ;
62 }
63 }
64
65 méthode de calcul du laplacien

66 Li : partie intérieure
67 Lf : partie qui couple les noeuds de frontière aux noeuds intérieurs
68 z : multiplicateur
69 void Laplacian(SparseMatrix &Li, SparseMatrix &Lf, double z = 1.0){
70 const int n = x.size() ;
72
73 assert(Li.rows() == ni) ;
74 assert(Lf.rows() == ni and Lf.columns() == 2) ;
75 Lf.Insert(0,0,z/(x[1]-x[0])) ;
76 Lf.Insert(n-3,1,z/(x[n-1]-x[n-2])) ;
77 Li.Insert(0,0,-z/(x[2]-x[1])-z/(x[1]-x[0])) ;
78 for(int i=1; i<ni ; i++){
79 Li.Insert(i-1,i,z/(x[i+1]-x[i])) ;
80 Li.Insert(i,i-1,z/(x[i+1]-x[i])) ;
81 Li.Insert(i,i,-z/(x[i+2]-x[i+1])-z/(x[i+1]-x[i])) ;
82 }
83 }
84
85 évaluation des fonctions tente

86 double tente(int i, double z){
87 double u = 0.0;
88 int n1 = x.size()-1;
89 if(i==0){
90 if(z>x[0] and z<x[1]) u = (z-x[1])/(x[0]-x[1]) ;
91 }
92 else if(i==n1){
93 if(z>x[n1-1] and z<x[n1]) u = (z-x[n1-1])/(x[n1]-x[n1-1]) ;
94 }
95 else{
96 if(z>x[i-1] and z<x[i]) u = (z-x[i-1])/(x[i]-x[i-1]) ;
97 else if(z>x[i] and z<x[i+1]) u = (z-x[i+1])/(x[i]-x[i+1]) ;
98 }
99 return u ;
100 }
101
102 };
103 #endif
104
105 calcul des éléments de matrice d’une fonction f(x)

106 f : foncteur représentant la fonction
109 l ’ intégration est réalisée par quadrature gaussienne
111 void potentiel(maillage1D &grille, T &f, SparseMatrix &Mi, SparseMatrix &Mf){
112 const int n = grille.x.size() ;
114 double z ;
115
116 const int gln = 7;

117 Vector<double> glx(gln) ;
118 Vector<double> glf(gln) ;
119
. 120 éléments hors diagonale mixtes
180
C.3. Autres codes
121 Gauss_Legendre_x(glx,grille.x[0],grille.x[1]) ;
122 for(int j=0; j<gln ; j++) glf[j] = grille.tente(0,glx[j])*grille.tente(1,glx[j])*
f(glx[j]) ;
123 z = Gauss_Legendre(glf) ;
124 Mf.Insert(0,0,z) ;
125
126 Gauss_Legendre_x(glx,grille.x[ni],grille.x[ni+1]) ;
127 for(int j=0; j<gln ; j++) glf[j] = grille.tente(ni,glx[j])*grille.tente(ni+1,glx[
j])*f(glx[j]) ;
129 Mf.Insert(ni-1,1,z) ;
130
131 éléments hors diagonale internes

132 for(int i=2; i<=ni ; i++){
133 Gauss_Legendre_x(glx,grille.x[i-1],grille.x[i]) ;
134 for(int j=0; j<gln ; j++) glf[j] = grille.tente(i-1,glx[j])*grille.tente(i,glx[
j])*f(glx[j]) ;
136 Mi.Insert(i-2,i-1,z) ;
138 }
139
140 éléments diagonaux internes

141 for(int i=1; i<=ni ; i++){
142 Gauss_Legendre_x(glx,grille.x[i-1],grille.x[i]) ;
143 for(int j=0; j<gln ; j++) glf[j] = grille.tente(i,glx[j])*grille.tente(i,glx[j
])*f(glx[j]) ;
145 Gauss_Legendre_x(glx,grille.x[i],grille.x[i+1]) ;
146 for(int j=0; j<gln ; j++) glf[j] = grille.tente(i,glx[j])*grille.tente(i,glx[j
])*f(glx[j]) ;
147 z += Gauss_Legendre(glf) ;
149 }
150 }
.
Code C.9 : Programme principal, calcul des premiers modes propres : Helmholtz1D.cpp
2 #include <string>
4
5 #include ”maillage1D.h”
7
8 calcul des modes propres de l’équation de Helmholtz en 1D, conditions aux limites de Dirichlet
9 int main() {
10
11 int n_points ;
12 maillage1D grille ;
13 string filename ;
14 ofstream fout ;
16
17 bool dense=false ; ’true’ si on utilise des matrices denses

18 bool generalized=false ; ’true’ si on applique le problème aux VP généralisé
19
20 if(fin==”dense”) dense = true ;

21 if(fin==”generalized”) generalized = true ;
22
. 23 initialisation de la grille
181
Annexe C. Codes
24 if(fin == ”grille”){ lecture d’une grille calculée au préalable (non uniforme)

25 fin >> filename ;
26 grille.init(filename) ;
27 }
28 else{ construction d’une grille uniforme
29 double L ;
30 fin >> ”points” >> n_points ;
31 fin >> ”L” >> L ;
32 grille.init(n_points,L) ;
33 }
34
35 int modes=0; nombre de modes calculés

36 fin >> ”modes” >> modes ;
37 fin.close() ;
38 int ni = grille.x.size()-2; nombre de points intérieurs
39 if(modes>ni) modes = ni ;
40
41 matrices creuses représentant le laplacien

42 SparseMatrix Li(ni) ; pour les noeuds intérieurs
43 SparseMatrix Lb(ni,2) ; couplage intérieur−frontière
44 cout << ”calcul du laplacien...\n” ;
45 grille.Laplacian(Li,Lb) ;
46
47 matrices creuses représentant la matrice de masse

48 SparseMatrix Mi(ni) ; pour les noeuds intérieurs
49 SparseMatrix Mb(ni,2) ; couplage intérieur−frontière
50 cout << ”calcul de la matrice de masse...\n” ;
51 grille.mass_matrix(Mi,Mb) ;
52
53 cout << ”calcul des vecteurs et valeurs propres...\n” ;

54
55 if(dense){
56 Matrix<double> Li_dense(ni) ;
57 Li.make_dense(Li_dense) ;
58 Matrix<double> Mi_dense(ni) ;
59 Mi.make_dense(Mi_dense) ;
60 Matrix<double> U(ni) ;
61 Vector<double> eigenvalue(ni) ;
62 if(generalized) Li_dense.generalized_eigensystem(Mi_dense,eigenvalue,U) ;
63 else Li_dense.eigensystemSym(eigenvalue,U) ;
64
65 impression des valeurs propres et vecteurs propres

66 fout.open(”vp.dat”) ;
67 fout << ”#x\t” ;
68 for(int j=0; j<modes ; j++){
69 fout << eigenvalue[ni-j-1] << ’\t’ ;
70 }
71 fout << endl ;
72 fout << grille.x[0] << ’\t’ ;
73 for(int j=0; j<modes ; j++) fout << 0 << ’\t’ ;
74 fout << endl ;
75 for(int i=0; i< ni ; i++){
76 fout << grille.x[i+1] << ’\t’ ;
77 for(int j=0; j<modes ; j++) fout << U(i,ni-j-1) << ’\t’ ;
78 fout << endl ;
79 }
80 fout << grille.x[ni+1] << ’\t’ ;
82 fout << endl ;
83 fout.close() ;
84 }
. 85 else{
182
C.3. Autres codes
86 allocation de l’espace pour les valeurs propres et les vecteurs propres

87 Vector<double> eigenvalue(modes) ;
88 vector<Vector<double> > eigenvector(modes) ;
89 for(int i=0; i<modes ; i++) eigenvector[i].Alloc(Li.rows()) ;
90 if(generalized) Li.Lanczos_generalized(modes, eigenvalue, eigenvector, true, &
Mi) ;
91 else Li.Lanczos(modes, eigenvalue, eigenvector, true) ;
92
93 impression des valeurs propres et vecteurs propres

94 fout.open(”vp.dat”) ;
95 fout << ”#x\t” ;
96 for(int j=0; j<modes ; j++){
97 fout << eigenvalue[j] << ’\t’ ;
98 }
99 fout << endl ;
100 fout << grille.x[0] << ’\t’ ;
102 fout << endl ;
103 for(int i=0; i< ni ; i++){
104 fout << grille.x[i+1] << ’\t’ ;
105 for(int j=0; j<modes ; j++) fout << eigenvector[j][i] << ’\t’ ;
106 fout << endl ;
107 }
108 fout << grille.x[ni+1] << ’\t’ ;
110 fout << endl ;
111 fout.close() ;
112 }
113

115 }
.
Code C.10 : Éléments finis en dimension 2 : maillage2D.h
1 #ifndef MAILLAGE2D_H_
2 #define MAILLAGE2D_H_
3
6 #include <string>
8
9 #include ”SparseMatrix.h” classe représentant des matrices creuses

10
11 typedef struct{
12 double x ; coordonnée x
13 double y ; coordonnée y
14 int b ; frontière à laquelle appartient le noeud (0=aucune)
15 } Node ;
16
17 typedef struct{
18 int a ; indice du 1er noeud
19 int b ; indice du 2e noeud
20 int c ; indice du 3e noeud
21 double ab ; longueur au carré du lien ab
22 double bc ; longueur au carré du lien bc
23 double ca ; longueur au carré du lien ac
24 double A ; aire de la face
25 } Face ;
26
. 27 class maillage2D{
183
Annexe C. Codes
28 public :
29 int n ; nombre de noeuds
30 int ni ; nombre de noeuds intérieurs
31 int nb ; nombre de noeuds à la frontière
32 int nf ; nombre de faces
33 int na ; nombre d’attributs par noeud
34
35 Node *node ; tableau des noeuds

36 Face *face ; tableau des faces
37 double **att ; attributs de chaque noeud
38 string name ; radical du nom du fichier contenant la description de la triangulation (pour lecture)
39
40 maillage2D(string &_name) : node(0L), face(0L), att(0L), name(_name){

41
42 ouverture et lecture du fichier .node

44 filename = name + ”.node” ;
45 ifstream elem_file(filename.c_str()) ;
46 assert(elem_file) ;
47
48 int dummy ;
49 elem_file >> n >> dummy >> na >> dummy ;
50
51 allocation des attributs (si présents)

52 double att_tmp[na];
53 if(na>0){
54 att = new double*[na];
55 }
56 for(int i=0; i<na ; i++) att[i] = new double[n];
57
58 il faut réindexer les noeuds, pour séparer les noeuds intérieurs de la frontière
59 donc on introduit un index
60 int index[n+1];
61
62 node = new Node[n];

63 Node node_tmp ;
64 int k=0;
65 for(int i=0; i<n ; i++){
66 elem_file >> dummy >> node_tmp.x >> node_tmp.y ;
67 assert(dummy == i+1) ;
68 for(int a=0; a<na ; a++) elem_file >> att_tmp[a];
69 elem_file >> node_tmp.b ;
70 if(node_tmp.b) continue ;
71 index[i+1] = k ;
72 if(na) memcpy(att[k],att_tmp,na*sizeof(*att_tmp)) ;
73 node[k] = node_tmp ;
74 k++;
75 }
76 ni = k ; nombre de noeuds intérieurs
77 nb = n - ni ;
78 elem_file.seekg(0) ;
79 elem_file >> n >> dummy >> na >> dummy ;
80 for(int i=0; i<n ; i++){
81 elem_file >> dummy >> node_tmp.x >> node_tmp.y ;
82 for(int a=0; a<na ; a++) elem_file >> att_tmp[a];
83 elem_file >> node_tmp.b ;
84 if(node_tmp.b==0) continue ;
85 index[i+1] = k ;
86 if(na) memcpy(att[k],att_tmp,na*sizeof(*att_tmp)) ;
87 node[k] = node_tmp ;
88 k++;
. 89 }
184
C.3. Autres codes
90 elem_file.close() ;
91
92 ouverture et lecture du fichier .ele

93 filename = name + ”.ele” ;
94 elem_file.open(filename.c_str()) ;
95 assert(elem_file) ;
96
97 elem_file >> nf >> dummy >> dummy ;

98 assert(dummy==0) ; on suppose aucun attribut pour les faces
99 face = new Face[nf];
100
101 lecture des faces et calcul de leurs propriétés

102 for(int i=0; i<nf ; i++){
103 int a,b,c ;
104 elem_file >> dummy >> a >> b >> c ;
105 assert(dummy == i+1) ;
106 face[i].a = index[a];
107 face[i].b = index[b];
108 face[i].c = index[c];
109
110 Node na = node[face[i].a];

111 Node nb = node[face[i].b];
112 Node nc = node[face[i].c];
113 face[i].ab = (na.x-nb.x)*(na.x-nb.x)+(na.y-nb.y)*(na.y-nb.y) ;
114 face[i].bc = (nc.x-nb.x)*(nc.x-nb.x)+(nc.y-nb.y)*(nc.y-nb.y) ;
115 face[i].ca = (na.x-nc.x)*(na.x-nc.x)+(na.y-nc.y)*(na.y-nc.y) ;
116 face[i].A = 0.5*abs((nc.x*(na.y - nb.y) + na.x*(nb.y - nc.y) + nb.x*(nc.y -
na.y))) ;
117 }
118 elem_file.close() ;
119 }
120
121 assignation des valeurs aux frontières

122 void set_BC(Vector<double> &rho, int border, int value){
123 for(int i=ni ; i<n ; i++) if(node[i].b == border) rho[i-ni] = value ;
124 }
125
126 surcharge de l’opérateur de flux pour l’impression de la triangulation

127 friend std ::ostream & operator<<(std ::ostream &flux, const maillage2D &x){
128 flux << ”Noeuds intérieurs :\n” ;
129 for(int i=0; i<x.ni ; i++){
130 flux << i+1 << ” :\t” << x.node[i].x << ’\t’ << x.node[i].y << endl ;
131 }
132 flux << ”Noeuds à la frontière :\n” ;
133 for(int i=x.ni ; i<x.n ; i++){
134 flux << i+1 << ” :\t” << x.node[i].x << ’\t’ << x.node[i].y << ’\t’ << x.
node[i].b << endl ;
135 }
136 flux << ”Triangles :\n” ;
137 for(int i=0; i<x.nf ; i++){
138 flux << i+1 << ” :\t” << x.face[i].a+1 << ’\t’ << x.face[i].b+1 << ’\t’ <<
x.face[i].c+1 << endl ;
139 }
140
141 return flux ;

142 }
143
144 méthode de calcul de la matrice de masse

147 void mass_matrix(SparseMatrix &Mi, SparseMatrix &Mf){
. 148 assert(Mi.rows() == ni) ;
185
Annexe C. Codes
149 assert(Mf.rows() == ni and Mf.columns() == nb) ;

150
151 on boucle sur les faces : chaque face ayant trois liens
152 on doit tenir compte des faces qui ont déjà été couvertes, pour ne pas répéter les liens
153 boucle sur les face
154 for(int i=0; i<nf ; i++){
155 int na = face[i].a ;
156 int nb = face[i].b ;
157 int nc = face[i].c ;
158
159 double aa = face[i].A/6;

160 if(na<ni) Mi.Insert(na,na,aa) ;
161 if(nb<ni) Mi.Insert(nb,nb,aa) ;
162 if(nc<ni) Mi.Insert(nc,nc,aa) ;
163 aa *= 0.5;
164
165 if(na < ni and nb < ni) {Mi.Insert(na,nb,aa) ; Mi.Insert(nb,na,aa) ;}

166 else if(na < ni and nb >= ni) Mf.Insert(na,nb-ni,aa) ;
167 else if(nb < ni and na >= ni) Mf.Insert(nb,na-ni,aa) ;
168
169 if(na < ni and nc < ni) {Mi.Insert(na,nc,aa) ; Mi.Insert(nc,na,aa) ;}

170 else if(na < ni and nc >= ni) Mf.Insert(na,nc-ni,aa) ;
171 else if(nc < ni and na >= ni) Mf.Insert(nc,na-ni,aa) ;
172
173 if(nb < ni and nc < ni) {Mi.Insert(nb,nc,aa) ; Mi.Insert(nc,nb,aa) ;}

174 else if(nb < ni and nc >= ni) Mf.Insert(nb,nc-ni,aa) ;
175 else if(nc < ni and nb >= ni) Mf.Insert(nc,nb-ni,aa) ;
176 }
177 }
178
179 méthode de calcul du laplacien

180 Li : partie intérieure
181 Lf : partie qui couple les noeuds de frontière aux noeuds intérieurs
182 void Laplacian(SparseMatrix &Li, SparseMatrix &Lf){
183 assert(Li.rows() == ni) ;
184 assert(Lf.rows() == ni and Lf.columns() == nb) ;
185
186 on boucle sur les faces : chaque face ayant trois liens
187 on doit tenir compte des faces qui ont déjà été couvertes, pour ne pas répéter les liens
188 boucle sur les face
189 for(int i=0; i<nf ; i++){
190 int na = face[i].a ;
191 int nb = face[i].b ;
192 int nc = face[i].c ;
193
194 double z = -0.25/face[i].A ;

195 if(na<ni) Li.Insert(na, na, z*face[i].bc) ;
196 if(nb<ni) Li.Insert(nb, nb, z*face[i].ca) ;
197 if(nc<ni) Li.Insert(nc, nc, z*face[i].ab) ;
198
199 z *= 0.5;
200
201 double zz = z*(face[i].ab - face[i].bc - face[i].ca) ;

202 if(na < ni and nb < ni) {Li.Insert(na,nb,zz) ; Li.Insert(nb,na,zz) ;}
203 else if(na < ni and nb >= ni) Lf.Insert(na,nb-ni,zz) ;
204 else if(nb < ni and na >= ni) Lf.Insert(nb,na-ni,zz) ;
205
206 zz = z*(face[i].ca - face[i].ab - face[i].bc) ;

207 if(na < ni and nc < ni) {Li.Insert(na,nc,zz) ; Li.Insert(nc,na,zz) ;}
208 else if(na < ni and nc >= ni) Lf.Insert(na,nc-ni,zz) ;
209 else if(nc < ni and na >= ni) Lf.Insert(nc,na-ni,zz) ;
. 210
186
C.3. Autres codes
211 zz = z*(face[i].bc - face[i].ca - face[i].ab) ;

212 if(nb < ni and nc < ni) {Li.Insert(nb,nc,zz) ; Li.Insert(nc,nb,zz) ;}
213 else if(nb < ni and nc >= ni) Lf.Insert(nb,nc-ni,zz) ;
214 else if(nc < ni and nb >= ni) Lf.Insert(nc,nb-ni,zz) ;
215 }
216 }
217
218 #define MIN_AREA 0.0001

219 impression des triangles compatibles avec le programme ”triangle”, pour un éventuel raffinement de
la triangulation
220 psi : solution à une étape donnée
221 rho : vecteur de charge
222 prec : précision requise
223 void print_area_file(Vector<double>&psi, Vector<double>&rho, double prec){
225 filename = name + ”.area” ;
226 ofstream fout(filename.c_str()) ;
227 filename = name + ”.err” ;
228 ofstream fout2(filename.c_str()) ;
229 fout << nf << endl ;
230 for(int i=0; i<nf ; i++){ boucle sur les faces
231 double psi_a, psi_b, psi_c ; valeurs du champs aux trois sommets de la face
232 Face F = face[i];
233 int k = F.a ;
234 if(k < ni) psi_a = psi[k]; else psi_a = rho[k-ni];
235 k = F.b ;
236 if(k < ni) psi_b = psi[k]; else psi_b = rho[k-ni];
237 k = F.c ;
238 if(k < ni) psi_c = psi[k]; else psi_b = rho[k-ni];
239
240 double area ; aire visée à la prochaine étape

241 area = psi_a*psi_a*F.bc + psi_b*psi_b*F.ca + psi_c*psi_c*F.ab + psi_a*psi_b
*(F.ab-F.bc-F.ca) + psi_b*psi_c*(F.bc-F.ab-F.ca)+psi_c*psi_a*(F.ca-F.bc-
F.ab) ;
242 area /= (4*F.A) ;
243 area = prec/area ;
244 fout2 << 0.333333*(node[F.a].x+node[F.b].x+node[F.c].x) << ’\t’ <<
0.333333*(node[F.a].y+node[F.b].y+node[F.c].y) << ’\t’ << area << endl ;
245 if(area < MIN_AREA) area = MIN_AREA ;
246 fout << i << ’\t’ << area << ’\n’ ;
247
248 }
249 fout.close() ;
250 }
251
252 void print(ostream &out, int M, double *psi, double *psif=0L){

253 for(int j=0; j<M ; j++){
254 int offset = j*ni ;
255 for(int i=0; i<ni ; i++) out << node[i].x << ’\t’ << node[i].y << ’\t’ << psi
[i+offset] << endl ;
256 if(psif==0L){
257 for(int i=ni ; i<n ; i++) out << node[i].x << ’\t’ << node[i].y << ’\t’ <<
0 << endl ;
258 }
259 else{
260 offset = j*(n-ni) ;
261 for(int i=ni ; i<n ; i++) out << node[i].x << ’\t’ << node[i].y << ’\t’ <<
psif[i-ni+offset] << endl ;
262 }
263 out << ”\n\n” ;
264 }
. 265 }
187
Annexe C. Codes
266
267 ~maillage2D(){
268 if(att){
269 for(int i=0; i<na ; i++) delete[] att[i];
270 delete[] att ;
271 }
272 if(node) delete[] node ;
273 if(face) delete[] face ;
274 }
275 };
276 #endif
.
Code C.11 : Programme principal pour la solution de l’équation de Laplace : Laplace2D

.cpp
2 #include <string>
4
5 #include ”maillage2D.h”
7
8 résolution de l’équation de Laplace en 2D, conditions aux limites de Dirichlet

9 int main() {
10
12 ofstream fout ;
14
15 fin >> ”grille” >> filename ;

16
17 maillage2D grille(filename) ;
18
19 matrices creuses représentant le laplacien

20 SparseMatrix Li(grille.ni) ; pour les noeuds intérieurs (L I )
21 SparseMatrix Lf(grille.ni,grille.nb) ; couplage intérieur−frontière (L F )
22 cout << ”calcul du laplacien...\n” ;
23 grille.Laplacian(Li,Lf) ;
24
25 cout << ”Solution du problème aux limites...\n” ;

26
27 Vector<double> psi(grille.ni) ; allocation de ψI

28
29 allocation et définition des conditions aux limites

30 Vector<double> psif(grille.nb) ; vecteur de charge ψF
31 int n_cond=0; nombre de conditions aux limites
32 double prec ; facteur de précision requis dans le raffinement de la grille
33 fin >> ”precision” >> prec ;
34 fin >> ”conditions_limites” >> n_cond ;
35 for(int i=0; i<n_cond ; i++){
36 int frontiere ;
37 double val ;
38 fin >> frontiere >> val ;
39 grille.set_BC(psif,frontiere,val) ; assigne les valeurs de ψF à la frontière
40 }
41 fin.close() ;
42
43 on calcule D 2F ψF
44 Vector<double> b(grille.ni) ;
. 45 Lf.mult(b,psif) ;
188
C.3. Autres codes
46 b *= -1.0;
47 Li.ConjugateGradient(b, psi, 1.0e-6) ; méthode du gradient conjugué
48 fout.open(”out.dat”) ;
49 grille.print(fout,1,psi.array(),psif.array()) ;
50 fout.close() ;
51
52 grille.print_area_file(psi, psif, prec) ; imprime un fichier en vue de raffiner la grille

53

55 }
.
Code C.12 : Fonctions cardinales collocation.h
1 #ifndef COLLOCATION_H
2 #define COLLOCATION_H
3
6 #include <string>
10
11 représentation d’une fonction à l’aide des fonctions cardinales

12 class collocation{
13 public :
14 int N ; nombre de points sur la grille
15 double x1 ; début de l’intervalle
16 double L ; largeur de l’intervalle
17 int max_order ; ordre maximum des dérivées dans l’opérateur différentiel
18 int plot_points ; nombre de points pour les graphiques
19 Vector<double> x ; abcisses
20 Matrix<double> C ; matrice des poids
21 Vector<Matrix<double> > D ; matrice des dérivées
22
23 constructeur
24 collocation(string type, int _N, int _max_order, int _np) : N(_N), max_order(
_max_order), plot_points(_np) {
25 x.Alloc(N) ;
26
27 if(type==”gauss_lobatto”){
28 x1 = -1.0;
29 L = 2.0;
30 for(int i=0; i<N ; i++){
31 x[i] = cos(((N-1-i)*M_PI)/(N-1)) ; points de la grille de Gauss−Lobatto
32 }
33 }
34 else if(type==”tchebychev”){
35 x1 = -1.0;
36 L = 2.0;
37 for(int i=0; i<N ; i++){
38 x[i] = cos(((N-i-0.5)*M_PI)/N) ; points de la grille de Tchébychev (points intérieurs)
39 }
40 }
41 else{
42 cout << ”type de grille non reconnu (” << type << ”)\n” ;
43 exit(1) ;
44 }
45 C.Alloc(N,max_order+1) ;
46 D.Alloc(max_order) ;
. 47
189
Annexe C. Codes
48 calcule les matrices de dérivées jusqu’à l’ordre M inclus

49 for(int k=0; k<max_order ; k++) D[k].Alloc(N) ;
50 for(int i=0; i<N ; i++){
51 poids(x[i],max_order) ;
52 for(int k=0; k<max_order ; k++){
53 for(int j=0; j<N ; j++) D[k](i,j) = C(j,k+1) ;
54 }
55 }
56 }
57
58 fonctions cardinales et leurs dérivées

59 routine ”weights” de Numerical Recipes
60 D’arpès Fornberg. Voir http ://www.scholarpedia.org/article/Finite_difference_method
61 z : position
62 m : ordre de la dérivée (0 pour les fonctions cardinales elles−mêmes)
63 void poids(const double z, int m)
64 {
65 assert(m<=max_order) ;
66 double c1=1.0;
67 double c4=x[0]-z ;
68 C.clear() ;
69 C(0,0)=1.0;
70 for (int i=1; i<N ; i++){
71 int mn = (i<m) ? i :m ;
72 double c2=1.0;
73 double c5=c4 ;
74 c4=x[i]-z ;
75 for (int j=0; j0; k--) C(i,k)=c1*(k*C(i-1,k-1)-c5*C(i-1,k))/c2 ;
80 C(i,0) = -c1*c5*C(i-1,0)/c2 ;
81 }
82 for (int k=mn ; k>0; k--) C(j,k)=( c4*C(j,k) - k*C(j,k-1) )/c3 ;
83 C(j,0) *= c4/c3 ;
84 }
85 c1 = c2 ;
86 }
87 }
88
89 sortie de la fonction psi

90 sous forme d’un tableau linéaire contenant les M composantes de la fonction, chaque composante
91 étant inscrite sur une colonne différente du fichier
92 void plot(ostream &fout, double *psi, int M = 1){
93 double dz = L/(plot_points-1) ;
94 double z = x1 ;
95 for(int i=0; i<plot_points ; i++, z += dz){
96 fout << z ;
97 poids(z,0) ;
98 for(int k=0; k<M ; k++){
99 double y = 0.0;
100 for(int j=0; j<N ; j++) y += psi[k*N+j]*C(j,0) ;
101 fout << ’\t’ << y ;
102 }
103 fout << endl ;
104 }
105 }
106
107 sortie des fonctions cardinales (pour fins d’illustration seulement)

108 void plot_cardinal(ostream &fout){
. 109 double dz = L/(plot_points-1) ;
190
C.3. Autres codes
110 double z = x1 ;
112 poids(z,0) ;
113 fout << z ;
114 for(int j=0; j<N ; j++) fout << ’\t’ << C(j,0) ;
115 fout << endl ;
116 }
117 }
118
119 };
120
121 #endif
.
Code C.13 : Classe de fonctions cardinales
1 #ifndef COLLOCATION_PERIODIC_H
2 #define COLLOCATION_PERIODIC_H
3
6 #include <string>
11
12 représentation d’une fonction à l’aide des fonctions cardinales associées aux séries de Fourier
13 class collocation_periodic{
14 public :
15 int N ; nombre de points sur la grille
16 double L ; largeur de l’intervalle
17 int max_order ; ordre maximum des dérivées dans l’opérateur différentiel
18 int plot_points ; nombre de points pour les graphiques
19 Vector<double> x ; abcisses
20 Vector<Matrix<double> > D ; matrice des dérivées
21
22 constructeur
23 collocation_periodic(int _N, double _L, int _max_order, int _np) : N(_N), L(_L)
, max_order(_max_order), plot_points(_np) {
24 x.Alloc(N) ;
25 for(int i=0; i<N ; i++) x[i] = i*2*M_PI/N ;
26 D.Alloc(max_order) ;
27
28 calcule les matrices de dérivées jusqu’à l’ordre M inclus

29 D[0].Alloc(N) ;
30 for(int i=0; i<N ; i++){
31 for(int j=0; j1){
39 D[1].Alloc(N) ;
40 for(int i=0; i<N ; i++){
41 D[1](i,i) = -(1.0+0.5*N*N)/6;
42 for(int j=0; j<i ; j++){
43 double z = sin(0.5*(x[i]-x[j])) ;
44 D[1](i,j) = 0.5/(z*z) ;
. 45 if((i-j+1)%2) D[1](i,j) = -D[1](i,j) ;
191
Annexe C. Codes
46 D[1](j,i) = D[1](i,j) ;
47 }
48 }
49 }
50 for(int j=2; j<max_order ; j++) D[j] = D[j-1]*D[0];
51
52 }
53
54 fonctions cardinales
55 inline double cardinal(int i, double z){
56 return sin(0.5*N*(z-x[i]))/(N*tan(0.5*(z-x[i]))) ;
57 }
58

60 void plot(ostream &fout, double *psi, int M = 1){
62 double z = 0;
64 fout << z ;
65 for(int k=0; k<M ; k++){
66 double y = 0.0;
67 for(int j=0; j<N ; j++) y += psi[k*N+j]*cardinal(j,z) ;
68 fout << ’\t’ << y ;
69 }
70 fout << endl ;
71 }
72 }
73

75 void plot(double *xx, double *yy, double *psi, int M = 1){
77 double z = 1e-8;
79 xx[i] = i*1.0/(plot_points-1) ;
80 for(int k=0; k<M ; k++){
81 double y = 0.0;
82 for(int j=0; j<N ; j++) y += psi[k*N+j]*cardinal(j,z) ;
83 yy[i] = y ;
84 }
85 }
86 }
87
88 sortie des fonctions cardinales

89 void plot_cardinal(ostream &fout){
91 double z = 0;
93 fout << z ;
94 for(int j=0; j<N ; j++) fout << ’\t’ << cardinal(j,z) ;
95 fout << endl ;
96 }
97 }
98
99 };
100
101 #endif
.
Code C.14 : Résolution de l’équation de KdeV
. 2 #include <fstream>
192
C.3. Autres codes

4
5 #ifdef GNUPLOT
6 extern ”C”{
8 }
9 #endif
10
11 #ifdef DISLIN
13 #endif
14
15 #include ”collocation_periodic.h”
17
18 routine qui construit un soliton de large sigma et d’amplitude A centré à A

19 x : grille de points
20 psi : champ auquel on ajoute le soliton
21 void soliton(Vector<double> &x, Vector<double> &psi, double x0, double A, double
sigma){
22 for(int i=0; i<x.size() ; i++){
23 double v = (x[i]-x0)/sigma ;
24 v = 1.0/cosh(v) ;
25 v *= v ;
26 psi[i] += A*v ;
27 }
28 }
29 int main(){
30 Vector<double> psi ; champ
31 int N ; nombre de points de collocation
32 int np ; nombre de points sur le graphique
33 double h ; pas temporel
34 double dt_display ; intervalle d’affichage
36 bool deux_solitons = false ; vrai si la valeur initiale comporte deux solitons
37 bool lineaire = false ; vrai si on modifie l’équation pour la rendre linéaire
38
40 para >> ”N” >> N ;
41 para >> ”plot_points” >> np ;
42 para >> ”h” >> h ;
43 para >> ”temps_de_simulation” >> tmax ;
44 para >> ”intervalle_affichage” >> dt_display ;
45
46 double mu ; paramètre de dispersion dans l’équation KdV

47 double epsilon ; paramètre non linéaire dans l’équation KdV
48 para >> ”mu” >> mu ;
49 para >> ”epsilon” >> epsilon ;
50
52 double sigma ; largeur du paquet d’ondes (espace réel)
53 double x0 ; centre du paquet d’ondes
54 double psi_max ; valeur maximale
55 double ymax ;
56 double ymin ;
57 para >> ”sigma” >> sigma ;
58 para >> ”psi_max” >> psi_max ;
59 para >> ”x0” >> x0 ;
60 para >> ”ymax” >> ymax ;
61 para >> ”ymin” >> ymin ;
62
. 63 if(para==”deux_solitons”) deux_solitons = true ;
193
Annexe C. Codes
64 if(para==”lineaire”) lineaire = true ;

65
66 Matrix<double> evol(N) ;
67 psi.Alloc(N) ;
68 evol.Alloc(N) ;
69 collocation_periodic grille(N, 2*M_PI, 3, np) ; Grille de fonctions cardinales
70
71 soliton(grille.x, psi, x0, psi_max,sigma) ; construction du premier soliton

72 ajout du deuxième soliton
73 if(deux_solitons) soliton(grille.x,psi, x0+2.0, 0.5*psi_max,sigma*1.4142) ;
74

76 #ifdef GNUPLOT
77 int temps_mort ;
78 para >> ”temps_mort” >> temps_mort ;
79 ofstream gout ;
83 gnuplot_cmd(GP,(char *)”set xr [0:2*pi]”) ;
84 gnuplot_cmd(GP,(char *)”set yr [%g :%g]”,ymin,ymax) ;
85 #endif
86 #ifdef DISLIN
87 Dislin g ;
88 int width = 3000;
90 int temps_mort ;
91 para >> ”temps_mort” >> temps_mort ;
92 g.metafl(”xwin”) ;
93 g.page(width,0.7*width) ;
94 g.scrmod(”revers”) ;
95 g.disini() ;
96 g.pagera() ;
97 g.complx() ;
98 g.height(40) ;
99 g.axspos (margin, 0.7*width-margin) ;
100 g.axslen (width-2*margin,0.7*width-2*margin) ;
101 #endif
102
103 para.close() ;
105 for(double t=0.0; t<tmax ; t+= h){
107 output_step++;
108 #ifdef GNUPLOT
110 grille.plot(gout,psi.array()) ;
111 gout.close() ;
112 gnuplot_cmd(GP,(char *)”set title ’t = %g’”,t) ;
113 gnuplot_cmd(GP,(char *)”plot ’tmp.dat’ u 1:2 w l t ’’”) ;
114 usleep(temps_mort) ; temps mort entre les affichages, en microsecondes
115 #endif
116 #ifdef DISLIN
117 double xx[np],yy[np];
118 g.erase() ;
119 g.color(”black”) ;
120 g.pagera() ;
122 g.linwid(5) ;
123 g.graf(0.0, 1, 0.0, 0.25,ymin, ymax, ymin, (ymax-ymin)/4) ;
. 125 sprintf(titre,”t = %3.3g”,t) ;
194
C.3. Autres codes
127 g.title() ;
129 grille.plot(xx,yy,psi.array()) ;
130 g.linwid(10) ;
131 g.curve(xx,yy,np) ;
132 g.endgrf() ;
133 usleep(temps_mort) ;
134 #endif
135 }
136 évolution sur un intervalle de temps h (Crank−Nicholson)
137 Vector<double> xi(N) ;
138 evol.clear() ; U = 0
139 evol += grille.D[0]; U = ∂x
140 if(lineaire == false) evol.mult_diagonal(psi) ; U = u∂x .
141 evol *= epsilon ; U = ϵu∂x
142 evol.mult_add(grille.D[2],mu) ; U = ϵu∂x + µ∂3x
143 evol *= -h*0.5; U = − 12 dt (ϵu∂x + µ∂3x )
144 evol.add_to_diagonal(1.0) ; U = 1 − 12 dt (ϵu∂x + µ∂3x )
145
146 evol.mult_add(psi,xi) ; ξ = (1 + 12 dt L )ψ : évolution vers l’avant de t n vers t n + h/2

147 evol.add_to_diagonal(-2.0) ;
148 evol *= -1.0; maintenant U = (1 − 12 dt L )
149 evol.solve(psi,xi) ; trouve ψ tel que ξ = (1 − 12 dt L )ψ
150 }
151
152 #ifdef GNUPLOT

153 sleep(-1) ; temps mort après le dernier affichage, en secondes
155 #endif
156 #ifdef DISLIN
157 g.disfin() ;
158 #endif
159

161 }
.
Code C.15 : Classe d’observables statistiques : observable.h
1 #ifndef OBSERVABLE_H_
2 #define OBSERVABLE_H_
3
6 #include <cmath>
7 #include <vector>
8

10
11 #define LMAX 256

12 #define MAXFLOOR 32
13 #define MINFLOOR 8
14 #define FLOOR_OFFSET 5
15
16 extern bool observable_verbose ; vrai pour imprimer plus de détails sur l’analyse d’erreur
17
18 class observable{
19 public :
20 vector<double> sum ; sommes des moyennes partielles
. 21 vector<double> sum2 ; sommes des moyennes partielles au carré
195
Annexe C. Codes
22 vector<double> prec ; valeurs précédentes de la moyenne partielle

23 vector<double> delta ; variance partielle
24 vector<int> n ; nombre de moyennes partielles
25 double tau ; temps d’autocorrélation
26
27 double value ; valeur de l’observable pour la configuration courante

28 double moyenne ; moyenne estimée de l’observable
29 double erreur ; erreur estimée de l’observable
30
31 Constructeur
32 observable() {
33 sum.reserve(MAXFLOOR) ;
34 sum2.reserve(MAXFLOOR) ;
35 prec.reserve(MAXFLOOR) ;
36 delta.reserve(MAXFLOOR) ;
37 n.reserve(MAXFLOOR) ;
38 }
39
40 Accumule les statistiques de l’observable par l’analyse logarithmique d’erreur (binning)

41 void collecte(unsigned int &level, double x){
42 if(level < sum.size()){
43 sum[level] += x ;
44 sum2[level] += x*x ;
45 n[level]++;
46 }
47 else{
48 sum.push_back(x) ;
49 sum2.push_back(x*x) ;
50 n.push_back(1) ;
51 }
52 if(n[level]%2 == 0){
53 double ave = 0.5*(prec[level]+x) ;
54 collecte(++level,ave) ;
55 }
56 else prec[level] = x ;
57 }
58
59 Calcule la moyenne et l’erreur sur l’observable

60 void calcul_erreur(){
61 delta.clear() ;
62 int nn = sum.size()-FLOOR_OFFSET ;
63 for(int i=0; i<nn ; i++){
64 double tmp = sum2[i] - sum[i]*(sum[i]/n[i]) ;
65 tmp /= n[i];
66 tmp /= (n[i]-1) ;
67 delta.push_back(sqrt(tmp)) ;
68 }
69 moyenne = sum[sum.size()-1]/n[sum.size()-1];
70 int j = sum.size()-FLOOR_OFFSET-1;
71 erreur = delta[j];
72 tau = delta[j]/delta[0];
73 tau *= tau ;
74 tau -= 1.0;
75 tau *= 0.5;
76
77 if(observable_verbose){
78 cout << endl ;
79 for(int i=0; i<j ; i++) cout << i << ’\t’ << n[i] << ’\t’ << sum[i]/n[i] << ’
\t’ << sum2[i]/n[i] << ’\t’ << delta[i] << endl ;
80 }
81 }
. 82
196
C.3. Autres codes
83 Surcharge l’opérateur de flux

84 friend std ::ostream & operator<<(std ::ostream &flux, const observable &x){
85 flux << x.moyenne << ’\t’ << x.erreur << ’\t’ << x.tau ;
86 return flux ;
87 }
88
89 remet à zéro les sommes partielles

90 void reset(){
91 sum.clear() ;
92 sum2.clear() ;
93 prec.clear() ;
94 delta.clear() ;
95 n.clear() ;
96 }
97 };
98
99 #endif
.
Code C.16 : Classe de modèle statistique : Ising.h
1 #ifndef ISING_H_
2 #define ISING_H_
3
6 #include <cmath>
7 #include <vector>
8 #include ”Random.h”
9 #include ”observable.h”
10

12
13 #ifdef GNUPLOT
14 extern ”C”{
16 }
17 #endif
18
19 class Ising{
20 public :
21 int L ; nombre de sites sur un côté du carré
22 double h ; champ magnétique
23 int LL ; = L*L ;
24 observable E ; énergie
25 observable M ; aimantation
26 observable *corr ; fonction de corrélation
27 Random R ; générateur de nombre aléatoire
28 char **s ; variables d’état (tableau 2D)
29 double T ; température (Tc = 2/(ln(1+\sqrt2)) = 2.2691853142130221)
30
31 constructeur et initialisation
32 Ising(int _L, double _h) : L(_L), h(_h){
33 assert(L > 0 and L <= LMAX) ;
34 s = new char*[L];
35 for(int i=0; i<L ; i++) s[i] = new char[L];
36
37 LL = L*L ;
38 corr = new observable[L/2];
39
40 configuration initiale aléatoire

. 41 for(int x=0; x<L ; x++){
197
Annexe C. Codes
42 for(int y=0; y<L ; y++) s[x][y] = R.integer()%2;

43 }
44 energie() ;
45
46 }
47
48 Calcule l’énergie et l ’ aimantation de la configuration

49 void energie(){
50 int e = 0;
51 int m = -LL ;
52 for(int x=0; x<L ; x++){
53 for(int y=0; y<L ; y++){
54 if((s[x][y]^s[(x+1)%L][y])&1) e-- ;
55 else e++;
56
57 if((s[x][y]^s[x][(y+1)%L])&1) e-- ;
58 else e++;
59
60 if(s[x][y]) m += 2;
61 }
62 }
63 M.value = (double)m ;
64 E.value = -(double)e - h*m ;
65 }
66
67 Changement d’énergie obtenu en inversant le spin à (x,y)

68 double delta(int x, int y){
69 int D ;
70
71 if(s[x][y]) D = 2*h ;
72 else D = -2*h ;
73
74 if((s[x][y]^s[(x+1)%L][y])&1) D-- ;
75 else D++;
76
77 if((s[x][y]^s[x][(y+1)%L])&1) D-- ;
78 else D++;
79
80 if((s[x][y]^s[(x+L-1)%L][y])&1) D-- ;
81 else D++;
82
83 if((s[x][y]^s[x][(y+L-1)%L])&1) D-- ;
84 else D++;
85
86 return(2.0*D) ;
87 }
88
89 Met à jour la configuration par l’algorithme de Metropolis

90 void update(){
91 choisir le spin à retourner
92 int xy = R.integer()%LL ;
93 int x = xy/L ;
94 int y = xy%L ;
95 double del = delta(x,y) ;
96
97 bool flip = false ;

98
99 if(del < 0) flip = true ; le renversement est accepté

100 else{
101 if(R.uniform() < exp(-del/T)) flip = true ; le renversement est accepté
102 }
. 103
198
C.3. Autres codes
104 if(flip){
105 s[x][y]^=1; renverse le spin
106 E.value += del ;
107 if(s[x][y]&1) M.value += 2.0;
108 else M.value -= 2.0;
109 }
110 }
111
112 Effectue la simulation, incluant le réchauffement.

113 nmesure : nombre de mesures
114 intervalle : intervalle entre les mesures
115 rechauffement : période de réchauffement
116 T : température
117 void simulate(unsigned int log2N, int intervalle, int rechauffement, double _T){
118 T = _T ;
119 if(log2N < MINFLOOR) log2N = MINFLOOR ;
120 int L2 = L/2;
121
122 #ifdef GNUPLOT

123 ofstream gout ;
127 gnuplot_cmd(GP,(char *)”set xr [0:%d]”,L-1) ;
128 gnuplot_cmd(GP,(char *)”set yr [0:%d]”,L-1) ;
129 gnuplot_cmd(GP,(char *)”unset tics”) ;
130 gnuplot_cmd(GP,(char *)”set size ratio 1”) ;
132 #endif
133
134 for(int i=0; i<rechauffement ; i++) update() ;

135
136 E.reset() ;
137 M.reset() ;
138 for(int j=0; j<L2 ; j++) corr[j].reset() ;
139 while(1){
140 for(int j=0; j<intervalle ; j++) update() ;
141 unsigned int level=0;
142 E.collecte(level,E.value) ;
143 level=0; M.collecte(level,M.value) ;
144 for(int j=0; j<L2 ; j++){
145 corr[j].value = (2*s[0][0]-1)*(2*s[j][0]-1) ;
146 level=0;
147 corr[j].collecte(level,corr[j].value) ;
148 }
149
150 if(level==log2N) break ;

151 #ifdef GNUPLOT
153 plot(gout) ;
154 gout.close() ;
155 gnuplot_cmd(GP,(char *)”set title ’T = %2.3f, M = %1.3f’”,T,M.value/LL) ;
156 gnuplot_cmd(GP,(char *)”plot ’tmp.dat’ i 0 pt 5 ps 2 lc 0”) ;
157 usleep(50000) ;
158 #endif
159 }
160 E.calcul_erreur() ;
161 M.calcul_erreur() ;
162 for(int j=0; j<L2 ; j++) corr[j].calcul_erreur() ;
163
164 int nn = E.sum.size()-FLOOR_OFFSET-1;

. 165
199
Annexe C. Codes
166 ofstream fout(”out.dat”,ios ::app) ;

167 cout << T << ’\t’ << h << ’\t’ << (1<<nn) << ’\t’ << E << ’\t’ << M << endl ;
168 fout << ”# T\th\tN\tE\tdE\ttau(E)\tM\tdM\ttau(M)\n” ;
169 fout << T << ’\t’ << h << ’\t’ << (1<<nn) << ’\t’ << E << ’\t’ << M << endl ;
170 fout.close() ;
171 fout.open(”corr.dat”,ios ::app) ;
172 fout << ”\n\n# T\th\tN\tE\tdE\ttau(E)\tM\tdM\ttau(M)\n” ;
173 fout << ”# ” << T << ’\t’ << h << ’\t’ << (1<<nn) << ’\t’ << E << ’\t’ << M <<
endl ;
174 fout << ”#i\tcorr\tdcorr\ttau(corr)\n” ;
175 for(int j=0; j<L2 ; j++) fout << j << ’\t’ << corr[j] << endl ;
176 fout.close() ;
177 }
178
179 imprime la configuration courante à l’écran

180 void plot(ostream &fout){
181 fout <<”\n\n” ;
182 for(int x=0; x<L ; x++){
183 for(int y=0; y<L ; y++){
184 if(s[x][y]&1) fout << x << ’\t’ << y << ’\n’ ;
185 }
186 }
187 fout <<”\n\n” ;
188 for(int x=0; x<L ; x++){
189 for(int y=0; y<L ; y++){
190 if(!s[x][y]) fout << x << ’\t’ << y << ’\n’ ;
191 }
192 }
193 fout <<”\n\n” ;
194 }
195
196 destructeur
197 ~Ising(){
198 for(int i=0; i<L ; i++) delete[] s[i];
199 delete[] s ;
200 }
201 };
202
203 #endif
.
Code C.17 : Programme principal : Ising.cpp
3
5 #include ”Ising.h”
7
8 bool observable_verbose ;
9
10 int main() {
11
12 double T1,T2,delta_T,h ;
13 int L ;
14 unsigned long int log2N ;
15 int intervalle ;
16 int rechauffement ;
17
. 19
200
C.3. Autres codes
20 fin >> ”L” >> L ;

21 fin >> ”log2N” >> log2N ;
22 fin >> ”intervalle” >> intervalle ;
23 fin >> ”rechauffement” >> rechauffement ;
24 fin >> ”temperature_initiale” >> T1 ;
25 fin >> ”temperature_finale” >> T2 ;
26 fin >> ”delta_T” >> delta_T ;
27 fin >> ”h” >> h ;
28 if(fin==”verbose”) observable_verbose = true ;
29
30 assert(T1 > 0) ;
31 assert(T2 > 0) ;
32
33 fin.close() ;
34
35 cout << ”Simulation du modèle d’Ising 2D sur un réseau ” << L << ” x ” << L <<
endl ;
36 cout << ”Analyse d’erreur logarithmique à ” << log2N << ” niveaux.” << endl ;
37
38 Ising systeme(L,h) ;
39 if(T1<T2) for(double T=T1 ; T <= T2 ; T += delta_T) systeme.simulate(log2N,
intervalle, rechauffement, T) ;
40 else for(double T=T1 ; T >= T2 ; T -= delta_T) systeme.simulate(log2N, intervalle,
rechauffement, T) ;
41

43 }
.
Code C.18 : Simulation du plasma 1D (plasma.cpp)
3 #include <cmath>
4
5 #include <gsl/gsl_fft_real.h>
6 #include <gsl/gsl_fft_halfcomplex.h>
7 #include <gsl/gsl_rng.h>
8 #include <gsl/gsl_randist.h>
12

14
15 #ifdef GNUPLOT
16 extern ”C”{
18 }
19 #endif
20
21 #ifdef DISLIN
23 #endif
24
25 int main(){
26
28
29 int log2M ; fin >> ”log2M” >> log2M ; logarithme en base 2 du nombre de points de grille
30 int M = 1 << log2M ; nombre de points = 2^log2M
. 31 int N ; fin >> ”N” >> N ; nombre de particules
201
Annexe C. Codes
32 double L ; fin >> ”L” >> L ; longueur de l’intervalle périodique

33 double h ; fin >> ”h” >> h ; pas temporel
34 double T ; fin >> ”T” >> T ; temps de simulation
35 double v0 ; fin >> ”v0” >> v0 ; vitesse caractéristique des faisceaux opposés
36 double dv0 ; fin >> ”dv0” >> dv0 ; écart−type de la distribution des vitesses
37 double gamma ; fin >> ”gamma” >> gamma ; amortissement
38 double dt_display ; fin >> ”intervalle_affichage” >> dt_display ; intervalle entre les
affichages
39
40 double a = L/M ; pas de réseau

41 double ia = 1.0/a ; pas de réseau inverse
42 Vector<double> rho(M) ; tableau contenant la densité normalisée
43 Vector<double> phi(M) ; tableau contenant le potentiel électrique normalisé
44 Vector<double> E(M) ; tableau contenant le champ électrique normalisé
45 Vector<double> x(N) ; tableau contenant les positions
46 Vector<double> v(N) ; tableau contenant les vitesses
47 Vector<double> F(N) ; tableau contenant les accélérations
48
49 initialisation des positions et des vitesses des particules

50 gsl_rng *R ;
51 R = gsl_rng_alloc(gsl_rng_default) ;
52 for(int i=0; i<N ; i++){
53 x[i] = gsl_rng_uniform(R)*L ;
54 v[i] = (1-2*(i%2))*v0 + gsl_ran_gaussian(R,dv0) ;
55 }
56
57 ofstream gout ;
58 #ifdef GNUPLOT
61 int taille = 800;
62 gnuplot_cmd(GP,(char *)”set term x11 size %d,%d title ’Plasma’”,taille,taille) ;
63 gnuplot_cmd(GP,(char *)”set xr [%g :%g]”,0.0,L) ;
64 gnuplot_cmd(GP,(char *)”set yr [%g :%g]”,-2.5*v0,2.5*v0) ;
66 #endif
67 #ifdef DISLIN
68 Dislin g ;
69 int width = 3000;
70 int height = width ;
72 g.metafl (”xwin”) ;
73 g.page(width,height) ;
74 g.scrmod (”revers”) ;
75 g.disini () ;
76 g.pagera () ;
77 g.complx () ;
78 g.height(40) ;
79 g.errmod(”CHECK”,”OFF”) ;
80 Vector<double> xx(M) ;
81 for(int i=0; i<M ; i++) xx[i] = i*a ;
82 double r0 = 2.0;
83
84 #endif
85
86 boucle sur les temps

88 for(double t=0.0; t<=T ; t+=h){
89
90 calcul de la densité d’électrons

91 rho.clear() ;
. 92 double LNaa = L/(N*a*a) ;
202
C.3. Autres codes
93 for(int i=0; i<N ; i++){

94 int j = x[i]*ia ; conversion implicite d’un réel en entier
95 assert(j<M and j>= 0) ;
96 int jn = ((j+1)+M)%M ;
97 rho[j] += ((j+1)*a-x[i])*LNaa ;
98 rho[jn] += (x[i]-j*a)*LNaa ;
99 }
100
101 calcul du potentiel électrique par TdFR

102 phi = rho ;
103 gsl_fft_real_radix2_transform(phi.array(), 1, M) ; transformée directe
104 phi[0] = 0.0; condition de neutralité
105 int m = M/2;
106 double k0 = 2.0*M_PI/L ;
107 for(int i=1; i<=m ; i++){ solution de l’équation de Poisson
108 double z = i*k0 ;
109 z = 1.0/(z*z) ;
110 phi[i] *= z ;
111 phi[M-i] *= z ;
112 }
113 gsl_fft_halfcomplex_radix2_inverse(phi.array(),1,M) ; transformée inverse
114
115 calcul du champ électrique

116 int M1 = M-1;
117 for(int i=1; i<M1 ; i++) E[i] = -0.5*ia*(phi[i+1]-phi[i-1]) ;
118 E[0] = -0.5*ia*(phi[1]-phi[M1]) ;
119 E[M1] = -0.5*ia*(phi[0]-phi[M1-1]) ;
120
121 propagation des particules (méthode de Verlet)

122 double z = 0.5*h*h ;
123 double z1 = 0.5*h ;
124 for(int i=0; i<N ; i++){
125 x[i] += v[i]*h + F[i]*z ; avancement des positions
126 if(x[i] > L) x[i] -= L ; imposition des conditions aux limites périodiques
127 if(x[i] < 0.0) x[i] += L ;
128
129 double X = x[i]; calcul de la force

130 int j = X*ia ;
131 assert(j<M and j>= 0) ;
132 int jn = ((j+1)+M)%M ;
133 double F0 = F[i];
134 F[i] = ia*(((j+1)*a-X)*E[j] + (X-j*a)*E[jn]) ; interpolation linéaire
135 v[i] += (F[i]+F0)*z1 -v[i]*(h*gamma) ; calcul de la vitesse au temps t+h
136 }
137
138 affichage périodique des résultats

140 output_step++;
141 #ifdef GNUPLOT
142 gout.open(”out.dat”) ;
143 for(int i=0; i<N ; i++) gout << x[i] << ’\t’ << v[i] << endl ;
144 gout << ”\n\n” ;
145 gout.close() ;
146 usleep(20000) ;
147 gnuplot_cmd(GP,(char *)”set title ’t = %2.3f’”,t) ;
148 gnuplot_cmd(GP,(char *)”plot ’out.dat’ w d”) ;
149 usleep(20000) ;
150 #endif
151 #ifdef DISLIN
152
153 g.erase() ;
. 154 g.color(”blue”) ;
203
Annexe C. Codes
155 g.axspos(margin, 0.7*height-margin) ;

156 g.axslen(width-2*margin,0.7*height-2*margin) ;
157 g.graf(0.0, L, 0.0, L/4, -3*v0, 3*v0, -3*v0, v0) ;
159 sprintf(titre,”Ecoulement d’un plasma1D. t = %3.3g”,t) ;
161 g.title() ;
163 g.incmrk(-1) ;
164 g.marker(21) ;
165 g.hsymbl(4) ;
166 g.curve(x.array(),v.array(),N) ;
167 g.endgrf() ;
168
170 g.axspos(margin, height-margin) ;
171 g.axslen(width-2*margin,0.3*height-2*margin) ;
172 g.graf(0.0, L, 0.0, L/4, 0, r0, 0, r0/4) ;
173 g.titlin(”Densite normalisee”,4) ;
174 g.title() ;
175 g.incmrk(0) ;
176 g.rline(0,1,L,1) ;
177 g.color(”green”) ;
178 g.curve(xx.array(),rho.array(),M) ;
179 g.endgrf() ;
180 usleep(10000) ;
181 #endif
182 }
183
184 }
185 gout.open(”out.dat”) ;
186 for(int i=0; i<N ; i++) gout << x[i] << ’\t’ << v[i] << endl ;
187 gout.close() ;
188

190 }
.
Code C.19 : Recuit simulé (recuit.cpp)
3
8
9 #define GNUPLOT
10
11 #ifdef GNUPLOT
12 extern ”C”{
14 }
15 #endif
16
17 Random R ;
18

20
21 classe décrivant la configuration dans le problème du commis−voyageur

. 22 class voyageur{
204
C.3. Autres codes
23 public :
24 int n ; nombre de villes
25 double E ; longueur du chemin courant
26 Vector<Vector2D>x ; position des villes
27 Vector<int> I ; ordre de position des villes (permutation de la séquence 0..n−1)
28 Vector<int> I0 ; ordre de position des villes (permutation de la séquence 0..n−1)
29 Matrix<double> dist ;
30
31 positions distribuées sur une grille régulière, avec bruit

32 void init(int sn, double noise){
33 n = sn*sn ;
34 x.Alloc(n) ;
35 int k=0;
36 for(int i=0; i<sn ; i++){
37 for(int j=0; j<sn ; j++){
38 x[k++] = Vector2D(i+noise*(2*R.uniform()-1),j+noise*(2*R.uniform()-1)) ;
39 }
40 }
41 consol() ;
42 }
43
44 lecture des positions à partir d’un fichier

45 void init(istream &fin){
46 fin >> n ;
47 x.Alloc(n) ;
48 for(int i=0; i<n ; i++) fin >> x[i];
49 consol() ;
50 }
51
52 conclusion de l’initialisation
53 void consol(){
54 I.Alloc(n) ;
55 for(int i=0; i<n ; i++) I[i] = i ; initialisation du chemin
56 int np = 5*n ;
57 for(int i=0; i<np ; i++){ mélange aléatoire
58 int i1 = R.integer()%n ;
59 int i2 = R.integer()%n ;
60 int tmp = I[i1];
61 I[i1] = I[i2];
62 I[i2] = tmp ;
63 }
64
65 dist.Alloc(n) ;
66 for(int i=0; i<n ; i++){
67 for(int j=0; j<i ; j++){
68 dist(i,j) = dist(j,i) = (x[i]-x[j]).norm() ;
69 }
70 }
71 E = energie() ;
72 I0 = I ;
73 }
74
75 calcul de la fonction ”énergie” E (x)

76 double energie(){
77 double e=0.0;
78 for(int i=1; i<n ; i++) e += dist(I[i],I[i-1]) ;
79 e += dist(I[0],I[n-1]) ;
80 return e ;
81 }
82
83 mise à jour de la configuration à une température T

. 84 void update(double T){
205
Annexe C. Codes
85 int i0,i1,i2,i3 ;
86 i1 = R.integer()%n ; choix aléatoire d’une première ville (indice i )
87 int diff = floor(-(n/5)*log(R.uniform())) ; choix d’une distance
88 i2 = (i1 + diff + n)%n ; position de la deuxième ville (indice j )
89 if(i2==i1) return ;
90 else if(i2<i1){
91 i0 = i1 ; i1 = i2 ; i2 = i0 ;
92 }
93 if(i2-i1 >= n-2) return ;
94 i0 = (i1+n-1)%n ; position de la ville d’incide i − 1
95 i3 = (i2+1)%n ; position de la ville d’incide j + 1
96 différence d’énergie après la section et le recollage inversé
97 double deltaE = dist(I[i0],I[i2])+dist(I[i1],I[i3])-dist(I[i0],I[i1])-dist(I[
i2],I[i3]) ;
98
99 bool flip = false ;

100
101 if(deltaE < 0) flip = true ; le changement est accepté

102 else if(R.uniform() < exp(-deltaE/T)) flip = true ; le renversement est accepté
103
104 if(flip){
105 E += deltaE ;
106 recollage du segment sectionné
107 if(i1<i2) for(int i=i1 ; i<=i2 ; i++) I[i] = I0[i2+i1-i];
108 else for(int i=i2 ; i<=i1 ; i++) I[i] = I0[i2+i1-i];
109 I0 = I ;
110 }
111 }
112
113 friend std ::ostream & operator<<(ostream& flux, const voyageur& X){
114 for(int i=0; i<X.n ; i++) flux << X.x[X.I[i]].x << ’\t’ << X.x[X.I[i]].y << ’\n
’;
115 flux << X.x[X.I[0]].x << ’\t’ << X.x[X.I[0]].y << ’\n’ ;
116 return flux ;
117 }
118
119 identifie les bornes d’un graphique des villes (positions maximales et minimales)
120 void bornes(Vector2D &x1, Vector2D &x2){
121 x2 = Vector2D(-1e6,-1e6) ;
122 x1 = Vector2D(1e6,1e6) ;
123 for(int i=0; i<n ; i++){
124 if(x[i].x > x2.x) x2.x = x[i].x ;
125 if(x[i].y > x2.y) x2.y = x[i].y ;
126 if(x[i].x < x1.x) x1.x = x[i].x ;
127 if(x[i].y < x1.y) x1.y = x[i].y ;
128 }
129 }
130
131 };
132
133 int main() {

134
135 double T1,T2,epsilon,noise ;

136 int n,m ;
137 ofstream fout ;
138 bool carre = false ;
139
140 fstream fin(”para.dat”) ; lecture des paramètres

141 fin >> ”n” >> n ;
142 fin >> ”m” >> m ;
143 fin >> ”temperature_initiale” >> T1 ;
. 144 fin >> ”temperature_finale” >> T2 ;
206
C.3. Autres codes
145 fin >> ”epsilon” >> epsilon ;

146 fin >> ”noise” >> noise ;
147 if(fin == ”carre”) carre = true ;
148 fin.close() ;
149
150 assert(T1 > 0) ;

151 assert(T2 > 0 and T2 < T1) ;
152 assert(epsilon > 0.001 and epsilon < 0.5) ;
153 assert(m>0) ;
154
155 cout << ”Recuit simulé” << endl ;

156
157 voyageur X ; création d’une instance du commis−voyageur

158 if(carre) X.init(n,noise) ;
159 else{
160 fin.open(”villes.dat”) ;
161 X.init(fin) ;
162 fin.close() ;
163 }
164
165 cout << ”longueur initiale : ” << X.E << endl ;

166
167 #ifdef GNUPLOT

168 ofstream gout ;
169 Vector2D x1,x2 ;
170 X.bornes(x1,x2) ;
174 gnuplot_cmd(GP,(char *)”set xr [%f :%f]”,x1.x-0.5,x2.x+0.5) ;
175 gnuplot_cmd(GP,(char *)”set yr [%f :%f]”,x1.y-0.5,x2.y+0.5) ;
176 gnuplot_cmd(GP,(char *)”unset tics”) ;
177 gnuplot_cmd(GP,(char *)”set size ratio 1”) ;
179 #endif
180
181 boucle de refroidissement

182 for(double T=T1 ; T > T2 ; T *= (1-epsilon)){
183 for(int i=0; i<m ; i++) X.update(T) ; m mises à jour par valeur de T
184 #ifdef GNUPLOT
185 fout.open(”tmp.dat”) ;
186 fout << X << endl ;
187 fout.close() ;
188 gnuplot_cmd(GP,(char *)”set title ’T = %2.3f, L = %1.3f’”,T,X.E) ;
189 gnuplot_cmd(GP,(char *)”plot ’tmp.dat’ w lp pt 5 ps 1 lw 2”) ;
190 usleep(5000) ;
191 #endif
192 }
193 #ifdef GNUPLOT
194 sleep(5) ;
195 #endif
196
197 cout << ”longueur finale : ” << X.E << ” = ” << X.energie() << endl ;
198
199 fout.open(”out.dat”) ;
200 fout << X << endl ;
201 fout.close() ;
202

204 }
.
207
Bibliographie
[AS64] M. Abramowitz and I.A. Stegun. Handbook of mathematical functions with formulas,
graphs, and mathematical tables. Dover publications, 1964.
[AT10] Vinay Ambegaokar and Matthias Troyer. Estimating errors reliably in monte carlo simu-
lations of the ehrenfest model. Am. J. Phys., 78 :150, 2010.
[BB01] J.P. Boyd and J.P. Boyd. Chebyshev and Fourier spectral methods. Dover Pubns, 2001.
[CD98] Shiyi Chen and Gary D. Doolen. Lattice Boltzmann method for fluid flows. Annu. Rev.
Fluid Mech., 30 :329–364, 1998.
[Cha] L. Champaney. Méthodes numériques pour la mécanique. Notes de cours, Université de
Versailles, St-Quentin en Yvelines.
[DD01] H.M. Deitel and P.J. Deitel. Comment programmer en C+. Éditions R. Goulet, 2001.
[Fit] Richard Fitzpatrick. Computational physics. Lecture notes, University of Texas at Austin.
[For98] B. Fornberg. Calculation of weights in finite difference formulas. SIAM review, 40(3) :685–
691, 1998.
[For08] A. Fortin. Analyse numérique pour ingénieurs. Presses inter Polytechnique, 2008.
[GO89] Gene H. Golub and Dianne P. O’Leary. Some history of the conjugate gradient and lanczos
algorithms : 1948-1976. SIAM Review, 31(1) :pp. 50–102, 1989.
[GT88] H. Gould and J. Tobochnik. An introduction to computer simulation methods : applications
to physical systems. Addison-Wesley Reading (MA), 1988.
[HL97] Xiaoyi He and Li-Shi Luo. Theory of the lattice boltzmann method : From the boltzmann
equation to the lattice boltzmann equation. Phys. Rev. E, 56(6) :6811–6817, Dec 1997.
[LPB08] Rubin H. Landau, Manuel José Páez, and Cristian C. Bordeianu. A survey of computational
physics. Princeton University Press, 2008.
[Mac] Angus MacKinnon. Computational physics — 3rd/4th year option. Lecture notes, Imperial
College, London.
[Pai72] C.C. Paige. Computational variants of the Lanczos method for the eigenproblem. J. Inst.
Maths Applics, 10 :373–381, 1972.
[Pai80] C.C. Paige. Accuracy and effectiveness of the Lanczos algorithm for the symmetric eigen-
problem. Linear algebra and its applications, 34 :235–258, 1980.
[PTVF07] W.H. Press, S.A. Teukolsky, W.T. Vetterling, and B.P. Flannery. Numerical Recipes, the art
of scientific computing. Cambridge, 2007.
[SB02] J. Stoer and R. Bulirsch. Introduction to numerical analysis. Springer, 2002.
209

PHQ405 A4

Transféré par

Droits d'auteur :

Formats disponibles

PHQ405 A4

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

PHQ405 A4

Transféré par

Droits d'auteur :

Formats disponibles

MÉTHODES NUMÉRIQUES

1 Rappels de programmation scientiﬁque 9

2 Équations diﬀérentielles ordinaires 19

3 Représentations des fonctions 33

3.2.2 Quadratures gaussiennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

4 Problèmes aux limites 53

5 Équations aux dérivées partielles dépendant du temps 71

7 Dynamique des ﬂuides 103

7.1 Équations fondamentales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

8 Équations non linéaires et optimisation 115

A Opérations matricielles 129

B Calcul Parallèle 141

1.1 Classe de vecteurs en 3D : Vector3D.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.1 Approche numérique aux problème physiques

1.2 Représentation des nombres sur ordinateur

1.2.1 Nombres entiers

57 = 1110012 2532 = 1001111001002 (1.1)

1.2.2 Nombres à virgule ﬂottante

x → ±b p b p−1 . . . b 1 × 2±e q e q−1 ...e 1 (1.2)

x → ±1. f × 2e−decal. (1.3)

où f est la partie fractionnaire de la mantisse et où un décalage est ajouté à l’exposant e . L’exposant e

avec 15 chiﬀres signiﬁcatifs en base 10.

1.2.3 Erreurs d’arrondi

Exemple 1.1 : Erreur d’arrondi dans une addition simple

Nom type octets

7 + 1.0 × 10−7 = 7 (simple précision) (1.8)

1.3 Programmation par objets

1.3.1 Types fondamentaux en C++

1.3.2 Exemple d’objet : vecteurs en trois dimensions

Code 1.1 : Classe de vecteurs en 3D : Vector3D.h

6 using namespace std ;

38 multiplication par une constante

54 friend std ::istream & operator>>(std ::istream &flux, Vector3D &x){

66 Vector3D vector_product(const Vector3D &A, const Vector3D &B)

71 Vector3D operator *(double &c, Vector3D &A)

1 Vector3D operator+(const Vector3D &p, const Vector3D &q){

Test de l’utilisation de la classe Vector3D

Code 1.2 : Programme principal utilisant la classe Vector3D

9 cout << ”Test de la classe Vector3D” << endl ;

15 cout << ”Somme A+B = ” << A+B << endl ;

1.3.3 Avantages de la programmation par objet

1 double f(double x, double *params){ return(params[0]*x+params[1]) ;}

3 double integrate(double (*F)(double x, double *params), double x1, double x2){

Au lieu de procéder ainsi, on peut introduire une structure comme suit :

14 func F(0.1,3.0) ; instance du foncteur

A Mettez en place le programme Vector3D.cpp dans l’environnement de programmation de votre choix.

1.4 Autres outils

1.4.1 Environnement de développement

1.4.2 Serveurs de calcul

1.4.3 Visualisation des données

En déﬁnissant les variables x 1 = y et x 2 = ẏ , cette équation peut être ramenée au système

qui est bien de la forme (2.1) où f 1 = f et f 2 (x, t ) = x 2 .

2.1 Méthode d’Euler

2.1.1 Précision de la méthode d’Euler

2.1.2 Stabilité de la méthode d’Euler

où la matrice M possède les composantes suivantes :

et est évaluée au temps t n .

1. Les éléments du vecteur xn sont notés x α,n , où α = 1, 2, . . . , N .

Exemple 2.1 : Équation linéaire à une variable

1 double f(double x, double params){ return(params[0]x+params[1]) ;}

3 double integrate(double (F)(double x, double params), double x1, double x2){