Ecole Nationale de Techniques Avancées

Simulation Numérique
Introduction

Eric Lunéville

Qu’est ce que la simulation numérique ?

De la modélisation aux résultats numériques

Problème physique, mécanique, économique, biologique
Modèlisation mathématique (EDO, EDP, …)
Etudes mathématiques (existence, unicité, caractérisation)
Discrétisation et approximation
Analyse numérique (convergence, erreurs d’approximation)
Algorithmique (stabilité et efficacité)
Implémentation sur ordinateur
Validation, analyse des résultats
Exploitation
Sim. Numérique – Introduction 1
 Exemple : multi-diffusion
Béton
Modèle simplifié

Modèle math. études math. ok

Discrétisation
∂2p ∂2p
2
+ 2 + k2 p = 0
Eléments finis ∂x ∂y

Algorithmique Code EF (Melina)

Analyse numérique ok Génération aléatoirede diffuseurs
Implémentation
Validation.
Programmation scientifique

Exploitation

Sim. Numérique – Introduction 2

Problématique de la prog. scientifique

Précision (propagation des erreurs, stabilité)

Rapidité (algorithmes)
Gestion de la mémoire (allocation dynamique)
Structuration (organisation, hiérarchisation)
Ré-utilisabilité (clarté, bibliothèques)
Debogage, validation
Phase de développement (dvp coopératif)
Quel langage de programmation ?

Sim. Numérique – Introduction 3

 Précision : instabilité !
Calcul des racines de : εx2 + x − 1 = 0
√ ε→0 ε
−1± 1+4ε
x± = 2ε
x+ ≈ 1 −
2
f l o a t eps=1E−8; f l o a t a=ep s ; f l o a t b=1; f l o a t c=−1;
f l o a t d e l t a=s q r t ( b∗b−4∗a∗ c ) ; f l o a t xp=(−b+d e l t a ) / ( 2 ∗ a ) ;

ε = 10−6 =⇒ xp = 1.01328
ε = 10−7 =⇒ xp = 1.19209
ε = 10−8 =⇒ xp = 0
erreur de « cancellation » : x∼
=y →x−y = ?
erreur d’arrondi : x ≫ y → x + y = x
√
−b−signe(b) b2 −4ac c
Une méthode stable : x1 = x2 =
2a a∗x1
Sim. Numérique – Introduction 4

Précision : toute série converge !

1
Série divergente : SN = , SN ∼
= ln(N )
n=1,N
n

f l o a t S = 0 . ; in t N=200000000;
for ( int n=1;n<=N; n++) S+=1./n ;

N = 106 =⇒ S = 14.3574 ln(N ) = 13.8155

N = 107 =⇒ S = 15.4037 ln(N ) = 16.1181
N = 2.107 =⇒ S = 15.4037 ln(N ) = 16.8112 Convergence !

erreur d’arrondi : x ≫ y → x + y = x

En double précision (double S) : N = 2107 =⇒ S = 17.3885

Avec une boucle rétrograde : N = 2107 =⇒ S = 17.3901

Sim. Numérique – Introduction 5
 Rapidité : ce qu'il ne faut jamais faire
Calcul constant dans une boucle
for ( int i =1; i<=N; i ++) f l o a t a=s q r t (3)+ f l o a t ( i ) ;
Temps de calcul pour N = 500000000 : 14 sec

f l o a t s 3=s q r t ( 3 ) ;
for ( int i =1; i<=N; i ++) f l o a t a=s 3+f l o a t ( i ) ;

Temps de calcul pour N = 500000000 : 2 sec

C'est pire avec un log !

for ( int i =1; i<=N; i ++) f l o a t a=l o g (3)+ f l o a t ( i ) ;
Temps de calcul pour N = 500000000 : 37 sec

Sim. Numérique – Introduction 6

Rapidité : juste un peu de bon sens !

Réorganisation des calculs dans une boucle
for ( int i =1; i<=N; i ++)
f l o a t a=l o g ( f l o a t ( i ))− l o g ( f l o a t ( i + 1 ) ) ;
Temps de calcul pour N = 500000000 : 83 sec

for ( int i =1; i<=N; i ++)

f l o a t a=l o g ( f l o a t ( i )/ f l o a t ( i + 1 ) ) ;
Temps de calcul pour N = 500000000 : 44 sec

Réduire le temps calcul diminue souvent la clarté du programme,

il faut donc que le jeu en vaille la chandelle!

Sim. Numérique – Introduction 7

Rapidité : complexité algorithmique
Résolution d'un système linéaire d'ordre N
Méthode du déterminant ≈ (N + 1)! nbOps
N + 1 déterminants d’ordre N à calculer
nbOps(detN ) = N × nbOps(detN−1 )

Elimination de Gauss ≈ N 3 nbOps

