determinant d'une matrice Fermé

Question

Bonsoir, j'essaie de faire un programme de réseaux ouverts de files d'attentes avec turbo pascal(TP7) dont j'ai besoin de calculer le déterminant d'une matrice donnée. Le problème c'est que lorsque j'exécute le programme m'affiche une valeur différente de celle que j'ai calculé manuellement.(c-a-d il m'affiche une fausse valeur). Si vous pouvez m'aider a trouver l'erreur dans mon programme. Voici le code que j'ai réalisé: procedure det_aux( ma:matrice;var mb:matrice;l,c:integer); var i,j,d,e:integer; begin e:=1; for i:=1 to l do begin d:=1; if (i<>1) then begin for j:=1 to N do if(j<>c) then begin mb[e,d]:=ma[i,j]; d:=d+1; end; e:=e+1; end; end; end; function expo(n:integer):integer; begin if (n mod 2=0) then expo:=1 else expo:=-1 ; end; function determinant(m:matrice;l:integer):real; var i:integer; var m2:matrice; var x:real; begin x:=0; if(l=1) then determinant:=m[1,1] else begin for i:=1 to l do begin det_aux(m,m2,i,1); x:=x+(expo(i)*m[i,1]*determinant(m2,(l-1))); end; determinant:=x; end; end; Merci

KX · Answer

Dans det_aux, tu as mis : if (i<>1) then au lieu de if (i<>l) then De plus tu vas jusqu'à N sur j, or tu devrais t'arrêter à l comme pour i. Je ne sais pas si c'est suffisant, néanmoins quelques conseils supplémentaires : Utilises result dans les fonctions plutôt que le nom de la fonction. Exemple : result:=x; au lieu de determinant:=x; De plus je pense que tu aurais intérêt à faire de det_aux une fonction plutôt qu'une procédure (et la renommer) : function matricePriveDe(m:matrice; l,c:integer):matrice; Comme ça ton calcul principal est plus clair : result := result + expo(i)*m[i,1]*determinant( matricePriveDe(m,i,1), l-1);

hajerboug · Answer

bonsoir,
J'ai essayé de faire ce que vous m'avez dit mais dommage ça ne marche pas aussi surtout le cas où la taille de la matrice est supérieur à 2!!!!!!
Merci beaucoup pour tes conseils, mais a propos de la fonction pascal d'après ce que je cannais  pascal ne peut pas me rendre une matrice, c'est pour cela que j'ai fait une procédure(par contre en C on peut la faire normalement).
Vous ne pouvez pas encore m' aidé car si je n'arrive pas à résoudre le problème du déterminant, toutes les valeurs qui viennent après seront fausses(parce qu'elles ont un rapport avec le déterminant).
merci.

KX · Answer

Il est possible de mettre ton type matrice en résultat d'une fonction (d'ailleurs je ne connais aucun type qui ne peut pas être passé en retour d'une fonction)

J'ai adapté mon code à ton type matrice ce qui donne :

PROGRAM Determinants;

const nb_max = 10;

type matrice = array [1..nb_max,1..nb_max] of real;

function matricePriveDe(m:matrice;
         nbLigne,nbColonne,ligne,colonne:byte):matrice;
var l,c:byte;
begin
     for l:=1 to ligne-1 do
     begin
          for c:=1 to colonne-1 do
              result[l,c]:=m[l,c];

          for c:=colonne+1 to nbColonne do
              result[l,c-1]:=m[l,c];
     end;
        
     for l:=ligne+1 to nbLigne do
     begin
          for c:=1 to colonne-1 do
              result[l-1,c]:=m[l,c];

          for c:=colonne+1 to nbColonne do
              result[l-1,c-1]:=m[l,c];
     end;
end;

procedure afficher(m:matrice; nbLignes,nbColonnes:byte);
var l,c:byte;
begin
     for l:=1 to nbLignes do
     begin
          for c:=1 to nbColonnes do
              write(m[l,c]:0:2,chr(9));
          writeln;
     end;
     writeln;
end;

function determinant(m:matrice; nbLC:byte):real; // calcul sur la première ligne
var c:byte; r:real;
begin
     if nbLC=1
     then exit(m[1,1]);

     result:=0;
     for c:=1 to nbLC do
     begin
         if m[1,c]=0
         then r:=0
         else r:=m[1,c]*determinant(matricePriveDe(m,nbLC,nbLC,1,c),nbLC-1);

         if odd(c)
         then result:=result-r
         else result:=result+r;
     end;
end;

VAR m:matrice;
BEGIN
     m[1,1]:=4; m[1,2]:=3; m[1,3]:=1; // 4 3 1
     m[2,1]:=5; m[2,2]:=2; m[2,3]:=7; // 5 2 7
     m[3,1]:=8; m[3,2]:=0; m[3,3]:=2; // 8 0 2

     afficher(m,3,3);

     writeln(determinant(m,3):0:3); // 138.000
     readln;
END.

KX · Answer

En Pascal on peut le faire, j'ai testé le code avec Dev-Pascal et ça marche très bien, c'est juste Turbo Pascal qui fait un petit caprice voilà tout ^^

Alors avec une procédure ça donnerait : 

procedure matricePriveDe(m:matrice;
         nbLigne,nbColonne,ligne,colonne:byte;
         var mpd:matrice);
var l,c:byte;
begin
     for l:=1 to ligne-1 do
     begin
          for c:=1 to colonne-1 do
              mpd[l,c]:=m[l,c];

          for c:=colonne+1 to nbColonne do
              mpd[l,c-1]:=m[l,c];
     end;
        
     for l:=ligne+1 to nbLigne do
     begin
          for c:=1 to colonne-1 do
              mpd[l-1,c]:=m[l,c];

          for c:=colonne+1 to nbColonne do
              mpd[l-1,c-1]:=m[l,c];
     end;
end;

function determinant(m:matrice; nbLC:byte):real; // calcul sur la première ligne
var c:byte; r:real; var mpd:matrice;
begin
    //...
         else begin
              matricePriveDe(m,nbLC,nbLC,1,c,mpd);
              r:=m[1,c]*determinant(mpd,nbLC-1);
              end;
    //...
end;

KX · Answer

Je regarderais plus un détail le reste du code demain si ça ne résout pas ton problème, mais tu as modifié mon code de façon erronée :

Tu as écrit :

if not odd(c)
then result:=result-r
else result:=result+r;
Alors que moi j'avait écrit :

if odd(c)
then result:=result-r
else result:=result+r;

KX · Answer

Je n'ai pas repris ton code car je trouve que tu fais beaucoup plus de fonctions que tu n'en as besoin ! 

J'ai donc repris tes 4 points et fais une fonction pour chacun des ces 4 points. 
Faire des fonctions intermédiaires n'est pas utile ici puisque tes 3 premiers points définissent déjà les fonctions intermédiaires de la quatrième. 

De plus, pour être cohérent, j'ai modifié ton type tab en un type vecteur qui contient la taille réelle de celui-ci (comme le type matrice). Ça évite d'avoir à se promener avec des paramètres de tailles dans les fonctions alors qu'ils sont inhérents non pas au calcul mais aux données ! 

Remarque : je n'ai pas effectué de tests, je te laisse le soin de regarder ce que ça donne... 

PROGRAM Determinants;
        
//---------------------------------------------

const NMAX = 20;

type vecteur = record
               tableau : array[1..NMAX] of real;
               nbLignes : byte;
               end;

type matrice = record
               tableau : array[1..NMAX,1..NMAX] of real;
               nbLignes : byte;
               nbColonnes : byte; 
               end;
       
//---------------------------------------------

function matricePriveDe(m:matrice; ligne,colonne:byte):matrice;
var l,c:byte;
begin
     result.nbLignes:=m.nbLignes-1;
     result.nbColonnes:=m.nbColonnes-1;

     for l:=1 to ligne-1 do
     begin
          for c:=1 to colonne-1 do
              result.tableau[l,c]:=m.tableau[l,c];

          for c:=colonne+1 to m.nbColonnes do
              result.tableau[l,c-1]:=m.tableau[l,c];
     end;

     for l:=ligne+1 to m.nbLignes do
     begin
          for c:=1 to colonne-1 do
              result.tableau[l-1,c]:=m.tableau[l,c];

          for c:=colonne+1 to m.nbColonnes do
              result.tableau[l-1,c-1]:=m.tableau[l,c];
     end;
end;
              
//---------------------------------------------

function determinant(m:matrice):real;
var c:byte; r:real;
begin
     if m.nbLignes=1
     then
     begin
     result:=m.tableau[1,1];
     exit;
     end;
     result:=0;

     for c:=1 to m.nbLignes do
     begin
         if m.tableau[1,c]=0
         then r:=0
         else r:=m.tableau[1,c]*determinant(matricePriveDe(m,1,c));

         if odd(c)
         then result:=result+r
         else result:=result-r;
     end;
end;

//---------------------------------------------

function difference(m:matrice):matrice; // calcul de (I-M)
var l,c:byte;
begin
     result.nbLignes:=m.nbLignes;
     result.nbColonnes:=m.nbColonnes;

     for l:=1 to m.nbLignes do
     for c:=1 to m.nbColonnes do
         if l=c
         then result.tableau[l,c]:=1-m.tableau[l,c]
         else result.tableau[l,c]:=-m.tableau[l,c];
end;             

//---------------------------------------------

function inverse(m:matrice):matrice; // méthode des cofacteurs
var l,c:byte; r,d:real;
begin
     d:=determinant(m);

     if d=0
     then begin
          writeln('matrice non inversible');
          halt;
          end;

     result.nbLignes:=m.nbColonnes;
     result.nbColonnes:=m.nbLignes;

     for l:=1 to m.nbLignes do
     for c:=1 to m.nbColonnes do
     begin
         r:=determinant(matricePriveDe(m,l,c)); // cofacteur

         if odd(l+c)
         then result.tableau[c,l]:=-r/d  // on transpose directement 
         else result.tableau[c,l]:= r/d; // sans oublier la division
     end;
end;                       

//---------------------------------------------

function multiplier(m:matrice;v:vecteur):vecteur; // m*v
var l,c:byte; r:real;
begin
     if m.nbColonnes<>v.nbLignes
     then begin
          writeln('multiplication incompatible');
          halt;
          end;

     result.nbLignes:=v.nbLignes;

     for l:=1 to m.nbLignes do
     begin
          r:=0;

          for c:=1 to m.nbColonnes do
              r:=r+m.tableau[l,c]*v.tableau[c];

          result.tableau[l]:=r;
     end;
end;                               

//---------------------------------------------

function lambda(m:matrice;v:vecteur):vecteur;
begin
     result:=multiplier(inverse(difference(m)),v);
end;

//---------------------------------------------

BEGIN

END.
La confiance n'exclut pas le contrôle

KX · Answer

Resource file icon file not found : tu as surement dû vouloir faire un nouveau projet ou je ne sais pas trop quoi dont je ne me sers jamais...
Si tu fais un "New Source File (Ctrl+U)" et que tu colles exactement ce que j'ai mis dans Dev-Pascal et que tu enregistres ça dans un fichier .pas, ça marche (c'est ce que je fais)

Il est possible qu'il ne t'affiche que des 0.00 car les valeurs sont trop petites.
En effet ma fonction d'affichage (que je n'avais pas remise d'ailleurs) tronquait les valeurs à 2 chiffres après la virgule, donc 0.002 est tronquée en 0.00

De mon côté j'ai fait quelques tests, et je trouve à la main les même résultats que le programme pour déterminant, différence, inverse, et multiplier (je n'ai pas fait lambda mais ça se déduit des précédents)

