I.2 - Méthode De Gauss - Jordan
(Utilisée pour calculer l'inverse d'une matrice)
Objectif : calcul de la matrice inverse
On considère le système linéaire AX = B
suivant :
(a11 a12
·
·
· aln) (x1) (b1
am a22
·
·
· a2n
. ... .
x2
. = b2 .
an1 an2
·
·
· ann
xn
bn
1 0 0
(01 ... 0) x1 b1( bi
b2
=
bn
00
·
·
·1xn
Le but de cette méthode est de rendre la matrice A
diagonale unitaire c'est-à- dire :
. .
· . . .
. . . . . .
. . . . .
On peut trouver toutes les valeurs de Xi par la
méthode itérative suivante
xi = bi; i: 1,n
L'un des grands défis de l'algèbre
linéaire est de trouver la matrice inverse A-1 .Avec cette
méthode on peut calculer la matrice inverse sans utiliser la
cof acte ur (a i j)
formule théorique (A_1)i] =det (A)
qui est impraticable, par la
résolution de n système au même temps A
A-1 = I (I matrice identité
(a11 a12
·
·
· aln 1 0 ... 0
am a22
·
·
· a2n A
_i= ~0 1
·
·
· 0
an1 an2
·
·
· ann 0 0
·
·
· 1
. ... .
·
·
·
·
·
·
·
·
. . . .
Le programme
//TP2 Calcul Numérique
//Méthode de Jordan Pour Calculer L'inverse d' une
matrice
#include<stdio.h> #include<alloc.h>
#include<iostream.h> #include<iomanip.h> #include<math.h>
#include<conio.h>
struct PosMax //enregistrement pour le maximum {int IL;int
JC;};
//enregistrement pour la matrice inverse struct inverse {double
*x;int indice;};
double **NewMat(int n,int m) //creation dynamique d'une matrice
{double * *mat=(double* *)malloc(n*sizeof(double*));
for(int i=0;i<n;i++)
mat[i]=(double*)malloc(m*sizeof(double));
return mat;
}
void charger(double **mat,int n,int m) //initialisation du
matrice { cout<<"Entrer la matrice \n";
for(int i=0;i<n;i++)
{int x=wherex();
for(int j=0;j<m;j++)
{cin>>mat[i] [j] ;gotoxy(x+=6,wherey()- 1); }
cout<<endl;
}
}
void print(double **mat,int n,int m)//afficher une matrice
{for(int i=0;i<n;i++)
{for(int j=0;j<m;j++)
cout<<setfill('
')<<setw(4)<<setprecision(2)<<mat[i] [j]<<"\t";
printf("\n");
}
}
//Chercher la posision du max
PosMax SearchMax(double **mat,int n,int m,int k)
{PosMax max;
max.IL=max.JC=k;
double tmp=fabs(mat[k] [k]); for(int i=k;i<n;i++)
for(int j=k;j<m;j++)
if(tmp<fabs(mat[i] [j]))
{max.IL=i;max.JC=j;
tmp=fabs(mat[i] [j]);
}
return max;
//fonction de normalisation
void normalis(double **mat,int m,int k)
{double p=mat[k] [k];
for(int j=k;j<m;j++) mat[k] [j]=(double)mat[k]
[j]/(double)p;
}
//fonction de la permutation
void permut(double **mat,int n,int m,int k,inverse *inv)
{PosMax grand=SearchMax(mat,n,n,k);
if(grand.IL != k)//permutation de ligne
{double inter;
for(int j=k;j<m;j++)
{inter=mat[k] [j] ;mat[k] [j]=mat[grand.IL] [j] ;mat[grand.IL]
[j]=inter; }
}
if(grand.JC != k)//permutation de colonne
{double inter;
for(int i=k;i<n;i++)
{inter=mat[i] [k] ;mat[i] [k]=mat[i] [grand.JC] ;mat[i]
[grand.JC]=inter; }
int ind=inv[k] .indice;inv[k] .indice=inv[grand.JC]
.indice;inv[grand .JC].indice=ind; }
}
//fonction de reduction
int reduction(double **mat,int n,int m,inverse *inv,double
eps=0.001)
{for(int k=0;k<n;k++) {permut(mat,n,m,k,inv);
if(fabs(mat[k][k]) > eps)
{normalis(mat,m,k);//normalisation de la ligne k
for(int i=0;i<n;i++)
if( i != k)
{for(int j=k+1 ;j<m;j++) mat[i] [j] -=(double)mat[i] [k]
*mat[k] [j];
mat[i] [k]=0; }
}
else {cout<<"Matrice Singuliere ! ! ! ";return 0; }
}
return 1;
}
//fonction pour extraire la matrice invese
void GetInv(double **mat,int n,inverse *inv)
{for(int i=0;i<n;i++)
{inv[i] .x=(double*)malloc(n*sizeof(double));
for(int j=0;j<n;j++) inv[i] .x[j]=mat[i] [n+j];
}
}
//fonction d'affichge pour la matrice inverse
void PrintInv(inverse *inv,int n)
{for(int i=0;i<n;i++) {for(int j=0;j<n;j++)
cout<<setfill('
')<<setw(4)<<setprecision(2)<<inv[i] .x[j]<<"\t";
printf("\n");
}
}
//mise on ordre les ligne de la matrice inverse
void ordre(inverse *inv,int n)
{for(int i=0;i<n;i++)
{int ind=inv[i] .indice;
for(int j=i+1 ;j<n;j++) if(ind>inv[j] .indice) ind=inv[j]
.indice; if(ind != i)
{inverse tmp=inv[i] ;inv[i]=inv[ind] ;inv[ind]=tmp; }
}
}
//chargement automatique de la matrice identitée
void ChargerI(double **mat,int n,int m)
{for(int i=0;i<n;i++)
for(int j=n;j<m;j++)
if(i == j-n) mat[i][j]=1;
else mat[i][j]=0;
}
void main()
{char rep;
do
{clrscr();
cout<<"\t\t Calcul Du Matrice Inverse\n\t\t Methode de
Jordan - Gauss\n"; cout<<"Entrer la dimension du matrice n:";
int dim;
cin>>dim;
inverse *inv=(inverse*)malloc(dim*sizeof(inverse));
for(int i=0;i<dim;i++) inv[i] .indice=i;//initialisation des
indices
cout<<endl;
//Declaration de la matrice augmentée
double * *A=NewMat(dim,dim*2);
charger(A,dim,dim);//initialisation de A
ChargerI(A,dim,dim*2);//ajoute la matrice identitée
cout<<"\nMatrice Augmentée Non
Traitée"<<endl;
print(A,dim,dim*2);
int ok = reduction(A,dim,dim*2,inv);//reduction
cout<<endl; if(ok)
{ cout<<"Matrice Augmentée
Traitée"<<endl;
print(A,dim,dim*2);
GetInv(A,dim,inv);//Donner l'inverse dans inv
cout<<endl;
ordre(inv,dim);//mise on ordre inverse
cout<<"La Matrice Inverse"<<endl;
PrintInv(inv,dim);//afficher la matrice inverse
}
free(A);free(inv);//libération mmoire
cout<<"Voulez vous répéter o/n:";
cin>>rep;
}while (rep == 'o');
| 
