Discussion :

[mouchT8]

Bonjour,

Me revoilà avec des problèmes de Matrice.
C'est la première fois que j'utilise les Matrice, et ça se voit !!

J'ai plusieurs problèmes à résoudre mais tout d'abord commençons par ce qui me pose le plus gros problème!

J'ai une matrice carré 4X4 a initialiser jusque là pas trop de problème mais là ou ça "choc" c'est lorsque je doit calculer le déterminant !
Je ne trouve pas la formule correcte !!!
Pour une 2X2 facil, POur une 3X3 idem, mais la 4X4 ...

J'ai bien une "formule" donné par mon énoncé mais alors impossible de la rentré correctement avec VS !!

La voici:

Det(A)= detA = somme[1<=i<=n] (-1)i+1 ai1 |Aij|;

avec
A: une matrice carrée
(a): l'élément unique de la matrice
(aij): les éléments de la matrice (je sais pas pourquoi mais les indices ne s'affiche pas dsl)
det(A): le déterminant
A(ij) une sous matrice de A

J'avoue que je ne comprend rien !!!
N'y aurait t il pas une formule plus "soft" ???

Merci de votre aide !!

[nicroman]

Ben non... c'est la formule de base du déterminant.... Et c'est la même quelque soit la taille de matrice...

On prend une colonne (ou un ligne), et pour chaque element on ajoute (pour les index pairs) ou on retire (pour les index impairs) sa valeur multiplié par le determinant de la matrice qui reste une fois qu'on a enleve la colonne et la ligne de cet élément.

Pour
00 01
10 11
on a donc: 00 * det(11) - 10 * det(01) = 00 * 11 - 10 * 01

Pour:
00 01 02
10 11 12
20 21 22
on a donc: 00 * det (11,12,21,22) - 10 * det(01,02,21,22) + 20 * det(01,02,11,12)
soit: 00*11*22 - 00*12*21 - 10*01*22 + 10*21*02 + 20*01*12 - 20*02*11


Pour:
00 01 02 03
10 11 12 13
20 21 22 23
30 31 32 33

Le determinant est:

Code :

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

1
2
3
4
 
         11 12 13             01 02 03             01 02 03             01 02 03
00 * det(21 22 23) - 10 * det(21 22 23) + 20 * det(11 12 13) - 30 * det(11 12 13)
         31 32 33             31 32 33             31 32 33             21 22 23

Maintenant, je ne sais pas ce que tu fais sur ces matrices, peut-être ont elles des particularités ?
Parceque pour une matrice 'quelconque', ca fait quand même (n! - 1) additions et (n-1)*n! multiplications

[mouchT8]

non je ne fait rien de particulier,
c'est une simple matrice, juste pour apprendre à les manipuler quoi.

Mais le probleme c'est que de la manière dont la formule est écrite, j'ai plein d'erreur sur cette ligne avec VS.
Deja les indices ne s'écrivent pas en indices
et on dirait qu'il manque des opérateurs non ??
Mon dieu que le temps du lycée est loin

[Flow_75]

Code :

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

Det(A)= detA = somme[1<=i<=n] (-1)i+1 ai1 |Aij|

Tu le code comment sous VC ?

sinon, la méthode de nicroman est correcte pour un déterminant d'une matrice 4x4 et assez simple à coder si tu as fait le calcul de déterminant pour 3x3

[nicroman]

Faudrait voir un bout de code...
C++ (forum C++)


Voici un 'exemple' de code (j'ai pas compilé, mais l'idée y est):

Code C :

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
 
/// on passe n ligne de n valeurs....
template<type T> T det(int numRows, const T** rows)
{
     int numSubRows = numRows - 1;
     if (numSubRows == 0)
         return rows[0][0];
 
     T acc = 0;
 
     const T** subrows = new (const T*)[numRows-1];
     for (int i = 0; (i < numRows); ++i) {
         // filling subrows
         if (i == 0) {
             // initial setup
             for (int j = 0; (j < numSubRows ); ++j) 
                subrows[j] = rows[j+1] + 1;
         } else {
             // we just have to replace row i-1  !!!
             subrows[i-1] = rows[i-1] + 1;
         }
         T subdet = det<T>(numSubRows,subrows);
         if (i % 2)
            acc -= rows[i][0] * subdet;
         else
            acc += rows[i][0] * subdet;
     }
     delete [] subrows;
     return acc;
}

[nicroman]

Et un exemple à base de template (déroulés)

Code C++ :

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
 
///
/// Initial setup of sub-elements, starting with last row...
///
template<type T, int row> void det_subelts_setup(const T** elts, const T** subelts)
{
    det_subelts_setup<T,row-1>(elts,subelts);
    subelts[row] = elts[row]+1;
}
///
/// Specialisation when row index is 0 (no call to previous row)
///
template<type T, 0> void det_subelts_setup(const T** elts, const T** subelts)
{
    subelts[0] = elts[0] +1;
}
 
///
/// Code factorisation to retrieve a sub-matrix * element value
///
template<type T, int n, int row> T det_part(const T** elts, const T** subelts)
{
    return (row%2) ? 
        -elts[row][0] * det<T,n-1>(subelts) :
        +elts[row][0] * det<T,n-1>(subelts);
}
 
///
/// Determinant accumlation for any row (subelts must be already setup 
/// for that row).
///
template<type T, int n, int row> T det_acc(const T** elts, const T** subelts)
{
    // subelts is already setup to handle row !
    T ret = det_part<T,n,row>(elts,subelts);
    // replacing previous row
    subelts[row-1] = elts[row]+1;
    // accumulating (loop)
    ret += det_acc<T,n,row-1>(elts,subelts);
    return ret;
}
///
/// Specialisation for row 0 (no call to previous row)
///
template<type T, int n, 0> T det_acc(const T** elts, const T** subelts)
{
     return det_part<T,n,row>(elts,subelts);
}
 
///
/// Determinant function:
/// - Prepare sub-rows
/// - Start accumulation
template<type T, int n> det(const T** elts)
{
     const T* subelts[n-1];
     det_subelts_setup<T,n-2>(elts,subelts);
     // making the loop
     return det_acc<T,n,n-1>(elts,subelts);
}
 
/// specialization for n==1
template<type T,1> T det(const T** elts)
{ 
    return elts[0][0];
}
 
/// specialization for n==2 (optionel)
template<type T,2> T det(const T** elts)
{ 
    return elts[0][0]*elts[1][1] - elts[0][1]*elts[1][0];
}

Là encore, j'ai pas compilé... mais le coeur y est !