Bonjour à tous !
Je développe une classe de matrices de rationnels.
J'ai déjà une classe de rationnels (entièrement testée).
Voici le début de ma classe MatRat (matrices de rationnels).
Tout a été testé et fonctionne normalement a l'exception du déterminant. J'ai utilisé la méthode du développement suivant la première ligne. Ce n'est pas, et de loin la meilleure, mais c'est sans importance mes matrices sont petites.
Voici le code. J'ai commenté la méthode 'Det':
Code Java : 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
 
import java.util.Vector;
 
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author gilles
 */
public class MatRat extends Object {
 
    public int lignes;
    public int colonnes;
    public Vector V;
 
    public MatRat(int m, int n) {
        lignes = m;
        colonnes = n;
        V = new Vector();
        V.setSize(m * n);
    }
 
    public MatRat(int m) {
        lignes = colonnes = m;
        V = new Vector();
        V.setSize(m * m);
    }
 
    public void setAt(int i, int j, Rationnel r) {
        V.setElementAt(r, i * colonnes + j);
    }
 
    public Rationnel getAt(int i, int j) {
        return (Rationnel) V.get(i * colonnes + j);
    }
 
    @Override
    public String toString() {
        String result = new String();
        result = "{";
        String ligne = new String();
        for (int i = 0; i < lignes; i++) {
            ligne = "(";
            {
                for (int j = 0; j < colonnes; j++) {
                    ligne = ligne.concat(this.getAt(i, j).toString());
                    if (j != colonnes - 1) {
                        ligne = ligne.concat(",");
                    }
                }
                ligne = ligne.concat(")");
                result = result.concat(ligne);
                if (i != lignes - 1) {
                    result = result.concat(";");
                }
            }
        }
        result = result.concat("}");
        return result;
    }
 
    public MatRat Mineur(int i, int j) {
        MatRat M = new MatRat(lignes - 1, colonnes - 1);
        int k = 0;
        for (int u = 0; u < lignes; u++) {
            for (int v = 0; v < colonnes; v++) {
                if ((u != i) && (v != j)) {
                    M.V.setElementAt(this.getAt(u, v), k);
                    k++;
                }
            }
        }
        return M;
 
    }
    // Calcul du déterminant par la formule du développement suivant la première ligne.
 
    public Rationnel Det() {
        // variables locales 
        Rationnel r; // résultat à retourner
        Rationnel m; // variable de boucle
        int signe; //idem
        int j; // compteur
        MatRat H; //pas indispensable juste pour augmenter lisibilité
        // condition terminale de la récursivité
        if (lignes == 1) {
            r = getAt(0, 0); // le déterminant est l'unique coefficient
        } else {
            r = new Rationnel(0, 1); // r initialisé à zéro-accumulateur
            signe = +1; // on commence avec un signe +
            for (j = 0; j < colonnes; j++) {
                H = Mineur(0, j); // on prend le mineur
                m = H.Det(); // appel récursif
                m = m.multiply(getAt(0, j)); // multiplier par le coeff 
                if (signe == -1) {
                    m = new Rationnel(-m.getNumerator(), m.getDenominator());
                } // changer  le signe une fois sur deux
                signe = -signe; // pour l'alterrnance des signes
                r = r.add(m); // ajouter à l'accu.
            }
        }
        return r;// résultat
    }
}
A l'exception des matrices (1,1) Tout appel à Det provoque un plantage (apparemment une boucle infinie, on ne sort pas de la récursion). Je ne comprends pas pourquoi. J'ai programmé cela cent fois dans d'autres langages sans le moindre problème. Si quelqu'un voit ce qui se passe. Merci ...