Soit le système d’équations suivantes :

a 00 x 0  a 01x1  ...  a 0,N1x N1  y 0


a10 x 0  a11x1  ...  a1,N1x N1  y1
 On peut écrire ce système sous une forme matricielle

a N1,0 x 0  a N1,1x1  ...  a N1,N1x N1  y N1

 a11 a1N   x1   y1 
[A] [X] = [Y]
       ceci va conduire vers la matrice caractéristique du système B
    
a
 N1 a NN   x n   y3 
 a11 a1N y1 
 
qui s’écrit sous la forme : B 
a a NN y N 
 N1
 Les Operations Blanches : Ce sont des opérations ou bien des transformations appliqués sur les lignes de la
matrice B mais ces opérations ne changent pas les solutions.

 Multiplication par un scalaire Li 

Li .

 Remplacer une ligne par une combinaison de cette ligne et une autre Li 
 Li  L j

 Permuter une ligne Li 

Lj.

On applique une série d’opérations blanches en normalisant et annulant on obtient finalement une matrice de la
forme :

1 0 y1'   y1' 
   
où la colonne représente la solution.
   
0 ' 
1 yN   y' 
  N

[B]

Operations
Blanches

La solution est la dernière

[B’] colonne
Exemple d’un système à 3 inconnues :

 a11 a12 a13 y1   1 a12* a13* y1*   1 a12

* *
a13 y1* 
   L  L1  a a22

a23 y2  (Normalisation) 

 L2  L2  a21 L1  0 a22
* *
a23 y2* 

 a21 a11 
a22 a23 y2  1 21
a a33 y3  a33 y3  L3  L3  a31 L1  0 a32
* *
y3* 
 31 a32 a
 31 a32 a33

 1 a12** a13* y1*  L1  L1  a12** L1  1 0 a13*** y1**   1 0 a13 y1 

*** **

L  **   *** **  L3  *** ** 
L2  *2  0 1 a23 y2  
*
  0 1 a23 y2    L3  ***  0 1 a23 y2 
a22  *  a33 
**
 0 a32
*
a33 y3  L3  L3  a13 L1  0 0 a33 y3 
** *** **
 0 0 1 Y3 


L1  L1  a13
***
L1  1 0 0 Y0 
 
L2  L2  a23 L1  0 1 0 Y1 
**

 0 0 1Y 
 2

Soit par exemple le systéme :

2 x  y  z  4  2 1 1 4
  
2 x  2 y  z  1    2 2 1 1 
forme
matricielle
x  y  4z  2  
  1 1 4 2 

#include<stdio.h>
#include<conio.h>
void saisie(float*,int);
void affiche(float*,int);
void pivot(float*,int);
main()
{
float A[3][4];
int N=3;
printf("Entrez Les Coefficients De La Matrice Caracteristique \n");
saisie(A[0],N);
printf("Affhichage De La Matrice Caracteristique \n ");
affiche(A[0],N);
pivot(A[0],N);
printf("Affichage De La Matrice Diagonalisee \n");
affiche(A[0],N);
scanf("%d",&N);
}

void saisie(float*p,int M)
{
int i,j;
for(i=0;i<M;i++)
{
for(j=0;j<M+1;j++)
{
printf("A[%d][%d]=",i,j);
scanf("%f",p+(M+1)*i+j);
}
}
}
void affiche(float*p,int M)
{
 int i,j;
for(i=0;i<M;i++)
{
for(j=0;j<M+1;j++)
{
printf("%f \t",*(p+(M+1)*i+j));
}
printf("\n");
}
}
void pivot(float*p,int M)
{
int i,k,l;
float P,S;

for (i=0;i<=M-1;i++)
{
//normalisation
P=*(p+i+i*(M+1));
for (k=0;k<=M;k++)
{
*(p+k+i*(M+1))=*(p+k+i*(M+1))/P;
}
//annulation
for (l=0;l<=M-1;l++)
{
if(l!=i)
{
S=*(p+i+l*(M+1));
for (k=0;k<=M;k++)
{
*(p+k+l*(M+1))= *(p+k+l*(M+1))-S*(*(p+k+i*(M+1)));
}
}
}
}
}

Programme en matlab :

1 0 0
1  
 A * A * X  A *Y or A * A  I   0 1 0  donc X  A1 *Y
AX  Y  1 1

0 0 1
 
Programme 1 :

A=[2 1 1 ; 2 -2 1 ; 1 1 -4 ]; % saisir les valeurs de A

Y=[ 4 ; 1 ; -2]; % saisir la valeur de Y
X=inv(A)*Y; % solution
Dans la zone de travail on visualise la solution :

Programme2 :

a=[2 1 1 4;2 -2 1 1; 1 1 -4 -2];

[n,m]=size(a);
for i=1:1:n
piv=a(i,i);
for j=1:1:m
a(i,j)=(a(i,j)/piv);
end
for l=1:1:n
if(l~=i)
svg=a(l,i);
for k=1:1:m
a(l,k)=a(l,k)-svg*a(i,k);
end
end
end
end