Vous êtes sur la page 1sur 16

Ecole Nationale de Techniques Avancées

Simulation Numérique
Chapitre 7
Librairies
Eric Lunéville
Introduction
Nombreuses librairies (gratuites ou payantes) de bonne qualité,
développées par d'autres avec un souci de généralité et d'efficacité
les utiliser !
En particulier, la Standard Template Library (STL) : librairie normalisée
"attachée" au C++, fournit :
des nouveaux "types" (complexe, chaîne de caractères)
des utilitaires (mémoire, fonctions mathématiques, ...)
des "containers" (vecteur, liste, ...),
des algorithmes (tri, ..)
Les librairies de calcul scientifique (Lapack++, Eispack,...), beaucoup
sont en Fortran : interfacer du C++ et du Fortran
Les librairies graphiques (OpenGL, directx, GTK, wxWidget, QT, ...)
Deux problématiques :
Utiliser ou non une librairie et laquelle choisir ?
Développer une nouvelle librairie ?
Sim. Numérique – chapitre 7 - 1
Plan
Principales fonctionnalités de la STL
types fondamentaux (string, complex,...)
fonctions mathématiques (générateur aléatoire)
entrées/sorties(iostream, fstream,...)
structure de données (vector,list,map,set,...)
méthodes et algorithmes (iterator, tri, ...)
Librairies scientifiques
Principales librairies
Interface C++/Fortran
Librairies graphiques
Fabrication d'une librairie
Sim. Numérique – chapitre 7 - 2
Standard Template Library
Librairie "normalisée" proposant un grand nombre de nouveaux types
et fonctionnalités :
primitifs : pas 2 rôles pour une fonctionnalité
irremplaçables et abordables pour tout utilisateur
robustes et efficaces (difficile de faire mieux!)
génériques : intégration des types de l'utilisateur
encapsulent ou recouvrent des fonctions C
plusieurs fichiers d'entête : #INCLUDE<XXXXX>
les fonctions de la STL sont dans l'espace de nom std
using namespace std; ou std::xxxxx
ici pas de description exhaustive de la STL
seulement les principales fonctionnalités
voir la documentation en ligne :
http://www.sgi.com/tech/stl/ ou http://www.dinkumware.com/manuals/
Sim. Numérique – chapitre 7 - 3
STL : chaînes de caractères
class string, entête <string>
chaîne de caractères de longueur variable (char *) proposant de
nombreuses fonctionnalités
Constructeurs à partir de char * ou string
string V; // c h ai n e v i d e
string S ( ” co ucou ” ) ; // c o n t i e n t ” coucou ”
string T1 ( S ) ; // c o p i e de S
string T2 ( S , 0 , 3 ) ; // c o n t i e n t ” cou”
Accès : opérateur [ ] ,fonctions at() , c_str() , substr()
s t r i n g S ( ” co ucou ” ) ; // c o n t i e n t ” coucou ”
char c=S [ 0 ] ; // premier c a r a c t e r e ( c ) , pas de c o n t r o l e
S[0]= ’ t ’ ; //S=”touco u ”
c=S . a t ( 1 ) ; // deuxième c a r a c t e r e ( o ) , a c c e s a vec c o n t r o l e
const char ∗ t=S . c s t r ( ) ; // a c c e s v i a p o i n t e u r c o n s t a n t de char
s t r i n g SS=S . s u b s t r ( 1 , 3 ) ; // a c c e s à l a sous−c h a in e 2−>4
Sim. Numérique – chapitre 7 -4
STL : chaînes de caractères
Assignation : opérateur =, fonction assign() (≈ constructeurs)
s t r i n g S ( ” couc ou ” ) ; // c o n t i e n t ” coucou ”
s t r i n g V; // c h a in e v i d e
V=S ; // r e c o p i e ;
V=” h e l l o ” ; // a f f e c t a t i o n d ’ un char ∗
V. a s s i g n ( S , 0 , 3 ) ; //met ” cou ” dans V
Insertion, suppression : fonctions insert() , replace(), erase(), clear()
s t r i n g S ( ” couc ou ” ) ; // c o n t i e n t ” coucou ”
S . i nsert (0 , ” hello ” ) ; // i n s e r t i o n au d e b u t −> ” h e l l o coucou ”
S . r e p l a c e ( 6 , 6 , ” prenom ” ) ; // remplace ” coucou ” par ”prenom”
S . erase (0 ,6); // supprime ” h e l l o ” −> ”prenom”
S. clear (); // supprime t o u t −> c h a i n e v i d e
Taille : fonctions size(), capacity(), resize(), reserve()
s t r i n g S ( ” co ucou ” ) ; // c o n t i e n t ” coucou ”
i n t n=S . s i z e ( ) ; // t a i l l e 6
S. resize (3); // c o n t i e n t ” cou ”
S . reserve (20); // a l l o c a t i o n de l o n g u e u r 20 , t a i l l e =3!
Sim. Numérique – chapitre 7 - 5
STL : chaînes de caractères
Recherche : fonctions find(), rfind() (reverse find)
s t r i n g S ( ” co ucou ” ) ; // c o n t i e n t ” coucou ”
i n t p=S . f i n d ( ”u” ) ; // r e n v o i e 2
i n t q=S . f i n d ( ”u” , 3 ) ; // r e n v o i e 5 ( r e c h e r c h e à p a r t i r du 4 eme car . )
i n t r=S . r f i n d ( ”u” ) ; // r e n v o i e 5
s t r i n g T( ” cou ” ) ;
p=S . f i n d (T ) ; // r e n v o i e 0
p=S . r f i n d (T ) ; // r e n v o i e 3
Comparaison : compare(), opérateurs ==, !=, >, >=, <, <=
lexicographique (ordre ascii : 0<...<9<A<...<Z<a<...<z)
s t r i n g S ( ” couc ou ” ) ; // c o n t i e n t ” coucou ”
s t r i n g T( ” c o u r s ” ) ; // c o n t i e n t ” co u rs ”
i n t n=S . compare (T ) ; // r e n v o i e un n e g a t i f car ” couc”<”cour ”
n=S . compare (T , 3 ) ; // r e n v o i e 0 même 3 p r e m i er s c a r a c t è r e s
bool b=(S==B ) ; // r e n v o i e f a l s e
b=(S<B ) ; // r e n v o i e t r u e
Sim. Numérique – chapitre 7 - 6
STL : chaînes de caractères
Concaténation : operateur +, +=
s t r i n g S ( ” couc ou ” ) ; // c o n t i e n t ” coucou ”
S+=” ” ; // a j o u t e un e s pa c e a l a f i n
s t r i n g T( ” h e l l o ” ) ;
s t r i n g W=S+T ; // W c o n t i e n t ” coucou h e l l o ” ;
W=T+” ”+” prenom ” ; // ERREUR! ! ! a d d i t i o n de p o i n t e u r s
entrée/sortie : operateur <<, >>, fonction getline()
s t r i n g S ( ” co ucou ” ) ; // c o n t i e n t ” coucou ”
co ut<<S ; // a f f i c h a g e de S
s t r i n g T;
c i n >>T ; // l e c t u r e d ’ une c h a i n e
// ( par d é f a u t e o l e t b l a n c s o n t l e s d é l i m i t e u r s )
g e t l i n e ( cin ,T) ; // l i t t o u t e l a l i g n e ( j u s q u ’ à e o l ) dans un s t r i n g
la classe string ne possède pas de fonctions :
 de conversion majuscule / minuscule
 de suppression des blancs en début ou fin
