Articles

[Java] Matrices

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 Java

Té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;
}
}

[Java] Procédé de Gram-Schmidt à partir de trois points

Application du procédé d'orthonormalisation de Gram-Schmidt pour obtenir les vecteurs du repère formé par trois points javax.vecmath.Point3d. Cette méthode retourne les trois vecteurs e1,e2,e3 qui composent le repère. Pour plus de détails, voyez l'article sur Wikipédia : Procédé de Gram-Schmidt.

 

public static Vector3d[] gramSchmidt(Point3d o, Point3d a, Point3d b) {

Vector3d e2 = new Vector3d(a);
e2.scale(-1);
e2.add(b);
e2.normalize();

Vector3d AO = new Vector3d(a);
AO.scale(-1);
AO.add(o);

double PS = AO.dot(e2);
Vector3d AC = new Vector3d(e2);
AC.scale(PS);

Vector3d CO = new Vector3d(AC);
CO.scale(-1);
CO.add(AO);

Vector3d e1 = new Vector3d(CO);
e1.normalize();

Vector3d e3 = new Vector3d();
e3.cross(e1, e2);
e3.normalize();

return new Vector3d[] { e1, e2, e3 };

}

[Java] Calculer l'equation de la droite perpendiculaire à la droite AB et passant par B

/**
* Soit la droite (ab), on cherche l'equation de la droite (D) tel
* que (D) est perpendiculaire à (ab) et passe par b
*/

public static double[] getPerpendiculaire(Point2d a, Point2d b) {
return getPerpendiculaire(lineEquation(a, b), b);
}

public static double[] getPerpendiculaire(double[] eq, Point2d b) {
double coef = -1 / eq[0];
double pos = b.y - coef * b.x;
return new double[] { coef, pos };
}