//---------------------------------------------

const NCAV = 4; // nombre de chiffres après la virgule

procedure afficher(m:matrice);
var l,c:byte;
begin
     for l:=1 to m.nbLignes do
     begin
          for c:=1 to m.nbColonnes do
              write(m.tableau[l,c]:0:NCAV,chr(9));
          writeln;
     end;
     writeln;
end;

procedure afficher(v:vecteur);
var l:byte;
begin
     for l:=1 to v.nbLignes do
         writeln(v.tableau[l]:0:NCAV);
     writeln;
end;

var m:matrice; v:vecteur;
BEGIN
     m.nbLignes:=3;
     m.nbColonnes:=3;

     m.tableau[1,1]:=6; m.tableau[1,2]:=2; m.tableau[1,3]:=5;
     m.tableau[2,1]:=7; m.tableau[2,2]:=1; m.tableau[2,3]:=0;
     m.tableau[3,1]:=4; m.tableau[3,2]:=8; m.tableau[3,3]:=3;

     afficher(m); // OK

     v.nbLignes:=3;

     v.tableau[1]:=5;
     v.tableau[2]:=2;
     v.tableau[3]:=4;

     afficher(v); // OK

     writeln(determinant(m):0:NCAV,chr(10)); // 236 : OK

     afficher(difference(m)); // [-5 -2 -5 -7 0 0 -4 -5 -2] : OK

     afficher(inverse(m)); // [3 34 -5 -21 -2 35 52 -40 -8]/236 : OK

     afficher(multiplier(m,v)); // [54 37 48] : OK

     afficher(lambda(m,v)); // [-0.2857 -0.1984 -0.63]

     readln;
END.

Determinant d'une matrice

7 réponses

Discussions similaires