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
| public class Matrice extends AbstractTableModel {
/**
*
*/
private static final long serialVersionUID = 1337856695785836421L;
private int nbLigne;
private int nbColonne;
public double[][] tab; // Matrice M x N
// Création d'une matrice nulle M x N
public Matrice(int nbLigne, int nbColonne) {
this.nbLigne = nbLigne;
this.nbColonne = nbColonne;
tab = new double[nbLigne][nbColonne];
for(int i=0;i<tab.length;i++){
for(int j=0;j<tab[0].length;j++){
tab[i][j]= 0.0;
}
}
}
// Création d'une matrice depuis une deuxième matrice
public Matrice(double[][] tab) {
nbLigne = tab.length;
nbColonne = tab[0].length;
this.tab = new double[nbLigne][nbColonne];
for (int i = 0; i < nbLigne; i++)
for (int j = 0; j < nbColonne; j++)
this.tab[i][j] = tab[i][j];
}
// Constructeur de copie
private Matrice(Matrice matrice) { this(matrice.tab); }
/* Crée et retourne une matrice M x N aléatoire avec des valeurs comprises entre 0 et 1
public static Matrice random(int M, int N) {
Matrice A = new Matrice(M, N);
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++)
A.tab[i][j] = Math.random();
return A;
}*/
// Crée une matrice identité
public static Matrice identité(int longueur) {
Matrice matIdentite = new Matrice(longueur, longueur);
for (int i = 0; i < longueur; i++)
matIdentite.tab[i][i] = 1;
return matIdentite;
}
// Echange deux lignes d'une matrice
private void swap(int index1, int index2) {
double[] temp = tab[index1];
tab[index1] = tab[index2];
tab[index2] = temp;
}
// Crée une transposée
public Matrice transpose() {
Matrice matTransposee = new Matrice(nbLigne, nbColonne);
for (int i = 0; i < nbLigne; i++)
for (int j = 0; j < nbLigne; j++)
matTransposee.tab[j][i] = this.tab[i][j];
return matTransposee;
}
/* Additionne deux matrices (C = A + B)
public Matrice additionner(Matrice matB) {
Matrice matA = this;
if (B.M != A.M || B.N != A.N) throw new RuntimeException("Illegal Matrice dimensions.");
Matrice matC = new Matrice(M, N);
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++)
C.tab[i][j] = A.tab[i][j] + B.tab[i][j];
return C;
}
// Soustrait deux matrices (C = A - B)
public Matrice soustraire(Matrice B) {
Matrice A = this;
if (B.M != A.M || B.N != A.N) throw new RuntimeException("Illegal Matrice dimensions.");
Matrice C = new Matrice(M, N);
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++)
C.tab[i][j] = A.tab[i][j] - B.tab[i][j];
return C;
}
// Teste l'égalité entre deux matrices
public boolean estEgal(Matrice B) {
Matrice A = this;
if (B.M != A.M || B.N != A.N) throw new RuntimeException("Illegal Matrice dimensions.");
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++)
if (A.tab[i][j] != B.tab[i][j]) return false;
return true;
}
// Multiplie deux matrices (C = A * B)
public Matrice Multiplier(Matrice B) {
Matrice A = this;
if (A.N != B.M) throw new RuntimeException("Illegal Matrice dimensions.");
Matrice C = new Matrice(A.M, B.N);
for (int i = 0; i < C.M; i++)
for (int j = 0; j < C.N; j++)
for (int k = 0; k < A.N; k++)
C.tab[i][j] += (A.tab[i][k] * B.tab[k][j]);
return C;
}
*/
// Résoud une matrice carrée NxN avec un second membre rhs
public Matrice solve(Matrice mat) {
if (nbLigne != nbColonne || mat.nbLigne != nbColonne || mat.nbColonne != 1)
throw new RuntimeException("Illegal Matrice dimensions.");
// Création d'une copie des matrices
Matrice matA = new Matrice(this);
Matrice matB = new Matrice(mat);
// Elimination par pivotages de Gauss
for (int i = 0; i < nbColonne; i++) {
// Trouve la ligne pivot et l'échange
int max = i;
for (int j = i + 1; j < nbColonne; j++)
if (Math.abs(matA.tab[j][i]) > Math.abs(matA.tab[max][i]))
max = j;
matA.swap(i, max);
matB.swap(i, max);
// La matrice est singulière
if (matA.tab[i][i] == 0.0) throw new RuntimeException("Matrice is singular.");
// pivot avec B
for (int j = i + 1; j < nbColonne; j++)
matB.tab[j][0] -= matB.tab[i][0] * matA.tab[j][i] / matA.tab[i][i];
// pivot avec A
for (int j = i + 1; j < nbColonne; j++) {
double m = matA.tab[j][i] / matA.tab[i][i];
for (int k = i+1; k < nbColonne; k++) {
matA.tab[j][k] -= matA.tab[i][k] * m;
}
matA.tab[j][i] = 0.0;
}
}
// substitution de retour
Matrice matX = new Matrice(nbColonne, 1);
for (int j = nbColonne - 1; j >= 0; j--) {
double t = 0.0;
for (int k = j + 1; k < nbColonne; k++)
t += matA.tab[j][k] * matX.tab[k][0];
matX.tab[j][0] = (matB.tab[j][0] - t) / matA.tab[j][j];
}
return matX;
}
// Affiche une matrice
public void Afficher() {
for (int i = 0; i < nbLigne; i++) {
for (int j = 0; j < nbColonne; j++)
System.out.print(tab[i][j] +" ");
System.out.println();
}
}
public int getColumnCount() {
return tab[0].length;
}
public int getRowCount() {
return tab.length;
}
public Object getValueAt(int ligne, int colonne) {
return new Double(tab[ligne][colonne]);
}
public void setValueAt(double val,int ligne,int colonne){
tab[ligne][colonne] = val;
fireTableDataChanged();
fireTableStructureChanged();
}
public boolean isCellEditable(int ligne,int colonne){
return true;
}
} |
Partager