Plan du cours

Rappels d’algèbre linéaire 4

Vecteurs de Rn 4
Application linéaire 7
Matrices et propriétés 8
Méthodes numériques et langage C Représentation en langage C 16
Algèbre linéaire Blas et allocation mémoire 16
Vecteurs 20
Matrices 23
R. Flamary Matrices creuses 25

Opérations vectorielles et matricielles 27

Opérations sur les vecteurs 27
17 octobre 2018 Opérations matrice/vecteur 30
Opérations matricielles 33

Résolutions d’équations linéaires 35

Système d’équations et matrices 35
Matrices particulières 39
Pivot de Gauss 42
Factorisation de matrice 48

2 / 53

Algebre linéaire Espaces de dimension finie

Espace vectoriel
Principe Un espace vectoriel sur K est est un ensemble E muni de deux lois :
I Outils mathématiques permettant de modéliser les espaces vectoriels et des I L’addition + : E 2 → E, opération commutative et associative d’élément neutre 0
relations linéaires entre vecteurs. appelé vecteur nul.
I Relations linéaires simples à interpréter. I La multiplication par un scalaire · : K × E → E, opération distributive et
d’élément neutre 1.
I Modélisation des données numériques sous la forme de tableau.
Un vecteur de v ∈ E est définit par un symbole en gras dans ce cours.

Exemples d’utilisation Famille de vecteurs

I Systèmes de recommandation (Netflix, Amazon, Criteo).
I Moteurs de recherche (Google, Bing, Duckduckgo).
I Prédiction de valeurs réelles (Météo, cours de la bourse).
I Traitement du signal et des images (systèmes linaires, filtrage, reconstruction).
I Simulations physiques (méthodes d’élément finis, équations de la chaleur).
I Soit une famille de vecteur {vi }i=1,...,m .
I La famille est dite linéairement indépendante si la seule combinaison linéaire de la
P
forme i λi vi = 0 est celle avec λi = 0, ∀i.
I Le sous-espace vectoriel engendré par une famille {vi }i=1,...,m dénoté
V ec({vi }i=1,...,m ) est l’ensemble des combinaisons linéaires de vi .
I La famille {vi }i=1,...,m linéairement indépendante est une base de E si
V ec({vi }i=1,...,m ) = E.

3 / 53 4 / 53
Vecteurs dans Rn Produit scalaire
Notation
Les vecteurs de Rn peuvent être exprimés sous la forme : I Le produit scalaire entre deux vecteurs x et y de Rn est l’application bilinéaire :
  X
v1 hx, yi = x> y = xi yi
 v2 
  i
v= .  ou v> = [v1 , v2 , . . . , vn ]
 ..  I La norme euclidienne au carré d’un vecteur est son produit scalaire avec lui
vn même :
kvk2 = hv, vi = v> v
En l’absence du symbole >, tous les vecteurs sont supposés vecteurs colonne.
I Un espace vectoriel associé à un produit scalaire est appelé un espace
Base canonique et norme
pré-hilbertien.
I La base canonique de Rn est la famille de vecteurs {vi }i=1,...,n telle que vi = δi I Inégalité de Cauchy-Schwartz :
où δi est le vecteur dirac nul sur toutes ses composante à par la composante i
égale à 1. ∀x, y ∈ E |hx , yi| ≤ kxkkyk
I La norme d’un vecteur de R est définie par
n
I L’angle θ entre deux vecteurs peut être déterminé grâce à
X 2
kvk2 = vi hx, yi = kxkkyk cos θ
i

I La base canonique est orthonormale, c’est à dire orthogonale et chaque élément a I Le produit scalaire peut être utilisé pour projeter un vecteur sur un autre vecteur.
une norme unité.
5 / 53 6 / 53

Application linéaire Matrice

Notation
Définition Les matrices de Rm×n sont définies par :
Soient E et F deux espaces vectoriels. Une application f de E vers F est dite linéaire  
si elle est additive et commute à la multiplication par les scalaires : a1,1 a1,2 · · · a1,n
 a2,1 a2,2 · · · a2,n 
 
∀x, y ∈ E, f (x + y) =f (x) + f (y), A= . .. .. ..  , ai,j ∈ R, ∀i, j
 .. . . . 
∀x ∈ E, ∀λ ∈ K, f (λx) =λf (x).
am,1 am,2 · · · am,n
Autrement dit, f préserve les combinaisons linéaires.
On pourra également utiliser A(:, k) pour désigner la kième colonne de A et A(k, :)
Noyaux et image pour désigner la kième ligne de A.
Attention, en C on utilise l’indexage à 0, a1,1 correspondra donc à l’index entier (0, 0).
Pour toute application linéaire f de E dans F ,
I Les vecteurs x de E tels que f (x) = 0 forment un sous-espace vectoriel de E, Opérations de base
appelé le noyau de f et noté Ker(f ). I Transposition
I les vecteurs f (x) pour x dans E forment un sous-espace vectoriel de F , appelé C = A> ⇔ ci,j = aj,i
l’image de f et noté Im(f ). I Addition
I Les dimensions des sous-espaces sont liées par le téorème du rang : C=A+B ⇔ ci,j = ai,j + bi,j