attention au coût calcul (réallocation)
Sim. Numérique – chapitre 7 - 7
STL : nombres complexes
classe template complex<T>, entête <complex>
classe simple permettant de manipuler des nombres complexes
template avec spécialisation float, double, long double
transtype automatiquement les réels,
pas de transtypage implicite complexe → réel (x=reel(z) est inconsistant!)
implémente les opérations algébriques classiques : += -= *= /= + - * /
implémente les fontions mathématiques usuelles :
real imag abs norm arg polar conj cos sin tan exp cosh sinh tanh sqrt
log log10 pow (coupure sur le demi-axe réel négatif)
supporte les opérateurs de flux <<, >>
comparaison : ==, !=
Sim. Numérique – chapitre 7 - 8
STL : exemple d'utilisation des complexes
#include <complex>
using namespace s t d ;
typedef complex<double> Complexe ; // a l i a s
i n t main ( )
{ Complexe i ( 0 . , 1 . ) ; // i m a g i n a i r e pur
Complexe Z=s q r t ( i ) ; // c o n s t r u c t e u r c o p i e de r a c i n e ( i )
double x=Z . r e a l ( ) ; // p a r t i e r é e l l e de Z
double y=Z . imag ( ) ; // p a r t i e i m a g i n a i r e de Z
Complexe Zb=Z . c o n j ( ) ; // c o n ju g ué e de Z
bool b=(Z==Zb ) ; // t r u e s i Z e s t r é e l
cout<<Z ; // a f f i c h a g e de Z
double r=Z ; //ERREUR ! ! ! t r a n s t y p a g e complexe−>r e e l
}
Sim. Numérique – chapitre 7 - 9
STL : limites numériques
Utilitaire fournissant les nombres min et max d'un type :
classe template numeric_limits<T>, entête <limits>
spécialisation pour les types fondamentaux (entier, réel, caractère et booléan),
pas pour les types dérivés (complex, …)
Par exemple, pour les caractères numeric_limits<char> :
digits() : nombre de bits (7)
min() : valeur minimum (-128)
max() : valeur maximum ( 127)
pour les réels numeric_limits<float> , numeric_limits<double> :
digits() : nombre de bits mantisse (24 en float)
min() : valeur minimum (1.17..E-38)
max() : valeur maximum (3.40..E+38)
epsilon() : réel positif le plus proche de 0 (1.19..E-7)
Sim. Numérique – chapitre 7 -10
STL : fonctions mathématiques
entêtes <cmath> <math.h> : fonctions sur les réels (float, double, long double)
 algébrique : abs fabs ceil floor pow
 trigonométrique : cos sin tan acos asin atan atan2
 transcendante : exp sinh cosh tanh log log10
 divers : modf frexp fmod ldexp