for ( int k=1;k<N; k++)
for ( int i=k+1; i<=N; i ++)
{ for ( int j=k+1; j<=N; j ++)
{A( i , j )−=A( i , k )∗A( k , j ) /A( k , k ) ; }
B( i )−=A( i , k ) ∗B( k ) /A( k , k ) ;
}

Par exemple pour N = 10 le rapport du temps de calcul entre les deux

méthodes est de l'ordre de 40 000!
Sim. Numérique – Introduction 8

Mémoire : les différents types

Mémoire cache (CPU)
Ultra rapide mais limitée (1-2Mo)
2 ns
Mémoire centrale (RAM)
très rapide mais limitée (256 Mo -> 4 Go sur un pc) 10 ns

Mémoire temporaire (SWAP) : zone disque spécifique

quelques Go sur un pc, mais lente
transfert optimisé par le système

Mémoire secondaire : zone disque standard

plusieurs Go sur un pc, mais lente 10 ms
pas d’optimisation particulière

Eviter d’utiliser la mémoire disque (SWAP ou Secondaire)

Sim. Numérique – Introduction 9
 Mémoire : savoir l’économiser
Pour les grandes structures de données (matrices, arbres, …)
choisir un type de stockage adapté :
char 1 octet =1 byte = 8 bits
short int 2 octets = 16 bits
int 4 octets = 32 bits
float 4 octets = 32 bits
long int 8 octets = 64 bits
double 8 octets = 64 bits

Stockage d'une matrice réelle (4 octets) d'ordre N avec 256 Mo de mémoire

matrice pleine Nmax=8000
matrice pleine symétrique Nmax~16000
matrice bande (lb=10) Nmax~300000
matrice profil, morse variable
Sim. Numérique – Introduction 10

Mémoire : gestion
Allocation mémoire = demande de mém. centrale (RAM ou SWAP)

Allocation statique :
prévue à la compilation

Allocation dynamique
à la demande lors de l’exécution
non disponible en Fortran 77 (émulation)
intégré dans les langages plus récents : (C,C++,Java,Fortran95)
fuite de mémoire : garbage collector

Sim. Numérique – Introduction 11

 Présentation : Clarté
Règles de présentation de programmation
Cohérence du code, facilité de relecture, de débogage
Transmission du code
Trois règles principales :
Commentaires : nombreux, clairs et à mettre tout de suite
When the code and the comments disagree, both are probably wrong,
Norm Schryer

Indentation des structures de contrôle (if, for, while, …)

int i ; main ( ) { for ( ; i [ ”]< i ;++ i ){−− i ; } ” ] ; r ea d ( ’− ’− ’−
, i+++”h e l l \o , world ! \ \ n ” , ’ / ’ / ’ / ’ ) ) ; } read ( j , i , p ) { w r i t e
( j /p+p , i −−−j , i / i ) ; }

Choix des noms (variables, fonctions, …) : significatif et clair

Exemple de règles : http://www.chris-lott.org/resources/cstyle/indhill-cstyle.html
Sim. Numérique – Introduction 12

Structuration : conseils généraux

Afin d'augmenter la visibilité du code : structurer le
ce qui facilitera son développement

faire de nombreuses fonctions ou procédures indépendantes

factoriser le code : limite les erreurs

organiser le code de façon logique

utiliser plusieurs fichiers (programmation dissociée)

Sim. Numérique – Introduction 13

Structuration : ré-utilisabilité

Votre code pourra être repris plus tard ou par un autre

Certains morceaux de code ont un caractère général

réutilisables dans d'autres codes

Utiliser des bibliothèques existantes

ne pas refaire ce qui existe déjà en mieux !

Faire une documentation même rudimentaire

Sim. Numérique – Introduction 14

Phase de développement
Conception, structures de données
principales fonctionnalités
architecture générale : outil de modélisation (UML)

par bloc de fonctionnalités élémentaires

Ecriture du code : validation de chaque bloc (test bas niveau)

plusieurs tests
Test globaux :
archivage des tests

options de compilation
Optimisation du code : temps de calcul (outil de profiling)

Documentation : en plus des commentaires dans le code

outils de génération automatique

Evolution du code : Outils de gestion de versions (ex. CVS)

Sim. Numérique – Introduction15
 Validation : débogage

Débogage ascendant
tester chaque fonction de la plus interne à la plus globale

Faire des tests sur des petits cas puis sur de plus gros
test de débordement mémoire

Prévoir des mécanismes de contrôle désactivables

impression de variables internes
test de débordement

Utiliser des outils de débogage

points d’arrêt, exploration des variables, …

Sim. Numérique – Introduction16

Outils de développement intégré

Environnement de développement intégré (EDI, IDE, RAD)
Notion de projets : console, librairie, prog. événementielle ,…

Editeur avec mise en évidence de la syntaxe du langage

Explorateur de code

Appel du compilateur

Debogueur intégré

Profiler intégré

Générateur de documentation

Gestionnaire de versions
Sim. Numérique – Introduction17
 EDI sur PC
