Programmation

00000000001010101011111110100000000011111111100000000010100000000000101
01010100000001010101010000000101010000000010100000000101000000000001000
00000000001010101011111110100000000011111111100000000010100000000000101
01010100000001010101010000000101010000000010100000000101000000000001000
00000000001010101011111110100000000011111111100000000010100000000000101
01010100000001010101010000000101010000000010100000000101000000000001000
00000000001010101011111110100000000011111111100000000010100000000000101
01010100000001010101010000000101010000000010100000000101000000000001000
00000000001010101011111110100000000011111111100000000010100000000000101
01010100000001010101010000000101010000000010100000000101000000000001000
00000000001010101011111110100000000011111111100000000010100000000000101
01010100000001010101010000000101010000000010100000000101000000000001000
00000000001010101011111110100000000011111111100000000010100000000000101
01010100000001010101010000000101010000000010100000000101000000000001000

je ne sais pas, désolé mais c'était trop tentant ^^'

Salut,

Ce n'est pas trop dure et en cherchant bien sur google tu trouveras certainement un prog fait ou l'algorithme !
Mais le forum n'est pas là pour tout te donner mais pour t'aider à te faire avancer. As tu déjà fais quelque chose sur ce programme ?

il faut que tu prenne le cas général.
Déjà il te faut savoir la taille de ta matrice, puis tu fait faire à ton programme les équation:

X = a*x + b*y + c*z
Y = d*x + e*y + f*z
Z = g*x + h*y + i*z

et tu fait exprimer x,y et z en fonction X,Y et Z (a,b,c,d,e,f,g,h,i étant le constante de ta matrice de taille trois)
ainsi tu auras ta matrice inverse.

Si la taille est plus grande que troi, tu rajoute deux inconnu:pour taille 4

X = a*x + b*y + c*z + j*w
Y = d*x + e*y + f*z + k*w
Z = g*x + h*y + i*z + l*w
W = m*x + n*y+ o*z + p*w

et tu exprimes x,y,z,w en fonction de X,Y,Z,W

Cher ami zozopa, je te repond comme l'ami qui m'a précédé que le forum est là pour t'aider cad vous pouvez commencer par faire quelque chose et situer ta difficulté là on peut t'aider. Tresor

Bonjour

Inversion de matrice par la méthode de Pan et Reiff.

Le programme en Turbo Pascal

SOURCE : http://www.chez.com/algor/pan.htm

Cliquez ici pour charger une archive contenant les implémentations de l'algo en Turbo Pascal et en Delphi.

PROGRAM Pan_Reiff;

USES Crt;

TYPE Matrice=ARRAY[1..10,1..10] OF REAL;

VAR MatA,MatB,MatC:Matrice;
    N:BYTE;
    OK:BOOLEAN;

PROCEDURE Intro(VAR N:BYTE;VAR Mat:Matrice);
VAR i,j:BYTE;
BEGIN
CLRSCR;
TEXTCOLOR(YELLOW);
WRITE('Nombre de lignes:');READLN(N);
FOR i:=1 TO N DO
  FOR j:=1 TO N DO
    BEGIN
    {GOTOXY(3,4);CLREOL;
    WRITE('Introduisez A(',i,',',j,'): ');
    READLN(Mat[i,j]);}
    Mat[i,j]:=RANDOM(100);{Pour tester}
    END;
END;

PROCEDURE Attente;
VAR St:STRING;
BEGIN
TEXTCOLOR(LIGHTRED);
St:='Une touche pour continuer.';
GOTOXY(40-LENGTH(St) DIV 2,25);WRITE(St);READKEY;
END;

PROCEDURE Affiche(S:STRING;N:BYTE;Mat:Matrice);
VAR i,j:BYTE;
BEGIN
CLRSCR;
TEXTCOLOR(LIGHTGREEN);
WRITELN(S);
FOR i:=1 TO N DO
  BEGIN
  FOR j:=1 TO N DO
      WRITE(Mat[i,j]:9:4);
  WRITELN;
  END;
END;

PROCEDURE Somme(N:BYTE;MatA,MatB:Matrice;VAR MatC:Matrice);
VAR i,j:BYTE;
BEGIN
FOR i:=1 TO N DO
  FOR j:=1 TO N DO
     MatC[i,j]:=MatA[i,j]+MatB[i,j];
END;

PROCEDURE Difference(N:BYTE;MatA,MatB:Matrice;VAR MatC:Matrice);
VAR i,j:BYTE;
BEGIN
FOR i:=1 TO N DO
  FOR j:=1 TO N DO
     MatC[i,j]:=MatA[i,j]-MatB[i,j];
