D getDecomposition() {
return alg.getDecomposition();
}
}
ejml-0.28/main/core/src/org/ejml/data/ 0000775 0000000 0000000 00000000000 12561715344 0017474 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/src/org/ejml/data/BlockMatrix64F.java 0000664 0000000 0000000 00000011107 12561715344 0023036 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.EjmlParameters;
import org.ejml.ops.MatrixIO;
/**
* A row-major block matrix declared on to one continuous array.
*
* @author Peter Abeles
*/
public class BlockMatrix64F extends D1Matrix64F {
public int blockLength;
public BlockMatrix64F( int numRows , int numCols , int blockLength)
{
this.data = new double[ numRows * numCols ];
this.blockLength = blockLength;
this.numRows = numRows;
this.numCols = numCols;
}
public BlockMatrix64F( int numRows , int numCols )
{
this(numRows,numCols, EjmlParameters.BLOCK_WIDTH);
}
public BlockMatrix64F(){}
public void set( BlockMatrix64F A ) {
this.blockLength = A.blockLength;
this.numRows = A.numRows;
this.numCols = A.numCols;
int N = numCols*numRows;
if( data.length < N )
data = new double[ N ];
System.arraycopy(A.data,0,data,0,N);
}
public static BlockMatrix64F wrap( double data[] , int numRows , int numCols , int blockLength )
{
BlockMatrix64F ret = new BlockMatrix64F();
ret.data = data;
ret.numRows = numRows;
ret.numCols = numCols;
ret.blockLength = blockLength;
return ret;
}
@Override
public double[] getData() {
return data;
}
@Override
public void reshape(int numRows, int numCols, boolean saveValues)
{
if( numRows*numCols <= data.length ) {
this.numRows = numRows;
this.numCols = numCols;
} else {
double[] data = new double[ numRows*numCols ];
if( saveValues ) {
System.arraycopy(this.data,0,data,0,getNumElements());
}
this.numRows = numRows;
this.numCols = numCols;
this.data = data;
}
}
public void reshape(int numRows, int numCols, int blockLength , boolean saveValues) {
this.blockLength = blockLength;
this.reshape(numRows,numCols,saveValues);
}
@Override
public int getIndex( int row, int col ) {
// find the block it is inside
int blockRow = row / blockLength;
int blockCol = col / blockLength;
int localHeight = Math.min(numRows - blockRow*blockLength , blockLength);
int index = blockRow*blockLength*numCols + blockCol* localHeight * blockLength;
int localLength = Math.min(numCols - blockLength*blockCol , blockLength);
row = row % blockLength;
col = col % blockLength;
return index + localLength * row + col;
}
@Override
public double get( int row, int col) {
return data[ getIndex(row,col)];
}
@Override
public double unsafe_get( int row, int col) {
return data[ getIndex(row,col)];
}
@Override
public void set( int row, int col, double val) {
data[ getIndex(row,col)] = val;
}
@Override
public void unsafe_set( int row, int col, double val) {
data[ getIndex(row,col)] = val;
}
@Override
public int getNumRows() {
return numRows;
}
@Override
public int getNumCols() {
return numCols;
}
@Override
public void set(Matrix original) {
if( original instanceof BlockMatrix64F ) {
set((BlockMatrix64F)original);
} else {
RealMatrix64F m = (RealMatrix64F) original;
for (int i = 0; i < numRows; i++) {
for (int j = 0; j < numCols; j++) {
set(i, j, m.get(i, j));
}
}
}
}
@Override
public int getNumElements() {
return numRows*numCols;
}
@Override
public void print() {
MatrixIO.print(System.out,this);
}
public BlockMatrix64F copy() {
BlockMatrix64F A = new BlockMatrix64F(numRows,numCols,blockLength);
A.set(this);
return A;
}
}
ejml-0.28/main/core/src/org/ejml/data/CD1Matrix64F.java 0000664 0000000 0000000 00000006153 12561715344 0022360 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixDimensionException;
/**
* A generic abstract class for matrices whose data is stored in a single 1D array of doubles. The
* format of the elements in this array is not specified. For example row major, column major,
* and block row major are all common formats.
*
* @author Peter Abeles
*/
public abstract class CD1Matrix64F implements ComplexMatrix64F, ReshapeMatrix{
/**
* Where the raw data for the matrix is stored. The format is type dependent.
*/
public double[] data;
/**
* Number of rows in the matrix.
*/
public int numRows;
/**
* Number of columns in the matrix.
*/
public int numCols;
/**
* Used to get a reference to the internal data.
*
* @return Reference to the matrix's data.
*/
public double[] getData() {
return data;
}
/**
* Changes the internal array reference.
*/
public void setData( double[] data ) {
this.data = data;
}
/**
* Returns the internal array index for the specified row and column.
*
* @param row Row index.
* @param col Column index.
* @return Internal array index.
*/
public abstract int getIndex( int row, int col );
/**
* Sets the value of this matrix to be the same as the value of the provided matrix. Both
* matrices must have the same shape:
*
* aij = bij
*
*
* @param b The matrix that this matrix is to be set equal to.
*/
public void set( CD1Matrix64F b )
{
if( numRows != b.numRows || numCols != b.numCols ) {
throw new MatrixDimensionException("The two matrices do not have compatible shapes.");
}
int dataLength = b.getDataLength();
System.arraycopy(b.data, 0, this.data, 0, dataLength);
}
/**
* {@inheritDoc}
*/
@Override
public int getNumRows() {
return numRows;
}
/**
* {@inheritDoc}
*/
@Override
public int getNumCols() {
return numCols;
}
/**
* Sets the number of rows.
*
* @param numRows Number of rows
*/
public void setNumRows(int numRows) {
this.numRows = numRows;
}
/**
* Sets the number of columns.
*
* @param numCols Number of columns
*/
public void setNumCols(int numCols) {
this.numCols = numCols;
}
} ejml-0.28/main/core/src/org/ejml/data/CDenseMatrix64F.java 0000664 0000000 0000000 00000014270 12561715344 0023151 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
* Dense matrix for complex numbers. Internally it stores its data in a single row-major array with the real
* and imaginary components interlaces, in that order. The total number of elements in the array will be
* numRows*numColumns*2.
*
* @author Peter Abeles
*/
public class CDenseMatrix64F extends CD1Matrix64F {
/**
*
* Creates a matrix with the values and shape defined by the 2D array 'data'.
* It is assumed that 'data' has a row-major formatting:
*
* data[ row ][ column ]
*
* @param data 2D array representation of the matrix. Not modified.
*/
public CDenseMatrix64F( double data[][] ) {
this.numRows = data.length;
this.numCols = data[0].length/2;
this.data = new double[ numRows * numCols * 2 ];
for (int i = 0; i < numRows; i++) {
double[] row = data[i];
if( row.length != numCols*2 )
throw new IllegalArgumentException("Unexpected row size in input data at row "+i);
System.arraycopy(row,0,this.data,i*numCols*2,row.length);
}
}
public CDenseMatrix64F(int numRows, int numCols, boolean rowMajor, double... data) {
if( data.length != numRows*numCols*2 )
throw new RuntimeException("Unexpected length for data");
this.data = new double[ numRows * numCols * 2 ];
this.numRows = numRows;
this.numCols = numCols;
set(numRows,numCols, rowMajor, data);
}
/**
* Creates a new {@link org.ejml.data.CDenseMatrix64F} which is a copy of the passed in matrix.
* @param original Matrix which is to be copied
*/
public CDenseMatrix64F(CDenseMatrix64F original) {
this(original.numRows, original.numCols);
set(original);
}
/**
* Creates a new matrix with the specified number of rows and columns
*
* @param numRows number of rows
* @param numCols number of columns
*/
public CDenseMatrix64F(int numRows, int numCols) {
this.numRows = numRows;
this.numCols = numCols;
this.data = new double[numRows*numCols*2];
}
@Override
public int getIndex(int row, int col) {
return row*numCols*2 + col*2;
}
@Override
public void reshape( int numRows , int numCols ) {
int newLength = numRows*numCols*2;
if( newLength > data.length ) {
data = new double[newLength];
}
this.numRows = numRows;
this.numCols = numCols;
}
@Override
public void get(int row, int col, Complex64F output) {
int index = row*numCols*2 + col*2;
output.real = data[index];
output.imaginary = data[index+1];
}
@Override
public void set(int row, int col, double real, double imaginary) {
int index = row*numCols*2 + col*2;
data[index] = real;
data[index+1] = imaginary;
}
@Override
public double getReal(int row, int col) {
return data[row*numCols*2 + col*2];
}
@Override
public void setReal(int row, int col, double val) {
data[row*numCols*2 + col*2] = val;
}
@Override
public double getImaginary(int row, int col) {
return data[row*numCols*2 + col*2 + 1];
}
@Override
public void setImaginary(int row, int col, double val) {
data[row*numCols*2 + col*2 + 1] = val;
}
@Override
public int getDataLength() {
return numRows*numCols*2;
}
public void set( CDenseMatrix64F original ) {
reshape(original.numRows,original.numCols);
int columnSize = numCols*2;
for (int y = 0; y < numRows; y++) {
int index = y*numCols*2;
System.arraycopy(original.data,index,data,index,columnSize);
}
}
@Override
public CDenseMatrix64F copy() {
return new CDenseMatrix64F(this);
}
@Override
public void set(Matrix original) {
reshape(original.getNumRows(),original.getNumCols());
ComplexMatrix64F n = (ComplexMatrix64F)original;
Complex64F c = new Complex64F();
for (int i = 0; i < numRows; i++) {
for (int j = 0; j < numCols; j++) {
n.get(i,j,c);
set(i,j,c.real,c.imaginary);
}
}
}
@Override
public void print() {
MatrixIO.print(System.out, this);
}
/**
* Number of array elements in the matrix's row.
*/
public int getRowStride() {
return numCols*2;
}
/**
* Sets this matrix equal to the matrix encoded in the array.
*
* @param numRows The number of rows.
* @param numCols The number of columns.
* @param rowMajor If the array is encoded in a row-major or a column-major format.
* @param data The formatted 1D array. Not modified.
*/
public void set(int numRows, int numCols, boolean rowMajor, double ...data)
{
reshape(numRows,numCols);
int length = numRows*numCols*2;
if( length > data.length )
throw new RuntimeException("Passed in array not long enough");
if( rowMajor ) {
System.arraycopy(data,0,this.data,0,length);
} else {
int index = 0;
int stride = numRows*2;
for( int i = 0; i < numRows; i++ ) {
for( int j = 0; j < numCols; j++ ) {
this.data[index++] = data[j*stride+i*2];
this.data[index++] = data[j*stride+i*2+1];
}
}
}
}
}
ejml-0.28/main/core/src/org/ejml/data/Complex64F.java 0000664 0000000 0000000 00000005347 12561715344 0022237 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.ComplexMath64F;
import java.io.Serializable;
/**
*
* Represents a complex number using 64bit floating point numbers. A complex number is composed of
* a real and imaginary components.
*
*/
public class Complex64F implements Serializable {
public double real;
public double imaginary;
public Complex64F(double real, double imaginary) {
this.real = real;
this.imaginary = imaginary;
}
public Complex64F() {
}
public double getReal() {
return real;
}
public double getMagnitude() {
return Math.sqrt(real*real + imaginary*imaginary);
}
public double getMagnitude2() {
return real*real + imaginary*imaginary;
}
public void setReal(double real) {
this.real = real;
}
public double getImaginary() {
return imaginary;
}
public void setImaginary(double imaginary) {
this.imaginary = imaginary;
}
public void set(double real, double imaginary) {
this.real = real;
this.imaginary = imaginary;
}
public void set(Complex64F a) {
this.real = a.real;
this.imaginary = a.imaginary;
}
public boolean isReal() {
return imaginary == 0.0;
}
public String toString() {
if( imaginary == 0 ) {
return ""+real;
} else {
return real+" "+imaginary+"i";
}
}
public Complex64F plus( Complex64F a ) {
Complex64F ret = new Complex64F();
ComplexMath64F.plus(this,a,ret);
return ret;
}
public Complex64F minus( Complex64F a ) {
Complex64F ret = new Complex64F();
ComplexMath64F.minus(this, a, ret);
return ret;
}
public Complex64F times( Complex64F a ) {
Complex64F ret = new Complex64F();
ComplexMath64F.multiply(this,a,ret);
return ret;
}
public Complex64F divide( Complex64F a ) {
Complex64F ret = new Complex64F();
ComplexMath64F.divide(this,a,ret);
return ret;
}
}
ejml-0.28/main/core/src/org/ejml/data/ComplexMatrix64F.java 0000664 0000000 0000000 00000005340 12561715344 0023415 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
/**
* Interface for all complex 64 bit floating point rectangular matrices.
*
* @author Peter Abeles
*/
public interface ComplexMatrix64F extends Matrix {
/**
* Returns the complex value of the matrix's element
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @param output Storage for the complex number
*/
public void get( int row , int col , Complex64F output );
/**
* Set's the complex value of the matrix's element
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @param real The real component
* @param imaginary The imaginary component
*/
public void set( int row , int col , double real , double imaginary );
/**
* Returns the real component of the matrix's element.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @return The specified element's value.
*/
public double getReal(int row, int col);
/**
* Sets the real component of the matrix's element.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @param val The element's new value.
*/
public void setReal(int row, int col, double val);
/**
* Returns the imaginary component of the matrix's element.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @return The specified element's value.
*/
public double getImaginary(int row, int col);
/**
* Sets the imaginary component of the matrix's element.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @param val The element's new value.
*/
public void setImaginary(int row, int col, double val);
/**
* Returns the number of elements in the internal data array
*
* @return Number of elements in the data array.
*/
public int getDataLength();
}
ejml-0.28/main/core/src/org/ejml/data/ComplexPolar64F.java 0000664 0000000 0000000 00000003224 12561715344 0023225 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.ComplexMath64F;
/**
*
* {@link Complex64F} number in polar notation.
* z = r*(cos(θ) + i*sin(θ))
* where r and θ are polar coordinate parameters
*
* @author Peter Abeles
*/
public class ComplexPolar64F {
public double r;
public double theta;
public ComplexPolar64F(double r, double theta) {
this.r = r;
this.theta = theta;
}
public ComplexPolar64F( Complex64F n ) {
ComplexMath64F.convert(n, this);
}
public ComplexPolar64F() {
}
public Complex64F toStandard() {
Complex64F ret = new Complex64F();
ComplexMath64F.convert(this, ret);
return ret;
}
public double getR() {
return r;
}
public void setR(double r) {
this.r = r;
}
public double getTheta() {
return theta;
}
public void setTheta(double theta) {
this.theta = theta;
}
public String toString() {
return "( r = "+r+" theta = "+theta+" )";
}
}
ejml-0.28/main/core/src/org/ejml/data/D1Matrix32F.java 0000664 0000000 0000000 00000021662 12561715344 0022252 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
/**
* A generic abstract class for matrices whose data is stored in a single 1D array of floats. The
* format of the elements in this array is not specified. For example row major, column major,
* and block row major are all common formats.
*
* @author Peter Abeles
*/
public abstract class D1Matrix32F implements ReshapeMatrix, RealMatrix32F {
/**
* Where the raw data for the matrix is stored. The format is type dependent.
*/
public float[] data;
/**
* Number of rows in the matrix.
*/
public int numRows;
/**
* Number of columns in the matrix.
*/
public int numCols;
/**
* Used to get a reference to the internal data.
*
* @return Reference to the matrix's data.
*/
public float[] getData() {
return data;
}
/**
* Changes the internal array reference.
*/
public void setData( float[] data ) {
this.data = data;
}
/**
* Returns the internal array index for the specified row and column.
*
* @param row Row index.
* @param col Column index.
* @return Internal array index.
*/
public abstract int getIndex( int row, int col );
/**
* Sets the value of this matrix to be the same as the value of the provided matrix. Both
* matrices must have the same shape:
*
* aij = bij
*
*
* @param b The matrix that this matrix is to be set equal to.
*/
public void set( D1Matrix32F b )
{
this.reshape(b.numRows,b.numCols);
int dataLength = b.getNumElements();
System.arraycopy(b.data, 0, this.data, 0, dataLength);
}
/**
* Returns the value of the matrix at the specified internal array index. The element at which row and column
* returned by this function depends upon the matrix's internal structure, e.g. row-major, column-major, or block.
*
* @param index Internal array index.
* @return Value at the specified index.
*/
public float get( int index ) {
return data[index];
}
/**
* Sets the element's value at the specified index. The element at which row and column
* modified by this function depends upon the matrix's internal structure, e.g. row-major, column-major, or block.
*
* @param index Index of element that is to be set.
* @param val The new value of the index.
*/
public float set( int index , float val ) {
// See benchmarkFunctionReturn. Pointless return does not degrade performance. Tested on JDK 1.6.0_21
return data[index] = val;
}
/**
*
* Adds the specified value to the internal data array at the specified index.
*
* Equivalent to: this.data[index] += val;
*
*
*
* Intended for use in highly optimized code. The row/column coordinate of the modified element is
* dependent upon the matrix's internal structure.
*
*
* @param index The index which is being modified.
* @param val The value that is being added.
*/
public float plus( int index , float val ) {
// See benchmarkFunctionReturn. Pointless return does not degrade performance. Tested on JDK 1.6.0_21
return data[index] += val;
}
/**
*
* Subtracts the specified value to the internal data array at the specified index.
*
* Equivalent to: this.data[index] -= val;
*
*
*
* Intended for use in highly optimized code. The row/column coordinate of the modified element is
* dependent upon the matrix's internal structure.
*
*
* @param index The index which is being modified.
* @param val The value that is being subtracted.
*/
public float minus( int index , float val ) {
// See benchmarkFunctionReturn. Pointless return does not degrade performance. Tested on JDK 1.6.0_21
return data[index] -= val;
}
/**
*
* Multiplies the specified value to the internal data array at the specified index.
*
* Equivalent to: this.data[index] *= val;
*
*
*
* Intended for use in highly optimized code. The row/column coordinate of the modified element is
* dependent upon the matrix's internal structure.
*
*
* @param index The index which is being modified.
* @param val The value that is being multiplied.
*/
public float times( int index , float val ) {
// See benchmarkFunctionReturn. Pointless return does not degrade performance. Tested on JDK 1.6.0_21
return data[index] *= val;
}
/**
*
* Divides the specified value to the internal data array at the specified index.
*
* Equivalent to: this.data[index] /= val;
*
*
*
* Intended for use in highly optimized code. The row/column coordinate of the modified element is
* dependent upon the matrix's internal structure.
*
*
* @param index The index which is being modified.
* @param val The value that is being divided.
*/
public float div( int index , float val ) {
// See benchmarkFunctionReturn. Pointless return does not degrade performance. Tested on JDK 1.6.0_21
return data[index] /= val;
}
/**
*
* Changes the number of rows and columns in the matrix, allowing its size to grow or shrink.
* If the saveValues flag is set to true, then the previous values will be maintained, but
* reassigned to new elements in a row-major ordering. If saveValues is false values will only
* be maintained when the requested size is less than or equal to the internal array size.
* The primary use for this function is to encourage data reuse and avoid unnecessarily declaring
* and initialization of new memory.
*
*
*
* Examples:
* [ 1 2 ; 3 4 ] -> reshape( 2 , 3 , true ) = [ 1 2 3 ; 4 0 0 ]
* [ 1 2 ; 3 4 ] -> reshape( 1 , 2 , true ) = [ 1 2 ]
* [ 1 2 ; 3 4 ] -> reshape( 1 , 2 , false ) = [ 1 2 ]
* [ 1 2 ; 3 4 ] -> reshape( 2 , 3 , false ) = [ 0 0 0 ; 0 0 0 ]
*
*
* @param numRows The new number of rows in the matrix.
* @param numCols The new number of columns in the matrix.
* @param saveValues If true then the value of each element will be save using a row-major reordering. Typically this should be false.
*/
public abstract void reshape(int numRows, int numCols, boolean saveValues);
/**
* Equivalent to invoking reshape(numRows,numCols,false);
*
* @param numRows The new number of rows in the matrix.
* @param numCols The new number of columns in the matrix.
*/
@Override
public void reshape( int numRows , int numCols ) {
reshape(numRows,numCols,false);
}
/**
* Creates a new iterator for traversing through a submatrix inside this matrix. It can be traversed
* by row or by column. Range of elements is inclusive, e.g. minRow = 0 and maxRow = 1 will include rows
* 0 and 1. The iteration starts at (minRow,minCol) and ends at (maxRow,maxCol)
*
* @param rowMajor true means it will traverse through the submatrix by row first, false by columns.
* @param minRow first row it will start at.
* @param minCol first column it will start at.
* @param maxRow last row it will stop at.
* @param maxCol last column it will stop at.
* @return A new MatrixIterator
*/
public MatrixIterator32F iterator(boolean rowMajor, int minRow, int minCol, int maxRow, int maxCol)
{
return new MatrixIterator32F(this,rowMajor, minRow, minCol, maxRow, maxCol);
}
/**
* {@inheritDoc}
*/
@Override
public int getNumRows() {
return numRows;
}
/**
* {@inheritDoc}
*/
@Override
public int getNumCols() {
return numCols;
}
/**
* Sets the number of rows.
*
* @param numRows Number of rows
*/
public void setNumRows(int numRows) {
this.numRows = numRows;
}
/**
* Sets the number of columns.
*
* @param numCols Number of columns
*/
public void setNumCols(int numCols) {
this.numCols = numCols;
}
} ejml-0.28/main/core/src/org/ejml/data/D1Matrix64F.java 0000664 0000000 0000000 00000021701 12561715344 0022251 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
/**
* A generic abstract class for matrices whose data is stored in a single 1D array of doubles. The
* format of the elements in this array is not specified. For example row major, column major,
* and block row major are all common formats.
*
* @author Peter Abeles
*/
public abstract class D1Matrix64F implements ReshapeMatrix, RealMatrix64F {
/**
* Where the raw data for the matrix is stored. The format is type dependent.
*/
public double[] data;
/**
* Number of rows in the matrix.
*/
public int numRows;
/**
* Number of columns in the matrix.
*/
public int numCols;
/**
* Used to get a reference to the internal data.
*
* @return Reference to the matrix's data.
*/
public double[] getData() {
return data;
}
/**
* Changes the internal array reference.
*/
public void setData( double[] data ) {
this.data = data;
}
/**
* Returns the internal array index for the specified row and column.
*
* @param row Row index.
* @param col Column index.
* @return Internal array index.
*/
public abstract int getIndex( int row, int col );
/**
* Sets the value of this matrix to be the same as the value of the provided matrix. Both
* matrices must have the same shape:
*
* aij = bij
*
*
* @param b The matrix that this matrix is to be set equal to.
*/
public void set( D1Matrix64F b )
{
this.reshape(b.numRows,b.numCols);
int dataLength = b.getNumElements();
System.arraycopy(b.data, 0, this.data, 0, dataLength);
}
/**
* Returns the value of the matrix at the specified internal array index. The element at which row and column
* returned by this function depends upon the matrix's internal structure, e.g. row-major, column-major, or block.
*
* @param index Internal array index.
* @return Value at the specified index.
*/
public double get( int index ) {
return data[index];
}
/**
* Sets the element's value at the specified index. The element at which row and column
* modified by this function depends upon the matrix's internal structure, e.g. row-major, column-major, or block.
*
* @param index Index of element that is to be set.
* @param val The new value of the index.
*/
public double set( int index , double val ) {
// See benchmarkFunctionReturn. Pointless return does not degrade performance. Tested on JDK 1.6.0_21
return data[index] = val;
}
/**
*
* Adds the specified value to the internal data array at the specified index.
*
* Equivalent to: this.data[index] += val;
*
*
*
* Intended for use in highly optimized code. The row/column coordinate of the modified element is
* dependent upon the matrix's internal structure.
*
*
* @param index The index which is being modified.
* @param val The value that is being added.
*/
public double plus( int index , double val ) {
// See benchmarkFunctionReturn. Pointless return does not degrade performance. Tested on JDK 1.6.0_21
return data[index] += val;
}
/**
*
* Subtracts the specified value to the internal data array at the specified index.
*
* Equivalent to: this.data[index] -= val;
*
*
*
* Intended for use in highly optimized code. The row/column coordinate of the modified element is
* dependent upon the matrix's internal structure.
*
*
* @param index The index which is being modified.
* @param val The value that is being subtracted.
*/
public double minus( int index , double val ) {
// See benchmarkFunctionReturn. Pointless return does not degrade performance. Tested on JDK 1.6.0_21
return data[index] -= val;
}
/**
*
* Multiplies the specified value to the internal data array at the specified index.
*
* Equivalent to: this.data[index] *= val;
*
*
*
* Intended for use in highly optimized code. The row/column coordinate of the modified element is
* dependent upon the matrix's internal structure.
*
*
* @param index The index which is being modified.
* @param val The value that is being multiplied.
*/
public double times( int index , double val ) {
// See benchmarkFunctionReturn. Pointless return does not degrade performance. Tested on JDK 1.6.0_21
return data[index] *= val;
}
/**
*
* Divides the specified value to the internal data array at the specified index.
*
* Equivalent to: this.data[index] /= val;
*
*
*
* Intended for use in highly optimized code. The row/column coordinate of the modified element is
* dependent upon the matrix's internal structure.
*
*
* @param index The index which is being modified.
* @param val The value that is being divided.
*/
public double div( int index , double val ) {
// See benchmarkFunctionReturn. Pointless return does not degrade performance. Tested on JDK 1.6.0_21
return data[index] /= val;
}
/**
*
* Changes the number of rows and columns in the matrix, allowing its size to grow or shrink.
* If the saveValues flag is set to true, then the previous values will be maintained, but
* reassigned to new elements in a row-major ordering. If saveValues is false values will only
* be maintained when the requested size is less than or equal to the internal array size.
* The primary use for this function is to encourage data reuse and avoid unnecessarily declaring
* and initialization of new memory.
*
*
*
* Examples:
* [ 1 2 ; 3 4 ] -> reshape( 2 , 3 , true ) = [ 1 2 3 ; 4 0 0 ]
* [ 1 2 ; 3 4 ] -> reshape( 1 , 2 , true ) = [ 1 2 ]
* [ 1 2 ; 3 4 ] -> reshape( 1 , 2 , false ) = [ 1 2 ]
* [ 1 2 ; 3 4 ] -> reshape( 2 , 3 , false ) = [ 0 0 0 ; 0 0 0 ]
*
*
* @param numRows The new number of rows in the matrix.
* @param numCols The new number of columns in the matrix.
* @param saveValues If true then the value of each element will be save using a row-major reordering. Typically this should be false.
*/
public abstract void reshape(int numRows, int numCols, boolean saveValues);
/**
* Equivalent to invoking reshape(numRows,numCols,false);
*
* @param numRows The new number of rows in the matrix.
* @param numCols The new number of columns in the matrix.
*/
@Override
public void reshape( int numRows , int numCols ) {
reshape(numRows,numCols,false);
}
/**
* Creates a new iterator for traversing through a submatrix inside this matrix. It can be traversed
* by row or by column. Range of elements is inclusive, e.g. minRow = 0 and maxRow = 1 will include rows
* 0 and 1. The iteration starts at (minRow,minCol) and ends at (maxRow,maxCol)
*
* @param rowMajor true means it will traverse through the submatrix by row first, false by columns.
* @param minRow first row it will start at.
* @param minCol first column it will start at.
* @param maxRow last row it will stop at.
* @param maxCol last column it will stop at.
* @return A new MatrixIterator
*/
public MatrixIterator64F iterator(boolean rowMajor, int minRow, int minCol, int maxRow, int maxCol)
{
return new MatrixIterator64F(this,rowMajor, minRow, minCol, maxRow, maxCol);
}
/**
* {@inheritDoc}
*/
@Override
public int getNumRows() {
return numRows;
}
/**
* {@inheritDoc}
*/
@Override
public int getNumCols() {
return numCols;
}
/**
* Sets the number of rows.
*
* @param numRows Number of rows
*/
public void setNumRows(int numRows) {
this.numRows = numRows;
}
/**
* Sets the number of columns.
*
* @param numCols Number of columns
*/
public void setNumCols(int numCols) {
this.numCols = numCols;
}
} ejml-0.28/main/core/src/org/ejml/data/D1Submatrix64F.java 0000664 0000000 0000000 00000004730 12561715344 0022766 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
*
* Describes a rectangular submatrix inside of a {@link D1Matrix64F}.
*
*
*
* Rows are row0 <= i < row1 and Columns are col0 <= j < col1
*
*
* @author Peter Abeles
*/
public class D1Submatrix64F {
public D1Matrix64F original;
// bounding rows and columns
public int row0,col0;
public int row1,col1;
public D1Submatrix64F() {
}
public D1Submatrix64F(D1Matrix64F original) {
set(original);
}
public D1Submatrix64F(D1Matrix64F original,
int row0, int row1, int col0, int col1) {
set(original,row0,row1,col0,col1);
}
public void set(D1Matrix64F original,
int row0, int row1, int col0, int col1) {
this.original = original;
this.row0 = row0;
this.col0 = col0;
this.row1 = row1;
this.col1 = col1;
}
public void set(D1Matrix64F original) {
this.original = original;
row1 = original.numRows;
col1 = original.numCols;
}
public int getRows() {
return row1 - row0;
}
public int getCols() {
return col1 - col0;
}
public double get(int row, int col ) {
return original.get(row+row0,col+col0);
}
public void set(int row, int col, double value) {
original.set(row+row0,col+col0,value);
}
public DenseMatrix64F extract() {
DenseMatrix64F ret = new DenseMatrix64F(row1-row0,col1-col0);
for( int i = 0; i < ret.numRows; i++ ) {
for( int j = 0; j < ret.numCols; j++ ) {
ret.set(i,j,get(i,j));
}
}
return ret;
}
public void print() {
MatrixIO.print(System.out,original,"%6.3f",row0,row1,col0,col1);
}
}
ejml-0.28/main/core/src/org/ejml/data/DenseMatrix32F.java 0000664 0000000 0000000 00000030244 12561715344 0023040 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.Arrays;
/**
*
* DenseMatrix64F is a dense matrix with elements that are 32-bit floats. A matrix
* is the fundamental data structure in linear algebra. Unlike a sparse matrix, there is no
* compression in a dense matrix and every element is stored in memory. This allows for fast
* reads and writes to the matrix.
*
*
*
* The matrix is stored internally in a row-major 1D array format:
*
* data[ y*numCols + x ] = data[y][x]
*
* For example:
* data =
*
*
* a[0] a[1] a[2] a[3]
* a[4] a[5] a[6] a[7]
* a[8] a[9] a[10] a[11]
* a[12] a[13] a[14] a[15]
*
*
* @author Peter Abeles
*/
public class DenseMatrix32F extends D1Matrix32F {
/**
*
* Creates a new matrix which has the same value as the matrix encoded in the
* provided array. The input matrix's format can either be row-major or
* column-major.
*
*
*
* Note that 'data' is a variable argument type, so either 1D arrays or a set of numbers can be
* passed in:
* DenseMatrix a = new DenseMatrix(2,2,true,new float[]{1,2,3,4});
* DenseMatrix b = new DenseMatrix(2,2,true,1,2,3,4);
*
* Both are equivalent.
*
*
* @param numRows The number of rows.
* @param numCols The number of columns.
* @param rowMajor If the array is encoded in a row-major or a column-major format.
* @param data The formatted 1D array. Not modified.
*/
public DenseMatrix32F(int numRows, int numCols, boolean rowMajor, float... data) {
final int length = numRows * numCols;
this.data = new float[ length ];
this.numRows = numRows;
this.numCols = numCols;
set(numRows,numCols, rowMajor, data);
}
/**
*
* Creates a matrix with the values and shape defined by the 2D array 'data'.
* It is assumed that 'data' has a row-major formatting:
*
* data[ row ][ column ]
*
* @param data 2D array representation of the matrix. Not modified.
*/
public DenseMatrix32F(float data[][]) {
this.numRows = data.length;
this.numCols = data[0].length;
this.data = new float[ numRows*numCols ];
int pos = 0;
for( int i = 0; i < numRows; i++ ) {
float []row = data[i];
if( row.length != numCols ) {
throw new IllegalArgumentException("All rows must have the same length");
}
System.arraycopy(row,0,this.data,pos,numCols);
pos += numCols;
}
}
/**
* Creates a new Matrix with the specified shape whose elements initially
* have the value of zero.
*
* @param numRows The number of rows in the matrix.
* @param numCols The number of columns in the matrix.
*/
public DenseMatrix32F(int numRows, int numCols) {
data = new float[ numRows * numCols ];
this.numRows = numRows;
this.numCols = numCols;
}
/**
* Creates a new matrix which is equivalent to the provided matrix. Note that
* the length of the data will be determined by the shape of the matrix.
*
* @param orig The matrix which is to be copied. This is not modified or saved.
*/
public DenseMatrix32F(DenseMatrix32F orig) {
this(orig.numRows,orig.numCols);
System.arraycopy(orig.data, 0, this.data, 0, orig.getNumElements());
}
/**
* This declares an array that can store a matrix up to the specified length. This is use full
* when a matrix's size will be growing and it is desirable to avoid reallocating memory.
*
* @param length The size of the matrice's data array.
*/
public DenseMatrix32F(int length) {
data = new float[ length ];
}
/**
* Default constructor in which nothing is configured. THIS IS ONLY PUBLICLY ACCESSIBLE SO THAT THIS
* CLASS CAN BE A JAVA BEAN. DON'T USE IT UNLESS YOU REALLY KNOW WHAT YOU'RE DOING!
*/
public DenseMatrix32F(){}
/**
* Creates a new DenseMatrix64F which contains the same information as the provided Matrix64F.
*
* @param mat Matrix whose values will be copied. Not modified.
*/
public DenseMatrix32F(RealMatrix32F mat) {
this(mat.getNumRows(),mat.getNumCols());
for( int i = 0; i < numRows; i++ ) {
for( int j = 0; j < numCols; j++ ) {
set(i,j, mat.get(i,j));
}
}
}
/**
* Creates a new DenseMatrix64F around the provided data. The data must encode
* a row-major matrix. Any modification to the returned matrix will modify the
* provided data.
*
* @param numRows Number of rows in the matrix.
* @param numCols Number of columns in the matrix.
* @param data Data that is being wrapped. Referenced Saved.
* @return A matrix which references the provided data internally.
*/
public static DenseMatrix32F wrap( int numRows , int numCols , float []data ) {
DenseMatrix32F s = new DenseMatrix32F();
s.data = data;
s.numRows = numRows;
s.numCols = numCols;
return s;
}
/**
* @inheritDoc
*/
@Override
public void reshape(int numRows, int numCols, boolean saveValues) {
if( data.length < numRows * numCols ) {
float []d = new float[ numRows*numCols ];
if( saveValues ) {
System.arraycopy(data,0,d,0,getNumElements());
}
this.data = d;
}
this.numRows = numRows;
this.numCols = numCols;
}
/**
*
* Assigns the element in the Matrix to the specified value. Performs a bounds check to make sure
* the requested element is part of the matrix.
*
* aij = value
*
*
* @param row The row of the element.
* @param col The column of the element.
* @param value The element's new value.
*/
@Override
public void set( int row , int col , float value ) {
if( col < 0 || col >= numCols || row < 0 || row >= numRows ) {
throw new IllegalArgumentException("Specified element is out of bounds: ("+row+" , "+col+")");
}
data[ row * numCols + col ] = value;
}
@Override
public void unsafe_set( int row , int col , float value ) {
data[ row * numCols + col ] = value;
}
/**
*
* Adds 'value' to the specified element in the matrix.
*
* aij = aij + value
*
*
* @param row The row of the element.
* @param col The column of the element.
* @param value The value that is added to the element
*/
// todo move to commonops
public void add( int row , int col , float value ) {
if( col < 0 || col >= numCols || row < 0 || row >= numRows ) {
throw new IllegalArgumentException("Specified element is out of bounds");
}
data[ row * numCols + col ] += value;
}
/**
* Returns the value of the specified matrix element. Performs a bounds check to make sure
* the requested element is part of the matrix.
*
* @param row The row of the element.
* @param col The column of the element.
* @return The value of the element.
*/
@Override
public float get( int row , int col ) {
if( col < 0 || col >= numCols || row < 0 || row >= numRows ) {
throw new IllegalArgumentException("Specified element is out of bounds: "+row+" "+col);
}
return data[ row * numCols + col ];
}
@Override
public float unsafe_get( int row , int col ) {
return data[ row * numCols + col ];
}
@Override
public int getIndex( int row , int col ) {
return row * numCols + col;
}
/**
* Determins if the specified element is inside the bounds of the Matrix.
*
* @param row The element's row.
* @param col The elements' column.
* @return True if it is inside the matrices bound, false otherwise.
*/
public boolean isInBounds( int row , int col ) {
return( col >= 0 && col < numCols && row >= 0 && row < numRows );
}
/**
* Returns the number of elements in this matrix, which is equal to
* the number of rows times the number of columns.
*
* @return The number of elements in the matrix.
*/
@Override
public int getNumElements() {
return numRows*numCols;
}
/**
* Sets this matrix equal to the matrix encoded in the array.
*
* @param numRows The number of rows.
* @param numCols The number of columns.
* @param rowMajor If the array is encoded in a row-major or a column-major format.
* @param data The formatted 1D array. Not modified.
*/
public void set(int numRows, int numCols, boolean rowMajor, float ...data)
{
reshape(numRows,numCols);
int length = numRows*numCols;
if( length > this.data.length )
throw new IllegalArgumentException("The length of this matrix's data array is too small.");
if( rowMajor ) {
System.arraycopy(data,0,this.data,0,length);
} else {
int index = 0;
for( int i = 0; i < numRows; i++ ) {
for( int j = 0; j < numCols; j++ ) {
this.data[index++] = data[j*numRows+i];
}
}
}
}
/**
* Sets all elements equal to zero.
*/
public void zero() {
Arrays.fill(data, 0, getNumElements(), 0.0f);
}
/**
* Creates and returns a matrix which is idential to this one.
*
* @return A new identical matrix.
*/
@SuppressWarnings({"unchecked"})
public DenseMatrix32F copy() {
return new DenseMatrix32F(this);
}
@Override
public void set(Matrix original) {
RealMatrix32F m = (RealMatrix32F)original;
reshape(original.getNumRows(),original.getNumCols());
if( original instanceof DenseMatrix32F) {
// do a faster copy if its of type DenseMatrix64F
System.arraycopy(((DenseMatrix32F)m).data,0,data,0,numRows*numCols);
} else {
int index = 0;
for (int i = 0; i < numRows; i++) {
for (int j = 0; j < numCols; j++) {
data[index++] = m.get(i, j);
}
}
}
}
/**
* Prints the value of this matrix to the screen. For more options see
* {@link org.ejml.UtilEjml}
*
*/
@Override
public void print() {
MatrixIO.print(System.out,this);
}
/**
*
* Prints the value of this matrix to the screen using the same format as {@link java.io.PrintStream#printf).
*
*
* @param format The format which each element is printed uses.
*/
public void print( String format ) {
MatrixIO.print(System.out,this,format);
}
/**
*
* Converts the array into a string format for display purposes.
* The conversion is done using {@link org.ejml.ops.MatrixIO#print(java.io.PrintStream, org.ejml.data.RealMatrix64F)}.
*
*
* @return String representation of the matrix.
*/
@Override
public String toString() {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
MatrixIO.print(new PrintStream(stream),this);
return stream.toString();
}
}
ejml-0.28/main/core/src/org/ejml/data/DenseMatrix64F.java 0000664 0000000 0000000 00000030272 12561715344 0023046 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.UtilEjml;
import org.ejml.ops.MatrixIO;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.Arrays;
/**
*
* DenseMatrix64F is a dense matrix with real elements that are 64-bit floats. A matrix
* is the fundamental data structure in linear algebra. Unlike a sparse matrix, there is no
* compression in a dense matrix and every element is stored in memory. This allows for fast
* reads and writes to the matrix.
*
*
*
* The matrix is stored internally in a row-major 1D array format:
*
* data[ y*numCols + x ] = data[y][x]
*
* For example:
* data =
*
*
* a[0] a[1] a[2] a[3]
* a[4] a[5] a[6] a[7]
* a[8] a[9] a[10] a[11]
* a[12] a[13] a[14] a[15]
*
* @author Peter Abeles
*/
public class DenseMatrix64F extends RowD1Matrix64F {
/**
*
* Creates a new matrix which has the same value as the matrix encoded in the
* provided array. The input matrix's format can either be row-major or
* column-major.
*
*
*
* Note that 'data' is a variable argument type, so either 1D arrays or a set of numbers can be
* passed in:
* DenseMatrix a = new DenseMatrix(2,2,true,new double[]{1,2,3,4});
* DenseMatrix b = new DenseMatrix(2,2,true,1,2,3,4);
*
* Both are equivalent.
*
*
* @param numRows The number of rows.
* @param numCols The number of columns.
* @param rowMajor If the array is encoded in a row-major or a column-major format.
* @param data The formatted 1D array. Not modified.
*/
public DenseMatrix64F(int numRows, int numCols, boolean rowMajor, double... data) {
final int length = numRows * numCols;
this.data = new double[ length ];
this.numRows = numRows;
this.numCols = numCols;
set(numRows,numCols, rowMajor, data);
}
/**
*
* Creates a matrix with the values and shape defined by the 2D array 'data'.
* It is assumed that 'data' has a row-major formatting:
*
* data[ row ][ column ]
*
* @param data 2D array representation of the matrix. Not modified.
*/
public DenseMatrix64F( double data[][] ) {
this.numRows = data.length;
this.numCols = data[0].length;
this.data = new double[ numRows*numCols ];
int pos = 0;
for( int i = 0; i < numRows; i++ ) {
double []row = data[i];
if( row.length != numCols ) {
throw new IllegalArgumentException("All rows must have the same length");
}
System.arraycopy(row,0,this.data,pos,numCols);
pos += numCols;
}
}
/**
* Creates a new Matrix with the specified shape whose elements initially
* have the value of zero.
*
* @param numRows The number of rows in the matrix.
* @param numCols The number of columns in the matrix.
*/
public DenseMatrix64F( int numRows , int numCols ) {
data = new double[ numRows * numCols ];
this.numRows = numRows;
this.numCols = numCols;
}
/**
* Creates a new matrix which is equivalent to the provided matrix. Note that
* the length of the data will be determined by the shape of the matrix.
*
* @param orig The matrix which is to be copied. This is not modified or saved.
*/
public DenseMatrix64F( DenseMatrix64F orig ) {
this(orig.numRows,orig.numCols);
System.arraycopy(orig.data, 0, this.data, 0, orig.getNumElements());
}
/**
* This declares an array that can store a matrix up to the specified length. This is use full
* when a matrix's size will be growing and it is desirable to avoid reallocating memory.
*
* @param length The size of the matrice's data array.
*/
public DenseMatrix64F( int length ) {
data = new double[ length ];
}
/**
* Default constructor in which nothing is configured. THIS IS ONLY PUBLICLY ACCESSIBLE SO THAT THIS
* CLASS CAN BE A JAVA BEAN. DON'T USE IT UNLESS YOU REALLY KNOW WHAT YOU'RE DOING!
*/
public DenseMatrix64F(){}
/**
* Creates a new DenseMatrix64F which contains the same information as the provided Matrix64F.
*
* @param mat Matrix whose values will be copied. Not modified.
*/
public DenseMatrix64F(RealMatrix64F mat) {
this(mat.getNumRows(),mat.getNumCols());
for( int i = 0; i < numRows; i++ ) {
for( int j = 0; j < numCols; j++ ) {
set(i,j, mat.get(i,j));
}
}
}
/**
* Creates a new DenseMatrix64F around the provided data. The data must encode
* a row-major matrix. Any modification to the returned matrix will modify the
* provided data.
*
* @param numRows Number of rows in the matrix.
* @param numCols Number of columns in the matrix.
* @param data Data that is being wrapped. Referenced Saved.
* @return A matrix which references the provided data internally.
*/
public static DenseMatrix64F wrap( int numRows , int numCols , double []data ) {
DenseMatrix64F s = new DenseMatrix64F();
s.data = data;
s.numRows = numRows;
s.numCols = numCols;
return s;
}
/**
* @inheritDoc
*/
@Override
public void reshape(int numRows, int numCols, boolean saveValues) {
if( data.length < numRows * numCols ) {
double []d = new double[ numRows*numCols ];
if( saveValues ) {
System.arraycopy(data,0,d,0,getNumElements());
}
this.data = d;
}
this.numRows = numRows;
this.numCols = numCols;
}
/**
*
* Assigns the element in the Matrix to the specified value. Performs a bounds check to make sure
* the requested element is part of the matrix.
*
* aij = value
*
*
* @param row The row of the element.
* @param col The column of the element.
* @param value The element's new value.
*/
@Override
public void set( int row , int col , double value ) {
if( col < 0 || col >= numCols || row < 0 || row >= numRows ) {
throw new IllegalArgumentException("Specified element is out of bounds: ("+row+" , "+col+")");
}
data[ row * numCols + col ] = value;
}
@Override
public void unsafe_set( int row , int col , double value ) {
data[ row * numCols + col ] = value;
}
/**
*
* Adds 'value' to the specified element in the matrix.
*
* aij = aij + value
*
*
* @param row The row of the element.
* @param col The column of the element.
* @param value The value that is added to the element
*/
// todo move to commonops
public void add( int row , int col , double value ) {
if( col < 0 || col >= numCols || row < 0 || row >= numRows ) {
throw new IllegalArgumentException("Specified element is out of bounds");
}
data[ row * numCols + col ] += value;
}
/**
* Returns the value of the specified matrix element. Performs a bounds check to make sure
* the requested element is part of the matrix.
*
* @param row The row of the element.
* @param col The column of the element.
* @return The value of the element.
*/
@Override
public double get( int row , int col ) {
if( col < 0 || col >= numCols || row < 0 || row >= numRows ) {
throw new IllegalArgumentException("Specified element is out of bounds: "+row+" "+col);
}
return data[ row * numCols + col ];
}
@Override
public double unsafe_get( int row , int col ) {
return data[ row * numCols + col ];
}
@Override
public int getIndex( int row , int col ) {
return row * numCols + col;
}
/**
* Determins if the specified element is inside the bounds of the Matrix.
*
* @param row The element's row.
* @param col The elements' column.
* @return True if it is inside the matrices bound, false otherwise.
*/
public boolean isInBounds( int row , int col ) {
return( col >= 0 && col < numCols && row >= 0 && row < numRows );
}
/**
* Returns the number of elements in this matrix, which is equal to
* the number of rows times the number of columns.
*
* @return The number of elements in the matrix.
*/
@Override
public int getNumElements() {
return numRows*numCols;
}
/**
* Sets this matrix equal to the matrix encoded in the array.
*
* @param numRows The number of rows.
* @param numCols The number of columns.
* @param rowMajor If the array is encoded in a row-major or a column-major format.
* @param data The formatted 1D array. Not modified.
*/
public void set(int numRows, int numCols, boolean rowMajor, double ...data)
{
reshape(numRows,numCols);
int length = numRows*numCols;
if( length > this.data.length )
throw new IllegalArgumentException("The length of this matrix's data array is too small.");
if( rowMajor ) {
System.arraycopy(data,0,this.data,0,length);
} else {
int index = 0;
for( int i = 0; i < numRows; i++ ) {
for( int j = 0; j < numCols; j++ ) {
this.data[index++] = data[j*numRows+i];
}
}
}
}
/**
* Sets all elements equal to zero.
*/
public void zero() {
Arrays.fill(data, 0, getNumElements(), 0.0);
}
/**
* Creates and returns a matrix which is idential to this one.
*
* @return A new identical matrix.
*/
@SuppressWarnings({"unchecked"})
public DenseMatrix64F copy() {
return new DenseMatrix64F(this);
}
@Override
public void set(Matrix original) {
RealMatrix64F m = (RealMatrix64F)original;
reshape(original.getNumRows(),original.getNumCols());
if( original instanceof DenseMatrix64F ) {
// do a faster copy if its of type DenseMatrix64F
System.arraycopy(((DenseMatrix64F)m).data,0,data,0,numRows*numCols);
} else {
int index = 0;
for (int i = 0; i < numRows; i++) {
for (int j = 0; j < numCols; j++) {
data[index++] = m.get(i, j);
}
}
}
}
/**
* Prints the value of this matrix to the screen. For more options see
* {@link UtilEjml}
*
*/
@Override
public void print() {
MatrixIO.print(System.out,this);
}
/**
*
* Prints the value of this matrix to the screen using the same format as {@link java.io.PrintStream#printf).
*
*
* @param format The format which each element is printed uses.
*/
public void print( String format ) {
MatrixIO.print(System.out,this,format);
}
/**
*
* Converts the array into a string format for display purposes.
* The conversion is done using {@link MatrixIO#print(java.io.PrintStream, RealMatrix64F)}.
*
*
* @return String representation of the matrix.
*/
@Override
public String toString() {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
MatrixIO.print(new PrintStream(stream),this);
return stream.toString();
}
}
ejml-0.28/main/core/src/org/ejml/data/Eigenpair64F.java 0000664 0000000 0000000 00000002154 12561715344 0022524 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
/**
* An eigenpair is a set composed of an eigenvalue and an eigenvector. In this library since only real
* matrices are supported, all eigenpairs are real valued.
*
* @author Peter Abeles
*/
public class Eigenpair64F {
public double value;
public DenseMatrix64F vector;
public Eigenpair64F(double value, DenseMatrix64F vector) {
this.value = value;
this.vector = vector;
}
}
ejml-0.28/main/core/src/org/ejml/data/FixedMatrix2_64F.java 0000664 0000000 0000000 00000006131 12561715344 0023265 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
* Fixed sized vector with 2 elements. Can represent a 2 x 1 or 1 x 2 matrix, context dependent.
*
* @author Peter Abeles
*/
public class FixedMatrix2_64F implements FixedMatrix64F {
public double a1,a2;
public FixedMatrix2_64F() {
}
public FixedMatrix2_64F(double a1,double a2)
{
this.a1 = a1;
this.a2 = a2;
}
public FixedMatrix2_64F(FixedMatrix2_64F o) {
this.a1 = o.a1;
this.a2 = o.a2;
}
@Override
public double get(int row, int col) {
return unsafe_get(row,col);
}
@Override
public double unsafe_get(int row, int col) {
if( row != 0 && col != 0 )
throw new IllegalArgumentException("Row or column must be zero since this is a vector");
int w = Math.max(row,col);
if( w == 0 ) {
return a1;
} else if( w == 1 ) {
return a2;
} else {
throw new IllegalArgumentException("Out of range. "+w);
}
}
@Override
public void set(int row, int col, double val) {
unsafe_set(row,col,val);
}
@Override
public void unsafe_set(int row, int col, double val) {
if( row != 0 && col != 0 )
throw new IllegalArgumentException("Row or column must be zero since this is a vector");
int w = Math.max(row,col);
if( w == 0 ) {
a1 = val;
} else if( w == 1 ) {
a2 = val;
} else {
throw new IllegalArgumentException("Out of range. "+w);
}
}
@Override
public void set(Matrix original) {
RealMatrix64F m = (RealMatrix64F)original;
if( m.getNumCols() == 1 && m.getNumRows() == 2 ) {
a1 = m.get(0,0);
a2 = m.get(1,0);
} else if( m.getNumRows() == 1 && m.getNumCols() == 2 ){
a1 = m.get(0,0);
a2 = m.get(0,1);
} else {
throw new IllegalArgumentException("Incompatible shape");
}
}
@Override
public int getNumRows() {
return 2;
}
@Override
public int getNumCols() {
return 1;
}
@Override
public int getNumElements() {
return 2;
}
@Override
public T copy() {
return (T)new FixedMatrix2_64F(this);
}
@Override
public void print() {
MatrixIO.print(System.out, this);
}
}
ejml-0.28/main/core/src/org/ejml/data/FixedMatrix2x2_64F.java 0000664 0000000 0000000 00000006673 12561715344 0023552 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
* Fixed sized 2 by FixedMatrix2x2_64F matrix. The matrix is stored as class variables for very fast read/write. aXY is the
* value of row = X and column = Y.
*
* @author Peter Abeles
*/
public class FixedMatrix2x2_64F implements FixedMatrix64F {
public double a11,a12;
public double a21,a22;
public FixedMatrix2x2_64F() {
}
public FixedMatrix2x2_64F( double a11,double a12,
double a21,double a22)
{
this.a11 = a11;
this.a12 = a12;
this.a21 = a21;
this.a22 = a22;
}
public FixedMatrix2x2_64F( FixedMatrix2x2_64F o ) {
this.a11 = o.a11;
this.a12 = o.a12;
this.a21 = o.a21;
this.a22 = o.a22;
}
@Override
public double get(int row, int col) {
return unsafe_get(row,col);
}
@Override
public double unsafe_get(int row, int col) {
if( row == 0 ) {
if( col == 0 ) {
return a11;
} else if( col == 1 ) {
return a12;
}
} else if( row == 1 ) {
if( col == 0 ) {
return a21;
} else if( col == 1 ) {
return a22;
}
}
throw new IllegalArgumentException("Row and/or column out of range. "+row+" "+col);
}
@Override
public void set(int row, int col, double val) {
unsafe_set(row,col,val);
}
@Override
public void unsafe_set(int row, int col, double val) {
if( row == 0 ) {
if( col == 0 ) {
a11 = val; return;
} else if( col == 1 ) {
a12 = val; return;
}
} else if( row == 1 ) {
if( col == 0 ) {
a21 = val; return;
} else if( col == 1 ) {
a22 = val; return;
}
}
throw new IllegalArgumentException("Row and/or column out of range. "+row+" "+col);
}
@Override
public void set(Matrix original) {
if( original.getNumCols() != 2 || original.getNumRows() != 2 )
throw new IllegalArgumentException("Rows and/or columns do not match");
RealMatrix64F m = (RealMatrix64F)original;
a11 = m.get(0,0);
a12 = m.get(0,1);
a21 = m.get(1,0);
a22 = m.get(1,1);
}
@Override
public int getNumRows() {
return 2;
}
@Override
public int getNumCols() {
return 2;
}
@Override
public int getNumElements() {
return 4;
}
@Override
public T copy() {
return (T)new FixedMatrix2x2_64F(this);
}
@Override
public void print() {
MatrixIO.print(System.out, this);
}
}
ejml-0.28/main/core/src/org/ejml/data/FixedMatrix3_64F.java 0000664 0000000 0000000 00000006467 12561715344 0023302 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
* Fixed sized vector with 3 elements. Can represent a 3 x 1 or 1 x 3 matrix, context dependent.
*
* @author Peter Abeles
*/
public class FixedMatrix3_64F implements FixedMatrix64F {
public double a1,a2,a3;
public FixedMatrix3_64F() {
}
public FixedMatrix3_64F(double a1,double a2,double a3)
{
this.a1 = a1;
this.a2 = a2;
this.a3 = a3;
}
public FixedMatrix3_64F(FixedMatrix3_64F o) {
this.a1 = o.a1;
this.a2 = o.a2;
this.a3 = o.a3;
}
@Override
public double get(int row, int col) {
return unsafe_get(row,col);
}
@Override
public double unsafe_get(int row, int col) {
if( row != 0 && col != 0 )
throw new IllegalArgumentException("Row or column must be zero since this is a vector");
int w = Math.max(row,col);
if( w == 0 ) {
return a1;
} else if( w == 1 ) {
return a2;
} else if( w == 2 ) {
return a3;
} else {
throw new IllegalArgumentException("Out of range. "+w);
}
}
@Override
public void set(int row, int col, double val) {
unsafe_set(row,col,val);
}
@Override
public void unsafe_set(int row, int col, double val) {
if( row != 0 && col != 0 )
throw new IllegalArgumentException("Row or column must be zero since this is a vector");
int w = Math.max(row,col);
if( w == 0 ) {
a1 = val;
} else if( w == 1 ) {
a2 = val;
} else if( w == 2 ) {
a3 = val;
} else {
throw new IllegalArgumentException("Out of range. "+w);
}
}
@Override
public void set(Matrix original) {
RealMatrix64F m = (RealMatrix64F)original;
if( m.getNumCols() == 1 && m.getNumRows() == 3 ) {
a1 = m.get(0,0);
a2 = m.get(1,0);
a3 = m.get(2,0);
} else if( m.getNumRows() == 1 && m.getNumCols() == 3 ){
a1 = m.get(0,0);
a2 = m.get(0,1);
a3 = m.get(0,2);
} else {
throw new IllegalArgumentException("Incompatible shape");
}
}
@Override
public int getNumRows() {
return 3;
}
@Override
public int getNumCols() {
return 1;
}
@Override
public int getNumElements() {
return 3;
}
@Override
public T copy() {
return (T)new FixedMatrix3_64F(this);
}
@Override
public void print() {
MatrixIO.print(System.out, this);
}
}
ejml-0.28/main/core/src/org/ejml/data/FixedMatrix3x3_64F.java 0000664 0000000 0000000 00000011245 12561715344 0023543 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
* Fixed sized 3 by FixedMatrix3x3_64F matrix. The matrix is stored as class variables for very fast read/write. aXY is the
* value of row = X and column = Y.
*
* @author Peter Abeles
*/
public class FixedMatrix3x3_64F implements FixedMatrix64F {
public double a11,a12,a13;
public double a21,a22,a23;
public double a31,a32,a33;
public FixedMatrix3x3_64F() {
}
public FixedMatrix3x3_64F( double a11,double a12,double a13,
double a21,double a22,double a23,
double a31,double a32,double a33)
{
this.a11 = a11;
this.a12 = a12;
this.a13 = a13;
this.a21 = a21;
this.a22 = a22;
this.a23 = a23;
this.a31 = a31;
this.a32 = a32;
this.a33 = a33;
}
public FixedMatrix3x3_64F( FixedMatrix3x3_64F o ) {
this.a11 = o.a11;
this.a12 = o.a12;
this.a13 = o.a13;
this.a21 = o.a21;
this.a22 = o.a22;
this.a23 = o.a23;
this.a31 = o.a31;
this.a32 = o.a32;
this.a33 = o.a33;
}
@Override
public double get(int row, int col) {
return unsafe_get(row,col);
}
@Override
public double unsafe_get(int row, int col) {
if( row == 0 ) {
if( col == 0 ) {
return a11;
} else if( col == 1 ) {
return a12;
} else if( col == 2 ) {
return a13;
}
} else if( row == 1 ) {
if( col == 0 ) {
return a21;
} else if( col == 1 ) {
return a22;
} else if( col == 2 ) {
return a23;
}
} else if( row == 2 ) {
if( col == 0 ) {
return a31;
} else if( col == 1 ) {
return a32;
} else if( col == 2 ) {
return a33;
}
}
throw new IllegalArgumentException("Row and/or column out of range. "+row+" "+col);
}
@Override
public void set(int row, int col, double val) {
unsafe_set(row,col,val);
}
@Override
public void unsafe_set(int row, int col, double val) {
if( row == 0 ) {
if( col == 0 ) {
a11 = val; return;
} else if( col == 1 ) {
a12 = val; return;
} else if( col == 2 ) {
a13 = val; return;
}
} else if( row == 1 ) {
if( col == 0 ) {
a21 = val; return;
} else if( col == 1 ) {
a22 = val; return;
} else if( col == 2 ) {
a23 = val; return;
}
} else if( row == 2 ) {
if( col == 0 ) {
a31 = val; return;
} else if( col == 1 ) {
a32 = val; return;
} else if( col == 2 ) {
a33 = val; return;
}
}
throw new IllegalArgumentException("Row and/or column out of range. "+row+" "+col);
}
@Override
public void set(Matrix original) {
if( original.getNumCols() != 3 || original.getNumRows() != 3 )
throw new IllegalArgumentException("Rows and/or columns do not match");
RealMatrix64F m = (RealMatrix64F)original;
a11 = m.get(0,0);
a12 = m.get(0,1);
a13 = m.get(0,2);
a21 = m.get(1,0);
a22 = m.get(1,1);
a23 = m.get(1,2);
a31 = m.get(2,0);
a32 = m.get(2,1);
a33 = m.get(2,2);
}
@Override
public int getNumRows() {
return 3;
}
@Override
public int getNumCols() {
return 3;
}
@Override
public int getNumElements() {
return 9;
}
@Override
public T copy() {
return (T)new FixedMatrix3x3_64F(this);
}
@Override
public void print() {
MatrixIO.print(System.out, this);
}
}
ejml-0.28/main/core/src/org/ejml/data/FixedMatrix4_64F.java 0000664 0000000 0000000 00000007025 12561715344 0023272 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
* Fixed sized vector with 4 elements. Can represent a 4 x 1 or 1 x 4 matrix, context dependent.
*
* @author Peter Abeles
*/
public class FixedMatrix4_64F implements FixedMatrix64F {
public double a1,a2,a3,a4;
public FixedMatrix4_64F() {
}
public FixedMatrix4_64F(double a1,double a2,double a3,double a4)
{
this.a1 = a1;
this.a2 = a2;
this.a3 = a3;
this.a4 = a4;
}
public FixedMatrix4_64F(FixedMatrix4_64F o) {
this.a1 = o.a1;
this.a2 = o.a2;
this.a3 = o.a3;
this.a4 = o.a4;
}
@Override
public double get(int row, int col) {
return unsafe_get(row,col);
}
@Override
public double unsafe_get(int row, int col) {
if( row != 0 && col != 0 )
throw new IllegalArgumentException("Row or column must be zero since this is a vector");
int w = Math.max(row,col);
if( w == 0 ) {
return a1;
} else if( w == 1 ) {
return a2;
} else if( w == 2 ) {
return a3;
} else if( w == 3 ) {
return a4;
} else {
throw new IllegalArgumentException("Out of range. "+w);
}
}
@Override
public void set(int row, int col, double val) {
unsafe_set(row,col,val);
}
@Override
public void unsafe_set(int row, int col, double val) {
if( row != 0 && col != 0 )
throw new IllegalArgumentException("Row or column must be zero since this is a vector");
int w = Math.max(row,col);
if( w == 0 ) {
a1 = val;
} else if( w == 1 ) {
a2 = val;
} else if( w == 2 ) {
a3 = val;
} else if( w == 3 ) {
a4 = val;
} else {
throw new IllegalArgumentException("Out of range. "+w);
}
}
@Override
public void set(Matrix original) {
RealMatrix64F m = (RealMatrix64F)original;
if( m.getNumCols() == 1 && m.getNumRows() == 4 ) {
a1 = m.get(0,0);
a2 = m.get(1,0);
a3 = m.get(2,0);
a4 = m.get(3,0);
} else if( m.getNumRows() == 1 && m.getNumCols() == 4 ){
a1 = m.get(0,0);
a2 = m.get(0,1);
a3 = m.get(0,2);
a4 = m.get(0,3);
} else {
throw new IllegalArgumentException("Incompatible shape");
}
}
@Override
public int getNumRows() {
return 4;
}
@Override
public int getNumCols() {
return 1;
}
@Override
public int getNumElements() {
return 4;
}
@Override
public T copy() {
return (T)new FixedMatrix4_64F(this);
}
@Override
public void print() {
MatrixIO.print(System.out, this);
}
}
ejml-0.28/main/core/src/org/ejml/data/FixedMatrix4x4_64F.java 0000664 0000000 0000000 00000014524 12561715344 0023550 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
* Fixed sized 4 by FixedMatrix4x4_64F matrix. The matrix is stored as class variables for very fast read/write. aXY is the
* value of row = X and column = Y.
*
* @author Peter Abeles
*/
public class FixedMatrix4x4_64F implements FixedMatrix64F {
public double a11,a12,a13,a14;
public double a21,a22,a23,a24;
public double a31,a32,a33,a34;
public double a41,a42,a43,a44;
public FixedMatrix4x4_64F() {
}
public FixedMatrix4x4_64F( double a11,double a12,double a13,double a14,
double a21,double a22,double a23,double a24,
double a31,double a32,double a33,double a34,
double a41,double a42,double a43,double a44)
{
this.a11 = a11;
this.a12 = a12;
this.a13 = a13;
this.a14 = a14;
this.a21 = a21;
this.a22 = a22;
this.a23 = a23;
this.a24 = a24;
this.a31 = a31;
this.a32 = a32;
this.a33 = a33;
this.a34 = a34;
this.a41 = a41;
this.a42 = a42;
this.a43 = a43;
this.a44 = a44;
}
public FixedMatrix4x4_64F( FixedMatrix4x4_64F o ) {
this.a11 = o.a11;
this.a12 = o.a12;
this.a13 = o.a13;
this.a14 = o.a14;
this.a21 = o.a21;
this.a22 = o.a22;
this.a23 = o.a23;
this.a24 = o.a24;
this.a31 = o.a31;
this.a32 = o.a32;
this.a33 = o.a33;
this.a34 = o.a34;
this.a41 = o.a41;
this.a42 = o.a42;
this.a43 = o.a43;
this.a44 = o.a44;
}
@Override
public double get(int row, int col) {
return unsafe_get(row,col);
}
@Override
public double unsafe_get(int row, int col) {
if( row == 0 ) {
if( col == 0 ) {
return a11;
} else if( col == 1 ) {
return a12;
} else if( col == 2 ) {
return a13;
} else if( col == 3 ) {
return a14;
}
} else if( row == 1 ) {
if( col == 0 ) {
return a21;
} else if( col == 1 ) {
return a22;
} else if( col == 2 ) {
return a23;
} else if( col == 3 ) {
return a24;
}
} else if( row == 2 ) {
if( col == 0 ) {
return a31;
} else if( col == 1 ) {
return a32;
} else if( col == 2 ) {
return a33;
} else if( col == 3 ) {
return a34;
}
} else if( row == 3 ) {
if( col == 0 ) {
return a41;
} else if( col == 1 ) {
return a42;
} else if( col == 2 ) {
return a43;
} else if( col == 3 ) {
return a44;
}
}
throw new IllegalArgumentException("Row and/or column out of range. "+row+" "+col);
}
@Override
public void set(int row, int col, double val) {
unsafe_set(row,col,val);
}
@Override
public void unsafe_set(int row, int col, double val) {
if( row == 0 ) {
if( col == 0 ) {
a11 = val; return;
} else if( col == 1 ) {
a12 = val; return;
} else if( col == 2 ) {
a13 = val; return;
} else if( col == 3 ) {
a14 = val; return;
}
} else if( row == 1 ) {
if( col == 0 ) {
a21 = val; return;
} else if( col == 1 ) {
a22 = val; return;
} else if( col == 2 ) {
a23 = val; return;
} else if( col == 3 ) {
a24 = val; return;
}
} else if( row == 2 ) {
if( col == 0 ) {
a31 = val; return;
} else if( col == 1 ) {
a32 = val; return;
} else if( col == 2 ) {
a33 = val; return;
} else if( col == 3 ) {
a34 = val; return;
}
} else if( row == 3 ) {
if( col == 0 ) {
a41 = val; return;
} else if( col == 1 ) {
a42 = val; return;
} else if( col == 2 ) {
a43 = val; return;
} else if( col == 3 ) {
a44 = val; return;
}
}
throw new IllegalArgumentException("Row and/or column out of range. "+row+" "+col);
}
@Override
public void set(Matrix original) {
if( original.getNumCols() != 4 || original.getNumRows() != 4 )
throw new IllegalArgumentException("Rows and/or columns do not match");
RealMatrix64F m = (RealMatrix64F)original;
a11 = m.get(0,0);
a12 = m.get(0,1);
a13 = m.get(0,2);
a14 = m.get(0,3);
a21 = m.get(1,0);
a22 = m.get(1,1);
a23 = m.get(1,2);
a24 = m.get(1,3);
a31 = m.get(2,0);
a32 = m.get(2,1);
a33 = m.get(2,2);
a34 = m.get(2,3);
a41 = m.get(3,0);
a42 = m.get(3,1);
a43 = m.get(3,2);
a44 = m.get(3,3);
}
@Override
public int getNumRows() {
return 4;
}
@Override
public int getNumCols() {
return 4;
}
@Override
public int getNumElements() {
return 16;
}
@Override
public T copy() {
return (T)new FixedMatrix4x4_64F(this);
}
@Override
public void print() {
MatrixIO.print(System.out, this);
}
}
ejml-0.28/main/core/src/org/ejml/data/FixedMatrix5_64F.java 0000664 0000000 0000000 00000007363 12561715344 0023300 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
* Fixed sized vector with 5 elements. Can represent a 5 x 1 or 1 x 5 matrix, context dependent.
*
* @author Peter Abeles
*/
public class FixedMatrix5_64F implements FixedMatrix64F {
public double a1,a2,a3,a4,a5;
public FixedMatrix5_64F() {
}
public FixedMatrix5_64F(double a1,double a2,double a3,double a4,double a5)
{
this.a1 = a1;
this.a2 = a2;
this.a3 = a3;
this.a4 = a4;
this.a5 = a5;
}
public FixedMatrix5_64F(FixedMatrix5_64F o) {
this.a1 = o.a1;
this.a2 = o.a2;
this.a3 = o.a3;
this.a4 = o.a4;
this.a5 = o.a5;
}
@Override
public double get(int row, int col) {
return unsafe_get(row,col);
}
@Override
public double unsafe_get(int row, int col) {
if( row != 0 && col != 0 )
throw new IllegalArgumentException("Row or column must be zero since this is a vector");
int w = Math.max(row,col);
if( w == 0 ) {
return a1;
} else if( w == 1 ) {
return a2;
} else if( w == 2 ) {
return a3;
} else if( w == 3 ) {
return a4;
} else if( w == 4 ) {
return a5;
} else {
throw new IllegalArgumentException("Out of range. "+w);
}
}
@Override
public void set(int row, int col, double val) {
unsafe_set(row,col,val);
}
@Override
public void unsafe_set(int row, int col, double val) {
if( row != 0 && col != 0 )
throw new IllegalArgumentException("Row or column must be zero since this is a vector");
int w = Math.max(row,col);
if( w == 0 ) {
a1 = val;
} else if( w == 1 ) {
a2 = val;
} else if( w == 2 ) {
a3 = val;
} else if( w == 3 ) {
a4 = val;
} else if( w == 4 ) {
a5 = val;
} else {
throw new IllegalArgumentException("Out of range. "+w);
}
}
@Override
public void set(Matrix original) {
RealMatrix64F m = (RealMatrix64F)original;
if( m.getNumCols() == 1 && m.getNumRows() == 5 ) {
a1 = m.get(0,0);
a2 = m.get(1,0);
a3 = m.get(2,0);
a4 = m.get(3,0);
a5 = m.get(4,0);
} else if( m.getNumRows() == 1 && m.getNumCols() == 5 ){
a1 = m.get(0,0);
a2 = m.get(0,1);
a3 = m.get(0,2);
a4 = m.get(0,3);
a5 = m.get(0,4);
} else {
throw new IllegalArgumentException("Incompatible shape");
}
}
@Override
public int getNumRows() {
return 5;
}
@Override
public int getNumCols() {
return 1;
}
@Override
public int getNumElements() {
return 5;
}
@Override
public T copy() {
return (T)new FixedMatrix5_64F(this);
}
@Override
public void print() {
MatrixIO.print(System.out, this);
}
}
ejml-0.28/main/core/src/org/ejml/data/FixedMatrix5x5_64F.java 0000664 0000000 0000000 00000020706 12561715344 0023551 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
* Fixed sized 5 by FixedMatrix5x5_64F matrix. The matrix is stored as class variables for very fast read/write. aXY is the
* value of row = X and column = Y.
*
* @author Peter Abeles
*/
public class FixedMatrix5x5_64F implements FixedMatrix64F {
public double a11,a12,a13,a14,a15;
public double a21,a22,a23,a24,a25;
public double a31,a32,a33,a34,a35;
public double a41,a42,a43,a44,a45;
public double a51,a52,a53,a54,a55;
public FixedMatrix5x5_64F() {
}
public FixedMatrix5x5_64F( double a11,double a12,double a13,double a14,double a15,
double a21,double a22,double a23,double a24,double a25,
double a31,double a32,double a33,double a34,double a35,
double a41,double a42,double a43,double a44,double a45,
double a51,double a52,double a53,double a54,double a55)
{
this.a11 = a11;
this.a12 = a12;
this.a13 = a13;
this.a14 = a14;
this.a15 = a15;
this.a21 = a21;
this.a22 = a22;
this.a23 = a23;
this.a24 = a24;
this.a25 = a25;
this.a31 = a31;
this.a32 = a32;
this.a33 = a33;
this.a34 = a34;
this.a35 = a35;
this.a41 = a41;
this.a42 = a42;
this.a43 = a43;
this.a44 = a44;
this.a45 = a45;
this.a51 = a51;
this.a52 = a52;
this.a53 = a53;
this.a54 = a54;
this.a55 = a55;
}
public FixedMatrix5x5_64F( FixedMatrix5x5_64F o ) {
this.a11 = o.a11;
this.a12 = o.a12;
this.a13 = o.a13;
this.a14 = o.a14;
this.a15 = o.a15;
this.a21 = o.a21;
this.a22 = o.a22;
this.a23 = o.a23;
this.a24 = o.a24;
this.a25 = o.a25;
this.a31 = o.a31;
this.a32 = o.a32;
this.a33 = o.a33;
this.a34 = o.a34;
this.a35 = o.a35;
this.a41 = o.a41;
this.a42 = o.a42;
this.a43 = o.a43;
this.a44 = o.a44;
this.a45 = o.a45;
this.a51 = o.a51;
this.a52 = o.a52;
this.a53 = o.a53;
this.a54 = o.a54;
this.a55 = o.a55;
}
@Override
public double get(int row, int col) {
return unsafe_get(row,col);
}
@Override
public double unsafe_get(int row, int col) {
if( row == 0 ) {
if( col == 0 ) {
return a11;
} else if( col == 1 ) {
return a12;
} else if( col == 2 ) {
return a13;
} else if( col == 3 ) {
return a14;
} else if( col == 4 ) {
return a15;
}
} else if( row == 1 ) {
if( col == 0 ) {
return a21;
} else if( col == 1 ) {
return a22;
} else if( col == 2 ) {
return a23;
} else if( col == 3 ) {
return a24;
} else if( col == 4 ) {
return a25;
}
} else if( row == 2 ) {
if( col == 0 ) {
return a31;
} else if( col == 1 ) {
return a32;
} else if( col == 2 ) {
return a33;
} else if( col == 3 ) {
return a34;
} else if( col == 4 ) {
return a35;
}
} else if( row == 3 ) {
if( col == 0 ) {
return a41;
} else if( col == 1 ) {
return a42;
} else if( col == 2 ) {
return a43;
} else if( col == 3 ) {
return a44;
} else if( col == 4 ) {
return a45;
}
} else if( row == 4 ) {
if( col == 0 ) {
return a51;
} else if( col == 1 ) {
return a52;
} else if( col == 2 ) {
return a53;
} else if( col == 3 ) {
return a54;
} else if( col == 4 ) {
return a55;
}
}
throw new IllegalArgumentException("Row and/or column out of range. "+row+" "+col);
}
@Override
public void set(int row, int col, double val) {
unsafe_set(row,col,val);
}
@Override
public void unsafe_set(int row, int col, double val) {
if( row == 0 ) {
if( col == 0 ) {
a11 = val; return;
} else if( col == 1 ) {
a12 = val; return;
} else if( col == 2 ) {
a13 = val; return;
} else if( col == 3 ) {
a14 = val; return;
} else if( col == 4 ) {
a15 = val; return;
}
} else if( row == 1 ) {
if( col == 0 ) {
a21 = val; return;
} else if( col == 1 ) {
a22 = val; return;
} else if( col == 2 ) {
a23 = val; return;
} else if( col == 3 ) {
a24 = val; return;
} else if( col == 4 ) {
a25 = val; return;
}
} else if( row == 2 ) {
if( col == 0 ) {
a31 = val; return;
} else if( col == 1 ) {
a32 = val; return;
} else if( col == 2 ) {
a33 = val; return;
} else if( col == 3 ) {
a34 = val; return;
} else if( col == 4 ) {
a35 = val; return;
}
} else if( row == 3 ) {
if( col == 0 ) {
a41 = val; return;
} else if( col == 1 ) {
a42 = val; return;
} else if( col == 2 ) {
a43 = val; return;
} else if( col == 3 ) {
a44 = val; return;
} else if( col == 4 ) {
a45 = val; return;
}
} else if( row == 4 ) {
if( col == 0 ) {
a51 = val; return;
} else if( col == 1 ) {
a52 = val; return;
} else if( col == 2 ) {
a53 = val; return;
} else if( col == 3 ) {
a54 = val; return;
} else if( col == 4 ) {
a55 = val; return;
}
}
throw new IllegalArgumentException("Row and/or column out of range. "+row+" "+col);
}
@Override
public void set(Matrix original) {
if( original.getNumCols() != 5 || original.getNumRows() != 5 )
throw new IllegalArgumentException("Rows and/or columns do not match");
RealMatrix64F m = (RealMatrix64F)original;
a11 = m.get(0,0);
a12 = m.get(0,1);
a13 = m.get(0,2);
a14 = m.get(0,3);
a15 = m.get(0,4);
a21 = m.get(1,0);
a22 = m.get(1,1);
a23 = m.get(1,2);
a24 = m.get(1,3);
a25 = m.get(1,4);
a31 = m.get(2,0);
a32 = m.get(2,1);
a33 = m.get(2,2);
a34 = m.get(2,3);
a35 = m.get(2,4);
a41 = m.get(3,0);
a42 = m.get(3,1);
a43 = m.get(3,2);
a44 = m.get(3,3);
a45 = m.get(3,4);
a51 = m.get(4,0);
a52 = m.get(4,1);
a53 = m.get(4,2);
a54 = m.get(4,3);
a55 = m.get(4,4);
}
@Override
public int getNumRows() {
return 5;
}
@Override
public int getNumCols() {
return 5;
}
@Override
public int getNumElements() {
return 25;
}
@Override
public T copy() {
return (T)new FixedMatrix5x5_64F(this);
}
@Override
public void print() {
MatrixIO.print(System.out, this);
}
}
ejml-0.28/main/core/src/org/ejml/data/FixedMatrix64F.java 0000664 0000000 0000000 00000001544 12561715344 0023047 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
/**
* Interface which all fixed sized matrices must implement
*
* @author Peter Abeles
*/
public interface FixedMatrix64F extends RealMatrix64F {
}
ejml-0.28/main/core/src/org/ejml/data/FixedMatrix6_64F.java 0000664 0000000 0000000 00000007721 12561715344 0023277 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
* Fixed sized vector with 6 elements. Can represent a 6 x 1 or 1 x 6 matrix, context dependent.
*
* @author Peter Abeles
*/
public class FixedMatrix6_64F implements FixedMatrix64F {
public double a1,a2,a3,a4,a5,a6;
public FixedMatrix6_64F() {
}
public FixedMatrix6_64F(double a1,double a2,double a3,double a4,double a5,double a6)
{
this.a1 = a1;
this.a2 = a2;
this.a3 = a3;
this.a4 = a4;
this.a5 = a5;
this.a6 = a6;
}
public FixedMatrix6_64F(FixedMatrix6_64F o) {
this.a1 = o.a1;
this.a2 = o.a2;
this.a3 = o.a3;
this.a4 = o.a4;
this.a5 = o.a5;
this.a6 = o.a6;
}
@Override
public double get(int row, int col) {
return unsafe_get(row,col);
}
@Override
public double unsafe_get(int row, int col) {
if( row != 0 && col != 0 )
throw new IllegalArgumentException("Row or column must be zero since this is a vector");
int w = Math.max(row,col);
if( w == 0 ) {
return a1;
} else if( w == 1 ) {
return a2;
} else if( w == 2 ) {
return a3;
} else if( w == 3 ) {
return a4;
} else if( w == 4 ) {
return a5;
} else if( w == 5 ) {
return a6;
} else {
throw new IllegalArgumentException("Out of range. "+w);
}
}
@Override
public void set(int row, int col, double val) {
unsafe_set(row,col,val);
}
@Override
public void unsafe_set(int row, int col, double val) {
if( row != 0 && col != 0 )
throw new IllegalArgumentException("Row or column must be zero since this is a vector");
int w = Math.max(row,col);
if( w == 0 ) {
a1 = val;
} else if( w == 1 ) {
a2 = val;
} else if( w == 2 ) {
a3 = val;
} else if( w == 3 ) {
a4 = val;
} else if( w == 4 ) {
a5 = val;
} else if( w == 5 ) {
a6 = val;
} else {
throw new IllegalArgumentException("Out of range. "+w);
}
}
@Override
public void set(Matrix original) {
RealMatrix64F m = (RealMatrix64F)original;
if( m.getNumCols() == 1 && m.getNumRows() == 6 ) {
a1 = m.get(0,0);
a2 = m.get(1,0);
a3 = m.get(2,0);
a4 = m.get(3,0);
a5 = m.get(4,0);
a6 = m.get(5,0);
} else if( m.getNumRows() == 1 && m.getNumCols() == 6 ){
a1 = m.get(0,0);
a2 = m.get(0,1);
a3 = m.get(0,2);
a4 = m.get(0,3);
a5 = m.get(0,4);
a6 = m.get(0,5);
} else {
throw new IllegalArgumentException("Incompatible shape");
}
}
@Override
public int getNumRows() {
return 6;
}
@Override
public int getNumCols() {
return 1;
}
@Override
public int getNumElements() {
return 6;
}
@Override
public T copy() {
return (T)new FixedMatrix6_64F(this);
}
@Override
public void print() {
MatrixIO.print(System.out, this);
}
}
ejml-0.28/main/core/src/org/ejml/data/FixedMatrix6x6_64F.java 0000664 0000000 0000000 00000025774 12561715344 0023565 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.MatrixIO;
/**
* Fixed sized 6 by FixedMatrix6x6_64F matrix. The matrix is stored as class variables for very fast read/write. aXY is the
* value of row = X and column = Y.
*
* @author Peter Abeles
*/
public class FixedMatrix6x6_64F implements FixedMatrix64F {
public double a11,a12,a13,a14,a15,a16;
public double a21,a22,a23,a24,a25,a26;
public double a31,a32,a33,a34,a35,a36;
public double a41,a42,a43,a44,a45,a46;
public double a51,a52,a53,a54,a55,a56;
public double a61,a62,a63,a64,a65,a66;
public FixedMatrix6x6_64F() {
}
public FixedMatrix6x6_64F( double a11,double a12,double a13,double a14,double a15,double a16,
double a21,double a22,double a23,double a24,double a25,double a26,
double a31,double a32,double a33,double a34,double a35,double a36,
double a41,double a42,double a43,double a44,double a45,double a46,
double a51,double a52,double a53,double a54,double a55,double a56,
double a61,double a62,double a63,double a64,double a65,double a66)
{
this.a11 = a11;
this.a12 = a12;
this.a13 = a13;
this.a14 = a14;
this.a15 = a15;
this.a16 = a16;
this.a21 = a21;
this.a22 = a22;
this.a23 = a23;
this.a24 = a24;
this.a25 = a25;
this.a26 = a26;
this.a31 = a31;
this.a32 = a32;
this.a33 = a33;
this.a34 = a34;
this.a35 = a35;
this.a36 = a36;
this.a41 = a41;
this.a42 = a42;
this.a43 = a43;
this.a44 = a44;
this.a45 = a45;
this.a46 = a46;
this.a51 = a51;
this.a52 = a52;
this.a53 = a53;
this.a54 = a54;
this.a55 = a55;
this.a56 = a56;
this.a61 = a61;
this.a62 = a62;
this.a63 = a63;
this.a64 = a64;
this.a65 = a65;
this.a66 = a66;
}
public FixedMatrix6x6_64F( FixedMatrix6x6_64F o ) {
this.a11 = o.a11;
this.a12 = o.a12;
this.a13 = o.a13;
this.a14 = o.a14;
this.a15 = o.a15;
this.a16 = o.a16;
this.a21 = o.a21;
this.a22 = o.a22;
this.a23 = o.a23;
this.a24 = o.a24;
this.a25 = o.a25;
this.a26 = o.a26;
this.a31 = o.a31;
this.a32 = o.a32;
this.a33 = o.a33;
this.a34 = o.a34;
this.a35 = o.a35;
this.a36 = o.a36;
this.a41 = o.a41;
this.a42 = o.a42;
this.a43 = o.a43;
this.a44 = o.a44;
this.a45 = o.a45;
this.a46 = o.a46;
this.a51 = o.a51;
this.a52 = o.a52;
this.a53 = o.a53;
this.a54 = o.a54;
this.a55 = o.a55;
this.a56 = o.a56;
this.a61 = o.a61;
this.a62 = o.a62;
this.a63 = o.a63;
this.a64 = o.a64;
this.a65 = o.a65;
this.a66 = o.a66;
}
@Override
public double get(int row, int col) {
return unsafe_get(row,col);
}
@Override
public double unsafe_get(int row, int col) {
if( row == 0 ) {
if( col == 0 ) {
return a11;
} else if( col == 1 ) {
return a12;
} else if( col == 2 ) {
return a13;
} else if( col == 3 ) {
return a14;
} else if( col == 4 ) {
return a15;
} else if( col == 5 ) {
return a16;
}
} else if( row == 1 ) {
if( col == 0 ) {
return a21;
} else if( col == 1 ) {
return a22;
} else if( col == 2 ) {
return a23;
} else if( col == 3 ) {
return a24;
} else if( col == 4 ) {
return a25;
} else if( col == 5 ) {
return a26;
}
} else if( row == 2 ) {
if( col == 0 ) {
return a31;
} else if( col == 1 ) {
return a32;
} else if( col == 2 ) {
return a33;
} else if( col == 3 ) {
return a34;
} else if( col == 4 ) {
return a35;
} else if( col == 5 ) {
return a36;
}
} else if( row == 3 ) {
if( col == 0 ) {
return a41;
} else if( col == 1 ) {
return a42;
} else if( col == 2 ) {
return a43;
} else if( col == 3 ) {
return a44;
} else if( col == 4 ) {
return a45;
} else if( col == 5 ) {
return a46;
}
} else if( row == 4 ) {
if( col == 0 ) {
return a51;
} else if( col == 1 ) {
return a52;
} else if( col == 2 ) {
return a53;
} else if( col == 3 ) {
return a54;
} else if( col == 4 ) {
return a55;
} else if( col == 5 ) {
return a56;
}
} else if( row == 5 ) {
if( col == 0 ) {
return a61;
} else if( col == 1 ) {
return a62;
} else if( col == 2 ) {
return a63;
} else if( col == 3 ) {
return a64;
} else if( col == 4 ) {
return a65;
} else if( col == 5 ) {
return a66;
}
}
throw new IllegalArgumentException("Row and/or column out of range. "+row+" "+col);
}
@Override
public void set(int row, int col, double val) {
unsafe_set(row,col,val);
}
@Override
public void unsafe_set(int row, int col, double val) {
if( row == 0 ) {
if( col == 0 ) {
a11 = val; return;
} else if( col == 1 ) {
a12 = val; return;
} else if( col == 2 ) {
a13 = val; return;
} else if( col == 3 ) {
a14 = val; return;
} else if( col == 4 ) {
a15 = val; return;
} else if( col == 5 ) {
a16 = val; return;
}
} else if( row == 1 ) {
if( col == 0 ) {
a21 = val; return;
} else if( col == 1 ) {
a22 = val; return;
} else if( col == 2 ) {
a23 = val; return;
} else if( col == 3 ) {
a24 = val; return;
} else if( col == 4 ) {
a25 = val; return;
} else if( col == 5 ) {
a26 = val; return;
}
} else if( row == 2 ) {
if( col == 0 ) {
a31 = val; return;
} else if( col == 1 ) {
a32 = val; return;
} else if( col == 2 ) {
a33 = val; return;
} else if( col == 3 ) {
a34 = val; return;
} else if( col == 4 ) {
a35 = val; return;
} else if( col == 5 ) {
a36 = val; return;
}
} else if( row == 3 ) {
if( col == 0 ) {
a41 = val; return;
} else if( col == 1 ) {
a42 = val; return;
} else if( col == 2 ) {
a43 = val; return;
} else if( col == 3 ) {
a44 = val; return;
} else if( col == 4 ) {
a45 = val; return;
} else if( col == 5 ) {
a46 = val; return;
}
} else if( row == 4 ) {
if( col == 0 ) {
a51 = val; return;
} else if( col == 1 ) {
a52 = val; return;
} else if( col == 2 ) {
a53 = val; return;
} else if( col == 3 ) {
a54 = val; return;
} else if( col == 4 ) {
a55 = val; return;
} else if( col == 5 ) {
a56 = val; return;
}
} else if( row == 5 ) {
if( col == 0 ) {
a61 = val; return;
} else if( col == 1 ) {
a62 = val; return;
} else if( col == 2 ) {
a63 = val; return;
} else if( col == 3 ) {
a64 = val; return;
} else if( col == 4 ) {
a65 = val; return;
} else if( col == 5 ) {
a66 = val; return;
}
}
throw new IllegalArgumentException("Row and/or column out of range. "+row+" "+col);
}
@Override
public void set(Matrix original) {
if( original.getNumCols() != 6 || original.getNumRows() != 6 )
throw new IllegalArgumentException("Rows and/or columns do not match");
RealMatrix64F m = (RealMatrix64F)original;
a11 = m.get(0,0);
a12 = m.get(0,1);
a13 = m.get(0,2);
a14 = m.get(0,3);
a15 = m.get(0,4);
a16 = m.get(0,5);
a21 = m.get(1,0);
a22 = m.get(1,1);
a23 = m.get(1,2);
a24 = m.get(1,3);
a25 = m.get(1,4);
a26 = m.get(1,5);
a31 = m.get(2,0);
a32 = m.get(2,1);
a33 = m.get(2,2);
a34 = m.get(2,3);
a35 = m.get(2,4);
a36 = m.get(2,5);
a41 = m.get(3,0);
a42 = m.get(3,1);
a43 = m.get(3,2);
a44 = m.get(3,3);
a45 = m.get(3,4);
a46 = m.get(3,5);
a51 = m.get(4,0);
a52 = m.get(4,1);
a53 = m.get(4,2);
a54 = m.get(4,3);
a55 = m.get(4,4);
a56 = m.get(4,5);
a61 = m.get(5,0);
a62 = m.get(5,1);
a63 = m.get(5,2);
a64 = m.get(5,3);
a65 = m.get(5,4);
a66 = m.get(5,5);
}
@Override
public int getNumRows() {
return 6;
}
@Override
public int getNumCols() {
return 6;
}
@Override
public int getNumElements() {
return 36;
}
@Override
public T copy() {
return (T)new FixedMatrix6x6_64F(this);
}
@Override
public void print() {
MatrixIO.print(System.out, this);
}
}
ejml-0.28/main/core/src/org/ejml/data/Matrix.java 0000664 0000000 0000000 00000002673 12561715344 0021613 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import java.io.Serializable;
/**
* Base interface for all rectangular matrices
*
* @author Peter Abeles
*/
public interface Matrix extends Serializable {
/**
* Returns the number of rows in this matrix.
*
* @return Number of rows.
*/
public int getNumRows();
/**
* Returns the number of columns in this matrix.
*
* @return Number of columns.
*/
public int getNumCols();
/**
* Creates an exact copy of the matrix
*/
public T copy();
/**
* Sets this matrix to be identical to the 'original' matrix passed in.
*/
public void set( Matrix original );
/**
* Prints the matrix to standard out.
*/
public void print();
}
ejml-0.28/main/core/src/org/ejml/data/MatrixIterator32F.java 0000664 0000000 0000000 00000010373 12561715344 0023574 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import java.util.Iterator;
/**
* This is a matrix iterator for traversing through a submatrix. For speed it is recommended
* that you directly access the elements in the matrix, but there are some situations where this
* can be a better design.
*
* @author Peter Abeles
*/
public class MatrixIterator32F implements Iterator {
// the matrix which is being iterated through
private D1Matrix32F a;
// should it iterate through by row or by column
private boolean rowMajor;
// the first row and column it returns
private int minCol;
private int minRow;
// where in the iteration it is
private int index = 0;
// how many elements inside will it return
private int size;
// how wide the submatrix is
private int submatrixStride;
// the current element
int subRow,subCol;
/**
* Creates a new iterator for traversing through a submatrix inside this matrix. It can be traversed
* by row or by column. Range of elements is inclusive, e.g. minRow = 0 and maxRow = 1 will include rows
* 0 and 1. The iteration starts at (minRow,minCol) and ends at (maxRow,maxCol)
*
* @param a the matrix it is iterating through
* @param rowMajor true means it will traverse through the submatrix by row first, false by columns.
* @param minRow first row it will start at.
* @param minCol first column it will start at.
* @param maxRow last row it will stop at.
* @param maxCol last column it will stop at.
* @return A new MatrixIterator
*/
public MatrixIterator32F(D1Matrix32F a, boolean rowMajor,
int minRow, int minCol, int maxRow, int maxCol
) {
if( maxCol < minCol )
throw new IllegalArgumentException("maxCol has to be more than or equal to minCol");
if( maxRow < minRow )
throw new IllegalArgumentException("maxRow has to be more than or equal to minCol");
if( maxCol >= a.numCols)
throw new IllegalArgumentException("maxCol must be < numCols");
if( maxRow >= a.numRows)
throw new IllegalArgumentException("maxRow must be < numCRows");
this.a = a;
this.rowMajor = rowMajor;
this.minCol = minCol;
this.minRow = minRow;
size = (maxCol-minCol+1)*(maxRow-minRow+1);
if( rowMajor )
submatrixStride = maxCol-minCol+1;
else
submatrixStride = maxRow-minRow+1;
}
@Override
public boolean hasNext() {
return index < size;
}
@Override
public Float next() {
if( rowMajor ) {
subRow = index / submatrixStride;
subCol = index % submatrixStride;
} else {
subRow = index % submatrixStride;
subCol = index / submatrixStride;
}
index++;
return a.get(subRow+minRow,subCol+minCol);
}
@Override
public void remove() {
throw new RuntimeException("Operation not supported");
}
/**
* Which element in the submatrix was returned by next()
*
* @return Submatrix element's index.
*/
public int getIndex() {
return index-1;
}
/**
* True if it is iterating through the matrix by rows and false if by columns.
* @return row major or column major
*/
public boolean isRowMajor() {
return rowMajor;
}
/**
* Sets the value of the current element.
*
* @param value The element's new value.
*/
public void set( float value ) {
a.set(subRow+minRow,subCol+minCol,value);
}
}
ejml-0.28/main/core/src/org/ejml/data/MatrixIterator64F.java 0000664 0000000 0000000 00000010376 12561715344 0023604 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import java.util.Iterator;
/**
* This is a matrix iterator for traversing through a submatrix. For speed it is recommended
* that you directly access the elements in the matrix, but there are some situations where this
* can be a better design.
*
* @author Peter Abeles
*/
public class MatrixIterator64F implements Iterator {
// the matrix which is being iterated through
private D1Matrix64F a;
// should it iterate through by row or by column
private boolean rowMajor;
// the first row and column it returns
private int minCol;
private int minRow;
// where in the iteration it is
private int index = 0;
// how many elements inside will it return
private int size;
// how wide the submatrix is
private int submatrixStride;
// the current element
int subRow,subCol;
/**
* Creates a new iterator for traversing through a submatrix inside this matrix. It can be traversed
* by row or by column. Range of elements is inclusive, e.g. minRow = 0 and maxRow = 1 will include rows
* 0 and 1. The iteration starts at (minRow,minCol) and ends at (maxRow,maxCol)
*
* @param a the matrix it is iterating through
* @param rowMajor true means it will traverse through the submatrix by row first, false by columns.
* @param minRow first row it will start at.
* @param minCol first column it will start at.
* @param maxRow last row it will stop at.
* @param maxCol last column it will stop at.
* @return A new MatrixIterator
*/
public MatrixIterator64F(D1Matrix64F a, boolean rowMajor,
int minRow, int minCol, int maxRow, int maxCol
) {
if( maxCol < minCol )
throw new IllegalArgumentException("maxCol has to be more than or equal to minCol");
if( maxRow < minRow )
throw new IllegalArgumentException("maxRow has to be more than or equal to minCol");
if( maxCol >= a.numCols)
throw new IllegalArgumentException("maxCol must be < numCols");
if( maxRow >= a.numRows)
throw new IllegalArgumentException("maxRow must be < numCRows");
this.a = a;
this.rowMajor = rowMajor;
this.minCol = minCol;
this.minRow = minRow;
size = (maxCol-minCol+1)*(maxRow-minRow+1);
if( rowMajor )
submatrixStride = maxCol-minCol+1;
else
submatrixStride = maxRow-minRow+1;
}
@Override
public boolean hasNext() {
return index < size;
}
@Override
public Double next() {
if( rowMajor ) {
subRow = index / submatrixStride;
subCol = index % submatrixStride;
} else {
subRow = index % submatrixStride;
subCol = index / submatrixStride;
}
index++;
return a.get(subRow+minRow,subCol+minCol);
}
@Override
public void remove() {
throw new RuntimeException("Operation not supported");
}
/**
* Which element in the submatrix was returned by next()
*
* @return Submatrix element's index.
*/
public int getIndex() {
return index-1;
}
/**
* True if it is iterating through the matrix by rows and false if by columns.
* @return row major or column major
*/
public boolean isRowMajor() {
return rowMajor;
}
/**
* Sets the value of the current element.
*
* @param value The element's new value.
*/
public void set( double value ) {
a.set(subRow+minRow,subCol+minCol,value);
}
}
ejml-0.28/main/core/src/org/ejml/data/RealMatrix32F.java 0000664 0000000 0000000 00000005367 12561715344 0022675 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
/**
* Interface for all 32 bit floating point rectangular matrices.
*
* @author Peter Abeles
*/
public interface RealMatrix32F extends Matrix {
/**
* Returns the value of value of the specified matrix element.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @return The specified element's value.
*/
public float get(int row, int col);
/**
* Same as {@link #get} but does not perform bounds check on input parameters. This results in about a 25%
* speed increase but potentially sacrifices stability and makes it more difficult to track down simple errors.
* It is not recommended that this function be used, except in highly optimized code where the bounds are
* implicitly being checked.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @return The specified element's value.
*/
public float unsafe_get(int row, int col);
/**
* Sets the value of the specified matrix element.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @param val The element's new value.
*/
public void set(int row, int col, float val);
/**
* Same as {@link #set} but does not perform bounds check on input parameters. This results in about a 25%
* speed increase but potentially sacrifices stability and makes it more difficult to track down simple errors.
* It is not recommended that this function be used, except in highly optimized code where the bounds are
* implicitly being checked.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @param val The element's new value.
*/
public void unsafe_set(int row, int col, float val);
/**
* Returns the number of elements in this matrix, which is the number of rows
* times the number of columns.
*
* @return Number of elements in this matrix.
*/
public int getNumElements();
}
ejml-0.28/main/core/src/org/ejml/data/RealMatrix64F.java 0000664 0000000 0000000 00000005373 12561715344 0022677 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
/**
* Interface for all 64 bit floating point rectangular matrices.
*
* @author Peter Abeles
*/
public interface RealMatrix64F extends Matrix {
/**
* Returns the value of value of the specified matrix element.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @return The specified element's value.
*/
public double get(int row, int col);
/**
* Same as {@link #get} but does not perform bounds check on input parameters. This results in about a 25%
* speed increase but potentially sacrifices stability and makes it more difficult to track down simple errors.
* It is not recommended that this function be used, except in highly optimized code where the bounds are
* implicitly being checked.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @return The specified element's value.
*/
public double unsafe_get(int row, int col);
/**
* Sets the value of the specified matrix element.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @param val The element's new value.
*/
public void set(int row, int col, double val);
/**
* Same as {@link #set} but does not perform bounds check on input parameters. This results in about a 25%
* speed increase but potentially sacrifices stability and makes it more difficult to track down simple errors.
* It is not recommended that this function be used, except in highly optimized code where the bounds are
* implicitly being checked.
*
* @param row Matrix element's row index..
* @param col Matrix element's column index.
* @param val The element's new value.
*/
public void unsafe_set(int row, int col, double val);
/**
* Returns the number of elements in this matrix, which is the number of rows
* times the number of columns.
*
* @return Number of elements in this matrix.
*/
public int getNumElements();
}
ejml-0.28/main/core/src/org/ejml/data/ReshapeMatrix.java 0000664 0000000 0000000 00000002106 12561715344 0023112 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
/**
* Matrix which can be reshaped
*
* @author Peter Abeles
*/
public interface ReshapeMatrix extends Matrix{
/**
* Equivalent to invoking reshape(numRows,numCols,false);
*
* @param numRows The new number of rows in the matrix.
* @param numCols The new number of columns in the matrix.
*/
public void reshape( int numRows , int numCols );
}
ejml-0.28/main/core/src/org/ejml/data/RowD1Matrix64F.java 0000664 0000000 0000000 00000001566 12561715344 0022750 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2013, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
/**
* Interface for a row-major matrix that uses a single array internally.
*
* @author Peter Abeles
*/
public abstract class RowD1Matrix64F extends D1Matrix64F {
}
ejml-0.28/main/core/src/org/ejml/interfaces/ 0000775 0000000 0000000 00000000000 12561715344 0020706 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/src/org/ejml/interfaces/decomposition/ 0000775 0000000 0000000 00000000000 12561715344 0023562 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/src/org/ejml/interfaces/decomposition/BidiagonalDecomposition.java 0000664 0000000 0000000 00000004556 12561715344 0031225 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.decomposition;
import org.ejml.data.Matrix;
/**
*
* Computes a matrix decomposition such that:
*
* A = U*B*VT
*
* where A is m by n, U is orthogonal and m by m, B is an m by n bidiagonal matrix, V is orthogonal and n by n.
* This is used as a first step in computing the SVD of a matrix for the QR algorithm approach.
*
*
* A bidiagonal matrix has zeros in every element except for the two diagonals.
*
* b_ij = 0 if i > j or i < j-1
*
*
*
* @author Peter Abeles
*/
public interface BidiagonalDecomposition
extends DecompositionInterface {
/**
* Returns the bidiagonal matrix.
*
* @param B If not null the results are stored here, if null a new matrix is created.
* @return The bidiagonal matrix.
*/
public T getB( T B , boolean compact );
/**
* Returns the orthogonal U matrix.
*
* @param U If not null then the results will be stored here. Otherwise a new matrix will be created.
* @return The extracted Q matrix.
*/
public T getU( T U , boolean transpose , boolean compact );
/**
* Returns the orthogonal V matrix.
*
* @param V If not null then the results will be stored here. Otherwise a new matrix will be created.
* @return The extracted Q matrix.
*/
public T getV( T V , boolean transpose , boolean compact );
/**
* Extracts the diagonal and off diagonal elements from the decomposition.
*
* @param diag diagonal elements from B.
* @param off off diagonal elements form B.
*/
public void getDiagonal( double diag[], double off[] );
} ejml-0.28/main/core/src/org/ejml/interfaces/decomposition/CholeskyDecomposition.java 0000664 0000000 0000000 00000004343 12561715344 0030747 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.decomposition;
import org.ejml.data.Complex64F;
import org.ejml.data.DenseMatrix64F;
import org.ejml.data.Matrix;
/**
*
* Cholesky decomposition for {@link DenseMatrix64F}. It decomposes positive-definite symmetric matrices (real)
* or hermitian-positive definite (complex) into either upper or lower triangles:
*
* L*LH=A
* RH*R=A
*
* where L is a lower triangular matrix and R is an upper triangular matrix. This is typically
* used to invert matrices, such as a covariance matrix.
*
*
* @author Peter Abeles
*/
public interface CholeskyDecomposition
extends DecompositionInterface {
/**
* If true the decomposition was for a lower triangular matrix.
* If false it was for an upper triangular matrix.
*
* @return True if lower, false if upper.
*/
public boolean isLower();
/**
*
* Returns the triangular matrix from the decomposition.
*
*
*
* If an input is provided that matrix is used to write the results to.
* Otherwise a new matrix is created and the results written to it.
*
*
* @param T If not null then the decomposed matrix is written here.
* @return A lower or upper triangular matrix.
*/
public MatrixType getT( MatrixType T );
/**
* Computes the matrix's determinant using the decomposition.
*
* @return The determinant.
*/
public Complex64F computeDeterminant();
} ejml-0.28/main/core/src/org/ejml/interfaces/decomposition/CholeskyLDLDecomposition.java 0000664 0000000 0000000 00000004704 12561715344 0031304 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.decomposition;
import org.ejml.data.Matrix;
/**
*
* Cholesky LDLT decomposition for {@link org.ejml.data.DenseMatrix64F}.
*
*
* A Cholesky LDL decomposition decomposes positive-definite symmetric matrices into:
*
* L*D*LT=A
*
* where L is a lower triangular matrix and D is a diagonal matrix. The main advantage of LDL versus LL or RR Cholesky is that
* it avoid a square root operation.
*
*
* @see org.ejml.alg.dense.decomposition.chol.CholeskyDecompositionLDL_D64
*
* @author Peter Abeles
*/
public interface CholeskyLDLDecomposition
extends DecompositionInterface {
/**
*
* Returns the lower triangular matrix from the decomposition.
*
*
*
* If an input is provided that matrix is used to write the results to.
* Otherwise a new matrix is created and the results written to it.
*
*
* @param L If not null then the decomposed matrix is written here.
* @return A lower triangular matrix.
*/
public MatrixType getL(MatrixType L);
/**
* Returns the elements in the diagonal matrix
* @return array with diagonal elements. Array might be larger than the number of elements.
*/
public double[] getDiagonal();
/**
*
* Returns the diagonal matrixfrom the decomposition.
*
*
*
* If an input is provided that matrix is used to write the results to.
* Otherwise a new matrix is created and the results written to it.
*
*
* @param D If not null it will be used to store the diagonal matrix
* @return D Square diagonal matrix
*/
public MatrixType getD(MatrixType D);
} ejml-0.28/main/core/src/org/ejml/interfaces/decomposition/DecompositionInterface.java 0000664 0000000 0000000 00000004340 12561715344 0031063 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.decomposition;
import org.ejml.data.Matrix;
/**
*
* An interface for performing matrix decompositions on a {@link org.ejml.data.DenseMatrix64F}.
*
*
*
* A matrix decomposition is an algorithm which decomposes the input matrix into a set of equivalent
* matrices that store the same information as the original. Decompositions are useful
* in that they allow specialized efficient algorithms to be run on generic input
* matrices.
*
*
*
* By default most decompositions will modify the input matrix. This is done to save
* memory and simply code by reducing the number of cases which need to be tested.
*
*
* @author Peter Abeles
*/
public interface DecompositionInterface {
/**
* Computes the decomposition of the input matrix. Depending on the implementation
* the input matrix might be stored internally or modified. If it is modified then
* the function {@link #inputModified()} will return true and the matrix should not be
* modified until the decomposition is no longer needed.
*
* @param orig The matrix which is being decomposed. Modification is implementation dependent.
* @return Returns if it was able to decompose the matrix.
*/
public boolean decompose( T orig );
/**
* Is the input matrix to {@link #decompose(org.ejml.data.Matrix)} is modified during
* the decomposition process.
*
* @return true if the input matrix to decompose() is modified.
*/
public boolean inputModified();
}
ejml-0.28/main/core/src/org/ejml/interfaces/decomposition/EigenDecomposition.java 0000664 0000000 0000000 00000006245 12561715344 0030220 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.decomposition;
import org.ejml.data.Complex64F;
import org.ejml.data.Matrix;
/**
*
* This is a generic interface for computing the eigenvalues and eigenvectors of a matrix.
* Eigenvalues and eigenvectors have the following property:
*
* A*v=λ*v
*
* where A is a square matrix and v is an eigenvector associated with the eigenvalue λ.
*
*
*
* In general, both eigenvalues and eigenvectors can be complex numbers. For symmetric matrices the
* eigenvalues and eigenvectors are always real numbers. EJML does not support complex matrices but
* it does have minimal support for complex numbers. As a result complex eigenvalues are found, but only
* the real eigenvectors are computed.
*
*
*
* To create a new instance of {@link EigenDecomposition} use {@link org.ejml.factory.DecompositionFactory}. If the matrix
* is known to be symmetric be sure to use the symmetric decomposition, which is much faster and more accurate
* than the general purpose one.
*
* @author Peter Abeles
*/
public interface EigenDecomposition
extends DecompositionInterface {
/**
* Returns the number of eigenvalues/eigenvectors. This is the matrix's dimension.
*
* @return number of eigenvalues/eigenvectors.
*/
public int getNumberOfEigenvalues();
/**
*
* Returns an eigenvalue as a complex number. For symmetric matrices the returned eigenvalue will always be a real
* number, which means the imaginary component will be equal to zero.
*
*
*
* NOTE: The order of the eigenvalues is dependent upon the decomposition algorithm used. This means that they may
* or may not be ordered by magnitude. For example the QR algorithm will returns results that are partially
* ordered by magnitude, but this behavior should not be relied upon.
*
*
* @param index Index of the eigenvalue eigenvector pair.
* @return An eigenvalue.
*/
public Complex64F getEigenvalue( int index );
/**
*
* Used to retrieve real valued eigenvectors. If an eigenvector is associated with a complex eigenvalue
* then null is returned instead.
*
*
* @param index Index of the eigenvalue eigenvector pair.
* @return If the associated eigenvalue is real then an eigenvector is returned, null otherwise.
*/
public MatrixType getEigenVector( int index );
}
ejml-0.28/main/core/src/org/ejml/interfaces/decomposition/LUDecomposition.java 0000664 0000000 0000000 00000007232 12561715344 0027506 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.decomposition;
import org.ejml.data.Complex64F;
import org.ejml.data.Matrix;
/**
*
* LU Decomposition refactors the original matrix such that:
*
PT*L*U = A
* where P is a pivot matrix, L is a lower triangular matrix, U is an upper triangular matrix and A is
* the original matrix.
*
*
*
* LU Decomposition is useful since once the decomposition has been performed linear
* equations can be quickly solved and the original matrix A inverted. Different algorithms
* can be selected to perform the decomposition, all will have the same end result.
*
*
* To use this class first specify the size of the matrix that will be decomposed by it in
* the constructor. Only square m by m matrices can be decomposed. Then to decompose a matrix
* call {@link #decompose}. If it encounters any problems an exception will be thrown. After
* that all the other functions will be available for solving and inverting matrices.
*
*
* @author Peter Abeles
*/
public interface LUDecomposition
extends DecompositionInterface {
/**
*
* Returns the L matrix from the decomposition. Should only
* be called after {@link #decompose(org.ejml.data.Matrix)} has
* been called.
*
*
*
* If parameter 'lower' is not null, then that matrix is used to store the L matrix. Otherwise
* a new matrix is created.
*
*
* @param lower Storage for T matrix. If null then a new matrix is returned. Modified.
* @return The L matrix.
*/
public T getLower( T lower );
/**
*
* Returns the U matrix from the decomposition. Should only
* be called after {@link #decompose(org.ejml.data.Matrix)} has
* been called.
*
*
*
* If parameter 'upper' is not null, then that matrix is used to store the U matrix. Otherwise
* a new matrix is created.
*
*
* @param upper Storage for U matrix. If null then a new matrix is returned. Modified.
* @return The U matrix.
*/
public T getUpper( T upper );
/**
*
* For numerical stability there are often row interchanges. This computes
* a pivot matrix that will undo those changes.
*
*
* @param pivot Storage for the pivot matrix. If null then a new matrix is returned. Modified.
* @return The pivot matrix.
*/
public T getPivot( T pivot );
/**
* Returns true if the decomposition detected a singular matrix. This check
* will not work 100% of the time due to machine precision issues.
*
* @return True if the matrix is singular and false if it is not.
*/
// TODO Remove? If singular decomposition will fail.
public boolean isSingular();
/**
* Computes the matrix's determinant using the LU decomposition.
*
* @return The determinant.
*/
public Complex64F computeDeterminant();
}
ejml-0.28/main/core/src/org/ejml/interfaces/decomposition/QRDecomposition.java 0000664 0000000 0000000 00000006376 12561715344 0027520 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.decomposition;
import org.ejml.data.Matrix;
/**
*
* QR decompositions decompose a rectangular matrix 'A' such that 'A=QR'. Where
* A ∈ ℜ n × m , n ≥ m, Q ∈ ℜ n × n is an orthogonal matrix,
* and R ∈ ℜ n × m is an upper triangular matrix. Some implementations
* of QR decomposition require that A has full rank.
*
*
* Some features of QR decompositions:
*
* - Can decompose rectangular matrices.
* - Numerically stable solutions to least-squares problem, but not as stable as SVD
* - Can incrementally add and remove columns from the decomposed matrix. See {@link org.ejml.alg.dense.linsol.qr.AdjLinearSolverQr_D64}
*
*
*
* Orthogonal matrices have the following properties:
*
*
* @see org.ejml.alg.dense.decomposition.qr.QRDecompositionHouseholder_D64
* @see org.ejml.alg.dense.decomposition.qr.QRDecompositionHouseholderColumn_D64
*
* @author Peter Abeles
*/
public interface QRDecomposition
extends DecompositionInterface {
/**
*
* Returns the Q matrix from the decomposition. Should only
* be called after {@link #decompose(org.ejml.data.Matrix)} has
* been called.
*
*
*
* If parameter Q is not null, then that matrix is used to store the Q matrix. Otherwise
* a new matrix is created.
*
*
* @param Q If not null then the Q matrix is written to it. Modified.
* @param compact If true an m by n matrix is created, otherwise n by n.
* @return The Q matrix.
*/
public T getQ( T Q, boolean compact);
/**
*
* Returns the R matrix from the decomposition. Should only be
* called after {@link #decompose(org.ejml.data.Matrix)} has been.
*
*
* If setZeros is true then an n × m matrix is required and all the elements are set.
* If setZeros is false then the matrix must be at least m × m and only the upper triangular
* elements are set.
*
*
*
* If parameter R is not null, then that matrix is used to store the R matrix. Otherwise
* a new matrix is created.
*
*
* @param R If not null then the R matrix is written to it. Modified.
* @param compact If true only the upper triangular elements are set
* @return The R matrix.
*/
public T getR( T R, boolean compact);
}
ejml-0.28/main/core/src/org/ejml/interfaces/decomposition/QRPDecomposition.java 0000664 0000000 0000000 00000004345 12561715344 0027632 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.decomposition;
import org.ejml.data.DenseMatrix64F;
import org.ejml.data.Matrix;
/**
*
* Similar to {@link QRDecomposition} but it can handle the rank deficient case by
* performing column pivots during the decomposition. The final decomposition has the
* following structure:
* A*P=Q*R
* where A is the original matrix, P is a pivot matrix, Q is an orthogonal matrix, and R is
* upper triangular.
*
*
* @author Peter Abeles
*/
public interface QRPDecomposition
extends QRDecomposition
{
/**
*
* Specifies the threshold used to flag a column as being singular. The specified threshold is relative
* and will very depending on the system. The default value is UtilEJML.EPS.
*
*
* @param threshold Singular threshold.
*/
public void setSingularThreshold( double threshold );
/**
* Returns the rank as determined by the algorithm. This is dependent upon a fixed threshold
* and might not be appropriate for some applications.
*
* @return Matrix's rank
*/
public int getRank();
/**
* Ordering of each column after pivoting. The current column i was original at column pivot[i].
*
* @return Order of columns.
*/
public int[] getPivots();
/**
* Creates the pivot matrix.
*
* @param P Optional storage for pivot matrix. If null a new matrix will be created.
* @return The pivot matrix.
*/
public DenseMatrix64F getPivotMatrix( DenseMatrix64F P );
}
ejml-0.28/main/core/src/org/ejml/interfaces/decomposition/SingularValueDecomposition.java 0000664 0000000 0000000 00000011710 12561715344 0031743 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.decomposition;
import org.ejml.data.Matrix;
/**
*
* This is an abstract class for computing the singular value decomposition (SVD) of a matrix, which is defined
* as:
*
A = U * W * V T
* where A is m by n, and U and V are orthogonal matrices, and W is a diagonal matrix.
*
*
*
* The dimension of U,W,V depends if it is a compact SVD or not. If not compact then U is m by m, W is m by n, V is n by n.
* If compact then let s be the number of singular values, U is m by s, W is s by s, and V is n by s.
*
*
*
* Accessor functions for decomposed matrices can return an internally constructed matrix if null is passed in for the
* optional storage parameter. The exact behavior is implementation specific. If an internally maintained matrix is
* returned then on the next call to decompose the matrix will be modified. The advantage of this approach is reduced
* memory overhead.
*
*
*
* To create a new instance of SingularValueDecomposition see {@link org.ejml.factory.DecompositionFactory#svd(int, int, boolean, boolean, boolean)}
* and {@link org.ejml.ops.SingularOps} contains additional helpful SVD related functions.
*
*
*
* *Note* that the ordering of singular values is not guaranteed, unless done so by a specific implementation.
* The singular values can be put into descending order while adjusting U and V using {@link org.ejml.ops.SingularOps#descendingOrder(org.ejml.data.DenseMatrix64F, boolean, org.ejml.data.DenseMatrix64F, org.ejml.data.DenseMatrix64F, boolean)} SingularOps.descendingOrder()}.
*
*
* @author Peter Abeles
*/
public abstract interface SingularValueDecomposition
extends DecompositionInterface {
/**
* Returns the singular values. This is the diagonal elements of the W matrix in the decomposition.
* Ordering of singular values is not guaranteed..
*
* @return Singular values. Note this array can be longer than the number of singular values.
* Extra elements have no meaning.
*/
public double [] getSingularValues();
/**
* The number of singular values in the matrix. This is equal to the length of the smallest side.
*
* @return Number of singular values in the matrix.
*/
public int numberOfSingularValues();
/**
* If true then compact matrices are returned.
*
* @return true if results use compact notation.
*/
public boolean isCompact();
/**
*
* Returns the orthogonal 'U' matrix.
*
*
* Internally the SVD algorithm might compute U transposed or it might not. To avoid an
* unnecessary double transpose the option is provided to select if the transpose is returned.
*
*
* @param U Optional storage for U. If null a new instance or internally maintained matrix is returned. Modified.
* @param transposed If the returned U is transposed.
* @return An orthogonal matrix.
*/
public T getU( T U , boolean transposed );
/**
*
* Returns the orthogonal 'V' matrix.
*
*
*
* Internally the SVD algorithm might compute V transposed or it might not. To avoid an
* unnecessary double transpose the option is provided to select if the transpose is returned.
*
*
* @param V Optional storage for v. If null a new instance or internally maintained matrix is returned. Modified.
* @param transposed If the returned V is transposed.
* @return An orthogonal matrix.
*/
public T getV( T V , boolean transposed );
/**
* Returns a diagonal matrix with the singular values. Order of the singular values
* is not guaranteed.
*
* @param W Optional storage for W. If null a new instance or internally maintained matrix is returned. Modified.
* @return Diagonal matrix with singular values along the diagonal.
*/
public T getW( T W );
/**
* Number of rows in the decomposed matrix.
* @return Number of rows in the decomposed matrix.
*/
public int numRows();
/**
* Number of columns in the decomposed matrix.
* @return Number of columns in the decomposed matrix.
*/
public int numCols();
}
ejml-0.28/main/core/src/org/ejml/interfaces/decomposition/TridiagonalSimilarDecomposition.java 0000664 0000000 0000000 00000004056 12561715344 0032745 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.decomposition;
import org.ejml.data.Matrix;
/**
*
* Finds the decomposition of a matrix in the form of:
*
* A = O*T*OT
*
* where A is a symmetric m by m matrix, O is an orthogonal matrix, and T is a tridiagonal matrix.
*
*
* @author Peter Abeles
*/
public interface TridiagonalSimilarDecomposition
extends DecompositionInterface {
/**
* Extracts the tridiagonal matrix found in the decomposition.
*
* @param T If not null then the results will be stored here. Otherwise a new matrix will be created.
* @return The extracted T matrix.
*/
public MatrixType getT( MatrixType T );
/**
* An orthogonal matrix that has the following property: T = QTAQ
*
* @param Q If not null then the results will be stored here. Otherwise a new matrix will be created.
* @return The extracted Q matrix.
*/
public MatrixType getQ( MatrixType Q , boolean transposed );
/**
* Extracts the diagonal and off diagonal elements of the decomposed tridiagonal matrix.
* Since it is symmetric only one off diagonal array is returned.
*
* @param diag Diagonal elements. Modified.
* @param off off diagonal elements. Modified.
*/
public void getDiagonal( double []diag, double []off );
}
ejml-0.28/main/core/src/org/ejml/interfaces/linsol/ 0000775 0000000 0000000 00000000000 12561715344 0022206 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/src/org/ejml/interfaces/linsol/LinearSolver.java 0000664 0000000 0000000 00000013257 12561715344 0025466 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.linsol;
import org.ejml.data.Matrix;
import org.ejml.interfaces.decomposition.DecompositionInterface;
/**
*
* An implementation of LinearSolver solves a linear system or inverts a matrix. It masks more complex
* implementation details, while giving the programmer control over memory management and performance.
* To quickly detect nearly singular matrices without computing the SVD the {@link #quality()}
* function is provided.
*
*
*
* A linear system is defined as:
* A*X = B.
* where A ∈ ℜ m × n, X ∈ ℜ n × p,
* B ∈ ℜ m × p. Different implementations can solve different
* types and shapes in input matrices and have different memory and runtime performance.
*
*
* To solve a system:
*
* - Call {@link #setA(org.ejml.data.Matrix)}
*
- Call {@link #solve(org.ejml.data.Matrix, org.ejml.data.Matrix)}.
*
*
*
*
* To invert a matrix:
*
* - Call {@link #setA(org.ejml.data.Matrix)}
*
- Call {@link #invert(org.ejml.data.Matrix)}.
*
* A matrix can also be inverted by passing in an identity matrix to solve, but this will be
* slower and more memory intensive than the specialized invert() function.
*
*
*
* IMPORTANT: Depending upon the implementation, input matrices might be overwritten by
* the solver. This
* reduces memory and computational requirements and give more control to the programmer. If
* the input matrices need to be not modified then {@link org.ejml.alg.dense.linsol.LinearSolverSafe} can be used. The
* functions {@link #modifiesA()} and {@link #modifiesB()} specify which input matrices are being
* modified.
*
*
* @author Peter Abeles
*/
public interface LinearSolver< T extends Matrix> {
/**
*
* Specifies the A matrix in the linear equation. A reference might be saved
* and it might also be modified depending on the implementation. If it is modified
* then {@link #modifiesA()} will return true.
*
*
*
* If this value returns true that does not guarantee a valid solution was generated. This
* is because some decompositions don't detect singular matrices.
*
*
* @param A The 'A' matrix in the linear equation. Might be modified or save the reference.
* @return true if it can be processed.
*/
public boolean setA( T A );
/**
*
* Returns a very quick to compute measure of how singular the system is. This measure will
* be invariant to the scale of the matrix and always be positive, with larger values
* indicating it is less singular. If not supported by the solver then the runtime
* exception IllegalArgumentException is thrown. This is NOT the matrix's condition.
*
*
*
* How this function is implemented is not specified. One possible implementation is the following:
* In many decompositions a triangular matrix
* is extracted. The determinant of a triangular matrix is easily computed and once normalized
* to be scale invariant and its absolute value taken it will provide functionality described above.
*
*
* @return The quality of the linear system.
*/
public double quality();
/**
*
* Solves for X in the linear system, A*X=B.
*
*
* In some implementations 'B' and 'X' can be the same instance of a variable. Call
* {@link #modifiesB()} to determine if 'B' is modified.
*
*
* @param B A matrix ℜ m × p. Might be modified.
* @param X A matrix ℜ n × p, where the solution is written to. Modified.
*/
public void solve( T B , T X );
/**
* Computes the inverse of of the 'A' matrix passed into {@link #setA(org.ejml.data.Matrix)}
* and writes the results to the provided matrix. If 'A_inv' needs to be different from 'A'
* is implementation dependent.
*
* @param A_inv Where the inverted matrix saved. Modified.
*/
public void invert( T A_inv );
/**
* Returns true if the passed in matrix to {@link #setA(org.ejml.data.Matrix)}
* is modified.
*
* @return true if A is modified in setA().
*/
public boolean modifiesA();
/**
* Returns true if the passed in 'B' matrix to {@link #solve(org.ejml.data.Matrix, org.ejml.data.Matrix)}
* is modified.
*
* @return true if B is modified in solve(B,X).
*/
public boolean modifiesB();
/**
* If a decomposition class was used internally then this will return that class.
* Most linear solvers decompose the input matrix into a more simplistic form.
* However some solutions do not require decomposition, e.g. inverse by minor.
* @param Decomposition type
* @return Internal decomposition class. If there is none then null.
*/
public D getDecomposition();
}
ejml-0.28/main/core/src/org/ejml/interfaces/linsol/ReducedRowEchelonForm.java 0000664 0000000 0000000 00000004140 12561715344 0027235 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.interfaces.linsol;
import org.ejml.data.RealMatrix64F;
/**
*
* An augmented system matrix is said to be in reduced row echelon form (RREF) if the following are true:
*
*
*
* - If a row has non-zero entries, then the first non-zero entry is 1. This is known as the leading one.
* - If a column contains a leading one then all other entries in that column are zero.
* - If a row contains a leading 1, then each row above contains a leading 1 further to the left.
*
*
*
* [1] Page 19 in, Otter Bretscherm "Linear Algebra with Applications" Prentice-Hall Inc, 1997
*
*
* @author Peter Abeles
*/
public interface ReducedRowEchelonForm {
/**
* Puts the augmented matrix into RREF. The coefficient matrix is stored in
* columns less than coefficientColumns.
*
*
* @param A Input: Augmented matrix. Output: RREF. Modified.
* @param coefficientColumns Number of coefficients in the system matrix.
*/
public void reduce( T A , int coefficientColumns );
/**
* Specifies tolerance for determining if the system is singular and it should stop processing.
* A reasonable value is: tol = EPS/max(||tol||).
*
* @param tol Tolerance for singular matrix. A reasonable value is: tol = EPS/max(||tol||). Or just set to zero.
*/
public void setTolerance(double tol);
}
ejml-0.28/main/core/src/org/ejml/ops/ 0000775 0000000 0000000 00000000000 12561715344 0017364 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/src/org/ejml/ops/ComplexMath64F.java 0000664 0000000 0000000 00000014461 12561715344 0022736 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.ops;
import org.ejml.data.Complex64F;
import org.ejml.data.ComplexPolar64F;
/**
* Basic math operations on complex numbers.
*
* @author Peter Abeles
*/
public class ComplexMath64F
{
/**
* Complex conjugate
* @param input Input complex number
* @param conj Complex conjugate of the input number
*/
public static void conj( Complex64F input , Complex64F conj ) {
conj.real = input.real;
conj.imaginary = -input.imaginary;
}
/**
*
* Addition: result = a + b
*
*
* @param a Complex number. Not modified.
* @param b Complex number. Not modified.
* @param result Storage for output
*/
public static void plus( Complex64F a , Complex64F b , Complex64F result ) {
result.real = a.real + b.real;
result.imaginary = a.imaginary + b.imaginary;
}
/**
*
* Subtraction: result = a - b
*
*
* @param a Complex number. Not modified.
* @param b Complex number. Not modified.
* @param result Storage for output
*/
public static void minus( Complex64F a , Complex64F b , Complex64F result ) {
result.real = a.real - b.real;
result.imaginary = a.imaginary - b.imaginary;
}
/**
*
* Multiplication: result = a * b
*
*
* @param a Complex number. Not modified.
* @param b Complex number. Not modified.
* @param result Storage for output
*/
public static void multiply(Complex64F a, Complex64F b, Complex64F result) {
result.real = a.real * b.real - a.imaginary*b.imaginary;
result.imaginary = a.real*b.imaginary + a.imaginary*b.real;
}
/**
*
* Division: result = a / b
*
*
* @param a Complex number. Not modified.
* @param b Complex number. Not modified.
* @param result Storage for output
*/
public static void divide(Complex64F a, Complex64F b, Complex64F result) {
double norm = b.getMagnitude2();
result.real = (a.real * b.real + a.imaginary*b.imaginary)/norm;
result.imaginary = (a.imaginary*b.real - a.real*b.imaginary)/norm;
}
/**
*
* Converts a complex number into polar notation.
*
*
* @param input Standard notation
* @param output Polar notation
*/
public static void convert( Complex64F input , ComplexPolar64F output ) {
output.r = input.getMagnitude();
output.theta = Math.atan2(input.imaginary, input.real);
}
/**
*
* Converts a complex number in polar notation into standard notation.
*
*
* @param input Standard notation
* @param output Polar notation
*/
public static void convert( ComplexPolar64F input , Complex64F output ) {
output.real = input.r*Math.cos(input.theta);
output.imaginary = input.r*Math.sin(input.theta);
}
/**
* Division in polar notation.
*
* @param a Complex number in polar notation. Not modified.
* @param b Complex number in polar notation. Not modified.
* @param result Storage for output.
*/
public static void multiply(ComplexPolar64F a, ComplexPolar64F b, ComplexPolar64F result)
{
result.r = a.r*b.r;
result.theta = a.theta + b.theta;
}
/**
* Division in polar notation.
*
* @param a Complex number in polar notation. Not modified.
* @param b Complex number in polar notation. Not modified.
* @param result Storage for output.
*/
public static void divide(ComplexPolar64F a, ComplexPolar64F b, ComplexPolar64F result)
{
result.r = a.r/b.r;
result.theta = a.theta - b.theta;
}
/**
* Computes the power of a complex number in polar notation
*
* @param a Complex number
* @param N Power it is to be multiplied by
* @param result Result
*/
public static void pow( ComplexPolar64F a , int N , ComplexPolar64F result )
{
result.r = Math.pow(a.r,N);
result.theta = N*a.theta;
}
/**
* Computes the Nth root of a complex number in polar notation. There are
* N distinct Nth roots.
*
* @param a Complex number
* @param N The root's magnitude
* @param k Specifies which root. 0 ≤ k < N
* @param result Computed root
*/
public static void root( ComplexPolar64F a , int N , int k , ComplexPolar64F result )
{
result.r = Math.pow(a.r,1.0/N);
result.theta = (a.theta + 2.0*k*Math.PI)/N;
}
/**
* Computes the Nth root of a complex number. There are
* N distinct Nth roots.
*
* @param a Complex number
* @param N The root's magnitude
* @param k Specifies which root. 0 ≤ k < N
* @param result Computed root
*/
public static void root( Complex64F a , int N , int k , Complex64F result )
{
double r = a.getMagnitude();
double theta = Math.atan2(a.imaginary,a.real);
r = Math.pow(r,1.0/N);
theta = (theta + 2.0*k*Math.PI)/N;
result.real = r*Math.cos(theta);
result.imaginary = r*Math.sin(theta);
}
/**
* Computes the square root of the complex number.
*
* @param input Input complex number.
* @param root Output. The square root of the input
*/
public static void sqrt(Complex64F input, Complex64F root)
{
double r = input.getMagnitude();
double a = input.real;
root.real = Math.sqrt((r+a)/2.0);
root.imaginary = Math.sqrt((r-a)/2.0);
if( input.imaginary < 0 )
root.imaginary = -root.imaginary;
}
}
ejml-0.28/main/core/src/org/ejml/ops/ConvertMatrixType.java 0000664 0000000 0000000 00000065330 12561715344 0023705 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.ops;
import org.ejml.data.*;
/**
* Functions for converting between matrix types. Both matrices must be the same size and their values will
* be copied.
*
* @author Peter Abeles
*/
public class ConvertMatrixType {
/**
* Generic, but slow, conversion function.
*
* @param input Input matrix.
* @param output Output matrix.
*/
public static void convert( RealMatrix64F input , RealMatrix64F output ) {
if( input.getNumRows() != output.getNumRows() )
throw new IllegalArgumentException("Number of rows do not match");
if( input.getNumCols() != output.getNumCols() )
throw new IllegalArgumentException("Number of columns do not match");
for( int i = 0; i < input.getNumRows(); i++ ) {
for( int j = 0; j < input.getNumCols(); j++ ) {
output.unsafe_set(i,j,input.unsafe_get(i,j));
}
}
}
/**
* Converts {@link FixedMatrix2x2_64F} into {@link DenseMatrix64F}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static DenseMatrix64F convert( FixedMatrix2x2_64F input , DenseMatrix64F output ) {
if( output == null)
output = new DenseMatrix64F(2,2);
if( input.getNumRows() != output.getNumRows() )
throw new IllegalArgumentException("Number of rows do not match");
if( input.getNumCols() != output.getNumCols() )
throw new IllegalArgumentException("Number of columns do not match");
output.data[0] = input.a11;
output.data[1] = input.a12;
output.data[2] = input.a21;
output.data[3] = input.a22;
return output;
}
/**
* Converts {@link FixedMatrix3x3_64F} into {@link DenseMatrix64F}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static DenseMatrix64F convert( FixedMatrix3x3_64F input , DenseMatrix64F output ) {
if( output == null)
output = new DenseMatrix64F(3,3);
if( input.getNumRows() != output.getNumRows() )
throw new IllegalArgumentException("Number of rows do not match");
if( input.getNumCols() != output.getNumCols() )
throw new IllegalArgumentException("Number of columns do not match");
output.data[0] = input.a11;
output.data[1] = input.a12;
output.data[2] = input.a13;
output.data[3] = input.a21;
output.data[4] = input.a22;
output.data[5] = input.a23;
output.data[6] = input.a31;
output.data[7] = input.a32;
output.data[8] = input.a33;
return output;
}
/**
* Converts {@link FixedMatrix4x4_64F} into {@link DenseMatrix64F}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static DenseMatrix64F convert( FixedMatrix4x4_64F input , DenseMatrix64F output ) {
if( output == null)
output = new DenseMatrix64F(4,4);
if( input.getNumRows() != output.getNumRows() )
throw new IllegalArgumentException("Number of rows do not match");
if( input.getNumCols() != output.getNumCols() )
throw new IllegalArgumentException("Number of columns do not match");
output.data[0] = input.a11;
output.data[1] = input.a12;
output.data[2] = input.a13;
output.data[3] = input.a14;
output.data[4] = input.a21;
output.data[5] = input.a22;
output.data[6] = input.a23;
output.data[7] = input.a24;
output.data[8] = input.a31;
output.data[9] = input.a32;
output.data[10] = input.a33;
output.data[11] = input.a34;
output.data[12] = input.a41;
output.data[13] = input.a42;
output.data[14] = input.a43;
output.data[15] = input.a44;
return output;
}
/**
* Converts {@link FixedMatrix5x5_64F} into {@link DenseMatrix64F}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static DenseMatrix64F convert( FixedMatrix5x5_64F input , DenseMatrix64F output ) {
if( output == null)
output = new DenseMatrix64F(5,5);
if( input.getNumRows() != output.getNumRows() )
throw new IllegalArgumentException("Number of rows do not match");
if( input.getNumCols() != output.getNumCols() )
throw new IllegalArgumentException("Number of columns do not match");
output.data[0] = input.a11;
output.data[1] = input.a12;
output.data[2] = input.a13;
output.data[3] = input.a14;
output.data[4] = input.a15;
output.data[5] = input.a21;
output.data[6] = input.a22;
output.data[7] = input.a23;
output.data[8] = input.a24;
output.data[9] = input.a25;
output.data[10] = input.a31;
output.data[11] = input.a32;
output.data[12] = input.a33;
output.data[13] = input.a34;
output.data[14] = input.a35;
output.data[15] = input.a41;
output.data[16] = input.a42;
output.data[17] = input.a43;
output.data[18] = input.a44;
output.data[19] = input.a45;
output.data[20] = input.a51;
output.data[21] = input.a52;
output.data[22] = input.a53;
output.data[23] = input.a54;
output.data[24] = input.a55;
return output;
}
/**
* Converts {@link FixedMatrix6x6_64F} into {@link DenseMatrix64F}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static DenseMatrix64F convert( FixedMatrix6x6_64F input , DenseMatrix64F output ) {
if( output == null)
output = new DenseMatrix64F(6,6);
if( input.getNumRows() != output.getNumRows() )
throw new IllegalArgumentException("Number of rows do not match");
if( input.getNumCols() != output.getNumCols() )
throw new IllegalArgumentException("Number of columns do not match");
output.data[0] = input.a11;
output.data[1] = input.a12;
output.data[2] = input.a13;
output.data[3] = input.a14;
output.data[4] = input.a15;
output.data[5] = input.a16;
output.data[6] = input.a21;
output.data[7] = input.a22;
output.data[8] = input.a23;
output.data[9] = input.a24;
output.data[10] = input.a25;
output.data[11] = input.a26;
output.data[12] = input.a31;
output.data[13] = input.a32;
output.data[14] = input.a33;
output.data[15] = input.a34;
output.data[16] = input.a35;
output.data[17] = input.a36;
output.data[18] = input.a41;
output.data[19] = input.a42;
output.data[20] = input.a43;
output.data[21] = input.a44;
output.data[22] = input.a45;
output.data[23] = input.a46;
output.data[24] = input.a51;
output.data[25] = input.a52;
output.data[26] = input.a53;
output.data[27] = input.a54;
output.data[28] = input.a55;
output.data[29] = input.a56;
output.data[30] = input.a61;
output.data[31] = input.a62;
output.data[32] = input.a63;
output.data[33] = input.a64;
output.data[34] = input.a65;
output.data[35] = input.a66;
return output;
}
/**
* Converts {@link DenseMatrix64F} into {@link FixedMatrix2x2_64F}
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FixedMatrix2x2_64F convert( DenseMatrix64F input , FixedMatrix2x2_64F output ) {
if( output == null)
output = new FixedMatrix2x2_64F();
if( input.getNumRows() != output.getNumRows() )
throw new IllegalArgumentException("Number of rows do not match");
if( input.getNumCols() != output.getNumCols() )
throw new IllegalArgumentException("Number of columns do not match");
output.a11 = input.data[0];
output.a12 = input.data[1];
output.a21 = input.data[2];
output.a22 = input.data[3];
return output;
}
/**
* Converts {@link DenseMatrix64F} into {@link FixedMatrix3x3_64F}
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FixedMatrix3x3_64F convert( DenseMatrix64F input , FixedMatrix3x3_64F output ) {
if( output == null)
output = new FixedMatrix3x3_64F();
if( input.getNumRows() != output.getNumRows() )
throw new IllegalArgumentException("Number of rows do not match");
if( input.getNumCols() != output.getNumCols() )
throw new IllegalArgumentException("Number of columns do not match");
output.a11 = input.data[0];
output.a12 = input.data[1];
output.a13 = input.data[2];
output.a21 = input.data[3];
output.a22 = input.data[4];
output.a23 = input.data[5];
output.a31 = input.data[6];
output.a32 = input.data[7];
output.a33 = input.data[8];
return output;
}
/**
* Converts {@link DenseMatrix64F} into {@link FixedMatrix4x4_64F}
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FixedMatrix4x4_64F convert( DenseMatrix64F input , FixedMatrix4x4_64F output ) {
if( output == null)
output = new FixedMatrix4x4_64F();
if( input.getNumRows() != output.getNumRows() )
throw new IllegalArgumentException("Number of rows do not match");
if( input.getNumCols() != output.getNumCols() )
throw new IllegalArgumentException("Number of columns do not match");
output.a11 = input.data[0];
output.a12 = input.data[1];
output.a13 = input.data[2];
output.a14 = input.data[3];
output.a21 = input.data[4];
output.a22 = input.data[5];
output.a23 = input.data[6];
output.a24 = input.data[7];
output.a31 = input.data[8];
output.a32 = input.data[9];
output.a33 = input.data[10];
output.a34 = input.data[11];
output.a41 = input.data[12];
output.a42 = input.data[13];
output.a43 = input.data[14];
output.a44 = input.data[15];
return output;
}
/**
* Converts {@link DenseMatrix64F} into {@link FixedMatrix5x5_64F}
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FixedMatrix5x5_64F convert( DenseMatrix64F input , FixedMatrix5x5_64F output ) {
if( output == null)
output = new FixedMatrix5x5_64F();
if( input.getNumRows() != output.getNumRows() )
throw new IllegalArgumentException("Number of rows do not match");
if( input.getNumCols() != output.getNumCols() )
throw new IllegalArgumentException("Number of columns do not match");
output.a11 = input.data[0];
output.a12 = input.data[1];
output.a13 = input.data[2];
output.a14 = input.data[3];
output.a15 = input.data[4];
output.a21 = input.data[5];
output.a22 = input.data[6];
output.a23 = input.data[7];
output.a24 = input.data[8];
output.a25 = input.data[9];
output.a31 = input.data[10];
output.a32 = input.data[11];
output.a33 = input.data[12];
output.a34 = input.data[13];
output.a35 = input.data[14];
output.a41 = input.data[15];
output.a42 = input.data[16];
output.a43 = input.data[17];
output.a44 = input.data[18];
output.a45 = input.data[19];
output.a51 = input.data[20];
output.a52 = input.data[21];
output.a53 = input.data[22];
output.a54 = input.data[23];
output.a55 = input.data[24];
return output;
}
/**
* Converts {@link DenseMatrix64F} into {@link FixedMatrix6x6_64F}
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FixedMatrix6x6_64F convert( DenseMatrix64F input , FixedMatrix6x6_64F output ) {
if( output == null)
output = new FixedMatrix6x6_64F();
if( input.getNumRows() != output.getNumRows() )
throw new IllegalArgumentException("Number of rows do not match");
if( input.getNumCols() != output.getNumCols() )
throw new IllegalArgumentException("Number of columns do not match");
output.a11 = input.data[0];
output.a12 = input.data[1];
output.a13 = input.data[2];
output.a14 = input.data[3];
output.a15 = input.data[4];
output.a16 = input.data[5];
output.a21 = input.data[6];
output.a22 = input.data[7];
output.a23 = input.data[8];
output.a24 = input.data[9];
output.a25 = input.data[10];
output.a26 = input.data[11];
output.a31 = input.data[12];
output.a32 = input.data[13];
output.a33 = input.data[14];
output.a34 = input.data[15];
output.a35 = input.data[16];
output.a36 = input.data[17];
output.a41 = input.data[18];
output.a42 = input.data[19];
output.a43 = input.data[20];
output.a44 = input.data[21];
output.a45 = input.data[22];
output.a46 = input.data[23];
output.a51 = input.data[24];
output.a52 = input.data[25];
output.a53 = input.data[26];
output.a54 = input.data[27];
output.a55 = input.data[28];
output.a56 = input.data[29];
output.a61 = input.data[30];
output.a62 = input.data[31];
output.a63 = input.data[32];
output.a64 = input.data[33];
output.a65 = input.data[34];
output.a66 = input.data[35];
return output;
}
/**
* Converts {@link FixedMatrix2_64F} into {@link DenseMatrix64F}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static DenseMatrix64F convert( FixedMatrix2_64F input , DenseMatrix64F output ) {
if( output == null)
output = new DenseMatrix64F(2,1);
if( output.getNumRows() != 1 && output.getNumCols() != 1 )
throw new IllegalArgumentException("One row or column must have a length of 1 for it to be a vector");
int length = Math.max(output.getNumRows(),output.getNumCols());
if( length != 2 )
throw new IllegalArgumentException("Length of input vector is not 2. It is "+length);
output.data[0] = input.a1;
output.data[1] = input.a2;
return output;
}
/**
* Converts {@link FixedMatrix3_64F} into {@link DenseMatrix64F}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static DenseMatrix64F convert( FixedMatrix3_64F input , DenseMatrix64F output ) {
if( output == null)
output = new DenseMatrix64F(3,1);
if( output.getNumRows() != 1 && output.getNumCols() != 1 )
throw new IllegalArgumentException("One row or column must have a length of 1 for it to be a vector");
int length = Math.max(output.getNumRows(),output.getNumCols());
if( length != 3 )
throw new IllegalArgumentException("Length of input vector is not 3. It is "+length);
output.data[0] = input.a1;
output.data[1] = input.a2;
output.data[2] = input.a3;
return output;
}
/**
* Converts {@link FixedMatrix4_64F} into {@link DenseMatrix64F}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static DenseMatrix64F convert( FixedMatrix4_64F input , DenseMatrix64F output ) {
if( output == null)
output = new DenseMatrix64F(4,1);
if( output.getNumRows() != 1 && output.getNumCols() != 1 )
throw new IllegalArgumentException("One row or column must have a length of 1 for it to be a vector");
int length = Math.max(output.getNumRows(),output.getNumCols());
if( length != 4 )
throw new IllegalArgumentException("Length of input vector is not 4. It is "+length);
output.data[0] = input.a1;
output.data[1] = input.a2;
output.data[2] = input.a3;
output.data[3] = input.a4;
return output;
}
/**
* Converts {@link FixedMatrix5_64F} into {@link DenseMatrix64F}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static DenseMatrix64F convert( FixedMatrix5_64F input , DenseMatrix64F output ) {
if( output == null)
output = new DenseMatrix64F(5,1);
if( output.getNumRows() != 1 && output.getNumCols() != 1 )
throw new IllegalArgumentException("One row or column must have a length of 1 for it to be a vector");
int length = Math.max(output.getNumRows(),output.getNumCols());
if( length != 5 )
throw new IllegalArgumentException("Length of input vector is not 5. It is "+length);
output.data[0] = input.a1;
output.data[1] = input.a2;
output.data[2] = input.a3;
output.data[3] = input.a4;
output.data[4] = input.a5;
return output;
}
/**
* Converts {@link FixedMatrix6_64F} into {@link DenseMatrix64F}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static DenseMatrix64F convert( FixedMatrix6_64F input , DenseMatrix64F output ) {
if( output == null)
output = new DenseMatrix64F(6,1);
if( output.getNumRows() != 1 && output.getNumCols() != 1 )
throw new IllegalArgumentException("One row or column must have a length of 1 for it to be a vector");
int length = Math.max(output.getNumRows(),output.getNumCols());
if( length != 6 )
throw new IllegalArgumentException("Length of input vector is not 6. It is "+length);
output.data[0] = input.a1;
output.data[1] = input.a2;
output.data[2] = input.a3;
output.data[3] = input.a4;
output.data[4] = input.a5;
output.data[5] = input.a6;
return output;
}
/**
* Converts {@link DenseMatrix64F} into {@link FixedMatrix2_64F}
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FixedMatrix2_64F convert( DenseMatrix64F input , FixedMatrix2_64F output ) {
if( output == null)
output = new FixedMatrix2_64F();
if( input.getNumRows() != 1 && input.getNumCols() != 1 )
throw new IllegalArgumentException("One row or column must have a length of 1 for it to be a vector");
int length = Math.max(input.getNumRows(),input.getNumCols());
if( length != 2 )
throw new IllegalArgumentException("Length of input vector is not 2. It is "+length);
output.a1 = input.data[0];
output.a2 = input.data[1];
return output;
}
/**
* Converts {@link DenseMatrix64F} into {@link FixedMatrix3_64F}
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FixedMatrix3_64F convert( DenseMatrix64F input , FixedMatrix3_64F output ) {
if( output == null)
output = new FixedMatrix3_64F();
if( input.getNumRows() != 1 && input.getNumCols() != 1 )
throw new IllegalArgumentException("One row or column must have a length of 1 for it to be a vector");
int length = Math.max(input.getNumRows(),input.getNumCols());
if( length != 3 )
throw new IllegalArgumentException("Length of input vector is not 3. It is "+length);
output.a1 = input.data[0];
output.a2 = input.data[1];
output.a3 = input.data[2];
return output;
}
/**
* Converts {@link DenseMatrix64F} into {@link FixedMatrix4_64F}
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FixedMatrix4_64F convert( DenseMatrix64F input , FixedMatrix4_64F output ) {
if( output == null)
output = new FixedMatrix4_64F();
if( input.getNumRows() != 1 && input.getNumCols() != 1 )
throw new IllegalArgumentException("One row or column must have a length of 1 for it to be a vector");
int length = Math.max(input.getNumRows(),input.getNumCols());
if( length != 4 )
throw new IllegalArgumentException("Length of input vector is not 4. It is "+length);
output.a1 = input.data[0];
output.a2 = input.data[1];
output.a3 = input.data[2];
output.a4 = input.data[3];
return output;
}
/**
* Converts {@link DenseMatrix64F} into {@link FixedMatrix5_64F}
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FixedMatrix5_64F convert( DenseMatrix64F input , FixedMatrix5_64F output ) {
if( output == null)
output = new FixedMatrix5_64F();
if( input.getNumRows() != 1 && input.getNumCols() != 1 )
throw new IllegalArgumentException("One row or column must have a length of 1 for it to be a vector");
int length = Math.max(input.getNumRows(),input.getNumCols());
if( length != 5 )
throw new IllegalArgumentException("Length of input vector is not 5. It is "+length);
output.a1 = input.data[0];
output.a2 = input.data[1];
output.a3 = input.data[2];
output.a4 = input.data[3];
output.a5 = input.data[4];
return output;
}
/**
* Converts {@link DenseMatrix64F} into {@link FixedMatrix6_64F}
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FixedMatrix6_64F convert( DenseMatrix64F input , FixedMatrix6_64F output ) {
if( output == null)
output = new FixedMatrix6_64F();
if( input.getNumRows() != 1 && input.getNumCols() != 1 )
throw new IllegalArgumentException("One row or column must have a length of 1 for it to be a vector");
int length = Math.max(input.getNumRows(),input.getNumCols());
if( length != 6 )
throw new IllegalArgumentException("Length of input vector is not 6. It is "+length);
output.a1 = input.data[0];
output.a2 = input.data[1];
output.a3 = input.data[2];
output.a4 = input.data[3];
output.a5 = input.data[4];
output.a6 = input.data[5];
return output;
}
/**
* Converts {@link DenseMatrix64F} into {@link BlockMatrix64F}
*
* Can't handle null output matrix since block size needs to be specified.
*
* @param src Input matrix.
* @param dst Output matrix.
*/
public static void convert( DenseMatrix64F src , BlockMatrix64F dst ) {
if( src.numRows != dst.numRows || src.numCols != dst.numCols )
throw new IllegalArgumentException("Must be the same size.");
for( int i = 0; i < dst.numRows; i += dst.blockLength ) {
int blockHeight = Math.min( dst.blockLength , dst.numRows - i);
for( int j = 0; j < dst.numCols; j += dst.blockLength ) {
int blockWidth = Math.min( dst.blockLength , dst.numCols - j);
int indexDst = i*dst.numCols + blockHeight*j;
int indexSrcRow = i*dst.numCols + j;
for( int k = 0; k < blockHeight; k++ ) {
System.arraycopy(src.data,indexSrcRow,dst.data,indexDst,blockWidth);
indexDst += blockWidth;
indexSrcRow += dst.numCols;
}
}
}
}
/**
* Converts {@link BlockMatrix64F} into {@link DenseMatrix64F}
*
* @param src Input matrix.
* @param dst Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static DenseMatrix64F convert( BlockMatrix64F src , DenseMatrix64F dst ) {
if( dst != null ) {
if( dst.numRows != src.numRows || dst.numCols != src.numCols )
throw new IllegalArgumentException("Must be the same size.");
} else {
dst = new DenseMatrix64F(src.numRows,src.numCols);
}
for( int i = 0; i < src.numRows; i += src.blockLength ) {
int blockHeight = Math.min( src.blockLength , src.numRows - i);
for( int j = 0; j < src.numCols; j += src.blockLength ) {
int blockWidth = Math.min( src.blockLength , src.numCols - j);
int indexSrc = i*src.numCols + blockHeight*j;
int indexDstRow = i*dst.numCols + j;
for( int k = 0; k < blockHeight; k++ ) {
System.arraycopy(src.data,indexSrc,dst.data,indexDstRow,blockWidth);
indexSrc += blockWidth;
indexDstRow += dst.numCols;
}
}
}
return dst;
}
}
ejml-0.28/main/core/src/org/ejml/ops/MatrixDimensionException.java 0000664 0000000 0000000 00000002032 12561715344 0025215 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.ops;
/**
* If two matrices did not have compatible dimensions for the operation this exception
* is thrown.
*
* @author Peter Abeles
*/
public class MatrixDimensionException
extends RuntimeException
{
public MatrixDimensionException(){}
public MatrixDimensionException(String message ) {
super(message);
}
}
ejml-0.28/main/core/src/org/ejml/ops/MatrixIO.java 0000664 0000000 0000000 00000020167 12561715344 0021731 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.ops;
import org.ejml.data.*;
import java.io.*;
/**
* Provides simple to use routines for reading and writing matrices to and from files.
*
* @author Peter Abeles
*/
public class MatrixIO {
/**
* Saves a matrix to disk using Java binary serialization.
*
* @param A The matrix being saved.
* @param fileName Name of the file its being saved at.
* @throws java.io.IOException
*/
public static void saveBin(RealMatrix64F A, String fileName)
throws IOException
{
FileOutputStream fileStream = new FileOutputStream(fileName);
ObjectOutputStream stream = new ObjectOutputStream(fileStream);
try {
stream.writeObject(A);
stream.flush();
} finally {
// clean up
try {
stream.close();
} finally {
fileStream.close();
}
}
}
/**
* Loads a DeneMatrix64F which has been saved to file using Java binary
* serialization.
*
* @param fileName The file being loaded.
* @return DenseMatrix64F
* @throws IOException
*/
public static T loadBin(String fileName)
throws IOException
{
FileInputStream fileStream = new FileInputStream(fileName);
ObjectInputStream stream = new ObjectInputStream(fileStream);
T ret;
try {
ret = (T)stream.readObject();
if( stream.available() != 0 ) {
throw new RuntimeException("File not completely read?");
}
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
stream.close();
return (T)ret;
}
/**
* Saves a matrix to disk using in a Column Space Value (CSV) format. For a
* description of the format see {@link MatrixIO#loadCSV(String)}.
*
* @param A The matrix being saved.
* @param fileName Name of the file its being saved at.
* @throws java.io.IOException
*/
public static void saveCSV( RealMatrix64F A , String fileName )
throws IOException
{
PrintStream fileStream = new PrintStream(fileName);
fileStream.println(A.getNumRows() + " " + A.getNumCols() + " real");
for( int i = 0; i < A.getNumRows(); i++ ) {
for( int j = 0; j < A.getNumCols(); j++ ) {
fileStream.print(A.get(i,j)+" ");
}
fileStream.println();
}
fileStream.close();
}
/**
* Reads a matrix in which has been encoded using a Column Space Value (CSV)
* file format. The number of rows and columns are read in on the first line. Then
* each row is read in the subsequent lines.
*
* @param fileName The file being loaded.
* @return DenseMatrix64F
* @throws IOException
*/
public static DenseMatrix64F loadCSV( String fileName )
throws IOException
{
FileInputStream fileStream = new FileInputStream(fileName);
ReadMatrixCsv csv = new ReadMatrixCsv(fileStream);
DenseMatrix64F ret = csv.read();
fileStream.close();
return ret;
}
/**
* Reads a matrix in which has been encoded using a Column Space Value (CSV)
* file format. For a description of the format see {@link MatrixIO#loadCSV(String)}.
*
* @param fileName The file being loaded.
* @param numRows number of rows in the matrix.
* @param numCols number of columns in the matrix.
* @return DenseMatrix64F
* @throws IOException
*/
public static DenseMatrix64F loadCSV( String fileName , int numRows , int numCols )
throws IOException
{
FileInputStream fileStream = new FileInputStream(fileName);
ReadMatrixCsv csv = new ReadMatrixCsv(fileStream);
DenseMatrix64F ret = csv.readReal(numRows, numCols);
fileStream.close();
return ret;
}
public static void print( PrintStream out , RealMatrix64F mat ) {
print(out,mat,6,3);
}
public static void print(PrintStream out, RealMatrix64F mat , int numChar , int precision ) {
String format = "%"+numChar+"."+precision+"f ";
print(out, mat,format);
}
public static void print(PrintStream out , RealMatrix64F mat , String format ) {
String type = ReshapeMatrix.class.isAssignableFrom(mat.getClass()) ? "dense" : "dense fixed";
out.println("Type = "+type+" real , numRows = "+mat.getNumRows()+" , numCols = "+mat.getNumCols());
format += " ";
for( int y = 0; y < mat.getNumRows(); y++ ) {
for( int x = 0; x < mat.getNumCols(); x++ ) {
out.printf(format,mat.get(y,x));
}
out.println();
}
}
public static void print( PrintStream out , RealMatrix32F mat ) {
print(out,mat,6,3);
}
public static void print(PrintStream out, RealMatrix32F mat , int numChar , int precision ) {
String format = "%"+numChar+"."+precision+"f ";
print(out, mat,format);
}
public static void print(PrintStream out , RealMatrix32F mat , String format ) {
String type = ReshapeMatrix.class.isAssignableFrom(mat.getClass()) ? "dense" : "dense fixed";
out.println("Type = "+type+" , numRows = "+mat.getNumRows()+" , numCols = "+mat.getNumCols());
format += " ";
for( int y = 0; y < mat.getNumRows(); y++ ) {
for( int x = 0; x < mat.getNumCols(); x++ ) {
out.printf(format,mat.get(y,x));
}
out.println();
}
}
public static void print( PrintStream out , RealMatrix64F mat , String format ,
int row0 , int row1, int col0 , int col1 ) {
out.println("Type = submatrix , rows "+row0+" to "+row1+" columns "+col0+" to "+col1);
format += " ";
for( int y = row0; y < row1; y++ ) {
for( int x = col0; x < col1; x++ ) {
out.printf(format,mat.get(y,x));
}
out.println();
}
}
public static void print( PrintStream out , ComplexMatrix64F mat ) {
print(out,mat,6,3);
}
public static void print(PrintStream out, ComplexMatrix64F mat , int numChar , int precision ) {
String format = "%"+numChar+"."+precision+"f + %"+numChar+"."+precision+"fi";
print(out, mat,format);
}
public static void print(PrintStream out , ComplexMatrix64F mat , String format ) {
String type = "dense";
out.println("Type = "+type+" complex , numRows = "+mat.getNumRows()+" , numCols = "+mat.getNumCols());
format += " ";
Complex64F c = new Complex64F();
for( int y = 0; y < mat.getNumRows(); y++ ) {
for( int x = 0; x < mat.getNumCols(); x++ ) {
mat.get(y,x,c);
out.printf(format,c.real,c.imaginary);
if( x < mat.getNumCols()-1 ) {
out.print(" , ");
}
}
out.println();
}
}
// public static void main( String []args ) {
// Random rand = new Random(234234);
// DenseMatrix64F A = RandomMatrices.createRandom(50,70,rand);
//
// SingularValueDecomposition decomp = DecompositionFactory.svd();
//
// decomp.decompose(A);
//
// displayMatrix(A,"Original");
// displayMatrix(decomp.getU(false),"U");
// displayMatrix(decomp.getV(false),"V");
// displayMatrix(decomp.getW(null),"W");
// }
}
ejml-0.28/main/core/src/org/ejml/ops/ReadCsv.java 0000664 0000000 0000000 00000010723 12561715344 0021561 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2013, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.ops;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
/**
*
* Base class for reading CSV formatted files. CSV stands for column-space-value where text strings are separated
* by a space character. The values are typically stored in a human readable format. The encoded text for a single
* variable is referred to as a word.
*
*
*
* Comments are allowed and identified by starting a line with the comment character. The comment character is user
* configurable. By default there is no comment character.
*
*
* @author Peter Abeles
*/
public class ReadCsv {
// if there is a comment character
private boolean hasComment = false;
// what the comment character is
private char comment;
// reader for the input stream
private BufferedReader in;
// number of lines that have been read
private int lineNumber = 0;
/**
* Constructor for ReadCsv
*
* @param in Where the input comes from.
*/
public ReadCsv(InputStream in) {
this.in = new BufferedReader(new InputStreamReader(in));
}
/**
* Sets the comment character. All lines that start with this character will be ignored.
*
* @param comment The new comment character.
*/
public void setComment(char comment) {
hasComment = true;
this.comment = comment;
}
/**
* Returns how many lines have been read.
*
* @return Line number
*/
public int getLineNumber() {
return lineNumber;
}
/**
* Returns the reader that it is using internally.
* @return The reader.
*/
public BufferedReader getReader() {
return in;
}
/**
* Finds the next valid line of words in the stream and extracts them.
*
* @return List of valid words on the line. null if the end of the file has been reached.
* @throws java.io.IOException
*/
protected List extractWords() throws IOException
{
while( true ) {
lineNumber++;
String line = in.readLine();
if( line == null ) {
return null;
}
// skip comment lines
if( hasComment ) {
if( line.charAt(0) == comment )
continue;
}
// extract the words, which are the variables encoded
return parseWords(line);
}
}
/**
* Extracts the words from a string. Words are seperated by a space character.
*
* @param line The line that is being parsed.
* @return A list of words contained on the line.
*/
protected List parseWords(String line) {
List words = new ArrayList();
boolean insideWord = !isSpace(line.charAt(0));
int last = 0;
for( int i = 0; i < line.length(); i++) {
char c = line.charAt(i);
if( insideWord ) {
// see if its at the end of a word
if( isSpace(c)) {
words.add( line.substring(last,i) );
insideWord = false;
}
} else {
if( !isSpace(c)) {
last = i;
insideWord = true;
}
}
}
// if the line ended add the final word
if( insideWord ) {
words.add( line.substring(last));
}
return words;
}
/**
* Checks to see if 'c' is a space character or not.
*
* @param c The character being tested.
* @return if it is a space character or not.
*/
private boolean isSpace(char c) {
return c == ' ' || c == '\t';
}
}
ejml-0.28/main/core/src/org/ejml/ops/ReadMatrixCsv.java 0000664 0000000 0000000 00000010121 12561715344 0022736 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.ops;
import org.ejml.data.CDenseMatrix64F;
import org.ejml.data.DenseMatrix64F;
import org.ejml.data.Matrix;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
/**
* Reads in a matrix that is in a column-space-value (CSV) format.
*
* @author Peter Abeles
*/
public class ReadMatrixCsv extends ReadCsv {
/**
* Specifies where input comes from.
*
* @param in Where the input comes from.
*/
public ReadMatrixCsv(InputStream in) {
super(in);
}
/**
* Reads in a DenseMatrix64F from the IO stream.
* @return DenseMatrix64F
* @throws IOException If anything goes wrong.
*/
public M read() throws IOException {
List words = extractWords();
if( words.size() != 3 )
throw new IOException("Unexpected number of words on first line.");
int numRows = Integer.parseInt(words.get(0));
int numCols = Integer.parseInt(words.get(1));
boolean real = words.get(2).compareToIgnoreCase("real") == 0;
if( numRows < 0 || numCols < 0)
throw new IOException("Invalid number of rows and/or columns: "+numRows+" "+numCols);
if( real )
return (M)readReal(numRows, numCols);
else
return (M)readComplex(numRows, numCols);
}
/**
* Reads in a DenseMatrix64F from the IO stream where the user specifies the matrix dimensions.
*
* @param numRows Number of rows in the matrix
* @param numCols Number of columns in the matrix
* @return DenseMatrix64F
* @throws IOException
*/
public DenseMatrix64F readReal(int numRows, int numCols) throws IOException {
DenseMatrix64F A = new DenseMatrix64F(numRows,numCols);
for( int i = 0; i < numRows; i++ ) {
List words = extractWords();
if( words == null )
throw new IOException("Too few rows found. expected "+numRows+" actual "+i);
if( words.size() != numCols )
throw new IOException("Unexpected number of words in column. Found "+words.size()+" expected "+numCols);
for( int j = 0; j < numCols; j++ ) {
A.set(i,j,Double.parseDouble(words.get(j)));
}
}
return A;
}
/**
* Reads in a CDenseMatrix64F from the IO stream where the user specifies the matrix dimensions.
*
* @param numRows Number of rows in the matrix
* @param numCols Number of columns in the matrix
* @return DenseMatrix64F
* @throws IOException
*/
public CDenseMatrix64F readComplex(int numRows, int numCols) throws IOException {
CDenseMatrix64F A = new CDenseMatrix64F(numRows,numCols);
int wordsCol = numCols*2;
for( int i = 0; i < numRows; i++ ) {
List words = extractWords();
if( words == null )
throw new IOException("Too few rows found. expected "+numRows+" actual "+i);
if( words.size() != wordsCol )
throw new IOException("Unexpected number of words in column. Found "+words.size()+" expected "+wordsCol);
for( int j = 0; j < wordsCol; j += 2 ) {
double real = Double.parseDouble(words.get(j));
double imaginary = Double.parseDouble(words.get(j+1));
A.set(i, j, real, imaginary);
}
}
return A;
}
}
ejml-0.28/main/core/test/ 0000775 0000000 0000000 00000000000 12561715344 0015235 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/test/org/ 0000775 0000000 0000000 00000000000 12561715344 0016024 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/test/org/ejml/ 0000775 0000000 0000000 00000000000 12561715344 0016753 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/test/org/ejml/TestUtilEjml.java 0000664 0000000 0000000 00000004153 12561715344 0022206 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2013, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml;
import org.ejml.data.DenseMatrix64F;
import org.junit.Test;
import java.util.Random;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Peter Abeles
*/
public class TestUtilEjml {
Random rand = new Random(23423);
@Test
public void max_array() {
double a[] = new double[]{-1,2,3,4,5,6,3,4,5,7,8,2,3,-5,-6};
assertTrue(8==UtilEjml.max(a,0,a.length));
assertTrue(5==UtilEjml.max(a,6,3));
}
/**
* Provide it a couple of different strings to parse. Then compare
* the results against the expect answer
*/
@Test
public void testParseMatrix() {
String a = "-0.779094 1.682750\n" +
" 1.304014 -1.880739\n";
DenseMatrix64F m = UtilEjml.parseMatrix(a,2);
assertEquals(2,m.numCols);
assertEquals(2,m.numRows);
assertEquals(-0.779094 , m.get(0,0) , 1e-5);
assertEquals(1.682750 , m.get(0,1) , 1e-5);
assertEquals(1.304014 , m.get(1,0) , 1e-5);
assertEquals(-1.880739 , m.get(1,1) , 1e-5);
// give it a matrix with a space in the first element, see if that screws it up
a = " -0.779094 1.682750 5\n" +
" 1.304014 -1.880739 8\n";
m = UtilEjml.parseMatrix(a,3);
assertEquals(3,m.numCols);
assertEquals(2,m.numRows);
assertEquals(-0.779094 , m.get(0,0) , 1e-5);
}
}
ejml-0.28/main/core/test/org/ejml/alg/ 0000775 0000000 0000000 00000000000 12561715344 0017516 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/test/org/ejml/alg/dense/ 0000775 0000000 0000000 00000000000 12561715344 0020614 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/test/org/ejml/alg/dense/linsol/ 0000775 0000000 0000000 00000000000 12561715344 0022114 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/test/org/ejml/alg/dense/linsol/TestLinearSolverSafe.java 0000664 0000000 0000000 00000013003 12561715344 0027020 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.alg.dense.linsol;
import org.ejml.data.DenseMatrix64F;
import org.ejml.interfaces.decomposition.DecompositionInterface;
import org.ejml.interfaces.linsol.LinearSolver;
import org.junit.Test;
import java.util.Random;
import static org.junit.Assert.*;
/**
* @author Peter Abeles
*/
public class TestLinearSolverSafe {
Random rand = new Random(234);
DenseMatrix64F Ainput = new DenseMatrix64F(1,1);
DenseMatrix64F Binput = new DenseMatrix64F(1,1);
/**
* Checks to see if the input matrix is copied after multiple calls. This was an actual bug.
*/
@Test
public void multipleCalls_setA() {
DummySolver dummy = new DummySolver(true,false);
dummy.expectedA = 5;
LinearSolver s = new LinearSolverSafe(dummy);
Ainput.set(0,5);
s.setA(Ainput);
// call it a second time and see if the input matrix has been reset to the
// correct value
s.setA(Ainput);
assertTrue(dummy.passedin != Ainput);
}
/**
* Checks to see if the input matrix is copied after multiple calls. This was an actual bug.
*/
@Test
public void multipleCalls_setB() {
DummySolver dummy = new DummySolver(false,true);
dummy.expectedB = 5;
LinearSolver s = new LinearSolverSafe(dummy);
Binput.set(0,5);
s.solve(Binput,new DenseMatrix64F(1,1));
// call it a second time and see if the input matrix has been reset to the
// correct value
s.solve(Binput,new DenseMatrix64F(1,1));
assertTrue(dummy.passedin != Ainput);
}
@Test
public void testSetA_notMod() {
DummySolver dummy = new DummySolver(false,false);
LinearSolver s = new LinearSolverSafe(dummy);
s.setA(Ainput);
assertTrue(dummy.passedin == Ainput);
}
@Test
public void testSetA_mod() {
DummySolver dummy = new DummySolver(true,false);
LinearSolver s = new LinearSolverSafe(dummy);
s.setA(Ainput);
assertTrue(dummy.passedin != Ainput);
}
@Test
public void testSolver_notMod() {
DummySolver dummy = new DummySolver(false,false);
LinearSolver s = new LinearSolverSafe(dummy);
s.solve(Binput,new DenseMatrix64F(1,1));
assertTrue(dummy.passedin == Binput);
}
@Test
public void testSolver_mod() {
DummySolver dummy = new DummySolver(false,true);
LinearSolver s = new LinearSolverSafe(dummy);
s.solve(Binput,new DenseMatrix64F(1,1));
assertTrue(dummy.passedin != Binput);
}
@Test
public void quality() {
DummySolver dummy = new DummySolver(false,false);
LinearSolver s = new LinearSolverSafe(dummy);
assertTrue(s.quality()==dummy.quality());
}
@Test
public void modifies() {
LinearSolver s = new LinearSolverSafe(null);
assertFalse(s.modifiesA());
assertFalse(s.modifiesB());
}
private class DummySolver implements LinearSolver
{
boolean modifiesA;
boolean modifiesB;
DenseMatrix64F passedin;
// the expected value of the input matrix
double expectedA = Double.NaN;
double expectedB = Double.NaN;
private DummySolver(boolean modifiesA, boolean modifiesB) {
this.modifiesA = modifiesA;
this.modifiesB = modifiesB;
}
@Override
public boolean setA(DenseMatrix64F A) {
passedin = A;
// the input matrix has an expected input value
if( !Double.isNaN(expectedA))
assertEquals(expectedA,A.get(0),1e-8);
if( modifiesA ) {
A.set(0,0,rand.nextDouble());
}
return true;
}
@Override
public double quality() {
return 1.1;
}
@Override
public void solve(DenseMatrix64F B, DenseMatrix64F X) {
passedin = B;
// the input matrix has an expected input value
if( !Double.isNaN(expectedB))
assertEquals(expectedB,B.get(0),1e-8);
if( modifiesB ) {
B.set(0,0,rand.nextDouble());
}
}
@Override
public void invert(DenseMatrix64F A_inv) {
}
@Override
public boolean modifiesA() {
return modifiesA;
}
@Override
public boolean modifiesB() {
return modifiesB;
}
@Override
public D getDecomposition() {
return null;
}
}
}
ejml-0.28/main/core/test/org/ejml/data/ 0000775 0000000 0000000 00000000000 12561715344 0017664 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/test/org/ejml/data/GenericTestsD1Matrix32F.java 0000664 0000000 0000000 00000003305 12561715344 0024754 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Peter Abeles
*/
public abstract class GenericTestsD1Matrix32F extends GenericTestsMatrix32F {
protected abstract D1Matrix32F createMatrix( int numRows , int numCols );
public void allTests() {
super.allTests();
testReshape();
testSetAndGet_1D();
}
public void testReshape() {
D1Matrix32F mat = createMatrix(3,2);
float []origData = mat.getData();
mat.reshape(6,1, false);
assertTrue(origData == mat.getData());
assertEquals(1,mat.getNumCols());
assertEquals(6,mat.getNumRows());
}
public void testSetAndGet_1D() {
D1Matrix32F mat = createMatrix(3,4);
int indexA = mat.getIndex(1,2);
int indexB = mat.getIndex(2,1);
assertTrue(indexA!=indexB);
mat.set(indexA,2.0f);
assertEquals(0,mat.get(indexB),1e-6);
assertEquals(2,mat.get(indexA),1e-6);
}
} ejml-0.28/main/core/test/org/ejml/data/GenericTestsD1Matrix64F.java 0000664 0000000 0000000 00000003305 12561715344 0024761 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2013, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Peter Abeles
*/
public abstract class GenericTestsD1Matrix64F extends GenericTestsMatrix64F {
protected abstract D1Matrix64F createMatrix( int numRows , int numCols );
public void allTests() {
super.allTests();
testReshape();
testSetAndGet_1D();
}
public void testReshape() {
D1Matrix64F mat = createMatrix(3,2);
double []origData = mat.getData();
mat.reshape(6,1, false);
assertTrue(origData == mat.getData());
assertEquals(1,mat.getNumCols());
assertEquals(6,mat.getNumRows());
}
public void testSetAndGet_1D() {
D1Matrix64F mat = createMatrix(3,4);
int indexA = mat.getIndex(1,2);
int indexB = mat.getIndex(2,1);
assertTrue(indexA!=indexB);
mat.set(indexA,2.0);
assertEquals(0,mat.get(indexB),1e-6);
assertEquals(2,mat.get(indexA),1e-6);
}
} ejml-0.28/main/core/test/org/ejml/data/GenericTestsMatrix32F.java 0000664 0000000 0000000 00000005670 12561715344 0024576 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import static org.junit.Assert.assertEquals;
/**
* @author Peter Abeles
*/
public abstract class GenericTestsMatrix32F {
protected abstract RealMatrix32F createMatrix( int numRows , int numCols );
public void allTests() {
testGetNumRows();
testGetNumCols();
testSetAndGet_2D();
testSetAndGet_2D_unsafe();
}
public void testGetNumRows() {
RealMatrix32F mat = createMatrix(2,3);
assertEquals(2,mat.getNumRows());
}
public void testGetNumCols() {
RealMatrix32F mat = createMatrix(2,3);
assertEquals(3,mat.getNumCols());
}
public void testSetAndGet_2D() {
// test a variety of different shapes. Added rigor needed
// to properly test block matrix.
checkSetAndGet(10, 12);
checkSetAndGet(12, 10);
checkSetAndGet(10, 10);
checkSetAndGet(19, 5);
checkSetAndGet(5, 19);
checkSetAndGet(19, 19);
}
private void checkSetAndGet(int m, int n) {
RealMatrix32F mat = createMatrix(m, n);
for( int i = 0; i < m; i++ ) {
for( int j = 0; j < n; j++ ) {
mat.set(i,j, i* m +j);
}
}
for( int i = 0; i < m; i++ ) {
for( int j = 0; j < n; j++ ) {
double found = mat.get(i,j);
assertEquals(i* m +j,found,1e-8);
}
}
}
public void testSetAndGet_2D_unsafe() {
// test a variety of different shapes. Added rigor needed
// to properly test block matrix.
checkSetAndGet_unsafe(10, 12);
checkSetAndGet_unsafe(12, 10);
checkSetAndGet_unsafe(10, 10);
checkSetAndGet_unsafe(19, 5);
checkSetAndGet_unsafe(5, 19);
checkSetAndGet_unsafe(19, 19);
}
private void checkSetAndGet_unsafe(int m, int n) {
RealMatrix32F mat = createMatrix(m, n);
for( int i = 0; i < m; i++ ) {
for( int j = 0; j < n; j++ ) {
mat.unsafe_set(i,j, i* m +j);
}
}
for( int i = 0; i < m; i++ ) {
for( int j = 0; j < n; j++ ) {
double found = mat.unsafe_get(i,j);
assertEquals(i* m +j,found,1e-8);
}
}
}
}
ejml-0.28/main/core/test/org/ejml/data/GenericTestsMatrix64F.java 0000664 0000000 0000000 00000005670 12561715344 0024603 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import static org.junit.Assert.assertEquals;
/**
* @author Peter Abeles
*/
public abstract class GenericTestsMatrix64F {
protected abstract RealMatrix64F createMatrix( int numRows , int numCols );
public void allTests() {
testGetNumRows();
testGetNumCols();
testSetAndGet_2D();
testSetAndGet_2D_unsafe();
}
public void testGetNumRows() {
RealMatrix64F mat = createMatrix(2,3);
assertEquals(2,mat.getNumRows());
}
public void testGetNumCols() {
RealMatrix64F mat = createMatrix(2,3);
assertEquals(3,mat.getNumCols());
}
public void testSetAndGet_2D() {
// test a variety of different shapes. Added rigor needed
// to properly test block matrix.
checkSetAndGet(10, 12);
checkSetAndGet(12, 10);
checkSetAndGet(10, 10);
checkSetAndGet(19, 5);
checkSetAndGet(5, 19);
checkSetAndGet(19, 19);
}
private void checkSetAndGet(int m, int n) {
RealMatrix64F mat = createMatrix(m, n);
for( int i = 0; i < m; i++ ) {
for( int j = 0; j < n; j++ ) {
mat.set(i,j, i* m +j);
}
}
for( int i = 0; i < m; i++ ) {
for( int j = 0; j < n; j++ ) {
double found = mat.get(i,j);
assertEquals(i* m +j,found,1e-8);
}
}
}
public void testSetAndGet_2D_unsafe() {
// test a variety of different shapes. Added rigor needed
// to properly test block matrix.
checkSetAndGet_unsafe(10, 12);
checkSetAndGet_unsafe(12, 10);
checkSetAndGet_unsafe(10, 10);
checkSetAndGet_unsafe(19, 5);
checkSetAndGet_unsafe(5, 19);
checkSetAndGet_unsafe(19, 19);
}
private void checkSetAndGet_unsafe(int m, int n) {
RealMatrix64F mat = createMatrix(m, n);
for( int i = 0; i < m; i++ ) {
for( int j = 0; j < n; j++ ) {
mat.unsafe_set(i,j, i* m +j);
}
}
for( int i = 0; i < m; i++ ) {
for( int j = 0; j < n; j++ ) {
double found = mat.unsafe_get(i,j);
assertEquals(i* m +j,found,1e-8);
}
}
}
}
ejml-0.28/main/core/test/org/ejml/data/TestBlockMatrix64F.java 0000664 0000000 0000000 00000002144 12561715344 0024067 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2013, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.junit.Test;
/**
* @author Peter Abeles
*/
public class TestBlockMatrix64F {
@Test
public void testGeneric() {
GenericTestsD1Matrix64F g;
g = new GenericTestsD1Matrix64F() {
protected D1Matrix64F createMatrix(int numRows, int numCols) {
return new BlockMatrix64F(numRows,numCols,10);
}
};
g.allTests();
}
}
ejml-0.28/main/core/test/org/ejml/data/TestCD1Matrix64F.java 0000664 0000000 0000000 00000003427 12561715344 0023411 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
/**
* @author Peter Abeles
*/
public class TestCD1Matrix64F {
@Test
public void set_matrix() {
CD1Matrix64F a = new CDenseMatrix64F(3,4);
a.set(1,3,9,2);
CD1Matrix64F b = new CDenseMatrix64F(3,4);
b.set(a);
for (int i = 0; i < a.getDataLength(); i++) {
assertEquals(a.data[i],b.data[i],1e-8);
}
assertEquals(9, b.getReal(1, 3), 1e-8);
}
@Test
public void getNumRows() {
CD1Matrix64F a = new CDenseMatrix64F(3,4);
assertEquals(3,a.getNumRows());
}
@Test
public void getNumCols() {
CD1Matrix64F a = new CDenseMatrix64F(3,4);
assertEquals(4,a.getNumCols());
}
@Test
public void setNumRows() {
CD1Matrix64F a = new CDenseMatrix64F(3,4);
a.setNumRows(6);
assertEquals(6, a.getNumRows());
}
@Test
public void setNumCols() {
CD1Matrix64F a = new CDenseMatrix64F(3,4);
a.setNumCols(6);
assertEquals(6,a.getNumCols());
}
} ejml-0.28/main/core/test/org/ejml/data/TestCDenseMatrix64F.java 0000664 0000000 0000000 00000011710 12561715344 0024175 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.CCommonOps;
import org.ejml.ops.CMatrixFeatures;
import org.ejml.ops.CRandomMatrices;
import org.ejml.ops.EjmlUnitTests;
import org.junit.Test;
import java.util.Random;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Peter Abeles
*/
public class TestCDenseMatrix64F {
Random rand = new Random(234);
@Test
public void constructor_darray() {
CDenseMatrix64F a = new CDenseMatrix64F(new double[][]{{1,2,3,4},{5,6,7,8},{5,6,7,8}});
CDenseMatrix64F b = new CDenseMatrix64F(3,2,true,1,2,3,4,5,6,7,8,5,6,7,8);
EjmlUnitTests.assertEquals(a, b, 1e-8);
}
@Test
public void constructor_cmatrix() {
CDenseMatrix64F a = new CDenseMatrix64F(3,4);
a.set(1,3,9,2);
CDenseMatrix64F b = new CDenseMatrix64F(a);
for (int i = 0; i < a.getDataLength(); i++) {
assertEquals(a.data[i],b.data[i],1e-8);
}
}
@Test
public void constructor_shape() {
CDenseMatrix64F a = new CDenseMatrix64F(5,7);
assertEquals(5,a.numRows);
assertEquals(7,a.numCols);
assertEquals(5*7*2,a.data.length);
}
@Test
public void getIndex() {
CDenseMatrix64F a = new CDenseMatrix64F(5,7);
assertEquals(2*14+6,a.getIndex(2,3));
}
@Test
public void reshape() {
CDenseMatrix64F a = new CDenseMatrix64F(5,7);
assertEquals(5*7*2,a.data.length);
assertEquals(5, a.numRows);
assertEquals(7,a.numCols);
// make it larger
a.reshape(10,6);
assertEquals(10*6*2,a.data.length);
assertEquals(10,a.numRows);
assertEquals(6,a.numCols);
// make it smaller
a.reshape(3,2);
assertTrue(a.data.length > 3*2*2);
assertEquals(3,a.numRows);
assertEquals(2,a.numCols);
}
@Test
public void get() {
CDenseMatrix64F a = new CDenseMatrix64F(3,4);
a.data[2*4*2 + 2] = 5;
a.data[2*4*2 + 3] = 6;
Complex64F c = new Complex64F();
a.get(2,1,c);
assertEquals(c.real,5,1e-8);
assertEquals(c.imaginary, 6, 1e-8);
}
@Test
public void set_rowcolumn() {
CDenseMatrix64F a = new CDenseMatrix64F(3,4);
a.set(2, 1, 5, 6);
assertEquals(5,a.data[2*4*2+2],1e-8);
assertEquals(6,a.data[2*4*2+3],1e-8);
}
@Test
public void getReal() {
CDenseMatrix64F a = new CDenseMatrix64F(3,4);
a.data[2*4*2 + 2] = 5;
a.data[2*4*2 + 3] = 6;
Complex64F c = new Complex64F();
a.get(2,1,c);
assertEquals(a.getReal(2, 1), 5, 1e-8);
}
@Test
public void setReal() {
CDenseMatrix64F a = new CDenseMatrix64F(3,4);
a.setReal(2,1,5);
assertEquals(5, a.data[2 * 4 * 2 + 2], 1e-8);
}
@Test
public void getImaginary() {
CDenseMatrix64F a = new CDenseMatrix64F(3,4);
a.data[2*4*2 + 2] = 5;
a.data[2*4*2 + 3] = 6;
Complex64F c = new Complex64F();
a.get(2,1,c);
assertEquals(a.getImaginary(2, 1), 6, 1e-8);
}
@Test
public void setImaginary() {
CDenseMatrix64F a = new CDenseMatrix64F(3,4);
a.setImaginary(2, 1, 6);
assertEquals(6, a.data[2 * 4 * 2 + 3], 1e-8);
}
@Test
public void getDataLength() {
assertEquals(3*4*2,new CDenseMatrix64F(3,4).getDataLength());
}
@Test
public void copy() {
CDenseMatrix64F a = new CDenseMatrix64F(3,4);
a.set(1, 3, 9, 2);
CDenseMatrix64F b = a.copy();
for (int i = 0; i < a.getDataLength(); i++) {
assertEquals(a.data[i],b.data[i],1e-8);
}
}
@Test
public void getRowStride() {
CDenseMatrix64F a = new CDenseMatrix64F(3,4);
assertEquals(4*2,a.getRowStride());
}
@Test
public void set_array() {
CDenseMatrix64F A = CRandomMatrices.createRandom(3,4,rand);
CDenseMatrix64F B = new CDenseMatrix64F(1,1);
B.set(3,4,true,A.data);
assertTrue(CMatrixFeatures.isEquals(A,B));
CDenseMatrix64F A_tran = new CDenseMatrix64F(4,3);
CCommonOps.transpose(A,A_tran);
B.set(3,4,false,A_tran.data);
assertTrue(CMatrixFeatures.isEquals(A,B));
}
}
ejml-0.28/main/core/test/org/ejml/data/TestD1Submatrix64F.java 0000664 0000000 0000000 00000003500 12561715344 0024010 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.CommonOps;
import org.ejml.ops.MatrixFeatures;
import org.ejml.ops.RandomMatrices;
import org.junit.Test;
import java.util.Random;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Peter Abeles
*/
public class TestD1Submatrix64F {
Random rand = new Random(234234);
@Test
public void get() {
DenseMatrix64F A = RandomMatrices.createRandom(5,10,-1,1,rand);
D1Submatrix64F S = new D1Submatrix64F(A,2,4,1,10);
assertEquals(A.get(3,2),S.get(1,1),1e-8);
}
@Test
public void set() {
DenseMatrix64F A = RandomMatrices.createRandom(5,10,-1,1,rand);
D1Submatrix64F S = new D1Submatrix64F(A,2,4,1,10);
S.set(1,1,5);
assertEquals(A.get(3,2),5,1e-8);
}
@Test
public void extract() {
DenseMatrix64F A = RandomMatrices.createRandom(5,10,-1,1,rand);
D1Submatrix64F S = new D1Submatrix64F(A,2,4,1,10);
DenseMatrix64F M = S.extract();
DenseMatrix64F E = CommonOps.extract(A,2,4,1,10);
assertTrue(MatrixFeatures.isEquals(E,M));
}
}
ejml-0.28/main/core/test/org/ejml/data/TestDenseMatrix32F.java 0000664 0000000 0000000 00000014566 12561715344 0024101 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.EjmlParameters;
import org.ejml.ops.EjmlUnitTests;
import org.junit.Ignore;
import org.junit.Test;
import java.util.Random;
import static org.junit.Assert.*;
/**
* @author Peter Abeles
*/
public class TestDenseMatrix32F {
Random rand = new Random(23432);
@Test
public void testGeneric() {
GenericTestsD1Matrix32F g;
g = new GenericTestsD1Matrix32F() {
protected D1Matrix32F createMatrix(int numRows, int numCols) {
return new DenseMatrix32F(numRows,numCols);
}
};
g.allTests();
}
/**
* Tests the following constructor:
*
* DenseMatrix32F( float data[] , int numCols , int numRows )
*/
@Test
public void testConstructorSingleArray()
{
float d[] = new float[]{1,2,3,4,5,6};
DenseMatrix32F mat = new DenseMatrix32F(3,2, true, d);
assertTrue( mat.data != d );
assertEquals(1,mat.get(0,0),1e-8);
assertEquals(2,mat.get(0,1),1e-8);
assertEquals(3,mat.get(1,0),1e-8);
assertEquals(4,mat.get(1,1),1e-8);
assertEquals(5,mat.get(2,0),1e-8);
assertEquals(6,mat.get(2,1),1e-8);
}
/**
* Tests the following constructor:
*
* DenseMatrix32F( float data[][] )
*/
@Test
public void testConstruactorfloatArray() {
float d[][] = new float[][]{{1,2},{3,4},{5,6}};
DenseMatrix32F mat = new DenseMatrix32F(d);
assertEquals(1,mat.get(0,0),1e-8);
assertEquals(2,mat.get(0,1),1e-8);
assertEquals(3,mat.get(1,0),1e-8);
assertEquals(4,mat.get(1,1),1e-8);
assertEquals(5,mat.get(2,0),1e-8);
assertEquals(6,mat.get(2,1),1e-8);
}
/**
* Tests the following constructor:
*
* DenseMatrix32F( int numCols , int numRows )
*/
@Test
public void testConstructorShape() {
DenseMatrix32F mat = new DenseMatrix32F(7,5);
assertEquals(5,mat.getNumCols());
assertEquals(7,mat.getNumRows());
assertEquals(7*5,mat.data.length);
}
/**
* Tests the following constructor:
*
* DenseMatrix32F( DenseMatrix32F orig )
*/
@Test
public void testConstructorCopy() {
float d[][] = new float[][]{{1,2},{3,4},{5,6}};
DenseMatrix32F mat = new DenseMatrix32F(d);
DenseMatrix32F copy = new DenseMatrix32F(mat);
assertTrue( mat.data != copy.data );
assertEquals(mat.getNumCols(),copy.getNumCols());
assertEquals(mat.getNumRows(),copy.getNumRows());
for( int i = 0; i < mat.getNumElements(); i++ ) {
assertEquals(mat.get(i),copy.get(i),EjmlParameters.TOL32);
}
}
@Test
public void wrap() {
float d[] = new float[]{1,2,3,4,5,6};
DenseMatrix32F mat = DenseMatrix32F.wrap(3,2,d);
assertTrue(mat.data==d);
assertEquals(1,mat.get(0,0),1e-8);
assertEquals(2,mat.get(0,1),1e-8);
assertEquals(3,mat.get(1,0),1e-8);
assertEquals(4,mat.get(1,1),1e-8);
assertEquals(5,mat.get(2,0),1e-8);
assertEquals(6,mat.get(2,1),1e-8);
}
@Test
public void testInBounds() {
DenseMatrix32F mat = new DenseMatrix32F(2,3);
assertTrue(mat.isInBounds(0,0));
assertTrue(mat.isInBounds(1,2));
assertTrue(mat.isInBounds(0,2));
assertFalse(mat.isInBounds(2,0));
assertFalse(mat.isInBounds(20,30));
}
@Test
public void testSet_Matrix() {
float d[][] = new float[][]{{1,2},{3,4},{5,6}};
DenseMatrix32F mat = new DenseMatrix32F(d);
DenseMatrix32F mat2 = new DenseMatrix32F(mat.numRows,mat.numCols);
mat2.set(mat);
EjmlUnitTests.assertEquals(mat,mat2,EjmlParameters.TOL32);
}
@Test
@Ignore
public void set_ColumnMajor() {
// todo implement later after basic 32bit operations are done
fail("implement");
// DenseMatrix32F A = UtilTestMatrix.random32(3,5,-1,1,rand);
//
// DenseMatrix32F Atran = A.copy();
// CommonOps.transpose(Atran);
// DenseMatrix32F Afound = new DenseMatrix32F(3,5);
// Afound.set(3,5, false, Atran.data);
//
// assertTrue(MatrixFeatures.isIdentical(Afound,A,EjmlParameters.TOL32));
}
@Test
@Ignore
public void set_RowMajor() {
// todo implement later after basic 32bit operations are done
fail("implement");
// DenseMatrix32F A = UtilTestMatrix.random32(3, 5, -1, 1, rand);
//
// DenseMatrix32F Afound = new DenseMatrix32F(3,5);
// Afound.set(3,5, true, A.data);
//
// assertTrue(MatrixFeatures.isIdentical(Afound,A,EjmlParameters.TOL32));
// assertTrue(A.data != Afound.data);
}
@Test
public void testset_Matrix() {
float d[][] = new float[][]{{1,2},{3,4},{5,6}};
DenseMatrix32F mat = new DenseMatrix32F(d);
DenseMatrix32F mat2 = new DenseMatrix32F(5,5);
mat2.set(mat);
assertEquals(mat.getNumCols(),mat2.getNumCols());
assertEquals(mat.getNumRows(),mat2.getNumRows());
EjmlUnitTests.assertEquals(mat,mat2, EjmlParameters.TOL32);
}
@Test
public void testReshape() {
float d[][] = new float[][]{{1,2},{3,4},{5,6}};
DenseMatrix32F mat = new DenseMatrix32F(d);
DenseMatrix32F orig = mat.copy();
// first see if reshape saves the data
mat.reshape(10,10,true);
for( int i = 0; i < 6; i++ ) {
assertEquals(mat.data[i],orig.data[i],EjmlParameters.TOL32);
}
// now make sure it doesn't
mat.reshape(11,10,false);
for( int i = 0; i < 6; i++ ) {
assertTrue(Math.abs(mat.data[i]-orig.data[i])>EjmlParameters.TOL32);
}
}
}
ejml-0.28/main/core/test/org/ejml/data/TestDenseMatrix64F.java 0000664 0000000 0000000 00000014113 12561715344 0024072 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.CommonOps;
import org.ejml.ops.EjmlUnitTests;
import org.ejml.ops.MatrixFeatures;
import org.ejml.ops.RandomMatrices;
import org.junit.Test;
import java.util.Random;
import static org.junit.Assert.*;
/**
* @author Peter Abeles
*/
public class TestDenseMatrix64F {
Random rand = new Random(23432);
@Test
public void testGeneric() {
GenericTestsD1Matrix64F g;
g = new GenericTestsD1Matrix64F() {
protected D1Matrix64F createMatrix(int numRows, int numCols) {
return new DenseMatrix64F(numRows,numCols);
}
};
g.allTests();
}
/**
* Tests the following constructor:
*
* DenseMatrix64F( double data[] , int numCols , int numRows )
*/
@Test
public void testConstructorSingleArray()
{
double d[] = new double[]{1,2,3,4,5,6};
DenseMatrix64F mat = new DenseMatrix64F(3,2, true, d);
assertTrue( mat.data != d );
assertEquals(1,mat.get(0,0),1e-8);
assertEquals(2,mat.get(0,1),1e-8);
assertEquals(3,mat.get(1,0),1e-8);
assertEquals(4,mat.get(1,1),1e-8);
assertEquals(5,mat.get(2,0),1e-8);
assertEquals(6,mat.get(2,1),1e-8);
}
/**
* Tests the following constructor:
*
* DenseMatrix64F( double data[][] )
*/
@Test
public void testConstruactorDoubleArray() {
double d[][] = new double[][]{{1,2},{3,4},{5,6}};
DenseMatrix64F mat = new DenseMatrix64F(d);
assertEquals(1,mat.get(0,0),1e-8);
assertEquals(2,mat.get(0,1),1e-8);
assertEquals(3,mat.get(1,0),1e-8);
assertEquals(4,mat.get(1,1),1e-8);
assertEquals(5,mat.get(2,0),1e-8);
assertEquals(6,mat.get(2,1),1e-8);
}
/**
* Tests the following constructor:
*
* DenseMatrix64F( int numCols , int numRows )
*/
@Test
public void testConstructorShape() {
DenseMatrix64F mat = new DenseMatrix64F(7,5);
assertEquals(5,mat.getNumCols());
assertEquals(7,mat.getNumRows());
assertEquals(7*5,mat.data.length);
}
/**
* Tests the following constructor:
*
* DenseMatrix64F( DenseMatrix64F orig )
*/
@Test
public void testConstructorCopy() {
double d[][] = new double[][]{{1,2},{3,4},{5,6}};
DenseMatrix64F mat = new DenseMatrix64F(d);
DenseMatrix64F copy = new DenseMatrix64F(mat);
assertTrue( mat.data != copy.data );
assertEquals(mat.getNumCols(),copy.getNumCols());
assertEquals(mat.getNumRows(),copy.getNumRows());
for( int i = 0; i < mat.getNumElements(); i++ ) {
assertEquals(mat.get(i),copy.get(i),1e-10);
}
}
@Test
public void wrap() {
double d[] = new double[]{1,2,3,4,5,6};
DenseMatrix64F mat = DenseMatrix64F.wrap(3,2,d);
assertTrue(mat.data==d);
assertEquals(1,mat.get(0,0),1e-8);
assertEquals(2,mat.get(0,1),1e-8);
assertEquals(3,mat.get(1,0),1e-8);
assertEquals(4,mat.get(1,1),1e-8);
assertEquals(5,mat.get(2,0),1e-8);
assertEquals(6,mat.get(2,1),1e-8);
}
@Test
public void testInBounds() {
DenseMatrix64F mat = new DenseMatrix64F(2,3);
assertTrue(mat.isInBounds(0,0));
assertTrue(mat.isInBounds(1,2));
assertTrue(mat.isInBounds(0,2));
assertFalse(mat.isInBounds(2,0));
assertFalse(mat.isInBounds(20,30));
}
@Test
public void testSet_Matrix() {
double d[][] = new double[][]{{1,2},{3,4},{5,6}};
DenseMatrix64F mat = new DenseMatrix64F(d);
DenseMatrix64F mat2 = new DenseMatrix64F(mat.numRows,mat.numCols);
mat2.set(mat);
EjmlUnitTests.assertEquals(mat,mat2,1e-10);
}
@Test
public void set_ColumnMajor() {
DenseMatrix64F A = RandomMatrices.createRandom(3,5,rand);
DenseMatrix64F Atran = A.copy();
CommonOps.transpose(Atran);
DenseMatrix64F Afound = new DenseMatrix64F(3,5);
Afound.set(3,5, false, Atran.data);
assertTrue(MatrixFeatures.isIdentical(Afound,A,1e-10));
}
@Test
public void set_RowMajor() {
DenseMatrix64F A = RandomMatrices.createRandom(3,5,rand);
DenseMatrix64F Afound = new DenseMatrix64F(3,5);
Afound.set(3,5, true, A.data);
assertTrue(MatrixFeatures.isIdentical(Afound,A,1e-10));
assertTrue(A.data != Afound.data);
}
@Test
public void testset_Matrix() {
double d[][] = new double[][]{{1,2},{3,4},{5,6}};
DenseMatrix64F mat = new DenseMatrix64F(d);
DenseMatrix64F mat2 = new DenseMatrix64F(5,5);
mat2.set(mat);
assertEquals(mat.getNumCols(),mat2.getNumCols());
assertEquals(mat.getNumRows(),mat2.getNumRows());
EjmlUnitTests.assertEquals(mat,mat2,1e-10);
}
@Test
public void testReshape() {
double d[][] = new double[][]{{1,2},{3,4},{5,6}};
DenseMatrix64F mat = new DenseMatrix64F(d);
DenseMatrix64F orig = mat.copy();
// first see if reshape saves the data
mat.reshape(10,10,true);
for( int i = 0; i < 6; i++ ) {
assertEquals(mat.data[i],orig.data[i],1e-8);
}
// now make sure it doesn't
mat.reshape(11,10,false);
for( int i = 0; i < 6; i++ ) {
assertTrue(Math.abs(mat.data[i]-orig.data[i])>1e-8);
}
}
}
ejml-0.28/main/core/test/org/ejml/data/TestMatrixIterator32F.java 0000664 0000000 0000000 00000005536 12561715344 0024631 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.EjmlParameters;
import org.junit.Test;
import java.util.Random;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Peter Abeles
*/
public class TestMatrixIterator32F {
Random rand = new Random(234234);
@Test
public void allRow() {
DenseMatrix32F A = UtilTestMatrix.random32(3, 6, -1, 1, rand);
MatrixIterator32F iter = A.iterator(true,0, 0, A.numRows-1, A.numCols-1);
for( int i = 0; i < A.numRows; i++ ) {
for( int j = 0; j < A.numCols; j++ ) {
assertTrue(iter.hasNext());
assertEquals(A.get(i,j),iter.next(),EjmlParameters.TOL32);
}
}
assertTrue(!iter.hasNext());
}
@Test
public void allCol() {
DenseMatrix32F A = UtilTestMatrix.random32(3, 6,-1,1, rand);
MatrixIterator32F iter = A.iterator(false,0, 0, A.numRows-1, A.numCols-1);
for( int j = 0; j < A.numCols; j++ ) {
for( int i = 0; i < A.numRows; i++ ) {
assertTrue(iter.hasNext());
assertEquals(A.get(i,j),iter.next(),EjmlParameters.TOL32);
}
}
assertTrue(!iter.hasNext());
}
@Test
public void subRow() {
DenseMatrix32F A = UtilTestMatrix.random32(3, 6, -1,1,rand);
MatrixIterator32F iter = A.iterator(true,1, 2 , A.numRows-2, A.numCols-1);
for( int i = 1; i < A.numRows-1; i++ ) {
for( int j = 2; j < A.numCols; j++ ) {
assertTrue(iter.hasNext());
assertEquals(A.get(i,j),iter.next(),EjmlParameters.TOL32);
}
}
assertTrue(!iter.hasNext());
}
@Test
public void subCol() {
DenseMatrix32F A = UtilTestMatrix.random32(3, 6,-1,1,rand);
MatrixIterator32F iter = A.iterator(false,1, 2 , A.numRows-2, A.numCols-1);
for( int j = 2; j < A.numCols; j++ ) {
for( int i = 1; i < A.numRows-1; i++ ) {
assertTrue(iter.hasNext());
assertEquals(A.get(i,j),iter.next(), EjmlParameters.TOL32);
}
}
assertTrue(!iter.hasNext());
}
}
ejml-0.28/main/core/test/org/ejml/data/TestMatrixIterator64F.java 0000664 0000000 0000000 00000005424 12561715344 0024632 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.ops.RandomMatrices;
import org.junit.Test;
import java.util.Random;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Peter Abeles
*/
public class TestMatrixIterator64F {
Random rand = new Random(234234);
@Test
public void allRow() {
DenseMatrix64F A = RandomMatrices.createRandom(3,6,rand);
MatrixIterator64F iter = A.iterator(true,0, 0, A.numRows-1, A.numCols-1);
for( int i = 0; i < A.numRows; i++ ) {
for( int j = 0; j < A.numCols; j++ ) {
assertTrue(iter.hasNext());
assertEquals(A.get(i,j),iter.next(),1e-8);
}
}
assertTrue(!iter.hasNext());
}
@Test
public void allCol() {
DenseMatrix64F A = RandomMatrices.createRandom(3,6,rand);
MatrixIterator64F iter = A.iterator(false,0, 0, A.numRows-1, A.numCols-1);
for( int j = 0; j < A.numCols; j++ ) {
for( int i = 0; i < A.numRows; i++ ) {
assertTrue(iter.hasNext());
assertEquals(A.get(i,j),iter.next(),1e-8);
}
}
assertTrue(!iter.hasNext());
}
@Test
public void subRow() {
DenseMatrix64F A = RandomMatrices.createRandom(3,6,rand);
MatrixIterator64F iter = A.iterator(true,1, 2 , A.numRows-2, A.numCols-1);
for( int i = 1; i < A.numRows-1; i++ ) {
for( int j = 2; j < A.numCols; j++ ) {
assertTrue(iter.hasNext());
assertEquals(A.get(i,j),iter.next(),1e-8);
}
}
assertTrue(!iter.hasNext());
}
@Test
public void subCol() {
DenseMatrix64F A = RandomMatrices.createRandom(3,6,rand);
MatrixIterator64F iter = A.iterator(false,1, 2 , A.numRows-2, A.numCols-1);
for( int j = 2; j < A.numCols; j++ ) {
for( int i = 1; i < A.numRows-1; i++ ) {
assertTrue(iter.hasNext());
assertEquals(A.get(i,j),iter.next(),1e-8);
}
}
assertTrue(!iter.hasNext());
}
}
ejml-0.28/main/core/test/org/ejml/data/UtilTestMatrix.java 0000664 0000000 0000000 00000006704 12561715344 0023500 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import java.util.Arrays;
import java.util.Random;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
/**
* Contains functions useful for testing the results of matrices
*
* @author Peter Abeles
*/
public class UtilTestMatrix {
public static void checkMat( DenseMatrix64F mat , double ...d )
{
double data[] = mat.getData();
for( int i = 0; i < mat.getNumElements(); i++ ) {
assertEquals(d[i],data[i],1e-6);
}
}
public static void checkSameElements( double tol, int length , double a[], double b[] )
{
double aa[] = new double[ length ];
double bb[] = new double[ length ];
System.arraycopy(a,0,aa,0,length);
System.arraycopy(b,0,bb,0,length);
Arrays.sort(aa);
Arrays.sort(bb);
for( int i = 0; i < length; i++ ) {
if( Math.abs(aa[i]-bb[i])> tol )
fail("Mismatched elements");
}
}
public static void checkNumFound( int expected , double tol , double value , double data[] )
{
int numFound = 0;
for( int i = 0; i < data.length; i++ ) {
if( Math.abs(data[i]-value) <= tol )
numFound++;
}
assertEquals(expected,numFound);
}
/**
*
* Sets each element in the matrix to a value drawn from an uniform distribution from 'min' to 'max' inclusive.
*
*
* @param min The minimum value each element can be.
* @param max The maximum value each element can be.
* @param rand Random number generator used to fill the matrix.
*/
public static DenseMatrix64F random64( int numRows , int numCols , double min , double max , Random rand )
{
DenseMatrix64F mat = new DenseMatrix64F(numRows,numCols);
double d[] = mat.getData();
int size = mat.getNumElements();
double r = max-min;
for( int i = 0; i < size; i++ ) {
d[i] = r*rand.nextDouble()+min;
}
return mat;
}
/**
*
* Sets each element in the matrix to a value drawn from an uniform distribution from 'min' to 'max' inclusive.
*
*
* @param min The minimum value each element can be.
* @param max The maximum value each element can be.
* @param rand Random number generator used to fill the matrix.
*/
public static DenseMatrix32F random32( int numRows , int numCols , float min , float max , Random rand )
{
DenseMatrix32F mat = new DenseMatrix32F(numRows,numCols);
float d[] = mat.getData();
int size = mat.getNumElements();
float r = max-min;
for( int i = 0; i < size; i++ ) {
d[i] = r*rand.nextFloat()+min;
}
return mat;
}
}
ejml-0.28/main/core/test/org/ejml/ops/ 0000775 0000000 0000000 00000000000 12561715344 0017554 5 ustar 00root root 0000000 0000000 ejml-0.28/main/core/test/org/ejml/ops/TestComplexMath64F.java 0000664 0000000 0000000 00000014567 12561715344 0023775 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.ops;
import org.ejml.data.Complex64F;
import org.ejml.data.ComplexPolar64F;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
/**
* @author Peter Abeles
*/
public class TestComplexMath64F {
@Test
public void conj() {
Complex64F a = new Complex64F(2, 3);
Complex64F b = new Complex64F(-3, 6);
ComplexMath64F.conj(a, b);
assertEquals(a.real, b.real, 1e-8);
assertEquals(-a.imaginary, b.imaginary, 1e-8);
}
@Test
public void plus() {
Complex64F a = new Complex64F(2, 3);
Complex64F b = new Complex64F(-3, 6);
Complex64F c = new Complex64F();
ComplexMath64F.plus(a, b, c);
assertEquals(-1, c.real, 1e-8);
assertEquals(9, c.imaginary, 1e-8);
}
@Test
public void minus() {
Complex64F a = new Complex64F(2, 3);
Complex64F b = new Complex64F(-3, 6);
Complex64F c = new Complex64F();
ComplexMath64F.minus(a, b, c);
assertEquals(5, c.real, 1e-8);
assertEquals(-3, c.imaginary, 1e-8);
}
@Test
public void multiply() {
Complex64F a = new Complex64F(2, 3);
Complex64F b = new Complex64F(-3, 6);
Complex64F c = new Complex64F();
ComplexMath64F.multiply(a, b, c);
assertEquals(-24, c.real, 1e-8);
assertEquals(3, c.imaginary, 1e-8);
}
@Test
public void divide() {
Complex64F a = new Complex64F(2, 3);
Complex64F b = new Complex64F(-3, 6);
Complex64F c = new Complex64F();
ComplexMath64F.divide(a, b, c);
assertEquals(0.26666666666, c.real, 1e-8);
assertEquals(-0.466666666666, c.imaginary, 1e-8);
}
/**
* Test conversion to and from polar form by doing just that and see if it gets the original answer again
*/
@Test
public void convert() {
Complex64F a = new Complex64F(2, 3);
ComplexPolar64F b = new ComplexPolar64F();
Complex64F c = new Complex64F();
ComplexMath64F.convert(a, b);
ComplexMath64F.convert(b, c);
assertEquals(a.real, c.real, 1e-8);
assertEquals(a.imaginary, c.imaginary, 1e-8);
}
@Test
public void mult_polar() {
Complex64F a = new Complex64F(2, 3);
Complex64F b = new Complex64F(-3, 6);
Complex64F expected = new Complex64F();
ComplexMath64F.multiply(a, b, expected);
ComplexPolar64F pa = new ComplexPolar64F(a);
ComplexPolar64F pb = new ComplexPolar64F(b);
ComplexPolar64F pc = new ComplexPolar64F();
ComplexMath64F.multiply(pa, pb, pc);
Complex64F found = pc.toStandard();
assertEquals(expected.real, found.real, 1e-8);
assertEquals(expected.imaginary, found.imaginary, 1e-8);
}
@Test
public void div_polar() {
Complex64F a = new Complex64F(2, 3);
Complex64F b = new Complex64F(-3, 6);
Complex64F expected = new Complex64F();
ComplexMath64F.divide(a, b, expected);
ComplexPolar64F pa = new ComplexPolar64F(a);
ComplexPolar64F pb = new ComplexPolar64F(b);
ComplexPolar64F pc = new ComplexPolar64F();
ComplexMath64F.divide(pa, pb, pc);
Complex64F found = pc.toStandard();
assertEquals(expected.real, found.real, 1e-8);
assertEquals(expected.imaginary, found.imaginary, 1e-8);
}
@Test
public void pow() {
ComplexPolar64F a = new ComplexPolar64F(2, 0.2);
ComplexPolar64F expected = new ComplexPolar64F();
ComplexPolar64F found = new ComplexPolar64F();
ComplexMath64F.multiply(a, a, expected);
ComplexMath64F.multiply(a, expected, expected);
ComplexMath64F.pow(a, 3, found);
assertEquals(expected.r, found.r, 1e-8);
assertEquals(expected.theta, found.theta, 1e-8);
}
@Test
public void root_polar() {
ComplexPolar64F expected = new ComplexPolar64F(2, 0.2);
ComplexPolar64F root = new ComplexPolar64F();
ComplexPolar64F found = new ComplexPolar64F();
// compute the square root of a complex number then see if the
// roots equal the output
for (int i = 0; i < 2; i++) {
ComplexMath64F.root(expected, 2, 0, root);
ComplexMath64F.multiply(root, root, found);
Complex64F e = expected.toStandard();
Complex64F f = found.toStandard();
assertEquals(e.real, f.real, 1e-8);
assertEquals(e.imaginary, f.imaginary, 1e-8);
}
}
@Test
public void root_standard() {
Complex64F expected = new Complex64F(2, 0.2);
Complex64F root = new Complex64F();
Complex64F found = new Complex64F();
// compute the square root of a complex number then see if the
// roots equal the output
for (int i = 0; i < 2; i++) {
ComplexMath64F.root(expected, 2, 0, root);
ComplexMath64F.multiply(root, root, found);
assertEquals(expected.real, found.real, 1e-8);
assertEquals(expected.imaginary, found.imaginary, 1e-8);
}
}
@Test
public void sqrt_standard() {
Complex64F input = new Complex64F(2, 0.2);
Complex64F root = new Complex64F();
Complex64F found = new Complex64F();
ComplexMath64F.sqrt(input, root);
ComplexMath64F.multiply(root, root, found);
assertEquals(input.real, found.real, 1e-8);
assertEquals(input.imaginary, found.imaginary, 1e-8);
input = new Complex64F(2, -0.2);
ComplexMath64F.sqrt(input, root);
ComplexMath64F.multiply(root, root, found);
assertEquals(input.real, found.real, 1e-8);
assertEquals(input.imaginary, found.imaginary, 1e-8);
}
}
ejml-0.28/main/core/test/org/ejml/ops/TestConvertMatrixType.java 0000664 0000000 0000000 00000012546 12561715344 0024736 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.ops;
import org.ejml.alg.block.BlockMatrixOps;
import org.ejml.data.BlockMatrix64F;
import org.ejml.data.DenseMatrix64F;
import org.ejml.data.FixedMatrix64F;
import org.ejml.data.RealMatrix64F;
import org.junit.Test;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Random;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Peter Abeles
*/
public class TestConvertMatrixType {
Random rand = new Random(234);
@Test
public void any_to_any() {
DenseMatrix64F a = new DenseMatrix64F(2,3,true,1,2,3,4,5,6);
DenseMatrix64F b = new DenseMatrix64F(2,3);
ConvertMatrixType.convert((RealMatrix64F)a,(RealMatrix64F)b);
assertTrue(MatrixFeatures.isIdentical(a,b,1e-12));
}
@Test
public void checkAll_Fixed_to_DM() throws IllegalAccessException, InstantiationException, InvocationTargetException {
Method[] methods = ConvertMatrixType.class.getMethods();
int numFound = 0;
for( Method m : methods ) {
if( !m.getName().equals("convert") )
continue;
Class[]param = m.getParameterTypes();
if( !FixedMatrix64F.class.isAssignableFrom(param[0]) ) {
continue;
}
FixedMatrix64F a = (FixedMatrix64F)param[0].newInstance();
DenseMatrix64F b = new DenseMatrix64F(a.getNumRows(),a.getNumCols());
for( int i = 0; i < b.numRows; i++ ) {
for( int j = 0; j < b.numCols; j++ ) {
a.set(i, j, rand.nextDouble());
}
}
Object[] input = new Object[param.length];
input[0] = a;
input[1] = b;
m.invoke(null,input);
checkIdentical(a,b);
numFound++;
}
assertEquals(5+5,numFound);
}
@Test
public void checkAll_DM_to_Fixed() throws IllegalAccessException, InstantiationException, InvocationTargetException {
Method[] methods = ConvertMatrixType.class.getMethods();
int numFound = 0;
for( Method m : methods ) {
if( !m.getName().equals("convert") )
continue;
Class[]param = m.getParameterTypes();
if( !FixedMatrix64F.class.isAssignableFrom(param[1]) ) {
continue;
}
FixedMatrix64F b = (FixedMatrix64F)param[1].newInstance();
DenseMatrix64F a = new DenseMatrix64F(b.getNumRows(),b.getNumCols());
for( int i = 0; i < a.numRows; i++ ) {
for( int j = 0; j < a.numCols; j++ ) {
a.set(i, j, rand.nextDouble());
}
}
Object[] input = new Object[param.length];
input[0] = a;
input[1] = b;
m.invoke(null,input);
checkIdentical(a,b);
numFound++;
}
assertEquals(5+5,numFound);
}
@Test
public void BM_to_DM() {
for( int rows = 1; rows <= 8; rows++ ) {
for( int cols = 1; cols <= 8; cols++ ) {
BlockMatrix64F a = BlockMatrixOps.createRandom(rows,cols,-1,2,rand);
DenseMatrix64F b = new DenseMatrix64F(rows,cols);
ConvertMatrixType.convert(a,b);
checkIdentical(a,b);
}
}
}
@Test
public void DM_to_BM() {
for( int rows = 1; rows <= 8; rows++ ) {
for( int cols = 1; cols <= 8; cols++ ) {
DenseMatrix64F a = RandomMatrices.createRandom(rows,cols,rand);
BlockMatrix64F b = new BlockMatrix64F(rows,cols,3);
ConvertMatrixType.convert(a,b);
checkIdentical(a,b);
}
}
}
private void checkIdentical( RealMatrix64F a , RealMatrix64F b ) {
for( int i = 0; i < a.getNumRows(); i++ ) {
for( int j = 0; j < a.getNumCols(); j++ ) {
assertEquals(a.get(i,j),b.get(i,j),1e-8);
}
}
}
private void checkIdenticalV( RealMatrix64F a , RealMatrix64F b ) {
boolean columnVectorA = a.getNumRows() > a.getNumCols();
boolean columnVectorB = b.getNumRows() > b.getNumCols();
int length = Math.max(a.getNumRows(),b.getNumRows());
for( int i = 0; i < length; i++ ) {
double valueA,valueB;
if( columnVectorA )
valueA = a.get(i,0);
else
valueA = a.get(0,i);
if( columnVectorB )
valueB = b.get(i,0);
else
valueB = b.get(0,i);
assertEquals(valueA,valueB,1e-8);
}
}
}
ejml-0.28/main/core/test/org/ejml/ops/TestMatrixIO.java 0000664 0000000 0000000 00000003562 12561715344 0022761 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2013, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.ops;
import org.ejml.data.DenseMatrix64F;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.util.Random;
import static org.junit.Assert.assertTrue;
/**
* @author Peter Abeles
*/
public class TestMatrixIO {
Random rand = new Random(23424);
@Test
public void load_save_binary() throws IOException {
DenseMatrix64F A = RandomMatrices.createRandom(6,3,rand);
MatrixIO.saveBin(A, "temp.mat");
DenseMatrix64F A_copy = MatrixIO.loadBin("temp.mat");
assertTrue(A != A_copy);
assertTrue(MatrixFeatures.isEquals(A,A_copy));
// clean up
File f = new File("temp.mat");
assertTrue(f.exists());
assertTrue(f.delete());
}
@Test
public void load_save_csv() throws IOException {
DenseMatrix64F A = RandomMatrices.createRandom(6,3,rand);
MatrixIO.saveCSV(A,"temp.csv");
DenseMatrix64F A_copy = MatrixIO.loadCSV("temp.csv");
assertTrue(A != A_copy);
assertTrue(MatrixFeatures.isEquals(A,A_copy));
// clean up
File f = new File("temp.csv");
assertTrue(f.exists());
assertTrue(f.delete());
}
}
ejml-0.28/main/core/test/org/ejml/ops/TestReadMatrixCsv.java 0000664 0000000 0000000 00000004033 12561715344 0023773 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.ops;
import org.ejml.data.CDenseMatrix64F;
import org.junit.Test;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
/**
* @author Peter Abeles
*/
public class TestReadMatrixCsv {
/**
* Make sure incorrectly formatted data is handled gracefully
*/
@Test(expected=IOException.class)
public void bad_matrix_row() throws IOException {
String s = "3 2 real\n0 0\n1 1";
ReadMatrixCsv alg = new ReadMatrixCsv(new ByteArrayInputStream(s.getBytes()));
alg.read();
fail("Should have had an exception");
}
@Test(expected=IOException.class)
public void bad_matrix_col() throws IOException {
String s = "3 2 real\n0 0\n1\n0 3";
ReadMatrixCsv alg = new ReadMatrixCsv(new ByteArrayInputStream(s.getBytes()));
alg.read();
fail("Should have had an exception");
}
public void complex() throws IOException {
String s = "3 2 complex\n0 2 0 -1\n1 2 -1 -1\n0 2 3 10";
ReadMatrixCsv alg = new ReadMatrixCsv(new ByteArrayInputStream(s.getBytes()));
CDenseMatrix64F expected = new CDenseMatrix64F(3,2,true,0,2,0,-1,1,2,-1,-1,0,2,3,10);
CDenseMatrix64F m = alg.read();
assertTrue(CMatrixFeatures.isIdentical(expected,m,1e-8));
}
}
ejml-0.28/main/dense64/ 0000775 0000000 0000000 00000000000 12561715344 0014576 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/build.gradle 0000664 0000000 0000000 00000000331 12561715344 0017052 0 ustar 00root root 0000000 0000000 dependencies {
compile project(':main:core')
testCompile project(':main:experimental')
testCompile project(':main:core').sourceSets.test.output
}
idea {
module {
name = "EJML Dense 64"
}
} ejml-0.28/main/dense64/generate/ 0000775 0000000 0000000 00000000000 12561715344 0016370 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/generate/org/ 0000775 0000000 0000000 00000000000 12561715344 0017157 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/generate/org/ejml/ 0000775 0000000 0000000 00000000000 12561715344 0020106 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/generate/org/ejml/CodeGeneratorBase.java 0000664 0000000 0000000 00000005257 12561715344 0024276 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
/**
* Base class for code generators.
*
* @author Peter Abeles
*/
public abstract class CodeGeneratorBase {
public static final String copyright =
"/*\n" +
" * Copyright (c) 2009-2013, Peter Abeles. All Rights Reserved.\n" +
" *\n" +
" * This file is part of Efficient Java Matrix Library (EJML).\n" +
" *\n" +
" * Licensed under the Apache License, Version 2.0 (the \"License\");\n" +
" * you may not use this file except in compliance with the License.\n" +
" * You may obtain a copy of the License at\n" +
" *\n" +
" * http://www.apache.org/licenses/LICENSE-2.0\n" +
" *\n" +
" * Unless required by applicable law or agreed to in writing, software\n" +
" * distributed under the License is distributed on an \"AS IS\" BASIS,\n" +
" * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" +
" * See the License for the specific language governing permissions and\n" +
" * limitations under the License.\n" +
" */";
protected PrintStream out;
protected String className;
/**
* Creates
*
* @throws java.io.FileNotFoundException
*/
public abstract void generate() throws FileNotFoundException;
public void setOutputFile( String className ) throws FileNotFoundException {
this.className = className;
out = new PrintStream(new FileOutputStream(className + ".java"));
out.print(copyright);
out.println();
out.println("package " + getPackage() + ";");
out.println();
}
public String getPackage() {
return getClass().getPackage().getName();
}
}
ejml-0.28/main/dense64/generate/org/ejml/alg/ 0000775 0000000 0000000 00000000000 12561715344 0020651 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/generate/org/ejml/alg/dense/ 0000775 0000000 0000000 00000000000 12561715344 0021747 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/generate/org/ejml/alg/dense/misc/ 0000775 0000000 0000000 00000000000 12561715344 0022702 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/generate/org/ejml/alg/dense/misc/GenerateDeterminantFromMinor.java 0000664 0000000 0000000 00000016106 12561715344 0031327 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.alg.dense.misc;
import org.ejml.alg.generic.CodeGeneratorMisc;
import java.io.FileNotFoundException;
import java.io.PrintStream;
/**
* Generates code for an unrolled determinant by minor.
*
* NOTE: There are some repeat calculations of inner determinants. Maybe it could be speed up by calculating those?
*
* @author Peter Abeles
*/
public class GenerateDeterminantFromMinor {
protected PrintStream stream;
protected int N;
public GenerateDeterminantFromMinor( String fileName ) throws FileNotFoundException {
stream = new PrintStream(fileName);
}
public GenerateDeterminantFromMinor(PrintStream stream) {
this.stream = stream;
}
public void createClass(int N) {
printTop(N);
printCalls(N);
print2();
print3();
for( int i = 4; i <= N; i++ ) {
printFunction(i);
}
stream.print("}\n");
}
private void printTop(int N) {
String foo = CodeGeneratorMisc.COPYRIGHT +
"\n" +
"package org.ejml.alg.dense.misc;\n" +
"\n" +
"import org.ejml.data.RowD1Matrix64F;\n" +
"\n" +
"\n" +
"/**\n" +
" * This code was auto generated by {@link GenerateDeterminantFromMinor} and should not be modified\n" +
" * directly. \n" +
" * \n" +
" * @author Peter Abeles\n" +
" */\n" +
"public class UnrolledDeterminantFromMinor {\n"+
" \n" +
" public static final int MAX = "+N+";\n";
stream.print(foo);
}
private void print2() {
stream.print(" public static double det2( RowD1Matrix64F mat )\n" +
" {\n" +
" return mat.get(0)*mat.get(3) - mat.get(1)*mat.get(2);\n" +
" }\n\n");
}
private void print3() {
stream.print(" public static double det3( RowD1Matrix64F mat )\n" +
" {\n" +
" double a11 = mat.get( 0 );\n" +
" double a12 = mat.get( 1 );\n" +
" double a13 = mat.get( 2 );\n" +
" double a21 = mat.get( 3 );\n" +
" double a22 = mat.get( 4 );\n" +
" double a23 = mat.get( 5 );\n" +
" double a31 = mat.get( 6 );\n" +
" double a32 = mat.get( 7 );\n" +
" double a33 = mat.get( 8 );\n" +
"\n" +
" double a = a11*(a22*a33 - a23*a32);\n" +
" double b = a12*(a21*a33 - a23*a31);\n" +
" double c = a13*(a21*a32 - a31*a22);\n" +
"\n" +
" return a-b+c;\n" +
" }\n" +
"\n");
}
private void printCalls( int N )
{
stream.print(
" \n" +
" public static double det( RowD1Matrix64F mat ) {\n");
stream.print(
" if( mat.numRows == 2 ) {\n" +
" return det2(mat);\n");
for( int i = 3; i <= N; i++ ) {
stream.print(" } else if( mat.numRows == "+i+" ) {\n" +
" return det"+i+"(mat); \n");
}
stream.print(" }\n" +
" \n" +
" throw new IllegalArgumentException(\"Not supported\");\n" +
" }\n\n");
}
protected String getInputValue( int element ) {
return "mat.get( "+element+" )";
}
private void printFunction( int N )
{
stream.print(" public static double det"+N+"( RowD1Matrix64F mat )\n" +
" {\n");
printFunctionInner(N);
stream.print(" return ret;\n");
stream.print(" }\n");
stream.print("\n");
}
public void printFunctionInner( int N ) {
// extracts the first minor
int M = N-1;
this.N = M;
int matrix[] = new int[M*M];
int index = 0;
for( int i = 1; i <= M; i++ ) {
int origIndex = i*N+1;
for( int j = 1; j <= M; j++ , origIndex++,index++) {
matrix[index] = index;
stream.print(" double "+a(index)+" = "+getInputValue(origIndex)+";\n");
}
}
stream.print("\n");
stream.print(" double ret = 0;\n");
stream.print(" ret += "+getInputValue(0)+" * (");
minor(matrix, 0, M);
stream.print(");\n");
for( int minor = 2; minor <= N; minor++ ) {
for( int i = 1; i <= M; i++ ) {
index = (minor-2)+(i-1)*M;
int origIndex = minor-2+i*N;
stream.print(" "+a(index)+" = "+getInputValue(origIndex)+";\n");
}
if( minor % 2 == 0 ) {
stream.print(" ret -= ");
} else {
stream.print(" ret += ");
}
stream.print(getInputValue(minor-1)+" * (");
minor(matrix,0,M);
stream.print(");\n");
}
}
private void minor( int m[] , int row , int N )
{
if( N == 2 ) {
stream.print(a(m[0])+"*"+a(m[3])+" - "+a(m[1])+"*"+a(m[2]));
} else {
int M = N-1;
int d[] = new int[ M*M ];
for( int i = 0; i < N; i++ ) {
int index = 0;
for( int j = 1; j < N; j++ ) {
for( int k = 0; k < N; k++ ) {
if( k != i ) {
d[index++] = m[j*N+k];
}
}
}
int pow = i;
if( pow % 2 == 0 )
stream.print(" + "+a(m[i])+"*(");
else
stream.print(" - "+a(m[i])+"*(");
minor(d,row+1,M);
stream.print(")");
}
}
}
private String a( int index )
{
int i = index/N+1;
int j = index%N+1;
return "a"+i+""+j;
}
public static void main( String args[] ) throws FileNotFoundException {
GenerateDeterminantFromMinor gen = new GenerateDeterminantFromMinor("UnrolledDeterminantFromMinor.java");
gen.createClass(6);
}
}
ejml-0.28/main/dense64/generate/org/ejml/alg/dense/misc/GenerateInverseFromMinor.java 0000664 0000000 0000000 00000016274 12561715344 0030476 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.alg.dense.misc;
import org.ejml.alg.generic.CodeGeneratorMisc;
import java.io.FileNotFoundException;
import java.io.PrintStream;
/**
* Generates unrolled matrix from minor analytical functions. these can run much faster than LU but will only
* work for small matrices.
*
* When computing the determinants for each minor there are some repeat calculations going on. I manually
* removed those by storing them in a local variable and only computing it once. Despite reducing the FLOP count
* it didn't seem to noticeably improve performance in a runtime benchmark..
*
* @author Peter Abeles
*/
public class GenerateInverseFromMinor {
String className = "UnrolledInverseFromMinor";
PrintStream stream;
int N;
public GenerateInverseFromMinor( boolean createStream ) throws FileNotFoundException {
if( createStream )
stream = new PrintStream(className +".java");
}
public void createClass(int N) {
printTop(N);
printCalls(N);
for( int i = 2; i <= N; i++ ) {
printFunction(i);
}
stream.print("}\n");
}
private void printTop(int N) {
String foo = CodeGeneratorMisc.COPYRIGHT +
"\n" +
"package org.ejml.alg.dense.misc;\n" +
"\n" +
"import org.ejml.data.DenseMatrix64F;\n" +
"\n" +
"\n" +
"/**\n" +
" * This code was auto generated by {@link GenerateInverseFromMinor} and should not be modified\n" +
" * directly. The input matrix is scaled make it much less prone to overflow and underflow issues.\n" +
" * \n" +
" * @author Peter Abeles\n" +
" */\n" +
"public class "+className+" {\n"+
" \n" +
" public static final int MAX = "+N+";\n";
stream.print(foo);
}
private void printCalls( int N )
{
stream.print(
" \n" +
" public static void inv( DenseMatrix64F mat , DenseMatrix64F inv ) {\n");
stream.print(" double max = Math.abs(mat.data[0]);\n" +
" int N = mat.getNumElements();\n" +
" \n" +
" for( int i = 1; i < N; i++ ) {\n" +
" double a = Math.abs(mat.data[i]);\n" +
" if( a > max ) max = a;\n" +
" }\n\n");
stream.print(
" if( mat.numRows == 2 ) {\n" +
" inv2(mat,inv,1.0/max);\n");
for( int i = 3; i <= N; i++ ) {
stream.print(" } else if( mat.numRows == "+i+" ) {\n" +
" inv"+i+"(mat,inv,1.0/max); \n");
}
stream.print(" } else {\n" +
" throw new IllegalArgumentException(\"Not supported\");\n" +
" }\n" +
" }\n\n");
}
private void printFunction( int N )
{
stream.print(" public static void inv"+N+"( DenseMatrix64F mat , DenseMatrix64F inv , double scale )\n" +
" {\n" +
" double []data = mat.data;\n"+
"\n");
this.N = N;
// extracts the first minor
int matrix[] = new int[N*N];
int index = 0;
for( int i = 1; i <= N; i++ ) {
for( int j = 1; j <= N; j++ , index++) {
matrix[index] = index;
stream.print(" double "+a(index)+" = "+"data[ "+index+" ]*scale;\n");
}
}
stream.println();
printMinors(matrix, N, stream);
stream.println();
stream.print(" data = inv.data;\n");
index = 0;
for( int i = 1; i <= N; i++ ) {
for( int j = 1; j <= N; j++ , index++) {
stream.print(" "+"data["+index+"] = m"+j+""+i+" / det;\n");
}
}
stream.println();
stream.print(" }\n");
stream.print("\n");
}
/**
* Put the core auto-code algorithm here so an external class can call it
*/
public void printMinors(int matrix[], int N, PrintStream stream) {
this.N = N;
this.stream = stream;
// compute all the minors
int index = 0;
for( int i = 1; i <= N; i++ ) {
for( int j = 1; j <= N; j++ , index++) {
stream.print(" double m"+i+""+j+" = ");
if( (i+j) % 2 == 1 )
stream.print("-( ");
printTopMinor(matrix,i-1,j-1,N);
if( (i+j) % 2 == 1 )
stream.print(")");
stream.print(";\n");
}
}
stream.println();
// compute the determinant
stream.print(" double det = (a11*m11");
for( int i = 2; i <= N; i++ ) {
stream.print(" + "+a(i-1)+"*m"+1+""+i);
}
stream.println(")/scale;");
}
private void printTopMinor( int m[] , int row , int col , int N )
{
int d[] = createMinor(m,row,col,N);
det(d,0,N-1);
}
private int[] createMinor( int m[] , int row , int col , int N )
{
int M = N-1;
int[] ret = new int[ M*M ];
int index = 0;
for( int i = 0; i < N; i++ ) {
if( i == row ) continue;
for( int j = 0; j < N; j++ ) {
if( j == col ) continue;
ret[index++] = m[i*N+j];
}
}
return ret;
}
private void det( int m[] , int row , int N )
{
if( N == 1 ) {
stream.print(a(m[0]));
} else if( N == 2 ) {
stream.print(a(m[0])+"*"+a(m[3])+" - "+a(m[1])+"*"+a(m[2]));
} else {
int M = N-1;
for( int i = 0; i < N; i++ ) {
int d[] = createMinor(m,0,i,N);
int pow = i;
if( pow % 2 == 0 )
stream.print(" + "+a(m[i])+"*(");
else
stream.print(" - "+a(m[i])+"*(");
det(d,row+1,M);
stream.print(")");
}
}
}
private String a( int index )
{
int i = index/N+1;
int j = index%N+1;
return "a"+i+""+j;
}
public static void main( String args[] ) throws FileNotFoundException {
GenerateInverseFromMinor gen = new GenerateInverseFromMinor(true);
gen.createClass(5);
}
} ejml-0.28/main/dense64/generate/org/ejml/alg/dense/mult/ 0000775 0000000 0000000 00000000000 12561715344 0022730 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/generate/org/ejml/alg/dense/mult/GeneratorMatrixMatrixMult.java 0000664 0000000 0000000 00000053526 12561715344 0030750 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.alg.dense.mult;
import org.ejml.alg.generic.CodeGeneratorMisc;
import java.io.FileNotFoundException;
import java.io.PrintStream;
/**
*
* This class generates code for various matrix matrix multiplication operations. The code associated
* with these operators is often only slightly different from each other. So to remove some
* of the tediousness of writing and maintaining it is autogenerated.
*
*
* To create {@link MatrixMatrixMult} simply run this application and copy it to the appropriate location.
*
*
* @author Peter Abeles
*/
public class GeneratorMatrixMatrixMult {
PrintStream stream;
public GeneratorMatrixMatrixMult( String fileName ) throws FileNotFoundException {
stream = new PrintStream(fileName);
}
public void createClass() {
String preamble = CodeGeneratorMisc.COPYRIGHT +
"\n" +
"package org.ejml.alg.dense.mult;\n" +
"\n" +
"import org.ejml.data.RowD1Matrix64F;\n"+
"import org.ejml.ops.CommonOps;\n" +
"\n" +
"/**\n" +
" * \n" +
" * This class contains various types of matrix matrix multiplication operations for {@link RowD1Matrix64F}.\n" +
" *
\n" +
" * \n" +
" * Two algorithms that are equivalent can often have very different runtime performance.\n" +
" * This is because of how modern computers uses fast memory caches to speed up reading/writing to data.\n" +
" * Depending on the order in which variables are processed different algorithms can run much faster than others,\n" +
" * even if the number of operations is the same.\n" +
" *
\n" +
" *\n" +
" * \n" +
" * Algorithms that are labeled as 'reorder' are designed to avoid caching jumping issues, some times at the cost\n" +
" * of increasing the number of operations. This is important for large matrices. The straight forward \n" +
" * implementation seems to be faster for small matrices.\n" +
" *
\n" +
" * \n" +
" * \n" +
" * Algorithms that are labeled as 'aux' use an auxiliary array of length n. This array is used to create\n" +
" * a copy of an out of sequence column vector that is referenced several times. This reduces the number\n" +
" * of cache misses. If the 'aux' parameter passed in is null then the array is declared internally.\n" +
" *
\n" +
" *\n" +
" * \n" +
" * Typically the straight forward implementation runs about 30% faster on smaller matrices and\n" +
" * about 5 times slower on larger matrices. This is all computer architecture and matrix shape/size specific.\n" +
" *
\n" +
" * \n" +
" * \n" +
" *
******** IMPORTANT **********\n" +
" * This class was auto generated using {@link "+getClass().getName()+"}\n" +
" * \n" +
" * \n" +
" * @author Peter Abeles\n" +
" */\n"+
"public class MatrixMatrixMult {\n";
stream.print(preamble);
for( int i = 0; i < 2; i++ ) {
boolean alpha = i == 1;
for( int j = 0; j < 2; j++ ) {
boolean add = j == 1;
printMult_reroder(alpha,add);
stream.print("\n");
printMult_small(alpha,add);
stream.print("\n");
printMult_aux(alpha,add);
stream.print("\n");
printMultTransA_reorder(alpha,add);
stream.print("\n");
printMultTransA_small(alpha,add);
stream.print("\n");
printMultTransAB(alpha,add);
stream.print("\n");
printMultTransAB_aux(alpha,add);
stream.print("\n");
printMultTransB(alpha,add);
stream.print("\n");
}
}
stream.print("}\n");
}
private String makeBoundsCheck(boolean tranA, boolean tranB, String auxLength)
{
String a_numCols = tranA ? "a.numRows" : "a.numCols";
String a_numRows = tranA ? "a.numCols" : "a.numRows";
String b_numCols = tranB ? "b.numRows" : "b.numCols";
String b_numRows = tranB ? "b.numCols" : "b.numRows";
String ret =
" if( a == c || b == c )\n" +
" throw new IllegalArgumentException(\"Neither 'a' or 'b' can be the same matrix as 'c'\");\n"+
" else if( "+a_numCols+" != "+b_numRows+" ) {\n" +
" throw new MatrixDimensionException(\"The 'a' and 'b' matrices do not have compatible dimensions\");\n" +
" } else if( "+a_numRows+" != c.numRows || "+b_numCols+" != c.numCols ) {\n" +
" throw new MatrixDimensionException(\"The results matrix does not have the desired dimensions\");\n" +
" }\n" +
"\n";
if( auxLength != null ) {
ret += " if( aux == null ) aux = new double[ "+auxLength+" ];\n\n";
}
return ret;
}
private String handleZeros( boolean add ) {
String fill = add ? "" : " CommonOps.fill(c,0);\n";
String ret =
" if( a.numCols == 0 || a.numRows == 0 ) {\n" +
fill +
" return;\n" +
" }\n";
return ret;
}
private String makeComment( String nameOp , boolean hasAlpha )
{
String a = hasAlpha ? "double, " : "";
String inputs = "("+a+" org.ejml.data.RowD1Matrix64F, org.ejml.data.RowD1Matrix64F, org.ejml.data.RowD1Matrix64F)";
String ret =
" /**\n" +
" * @see org.ejml.ops.CommonOps#"+nameOp+inputs+"\n" +
" */\n";
return ret;
}
private String makeHeader(String nameOp, String variant,
boolean add, boolean hasAlpha, boolean hasAux,
boolean tranA, boolean tranB)
{
if( add ) nameOp += "Add";
// make the op name
if( tranA && tranB ) {
nameOp += "TransAB";
} else if( tranA ) {
nameOp += "TransA";
} else if( tranB ) {
nameOp += "TransB";
}
String ret = makeComment(nameOp,hasAlpha)+
" public static void "+nameOp;
if( variant != null ) ret += "_"+variant+"( ";
else ret += "( ";
if( hasAlpha ) ret += "double alpha , ";
if( hasAux ) {
ret += "RowD1Matrix64F a , RowD1Matrix64F b , RowD1Matrix64F c , double []aux )\n";
} else {
ret += "RowD1Matrix64F a , RowD1Matrix64F b , RowD1Matrix64F c )\n";
}
ret += " {\n";
return ret;
}
public void printMult_reroder( boolean alpha , boolean add ) {
String header,valLine;
header = makeHeader("mult","reorder",add,alpha, false, false,false);
if( alpha ) {
valLine = "valA = alpha*a.get(indexA++);\n";
} else {
valLine = "valA = a.get(indexA++);\n";
}
String assignment = add ? "plus" : "set";
String foo =
header + makeBoundsCheck(false,false, null)+handleZeros(add) +
" double valA;\n"+
" int indexCbase= 0;\n" +
" int endOfKLoop = b.numRows*b.numCols;\n"+
"\n" +
" for( int i = 0; i < a.numRows; i++ ) {\n" +
" int indexA = i*a.numCols;\n" +
"\n"+
" // need to assign c.data to a value initially\n" +
" int indexB = 0;\n" +
" int indexC = indexCbase;\n" +
" int end = indexB + b.numCols;\n" +
"\n" +
" "+valLine +
"\n" +
" while( indexB < end ) {\n" +
" c."+assignment+"(indexC++ , valA*b.get(indexB++));\n" +
" }\n" +
"\n" +
" // now add to it\n"+
" while( indexB != endOfKLoop ) { // k loop\n"+
" indexC = indexCbase;\n" +
" end = indexB + b.numCols;\n" +
"\n" +
" "+valLine+
"\n" +
" while( indexB < end ) { // j loop\n" +
" c.plus(indexC++ , valA*b.get(indexB++));\n" +
" }\n" +
" }\n" +
" indexCbase += c.numCols;\n" +
" }\n" +
" }\n";
stream.print(foo);
}
public void printMult_small( boolean alpha , boolean add ) {
String header,valLine;
header = makeHeader("mult","small",add,alpha, false, false,false);
String assignment = add ? "plus" : "set";
if( alpha ) {
valLine = " c."+assignment+"( cIndex++ , alpha*total );\n";
} else {
valLine = " c."+assignment+"( cIndex++ , total );\n";
}
String foo =
header + makeBoundsCheck(false,false, null)+
" int aIndexStart = 0;\n" +
" int cIndex = 0;\n" +
"\n" +
" for( int i = 0; i < a.numRows; i++ ) {\n" +
" for( int j = 0; j < b.numCols; j++ ) {\n" +
" double total = 0;\n" +
"\n" +
" int indexA = aIndexStart;\n" +
" int indexB = j;\n" +
" int end = indexA + b.numRows;\n" +
" while( indexA < end ) {\n" +
" total += a.get(indexA++) * b.get(indexB);\n" +
" indexB += b.numCols;\n" +
" }\n" +
"\n" +
valLine +
" }\n" +
" aIndexStart += a.numCols;\n" +
" }\n" +
" }\n";
stream.print(foo);
}
public void printMult_aux( boolean alpha , boolean add ) {
String header,valLine;
header = makeHeader("mult","aux",add,alpha, true, false,false);
String assignment = add ? "plus" : "set";
if( alpha ) {
valLine = " c."+assignment+"( i*c.numCols+j , alpha*total );\n";
} else {
valLine = " c."+assignment+"( i*c.numCols+j , total );\n";
}
String foo =
header + makeBoundsCheck(false,false, "b.numRows")+
" for( int j = 0; j < b.numCols; j++ ) {\n" +
" // create a copy of the column in B to avoid cache issues\n" +
" for( int k = 0; k < b.numRows; k++ ) {\n" +
" aux[k] = b.unsafe_get(k,j);\n" +
" }\n" +
"\n" +
" int indexA = 0;\n" +
" for( int i = 0; i < a.numRows; i++ ) {\n" +
" double total = 0;\n" +
" for( int k = 0; k < b.numRows; ) {\n" +
" total += a.get(indexA++)*aux[k++];\n" +
" }\n" +
valLine +
" }\n" +
" }\n" +
" }\n";
stream.print(foo);
}
public void printMultTransA_reorder( boolean alpha , boolean add ) {
String header,valLine1,valLine2;
header = makeHeader("mult","reorder",add,alpha, false, true,false);
String assignment = add ? "plus" : "set";
if( alpha ) {
valLine1 = "valA = alpha*a.get(i);\n";
valLine2 = "valA = alpha*a.unsafe_get(k,i);\n";
} else {
valLine1 = "valA = a.get(i);\n";
valLine2 = "valA = a.unsafe_get(k,i);\n";
}
String foo =
header + makeBoundsCheck(true,false, null)+handleZeros(add)+
" double valA;\n" +
"\n" +
" for( int i = 0; i < a.numCols; i++ ) {\n" +
" int indexC_start = i*c.numCols;\n" +
"\n" +
" // first assign R\n" +
" " +valLine1+
" int indexB = 0;\n" +
" int end = indexB+b.numCols;\n" +
" int indexC = indexC_start;\n" +
" while( indexBCommon matrix operations for fixed sized matrices which are "+dimen+" x "+dimen+" or "+dimen+" element vectors.\n" +
" * DO NOT MODIFY. Automatically generated code created by "+getClass().getSimpleName()+"
\n" +
" *\n" +
" * @author Peter Abeles\n" +
" */\n" +
"public class "+className+" {\n");
}
private void add(int dimen){
out.print(" /**\n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * c = a + b
\n" +
" * cij = aij + bij
\n" +
" *
\n" +
" *\n" +
" * \n" +
" * Matrix C can be the same instance as Matrix A and/or B.\n" +
" *
\n" +
" *\n" +
" * @param a A Matrix. Not modified.\n" +
" * @param b A Matrix. Not modified.\n" +
" * @param c A Matrix where the results are stored. Modified.\n" +
" */\n" +
" public static void add( " + nameMatrix + " a , " + nameMatrix + " b , " + nameMatrix + " c ) {\n");
for( int y = 1; y <= dimen; y++ ) {
for( int x = 1; x <= dimen; x++ ) {
String n = y+""+x;
out.print(" c.a"+n+" = a.a"+n+" + b.a"+n+";\n");
}
}
out.print(" }\n\n");
}
private void vector_add( int dimen ) {
out.print(" /**\n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * c = a + b
\n" +
" * ci = ai + bi
\n" +
" *
\n" +
" *\n" +
" * \n" +
" * Vector C can be the same instance as Vector A and/or B.\n" +
" *
\n" +
" *\n" +
" * @param a A Vector. Not modified.\n" +
" * @param b A Vector. Not modified.\n" +
" * @param c A Vector where the results are stored. Modified.\n" +
" */\n" +
" public static void add( " + nameVector + " a , " + nameVector + " b , " + nameVector + " c ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" c.a"+y+" = a.a"+y+" + b.a"+y+";\n");
}
out.print(" }\n\n");
}
private void addEquals( int dimen ){
out.print(" /**\n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * a = a + b
\n" +
" * aij = aij + bij
\n" +
" *
\n" +
" *\n" +
" * @param a A Matrix. Modified.\n" +
" * @param b A Matrix. Not modified.\n" +
" */\n" +
" public static void addEquals( " + nameMatrix + " a , " + nameMatrix + " b ) {\n");
for( int y = 1; y <= dimen; y++ ) {
for( int x = 1; x <= dimen; x++ ) {
String n = y+""+x;
out.print(" a.a"+n+" += b.a"+n+";\n");
}
}
out.print(" }\n\n");
}
private void vector_addEquals( int dimen ) {
out.print(" /**\n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * a = a + b
\n" +
" * ai = ai + bi
\n" +
" *
\n" +
" *\n" +
" * @param a A Vector. Modified.\n" +
" * @param b A Vector. Not modified.\n" +
" */\n" +
" public static void addEquals( " + nameVector + " a , " + nameVector + " b ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" a.a"+y+" += b.a"+y+";\n");
}
out.print(" }\n\n");
}
private void subtract(int dimen){
out.print(" /**\n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * c = a - b
\n" +
" * cij = aij - bij
\n" +
" *
\n" +
" *\n" +
" * \n" +
" * Matrix C can be the same instance as Matrix A and/or B.\n" +
" *
\n" +
" *\n" +
" * @param a A Matrix. Not modified.\n" +
" * @param b A Matrix. Not modified.\n" +
" * @param c A Matrix where the results are stored. Modified.\n" +
" */\n" +
" public static void subtract( " + nameMatrix + " a , " + nameMatrix + " b , " + nameMatrix + " c ) {\n");
for( int y = 1; y <= dimen; y++ ) {
for( int x = 1; x <= dimen; x++ ) {
String n = y+""+x;
out.print(" c.a"+n+" = a.a"+n+" - b.a"+n+";\n");
}
}
out.print(" }\n\n");
}
private void vector_subtract( int dimen ) {
out.print(" /**\n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * c = a - b
\n" +
" * ci = ai - bi
\n" +
" *
\n" +
" *\n" +
" * \n" +
" * Vector C can be the same instance as Vector A and/or B.\n" +
" *
\n" +
" *\n" +
" * @param a A Vector. Not modified.\n" +
" * @param b A Vector. Not modified.\n" +
" * @param c A Vector where the results are stored. Modified.\n" +
" */\n" +
" public static void subtract( "+nameVector+" a , "+nameVector+" b , "+nameVector+" c ) {\n");
for( int y = 1; y <= dimen; y++) {
out.print(" c.a" + y + " = a.a" + y + " - b.a" + y + ";\n");
}
out.print(" }\n\n");
}
private void subtractEquals(int dimen) {
out.print(" /**\n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * a = a - b
\n" +
" * aij = aij - bij
\n" +
" *
\n" +
" *\n" +
" * @param a A Matrix. Modified.\n" +
" * @param b A Matrix. Not modified.\n" +
" */\n" +
" public static void subtractEquals( "+nameMatrix+" a , "+nameMatrix+" b ) {\n");
for( int y = 1; y <= dimen; y++ ) {
for (int x = 1; x <= dimen; x++) {
String n = y + "" + x;
out.print(" a.a" + n + " -= b.a" + n + ";\n");
}
}
out.print(" }\n\n");
}
private void vector_subtractEquals( int dimen ) {
out.print(" /**\n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * a = a - b
\n" +
" * ai = ai - bi
\n" +
" *
\n" +
" *\n" +
" * @param a A Vector. Modified.\n" +
" * @param b A Vector. Not modified.\n" +
" */\n" +
" public static void subtractEquals( "+nameVector+" a , "+nameVector+" b ) {\n");
for( int y = 1; y <= dimen; y++ ) {
String n = ""+y;
out.print(" a.a"+n+" -= b.a"+n+";\n");
}
out.print(" }\n\n");
}
private void transpose_one( int dimen ){
out.print(" /**\n" +
" * Performs an in-place transpose. This algorithm is only efficient for square\n" +
" * matrices.\n" +
" *\n" +
" * @param m The matrix that is to be transposed. Modified.\n" +
" */\n" +
" public static void transpose( " + nameMatrix + " m ) {\n" +
" double tmp;\n");
for (int y = 1; y <= dimen; y++) {
for (int x = y + 1; x <= dimen; x++) {
String f = +y + "" + x;
String t = +x + "" + y;
out.print(" tmp = m.a"+f+"; m.a"+f+" = m.a"+t+"; m.a"+t+" = tmp;\n");
}
}
out.print(" }\n\n");
}
private void transpose_two( int dimen ){
out.print(" /**\n" +
" * \n" +
" * Transposes matrix 'a' and stores the results in 'b':
\n" +
" *
\n" +
" * bij = aji
\n" +
" * where 'b' is the transpose of 'a'.\n" +
" *
\n" +
" *\n" +
" * @param input The original matrix. Not modified.\n" +
" * @param output Where the transpose is stored. If null a new matrix is created. Modified.\n" +
" * @return The transposed matrix.\n" +
" */\n" +
" public static " + nameMatrix + " transpose( " + nameMatrix + " input , " + nameMatrix + " output ) {\n" +
" if( input == null )\n" +
" input = new " + nameMatrix + "();\n\n");
for (int y = 1; y <= dimen; y++) {
for (int x = 1; x <= dimen; x++) {
String f = +y + "" + x;
String t = +x+""+y;
out.print(" output.a"+f+" = input.a"+t+";\n");
}
}
out.print("\n return output;\n" +
" }\n\n");
}
private void mult( int dimen , boolean add ){
String plus = add ? "+" : "";
String name = add ? "multAdd" : "mult";
out.print(" /**\n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * c "+plus+"= a * b
\n" +
" *
\n" +
" * cij "+plus+"= ∑k=1:n { aik * bkj}\n" +
" *
\n" +
" *\n" +
" * @param a The left matrix in the multiplication operation. Not modified.\n" +
" * @param b The right matrix in the multiplication operation. Not modified.\n" +
" * @param c Where the results of the operation are stored. Modified.\n" +
" */\n" +
" public static void "+name+"( "+nameMatrix+" a , "+nameMatrix+" b , "+nameMatrix+" c) {\n");
for( int y = 1; y <= dimen; y++ ) {
for( int x = 1; x <= dimen; x++ ) {
out.print(" c.a"+y+""+x+" "+plus+"= ");
for( int k = 1; k <= dimen; k++ ) {
out.print("a.a"+y+""+k+"*b.a"+k+""+x);
if( k < dimen )
out.print(" + ");
else
out.print(";\n");
}
}
}
out.print(" }\n\n");
}
private void multTransA( int dimen , boolean add ){
String plus = add ? "+" : "";
String name = add ? "multAddTransA" : "multTransA";
out.print(" /**\n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * c " + plus + "= aT * b
\n" +
" *
\n" +
" * cij " + plus + "= ∑k=1:n { aki * bkj}\n" +
" *
\n" +
" *\n" +
" * @param a The left matrix in the multiplication operation. Not modified.\n" +
" * @param b The right matrix in the multiplication operation. Not modified.\n" +
" * @param c Where the results of the operation are stored. Modified.\n" +
" */\n" +
" public static void " + name + "( " + nameMatrix + " a , " + nameMatrix + " b , " + nameMatrix + " c) {\n");
for (int y = 1; y <= dimen; y++) {
for (int x = 1; x <= dimen; x++) {
out.print(" c.a" + y + "" + x + " " + plus + "= ");
for (int k = 1; k <= dimen; k++) {
out.print("a.a" + k + "" + y + "*b.a" + k + "" + x);
if (k < dimen)
out.print(" + ");
else
out.print(";\n");
}
}
}
out.printf(" }\n\n");
}
private void multTransAB( int dimen , boolean add ){
String plus = add ? "+" : "";
String name = add ? "multAddTransAB" : "multTransAB";
out.printf(" /**\n" +
" * \n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * c " + plus + "= aT * bT
\n" +
" * cij " + plus + "= ∑k=1:n { aki * bjk}\n" +
" *
\n" +
" *\n" +
" * @param a The left matrix in the multiplication operation. Not modified.\n" +
" * @param b The right matrix in the multiplication operation. Not modified.\n" +
" * @param c Where the results of the operation are stored. Modified.\n" +
" */\n" +
" public static void " + name + "( " + nameMatrix + " a , " + nameMatrix + " b , " + nameMatrix + " c) {\n");
for (int y = 1; y <= dimen; y++) {
for (int x = 1; x <= dimen; x++) {
out.print(" c.a" + y + "" + x + " " + plus + "= ");
for (int k = 1; k <= dimen; k++) {
out.print("a.a" + k + "" + y + "*b.a" + x + "" + k);
if (k < dimen)
out.print(" + ");
else
out.print(";\n");
}
}
}
out.print(" }\n\n");
}
private void multTransB( int dimen , boolean add ){
String plus = add ? "+" : "";
String name = add ? "multAddTransB" : "multTransB";
out.print(" /**\n" +
" * \n" +
" * Performs the following operation:
\n" +
" *
\n" +
" * c "+plus+"= a * bT
\n" +
" * cij "+plus+"= ∑k=1:n { aik * bjk}\n" +
" *
\n" +
" *\n" +
" * @param a The left matrix in the multiplication operation. Not modified.\n" +
" * @param b The right matrix in the multiplication operation. Not modified.\n" +
" * @param c Where the results of the operation are stored. Modified.\n" +
" */\n" +
" public static void " + name + "( " + nameMatrix + " a , " + nameMatrix + " b , " + nameMatrix + " c) {\n");
for (int y = 1; y <= dimen; y++) {
for (int x = 1; x <= dimen; x++) {
out.print(" c.a" + y + "" + x + " " + plus + "= ");
for (int k = 1; k <= dimen; k++) {
out.print("a.a" + y + "" + k + "*b.a" + x + "" + k);
if (k < dimen )
out.print(" + ");
else
out.print(";\n");
}
}
}
out.print(" }\n\n");
}
private void mult_m_v_v( int dimen ){
out.print(" /**\n" +
" * Performs matrix to vector multiplication:
\n" +
" *
\n" +
" * c = a * b
\n" +
" *
\n" +
" * ci = ∑k=1:n { aik * bk}\n" +
" *
\n" +
" *\n" +
" * @param a The left matrix in the multiplication operation. Not modified.\n" +
" * @param b The right vector in the multiplication operation. Not modified.\n" +
" * @param c Where the results of the operation are stored. Modified.\n" +
" */\n" +
" public static void mult( " + nameMatrix + " a , " + nameVector + " b , " + nameVector + " c) {\n");
for (int y = 1; y <= dimen; y++) {
out.print(" c.a" + y + " = ");
for (int x = 1; x <= dimen; x++) {
out.print("a.a" + y + "" + x + "*b.a"+x);
if( x < dimen )
out.print(" + ");
else
out.print(";\n");
}
}
out.printf(" }\n\n");
}
private void mult_v_m_v( int dimen ){
out.print(" /**\n" +
" * Performs vector to matrix multiplication:
\n" +
" *
\n" +
" * c = a * b
\n" +
" *
\n" +
" * cj = ∑k=1:n { bk * akj }\n" +
" *
\n" +
" *\n" +
" * @param a The left vector in the multiplication operation. Not modified.\n" +
" * @param b The right matrix in the multiplication operation. Not modified.\n" +
" * @param c Where the results of the operation are stored. Modified.\n" +
" */\n" +
" public static void mult( "+nameVector+" a , "+nameMatrix+" b , "+nameVector+" c) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" c.a"+y+" = ");
for( int x = 1; x <= dimen; x++ ) {
out.print("a.a"+x+"*b.a"+x+""+y);
if( x < dimen )
out.print(" + ");
else
out.print(";\n");
}
}
out.print(" }\n\n");
}
private void dot( int dimen ){
out.print(" /**\n" +
" * Performs the vector dot product:
\n" +
" *
\n" +
" * c = a * b
\n" +
" *
\n" +
" * c> = ∑k=1:n { bk * ak }\n" +
" *
\n" +
" *\n" +
" * @param a The left vector in the multiplication operation. Not modified.\n" +
" * @param b The right matrix in the multiplication operation. Not modified.\n" +
" * @return The dot product\n" +
" */\n" +
" public static double dot( "+nameVector+" a , "+nameVector+" b ) {\n");
out.print(" return ");
for( int i = 1; i <= dimen; i++) {
out.print("a.a"+i+"*b.a"+i);
if( i < dimen )
out.print(" + ");
else
out.print(";\n");
}
out.print(" }\n\n");
}
private void setIdentity( int dimen ){
out.print(" /**\n" +
" * Sets all the diagonal elements equal to one and everything else equal to zero.\n" +
" * If this is a square matrix then it will be an identity matrix.\n" +
" *\n" +
" * @param a A matrix.\n" +
" */\n" +
" public static void setIdentity( "+nameMatrix+" a ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
int val = x==y?1:0;
out.print("a.a"+x+""+y+" = "+val+";");
if( x < dimen )
out.print(" ");
else
out.print("\n");
}
}
out.print(" }\n\n");
}
private void invert( int dimen ){
out.print(" /**\n" +
" * Inverts matrix 'a' using minor matrices and stores the results in 'inv'. Scaling is applied to improve\n" +
" * stability against overflow and underflow.\n" +
" *\n" +
" * WARNING: Potentially less stable than using LU decomposition.\n" +
" *\n" +
" * @param a Input matrix. Not modified.\n" +
" * @param inv Inverted output matrix. Modified.\n" +
" * @return true if it was successful or false if it failed. Not always reliable.\n" +
" */\n" +
" public static boolean invert( "+nameMatrix+" a , "+nameMatrix+" inv ) {\n" +
"\n" +
" double scale = 1.0/elementMaxAbs(a);\n" +
"\n");
int matrix[] = new int[dimen*dimen];
int index = 0;
for (int y = 1; y <= dimen; y++) {
for (int x = 1; x <= dimen; x++, index++) {
matrix[index] = index;
String coor = y + "" + x;
out.print(" double a" + coor + " = a.a" + coor + "*scale;\n");
}
}
out.println();
try {
GenerateInverseFromMinor gen = new GenerateInverseFromMinor(false);
gen.printMinors(matrix, dimen, out);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
out.println();
for (int y = 1; y <= dimen; y++) {
for( int x = 1; x <= dimen; x++ ) {
String coor0 = y+""+x;
String coor1 = x+""+y;
out.print(" inv.a"+coor0+" = m"+coor1+"/det;\n");
}
}
out.println();
out.print(" return !Double.isNaN(det) && !Double.isInfinite(det);\n");
out.print(" }\n\n");
}
private void trace(int dimen) {
out.print(" /**\n" +
" * \n" +
" * This computes the trace of the matrix:
\n" +
" *
\n" +
" * trace = ∑i=1:n { aii }\n" +
" *
\n" +
" * \n" +
" * The trace is only defined for square matrices.\n" +
" *
\n" +
" *\n" +
" * @param a A square matrix. Not modified.\n" +
" */\n" +
" public static double trace( "+nameMatrix+" a ) {\n");
out.print(" return ");
for( int i = 1; i <= dimen; i++ ) {
out.print("a.a"+i+""+1);
if( i < dimen )
out.print(" + ");
else
out.println(";");
}
out.print(" }\n\n");
}
private void det( int dimen ){
out.print(" /**\n" +
" * Computes the determinant using minor matrices.\n" +
" * \n" +
" * WARNING: Potentially less stable than using LU decomposition.\n" +
" *\n" +
" * @param mat Input matrix. Not modified.\n" +
" * @return The determinant.\n" +
" */\n" +
" public static double det( "+nameMatrix+" mat ) {\n" +
"\n");
if( dimen == 2 ) {
out.print(" return mat.a11*mat.a22 - mat.a12*mat.a21;\n");
} else if( dimen == 3 ) {
out.print( " double a = mat.a11*(mat.a22*mat.a33 - mat.a23*mat.a32);\n" +
" double b = mat.a12*(mat.a21*mat.a33 - mat.a23*mat.a31);\n" +
" double c = mat.a13*(mat.a21*mat.a32 - mat.a31*mat.a22);\n" +
"\n" +
" return a-b+c;\n");
} else {
GenerateDeterminantFromMinor helper = new GenerateDeterminantFromMinor(out) {
@Override
protected String getInputValue(int element) {
int row = element/(N+1) + 1;
int col = element%(N+1) + 1;
return "mat.a"+row+""+col;
}
};
helper.printFunctionInner(dimen);
out.print("\n return ret;\n");
}
out.print(" }\n\n");
}
private void diag( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Extracts all diagonal elements from 'input' and places them inside the 'out' vector. Elements\n" +
" * are in sequential order.\n" +
" *
\n" +
" *\n" +
" *\n" +
" * @param input Matrix. Not modified.\n" +
" * @param out Vector containing diagonal elements. Modified.\n" +
" */\n" +
" public static void diag( "+nameMatrix+" input , "+nameVector+" out ) {\n");
for( int i = 1; i <= dimen; i++ ) {
out.print(" out.a" + i + " = input.a" + i + "" + i + ";\n");
}
out.print(" }\n\n");
}
private void elementMax( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Returns the value of the element in the matrix that has the largest value.
\n" +
" *
\n" +
" * Max{ aij } for all i and j
\n" +
" *
\n" +
" *\n" +
" * @param a A matrix. Not modified.\n" +
" * @return The max element value of the matrix.\n" +
" */\n" +
" public static double elementMax( "+nameMatrix+" a ) {\n");
out.print(" double max = a.a11;\n");
for( int y = 1; y <= dimen; y++ ) {
for( int x = 1; x <= dimen; x++ ) {
if( y == 1 && x == 1 )
continue;
out.print(" max = Math.max(max,a.a"+y+""+x+");\n");
}
}
out.print("\n" +
" return max;\n" +
" }\n\n");
}
private void elementMax_vector( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Returns the value of the element in the vector that has the largest value.
\n" +
" *
\n" +
" * Max{ ai } for all i
\n" +
" *
\n" +
" *\n" +
" * @param a A vector. Not modified.\n" +
" * @return The max element value of the matrix.\n" +
" */\n" +
" public static double elementMax( "+nameVector+" a ) {\n");
out.print(" double max = a.a1;\n");
for( int y = 2; y <= dimen; y++ ) {
out.print(" max = Math.max(max,a.a"+y+");\n");
}
out.print("\n" +
" return max;\n" +
" }\n\n");
}
private void elementMaxAbs( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Returns the absolute value of the element in the matrix that has the largest absolute value.
\n" +
" *
\n" +
" * Max{ |aij| } for all i and j
\n" +
" *
\n" +
" *\n" +
" * @param a A matrix. Not modified.\n" +
" * @return The max abs element value of the matrix.\n" +
" */\n" +
" public static double elementMaxAbs( "+nameMatrix+" a ) {\n");
out.print(" double max = a.a11;\n");
for (int y = 1; y <= dimen; y++ ) {
for( int x = 1; x <= dimen; x++ ) {
if( y == 1 && x == 1 )
continue;
out.print(" max = Math.max(max,Math.abs(a.a" + y + "" + x + "));\n");
}
}
out.print("\n" +
" return max;\n" +
" }\n\n");
}
private void elementMaxAbs_vector( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Returns the absolute value of the element in the vector that has the largest absolute value.
\n" +
" *
\n" +
" * Max{ |ai| } for all i
\n" +
" *
\n" +
" *\n" +
" * @param a A matrix. Not modified.\n" +
" * @return The max abs element value of the vector.\n" +
" */\n" +
" public static double elementMaxAbs( "+nameVector+" a ) {\n");
out.print(" double max = a.a1;\n");
for( int y = 2; y <= dimen; y++ ) {
out.print(" max = Math.max(max,Math.abs(a.a"+y+"));\n");
}
out.print("\n" +
" return max;\n" +
" }\n\n");
}
private void elementMin( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Returns the value of the element in the matrix that has the minimum value.
\n" +
" *
\n" +
" * Min{ aij } for all i and j
\n" +
" *
\n" +
" *\n" +
" * @param a A matrix. Not modified.\n" +
" * @return The value of element in the matrix with the minimum value.\n" +
" */\n" +
" public static double elementMin( "+nameMatrix+" a ) {\n");
out.print(" double min = a.a11;\n");
for( int y = 1; y <= dimen; y++ ) {
for( int x = 1; x <= dimen; x++ ) {
if( y == 1 && x == 1 )
continue;
out.print(" min = Math.min(min, a.a"+y+""+x+");\n");
}
}
out.print("\n" +
" return min;\n" +
" }\n\n");
}
private void elementMin_vector( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Returns the value of the element in the vector that has the minimum value.
\n" +
" *
\n" +
" * Min{ ai } for all
\n" +
" *
\n" +
" *\n" +
" * @param a A matrix. Not modified.\n" +
" * @return The value of element in the vector with the minimum value.\n" +
" */\n" +
" public static double elementMin( "+nameVector+" a ) {\n");
out.print(" double min = a.a1;\n");
for( int y = 2; y <= dimen; y++ ) {
out.print(" min = Math.min(min, a.a"+y+");\n");
}
out.print("\n" +
" return min;\n" +
" }\n\n");
}
private void elementMinAbs( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Returns the absolute value of the element in the matrix that has the smallest absolute value.
\n" +
" *
\n" +
" * Min{ |aij| } for all i and j
\n" +
" *
\n" +
" *\n" +
" * @param a A matrix. Not modified.\n" +
" * @return The max element value of the matrix.\n" +
" */\n" +
" public static double elementMinAbs( "+nameMatrix+" a ) {\n");
out.print(" double min = a.a11;\n");
for (int y = 1; y <= dimen; y++ ) {
for( int x = 1; x <= dimen; x++ ) {
if( y == 1 && x == 1 )
continue;
out.print(" min = Math.min(min,Math.abs(a.a"+y+""+x+"));\n");
}
}
out.print("\n" +
" return min;\n" +
" }\n\n");
}
private void elementMinAbs_vector(int dimen) {
out.print(" /**\n" +
" * \n" +
" * Returns the absolute value of the element in the vector that has the smallest absolute value.
\n" +
" *
\n" +
" * Min{ |ai| } for all i
\n" +
" *
\n" +
" *\n" +
" * @param a A matrix. Not modified.\n" +
" * @return The max element value of the vector.\n" +
" */\n" +
" public static double elementMinAbs( "+nameVector+" a ) {\n");
out.print(" double min = a.a1;\n");
for( int y = 2; y <= dimen; y++ ) {
out.print(" min = Math.min(min,Math.abs(a.a"+y+"));\n");
}
out.print("\n" +
" return min;\n" +
" }\n\n");
}
private void elementMult_two( int dimen ) {
out.print(" /**\n" +
" * Performs an element by element multiplication operation:
\n" +
" *
\n" +
" * aij = aij * bij
\n" +
" *
\n" +
" * @param a The left matrix in the multiplication operation. Modified.\n" +
" * @param b The right matrix in the multiplication operation. Not modified.\n" +
" */\n" +
" public static void elementMult( " + nameMatrix + " a , " + nameMatrix + " b) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
String w = "a"+y+""+x;
out.print("a."+w+" *= b."+w+ ";");
if (x < dimen)
out.print(" ");
else
out.println();
}
}
out.print(" }\n\n");
}
private void elementMult_vector_two(int dimen) {
out.print(" /**\n" +
" * Performs an element by element multiplication operation:
\n" +
" *
\n" +
" * ai = ai * bi
\n" +
" *
\n" +
" * @param a The left vector in the multiplication operation. Modified.\n" +
" * @param b The right vector in the multiplication operation. Not modified.\n" +
" */\n" +
" public static void elementMult( "+nameVector+" a , "+nameVector+" b) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" a.a"+y+" *= b.a"+y+";\n");
}
out.print(" }\n\n");
}
private void elementMult_three( int dimen ) {
out.print(" /**\n" +
" * Performs an element by element multiplication operation:
\n" +
" *
\n" +
" * cij = aij * bij
\n" +
" *
\n" +
" * @param a The left matrix in the multiplication operation. Not modified.\n" +
" * @param b The right matrix in the multiplication operation. Not modified.\n" +
" * @param c Where the results of the operation are stored. Modified.\n" +
" */\n" +
" public static void elementMult( "+nameMatrix+" a , "+nameMatrix+" b , "+nameMatrix+" c ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
String w = "a"+y+""+x;
out.print("c."+w+" = a."+w+"*b."+w+";");
if( x < dimen )
out.print(" ");
else
out.println();
}
}
out.print(" }\n\n");
}
private void elementMult_vector_three( int dimen ) {
out.print(" /**\n" +
" * Performs an element by element multiplication operation:
\n" +
" *
\n" +
" * ci = ai * bj
\n" +
" *
\n" +
" * @param a The left vector in the multiplication operation. Not modified.\n" +
" * @param b The right vector in the multiplication operation. Not modified.\n" +
" * @param c Where the results of the operation are stored. Modified.\n" +
" */\n" +
" public static void elementMult( "+nameVector+" a , "+nameVector+" b , "+nameVector+" c ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" c.a"+y+" = a.a"+y+"*b.a"+y+";\n");
}
out.print(" }\n\n");
}
private void elementDiv_two( int dimen ) {
out.print(" /**\n" +
" * Performs an element by element division operation:
\n" +
" *
\n" +
" * aij = aij / bij
\n" +
" *
\n" +
" * @param a The left matrix in the division operation. Modified.\n" +
" * @param b The right matrix in the division operation. Not modified.\n" +
" */\n" +
" public static void elementDiv( "+nameMatrix+" a , "+nameMatrix+" b) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
String w = "a"+y+""+x;
out.print("a."+w+" /= b."+w+";");
if( x < dimen )
out.print(" ");
else
out.println();
}
}
out.print(" }\n\n");
}
private void elementDiv_vector_two( int dimen ) {
out.print(" /**\n" +
" * Performs an element by element division operation:
\n" +
" *
\n" +
" * ai = ai / bi
\n" +
" *
\n" +
" * @param a The left vector in the division operation. Modified.\n" +
" * @param b The right vector in the division operation. Not modified.\n" +
" */\n" +
" public static void elementDiv( "+nameVector+" a , "+nameVector+" b) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" a.a"+y+" /= b.a"+y+";\n");
}
out.print(" }\n\n");
}
private void elementDiv_three( int dimen ) {
out.print(" /**\n" +
" * Performs an element by element division operation:
\n" +
" *
\n" +
" * cij = aij / bij
\n" +
" *
\n" +
" * @param a The left matrix in the division operation. Not modified.\n" +
" * @param b The right matrix in the division operation. Not modified.\n" +
" * @param c Where the results of the operation are stored. Modified.\n" +
" */\n" +
" public static void elementDiv( "+nameMatrix+" a , "+nameMatrix+" b , "+nameMatrix+" c ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
String w = "a"+y+""+x;
out.print("c."+w+" = a."+w+"/b."+w+";");
if( x < dimen )
out.print(" ");
else
out.println();
}
}
out.print(" }\n\n");
}
private void elementDiv_vector_three( int dimen ) {
out.print(" /**\n" +
" * Performs an element by element division operation:
\n" +
" *
\n" +
" * ci = ai / bi
\n" +
" *
\n" +
" * @param a The left vector in the division operation. Not modified.\n" +
" * @param b The right vector in the division operation. Not modified.\n" +
" * @param c Where the results of the operation are stored. Modified.\n" +
" */\n" +
" public static void elementDiv( "+nameVector+" a , "+nameVector+" b , "+nameVector+" c ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" c.a"+y+" = a.a"+y+"/b.a"+y+";\n");
}
out.print(" }\n\n");
}
private void scale_two( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Performs an in-place element by element scalar multiplication.
\n" +
" *
\n" +
" * aij = α*aij\n" +
" *
\n" +
" *\n" +
" * @param a The matrix that is to be scaled. Modified.\n" +
" * @param alpha the amount each element is multiplied by.\n" +
" */\n" +
" public static void scale( double alpha , "+nameMatrix+" a ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
String w = "a"+y+""+x;
out.print("a."+w+" *= alpha;");
if( x < dimen )
out.print(" ");
else
out.println();
}
}
out.print(" }\n\n");
}
private void scale_vector_two( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Performs an in-place element by element scalar multiplication.
\n" +
" *
\n" +
" * aij = α*aij\n" +
" *
\n" +
" *\n" +
" * @param a The vector that is to be scaled. Modified.\n" +
" * @param alpha the amount each element is multiplied by.\n" +
" */\n" +
" public static void scale( double alpha , "+nameVector+" a ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" a.a"+y+" *= alpha;\n");
}
out.print(" }\n\n");
}
private void scale_three( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Performs an element by element scalar multiplication.
\n" +
" *
\n" +
" * bij = α*aij\n" +
" *
\n" +
" *\n" +
" * @param alpha the amount each element is multiplied by.\n" +
" * @param a The matrix that is to be scaled. Not modified.\n" +
" * @param b Where the scaled matrix is stored. Modified.\n" +
" */\n" +
" public static void scale( double alpha , "+nameMatrix+" a , "+nameMatrix+" b ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
String w = "a"+y+""+x;
out.print("b."+w+" = a."+w+"*alpha;");
if( x < dimen )
out.print(" ");
else
out.println();
}
}
out.print(" }\n\n");
}
private void scale_vector_three( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Performs an element by element scalar multiplication.
\n" +
" *
\n" +
" * bi = α*ai\n" +
" *
\n" +
" *\n" +
" * @param alpha the amount each element is multiplied by.\n" +
" * @param a The vector that is to be scaled. Not modified.\n" +
" * @param b Where the scaled matrix is stored. Modified.\n" +
" */\n" +
" public static void scale( double alpha , "+nameVector+" a , "+nameVector+" b ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" b.a"+y+" = a.a"+y+"*alpha;\n");
}
out.print(" }\n\n");
}
private void divide_two( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Performs an in-place element by element scalar division. Scalar denominator.
\n" +
" *
\n" +
" * aij = aij/α\n" +
" *
\n" +
" *\n" +
" * @param a The matrix whose elements are to be divided. Modified.\n" +
" * @param alpha the amount each element is divided by.\n" +
" */\n" +
" public static void divide( "+nameMatrix+" a , double alpha ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
String w = "a"+y+""+x;
out.print("a."+w+" /= alpha;");
if( x < dimen )
out.print(" ");
else
out.println();
}
}
out.print(" }\n\n");
}
private void divide_vector_two( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Performs an in-place element by element scalar division. Scalar denominator.
\n" +
" *
\n" +
" * ai = ai/α\n" +
" *
\n" +
" *\n" +
" * @param a The vector whose elements are to be divided. Modified.\n" +
" * @param alpha the amount each element is divided by.\n" +
" */\n" +
" public static void divide( "+nameVector+" a , double alpha ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" a.a"+y+" /= alpha;\n");
}
out.print(" }\n\n");
}
private void divide_three( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Performs an element by element scalar division. Scalar denominator.
\n" +
" *
\n" +
" * bij = aij /α\n" +
" *
\n" +
" *\n" +
" * @param alpha the amount each element is divided by.\n" +
" * @param a The matrix whose elements are to be divided. Not modified.\n" +
" * @param b Where the results are stored. Modified.\n" +
" */\n" +
" public static void divide( "+nameMatrix+" a , double alpha , "+nameMatrix+" b ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
String w = "a"+y+""+x;
out.print("b."+w+" = a."+w+"/alpha;");
if( x < dimen )
out.print(" ");
else
out.println();
}
}
out.print(" }\n\n");
}
private void divide_vector_three( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Performs an element by element scalar division. Scalar denominator.
\n" +
" *
\n" +
" * bi = ai /α\n" +
" *
\n" +
" *\n" +
" * @param alpha the amount each element is divided by.\n" +
" * @param a The vector whose elements are to be divided. Not modified.\n" +
" * @param b Where the results are stored. Modified.\n" +
" */\n" +
" public static void divide( "+nameVector+" a , double alpha , "+nameVector+" b ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" b.a"+y+" = a.a"+y+"/alpha;\n");
}
out.print(" }\n\n");
}
private void changeSign( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Changes the sign of every element in the matrix.
\n" +
" *
\n" +
" * aij = -aij\n" +
" *
\n" +
" *\n" +
" * @param a A matrix. Modified.\n" +
" */\n" +
" public static void changeSign( "+nameMatrix+" a )\n" +
" {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
String w = "a"+y+""+x;
out.print("a."+w+" = -a."+w+";");
if( x < dimen )
out.print(" ");
else
out.println();
}
}
out.print(" }\n\n");
}
private void changeSign_vector( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Changes the sign of every element in the vector.
\n" +
" *
\n" +
" * ai = -ai\n" +
" *
\n" +
" *\n" +
" * @param a A vector. Modified.\n" +
" */\n" +
" public static void changeSign( "+nameVector+" a )\n" +
" {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" a.a"+y+" = -a.a"+y+";\n");
}
out.print(" }\n\n");
}
private void fill( int dimen ) {
out.print(" /**\n" +
" * \n" +
" * Sets every element in the matrix to the specified value.
\n" +
" *
\n" +
" * aij = value\n" +
" *
\n" +
" *\n" +
" * @param a A matrix whose elements are about to be set. Modified.\n" +
" * @param v The value each element will have.\n" +
" */\n" +
" public static void fill( "+nameMatrix+" a , double v ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
String w = "a"+y+""+x;
out.print("a."+w+" = v;");
if( x < dimen )
out.print(" ");
else
out.println();
}
}
out.print(" }\n\n");
}
private void fill_vector( int dimen ) {
out.print(" /**\n" +
" *
\n" +
" * Sets every element in the vector to the specified value.
\n" +
" *
\n" +
" * ai = value\n" +
" *
\n" +
" *\n" +
" * @param a A vector whose elements are about to be set. Modified.\n" +
" * @param v The value each element will have.\n" +
" */\n" +
" public static void fill( "+nameVector+" a , double v ) {\n");
for( int y = 1; y <= dimen; y++ ) {
out.print(" a.a"+y+" = v;\n");
}
out.print(" }\n\n");
}
private void extract( int dimen ) {
out.print(" /**\n" +
" * Extracts the row from the matrix a.\n" +
" * @param a Input matrix\n" +
" * @param row Which row is to be extracted\n" +
" * @param out output. Storage for the extracted row. If null then a new vector will be returned.\n" +
" * @return The extracted row.\n" +
" */\n" +
" public static "+nameVector+" extractRow( "+nameMatrix+" a , int row , "+nameVector+" out ) {\n" +
" if( out == null) out = new "+nameVector+"();\n" +
" switch( row ) {\n");
for (int i = 0; i < dimen; i++) {
out.print(" case "+i+":\n");
for (int j = 0; j < dimen; j++) {
int n = j+1;
out.print(" out.a"+n+" = a.a"+(i+1)+""+n+";\n");
}
out.print(" break;\n");
}
out.print(" default:\n" +
" throw new IllegalArgumentException(\"Out of bounds row. row = \"+row);\n" +
" }\n" +
" return out;\n" +
" }\n" +
"\n" +
" /**\n" +
" * Extracts the column from the matrix a.\n" +
" * @param a Input matrix\n" +
" * @param column Which column is to be extracted\n" +
" * @param out output. Storage for the extracted column. If null then a new vector will be returned.\n" +
" * @return The extracted column.\n" +
" */\n" +
" public static "+nameVector+" extractColumn( "+nameMatrix+" a , int column , "+nameVector+" out ) {\n" +
" if( out == null) out = new "+nameVector+"();\n" +
" switch( column ) {\n");
for (int i = 0; i < dimen; i++) {
out.print(" case "+i+":\n");
for (int j = 0; j < dimen; j++) {
int n = j+1;
out.print(" out.a"+n+" = a.a"+n+""+(i+1)+";\n");
}
out.print(" break;\n");
}
out.print(" default:\n" +
" throw new IllegalArgumentException(\"Out of bounds column. column = \"+column);\n" +
" }\n" +
" return out;\n" +
" }\n\n");
}
public static void main( String args[] ) throws FileNotFoundException {
GenerateFixedOps app = new GenerateFixedOps();
app.generate();
}
} ejml-0.28/main/dense64/generate/org/ejml/data/ 0000775 0000000 0000000 00000000000 12561715344 0021017 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/generate/org/ejml/data/GenerateFixedMatrixN.java 0000664 0000000 0000000 00000016430 12561715344 0025703 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.CodeGeneratorBase;
import java.io.FileNotFoundException;
/**
* @author Peter Abeles
*/
public class GenerateFixedMatrixN extends CodeGeneratorBase{
String classPreamble = "FixedMatrix";
@Override
public void generate() throws FileNotFoundException {
for( int dimension = 2; dimension <= 6; dimension++ ){
print(dimension);
}
}
public void print( int dimen ) throws FileNotFoundException {
String className = classPreamble +dimen+"_64F";
setOutputFile(className);
out.print("import org.ejml.ops.MatrixIO;\n" +
"\n" +
"/**\n" +
" * Fixed sized vector with "+dimen+" elements. Can represent a "+dimen+" x 1 or 1 x "+dimen+" matrix, context dependent.\n" +
" *
DO NOT MODIFY. Automatically generated code created by "+getClass().getSimpleName()+"
\n" +
" *\n" +
" * @author Peter Abeles\n" +
" */\n" +
"public class "+className+" implements FixedMatrix64F {\n");
printClassParam(dimen);
out.print("\n" +
" public "+className+"() {\n" +
" }\n" +
"\n" +
" public "+className+"(");
printFunctionParam(dimen);
out.print(")\n" +
" {\n");
printSetFromParam(dimen,"");
out.print(" }\n" +
"\n" +
" public "+className+"("+className+" o) {\n");
printSetFromParam(dimen,"o.");
out.print(" }\n" +
"\n" +
" @Override\n" +
" public double get(int row, int col) {\n" +
" return unsafe_get(row,col);\n" +
" }\n" +
"\n" +
" @Override\n" +
" public double unsafe_get(int row, int col) {\n" +
" if( row != 0 && col != 0 )\n" +
" throw new IllegalArgumentException(\"Row or column must be zero since this is a vector\");\n" +
"\n" +
" int w = Math.max(row,col);\n" +
"\n");
setGetter(dimen);
out.print(" } else {\n" +
" throw new IllegalArgumentException(\"Out of range. \"+w);\n" +
" }\n" +
" }\n" +
"\n" +
" @Override\n" +
" public void set(int row, int col, double val) {\n" +
" unsafe_set(row,col,val);\n" +
" }\n" +
"\n" +
" @Override\n" +
" public void unsafe_set(int row, int col, double val) {\n" +
" if( row != 0 && col != 0 )\n" +
" throw new IllegalArgumentException(\"Row or column must be zero since this is a vector\");\n" +
"\n" +
" int w = Math.max(row,col);\n" +
"\n");
setSetter(dimen);
out.print(" } else {\n" +
" throw new IllegalArgumentException(\"Out of range. \"+w);\n" +
" }\n" +
" }\n" +
"\n");
printSetMatrix(dimen);
out.print(" @Override\n" +
" public int getNumRows() {\n" +
" return "+dimen+";\n" +
" }\n" +
"\n" +
" @Override\n" +
" public int getNumCols() {\n" +
" return 1;\n" +
" }\n" +
"\n" +
" @Override\n" +
" public int getNumElements() {\n" +
" return "+dimen+";\n" +
" }\n" +
"\n" +
" @Override\n" +
" public T copy() {\n" +
" return (T)new "+className+"(this);\n" +
" }\n" +
"\n" +
" @Override\n" +
" public void print() {\n" +
" MatrixIO.print(System.out, this);\n" +
" }\n" +
"}\n\n");
}
private void printClassParam( int dimen ) {
out.print(" public double ");
for( int i = 1; i <= dimen; i++ ) {
out.print("a"+i);
if( i < dimen )
out.print(",");
else
out.print(";\n");
}
}
private void printFunctionParam( int dimen ) {
for( int i = 1; i <= dimen; i++ ) {
out.print("double a"+i);
if( i < dimen )
out.print(",");
}
}
private void printSetFromParam(int dimen, String prefix) {
for( int i = 1; i <= dimen; i++ ) {
out.println(" this.a"+i+" = "+prefix+"a"+i+";");
}
}
private void printSetMatrix(int dimen) {
out.print(" @Override\n" +
" public void set(Matrix original) {\n" +
" RealMatrix64F m = (RealMatrix64F)original;\n" +
"\n" +
" if( m.getNumCols() == 1 && m.getNumRows() == "+dimen+" ) {\n");
for (int i = 0; i < dimen; i++) {
out.print(" a"+(i+1)+" = m.get("+i+",0);\n");
}
out.print(" } else if( m.getNumRows() == 1 && m.getNumCols() == "+dimen+" ){\n");
for (int i = 0; i < dimen; i++) {
out.print(" a"+(i+1)+" = m.get(0,"+i+");\n");
}
out.print(" } else {\n" +
" throw new IllegalArgumentException(\"Incompatible shape\");\n" +
" }\n" +
" }\n\n");
}
private void setGetter(int dimen) {
for( int i = 0; i < dimen; i++ ) {
if( i == 0 )
out.print(" if( w == 0 ) {\n");
else
out.print(" } else if( w == "+i+" ) {\n");
out.print(" return a"+(i+1)+";\n");
}
}
private void setSetter(int dimen ) {
for( int i = 0; i < dimen; i++ ) {
if( i == 0 )
out.print(" if( w == 0 ) {\n");
else
out.print(" } else if( w == "+i+" ) {\n");
out.print(" a"+(i+1)+" = val;\n");
}
}
public static void main( String args[] ) throws FileNotFoundException {
GenerateFixedMatrixN app = new GenerateFixedMatrixN();
app.generate();
}
}
ejml-0.28/main/dense64/generate/org/ejml/data/GenerateFixedMatrixNxN.java 0000664 0000000 0000000 00000017355 12561715344 0026220 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2015, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.data;
import org.ejml.CodeGeneratorBase;
import java.io.FileNotFoundException;
/**
* @author Peter Abeles
*/
public class GenerateFixedMatrixNxN extends CodeGeneratorBase{
String classPreamble = "FixedMatrix";
@Override
public void generate() throws FileNotFoundException {
for( int dimension = 2; dimension <= 6; dimension++ ){
print(dimension);
}
}
public void print( int dimen ) throws FileNotFoundException {
String className = classPreamble +dimen+"x"+dimen+"_64F";
setOutputFile(className);
out.println("import org.ejml.ops.MatrixIO;\n\n"+
"/**\n" +
" * Fixed sized "+dimen+" by "+className+" matrix. The matrix is stored as class variables for very fast read/write. aXY is the\n" +
" * value of row = X and column = Y.\n" +
" * DO NOT MODIFY. Automatically generated code created by "+getClass().getSimpleName()+"
\n" +
" *\n" +
" * @author Peter Abeles\n" +
" */\n" +
"public class "+className+" implements FixedMatrix64F {\n");
printClassParam(dimen);
out.print("\n" +
" public "+className+"() {\n" +
" }\n" +
"\n" +
" public "+className);
printFunctionParam(dimen);
out.print(" {\n");
printSetFromParam(dimen, "");
out.print(" }\n" +
"\n" +
" public " + className + "( " + className + " o ) {\n");
printSetFromParam(dimen, "o.");
out.print(" }\n" +
"\n" +
" @Override\n" +
" public double get(int row, int col) {\n" +
" return unsafe_get(row,col);\n" +
" }\n" +
"\n" +
" @Override\n" +
" public double unsafe_get(int row, int col) {\n");
setGetter(dimen);
out.print(" throw new IllegalArgumentException(\"Row and/or column out of range. \"+row+\" \"+col);\n" +
" }\n" +
"\n" +
" @Override\n" +
" public void set(int row, int col, double val) {\n" +
" unsafe_set(row,col,val);\n" +
" }\n" +
"\n" +
" @Override\n" +
" public void unsafe_set(int row, int col, double val) {\n");
setSetter(dimen);
out.print(" throw new IllegalArgumentException(\"Row and/or column out of range. \"+row+\" \"+col);\n" +
" }\n" +
"\n");
printSetMatrix(dimen);
out.print(" @Override\n" +
" public int getNumRows() {\n" +
" return "+dimen+";\n" +
" }\n" +
"\n" +
" @Override\n" +
" public int getNumCols() {\n" +
" return "+dimen+";\n" +
" }\n" +
"\n" +
" @Override\n" +
" public int getNumElements() {\n" +
" return "+(dimen*dimen)+";\n" +
" }\n" +
"\n" +
" @Override\n" +
" public T copy() {\n" +
" return (T)new "+className+"(this);\n" +
" }\n" +
"\n" +
" @Override\n" +
" public void print() {\n" +
" MatrixIO.print(System.out, this);\n" +
" }\n" +
"}\n\n");
}
private void printClassParam( int dimen ) {
for( int y = 1; y <= dimen; y++ ) {
out.print(" public double ");
for( int x = 1; x <= dimen; x++ ) {
out.print("a"+y+""+x);
if( x != dimen )
out.print(",");
else
out.println(";");
}
}
}
private void printFunctionParam( int dimen ) {
for( int y = 1; y <= dimen; y++ ) {
if( y == 1 )
out.print("( ");
else
out.print(" ");
for( int x = 1; x <= dimen; x++ ) {
out.print("double a"+y+""+x);
if( x != dimen )
out.print(",");
else if( y != dimen )
out.println(",");
else
out.println(")");
}
}
}
private void printSetFromParam(int dimen, String prefix) {
for( int y = 1; y <= dimen; y++ ) {
for( int x = 1; x <= dimen; x++ ) {
out.println(" this.a"+y+""+x+" = "+prefix+"a"+y+""+x+";");
}
}
}
private void setGetter(int dimen) {
for( int y = 1; y <= dimen; y++ ) {
if( y == 1 )
out.print(" if( row == 0 ) {\n");
else
out.print(" } else if( row == "+(y-1)+" ) {\n");
for( int x = 1; x <= dimen; x++ ) {
if( x == 1 )
out.print(" if( col == 0 ) {\n");
else
out.print(" } else if( col == "+(x-1)+" ) {\n");
out.print(" return a"+y+""+x+";\n");
}
out.print(" }\n");
}
out.print(" }\n");
}
private void setSetter(int dimen ) {
for( int y = 1; y <= dimen; y++ ) {
if( y == 1 )
out.print(" if( row == 0 ) {\n");
else
out.print(" } else if( row == "+(y-1)+" ) {\n");
for( int x = 1; x <= dimen; x++ ) {
if( x == 1 )
out.print(" if( col == 0 ) {\n");
else
out.print(" } else if( col == "+(x-1)+" ) {\n");
out.print(" a"+y+""+x+" = val; return;\n");
}
out.print(" }\n");
}
out.print(" }\n");
}
private void printSetMatrix( int dimen ) {
out.print(" @Override\n" +
" public void set(Matrix original) {\n" +
" if( original.getNumCols() != "+dimen+" || original.getNumRows() != "+dimen+" )\n" +
" throw new IllegalArgumentException(\"Rows and/or columns do not match\");\n" +
" RealMatrix64F m = (RealMatrix64F)original;\n" +
" \n");
for( int y = 1; y <= dimen; y++ ) {
for( int x = 1; x <= dimen; x++ ) {
out.print(" a"+y+""+x+" = m.get("+(y-1)+","+(x-1)+");\n");
}
}
out.print(" }\n\n");
}
public static void main( String args[] ) throws FileNotFoundException {
GenerateFixedMatrixNxN app = new GenerateFixedMatrixNxN();
app.generate();
}
}
ejml-0.28/main/dense64/src/ 0000775 0000000 0000000 00000000000 12561715344 0015365 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/src/org/ 0000775 0000000 0000000 00000000000 12561715344 0016154 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/src/org/ejml/ 0000775 0000000 0000000 00000000000 12561715344 0017103 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/src/org/ejml/alg/ 0000775 0000000 0000000 00000000000 12561715344 0017646 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/src/org/ejml/alg/block/ 0000775 0000000 0000000 00000000000 12561715344 0020740 5 ustar 00root root 0000000 0000000 ejml-0.28/main/dense64/src/org/ejml/alg/block/BlockInnerMultiplication.java 0000664 0000000 0000000 00000046267 12561715344 0026566 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2009-2014, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ejml.alg.block;
/**
*
* Matrix multiplication for the inner row major blocks, typically inside of a {@link org.ejml.data.BlockMatrix64F}.
*
*
*
* This code was auto generated by {@link GeneratorBlockInnerMultiplication} and should not be modified directly.
*
*
* @author Peter Abeles
*/
public class BlockInnerMultiplication {
/**
*
* Performs the follow operation on individual inner blocks: