1

Pernod Erik ISITV Calcul scientifique 2ème année

Travaux

Pratiques

De

GSM

2

I - Méthodes itératives de calcul de valeur propre I.1 – Méthode de la puissance itérée I.1.1 – Principe…………………………………………………………………………3 I.1.2 – calcul théorique de la solution………………………………………………….5 I.1.3 – Algorithme……………………………………………………………………...6 I.1.4 – Points délicats…………………………………………………………………..7 I.1.5 – Résultats………………………………………………………………………...7 I.2 – Méthode de la déflation I.2.1 – Principe…………………………………………………………………………8 I.2.2 – calcul théorique de la solution………………………………………………….8 I.2.3 – Algorithme……………………………………………………………………...9 I.2.4 – Points délicats…………………………………………………………………10 I.2.5 – Résultats……………………………………………………………………….10 I.3 – Méthode de la puissance inverse I.3.1 – Principe………………………………………………………………………..11 I.3.2 – calcul théorique de la solution………………………………………………...11 I.3.3 – Algorithme…………………………………………………………………….12 I.3.4 – Points délicats…………………………………………………………………13 I.3.5 – Résultats……………………………………………………………………….13

II – Accélération d’une méthode itérative II.1 – Principe………………………………………………...……………………….15 II.2 – calcul théorique de la solution…………………………………..……………...15 II.3 – Algorithme……………………………………………………..……………….16 II.5 – Résultats………………………………………………………..……………….17 III – Programmes III – Programmes…………………………………………………………………….18

TP 2 : Méthodes de la puissance itérée et inverse.

Méthode de la déflation. Accélération d’une méthode itérative.

3

I - Méthodes itératives de calcul de valeur propre Dans plusieurs problèmes physiques ou mathématiques, il est souvent nécessaire de trouver les valeurs propres d’une matrice et les vecteurs propres associés. La méthode utilisée en classe préparatoire nécessite le calcul d’un déterminant de la matrice, soit un calcul très lourd en opération lorsque la matrice est de dimension élevée. C’est pourquoi, ce TP nous montre l’efficacité des méthodes itératives basées sur une suite de vecteurs qui tendent vers un vecteur propre. I.1 – Méthode de la puissance itérée I.1.1 – Principe La méthode de la puissance itérée est utilisée pour calculer la plus grande valeur propre et le vecteur propre associé d’une matrice A. Pour appliquer cette méthode la matrice A doit répondre à certaines contraintes : - A doit être symétrique - A doit être positive => A doit être diagonalisable - A doit être définie positive On prendra la matrice A de dimension A(n*n). Et on suppose qu’elle répond à toutes ces conditions et que ses valeurs propres sont toutes différentes. Ainsi A possède n valeurs propres : λ1, …, λn telles que |λ1| > |λ2| ≥ … ≥ |λn| . Soient u1, …, un les vecteurs propres associés. On pose x0 un vecteur de IRn de norme égale a 1 (ou quelconque) que l’on décompose de la façon suivante :

∑=

=n

iii uxx

10 .

On calcul la suite kk xAx .1 =+ de la façon suivante :

0.xAx kk =

∑=

=n

iii

kk uax

11 ..λ

En mettant knλ en facteur on obtient :

= ∑

=

n

iiik

n

kik

nk uax1

...λλλ

4

Or

kn

ki

λλ

tend vers 0 donc le terme prépondérant est : nnkn ua ..λ . Ainsi au bout de quelques

itérations on obtient la plus grande valeur propre :k

kn x

x 1+≈λ .

Et le vecteur propre associé : kn xu ≈ .

Si on se retrouve dans le cas où nλ est grand, il est nécessaire de normaliser la suite :

k

kk x

xx = (Ou alors en posant un nouveau vecteur). Le principe reste le même par la suite.

5

I.1.2 – calcul théorique de la solution A l’aide de la commande : « int(rand(0)*10+1-1))+1 » on peut créer une matrice composée d’entiers aléatoires compris entre 1 et 10. En la stockant dans un fichier texte il est possible de récupérer cette matrice sous maple pour effectuer le calcul exacte de ses valeurs propres et vecteurs propres :

> f := fopen( "E:\\--= ISITV 2A =--\\GSM\\TP2\\Résultats\\Matrices.n=3.dat",READ ): > n:=3: > all:=readdata(f,float,1): fclose(f): > for i from 1 to n do a[i]:=[seq(all[j+(i-1)*n],j=1..n)]: od: mat:=[seq(a[i],i=1..n)]: MAT:=convert(mat,Matrix);

:= MAT

1.0 6.0 2.09.0 6.0 5.04.0 9.0 9.0

> TransMAT:=transpose(MAT): > A:=evalm(MAT &* TransMAT);

:= A

41.00 55.00 76.0055.00 142.00 135.0076.00 135.00 178.00

> b:=eigenvects(A): for i from 1 to n do vecteur_propre[i]:=convert(b[i,3,1],Vector): valeur_propre[i]=b[i,1]: ordre[i]=b[i,2]: od;

:= vecteur_propre1

[ ], , ,-0.6277490352-0.16172968460.089339540380.7561700241

= valeur_propre1

60.51623271

= ordre1

1

:= vecteur_propre2

[ ], , ,0.41493115280.52446310150.63831153420.3812203799

= valeur_propre2

554.4875762

= ordre2

1

:= vecteur_propre3

[ ], , ,0.3400336327-0.83353038520.43220474710.05294603628

= valeur_propre3

5.574705411

= ordre3

1

:= vecteur_propre4

[ ], , ,-0.56403937490.063317153170.6306947660-0.5292207801

= valeur_propre4

6.421485127

= ordre4

1

6

I.1.3 – Algorithme

7

I.1.4 – Points délicats

