Discussion :

[InJeCt]

Bonjour à tous ! Je débute une programmation en C# depuis ce début d'année, et je me suis lancé dans un programme permettant le traitement de matrices saisies par l'utilisateur.
J'ai cependant un soucis pour deux fonctions : le pivot de gauss, et le calcul de déterminant.
Je voudrais donc savoir si quelques uns d'entre vous pouvez m'aider/me donner quelques piste de réflexions parce que je bloque un peu ces derniers temps.
Je vous met ci-dessous un extrait de mon programmes :

Le programme principal :

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
 
class Program
    {
        static void Main(string[] args)
        {
              int choix = ChoixOp();
              switch (choix){
                    case 6:
                    Matrice mat7 = new Matrice();
                    Console.Out.WriteLine("Entrez le nombre de lignes de la première matrice");
                    mat7.setLigne(int.Parse(Console.In.ReadLine()));
                    Console.Out.WriteLine("Entrez le nombre de colonnes de la première matrice");
                    mat7.setColonne(int.Parse(Console.In.ReadLine()));
 
                    mat7.RemplirMatrice();
                    int dim = 3;
                    Matrice M_inv = new Matrice() ;
                    M_inv.setLigne(dim) ;
                    M_inv.setColonne(dim);
                    //3Matrice.Gauss(mat7, M_inv, dim) ;
                    M_inv.AfficheMat() ;
                    break;
               }
        }
 
 
        public static int ChoixOp(){
            int choix;
            Console.Out.WriteLine("Que voulez-vous faire ?");
            Console.Out.WriteLine("1. Additionner \n2. Soustraire \n3. Multiplier \n4. Calculer le déterminant \n5. Faire le transpose \n6. Pivot de Gauss \n7. (provisoire) Identité");
            choix = int.Parse(Console.In.ReadLine());
            return choix;
        }

Et dans ma classe matrice :

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
 
namespace Matrice
{
    public class Matrice
    {
            protected int nbrLigne ;
            protected int nbrColonne ;
            protected double[,] composant ;
            protected double determinant ;
 
public static void Gauss(Matrice mat1, Matrice mat2, int dim){
                Matrice temp = new Matrice();
                CopieMatrice(mat1, temp, dim);
                double a, b;
                a = 0;
                b = 0;
                int c = 0;
                Identite(mat2, dim);
                for (int k = 0; k < dim; k++){
                    a = temp.composant[k, k * dim];
                    // Vérifie la condition a != 0
                    c = 0;
                    while( a != 0){
                        c++;
                        for (int q = 0; q < dim; q++){
                            temp.composant[k, q * dim] = temp.composant[k, q * dim] + temp.composant[k + c, q * dim];
                            mat2.composant[k, q * dim] = mat2.composant[k, q * dim] + mat2.composant[k + c, q * dim];
                        }
                        a = temp.composant[k, k * dim];
                    }
 
                    //normalisation de la ligne k 
                    for (int l = 0; l < dim; l++) {
                        temp.composant[k, l * dim] = temp.composant[k, l * dim] / a;
                        mat2.composant[k, l * dim] = mat2.composant[k, l * dim] / a;
                    }
 
                    //Réduction e gauss-jordan
                    for (int i = 0; i < dim; i++) {
                        b = temp.composant[i, k * dim];
                        if (i != k) {
                            for (int j = 0; j < dim; j++) {
                                temp.composant[i, j * dim] = temp.composant[i, j * dim] - b * temp.composant[k, j * dim];
                                mat2.composant[i, j * dim] = mat2.composant[i, j * dim] - b * mat2.composant[k, j * dim];
                            }
                        }
                    }
                }
            }
 
public static void CopieMatrice(Matrice mat1, Matrice mat2, int dim){
                for (int i = 0; i < dim; i++){
                    for (int j = 0; j < dim; j++){
                        mat2.composant[i,j*dim] = mat1.composant[i,j*dim] ;
                    }
                }
            } 
 
public static void Identite(Matrice mat1, int dim){
                for (int i = 0; i < dim; i++){
                    for (int j = 0; j < dim; j++){
                        if (i == j){
                            mat1.composant[i, j] = 1;
                        }
                        else{
                            mat1.composant[i, j] = 0;
                        }
                    }
                }
            }

En fait ma fonction du pivot de gauss me renvoi une matrice vide, enfin avec que des 0 à la place des valeurs... Et je bloque complètement dessus.

Pour calculer le déterminant, j'avais vaguement commencé une fonction en récursif qui réduisait l'ordre au fur et à mesure mais je n'ai jamais réussi à la terminer, je me suis emmêlé quelque part et je n'ai pas réussi à retrouver le bout du fil.

J'espère que le code n'est pas trop long et un futur merci à ceux qui se pencheront sur mon problème !

[Er3van]

Ce qui serait bien pour qu'on puisse t'aider, c'est que tu définisses un les règles métiers : comment fait-on un pivot de Gauss.
Sans ça, ça risque de limiter le nombre de personnes susceptibles de t'aider.

Par ailleurs, ton code pourrait sans doute être optimisé, mais on y reviendra quand le problème sera résolu.

Sinon, tu peux déjà commencer par débugger le programme pour voir à quel niveau ça coince non ? Le problème vient de la normalisation de la matrice ou de sa réduction ?

[tomlev]

Ce qui serait bien pour qu'on puisse t'aider, c'est que tu définisses un les règles métiers : comment fait-on un pivot de Gauss.

bah alors, t'as oublié tes cours de terminale ? (moi j'ai oublié en tous cas )
http://fr.wikipedia.org/wiki/%C3%89l...e_Gauss-Jordan

[kheironn]

bah alors, t'as oublié tes cours de terminale ? (moi j'ai oublié en tous cas )

Les matrices, ce n'était pas au programme de la T.D... à ma lointaine époque

je flood... ok, je sors.

[Er3van]

bah alors, t'as oublié tes cours de terminale ? (moi j'ai oublié en tous cas )
http://fr.wikipedia.org/wiki/%C3%89l...e_Gauss-Jordan

Le pire c'est que je viens de finir mon cursus d'ingé, j'en ai bouffé... mais bizarrement c'est du "fire and forget" : exam validé, cours oublié !

Sinon pour la version facile de la résolution de ton problème : Gauss Jordan en C#