Génie de l’Eau GE3 / 2012-2013

Sophia Antipolis - 19 Novembre 2012

Résolution de systèmes linéaires de très grande taille
Présenté par :
B !"E# $arion %!"&% #'omas G()*!*% Emeline +,!& (# !nt'ony

!lain ( &"E##&-------------------------.#uteur a/adémi0ue

Ecole Polytechnique de l’Université de Nice – Sophia Antipolis POLYTE !’N" E#SOP!"A $éparte%ent !ydroin&or%atique et "n'énierie de l’Eau ()*+, route des Lucioles – -)*(- ."OT éde/ Tél0 1223-4*56277++- – 8a/ 1**3-4*56277+-6 – hydro9polytech0unice0&r – :::0polytech0unice0&r

........................................................... 5 6............ 4 3..................................2 3.............................%’autres mét'odes.......................&ntrodu/tion......................7our/es........................................................................................... 10 2 ......... 3 2......................Sommaire 1.......................3 2.................................................................................................................................................................... e /ode en langage + de la mét'ode de Gauss......+omparaison........................... e prin/ipe de la mét'ode de Gauss-1ordan..............................

1. a résolution de systèmes de très grande taille est très /ourante dans les domaines s/ienti.i/a/es de résolution. 7i le pro8lème /omporte n in/onnues: alors n é0uations linéairement indépendantes sont né/essaires pour toutes les déterminer. +’est pour0uoi il est important de /onna=tre une ou plusieurs mét'odes rapides: pré/ises et e.orman/es. Introduction )n système d’é0uations est un ensem8le de plusieurs é0uations /omprenant les m9mes in/onnues. !près a?oir présenté /ette mét'ode et son /ode: nous l’a?ons testé sur plusieurs e<emples et l’a?ons /omparé a?e/ les autres mét'odes dont le /ode nous était donné a.i0ues et /eu< de l’ingénierie.in d’é?aluer ses per. 3 .. &l en e<iste plusieurs telles 0ue la mét'ode de Gauss-1ordan: la dé/omposition de +'oles>i ou en/ore la dé/omposition de ). %ans notre /as: nous a?ons restreint notre étude au< systèmes linéaires et nous nous sommes intéressés plus parti/ulièrement @ la mét'ode de Gauss-1ordan /ar elle suit la mét'ode 0ue nous utilisons pour résoudre un système A @ la main B. e prin/ipe de la mét'ode de Gauss1ordan.

i/ients /onnus. Le principe de la méthode de Gauss-Jordan En général: on é/rit un système linéaire sous la .. e terme a11 est le pi?ot de l’étape de l’algorit'me..e/tuant les m9mes opérations sur les lignes du ?e/teur 8. En réitérant le pro/édé: on a8outit @ une matri/e triangulaire : En /al/ul numéri0ue: pour minimiser les erreurs d’arrondi: on /'oisit /omme pi?ot le terme le plus grand en ?aleur a8solue en é/'angeant des lignes: /e 0ui n’a pas 2 . Pour iE1 par e<emple: les trans.orme matri/ielle sui?ante : !<DB a?e/ a mét'ode de Gauss-1ordan est simple puis0u’elle retrans/rit /e 0ue nous .aut triangulariser la matri/e ! tout en e.2.ormations 1 i D i F ai1 a11 1 éliminent l’in/onnue <1 dans les lignes autres 0ue . %ans un premier temps: il .orme sui?ante : (C <i sont les in/onnues @ déterminer et am:n et 8m sont des /oe.aisons @ la main pour résoudre /e pro8lème. $ais pour un système de très grande taille: il est intéressant de l’é/rire sous la .

').cases!(double**) malloc(nbLigne*si"eo#(double*)).h> //&nitialisation des matri/es struct matrix { int nbLigne.cases&i'&. (n peut ainsi /onna=tre Gn 0ue l’on reporte dans la ligne n-a oC la seule in/onnue n’est plus 0ue G n-1 et/. } } 00 1onction 2ermutation 3 +ermet de +ermuter deux lignes dans une matrice 3 . }. } (oid matrix)##iche atrice(struct matrix *n+ut) { int i!$..nbColonne!nbColonne..nbColonne. #or(i!$. Le code en langage C de la méthode de Gauss #include<stdio.d’in.. int nbColonne) { struct matrix .nbLigne!nbLigne.luen/e sur le système. 3.i<*n+ut. En.. double **cases. En e.!$. } +rint#(-/n-).nbLigne.!$..cases&i'!(double*) malloc(nbColonne*si"eo#(double)). #or (i!$. nbColonne.<*n+ut.in: il reste @ résoudre : ann’ Gn D 8n’ .i< . struct matrix matrixCreation(int nbLigne.h> #include <stdlib.i%%) { .i%%) { #or(. . . } return . .%%) { +rint#(-.nbLigne.et: /ela re?ient seulement @ /'anger la pla/e de deu< é0uations dans le système.h> #include<math.*n+ut.lg . int i.