• On constate que la fonction « random » du fortran se base très probablement sur l’horloge interne de l’ordinateur. Ainsi la matrice obtenue dans le programme est bien aléatoire la première fois, mais par la suite à chaque fois que le programme sera à nouveau exécuté la matrice sera la même.

I.1.5 – Résultats A l’aide des résultats de Maple et du programme fortran on obtient le tableau suivant :

Valeur calculée Valeur Maple Erreur Itérations n = 3 Valeur propre 326.756496 326.7564957 1.10-6

Vecteur propre

0.431310722 0.859088007

1.

0.3109430252 0.6193387056 0.7209257955

3.10-1 10

n = 4 Valeur propre 554.487577 554.4875762 1.10-5

Vecteur propre

0.414931153 0.524463101 0.638311535 0.38122038

0.4149311528 0.5244631015 0.6383115342 0.3812203799

1.10-8 12

n = 5 Valeur propre 637.704463 637.7044629 1.10-5

Vecteur propre

0.4503285 0.628512645

0.534645 0.18209227 0.288397688

0.4503285007 0.6285126446 0.5346449998 0.1820922705 0.2883976877

1.10-6 14

Constatations :

• Plus n est grand (taille de la matrice carrée n*n), plus il faut d’itérations pour obtenir la valeur propre la plus grande en module. Ce qui est évident. Mais le nombre d’itération reste très faible. (pour une matrice 40x10 il faut environ 185 itérations)

• Lorsqu’on augmente n la précision de la valeur propre obtenue diminue légèrement,

alors que la précision du vecteur propre augmente considérablement.

• Les résultats utilisés sont ceux obtenus avec la norme 2 car les vecteurs obtenus à l’aide de la norme infinie n’étaient pas précis. Cependant les valeurs propres obtenues par la norme infinie sont identiques à celles obtenues avec la norme 2.

8

• En utilisant les résultats du compteur inclus dans la boucle principale du calcul de la

puissance itérée. On remarque que l’utilisation de la norme infinie permet une convergence plus rapide de la méthode.

I.2 – Méthode de la déflation I.2.1 – Principe Considérons la matrice A utilisée dans la partie précédente. On applique une première fois la méthode de la puissance itérée sur cette matrice. Ainsi on obtient la valeur propre la plus grande en module. On suppose qu’il s’agit de la valeur propre : λ1 et du vecteur propre u1 A présent on veut trouver les valeurs propres restantes soient : λ2, …, λn. L’idée consiste donc a créer une matrice B qui a pour valeur propre : 0, λ2, …, λn-1. Soit :

111 uuAB tλ−= Puis on applique la méthode de la puissance itérée à cette nouvelle matrice, on obtient la deuxième plus grande valeur propre et son vecteur propre associé. Puis pour obtenir toutes les autres valeurs propres il suffit de réitérer ce procédé en recréant à chaque fois la matrice B. I.2.2 – calcul théorique de la solution Dans la partie précédente, les commandes Maple permettaient d’obtenir l’ensemble des valeurs propres et des vecteurs propres de la matrice. On dispose donc déjà de tous les résultats théoriques nécessaires pour cette partie.

9

I.2.3 – Algorithme

10

I.2.4 – Points délicats

• Seul point délicat : le passage de la méthode itérée en subroutine nécessite de la rigueur au niveau des variables.

I.2.5 – Résultats A l’aide des résultats de Maple et du programme fortran on obtient le tableau suivant. On prendra n=4. La précision étant sensiblement la même pour différentes valeurs de n.

Valeur calculée Valeur Maple Erreur Itérations Valeur propre 554.487577 554.4875762 1.10-6

Vecteur propre

0.414931153 0.524463101 0.638311535 0.38122038

0.4149311528 0.5244631015 0.6383115342 0.3812203799

1.10-8 12

Valeur propre 60.5162327 60.5162327 1.10-7

Vecteur propre

-0.627749034 -0.161729684 0.0893395386 0.756170025

-0.6277490352 -0.1617296846 0.08933954038 0.7561700241

1.10-8 11

Valeur propre 6.42148515 6.421485127 1.10-7

Vecteur propre

0.564039366 -0.063317129 -0.630694778 0.529220778

0.5640393749 -0.06331715317 -0.6306947660 0.5292207801

1.10-7 138

Valeur propre 5.57470539 5.574705411 1.10-7

Vecteur propre

0.340033649 -0.833530387 0.432204729 0.0529460522

0.3400336327 -0.8335303852 0.4322047471 0.05294603628

1.10-7 2

Constatations :

• Pour une matrice de taille n donné, le nombre d’itérations pour déterminer la valeur propre ne dépend pas de la grandeur de cette valeur propre. Comme le montre cet exemple, la variation du nombre d’itérations d’une valeur propre à une autre est énorme.

• L’utilisation de la méthode de la déflation n’entraîne pas de perte de précision bien

que le calcul d’une valeur propre nécessite l’utilisation des valeurs propres précédentes qui comportent déjà une erreur de calcul.

11

I.3 – Méthode de la puissance inverse I.3.1 – Principe La méthode de la puissance itérée est utilisée pour calculer la plus petite valeur propre (en module) et le vecteur propre associé d’une matrice A. En constatant que la valeur propre la plus grande en module pour A correspond à la valeur propre la plus petite en module pour la matrice A-1. On en déduit que cette méthode consiste donc à appliquer la puissance itérée à la matrice A-1 I.3.2 – calcul théorique de la solution Dans cette partie on ne détaillera pas la discrétisation du problème de la plaque du TP1. Seul la matrice A de ce TP nous intéresse. En reprenant la partie concernant la création de cette matrice dans le programme du TP1 et en la stockant dans un fichier .doc on peut, comme pour la puissance itérée, calculer les valeurs propres de cette matrice :

Dans cet exemple, N = M = 3 (Matrice(NxM,NxM)). h = k = 1/(N+1) = 0.25