dim(E) = dim Ker(f ) + dim Im(f ) I Multiplication par un scalaire α

C = αA ⇔ cij = αaij
7 / 53 8 / 53
Multiplication matricielle Matrice et application linéaire

Multiplication matricielle I Toute application linéaire entre deux espaces munis chacun d’une base finie est
Soient deux matrices A ∈ Rm×p et
n colonnes représentable par une matrice.
B ∈ Rp×n I Une application linéaire f : Rn → Rm peut donc être mise sous la forme :

p lignes
B
p
f (x) = Ax
X p colonnes
C = AB ⇔ ci,j = ai,k bk,j
k=1 I L’image Im(f ) de f est le sous espace V ec(A(:, k)k=1,...,n ) engendré par
les colonnes de A.
avec C ∈ Rm×n I Le noyau Ker(f ) de f est le sous espace orthogonal aux lignes A(k, :) de A.

m lignes
Attention le produit matriciel n’est pas A C
commutatif (AB 6= BA). I Cas particulier où A = v> est un vecteur transposé, f : Rn → R est une fonction
à valeur réelle. X
Multiplication matrice vecteur f (x) = v> x = hv, xi = vk xk
Si B = b est un vecteur de taille p alors k

La valeur de la fonction est une somme des composante xk de x pondérées par v.

p
X
c = Ab ⇔ ci = ai,k bk I Cas particulier où m = n et les lignes de A définissent une base orthonormale de
Conseil : faire le dessin.
k=1 Rn : l’application linéaire est un changement de base.

9 / 53 10 / 53

Matrices particulières Exercice 1 : Multiplication matricielle

Soit les vecteurs et matrice suivants :

Matrice Diagonale (m = n) Matrice triangulaire        
  1 1 1 −1 0 1 2
 
a1,1 0 ··· 0 a1,1 0 ··· 0 u = 2 , v = 1 , A = −1 1 −1 , B = 3 4
 0 a2,2 ··· 0   a2,1 a2,2 ··· 0  3 1 0 −1 1 5 6
   
 .. .. .. ..   . .. .. .. 
 . . . .   .. . . . 
Calculer les produits suivants :
0 0 ··· am,n am,1 am,2 ··· am,n
u> u = u> v = u> Av =
I Matrice diagonale : I Matrice triangulaire inférieure :

i 6= j ⇒ aij = 0, ∀i, j i < j ⇒ aij = 0, ∀i, j

uu> = uv> = AA =
I Matrice scalaire si aii = C, ∀i. I A> est triangulaire supérieure.
I Matrice identité si aii = 1, ∀i. I Strictement triangulaire inférieure si
Au = Av = B> u = AB =
i ≤ j ⇒ aij = 0, ∀i, j

11 / 53 12 / 53
Applications de l’algèbre linéaire Applications de l’algèbre linéaire
Prédiction linéaire
I Soit la fonction linéaire
Infographie X
f (x) = v> x = vk xk
I L’immense majorité des modèles 3D k

utilisés dans les jeux vidéo sont I x est un vecteur décrivant un objet et
représentés par
v le paramètre du modèle.
I Vecteurs de position dans R3 .
I Prédiction de valeur continue.
I Matrice d’adjacence.
I Les algorithmes d’illumination font
Exemples d’utilisation
souvent appel au produit scalaire
entre un vecteur normal à la surface I Météo (température, humidité,
et la direction d’une source lumineuse direction du vent à partir de mesures).
ponctuelle. I Moteur de recherche (score à partir
I Les rotations et déplacements des de requête web et pagerank).
membres des models 3D sont I Détection de SPAM (score à partir
modélisés par des produits matriciels.
d’email).

13 / 53 14 / 53

Applications de l’algèbre linéaire Représentation mémoire en langage C

Factorisation de matrice
I On cherche à factoriser une matrice Représentation mémoire
A ∈ Rm×n sous la forme : I Il existe de multiples implémentations possibles (pointeurs, tableaux, . . .).
A ≈ UV >
I Dans ce cours nous nous concentrerons sur l’utilisation de pointeurs.
I Pour les matrices on veut un stockage mémoire contigu pour permettre une
avec U ∈ Rm×p , V ∈ Rn×p et
p  m, p  n interface avec BLAS (interface standard pour les opérations d’algèbre linéaire).
I A peut ne pas être complètement
observée. Principe général
I Déclaration des vecteurs et matrices (pointeurs).
Exemples d’utilisation
I Allocation mémoire dynamique au début du programme (malloc).
I Recommandations Amazon. I Calculs effectués sur les vecteurs matrices alloués.
I Recommandations Netflix. I Libération mémoire à la fin du programme (free).
I Clustering de réseaux sociaux.
I Réduction de dimension.

