Discussion :

[achraf_djy]

Salut
J'ai reussi à calculer le determinant d'une matrice d'orde 2 4, mais j'ai pas trouve une methode pour une matrice nn en utilisant seulement la bibliotheque stdio.h et stdlib.h.
Pourriez vous m'orienter vers des pistes qui me permettraient de réaliser ce que je souhaite faire ?

Merci.

[Soack]

Regarde du côtés de Boost.Ublas, il me semble que tu trouveras une classe Matrice qui contient une méthode pour calculer un determinant de matrice NxN.

[Alp]

salut j'ai reussi à calculer le determinant d'une matrice d'orde 2 4, mais j'ai pas trouve une methode pour une matrice nn en utilisant selemant la biblioteque stdio.h et stdlib.h aidez moi

http://en.wikipedia.org/wiki/Determi...implementation ?

[achraf_djy]

slt merci les amis pour votre attention, pour Soack j'ai pas bien compris ce que tu veut dire?

[darrylsite]

salut j'ai reussi à calculer le determinant d'une matrice d'orde 2 4, mais j'ai pas trouve une methode pour une matrice nn en utilisant selemant la biblioteque stdio.h et stdlib.h aidez moi

Tu peux utilisé la formule classique supprimant ligne ou colonne, ... Une fonction récursive devrait facilement faire l'affaire.
Pour une matrice d'ordre carre n, la suppression des ligne ou colonne peut réduire la matrice à une matrice d'ordre <=3 dont on sait calculer le determinant.

[achraf_djy]

merci mr darrylsite, mais j'ai pas reussi à encoder ce que tu m'a dit en c#, peut tu m'aider encore un petit peut

[lcfseth]

si c'est du c#que tu cherche tu devrais voir ce lien,
c'est en anglais mais la bibliothèque permet un traitement complet des matrices.
http://www.codeproject.com/KB/cs/CSML.aspx

[Alp]

Sinon, mon lien wikipedia aide pas mal... Bon c'est vrai il ne te mâche pas TOUT le travail, il te donne juste les différents algorithmes possibles, il te reste à les implémenter après ! Rhooo.

[Soack]

Je crois (à vérifier) que Boost propose de calculer un déterminant d'une matrice NxN, tu peux toujours t'inspirer de leur code, non ? Si Boost ne propose pas, oublie ce que j'ai dis. :p

[achraf_djy]

merci les amis mais je ne comprend pas l'anglais tres bien,(svp qq m'ecrit juste le debut de l'astuce en c#)

[marcus18]

sinon si ta reussi à calculer le determinant d'une matrice d'ordre 24 normalement tu aurais bien pu generaliser pour un ordre quelconque en utilisant les fonctions recursives

[MABROUKI]