> f := fopen( "E:\\--= ISITV 2A =--\\GSM\\TP2\\Résultats\\Matrice.exo2.dat",READ ): > n:=9: > all:=readdata(f,float,1): fclose(f): > for i from 1 to n do a[i]:=[seq(all[j+(i-1)*n],j=1..n)]: od: mat:=[seq(a[i],i=1..n)]: A:=convert(mat,Matrix);

:= A

64.0 -16.0 0. -16.0 0. 0. 0. 0. 0.-16.0 64.0 -16.0 0. -16.0 0. 0. 0. 0.

0. -16.0 64.0 0. 0. -16.0 0. 0. 0.-16.0 0. 0. 64.0 -16.0 0. -16.0 0. 0.

0. -16.0 0. -16.0 64.0 -16.0 0. -16.0 0.0. 0. -16.0 0. -16.0 64.0 0. 0. -16.00. 0. 0. -16.0 0. 0. 64.0 -16.0 0.0. 0. 0. 0. -16.0 0. -16.0 64.0 -16.00. 0. 0. 0. 0. -16.0 0. -16.0 64.0

> b:=eigenvects(A): for i from 1 to n do vecteur_propre[i]:=convert(b[i,3,1],Vector): valeur_propre[i]=b[i,1]: ordre[i]=b[i,2]: od;

12

I.3.3 – Algorithme

13

I.3.4 – Points délicats

• Seul point délicat : le passage du gradient conjugué en subroutine nécessite de la rigueur au niveau des variables. On constate également qu’il n’est pas possible d’utiliser la déflation sur la puissance inverse. Puisque c’est la plus petite valeur qui est calculé en première.

I.3.5 – Résultats A l’aide des résultats de Maple et du programme fortran on obtient le tableau suivant :

Itérations Valeur calculée Valeur Maple Erreur

P. Inverse Gradient n = 2 Valeur propre 18. 17.99999999 1.100

Vecteur propre

0.5 0.5 0.5 0.5

-0.4999999995 -0.4999999999 -0.4999999991 -0.4999999999

1.10-2 32 98

n = 3 Valeur propre 18.745166 18.74516606 1.10-6

Vecteur propre

0.25 0.353553391

0.25 0.353553391

0.5 0.353553391

0.25 0.353553391

0.25

0.24999999994 0.3535533901 0.25000000001 0.3535533903

0.5 0.3535533903 0.25000000009 0.3535533915 0.2500000006

1.10-8 29 159

n = 4 Valeur propre 19.0983006 19.0983006 1.10-7

Vecteur propre

0.138196601 0.223606798 0.223606798 0.138196601 0.223606798 0.361803399 0.361803399 0.223606798 0.223606798 0.361803399 0.361803399 0.223606798 0.138196601 0.223606798 0.223606798 0.138196601

.1381966013

.2236067980

.2236067980

.1381966014

.2236067980

.3618033997

.3618033990

.2236067978

.2236067975

.3618033982

.3618033990

.2236067985

.1381966005

.2236067965

.2236067986

.1381966022

1.10-9 27 176

14

Constatations :

• Plus n est grand (taille de la matrice carrée n*n), plus il faut d’itérations pour obtenir la valeur propre la plus grande en module. Ce qui est évident. Mais le nombre d’itération reste très faible. (pour une matrice 40x10 il faut environ 185 itérations)

• Lorsqu’on augmente n la précision de la valeur propre obtenue diminue légèrement,

alors que la précision du vecteur propre augmente considérablement.

• Les résultats utilisés sont ceux obtenus avec la norme 2 car les vecteurs obtenus à l’aide de la norme infinie n’étaient pas précis. Cependant les valeurs propres obtenues par la norme infinie sont identiques à celles obtenues avec la norme 2.

15

II – Accélération d’une méthode itérative II.1 – Principe On cherche à comparer la vitesse d’une méthode itérative de résolution de système avant et après accélération. On se donne le système suivant :

cxAx kk +=+ .1 Avec 1<A

Ainsi on utilise : := MAT

0.98 0.001 0.0010.001 0.5 0.0010.001 0.001 0.3 et

:= C

555

La solution est telle que : cxAx += . Le principe de l’accélération est de calculer par la méthode de la puissance itérée la valeur

propre la plus grande en module λ1 et son vecteur propre correspondant1er

.

Ainsi on pose : 111

11 ,

,e

ee

eccc

rrr

rrr −=

Et comme dans le principe de la déflation, on remplace la valeur propre λ1 par un 0 dans la matrice A :

111 eeAB tλ−=

Le nouveau système donne : 11 . cyBy kk +=+

Avec solution de la forme : k

n

k k

k ey ∑= −

=2 1 λ

α

Ainsi la solution du problème initiale sera : 11

1

1

,e

ecyx

rr

λ−+=

II.2 – calcul théorique de la solution A l’aide de maple il est impossible de trouver la solution du système « x = A.x + c » à l’aide d’une simple commande. Il faudrait passer également par un programme de résolution. Il n’y a donc pas vraiment d’intérêt de comparer la précision de maple à celle du fortran. D’autant plus que les résultats obtenus sont a chaque fois les même (cf. partie résultat plus loin).

16

II.3 – Algorithme

17

II.4 – Résultats

Méthode normale Méthode accélérée Norme 2 Norme infinie Norme 2 Norme infinie

Précision 1.10-8 Nombre

d’itérations 993 993

30 36

30 36

Vecteur solution 250.901657 10.5168359 7.51631213

250.901657 10.5168359 7.51631213

250.901657 10.5168359 7.51631213

250.903295 10.5168394 7.51631455

Précision 1.10-4 Nombre

d’itérations 537 537

17 22

17 22

Vecteur solution 250.896793 10.5168258 7.51630496

250.896793 10.5168258 7.51630496