15 / 53 16 / 53
BLAS (Basic Linear Algebra Subprograms) BLAS et complexité
Description Les fonctions définies dans BLAS sont regroupées par niveaux de complexité
algorithmique.
I BLAS est une spécification décrivant les diverses opérations de base en algèbre
Niveau 1 (Complexité linéaire)
linéaire.
I Vecteur taille n.
I L’origine de la spécification est une bibliothèque Fortran proposée en 1979.
I T (n) = O(n), S(n) = O(n)
I Une implémentation de référence en Fortran est disponible sur
http://www.netlib.org/blas/. I Exemple : produit scalaire , multiplication par un scalaire, addition de vecteurs.
I Une interface C appelée cblas est également disponible.
I Types de fonctions séparées par leur complexité (mémoire/temporelle). Niveau 2 (Complexité quadratique)
I Vecteur taille n, Matrice de taille m×n
Importance de la compatibilité I T (n) = O(n2 ) ou O(mn), S(n) = O(n2 ) ou O(mn)
I De nombreuses bibliothèques fournissent une I Exemple : produit dyadique , multiplication matrice/vecteur.
implémentation BLAS extrêmement optimisée.
I Choix de la bibliothèque au niveau système Niveau 3 (Complexité cubique)
sous Linux. I Matrice de taille n×n
I Exemples : Intel MKL, Atlas, OpenBLAS. I T (n) = O(n3 ), S(n) = O(n2 )
I Exemple : produit matriciel.
Source http://blog.nguyenvq.com/
17 / 53 18 / 53

Convention des fonctions BLAS Vecteurs en C

I Les fonctions et procédures BLAS sont des fonctions Fortran en majuscule.

I Nom typique : xNOMFONCTION où x donne le type des vecteurs : x x[0] x[1] x[2] x[3] x[4] x[5] x[6] x[7] x[8] x[9]
S Simple précision (float) x1 x2 x3 x4 x5 x6 x7 x8 x9 x10
D Double précision (double)
C Complexe simple précision
Z Complexe double précision Principe
I L’interface cblas fournit des fonctions C appelant directement les fonctions
I Les vecteurs sont représentés par des pointeurs vers des flottants.
BLAS.
I Déclaration : double *x;
I Nom des fonctions cblas : cblas xnomfonction
I Initialisation mémoire : x=malloc(n*sizeof(double)); (calloc pour init. à 0)
I Le passage de paramètre se fait toujours par référence pour les matrices et
vecteurs (on donne les pointeurs) I Utilisation : x[i]=10.; ou *(x+i)=10.;
I Les pointeurs doivent adresser des espaces mémoire alloués. I Libération mémoire : free(x);
I Dans le cours nous donnerons le nom des fonctions BLAS associées aux I Attention à libérer la mémoire et à ne pas faire de malloc dans la boucle d’une
opérations de base en algèbre linéaire. procédure itérative.

19 / 53 20 / 53
Fonctions utiles pour les vecteurs Exercice 2 : Initialisation et impression
Quelle est la sortie imprimée dans le terminal pour le programme suivant :

Code Allocation et initialisation Code source Sortie

1 double *vinit(int n,double alpha) 1 int n=10;
2 { I v ← α1n 2 double *v1;
3 double * res= (double *)malloc(n* I Allocation et mise à α des 3 double *v2;
sizeof(double)); 4 double alpha=3.;
composantes d’un vecteur.
4 for (int i=0;i<n;i++) 5

5 res[i]=alpha; I Complexité T () : 6 v1=vinit(n,0);

return res; 7 v1[2]=1;
I Complexité S() :
6
7 } 8
9 v2=vinit(n,1);
Code Impression écran 10 for (int i=0;i<n;i+=2)
1 void vprint(int n, double *v) 11 v2[i]*=i;
2 { I Imprime un vecteur dans le terminal 12

3 printf("["); (sur une ligne). 13 printf("v1=");vprint(n,v1);

for (int i=0;i<n;i++) 14 printf("v2=");vprint(n,v2);
I Complexité T () :
4
5 printf(" %2.2f ",v[i]); 15

6 printf("]\n"); I Complexité S() : 16 printf("Modification de v2:\n");

7 } 17 for (int i=0;i<n;i++)
18 v2[i]*=alpha;
19 printf("v2=");vprint(n,v2);

21 / 53 22 / 53

Matrices en C Allocation et libération de mémoire