Quelques EDI libres
Kdevelopp : linux, multi-langage (www.kde.org/download)
Eclipse : multi-plateforme, multi-langage (www.eclipse.org)
Code::blocks : multi-plateforme, C++ (www.codeblocks.org)
DevCPP : windows, C++ (www.bloodshed.net)

Quelques EDI commerciales

Borland : multi-langage, multi-plateforme, prog.interactive
C++builder, Delphi, Javabuilder, Kylix (www.borland.com)
Microsoft : multi-langage, windows, prog.interactive
visual studio (C++,java) www.microsoft.com/france/msdn/vstudio
IBM : multi-plateforme, multi-langage
rational, www-306.ibm.com/software/fr/rational/
Sim. Numérique – Introduction18

Exemple : code::blocks

Sim. Numérique – Introduction19

 Exemple : C++Builder

Sim. Numérique – Introduction20

Quel langage ?
Histoire des langages pour le « calcul scientifique »
1947 Assembleur – langage machine
1951 A0 - premier langage compilé
1956 FORTRAN (FORmula TRANslator) - premier langage de haut niveau
1960 ALGOL (ALGOrithmic Language) - théorique, peu utilisé
1968 PASCAL - usage pédagogique
1972 C - à l'intention des informaticiens, développement d'Unix
1978 FORTRAN77 - normalisation importante du Fortran
1979 VISICALC (VISIble CALCulator) - premier tableur, ancêtre d'EXCEL
1981 C++ - "`évolution"' du C, concept Objet
1984 MATLAB - langage de type script
1987 CAML - Langage fonctionnel
1990 FORTRAN90 - FORTRAN intégrant l’allocation dynamique
1994 JAVA - langage objet "`pur"', simplification du C++, multi-plateforme
1995 FORTRAN95 - évolution du FORTRAN90
1996 OCAML (Objective CAML) - Caml objet
1996 ANSI C++ - Normalisation du C++
2000 C# - C++ simplifié, concurrent du JAVA (Microsoft) Sim. Numérique – Introduction21
 Quel langage ? : Orienté Objet
Langage permettant de déclarer des nouveaux types de
variable (objet) auxquels sont attachés :
des données (voir d’autres objets) : structuration des données
des fonctions : structuration des fonctionnalités
des opérateurs (+,-,…) : structuration sémantique

Intérêts :
manipuler plus simplement des structures complexes (matrice,...)
complexité reportée dans la définition des objets
structuration implicite du code
séparation des concepts
plus grande ré-utilisabilté
très adapté au calcul scientifique (objets mathématiques naturels)

Inconvénient : programmation plus complexe et exigeante

Sim. Numérique – Introduction22

Quel langage ? : Comparatif

Fortran : le langage de référence du calcul scientifique
très rapide (transfert pointeur automatique)
nombreuses bibliothèques optimisées (BLAS), nombreux codes
dernière norme (F95) : allocation dynamique, calcul matriciel, couche objet
contraintes de mise en page, couche objet incomplète
C++ : un langage objet complet (non pur)
grande liberté de codage, plus près du système (héritage du C)
bibliothèque intégré d’objets et de fonctionnalités (STL)
couche objet complète (héritage, surcharge d'opérateurs, prog. générique)
pas de variable native de type matrice
plus difficile à maitrîser, un peu plus lent que le Fortran

Java : un langage objet pur mais incomplet

langage plus fiable, prisé des informaticiens
pas de polymorphisme, de surcharge d’opérateurs, de prog. générique
génère du pseudo-code plus lent
Sim. Numérique – Introduction23
 Quel langage ? : Comparatif
Matlab : langage non compilé, adapté au prototypage
logiciel commercial dans un environnement (scilab son alter ego libre)
calcul matriciel de base
langage de script très lent
fonctions de haut niveau compilées
richesse des fonctionnalités (meth. numériques, graphique, …)

OCAML : un langage objet fonctionnel qui émerge

approche fonctionnelle
très robuste
plus lent et moins adapté au calcul scientifique

dans le milieu du calcul scientifique :

C++ tend à supplanter le Fortran (C++ exclusif en Finance)
les autes langages restent encore marginaux
Sim. Numérique – Introduction24

Objectifs du cours
Appréhender divers aspects de la
programmation scientifique

Apprendre à développer un code en langage objet

Apprentissage du C++ (cours + TP)
Développement d’un code complet (projet en groupe)

Le calcul haute performance (vectorisation, parallélisation de code) ne

sera pas abordé (module de 3ème année)

Sim. Numérique – Introduction25

 Plan du cours

1. C++ une extension du C

2. Eléments d’analyse numérique
3. Introduction à la notion de classe d’objets
4. Surcharge des opérateurs
5. Programmation générique
6. Librairies, Standard Template Library
7. Héritage
8. Projets
14. Rapport de projet et soutenance orale

Sim. Numérique – Introduction26