250.90175 10.5168568 7.51631237

250.903387 10.5168602 7.51631478

Constatations :

• Comme attendu on constate que l’accélération de la méthode est vraiment impressionnante. Pour une matrice de taille (3x3), la méthode normale demande presque 1000 itérations alors qu’en utilisant le principe de l’accélération on arrive à 30 itérations pour la résolution du système en comptant 36 itérations en plus pour trouver la valeur propre de la matrice. Soit environ 70 itérations contre 1000.

• L’utilisation de la norme 2 plutôt que celle infinie ne change pas le nombre

d’itérations mais uniquement la précision du vecteur solution. On constate qu’en accélérant la méthode (ce qui signifie utiliser la puissance itérée) provoque une erreur de l’ordre de 1.10-4 sur le vecteur solution.

• En réduisant la précision demandé on peut voir que le nombre d’itérations reste

proportionnel : environ 40 (accéléré) pour 500 (normale).

18

III – Programmes III.1 – Méthode de la puissance itérée et déflation c ********************************************* ********************* c | | c | TP2 : Exo 1 :M‚thode de la puissance it‚r‚e | c | & Deflation | c | | c ********************************************* ********************* c PROGRAM Puissance_iteree c c --- D‚claration --- c INTEGER i,j,k,N,dim,choix DOUBLE PRECISION A,AT,PRO,lambda,Vpro,B,precision PARAMETER (dim=1000) DIMENSION A(dim,dim), AT(dim,dim),PRO(dim,dim),Vpro(dim), & B(dim,dim) c OPEN(UNIT=69, FILE='Matrices.dat',STATUS='UNKNOWN') OPEN(UNIT=17, FILE='Resultat.dat',STATUS='UNKNOWN') c c --- Formulaire --- c WRITE(*,*)'TP2 : Methode de la puissance iteree' WRITE(*,*) 10 WRITE(*,*)'Taille de la matrice A(NxN), saisir N :' READ(*,*)N c c WRITE(*,*)'Choix de la norme :' WRITE(*,*)'1 = norme 2' WRITE(*,*)'2 = norme infinie' READ(*,*)choix c c IF(N.gt.dim)THEN WRITE(*,*)'N est trop grand, rejouez...' GOTO 10 ENDIF c c WRITE(*,*)'Precision demandee : (entre 0.1 et 1*10^-8)' READ(*,*)precision c c c --- Cr‚ation des matrices A et AT --- c CALL MAT(N,dim,A,AT) !cr‚ation de A et de sa transpos‚e c CALL PROMAT(N,dim,A,AT,PRO) !calcul de AxTA c !Impression du tout dans le fichier matrices.dat WRITE(69,*)'Matrice A, ,Transposee, ,Produit AxTA'

19

WRITE(69,*) WRITE(69,*) c DO i=1,N DO j=1,N WRITE(69,*)A(i,j),' ',AT(i,j),' ',PRO(i,j) ENDDO ENDDO c c |---------------| c |-- Deflation --| c |---------------| c c CALL METHODE_ITEREE(N,dim,PRO,choix,lambda,Vpro,precision) c !appel de la methode it‚r‚e, on recupere la premiere valeur c !propre et le premier vecteur propre WRITE(17,*)'1er vecteur propre :' DO i=1,N WRITE(17,*)Vpro(i) ENDDO WRITE(17,*) WRITE(17,*)'1ere valeur propre :' WRITE(17,*)lambda WRITE(17,*) WRITE(17,*) c c DO k=2,N c DO i=1,N DO j=1,N PRO(i,j)=PRO(i,j)-lambda*Vpro(i)*Vpro(j) ENDDO ENDDO c CALL METHODE_ITEREE(N,dim,PRO,choix,lambda,Vpro,precision) c WRITE(17,*)k,'eme vecteur propre :' DO i=1,N WRITE(17,*)Vpro(i) ENDDO WRITE(17,*) WRITE(17,*)k,'eme valeur propre :' WRITE(17,*)lambda WRITE(17,*) WRITE(17,*) ENDDO c close(17) close(69) END c c ********************************************* ********************* c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c METHODE DE LA PUISSANCE ITEREE c SUBROUTINE METHODE_ITEREE(N,dim,PRO,choix,lambda,Vpro,precision)

20

c INTEGER i,dim,N,choix,cpt DOUBLE PRECISION Xk,Xkk,erreur,PRO,AXk,AQk,norme,Qk,lambda,vpro & ,precision DIMENSION PRO(dim,dim),AXk(dim),AQk(dim),Xk(dim),Xkk(dim),Qk(dim) & ,Vpro(dim) c c Initialisation : c c DO i=1,N !on veut q0 non orthgonal a e1 => q0=e1 Xk(i)=i ENDDO c cpt=0 c c c It‚rations : c erreur=1 DOWHILE (erreur.gt.precision) c CALL PROVECT(N,dim,PRO,Xk,AXk) c c DO i=1,N Xkk(i)=AXk(i) ENDDO c c CALL NORME_VECT(N,dim,Xkk,choix,norme) c c DO i=1,N Qk(i)=Xkk(i)/norme Xk(i)=Qk(i) ENDDO c c CALL PROVECT(N,dim,PRO,Qk,AQk) c CALL TEST_ARRET(N,dim,AQk,Qk,erreur) c cpt=cpt+1 c ENDDO c c c Affichage des solutions c WRITE(*,*)'Vecteur propre :' DO i=1,N WRITE(*,*)Qk(i) ENDDO WRITE(*,*) WRITE(*,*)'Valeur propre :' WRITE(*,*)AQk(1)/Qk(1) c DO i=1,N Vpro(i)=Qk(i)

21