END;

PROCEDURE Produit(N:BYTE;MatA,MatB:Matrice;VAR MatC:Matrice);
VAR i,j,k:BYTE;
BEGIN
FOR i:=1 TO N DO
  FOR j:=1 TO N DO
    BEGIN
    MatC[i,j]:=0;
    FOR k:=1 TO N DO
      MatC[i,j]:=MatC[i,j]+MatA[i,k]*MatB[k,j];
    END;
END;

PROCEDURE Inverse(N:BYTE;A:Matrice;VAR X:Matrice;VAR OK:BOOLEAN);
VAR Id,E,B:Matrice;
    Old,New:REAL;
    Cpt:BYTE;

  FUNCTION Norme_Ligne(N:BYTE;B:Matrice):REAL;
  VAR Tmp,Tmp2:REAL;
      i,j:BYTE;
  BEGIN
  Tmp:=0;
  FOR i:=1 TO N DO
    BEGIN
    Tmp2:=0;
    FOR j:=1 TO N DO
      Tmp2:=Tmp2+ABS(B[i,j]);
    IF Tmp2>Tmp THEN Tmp:=Tmp2;
    END;
  Norme_Ligne:=Tmp
  END;

  FUNCTION Norme_Colonne(N:BYTE;B:Matrice):REAL;
  VAR Tmp,Tmp2:REAL;
      i,j:BYTE;
  BEGIN
  Tmp:=0;
  FOR i:=1 TO N DO
    BEGIN
    Tmp2:=0;
    FOR j:=1 TO N DO
      Tmp2:=Tmp2+ABS(B[j,i]);
    IF Tmp2>Tmp THEN Tmp:=Tmp2;
    END;
  Norme_Colonne:=Tmp
  END;

  PROCEDURE Init(N:BYTE;A:Matrice;VAR B:Matrice;VAR OK:BOOLEAN);
  VAR i,j:BYTE;
      T:REAL;
  BEGIN
  FILLCHAR(Id,SizeOf(Id),0);
  T:=Norme_Ligne(N,A)*Norme_Colonne(N,A);
  IF ABS(T)>1E-10 THEN BEGIN
                       OK:=TRUE;
                       FOR i:=1 TO N DO
                         BEGIN
                         Id[i,i]:=1;
                         B[i,i]:=A[i,i]/T;
                         FOR j:=i+1 TO N DO
                           BEGIN
                           B[i,j]:=A[j,i]/T;
                           B[j,i]:=A[i,j]/T;
                           END;
                         END;
                       END
  ELSE OK:=FALSE;
  END;

  PROCEDURE Calcule_E;
  VAR C:Matrice;
  BEGIN
  Produit(N,B,A,C);
  Difference(N,Id,C,E);
  END;

  PROCEDURE Calcule_B;
  VAR C,D:Matrice;
  BEGIN
  Somme(N,Id,E,D);
  Produit(N,D,B,C);
  B:=C
  END;

BEGIN
Init(N,A,B,OK);
IF NOT OK THEN WRITELN('Matrice nulle!')
ELSE BEGIN
     Calcule_E;
     Old:=Norme_Ligne(N,E);
     New:=Old;
     Cpt:=0;
     WHILE NOT ((New<1E-6) OR ((New>Old) AND (Cpt>5))) DO
       BEGIN
       Old:=New;
       Calcule_B;
       Calcule_E;
       New:=Norme_Ligne(N,E);
       INC(Cpt);
       END;
    OK:=TRUE;
    IF New<1E-6 THEN X:=B
    ELSE OK:=FALSE
    END;
END;

BEGIN
Intro(N,MatA);
Affiche('A=',N,MatA);
Attente;
Inverse(N,MatA,MatB,OK);
IF OK THEN BEGIN
           Affiche('Inverse de A=',N,MatB);
           Attente;
           Produit(N,MatA,MatB,MatC);
           Affiche('Produit des matrices inverses=',N,MatC);
           Attente;
           END
ELSE BEGIN
     CLRSCR;
     WRITELN('Pas d''inverse!');
     END;
END.

Merci

ouai, il est bien ce programme, il prend les matrice de n'importe quelle taille.
Cependant c'est de l'algorithme, pas du pascal, non?

Bonjour

Cependant c'est de l'algorithme, pas du pascal, non ?

C'est un 'Algorithme' écrit ou codifié avec les règles du langage 'Turbo Pascal' ;))

(je ne sais pas tout = m'embrouilles pas ;)) ; merci.)

Merci