/*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Matrix.java
* Copyright (C) 1999-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core;
import java.io.Reader;
import java.io.Serializable;
import java.io.Writer;
/**
* Class for performing operations on a matrix of floating-point values.
* <p/>
* Deprecated: Uses internally the code of the sub-package
* <code>weka.core.matrix</code> - only for backwards compatibility.
*
* @author Gabi Schmidberger (gabi@cs.waikato.ac.nz)
* @author Yong Wang (yongwang@cs.waikato.ac.nz)
* @author Eibe Frank (eibe@cs.waikato.ac.nz)
* @author Len Trigg (eibe@cs.waikato.ac.nz)
* @author Fracpete (fracpete at waikato dot ac dot nz)
* @version $Revision: 8034 $
* @deprecated Use <code>weka.core.matrix.Matrix</code> instead - only for
* backwards compatibility.
*/
public class Matrix
implements Cloneable, Serializable, RevisionHandler {
/** for serialization */
private static final long serialVersionUID = -3604757095849145838L;
/**
* The actual matrix */
protected weka.core.matrix.Matrix m_Matrix = null;
/**
* Constructs a matrix and initializes it with default values.
*
* @param nr the number of rows
* @param nc the number of columns
*/
public Matrix(int nr, int nc) {
m_Matrix = new weka.core.matrix.Matrix(nr, nc);
}
/**
* Constructs a matrix using a given array.
*
* @param array the values of the matrix
*/
public Matrix(double[][] array) throws Exception {
m_Matrix = new weka.core.matrix.Matrix(array);
}
/**
* Reads a matrix from a reader. The first line in the file should
* contain the number of rows and columns. Subsequent lines
* contain elements of the matrix.
*
* @param r the reader containing the matrix
* @throws Exception if an error occurs
*/
public Matrix(Reader r) throws Exception {
m_Matrix = new weka.core.matrix.Matrix(r);
}
/**
* Creates and returns a clone of this object.
*
* @return a clone of this instance.
* @throws Exception if an error occurs
*/
public Object clone() {
try {
return new Matrix(m_Matrix.getArrayCopy());
}
catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* Writes out a matrix.
*
* @param w the output Writer
* @throws Exception if an error occurs
*/
public void write(Writer w) throws Exception {
m_Matrix.write(w);
}
/**
* returns the internal matrix
* @see #m_Matrix
*/
protected weka.core.matrix.Matrix getMatrix() {
return m_Matrix;
}
/**
* Returns the value of a cell in the matrix.
*
* @param rowIndex the row's index
* @param columnIndex the column's index
* @return the value of the cell of the matrix
*/
public final double getElement(int rowIndex, int columnIndex) {
return m_Matrix.get(rowIndex, columnIndex);
}
/**
* Add a value to an element.
*
* @param rowIndex the row's index.
* @param columnIndex the column's index.
* @param value the value to add.
*/
public final void addElement(int rowIndex, int columnIndex, double value) {
m_Matrix.set(
rowIndex, columnIndex, m_Matrix.get(rowIndex, columnIndex) + value);
}
/**
* Returns the number of rows in the matrix.
*
* @return the number of rows
*/
public final int numRows() {
return m_Matrix.getRowDimension();
}
/**
* Returns the number of columns in the matrix.
*
* @return the number of columns
*/
public final int numColumns() {
return m_Matrix.getColumnDimension();
}
/**
* Sets an element of the matrix to the given value.
*
* @param rowIndex the row's index
* @param columnIndex the column's index
* @param value the value
*/
public final void setElement(int rowIndex, int columnIndex, double value) {
m_Matrix.set(rowIndex, columnIndex, value);
}
/**
* Sets a row of the matrix to the given row. Performs a deep copy.
*
* @param index the row's index
* @param newRow an array of doubles
*/
public final void setRow(int index, double[] newRow) {
for (int i = 0; i < newRow.length; i++)
m_Matrix.set(index, i, newRow[i]);
}
/**
* Gets a row of the matrix and returns it as double array.
*
* @param index the row's index
* @return an array of doubles
*/
public double[] getRow(int index) {
double[] newRow = new double[this.numColumns()];
for (int i = 0; i < newRow.length; i++)
newRow[i] = getElement(index, i);
return newRow;
}
/**
* Gets a column of the matrix and returns it as a double array.
*
* @param index the column's index
* @return an array of doubles
*/
public double[] getColumn(int index) {
double[] newColumn = new double[this.numRows()];
for (int i = 0; i < newColumn.length; i++)
newColumn[i] = getElement(i, index);
return newColumn;
}
/**
* Sets a column of the matrix to the given column. Performs a deep copy.
*
* @param index the column's index
* @param newColumn an array of doubles
*/
public final void setColumn(int index, double[] newColumn) {
for (int i = 0; i < numRows(); i++)
m_Matrix.set(i, index, newColumn[i]);
}
/**
* Converts a matrix to a string
*
* @return the converted string
*/
public String toString() {
return m_Matrix.toString();
}
/**
* Returns the sum of this matrix with another.
*
* @return a matrix containing the sum.
*/
public final Matrix add(Matrix other) {
try {
return new Matrix(m_Matrix.plus(other.getMatrix()).getArrayCopy());
}
catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* Returns the transpose of a matrix.
*
* @return the transposition of this instance.
*/
public final Matrix transpose() {
try {
return new Matrix(m_Matrix.transpose().getArrayCopy());
}
catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* Returns true if the matrix is symmetric.
*
* @return boolean true if matrix is symmetric.
*/
public boolean isSymmetric() {
return m_Matrix.isSymmetric();
}
/**
* Returns the multiplication of two matrices
*
* @param b the multiplication matrix
* @return the product matrix
*/
public final Matrix multiply(Matrix b) {
try {
return new Matrix(getMatrix().times(b.getMatrix()).getArrayCopy());
}
catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* Performs a (ridged) linear regression.
*
* @param y the dependent variable vector
* @param ridge the ridge parameter
* @return the coefficients
* @throws IllegalArgumentException if not successful
*/
public final double[] regression(Matrix y, double ridge) {
return getMatrix().regression(y.getMatrix(), ridge).getCoefficients();
}
/**
* Performs a weighted (ridged) linear regression.
*
* @param y the dependent variable vector
* @param w the array of data point weights
* @param ridge the ridge parameter
* @return the coefficients
* @throws IllegalArgumentException if the wrong number of weights were
* provided.
*/
public final double[] regression(Matrix y, double [] w, double ridge) {
return getMatrix().regression(y.getMatrix(), w, ridge).getCoefficients();
}
/**
* Returns the L part of the matrix.
* This does only make sense after LU decomposition.
*
* @return matrix with the L part of the matrix;
* @see #LUDecomposition()
*/
public Matrix getL() throws Exception {
int nr = numRows(); // num of rows
int nc = numColumns(); // num of columns
double[][] ld = new double[nr][nc];
for (int i = 0; i < nr; i++) {
for (int j = 0; (j < i) && (j < nc); j++) {
ld[i][j] = getElement(i, j);
}
if (i < nc) ld[i][i] = 1;
}
Matrix l = new Matrix(ld);
return l;
}
/**
* Returns the U part of the matrix.
* This does only make sense after LU decomposition.
*
* @return matrix with the U part of a matrix;
* @see #LUDecomposition()
*/
public Matrix getU() throws Exception {
int nr = numRows(); // num of rows
int nc = numColumns(); // num of columns
double[][] ud = new double[nr][nc];
for (int i = 0; i < nr; i++) {
for (int j = i; j < nc ; j++) {
ud[i][j] = getElement(i, j);
}
}
Matrix u = new Matrix(ud);
return u;
}
/**
* Performs a LUDecomposition on the matrix.
* It changes the matrix into its LU decomposition.
*
* @return the indices of the row permutation
*/
public int[] LUDecomposition() throws Exception {
// decompose
weka.core.matrix.LUDecomposition lu = m_Matrix.lu();
// singular? old class throws Exception!
if (!lu.isNonsingular())
throw new Exception("Matrix is singular");
weka.core.matrix.Matrix u = lu.getU();
weka.core.matrix.Matrix l = lu.getL();
// modify internal matrix
int nr = numRows();
int nc = numColumns();
for (int i = 0; i < nr; i++) {
for (int j = 0; j < nc; j++) {
if (j < i)
setElement(i, j, l.get(i, j));
else
setElement(i, j, u.get(i, j));
}
}
u = null;
l = null;
return lu.getPivot();
}
/**
* Solve A*X = B using backward substitution.
* A is current object (this). Note that this matrix will be changed!
* B parameter bb.
* X returned in parameter bb.
*
* @param bb first vector B in above equation then X in same equation.
*/
public void solve(double[] bb) throws Exception {
// solve
weka.core.matrix.Matrix x = m_Matrix.solve(
new weka.core.matrix.Matrix(bb, bb.length));
// move X into bb
int nr = x.getRowDimension();
for (int i = 0; i < nr; i++)
bb[i] = x.get(i, 0);
}
/**
* Performs Eigenvalue Decomposition using Householder QR Factorization
*
* Matrix must be symmetrical.
* Eigenvectors are return in parameter V, as columns of the 2D array.
* (Real parts of) Eigenvalues are returned in parameter d.
*
* @param V double array in which the eigenvectors are returned
* @param d array in which the eigenvalues are returned
* @throws Exception if matrix is not symmetric
*/
public void eigenvalueDecomposition(double[][] V, double[] d)
throws Exception {
// old class only worked with symmetric matrices!
if (!this.isSymmetric())
throw new Exception("EigenvalueDecomposition: Matrix must be symmetric.");
// perform eigenvalue decomposition
weka.core.matrix.EigenvalueDecomposition eig = m_Matrix.eig();
weka.core.matrix.Matrix v = eig.getV();
double[] d2 = eig.getRealEigenvalues();
// transfer data
int nr = numRows();
int nc = numColumns();
for (int i = 0; i < nr; i++)
for (int j = 0; j < nc; j++)
V[i][j] = v.get(i, j);
for (int i = 0; i < d2.length; i++)
d[i] = d2[i];
}
/**
* Returns sqrt(a^2 + b^2) without under/overflow.
*
* @param a length of one side of rectangular triangle
* @param b length of other side of rectangular triangle
* @return lenght of third side
*/
protected static double hypot(double a, double b) {
return weka.core.matrix.Maths.hypot(a, b);
}
/**
* converts the Matrix into a single line Matlab string: matrix is enclosed
* by parentheses, rows are separated by semicolon and single cells by
* blanks, e.g., [1 2; 3 4].
* @return the matrix in Matlab single line format
*/
public String toMatlab() {
return getMatrix().toMatlab();
}
/**
* creates a matrix from the given Matlab string.
* @param matlab the matrix in matlab format
* @return the matrix represented by the given string
* @see #toMatlab()
*/
public static Matrix parseMatlab(String matlab) throws Exception {
return new Matrix(weka.core.matrix.Matrix.parseMatlab(matlab).getArray());
}
/**
* Returns the revision string.
*
* @return the revision
*/
public String getRevision() {
return RevisionUtils.extract("$Revision: 8034 $");
}
/**
* Main method for testing this class.
*/
public static void main(String[] ops) {
double[] first = {2.3, 1.2, 5};
double[] second = {5.2, 1.4, 9};
double[] response = {4, 7, 8};
double[] weights = {1, 2, 3};
try {
// test eigenvaluedecomposition
double[][] m = {{1, 2, 3}, {2, 5, 6},{3, 6, 9}};
Matrix M = new Matrix(m);
int n = M.numRows();
double[][] V = new double[n][n];
double[] d = new double[n];
double[] e = new double[n];
M.eigenvalueDecomposition(V, d);
Matrix v = new Matrix(V);
// M.testEigen(v, d, );
// end of test-eigenvaluedecomposition
Matrix a = new Matrix(2, 3);
Matrix b = new Matrix(3, 2);
System.out.println("Number of columns for a: " + a.numColumns());
System.out.println("Number of rows for a: " + a.numRows());
a.setRow(0, first);
a.setRow(1, second);
b.setColumn(0, first);
b.setColumn(1, second);
System.out.println("a:\n " + a);
System.out.println("b:\n " + b);
System.out.println("a (0, 0): " + a.getElement(0, 0));
System.out.println("a transposed:\n " + a.transpose());
System.out.println("a * b:\n " + a.multiply(b));
Matrix r = new Matrix(3, 1);
r.setColumn(0, response);
System.out.println("r:\n " + r);
System.out.println("Coefficients of regression of b on r: ");
double[] coefficients = b.regression(r, 1.0e-8);
for (int i = 0; i < coefficients.length; i++) {
System.out.print(coefficients[i] + " ");
}
System.out.println();
System.out.println("Weights: ");
for (int i = 0; i < weights.length; i++) {
System.out.print(weights[i] + " ");
}
System.out.println();
System.out.println("Coefficients of weighted regression of b on r: ");
coefficients = b.regression(r, weights, 1.0e-8);
for (int i = 0; i < coefficients.length; i++) {
System.out.print(coefficients[i] + " ");
}
System.out.println();
a.setElement(0, 0, 6);
System.out.println("a with (0, 0) set to 6:\n " + a);
a.write(new java.io.FileWriter("main.matrix"));
System.out.println("wrote matrix to \"main.matrix\"\n" + a);
a = new Matrix(new java.io.FileReader("main.matrix"));
System.out.println("read matrix from \"main.matrix\"\n" + a);
} catch (Exception e) {
e.printStackTrace();
}
}
}