ENDDO lambda=AQk(1)/Qk(1) c WRITE(*,*) WRITE(*,*)cpt WRITE(*,*) c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c CREATION DE LA MATRICE A ET DE LA TRANSPOSEE c SUBROUTINE MAT(N,dim,A,AT) c INTEGER i,j,dim,N,L0,L1 DOUBLE PRECISION A,AT DIMENSION A(dim,dim),AT(dim,dim) c L0=1 L1=10 c DO i=1,N DO j=1,N A(i,j)=int(rand(0)*(L1+1-L0))+L0 ENDDO ENDDO c DO i=1,N DO j=1,N AT(i,j)=A(j,i) ENDDO ENDDO c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c PRODUIT MATRICE x MATRICE c SUBROUTINE PROMAT(N,dim,A,AT,PRO) c INTEGER i,j,k,N,dim DOUBLE PRECISION A,AT,PRO DIMENSION A(dim,dim),AT(dim,dim),PRO(dim,dim) c DO i=1,N DO j=1,N DO k=1,N PRO(i,j)=PRO(i,j)+A(i,k)*AT(k,j) ENDDO ENDDO ENDDO c RETURN END

22

c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c PRODUIT MATRICE x VECTEUR c SUBROUTINE PROVECT(N,dim,A,vect,AK) c INTEGER i,j,N,dim DOUBLE PRECISION A,AK,vect DIMENSION A(dim,dim),AK(dim),vect(dim) c DO i=1,N AK(i)=0 DO j=1,N AK(i)=AK(i)+A(i,j)*vect(j) ENDDO ENDDO c c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c CALCUL DE LA NORME (2 ou infinie) c SUBROUTINE NORME_VECT(N,dim,V,choix,norme) c INTEGER i,N,dim,choix DOUBLE PRECISION V,norme,tp DIMENSION V(dim) c norme=0 tp=0 c IF(choix.eq.1)THEN !norme 2 DO i=1,N norme=norme+V(i)*V(i) ENDDO norme=sqrt(norme) c ELSEIF(choix.eq.2)THEN !norme infinie norme=V(1) DO i=2,N IF(V(i).gt.norme)THEN norme=V(i) ENDIF ENDDO ELSE WRITE(*,*)'mauvaise selection de la norme' WRITE(*,*) ENDIF c c RETURN END c c ------------------------------------------------------------------

23

c c ------------------------------------------------------------------ c TEST D ARRET c SUBROUTINE TEST_ARRET(N,dim,AK,vect,erreur) c INTEGER i,N,dim DOUBLE PRECISION AK,vect,pif,erreur DIMENSION AK(dim),vect(dim) c erreur=0 DO i=1,N pif=abs(Ak(i)/vect(i)-Ak(1)/vect(1)) IF(pif.gt.erreur)THEN erreur=pif ENDIF ENDDO c c RETURN END

24

III.2 – Méthode de la puissance inverse c ********************************************* ********************* c | | c | TP2 : Exo 2 : M‚thode de la puissance inverse | c | sur la matrice du TP1 | c | | c ********************************************* ********************* c PROGRAM RESOLUTION_NUMERIQUE c c c --- Declarations --- c c INTEGER i,j,z,N,M,choix,dim PARAMETER (dim=1000) DOUBLE PRECISION h,k,D0,D1,d2,D_1,D_2,A,lambda,Vpro, & precision DIMENSION D0(dim),D1(dim),d2(dim),D_1(dim),D_2(dim),A(dim,dim), & Vpro(dim) c OPEN(UNIT=15, FILE='Matrice.exo2.dat',STATUS='UNKNOWN') OPEN(UNIT=17, FILE='exo2.resultats.dat',STATUS='UNKNOWN') c c c c --- Initialisation --- c 10 DO i=1,10 !espacement pour le redemarrage du programme WRITE(*,*) ENDDO c c c c --- Formulaire --- c !initialisation par l'utilisateur WRITE(*,*)'TP 2 exo 2' 20 WRITE(*,*) WRITE(*,*)'Rentrez la valeur de N: (discretisation de a=1)' READ(*,*)N WRITE(*,*)'Rentrez la valeur de M: (discretisation de b=1)' READ(*,*)M WRITE(*,*) c IF(M.gt.N)THEN !alors dim(blocs) > dim(T(x,y)) WRITE(*,*)'Vous avez tapez un N plus petit que M' WRITE(*,*)'0 = Intervertir N et M' WRITE(*,*)'1 = Rentrer des nouvelles valeurs de N et M' READ(*,*)choix c IF(choix.EQ.0)THEN !On interventi N et M z=M M=N N=z ELSEIF(choix.EQ.1)THEN GOTO 20 !Retour … la saisi de N et M ELSE GOTO 10 !Retour au d‚but du programme

25

ENDIF ENDIF c c c c IF(M*N.gt.dim)THEN !test sur la dimension des vecteurs WRITE(*,*)'M*N>5000 : trop grand! rejouez...' GOTO 10 !Retour au d‚but du programme ENDIF c c !calcul des pas de discr‚tisation : h=1.d0/(N+1) k=1.d0/(M+1) c c WRITE(*,*)'Choix de la norme :' WRITE(*,*)'1 = norme 2' WRITE(*,*)'2 = norme infinie' READ(*,*)choix c c c c WRITE(*,*)'Precision demandee : (entre 0.1 et 1*10^-8)' READ(*,*)precision c c c c --- Corps du programme --- c c ---Cr‚ation et Remplissage de la matrice A --- c DO i=1,M*N !remplissage des vecteurs colonne D0(i)=2*(1/(h*h)+1/(k*k)) D1(i)=-1/(k*k) D_1(i)=-1/(k*k) D_2(i)=-1/(h*h) D2(i)=-1/(h*h) ENDDO c DO i=1,N-1 !attribution des 0 venant des blocs In D_1(i*M)=0 D1(i*M)=0 ENDDO c c c !cr‚ation de la matrice A DO i=1,N*M !remplissage par des 0 par d‚faut DO j=1,N*M A(i,j)=0 ENDDO ENDDO c DO i=1,N*M !diagonale 0 A(i,i)=D0(i) ENDDO c DO i=1,N*M-1 !diagonale -1 et 1 A(i,i+1)=D1(i)

