Eigenvalue and Eigenvector related functions.
* Methods exist for working with symmetric matrices or general eigenvalues.
* The symmetric versions are usually much faster on symmetric matrices.
*/
public class Eigen {
private static final DoubleMatrix dummyDouble = new DoubleMatrix(1);
/**
* Compute the eigenvalues for a symmetric matrix.
*/
public static DoubleMatrix symmetricEigenvalues(DoubleMatrix A) {
A.assertSquare();
DoubleMatrix eigenvalues = new DoubleMatrix(A.rows);
int isuppz[] = new int[2 * A.rows];
SimpleBlas.syevr('N', 'A', 'U', A.dup(), 0, 0, 0, 0, 0, eigenvalues, dummyDouble, isuppz);
return eigenvalues;
}
/**
* Computes the eigenvalues and eigenvectors for a symmetric matrix.
*
* @return an array of DoubleMatrix objects containing the eigenvectors
* stored as the columns of the first matrix, and the eigenvalues as
* diagonal elements of the second matrix.
*/
public static DoubleMatrix[] symmetricEigenvectors(DoubleMatrix A) {
A.assertSquare();
DoubleMatrix eigenvalues = new DoubleMatrix(A.rows);
DoubleMatrix eigenvectors = A.dup();
int isuppz[] = new int[2 * A.rows];
SimpleBlas.syevr('V', 'A', 'U', A.dup(), 0, 0, 0, 0, 0, eigenvalues, eigenvectors, isuppz);
return new DoubleMatrix[]{eigenvectors, DoubleMatrix.diag(eigenvalues)};
}
/**
* Computes the eigenvalues of a general matrix.
*/
public static ComplexDoubleMatrix eigenvalues(DoubleMatrix A) {
A.assertSquare();
DoubleMatrix WR = new DoubleMatrix(A.rows);
DoubleMatrix WI = WR.dup();
SimpleBlas.geev('N', 'N', A.dup(), WR, WI, dummyDouble, dummyDouble);
return new ComplexDoubleMatrix(WR, WI);
}
/**
* Computes the eigenvalues and eigenvectors of a general matrix.
*
* @return an array of ComplexDoubleMatrix objects containing the eigenvectors
* stored as the columns of the first matrix, and the eigenvalues as the
* diagonal elements of the second matrix.
*/
public static ComplexDoubleMatrix[] eigenvectors(DoubleMatrix A) {
A.assertSquare();
// setting up result arrays
DoubleMatrix WR = new DoubleMatrix(A.rows);
DoubleMatrix WI = WR.dup();
DoubleMatrix VR = new DoubleMatrix(A.rows, A.rows);
SimpleBlas.geev('N', 'V', A.dup(), WR, WI, dummyDouble, VR);
// transferring the result
ComplexDoubleMatrix E = new ComplexDoubleMatrix(WR, WI);
ComplexDoubleMatrix V = new ComplexDoubleMatrix(A.rows, A.rows);
//System.err.printf("VR = %s\n", VR.toString());
for (int i = 0; i < A.rows; i++) {
if (E.get(i).isReal()) {
V.putColumn(i, new ComplexDoubleMatrix(VR.getColumn(i)));
} else {
ComplexDoubleMatrix v = new ComplexDoubleMatrix(VR.getColumn(i), VR.getColumn(i + 1));
V.putColumn(i, v);
V.putColumn(i + 1, v.conji());
i += 1;
}
}
return new ComplexDoubleMatrix[]{V, ComplexDoubleMatrix.diag(E)};
}
/**
* Compute generalized eigenvalues of the problem A x = L B x.
*
* @param A symmetric Matrix A. Only the upper triangle will be considered.
* @param B symmetric Matrix B. Only the upper triangle will be considered.
* @return a vector of eigenvalues L.
*/
public static DoubleMatrix symmetricGeneralizedEigenvalues(DoubleMatrix A, DoubleMatrix B) {
A.assertSquare();
B.assertSquare();
DoubleMatrix W = new DoubleMatrix(A.rows);
SimpleBlas.sygvd(1, 'N', 'U', A.dup(), B.dup(), W);
return W;
}
/**
* Solve a general problem A x = L B x.
*
* @param A symmetric matrix A
* @param B symmetric matrix B
* @return an array of matrices of length two. The first one is an array of the eigenvectors X
* The second one is A vector containing the corresponding eigenvalues L.
*/
public static DoubleMatrix[] symmetricGeneralizedEigenvectors(DoubleMatrix A, DoubleMatrix B) {
A.assertSquare();
B.assertSquare();
DoubleMatrix[] result = new DoubleMatrix[2];
DoubleMatrix dA = A.dup();
DoubleMatrix dB = B.dup();
DoubleMatrix W = new DoubleMatrix(dA.rows);
SimpleBlas.sygvd(1, 'V', 'U', dA, dB, W);
result[0] = dA;
result[1] = W;
return result;
}
//BEGIN
// The code below has been automatically generated.
// DO NOT EDIT!
private static final FloatMatrix dummyFloat = new FloatMatrix(1);
/**
* Compute the eigenvalues for a symmetric matrix.
*/
public static FloatMatrix symmetricEigenvalues(FloatMatrix A) {
A.assertSquare();
FloatMatrix eigenvalues = new FloatMatrix(A.rows);
int isuppz[] = new int[2 * A.rows];
SimpleBlas.syevr('N', 'A', 'U', A.dup(), 0, 0, 0, 0, 0, eigenvalues, dummyFloat, isuppz);
return eigenvalues;
}
/**
* Computes the eigenvalues and eigenvectors for a symmetric matrix.
*
* @return an array of FloatMatrix objects containing the eigenvectors
* stored as the columns of the first matrix, and the eigenvalues as
* diagonal elements of the second matrix.
*/
public static FloatMatrix[] symmetricEigenvectors(FloatMatrix A) {
A.assertSquare();
FloatMatrix eigenvalues = new FloatMatrix(A.rows);
FloatMatrix eigenvectors = A.dup();
int isuppz[] = new int[2 * A.rows];
SimpleBlas.syevr('V', 'A', 'U', A.dup(), 0, 0, 0, 0, 0, eigenvalues, eigenvectors, isuppz);
return new FloatMatrix[]{eigenvectors, FloatMatrix.diag(eigenvalues)};
}
/**
* Computes the eigenvalues of a general matrix.
*/
public static ComplexFloatMatrix eigenvalues(FloatMatrix A) {
A.assertSquare();
FloatMatrix WR = new FloatMatrix(A.rows);
FloatMatrix WI = WR.dup();
SimpleBlas.geev('N', 'N', A.dup(), WR, WI, dummyFloat, dummyFloat);
return new ComplexFloatMatrix(WR, WI);
}
/**
* Computes the eigenvalues and eigenvectors of a general matrix.
*
* @return an array of ComplexFloatMatrix objects containing the eigenvectors
* stored as the columns of the first matrix, and the eigenvalues as the
* diagonal elements of the second matrix.
*/
public static ComplexFloatMatrix[] eigenvectors(FloatMatrix A) {
A.assertSquare();
// setting up result arrays
FloatMatrix WR = new FloatMatrix(A.rows);
FloatMatrix WI = WR.dup();
FloatMatrix VR = new FloatMatrix(A.rows, A.rows);
SimpleBlas.geev('N', 'V', A.dup(), WR, WI, dummyFloat, VR);
// transferring the result
ComplexFloatMatrix E = new ComplexFloatMatrix(WR, WI);
ComplexFloatMatrix V = new ComplexFloatMatrix(A.rows, A.rows);
//System.err.printf("VR = %s\n", VR.toString());
for (int i = 0; i < A.rows; i++) {
if (E.get(i).isReal()) {
V.putColumn(i, new ComplexFloatMatrix(VR.getColumn(i)));
} else {
ComplexFloatMatrix v = new ComplexFloatMatrix(VR.getColumn(i), VR.getColumn(i + 1));
V.putColumn(i, v);
V.putColumn(i + 1, v.conji());
i += 1;
}
}
return new ComplexFloatMatrix[]{V, ComplexFloatMatrix.diag(E)};
}
/**
* Compute generalized eigenvalues of the problem A x = L B x.
*
* @param A symmetric Matrix A. Only the upper triangle will be considered.
* @param B symmetric Matrix B. Only the upper triangle will be considered.
* @return a vector of eigenvalues L.
*/
public static FloatMatrix symmetricGeneralizedEigenvalues(FloatMatrix A, FloatMatrix B) {
A.assertSquare();
B.assertSquare();
FloatMatrix W = new FloatMatrix(A.rows);
SimpleBlas.sygvd(1, 'N', 'U', A.dup(), B.dup(), W);
return W;
}
/**
* Solve a general problem A x = L B x.
*
* @param A symmetric matrix A
* @param B symmetric matrix B
* @return an array of matrices of length two. The first one is an array of the eigenvectors X
* The second one is A vector containing the corresponding eigenvalues L.
*/
public static FloatMatrix[] symmetricGeneralizedEigenvectors(FloatMatrix A, FloatMatrix B) {
A.assertSquare();
B.assertSquare();
FloatMatrix[] result = new FloatMatrix[2];
FloatMatrix dA = A.dup();
FloatMatrix dB = B.dup();
FloatMatrix W = new FloatMatrix(dA.rows);
SimpleBlas.sygvd(1, 'V', 'U', dA, dB, W);
result[0] = dA;
result[1] = W;
return result;
}
//END
}
jblas-1.2.3/src/main/java/org/jblas/FloatFunction.java 0000664 0000000 0000000 00000003527 12106720513 0022550 0 ustar 00root root 0000000 0000000 // --- BEGIN LICENSE BLOCK ---
/*
* Copyright (c) 2009, Mikio L. Braun
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* * Neither the name of the Technische Universität Berlin nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// --- END LICENSE BLOCK ---
package org.jblas;
/**
* Represents a function on floats.
*/
public interface FloatFunction {
/** Compute the function. */
public float compute(float x);
} jblas-1.2.3/src/main/java/org/jblas/FloatMatrix.java 0000664 0000000 0000000 00000317012 12106720513 0022224 0 ustar 00root root 0000000 0000000 // --- BEGIN LICENSE BLOCK ---
/*
* Copyright (c) 2009, Mikio L. Braun
* Copyright (c) 2008, Johannes Schaback
* Copyright (c) 2009, Jan Saputra Müller
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* * Neither the name of the Technische Universität Berlin nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// --- END LICENSE BLOCK ---
package org.jblas;
import org.jblas.exceptions.SizeException;
import org.jblas.ranges.Range;
import org.jblas.util.Random;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.io.StringWriter;
import java.util.AbstractList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
/**
* A general matrix class for To construct a two-dimensional matrices, you can use the following constructors
* and static methods.
*
*
* | Method | Description
* |
|---|
| FloatMatrix(m,n, [value1, value2, value3...]) | Values are filled in row by row.
* |
| FloatMatrix(new float[][] {{value1, value2, ...}, ...} | Inner arrays are columns.
* |
| FloatMatrix.zeros(m,n) | Initial values set to 0.0f.
* |
| FloatMatrix.ones(m,n) | Initial values set to 1.0f.
* |
| FloatMatrix.rand(m,n) | Values drawn at random between 0.0f and 1.0f.
* |
| FloatMatrix.randn(m,n) | Values drawn from normal distribution.
* |
| FloatMatrix.eye(n) | Unit matrix (values 0.0f except for 1.0f on the diagonal).
* |
| FloatMatrix.diag(array) | Diagonal matrix with given diagonal elements.
* |
*
* Alternatively, you can construct (column) vectors, if you just supply the length
* using the following constructors and static methods.
*
* You can also construct new matrices by concatenating matrices either horziontally
* or vertically:
*
* To access individual elements, or whole rows and columns, use the following
* methods:
* | x.Method | Description
* |
|---|
| x.get(i,j) | Get element in row i and column j.
* |
| x.put(i, j, v) | Set element in row i and column j to value v
* |
| x.get(i) | Get the ith element of the matrix (traversing rows first).
* |
| x.put(i, v) | Set the ith element of the matrix (traversing rows first).
* |
| x.getColumn(i) | Get a copy of column i.
* |
| x.putColumn(i, c) | Put matrix c into column i.
* |
| x.getRow(i) | Get a copy of row i.
* |
| x.putRow(i, c) | Put matrix c into row i.
* |
| x.swapColumns(i, j) | Swap the contents of columns i and j.
* |
| x.swapRows(i, j) | Swap the contents of columns i and j.
* |
*
* There exist the following Range objects. The Class RangeUtils also
* contains the a number of handy helper methods for constructing these ranges.
* The following methods can be used for duplicating and copying matrices.
*
* The following methods permit to acces the size of a matrix and change its size or shape.
*
*
* | x.Method | Description
* |
|---|
| x.rows | Number of rows.
* |
| x.columns | Number of columns.
* |
| x.length | Total number of elements.
* |
| x.isEmpty() | Checks whether rows == 0 and columns == 0.
* |
| x.isRowVector() | Checks whether rows == 1.
* |
| x.isColumnVector() | Checks whether columns == 1.
* |
| x.isVector() | Checks whether rows == 1 or columns == 1.
* |
| x.isSquare() | Checks whether rows == columns.
* |
| x.isScalar() | Checks whether length == 1.
* |
| x.resize(r, c) | Resize the matrix to r rows and c columns, discarding the content.
* |
| x.reshape(r, c) | Resize the matrix to r rows and c columns.
Number of elements must not change.
* |
*
* The usual arithmetic operations are implemented. Each operation exists in a
* in-place version, recognizable by the suffix "i", to which you can supply
* the result matrix (or this is used, if missing). Using in-place operations
* can also lead to a smaller memory footprint, as the number of temporary objects
* which are directly garbage collected again is reduced.
*
* Whenever you specify a result vector, the result vector must already have the
* correct dimensions.
*
* Methods which operate element-wise only make sure that the length of the matrices
* is correct. Therefore, you can add a 3 * 3 matrix to a 1 * 9 matrix, for example.
*
* Finally, there exist versions which take floats instead of FloatMatrix Objects
* as arguments. These then compute the operation with the same value as the
* right-hand-side. The same effect can be achieved by passing a FloatMatrix with
* exactly one element.
*
* There also exist operations which work on whole columns or rows.
*
* In principle, you could achieve the same result by first calling getColumn(),
* adding, and then calling putColumn, but these methods are much faster.
*
* Logical operations are also supported. For these operations, a value different from
* zero is treated as "true" and zero is treated as "false". All operations are carried
* out elementwise.
*
*