3.6.2 ´ Elimination gaussienne
3.9 Enjeux de complexit´e
b1 c1 0 ··· ··· 0 a2 b2 c2 0 ... 0 a3 . .. . .. . .. ... .. . 0 . .. . .. . .. 0 .. . . .. a n−1 bn−1 cn−1 0 ··· ··· 0 an bn , (3.136)
les ´el´ements non nuls de A peuvent ˆetre stock´es dans trois vecteurs a, b et c (un par diagonale descendante non nulle). Ceci permet d’´economiser de la m´emoire qui au-rait ´et´e utilis´ee de fac¸on inutile pour stocker les ´el´ements nuls de A. La factorisation LU devient alors extraordinairement simple avec l’algorithme de Thomas [42]. La fac¸on dont MATLAB g`ere les matrices creuses est expliqu´ee dans [70]. Un point critique quand on r´esout des syst`emes de grande taille est la fac¸on dont les ´el´ements non nuls de A sont stock´es. Des choix malvenus peuvent se traduire par des ´echanges intenses avec la m´emoire disque, ce qui peut ralentir l’ex´ecution de plusieurs ordres de grandeur. Des algorithmes (non pr´esent´es ici) sont disponibles pour r´eordonner les ´el´ements de matrices creuses de fac¸on automatique.
3.9 Enjeux de complexit´e
Une premi`ere mesure naturelle de la complexit´e d’un algorithme est le nombre des op´erations requises.
3.9.1 Compter les flops
En g´en´eral, on se borne `a compter les op´erations `a virgule flottante (ou flops). Pour les algorithmes finis, le comptage des flops est juste une question de compta-bilit´e.
Exemple 3.6.Multiplier deux matrices n× n g´en´eriques requiert O(n3) flops ; mul-tiplier une matrice n× n g´en´erique par un vecteur g´en´erique ne requiert que O(n2)
flops.
Exemple 3.7.Pour r´esoudre un syst`eme triangulaire sup´erieur avec l’algorithme de la section 3.6.1, il faut un flop pour obtenir xn par (3.31), trois flops de plus pour obtenir xn−1 par (3.32), ···, et 2n − 1 flops suppl´ementaires pour obtenir x1 par (3.33). Le nombre total de flops est donc
Exemple 3.8.Quand A est tridiagonale, (3.1) peut ˆetre r´esolue avec l’algorithme de Thomas (un cas particulier de la factorisation LU) en 8n− 6 flops [42]. Pour une matrice A g´en´erique n× n, le nombre de flops requis pour r´esoudre un syst`eme d’´equations lin´eaires se r´ev`ele beaucoup plus grand que dans les exemples 3.7 et 3.8 :
— la factorisation LU requiert 2n3/3 flops. La r´esolution de chacun des deux syst`emes triangulaires r´esultants pour obtenir la solution pour un seul membre de droite demande environ n2flops suppl´ementaires, de sorte que le nombre total de flops pour m membres de droite est environ(2n3/3) + 2mn2. — la factorisation QR requiert 4n3/3 flops, et le nombre total de flops pour m
membres de droite est(4n3/3) + 3mn2. — la SVD requiert(20n3/3) + O(n2) flops [49].
Remarque 3.21.Pour une matrice A g´en´erique n× n, les factorisations LU, QR et SVD requi`erent donc toutes O(n3) flops. On peut cependant les classer du point de vue du nombre de flops requis, avec LU< QR < SVD. Pour de petits probl`emes, chacune de ces factorisations est de toute fac¸on obtenue tr`es rapidement, de sorte que ces enjeux de complexit´e ne deviennent significatifs que pour des probl`emes de grande taille (ou des probl`emes r´esolus `a de nombreuses reprises par des algorithmes
it´eratifs).
Quand A est sym´etrique d´efinie positive, la factorisation de Cholesky s’applique, et ne requiert que n3/3 flops. Le nombre total de flops pour m membres de droite devient alors(n3/3) + 2mn2.
Le nombre de flops requis par des m´ethodes it´eratives d´epend du degr´e de creux de A, de la vitesse de convergence de ces m´ethodes (qui d´epend elle-mˆeme du probl`eme consid´er´e) et du degr´e d’approximation qu’on est prˆet `a tol´erer dans la r´esolution. Pour les solveurs de Krylov, le nombre maximum d’it´erations requis pour obtenir une solution exacte en l’absence d’erreurs d’arrondi est connu et ´egal `a dim x. C’est un avantage consid´erable sur les m´ethodes it´eratives classiques.
3.9.2 Faire faire le travail rapidement
Pour un syst`eme lin´eaire de grande taille, comme on en rencontre dans de vraies applications, le nombre de flops n’est qu’un ingr´edient parmi d’autres pour d´eterminer le temps n´ecessaire pour arriver `a une solution, car faire entrer et sor-tir les donn´ees pertinentes des unit´es arithm´etiques peut prendre plus de temps que l’ex´ecution des flops. Il faut noter que la m´emoire de l’ordinateur est in-trins`equement unidimensionnelle, tandis que A a deux dimensions. La fac¸on dont les tableaux `a deux dimensions sont transform´ees en objets `a une dimension pour tenir compte de ce fait d´epend du langage utilis´e. FORTRAN, MATLAB, Octave,
R et Scilab, par exemple, stockent les matrices denses par colonnes, tandis que C et Pascal les stockent par lignes. Pour les matrices creuses, la situation est encore plus diverse.
La connaissance et l’exploitation de la fac¸on dont les tableaux sont stock´es per-mettent d’acc´el´erer les algorithmes, car l’acc`es `a des ´el´ements contigus est rendu beaucoup plus rapide par l’utilisation de m´emoire cache.
Quand on utilise un langage interpr´et´e `a base de matrices, comme MATLAB, Oc-tave ou Scilab, il faut ´eviter, chaque fois que possible, de d´ecomposer des op´erations telles que (2.1) sur des matrices g´en´eriques en des op´erations sur les ´el´ements de ces matrices comme dans (2.2) car ceci ralentit consid´erablement les calculs.
Exemple 3.9.Soient v et w deux vecteurs choisis au hasard dans Rn. Le calcul de leur produit scalaire vTw par d´ecomposition en une somme de produit d’´el´ements, comme dans le script
vTw = 0; for i=1:n,
vTw = vTw + v(i)*w(i); end
prend plus de temps que son calcul par
vTw = v’*w;
Sur un MacBook Pro avec un processeur 2.4 GHz Intel Core 2 Duo et 4 Go de RAM, qui sera toujours utilis´e pour les mesures de temps de calcul, la premi`ere m´ethode prend environs 8 s pour n= 106, tandis que la seconde demande environ 0.004 s, de sorte qu’elle est `a peu pr`es 2000 fois plus rapide. La possibilit´e de modifier la taille d’une matrice M `a chaque it´eration s’av`ere elle aussi coˆuteuse. Chaque fois que possible, il est beaucoup plus efficace de cr´eer un tableau de taille appropri´ee une fois pour toute en incluant dans le script MATLAB une instruction comme M=zeros(nr,nc);, o`u nr est un nombre fix´e de lignes et nc un nombre fix´e de colonnes.
Quand on tente de r´eduire les temps de calcul en utilisant des processeurs gra-phiques (ou GPU, pour Graphical Processing Units) comme acc´el´erateurs, il faut se rappeler que le rythme avec lequel le bus transf`ere des nombres de ou vers un GPU est beaucoup plus lent que le rythme auquel ce GPU peut les traiter, et organiser les transferts de donn´ees en cons´equence.
Avec les ordinateurs personnels multicœurs, les acc´el´erateurs GPU, les proces-seurs embarqu´es `a grand nombre de cœurs, les clusters, les grilles et les supercalcu-lateurs massivement parall`eles, le paysage du calcul num´erique n’a jamais ´et´e aussi divers, mais la question de Gene Golub et Charles Van Loan [80] demeure :
Pouvons-nous occuper les unit´es arithm´etiques ultrarapides en leur livrant suffisamment de donn´ees sur des matrices et pouvons-nous r´eexp´edier les r´esultats vers la m´emoire suffi-samment vite pour ´eviter de prendre du retard ?