Code Allocation et initialisation
a a[0] a[1] a[2]
1 double **minit(int m, int n,double
alpha) I A ← α1m 1>
n
2 { I Allocation et mise à α des
3 double ** res= (double **)malloc(m*
a[0][0] a[0][1] a[0][2] a[0][3] a[1][0] a[1][1] a[1][2] a[1][3] a[2][0] a[2][1] a[2][2] a[2][3]
composantes d’une matrice.
sizeof(double *));
4 double * data=(double *)malloc(m*n* I Complexité T () :
a1,1 a1,2 a1,3 a1,4 a2,1 a2,2 a2,3 a2,4 a3,1 a3,2 a3,3 a3,4 sizeof(double));
I Complexité S() :
5 for (int i=0;i<m*n;i++)
6 data[i]=alpha;
Principe 7 for (int i=0;i<m;i++)
res[i]=data+i*n;
I Les matrices sont représentées par un tableau de pointeurs (vers chaque ligne de
8
9 return res;
la matrice). 10 }
I Déclaration : double **a;
Code Libération mémoire
I Initialisation mémoire : 2 malloc (un pour le tableau a, un pour les données) 1
void mfree(double **a) I Libération de la mémoire (données et
I Utilisation : a[i][j]=10.; 2
3 { tableau de pointeurs).
I Libération mémoire (2 free) : free(&a[0][0]);free(a); 4 free(&a[0][0]); I Complexité T () :
5 free(a);
I Une espace mémoire contigu est nécessaire pour une interface avec BLAS. 6 } I Complexité S() :

23 / 53 24 / 53
Matrices creuses Matrice creuse (2)
Exemple sous Matlab
Principe Opération Dense Creux
I n = 10000
I Stockage mémoire classique est  dense . v> v 0.0001 0.0005
I nv = 100 Av 0.0525 0.0007
I Les matrices et vecteurs creux (parcimonieux) ont un petit nombre nv  n de
I Temps de calcul (en sec). AA 19.2145 0.0397
valeurs différentes de 0.
I Il est plus efficace de stocker en mémoire une liste des positions et les valeurs
correspondantes. Exemples d’utilisation
I Vecteur v de taille n avec nv valeurs différentes de zéros format compressé :

is ∈ Nnv et vs ∈ Rnv

I Matrice A de taille m × n avec nv valeurs différentes de zéros format compressé :

is ∈ Nnv , js ∈ Nnv et vs ∈ Rnv

I La représentation ci-dessus s’appelle la représentation par coordonnée.

I Différents types de représentation (Yale sparse matrix, Compressed Sparse
I Données web (page web, profil).
Column ) sont plus ou moins efficaces selon les opérations à effectuer (opération
matricielle, remplissage). I Graphe de relations (réseaux sociaux).
I Objets 3D en infographie.
25 / 53
I Simulations numériques (éléments 26 / 53

finis).
Opérations de base sur des vecteurs Opérations sur des vecteurs en C
I Convolution discrète.

Multiplication par un scalaire (xSCAL) Code

I Multiplication par un scalaire (xSCAL) 1 void vscale(int n, double *v, double
I v ← αv alpha)
{
v ← αv I Fonction BLAS de Niveau 1 :
2
3 for (int i=0;i<n;i++)
void cblas_dscal(int n,double alpha v[i]=alpha*v[i];
I Somme et soustraction 4
, double *v,int incx) 5 }
v ←x+y
Appel : cblas_dscal(n,alpha,v,1);
I Produit scalaire (xDOT)
s ← x> y Source : http://www.cise.ufl.edu/research/sparse/matrices/
Produit scalaire (xDOT) Code
I Cas général (xAXPY) 1 double vdot(int n , double *x,double
y ← αx + y I s ← x> y *y)
{
I Fonction BLAS de Niveau 1 :
2
I Complexité de toutes ces opérations : 3 double res=0;
double cblas_ddot(int n,double *x, 4 for (int i=0;i<n;i++)
T (n) = O(n), S(n) = O(n) int incx,double *y,int incy); 5 res+=x[i]*y[i];
Appel : 6 return res;
7 }
double s=cblas_ddot(n,x,1,y,1);