cases&*'&.*!i.cases&i%4'&$'* .i.%%) { .. . 00 )#in d6annuler les coe##icients sous le +i(ot } =.nbColonne. 00 ?n a++li8ue les m@mes calculs sur la matrice = } } 001onction A:solution du sBstCme (oid Aesolution(struct matrix .. 6 .nbLigne>4'&$'!=.'! .'* .struct matrix =. on la #ixe #or (i.!i.nbLigne>4.cases&Ligne4'&..')>max) { max!abs( .'! .'!.i< .<! . #or (i.'.cases&Ligne5'&.').'.i%%) 00?n +arcourt les lignes { tem+! .cases&i'&i'.int i) { int max.cases&i%4'&*'.'.'! .cases&i'&i'. 2ermutation(=. max! .cases&i%4'&$'!=. struct matrix =.cases&i'&. int .cases&i'&$'0 .%%) 002uis les colonnes { .(oid 2ermutation(struct matrix .!$.int Ligne4.). 2ermutation( .cases&i%4'&.cases&*'&*'>tem+* .i< .nbLigne'.cases&*'&$'. } } } 001onction de <auss 3 +ermet de #aire les calculs +our a(oir des ":ros sous la diagonale (oid <auss(struct matrix ..i%%) { i# (abs( ..nbLigne.nbLigne>4.em+&.'.em+& . D..int Ligne5) { 00 *nitialisation d6un tableau +our stoc7er tem+orairement une ligne de matrice 8ue l9on souhaite d:+lacer int .struct matrix =..em+&.< .. #or (. } } 001onction du +lus grand +i(ot 3 com+are les +i(ots et choisit le +lus grand coe##icient en (aleur absolue (oid 2lus<rand2i(ot(struct matrix .cases&*'&*'>tem+*=... 00* est la ligne du 2i(ot. #or (.struct matrix D) { int i! . .!*.cases&i'&.i..).int i) { int .cases&i%4'&.cases& .cases&Ligne5'&.nbLigne.tem+.cases&Ligne4'&.

<! . #or (. F.cases&$'&4'!5. <auss(F.cases&i'&$'>! .=. { 00Aem+lissage des matrices =.cases&$'&$'!H. D!matrixCreation(F.=.cases&5'&$'!>4.atrice = de d:+art/n-). F.cases&5'&5'!I.cases&4'&$'!>H. F.!i%4. struct matrix F. F. F.'&$'. struct matrix =.cases&i'&.atrice F de d:+art/n-).cases&5'&4'!5. } D. D.i>>) { D.cases&4'&5'!5.cases&i'&$'. =.%%) { D.cases&i'&$'!=. H . } } int main() { int n.cases&. F. int i.i).cases&$'&$'!$. D. sto+.4).cases&i'&$'0 .cases&4'&$'!$. timeJt start.cases&i'&i'.atrice F de #in/n-). +rint#(-Calcul du +i(ot en cours/n-). =.cases&i'&$'!D. +rint#(.nbLigne>4. matrix)##iche atrice(=).cases&$'&5'!>4.cases&4'&4'!4.cases&4'&$'!5.iE!>4. D. #or (i!$. } +rint#(. struct matrix D.nbLigne>4.cases&5'&$'!$. F.n).i<F.. F. start!time(FKLL). =!matrixCreation(F.nbLigne.cases&$'&$'!I. F.'*D. F!matrixCreation(n. matrix)##iche atrice(F)..i).cases&5'&$'!$. } 00*ci ce sont les sorties du +i(ot de <auss +rint#(.i%%) 002ermet de balaBer toutes les lignes { 2lus<rand2i(ot(F. +rint#(-/n-). n!G. +rint#(-/n-).#or (i!i>4.4).nbLigne.

=./n.em+s d6execution 3 . matrix)##iche atrice(D). (n notera les éléments de /es deu< matri/es de la manière sui?ante: Supposons maintenant que nous connaissons la factorisation LU de la matrice A. +rint#(-/n-). +rint#(.érieure ayant des 1 sur la diagonale et ) une matri/e triangulaire supérieure. 4 . +rint#(-Lolution du sBstCme 3 /n-). Ce système est rapide à résoudre. sto+!time(FKLL). Ainsi.D). +rint#(-/n. +rint#(-/n-). Voici l’algorithme pour trouver z. Aesolution(F.d s. Nous avons donc que Lz = b. D autres méthodes a . +rint#(-/n-)..(int)(sto+>start)).a/torisation ) /onsiste @ é/rire une matri/e non-singulière ! /omme le produit de deu< autres matri/es et ) .atrice = de #in/n-). dit la substitution avant. 4. return $. est une matri/e triangulaire in. car la matrice L est triangulaire inférieure. Posons z = U x. le système Ax = b peut se réécrire LU x = b. matrix)##iche atrice(=).} matrix)##iche atrice(F).

Comme nous l’avons mentionn é plus tôt. C’est ces opérations qui demandent plus grand temps de calcul à l’ordinateur. 5 . Ceci est la substitution arrière qui est la même que la deuxième partie de l’algorithme de Gauss. Comparaison Nombre d’opérations Nous obtenons ainsi le vecteur x.Algorithme de substitution avant Il ne reste plus que résoudre le système U x = z. ce qui est important de savoir pour comparer deux algorithmes. Algorithme de substitution arrière !. La première étape du pivot de Gauss-Jordan demande de transformer une matrice initial en une matrice triangulaire supérieure. l’addition et la soustraction sont beaucoup plus rapide. Il ne faut pas oublier que U est une matrice triangulaire supérieure. ce qui amène à multiplier les éléments de la matrice par des coefficients puis de soustraire les ligne entres elles. c’est le nombre de multiplication et de division demandé par chacun.

il y a autant d'opération que pour la méthode de Gauss-Jordan cependant la substitution avant est nettement simplifiée du fait de la position des 1 sur la diagonale évitant ainsi la division par ces coefficients à chaque ligne. Comptons le nombre d’opération de ces deux algorithmes./fatorisationLU. Pour la substitution arrière.umontreal.ca/.La deuxième étape (la substitution arrière) demande moins d'opération mais contient tout de même des multiplications/divisions. Il en résulte que le comptage des opérations nous permet de conclure que si nous connaissons la factorisation LU et que n est grand.espci. Sources www.dms.fr/_didier/fr/systemes/systemes.pdf www.pdf 10 .loa.. ". il est plus plus rapide d’utiliser la méthode de factorisation LU .. que la méthode de Gauss.