La boˆıte `a outils de la ´ PHYSIQUE NUMERIQUE Licence de physique L3 Physique fondamentale et PHYTEM Universit´e Pierre et Marie Curie Paris-6
—
ENS-Cachan
Ph. Depondt1 Ann´ee 2008-2009
1
INSP (Institut des NanoSciences de Paris), CNRS UMR 7588 & Universit´e P. et M. Curie Paris-6. Contact :
[email protected]
2
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
Table des mati` eres 1 Introduction 1.1 Des m´ethodes num´eriques, pour quoi 1.1.1 Quelques jalons. . . . . . . . . 1.1.2 . . . et quelques exemples. . . 1.2 Plan succinct. . . . . . . . . . . . . .
faire ? . . . . . . . . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
2 Notions pratiques de FORTRAN95. 2.1 Qu’est-ce qu’un langage de programmation ? . . . . . . . . . . 2.2 Notions ´el´ementaires. . . . . . . . . . . . . . . . . . . . . . . . 2.2.1 Instructions. . . . . . . . . . . . . . . . . . . . . . . . 2.2.2 D´eclarations. . . . . . . . . . . . . . . . . . . . . . . . 2.2.3 Op´erations ´el´ementaires sur les nombres. . . . . . . . . 2.3 Premi`eres boucles. . . . . . . . . . . . . . . . . . . . . . . . . 2.3.1 Pour quoi faire ? . . . . . . . . . . . . . . . . . . . . . 2.3.2 Pratiquement. . . . . . . . . . . . . . . . . . . . . . . . 2.3.3 Boucles imbriqu´ees . . . . . . . . . . . . . . . . . . . . 2.3.4 Boucles munies d’un nom . . . . . . . . . . . . . . . . 2.4 Conditions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5 Entr´ees-sorties. . . . . . . . . . . . . . . . . . . . . . . . . . . ´ 2.5.1 Ecran et clavier. . . . . . . . . . . . . . . . . . . . . . 2.5.2 Les fichiers. . . . . . . . . . . . . . . . . . . . . . . . . 2.5.3 Les formats. . . . . . . . . . . . . . . . . . . . . . . . . 2.6 Les fonctions intrins`eques. . . . . . . . . . . . . . . . . . . . . 2.7 Autres boucles. . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7.1 do while . . . . . . . . . . . . . . . . . . . . . . . . . 2.7.2 Boucles infinies : exit et cycle. . . . . . . . . . . . . 2.7.3 Boucles implicites. . . . . . . . . . . . . . . . . . . . . 2.8 Tableaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.8.1 D´eclaration . . . . . . . . . . . . . . . . . . . . . . . . 2.8.2 Manipulation globale de tableaux . . . . . . . . . . . . 2.8.3 Fonctions intrins`eques et tableaux . . . . . . . . . . . 2.8.4 Allocation dynamique de m´emoire . . . . . . . . . . . 2.9 Fonctions et sous-programmes. . . . . . . . . . . . . . . . . . 2.9.1 Les function. . . . . . . . . . . . . . . . . . . . . . . 2.9.2 Et les subroutine. . . . . . . . . . . . . . . . . . . . . 2.9.3 L’intention . . . . . . . . . . . . . . . . . . . . . . . . 2.9.4 La mise en commun de variables. . . . . . . . . . . . . 2.9.5 Mettre un nom de sous-programme comme argument. 2.9.6 Les biblioth`eques. . . . . . . . . . . . . . . . . . . . . 2.10 Les commentaires. . . . . . . . . . . . . . . . . . . . . . . . . 2.11 Une instruction sur plusieurs lignes. . . . . . . . . . . . . . . 2.12 Les chaˆınes de caract`eres. . . . . . . . . . . . . . . . . . . . . 2.12.1 D´eclaration . . . . . . . . . . . . . . . . . . . . . . . . 2.12.2 Op´erations sur les chaˆınes . . . . . . . . . . . . . . . . 2.12.3 Conversion chaˆıne ⇔ nombres . . . . . . . . . . . . . . 2.13 D´etection de fin de fichier. . . . . . . . . . . . . . . . . . . . . 2.14 FORTRAN77-90-95 : filiation et diff´erences. . . . . . . . . . . 2.14.1 kind . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.14.2 Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . 2.14.3 Objets de type d´eriv´e. . . . . . . . . . . . . . . . . . . 2.14.4 Pointeurs. . . . . . . . . . . . . . . . . . . . . . . . . . 3
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . .
7 8 8 10 13
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15 15 17 17 19 20 20 20 21 21 21 21 23 23 23 24 25 25 25 25 26 26 26 27 28 29 30 30 31 31 31 32 32 33 34 34 34 34 34 35 35 36 36 37 38
4
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
2.14.5 R´ecursivit´e. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Un prototype de TP 3.1 Introduction. . . . . . . . . . . . . . . . 3.2 L’´equation logistique. . . . . . . . . . . . 3.2.1 De la multiplication des insectes. ´ 3.2.2 Etude pr´ealable. . . . . . . . . . ´ 3.2.3 Etude num´erique. . . . . . . . .
38
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
41 41 41 41 41 42
4 M´ ethodes num´ eriques. 4.1 Recherche des z´eros d’une fonction. . . . . . . . . . . . . . . . . . . . . . . . . 4.1.1 M´ethode de la dichotomie. . . . . . . . . . . . . . . . . . . . . . . . . . 4.1.2 M´ethode de Newton. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1.3 Comment s’y prendre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Repr´esentation des nombres dans un ordinateur. . . . . . . . . . . . . . . . . 4.2.1 Les nombres entiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.2 Les nombres r´eels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.3 Cons´equence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3 Suites et s´eries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.1 G´en´eralit´es et premi`eres difficult´es. . . . . . . . . . . . . . . . . . . . . 4.3.2 Calcul des int´egrales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . ´ 4.4 Echantillonnages, interpolation. . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4.1 Interpolation lin´eaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4.2 Approximation parabolique. . . . . . . . . . . . . . . . . . . . . . . . . 4.4.3 Polynˆ omes de Lagrange. . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4.4 D´eriv´ees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.5 Alg`ebre lin´eaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.5.1 Un exemple : la diffusion de la chaleur `a une dimension. . . . . . . . . 4.5.2 Syst`emes d’´equations lin´eaires. . . . . . . . . . . . . . . . . . . . . . . 4.5.3 Une g´en´eralisation de la m´ethode de Newton `a plusieurs dimensions. . 4.5.4 Probl`emes de vecteurs propres et de valeurs propres ou eigenproblems. 4.6 Probl`emes autocoh´erents. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.6.1 Qu’est-ce donc ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.6.2 Formulation g´en´erale. . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.6.3 Est-ce que c¸a converge ? . . . . . . . . . . . . . . . . . . . . . . . . . . 4.7 Recherche des minima d’une fonction. . . . . . . . . . . . . . . . . . . . . . . 4.7.1 Du mouvement des amibes (m´ethode du simplex). . . . . . . . . . . . 4.7.2 M´ethode de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.7.3 Recherche ` a une dimension : interpolation parabolique. . . . . . . . . 4.7.4 M´ethode du gradient conjugu´e. . . . . . . . . . . . . . . . . . . . . . . 4.7.5 Minimisation avec contrainte : les multiplicateurs de Lagrange. . . . . 4.8 Mod´elisation de donn´ees exp´erimentales. . . . . . . . . . . . . . . . . . . . . . 4.8.1 Donn´ees et moindres carr´es. . . . . . . . . . . . . . . . . . . . . . . . . 4.8.2 Ajustement d’une fonction lin´eaire. . . . . . . . . . . . . . . . . . . . . 4.8.3 Ajustement d’un polynˆ ome. . . . . . . . . . . . . . . . . . . . . . . . . 4.8.4 D´eriv´ee locale d’une courbe exp´erimentale. . . . . . . . . . . . . . . . 4.8.5 Lissage : a dirty trick ! . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.8.6 Ajustement non-lin´eaire. . . . . . . . . . . . . . . . . . . . . . . . . . . 4.9 Syst`emes d’´equations diff´erentielles ordinaires. . . . . . . . . . . . . . . . . . . 4.9.1 Un exemple : les lignes de champ. . . . . . . . . . . . . . . . . . . . . 4.9.2 La m´ethode d’Euler. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.9.3 La m´ethode d’Euler « am´elior´ee » ou m´ethode de Heun. . . . . . . . . 4.9.4 La m´ethode de Runge-Kutta d’ordre 4. . . . . . . . . . . . . . . . . . 4.9.5 La m´ethode de Cranck et Nicholson . . . . . . . . . . . . . . . . . . . ´ 4.9.6 Equations d’ordre sup´erieur ` a 1. . . . . . . . . . . . . . . . . . . . . . 4.9.7 M´ethode de Verlet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.9.8 Le probl`eme du pas d’int´egration. . . . . . . . . . . . . . . . . . . . . 4.9.9 Quelle m´ethode choisir ? . . . . . . . . . . . . . . . . . . . . . . . . . . 4.10 Transform´ees de Fourier rapides. . . . . . . . . . . . . . . . . . . . . . . . . . 4.10.1 La transform´ee de Fourier en physique. . . . . . . . . . . . . . . . . . 4.10.2 La transform´ee de Fourier discr`ete. . . . . . . . . . . . . . . . . . . . . 4.10.3 Filtrage de donn´ees exp´erimentales. . . . . . . . . . . . . . . . . . . . 4.11 Les m´ethodes de Monte-Carlo. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
45 45 45 46 48 48 48 49 49 49 49 50 53 54 54 55 55 55 55 56 58 59 61 61 61 62 62 63 63 63 64 65 66 66 67 68 69 69 70 71 71 72 72 73 74 74 75 75 76 78 78 84 86 86
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
5
Physique num´erique, Philippe Depondt
4.11.1 4.11.2 4.11.3 4.11.4 4.11.5 4.11.6 4.11.7 4.12 Le tri.
Processus stochastiques et chaˆınes de Markov. . . . . . . . . Les vicissitudes de π. . . . . . . . . . . . . . . . . . . . . . . . La production de nombres « al´eatoires ». . . . . . . . . . . . Obtenir une distribution autre qu’uniforme. . . . . . . . . . . Int´egration multidimensionnelle sur des domaines compliqu´es. Simulation de Monte-Carlo-Metropolis. . . . . . . . . . . . . Recherche du minimum d’une fonction : le recuit simul´e. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5 Introduction ` a la simulation num´ erique 5.1 Pourquoi la Simulation num´erique ? . . . . . . . 5.2 La mati`ere consid´er´ee comme un milieu continu. 5.2.1 Quels types de questions se pose-t-on ? . . 5.2.2 La m´ethode des diff´erences finies . . . . . 5.2.3 Les m´ethodes spectrales . . . . . . . . . . 5.2.4 Introduction aux ´el´ements finis . . . . . . 5.3 La mati`ere comme une collection de particules. . 5.3.1 Matrice dynamique . . . . . . . . . . . . . 5.3.2 Simulations Monte-Carlo. . . . . . . . . . 5.3.3 Simulations de dynamique mol´eculaire. . . 5.3.4 Simulations ab-initio. . . . . . . . . . . . 6 Optimisation de code. ´ 6.1 Eviter les calculs inutiles . . . . . . . 6.2 Utiliser les sym´etries. . . . . . . . . . 6.3 Stocker des r´esultats interm´ediaires. 6.4 Utilisation des caches . . . . . . . . . 6.5 Eviter les interruptions . . . . . . . . 6.6 Ne pas r´einventer ce qui existe d´ej` a.
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
86 87 87 88 89 92 94 95
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
97 97 97 97 98 103 104 105 105 110 110 111
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
115 115 115 116 116 117 117
et parall´ elisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
119 119 119 120 120
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
121 121 122 122 122 122 122 122 122 123 123 124 124 124 124 124 125
9 La question du calcul formel. 9.1 Calcul formel, calcul num´erique : quelle diff´erence ? . . . . . 9.2 Quelques exemples . . . . . . . . . . . . . . . . . . . . . . . 9.2.1 ax + b = 0 . . . . . . . . . . . . . . . . . . . . . . . . 9.2.2 Le gaz de Van der Waals . . . . . . . . . . . . . . . 9.2.3 Mod`ele de Brillouin-Weiss . . . . . . . . . . . . . . . 9.2.4 Le projectile . . . . . . . . . . . . . . . . . . . . . . 9.2.5 Une « grosse » simulation : les anneaux de Saturne. 9.3 Que peut-on en conclure ? . . . . . . . . . . . . . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
127 127 127 127 128 128 129 131 134
7 Calculs tr` es lourds : vectorisation 7.1 L’architecture vectorielle . . . . . 7.2 Parall`elisme . . . . . . . . . . . . 7.2.1 M´emoire partag´ee . . . . 7.2.2 M´emoire distribu´ee . . . .
. . . . . .
. . . . . .
. . . . . .
8 Quelques ´ el´ ements de C++ 8.1 Avant mˆeme de commencer . . . . . . . . 8.2 D´eclarations . . . . . . . . . . . . . . . . . 8.3 Structures de base diverses . . . . . . . . 8.3.1 Boucles . . . . . . . . . . . . . . . 8.3.2 Conditions . . . . . . . . . . . . . 8.3.3 Sauvegardes . . . . . . . . . . . . . 8.4 Tableaux . . . . . . . . . . . . . . . . . . 8.4.1 Tableaux de taille fixe . . . . . . . 8.4.2 Les pointeurs : premiers pas . . . . 8.4.3 Tableaux dynamiques . . . . . . . 8.5 Fonctions . . . . . . . . . . . . . . . . . . 8.5.1 Une fonction tr`es simple . . . . . . 8.5.2 Prototype . . . . . . . . . . . . . . 8.5.3 Passage d’arguments par valeur . . 8.5.4 Passage d’arguments par r´ef´erence 8.6 Les classes . . . . . . . . . . . . . . . . . .
. . . . . .
. . . . . . . . . . . . . . . .
. . . . . .
. . . . . . . . . . . . . . . .
. . . . . .
. . . . . . . . . . . . . . . .
. . . . . .
. . . . . . . . . . . . . . . .
. . . . . .
. . . . . . . . . . . . . . . .
. . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
6 10 Bibliographie.
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
135
Chapitre 1
Introduction tion d’irradiation de mat´eriaux divers ou r´egulation de la distribution d’´electricit´e ; les fabriquants de turbines qui cherchent `a optimiser leur fonctionnement simulent les ph´enom`enes tr`es complexes li´es aux instabilit´es dans les chambres de combustion. Il n’y a gu`ere de domaine qui ´echappe : mˆeme la finance recrute des scientifiques capables de mod´eliser sur ordinateur ! Un(e) physicien(e) de formation, que ce soit dans un environnement recherche ou industriel peut difficilement ignorer ce domaine dont l’importance est de plus en plus massive, mˆeme si il/elle n’est pas directement impliqu´e(e) dans des calculs l´egers ou lourds. L’´evolution fulgurante de la capacit´e de calcul disponible ne peut toutefois ˆetre utile et profitable que s’il y a des personnes comp´etentes pour s’en servir de fa¸con pertinente et donc convenablement form´ees : il s’agit l` a d’une double comp´etence `a la fois scientifique dans la discipline d’origine (physique, chimie, math´ematiques, science de la vie, etc.) et de simulation : « Some jog along with the technology while others lag behind 3 . . . ». Ce monde ´evolue rapidement et le but de ce cours est de fournir les bases et les d´emarches permettant de s’y rep´erer.
« Si vous pensez que le calcul num´erique, c’est l’affaire des autres, c’est qu’il est temps de vous recycler » : cette affirmation p´eremptoire, et volontairement provocatrice1 , est `a comprendre dans un contexte o` u le CEA, le CNRS, la Communaut´e Europ´eene et les grands industriels s’´equipent r´esolument de moyens de calcul toujours plus consid´erables. Le sigle HPC (High Performance Computing) jaillit un peu partout. . . On parle volontier, et le plus s´erieusement du monde, de PetaFlops 2 (sans forc´ement toujours tr`es bien comprendre de quoi il s’agit. . .). C’est sans doute que l’enjeu en paraˆıt important aux d´ecideurs (et aux payeurs) ` a la fois pour la recherche scientifique et pour la recherche et d´eveloppement (R & D) industriel. Les demandeurs de ce genre de calculs lourds voire tr`es lourds sont divers ; par exemple et dans le d´esordre : – La m´et´eorologie est l’un des utilisateurs civils les plus importants : les pr´evisions au quotidien bien sˆ ur, mais aussi les recherches sur le r´echauffement climatique, essayer d’en pr´evoir les cons´equences, voire trouver des rem`edes requi`erent des simulations tr`es ´elabor´ees des mouvements atmosph´eriques et des ´echanges chimiques et ´energ´etiques. – La mati`ere condens´ee, les mat´eriaux et les nanosciences en physique et en chimie offrent une vari´et´e incroyable de probl`emes mettant en jeu un grand nombre (entre quelques dizaines et le nombre d’Avogadro !) d’atomes : des calculs classiques ou quantiques, parfois assez simples, parfois tr`es lourds, sont mis en œuvre pour tenter de comprendre ou de pr´edire leurs propri´et´es. – Les sciences de la vie se pr´eoccupent, au niveau microscopique, de mol´ecules ´enormes, extraordinairement complexes. Des efforts consid´erables sont faits pour tenter de mod´eliser ces objets, avec des enjeux importants : repliement de proteines, cons´equences pour la maladie d’Alzheimer ou celle de Parkinson, drug design, etc. La g´enomique, de son cˆ ot´e, doit utiliser des bases de donn´ees colossales en utilisant des m´ethodes qui doivent ˆetre efficaces et n’ont rien de trivial. – Les sciences de l’ing´enieur sont aussi tr`es demandeuses. Les simulations a´erodynamiques permettent de pr´evoir et d’optimiser les caract`eristiques d’un avion avant mˆeme son premier vol ; un industriel comme EDF d´eveloppe des calculs souvent tr`es lourds dans des domaines d’une grande diversit´e : simula-
L’exp´erience tend `a montrer que ce cours de Physique num´erique surprend parfois un peu ceux `a qui il s’adresse. Il commence, en effet, par de la programmation et quelques notions d’Unix : serait-ce alors un « cours d’info », comme on l’entend souvent appeler ? Tr`es rapidement toutefois, apr`es quelques semaines, on ne parle plus, ou presque plus, d’informatique ou de programmation : c’est suppos´e acquis ; on parle de physique principalement, parfois orn´ee d’un peu de math´ematiques appliqu´ees. En outre, cette physique ne paraˆıt, parfois, gu`ere famili`ere `a des ´etudiants habitu´es `a r´esoudre des probl`emes dont la solution analytique est connue : c’est qu’ici, justement, l’objectif est de r´esoudre des probl`emes pour lesquels il n’y a pas de solution analytique, c’est-`a-dire l’immense majorit´e. . . L’informatique est alors pour nous un outil - qu’il faut bien sˆ ur maˆıtriser - pour s’attaquer `a des probl`emes de physiques vari´es. Le charme de cet enseignement, pour les enseignants mais aussi souhaitons-le pour ceux qui le re¸coivent, une fois - r´ep´etons-le - l’outil acquis, est qu’il ne se cantonne pas `a tel ou tel domaine de la physique, mais qu’il pioche ses exemples dans des champs aussi vari´es que possible, dans des questions souvent tr`es contemporaines, avec des approches parfois inattendues. Le pr´esent polycopi´e d´eborde assez largement le strict minimum n´ecessaire `a la r´eussite `a l’examen. . . c’est vo-
1 faite par un professeur de math´ ematiques a ` l’UPMC en introduction a ` un colloque intitul´ e Penser PetaFlops en mai 2008. 2 1015 floating point operations per second. La premi` ere machine « p´ etaflopique » a fonctionn´ e au printemps 2008. L’´ etape suivante est l’ExaFlops : 1018 flops. . .
3 « Certains accompagnent le peloton tandis que d’autres traˆ ınent derri` ere. »
7
8
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
lontaire : `a chacun de s´electionner ce qui lui paraˆıt utile, Un autre exemple, moins c´el`ebre sans doute, est les s´eances de travaux dirig´es et de travaux pratiques ´etant l’ensemble des op´erations qui, pendant la R´evolution de bons guides en la mati`ere4 . Fran¸caise, ont abouti `a la d´efinition du m`etre, en remplacement du maquis d’unit´es de l’Ancien R´egime, par un syst`eme uniforme et rationnel. On voulait que le m`etre fˆ ut 1.1 Des m´ ethodes num´ eriques, universel (on aurait certes put choisir comme r´ef´erence les unit´es en vigueur `a Paris, mais l’id´eal universaliste pour quoi faire ? des r´evolutionnaires l’interdisait) et l’on choisit ainsi une ut ˆetre commune `a toute l’humanit´e : la dix` titre de provocation, on pourrait dire que l’objet de ce r´ef´erence qui pˆ A millioni`eme partie du quart du m´eridien terrestre. Encore cours est de faire aussi peu d’informatique que possible. Il fallait-il en mesurer la longueur. . . On envoya donc deux s’agit plutˆ ot d’utiliser les ressources fournies par les ordimath´ematiciens-astronomes r´eput´es pour leur pr´ecision et nateurs pour tenter de traiter des probl`emes de physique le soin avec lequel ils menaient leurs observations (Jeanaussi vari´es que possible, afin, soit de se simplifier la vie Baptiste-Joseph Delambre (1749-1822) et Pierre-Fran¸coiset gagner du temps en faisant faire par un ordinateur des Andr´e M´echain (1744-1804)) ´equip´es des instruments de calculs fastidieux que l’on pourrait sans doute faire soivis´ee les plus ´elabor´es, mesurer entre Dunkerque et Barmˆeme, soit au contraire de s’attaquer ` a des questions que celone la longueur de l’arc de m´eridien de Paris : en l’on ne pourrait en aucun cas traiter avec une feuille de d´eterminant tr`es pr´ecis´ement la latitude des deux villes papier et un crayon. . . Nous chercherons ainsi dans divers ´ (` a partir de la hauteur de l’Etoile Polaire et de quelques domaines de la physique des probl`emes, de pr´ef´erence peu autres) on en d´eduirait ais´ement la longueur du m´eridien susceptibles d’une solution analytique, afin de les traiter complet. num´eriquement `a l’aide d’un calcul sur ordinateur, l’obIl fallait donc ´etablir un r´eseau de triangles qui recouvre jectif ´etant d’apprendre comment aborder une question de compl´ etement l’arc de m´eridien compris entre les deux fa¸con qu’un calcul permette d’y r´epondre de mani`ere savilles, mesurer avec une pr´ecision m´eticuleuse les angles tisfaisante, quitte `a la reformuler au passage pour la faire aux sommets de tous ces triangles afin d’en calculer la entrer dans un cadre propice ` a ce genre de traitement. longueur des cˆ ot´es, puis par trigonom´etrie, la longueur de l’arc. Cette ´epop´ee (racont´ee par Ken Alder dans The mea1.1.1 Quelques jalons. . . sure of all things, Free Press (2002)) dura sept ans (17921799) dans une France en proie `a toutes sortes de vioIl ne faut cependant pas croire que les calculs num´e- lences (les invasions, les guerres r´evolutionnaires, la Terriques aient attendu l’invention de l’ordinateur pour voir reur, Thermidor. . .) : dans les jours qui suivirent la fuite le jour. Au XVIIe si`ecle d´ej` a, l’invention des logarithmes de Louis XVI `a Varennes, Delambre avec son attirail de par John Napier (1550-1616) fut une r´evolution (Miri- longue-vues et d’instruments, et, pire encore, son ordre de fici logarithmorum canoni descriptio, Edimbourg (1614)) : mission sign´e par le roi fugitif, fut arrˆet´e `a plusieurs reune multiplication se transformait en addition -beaucoup prises comme « espion » ; un peu plus tard, M´echain resta plus ais´ee-, une extraction de racine carr´ee en division bloqu´e en Catalogne quand l’Espagne bourbonnienne et par deux ! L’astronome Johannes Kepler (1571-1630) qui la France r´epublicaine se trouv`erent en guerre ; M´echain d´ecouvrit l’ellipticit´e des orbes plan´etaires, se livra `a dut aussi lutter en permanence contre un ´etat psycholodes calculs num´eriques vertigineux dans, par exemple, gique d´epressif li´e `a son inqui´etude quant `a la qualit´e de son œuvre principale, l’Astronomie Nouvelle (Astronomia ses mesures. Les deux hommes revinrent enfin `a Paris en Nova, (1609) ). Ainsi, par exemple, pour ´evaluer les posi- 1799 pour pr´esenter leurs r´esultats : une conf´erence intertions au cours du temps d’une plan`ete alors qu’elle parnationale de math´ematiciens devait : 1o v´erifier et valider court ce qui n’est encore qu’un « ovo¨ıde » avec une vitesse la coh´erence de leurs observations, et 2o en d´eduire la lonvariable5 , il divise la trajectoire en 360 petits segments gueur du m`etre. et additionne les r´esultats obtenus pour chaque segment : Il fallait donc, pour la deuxi`eme partie de ce travail, faire c’est ce que l’on appelle maintenant une discr´etisation. des calculs de trigonom´etrie sur une surface sph´erique. Kepler, lui, appelait cela un « morcellement num´erique » On savait cependant qu’outre les montagnes dont il falet se plaignait de ce que ce calcul fˆ ut « m´ecanique et enlait bien sˆ u r tenir compte, la Terre n’´etait pas une sph`ere nuyeux » : comme son employeur, l’empereur Rudolf II., parfaite mais plutˆ ot un ellipso¨ıde de r´evolution l´eg`erement ne payait son salaire qu’occasionnellement, il n’avait pas applati aux pˆ o les : toutefois, le choix d’un arc de m´eridien les moyens d’employer lui-mˆeme un assistant pour l’aisitu´ e a ` des latitudes interm´ediaires (le 45˚ parall`ele passe der. . . Il connaissait d’ailleurs les tables de logarithmes de a ` Bordeaux et donc coupe l’arc Dunkerque-Barcelone non Napier et en ´etablit lui-mˆeme dans ses Tables Rodolphines loin de son milieu) permettait d’esp´erer obtenir une va(Tabulæ Rudolphinæ, (1627) ). leur moyenne qui pˆ ut servir de r´ef´erence. On fit alors une 4 Le chapitre 5, en particulier doit ˆ ecouverte compl´etement inattendue : le g´eo¨ıde n’´etait pas etre consid´ er´ e comme la suite d´ logique du cours, mais n’en fait a ` proprement parler partie. r´egulier mais recouvert de bosses et de creux. La valeur 5 Jusqu’alors, on croyait, Copernic, Tycho Brahe et Galil´ ee y comdu rayon de courbure de la surface terrestre d´ependait de pris, que les mouvements plan´ etaires ´ etaient des mouvements ciru il ´etait mesur´e, or la pr´ecision magnifique des culaires uniformes, ou des combinaisons de mouvements circulaires l’endroit o` echain, le soin m´eticuleux uniformes, ce qui permettait un calcul facile des positions plan´ etaires observations de Delambre et M´ futures. Kepler, comme on le sait, introduisit, a ` cause d’un d´ esaccord -voire obsessionnel dans le cas de M´ echain- avec lequel de 8 minutes d’angle dans la position de Mars, les orbes, d’abord elles avaient ´et´e r´ealis´ees ne permettaient pas de mettre ce ovo¨ıdes puis elliptiques, parcourues a ` vitesse variable ; les pr´ edictions esultat sur le compte d’erreurs ou d’impr´ecisions de meen devenaient beaucoup plus difficiles : il fallut attendre Newton pour r´ voir la r´ esolution de ce probl` eme. sure. Apr`es de longues tergiversations, on finit n´eanmoins
9
Physique num´erique, Philippe Depondt
Curseur transparent
Réglette
a
Graduations logarithmiques
b a.b
Fig. 1.1 – La r`egle `a calcul, h´eriti`ere des tables de logarithmes de John Napier, en usage jusqu’` a la fin des ann´ees 1970. La r´eglette pouvait coulisser dans une gorge am´enag´ee dans la r`egle et le curseur pouvait glisser sur l’ensemble. Pour faire le produit de deux nombres a et b (par exemple pour convertir des calories en joules), on d´epla¸cait la r´eglette de telle fa¸con que son origine se trouve en face de la graduation a de la r`egle, puis on d´epla¸cait le curseur jusqu’` a la graduation b de la r´eglette pour lire le r´esultat : comme les graduations ´etaient logarithmiques, on additionnait ainsi deux logarithmes pour obtenir le produit de leurs arguments. par fixer la valeur du m`etre ` a 443,296 lignes (une unit´e en vigueur `a Paris alors) et l’on fondit le fameux m`etre-´etalon en platine irridi´e du pavillon de Breteuil. Au-del` a de l’histoire plus ou moins anecdotique, on devine en arri`ere-plan les prodigieux calculs num´eriques que les math´ematiciens de la conf´erence ont dˆ u faire (outre les travaux de d´egrossissage r´ealis´es par Delambre et M´echain : corrections pour l’altitude, la r´efraction atmosph`erique, la temp´erature, etc.) arm´es d’une plume pour ´ecrire et d’une table de logarithmes. Il ne se r´epartirent mˆeme pas la tˆ ache, car pour plus de sˆ uret´e, chaque participant devait faire ind´ependamment l’int´egralit´e des calculs en utilisant ses propres m´ethodes ! On reste pantois devant la dext´erit´e et l’acharnement calculatoires que cela repr´esente. . . Un peu plus tard, au XIXe si`ecle, Urbain Le Verrier ´etudia les perturbations observ´ees dans l’orbite d’Uranus et postula l’existence d’une autre plan`ete jusqu’alors inconnue. Il calcula la position de cette plan`ete et le directeur de l’observatoire de Berlin, Johann Galle, vit `a l’endroit indiqu´e, le 23 septembre 1846, la nouvelle plan`ete, Neptune : un triomphe pour le valeureux calculateur ! On imagine sans peine cependant l’´enorme labeur que repr´esent`erent, pour Le Verrier, ces calculs, enti`erement faits `a la main. . . Cependant, l’id´ee d’automatiser des calculs ennuyeux est ancienne. Le baron Gaspard de Prony ´etait charg´e pendant le Premier Empire d’´etablir des tables pour le calcul de l’impˆot foncier : pour cela, il divisa le travail en trois grands blocs. La premi`ere partie, la plus noble, ´etait confi´ee ` a des math´ematiciens : il s’agissait de d´ecomposer tous les calculs n´ecessaires en s´eries d’op´erations ´el´ementaires. La deuxi`eme tˆ ache consistait `a organiser le travail et ` a compiler les r´esultats. La troisi`eme, faire les calculs r´eduits ` a des op´erations tr`es simples, fut confi´ee `a une arm´ee de calculateurs humains dont la seule qualification ´etait d’ˆetre capable de faire des additions. L’´etape suivante fut franchie par Charles Babbage, un gentleman philosopher britannique du d´ebut du XIXe si`ecle qui eut l’id´ee d’associer cette d´ecomposition des calculs en tˆ aches ´el´ementaires avec une calculatrice du type
de celle de Pascal et un syst`eme de cartes perfor´ees issu des m´etiers `a tisser Jacquard. Malheureusement, malgr´e un financement public cons´equent, et une « communication » - comme on dirait maintenant - efficace assur´ee par Ada Byron6 , les r´ealisations pratiques ne donn`erent jamais satisfaction, `a cause semble-t-il des frottements excessifs des m´ecanismes. La premi`ere r´ealisation pratique de calculs massifs automatis´es est due `a Herman Hollerith qui inventa une machine pour traiter les donn´ees du recensement am´ericain de 1890 `a l’aide de cartes perfor´ees. Le r´esultat (62 622 250 habitants) fut obtenu en six semaines au lieu de sept ans pour le recensement pr´ec´edent. Fort de ce succ`es, Hollerith fonda en 1896 la Tabulating Machine Company qui changea de nom en 1924 pour devenir International Business Machines : ibm. . . sp´ecialis´ee dans la fabrication de calculatrices m´ecaniques de bureau, parfois mˆ ues par des moteurs ´electriques, ou utilisant des cartes perfor´ees. Un effort de recherche important sur le calcul automa´ tique fut men´e aux Etats-Unis pendant la deuxi`eme guerre mondiale pouss´e en grande partie par le Ballistic Research Laboratory. Il fallait calculer les trajectoires des projectiles tir´es par divers armements afin de fournir des tables de pointage aux artilleurs. Pour chaque nouvelle munition, il fallait produire une nouvelle table. Une arm´ee d’employ´es, dot´es de calculatrices m´ecaniques de bureau, faisait ces calculs, mais `a la fin de la guerre, ´etait litt´eralement submerg´ee par l’afflux de munitions de tous types et de tous calibres produits par une industrie de guerre en plein effort. . . La premi`ere calculatrice ´electronique, l’ENIAC en 1945, ´etait un monstre de 30 tonnes comportant 17 468 tubes `a vide7 et consommant 150 kW. La panne d’un seul tube arrˆetait la machine qui occupait un bˆ atiment `a elle toute seule et n´ecessitait un syst`eme de refroidissement puissant pour ´evacuer la chaleur produite ! Les premiers ordinateurs virent le jour `a la fin des ann´ees 1940, trop tard pour participer `a l’effort de guerre. Rapidement, les banques, les compagnies d’assurance8 6 la
fille du po` ete. n’y avait pas encore de transistors et encore moins de circuits int´ egr´ es. 8 Du point de vue des constructeurs d’ordinateurs, ce genre de 7 il
10
Licence de physique L3 : Physique Fondamentale & PHYTEM,
et toutes les entreprises astreintes ` a une comptabilit´e lourde comprirent l’usage qu’elles pouvaient faire de ces nouvelles machines et constitu`erent un march´e important pour les constructeurs. Cependant, la demande de calculs toujours plus importants venant des scientifiques, physiciens et astronomes en tˆete, n’a jamais cess´e d’ˆetre pressante, toujours de quelques ordres de grandeur au-del` a de ce que pouvaient fournir les ordinateurs les plus puissants du moment : cette histoire se poursuit actuellement, certains calculs quantiques, par exemple, se chargeant, par leurs exigences en termes de puissance de calcul, de ramener ` a une saine modestie les fabriquants des processeurs les plus ´eblouissants !
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
la fin de la d´ecennie. Un livre de « math´ematiques computationelles9 » r´eguli`erement r´e´edit´e jusqu’` a la fin des ann´ees 80 explique, dans un chapitre d’introduction intitul´e « General rules of computation work », que si l’on veut construire une table des valeurs de la fonction : ex + cos x p y= + 1 + sin2 x 1 + x2
il faut faire sur une feuille de papier un tableau `a 12 colonnes donnant, pour la premi`ere la liste des valeurs de x, la deuxi`eme celles de x2 , la troisi`eme ex , etc., la douzi`eme donnant enfin la liste des valeurs de y (voir la table 1.1) : il n’est pas inutile de r´ealiser que tous les calculs scientifiques ´etaient r´ealis´es de la sorte jusqu’` a un pass´e somme toute r´ecent `a l’´echelle d’une vie humaine10 . Sur l’histoire de l’informatique, on se reportera avec profit aux ouvrages suivants : Ph. Breton M. Campbell-Kelly & W. Aspray Ph. Breton
1.1.2
Fig. 1.2 – Page de garde de la table de logarithmes Bouvart et Ratinet (´edition 1957) en usage dans les classes scientifiques des lyc´ees jusque dans les ann´ees 1970. ` titre de t´emoignage de la rapidit´e avec laquelle la vie A des scientifiques a chang´e, rappelons qu’encore au d´ebut des ann´ees soixante-dix, les ´el`eves des classes pr´eparatoires passaient plusieurs heures par semaine ` a remplir des colonnes de chiffres, stylo d’une main, table de logarithmes (figures 1.2 et 1.3) de l’autre, un entraˆınement jug´e indispensable `a leur dext´erit´e calculatoire. . . les calculettes ´electroniques n’ayant d´etrˆ on´e l’invention de Napier qu’` a clients avait l’avantage d’ˆ etre largement solvable, un encouragement fort a ` faire les investissements n´ ecessaires a ` la production de calculatrices rapides et fiables !
Histoire de l’informatique, La D´ecouverte (1987) Computer. A history of the information machine, Basic Books (1996) Le premier ordinateur copiait le cerveau humain, La Recherche 290 (1996) p. 80
. . . et quelques exemples.
Au d´ebut du XXe si`ecle, le math´ematicien Henri Poincar´e, ´etudiant le probl`eme dit « `a N corps » par exemple N − 1 plan`etes et leur soleil, d´ecouvrit la « sensiblit´e aux conditions initiales » qui interdit de trouver des solutions g´en´erales aux syst`emes d’´equations diff´erentielles produites par ces probl`emes : une infime diff´erence dans les conditions initiales suffit `a induire un comportement radicalement diff´erent du syst`eme. Autant dire que, malgr´e le d´eterminisme intrins`eque de la m´ecanique newtonienne, un tel syst`eme devient rapidement impr´evisible11 . Toutefois, malgr´e cette d´ecouverte fondamentale, Poincar´e ne put gu`ere aller plus loin et l’on en resta l` a jusque vers les ann´ees 1960. C’est alors que le math´ematicien-m´et´eorologue am´ericain Edward Lorenz12 se mit `a r´esoudre sur ordinateur des ´equations diff´erentielles qui visaient `a simuler le comportement de l’atmosph`ere terrestre : il red´ecouvrit alors des syst`emes au comportement irr´egulier similaire `a ce qu’avait pr´edit Poincar´e. Le triangle simulation-surordinateur/th´eorie/exp´erience donna naissance `a un domaine de recherches nouveau et toujours actif de nos jours : le chaos, la turbulence, les fractals. . ., tout ce qui a trait `a la dynamique des syst`emes non-lin´eaires. Il fallait ´evidemment pour cela que l’on pˆ ut faire des simulations sur ordinateur, car le calcul analytique est insuffisant : d’ailleurs maintenant, la m´et´eorologie nationale est un des 9 Voir la r´ ef´ erence [2] dans la bibliographie. Il s’agit certes d’un livre sovi´ etique et l’informatique est sans doute l’un des domaines dans lequel le retard de l’Union sovi´ etique ´ etait sensible. 10 Pour fixer les id´ ees, pr´ ecisons que l’esp` ece Tyranosaurus Rex ´ etait d´ ej` a´ eteinte depuis quelques ann´ ees. . . 11 Voir par exemple : David Ruelle, Hasard et chaos, Odile Jacob (1991). 12 A ` ne pas confondre avec l’´ ethologiste autrichien Konrad Lorentz et ses oies.
Physique num´erique, Philippe Depondt
11
Fig. 1.3 – Une page de la table de logarithmes Bouvart et Ratinet. Admettons que l’on cherche le produit 0,1263×18,17 ; une calculette donne 2,2949. Avec la table, il faut d’abord chercher 1263, soit 120 puis la sixi`eme ligne pour 126 et enfin la colonne 3 : on y trouve 10140. La mˆeme op´eration pour 1817 donne 25935. La somme de ces deux nombres est 36075. En cherchant dans la table, on trouve que 39078 correspond `a 2295, reste `a d´ecaler la virgule convenablement pour obtenir le r´esultat. Si l’on veut avoir 5 chiffres significatifs, il faut utiliser les tables de multiplication fournies dans la marge pour faire des interpolations lin´eaires. Avec un peu d’habitude, c¸a va assez vite, plus vite en tous cas que la multiplication ` a la main ! plus gros consomateurs civils de calcul sur les ordinateurs les plus puissants. Dans un autre domaine, les exp´eriences faites par exemple `a l’aide du rayonnement synchrotron produit dans des laboratoires tels que SOLEIL ` a Orsay et l’ESRF a Grenoble, produisent une grande quantit´e de donn´ees ` num´eriques qui ne se traduisent pas imm´ediatement par des informations de type physique : par exemple, les positions des atomes d’une prot´eine, qui en comporte des centaines voire des milliers, destin´ee ` a soigner telle ou telle maladie. Survient alors une tˆ ache assez diffi-
cile, la « mod´elisation de donn´ees d’exp´erience » qui consiste `a ajuster un mod`ele th´eorique aux donn´ees exp´erimentales connues, en tenant compte des barres d’erreur exp´erimentales. Il s’agit en g´en´eral de minimiser autant que possible l’´ecart entre les donn´ees empiriques et les pr´edictions du mod`ele th´eorique : cette minimisation, une optimisation du mod`ele si l’on pr´ef`ere, est ´etablie en ajustant un nombre souvent ´elev´e de param`etres (les positions atomiques, la caract´erisation de l’agitation thermique) et ne peut pratiquement se faire qu’` a l’aide d’un ordinateur. L’´etude des syst`emes d´esordonn´es est aussi grosse
12 1 x
Licence de physique L3 : Physique Fondamentale & PHYTEM,
2 x2 (1)2
3 ex
4 sin x
5 cos x
6 e + cos x (3) + (5) x
7 1 + x2 1 + (2)
8 ex +cos x 1+x2
(6)/(7)
0 0.1 0.2 0.3 0.4 ...
9 sin2 x (4)2
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
10 1 + sin2 x 1 + (9)
p 11 1 + sin2 x p (10)
12 y (8) + (11)
ex + cos x p + 1 + sin2 x, `a remplir, colonne par colonne, `a l’aide 1 + x2 d’une machine a` calculer m´ecanique ou ´electro-m´ecanique. . . Tab. 1.1 – Feuille de calcul pour la fonction y =
Tab. 1.2 – Un article du journal Le Monde en 1957, les derniers progr`es de la pr´evision m´et´eorologique, il y a un demi-si`ecle : Une machine ` a pr´ edire le temps Quel temps fera-t-il demain ? Vieille question ` a laquelle les offices m´et´eorologiques s’efforcent de r´epondre. Mais voici que la machine ´electronique vient ` a leur secours. On connaˆıt les aptitudes extraordinaires de ces ordinateurs, v´eritables cerveaux de remplacement, dou´es de raisonnement et d’une fabuleuse m´emoire, qui peuvent aujourd’hui r´epondre en quelques secondes ` a des questions qui embarasseraient plus d’un auditoire savant. C’est ` a des machines semblables que le Bureau m´et´eorologique am´ericain demande de travailler pour lui, au moins pour un certain nombre de calculs. Ce bureau centralise des milliers d’observations qu’une arm´ee de savants, de ballons-sondes, toute une flotille de bateaux, tout un r´eseau de postes et de stations diss´emin´es aux quatre coins du monde, glanent quotidiennement et ` a chaque instant sur terre, sur mer et dans le ciel. Rien n’a chang´e dans le syst`eme, si ce n’est qu’une grande partie des op´erations math´ematiques, la plus dure, la plus longue, est confi´ee ` a l’ordinateur. A chaque instant on introduit dans la machine, sous forme de bandes magn´etiques, de nouvelles observations, de nouveaux chiffres, qui sont la nourriture de ce cerveau surhumain, et les savants n’ont plus qu’` a tirer leurs conclusions. Ils peuvent ainsi annoncer, avec une plus grande sˆ uret´e de diagnostic, l’´evolution du temps pour des p´eriodes de vingt-quatre, quarante-huit et mˆeme soixante-douze heures. (Le Monde, le 25 juillet 1957, reproduit le 25/07/2007).
consommatrice de moyens de calcul. Par exemple, une chaˆıne lin´eaire harmonique d’atomes, tous de masse m, est parcourue de vibrations de type onde plane xℓ = u ei(ωt−kℓa) , o` u xℓ est le d´epacement de l’atome ℓ par rapport `a sa position d’´equilibre et a est la distance interatomique. Un calcul classique13 ` a partir des ´equations du mouvement : mx ¨ℓ = C(xℓ+1 − 2xℓ + xℓ−1 )
m′ r´eparties al´eatoirement, le probl`eme devient beaucoup plus difficile `a r´esoudre. On montre cependant sans grande difficult´e que la solution est donn´ee par la recherche des valeurs propres et vecteurs propres d’une ´enorme matrice n × n, appel´ee « matrice dynamique » o` u n est le nombre d’atomes de la chaˆıne. Le probl`eme est tr`es facile `a r´esoudre num´eriquement `a l’aide d’un sous-programme de biblioth`eque, alors que le d´esespoir guette quiconque tenterait de le r´esoudre `a la main. . . On pourrait objecter `a ce qui pr´ec`ede qu’un probl`eme de physique qui n´ecessite plus qu’une r`egle de trois pour ˆetre r´esolu est un probl`eme mal pos´e. L’art du physicien th´eoricien n’est-il pas justement de faire des approximations adroites de fa¸con `a rendre r´esolubles ces probl`emes tout en isolant les principes importants ? L’int´erˆet n’est-il pas plutˆ ot dans les concepts que dans les techniques de calcul plus ou moins laborieuses ? Cette objection est parfaitement recevable et c’est toujours une bonne d´emarche que de tenter de r´efl´echir `a une question avant de se lancer dans des calculs effr´en´es. Il y a cependant des limites qui souvent arrivent tr`es vite : imaginons un pendule simple qui subit un frottement a´erodynamique. Il pend verticalement et on le lance avec une vitesse initiale donn´ee, suffisamment fort pour qu’il passe `a la verticale au dessus de son point d’´equilibre pour retomber de l’autre cot´e. Combien de tours fera-til autour de son axe avant de se mettre `a osciller ? Il est clair qu’on est fort loin des conditions o` u l’on peut faire les approximations usuelles (angle petit). En attendant de trouver le concept ad´equat, il n’est peut-ˆetre pas stupide de faire une petite simulation num´erique sur un ordinateur : cela ne repr´esente gu`ere plus que quelques dizaines de lignes de programme et quelques secondes de simulation sur une machine mˆeme de puissance m´ediocre. . .
Il ne faut pas croire non plus que le calcul num´erique sur ordinateur se limite `a la physique : les pr´evisions m´et´eorologiques (voir la table 1.2) sont ´evidemment un cas bien connu, mais aussi les simulateurs de vol permettent `a des pilotes d’essais de tester le comportement d’un nouvel avion sans risquer leurs vies et des simulateurs d’op´erations permettent `a des chirurgiens de s’entraˆıner o` u C est la constante de force entre deux atomes. Main- sans risquer celles de leurs patients ! Le dossier de la revue tenant, si la chaˆıne comporte des impuret´es de masse Pour la Science (voir la bibliographie, ref. (20)) consacr´e 13 Voir, par exemple : Charles Kittel, Introduction to Solid State`a la mod´elisation informatique parcourt quelques th`emes « `a la mode ». . . Physics, New York : Wiley, (1986).
donne la pulsation ω en fonction du vecteur d’onde k, c’esta-dire la relation de dispersion : ` r ka C sin ω(k) = 2 m 2
Physique num´erique, Philippe Depondt
1.2
Plan succinct.
La premi`ere ´etape est l’apprentissage d’un langage de programmation. Il faut pouvoir « dire » ` a l’ordinateur ce que l’on veut qu’il fasse. Le langage le plus adapt´e au calcul scientifique est le fortran95. Son concurrent, le langage C, plus g´en´eraliste et plus adapt´e ` a la programmation syst`eme -le syst`eme d’exploitation unix est programm´e en C-, n´ecessiterait un apprentissage plus long, qui n’apporterait rien de plus `a notre objectif, sans apporter la puissance qu’offre fortran95 en particulier dans la manipulation des tableaux. Afin d’illustrer l’objectif de ce cours, cette premi`ere partie est suivie d’un chapitre dont le but est de montrer sur un exemple la fa¸con dont on proc`ede pour aborder un probl`eme et en particulier essayer d’expliciter ce qui est attendu lors des s´eances de travaux pratiques. La deuxi`eme ´etape consistera ` a passer en revue les m´ethodes les plus utilis´ees par les physiciens, autant que possible `a l’aide d’exemples tir´es de la physique. L’accent ne sera pas forc´ement mis sur les d´etails les plus intimes des algorithmes, car des math´ematiciens seraient sˆ urement plus `a mˆeme de le faire que des physiciens dont ce n’est pas le centre d’int´erˆet principal : de fait, la pratique des physiciens est souvent d’utiliser des sous-programmes de biblioth`eque existants et ´eprouv´es que l’on « appelle » `a partir d’un programme sp´ecifique ` a un probl`eme donn´e. L’effort portera donc plutˆ ot sur les contraintes que ces algorithmes peuvent exercer sur les probl`emes que se posent les physiciens, ´eventuellement sur les pi`eges qu’ils rec`elent. En gros, il s’agit d’essayer de r´epondre ` a trois questions : « comment c¸a marche ? », « quelles cons´equences cela peut-il avoir pour moi, physicien ? » et bien sˆ ur : « qu’estce que je peux faire avec ? ». Une ouverture est donn´ee sur la simulation num´erique. La troisi`eme ´etape consistera ` a utiliser un logiciel de calcul formel pour tenter de r´esoudre les mˆemes probl`emes que pr´ec´edemment. Dans certains cas, le caract`ere convivial et automatique du logiciel tout fait fera des miracles, dans d’autres en revanche, c¸a sera moins convaincant. . . mieux vaut savoir se rep´erer, d’autant que, l` a encore, des pi`eges subsistent. Ainsi ce cours se veut, non pas un cours d’« informatique pour physiciens » mais un cours pratique de « Physique num´erique » c’est-`a-dire des m´ethodes qu’utilisent les physiciens pour r´esoudre un grand nombre de probl`emes de physique.
13
14
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
Chapitre 2
Notions pratiques de FORTRAN95. Les notes ci-dessous ont pour but de donner rapidement au lecteur la capacit´e d’´ecrire des programmes ; elles ne remplacent pas, bien sˆ ur, un cours syst´ematique1. Il s’agit ici d’un outil dont la maˆıtrise est un pr´ealable indispensable `a tout travail de calcul num´erique : il n’est pas utile de connaˆıtre toutes les subtilit´es du Fortran95, mais il faut imp´erativement ˆetre capable d’´ecrire rapidement des programmes simples « qui marchent » car, sinon, les s´eances de travaux pratiques destin´ees ` a faire de la physique que l’on esp`ere int´eressante avec cet outil, en deviendraient suprˆemement ennuyeuses pour tous, enseignants compris. . .
2.1
Qu’est-ce qu’un langage de programmation ?
Un ordinateur, lorsqu’il ex´ecute un programme, lit l’une apr`es l’autre dans sa m´emoire des instructions ´el´ementaires, par exemple : « aller chercher un nombre a ` tel emplacement dans la m´emoire » ou « multiplier tel nombre par tel autre ». Ce sch´ema correspond ` a la c´el`ebre « machine de Turing » qui sert de mod`ele th´eorique `a l’immense majorit´e des ordinateurs (figure 2.1) : instructions et donn´ees sont inscrites sur un mˆeme support appel´e m´emoire2. La m´emoire est constitu´ee d’emplacements correspondant chacun ` a une adresse et contenant chacun une instruction ou une donn´ee : on peut se repr´esenter cette m´emoire comme une esp`ece de long ruban divis´e en cases, chacune d’entre elles ayant un num´ero, comme les maisons le long d’une rue, chaque num´ero constituant une « adresse ». La « machine » lit dans la m´emoire les instructions et les ex´ecute l’une apr`es l’autre s´equentiellement3 . Une instruction peut ˆetre l’ordre d’aller lire une donn´ee ` a l’adresse en m´emoire indiqu´ee par cette instruction, ou de modifier une donn´ee ou encore d’inscrire une donn´ee ` a une autre adresse dans la m´emoire : on peut donc modifier le contenu de la m´emoire. Chaque instruction est d´esign´ee par un code binaire constitu´e de 0 et de 1, et chaque emplacement dans 1 voir par exemple J. F. Kerrigan, r´ ef. [6] dans la bibliographie, ou, plus r´ ecent et plus complet M. Metcalf et al., r´ ef. [18]. 2 Le terme m´ emoire date des ann´ ees 1940, lorsque John Von Neumann s’est pr´ eoccup´ e de r´ ealisations pratiques de la machine de Turing qui dans son esprit devaient ˆ etre des cerveaux artificiels. Avant, on parlait, plus prosa¨ıquement, de storage en anglais, soit stockage. 3 d’o` u l’expression « machine s´ equentielle » que l’on retrouve fr´ equemment : il s’agit simplement d’une machine qui ex´ ecute les instructions l’une apr` es l’autre, par opposition aux machines dites « parall` eles ».
la m´emoire est aussi d´esign´e par une adresse binaire. C’est ce qu’on appelle le langage machine. R´ealiser un programme consiste donc `a fournir `a l’ordinateur une s´equence d’instructions de ce type pour qu’il la place dans sa m´emoire pour ex´ecution ; or il est rapidement fastidieux d’aligner des listes fort longues de 1 et de 0, sans compter les risques d’erreurs que cela comporte ! Un premier progr`es fut de remplacer le code binaire d’une instruction par un mot-clef, par exemple load (pour charger en m´emoire), et d’´ecrire les adresses en d´ecimal (ou en hexad´ecimal) plutˆ ot qu’en binaire. Cela donne quelque chose qui peut ressembler `a : load 150 aller chercher un nombre a ` l’adresse 150 add 200 additionner avec le contenu de l’adr. 200 store 220 ranger le r´esultat a l’adresse 220 C’est nettement plus lisible que : 0011010100101100011111100100001001110101...
Un programme sp´ecial, en g´en´eral fourni avec l’ordinateur et appel´e assembleur traduit alors toutes ces instructions en binaire ou langage machine, puis on peut faire ex´ecuter le programme (voir les tables 2.1 et 2.2). L’assembleur permet de faire beaucoup de choses, presque tout, `a vrai dire : `a une ´epoque (les ann´ees 80) o` u les m´emoires disponibles n’´etaient pas ce qu’elles sont devenues, la programmation en assembleur permettait d’´ecrire des programmes efficaces et peu encombrants, au d´etriment ´evidemment de la facilit´e et du temps pass´e `a la programmation, car tout cela reste tr`es « proche de la machine » et certainement assez peu convivial4 . L’´etape suivante fut donc de cr´eer des langages dits « ´evolu´es » avec lesquels on puisse faire ais´ement des instructions beaucoup plus compliqu´ees comme, par exemple : x = a*exp(i*(omega*t+phi))
qui ressemble beaucoup `a l’expression math´ematique : x = a ei(ωt+ϕ) et o` u x et i sont des nombres complexes, les autres variables ´etant r´eelles, exp d´esignant ´evidemment l’exponentielle et * la multiplication. Un autre programme appel´e compilateur doit alors d´ecomposer ces instructions ´evolu´ees en instructions ´el´ementaires, les coder en binaire et affecter des adresses en m´emoire `a toutes les variables pour produire un programme ex´ecutable : cette 4 J’ai, personnellement, quelques souvenirs cuisants a ` ce titre : a ` la suite -entre autres- d’une erreur dans le calcul d’une adresse, un programme pouvait tr` es bien ´ ecrire une donn´ ee a ` un emplacement r´ eserv´ e a ` une fonctionalit´ e de base du syst` eme, ce qui ´ etait ´ evidemment plutˆ ot catastrophique !
15
16
3
4
charger add. ranger aller 150 200 220 en 10
150 151 retour en 1
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
200 201
220
2. 64 58
2
1. 41 4 3. 14 16
1
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Fig. 2.1 – La machine th´eorique de Turing. Le curseur lit les instructions les unes apr`es les autres et la machine les ex´ecute. Par exemple : aller lire une donn´ee ` a un emplacement de la m´emoire vive, ou sauter `a une autre instruction, etc.
Tab. 2.1 – Pour comprendre comment « c¸a marche » : quelques ´el´ements d’assembleur L’unit´e centrale (CPU ou Central Processing Unit) d’un ordinateur ne travaille pas directement dans la m´emoire vive : elle a ses propres emplacements m´emoires appel´es « registres ». Elle doit donc aller chercher en m´emoire vive les grandeurs n´ecessaires ` a un calcul, les copier dans ses registres, faire les op´erations requises et stoker les r´esultats dans la m´emoire. Pourquoi toutes ces complications, pourquoi ne pas tout stocker d’embl´ee dans les registres de l’unit´e centrale ? Tout simplement parce qu’ils sont tr`es peu nombreux, de l’ordre de la dizaine. . . Certains ordinateurs tr`es puissants -et extrˆemement coˆ uteux- poss`edent des registres en grand nombre ce qui acc´el`ere consid´erablement les calculs mais suppose un budget cons´equent ! Mettons que l’ordinateur utilis´e poss`ede deux registres ` a usage g´en´eral appel´es « accumulateurs », d´esign´es par A et B dans lesquels on peut placer des nombres, par exemple. L’instruction pour charger le contenu d’un emplacement m´emoire dans le registre A est LDA et celle pour B est LDB (les syntaxes sont donn´ees ici ` a titre indicatif : cela d´epend du processeur). On peut donc ´ecrire, par exemple : LDA $40B6 ce qui signifie « charger le contenu de $40B6 dans le registre A, le symbole $ indiquant que l’adresse est donn´ee en hexad´ecimal (en base 16), soit : $40B6= 4 × 163 + 0 × 162 + 11 × 16 + 6 soit 16566.De mˆeme : ADDA $B003 additionne le contenu du registre A avec le contenu de l’emplacement $B003 et place le r´esultat dans A. (Suite : table 2.2)
traduction, ce programme ex´ecutable est g´en´eralement stock´e sur le disque dur de l’ordinateur dans un fichier dit « ex´ecutable » qu’il suffit d’invoquer (en g´en´eral en tapant son nom sur le clavier) pour qu’il s’ex´ecute. Ainsi, lorsqu’on ´ecrit un programme, que ce soit en fortran, C, pascal ou autre, on doit d’abord cr´eer, ` a l’aide d’un ´editeur de texte5 comme emacs, xedit, kedit, vi (pour les amateurs), voire ed, un fichier que l’on appelle le « fichier source » qui contient les instructions que l’on a ´ecrites en langage ´evolu´e. Ce fichier source n’est pas ex´ecutable : il ne contient que des caract`eres, a priori inutilisables en l’´etat par l’unit´e centrale. On doit alors compiler le programme pour obtenir un fichier ex´ecutable, et enfin lancer l’ex´ecution de celui-ci. Bien, ´evidemment, ` a chaque modification du fichier source, il faut re-compiler et relancer 5 et non un traitement de texte, dont les fonctionnalit´ es (mise en page, correction orthographiques, effets divers) sont infiniment plus riches qu’un simple ´ editeur qui se borne a ` enregistrer les caract` eres que l’on tape au clavier pour les inscrire dans un fichier texte sur le disque dur.
Tab. 2.2 – Suite de la table 2.1 Un autre registre tr`es important est le « compteur ordinal » : il contient l’adresse de la prochaine instruction qui doit ˆetre lue. Le contenu de ce registre est incr´ement´e automatiquement chaque fois qu’une instruction est lue, sauf si l’instruction pr´ec´edente est une instruction dite « de branchement ». Ainsi, le CPU lit une instruction, incr´emente le compteur ordinal, ex´ecute l’instruction, puis lit l’instruction suivante, incr´emente le compteur, ex´ecute l’instruction, etc. C’est ce qu’on appelle une « architecture s´equentielle ». Cependant, si l’instruction lue est une instruction de branchement, celle-ci modifie le contenu du compteur afin de forcer la lecture d’une autre instruction que la suivante. Ce branchement est en g´en´eral soumis au contenu d’un registre « d’´etat » qui dit si une grandeur derni`erement trait´ee et positive ou n´egative, s’il y a eu un d´epassement de capacit´e, etc. On peut modifier le registre d’´etat ` a l’aide d’instructions de comparaison, par exemple : CMPB $310F compare le contenu du registre B avec celui de l’emplacement $310F et modifie le registre d’´etat en cons´equence, puis BGE $11DA nous exp´edie ` a l’adresse m´emoire $11DA, si le r´esultat de la comparaison est positif (B veut dire branch et GE signifie Greater or Equal ), pour y lire une instruction. On obtient ainsi la possibilit´e d’instructions soumises ` a condition ; reste toutefois ` a esp´erer que l’emplacement en question contient bien une instruction, c’est une source de « plantages » spectaculaires, mais l` a r´eside une grande part du charme d´esuet de l’assembleur ! Si l’on souhaite un plat un peu plus cors´e encore, on peut placer un nombre d´esignant une adresse dans un emplacement de la m´emoire. Par exemple : LDA #$0114 place le nombre (et non le contenu de l’adresse) dans le registre A, STA $041E place ce nombre ` a l’emplacement $041E LDB [$041E] charge dans B, non pas le contenu de $041E, mais le contenu de l’adresse elle-mˆeme contenue dans $041E. Ainsi INC $041E incr´emente le contenu de cette adresse, et LDB [$041E] permet d’aller chercher ce qui se trouve ` a l’emplacement suivant : en accroissant pas ` a pas le contenu de l’emplacement $041E on peut parcourir l’un apr`es l’autre toute une s´erie d’emplacements successifs dans la m´emoire. Les amateurs de langage C auront reconnu ici un embryon de pointeur. En fortran ce genre de situation est g´er´e par les tableaux.
l’ex´ecution6 ! 6 il existe des environnements int´ egr´ es, en particulier sous Windows, dans lesquels ces ´ etapes sont plus ou moins automatiques et
17
Physique num´erique, Philippe Depondt
Le fortran est le premier de ces langages ´evolu´es `a avoir vu le jour, mais beaucoup d’autres ont suivi : algol, cobol, pl1, basic, pascal, forth, C, ada, occam. . . Pour ce qui est de la programmation scientifique, outre fortran, seul le langage C semble survivre. Le sigle fortran signifie « formula translator » (traducteur de formules) : l’id´ee est donc de coder des formules de fa¸con aussi proche que possible de ce que l’on fait lorsqu’on ´ecrit des ´equations ` a la main et de traduire ceci en instructions ex´ecutables par l’ordinateur. C’est ` a premi`ere vue une gageure, mais, en fait, fortran est un langage simple, bien adapt´e au calcul scientifique. Mis au point dans sa premi`ere version par John Backus en 1956, il n’a pas cess´e d’´evoluer depuis et ses variantes sont nombreuses tant les fa¸cons de programmer ont ´evolu´e. En effet, les moins jeunes de vos enseignants ont appris le fortranIV et ont travaill´e avec des cartes perfor´ees : ils ont bien sˆ ur des anecdotes `a raconter sur des paquets de cartes s’´echappant de leur carton et se r´epandant sur le sol ou de cartes abˆım´ees apr`es de nombreux usages (apr`es tout, il ne s’agissait que de morceaux de papier bristol) se coin¸cant dans le lecteur et dont il fallait aller chercher les d´ebris avec une pince `a ´epiler ! Le bruit des machines `a perforer7 a marqu´e un certain nombre de g´en´erations de pro` la fin des ann´ees soixante-dix et au d´ebut grammeurs. . . A des ann´ees quatre-vingt, les cartes perfor´ees disparurent, remplac´ees d’abord par des t´el´etypes puis par l’ensemble ´ecran-clavier que nous connaissons maintenant. Le fortranIV avait bien des d´efauts. Il comportait des instructions (go to et if « arithm´etique ») capables de produire des logiques ´echevel´ees, bondissant d’un bout a l’autre du programme en des itin´eraires dignes d’un ` plat de spaghettis : autant dire que ce n’´etait pas tr`es lisible et g´en´erateur d’erreurs retorses. Entre-temps, les id´ees li´ees `a la programmation dite « structur´ee » s’´etaient d´evelopp´ees, incarn´ees entre autres par le langage pascal, et le fortran a int´egr´e une bonne part de ces concepts. Deux normes officielles de fortran coexistent actuellement : fortran77 qui reste assez classique et fortran90 (ou fortran95 quasiment identique), beaucoup plus ´evolu´e, qui est appel´e ` a le remplacer progressivement et qui constitue la norme sur les gros calculateurs d´edi´es aux calculs lourds. Nous utiliserons ici la norme fortran95, principalement pour sa capacit´e ` a travailler sur des tableaux de nombres de fa¸con tr`es confortable et efficace8 . Le compilateur g77 qui fait partie de toutes les distributions Linux, librement diffus´e par gnu (Le mot anglais gnu d´esigne le gnou, une esp`ece de buffle, et le sigle gnu signifie : GNU’s Not Unix, un exemple d’autor´ef´erence typique d’un certain humour informatique), est bas´e sur fortran77, mais il int`egre un grand nombre de caract´eristiques de fortran90 ce qui en fait un outil puissant tout en gardant une grande simplicit´e. Toutefois, de bons compilateurs fortran95 (g95 et gfortran9) donc quasiment invisibles. 7 Il y eut aussi l’´ etape ruban perfor´ e qui permettait, avant les bandes, disquettes et autres supports magn´ etiques, d’enregistrer des donn´ ees : cet engin ´ etait -justement- surnomm´ e « la mitrailleuse » ! 8 Les programmes ´ ecrits en fortran77 peuvent ˆ etre compil´ es avec un compilateur fortran95. 9 Le compilateur g95 est ais´ ement t´ el´ echargeable sur http ://g95.org/. Le compilateur gnu gfortran commence a ` ˆ etre disponible comme faisant partie de certaines distributions
commencent `a ˆetre disponibles en libre diffusion et il n’y a donc gu`ere de raison de s’en priver. Des « nouvelles du front » ainsi que des compilateurs t´el´echargeables, peuvent ˆetre obtenus via le site : http ://programming.ccp14.ac.uk/fortran-resources/~ cgp/fortran.html
Dans les notes qui suivent, nous suivrons le « format libre » (ou free form) qui permet de s’affranchir de l’obligation de s’en tenir aux colonnes 7 `a 72 comme au bon vieux temps des cartes perfor´ees. . . Les compilateurs s’en accomodent en principe sans probl`eme encore que quelques fac´eties soient possible : on peut alors tenter d’utiliser l’option de compilation -ffree-form, voire lire le manuel d’utilisation du compilateur. . . La compilation s’effectue par la commande : g95 monboprog.f90 -o monboprog monboprog.f90 (ou tout autre nom se terminant par .f90) est le fichier, dit « fichier source » cr´e´e avec un ´editeur comme emacs, qui contient toutes les instructions ´ecrites en fortran10 . L’option -o (pour output ) indique au compilateur o` u il doit placer le r´esultat de son travail, ainsi le fichier monboprog contient le programme ex´ecutable, c’est-`a-dire sa traduction en langage machine11 . Evidemment, si l’on utilise un autre compilateur que g95 (par exemple gfortran12, pgf9013 ou xlf9014 ), il faut remplacer g95 par le nom du compilateur. Le r´esultat de la compilation est donc, quand tout s’est bien pass´e, un programme ex´ecutable qu’il reste `a faire travailler, mais en g´en´eral, au premier essai, il reste des erreurs de programmation que le compilateur d´etecte : il faut alors corriger le programme-source en tenant compte des diagnostics fournis par le compilateurs et re-compiler. . . jusqu’` a ce que c¸a marche ! (figure 2.2).
2.2 2.2.1
Notions ´ el´ ementaires. Instructions.
Une instruction tr`es simple de fortran peut ˆetre par exemple : a = b + c
elle signifie : 1. que l’on d´esigne par a, b et c trois emplacements dans la m´emoire vive de l’ordinateur, 2. que l’on prend le contenu des emplacements b et c, 3. que l’on en fait la somme (cela suppose qu’il s’agit de nombres) Linux (Debian et Fedora au moment o` u ces lignes sont ´ ecrites) et, convenablement install´ e, il paraˆıt plutˆ ot plus efficace ` a condition d’utiliser l’option -ffast-math. 10 certains compilateurs fortran90 exigent que le nom du fichier source se termine par .f. Pour d’autres, la terminaison .f signifie « format fixe » et la terminaison .f90, « format libre » 11 On peut fabriquer une commande personnelle de compilation, par exemple en cr´ eant un fichier appel´ e gf95 dans lequel on met la ligne : g95 $1.f90 -o $1. Ce fichier peut alors ˆ etre rendu ex´ ecutable par la commande : chmod +x gf95. Pour compiler un programme, il suffira dor´ enavant de taper : gf95 monboprog. Selon les besoins, gf95 peut ˆ etre modifi´ e ensuite pour inclure d’autres options de compilation comme -O3 (optimisation) ou des biblioth` eques de calcul. 12 version gnu. 13 compilateur commercial de Portland Group. 14 compilateur ibm.
18
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Edition : emacs monboprog.f90 &
Compilation : g95 monboprog.f90 −o monboprog
Exécution : ./monboprog
Fig. 2.2 – Le cycle de mise au point d’un programme : ´edition du fichier-source, compilation, ex´ecution. La compilation permet de d´etecter les erreurs de syntaxe que l’on ` l’ex´ecution, la corrige par un retour ` a l’´etape d’´edition. A prudence impose de tester le programme, en g´en´eral en faisant des calculs dont on connait le r´esultat : les erreurs ainsi d´etect´ees renvoient aussi ` a l’´edition. En principe, le cycle converge assez vite. . . 4. que l’on met le r´esultat dans l’emplacement a.
a = b + c
Ceci n’est pas un
=
Fig. 2.3 – Le signe = dans une instruction n’est pas une ´egalit´e math´ematique ! Il ne faut surtout pas s’imaginer que le signe = ci-dessus soit une ´egalit´e math´ematique ! Il s’agit d’une instruction, d’un ordre que l’on donne ` a l’ordinateur : on lui « dit » de calculer la valeur num´erique de ce qui se trouve `a droite du signe ´egal et de le placer dans l’emplacement de la m´emoire d´esign´e par le symbole qui se trouve ` a sa gauche. On peut consid´erer le signe ´egal comme une affectation ou une fl`eche :
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
Tab. 2.3 – Qu’est-ce qu’un syst`eme d’exploitation ? On doit, on l’a vu, mettre dans la m´emoire vive de l’ordinateur le ou les programmes que l’on utilise ainsi que les donn´ees correspondantes. C’est une des tˆ aches du syst`eme d’exploitation : quand, sous unix, on tape le nom d’un programme, un autre programme (ou plusieurs autres programmes) qui fait partie du syst`eme d’exploitation, lit les caract`eres que l’on tape sur le clavier, au passage reproduit ces caract`eres sur l’´ecran, puis va lire le fichier ex´ecutable au bon endroit sur le disque dur, l’installe ´ en m´emoire et lance son ex´ecution. Eventuellement, il fera apparaˆıtre un message du genre file not found ou toute autre chose de ce style. . . Si plusieurs programmes doivent s’´ex´ecuter en mˆeme temps, ou si plusieurs utilisateurs travaillent en mˆeme temps sur le mˆeme ordinateur, c’est le syst`eme d’exploitation qui r´epartira les ressources (m´emoire, processeur, disque dur, imprimantes, etc.) entre les programmes et les utilisateurs. C’est aussi au syst`eme d’exploitation que l’on a ` a faire lorsqu’il faut s’identifier comme utilisateur (login et mot de passe). Le syst`eme d’exploitation unix date du d´ebut des ann´ees 1970 ; il a d’abord ´et´e install´e sur des stations de travail « moyennes » mais il a rapidement envahi le monde des ordinateurs destin´e au calcul scientifique. Le premier syst`eme d’exploitation de Microsoft, dos (1981), est une version extrˆemement simplifi´ee d’unix, en particulier, il est mono-utilisateur, alors qu’Unix est multi-utilisateur, c’est-` a-dire que plusieurs personnes peuvent utiliser simultan´ement le mˆeme ordinateur : c’est particuli`erement important sur les grosses machines et les serveurs. En 1991, Linus Torvalds cr´ea linux, une version, compl`ete cette fois-ci, d’unix utilisable sur des ordinateurs personnels. Les machines utilis´ees pour les travaux pratiques de ce module tournent sous linux. Un grosse partie de la tˆ ache du syst`eme d’exploitation est de g´erer les p´eriph´eriques, en particulier, les disques (d’ailleurs le nom dos signifie disk operating system), car c’est l` a que se trouvent les donn´ees et les programmes. Un disque dur est en g´en´eral structur´e en r´epertoires : une partie du disque est r´eserv´ee au syst`eme d’exploitation, une autre aux utilisateurs (en g´en´eral home). Chaque utilisateur a son propre sousr´epertoire et souvent les utilisateurs sont organis´es en groupes (par exemple phys, math, chim,. . .). Si vous tapez par exemple la commande pwd (print working directory), vous obtiendrez quelque chose qui peut ressembler ` a: /home/phys/enseign/depondt c’est-` a-dire que le r´epertoire de travail courant depondt est en fait un sous-r´epertoire d’enseign, lui-mˆeme un sous-r´epertoire de phys, etc. La commande ls (list) donne la liste des fichiers et sous-r´epertoires pr´esents dans un r´epertoire. On peut cr´eer un r´epertoire (que l’on choisit d’appeler par exemple td1) par la commande mkdir td1 (make directory) par exemple et changer de r´epertoire par cd td1 (change directory) : pwd donnera alors /home/phys/enseign/depondt/td1. Depuis le milieu des ann´ees 1980, les syst`emes d’exploitation comportent ´egalement les icˆ ones et fenˆetres devenues coutumi`eres : quand on clique sur une icˆ one, on « dit » au syst`eme de lancer le programme correspondant au lieu de taper son nom sur le clavier. gnome ou kde sont des syst`emes de fenˆetrage qui viennent se greffer sur linux, mais on peut tr`es bien travailler sur des machines qui en sont d´epourvues : c’est un peu moins convivial. . . mais parfois plus robuste ! a = b
a = b
peut ˆetre compris comme a ← b
(mettre b dans a) et b = a
on met b dans a. Cela a quelques cons´equences pratiques, (mettre a dans b) ne signifient pas la mˆeme chose et les ainsi deux instructions :
19
Physique num´erique, Philippe Depondt
a = b
Tab. 2.4 – Quelques commandes Unix de base Beaucoup de choses peuvent ˆetre faites sous Unix en cliquant sur des icˆ ones : les gestionnaires de fenˆetre tels que kde ou gnome sont devenus tr`es similaires ` a Windows ou MacOS. Il est bon cependant de connaˆıtre les commandes de base d’Unix, d’une part parce que les icˆ ones sont loin d’ˆetre capables de tout faire et de l’autre, il est souvent sensiblement plus rapide de taper une commande dans un terminal que de d´eployer tout l’arsenal, graphique en particulier, qui accompagne les gestionnaires de fenˆetres et d’icˆ ones et qui est g´en´eralement gourmand en ressources. mkdir make directory cr´eer un r´epertoire pwd print working directory nom du r´epertoire courant cd change directory changer de r´epertoire cp copy copier des fichiers, rm remove effacer des fichiers mv move d´eplacer un fichier more more voir le contenu d’un fichier texte. lpr line printer imprimer a2ps ASCII to postscript imprimer un fichier texte emacs ´editeur de texte g95 compilateur fortran man manual manuel en ligne Par exemple : cp machin nouveau machin cr´ee un fichier qui est la copie de machin. On peut d´eplacer ou copier d’un r´epertoire ` a un autre : mv td1/prog.f td2 d´eplacera le fichier prog.f du r´epertoire td1 au r´epertoire td2. La plupart des commande ont des options marqu´ees par un tiret -, par exemple : g95 prog.f90 -O3 -o prog utilise deux options (optimisation, et nom du fichier de sortie), ou : lpr -Ppr1 figure.ps pr´ecise sur quelle imprimante l’impression doit se faire. Pour trouver les possibilit´es d’une commande et les options qu’elle peut utiliser : man nom de commande. Finalement, le r´epertoire courant est marqu´e par un point : . et le r´epertoire situ´e au-dessus du courant par deux points : .., ainsi cd . ne fait rien, mais cd .. remonte d’un cran dans la hierarchie des fichiers. Si l’on veut copier un fichier d’un autre r´epertoire vers le r´epertoire courant, on peut faire, par exemple, un cp /home/machin/truc/fichier origine . , o` u le point “.” est la destination de la copie.
Tab. 2.5 – Le BIOS ou Basic Input/Output System. Le BIOS est un programme qui est directement install´e par le constructeur sur la carte-m`ere (c’est-` a-dire la carte qui comporte le processeur, la m´emoire vive, etc.) de l’ordinateur et qui peut donc d´emarrer d`es la mise sous tension alors qu’aucun p´eriph´erique n’est encore op´erationnel. C’est lui qui, apr`es avoir identifi´e les p´eriph´eriques disponibles, charge le syst`eme d’exploitation qui se trouve, lui, g´en´eralement sur le disque dur, un CD, voire une disquette ou une autre machine accessible par r´eseau.
alors, a, b et c contiennent la valeur 3. . . Il s’agit donc bien de deux instructions ex´ecut´ees l’une apr`es l’autre dans l’ordre donn´e dans le programme. Finalement, l’instruction : i = i + 1
n’a rien d’absurde : il s’agit simplement de l’ordre d’augmenter la valeur de i de 1 (on prend i, on lui ajoute 1 et on met de r´esultat dans i). En revanche : a + b = 3*x + c
! ATTENTION, CECI N’A AUCUN SENS
est totalement d´epourvu de sens pour l’ordinateur car l’expression a + b `a gauche du signe = ne d´esigne pas un emplacement dans la m´emoire. . . pire encore : a = b = c ! CA NE PLAIRA PAS DU TOUT AU COMPILATEUR
`a droite du premier signe =, il y a une expression b = c qui ne peut pas ˆetre ´evalu´ee, puisque ce n’est pas une valeur, c’est une instruction !
2.2.2
D´ eclarations.
Tout ceci suppose cependant que l’on ait d´ej` a « dit » a` l’ordinateur que a, b et c sont des emplacements de la m´emoire destin´es `a contenir des nombres, par exemple des nombres r´eels : c’est ce qu’on appelle une d´eclaration. Ainsi la d´eclaration : real :: a, b, c
d´eclare que l’on va occuper trois emplacements m´emoire dor´enavant appel´es a, b et c et que l’on mettra des nombres r´eels dedans15 . Comme on peut changer la valeur du contenu de ces emplacements, on les appelle variables. Un nom de variable peut ˆetre simplement une lettre comme a ou x, ou alors une combinaison de lettres et de chiffres `a condition de commencer par une lettre, par exemple : agecpt, y2, zmax, mais pas : 2pi ou s*3 (* est un caract`ere sp´ecial d´esignant la multiplication). Le caract`ere “ ” « blanc soulign´e » ou underscore est ´egalement autoa ris´e : pere ubu ou nbr pas. La longueur peut aller jusqu’` 31 caract`eres : age du capitaine. Il ne faut pas utiliser les lettres accentu´ees, c´edilles, tr´emas, et autres signes diacritiques. Enfin, fortran ne fait pas la distinction entre lettres majuscules et minuscules (Zmin est identique `a zmin) alors que le syst`eme d’exploitation unix le fait (les fichiers resultats et Resultats sont distincts). On peut d´eclarer des nombres entiers, par exemple : integer :: i, m, nbrpas
a = b b = c
ou des nombres complexes : complex :: z, s
ne signifient pas que les trois nombres a, b et c soient ´egaux ! Cela signifie : « prendre le contenu de l’emplacement d´esign´e par la lettre b et le mettre dans a, puis modifer le contenu de b en y mettant le contenu de c ». Donc, apr`es coup, a et b peuvent ˆetre diff´erents. De mˆeme, l’ordre des instructions a une importance : mettons que l’on ait affect´e les valeurs, respectivement, 1, 2 et 3 ` a a, b et c. Les deux instructions ci-dessus aboutiront ` a avoir 2 dans a et 3 dans b et c. Mais si l’on intervertit les instructions : b = c
Toutes les d´ eclarations doivent figurer au d´ ebut du programme, avant les instructions dites « ex´ecutables ». Une instruction du type a = 3*b - c avec laquelle on « dit » `a l’ordinateur de faire quelque chose est ex´ecutable, une d´eclaration o` u l’on r´eserve de l’espace pour des variables ne l’est pas. 15 On utilise ici la forme fortran90 destin´ ee a ` prendre assez rapidement le relais de la forme fortran77 : real a, b, c, ´ egalement accept´ ee par g95.
20
Licence de physique L3 : Physique Fondamentale & PHYTEM,
L’affectation de valeurs initiales `a certaines variables peut ˆetre faite directement dans la d´eclaration :
Tab. 2.6 – Liste des types de variables : d´eclaration type des variables integer entier real r´eel double precision r´eel en double pr´ecision complex complexe double complex complexe en double pr´ecision character chaˆıne de caract`eres logical variable logique
program addition implicit none real :: a, b = 1.414, c = 1.732 a = b + c write(*,*) a end
En fortran, il existe ce que l’on appelle des d´eclarations implicites, survivance des anciennes versions de ce langage de programmation, qu’il est formellement d´econseill´e d’utiliser16 . Pour les rendre inop´erantes, on utilise l’instruction : implicit none
2.2.3
Op´ erations nombres.
´ el´ ementaires
sur
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
les
Un programme ´el´ementaire pourrait donc ˆetre : program addition ! DEBUT DU PROGRAMME implicit none ! PAS DE DECLARATIONS IMPLICITES real :: a, b, c ! DECLARATION DE 3 VARIABLES REELLES ! DEBUT DES INSTRUCTIONS EXECUTABLES b = 1.414 ! PLACER LA VALEUR 1.414 DANS b c = 1.732 ! PLACER LA VALEUR 1.732 DANS c a = b + c ! SOMMER & PLACER LE RESULTAT DANS a write(*,*) a ! IMPRIMER LE CONTENU DE a end ! FIN DU PROGRAMME
L’instruction end marque la fin du programme. L’instruction program donne un nom au programme qui peut ˆetre distinct du nom du fichier-source qui le contient. Tab. 2.7 – Liste des op´erations sur les nombres : L’addition La soustraction La multiplication La division La mise `a la puissance
s’´ecrit s’´ecrit s’´ecrit s’´ecrit s’´ecrit
: : : : :
+ * / **
e.g. e.g. e.g. e.g. e.g.
: : : : :
a + b 3. - x a*b p/q x**p
On peut m´elanger les types integer, real, double precision, complex et double complex au sein de la mˆeme expression. Ainsi : complex :: z, t integer :: k = 392 real :: x = 1.03 , y = 0.707 z = (3.7,9.03) t = x**2 + (k-1)/z**y
calcule x2 + k −y 1 . Le r´esultat est un nombre complexe. z Noter qu’un nombre complexe s’´ecrit en donnant parties qui calcule la somme de 1,414 et 1,732 et imprime le r´esultat (instruction write). Il faut noter que le passage r´eelle et imaginaire entre parenth`eses et s´epar´ees par une a la ligne signifie la fin d’une instruction, ` ` a la diff´erence virgule. d’autres langages comme pascal ou C. On peut cependant ´ecrire plusieurs instructions par ligne en les s´eparant 2.3 Premi` eres boucles. par un point-virgule, ainsi : program addition implicit none real :: a, b, c b = 1.414 ; c = 1.732 ; a = b + c write(*,*) a end
La d´ecimale des constantes r´eelles est marqu´ee par un point et non une virgule (1.414 et non 1,414). Une constante r´eelle doit comporter un point : 1. est une constante r´eelle, mais 1 est une constante enti`ere, 2./3. est une constante r´eelle qui vaut 0,666667, alors que 2/3 est une constante enti`ere, r´esultat de la division du nombre entier 2 par le nombre entier 3, elle vaut donc z´ero ! On peut aussi utiliser la notation dite « scientifique » (comme avec une calculette) pour les nombres r´eels, 1, 6 10−19 s’´ecrit : 1.6e-19, c’est plus ´economique qu’aligner de nombreux z´eros. . . La lettre e ne d´esigne pas ici une variable mais indique l’exposant17 . 16 La raison en est que si l’on fait une faute de frappe en tapant le nom d’une variable (par exemple nb pas au lieu de nbr pas), l’ordinateur cr´ eera simplement une nouvelle variable, avec des r´ esultats. . . impr´ evisibles ! Si l’on rend obligatoire la d´ eclarations de toutes les variables, alors le compilateur d´ etectera en principe une variable non-d´ eclar´ ee et produira un message d’erreur appropri´ e. 17 on peut parfaitement ´ ecrire une instruction du type : e = 1.6e-19, il n’y a aucune confusion possible.
2.3.1
Pour quoi faire ?
L’une des grandes qualit´es des ordinateurs est leur capacit´e `a effectuer des calculs r´ep´etitifs avec des valeurs num´eriques diff´erentes. Imaginons par exemple que l’on veuille calculer x3 pour x variant de -10 `a +10 par pas de 0,1. On pourrait bien sˆ ur ´ecrire : implicit none real :: x = -10.0, y y = x**3 x = x + 0.1 ; y = x**3 x = x + 0.1 ; y = x**3 x = x + 0.1 ; y = x**3 x = x + 0.1 ; y = x**3 x = x + 0.1 ; y = x**3 ...
etc. L’instruction x = x + 0.1 prend la valeur de x en m´emoire, lui rajoute 0,1 et ´ecrit le r´esultat dans le mˆeme emplacement : le contenu de x est donc augment´e de 0,1. Donc, x commence par valoir -10, puis −10 + 0, 1 = −9, 9 et l’on calcule y, puis 9,8 avec un nouveau calcul de y, etc. On remarque cependant que la s´equence : x = x + 0.1 ; y = x**3
doit ˆetre r´ep´et´ee autant de fois que l’on veut faire le calcul (ici, 201 fois).
21
Physique num´erique, Philippe Depondt
2.3.2
Pratiquement. . .
2.3.3
Boucles imbriqu´ ees
Une fa¸con plus ´el´egante de proc´eder consiste ` a utiliser Les boucles peuvent ˆetre imbriqu´ees les unes dans les une boucle afin de r´ep´eter un grand nombre de fois le mˆeme autres : calcul en faisant varier un param`etre, ainsi : implicit none integer :: i real :: x, y do i = -100, 100 x = 0.1*i y = x**3 enddo
signifie que l’instruction y = x**3 doit ˆetre r´ep´et´ee pour toutes les valeurs de l’indice i allant de -100 `a 100 : ainsi x prend successivement les valeurs -10., -9.9, . . .0.1, 0., 0.1,. . .9.9, 10.18 et l’on doit calculer y pour chacune de ces valeurs. L’instruction enddo marque la fin du « bloc » : toutes les instructions comprises entre do et enddo font partie du mˆeme ensemble qui doit ˆetre ex´ecut´e pour chaque valeur de i. Il faut remarquer au passage qu’` a chaque tour de la boucle la variable y est modifi´ee et que donc les anciennes valeurs sont oubli´ees : ` a la fin, seule la derni`ere valeur calcul´ee reste. Il faut donc penser ` a faire quelque chose des valeurs interm´ediaires si on en a besoin : les ´ecrire par exemple. Ainsi, implicit none complex :: z, zim=(0.0,1.0) integer :: i real :: omega = 6.283185, t do i = 0, 1000 t = 0.1*i z = exp(zim*omega*t) ; write(*,*) t, z enddo
va calculer z = eiωt pour t variant de 0 ` a 100, par pas de 0, 1 et ´ecrire les r´esultats sur l’´ecran. Noter la d´eclaration du nombre imaginaire i dans la variable zim, dont la partie r´eelle est nulle et la partie imaginaire ´egale ` a 1. Un autre exemple : implicit none integer :: k, s2 = 0 do k = 1, 10 s2 = s2 + k**2 enddo
calcule la somme des 10 premiers carr´es. Le pas de la boucle est implicitement ´egal ` a 1, mais on peut le choisir explicitement : do k = 1, 10, 2 s2 = s2 + k**2 enddo
do k = kmin, kmax ... do ix = ixmin, ixmax ... enddo ... enddo
ainsi, la boucle interne sur x s’ex´ecutera pour chaque valeur de k et les instructions qu’elle comporte se r´ep´eteront donc (kmax-kmin+1)*(ixmax-ixmin+1) fois : cela peut faire beaucoup. Par exemple, si kmax=1000, kmin=1, ixmax=10000, ixmin=1, la boucle interne s’ex´ecutera 107 fois, et si elle prend 10−3 seconde `a l’ex´ecution, le programme, lui, prendra 104 s soit 2h45mn ! Si maintenant, la boucle externe est elle-mˆeme imbriqu´ee dans une autre boucle, on obtient tr`es facilement un programme tr`es lourd. . .
2.3.4
Boucles munies d’un nom
Quand plusieurs boucles sont imbriqu´ees, il est parfois utile de leur donner un nom afin de clarifier le d´ebut et la fin de chacune : boucle1 : do k = kmin, kmax ... ... boucle2 : do i = imin, imax ... ... enddo boucle2 ... ... enddo boucle1
2.4
Conditions.
Il arrive que l’on veuille que certaines instructions ne s’ex´ecutent que dans certaines conditions. Par exemple, si l’on a calcul´e une quantit´e y, on peut en vouloir la racine carr´ee uniquement si y est positif :
calcule la somme 12 + 32 + 52 + 72 + 92 , et : do k = 10, 1, -1 ... enddo
descend de 10 `a 1. Note « esth´etique » : les instructions du bloc compris dans la boucle sont d´ecal´ees d’une ou plusieurs colonnes, c’est l’indentation. Cela ne pr´esente aucun caract`ere obligatoire et ne fait pas partie des r`egles du langage, mais c’est une bonne habitude qui rend la lecture des programmes nettement plus facile. 18 On note au passage que l’expression 0.1*i m´ elange une constante r´ eelle et un entier : le r´ esultat est r´ eel.
if( y > 0.0 ) then z = sqrt(y) endif
La fonction sqrt qui calcule la racine carr´ee (square root) est dite « intrins`eque » parce qu’elle fait partie des fonctions que tout compilateur fortran doit fournir. L’expression y > 0.0 est du type logique, cela signifie qu’elle ne peut prendre que deux valeurs : .TRUE. (vrai) si y > 0 et .FALSE. (faux) si y ≤ 0. Deux ´ecritures sont possibles pour les op´erateurs logiques, premi`ere et deuxi`eme colonnes ci-dessous :
22
Licence de physique L3 : Physique Fondamentale & PHYTEM,
> < >= <= == /=
.gt. .lt. .ge. .le. .eq. .ne. .and. .or. .not.
> (greater than) < (less than) ≥ (greater or equal ) ≤ (less or equal ) = (equal ) 6 = (not equal ) et ou contraire d’une expression logique
Ne pas oublier les points de part et d’autre des op´erateurs logiques de la deuxi`eme colonne. L’op´erateur logique == qui est une comparaison, est distinct du signe « d’´egalit´e » = qui signifie en fait « mettre quelque chose dans une variable ». L’expression : a == b
est une expression logique qui prend une valeur, soit vraie soit fausse, et a = b
est une instruction qui place la valeur de b dans a. . ., ainsi, integer :: a, b logical :: ok ok = a == b
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
if( y < 0.0 ) write(*,*) ’y est negatif !’ z = sqrt(y)
Ici, on se borne `a mettre un message d’avertissement, mais l’instruction suivante s’ex´ecutera de toutes fa¸cons et le programme donnera la valeur NaN (Not a Number ) `a z. On peut aligner autant de else if que l’on souhaite19 . Cependant si l’on a une s´erie de possibilit´es `a envisager, l’instruction select case20 peut ˆetre plus commode. Par exemple : implicit none integer :: a write(*,*) ’entrer un nombre’; select case( a ) case( : 1 ) write(*,*) ’a est plus petit case( 10 : ) write(*,*) ’a est plus grand case (2 : 3 ) write(*,*) ’a est entre 2 et case default write(*,*) ’a est entre 4 et end select end
read(*,*) a
ou egal a 1’ ou egal a 10’ 3’ 9’
Un autre exemple, pour convertir des unit´es anglosaxonnes en unit´es m´etriques :
signifie que la variable logique ok prend la valeur .TRUE. program metre si a et b sont ´egaux et .FALSE. sinon. implicit none On peut aussi utiliser des variables logiques de fa¸con real, parameter plus compliqu´ee : logical :: ok real :: x, y ... ... ok = y > 0.0 .and. x <= y if (.not. ok ) then write(*,*) ’Il y a un probleme quelque part’ stop endif
L’instruction stop arrˆete l’ex´ecution du programme. On peut pr´evoir une alternative : si une condition est v´erifi´ee, on fait une chose, sinon on fait autre chose : if( y >= 0.0 ) then z = sqrt(y) else write(*,*) ’y est negatif’ stop endif
Le deuxi`eme volet de l’alternative peut ˆetre lui-mˆeme soumis a` condition : if( y >= 0.0 ) then z = sqrt(y) else if ( y > -0.0001 ) then write(*,*) ’y est compris entre -0.0001 et 0.0 :’ write(*,*) ’on le considere comme presque nul’ z = 0. else write(*,*) ’y est franchement negatif’ stop endif
Si l’on n’a qu’une instruction ` a ex´ecuter dans le if, on peut la fusionner dans l’instruction if :
:: c = 0.3048, kt = 1.852, & mph = 1.609, & gallon = 3.7854118, lbs = 0.45455 real :: l character(len=10) :: unit ! le premier argument de la ligne de commande est la ! quantite, le deuxieme l’unite. ! s’il n’y a pas deux arguments, poser la question ! explicitement if ( command_argument_count() >= 2 ) then call get_command_argument(1,unit) read(unit,*) l ! convertir la chaine de caracteres ! en reel (cf ’chaines de caracteres’) call get_command_argument(2,unit) else write(*,’("Entrer la longueur et l’’unite ",$)’) read(*,*) l, unit endif select case(trim(unit)) case (’ft’,’feet’,’foot’,’pieds’,’pied’) write(*,*) l*c,’ metres’ case (’in’,’inch’,’inches’,’pouces’,’pouce’) write(*,*) 1000.*l*c/12.,’ mm’
19 Pour bien appr´ ecier le confort (et la s´ ecurit´ e) qu’apporte la structure if(...) then, il faut rappeler le fonctionnement du if arithm´ etique en usage dans les premi` eres version du langage fortran : if(k) 100,101,102 100 .... go to 103 101 .... go to 103 102 ... 103 ... ce qui signifie que si k est n´ egatif, l’on va a ` l’´ etiquette 100, si k est nul, alors on va en 101 et sinon en 102, apr` es quoi, l’instruction situ´ ee en 103 est ex´ ecut´ ee. Bien ´ evidemment, rien n’empˆ eche, par exemple, un go to 101 n’importe o` u ailleurs dans le programme. . . 20 h´ eriti` ere du go to calcul´ e d’antan.
23
Physique num´erique, Philippe Depondt
program racines case(’m’,’metres’) implicit none write(*,*) l/c,’ ft’ real :: xmin, xmax, dx, x, y case(’kt’,’kts’,’knots’,’noeuds’) integer :: i, imin, imax write(*,*) l*kt,’ km/h’ write(*,*) ’** Ce programme calcule **’ case(’nm’) write(*,*) ’** une serie de racines carres **’ write(*,*) l*kt,’ km’ write(*,*) ’Tapez sur le clavier’ case(’mph’) write(*,*) ’les valeurs de xmin et xmax :’ write(*,*) l*mph,’ km/h’ read(*,*) xmin, xmax case(’mile’,’miles’) write(*,*) ’Donnez egalement le pas :’ write(*,*) l*mph,’ km’ read(*,*) dx case( ’gal’, ’gallon’, ’gallons’) imin = xmin/dx ; imax = xmax/dx write(*,*) l*gallon, ’l’ case(’lbs’, ’lb’, ’pound’, ’pounds’,’livre’, ’livres’)do i = imin, imax x = i*dx write(*,*) l*lbs, ’kg’ if( x < 0.0 ) then case default write(*,*) ’x est negatif : x=’, x write(*,*) ’unite inconnue’ else end select y = sqrt(x) end write(*,*) ’la racine carree de ’,x, ’ est ’, y de sorte que l’on obtient, par exemple : endif ~$ metres 175 lbs enddo end 79.54625 kg
2.5
Entr´ ees-sorties.
Il s’agit des instructions d’´ecriture et de lecture.
2.5.1
´ Ecran et clavier.
L’instruction : write(*,*) x
2.5.2
Les fichiers.
2.5.2.1
Fichier texte
Ce que l’on ´ecrit sur l’´ecran disparaˆıt assez rapidement. Si l’on veut conserver des r´esultats de calcul afin de les relire ou les traiter avec un autre programme ou encore les utiliser pour tracer une courbe, il faut les ´ecrire dans un fichier du disque dur de l’ordinateur. Pour cela, il faut commencer par « dire » que l’on veut ´ecrire dans un fichier avec l’instruction open :
´ecrit sur l’´ecran du terminal la valeur de x. Si x vaut open(1,file=’resultats’) 3,14159, on obtiendra 3.14159. En revanche : write(*,*) ’x’
´ecrira la lettre x sur l’´ecran, puisque ’x’ d´esigne une chaˆıne de caract`eres. Par exemple : write(*,*) ’x=’, x
Ainsi, on fait le lien entre le fichier resultats et l’unit´e 1 : maintenant, si l’on ´ecrit dans cette unit´e, cela revient `a ´ecrire dans ce fichier, par exemple : open(1,file=’resultats’) write(1,*) x, y write(1,*) ’Age du capitaine = ’, agdcpt
donnera : x= 3.14159, l’ordinateur commence par ´ecrire la chaˆıne de caract`eres x=, puis la valeur de la variable x. ´ecrit dans le fichier resultats. L’instruction : Lorsqu’on a fini d’´ecrire on « ferme » le fichier `a l’aide de
read(*,*) x
lit sur le clavier du terminal la valeur de x. Ainsi : read(*,*) x write(*,*) ’Vous venez de taper x=’, x
a pour effet que le programme arrivant ` a l’instruction read s’interrompt pour attendre que l’on tape quelque chose sur le clavier, puis repart pour ex´ecuter l’instruction suivante. Le premier * dans (*,*) apr`es read et write repr´esente l’unit´e d’´ecriture ou de lecture, c’est ` a dire l’endroit o` u l’on ´ecrit ou o` u l’on lit : il s’agit du clavier ` a la lecture et de l’´ecran `a l’´ecriture. Le deuxi`eme repr´esente le format, c’est-`a-dire, par exemple pour un nombre r´eel, le nombre de colonnes qu’il doit occuper et le nombre de chiffres apr`es la d´ecimale : on peut le pr´eciser explicitement, mais en g´en´eral le format * (list directed format en anglais ou : format contrˆol´e par la liste [des arguments]), o` u l’ordinateur doit se d´ebrouiller avec ce qu’on lui fournit, convient tr`es bien. Voici donc un programme qui r´esume ce qui pr´ec`ede :
close(1)
Ce que l’on obtient est un fichier texte que l’on peut lire et modifier (sous unix et non dans le programme lui-mˆeme) `a l’aide d’un ´editeur comme emacs ou vi, par exemple : emacs resultats &
ou bien, si l’on souhaite seulement le lire sans en modifier le contenu : more resultats
Si, dans un mˆeme programme, l’on fait plusieurs ´ecritures `a la suite les unes des autres, elles se placeront les unes derri`ere les autres dans le fichier tant que l’on ne ferme pas le fichier avec un close. Mais, si apr`es un close, l’on refait un open sur le mˆeme fichier, on se retrouve au d´ebut de celui-ci et une nouvelle ´ecriture va donc ´ecraser ce qui s’y trouvait d´ej` a : prudence ! La lecture dans un fichier se fait de la mˆeme fa¸con :
24
Licence de physique L3 : Physique Fondamentale & PHYTEM,
open(10, file=’donnees’) read(10,*) a, b, c close(10)
2.5.3
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
Les formats.
Pour une ´ecriture en mode texte, fichier ou ´ecran, on peut pr´eciser la fa¸con dont on veut que les choses soient On peut ouvrir plusieurs fichiers simultan´ement `a condi- ´ecrites. Ainsi, tion de leur donner des num´eros d’unit´e diff´erents : write(*,’(i5)’) k
open(10, file=’coefficients’) open(11, file=’bornes’) open(12, file=’polynome’) read(10,*) a, b, c read(11,*) xmin, xmax, dx imin = xmin/dx ; imax = xmax/dx do i = imin, imax x = i*dx y = (a*x + b)*x + c write(12,*) x, y enddo close(10) ; close(11) ; close(12) end
´ecrira le nombre entier (i pour integer ) k avec 5 chiffres. On notera la syntaxe : la deuxi`eme * du write est remplac´ee par : ’(...)’ o` u les trois points d´esignent la description du format. De mˆeme : write(*,’(f10.3)’) r
doit ´ecrire le nombre r´eel (f pour float, c’est-`a-dire `a d´ecimale flottante) r avec 10 caract`eres (y compris le point de la d´ecimale) dont 3 apr`es la « virgule » : 123456.789 ou 1.414 (avec 5 espaces, repr´esent´es ici par le symbole , pour compl´eter). Si l’on doit ´ecrire plusieurs nombres `a la suite de la mˆeme fa¸con, il n’est pas utile de r´ep´eter explicitement le format, il suffit de le faire pr´ec´eder du Caveat ! Imaginons que l’on ait ´ecrit un programme nombre de fois que l’on veut l’utiliser : dans un fichier-source calcul.f90. On compile avec la write(*,’(3f12.4)’) x,y,z commande habituelle et on lance l’ex´ecution. . ., or dans le programme, il y a les instructions : ´ecrira trois nombres r´eels sur 12 caract`eres (soit 36 colonnes en tout, sachant qu’une feuille de papier ou un teropen(10,file=’calcul.f90’) minal font en g´en´eral 80 colonnes) avec chacun 4 chiffres write(10,*) x, y, z apr`es la d´ecimale, par exemple : close(10) 1234567.8912 3.14161048576.4321 Question : qu’arrivera-t-il au programme-source ? attention, dans cet exemple, il y a bien trois nombres, Ce sont des choses que l’on voit r´eguli`erement arriver, mais le dernier occupe les 12 colonnes, et donc, il n’y a au grand d´esarrois des victimes, car il ne reste plus alors pas d’espace qui le s´epare du pr´ec´edent. On peut mettre des chaˆınes de caract`eres dans un forqu’` a tout retaper mˆeme si calcul.f90 comportait des centaines de lignes ! Un homme - ou une femme - pr´evenu(e) mat : en vaut deux. . . write(*,’("L’’age du capitaine est : ")’) write(*,’(i2," ans")’) age_captain
2.5.2.2
Fichier binaire
L’´ecriture d’un fichier texte suppose que les nombres qui sont stock´es en binaire dans la m´emoire vive de l’ordinateur soient traduits du binaire en caract`eres alphanum´eriques : par exemple le nombre entier 19 s’´ecrit 10011 en binaire et doit ˆetre converti en un caract`ere 1 suivi du caract`ere 9 avant d’ˆetre ´ecrit comme du texte. Il arrive que l’on ait `a produire un tr`es grand nombre de nombres et que cette conversion prenne un temps de calcul non n´egligeable, sans compter la taille du fichier r´esultat. Dans ce cas, on peut avoir int´erˆet ` a ´ecrire directement du code binaire dans le fichier. Evidemment, dans ces conditions on ne peut plus lire ce fichier avec un ´editeur ou l’imprimer sur une imprimante, mais cet inconv´enient n’est pas tr`es important dans le cas pr´esent : qui irait lire directement un fichier de plusieurs centaines de kilo-octets de nombres ? Le but ici est de stocker des donn´ees en vue d’une utilisation ult´erieure `a l’aide d’un autre programme21. Lors de l’ouverture, il suffit de sp´ecifier que le fichier doit ˆetre « non-formatt´e » : open(1,file=’nfich binaire’,form=’unformatted’)
Dans ce cas, il vaut mieux, bien sˆ ur, que le capitaine ne soit pas centenaire. . . Noter que l’apostrophe doit ˆetre redoubl´ee (sinon le compilateur interprˆete cela comme la fin de la chaˆıne de caract`eres). Le format exponentiel ( ou « notation scientifique ») est une autre possibilit´e pour les r´eels, par exemple : ev =1.6e-19 write(*,’("eV=",e13.5)’) ev
donne : eV= 0.16000E-18, soit 13 caract`eres, dont 5 apr`es la virgule. Le format g (g´en´eral) combine f et e x = 1. ; ev = 1.6e-9 write(*,’("x=",g13.5," eV = ",g13.5)’) x, ev
donne : x= 1.00000 eV = 0.16000E-08. C’est assez commode lorsqu’on veut ´ecrire des nombres dont on ne connait pas a priori l’ordre de grandeur, tout en contrˆolant la place qu’ils prendront pour une mise en page. La lettre x dans un format signifie un espace, le symbole / un passage `a la ligne. Au contraire, $ inhibe le passage `a la ligne apr`es un write. Par exemple :
Les instruction d’´ecriture et de lecture se passent alors write(*,’("Donnez l’’age du capitaine : ",$)’) read(*,*) agecpt de sp´ecification de format : write(1) x, y, z read(1) a, b, c 21 Il faut aussi signaler qu’un tel fichier est moins transportable qu’un fichier texte : le codage binaire d´ epend du processeur et si l’on veut utiliser des donn´ ees sur une autre machine que celle o` u elles ont ´ et´ e produites (par exemple un gros calculateur vers un PC linux), alors il est parfois indispensable de passer par l’´ etape texte.
Lors de l’ex´ecution du programme, la question et la r´eponse apparaˆıtront sur la mˆeme ligne du terminal. Les chaˆınes de caract`eres peuvent s’´ecrire avec le format a: salut = "Bonjour" write(*,’(a7)’) salut
25
Physique num´erique, Philippe Depondt
2.6
Les fonctions intrins` eques.
2.7
Autres boucles.
fortran fournit un grand nombre de fonctions in- 2.7.1 do while trins`eques comme sqrt d´ej` a vu et qui permet de calculer La boucle do while permet des logiques plus comla racine carr´ee de son argument. pliqu´ ees que celles qu’on a d´ej` a vues, par exemple : En voici quelques unes : sqrt abs exp log log10 sin asin cos acos tan atan int nint real aimag conjg trim len trim
racine carr´ee valeur absolue exponentielle logarithme logarithme d´ecimal sinus arcsinus cosinus arccosinus tangente arctangente troncature d’un r´eel en entier arrondi d’un r´eel (nearest integer ) partie r´eelle d’un nombre complexe partie imaginaire d’un nombre complexe conjugu´e d’un nombre complexe troncature d’une chaˆıne de caract`eres apr`es le dernier non-blanc nombre de caract`eres de la chaˆıne tronqu´ee
Par exemple : implicit none real :: e0, t, omega, tfin, dt integer :: it, itfin ... itfin = tfin/dt do it = 0, itfin t = it*dt ; write(1,*) t, e0*cos(omega*t) enddo
Les arguments des fonctions trigonom´etriques sont en radians, donc si l’on veut travailler en degr´es, il faut faire la conversion : real :: pi, angle pi = acos(-1.0) write(*, ’("Donnez un angle en degres : ",$)’) read(*,*) angle write(*,*) ’le sinus de ’, angle,’ degres’ write(*,*) ’est ’, sin(pi*angle/180.)
La diff´erence entre int et nint est que si x vaut, par exemple 1,6, alors int(x) donne 1 alors que nint(x) donne 2. On peut utiliser une fonction comme argument d’une autre, ainsi, par exemple, le module d’un nombre complexe z s’´ecrit √ : sqrt(z*conjg(z)), la transcription de l’expression zz ∗ . La commande info g77 permet d’acc´eder, apr`es quelques manipulations, ` a la liste des fonctions intrins`eques connues par g77 (il y en a beaucoup) ainsi qu’` a leur mode d’emploi. Ces renseignements sont donn´es en anglais, mais il n’est pas mauvais de se frotter de temps en temps `a ce genre de documentation. Ces informations ne sont ´evidemment valides en toute rigueur que pour g77, toutefois les fonctions les plus usuelles sont communes ; si le compilateur utilis´e ne reconnait pas une fonction suppos´ee intrins`eque22 , il faut alors consulter une documentation sp´ecifique (Fortran95/2003 explained par exemple). 22 Par
exemple, g77 fait la distinction entre real(z), conversion en
open(1,file=’donnees’) read(1,*) x do while ( x > 0. ) write(*,*) ’La racine de’,x,’ est’, sqrt(x) read(1,*) x enddo close(1)
va lire des valeurs de x dans le fichier tant que la derni`ere valeur de x reste positive, et `a la premi`ere valeur n´egative trouv´ee, l’on passera `a l’instruction close. –Exercice : trouver pourquoi l’on a mis le write avant le read. L’avantage de ce type de boucle est que l’on peut faire des choses assez sophistiqu´ees ; c’est s´eduisant, souvent efficace, mais parfois dangereux, ainsi : implicit none real :: x, dx = 0.1 .... x = 1.0 do while ( x > 0.0 ) ... x = x + dx .. enddo
–Exercice : montrer pourquoi cette boucle va tourner ind´efiniment. . .
2.7.2
Boucles infinies : exit et cycle.
On peut aussi faire des boucles « infinies » dont on ne sort que grˆace `a exit : do write(*,’("Entrer un nombre positif : ",$)’) read(*,*) x if ( x >= 0. ) exit write(*,*) "Apprenez a lire !" enddo y = sqrt(x)
Tant que l’on entrera des nombres n´egatifs, on aura droit `a l’aimable invitation d’apprendre `a lire, mais d`es le premier nombre positif, le programme en calculera la racine carr´ee. L’instruction cycle permet de r´ep´eter une boucle partiellement : do write(*,’("Entrer un nombre positif : ",$)’) read(*,*) x if ( x < 0 ) cycle y = sqrt(x) write(*,*) ’La racine carree de’,x,’ est ’, y if( x == 0. ) exit enddo type r´ eel, et realpart(z), partie r´ eelle d’un complexe, alors que la norme fortran95 pr´ evoit que real prenne justement la partie r´ eelle si son argument est complexe si bien que realpart n’existe pas.
26
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
` chaque fois que l’on tape un nombre n´egatif, l’on obtien- 2.7.3 Boucles a dra la requˆete d’un nombre positif sans que le calcul de la Plutˆ ot qu’´ecrire : racine ne soit fait ; en revanche, si l’on entre un nombre positif, on en obtiendra la racine, et enfin si ce nombre est do i = 1, n write(1,*) x(i) nul (strictement : on verra un peu plus loin ce que cela enddo signifie) on sort de la boucle. Autre exemple : v´erifier qu’un fichier existe d´ej` a avant on peut ´ecrire : de tenter de l’ouvrir en lecture,
implicites.
write(1,*) ( x(i), i = 1, n )
! declaration d’une chaine de 40 caracteres ! qui devra contenir le nom du fichier character (len=40) :: n_fic ! nom de fichier logical :: ok ! variable logique
La diff´erence est que dans le deuxi`eme cas tous les ´el´ements du tableau24 sont ´ecrits sur la mˆeme ligne, sauf si on le pr´ecise par format. Plus concis encore, si x est un tableau :
do
´ecrit tout le tableau. On peut faire la mˆeme chose avec read.
write(*,’(‘‘Nom du fichier de donnees : ‘‘,$)’) read(*,*) n_fic ! lire au clavier le nom du fichier ! inquire est une commande FORTRAN permettant de ! verifier l’existence du fichier inquire(file=n_fic,exist=ok) ! existe: ok = .TRUE. if ( ok ) exit ! et on n’insiste pas ! sinon, il faut recommencer write(*,’(‘‘Fichier non trouve’’)’) enddo open(10,file=n_fic) ! ouverture du fichier ...
Les boucles infinies, assorties de exit et cycle, tendent ` remplacer le do while, souvent consid´er´e comme oba sol`ete. Le until du pascal n’existe pas en fortran : de fait, exit et cycle sont beaucoup plus riches, puisqu’ils peuvent ˆetre plac´es n’importe o` u dans la boucle, et non seulement au d´ebut comme while ou ` a la fin comme until23. Si les boucles ont un nom, exit et cycle en tiennent compte : l1 : do ... l2 : do ... if ( age_du_capitaine < 0 ) exit l1 ... if ( ok ) cycle l2 ... enddo l2 ... enddo l1
write(1,*) x
2.8
Tableaux.
Les tableaux de nombres sont l’´equivalent informatique des vecteurs et des matrices : on peut ainsi d´esigner plusieurs nombres par une seule variable ; le vecteur V de dimension n d´esigne l’ensemble de ses n ´el´ements vi , i ∈ [1, n], la matrice A de dimension (n, m) d´esigne tous les n × m ´el´ements aij , le tenseur T de rang 3 d´esigne tous les ´el´ements tijk , et ainsi de suite. Comme dans ces exemples, un ou plusieurs indices entiers servent `a indiquer l’´el´ement voulu du tableau. Avec les tableaux, on acquiert la capacit´e `a traiter, comme s’il s’agissait d’une seule entit´e, un grand nombre de donn´ees, pour ainsi dire « d’un coup » !
2.8.1
D´ eclaration
La d´eclaration d’un tableau est faite en indiquant les valeurs extrˆemes des indices de chacune des dimensions du tableau, par exemple : real, dimension(1:100) :: x
d´eclare un tableau `a un seul indice qui va de 1 `a 100, c’est`a-dire un tableau unidimensionnel de r´eels `a 100 ´el´ements ou un vecteur `a 100 coordonn´ees si l’on pr´ef`ere. Le i-`eme ´el´ement est d´esign´e par x(i) ; i est bien entendu un entier. Par exemple : real, dimension(0:100) :: x real :: pi = acos(-1.0) integer :: i
Le exit l1 fait sortir de la boucle l1, la plus externe, alors do i = 0, 100 que l’instruction se trouve dans la boucle la plus interne : x(i) = cos(i*pi/100.) c¸a permet de sauter par dessus un niveau d’imbrication. enddo 23 L’int´ erˆ et de ces structures est r´ eel, toutefois pour relativiser, notons qu’en fortranIV, on pouvait tr` es bien fabriquer des logiques similaires a ` ce que permettent exit et cycle, l’esprit ´ etait simplement moins orient´ e « programmation par bloc » et il fallait s’astreindre a ` un minimum de discipline, par exemple : do 100 i = 1, 1000000 ... c ici l’equivalent d’un ‘‘cycle’’ if ( x .gt. y ) go to 100 ... c ici l’equivalent d’un ‘‘exit’’ if ( z .le. 0. ) go to 200 ... 100 continue 200 ... Il ´ etait prudent d’´ eviter de placer l’´ etiquette 200 a ` l’autre bout du programme, du moins si l’on avait l’ambition d’´ ecrire un code « maintenable ». . .
remplit un tableau de 101 ´el´ements avec les valeurs prises par cos θ avec θ ∈ [0, π] par pas de π/100. On peut faire des d´eclarations du genre : real, dimension(-100:100) :: x
ce qui donne dans ce cas un tableau `a 201 ´el´ements dont l’indice varie de -100 `a 100, et alors, on peut acc´eder `a des ´el´ements comme par exemple x(-20). La d´eclaration real, dimension(100) :: x est ´equivalente `a real, dimension(1:100) :: x25 . Pour les tableaux `a plusieurs dimensions, il faut sp´ecifier les valeurs extrˆemes de chacun des indices : 24 voir
les tableaux dans la section suivante. la diff´ erence du langage C pour lequel les tableaux commencent avec l’´ el´ ement 0. 25 a `
27
Physique num´erique, Philippe Depondt
integer, dimension(1:25,-2:2) :: a
integer :: i real, dimension(-2:2) :: x=(/ (2*i, i=-2,2) /)
d´eclare un tableau `a deux dimensions d’entiers de 25 × 5. Le premier indice va de 1 ` a 25, le deuxi`eme de -2 `a 2. Un ´el´ement est donc d´esign´e, par exemple, par a(i,j) ou 2.8.2 a(12,-1). 2.8.2.1 L’exemple suivant : integer complex, dimension(200) complex real omega = 2*acos(-1.0) do i = 1, 200 t = (i-1)*0.005 ; s(i) enddo
:: :: :: ::
integer, parameter real, dimension(l,m) real, dimension(m,n) real, dimension(l,n) integer
l = 20, m = 100, n = 30 x y z i, j, k
Manipulation globale de tableaux n d’un coup ! (mieux que le petit tailleur)
i s im = (0.,1.) omega, t
On peut faire des calculs en manipulant les ´el´ements de tableaux un `a un dans des boucles comme dans les exemples ci-dessus ; c’est d’ailleurs ce que l’on faisait jusqu’` a l’apparition de fortran9026 . La manipulation globale de tableaux est sans doute l’apport le plus important de fortran90 par rapport aux langages qui l’ont pr´ec´ed´e ; = exp(im*omega*t) c’est aussi un ingr´edient qui facilite beaucoup les calculs num´eriques d`es qu’ils deviennent un peu lourds. d´eclare un tableau complexe de 200 ´el´ements et le remplit. Admettons que les ´el´ements du tableau c doivent ˆetre Il peut ˆetre commode de remplacer une dimenla somme des ´el´ements correspondants des tableaux a et sion explicitement fix´ee ` a une certaine valeur, du type dimension(100), par dimension(n) o` u n est un nombre b : entier. Il faut alors d´eclarer n comme un param`etre, c’esta-dire un nombre dont on ne peut pas changer la valeur integer, parameter :: n = 1000 ` integer :: i en cours d’ex´ecution du programme. Ainsi : :: :: :: :: ::
open(10,file=’fichier.x’) ! lecture x do j = 1, m do i = 1, l read(10,*) x(i,j) enddo enddo close(10) open(10,file=’fichier.y’) ! lecture y do j = 1, n do i = 1, m read(10,*) y(i,j) enddo enddo close(10) do j = 1, n ! produit matriciel do i = 1, l z(i,j) = 0. do k = 1, m z(i,j) = z(i,j) + x(i,k)*y(k,j) enddo enddo enddo
real, dimension(n) :: a, b, c !.... ! il faudrait lire les elements de a et b ! dans un fichier par exemple. do i = 1, n c(i) = a(i) + b(i) enddo
En fortran90, la boucle peut se r´esumer en une seule instruction : c = a + b
! ici on fait n additions.
le compilateur se chargeant de v´erifier que tous les tableaux concern´es ont bien la mˆeme dimension. . . On peut donner explicitement les bornes : c(1:n) = a(1:n) + b(1:n)
ce qui a le mˆeme r´esultat que ci-dessus : c¸a n’a aucun int´erˆet dans cet exemple, mais imaginons que l’on veuille additionner la premi`ere moiti´e du tableau a avec la deuxi`eme moiti´e du tableau b et inversement, la deuxi`eme moiti´e de a avec la premi`ere de b : c(1:n/2) = a(1:n/2) + b(n/2+1:n) c(n/2+1:n) = a(n/2+1:n) + b(1:n/2)
ou bien que l’on ne s’int´eresse qu’aux ´el´ements impairs : d´eclare 3 tableaux de 20 × 100, 100 × 30 et 20 × 30, lit les valeurs des ´el´ements de x et y dans des fichiers et fait le c = 0. ! initialisation de c produit des deux matrices dans z (attention ` a la diff´erence c(1:n:2) = a(1:n:2) + b(1:n:2) entre le chiffre 1 et la lettre l). Malgr´e son apparente complexit´e, l’avantage de cette le dernier indice ´etant le pas, comme pour une boucle do27 . fa¸con de d´eclarer les tableaux est que si l’on veut, dans une 26 Plus pr´ ecis´ ement, certains constructeurs d’ordinateurs a ` capanouvelle version du programme, changer une dimension cit´ e vectorielle avaient commenc´ ea ` produire dans les ann´ ees 1980 des d’un tableau, il suffit de changer la valeur du param`etre compilateurs fortran8X sp´ ecifiques a ` leurs machines : fortran90 correspondant et toutes les boucles s’adaptent automati- est l’h´eritier de ces innovations. 27 Il faut toutefois faire un peu attention car la norme ne garanquement. Finalement, il est possible d’initialiser un tableau dans tit pas que les op´erations effectu´ees dans un traitement global de tableau se fassent dans l’ordre des indices de sorte que si un calcul la d´eclaration, comme un scalaire : real, dimension(-2:2) :: x=(/-4,-2,0,2,4/)
ici, x(-2) = -4, x(-1) = -2, etc. Une boucle implicite peut aussi ˆetre utilis´ee pour le mˆeme r´esultat :
d´ epend d’un r´ esultat obtenu pr´ ec´ edemment sur un ´ el´ ement d’indice inf´ erieur, il faut ´ ecrire explicitement une boucle. En revanche, certains ordinateurs sont optimis´ es pour ce genre de calcul et un traitement global, quand il est possible, peut se traduire par un gain de temps sensible.
28
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
c’est, encore une fois, l’´equivalent d’une boucle car x et y ne sont pas des scalaires mais des tableaux de nombres et, Finalement, les conditions s’expriment ` a l’aide de where avec une syntaxe tr`es proche du if, sauf qu’´evidemment en une ligne, est concentr´e un calcul de 5000 sinus. . . fortran90 offre en outre une panoplie de fonctions il s’agit maintenant de tableaux pris globalement : intrins`eques sp´ecialement destin´ees aux op´erations sur integer, parameter :: n = 5000 les tableaux, par exemple, pour obtenir la somme des real, dimension(n) :: x, y ´el´ements d’un tableau : 2.8.2.2
where
! .... where ( x >= 0.) y = sqrt(x) else where y = 0. end where
integer, parameter :: n = 2048 real, dimension(n) :: x real :: y ! .... y = sum(x)
on calcule donc les racines carr´ees de tous les ´el´ements ou de fa¸con plus sophistiqu´ee, la somme des ´el´ements popositifs du tableau x, et l’on annule y pour les ´el´ements sitifs d’un tableau : n´egatifs de x : c’est l’´equivalent de la boucle : integer, parameter :: n = 6723 real, dimension(n) :: x real :: y ! .... y = sum(x, mask = x >= 0.)
integer, parameter :: n = 5000 real, dimension(n) :: x, y integer :: i ! .... do i = 1, n if ( x(i) >= 0.) then y(i) = sqrt(x(i)) else y(i) = 0. endif enddo
2.8.2.3
ce qui suit mask devant ˆetre un tableau logique de la bonne dimension. La moyenne des racines carr´ees donnerait : y = sum(sqrt(x), mask = x >= 0.)/count(x >= 0.)
forall
Imaginons toutefois que l’on veuille, la matrice identit´e d’ordre n : 1 0 0 ... 0 0 1 0 ... 0 0 0 1 ... 0 I= . . . . . . ... .. .. .. 0 0 0 ... 1 0 0 0 ... 0
par exemple, cr´eer 0 0 0 .. .
0 1
il faut pouvoir acc´eder aux termes diagonaux de la matrice : une boucle do peut faire l’affaire, mais celleci impose que les op´erations demand´ees soient effectu´ees s´equentiellement dans l’ordre indiqu´e par l’indice ; sur certains ordinateurs cela peut sensiblement ralentir l’ex´ecution. L’instruction forall est tr`es similaire `a do mais l`eve cette contrainte, ainsi : real, dimension(n,n) :: id ! matrice identite ... id = 0. ! mise a zero des n*n termes forall ( i = 1:n ) id(i,i) = 1.0 ! n termes diagonaux
La fonction intrins`eque count compte le nombre de fois o` u la condition est vraie. Si le tableau est multidimensionnel, on sp´ecifie la dimension sur laquelle la somme doit ˆetre faite : integer, parameter :: n = 237, m = 53 real, dimension(n,m) :: x real, dimension(m) :: y ! .... y = sum(x, dim = 1, mask = x >= 0.)
donne : yj =
n X
xi,j , ∀j ∈ [1, m], le r´esultat est donc
i=1 xi,j ≥ 0
´evidemment un tableau. On peut ´ecrire de fa¸con plus succinte : y = sum(x, 1, x >= 0.)
La fonction product, d’usage similaire, fait le produit des ´el´ements d’un tableau. n X xi yi s’obtient avec Le produit scalaire z =
dot product :
i=1
integer, parameter :: n = 8000
Noter que la syntaxe est un peu diff´erente que celle de do. real, dimension(n) :: x, y real :: z On a aussi : forall ( i = 1:n ) ... end forall
! .... z = dot_product(x,y)
et le produit de deux matrices ci,j =
2.8.3
Fonctions intrins` eques et tableaux
matmul :
Les fonctions intrins`eques du fortran s’accommodent integer, parameter tr`es bien de tableaux, par exemple : integer, parameter :: n = 5000 real, dimension(n) :: x, y ! .... y = sin(x)
m X
ai,k bk,j avec
k=1
:: n = 100, m = 50, p = 32 real, dimension(n,m) :: a ! attention au real, dimension(m,p) :: b ! dimensionnement real, dimension(n,p) :: c ! des tableaux ! .... c = matmul(a,b)
29
Physique num´erique, Philippe Depondt
Nom count(l,mask,dim) dot product(a,b) matmul(a,b) maxloc(a,dim,mask) maxval(a,dim,mask) minloc(a,dim,mask) minval(a,dim,mask) product(a,dim,mask) sum(a,dim,mask)
cshift(a,shift,dim)
eoshift(a,shift, boundary,dim)
pack(a,mask, vector) unpack(a,mask, missing)
Type
Description Fonctions math´ematiques entier nombre de fois o` u le tableau logique l est vrai, selon la dimension dim quand mask est vrai num´erique, mˆeme type que a et b produit scalaire des tableaux unidimensionnels a et b num´erique, mˆeme type que a et b produit des deux matrices a et b entier position du plus grand ´el´ement du tableau a selon la dimension dim quand mask est vrai. entier ou r´eel valeur du plus grand ´el´ement du tableau a selon la dimension dim quand mask est vrai. entier position du plus petit ´el´ement du tableau a selon la dimension dim quand mask est vrai. entier ou r´eel valeur du plus petit ´el´ement du tableau a selon la dimension dim quand mask est vrai. num´erique, du mˆeme type que a produit des ´el´ements du tableau a selon la dimension dim quand mask est vrai num´erique, du mˆeme type que a somme des ´el´ements du tableau a selon la dimension dim quand mask est vrai Transformations de tableaux indiff´erent permutation circulaire des ´el´ements du tableau a selon la dimension dim. Si shift est positif, d´eplacement de shift positions ` a gauche, sinon ` a droite indiff´erent d´ecalage des ´el´ements du tableau a selon la dimension dim. Si shift est positif, d´eplacement de shift positions ` a gauche, sinon ` a droite. Les ´el´ements manquants ` a l’extr´emit´e sont remplac´es par ceux de boundary, ou z´ero si boundary absent. indiff´erent transforme le tableau multidimensionnel a en un tableau unidimensionnel quand mask est vrai, les ´el´ements filtr´es par mask ´etant remplac´es par ceux du vecteur vector indiff´erent transforme le tableau unidimensionnel a en un tableau multidimensionnel quand mask est vrai, les ´el´ements filtr´es par mask ´etant remplac´es par ceux de missing. La forme du tableau r´esultant est celle de mask
Tab. 2.8 – Quelques fonctions de manipulation globale de tableaux. quelles on aimerait pouvoir modifier la taille d’un tableau en cours d’ex´ecution : par exemple, si l’on a ´ecrit un programme qui calcule la moyenne des ´el´ements d’un tableau de nombres de longueur quelconque, il serait agr´eable de pouvoir entrer la taille du tableau, puis le dimensionner, puis faire le calcul sans avoir `a recompiler le programme `a chaque fois que le nombre de nombres dont on veut la 2.8.4 Allocation dynamique de m´ emoire moyenne a chang´e ! L’allocation dynamique de m´emoire permet de d´eclarer Une d´eclaration est, comme on l’a d´ej` a vu, une un tableau sans en donner la taille, puis de lui donner r´eservation d’espace dans la m´emoire vive de l’ordinateur. une taille en cours d’ex´ecution, de le supprimer puis de lui Ainsi, real :: x d´eclare une variable r´eelle x et, de ce donner une autre taille, etc. Par exemple : fait, r´eserve 4 octets (ou 32 bits) en m´emoire, parce que c’est la place qu’occupe un r´eel en simple pr´ecision29 : ces ! declaration d’un tableau unidimensionnel 4 octets sont donc affect´es ` a cette variable et ne peuvent ! sans taille fixe pas ˆetre utilis´es `a autre chose. De mˆeme, lorsqu’on d´eclare real, dimension(:), allocatable :: x un tableau, par exemple real, dimension(n) :: x, on integer :: n r´eserve n fois 4 octets. On comprend donc que cette !... r´eservation doive ˆetre faite avant l’ex´ecution du pro- write(*,’(‘‘Entrer le nombre d’elements ‘‘,$)’) gramme : si l’on veut changer la taille d’un tableau, cela read(*,*) n ! affectation d’une taille donnee au tableau revient `a modifier la taille de l’espace qu’il occupe en allocate(x(n)) m´emoire ; il faut arrˆeter l’ex´ecution du programme, mo- !... ici on fait des calculs 30 difier le code source, recompiler et relancer l’ex´ecution . deallocate(x) ! desaffectation Il existe cependant des quantit´es de situations dans les- ! on recommence avec un tableau plus petit Noter que le r´esultat fourni par cette fonction est lui-mˆeme une matrice. Un r´esum´e (non exhaustif) de quelques fonctions que l’on est amen´e `a utiliser assez souvent est donn´e dans la table 2.828 .
28 NE
PAS apprendre ce tableau par cœur ! 29 pour la plupart des ordinateurs courants. L’usage de mots de 64 bits commence toutefois a ` se r´ epandre assez rapidement. 30 ou alors, en fortran77, en l’absence d’allocation dynamique de m´ emoire, on pr´ evoyait large : on r´ eservait par exemple 1 000 000 d’emplacements pour n’en utiliser finalement que quelques uns.
! qui commence en zero au lieu de un allocate(x(0:n/2-1)) !... deallocate(x)
On g`ere ainsi la m´emoire occup´ee pour ainsi dire
30
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
« au vol », ou plutˆ ot, dynamiquement dans le jargon real s = 0. consacr´e. . .
2.9
Fonctions mes.
et
sous-program-
Rien n’oblige `a ´ecrire tous les calculs que l’on veut faire dans un mˆeme programme : c’est mˆeme assez d´econseill´e ! Pour des raisons, ne serait-ce que de lisibilit´e, on a tr`es souvent int´erˆet `a d´ecouper un gros probl`eme en plusieurs petits pour lesquels les possibilit´es de se tromper sont plus faibles31 . De plus, si le mˆeme type de calcul doit ˆetre r´ep´et´e `a plusieurs endroits du programme (par exemple un calcul d’int´egrale), ce n’est pas la peine de le reprogrammer plusieurs fois. Si, enfin, on a d´ej` a ´ecrit (et test´e) un programme qui sait faire un certain type de calcul (par exemple, calculer une int´egrale num´erique ou r´esoudre un syst`eme lin´eaire d’´equations), il est utile de pouvoir le r´ecup´erer et l’ins´erer dans le programme que l’on est en train de faire sans avoir ` a le re´ecrire. Il existe en outre, et l’on verra dans ce cours un certain nombre d’exemples de leur utilisation, des biblioth`eques de sous-programmes et de fonctions extrˆemement riches, telles linpack, lapack, nag, imsl. . ., dans lesquelles on peut puiser sans vergogne et ainsi ´eviter de r´einventer la roue. Fonctions et sous-programmes sont donc des ingr´edients essentiels !
2.9.1
Les function.
2.9.1.1
D´ efinir une function.
On peut ´ecrire ses propres fonctions en plus des fonctions intrins`eques. On les utilise de la mˆeme fa¸con que les fonctions intrins`eques mais ´evidemment, il faut aussi les d´efinir, alors que les fonctions intrins`eques sont bien sˆ ur pr´ed´efinies. Pour cela, on place les instructions correspondantes, par exemple dans le mˆeme fichier-source que le programme lui-mˆeme, mais en dehors de celui-ci (avant program ou apr`es end. Par exemple, supposons que l’on veuille calculer le barycentre, ` a une dimension, d’un ensemble de nombres lus dans un fichier : program calcul ! debut du programme principal implicit none integer, parameter :: n = 100 real, dimension (1:n) :: x real :: bsom open (1, file=’machin’) read(1,*) x close(1) write(*,*) ’Le barycentre des elements de X est : ’ write(*,*) bsom(x,n) ! appel de bsom end ! fin du programme principal real function bsom(z,m) ! debut de la function bsom implicit none integer :: i, m real, dimension(1:m) :: z 31 c’est
ce que l’on appelle avec quelque p´ edanterie « l’analyse descendante », c’est-` a-dire que l’on divise un probl` eme P a priori compliqu´ e en plusieurs sous-probl` emes P1 , P2 , . . ., puis chaque sousprobl` eme est redivis´ e en P1,1 , P1,2 , . . . , P2,1 , . . ., etc. On arrˆ ete quand tous les sous-sous-sous-. . .-probl` emes sont tellement ´ el´ ementaires qu’il n’y a plus de probl` eme !
:: s
do i = 1, m s = s + i*z(i) enddo bsom = s/sum(z) end
! fin de la function bsom
La premi`ere partie est ce qu’on appelle le « programme principal », la seconde, la fonction32 . L’appel de la fonction dans le programme principal est fait normalement, ici dans une instruction write(*,*) bsom(x,n)
mais cela pourrait ˆetre dans une expression comme r = sqrt(2.0)*bsom(x,n) - k
l’usage d’une fonction est donc tr`es similaire `a celle des fonctions intrins`eques du fortran, comme sin, exp, etc. Dans la d´efinition de la fonction, on doit ´ecrire explicitement l’expression donnant la valeur de la fonction : si l’on oublie l’instruction bsom = s/sum(z), il n’y aura pas d’erreur d´etect´ee, le calcul sera fait normalement, mais le r´esultat ne sera pas transmis au programme appelant. La fonction doit se terminer par l’instruction end qui en marque la fin, comme le programme principal. 2.9.1.2
Les arguments et les variables d’une function.
Dans cet exemple, la fonction r´eelle bsom calcule le barycentre des ´el´ements de z. Le tableau z est un argument de la fonction ( function bsom(z,m) ). Dans l’appel de bsom, le premier argument est le tableau x qui doit avoir le mˆeme type et le mˆeme nombre d’´el´ements que z dans la d´efinition de la fonction : la correspondance entre les variables du programme principal et celles de la fonction est donn´ee par l’ordre dans lequel elles apparaissent dans l’appel et la d´efinition de la fonction. En effet x est la premi`ere variable qui apparaˆıt dans l’appel de bsom(x,n) dans le programme principal et z est la premi`ere dans la d´efinition real function bsom(z,m). Ainsi, x dans le programme principal et z dans la fonction d´esignent la mˆeme variable ; de mˆeme pour n et m. write(*,*) bsom(
1er, 2e argument x, n) appel, dans p. princ.
ll
← correspondance real function bsom( z, m) d´efinition Attention ! Ce n’est pas parce qu’une variable a le mˆeme nom dans une fonction qu’une autre dans le programme principal qu’il s’agit de la mˆeme chose ; au contraire, ces deux variables mˆeme si elles ont le mˆeme nom n’ont aucun rapport ! En revanche, une variable du programme principal repr´esente strictement la mˆeme chose qu’une autre, mˆeme de nom diff´erent, dans la fonction a ` condition d’avoir ´et´e transmise comme argument dans l’appel et la d´efinition de la fonction comme dans l’exemple cidessus33 . Ainsi, la variable x du programme principal est identique `a la variable z de la fonction, mais la variable s de 32 ou
plus pr´ ecis` ement la d´ efinition de la function. seule chose qui soit transmise est l’adresse du premier ´ el´ ement du tableau x. C’est en fait un pointeur masqu´ e! 33 La
31
Physique num´erique, Philippe Depondt
la fonction bsom est compl`etement ind´ependante de ce qui peut ˆetre d´eclar´e dans le programme principal : il pourrait tr`es bien y avoir une autre variable s dans le programme principal sans qu’il y ait la moindre interaction entre les deux. Lorsqu’on apprend ` a programmer, c’est une source d’erreur classique et cela paraˆıt inutilement compliqu´e, mais `a l’usage c’est un grand avantage car ainsi la fonction bsom, une fois ´ecrite et test´ee, est ind´ependante du cadre dans lequel elle est utilis´ee, on peut donc s’en servir dans un grand nombre de circonstances sans se pr´eoccuper du d´etail de la fa¸con dont elle est ´ecrite. Par exemple, on peut tr`es bien avoir oubli´e qu’il y a des variables s et z dans bsom, et faire dans le programme principal un appel du type : z = bsom(s,m)
sans cons´equence dramatique, ` a condition que, dans le programme principal, s soit un tableau de m ´el´ements et z un scalaire r´eel. Il faut donc se rappeler qu’en fortran, il n’y a pas de variables globales, toutes les variables doivent ˆetre explicitement transmises de programme appelant ` a fonction ou sous-programme.
2.9.2
Et les subroutine.
end
Le sous-programme baryc utilise les donn´ees rx, ry, rz, et masse, ainsi que le nombre de masses impliqu´ees, pour rendre les coordonn´ees du centre de masse et la masse totale. Noter la diff´erence avec une fonction : on peut ins´erer l’appel d’une fonction dans une expression, ´ecrire : write(*,*) bsom(x,n)/pi ou bien : xtot = 3.*bsom(x,n) + w, mais un sous-programme doit ˆetre appel´e par un call. Par ailleurs, une fonction doit ˆetre d´eclar´ees car elle a un type : entier, r´eel, double pr´ecision, logique. . . en revanche, un sous-programme ne doit pas ˆetre d´eclar´e mais bien sˆ ur, ses arguments, eux, doivent l’ˆetre, car un sous-programme ne prend pas de valeur, mais se borne `a modifier certains de ses arguments. Les autres remarques concernant l’ind´ependance des variables d’une fonction vis-` a-vis de celles du programme principal et le dimensionnement des tableaux transmis comme argument sont aussi valables dans le cas d’un sousprogramme.
2.9.3
L’intention
On voit, dans l’exemple ci-dessus par exemple, que certains arguments sont des donn´ees que la subroutine doit utiliser pour faire ses calculs (m, x, y, z, n), d’autres (mt, gx, gy, gz) des r´esultats qu’elle doit calculer : les premiers sont donc « en entr´ee », les autres « en sortie », sans que rien dans la syntaxe n’indique cette diff´erence. C’est ici qu’intervient l’id´ee « d’intention » ou intent en anglais. On sp´ecifie, dans les d´eclaration du sous-programme, si un argument est en entr´ee ou en sortie, ainsi :
Une fonction souffre de la limitation qu’elle ne peut produire qu’une seule valeur comme r´esultat : ainsi, si l’on veut calculer plusieurs choses, il faut faire un sous-programme (subroutine). Par exemple, si l’on veut calculer, dans l’espace `a trois dimensions, le barycentre d’un ensemble de masses (donc trois nombres) ainsi que la masse totale (un quatri`eme nombre), on peut proc´eder comme suit : subroutine baryc( gx, gy, gz, mt, x, y, z, m, n ) program cmasse implicit none integer, parameter real, dimension(1:n) real integer
:: :: :: ::
n = 100 masse, rx, ry, rz ogx, ogy, ogz, mtot i
open(1, file=’masses’) do i = 1, n read(1,*) rx(i), ry(i), rz(i), masse(i) enddo close(1) call baryc (ogx,ogy,ogz,mtot,rx,ry,rz,masse,n) write(*,*) ’Masse totale : ’, mtot write(*,*) ’Coordonnees du centre de masse : ’ write(*,*) ogx, ogy, ogz end
implicit none integer, intent(in) :: n real,intent(out) :: gx, gy, gz, mt real, dimension(1:n), intent(in) :: m, x, y, z mt gx gy gz
= = = =
sum(m) dot_product(x,m)/mt dot_product(y,m)/mt dot_product(z,m)/mt
end
Cela a deux cons´equences : 1o c’est plus clair pour le programmeur, 2o le compilateur d´etectera une erreur si, par exemple, on essaie de modifier un argument d´eclar´e in. L’intent(inout) existe aussi, pour les arguments dont on doit utiliser la valeur en entr´ee, mais que l’on doit ´egalement modifier.
2.9.4 subroutine baryc( gx, gy, gz, mt, x, y, z, m, n ) implicit none integer :: n real :: gx, gy, gz, mt real, dimension(1:n) :: m, x, y, z mt gx gy gz
= = = =
sum(m) dot_product(x,m)/mt dot_product(y,m)/mt dot_product(z,m)/mt
La mise en commun de variables.
On a vu que fonctions et sous-programmes ´etaient `a peu pr`es ´etanches vis-` a-vis du monde ext´erieur, `a l’exception, ´evidemment, des variables transmises comme arguments : c’est un avantage, mais, c’est parfois un peu rigide. On peut alors mettre en commun des variables entre programme et sous-programme ou entre sous-programmes ou fonctions diff´erents, `a l’aide de modules. Imaginons, par exemple, un code comprenant un programme principal et des sous-programmes qui utilisent tous la grandeur π et les conversions entre degr´es et radians. Plutˆ ot que red´efinir ces grandeurs dans chaque programme et sous-programme,
32
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
on peut commencer par faire un module, plac´e au d´ebut (si c’est un programme compliqu´e surtout si on ne l’a pas du fichier source : ´ecrit soi-mˆeme, c’est toujours un peu dangereux), il suffit de faire un module pour mettre ces variables en commun module trig_consts entre le programme principal et B : on saute, pour ainsi ! definition de constantes trigonometriques dire, par-dessus A ! implicit none real, parameter :: pi = acos(-1.0) real, parameter :: deg_rad = pi/180. real, parameter :: rad_deg = 180./pi end
il s’agit simplement de d´eclarations (ici de param`etres, mais ce n’est pas obligatoire) et, le cas ´ech´eant, d’affectations de valeurs. Dans un programme ou sous-programme dans lequel on veut utiliser ces variables, il faut sp´ecifier au d´ebut des d´eclarations
2.9.5
Mettre un nom de sous-programme comme argument.
Admettons que l’on ait ´ecrit une fonction somdef qui sache calculer une int´egrale d´efinie : il faut lui transmettre comme argument, outre les bornes xmin et xmax de l’int´egrale et la pr´ecision eps souhait´ee, le nom de la fonction `a int´egrer. Par exemple : xmin = 0. ; xmax = acos(-1.0) write(*,*) somdef( xmin, xmax, eps, sin )
use trig_consts
et les variables pi, deg rad et rad deg sont utilisables sans si l’on veut calculer l’int´egrale de 0 `a π de sin x. Cepenautre forme de proc`es ; ainsi, si theta est un angle donn´e dant, si l’on proc`ede sans pr´ecaution, le compilateur diagen degr´es : nostiquera que la variable sin n’est pas d´eclar´ee, et dira quelque chose qui peut ressembler `a : Error : Symbol sin_theta = sin(deg_rad*theta) ’sin’ at (1) has no IMPLICIT type, ce qui est abest correct mˆeme si deg rad n’a pas ´et´e d´eclar´e dans le surde puisqu’il s’agit d’une fonction intrins`eque. . . C’est a, il ne reconnait pas sin comme programme. Quand on fait cela, il faut faire un peu atten- que dans ce contexte l` tion, puisque si l’on a une autre variable pi dans un des une fonction : il faut donc le pr´eciser dans les d´eclarations programmes qui utilisent ce module, il y aura un conflit avec intrinsic. d´etect´e par le compilateur. Cependant, comme il faut faire real :: xmin, xmax, eps, somdef appel explicitement par use aux modules dont on a besoin intrinsic :: sin dans chaque sous-programme qui l’utilise, les d´egats po... 34 tentiels restent limit´es : on peut tr`es bien imaginer des xmin = 0. ; xmax = acos(-1.0) structures comme : write(*,*) somdef( xmin, xmax, eps, sin )
module blabla ! acceleration de la pesanteur terrestre real, parameter :: g=9.81 end program truc use blabla implicit none real :: p, m = 75 p = m*g write(*,*)’Poids =’,p call machin(p) end
! rappel du module blabla
subroutine machin(poids) implicit none ! ici pas de module blabla real, intent(in) :: poids real :: g= 2. write(*,*) ’Poids a’,g ,’ g =’, poids*g end
La variable g de machin n’a rien ` a voir avec celle du module et du programme principal, puisque machin n’utilise pas le module blabla (il n’y a pas use blabla). Outre la d´efinition de constantes, un des usages les plus courants des modules est quand un programme principal appelle un sous-programme A qui lui-mˆeme en appelle un autre B. A priori, les seules variables connues du sousprogramme B sont celles que lui a transmises A, or il se peut tr`es bien qu’il ait besoin d’autres grandeurs utilis´ees par le programme principal. Si l’on ne veut pas modifier A 34 De ce point de vue, on reste assez loin des variables globales du C dont les auteurs du langage disent eux-mˆ emes que ce n’est pas ce qu’ils ont fait de mieux ! (B. W. Kernighan, D. M. Ritchie, Le langage C, Masson (1997), p. 33.)
De mˆeme, s’il s’agit d’une fonction mafct que l’on a ´ecrite soi-mˆeme, il faut la d´eclarer par external real :: xmin, xmax, eps, somdef external :: mafct ... xmin = .. ; xmax = .. write(*,*) somdef( xmin, xmax, eps, mafct )
Les mˆemes r`egles s’appliquent pour les sousprogrammes35. Ce sont l` a les seuls cas d’utilisation de intrinsic et external : quand on ne transmet pas comme argument le nom d’un sous-programme ou d’une fonction `a un autre sous-programme ou fonction, il est compl`etement inutile d’utiliser ces d´eclarations36.
2.9.6
Les biblioth` eques.
2.9.6.1
Pour quoi faire ?
Imaginons que l’on ait ´ecrit une s´erie de sousprogrammes, par exemple des calculs d’int´egrale, dont le code-source, c’est-`a-dire ´ecrit en Fortran, est plac´e pour chaque sous-programme dans un fichier dont le nom se termine par .f90. Pour r´eutiliser ces sous-programmes dans d’autres programmes, on peut bien sˆ ur simplement inclure les fichiers correspondants `a l’aide de directives include 35 Certains compilateurs plus anciens n’acceptent que l’ancienne syntaxe external mafct (sans les ::). 36 Cette affirmation est en fait un peu p´ eremptoire. . ., on peut imaginer des situations o` u cela peut ˆ etre n´ ecessaire, par exemple si l’on a ´ ecrit soi-mˆ eme un sous-programme dot product qui risque d’entrer en conflit avec la fonction intrins` eque de mˆ eme nom ; la d´ eclaration external r´ esout alors le probl` eme.
33
Physique num´erique, Philippe Depondt
’nom de fichier.f90’, c’est d’ailleurs ce que l’on fait souvent. Toutefois, il arrive que ces sous-programmes aient euxmˆeme besoin d’autres sous-programmes pour fonctionner. Par exemple, les programmes de calcul de tranform´ee de Fourier vont tous utiliser le mˆeme algorithme, mais vont diff´erer selon que l’on veut une transform´ee directe ou inverse : ainsi le programme que l’on appelle ne fait qu’appeler un autre programme en modifiant ´eventuellement un signe ; il faudrait alors inclure explicitement les deux sous-programmes, ce qui suppose que l’on connaisse sp´ecifiquement comment tout cela est organis´e : autant dire que c’est rarement le cas quelques ann´ees apr`es l’´ecriture initiale. Une bonne solution est alors de constituer une biblioth`eque (library en anglais37 ). Une biblioth`eque est un fichier dans lequel sont regroup´es un ensemble se sous-programmes d´ej` a compil´es et dans lequel le compilateur peut aller pˆecher ce dont il a besoin, par exemple un sous-programme de calcul de transform´ee de Fourier et tous les sous-programmes auxquels celui-ci fait appel : dans le programme principal, il suffira de faire un call du sous-programme voulu. 2.9.6.2
Cr´ eer une biblioth` eque personnelle.
On a donc ´ecrit un certain nombre de sous-programmes et de fonction (dˆ ument test´es, bien sˆ ur. . .) plac´es dans des fichiers machin 01.f90, machin 02.f90, truc real.f90, truc dbl prec.f90, etc. Si on compile tout cela par g95 *.f90, le compilateur refusera de la faire parce qu’il n’y a pas de programme principal : il faut donc inhiber l’´editeur de lien38 avec l’option -c et pendant qu’on y est, on peut demander une optimisation du code avec l’option -O3. Cela donne : g95 -c -O3 *.f90 on obtiendra alors une s´erie de fichiers machin 01.o, machin 02.o, truc real.o, truc dbl prec.o, etc. Ces fichiers doivent alors ˆetre inclus dans un fichier d’archive : ar rv libmabib.a *.o Le fichier libmabib.a contient la biblioth`eque mabib. On peut alors supprimer tous les fichiers interm´ediaires : rm -f *.o Pour utiliser cela, il suffit de compiler normalement son programme principal, dans lequel il y a des call machin 01(arg1, arg2), avec la commande : g95 big prog.f90 -Lrepertoire de mabib -lmabib -o big prog u se trouve o` u repertoire de mabib est le r´epertoire o` le fichier libmabib.a. Si l’on peut placer le fichier libmabib.a dans le r´epertoire /usr/local/lib39, l’option -L n’est plus n´ecessaire. 2.9.6.3
Utiliser une biblioth` eque existante.
d’invoquer `a la compilation par : g95 mon big prog.f90 -llapack -o mon big prog Cela suppose ´evidemment que l’on ait la documentation qui va avec, mais c’est g´en´eralement facile `a obtenir via Internet. C’est tr`es souvent ainsi que l’on travaille dans « le monde r´eel de la simulation » : pour r´esoudre un probl`eme, on identifie une m´ethode de r´esolution dont le noyau r´eside dans un algorithme connu (inversion de matrice, transform´ee de Fourier, valeurs propres, . . .) et l’on trouve le programme de biblioth`eque convenable, on l’appelle et on compile l’ensemble avec l’invocaton de la biblioth`eque idoine : un appr´eciable gain de temps !
2.10
Les commentaires.
On peut, et c’est mˆeme conseill´e, commenter ses programmes, d’ailleurs les exemples donn´es ci-dessus comportent des commentaires. Pour cela, il suffit d’utiliser le symbole ! qui marque le d´ebut d’un commentaire qui ne sera donc pas interpr´et´e comme une instruction `a ex´ecuter : ! ceci est un commentaire, mais la ligne ! qui suit est une instruction read(*,*) x
C’est tr`es utile quand on veut pouvoir s’y retrouver dans un programme ´ecrit quelques temps avant, par exemple : !----------------------------------------------! Ceci est un programme ecrit le 06-11-98 ! par Tycho Brahe ! Il comporte trois boucles imbriquees ! ! Mise a jour (adaptation free form) le 18-12-01 ! par Johannes Kepler !----------------------------------------------.... ! debut de la grande boucle do i = 1, n ...... ...... ! debut de la moyenne boucle do j = 1, m ........ ........ ! debut de la petite boucle do k = 1, l ...... ...... ...... enddo ! fin de la petite boucle ...... ...... enddo ! fin de la moyenne boucle ..... ..... enddo ! fin de la grande boucle
Il est toutefois assez rare que l’on ait ` a cr´eer une biblioth`eque de toutes pi`eces : l’essentiel des algorithmes courants a d´ej` a ´et´e programm´e, compil´e, test´e, etc., il est inutile -voire nocif- de les refaire ! Pour l’alg`ebre lin´eaire, il y a par exemple lapack qu’en g´en´eral, il suffit Si chaque s´erie de points (.....) repr´esente plusieurs centaines d’instructions, les commentaires qui en marquent le 37 attention aux faux amis : en anglais, library signifie biblioth` eque d´ebut et la fin ne sont pas de trop. . . (l’endroit o` u l’on emprunte des livres) alors que librairie (l’endroit Le point d’exclamation plac´e ailleurs qu’en colonne 1, o` u l’on ach` ete des livres) se dit bookstore. . . 38 c’est ce qui fait le lien entre programmes et sous-programmes. transforme la fin de la ligne en commentaire, sans en af39 il faut pour cela les droits de super-utilisateur. fecter le d´ebut :
34
Licence de physique L3 : Physique Fondamentale & PHYTEM,
x = a + b z = (x/p)**1.5 k = mod(j,6)
! a partir d’ici c’est un ! commentaire, mais le debut de ! ces lignes s’execute normalement
2.12.2
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
Op´ erations sur les chaˆınes
On peut faire quelques op´erations sur les chaˆınes de caract`eres, par exemple :
Les d´eclarations de variables sont souvent un bon eni = len_trim(salut) droit pour mettre des commentaires : program capitaine implicit none ! ce programme calcule l’age du capitaine integer, parameter :: n = 100 ! nbr de points de ! discretisation real :: age_captain ! age du capitaine real, dimension(n) :: work ! zone de travail
2.11
Une instruction sur plusieurs lignes.
Il arrive qu’une instruction soit trop longue pour tenir sur une ligne : il faut donc la prolonger sur la ligne suivante. Pour cela, il suffit de placer le caract`ere & `a la fin de la ligne pour indiquer que la ligne suivante en est la suite : write(*,*) ’L’’age du capitaine est ’, ag_cpt, & ’ mais on manque un peu de place ’, & ’: d’’ailleurs, on est oblige’, & ’ de s’’etaler sur plusieurs lignes’
donne le nombre de caract`eres remplis de la chaˆıne (4 dans le cas Ciao mˆeme si la chaˆıne est d´eclar´ee avec 7 charact`eres). character (len=7) :: salut = ’Bonjour’ character (len=3) :: c c=salut(1:3)
donnera Bon dans c puisque l’on prend les caract`eres de 1 `a 3. Il est aussi possible d’ajouter des caract`eres `a une chaˆıne en utilisant l’op´eration // : integer l character (len=40) :: nfichier1 character (len=20) :: nfichier2 write(*,’("Entrer un nom de fichier : ",$)’) read(*,*) nfichier1 l = len_trim(nfichier1) ! l = longueur reelle ! du nom de fichier nfichier2=nfichier1(1:l)//’.res’ ! on prend la partie de la chaine nfichier1 ! qui est remplie et on ajoute ’.res’ apres
Ici, l’instruction prend quatre lignes. Si l’on interrompt une chaˆıne de caract`ere, il faut mettre & ` a la fin de la ligne et au d´ebut de la ligne suivante : write(*,*) "Fichier resultat : ", nfichier2 write(*,*) ’L’’age du capitaine est ’, ag_cpt, & ’ mais on manque un peu de place & &: d’’ailleurs, on est oblige & &de s’’etaler sur plusieurs lignes’
open(1,file=nfichier1) ; open(2,file=nfichier2)
Ainsi, si l’on r´epond `a la question « Entrer un nom de fichier » par : machin, on obtiendra : Fichier resultat : machin.res
comparer avec l’exemple pr´ec´edent. . .
2.12
Les chaˆınes de caract` eres.
2.12.3
Conversion chaˆıne ⇔ nombres
On peut donc fabriquer automatiquement des noms de fichiers ; toutefois, il est utile de pouvoir 2.12.1 D´ eclaration ins´erer des nombres dans ces noms, par exemple Une variable de type chaˆıne de charact`eres doit ˆetre res calc dt0.001.dat pour signifier que ce calcul a ´et´e d´eclar´ee avec le nombre de caract`eres qu’elle peut conte- fait avec dt=0.001. Il faut donc convertir ce nombre en chaˆıne de caract`eres. Il existe une fonction intrins`eque nir, par exemple : char qui permet de partir du code ASCII d’un caract`ere character (len=7):: salut pour ´ecrire ce caract`ere : c’est assez lourd, car il faut indique que salut peut faire 7 caract`eres. Par exemple : d´ecomposer le nombre en dizaines, centaines, connaˆıtre les codes ASCII. . . Il est beaucoup plus simple d’utiliser salut=’Bonjour’ les instructions d’entr´ee-sortie qui font aussi ce genre de conversion par le biais de ce qu’on appelle un « fichier Mais rien n’empˆeche : interne », qui consiste `a remplacer l’unit´e d’´ecriture par salut=’Ciao’ une chaˆıne de caract`eres : o` u seuls les quatre premiers caract`eres sont remplis. En integer :: i revanche, character (len=21) :: nom_fich salut=’Guten Tag’
risque d’ˆetre un peu d´ecevant, il serait judicieux de d´eclarer salut avec 9 caract`eres au moins. . . On peut, dans un sous-programme ou une fonction, d´eclarer une chaˆıne de caract`eres sans longueur d´efinie, a condition qu’elle soit transmise comme argument : ` subroutine char_process(str,a,b,c,d) character (len=*) :: str
! initialisation de la cha^ ıne de caracteres nom_fich = ’res_calc_dt_0.000.dat’ do i = 1, 8 ! completer les caracteres numeriques write(nom_fich(12:16),’(f5.3)’) 0.001*i ... enddo
Evidemment, cela suppose un certain soin et il est prudent de v´erifier que le nom de fichier obtenu est bien ce le sous-programme se d´ebrouillera avec la chaˆıne str que l’on attendait ! Ensuite, il est ais´e de produire autoquelle qu’en soit la longueur. matiquement des noms de fichiers explicites.
35
Physique num´erique, Philippe Depondt
D´ etection de fin de fichier. Les fichiers internes fonctionnent aussi pour l’´ecriture, 2.13 par exemple, le programme metres ci-dessous lit les arIl arrive que l’on lise un fichier dont la longueur est guments de la commande qui l’invoque, ainsi quand on inconnue : ainsi, on ne sait pas la longueur de la boucle de tape : lecture : $ metres 6500 pieds
on obtient 1981.200
metres
Le programme est aussi une illustration de select case : program metres implicit none real, parameter :: c = 0.3048 ! conversion real :: l character (len=10) :: unite ! si le nombre d’arguments est >= 2, lire les deux ! premiers, sinon, lire classiquement au clavier if ( command_argument_count() >= 2 ) then call get_command_argument(1,unite) ! 1er argument ! Le 1er argument est la longueur que l’on veut ! convertir, c’est donc un nombre, or on a une chaine ! de caracteres qu’il faut convertir en reel par ! unite interne read(unite,*) l ! on lit la chaine pour obtenir l call get_command_argument(2,unite) ! 2eme argument ! le 2eme argument est le nom de l’unite qui reste ! une chaine de caracteres : donc pas de conversion. else write(*,’("Entrer la longueur et l’’unite ",$)’) read(*,*) l, unite endif
open(1,file=nfichier) do i = 1, n ! mais quelle valeur donner a n ? read(1,*) x ... enddo
Une bonne solution est de faire une boucle infinie dont on sort quand une condition de fin de fichier est rencontr´ee : open(1,file=nfichier) do read(1,*,iostat=i) x if( i < 0 ) exit ... enddo
la sp´ecification iostat=i o` u i est une variable enti`ere place dans i un diagnostic du r´esultat de l’op´eration d’entr´ee-sortie. Tant que i reste positif ou nul, la lecture se poursuit. La fin du fichier ou une erreur de lecture produira une valeur n´egative, et la lecture s’arrˆete.
2.14
FORTRAN77-90-95 : filiation et diff´ erences.
Le langage fortran ne cesse d’´evoluer : la premi`ere norme officielle et ind´ependante d’un constructeur, fortran66 ou fortranIV, date de 1966. fortran77, en ! trim est une fonction intrinseque qui reduit une ! chaine de caracteres a sa partie utile (sans espaces) 1977, introduisait des structures comme if-then-else, les chaˆınes de caract`eres et des instructions d’entr´ee-sortie select case(trim(unite)) ´elabor´ees comme open. En 1991, la norme fortran90 fut case (’ft’,’feet’,’foot’,’pieds’,’pied’) write(*,*) l*c,’ metres’ d´efinie et les premiers compilateurs cray et ibm sont apcase (’in’,’inch’,’inches’,’pouces’,’pouce’) parus en 1994. Enfin, la norme fortran95 est devenue write(*,*) 1000.*l*c/12.,’ mm’ ! 1 ft = 12 in op´erationnelle en 1999 sur des gros calculateurs de type case(’m’,’metres’) cray et ibm. . . en attendant fortran2003 ! write(*,*) l/c,’ ft’ Si fortran95 apporte surtout des modifications de case default d´etail par rapport `a fortran90, celui-ci constitue write(*,*) ’unite inconnue’ une ´evolution significative. Certaines structures (comme end select do-if(...) exit-enddo) ´etaient d´ej` a int´egr´ees dans g77 end mais pas toutes : la manipulation globale de tableaux, les –Exercice : adapter ce programme pour pouvoir faire modules, l’intention, l’allocation dynamique de m´emoire des conversions du type metres 5 ft 10 in pour obte- n’en faisaient pas partie. nir 1.778 m. Cette capacit´e `a manipuler des tableaux est probableUne autre application est la cr´eation de formats au- ment l’apport principal de fortran90 au calcul scientitomatiques : imaginons que l’on ait d´eclar´e un tableau fique ; la logique des programmes peut en ˆetre modifi´ee : « allocatable » : combien d’´el´ements doit-on mettre un exemple pourrait ˆetre un calcul d’´energie potentielle dans le format d’´ecriture ? A priori, on ne peut pas le savoir d’interaction entre n atomes, `a partir de l’´energie de paire avant l’ex´ecution : c’est le but de l’allocation dynamique de m´emoire. . . On peut s’en sortir en se rappelant qu’un de chaque couple d’atomes, donn´ee par une expression du format est une chaˆıne de caract`eres que l’on peut modifier, type 12 6 ! σ σ ainsi : V (rij ) = ε −2 rij rij integer :: n real, dimension(:), allocatable :: s character (len=9) :: form=’(00f11.5)’ write(*,’("Donnez la dimension du tableau : ",$)’) read(*,*) n allocate(s(n)) ... write(form(2:3),’(i2.2)’) n ! modification du format write(*,form) s ! ecriture
et Ep =
n−1 X
n X
i=1 j=i+1
en fortran77 : do i = 1, n-1 do j = i+1, n
V (rij )
36
Licence de physique L3 : Physique Fondamentale & PHYTEM,
rij2 =
(x(i)-x(j))**2 + (y(i)-y(j))**2 + & (z(i)-z(j))**2 sigr6 = (sigma2/rij2)**3 epot = epot + sigr6*( sigr6 - 2.0 ) enddo enddo epot = epsilon*epot
en fortran90 :
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
On peut faire la mˆeme chose avec des entiers : integer :: l code l sur 4 octets et permet d’utiliser des nombres entiers jusqu’` a 109 , alors que integer (kind=8) :: l travaille sur 8 octets et permet d’aller jusqu’` a 1010 . Toutefois, tout ceci d´epend du processeur utilis´e : ce qui est cit´e ci-dessus n’est vrai que pour les processeurs les plus commun´ement utilis´es sur PC ; le programme suivant permet de tester tout cela en cas de doute :
do i = 1, n-1 rij2(i+1:n) = (x(i)-x(i+1:n))**2 + & program inquire_kind (y(i)-y(i+1:n))**2 + & implicit none (z(i)-z(i+1:n))**2 integer :: p sigr6(i+1:n) = (sigma2/rij2(i+1:n))**3 ! l’exposant est celui de la puissance de 10 accessible epot = epot + sum(sigr6(i+1:n)*(sigr6(i+1:n) - 2.0)) write(*,’("Nombres entiers :")’) enddo write(*,’("exposant, kind")’) epot = epsilon*epot do p = 1,10 write(*,’(2i6)’) p, selected_int_kind(p) o` u maintenant rij2 et sigr6 sont des tableaux : la boucle enddo interne est implicitement d´ecompos´ee en trois boucles plus ! la precision est le nombres de chiffres significatifs simples. Le r´esultat est que l’on occupe plus de m´emoire write(*,’("Nombres reels :")’) vive (plus de tableaux) mais que la logique du calcul s’en write(*,’("precision, kind")’) trouve d´ecompos´ee en ´el´ements plus simples. do p = 1, 20 write(*,’(2i7)’), p, selected_real_kind(p) Il y a cependant d’autres innovations, plus « informatiques » qui seront d´ecrites ici car elles ont un attrait cer- enddo tain, mais elles sont d’un int´erˆet moins imm´ediat pour le end
calcul scientifique pur et dur.
2.14.1
kind
Le type double precision est consid´er´e comme obsol`ete et disparaˆıtra probablement dans une version ult´erieure de Fortran. Son int´erˆet est de faire des calculs avec un plus grand nombre de chiffres significatifs, ce qui est parfois utile, sinon indispensable. Il est remplac´e par le concept plus g´en´eral de kind40 qui s’applique aux entiers, aux r´eels et aux caract`eres. Dans la plupart des cas (¸ca d´epend du processeur) un kind=4 codera un nombre sur 4 octets (c’est en g´en´eral ce qui se passe quand on ne pr´ecise rien et cela donne 6 chiffres significatifs) et un kind=8 sur 8 octets, soit la double precision ( 15 chiffres significatifs). Ainsi : real :: x et real (kind=4) :: x sont (sur la plupart des ordinateurs) ´equivalents. De mˆeme : double precision :: x et real (kind=8) :: x De la mˆeme fa¸con, on peut faire des double complex par complex (kind=8) :: z Quel int´erˆet tout cela peut-il avoir ? La d´eclaration real est un peu ambig¨ ue parce que, sur un processeur ` a 32 bits, le r´eel est bien cod´e sur 4 octets, alors que sur un processeur `a 64 bits (qui deviennent de plus en plus fr´equents) il est cod´e sur 8 octets, ce qui en fait l’´equivalent d’un double precision. . . La notion de kind a pour but de clarifier les choses. 40 Sorte
On peut aussi utiliser kind avec des caract`eres pour ´ecrire avec des caract`eres non-latins.
ou esp` ece. Par exemple : the American bald eagle is a kind of eagle found in Northern America. En am´ ericain « conversationnel », It’s kind of neat (prononcer : It’s kinda neat) : c’est super chouette ; he’s kind of weird : il est assez bizarre.
2.14.2
Interfaces.
Supposons qu’une ´equipe de programmeurs travaille collectivement sur un mˆeme (gros) programme en se r´epartissant les tˆ aches. Chaque programmeur n’est pas forc´ement toujours au courant du d´etail des arguments utilis´es par ses coll`egues dans tel ou tel sous-programme enfoui dans des dizaines de milliers de lignes de code ; il n’a pas forc´ement le temps ou le courage de relire tout le code existant pour retrouver la liste d’arguments et leurs types de la subroutine lfpz atis13102twr11800 ´ecrite deux ans auparavant par quelqu’un qui a entre-temps chang´e d’affectation ! Il peut ˆetre alors utile de r´esumer au d´ebut du programme principal, dans une interface, tout ce qu’il faut savoir sur tous les sous-programmes : program yepee interface subroutine lfpz_atis13102twr11800(x,y,n) integer, intent(in) :: n ! nombre real, dimension(n), intent(in) :: x ! annees real, dimension(n), intent(inout) :: y ! mvts end subroutine lfpz_atis13102twr11800(x,y,n) subroutine cp301_phln(a,h) real, intent(in) :: a ! annee real, intent(out) :: h ! heures end subroutine cp301_phln end interface ! declarations du programme principal implicit none ...
37
Physique num´erique, Philippe Depondt
Toutes les d´eclarations de tous les arguments de tous les sous-programmes sont ainsi r´ep´et´ees au d´ebut du programme principal (ou du programme appelant), avec ´eventuellement des commentaires : le compilateur peut ainsi v´erifer au passage la coh´erence des appels de sousprogrammes et signaler d’´eventuelles erreurs. L’interface ne sert cependant pas uniquement ` a se rappeler la syntaxe d’appel d’un sous-programme, elle permet de r´esoudre un certain nombre de probl`emes de d´eclaration de variables. Admettons que l’on cherche ` a faire une fonction qui fasse un produit vectoriel ~a ∧ ~b. Le r´esultat est un vecteur `a trois ´el´ements : comment d´eclarer une telle fonction ? La r´eponse est de faire une interface, ainsi :
op´erations sur les rationnels qui tiennent compte, en particulier, de la r´eduction au mˆeme d´enominateur :
program prod_test implicit none
program ratio use rat implicit none
! -- interface pour declarer une fonction-vecteur -interface function cross_product(a,b) result(c) ! result permet de definir une variable qui contient ! le resultat de la fonction. Ici cette variable est ! un vecteur a trois elements real, dimension(3), intent(in) :: a, b real, dimension(3) :: c end end interface ! --real, dimension(3) :: x, y, z write(*,’("Entrer X ",$)’) ; read(*,*) x write(*,’("Entrer Y ",$)’) ; read(*,*) y ! appel de la fonction (ce sont des tableaux!) z = cross_product(x,y) write(*,*) "X x Y = ", z ! test pour verifier que le resultat est bien ! perpendiculaire aux deux vecteurs initiaux write(*,*) "Produit scalaire X.Z", dot_product(x,z) write(*,*) "Produit scalaire Y.Z", dot_product(y,z) end !----- definition de la fonction ----function cross_product(a,b) result(c) implicit none real, dimension(3),intent(in) :: a, b real, dimension(3) :: c c = cshift(a,1)*cshift(b,-1)-cshift(b,1)*cshift(a,-1)
! programme principal
interface operator (*) ! definition de l’operateur * (multiplication) ! il s’agit ici simplemement de faire le lien ! entre le symbole ’*’ et la fonction ’ratmul’ function ratmul(q1,q2) result(q3) use rat type(rationnel), intent(in) :: q1, q2 type(rationnel) :: q3 end function ratmul end interface operator (*) interface operator (+) ! meme chose pour l’addition function ratadd(q1,q2) result(q3) use rat type(rationnel), intent(in) :: q1, q2 type(rationnel) :: q3 end function ratadd end interface operator (+) ! declaration de deux nombres rationnels p et q ! le numerateur de q s’ecrit q%n et ! son denominateur q%d ! meme chose pour p type (rationnel) :: q, p write(*,’("Num, denom 1: ",$)’) read(*,*) q%n, q%d write(*,’("Num, denom 2: ",$)’) read(*,*) p%n, p%d ! utilisation des deux nouveaux operateurs write(*,*) "produit ", q*p write(*,*) "somme ", q+p end
end
-Exercice : ´etudier le fonctionnement des cshift dans la fonction cross product en comparant avec la d´efinition du produit vectoriel. . .
2.14.3
module rat ! definition du type rationnel dans un module pour ! eviter d’avoir a le refaire dans tous les ! sous-programmes type rationnel integer :: n, d end type rationnel ! le type rationnel est compose de deux nombres ! entiers : n = numerateur et d = denominateur end module rat
Objets de type d´ eriv´ e.
function ratmul(q1,q2) result(q3) ! ratmul est une fonction de type rationnel ! mais ce type n’est pas encore defini pour ! cette fonction, d’ou la syntaxe result use rat implicit none type(rationnel), intent(in) :: q1, q2 type(rationnel) :: q3 q3%n = q1%n*q2%n q3%d = q1%d*q2%d call simplify(q3) end function ratmul
En fortran, il y a les types integer, real, etc. On peut aussi fabriquer dans un programme des types nouveaux en combinant des types existants, par exemple, character et real, et d´efinir des op´erations (addition, multiplication) s’effectuant sur ces nouveaux types. Par exemple, un rationnel est compos´e de deux nombres entiers, num´erateur et d´enominateur, et l’on peut d´efinir des function ratadd(q1,q2) result(q3)
38
Licence de physique L3 : Physique Fondamentale & PHYTEM,
use rat implicit none type(rationnel), intent(in) :: q1, q2 type(rationnel) :: q3 q3%n = q1%n*q2%d + q2%n*q1%d q3%d = q1%d*q2%d call simplify(q3) end function ratadd subroutine simplify(q) use rat implicit none type(rationnel) :: q integer :: i, m ! si a la fois numerateur et denominateur sont ! divisibles par le meme nombre, le faire : ! c’est pedestre, mais ca marche... m = min(abs(q%n),abs(q%d)) l1 : do i = 2, m l2 : do ! il faut parfois recommencer if (mod(q%n,i) == 0 .and. mod(q%d,i) == 0 ) then q%n = q%n/i q%d = q%d/i else exit l2 endif enddo l2 enddo l1 end subroutine simplify
C ¸ a donne par exemple : $ ratio Num, denom 1: 5 2 Num, denom 2: 4 5 produit 2 1 somme 33 10
5 4 20 2 5 4 ce qui est correct : × = = et + = 2 5 10 1 2 5 33 5×5+2×4 = . 2×5 10 On peut, sans difficult´e majeure, ajouter ` a cela les deux autres op´erations et l’on aura cr´e´e un type nouveau et les op´erations associ´ees. Les types d´eriv´es et les op´erations associ´ees constituent un pas important du fortran en direction de la programmation orient´ee « objet » au d´etriment, sans doute, de la simplicit´e originelle du langage : la norme fortran2003 la d´eveloppe d’ailleurs encore davantage. -Exercice : d´efinir un type temps compos´e d’heures, minutes, secondes et une addition et une soustraction permettant de calculer en sexag´ecimal (par exemple : 1h32mn24s + 2h42mn39s = 4h15mn3s). -Exercice : d´efinir un type triangle d´efini par les coordonn´ees de ses trois sommets et une op´eration * d’homoth´etie permettant de le dilater d’un facteur r´eel sans d´eplacer son centre de gravit´e.
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
doute les scientifiques eux-mˆemes qui sont frapp´es d’obsolescence ! En attendant, l’un des reproches essentiels que l’on fai(sai)t au fortran est l’absence de pointeurs. Un pointeur est une variable qui contient l’adresse d’une variable : si l’on modifie un pointeur, on ne modifie pas la valeur de la variable, mais on « pointe » vers une autre adresse et donc une autre variable. A priori, un pointeur est donc juste une variable enti`ere qui contient une adresse et l’on peut faire les op´erations que l’on veut sur cette adresse, aux risques et p´erils de l’utilisateur. C’est ainsi en assembleur et en langage C qui est tr`es proche de la machine. En assembleur en particulier, il n’y a pas de tableaux, mais on peut acc´eder `a des grandeurs stock´ees `a la suite les unes des autres en m´emoire simplement en incr´ementant un pointeur, ce qui revient au mˆeme, si ce n’est que c’est d’un maniement sensiblement plus d´elicat. . . Les pointeurs sont importants en informatique parce que c’est le point de d´epart de l’allocation dynamique de m´emoire, puisqu’on acc`ede ainsi librement `a toute la m´emoire sans en r´eserver des morceaux `a telle ou telle variable. fortran90 g`ere l’allocation dynamique de m´emoire autrement, comme on l’a vu, et -opinion qui n’engage que son auteur- de fa¸con nettement plus prudente. Autant dire que pour l’essentiel du calcul scientifique, la capacit´e `a utiliser des tableaux efficacement est beaucoup plus importante. Toutefois, fortran90 introduit les pointeurs avec un certain nombre de garde-fous. Un pointeur doit ˆetre d´eclar´e avec le type de la variable vers lequel il pointe : un pointeur donn´e ne peut pas avoir pour cible un entier `a un moment et un r´eel un peu plus tard : ! declaration d’un pointeur integer, pointer ! declaration d’un pointeur real, dimension(:), pointer
vers un entier :: a vers un tableau reel :: b
Il faut aussi d´eclarer explicitement des variables comme cible (target en anglais) : integer, target :: n, m real, dimension(150), target :: x, y
Si l’on veut que a pointe vers m et b vers x, cela donne : a => m b => x
Quel int´erˆet ? On peut, par exemple, faire pointer un pointeur vers un morceau de tableau b => x(100:150)
ce qui permet d’optimiser des transferts de donn´ees d’un morceau de tableau `a un autre : dans certains cas on ´economise ainsi de l’espace m´emoire.
2.14.5
R´ ecursivit´ e.
fortran90 l’autorise. . . c’est parfois commode, rarement efficace, du moins pour le calcul scientifique pur et « Le fortran est un langage d´epass´e, vieillot, ob- dur. L’exemple que l’on donne toujours est le calcul de sol`ete. . . » : ce sont des propos que l’on entend depuis factorielles : la d´efinition de n! est, plus de vingt ans41 , or le fortran continue ` a ˆetre larn! = n(n − 1)! gement employ´e en calcul scientifique ; ce sont donc sans
2.14.4
Pointeurs.
41 Dans les ann´ ees 1980, il advint un jour que le laboratoire o` u je travaillais dut acqu´ erir une station de travail ; les repr´ esentants d’un des fournisseurs pressentis vinrent vanter les m´ erites de leurs
productions et demand` erent quel langage on utilisait afin d’inclure le compilateur dans leur devis. Quand la r´ eponse fut : « fortran », nous eˆ umes droit a ` des regards pour le moins. . . incr´ edules !
Physique num´erique, Philippe Depondt
Cela se programme sans difficult´e ` a condition de sp´ecifier que la function est r´ecursive : program factorielle implicit none integer :: n, fact write(*,’("Entrer un entier : ",$)’) ; read(*,*) n write(*,*)"Factorielle", n," vaut ",fact(n) end recursive function fact(n) result(f) implicit none integer, intent(in) :: n integer :: f if ( n > 1 ) then f = n*fact(n-1) ! ici la fonction s’appelle ! elle-meme, c’est recursif else f = 1 endif end function fact
Cinq minutes de r´eflexion permettent cependant de re´ecrire la fonction : integer function fact(n) implicit none integer, intent(in) :: n integer :: f = 1 if ( n > 1 ) then do i = 2, n f = f*i ! ici, ca n’a rien de recursif enddo endif fact = f end function fact
La deuxi`eme version est plus efficace parce que la premi`ere devra stocker tous les r´esultats interm´ediaires en m´emoire de fa¸con parfaitement inutile, ce que la deuxi`eme ne fait ´evidemment pas. La r´ecursivit´e est une question importante pour les informaticiens dans la mesure o` u elle leur facilite consid´erablement la tˆ ache dans, par exemple, des probl`emes de logique tournant autour de la d´ecidabilit´e (Entscheidungsproblem quand on veut montrer que l’on a de l’´education. . .). Pour un physicien qui se borne en g´en´eral `a utiliser des algorithmes standards, cela reste assez marginal. — Apr`es cette premi`ere partie, on constate donc que le langage fortran90 est tr`es riche et que l’on peut faire avec ce langage des choses plutˆ ot ´elabor´ees. Il n’est bien sˆ ur pas utile d’apprendre tous les d´etails du langage en quelques semaines, mais il est indispensable d’en avoir une pratique suffisante pour ne pas ˆetre gˆen´e par des d´etails de programmation pendant les s´eances de travaux pratiques, au cours desquelles, tr`es rapidement, on se pr´eoccupera plus de physique que de langage ! Il est recommand´e d’ˆetre capable, assez rapidement, d’´ecrire sans trop h´esiter des programmes comportant conditions, boucles, tableaux, sous-programmes et entr´ees-sorties : le reste viendra avec la pratique, mais,
39
les bases doivent ˆ etre imp´ erativement apprises et maˆıtris´ ees, car sans cela, on s’expose ` a patauger sans grand profit dans un bourbier de d´ etails informatiques sans int´ erˆ et !
Ces remarques ach`event la partie langage de ce cours. Dans la suite, les exemples seront donn´es en fortran, mais les algorithmes ´etudi´es ne d´ependent ´evidemment pas du langage de programmation choisi.
40
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
Chapitre 3
Un prototype de TP 3.1
Introduction.
3.2.1
La physique num´erique requiert sans doute quelques connaissances dont le pr´esent cours a pour but de fournir l’essentiel. Il s’agit toutefois d’une activit´e essentiellement pratique : il faut ´ecrire des programmes qui, non seulement « marchent », mais aussi r´epondent aux questions pos´ees de sorte que la physique du probl`eme soit trait´ee de fa¸con satisfaisante ; il faut pour cela un minimum d’exp´erience pour, bien sˆ ur, maˆıtriser le langage, mais en outre avoir une familiarit´e suffisante avec l’environnement et les m´ethodes afin que ceux-ci deviennent l’aide puissante qu’ils doivent ˆetre et non plus la gˆene. . . qu’ils constituent sans conteste au d´ebut ! C’est la raison pour laquelle cet enseignement comporte une part importante de travaux pratiques. Chacune de ces s´eances de TP est consacr´ee `a un probl`eme de physique qui illustre l’usage que l’on peut faire de telle ou telle m´ethode. Elle est pr´ec´ed´ee d’une s´eance de travaux dirig´es au cours de laquelle on pr´esente le probl`eme, ´eventuellement on montre les limites du calcul analytique et on d´ecrit les m´ethodes num´eriques qui seront utilis´ees pour le traiter. Si le probl`eme pr´esente des difficult´es particuli`eres de programmation, celles-ci seront ´egalement abord´ees. Il est attendu des ´etudiants qu’ils arrivent en s´eance de TP en ayant 1o pris connaissance du probl`eme et 2o avec une bonne id´ee de comment le r´esoudre et qu’ils en partent en rendant un compte-rendu qui compte pour la note de contrˆole continu. La question est ´evidemment : « que doit-il y avoir dans un compte-rendu de TP ? » Comme il s’agit d’un exercice un peu particulier, on traite ci-dessous, ` a titre d’exemple, la question de l’´equation logistique « ` a la mani`ere » d’un TP. . .
3.2
L’´ equation logistique.
De la multiplication des insectes.
Imaginons une population, par exemple, d’insectes, comportant `a la g´en´eration p, zp individus. Si chaque individu donne lieu, en moyenne, `a α insectes (par exemple en pondant α œufs, pour mourir ensuite) `a la g´en´eration suivante, celle-ci comportera zp+1 = α zp in´ dividus. Evidemment, si α > 1, la population d’insectes diverge exponentiellement, une perspective sans doute quelque peu effrayante mais qui ne tient pas compte des ressources disponibles, la nourriture en particulier : plus les insectes sont nombreux, plus les ressources deviennent rares pour chaque insecte qui aura donc plus de difficult´es `a s’assurer une descendance. Le coefficient α doit alors d´ecroˆıtre lorsque le nombre d’insecte augmente ; on peut alors prendre l’expression lin´eairement d´ecroissante (c’est le plus simple) suivante : α = r(1 −
zp ) ζ
o` u ζ est le nombre d’insectes qui ´epuise toutes les ressources au point de ne pas pouvoir donner lieu `a une g´en´eration suivante. . . Cela donne : zp+1 = r zp (1 −
zp ) ζ
On peut re´ecrire cette ´equation en prenant comme variable zp xp = ζ de sorte que 0 < xp < 1, et : xp+1 = r xp (1 − xp ) ce qui constitue l’´equation logistique. Il s’agit donc de d´eterminer comment se comportera la population d’insectes en fonction du param`etre r.
3.2.2
´ Etude pr´ ealable.
Il s’agit d’un grand classique de la physique du chaos1 , 3.2.2.1 Les points fixes. c’est un probl`eme qui ne n´ecessite pas de connaissances Existe-t-il des solutions stationnaires telles que xp+1 = particuli`eres en m´ethodes num´eriques et qui pr´esente un x ? Si oui, elles doivent obeir `a : p certain aspect ludique2 ce qui en fait un bon exemple d’une fa¸con de proc´eder. x = r x(1 − x) 1 Voir
par exemple : Edward Ott, Chaos in dynamical systems, Cambridge University Press (1993), p. 31. 2 On pourra certes objecter que le caract` ere « ludique » de cette activit´ e d´ epend un peu des goˆ uts. . . mais on postulera ici que le public de physiciens auquel ce cours s’adresse sera sensible a ` ses charmes.
soit :
1 r On admettra que la solution nulle n’a gu`ere d’int´erˆet puisque dans ce cas il n’y a pas d’insectes. La solution
41
x=0
ou
x=1−
42
Licence de physique L3 : Physique Fondamentale & PHYTEM,
non-nulle, elle, n’existe que si r > 1 car on ne consid`ere que les valeurs de x positives, s’agissant d’un nombre d’insectes. Par ailleurs, comme xp+1 doit, comme xp , par d´efinition, ˆetre inf´erieur `a un, le maximum de la fonction f (xp ) = r xp (1 − xp ) doit ˆetre ´egalement inf´erieur ` a un. Il est situ´e 1 r en xp = et vaut , autrement dit, r ≤ 4. Ainsi, on se 2 4 restreindra `a l’intervalle 1 < r ≤ 4 et les points fixes vont 3 de 0 pour r = 1 `a pour r = 4 (figure 3.1). 4 0.8 0.7 0.6
Point fixe
r = 4 n’a pas de comportement ais´ement caract´erisable `a premi`ere vue. Imaginons que l’on se trouve en xp `a une distance δ, 1 petite, d’un point fixe 1 − tel que : r xp = 1 −
0.4
alors, en appliquant `a xp l’´equation logistique : 1 1 xp+1 = r (1 − ) + δ 1 − (1 − ) − δ r r 1 = (1 − ) + δ (2 − r(1 + δ)) r
1 xp+1 − (1 − ) = r ≃
0.3 0.2 0.1 1
1.5
2
2.5 r
3
3.5
4
Fig. 3.1 – Point fixe de l’´equation logistique.
3.2.2.2
Y a-t-il convergence ?
L’existence de points fixes ne signifie pas automatiquement que le syst`eme doive converger vers l’un d’eux. Un fa¸con de s’en convaincre est de faire quelques essais comme sur la figure 3.2 sur laquelle on a trac´e les fonctions f (x) = r x(1 − x) pour plusieurs valeurs de r et g(x) = x : les points fixes sont donn´es par l’intersection des deux fonctions. 1
r=1 r=2 r=3 r=4 x
0.8
x(p+1)
0.6
0.4
0.2
0
1 +δ r
Le point xp+1 est-il plus proche du point fixe que xp ? L’´ecart s’´ecrit :
0.5
0
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
0.2
0.4
0.6
0.8
1
x(p)
´ Fig. 3.2 – Etude graphique de l’´equation logistique. Voir le texte. Prenons, par exemple, le cas r = 2 et partons de x0 = 0, 2. Alors, x1 = 2 × 0, 2(1 − 0, 2) = 0, 32 est donn´e sur la figure par l’intersection de la ligne verticale bleue avec la parabole correspondant ` a r = 2. Ce x1 doit ˆetre report´e en abscisse pour servir de nouveau point de d´epart : il suffit de tirer une ligne horizontale jusqu’` a l’intersection avec la droite g(x) = x, puis de nouveau une verticale pour obtenir x2 , etc. La figure paraˆıt montrer une convergence vers x = 0, 5, ce qui est bien ce que l’on attendait pour r = 2. Pour r = 3, il semble que le syst`eme ne converge pas, mais suive un cycle autour du point fixe, et finalement
δ(2 − r)
puisqu’a priori δ est petit devant 1. Alors : – si r = 2, on obtient un ´ecart nul, le syst`eme a converg´e, – si r = 3, on obtient −δ, l’´ecart n’a pas diminu´e mais change de signe – si r = 4, on obtient −2δ, l’´ecart a augment´e en valeur absolue et l’on peut donc s’attendre `a des ennuis ! Plus g´en´eralement, si 1 < r < 3, l’´ecart diminue en valeur absolue pr`es du point fixe, et donc on s’attend `a une convergence sans probl`eme, mais si r > 3, l’´ecart tend `a augmenter. Voici donc un premier tour d’horizon sur ce probl`eme : cela peut constituer la mati`ere du TD qui pr´ec`ede le TP. S’il doit y avoir des subtilit´es de programmation `a connaˆıtre ou des algorithmes particuliers `a appliquer (ce qui n’est pas vraiment le cas ici), ils seront ´egalement trait´es en TD. Rien de ce qui pr´ec`ede ne doit obligatoirement figurer dans votre compte-rendu, sinon pour vos propres archives : l’id´ee est qu’une s´eance de TP de 4 heures est bien courte pour perdre du temps `a recopier des notes prises en travaux dirig´es, mieux vaut faire cela chez soi !
3.2.3 0
δ (2 − r(1 + δ))
´ Etude num´ erique.
En revanche, le programme utilis´e pour r´esoudre le probl`eme doit imp´erativement ˆetre fourni, de pr´ef´erence avec des commentaires, ´eventuellement manuscrits, qui permettent de savoir ce que ce programme est cens´e faire et comment il le fait. program logistic implicit none ! equation logistique ! evolution de la population en fonction des ! generations real :: r, x, x0 = 0.01 ! condition initiale integer :: p, n=1000 ! nombre de generations ! write(*,’(" R : ",$)’) ; read(*,*) r ! lecture de r open(1, file=’logistic.res’) ! fichier de resultats do p = 1, n ! calcul et ecriture de x(p) x = r*x0*(1.-x0)
43
Physique num´erique, Philippe Depondt
write(1,*) p, x x0 = x enddo close(1) end
r=2 0.5
x(p)
0.4
0.2
0.1
0
0
5
10
15
20
25 p
30
35
40
45
50
995
1000
995
1000
0.676 r=3 0.674 0.672 0.67 0.668 x(p)
Si le r´esultat du calcul est juste un nombre, ce nombre doit ˆetre fourni dans le compte-rendu et ce r´esultat discut´e. Si le programme sert ` a une mise au point ou `a un essai, la comparaison avec ce qu’on attend doit ˆetre donn´ee. Quand le r´esultat est une figure, les axes de celle-ci doivent ˆetre identifi´es (on trace quoi en fonction de quoi ?) et les conditions du calcul pr´ecis´ees (ici la valeur de r et de la condition initiale). Des commentaires sur le r´esultat obtenu (quelle est sa signification physique ?) sont non seulement bienvenus mais attendus car le but n’est pas simplement d’´ecrire un programme mais de faire de la physique ` a l’aide de ce programme. . .
0.3
0.666 0.664
Lorqu’on modifie un programme, il faut expliquer ce que l’on est en train de faire, et ´evidemment fournir le programme modifi´e agr´ement´e des commentaires ad´equats. On aimerait ´etudier le comportement de la population d’insectes de fa¸con plus syst´ematique : pour cela, il suffit d’ajouter au programme une boucle sur r et de tracer xp non plus en fonction de p mais en fonction de r. On prend soin de ne garder que la fin du calcul pour chaque valeur de r afin d’´eliminer un ´eventuel transitoire. program logistic implicit none ! equation logistique ! diagramme de bifurcations real :: r, x, x0 integer :: i, p, n=2000, nsav open(1,file=’logistic2.out’) ! do i = 200, 400 ! boucle sur r r = 0.01*i x0 = 0.01 ! reinitialisation de x0 ! pour chaque nouvel r if ( r < 3 ) then ! quand le systeme nsav = 10 ! converge, on ne garde que else ! quelques pas mais quand ca nsav = 1000 ! devient irregulier, on doit endif ! en garder davantage !
0.662 0.66 0.658 950
955
960
965
970
975 p
980
985
990
0.9 r=3.5 0.85 0.8 0.75
x(p)
0.7 0.65 0.6 0.55 0.5 0.45 0.4 0.35 950
955
960
965
970
975 p
980
985
990
1 r=4 0.9 0.8 0.7 0.6 x(p)
La figure 3.3 montre l’´evolution de la population d’insectes pour quatre valeurs de r. – pour r = 2 le syst`eme converge rapidement vers le point fixe x = 0, 5 comme pr´evu (on a supprim´e la fin du graphe pour p > 50 car il ne s’y passe rien). – pour r = 3 le syst`eme oscille p´eriodiquement (on n’a gard´e que la fin du graphe (p > 950) correspondant a ce qui s’apparente ` ` a un r´egime stationnaire) autour 1 du point fixe 1 − ≃ 0, 667 : cela paraˆıt compatible 3 avec l’intuition que l’on en avait. – pour r = 3, 5, le syst`eme est encore p´eriodique, mais deux « p´eriodes » successives sont diff´erentes, autrement dit, la p´eriode est deux fois plus longue. – pour r = 4 le syst`eme semble se comporter de fa¸con irr´eguli`ere : on est dans une situation de chaos d´eterministe.
0.5 0.4 0.3 0.2 0.1 0 950
955
960
965
970
975 p
980
985
990
995
1000
´ Fig. 3.3 – Evolution de la population d’insectes pour r = 2, 3, 3, 5 et 4. Condition initiale x0 = 0, 01.
do p = 1, n x = r*x0*(1.-x0) ! le calcul est identique au precedent, mais on ! ecrit maintenant x en fonction de r if ( p > n-nsav ) write(1,*) r, x x0 = x enddo ! enddo ! close(1) end
44
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
1 Eq. logistique Pt fixe
0.9 0.8 0.7
x(p)
0.6 0.5 0.4 0.3 0.2 0.1 0
2
2.5
3 r
3.5
4
Fig. 3.4 – Diagramme de bifurcations pour l’´equation logistique. En bleu est repr´esent´ee la courbe des points fixes th´eoriques. On obtient ce qu’on appelle un diagramme de bifurcations (figure 3.4). En premier lieu, on constate que pour r < 3 le r´esultat coincide parfaitement avec la courbe des points fixes th´eoriques, ce qui est rassurant quant au bon fonctionnement du programme (mais ne d´emontre en aucun cas qu’il est d´epourvu d’erreur !).
On constatera les poids respectifs de l’informatique et de la physique (il est vrai qu’en l’occurence, il s’agit plutˆ ot d’´eco-zoologie, mais peu importe) dans ce qui pr´ec`ede : la balance penche fortement du cˆ ot´e de cette derni`ere et c’est ainsi qu’il doit en ˆetre. Parfois au cours d’un TP, on pourra rencontrer des aspects techniques plus d´elicats que dans cet exemple et il faudra s’assurer avec autant de soin que possible que la m´ethode utilis´ee est digne de confiance, mais le principe de base reste : « n’oublions jamais que nous sommes des physiciens ! »
On observe ensuite qu’` a partir de r = 3 la courbe se divise en deux : cela signifie que pour chaque valeur de r, xp Toutefois, apr`es cette belle d´eclaration de principes, il oscille entre deux valeurs comme sur la deuxi`eme courbe faut quand mˆeme s’occuper des m´ethodes elle-mˆemes. . . de la figure 3.3. Puis, un peu avant r = 3, 5, on a un nouveau d´edoublement et xp prend quatre valeurs distinctes. On observe encore un autre d´edoublement pour huit valeurs avant de tomber dans un continuum qui signifie que xp prend toutes les valeurs entre 0 et 1. Au-del` a, on observe quelques « fenˆetres d’ordre » dans les zones moins sombres qui correspondent au fait que xp n’explore pas toutes les valeurs du domaine. Une ´etude plus pouss´ee permettrait peut-ˆetre de v´erifier si la s´equence des d´edoublements suit une suite de Feigenbaum ou d’´etudier l’invariance par changement d’´echelle en calculant les dimensions fractales des domaines explor´es par xp en fonction de r. On peut aussi pr´ef´erer, ` a une ´etude du chaos d’un point de vue math´ematique, se poser la question de la validit´e du mod`ele en introduisant des ingr´edients suppl´ementaires, par exemple, le fait que les ressources ne se trouvent pas forc´ement `a proximit´e des insectes et que donc leurs fa¸cons de rechercher ces ressources (leurs « strat´egies ») n’est pas sans effet. D’´eventuels pr´edateurs peuvent ´egalement jouer un rˆ ole.
Chapitre 4
M´ ethodes num´ eriques. Ce chapitre d´eveloppe les principales m´ethodes On obtient apr`es quelques lignes de calcul : num´eriques utilis´ees par les physiciens : afin d’´eviter qq ′ xq cos θ + (yq − ℓ) sin θ d’en faire un manuel de math´ematiques appliqu´ees, que sin θ + 3 4πε mg 0 d’autres seraient sans doute mieux ` a mˆeme de r´ealiser, [(ℓ sin θ − xq )2 + (ℓ(1 − cos θ) − yq )2 ] 2 chaque m´ethode est illustr´ee par un exemple de phy=0 (4.1) sique puis´e dans la mesure du possible dans le bagage d’un ´etudiant de licence de physique, quitte ` a anticiper ce qui n’est pas ´evident `a r´esoudre analytiquement1 . l´eg`erement sur certains cours (en physique quantique ou Il s’agit d’un cas particulier du probl`eme de la recherche en thermodynamique statistique en particulier). du ou des z´ero(s) d’une fonction, c’est-`a-dire trouver le ou les x tel(s) que f (x) = 0
4.1
Recherche fonction.
des
z´ eros
d’une
Il existe deux m´ethodes principales pour r´esoudre num´eriquement ce genre de probl`eme.
Partons d’un exemple compl´etement acad´emique mais ethode de la dichotomie. tr`es simple : un pendule simple de masse m porte `a son 4.1.1 M´ extr´emit´e une charge q. On place ` a proximit´e une autre Comme son nom l’indique, il s’agit d’une recherche dans charge q ′ (figure 4.1). Trouver l’angle d’´equilibre θ du penun intervalle que l’on d´ecoupe en sous-intervalles (fig. 4.2). dule en fonction de la valeur de q ′ .
θ f(a) ε
q’ q f(b)
Fig. 4.1 – Le pendule charg´e
a
x
b
L’´energie potentielle de gravitation du pendule peut Fig. 4.2 – Recherche de z´ero par dichotomie. Les zones s’´ecrire : gris´ees sont ´elimin´ees par la recherche. Le rectangle allong´e Vg = mgz = −mgℓ cos θ horizontalement d´elimite la pr´ecision ε requise. o` u ℓ est la longueur du pendule et θ l’angle qu’il fait avec Admettons que sur l’intervalle [a, b] la fonction f ait un la verticale ; de mˆeme, l’´energie potentielle ´electrostatique z´ e ro et un seul : elle change de signe sur l’intervalle et donc des charges s’´ecrit : le produit f (a)f (b) est n´egatif. Coupons alors l’intervalle a+b qq ′ 1 . Si [a, b] en deux, ce qui nous donne le point x = p Ve = 2 4πε0 (ℓ sin θ − xq )2 + (ℓ(1 − cos θ) − yq )2 le produit f (a)f (x) est n´egatif, c’est que le z´ero recherch´e
se trouve dans l’intervalle [a, x], sinon il se trouve dans o` u xq et yq sont les coordonn´ees de la charge q ′ . L’´equilibre l’intervalle [x, b]. Il reste `a rediviser en deux l’intervalle est, comme d’habitude, donn´e par : d(Vg + Ve ) =0 dθ
1 On pourrait tenter de poser par exemple x = sin θ et y = cos θ, avec x2 + y 2 = 1. On tomberait alors sur un polynˆ ome de degr´ e 8 en x et y. . .
45
46
Licence de physique L3 : Physique Fondamentale & PHYTEM,
o` u se trouve le z´ero et ` a refaire la mˆeme recherche. On r´ep`ete encore la mˆeme op´eration plusieurs fois jusqu’` a ce que la pr´ecision requise soit atteinte. Comme on r´ep`ete la mˆeme proc´edure plusieurs fois de suite, on appelle cela un processus it´eratif. Deux crit`eres diff´erents sont possibles pour choisir d’arrˆeter ou non la recherche : – soit l’on d´esire une certaine pr´ecision sur la valeur de x et, donc, on arrˆete la recherche quand la longueur de l’intervalle devient inf´erieure ` a une valeur ε choisie a l’avance, ` – soit l’on veut que f (x) soit proche de z´ero avec une certaine pr´ecision comme sur la figure 4.2, c’est-`a-dire |f (x)| < ε. Une fonction informatique qui fasse cela pourrait s’´ecrire : real function dicho(f, a, b, epsilon) ! recherche de zero par dichotomie ! f = fonction reelle dont on cherche le zero ! a et b = bornes de l’intervalle de recherche ! epsilon = precision recherchee sur la valeur de f ! ! les variables y, y1, et y2 servent a conserver ! les valeurs prises par f afin d’eviter les ! calculs inutiles si f est longue a calculer
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
xq = .1 ; yq = 0. a = -1.57 ; b = 1.57 ; eps = 0.00001 open(1,file=’zero.out’)
! fichier ou l’on mettra ! les resultats
c = 0. do ! boucle pour faire varier c x = dicho(pendule, a, b, eps) write(1,*) c, x c = c + 0.01 if ( c > 2.0 ) exit enddo close(1) end ! !--------------------------real function pendule(theta) use pendu implicit none real :: theta ! l = 1 ! c = q*qprime/(4*pi*eps0*m*g)
implicit none real :: a, b, f, epsilon, y, y1, y2, x, x1, x2
pendule = sin(theta) & ! la formule occupe 3 lignes + c*( xq*cos(theta)-(1.-yq)*sin(theta))/ & ((sin(theta)-xq)**2+((1.-cos(theta))-yq)**2)**1.5 end
x1 = a ; x2 = b ! initialisation de l’algorithme y1 = f(a) ; y2 = f(b)
La fin est bien sˆ ur constitu´ee de la fonction dicho. Le r´esultat du calcul est donn´e figure 4.3. 0
do ! *** debut de la boucle *** x = 0.5*(x1+x2) ; y = f(x) ! dichotomie if ( abs(y) < epsilon ) exit ! critere d’arret ! de quel cote le zero se trouve-t-il ? if ( y1*y < 0 ) then x2 = x ; y2 = y ! a gauche [x1,x] else x1 = x ; y1 = y ! a droite [x,x2] endif enddo ! *** fin de la boucle ***
−0.2 −0.4 freq_eq
! verification de l’intervalle if( y1*y2 > 0. ) then write(*,*) ’Intervalle mal choisi’ stop endif
−0.6 −0.8 −1 −1.2 −1.4
0
0.2
0.4
0.6
0.8
1 C
1.2
1.4
1.6
1.8
2
Fig. 4.3 – Solution du probl`eme du pendule en fonction ′ de c = 4πεqq0 mg pour ℓ = 1.
On constate, sans v´eritable surprise, que plus c (ou la charge) augmente, plus le pendule s’´ecarte de la verticale. . . L’´equation (4.1) devient ais´ee a ` r´esoudre num´eriLa m´ethode de la dichotomie est assez p´edestre, elle quement `a l’aide d’un programme qui aurait l’allure sui- est sˆ ure, sans surprise. Elle n´ecessite une connaissance vante : pr´ealable de la fonction puisqu’elle suppose qu’il y ait un et un seul z´ero dans l’intervalle de recherche : il faut donc module pendu pouvoir choisir celui-ci judicieusement. dicho = x end
! ! !
mise en commun de variables pour << sauter >> par-dessus dicho valeur et position de la charge real :: c, xq, yq end
4.1.2
program zero use pendu implicit none real :: a, b, eps, dicho, x external pendule
La m´ethode de Newton est `a la fois plus efficace et plus dangereuse. Il s’agit, `a partir d’un point de d´epart x0 judicieusement choisi, d’approcher la fonction par sa tangente et de chercher l’intersection de celle-ci avec l’axe des x. Comme la fonction n’est pas a priori lin´eaire le r´esultat est faux, mais il constitue le point de d´epart d’une nouvelle recherche (figure 4.4).
M´ ethode de Newton.
47
Physique num´erique, Philippe Depondt
et un peu de trigonom´etrie ´el´ementaire donne i1 = arctan
i2 = arctan
a−x y
ainsi nous avons a rechercher la racine de la fonction a−x a+x − n2 sin arctan f = n1 sin arctan y y
y1 y2
a+x , y
x0
o` u x est l’inconnue. Si nous voulons utiliser la m´ethode de Newton, nous avons besoin de la d´eriv´ee de f par rapport `a x :
x1 x2 y0
df n1 = cos dx y Fig. 4.4 – La m´ethode de Newton.
1+
1
a+x y
2 +
n2 cos y
1+
1
Le programme suivant fait exactement cela :
a−x y
2
Si l’on part d’un point d’abscisse x0 , on doit pouvoir module params ! definition des parametres du probleme calculer f (x0 ) et la pente de la tangente f ′ (x0 ). L’inter- implicit none real, parameter :: n1 =1.0, n2 = 1.5, a = 1., y = 1. section de la tangente avec l’axe des x est donn´ee par end module params
f (x0 ) x1 = x0 − ′ f (x0 ) Il suffit de r´ep´eter l’op´eration pour x1 , x2 ,. . . xn+1 = xn −
f (xn ) f ′ (xn )
jusqu’` a ce que le crit`ere de convergence que l’on aura choisi soit v´erifi´e. Imaginons, par exemple, que l’on veuille chercher la point d’intersection d’un rayon lumineux avec un dioptre en utilisant la loi de Descartes (figure 4.5) : le rayon part −a d’un point de coordonn´ees dans un milieu d’iny a dice n1 pour arriver en un point de coordonn´ees −y dans un milieu d’indice , en passant par le dioptre au n2 x point de coordonn´ees . L’inconnue du probl`eme est 0 x.
n1
y
a i2 x
n2
subroutine trajet(x, f, df ) ! calcul de la fonction use params ! et de sa derivee implicit none real, intent(in) :: x real, intent(out) :: f, df real :: r1, r2 r1 = (a + x)/y ; r2 = (a - x)/y f = n1*sin(atan(r1)) - n2*sin(atan(r2)) df = n1*cos(1./(1.+r1**2))/y + & n2*cos(1./(1.+r2**2))/y end real function newton(x,f,eps) ! methode de Newton implicit none integer :: i, imax = 100 ! nombre max d’iterations real :: x, eps, xp, y, d
i1
a
program decartes use params implicit none real, parameter :: eps = 1.e-5 ! precision requise real :: newton external :: trajet real :: x = 0. ! condition initiale ! ce programme ne comporte qu’une instruction write(*,*) newton(x,trajet,eps), & n1*sin(atan((a+x)/y)) - n2*sin(atan((a-x)/y)) end
y
do i = 1, imax call f(x, y, d) xp = x - y/d if (abs(xp-x) < eps ) exit x = xp enddo newton = xp end
Fig. 4.5 – Loi de Descartes : notations pour utiliser la Cela donne : 0.36264408 -0.000014537249. On laissera le soin au lecteur de v´erifier que c’est correct. . . m´ethode de Newton La m´ethode de Newton a plusieurs avantages par rapport `a la m´ethode de la dichotomie. Elle est en g´en´eral La loi de Descartes s’´ecrit ´evidemment beaucoup plus rapide, ce qui dans certains cas peut n1 sin i1 = n2 sin i2 s’av´erer d´ecisif. Elle a par ailleurs le tr`es gros avantage
48
Licence de physique L3 : Physique Fondamentale & PHYTEM,
de pouvoir se g´en´eraliser ais´ement ` a plusieurs dimensions comme on le verra dans la suite. Elle a l’inconv´enient qu’il faut pouvoir calculer, ou au moins estimer la d´eriv´ee de la fonction, ce qui est parfois un peu laborieux (voir l’´equation (4.1) par exemple). Elle rec`ele toutefois quelques pi`eges parfois redoutables. Si par exemple, l’un des points xn est tel que f ′ (xn ) ∼ 0, le point xn+1 risque de se trouver projet´e fort loin du point de d´epart2 , un r´esultat contrariant alors qu’il s’agit d’une recherche en principe locale puisque bas´ee sur une approximation lin´eaire. Un deuxi`eme pi`ege est que si la fonction ´etudi´ee poss`ede plusieurs z´eros, rien ne permet de choisir `a coup sˆ ur celui que l’on veut puisqu’il n’y a pas d’intervalle de recherche pr´e-d´efini : on peut certes forcer le r´esultat `a rester dans un intervalle donn´e. Parfois, enfin, l’algorithme ne converge pas, mˆeme si une solution existe, en cas de changement de courbure malencontreux par exemple : un choix plus judicieux du point de d´epart peut r´egler le probl`eme.
4.1.3
Comment s’y prendre ?
Les paragraphes pr´ec´ecents d´ecrivent deux m´ethodes diff´erentes pour r´esoudre le mˆeme type de probl`eme, chacune avec ses qualit´es et ses d´efauts. En consultant des ouvrages sp´ecialis´es, on s’apercevra rapidement qu’il en existe d’autres. Comment proc´eder, alors ? La premi`ere ´etape est de tenter de d´egrossir qualitativement le probl`eme par des r´esolutions graphiques par exemple, soit `a l’aide de programmes de trac´e de courbes comme gnuplot, soit avec une calculette graphique, soit. . . a la main, ce qui est parfois le plus efficace car programmes ` et calculettes travaillent toujours dans un intervalle d´efini a priori et ne disent rien sur ce qui se passe ` a l’ext´erieur de cet intervalle, en particulier les asymptotes. La deuxi`eme ´etape est souvent de tenter de reformuler le probl`eme de fa¸con qu’il n’y ait qu’un seul z´ero dans le domaine « utile ». Par exemple, rechercher le z´ero de
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
0.8
tanh(x)−0.3*x tanh(x)/x−0.3
0.6 0.4 0.2 0 −0.2 −0.4 −0.6
−4
−2
0
2
4
tanh(x) Fig. 4.6 – Les courbes de tanh(x) − 0.3x et de − x 0.3 montrant que la deuxi`eme permet d’´eliminer la racine triviale pour x = 0 alors que les deux autres racines ne sont pas affect´ees. 1. l’algorithme lui-mˆeme peut-ˆetre plus ou moins pr´ecis 2. les nombres avec lesquels travaille l’ordinateur sont eux-mˆemes d´efinis avec une certaine pr´ecision. Par exemple, la m´ethode de la dichotomie, d´etermine un z´ero en l’encadrant par un intervalle d’´etendue b − a, puis b−a b−a . Comme le nombre d’it´erations est fini, , . . ., 2 2n cela donne la pr´ecision du calcul intrins`eque `a la m´ethode. Toutefois, mˆeme un algorithme parfait, s’il existait, ne pourrait pas donner des r´esultats infiniment pr´ecis `a cause du caract`ere fini de l’ordinateur lui-mˆeme qui ne peut pas repr´esenter un nombre de fa¸con parfaite.
4.2.1
Les nombres entiers.
Il a ´et´e mentionn´e que les nombres avaient une repr´esentation binaire, c’est-`a-dire constitu´ee de 0 et de 1. Ainsi pour les nombres entiers, on obtient la correspontanh x − ax = 0 dance habituelle entre repr´esentation d´ecimale (1`ere ligne) pour a < 1 donne trois solutions dont une solution triviale et binaire (2`eme ligne) : 0 1 2 3 4 5 6 7 8 ... pour x = 0 (figure 4.6) ; or l’ordinateur ne « sait » pas 0 1 10 11 100 101 110 111 1000 ... qu’elle est sans int´erˆet. Il peut ˆetre habile alors de chercher Une case contenant un 0 ou un 1 s’appelle un bit. plutˆ ot les solutions de Dans l’immense majorit´e des ordinateurs, les bits sont retanh(x) group´es par groupes de huit, les octets, ou bytes en an−a=0 x glais. Un octet constitue g´en´eralement un emplacement correspondant `a une adresse dans la m´emoire vive de l’orqui ´elimine la solution triviale si a 6= 1, puisque dinateur. Le tableau ci-dessus devrait donc se re´ecrire : 0 1 2 3 4 tanh(x) =1 lim 00000000 00000001 00000010 00000011 00000100 x→0 x C’est alors qu’on peut choisir une m´ethode, Newton si le probl`eme s’av`ere assez « civilis´e » dichotomie sinon.
5 00000101
6 00000110
7 00000111
8 00001000
... ...
Avec un octet on peut donc repr´esenter les nombres entiers allant de 0 `a 28 − 1 = 255 : c’est un peu limit´e, car aimerait pouvoir utiliser, d’une part, des nombres plus 4.2 Repr´ esentation des nombres on grands et, de l’autre, des nombres n´egatifs. dans un ordinateur. Pour pouvoir repr´esenter les nombres n´egatifs, on doit changer la convention et l’on prend le compl´ement `a Dans ce qui pr´ec`ede, on a introduit, sans trop insister, deux, soit, toujours sur un octet : 00000001 = 1 et la notion de pr´ecision du r´esultat. Cette pr´ecision n’est 11111110 = −1 au lieu de 254. Ainsi de 00000000 = 0 jamais absolue pour plusieurs raisons. `a 01111111 = 127 on code des nombres positifs et pour 2 Shot off to outer space comme disent joliment nos coll` egatifs, 11111110 = −1, 11111101 = −2, egues les nombres n´ am´ ericains. . . ., jusqu’` a 11111111 = −128. On peut v´erifier qu’avec
49
Physique num´erique, Philippe Depondt
cette convention l’addition suivante est correcte : −4 11111011 +2 00000010 = −2 11111101 Afin d’avoir une plage de nombres accessibles plus grande, les octets sont g´en´eralement regroup´es par ensembles de quatre (appel´es mots), soit 32 bits3 . Ainsi les nombres entiers peuvent aller de −231 = −2 147 483 648 `a 231 − 1 = 2 147 483 647, ce qui est largement suffisant pour la plupart des applications, mais, ´evidemment, pas infini.
4.2.2
Les nombres r´ eels.
Parler de nombres r´eels est un abus de langage puisque l’on √ ne peut traiter que les nombres rationnels. Ainsi, 2 sera approxim´e par, par exemple, 1,414213562. De plus, on est oblig´e de se restreindre encore davantage aux nombres rationnels ` a un nombre fini de chiffres : 1/3 devient par exemple 0,3333333333. Un tel nombre rationnel, si l’on supprime la virgule, est un nombre entier : il suffit de pr´eciser l’emplacement de la virgule, par une puissance de 10, par exemple. Ainsi, 1,414213562 peut s’´ecrire 1414213562 10−9 . Une autre fa¸con de s’y prendre serait : 0, 1414213562 101 . L’avantage de la deuxi`eme est que l’expression des chiffres composant le nombre est comprise entre 0 et 1, chaque chiffre correspondant non plus `a une puissance positive de 10 mais ` a une puissance n´egative. Il faut donc trois choses : le signe, la position de la virgule (ou l’exposant), et les chiffres (la mantisse). Le raisonnement men´e jusqu’` a pr´esent avec une notation d´ecimale peut-ˆetre tout aussi bien fait en binaire. Ainsi un nombre r´eel s’´ecrit, en g´en´eral sur quatre octets, soit 32 bits : 1 bit pour le signe, 8 bits pour l’exposant qui donne une puissance de 2 puisqu’il s’agit de nombres binaires, 23 bits pour la mantisse ; or le premier bit de la mantisse est toujours 1 (sinon, il faudrait diminuer l’exposant de 1), donc on l’omet ce qui permet de gagner un bit significatif. Dans ces conditions, les nombres r´eels peuvent s’´etendre de ±1, 175494 10−38 ` a ±3, 402823 1038 avec sept chiffres significatifs. Si cela ne suffit pas, on peut utiliser la double precision sur 8 octets qui donne 15 chiffres significatifs de 2, 225074 10−308 ` a 1, 797693 10308 . Certaines machines acceptent aussi les real*16 sur 16 octets. . .
pr´ecision machine, vaut 1000 : peu importe que l’on r´ep`ete l’op´eration un milliard de fois ! Finalement 1000 − 1000 = 0. . . En d´eclarant s en double precision on obtient : 0.9999894254 Il faut donc ˆetre assez m´efiant lorsqu’on traite des nombres qui prennent des valeurs tr`es diff´erentes. Il est aussi prudent de se rappeler que lorsqu’on fait des calculs it´eratifs, ce qui est tr`es souvent le cas, les erreurs peuvent s’ajouter les unes aux autres pour ne plus ˆetre n´egligeables du tout ! Un deuxi`eme cas de figure classique est le suivant : if( a == 0. ) then o` u a est un r´eel. Le r´esultat d’une telle instruction est al´eatoire `a cause des erreurs d’arrondi ! En effet, si a est le r´esultat de calculs longs et compliqu´es, va-t-il tomber pile sur z´ero ou sur 0.1234567E-35 ? Il vaut bien mieux d´efinir a priori la pr´ecision souhait´ee et donner l’instruction : if( abs(a) < epsilon ) then si la valeur absolue de a est plus petite que ε, alors. . . Ainsi, une r`egle d’or `a ne jamais oublier lorsqu’on fait des calculs num´eriques est de v´erifier sur des cas dont on connait la solution que les programmes que l’on a ´ecrits donnent bien la solution attendue. . . tout en sachant qu’il ne s’agit en aucun cas d’une garantie !
4.3 4.3.1
Suites et s´ eries. G´ en´ eralit´ es et premi` eres difficult´ es.
Une suite est d´efinie par une relation de r´ecurrence du type : un = f (un−1 , un−2 , . . . , un−p ) o` u un est une fonction de l’´el´ement de la suite pr´ec´edent ou de plusieurs ´el´ements pr´ec´edents. Par exemple, la factorielle : n! = n(n − 1)! avec 1! = 1 Une s´erie s’´ecrit comme : sn =
n X
ui ou bien sn = sn−1 + un
i=1
4.2.3
Cons´ equence.
Il n’est pas utile de faire un tableau contenant tous les termes de la suite ou de la s´erie, car on n’a en g´en´eral La cons´equence de tout ceci est que les calculs se font besoin que du dernier terme : c’est le reproche que l’on avec une certaine pr´ecision intrins`eque (qui est a priori bonne : sept chiffres significatifs. . .). Imaginons toutefois faisait `a la r´ecursivit´e. Dans le cas de la factorielle, il suffit d’´ecrire quelque chose qui ressemble `a le programme, certes stupide, suivant : implicit none integer :: i real :: s s = 1000. do i = 1, 1000000000 s = s + 1e-9 enddo write(*,*) s-1000. end
Le r´esultat obtenu est 0. et non 1. ! La raison en est que l’on ajoute 1000 + 1 10−9 ce qui, compte tenu de la 3 Certaines machines, comme les Cray ou certaines stations de travail, utilisent des mots de huit octets, soit 64 bits.
f = 1 do i = 2, n ; f = f*i ; enddo
en faisant croˆıtre i dans une boucle. Pour une s´erie, cela deviendrait : s = ... ! expression du premier terme do i = 2, n s = s + .... ! expression du terme general enddo 4 Le r´ esultat pr´ ecis d´ epend du type de la machine utilis´ ee, du compilateur : ici, il s’agit d’une machine Linux avec g77. Parfois il peut ˆ etre judicieux d’essayer le mˆ eme programme sur deux machines diff´ erentes avec deux compilateurs diff´ erents.
50
Licence de physique L3 : Physique Fondamentale & PHYTEM,
4.3.1.1
Pr´ ecision.
Il faut ˆetre prudent lors du calcul d’une suite car la remarque du paragraphe 4.2.3 s’applique tout `a fait et l’on a parfois des surprises. Par exemple, la s´erie : sn (x) = sn−1 (x) + (−1)n−1
2n−1
x , avec s1 (x) = x (2n − 1)!
est simplement le d´eveloppement de la fonction sinus limit´e `a l’ordre 2n − 1. Le programme suivant est l’application directe de cette formule : implicit none real :: x, s integer :: n, i, p, f, l n = 17 ! indice du dernier terme x = acos(-1.0)/2 ! calcul de pi/2 f = 1 ; s = x ; l = 1 ! initialisations do i = 2, n p = 2*i-1 ! exposant f = f*(p-1)*p ! factorielle l = -l ! changement de signe s = s + l*x**p/f enddo write(*,*) sin(x), s, s-sin(x) ! comparaison end
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
d´esastreuses6. Ce serait d’autant plus impardonnable qu’il existe une solution tr`es simple au probl`eme : Pn (x) = (. . . ((an x + an−1 )x + an−2 )x + . . .)x + a0 et cela se programme sans difficult´e `a l’aide d’une boucle d´ecroissante : real function polyn(x,a,n) ! schema de Horner integer :: i, n real, dimension(0:n) :: a real :: x, pn pn = a(n) do i = n-1, 0, -1 pn = pn*x + a(i) enddo polyn = pn end
On aurait tort de se priver !
4.3.2
Calcul des int´ egrales.
Toutes les int´egrales ne sont pas calculables analytiquement malgr´e les tables et les programmes de calcul formel, et c’est parfois bien utile de pouvoir les ´evaluer num´eriquement. Par exemple, admettons que l’on ait un fil charg´e. Le fil est d´ecrit par trois coordon´ees en fonction d’une abscisse ` l’ordre n = 17, ce qui correspond en fait `a un curviligne s : (x(s), y(s), z(s)) et sa charge par une densit´e A d´eveloppement limit´e ` a l’ordre 33 en x, on obtient pour lin´eique σ(s). Le potentiel ´electrostatique en un point de x = π2 , le r´esultat s=0.9964 au lieu de un, un r´esultat coordonn´ees (x0 , y0 , z0 ) s’´ecrit : un peu d´ecevant pour un ordre aussi ´elev´e. Pire, si l’on tente d’aller plus loin, n = 18, on obtient -INF. . . C’est V (x0 , y0 , z0 ) = Z s1 simplement que l’on est en train d’additionner des termes σ(s) ds 1 de signes oppos´es et que la diff´erence des valeurs absolues p 2 4πε0 s0 (x(s) − x0 ) + (y(s) − y0 )2 + (z(s) − z0 )2 est petite, donc ils se compensent en grande partie deux `a deux ; le r´esultat est entach´e d’une erreur relative importante. Si l’on essaye d’aller trop loin pour r´eduire l’erreur, les factorielles se mettent ` a produire des nombres gigantesques ! Il se trouve que pour ce genre de calcul, ce n’est pas la bonne m´ethode : il vaut mieux utiliser les polynˆomes dits « de Tchebytchev »5 . On peut en tirer deux conclusions. La premi`ere est que sommer des termes sans prendre de pr´ecautions est parfois dangereux. La deuxi`eme est que, lorsqu’on peut le faire, il est bon de classer les termes que l’on doit sommer par ordre croissant de telle fa¸con ` a ´eviter autant que possible les additions de termes d’ordre de grandeurs tr`es Fig. 4.7 – Un fil charg´e. diff´erents. 4.3.1.2
Polynˆ omes : le sch´ ema de Horner.
Si l’allure du fil ressemble `a celui de la figure 4.7, une int´egration num´erique sur ordinateur peut ˆetre une solution de bon goˆ ut !
Le calcul d’un polynˆ ome est un bon exemple de ce qui a ´et´e dit ci-dessus. Soit : 4.3.2.1 Pn (x) =
n X
aℓ xℓ
ℓ=0
Ne pas tenter de faire la somme ci-dessus directement ! En effet les puissances successives de x produiront sans aucun doute des termes dont les ordres grandeurs seront extrˆemement variables, avec des cons´equences 5 Voir par exemple dans les Numerical Recipes, r´ ef´ erence [3] dans la bibliographie.
M´ ethode des rectangles.
C’est la plus simple : il s’agit de remplacer une int´egrale par une somme finie (voir la figure 4.8) : Z
a
b
f (x) dx ∼
6 Numerical
n−1 X i=0
f (a + iδx )δx avec δx =
b−a n
Recipes (voir bibliographie, r´ ef´ erence [3]), qui n’y va pas avec le dos de la cuill` ere, va jusqu’` a menacer : « Come the (computer) revolution, all persons found guilty of such criminal behaviour will be summarily executed » ! L’humour est sans doute douteux, mais le message est clair.
51
Physique num´erique, Philippe Depondt
on remplace le calcul de la surface par une approximation soit en regroupant les termes identiques : constitu´ee d’une somme de surfaces de rectangles. ! Z b n−1 X 1 1 f (a + iδx ) + f (b) f (a) + f (x) dx ∼ δx 2 2 a i=1 on retrouve une formule tr`es similaire `a celle de la m´ethode des rectangles, mais elle est sym´etris´ee et les termes extrˆemes sont divis´es par deux : en fait, il s’agit d’une m´ethode des rectangles centr´ee dans laquelle les points extrˆemes « p`esent » moiti´e moins (figure 4.10).
Methode des rectangles a gauche
Methode des rectangles a droite
Fig. 4.8 – Les deux variantes de la m´ethode des rectangles. Une autre approximation tout aussi l´egitime serait : Z
a
b
f (x) dx ∼
n X
f (a + iδx )δx
i=1
La seule diff´erence est dans les bornes de la somme qui maintenant d´emarre en i = 1 au lieu de z´ero. Cela revient a ´evaluer la valeur de la fonction ` ` a droite de l’intervalle au Fig. 4.10 – Sch´ema ´equivalent `a la m´ethode des trap`ezes. lieu de l’´evaluer `a gauche. C’est pour cela que ces m´ethodes sont appel´ees m´ethodes des rectangles ` a gauche pour l’une, Le r´esultat en est un gain d’un ordre de grandeur sur a droite pour l’autre. En principe, plus n est grand, plus les l’incertitude du r´esultat. ` deux r´esultats doivent ˆetre proches : gare aux probl`emes d’arrondis num´eriques toutefois si n est trop grand ! 4.3.2.3 Recherche du pas d’int´ egration. La grosse diff´erence entre une int´egration num´erique et l’expression math´ematique est que le pas d’int´egration δx Une m´ethode moins primitive et ` a peine plus compliqu´ee ne tend pas vers z´ero, dans un calcul num´erique, il prend est la m´ethode des trap`ezes (figure 4.9). une valeur finie non nulle : c’est une approximation, il reste `a choisir cette valeur de la fa¸con la moins arbitraire possible. Une premi`ere m´ethode serait de choisir δx arbitrairement, faire le calcul d’int´egrale, puis choisir une autre valeur et refaire le calcul. Si les deux r´esultats diff`erent d’une quantit´e moindre que la pr´ecision souhait´ee, c’est que le calcul est « ind´ependant » de δx . Il n’est pas interdit d’essayer de syst´ematiser un peu ce genre de recherche. Commen¸cons par choisir δx = b − a, alors une premi`ere estimation de l’int´egrale par la m´ethode des trap`ezes serait : 4.3.2.2
M´ ethode des trap` ezes.
S0 = (b − a) Fig. 4.9 – La m´ethode des trap`ezes. La surface du i-i`eme trap`eze s’´ecrit : si =
1 (f (a + (i − 1)δx ) + f (a + iδx )) δx 2
et donc : Z b n X 1 (f (a + (i − 1)δx ) + f (a + iδx )) δx f (x) dx ∼ 2 a i=1
f (a) + f (b) 2
Pour une deuxi`eme estimation, on peut alors diviser δx par deux, on obtient alors : f (b) (b − a) f (a) a+b + S1 = +f 2 2 2 2 S0 + R1 = 2 avec, en posant h = b − a :
h a+b R1 = f 2 2
52
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
ce qui ´evite d’avoir ` a recalculer les deux points extrˆemes. sp = s/2 + r*hm On redivise le pas par deux, puis de nouveau encore, ! ---> le test force au moins quatre iterations if( abs(s-sp) < eps .and. n > 3 ) exit etc. Un calcul simple donne alors le terme g´en´eral de la s = sp r´ecurrence : Sn
=
Rn
=
Sn−1 + Rn 2 2n−1 h h X f a + (2i − 1) n 2n i=1 2
enddo trapeze = sp end
4.3.2.4
Un exemple : le principe de Fermat
Imaginons un rayon lumineux qui circule dans une fibre On arrˆete le calcul lorsque l’´ecart entre deux r´esultats suc- optique cylindrique, parall`ele `a x, dont l’indice d´epend de cessifs est inf´erieur ` a la pr´ecision requise : la distance `a l’axe : r2 |Sn − Sn−1 | < ε n = n0 1 − 2 2ρ C’est cependant une m´ethode qui n’est totalement d´enu´ee o` u n0 et ρ sont des constantes. Il s’agit d’une fibre `a grade danger : soit par exemple la fonction suivante (figure dient d’indice qui permet de pi´eger, pour ainsi dire, le 4.11), rayon lumineux au centre de la fibre. Si l’on se place dans le plan xOy, r2 se ram`ene `a y 2 et chercher le trajet du 1 rayon lumineux revient `a chercher la fonction y(x). Une incursion dans le cours d’optique fournit l’´equation de pro0.8 pagation d’un rayon lumineux : d~r 0.6 d n ds ~ n = grad (4.2) ds 0.4 o` u s est l’abscisse curviligne sur le rayon du point ~r. Ceci se r´esoud analytiquement assez ais´ement `a condition de se placer dans l’approximation o` u le rayon ne s’´eloigne pas 0 trop de l’axe de la fibre, de fa¸con que sa pente par rapport −2 −1.5 −1 −0.5 0 0.5 1 1.5 2 `a l’axe reste faible, de sorte que l’on puisse identifier ds `a Fig. 4.11 – Si l’on ne prend pas de pr´ecautions, l’int´egrale dx. On obtient : de cette fonction sera nulle ! d~r ∂n d n = 0 dx ∂x = ∂n si x < 0, 5 ou si x > 1, 5 f (x) = 0 n0 y dx = − 2 sinon f (x) = 1 ∂y ρ 0.2
que l’on souhaite int´egrer de a = −2 ` a b = 2. La premi`ere soit, apr`es quelques manipulations simples, ´etape donne z´ero, et . . . la deuxi`eme aussi. L’´ecart est nul n0 y d2 y n 2 =− 2 et donc inf´erieur `a ε : le programme s’arrˆetera. La mˆeme dx ρ m´esaventure arrive si l’on cherche Z π Il reste `a approximer n par n0 , puisqu’on ne s’´eloigne pas de l’axe de la fibre, et `a chercher des solutions du type : sin(x)dx −π
2π y(x) = a sin x on trouve le r´esultat correct (soit 0), mais compl`etement λ par hasard ! Il vaut mieux restreindre le calcul de 0 `a π. pour obtenir : Comme souvent dans ce genre d’activit´es, un minimum de λ = 2πρ circonspection s’impose. Un sous-programme pourrait donner quelque chose qui On obtient alors une trajectoire sinuso¨ıdale de p´eriode ressemble `a : 2πρ ind´ependante de l’amplitude des oscillations : c’est int´eressant pratiquement, car ainsi le rayon, mˆeme si, inidouble precision function trapeze(f, a, b, eps) tialement, il n’est pas parfaitement dans l’axe, se bornera implicit none `a osciller autour de celui-ci au cours de sa propagation. double precision :: f, a, b, eps, s, h, r, sp, hm Tout ceci reste cependant un peu formel et entach´e d’apinteger :: n, m, i proximations. Un cours d’optique normalement constitu´e affirme h = b-a ; m = 1 g´ e n´ eralement -voire mˆeme d´emontre- que l’´equation 4.2 s = h*(f(a)+f(b))*0.5d0 do n = 1, 20 ! 20 iterations max est une cons´equence du principe de Fermat qui veut que m = 2*m ! 2**n le chemin optique ne d´epende pas d’un petit changement hm = h/m ; r =0. de trajectoire, soit : do i = 1, m/2 ! de 1 a 2**(n-1) Z l r = r + f(a+(2*i-1)*hm) L = n ds est un extremum enddo 0
53
Physique num´erique, Philippe Depondt
L/lambda − n0
L egrales ind´ efinies. dans le cas de la trajectoire 4.3.2.5 Int´ Pour le v´erifier, calculons λ sinuso¨ıdale ci-dessus : Dans toutes les discussions ci-dessus, seules les Z λ 2 int´ egrales d´efinies ont ´et´e abord´ees. On ne peut pas calcuL n0 y = 1 − 2 ds ler par ces m´ethodes des int´egrales du type : λ λ 0 2ρ Z ∞ or s 2 f (x)dx dy −∞ ds2 = dx2 + dy 2 ⇒ ds = dx 1 + dx On a essentiellement deux solutions : soit l’int´egrale suivante ` a calculer : 1. la fonction f (x) doit tendre vers z´ero lorsque x → L ±∞, sinon le r´esultat est infini, alors on peut faire = λ l’approximation : !s 2 Z λ 2 2πx 2 a sin λ Z b Z ∞ 2π n0 2πx 1 + a2 1− cos2 dx f (x)dx f (x)dx ∼ λ 0 2ρ2 λ λ a −∞ (4.3) Choisissons de nous int´eresser au cas o` u a est petit par avec a et b suffisamment grands en valeur absolue rapport `a λ : on peut alors d´evelopper la racine carr´ee : pour que l’erreur soit n´egligeable. Par exemple, L Z 5σ Z ∞ ∼ x2 x2 λ e− σ2 dx e− σ2 dx ∼ ! ! 2 −5σ −∞ Z a2 sin2 2πx a2 2π n0 λ 2 2πx λ dx 1+ cos 1− n’est pas une mauvaise approximation. λ 0 2ρ2 2 λ λ 2. une m´ethode plus ´el´egante est de d´ecouper l’int´egrale peut ensuiteR ´eliminer le terme en a4 et sachant que ROn 2π 2π 2 2 Z ∞ Z b Z a Z ∞ sin x dx = 0 cos x dx = π, on finit par avoir : 0 f (x)dx f (x)dx + f (x)dx + f (x)dx = L a2 π 2 a2 b a −∞ −∞ ∼ n0 1 − 2 + 2 λ 4ρ λ et de faire des approximations pour les extr´emit´es, La condition pour que L ne d´epende pas de a est que : sur la base d’un d´eveloppement limit´e par exemple. Une illustration physique simple pourrait ˆetre une disλ = 2πρ tribution lin´eique de charges sur une pelote de ficelle ce qu’on avait d´ej` a trouv´e auparavent : l’int´erˆet du sede forme compliqu´ee mais dont les extr´emit´es vont `a cond calcul ´etant de montrer que le chemin optique ne l’infini. Le potentiel cr´e´e `a l’origine pourrait s’´ecrire : d´ependant pas de a, une source de lumi`ere coh´erente Z ∞ plac´ee `a l’entr´ee de la fibre sur son axe, et produisant σ(s) 1 p ds V = un faisceau non totalement parall`ele, donnera, en sortie 4πε0 −∞ x2 (s) + y 2 (s) + z 2 (s) de la fibre, un faisceau qui n’aura pas perdu sa coh´erence, malgr´e la divergence. o` u, σ, x, y et z sont des fonctions connues de l’abscisse curviligne s. Admettons qu’une approximation 0 serait que lorsque s > b alors σ ∼ sς et que −0.01 p 2 x (s) + y 2 (s) + z 2 (s) ∼ s. On obtient alors, −0.02 −0.03 Z ∞ Z ∞ ς σ(s) ς −0.04 p ds ∼ ds = 2 2 2 2 s b x (s) + y (s) + z (s) b b −0.05 −0.06 −0.07 −0.08 −0.09 −0.1
0
0.2
0.4
0.6
0.8
1
a
ee Fig. 4.12 – L’int´egrale L λ − n0 en fonction de a calcul´ num´eriquement par la m´ethode des trap`ezes.
La mˆeme approximation pour s < a donnerait en fin de compte : # " Z b ς σ(s) ς 1 p − + ds + V = 4πε0 a b x2 (s) + y 2 (s) + z 2 (s) a o` u la partie centrale serait calcul´ee par la m´ethode des trap`ezes.
On peut ´egalement utiliser des m´ethodes similaires autour On est toutefois en droit de se demander quelle est de points singuliers `a condition de les avoir identifi´es au la validit´e des approximations que l’on a faites : pour pr´ealable. cela, il suffit d’int´egrer num´eriquement l’´equation (4.3) (Exercice : le faire ! 7 ) en faisant varier a pour λ = 2πρ : ´ Echantillonnages, interpolacela donne la figure 4.12 ; on constate que tant que a < 4.4 0.5ρ, l’erreur reste inf´erieure ` a 0.01, (pour L ∼ 1.5) ce tion. qu’on n’aurait probablement pas devin´e sinon. 7 prendre par exemple ρ = 1 et n = 1.5. On calculera en double On a vu, pour le probl`eme de l’int´egration, l’impor0 precision. tance du pas d’int´egration : c’est d´ej` a une premi`ere forme
54
Licence de physique L3 : Physique Fondamentale & PHYTEM,
d’´echantillonnage puisqu’une fonction d´efinie sur un morceau de l’axe r´eel se trouve r´eduite ` a un ensemble discret de points.
4.4.1
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
Interpolation lin´ eaire.
C’est la plus simple : si x est compris entre xℓ et xℓ+1 , on ´ecrit la fonction approch´ee pℓ (x),
De mˆeme, lorsqu’on demande ` a un logiciel comme gnuplot (ou `a une calculette graphique, d’ailleurs) de traf (xℓ+1 ) − f (xℓ ) (x − xℓ ) (4.4) pℓ (x) = f (xℓ ) + cer le graphe d’une fonction, sin x par exemple, il calxℓ+1 − xℓ cule les valeurs de la fonction en un certain nombre de points, reli´es ensuite par des lignes droites ; en g´en´eral, ce qui revient `a consid´erer la fonction comme localement les « options par d´efaut » permettent d’´eviter de pr´eciser lin´eaire. L’erreur est ´evidemment d’autant plus grande que comment on veut que ce choix de points soit fait, ce la courbure de la fonction est grande. qui donne une fausse impression d’´evidence au choix de l’´echantillonnage. 4.4.2 Approximation parabolique. 1 0.8 0.6 0.4 0.2 0 −0.2 −0.4 −0.6 −0.8 −1 −10
−5
0
5
10
Fig. 4.13 – Le graphe de la fonction sin(100x) trac´e sans pr´ecaution particuli`ere. Fig. 4.14 – Approximation lin´eaire et approximation paIl arrive toutefois, comme on peut le constater sur la rabolique autour du point situ´e en x=0.5. figure 4.13, que le r´esultat ne soit pas ` a la hauteur des Pour tenir compte de la courbure, on peut remplacer esp´erances ! Dans cet exemple, en effet, on a tent´e de tra2π cer une fonction p´eriodique de p´eriode 100 a l’aide d’un l’approximation lin´eaire par une parabole qui, cette fois ` ´echantillonnage de 100 points sur un intervalle de longueur doit passer par trois points. Ainsi : 20, soit un pas d’´echantillonnage de 0, 2 plus grand que la pℓ (x) = aℓ x2 + bℓ x + cℓ p´eriode de la fonction. . . ´echec assur´e, encore fallait-il le pr´evoir8. de fa¸con que : Ainsi, une fonction9 y = f (x) pour un ordinateur est toujours repr´esent´ee en fin de compte par un nombre pℓ (xℓ−1 ) = f (xℓ−1 ) fini de points, c’est-` a-dire par un nombre fini de couples pℓ (xℓ ) = f (xℓ ) (xi , yi ). Dans le cas du sinus, bien sˆ ur, on peut toujours pℓ (xℓ+1 ) = f (xℓ+1 ) calculer des points suppl´ementaires si l’aspect de la courbe n’est pas convenable. Cependant, ce n’est pas toujours possible, soit parce que le temps de calcul ` a investir se- On obtient ais´ement : rait trop long, soit parce qu’il s’agit de donn´ees obtenues (x − xℓ )(x − xℓ+1 ) pℓ (x) = f (xℓ−1 ) autrement, exp´erimentalement par exemple, et qu’il n’est (xℓ−1 − xℓ )(xℓ−1 − xℓ+1 ) pas question de refaire l’exp´erience avec, mettons, cent fois (x − xℓ+1 )(x − xℓ−1 ) plus de points. . . or il peut arriver que l’on ait besoin de + f (xℓ ) (xℓ − xℓ+1 )(xℓ − xℓ−1 ) connaˆıtre la valeur de la fonction entre deux points. (x − xℓ−1 )(x − xℓ ) On peut, bien souvent, s’en sortir quand mˆeme `a l’aide + f (xℓ+1 ) (x ℓ+1 − xℓ−1 )(xℓ+1 − xℓ ) d’approximations moyennant quelques hypoth`eses. 8 le
logiciel gnuplot permet de d´ efinir le nombre de points que l’on veut sur un intervalle : par exemple set samples 1000 indique que dor´ enavent l’intervalle sera d´ ecrit pas 1000 points (au lieu de 100, la valeur par d´ efaut). Cependant, tenter de r´ esoudre le probl` eme de cette fa¸con serait dans ce cas d´ ecevant parce qu’on obtiendra selon toute vraisemblance un ´ ecran tout noir. . . Il est vrai que vouloir tracer une courbe de p´ eriode 2π/100 ≃ 0,0628 sur un intervalle [−10, 10], c’est chercher la difficult´ e. 9 Au sens math´ ematique, bien sˆ ur, il ne s’agit pas de la function fortran.
ceci est valable dans l’intervalle [xℓ − h2 , xℓ + h2 ] o` u, bien sˆ ur, h est l’intervalle entre deux points successifs. A priori cette approximation est meilleure que la pr´ec´edente, permettant une bonne description de la fonction avec un nombre de points plus faible ; il y cependant une hypoth`ese importante derri`ere cela, c’est que la fonction ne se livre pas `a des excentricit´es entre deux points successifs, par exemple, qu’il n’y ait pas de point singulier ou de variations ´enormes entre deux points connus.
55
Physique num´erique, Philippe Depondt
4.4.3
Polynˆ omes de Lagrange.
Il est ais´e quoique rapidement fastidieux de g´en´eraliser la m´ethode ci-dessus ` a un polynˆ ome de degr´e n quelconque. On obtient un polynˆ ome passant par les n + 1 points (x0 , f (x0 )), . . ., (xℓ , f (xℓ )) . . ., (xn , f (xn )) : pn (x) = n X
f (xℓ )
ℓ=0
(x − x0 ) . . . (x − xℓ−1 )(x − xℓ+1 ) . . . (x − xn ) (xℓ − x0 ) . . . (xℓ − xℓ−1 )(xℓ − xℓ+1 ) . . . (xℓ − xn )
dans les produits du num´erateur et du d´enominateur de la fraction ci-dessus, manquent ´evidemment les termes x−xℓ et . . . xℓ − xℓ ! Le choix du degr´e le plus appropri´e pour le polynˆome n’est pas facile. Une bonne r`egle est de ne pas essayer de trop bien faire ! En effet le choix d’un degr´e trop ´elev´e, bien loin d’am´eliorer l’interpolation, risque de produire des oscillations compl´etement erratiques de l’interpolation entre les points connus. Il est bien rare qu’un degr´e sup´erieur a 3 se justifie vraiment, c’est en g´en´eral le signe que l’on ` commence `a manquer de donn´ees de r´ef´erences : peut-ˆetre est-il temps alors d’envisager de faire quelques points de mesure exp´erimentaux suppl´ementaires. . . L’informatique, contrairement `a la magie, ne peut pas tout faire, en particulier inventer des donn´ees num´eriques manquantes !
4.4.4
D´ eriv´ ees.
Fig. 4.15 – Deriv´ee d’un sinus affect´e d’un l´eger bruit. La d´eriv´ee, elle, est affect´ee d’un fort bruit, mˆeme si l’allure g´en´erale est convenable.
4.5 4.5.1
Alg` ebre lin´ eaire. Un exemple : la diffusion de la chaleur ` a une dimension.
La loi de Fourier de diffusion de la chaleur dit simplement que le flux de chaleur en un point est proportionnel au gradient de temp´erature : ~ r ) = −κ(~r) grad ~ T (~r) φ(~
Les mˆemes m´ethodes permettent en principe une ´evaluation des d´eriv´ees successives d’une fonction puisqu’` a partir de l’expression d’un polynˆ ome de Lagrange de degr´e n on peut facilement obtenir des expressions pour les d´eriv´ees jusqu’` a la d´eriv´ee n-i`eme. Par exemple, une expression de la d´eriv´ee premi`ere peut ˆetre obtenue `a partir de l’approximation lin´eaire, ´eq. (4.4) : p′ℓ =
f (xℓ+1 ) − f (xℓ ) xℓ+1 − xℓ
o` u κ(~r) est la conductivit´e thermique qui d´epend de la nature du milieu. Si celui-ci est homog`ene, κ est une constante, sinon κ d´epend de la position ~r. Si l’on produit de la chaleur en un point ~r donn´e (par effet Joule ou par un apport quelconque, ou encore au contraire par une perte dans l’atmosph`ere), cette chaleur doit diffuser et cette chaleur diffus´ee par unit´e de temps ˙ r ) de chaleur produite par doit ˆetre ´egale `a la quantit´e Q(~ unit´e de temps, ce qui donne :
~ r ) = Q(~ ˙ r) div φ(~ En fait, il s’agirait plutˆ ot d’un calcul de la d´eriv´ee en xℓ+1 +xℓ , au milieu de l’intervalle, et non en xℓ . Si l’on En combinant ces deux ´equations, on obtient facilement : 2 pr´ef`ere une expression plus sym´etrique qui donne une ~ κ(~r) · grad ~ T (~r) + κ(~r) ∆T (~r) = −Q(~ ˙ r) grad (4.5) autre estimation plus pr´ecis´ement en xℓ : p′ℓ =
f (xℓ+1 ) − f (xℓ−1 ) xℓ+1 − xℓ−1
Cette ´equation, alli´ee `a d’´eventuelles conditions aux limites, permet, en principe, de calculer la distribution de temp´erature en r´egime stationnaire dans un objet, ˙ r ) et κ(~r). Autant dire que ce n’est pas connaissant Q(~ toujours facile : que faudrait-il faire pour une r´esolution num´erique ? Pour simplifier, on se restreindra ici `a une dimension, mais le probl`eme n’est pas tr`es diff´erent `a trois dimensions, du moins dans des g´eom´etries simples. L’´equation (4.5) se r´eduit alors `a :
On montre d’ailleurs ais´ement que cette derni`ere expression vient de la d´erivation de l’approximation parabolique. Il faut cependant ˆetre assez prudent. Outre la remarque ci-dessus concernant la limite pratique sur le degr´e du polynˆome utilis´e, il faut ˆetre conscient qu’un calcul de d´eriv´ee va tendre `a amplifier le bruit (figure 4.15). En effet, des fluctuations locales, de point ` a point, de la fonction peuvent donner des valeurs num´eriques importantes pour, dκ dT d2 T mettons, la d´eriv´ee premi`ere, et ces valeurs risquent de ˙ + κ 2 = −Q(x) dx dx dx changer brutalement d’un point ` a un autre. En pratique, Le premi`ere ´etape est de discr´etiser le probl`eme : on on se limite donc `a des d´eriv´ees d’ordre faible, un voire deux, sur des donn´ees de tr`es bonne qualit´e intrins`eque. pose, On verra dans le chapitre 4.8 d’autres m´ethodes plus sˆ ures x = i δx en pr´esence de bruit.
56
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
o` u i est un entier et δx un pas d’int´egration, similaire `a ce d’invoquer la biblioth`eque lors de la compilation : c’est en qui a d´ej` a ´et´e vu dans le chapitre 4.3.2. On note alors : g´en´eral une option de compilation11 : le compilateur ira puiser dans la biblioth`eque ce dont il a besoin. . . T (x) = T (i δx ) = Ti Il n’y a donc aucune raison de r´einventer la roue ! C’est en fait une d´emarche tr`es courante en calcul scientifique : dT on se pose un probl`eme de physique, puis on se demande La d´eriv´ee peut ˆetre approch´ee par : dx comment le traduire de fa¸con `a le traiter avec un programme de biblioth`eque d´ej` a existant. dT Ti+1 − Ti ∼ Dans le cas pr´ e sent, un syst` eme d’´equations lin´eaires se dx δx pr´esente de la fa¸con suivante : ou bien a11 x1 + a12 x2 + a13 x3 + · · · + a1n xn = b1 dT Ti − Ti−1 ∼ a = b2 21 x1 + a22 x2 + a23 x3 + · · · + a2n xn dx δx a31 x1 + a32 x2 + a33 x3 + · · · + a3n xn = b3 ou encore : a41 x1 + a42 x2 + a43 x3 + · · · + a4n xn = b4 dT Ti+1 − Ti−1 ∼ ··· dx 2δx an1 x1 + an2 x2 + an3 x3 + · · · + ann xn = bn On pr´ef`erera la troisi`eme forme plus sym´etrique. La o` u l’on cherche les xi . Le probl`eme peut se reformuler en d´eriv´ee seconde, la d´eriv´ee de la d´eriv´ee, s’´ecrit : termes matriciels : Ti+1 − Ti Ti − Ti−1 A·x=b − Ti+1 − 2Ti + Ti−1 d2 T δx δx avec ∼ = dx2 δx δx2 a11 a12 a13 · · · a1n a21 a22 a23 · · · a2n Cela donne donc, avec des notations ´evidentes : a31 a32 a33 · · · a3n A= a41 a42 a43 · · · a4n Ti+1 − 2Ti + Ti−1 dκ Ti+1 − Ti−1 + κi = −Q˙ i (4.6) ··· 2 dx i 2δx δx an1 an2 an3 · · · ann Si L est la longueur du barreau, alors n = δLx est le nombre et x1 b1 de segments sur le barreau : c’est a priori un nombre qui x2 b2 peut ˆetre grand, quelques centaines, milliers, voire plus ; x3 b3 or, l’´equation (4.6) se re´ecrit ais´ement : x= b= x4 b4 ··· ··· κi κi 1 dκ Ti+1 − 2 2 Ti + + xn bn 2δx dx i δx2 δx Pour ce qui est de la matrice A, il faut savoir que fortran stocke les matrices multicolonnes colonne par κi 1 dκ Ti−1 = −Q˙ i + − colonne : une colonne, puis une autre, puis une autre. 2δx dx i δx2 En m´emoire, se succ`edent ainsi : a11 , a21 , a31 , · · · an1 ou bien (premi`ere colonne), a12 , a22 ,. . .(deuxi`eme colonne),. . . etc., c’est-`a-dire que le premier indice « va le plus vite » (en ai,i+1 Ti+1 + ai,i Ti + ai,i−1 Ti−1 = bi ∀i C, c’est l’inverse). Si l’on veut ´ecrire des programmes efficaces, il faut tenter de privil´egier les appels `a des ´el´ements o` u les ai,j sont connus et o` u l’on cherche ` a calculer les successifs en m´emoire12 , et donc dans les boucles imTi . On vient de reformuler le probl`eme comme un syst`eme briqu´ees, mettre autant que possible, le premier indice lin´eaire de n ´equations ` a n inconnues (les Ti ) : si on peut dans la boucle la plus interne. Par exemple : trouver des m´ethodes pour r´esoudre de tr`es gros syst`emes do j = 1, n ! boucles dans le bon ordre d’´equations lin´eaires, alors le probl`eme ci-dessus peut ˆetre a(1:n,j) = ... consid´er´e comme r´esolu. enddo
4.5.2
Syst` emes d’´ equations lin´ eaires.
Au del` a de n = 2 ou 3, il ne faut surtout pas tenter de r´esoudre le syst`eme lin´eaire en proc´edant par ´elimination comme on le fait d’habitude pour une r´esolution ` a la main : les probl`emes de stabilit´e num´erique deviennent tr`es vite cruciaux. Il vaut bien mieux utiliser des sous-programmes de biblioth`eque : ce sont des programmes d´ej` a ´ecrits, souvent depuis longtemps, ´eprouv´es, dont les qualit´es et les d´efauts sont connus, compil´es et rassembl´es dans des biblioth`eques. Il suffit d’appeller le sous-programme choisi par un call dans le programme que l’on a ´ecrit comme n’importe quel autre sous-programme, en suivant toutefois les indications fournies dans la documentation10 puis 10 Souvent
en ligne.
et non l’inverse : do i = 1, n ! boucles dans le mauvais ordre a(i,1:n) = ... enddo
Pour r´esoudre le syst`eme d’´equations, on pourrait imaginer qu’il suffise de calculer l’inverse de la matrice A et faire le produit : x = A−1 · b mais il se trouve que les algorithmes de r´esolution directe du syst`eme d’´equations sont plus efficaces. 11 g´ en´ eralement,
l’option -l (pour library=biblioth` eque), par exemple avec la biblioth` eque linpack : g95 machin.f90 -llinpack -o machin. 12 Parce que le compilateur g` ere mieux les transferts entre m´emoire et processeur de paquets de nombres connexes que des nombres pris dans n’importe quel ordre.
57
Physique num´erique, Philippe Depondt
n(n + 1) ´el´ements a 2 2 C’est le v´eritable cheval de bataille de tous ces priori non nuls, ainsi que U, soit n + n inconnues, et donc probl`emes (voir r´ef. [3] pour une discussion plus appro- n de trop. On fixe alors : fondies des qualit´es et d´efauts des diff´erentes m´ethodes, par exemple Gauss-Jordan). lii = 1, ∀i Imaginons que l’on ait d´ecompos´e la matrice A en un Pour i ≤ j, on obtient ais´ement : produit de deux matrices : 4.5.2.1
La m´ ethode LU
A= L·U o` u L est une matrice triangulaire inf´erieure (L = lower ) qui n’a des ´el´ements que sur et sous la diagonale : l11 0 0 0 l21 l22 0 0 L= l31 l32 l33 0 l41 l42 l43 l44
dans le cas o` u n = 4, et U est une matrice triangulaire sup´erieure (U = upper ) qui n’a des ´el´ements que sur et au dessus de la diagonale : u11 u12 u13 u14 0 u22 u23 u24 U= 0 0 u33 u34 0 0 0 u44 Le syst`eme initial se re´ecrit :
L · (U · x) = b il reste `a chercher y tel que : L·y =b puis x tel que : U·x =y
Il y a n2 ´equations, or L comporte
uij = aij −
i−1 X
lik ukj
(4.8)
k=1
Enfin, pour i > j : 1 lij = ujj
aij −
j−1 X
k=1
lik ukj
!
(4.9)
Tous les termes dans les sommes des ´equations (4.8) et (4.9) sont d´ej` a calcul´es `a condition d’appliquer les deux ´equations par i croissants pour un j donn´e, puis changer de j. Il ne s’agit finalement que d’un r´eordonancement tr`es simple du probl`eme. En g´en´eral, les programmes qui appliquent cet algorithmes d´etruisent le contenu de la matrice A en rangeant les ´el´ements de L dans la partie inf´erieure de A, et les ´el´ements de U dans la partie sup´erieure, sachant que les lii ne sont pas conserv´es, puisqu’ils valent 1. En outre, afin de limiter les d´egˆats lors des divisions par ujj dans l’´equation (4.9), un certain r´earrangement des lignes et colonnes du syst`eme d’´equations doit ˆetre fait pour commencer par les ´el´ements pour lesquels ujj est grand (une division par un nombre tr`es petit donne parfois des r´esultats impr´evisibles). Les programmes de biblioth`eque font cela et souvent fournissent en prime des diagnostics lorsque A est singuli`ere, ou trop proche d’une matrice singuli`ere.
L’avantage de proc´eder ainsi est que maintenant le syst`eme elioration it´ erative de la pr´ ecision. est trivial `a cause de la forme triangulaire des deux ma- 4.5.2.2 Am´ trices : Il faut n´eanmoins faire un peu attention `a la pr´ecision du 1 1 b1 et dans les r´esultat obtenu, car les termes du type y1 = lii uii l11 ´equations (4.7) et (4.9) peuvent donner lieu `a des surprises 1 si les diviseurs sont petits. Il y a plusieurs fa¸cons de s’en [b2 − l21 y1 ] y2 = l22 sortir. La premi`ere consiste `a utiliser un sous-programme 1 de biblioth`eque capable de d´etecter ce genre de probl`eme : y3 = [b3 − (l31 y1 + l32 y2 )] l33 pratiquement toutes les biblioth`eques en proposent. Un ··· (4.7) autre test possible est de comparer les r´esultats obtenus en simple et en double pr´ecision. puis, en proc´edant de mˆeme ` a l’envers : Une cure possible est de partir d’une solution approch´ee ′ x , et donc fausse, obtenue par, mettons, la m´ethode LU yn xn = et de chercher `a l’am´eliorer. unn Soit : ··· A · x′ = b + δb Reste `a faire la d´ecomposition proprement dite. u δb est l’erreur qu’il faut r´eduire ; or : Il s’agit d’un algorithme typique de ceux dont sont o` friands les amateurs. Nous le d´etaillons ici pour le plaix′ = x + δx, et A · x = b sir de ce genre de tourisme13 ! Cela s’appelle l’algorithme de Crout. donc : Le probl`eme est de trouver lij et uij tels que : A · δx = δb = A · x′ − b min(i,j)
X
lik ukj = aij
k=1 13 Et
surtout pas pour l’apprendre par cœur. . .
qui est un syst`eme que l’on peut r´esoudre pour obtenir δx. On peut alors corriger x′ et recommencer jusqu’` a obtenir la pr´ecision voulue, `a condition ´evidemment que l’algorithme converge. . .
58
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
ot Il faut savoir cependant que les biblioth`eques pro- nuls. On ´ecrit plutˆ posent g´en´eralement un tr`es grand nombre de sous d1 f1 0 0 0 ··· 0 programmes pr´evus pour des cas tr`es divers : il est 0 ··· 0 e2 d2 f2 0 donc conseill´e de choisir le programme adapt´e. Toutefois, 0 e3 d3 f3 0 ··· 0 pour la plupart des probl`emes « standards » du physi ··· ··· ··· ··· ··· · · · · ·· A= cien, la m´ethode LU est tr`es satisfaisante, mais pour les ··· 0 ei di fi 0 ··· probl`emes exigeant d’´enormes matrices creuses tels que les ··· ··· ··· ··· ··· ··· ··· m´ethodes d’´el´ements finis (pour la r´esolution de probl`emes 0 0 · · · 0 en−1 dn−1 fn−1 de m´ecanique des fluides par exemple), des m´ethodes 0 0 ··· 0 0 en dn sp´ecialement pr´evues ` a cet effet doivent ˆetre utilis´ees. qui ne n´ecessite que trois tableaux de n ´el´ements, d pour la diagonale, e pour la sous-diagonale et f pour la surdiagonale. Noter que e1 et fn ne sont pas d´efinis. 4.5.2.3 Matrice inverse. Les ´equations (4.8) et (4.9) se r´eduisent `a : Une fois la d´ecomposition achev´ee, il est facile de remi = j − 1 uj−1j = ej placer b par : i=j ujj = dj − ljj−1 uj−1j 1 fj 0 i = j + 1 lj+1j = 0 ujj .. . Les ´equations ci-dessus ne constituent pas en elles-mˆeme 0
l’int´erˆet principal de ce paragraphe : le but est ici d’attirer l’attention sur le fait que pour un type de matrice, ce qui donne la premi`ere colonne de A−1 dans x, puis on la m´ethode de r´esolution que l’on choisira n’est pas touproc`ede colonne par colonne en posant : jours la mˆeme que pour un autre type de matrice. Les biblioth`eques sont parfois fort riches et il est de bon 0 ton de chercher un peu dans la documentation quel peut .. ˆ etre le sous-programme le plus adapt´e au cas particu . lier envisag´e. Il existe des solutions pour des matrices b= 1 « bande-diagonales » ou des solutions it´eratives par ap . .. proximations successives pour des probl`emes difficiles, des d´ecompositions en valeurs singuli`eres quand le probl`eme 0 se pose. . ., les ressources sont abondantes, parfois un peu en pla¸cant le nombre 1 sur la i-`eme ligne de b pour obtenir trop, mˆeme ! la i-`eme colonne de A−1 .
4.5.3 4.5.2.4
D´ eterminant d’une matrice.
Une g´ en´ eralisation de la m´ ethode de Newton ` a plusieurs dimensions.
Au chapitre 4.1.2, on a mentionn´e le fait que la m´ethode de Newton de recherche de z´ero pouvait se g´en´eraliser `a plusieurs dimensions. Cela peut ˆetre utile, si par exemple, n Y au lieu d’un seul pendule comme dans l’exemple, on en ujj det A = avait plusieurs coupl´es entre eux et non plus astreints `a se j=1 d´eplacer dans un plan : on aurait alors deux angles polaires par pendule `a trouver et donc un syst`eme de 2N variables `a rechercher. 4.5.2.5 Matrice tridiagonale. C’est le moment de s’y attaquer. Soit donc n fonctions de n variables Si l’on ´etudie l’´equation (4.6), on s’aper¸coit vite que seuls les termes en i − 1, i et i + 1 sont non nuls. La fj (x1 , . . . , xi , . . . , xn ), ∀j ∈ [1, n] matrice A ne comporte alors que des termes diagonaux, sous-diagonaux et sur-diagonaux : elle est donc tridiago- dont on suppose qu’elles poss`edent un z´ero et qu’elles sont nale : raisonnablement « civilis´ees »14 : ces fonctions ne sont C’est encore plus simple :
A=
a11 a21 0 ··· ··· ··· 0 0
a12 a22 a32 ··· 0 ··· 0 0
0 a23 a33 ··· aii−1 ··· ··· ···
0 0 a34 ··· aii ··· 0 0
0 0 0 ··· aii+1 ···
an−1n−2 0
··· ··· ··· ··· 0 ···
an−1n−1 ann−1
0 0 0 ··· ··· ···
an−1n ann
Dans ce cas, il n’est nul besoin de stocker toute la matrice A avec ses n2 ´el´ements puisque, pour la plupart, ils sont
toutefois ´evidemment pas lin´eaires. On d´emarre la recherche comme avant `a partir d’un point de d´epart : (0)
(0)
x1 , . . . , xi , . . . , x(0) n on lin´earise alors les fonctions localement : fj (x1 , . . . , xi , . . . , xn ) 14 Le terme civilis´ e pour une fonction signifie en gros que l’algorithme que l’on va utiliser marche. . .
59
Physique num´erique, Philippe Depondt
= (0) (0) fj (x1 , . . . , xi , . . . , x(0) n )+
∂fj ∂fj ∂fj dx1 + . . . + dxi + . . . + dxn ∂x1 ∂xi ∂xn
ce qui donne : 2 ω a1
ω 2 a2
=
C g a1 + (a1 − a2 ) ℓ1 m1 ℓ 1 g C a2 + (a2 − a1 ) ℓ2 m2 ℓ 2
= On cherche le point {xi } tel que o` u dxi = xi − fj (x1 , . . . , xi , . . . , xn ) = 0, ∀j, donc les ´equations ci- et : dessus se re´ecrivent : g C C 2 + − ω a1 − a2 = 0 ∂fj ∂fj ∂fj ℓ1 m1 ℓ 1 m1 ℓ 1 dx1 + . . . + dxi + . . . + dxn ∂x1 ∂xi ∂xn C g C − a1 + + − ω 2 a2 = 0 = m2 ℓ 2 ℓ2 m2 ℓ 2 (0) (0) −fj (x1 , . . . , xi , . . . , x(0) n ) ce qui se r´esout ais´ement en ´ecrivant que le d´eterminant C’est un syst`eme d’´equations lin´eaires dont les inconnues du syst`eme est nul, etc.15 sont les {dxi } : Cependant, on peut re´ecrire le probl`eme matricielleJ · dx(1) = −f (0) ment : D · a = ω2a avec des notations sans surprise. La matrice J des d´eriv´ees ∂fj , s’appelle la matrice jacobienne. partielles, Jij = avec ´evidemment : ∂xi On r´esout donc le syst`eme, ce qui permet de calculer les g C C (1) − + a convergence, comme {xi } puis on recommence jusqu’` ℓ1 m1 ℓ 1 m1 ℓ 1 a1 , a = D= dans le cas `a une dimension. a2 C g C + − m2 ℓ 2 ℓ2 m2 ℓ 2 (0) xi .
4.5.4
Probl` emes de vecteurs propres et de La matrice D s’appelle la matrice dynamique du syst`eme valeurs propres ou eigenproblems.
Il s’agit de r´esoudre l’´equation : A · x = λx o` u connaissant A, on en cherche les valeurs propres λ et les vecteurs propres x. 4.5.4.1
Un exemple : les modes propres d’un ensemble d’oscillateurs harmoniques coupl´ es.
Prenons un cas tr`es simple : deux pendules simples coupl´es par un fil de torsion. L’´energie potentielle du syst`eme s’´ecrit : 1 V = −m1 g cos θ1 − m2 g cos θ2 + C(θ1 − θ2 )2 2 avec des notations ´evidentes. Les ´equations du mouvement s’en d´eduisent sans difficult´e : g C θ¨1 = − ℓ sin θ1 − m ℓ (θ1 − θ2 ) 1 1 1 g C θ¨2 = − sin θ2 − (θ2 − θ1 ) ℓ2 m2 ℓ 2
et l’on s’aper¸coit donc que ω 2 est une valeur propre de la matrice dynamique et que a en est un vecteur propre. Pour un syst`eme 2 × 2 comme celui-ci, l’int´erˆet d’une telle remarque n’est pas ´evident, mais pour un syst`eme 100 × 100 ? Par exemple, une mol´ecule qui comporte ne seraitce que quelques dizaines d’atomes. . . il suffit alors d’´ecrire la matrice dynamique du syst`eme, une matrice n × n o` u n est le nombre de degr´es de libert´e du syst`eme, et d’en chercher valeurs et vecteurs propres. Il se trouve qu’il y a des algorithmes tr`es efficaces pour calculer num´eriquement les valeurs propres et les vecteurs propres de tr`es grosses matrices. Ici encore, la fa¸con de proc´eder d´epend du type de matrice que l’on veut ´etudier, et ici encore, il faut faire appel `a des programmes de biblioth`eque. 4.5.4.2
Matrices tridiagonales sym´ etriques : la m´ ethode QL.
La matrice dynamique du paragraphe 4.5.4.1 peut ˆetre √ sym´etris´ee √ en rempla¸cant a1 par α1 = m1 ℓ1 a1 et a2 par α2 = m1 ℓ2 a2 . De plus, si le nombre de pendules est plus grand que deux, si les pendules sont align´es et chaque pendule n’interagit qu’avec ses deux voisins les plus Puisque l’on s’int´eresse ici ` a un probl`eme lin´eaire, on peut proches, la matrice D est tridiagonale sym´etrique. Il se se restreindre `a des oscillations de petite amplitude, et trouve que beaucoup de probl`emes peuvent ˆetre ramen´es au calcul des valeurs propres d’une matrice tridiagonale avec l’approximation habituelle, on obtient : sym´etrique qui est justement le cas le plus simple. C g La plupart des programmes de biblioth`eque utilise la ¨ θ1 = − ℓ θ1 − m ℓ (θ1 − θ2 ) m´ethode QL qui consiste `a faire une s´erie de transforma1 1 1 tions orthogonales : C g θ¨2 = − θ2 − (θ2 − θ1 ) ℓ2 m2 ℓ 2 15 C’est d’ailleurs un exercice conseill´ e : le d´ eterminant donne une un syst`eme pour lequel on cherche des solutions stationnaires p´eriodiques du type : θ1 = a1 eiωt ,
θ2 = a2 eiωt
´ equation bicarr´ ee en ω, on trouve donc deux solutions positives et donc deux fr´ equences propres ; a ` chaque fr´ equence propre correspond un couple (a1 , a2 ) d’amplitudes pour les deux pendules, c’est-` a-dire un mode propre. Le mouvement des pendules est une combinaison lin´ eaire de ces deux modes.
60
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
l’´equation stationnaire et l’on tentera une r´esolution en d´eveloppant la fonction d’onde ψ sur une base de fonctions connues : c’est, a priori, une approximation car rien o` u Ls est une matrice triangulaire inf´erieure et Qs une ne dit que la « vraie » solution puisse ˆetre correctement matrice orthogonale, c’est-` a-dire que : d´evelopp´ee sur la base choisie, surtout si celle-ci est r´eduite −1 t `a un nombre fini, voire un petit nombre, de fonctions. Qs = Qs La consultation d’un cours de physique quantique montre que l’on peut poser le probl`eme de la fa¸con suiUne s´erie de th´eor`emes, que nous n’´etudierons pas ici, vante : montrent que l’on peut d´ecomposer Ls de la fa¸con suiR ∗ ψ (X)H(X)ψ(X)dX vante R (4.11) E = t ψ ∗ (X)ψ(X)dX Ls = Qs · As As+1 = Ls · Qs
u H est le Hamiltonien (connu) du syst`eme consid´er´e, ´ecrire Qs comme un produit de rotations planes et que la o` X d´esigne l’ensemble des variables du probl`eme, ψ(X) s´equence la fonction d’onde que l’on cherche et E l’´energie (que As+1 = Qts · As · Qs l’on cherche ´egalement). Pour simplifier les notations, il fera apparaˆıtre les valeurs propres sur la diagonale. est d’usage d’´ecrire la mˆeme ´equation comme suit : Pour l’utilisateur, il suffit de fournir deux tableaux unidimensionnels contenant la diagonale et la sous-diagonale < ψ|H|ψ > E= de la matrice initiale A ou A0 . Au retour, on obtient les va< ψ|ψ > leurs propres `a la place de la diagonale en g´en´eral class´ees par ordre de valeur d´ecroissante. Si l’on veut aussi les vec- L’´energie E d´epend ´evidemment de la fonction d’onde et teurs propres, il faut ´egalement fournir un tableau n × n l’on montre que si l’on modifie l´eg`erement ψ, E doit ˆetre et. . . bien lire la documentation pour d´eterminer si un vec- minimum par rapport `a ce changement, si toutefois E et teur propre donn´e occupe une ligne ou une colonne de la ψ sont solutions du probl`eme. On d´eveloppe alors la fonction d’onde sur une base de dite matrice ! En g´en´eral, les vecteurs propres obtenus sont fonctions connues χℓ : normalis´es `a 1, soit, pour un vecteur propre ai donn´e : X X a2i,ℓ = 1 ψ= c ℓ χℓ ℓ
o` u ai,ℓ est la ℓ-i`eme composante du vecteur propre ai .
ℓ
en esp´erant que la base choisie « marchera ». Le principe variationnel ci-dessus dit que le meilleur jeu de coefficients cℓ est celui pour lequel E est minimum, donc pour un δck 4.5.4.3 Rendre une matrice tridiagonale. quelconque, le δE doit ˆetre nul au premier ordre. Avec ces Quand la matrice n’a pas la forme requise, il faut la notations, l’´equation (4.11) s’´ecrit : transformer d’abord, par exemple, lorsque les pendules X coupl´es de notre exemple « voient » leurs seconds voisins, c∗ℓ cm Hℓm ou bien lorsque l’objet ´etudi´e est une mol´ecule en vibra(4.12) E = ℓmX tion dont les atomes sont coupl´es les uns aux autres en c∗ℓ cℓ trois dimensions. ℓ La m´ethode tourne toujours autour du mˆeme genre d’op´erations : on fait une s´equence du type : o` u Hℓm =< χℓ |H|χm > As+1 = Rts · As · Rs `a condition toutefois que la base de fonctions soit orthoo` u Rs est une rotation plane judicieusement choisie et l` a norm´ee, soit : encore une batterie de th´eor`emes appropri´es montre que < χℓ |χm >= δℓm l’on doit converger vers une matrice tridiagonale. Si l’on impose une variation δck au coefficient ck dans l’´equation (4.12), on obtient alors : 4.5.4.4 Probl` emes aux valeurs propres g´ en´ eralis´ es. δE = ! X X X Ce sont des probl`emes du type : δc∗k cm Hkm + c∗ℓ δck Hℓk c∗ℓ cℓ m ℓ ℓ X A · x = λB · x (4.10) − c∗ℓ cm Hℓm (δc∗k ck + c∗k δck ) ℓm o` u l’on cherche les valeurs propres λ et les vecteurs propres x, A et B ´etant des matrices connues : voyons un exemple. or δE doit ˆetre nul ∀k, ∀δck , ce qui donne, apr`es avoir r´e-inject´e l’´equation (4.11) dans l’expression ci-dessus : 4.5.4.4.1 L’´ equation de Schr¨ odinger. La r´esoluX tion num´erique de l’´equation de Schr¨odinger est un cm Hkm = E ck ∀k probl`eme particuli`erement difficile et, outre qu’un tome m entier ne suffirait pas ` a le traiter compl`etement (voir, par exemple, la r´ef´erence [12]), c’est un domaine o` u autrement dit la recherche est active ! Ici, nous nous contenterons de H·c =Ec
61
Physique num´erique, Philippe Depondt
avec des notations sans surprise. On reconnait l` a une ´equation aux valeurs propres : la r´esoudre donne `a la fois les ´energies propres et les coefficients correspondants du d´eveloppement de la fonction d’onde. Pour des raisons diverses, il peut arriver cependant que la base de fonctions utilis´ee ne soit pas orthonorm´ee : par exemple, si l’on cherche des fonctions d’onde ´electroniques dans le champ d’un ensemble de noyaux, on peut vouloir utiliser des fonctions d’onde localis´ees sur les noyaux atomiques avec un certain recouvrement. Les produits scalaires : < χℓ |χm >= sℓm
4.6
Probl` emes autocoh´ erents.
ou self-consistent problems en anglais.
4.6.1
Qu’est-ce donc ?
Imaginons, par exemple, un di´electrique constitu´e d’un ensemble d’atomes polarisables qui, lorsqu’ils sont soumis `a un champ ´electrique, voient leur nuage ´electronique d´eform´e. Ils portent alors un moment dipolaire dont on supposera ici selon l’approximation d’usage qu’il est proportionnel au champ :
~ ri ) deviennent alors les ´el´ements d’une matrice S qui n’est p~i = α E(~ plus la matrice unit´e. Le probl`eme se reformule l´eg`erement u p~i est le moment dipolaire port´e par l’atome i et ~ri est pour donner apr`es le mˆeme genre de calcul, le r´esultat o` la position de celui-ci. suivant : ~ ext Chaque atome est donc soumis au champ ext´erieur E H·c =ES·c que l’on applique et au champ dˆ u `a tous les autres dipˆoles : un probl`eme aux valeurs propres g´en´eralis´e similaire a` X (4.10). ~ ri ) = E ~ ext + ~ dipj (~ri ) E(~ E j, j6=i
4.5.4.4.2 R´ esolution. La m´ethode est en g´en´eral tr`es ~ dipj (~ri ) est le champ produit en ~ri par le dipˆole port´e simple : il suffit de remplacer (4.10) par : o` uE par l’atome j. Donc : B−1 · A · x = λ x X −1 La matrice B · A n’est g´en´eralement pas sym´etrique ~ ext + ~ dipj (~ri ) ~pi = α E E (4.13) mˆeme si A et B le sont. Les sous-programmes de bij, j6=i blioth`eque font alors une d´ecomposition de B en ainsi, pour calculer les valeurs des moments dipolaires p~i , B = L · Lt il faut connaˆıtre les champs dipolaires mais pour obtenir les champs dipolaires, il faut connaˆıtre les moments dipoet le probl`eme se re-´ecrit : laires : on tourne en rond. ~ dipj (~ri ) par son On peut, certes, tenter de remplacer E t t C· L ·x =λ L ·x expression en fonction de ~pj et r´esoudre, par exemple, par la m´ethode de Newton le syst`eme d’´equations : avec : −1 −1 t C= L ·A· L ~pi − f~i ({~ pj , j ∈ [1, n]}) = 0 i ∈ [1, n] La matrice C a les mˆemes valeurs propres que le probl`eme initial et ses vecteurs propres sont Lt · x. En principe, cela suppose cependant de calculer toutes les d´eriv´ees toutes ces transformations sont transparentes pour l’utili∂ f~i sateur. ∂~pj 4.5.4.5
Conclusion
une entreprise parfois un peu laborieuse, surtout si n est grand. [0] On peut toutefois partir d’une solution d’essai ~pi , calculer les champs dipolaires correspondants, puis, `a l’aide [1] de l’´equation (4.13), de nouvelles valeurs ~pi , puis de nou[2] veaux champs et p~i et ainsi de suite. La solution sera obtenue quand on aura atteint un « point fixe » tel que :
Tous ces algorithmes sont efficaces et rapides : il ne faut surtout pas se priver de les utiliser quand le probl`eme s’y prˆete, mˆeme si l’on ne maˆıtrise pas absolument leur fonctionnement, car ils sont dans l’ensemble assez robustes16 . En revanche, les biblioth`eques de programmes sont souvent extrˆemement riches et l’on a parfois du mal a d´eterminer quel est le sous-programme qui r´epondra le ` [k] [k+1] mieux `a la question pos´ee : il faut prendre le temps de ≃ p~i ~pi r´efl´echir, de lire la documentation disponible, h´elas pas toujours limpide, voire se poser la question si une refor- avec une pr´ecision suffisante. mulation du probl`eme de fa¸con l´eg`erement diff´erente ne permettrait pas, par exemple, de sym´etriser la matrice 4.6.2 Formulation g´ en´ erale. ´etudi´ee ou si une ´ecriture avec des termes complexes ne pourrait pas simplifier consid´erablement la vie de celui qui On cherche donc la solution du syst`eme d’´equations : ´ecrit le programme ! xi = fi (x1 , x2 , . . . , xn ), i ∈ [1, n] 16 ce qui ne dispense pas bien sˆ ur de v´ erifier sur des probl` emes dont la solution est connue que les programmes marchent convenablement, et, comme d’habitude, ne pas oublier d’user de l’esprit critique du physicien. . .
ou x = f (x)
62
Licence de physique L3 : Physique Fondamentale & PHYTEM,
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
o` u les lettres en caract`eres gras repr´esentent des vecteurs de notre fonction tend vers 1 lorsque x tend vers z´ero : de n ´el´ements. On part d’une solution d’essai x[0] et l’on on est `a la limite de la condition de convergence |a| < 1, construit la s´equence : ainsi, dans ce cas, plus on s’approche de la solution, plus la convergence devient difficile. On en concluera n´eanmoins x[k+1] = f (x[k] ) que le crit`ere ci-dessus, a priori valable pour une fonction lin´eaire, l’est ´egalement pour une fonction non-lin´eaire `a Le point fixe sera consid´er´e comme atteint quand les condition d’en connaˆıtre la d´eriv´ee au point fixe, ou du x[k] n’´evolueront plus de fa¸con significative a` chaque moins d’ˆetre capable d’estimer si elle est, en valeur absog´en´eration. lue, inf´erieure `a 117 . Ce genre de raisonnement est g´en´eralisable `a des 4.6.3 Est-ce que ¸ca converge ? syst`emes lin´eaires du type : Rien n’est moins sˆ ur ! Prenons un cas tr`es simple pour x = Ax + b lequel n = 1 et : f (x) = ax On obtient ´evidemment que : La solution est ´evidemment x = 0. Si l’on veut r´esoudre x[k] = Ak x[0] + I + A + A2 + . . . + Ak−1 b [0] ce probl`eme par la m´ethode ci-dessus, on part d’un x choisi arbitrairement et Pour que cela converge, on montre18 qu’il suffit que : x[1] = a x[0] ,
x[2] = a x[1] = a2 x[0]
||A|| < 1
et bien sˆ ur :
o` u ||A|| est l’une des normes de A :
x[k] = ak x[0] Si |a| < 1, la convergence est acquise, mais sinon c¸a diverge ! ´ Etudions maintenant le cas :
||A||m = max i
ou bien
f (x) = tanh x
l` a encore la solution x = 0 est connue. Le programme pour r´esoudre cel` a est d’une grande simplicit´e : ou encore program autoco implicit none real :: x=1. ! point de depart de la recherche integer :: k, kmax=100000 open(1,file=’autoco.res’) write(1,*) 0, x do k = 1, kmax x = tanh(x) if( mod(k, 10) == 0 ) write(1,*) k, x enddo close(1) end 1
x
0.1
0.01
0.001
10
100
1000 k
10000
100000
Fig. 4.16 – Convergence plus que m´ediocre de la recherche autocoh´erente de la solution de l’´equation x = tanh x (les ´echelles sont logarithmiques). Le r´esultat est malheureusement assez d´ecevant (figure 4.16) : apr`es 105 pas, on en est encore ` a quelques milli`emes de la solution ! On ´etait habitu´e ` a mieux. . . Si l’on essaie d’appliquer le crit`ere ci-dessus, on s’aper¸coit que la d´eriv´ee
||A||l = max j
n X j=1
n X i=1
|aij |
|aij |
v uX n u n X |aij |2 ||A||k = t i=1 j=1
En particulier, si l’on a : aij <
1 , n
∀ i, j ∈ [1, n]
la suite converge. Pour un syst`eme non-lin´eaire, la matrice A devient la matrice jacobienne J `a proximit´e du point fixe : cela suppose que l’on soit capable d’´evaluer cette matrice au point fixe qui est justement ce que l’on cherche ! Afin de temp´erer cette note apparemment pessimiste, l’on mentionnera -et le lecteur est chaleureusement invit´e `a le v´erifier- que le probl`eme du di´electrique converge de fa¸con tr`es satisfaisante en moins de 10 pas de calcul `a la suite d’un effort de programmation modeste. Ces m´ethodes peuvent ainsi se r´ev´eler extrˆemement pr´ecieuses dans bien des cas, mˆeme si l’´evaluation a priori de leurs chances de succ`es rel`eve parfois plus de l’astrologie que de la science. . .
4.7
Recherche des minima d’une fonction.
Il arrive bien souvent que l’on ait besoin, par exemple, du minimum de l’´energie potentielle d’un syst`eme qui 17 C’est un probl` eme similaire a ` celui que l’on avait recontr´ e a ` propos de l’´ equation logistique (§ 3.2.2, la recherche des points fixes est en fait une recherche de z´ eros) o` u l’on avait vu qu’un syst` eme nonlin´ eaire pouvait ˆ etre susceptible d’un comportement chaotique. . . 18 Voir par exemple la r´ ef´ erence [2], p. 322.
63
Physique num´erique, Philippe Depondt
d´epend d’une ou plusieurs variables pour en obtenir l’´equilibre stable : mettons, un ensemble d’atomes qui composent une mol´ecule dont on veut la conformation `a l’´equilibre compte tenu des potentiels d’interaction atomeatome. Un autre exemple, qui sera ´etudi´e plus en d´etail dans le chapitre 4.8, est celui de la recherche du minimum d’´ecart possible entre des donn´ees exp´erimentales et les pr´evisions d’un mod`ele th´eorique qui d´epend lui-mˆeme d’un certain nombre de param`etres : il faut donc chercher les valeurs de ces param`etres qui donne l’´ecart le plus faible possible. On pourrait aussi, dans un autre ordre d’id´ees, chercher le chemin optique le plus court pour un rayon lumineux, encore que la r´esolution d’une ´equation diff´erentielle ordinaire selon les m´ethodes du chapitre 4.9 paraisse plus facile dans un bon nombre de cas.
f (x) une fonction d’un ensemble de n variables d´esign´ees par x = (x1 , . . . , xn ). Un extremum est donn´e par : di (x) =
∂f =0 ∂xi
∀i
cela donne un syst`eme de n ´equations dont on cherche les z´eros, or la variation δdi (x) de di pour des variations δxi s’´ecrit : δdi (x) =
X ∂di X ∂2f δxj = δxj ∂xj ∂xi ∂xj j j
(4.14)
La matrice H telle que Hij =
∂2f ∂xi ∂xj
s’appelle la matrice Hessienne. C’est cette matrice qui
4.7.1
Du mouvement des amibes (m´ e- intervient dans le syst`eme lin´eaire (4.14) que l’on doit r´esoudre en δxi en suivant la m´ethode de Newton d´ej` a thode du simplex).
4.7.1.1
` une dimension A
On cherche donc le minimum d’une fonction f (x). On pourrait imaginer quelques chose qui s’apparente `a la m´ethode de la dichotomie : on choisit un intervalle, on prend le milieu, on regarde s’il est plus bas que les bords, etc. En fait, il suffit, dans un espace unidimensionnel, de prendre deux points : a et b. Mettons que f (a) < f (b), alors on cherchera un point c sym´etrique de b par rapport a a : on va dans le sens o` ` u c¸a d´ecroˆıt et cela s’appelle une r´eflexion. Si f (c) < f (a) c’est sans doute qu’on pouvait aller plus loin : on double alors le d´eplacement dans le mˆeme sens (dilatation) ; sinon, c’est qu’on est all´e trop loin, alors on divise le d´eplacement par deux (contraction). Puis on recommence l’op´eration jusqu’` a ce que l’intervalle entre les deux derniers points soit plus petit que la pr´ecision voulue. 4.7.1.2
` N dimensions. A
Le principe est le mˆeme : si l’on est dans un espace `a N dimension, on part de N + 1 points de l’espace : la figure obtenue s’appelle un simplex, par exemple, si N = 2, c’est un triangle. On remplace alors le point du simplex qui donne la valeur la plus ´elev´ee de la fonction par un autre obtenu en faisant une r´eflexion par rapport au centre de gravit´e du simplex, puis des dilatations ou des contractions a la demande. Ainsi, le simplex se d´eplace en se d´eformant, ` telle une amibe, en cherchant toujours ` a se concentrer sur point le plus bas. Quand il devient assez petit, le probl`eme est r´esolu. La m´ethode du simplex a le m´erite de ne n´ecessiter aucun calcul de d´eriv´ee et d’ˆetre simple ` a mettre en œuvre. Autant dire, cependant, qu’elle est assez inefficace : elle est a r´eserver aux probl`emes pas trop lourds num´eriquement ` pour lesquels on n’a pas de raison de faire d’effort particulier.
4.7.2
M´ ethode de Newton
vue : H · δx = −d avec des notations ´evidentes. Le vecteur d donne les variations qu’il faudrait imposer aux variables x (ou xi ∀i) pour annuler l’´ecart dans l’approximation lin´eaire. Comme la fonction f (x) n’est pas a priori lin´eaire, il faut recommencer l’op´eration jusqu’` a convergence. C’est souvent efficace et c’est extrˆemement simple `a mettre en œuvre (` a condition de pouvoir calculer les d´eriv´ees secondes qui composent la matrice hessienne), mais il faut ˆetre conscient qu’on ne se donne, alors, pas tous les moyens pour r´eussir. En effet, la m´ethode de Newton recherche les z´eros d’un ensemble de fonctions compl`etement ind´ependantes, alors que les d´eriv´ees d’une fonction ne le sont pas. En outre, la matrice Hessienne n’est pas toujours disponible ais´ement.
4.7.3
Recherche ` a une dimension : interpolation parabolique.
Admettons que l’on connaisse trois points x = a, b et c avec a < c < b d’une part, et f (c) < f (a) et f (c) < f (b) de l’autre. La deuxi`eme condition impose qu’il doit y avoir un minimum au moins dans l’intervalle [a, b]. On assimile alors localement la fonction `a une parabole passant par les trois points (figure 4.17) : f (x) ∼ p(x) = f (a) f (b)
(x − c)(x − b) + (a − c)(a − b)
(x − a)(x − c) (x − a)(x − b) + f (c) (b − a)(b − c) (c − a)(c − b)
dont on cherche le minimum :
p′ (x) = 0 soit : x=
1 f (a)(c2 − b2 ) + f (b)(a2 − c2 ) + f (c)(b2 − a2 ) 2 f (a)(c − b) + f (b)(a − c) + f (c)(b − a)
Il y a une m´ethode ´evidente : puisque l’on peut chercher les z´eros d’un ensemble de fonctions par la m´ethode puis on recommence avec une proc´edure similaire `a celle de de Newton, il suffit, lorsqu’on cherche les minima d’une la dichotomie : si x ∈]a, c[ on prend les points a, x et c, sifonction, de chercher les z´eros de ses d´eriv´ees. Soit donc non, on prend c, x et b et l’on calcule par la mˆeme m´ethode
64
Licence de physique L3 : Physique Fondamentale & PHYTEM,
f(b) f (x) ∼
Universit´e Pierre et Marie Curie Paris-6 & ENS-Cachan
X ∂f ∂2f 1X xj + xi + f0 xi 2 i,j ∂xi ∂xj ∂xi i
(4.16)
o` u l’on peut introduire la matrice Hessienne H et le gradient g de f tel que
f(a) f(c)
gi =
∂f ∂xi
L’´equation (4.16) se re´ecrit en notations matricielles : f (x) ∼
1 x · H · x + g · x + f0 2
(4.17)
et f ′ (x) ∼ H · x + g = r
a
c
x
b
Fig. 4.17 – Recherche de minimum parabolique ` a une dimension.
o` u r est le r´esidu qui devrait ˆetre nul si l’on ´etait au point x solution. C’est aussi le vecteur qui indique la direction de plus grande pente, direction de recherche. Mettons que l’on d´emarre la recherche d’un point x0 avec une direction de recherche r0 , l’on ´ecrira donc :
x1 = x0 + α0 r0 une nouvelle estimation x′ et ainsi de suite jusqu’` a obtenir il faut chercher α0 tel que f soit minimum sur la direction la pr´ecision voulue. Il reste cependant la question de savoir r0 , or en d´eveloppant (4.17) et en ´ecrivant la d´eriv´ee par si le minimum de la parabole est bien un minimum et non rapport `a α0 , on doit chercher α0 tel que : un maximum ! On peut v´erifier si par exemple, f (x) est α0 r0 · H · r0 + x0 · H · r0 + g · r0 = 0 bien inf´erieur `a f (c) ; s’il ne l’est pas on peut prendre par exemple le point milieu de c et de x. o` u l’on a tenu compte du fait que H est une matrice sym´etrique19 , ce qui donne une expression de α0 : 4.7.4 M´ ethode du gradient conjugu´ e. r0 · r0 α0 = − r Soit de nouveau une fonction f (x) o` u x est un vecteur 0 · H · r0 dans un espace de dimension quelconque n. On cherche le Si l’on r´ep`ete la mˆeme s´equence, la nouvelle direction de minimum de cette fonction. recherche r1 doit ˆetre orthogonale `a r0 parce que justement Une premi`ere id´ee qui pourrait venir ` a l’esprit serait de nous sommes d´ej` a sur un minimum de la fonction dans la suivre la ligne de plus grande pente (steepest descent ) : on direction r0 , donc : suit une droite parall`ele au gradient local de la fonction : r1 · r0 = 0 ~ grad(f ) (4.15) ce que l’on v´erifie facilement par le calcul. δx = −α ~ kgrad(f )k ` deux dimensions, l’on obtient donc les zizags de la A figure 4.18 et avec un plus grand nombre de dimensions, o` u α est un scalaire obtenu par exemple par la m´ethode c ¸ a doit ˆetre, a priori, pire. . . On remarque cependant que du paragraphe 4.7.3. si les courbes de niveaux de la figure 4.18 avaient ´et´e des cercles, la convergence aurait ´et´e obtenue en un pas, `a condition de choisir une direction de recherche parall`ele au gradient ! Il serait donc habile de tenter de faire entrer en ligne de compte la g´eom´etrie des courbes de niveaux et d’introduire non pas le produit scalaire ordinaire x · y, qui est bien adapt´e `a une sym´etrie sph´erique, mais le H-produit scalaire adapt´e `a la g´eom´etrie de H : Fig. 4.18 – La « ligne de plus grande pente » dans une x·H·y vall´ee ´etroite. Il faut un grand nombre de pas pour atteindre le fond de la vall´ee. Sans entrer dans les d´emonstrations20 ni dans le d´etail de l’algorithme, il suffit alors de chercher une s´erie de direcIl se trouve que c’est souvent assez peu efficace mˆeme tions de recherches di qui soient H-orthogonales entre elles si cela peut donner de bons r´esultats dans certains cas : de telle fa¸con que : en effet, si l’on cherche un minimum au fond d’une vall´ee ´etroite et si l’on part d’un bord de la vall´ee, on va partir xi+1 = xi + αi di dans une s´erie de zigzags plutˆ ot inutiles (figure 4.18). ∂2 f ∂2 f 19 Parce que H i,j = ∂x ∂x = ∂x ∂x = Hj,i , donc on se convainc i j j i Pour trouver