27 / 53 28 / 53
Exercice 3 : xAXPY Opérations matrice/vecteur
Code Exercice
1 void vaxpy(int n ,double alpha, Mise à jour de rang 1 (xGER)
double *x, double *y) I Compléter la fonction xAXPY à gauche.
A ← αxy> + A
2 { I On supose n déclaré et les vecteurs x et y
3
4
initialisés. I Avec α ∈ R, y ∈ Rn , x ∈ Rm et A ∈ Rm×n .
5 I Montrer que cette fonction permet I Complexité : T (n) = O(mn), S(n) = O(mn)
6 d’effectuer des sommes, soustractions et
7 I Cas particulier : A symétrique et x = y (xSYR).
multiplication par un scalaire :
8
9 I Somme y ← x + y : Produit matrice vecteur généralisé (xGEMV)
10 } I Soustraction y ← y − x :
y ← αAx + βy
I Mult. scalaire y ← αx :
I Avec α, β ∈ R2 , y ∈ Rm , x ∈ Rn et A ∈ Rm×n .
I Complexité :
I Cas particuliers :
I A symétrique (xSYMV).
I A bande (xSBMV).
I A triangulaire (xSTRMV).
Fonction BLAS de Niveau 1 :
void cblas_daxpy(int n,double alpha
29 / 53 30 / 53
, double *x,int incx,double *y,int
incy);
Mise à jour de rang 1 (xGER) Exercice 4 : Produit généralisé (xGEMV)
Appel :
cblas_daxpy(n,alpha,x,1,y,1); Code Exercice
1 void mgemv(int m, int n, double
alpha, double **A, double *x y ← αAx + βy
Implémentation Code
, double beta, double * y)
1 void mger(int m, int n, double alpha
2 { I α, β ∈ R2 , y ∈ Rm , x ∈ Rn et
, double **A, double *x, double
A ← αxy> + A 3
* y)
4
A ∈ Rm×n .
2 {
for (int i=0;i<m;i++)
5 I Compléter la fonction xGEMV à gauche.
I α ∈ R, y ∈ Rn , x ∈ Rm et
3
6
4 for (int j=0;j<n;j++) I Fonction BLAS de Niveau 1 :
A ∈ Rm×n . 5 A[i][j]+=alpha*x[i]*y[j];
7
8 void cblas_dgemv(CBLAS_ORDER order,
I Fonction BLAS de Niveau 1 : 6 }
9 CBLAS_TRANSPOSE TransA, int m, int n,
void cblas_dger( CBLAS_ORDER order, 10
double alpha, double *A, int lda,
int m, int n, double alpha, double 11
double *x, int incx, double beta,
12
*x, int incx, double *y, int incy, double *y, int incy);
13 }
double *A, int lda);
Appel :
Appel :
cblas_dgemv(CblasRowMajor,CblasNoTrans
cblas_dger(CblasRowMajor,m,n,alpha, ,m,n,alpha,&A[0][0],n,x,1,beta,y,1);
x,1,y,1,&A[0][0],n);

31 / 53 32 / 53
Opération matricielle généralisée (xGEMM) Opération matricielle généralisée (xGEMM)
Implémentation Code
Opération 1 void mgemm(int m, int n, int p,
double alpha, double **A, double
C ← αAB + βC
**B, double beta, double **C)
C ← αAB + βC
2 {
for (int i=0;i<m;i++)
I α, β ∈ R2 , C ∈ Rm×n , A ∈ Rm×p ,
3
for (int j=0;j<n;j++)
I α, β ∈ R2 , C ∈ Rm×n , A ∈ Rm×p , B ∈ Rp×n B ∈ Rp×n
4
5 {
I Complexité : T (n) = O(mnp), S(n) = O(mn) I Fonction BLAS de Niveau 1 : 6 C[i][j]=beta*C[i][j];
7 for (int k=0;k<p;k++)
void cblas_dgemm(CBLAS_ORDER Order,
8 C[i][j]+=alpha*A[i][k]*B[k][j];
Cas particuliers CBLAS_TRANSPOSE TransA, 9 }
CBLAS_TRANSPOSE TransB, int m, int 10 }
I A symétrique (xSYMM) n, int p, double alpha, double *A,
I A hermitienne (xHEMM) int lda, double *B, int ldb, double
beta, double *C, int ldc);
I A triangulaire (xTRMM)
Appel :
I B = A> (xSYRK)
cblas_dgemm(CblasRowMajor,
I C ← αAB> + ᾱBA> + βC (mise à jour symétrique xSYRK2) CblasNoTrans,CblasNoTrans,m,n,p,
alpha,&A[0][0],p,&B[0][0],n,beta,&C
[0][0],n);

33 / 53 34 / 53

Système d’équations linéaires Solutions des systèmes d’équations linéaires


 a1,1 x1 + a1,2 x2 + ... + a1,n xn = b1 Existence et unicité des solutions Exemple n = 3



 a2,1 x1 + a2,2 x2 + ... + a2,n xn = b2 Dépend de m, n et du rang de A :

 .. I m < n, il existe une infinité de solution.

. ⇔ Ax = b


 .. I A de rang < n il existe une infinité de solution.

 .
 I m = n et A de rang n, il existe une solution unique
am,1 x1 + am,2 x2 + ... + am,n xn = bm
I A de rang > n, il n’existe pas de solution
avec A ∈ Rm×n et b ∈ Rm .
→ solution des moindres carrés.
I On cherche le vecteur x de taille n satisfaisant
les m équations ci dessus. Résolution du système
I L’ensemble des solutions dépend des propriétés
I Cas particulier où m = n et A de rang n
de la matrice A.
I La résolution du système peut être I Solution unique :
particulièrement simple dans certains cas x? = A−1 b
particuliers (A diagonale, triangulaire). I Éviter l’inversion matricielle directe dès que possible
(matrices particulières).