26

A(i+1,i)=D_1(i) ENDDO c DO i=1,N*M-N !diagonale -2 et 2 A(i,M+i)=D2(i) A(M+i,i)=D_2(i) ENDDO DO i=1,N*M DO j=1,N*M WRITE(15,*)A(i,j) ENDDO ENDDO c c c c c --- Deflation --- c c c CALL METHODE_INVERSE(N,M,dim,A,choix,lambda,Vpro,precision) c !appel de la methode it‚r‚e, on recupere la premiere valeur c !propre et le premier vecteur propre WRITE(17,*)'valeur propre de plus petit module :' WRITE(17,*)lambda WRITE(17,*) WRITE(17,*) WRITE(17,*)'Vecteur propre correspondant' DO i=1,N*M WRITE(17,*)Vpro(i) ENDDO WRITE(17,*) WRITE(17,*) c c DO z=2,N*M c DO i=1,N*M DO j=1,N*M A(i,j)=A(i,j)-lambda*Vpro(i)*Vpro(j) ENDDO ENDDO c CALL METHODE_INVERSE(N,M,dim,A,choix,lambda,Vpro,precision) c WRITE(17,*)z,'eme vecteur propre :' DO i=1,N*M WRITE(17,*)Vpro(i) ENDDO WRITE(17,*) WRITE(17,*)z,'eme valeur propre :' WRITE(17,*)lambda WRITE(17,*) WRITE(17,*) ENDDO c close(17) close(15) END

27

c c c ********************************************* ********************* c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c METHODE DE LA PUISSANCE INVERSE c SUBROUTINE METHODE_INVERSE(N,M,dim,A,choix,lambda,Vpro,precision) c INTEGER i,dim,N,M,choix,cpt,cptgrad DOUBLE PRECISION Xk,Xkk,erreur,AQk,norme,Qk,lambda,vpro & ,precision,A DIMENSION A(dim,dim),AQk(dim),Xk(dim),Xkk(dim),Qk(dim) & ,Vpro(dim) c c Initialisation : c c DO i=1,N*M !on veut q0 non orthgonal a e1 => q0=e1 Xk(i)=i ENDDO c cpt=0 cptgrad=0 c c It‚rations : c erreur=1 DOWHILE (erreur.gt.precision) c CALL METHODE_GRAD(N,M,dim,A,Xk,Xkk,cptgrad) c c c CALL NORME_VECT(N,M,dim,Xkk,choix,norme) c c DO i=1,N*M Qk(i)=Xkk(i)/norme Xk(i)=Qk(i) ENDDO c c CALL PROVECT(N,M,dim,A,Qk,AQk) c CALL TEST_ARRET(N,M,dim,AQk,Qk,erreur) c cpt=cpt+1 ENDDO c c DO i=1,N*M Vpro(i)=Qk(i) ENDDO lambda=AQk(1)/Qk(1) c WRITE(*,*) WRITE(*,*)cpt WRITE(*,*)'compteur gradient :',cptgrad

28

WRITE(*,*) c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c PRODUIT MATRICE x VECTEUR c SUBROUTINE PROVECT(N,M,dim,A,vect,AK) c INTEGER i,j,N,M,dim DOUBLE PRECISION A,AK,vect DIMENSION A(dim,dim),AK(dim),vect(dim) c DO i=1,N*M AK(i)=0 DO j=1,N*M AK(i)=AK(i)+A(i,j)*vect(j) ENDDO ENDDO c c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c CALCUL DE LA NORME (2 ou infinie) c SUBROUTINE NORME_VECT(N,M,dim,V,choix,norme) c INTEGER i,N,M,dim,choix DOUBLE PRECISION V,norme DIMENSION V(dim) c norme=0 c IF(choix.eq.1)THEN !norme 2 DO i=1,N*M norme=norme+V(i)*V(i) ENDDO norme=sqrt(norme) c ELSEIF(choix.eq.2)THEN !norme infinie norme=V(1) DO i=2,N IF(V(i).gt.norme)THEN norme=V(i) ENDIF ENDDO ELSE WRITE(*,*)'mauvaise selection de la norme' WRITE(*,*) ENDIF c c RETURN

29

END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c TEST D ARRET c SUBROUTINE TEST_ARRET(N,M,dim,AK,vect,erreur) c INTEGER i,N,M,dim DOUBLE PRECISION AK,vect,pif,erreur DIMENSION AK(dim),vect(dim) c erreur=0 DO i=1,N*M pif=abs(Ak(i)/vect(i)-Ak(1)/vect(1)) IF(pif.gt.erreur)THEN erreur=pif ENDIF ENDDO c c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c METHODE DU GRADIENT CONJUGUE c SUBROUTINE METHODE_GRAD(N,M,dim,A,Xk,Xkk,cptgrad) c INTEGER i,j,cpt,N,M,dim,cptgrad,cpt1 DOUBLE PRECISION A,Xk,Xkk,rk,rkk,AXk,F,dk,ADk,scal1,scal2,alphak, & erreur1,erreur2,Bk DIMENSION A(dim,dim),Xk(dim),Xkk(dim),rk(dim),dk(dim),F(dim), & AXk(dim),ADk(dim),rkk(dim) c c c -- Initialisation -- c c DO i=1,N*M F(i)=Xk(i) ENDDO c cpt1=0 erreur1=1 !valeur par defaut de l'erreur pour lancer le prog c c -- Programme -- DOWHILE (erreur1.gt.0.000000000000001) c erreur1=0 c c c !cr‚ation du vecteur A.Xk => AXk DO i=1,N*M AXk(i)=0 DO j=1,N*M AXk(i)=AXk(i)+A(i,j)*Xk(j)