entête <cstdlib> : fonctions sur les entiers (int, unsigned int, long int)
 abs div (retourne le quotient et le reste)
 générateur aléatoire : rand srand
entête <numeric> (algorithme numérique) :
template fonctions : accumulate inner_product partial_sum partial_difference
Sim. Numérique – chapitre 7 -11
STL : les containers
Containers de la STL : classes génériques permettant de gérer des collections :
les listes : list<T> vector<T> deque<T> (entête <list>,<vector>, <deque>)
les listes associatives : map<K,T> multimap<K,T> (entête <map>)
les ensembles : set<T> multiset<T> (entête <set>)
les adaptateurs de containers : stack<T> queue<T> priority-queue<T>
(entête <stack>, <queue>)
Allocation mémoire automatique
Outil d’ajout et de suppression d’éléments
Mécanisme générique de parcours des collections :
les iterateurs (iterator) : pointeur généralisé
Outils de recherche
Sim. Numérique – chapitre 7 -12
STL : list
classe list définie dans l’entête <list>
template <class T, class Allocator=allocator<T> > class list
Liste à accès séquentiel (parcours dans les deux sens)
T type des éléments de la liste
allocator<T> : classe d’allocation mémoire par défaut
on peut en utiliser une autre …
Itérateur de list ≈ pointeur sur un élément de la liste :
list<T>::iterator it; itérateur direct (++ →)
list<T>::const_iterator cit; itérateur constant direct
list<T>::reverse_iterator rit; itérateur rétrograde (++ ← )
list<T>::const_reverse_iterator rcit; itérateur constant rétrograde
*it renvoie une référence sur un objet de type T
Sim. Numérique – chapitre 7 -13
STL : list
Construction, assignation :
list<T>(taille) taille =nb éléments
list<T>(taille, const T& ) initialisée avec un élément
list<T>(const list<T>&) par copie d’une liste
list<T>(iterator,iterator) par copie d’une plage d’éléments
list<T>& operator =(const list<T>&) //affectation
void assign (const list<T>&) //assignation
void assign(iterator,iterator)
Accès
T& front() référence sur le premier élément
T& back() référence sur le dernier élément
iterator begin() premier élément de la liste
iterator end() après le dernier élément de la liste
reverse_iterator rbegin() dernier élément de la liste
reverse_iterator rend() avant le premier élément de la liste
Sim. Numérique – chapitre 7 -14
STL : list
Modification de la liste
void push_front (const T&) ajoute un élément au début de la liste
void push_back (const T&) ajoute un élément à la fin de la liste
void pop_front () supprime le premier élément
void pop_back () supprime le dernier élément
iterator insert (iterator, const T&) insère un élément après l’élément pointé
void insert(iterator,iterator,iterator) insère une plage d’éléments
iterator erase (iterator) supprime l’élément pointé
iterator erase(iterator,iterator) supprime une plage d’éléments
void clear() efface tout
Autres opérations
swap, splice, remove, remove_if, unique, merge, sort, reverse
Opérateurs booléens
==, != (égalité/différence)
<, >, <=,>= (infériorité/supériorité de tous les éléments)
Sim. Numérique – chapitre 7 -15
STL : list, exemple
#include < l i s t >
#include <i o s t r e a m >
using namespace s t d ;
cla ss Point
{ public : f l o a t x , y ;
P o i n t ( f l o a t a =0 , f l o a t b=0) : x ( a ) , y ( b ) {}
bool operator ==(const p o i n t &P) { return x==P . x && y==P . y ; }
bool operator !=( const p o i n t &P) { return ! P==∗t h i s ; }
};
i n t main ( )
{ l i s t <Point> Lp ( ) ;
// r e m p l i s s a g e de l a l i s t e
f o r ( i n t i =0; i <10; i ++)
f o r ( i n t j =0; j <10; j ++) Lp . p us h b a c k ( P o i n t ( i , j ) ) ;
l i s t <Point > : : i t e r a t o r i t ;
// i m p r e s s i o n de l a l i s t e
f o r ( i t =Lp . b e g i n ( ) ; i t !=Lp . end ();++ i t )
c out<<” ( ” << i t −>x<<i t −>y<<” ) ” <<e n d l ;
// Recherche e t s u p p r e s s i o n du p o i n t ( 5 , 5 )
P o in t M( 5 , 5 ) ;
i t =Lp . b e g i n ( ) ;
while ( i t !=Lp . end ( ) )
{ i f ( ∗ i t !=M) i t ++;
e l s e { e r a s e ( i t ) ; break } ;
}
Sim. Numérique – chapitre 7 -16
STL : vector
classe vector définie dans l’entête <vector>
template <class T, class Allocator=allocator<T> > class vector
Liste à accès direct via un indice numérique
Implémentation mémoire contiguë (extension mémoire automatique)
Mêmes fonctions que list<T> avec en plus :
int capacity() : capacité maximale du vecteur
void reserve(int) : taille maximale du vecteur
T& at(int), T& operator[](int) : accès à l’élément i
push_front et pop_front non proposées !
Ce n’est pas un vecteur au sens mathématique
Les opérateurs + - * / ne sont pas surchargés
Sim. Numérique – chapitre 7 -17
STL : vector, exemple
#include <v e c t o r >
#include <i o s t r e a m >
using namespace s t d ;
i n t main ( )
{ // c o n s t r u c t e u r s
v e c t o r <double> X ( 1 0 , 0 . ) ;
v e c t e u r <double> Y;
// r e m p l i s s a g e v i a p u s h b a c k
f o r ( i n t i =0; i <10; i ++) Y. pu sh ba c k ( i +1) ;
// r e m p l i s s a g e e t p ar c o u r s avec i t é r a t e u r
v e c t e u r <double> Z ( 1 0 ) ;
v e c t e u r <double > : : i t e r a t o r i t ;
i n t i =0;
f o r ( i t =Y . b e g i n ( ) ; i t !=Y. end ();++ i t ,++ i ) Z [ i ]=∗ i t ;
}
L’opérateur d’accès [ ] n’est autorisé que si le vecteur est dimensionné
et a une taille suffisante !
Sim. Numérique – chapitre 7 -18
STL : map, multimap
classe map et multimap définie dans l’entête <map>
template <class K, class T, class Allocator=allocator<T> > class vector
Liste associative d’éléments (type T) à accès direct via une clé (type K)
généralisation de vecteur : liste[clé]=val
Maintient l'ordre lexicographique des clés et leur unicité (map)
Gestion automatique de la mémoire
Un itérateur retourne une pair (clé,val)
constructeurs : vide, copie, map partiel (itérateur)
accès : opérateur [ ], fonction begin() end()
map<s t r i n g , s t r i n g > A d r e s s e ( ) ; // l i s t e d ’ a d r e s s e i n d e xé e par un nom
A d r e s s e [ ”Dupont ” ]=” r u e . . ” ; // a j o u t d ’ un (nom, a d r e s s e )
A d r e s s e [ ”Durand” ]=” r u e . . ” ; // [ ] l e c t u r e / e c r i t u r e
map<s t r i n g , s t r i n g > : : i t e r a t o r i t ; // i t e r a t e u r de map
f o r ( i t=A d r e s s e . b e g i n ( ) ; i t != A d r e s s e . end ( ) ; i t ++) // p a r c o u r s de l a l i s t e
cout<<i t . f i r s t <<” ”<< i t . s econd<<e n d l ;
Sim. Numérique – chapitre 7 -19
STL : map
insertion/suppression : insert(), erase(), clear() (cf vector)
taille : size(), pas de resize() ni reserve()
comparaison : opérateurs == != < > <= >= (lexicographique)
spécifique à map : count(), find(), lower_bound(), upper_bound(),
equal_range()
map<s t r i n g , s t r i n g > A d r e s s e ( ) ; // l i s t e d ’ a d r e s s e i n d e xé e par un nom
A d r e s s e [ ”Dupont ” ]=” r u e . . ” ; // a j o u t d ’ un (nom, a d r e s s e )
A d r e s s e [ ”Durand” ]=” r u e . . ” ; // [ ] l e c t u r e / é c r i t u r e
i n t p=A d r e s s e . c ount ( ” Duroc ” ) ; // p=0 ca r ”Duroc” n ’ e s t pas une c l é
typedef map<s t r i n g , s t r i n g > : : i t e r a t o r i t e r ; // a l i a s i t e r a t e u r de map
iter it ; // i t e r a t e u r de map
i t =A d r e s s e . f i n d ( ” Dupont ” ) ; // s e p o s i t i o n n e s u r ”Dupont”
i t =A d r e s s e . f i n d ( ” Duroc ” ) ; // non t r o u v e : i t=end ( )
i t =A d r e s s e . l o w e r b o u n d ( ”Du” ) ; // s e p o s i t i o n n e s u r l a c l é > ”Du”
i t =A d r e s s e . upper bound ( ”Dup” ) ; // s e p o s i t i o n n e s u r l a c l e < ”Dup”
p a i r <i t e r , i t e r > P ; // une p a i r e d ’ i t é r a t e u r s
P=A d r e s s e . e q u a l r a n g e ( ”Du” ) ; // P . f i r s t = Adresse . l ow e r b o un d (”Du”)
// P . second=Adresse . upper boun d (”Du”)
Sim. Numérique – chapitre 7 -20
STL : autres containers
deque : file d'attente à double accès : accès aux extrémités et accès direct
moins performant que vector
queue, stack : adaptateurs de deque qui masquent et renomment des
fonctionnalités (push_back -> push)
priority_queue : type queue avec une information de priorité en plus (tri
implicite), basée sur vector
set, multiset : ensemble, similaire à map avec « val=clé », sans opérateur
d'accès [ ]}, multiset autorise les doublons
bitset :ensemble de N bits, taille fixe connue à la compilation, différent de
vector<bool>, implémente les opérations standards sur les bits
valarray : vecteur mathématique, optimisé pour le traitement numérique
(mémoire contigüe), propose les opérations standards et implémente le
concept de slice (accès aux lignes et colonnes d'une matrice représentée
par un tableau unidimensionnel), s'interface bien avec BLAS.
Sim. Numérique – chapitre 7 -21
STL : algorithmes
La STL fournit des algorithmes standards : parcours, accès, tri de
séquences … ≈ 60 fonctions, entête <algorithm>
générique : autonome (non attaché à une classe)
implémentation optimisée : difficile de mieux faire
s'appuie sur le concept de séquence (vecteur, liste,...) et itérateur
bien adapté aux containeurs de la STL
utilise le concept d’objet fonction pour personnaliser l'algorithme
Principaux algorithmes
recherche dans une séquence (pas de modification)
modification d'une séquence (remplacement, permutation, …)
tri d'une séquence
définition et construction d'une séquence
utilitaire (min,max)
Sim. Numérique – chapitre 7 -22
STL : algorithmes, itérateur
Accès à un container C via un itérateur
C::iterator It; déclaration d'un itérateur
It=C.begin(); premier élément
It=C.end(); après le dernier élément (liste ouverte)
défini pour les containers de la STL
à implémenter pour des classes containeurs personnels
Utilisation dans les algorithmes : algo(iter1,iter2,…)
exemple : algorithme de recherche find()
l i s t <s t r i n g > Noms ;
Noms . p u s h ba c k ( ” Dupont ” ) ; . . .
l i s t <s t r i n g > : : i t e r a t o r i t , i t 1 , i t 2 ; // i t e r a t e u r s
i t 1=Noms . b e g i n ( ) ; i t 2=Noms . end ( ) ;
i t=f i n d ( i t 1 , i t 2 , ” Duroc ” ) ; // i t=end ( ) s i a b s e n t
i t=f i n d ( Noms . b e g i n ( ) , Noms . end ( ) , ” Duroc ” ) ; // p l u s compact
aucun contrôle de cohérence des deux itérateurs en entrée !!!
Sim. Numérique – chapitre 7 -23
STL : objet fonction
Comment transmettre une fonction utilisateur à un algorithme générique ?
calcul de f(liste) à l'aide de l’algorithme for_each()
recherche dans une liste suivant un critère (x<y), algorithme find_if()
(une fonction retournant un booléen est un prédicat)
Classe fonction encapsulant une fonction (unaire, binaire)
Classes prédéfinies dans l’entête <functionnal> :
template <class Arg, class Res> unary_function
template <class Arg1, class Arg2, class Res> binary_function
Prototype de for_each :
template <class Iter, class Func> void for_each(Iter first, Iter last, Func f);
Principe : dériver une nouvelle classe fonction à partir des précédentes
Sim. Numérique – chapitre 7 -24
STL : objet fonction
Exemple : calculer le sinus d’un vecteur
Classe fonction sinus
class sinus : pr ivate u n a r y f u n c t i o n <double , double>
{ public :
double operator ( ) ( const double& x ) const // a p p e l
{ return s i n ( x ) ; }
};
Utilisation
i n t main ( )
{ v e c t o r <double> V( 1 0 ) ;
f o r ( i n t i =0; i <10; i ++) V[ i ]= i ; // i n i t i a l i s a t i o n du v e c t e u r
sinus S ( ) ; // i n s t a n c i a t i o n d u n o b j e t f o n c t i o n s i n u s
f o r e a c h (V. b e g i n ( ) ,V . end ( ) , S ) ; // c a l c u l de s i n (V)
}
classe ptr_fun : transforme une fonction en objet fonction
f o r e a c h (V. b e g i n ( ) ,V . end ( ) , p t r f u n ( s i n ) ) ;
Sim. Numérique – chapitre 7 -25
STL : objet fonction
Classes fonction unaire prédéfinies (entête <functionnal>) :
template <T> plus() minus() multiplies() divides() modulus() negate()
Classes prédicat binaire prédéfinies (entête <functionnal>) :
template <T,T,bool> equal_to() not_equal_to() greater() less()
greater_equal() less_equal() ...
Transformation d’un objet fonction binaire en objet fonction unaire :
bind1st() bind2nd()
...
i t= f i n d i f ( i t 1 , i t 2 , bind2nd ( g r e a t e r e q u a l <int > ( ) , 1 0 0 ) ) ;
transforme la fonction binaire x>=y en fonction unaire x>=100
objets fonction plus rapides que les fonctions !!!
concept difficile au niveau débutant, nombreux concepts sous-jacents
on peut s'en passer au début ...
Sim. Numérique – chapitre 7 -26
STL : principaux algorithmes
parcours d'une séquence : for_each()
recherche d'éléments dans une séquence : find() find_if() find_first_of()
search_n() count()
recherche de sous-séquence : mismatch() equal() search() find_end()
modifications dans une séquence : transform() copy() swap() replace() fill()
generate() remove() unique() reverse() rotate()
tri d'une séquence :sort() partial_sort() nth_element() lower_bound()
upper_bound() merge() partition()
inclusion, union et intersection (triée) : includest() set_union()
set_intersection()
minimum et maximum :min() max() min_element() max_element()
lexicographical_compare()
Sim. Numérique – chapitre 7 -27
Autres librairies
Principales librairies de calcul scientifique : http://www.netlib.org
 Basic Linear Algebra Subprograms (BLAS) : calculs super optimisés sur
les vecteurs et matrices (Fortran)
 Lapack++ : résolutions de système linéaire très performantes, recherche de
valeurs propres (matrice pleine, bande)(C++)
 Fonctions spéciales : amos, specfun (Fortran)
 Intégration numérique : quadpack ( Fortran)
 Résolution d'équation différentielles : odepack ( Fortran}
 Optimisation : opt ( Fortran)
 FFT : fftpack (Fortran et interface C)
 Générateurs aléatoires : random ( Fortran et C)
Boost : librairie généraliste complémentaire de la STL http://www.boost.org/
Sim. Numérique – chapitre 7 -28
Interfacer du Fortran
Fonction fortran réalisant le produit scalaire :
double precision function ddot(x,y,n)
Interface C/C++ :
extern ”C” double d d o t ( double [ ] , double [ ] , i n t ∗ ) ;
void main ( )
{ int n ;
double x [ 3 ] , y [ 3 ] , p r o d u i t ;
n=3;
x [ 0 ] = 2 . ; x [ 1 ] = 3 . ; x [2]= −1.;
y [ 0 ] = 1 . ; y [1]= −3.; y [2]= −2.;
p r o d u i t=d d o t ( x , y,&n ) ;
}
 passage d'arguments par POINTER (seul mode en Fortran)
 ajout de _ dans le prototype C++ de ddot() car le compilateur Fortran génère la
fonction ddot_
 déclarée en extern "C", pas de fichier entête en Fortran, prise en compte à
l'édition de lien
Sim. Numérique – chapitre 7 -29
Librairies graphiques
Librairies de bas niveau :
 Windows : API Windows(2D), DirectX (3D)
 Linux/Windows : GTK+(2D), OpenGL(3D)
Librairies de haut niveau 2D (fenêtre,boutons,..., programmation événementielle)
 Windows : C++Builder, VisualC++
 Linux/Windows : Kylix, wxWidget, Qt
demande un investissement assez important (nombreux objets graphiques...)
CodeBlocks permet de développer des interfaces graphiques simples
via le plugin wxSmith
Sim. Numérique – chapitre 7 -30
Développer des librairies ?
On distingue deux types de librairie :
 Statique : incluse dans l'exécutable lors de l'édition de lien
 Dynamique : non incluse dans l'éxécutable, chargée dynamiquement lors
de l'exécution (dll en windows)
Comment générer des librairies ?
Windows : utiliser les outils de développement (CodeBlocks par exemple)
Linux/Unix : deux commandes simples
ar qui crée une archive de fichiers compilés
ranlib qui crée un index.
attention aux dépendances entre librairies !
attention, difficulté supplémentaire avec les classes "templatées"
Sim. Numérique – chapitre 7 -31