net.sf.jaer.util
Class Matrix

java.lang.Object
  net.sf.jaer.util.Matrix

public class Matrix
extends java.lang.Object

// Matrix.java // solve, invert, etc. last argument is output // void solve(float A[][], float Y[], float X[]); X=A^-1*Y // void invert(float A[][]); A=A^-1 // float determinant(float A[]); d=det A // void eigenvalues(float A[][], float V[][], float Y[]); V,Y=eigen A // void checkeigen(float A[][], V[][], float Y[]); printout // void multiply(float A[][], float B[][], float C[][]); C=A*B // void add(float A[][], float B[][], float C[][]); C=A+B // void subtract(float C[][], float A[][], float B[][]); C=A-B // float norm1(float A[][]); d=norm1 A // float norm2(float A[][]); sqrt largest eigenvalue A^T*A d=norm2 A // float normFro(float A[][]); Frobenius d=normFro A // float normInf(float A[][]); d=normInf A // void identity(float A[][]); A=I // void zero(float A[][]); A=0 // void copy(float A[][], floatB[][]); B=A // void boolean equals(float A[][], floatB[][]); B==A // void print(float A[][]); A // void multiply(float A[][], float X[], float Y[]); Y=A*X // void add(float X[], float Y[], float Z[]); Z=X+Y // void subtract(float X[], float Y[], float Z[]); Z=X-Y // float norm1(float X[]); d=norm1 X // float norm2(float X[]); d=norm2 X // float normInf(float X[]); d=normInf X // void unitVector(float X[], int i); X[i]=1 else 0 // void zero(float X[]); X=0 // void copy(float X[], float Y[]); Y=X // void boolean equals(float X[], floatY[]); X==Y // void print(float X[]); X

Author:

Janick Cardinale

Constructor Summary

Matrix()

Method Summary

static void	add(float[][] A, float[][] B, float[][] C)
static void	add(float[] X, float[] Y, float[] Z)
static float[][]	addMatrix(float[][] a, float[][] b)
static void	copy(float[][] A, float[][] B)
static void	copy(float[] X, float[] Y)
static float	determinant(float[][] A)
static void	eigenCheck(float[][] A, float[][] V, float[] Y) // check A * X = lambda X lambda=Y[i] X=V[i]
static void	eigenvalues(float[][] A, float[][] V, float[] Y) // cyclic Jacobi iterative method of finding eigenvalues // advertized for symmetric real
static boolean	equals(float[][] A, float[][] B)
static boolean	equals(float[] X, float[] Y)
static void	identity(float[][] A)
static void	invert(float[][] A)
static void	multiply(float[][] A, float[][] B, float[][] C)
static void	multiply(float[][] A, float[] B, float[] C)
static float[][]	multMatrix(float[][] a, float s)
static float[]	multMatrix(float[][] a, float[] x)
static float[][]	multMatrix(float[][] a, float[][] b)
static float	norm1(float[] X)
static float	norm1(float[][] A)
static float	norm2(float[] X)
static float	norm2(float[][] A)
static float	normFro(float[][] A)
static float	normInf(float[] X)
static float	normInf(float[][] A)
static void	print(float[] X)
static void	print(float[][] A)
static void	solve(float[][] A, float[] Y, float[] X) // solve real linear equations for X where Y = A * X // method: Gauss-Jordan elimination using maximum pivot // usage: Matrix.solve(A,Y,X); // Translated to java by : Jon Squire , 26 March 2003 // First written by Jon Squire December 1959 for IBM 650, translated to // other languages e.g.
static void	subtract(float[][] A, float[][] B, float[][] C)
static void	subtract(float[] X, float[] Y, float[] Z)
static float[][]	transposeMatrix(float[][] a)
static void	unitVector(float[] X, int j)
static void	zero(float[] X)
static void	zero(float[][] A)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Matrix

public Matrix()

Method Detail

solve

public static void solve(float[][] A,
                         float[] Y,
                         float[] X)

// solve real linear equations for X where Y = A * X // method: Gauss-Jordan elimination using maximum pivot // usage: Matrix.solve(A,Y,X); // Translated to java by : Jon Squire , 26 March 2003 // First written by Jon Squire December 1959 for IBM 650, translated to // other languages e.g. Fortran converted to Ada converted to C // converted to java

Parameters:

A -

Y -

X -

invert

public static final void invert(float[][] A)

determinant

public static final float determinant(float[][] A)

eigenvalues

public static final void eigenvalues(float[][] A,
                                     float[][] V,
                                     float[] Y)

// cyclic Jacobi iterative method of finding eigenvalues // advertized for symmetric real

Parameters:

A - the matrix

V - eigenvectors

Y - the vector of eigenvalues

eigenCheck

public static final void eigenCheck(float[][] A,
                                    float[][] V,
                                    float[] Y)

// check A * X = lambda X lambda=Y[i] X=V[i]

Parameters:

A -

V -

Y -

multiply

public static final void multiply(float[][] A,
                                  float[][] B,
                                  float[][] C)

add

public static final void add(float[][] A,
                             float[][] B,
                             float[][] C)

addMatrix

public static final float[][] addMatrix(float[][] a,
                                        float[][] b)

subtract

public static final void subtract(float[][] A,
                                  float[][] B,
                                  float[][] C)

norm1

public static final float norm1(float[][] A)

normInf

public static final float normInf(float[][] A)

identity

public static final void identity(float[][] A)

zero

public static final void zero(float[][] A)

normFro

public static final float normFro(float[][] A)

norm2

public static final float norm2(float[][] A)

copy

public static final void copy(float[][] A,
                              float[][] B)

equals

public static final boolean equals(float[][] A,
                                   float[][] B)

print

public static final void print(float[][] A)

multiply

public static final void multiply(float[][] A,
                                  float[] B,
                                  float[] C)

multMatrix

public static final float[][] multMatrix(float[][] a,
                                         float s)

multMatrix

public static final float[][] multMatrix(float[][] a,
                                         float[][] b)

multMatrix

public static final float[] multMatrix(float[][] a,
                                       float[] x)

add

public static final void add(float[] X,
                             float[] Y,
                             float[] Z)

subtract

public static final void subtract(float[] X,
                                  float[] Y,
                                  float[] Z)

transposeMatrix

public static final float[][] transposeMatrix(float[][] a)

norm1

public static final float norm1(float[] X)

norm2

public static final float norm2(float[] X)

normInf

public static final float normInf(float[] X)

unitVector

public static final void unitVector(float[] X,
                                    int j)

zero

public static final void zero(float[] X)

copy

public static final void copy(float[] X,
                              float[] Y)

equals

public static final boolean equals(float[] X,
                                   float[] Y)

print

public static final void print(float[] X)