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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
// Mon implem. J'ai mis des commentaires dedans avec qq petits
// conseils pour si tu es débutant sur le langage Java
public class MatRat {
// Je crée une base de classe qui décrit les nombres
// rationnels pour pouvoir compiler et tester...
private static final class Rational {
private int _numerator;
private int _denominator;
public Rational(final int numerator, final int denominator) {
_numerator = numerator;
_denominator = denominator;
}
public int getNumerator() {
return _numerator;
}
public int getDenominator() {
return _denominator;
}
public void setNumerator(final int numerator) {
_numerator = numerator;
}
public void setDenominator(final int denominator) {
_denominator = denominator;
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
if (_numerator == 0)
return "0";
else if (_denominator == 1)
return Integer.toString(_numerator);
else
return
Integer.toString(_numerator) +
'/' +
Integer.toString(_denominator);
}
public static Rational additionNeutralElement() {
return new Rational(0, 1);
}
public Rational add(final Rational rational) {
final int numerator =
_numerator * rational.getDenominator() +
_denominator * rational.getNumerator();
return new Rational(numerator,
_denominator * rational.getDenominator());
}
public Rational multiply(final Rational rational) {
return new Rational(_numerator * rational.getNumerator(),
_denominator * rational.getDenominator());
}
public void sign(final int sign) {
if (sign < 0)
_numerator = -_numerator;
}
}
public int _lineCount;
public int _columnCount;
// Comme on connait la taille et qu'elle est fixe, avec un
// tableau, c'est plus simple et plus peformant. Sinon,
// préférer ArrayList à Vector
public Rational[] _values;
public MatRat(final int m, final int n) {
_lineCount = m;
_columnCount = n;
_values = new Rational[n * m];
}
public MatRat(final int m) {
// C'est mieux de rappeler l'autre constructeur, ça évite
// de dupliquer le code
this(m, m);
}
public void setAt(final int i, final int j, final Rational r) {
setAt(i * _columnCount + j, r);
}
public void setAt(final int k, final Rational r) {
_values[k] = r;
}
public Rational getAt(final int i, final int j) {
return _values[i * _columnCount + j];
}
// Implem pas très performante. Fait des tas d'allocations de
// chaines de caractères qui ne sont pas utiles. Voir commentaires
// dedans et corrigé après
// @Override
// public String toString() {
//
// // (1) Cette ligne ne sert à rien, une nouvelle chaine est allouée
// // à la ligne suivante
// String result = new String();
//
// // Est quasi-équivalent (en moins bien) à result = new String("{");
// // donc la référence allouée à la ligne précédente est perdue
// result = "{";
//
// // Même constat que dans les lignes précédentes (1)
// String ligne = new String();
//
// for (int i = 0; i < _lineCount; i++) {
// ligne = "(";
// {
// for (int j = 0; j < _columnCount; j++) {
// ligne = ligne.concat(this.getAt(i, j).toString());
// if (j != _columnCount - 1)
// ligne = ligne.concat(",");
// }
// ligne = ligne.concat(")");
// result = result.concat(ligne);
// if (i != _lineCount - 1)
// result = result.concat(";");
// }
// }
// result = result.concat("}");
// return result;
// }
@Override
public String toString() {
final StringBuilder result = new StringBuilder()
.append('{');
for (int i = 0; i < _lineCount; i++) {
result.append('(');
for (int j = 0; j < _columnCount; j++) {
result.append(getAt(i, j));
if (j != _columnCount - 1)
result.append(',').append(' ');
}
result.append(')');
if (i != _lineCount - 1)
result.append(';').append(' ');
}
return result.append('}').toString();
}
public MatRat minor(final int i, final int j) {
final MatRat minor = new MatRat(_lineCount - 1, _columnCount - 1);
int k = 0;
for (int u = 0; u < _lineCount; u++)
for (int v = 0; v < _columnCount; v++)
if ((u != i) && (v != j))
minor.setAt(k++, getAt(u, v));
return minor;
}
// Calcul du déterminant par la formule du développement suivant
// la première ligne.
//
// En simplifiant légèrement le code (et avec qq petites optims)
// on y voit plus clair !!
// Ceci étant dit, j'obtiens les même résultats qu'avec ton implem
// qui marche chez moi. Es-tu sur que le problème venait vraiment
// de cette méthode ???
public Rational determinant() {
if (_lineCount == 1)
return getAt(0, 0);
else {
Rational determinant = Rational.additionNeutralElement();
int sign = 1;
for (int j = 0; j < _columnCount; j++) {
final Rational m = minor(0, j)
.determinant()
.multiply(getAt(0, j));
m.sign(sign);
sign = -sign;
determinant = determinant.add(m);
}
return determinant;
}
}
} |
