Bon alors dans la série Java2D, aujourd'hui : les matrices.
Matrices usuelles
Matrice de rotation 2D
Matrice de rotation 3D autour de l'axe X
Matrice de rotation 3D autour de l'axe Y
Matrice de rotation 3D autour de l'axe Z
Outils Java
public static Matrix toMatrix(Vector3d v) {
return new Matrix(new double[][] {
new double[] { v.x },
new double[] { v.y },
new double[] { v.z }
});
}
Classe Matrix
Il s'agit d'une classe toute simple pour représenter une matrice ainsi que les opérations de bases (addition, multiplication, inversion et résolution avec l'algorithme de Gauss-Jordan). Si vous cherchez quelque chose de plus puissant regardez le Matrix Toolkit for JavaTélécharger le fichier Matrix.java
Afficher Matrix.java dans cette fenêtre
// Matrix.java
// a simple java file for a standard class
/**
* class Matrix
*/
public class Matrix{
// ===================================================================
// constants
// ===================================================================
// class variables
/** the number of rows. */
private int nRows;
/** the number of columns. */
private int nCols;
/** the element array of the matrix.*/
private double[][] el;
// ===================================================================
// constructors
/** Main constructor */
/**
* Construct a new Matrix, with 1 row and 1 column, initialized to 1.
*/
public Matrix(){
this(1, 1);
}
/** init a new Matrix with nbRows rows, and nbCols columns. */
public Matrix(int nbRows, int nbCols){
nRows = nbRows;
nCols = nbCols;
el = new double[nRows][nCols];
setToIdentity();
}
/**
* Construct a new Matrix, initialized with the given coefficients.
*/
public Matrix(double[][] coef){
if(coef==null){
nRows = 1;
nCols = 1;
el = new double[nRows][nCols];
setToIdentity();
return;
}
nRows = coef.length;
nCols = coef[0].length;
el = new double[nRows][nCols];
for(int r=0; r<nRows; r++)
for(int c=0; c<nCols; c++)
el[r][c] = coef[r][c];
}
public Matrix(Matrix m) {
this(m.el);
}
// ===================================================================
// accessors
/**
* return the coef. row and col are between 1 and the number of rows and columns.
*/
public double getCoef(int row, int col){
return el[row][col];
}
/** return the number of rows. */
public int getRows(){
return nRows;
}
/** return the number of columns. */
public int getColumns(){
return nCols;
}
/** return true if the matrix is square, i.e. the number of rows equals the number
* of columns. */
public boolean isSquare(){
return (nCols==nRows);
}
// ===================================================================
// modifiers
/**
* set the coef to the given value. row and col are between 1 and the
* number of rows and columns.
*/
public void setCoef(int row, int col, double coef){
el[row-1][col-1] = coef;
}
// ===================================================================
// computation methods
/**
* return the result of the multiplication of the matriux with another one.
* The content of the matrix is not modified.
*/
public Matrix multiplyWith(Matrix matrix){
//System.out.println(nCols+" != "+matrix.nRows);
// check sizes of the matrices
if(nCols != matrix.nRows){
System.out.println("Matrices size don't match ! ("+nCols+" != "+matrix.nRows+")");
return null;
}
double sum;
Matrix m = new Matrix(nRows, matrix.nCols);
for(int r=0; r<m.nRows; r++)
for(int c=0; c<m.nCols; c++){
sum=0;
for(int i=0; i<nCols; i++)
sum+=el[r][i]*matrix.el[i][c];
m.el[r][c] = sum;
}
return m;
}
/**
* return the result of the multiplication of the matrix with the given vector.
* The content of the matrix is not modified.
*/
public double[] multiplyWith(double [] coefs){
if(coefs==null){
System.out.println("no data to compute");
return null;
}
// check sizes of matrix and vector
if(coefs.length != nCols){
System.out.println("Matrices size don't match !");
return null;
}
double sum;
double[]res = new double[nRows];
for(int r=0; r<nRows; r++){
sum=0;
for(int c=0; c<nCols; c++)
sum+=el[r][c]*coefs[c];
res[r] = sum;
}
return res;
}
/**
* return the result of the multiplication of the matrix with the given vector.
* The content of the matrix is not modified.
*/
public double[] multiplyWith(double []src, double[]res){
if(src==null){
System.out.println("no data to compute");
return null;
}
// check sizes of matrix and vector
if(src.length != nCols){
System.out.println("Matrices size don't match !");
return null;
}
if(src.length != res.length)
res = new double[nRows];
double sum;
for(int r=0; r<nRows; r++){
sum=0;
for(int c=0; c<nCols; c++)
sum+=el[r][c]*src[c];
res[r] = sum;
}
return res;
}
/** transpose the matrix, changing the inner coefficients. */
public void transpose(){
int tmp = nCols;
nCols = nRows;
nRows = tmp;
double[][] oldData = el;
el = new double[nRows][nCols];
for(int r=0; r<nRows; r++)
for(int c=0; c<nCols; c++)
el[r][c] = oldData[c][r];
}
/** get the transposed matrix, without changing the inner coefficients
* of the original matrix. */
public Matrix getTranspose(){
Matrix mat = new Matrix(nCols, nRows);
for(int r=0; r<nRows; r++)
for(int c=0; c<nCols; c++)
mat.el[c][r] = el[r][c];
return mat;
}
/**
* compute the solution of a linear system, using the Gauss-Jordan algorithm. The
* inner coefficients of the matrix are not modified.
*/
public double[] solve(double vector []){
if(vector==null) throw new NullPointerException();
if(vector.length != nRows){
System.out.println("matrix and vector dimensions do not match!");
return null;
}
if(nCols != nRows){
System.out.println("Try to invert non square Matrix.");
return null;
}
double[] res = new double[vector.length];
for(int i=0; i<nRows; i++) res[i]=vector[i];
Matrix mat = new Matrix(el);
int r, c; // row and column indices
int p, r2; // pivot index, and secondary row index
double pivot, tmp;
// for each line of the matrix
for(r=0; r<nRows; r++){
p = r;
// look for the first non-null pivot
while((Math.abs(mat.el[p][r])<1e-15) && (p <= nRows))
p ++;
if(p==nRows){
System.out.println("Degenerated linear system :");
return null;
}
// swap the current line and the pivot
for(c=0; c<nRows; c++){
tmp = mat.el[r][c];
mat.el[r][c] = mat.el[p][c];
mat.el[p][c] = tmp;
}
// swap the corresponding values in the vector
tmp = res[r];
res[r] = res[p];
res[p] = tmp;
pivot = mat.el[r][r];
// divide elements of the current line by the pivot
for (c=r+1; c<nRows; c++)
mat.el[r][c] /= pivot;
res[r] /= pivot;
mat.el[r][r]=1;
// update other lines, before current line...
for (r2=0; r2<r; r2++){
pivot = mat.el[r2][r];
for(c=r+1; c<nRows; c++)
mat.el[r2][c] -= pivot*mat.el[r][c];
res[r2] -= pivot*res[r];
mat.el[r2][r] = 0;
}
// and after current line
for (r2=r+1; r2<nRows; r2++){
pivot = mat.el[r2][r];
for(c=r+1; c<nRows; c++)
mat.el[r2][c] -= pivot*mat.el[r][c];
res[r2] -= pivot*res[r];
mat.el[r2][r] = 0;
}
}
return res;
}
// ===================================================================
// general methods
/**
* Fill the matrix with zeros everywhere, except on the main diagonal, filled
* with ones.*/
public void setToIdentity(){
for(int r=0; r<nRows; r++)
for(int c=0; c<nCols; c++)
el[r][c] = 0;
for(int i=Math.min(nRows, nCols)-1; i>=0; i--)
el[i][i] = 1;
}
/**
* return a String representation of the elements of the Matrix
*/
public String toString(){
String res = new String("");
res = res.concat("Matrix size : " + Integer.toString(nRows) +
" rows and " + Integer.toString(nCols) + " columns.\n");
for(int r=0; r<nRows; r++){
for(int c=0; c<nCols; c++)
res = res.concat(Double.toString(el[r][c])).concat(" ");
res = res.concat(new String("\n"));
}
return res;
}
}