30

ENDDO ENDDO c IF(cpt1.eq.0)THEN DO i=1,N*M !calcul de rk rk(i)=F(i)-AXk(i) ENDDO c c C WRITE(*,*) AXk(1), rk(1) DO i=1,N*M !egalit‚ entre r0 et d0 dk(i)=rk(i) ENDDO ENDIF c c !cr‚ation du vecteur A.dk => ADk DO i=1,N*M ADk(i)=0 DO j=1,N*M ADk(i)=ADk(i)+A(i,j)*dk(j) ENDDO ENDDO c CALL SCALAIRE(rk,dk,dim,scal1) !calcul des produits scalaires CALL SCALAIRE(ADk,dk,dim,scal2) c alphak=scal1/scal2 !calcul de alphak c DO i=1,N*M Xkk(i)=Xk(i)+alphak*dk(i) !calcul de Xk+1 rkk(i)=rk(i)-alphak*ADk(i) !calcul de rk+1 c c erreur2=abs(Xkk(i)-Xk(i)) !calcul de l'erreur a chaque i IF(erreur2.gt.erreur1)THEN erreur1=erreur2 !on stock la + grande erreur des i ENDIF ENDDO c c CALL SCALAIRE(rkk,ADk,dim,scal1)!calcul des produits scalaires CALL SCALAIRE(ADk,dk,dim,scal2) c Bk=-scal1/scal2 c c !initialisation pour la boucle k+1 DO i=1,N*M dk(i)=rkk(i)+Bk*dk(i) rk(i)=rkk(i) Xk(i)=Xkk(i) c ENDDO c cpt1=cpt1+1 cptgrad=cptgrad+1 c ENDDO c c RETURN

31

END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c PRODUIT SCALAIRE c SUBROUTINE SCALAIRE (V1,V2,taille,res) c c --- Declarations --- INTEGER i, taille DOUBLE PRECISION V1(taille), V2(taille) DOUBLE PRECISION res c c --- Initialisation --- res=0 c c --- Calcul du Produit Scalaire --- DO i=1,taille res=res+V1(i)*V2(i) ENDDO RETURN END c ------------------------------------------------------------------

32

III.3 – Accélération d’une méthode itérative c ********************************************* ********************* c | | c | TP2 : Exo 3 : Acceleration d une M‚thode it‚rative | c | (gradient conjugu‚) | c | | c ********************************************* ********************* c PROGRAM ACCELERATION c c c --- Declarations --- c c INTEGER i,j,N,choix,dim,cpt,cptnormal,cptacc PARAMETER (dim=1000) DOUBLE PRECISION A,B,Vpro,C,C1,Xk,Xfin,scal1,scal2,lambda, & precision DIMENSION A(dim,dim),B(dim,dim),C(dim),C1(dim),Xk(dim),Xfin(dim), & Vpro(dim) c OPEN(UNIT=15, FILE='Matrice.exo3.dat',STATUS='UNKNOWN') OPEN(UNIT=17, FILE='exo3.resultats.dat',STATUS='UNKNOWN') c c c c c --- Initialisation --- c N=3 c c c --- Formulaire --- c !initialisation par l'utilisateur WRITE(*,*)'TP 2 exo 3' WRITE(*,*) c WRITE(*,*)'Choix de la norme :' WRITE(*,*)'1 = norme 2' WRITE(*,*)'2 = norme infinie' READ(*,*)choix c c WRITE(*,*)'Precision demandee : (entre 0.1 et 1*10^-8)' READ(*,*)precision WRITE(*,*) c c c c --- Corps du programme --- c c ---Cr‚ation et Remplissage de la matrice A --- c CALL MATRICE(A,N,dim) !cr‚ation de la matrice A c DO i=1,N !verification de la matrice A dans un fichier DO j=1,N

33

WRITE(15,*)A(i,j) ENDDO ENDDO c c CALL vecteur(C,N,5.d0,dim) !cr‚ation du vecteur C c CALL vecteur(Xk,N,1.d0,dim) !cr‚ation du vecteur Xk c CALL RESOL(A,Xk,C,N,dim,cptnormal,precision,choix) c WRITE(17,*)'resolution normale du systeme :' WRITE(17,*) WRITE(17,*)"nombre d'iterations : ",cptnormal WRITE(17,*) WRITE(17,*)'Vecteur solution trouve :' DO i=1,N WRITE(17,*)Xk(i) ENDDO WRITE(17,*) WRITE(17,*) WRITE(17,*) c --- m‚thode acceleration --- c c c CALL METHODE_ITEREE(N,dim,A,choix,lambda,Vpro,precision,cpt) c ! on calcul C1 = C - <c,e1>/<e1,e1> *e1 CALL SCALAIRE (C,Vpro,N,scal1) CALL SCALAIRE (Vpro,Vpro,N,scal2) c DO i=1,N C1(i)=C(i)- scal1/scal2*Vpro(i) ENDDO c DO i=1,N !principe de la deflation, on enleve la la valeur DO j=1,N !propre calcul‚ just avant (la plus grande) B(i,j)=A(i,j)-lambda*Vpro(i)*Vpro(j) ENDDO ENDDO c c CALL RESOL(B,Xk,C1,N,dim,cptacc,precision,choix) c DO i=1,n Xfin(i)=Xk(i) Xfin(i)=Xfin(i)+scal1*Vpro(i)/(1-lambda) ENDDO c c WRITE(17,*)'resolution accelere du systeme :' WRITE(17,*) WRITE(17,*)"nombre d'iterations : ",cptacc WRITE(17,*)"nombre d'iterations puissance iteree : ",cpt WRITE(17,*) WRITE(17,*)'Vecteur solution trouve :' DO i=1,N WRITE(17,*)Xfin(i) ENDDO WRITE(17,*)