35 / 53 36 / 53
LAPACK (Linear Algebra PACKage) LAPACK et interface C
Convention de nommage
I Nom des fonctions LAPACK : XMMAAA
Description
X type de données (même que pour BLAS).
I LAPACK est une bibliothèque Fortran qui MM type de matrice (GE générale, GB bande, SY symétrique, TR
fournit des fonctions de haut niveau en algèbre triangulaire, DI diagonale . . .
linéaire. AAA opération de taille 2-3 caractères.
I Bibliothèque d’accompagnement de BLAS I Type d’opérations AAA supportées :
utilisant les routines BLAS le plus possible. I Résolution de systèmes linéaires (SV).
I Interface C officielle : LAPACKE. I Moindres carrés (LS).
I Décomposition en valeurs/vecteurs propres EIG (TRD).
Fonctions proposées (Niveau 3) I Décomposition LU (TRF).
I Décomposition en valeur singulière SVD (BRD).
I Résolution de systèmes linéaires (cas général).
I Estimation des moindres carrés.
LAPACKE
I Factorisation de matrice (EIG, SVD, LU, QR).
I Bibliothèque officielle d’interface C.
I Nom des fonctions : LAPACKE xmmaa.
I Les tableaux définis dans le cours sont de type : LAPACK ROW MAJOR
37 / 53 38 / 53

Matrice A diagonale Matrice triangulaire

Résolution du système Résolution du système Matrice
 
I Soit A = L une matrice triangulaire inférieure. l1,1 0 ··· 0
I n équations indépendantes de la forme    l2,1 l2,2 ··· 0 
a1,1 0 ··· 0 I Le système linéaire peut être résolu  
ak,k xk = bk L= . .. .. .. 

 0 a2,2 ··· 0 
 composante par composante :  .. . . . 
 .. .. .. ..  ln,1 ln,2 ··· ln,n
I Solutions évidentes de la forme  . . . . 
b1
bk 0 0 ··· an,n x1 =
xk = l1,1 Système
ak,k
b2 − l2,1 x1
I Si ai,i = 0 et bi 6= 0 le système n’admet pas de solution. x2 = l1,1 x1 = b1
l2,2
P l2,1 x1 + l2,2 x2 = b2
I Si ai,i = 0 et bi = 0 le système admet une infinité de solutions. bk − k−1 i=1 lk,i xi ..
xk = .
lk,k
lk,1 x1 + · · · + lk,k xk = bk
Code Discussion
1 void diagsv(int n,double **A,double Exercice 5 : Solution
*b,double *x) I Complexité T (n) :
Trouver la solution x pour le système suivant
2 { I Complexité S(n) :    
3 for (int i=0;i<n;i++) 2 0 0 2 x=
x[i]=b[i]/A[i][i];
4
L= 4 −1 0  b= 3 
5 }
−6 1 −2 −7

39 / 53 40 / 53
Exercice 6 : Résolution de système triangulaire Matrice A générale : Pivot de Gauss
Code Exercice

1 void triinfsv(int n,double **L,  a1,1 x1 + a1,2 x2 + ... + a1,n xn = b1 (L1 )
double *b,double *x) −1 

x←L b  a2,1 x1 + a2,2 x2 + ... + a2,n xn = b2 (L2 )
2 { .. ..
3 avec L triangulaire inférieure. 
 . .


4
I Compléter la fonction triinfsv à gauche. am,1 x1 + am,2 x2 + ... + am,n xn = bm (Lm )
5
6 I Complexité T (n) : O(n2 )
I Effectuer des combinaisons linéaires des équations ne change pas le problème.
7
I Complexité S(n) : O(n2 )
8
I Le pivot de Gauss vise à utiliser des sommes pondérées des équations pour faire
9 I Serait-il possible de coder une résolution
10
disparaı̂tre les variables une à une.
plus efficace en mémoire qui utilise b pour
11
écrire la solution ? I A la fin, on trouve un système linéaire triangulaire simple à résoudre (O(n2 )) .
12
13 } I Première étape (colonne 1) : L2 ← L2 − a2,1
L ,
a1,1 1
. . ., Lm ← Lm −
am,1
a1,1
L1

a1,1 x1 + a1,2 x2 + ... + a1,n xn = b1

a2,1 a1,2 a2,1 a1,n a2,1
0 + (a2,2 − )x2 + ... + (a2,n − )xn = b2 − b1
a1,1 a1,1 a1,1
am,1 a1,2 am,1 a1,n am,1
0 + (am,2 − )x2 + ... + (am,n − )xn = bm − b1
a1,1 a1,1 a1,1

41 / 53 42 / 53

Exemple pivot de Gauss Pivot de Gauss en C

Résolution
Fonction Système
BLAS de niveau 3 (2linéaire
si B vecteur) Matrice augmentée
y − z = m×m   Implémentation simplifiée Code
I n = 3. B ← αA B +avec
−1 2x
A∈R
8 (L1 )
et B2∈ Rm×n
triangulaire 1 −1 8 1 void pivot(int n, double **A, double
−3x − y + 2z = −11 (L2 )  −3 −1 2 −11  *b)
void cblas_dtrsm(CBLAS_ORDER Order,CBLAS_SIDE Side, CBLAS_UPLO Uplo, A, b ← pivot(A, b)
−2x + y + 2z = −3 (L3 ) n, double alpha, double−3
CBLAS_TRANSPOSE TransA, CBLAS_DIAG Diag,int m, int
−2 1 2
*A,
2 {
3 for (int k=0;k<n-1;k++)
int lda, double *B, int ldb); { // k : colonne a mettre en
I A∈R
4
Itération 1   n×n
,b∈R n
Appel : cblas_dtrsm(CblasRowMajor,
3 CblasLeft,CblasLower,CblasNoTrans,
2 1 −1 8 echelon
L ← L + L 2x + y − z = 8 (L1 )
2 2
CblasNonUnit, 1
2 n, 1,1, &A[0][0], n,b, 1);  0 1/2 1/2 1  I Complexité T (n) : 5 for (int i=k+1;i<n;i++)
1 1 6 { // i : ligne mise a jour
L3 ← L3 + L1
y+ z=1 (L2 ) 0 2 1 5 I Pour résoudre le système linéaire : for (int j=k+1;j<n;j++)
2 2 7

2y + z = 5 (L3 ) 1. A, b ← pivot(A, b) 8 A[i][j]-=A[k][j]*A[i][k]/A[

k][k];
2. b ← A−1 b : inversion de matrice
9 // maj vec b
Itération 2   triangulaire. 10 b[i]-=A[i][k]*b[k]/A[k][k];
L3 ← L3 − 4L2 2x + y − z = 8 (L1 ) 2 1 −1 8
 0 1/2 1/2 1  I Résolution en C : 11 A[i][k]=0;// pivot mis a 0
1 1 12 }
y+ z =1 (L2 ) 0 0 −1 1 1 pivot(n,A,b); }
2 2 13
2 trisupsv(n,A,b,x); 14 }
−z = 1 (L3 )

La matrice est maintenant sous forme triangulaire.

43 / 53 44 / 53
Erreur numérique et implémentation Applications du pivot de Gauss
Erreur numérique et permutation Calcul de déterminant

I La méthode précédente traite les données lignes par lignes. I Le déterminant de A est égale au déterminant de la matrice triangulaire
(multiplication de ses éléments diagonaux).
I Attention à la propagation de l’erreur pour des flottants !
I Règles pour le calcul du déterminant :
I Erreur amplifiée lorsque le pivot est petit (division par le pivot).
I Multiplier une ligne par un scalaire multiplie le déterminant par un scalaire.
I En pratique on permute les lignes le long des itérations pour prendre le pivot I Permuter deux lignes multiplie le déterminant par −1.
ayant la valeur absolue maximum (Lapack retourne la permutation). I Ajouter à une ligne une combinaison linéaire des autres ne change pas le
déterminant.
Implémentation Lapack
Calcul de l’inverse d’une matrice
I Lapack implémente la résolution de système générale à l’aide d’une factorisation
LU (variante du pivot de Gauss). I On utilise une matrice augmentée [A|I] avec la matrice identité I.
I Fonction Lapack I Après triangualisation, on utilise une backsubstitution pour retrouver une matrice
int LAPACKE_dgesv( int matrix_order, int n, int nrhs, double*A, int lda, identité à gauche. La matrice augmentée devient [I|A−1 ].
int*ipiv, double*b, int ldb );
I nrhs nb. col de b. Calcul du rang d’une matrice
I ipiv permutations de lignes.
I Si une ligne nulle apparaı̂t le long des itérations, la matrice n’est pas inversible
Appel : (rank(A) < n).
LAPACKE_dgesv(LAPACK_ROW_MAJOR,n 1, &A[0][0],n,ipi, b,1); I Le rang de la matrice est le nombre de lignes non-nulles.
45 / 53 46 / 53

Linpack et HPLinpack Factorisation de matrice

I La résolution de système linéaire par pivot de Gauss a une complexité O(n3 ).
Principe
I Algorithme utilisé dans les systèmes de  benchmark  Linpack et HPLinpack
pour estimer la puissance de calcul des gros centres de calculs dans le monde. I On cherche à représenter A comme une multiplication de plusieurs matrices plus
simples (triangulaires).
I Un classement des centres de calculs mondiaux est disponible sur le site :
http://www.top500.org/ I Permet de résoudre de multiples systèmes linéaires plus efficacement.
I Meilleur interprétation des propriétés de A.
Ordres de grandeur (Juin 2015)

Machine Flops Factorisations classiques

PC perso, Intel Core i7 3.109 LU A = LU, où L triangulaire inférieure et U triangulaire supérieure.
Station de travail, Intel Xeon 12 coeurs 10.109
Station de travail, NVIDIA Titan X (Cuda) 2.1012 Cholesky A = LL> , pour A symétrique définie positive.
Centre de calcul de l’université de Nice 35.1012 QR A = QR, avec Q orthogonale et R triangulaire supérieure.
Total Exploration Production, France (rang 36) 2.1015
Vec. propres A = VDV> , où V orthonormale (vec. propres) et D diagonale (val.
National Super Computer Center in Guangzhou, China (rang 1) 33.1015
propres).
Cerveau humain (simulation temps réel) 37.1015
SVD A = UDV> , où U et V orthonormales et D diagonale.
Rappels : 109 (Giga), 1012 (Tera), 1015 (Peta)

47 / 53 48 / 53
Factorisation LU Factorisation de Cholesky
Principe
Principe
A = LU, avec A ∈ Rn×n , L ∈ Rn×n tri. inf. et U ∈ Rn×n tri. sup.
A = LL> , avec A ∈ Rn×n sym def. pos., L ∈ Rn×n tri. inf.
I Méthode proposée et étudiée par Alan Turing en 1948.
I Théorème d’existence : Si A est non singulière, il existe une décomposition LU. I Méthode proposée en 1924 par André-Louis Cholesky.

I Une généralisation permet d’utiliser une permutation des lignes : PA = LU I Matrices carrées définies positives mais généralisée aux matrices
complexes avec le transposé conjugué.
I On applique le pivot de Gauss sur ma matrice augmentée [A|I] pour trouver une
I Expression alt. : A = LDL> avec D diagonale et L unitaire.
matrice triangulaire supérieure [U|·].
I Complexité T (n) = n3
( O(n3 ) mais 2× plus efficace que LU).
I Complexité T (n) = 2n3
3
. 3

Résolution de systèmes linéaires Ax = b Résolution de systèmes linéaires Ax = b

I Ax = L(Ux) = b → Ly = b → Ux = y I Ax = L(L> x) = b → Ly = b → L> x = y
I x = U−1 L−1 b, soit deux systèmes linéaires triangulaires. I x = L>−1 L−1 b, soit deux systèmes linéaires triangulaires.

Implémentation Lapack : DGETRF Implémentation Lapack : DPPTRF

I Appel en C : I Appel en C :
int LAPACKE_dgetrf( int matrix_order, int m, int n, double*A, int lda, int int LAPACKE_dpptrf( int matrix_order, char uplo, int n, double*ap );
*ipiv ); I Utilisé pour la résolution de systèmes linéaire généralisés avec DPPTRS.
I Utilisé pour la résolution de systèmes linéaires généralisés avec DGESV.
49 / 53 50 / 53

Factorisation QR Factorisation SVD

Principe
Principe de la décomposition en valeurs singulières
A = QR> , avec Q ∈ Rn×n orthonormale, R ∈ Rn×n tri. sup.
A = UDV> avec A ∈ Rm×n U ∈ Rm×m V ∈ Rn×n othonormales, D ∈ Rm×n diag.
I Découverte indépendemment par John G. F. Francis en 1959, et Vera
Kublanovskaya en 1961. I A peut être une matrice quelconque m 6= n.
I Si A inversible alors factorisation unique. I D = diag(σ1 , . . . , σr ) avec r = min(m, n) contient les valeurs singulières.
I Factorisation d’une matrice rectangulaire avec m > n, alors les dernières lignes de I Calculée en effectuant plusieurs itérations de factorisation QR.
R sont nulles. I Complexité T (n) = km2 n + k0 n3 = O(n3 + m2 n) avec k = 4 et k0 = 22.
I Permet d’estimer le déterminant de A à partir du déterminant de R.
Approximation faible rang de la matrice A
I Complexité (Householder) T (n) = 23 n3 + n2 + 31 n − 2 = O(n3 ). La meilleur approximation de rang k < r de la matrice A obtenue par
Résolution de systèmes linéaires Ax = b e = UDV
A e > e = diag(σ1 , . . . , σk , 0, . . . , 0)
où D ( mise à 0 des σi après k)
I Ax = Q(Rx) = b → y = Q−1 b = Q> b → Rx = y
I x = R−1 Q> b, soit une multiplication et un système linéaire triangulaire. Implémentation Lapack : DGESVD
I Appel en C :
Implémentation Lapack : DGEQRF int LAPACKE_dgesvd( int matrix_order, char jobu, char jobvt,int m, int n,
I Appel en C : double*a, int lda, double*s, double*u, int ldu, double*vt, int ldvt,
int LAPACKE_dgeqrf( int matrix_order, int m, int n, double*a, int lda, double*superb );
double*tau );
51 / 53 52 / 53
Ressources bibliographiques I

I Rappels algèbre linéaire [3].

I Référence complète sur les matrices [2].
I Implémentation en C [4].
I Doc BLAS/LAPACK [1].

®
[1] “Reference manual for intel math kernel library - c,”
https://software.intel.com/en-us/mkl-reference-manual-for-c, version du
2015-11-16.
[2] G. H. Golub and C. F. Van Loan, Matrix computations. JHU Press, 2012, vol. 3.

[3] J. Grifone, Algebre linéaire. Cepadues-Editions, 1990.

[4] W. H. Press, S. A. Teukolsky, W. T. Vetterling, and B. P. Flannery, Numerical

recipies in C. Cambridge university press Cambridge, UK, 1992.

53 / 53