bonjour achraf_djy
La methode des cofacteurs est la plus simple à implementer ,en la rendant recursive et en arretant la recursion au rang 2(determinant simple a calculer).
Neanmoins ,tu peux aussi programmer la methode de substitution de Gauss puisque la diagonale de la matrice definitive est le determinant cherche...
voici 2 codes en c et un code public en java du site Wikibooks( pratiquement c'est du c) que tu pourras transposer facilement en c# base sur la methode des cofacteurs et mineurs de maniere recursive:
code 1 c++

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
/* a program in c++ that uses a recursive  function to calculate the determinant of
   a n x n matrix.
*/
 
 
#include<iostream.h>
#include<conio.h>
#include<math.h>
#include<stdlib.h>
 
typedef struct 
{
       int order;
       int **ar;        //for a 2-d array
 
}matrix;
 
int create( matrix *a,int order)
{
      if(order<1)
        return 0;             //checks for invalid order
 
      a->order=order;
 
      a->ar= (int**) malloc(order*sizeof(int *)); //allocate space for each row
 
      if(!a->ar)
        return 0;            //checks if memory is allocated
 
     for(int i=0;i<order;i++)
      { a->ar[i]=(int*) malloc(order*sizeof(int));
        if(!a->ar)
         return 0;
      }
       return 1;
}
 
void input(matrix *a )
{
        int i,j;
        for( i = 0; i < a->order; i++ )
         for( j = 0; j < a->order; j++ )
            {
                printf("Enter element at ( %d, %d ): ", i+1, j+1 );
                scanf("%d", &a->ar[i][j] );
             }
}
 
void display( matrix *a )
{
            int i,j;
 
            if( a->order < 1 )
            return;
 
            for( i = 0; i < a->order; i++ )
                {
                for( j = 0; j < a->order; j++ )
                printf("%5d ", a->ar[i][j] );
 
                printf("\n");
                }
}
int calcminor(matrix *a, matrix *minor, int row,int column)
 
{
       int p,q;
 
       if(a->order<=1||row>=a->order||column>=a->order)
     return 0;
 
       if(!create(minor,a->order-1))
     return 0;
 
       p=q=0;
 
       for(int i=0;i<a->order;i++)
         if(i!=row)
     {
           q=0;
         for(int j=0;j<a->order;j++)
           { if(j!=column)
           minor->ar[p][q]=a->ar[i][j];
           q++;
           }
        p++;
     }
     return 1;
}
 
void destroy(matrix *a)
 
{
     if(a->order<1)
       return;
 
       for(int i=0;i<a->order;i++)
         free(a->ar[i]);         // free space for the column
 
         free(a->ar);       //free memory  for rows
         a->order=0;
}
 
int calcdet(matrix *a)
 
{
       int result=0;
 
       matrix minor;
 
       if(a->order<1)
         return 0;
 
       if(a->order==1)      // stopping condition
         return a->ar[0][0];     //returns 0,0 element
 
       for(int i=0;i<a->order;i++)
 
     {
          if(!calcminor(a,&minor,0,i))
             return 0;
          result+=( pow(-1,i)*a->ar[0][i]*calcdet(&minor));
 
          destroy(&minor);
     }
 
       return result;
}
 
 
int main()
 
{
    matrix a;
    int order;
    cout<<"\nEnter The Order of The Square Matrix :";
    cin>>order;
 
    if(!create(&a,order))
       {
           cout<<"\n The Matrix Could Not Be Created !!!! ";
           getch();
          return 0;
       }
       input(&a);
       cout<<"The Matrix Is :\n";
       display(&a);  
 
 
    cout<<"\n The Determinant Of The Matrix Is : "<<calcdet(&a);
 
    getch();
    return 0;
}

code 2

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
atrixInversion: the main function to calculate the inverse matrix.
CalcDeterminant: calculate the determinant of a matrix.
GetMinor: Get minor matrix.
// matrix inversioon
// the result is put in Y
void MatrixInversion(float **A, int order, float **Y)
{
    // get the determinant of a
    double det = 1.0/CalcDeterminant(A,order);
 
    // memory allocation
    float *temp = new float[(order-1)*(order-1)];
    float **minor = new float*[order-1];
    for(int i=0;i<order-1;i++)
        minor[i] = temp+(i*(order-1));
 
    for(int j=0;j<order;j++)
    {
        for(int i=0;i<order;i++)
        {
            // get the co-factor (matrix) of A(j,i)
            GetMinor(A,minor,j,i,order);
            Y[i][j] = det*CalcDeterminant(minor,order-1);
            if( (i+j)%2 == 1)
                Y[i][j] = -Y[i][j];
        }
    }
 
    // release memory
    //delete [] minor[0];
    delete [] temp;
    delete [] minor;
}
 
// calculate the cofactor of element (row,col)
int GetMinor(float **src, float **dest, int row, int col, int order)
{
    // indicate which col and row is being copied to dest
    int colCount=0,rowCount=0;
 
    for(int i = 0; i < order; i++ )
    {
        if( i != row )
        {
            colCount = 0;
            for(int j = 0; j < order; j++ )
            {
                // when j is not the element
                if( j != col )
                {
                    dest[rowCount][colCount] = src[i][j];
                    colCount++;
                }
            }
            rowCount++;
        }
    }
 
    return 1;
}
 
// Calculate the determinant recursively.
double CalcDeterminant( float **mat, int order)
{
    // order must be >= 0
	// stop the recursion when matrix is a single element
    if( order == 1 )
        return mat[0][0];
 
    // the determinant value
    float det = 0;
 
    // allocate the cofactor matrix
    float **minor;
    minor = new float*[order-1];
    for(int i=0;i<order-1;i++)
        minor[i] = new float[order-1];
 
    for(int i = 0; i < order; i++ )
    {
        // get minor of element (0,i)
        GetMinor( mat, minor, 0, i , order);
        // the recusion is here!
 
        det += (i%2==1?-1.0:1.0) * mat[0][i] * CalcDeterminant(minor,order-1);
        //det += pow( -1.0, i ) * mat[0][i] * CalcDeterminant( minor,order-1 );
    }
 
    // release memory
    for(int i=0;i<order-1;i++)
        delete [] minor[i];
    delete [] minor;
 
    return det;
}
If you need to calculate matrix inverse frequently in your codes, you might want to optimize the code by declaring the matrix such as minor and temp as global variables and allocate memories for them only once.

code java wikibooks

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
Algorithm Implementation/Mathematics/Determinant of a MatrixFrom Wikibooks, open books for an open world
< Algorithm Implementation | Mathematics
Jump to: navigation, search 
[edit] Java       public static double[][] reduce(double[][] x, double[][] y, int r, int c, int n)
      {
         for (int h = 0, j = 0; h < n; h++)
         {
            if (h == r) 
               continue;
            for (int i = 0, k = 0; i < n; i++)
            {
               if (i == c) 
                  continue;
               y[j][k] = x[h][i];
               k++;
            } //end inner loop
            j++;
         } //end outer loop
         return y;
      } //end method
   //===================================================
       public static double det(int NMAX, double[][] x)
      {
         double ret=0;
         if (NMAX < 4)//base case
         {
            double prod1=1, prod2=1;
            for (int i = 0; i < NMAX; i++)
            {
                  prod1=1;
                  prod2=1;
 
               for (int j = 0; j < NMAX; j++)
               {
                  prod1 *= x[(j + i + 1) % NMAX][j];
                  prod2 *= x[(j + i + 1) % NMAX][NMAX - j - 1];
               } //end inner loop
               ret += prod1 - prod2;
            } //end outer loop
            return ret *- 1;
         } //end base case
         double[][] y = new double [NMAX - 1][NMAX - 1];
         for (int h = 0; h < NMAX; h++)
         {
            if (x[h][0] == 0) 
               continue;
            reduce(x, y, h, 0, NMAX);
            if (x[h][0] % 2 == 0) ret += det(NMAX - 1, y) * x[h][0];
            if (x[h][0]  %2 == 1) ret -= det(NMAX - 1, y) * x[h][0];
         } //end loop
         return ret;
      } //end method

Pour un usage personnel et en c#(professionnel il faut une license),la librairie Alglib.Net que tu peux telecharger avec l'aide en ligne .Alglib utilise la decomposition LU qui est la methode standard pour abiutir à un determinant ou au calcul d'une inverse(elle est implemente par toutes les librairies professionnelles,ISML,BLAS ) ...
lien Alglib.Net:
http://www.google.fr/url?sa=t&rct=j&...kRaO01Aw0Y01Bw
bon code potache..........