34

WRITE(17,*) WRITE(17,*) c c END c c c ********************************************* ********************* c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c Remplissage de la matrice A c SUBROUTINE MATRICE(A,n,dim) c INTEGER i,j,dim,n DOUBLE PRECISION A DIMENSION A(dim,dim) c DO i=1,n DO j=1,n A(i,i+j)=0.001d0 A(i+j,j)=0.001d0 ENDDO ENDDO c DO i=1,n A(i,i)=0.01d0 ENDDO c A(1,1)=0.98d0 A(2,2)=0.5d0 A(3,3)=0.3d0 A(4,4)=0.1d0 c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c Remplissage vecteur c SUBROUTINE vecteur(vect,n,valeur,dim) c INTEGER i,dim,n DOUBLE PRECISION vect,valeur DIMENSION vect(dim) c DO i=1,n vect(i)=valeur ENDDO c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c Resolution normale du systŠme

35

c SUBROUTINE RESOL(A,Xk,C,N,dim,cptnormal,precision,choix) c INTEGER i,dim,N,cptnormal,choix DOUBLE PRECISION A,C,precision,Xk,Xkk,norme,AXk,diff DIMENSION A(dim,dim),C(dim),Xk(dim),Xkk(dim),AXk(dim),diff(dim) c cptnormal=0 norme=1 CALL vecteur(Xk,N,1.d0,dim) c DOWHILE(norme.gt.precision) c CALL PROVECT(N,dim,A,Xk,AXk) !retourne le vecteur A.Xk c DO i=1,N Xkk(i)=AXk(i)+C(i) diff(i)=Xkk(i)-Xk(i) !comparaison de Xk et Xk+1 ENDDO c c CALL NORME_VECT(N,dim,diff,choix,norme) !calcul de la norme c c DO i=1,N Xk(i)=Xkk(i) ENDDO c cptnormal=cptnormal+1 ENDDO c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c PRODUIT MATRICE x VECTEUR c SUBROUTINE PROVECT(N,dim,A,vect,AK) c INTEGER i,j,N,dim DOUBLE PRECISION A,AK,vect DIMENSION A(dim,dim),AK(dim),vect(dim) c DO i=1,N AK(i)=0 DO j=1,N AK(i)=AK(i)+A(i,j)*vect(j) ENDDO ENDDO c c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------

36

c CALCUL DE LA NORME (2 ou infinie) c SUBROUTINE NORME_VECT(N,dim,V,choix,norme) c INTEGER i,N,dim,choix DOUBLE PRECISION V,norme DIMENSION V(dim) c norme=0 c IF(choix.eq.1)THEN !norme 2 DO i=1,N norme=norme+V(i)*V(i) ENDDO norme=sqrt(norme) c ELSEIF(choix.eq.2)THEN !norme infinie norme=V(1) DO i=2,N IF(V(i).gt.norme)THEN norme=V(i) ENDIF ENDDO ELSE WRITE(*,*)'mauvaise selection de la norme' WRITE(*,*) ENDIF c c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c METHODE DE LA PUISSANCE ITEREE c SUBROUTINE METHODE_ITEREE(N,dim,PRO,choix,lambda,Vpro,precision, & cpt) c INTEGER i,dim,N,choix,cpt DOUBLE PRECISION Xk,Xkk,erreur,PRO,AXk,AQk,norme,Qk,lambda,vpro & ,precision DIMENSION PRO(dim,dim),AXk(dim),AQk(dim),Xk(dim),Xkk(dim),Qk(dim) & ,Vpro(dim) c c Initialisation : c c CALL vecteur(Xk,N,1.d0,dim) c cpt=0 c c c It‚rations : c erreur=1 DOWHILE (erreur.gt.precision) c CALL PROVECT(N,dim,PRO,Xk,AXk)

37

c c DO i=1,N Xkk(i)=AXk(i) ENDDO c c CALL NORME_VECT(N,dim,Xkk,choix,norme) c c DO i=1,N Qk(i)=Xkk(i)/norme Xk(i)=Qk(i) ENDDO c c CALL PROVECT(N,dim,PRO,Qk,AQk) c CALL TEST_ARRET(N,dim,AQk,Qk,erreur) c cpt=cpt+1 c ENDDO c c c Affichage des solutions c WRITE(*,*)'Vecteur propre :' DO i=1,N WRITE(*,*)Qk(i) ENDDO WRITE(*,*) WRITE(*,*)'Valeur propre :' WRITE(*,*)AQk(1)/Qk(1) c DO i=1,N Vpro(i)=Qk(i) ENDDO lambda=AQk(1)/Qk(1) c WRITE(*,*) WRITE(*,*)cpt WRITE(*,*) c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c TEST D ARRET c SUBROUTINE TEST_ARRET(N,dim,AK,vect,erreur) c INTEGER i,N,dim DOUBLE PRECISION AK,vect,pif,erreur DIMENSION AK(dim),vect(dim) c erreur=0 DO i=1,N

38

pif=abs(Ak(i)/vect(i)-Ak(1)/vect(1)) IF(pif.gt.erreur)THEN erreur=pif ENDIF ENDDO c c RETURN END c c ------------------------------------------------------------------ c c ------------------------------------------------------------------ c PRODUIT SCALAIRE c SUBROUTINE SCALAIRE (V1,V2,taille,res) c c --- Declarations --- INTEGER i, taille DOUBLE PRECISION V1(taille), V2(taille) DOUBLE PRECISION res c c --- Initialisation --- res=0 c c --- Calcul du Produit Scalaire --- DO i=1,taille res=res+V1(i)*V2(i) ENDDO RETURN END c ------------------------------------------------------------------