PaceMatrix (Documentation for extended WEKA including Ensembles of Hierarchically Nested Dichotomies)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.functions.pace
Class PaceMatrix

java.lang.Object
  weka.classifiers.functions.pace.Matrix
      weka.classifiers.functions.pace.PaceMatrix

All Implemented Interfaces:: java.lang.Cloneable, java.io.Serializable

public class PaceMatrix
extends Matrix

Class for matrix manipulation used for pace regression.

REFERENCES

Wang, Y. (2000). "A new approach to fitting linear models in high dimensional spaces." PhD Thesis. Department of Computer Science, University of Waikato, New Zealand.

Wang, Y. and Witten, I. H. (2002). "Modeling for optimal probability prediction." Proceedings of ICML'2002. Sydney.

Version:: $Revision: 1.1 $
Author:: Yong Wang (yongwang@cs.waikato.ac.nz)
See Also:: Serialized Form

Field Summary

Fields inherited from class weka.classifiers.functions.pace.Matrix

A, m, n

Constructor Summary
`PaceMatrix(double[][] A)` Construct a PACE matrix from a 2-D array.
`PaceMatrix(double[][] A, int m, int n)` Construct a PACE matrix quickly without checking arguments.
`PaceMatrix(double[] vals, int m)` Construct a PaceMatrix from a one-dimensional packed array
`PaceMatrix(DoubleVector v)` Construct a PaceMatrix with a single column from a DoubleVector
`PaceMatrix(int m, int n)` Construct an m-by-n PACE matrix of zeros.
`PaceMatrix(int m, int n, double s)` Construct an m-by-n constant PACE matrix.
`PaceMatrix(Matrix X)` Construct a PaceMatrix from a Matrix

Method Summary
`void`	`backward(PaceMatrix b, IntVector pvt, int ks, int k0)` Backward ordering of columns in terms of response explanation.
`PaceMatrix`	`cbind(PaceMatrix b)` Returns a new matrix which binds two matrices with columns.
`java.lang.Object`	`clone()` Clone the PaceMatrix object.
`double`	`columnResponseExplanation(PaceMatrix b, IntVector pvt, int j, int ks)` Returns the squared ks-th response value if the j-th column becomes the ks-th after orthogonal transformation.
`protected java.text.DecimalFormat[]`	`format()` Decimal format for converting a matrix into a string
`protected java.text.DecimalFormat[]`	`format(int digits)` Decimal format for converting a matrix into a string
`protected java.text.DecimalFormat[]`	`format(int digits, boolean trailing)` Decimal format for converting a matrix into a string
`protected java.text.DecimalFormat`	`format(int i0, int i1, int j, int digits, boolean trailing)` Decimal format for converting a matrix into a string
`protected java.text.DecimalFormat[]`	`format(int i0, int i1, int j0, int j1, int digits, boolean trailing)` Decimal format for converting a matrix into a string
`void`	`forward(PaceMatrix b, IntVector pvt, int k0)` Forward ordering of columns in terms of response explanation.
`double[]`	`g1(double a, double b)` Constructs the Givens rotation
`void`	`g2(double[] cs, int i0, int i1, int j)`
`DoubleVector`	`getColumn(int j)` Return a DoubleVector that stores a column of the matrix
`DoubleVector`	`getColumn(int i0, int i1, int j)` Return a DoubleVector that stores some elements of a column of the matrix
`double[]`	`h1(int j, int k)` Constructs single Householder transformation for a column
`void`	`h2(int j, int k, double q, PaceMatrix b, int l)` Performs single Householder transformation on one column of a matrix
`boolean`	`isEmpty()` Check if the matrix is empty
`int`	`leastExplainingColumn(PaceMatrix b, IntVector pvt, int ks, int k0)` Returns the index of the column that has the smallest (squared) response, when the column is moved to become the (ks-1)-th column.
`void`	`lsqr(PaceMatrix b, IntVector pvt, int k0)` QR transformation for a least squares problem A x = b
`void`	`lsqrSelection(PaceMatrix b, IntVector pvt, int k0)` QR transformation for a least squares problem A x = b
`static void`	`main(java.lang.String[] args)`
`double`	`maxAbs()` Returns the maximum absolute value of all elements
`double`	`maxAbs(int i0, int i1, int j)` Returns the maximum absolute value of some elements of a column, that is, the elements of A[i0:i1][j].
`double`	`minAbs(int i0, int i1, int column)` Returns the minimum absolute value of some elements of a column, that is, the elements of A[i0:i1][j].
`int`	`mostExplainingColumn(PaceMatrix b, IntVector pvt, int ks)` Returns the index of the column that has the largest (squared) response, when each of columns pvt[ks:] is moved to become the ks-th column.
`DoubleVector`	`nnls(PaceMatrix b, IntVector pvt)` Solves the nonnegative linear squares problem.
`DoubleVector`	`nnlse(PaceMatrix b, PaceMatrix c, PaceMatrix d, IntVector pvt)` Solves the nonnegative least squares problem with equality constraint.
`DoubleVector`	`nnlse1(PaceMatrix b, IntVector pvt)` Solves the nonnegative least squares problem with equality constraint.
`void`	`positiveDiagonal(PaceMatrix Y, IntVector pvt)` Sets all diagonal elements to be positive (or nonnegative) without changing the least squares solution
`static Matrix`	`randomNormal(int m, int n)` Generate matrix with standard-normally distributed random elements
`PaceMatrix`	`rbind(PaceMatrix b)` Returns a new matrix which binds two matrices together with rows.
`void`	`rsolve(PaceMatrix b, IntVector pvt, int kp)` Solves upper-triangular equation R x = b
`void`	`setColumnDimension(int columnDimension)` Set the column dimenion of the matrix
`void`	`setMatrix(double[] v, boolean columnFirst)` Set the whole matrix from a 1-D array
`void`	`setMatrix(int i0, int i1, int j, DoubleVector v)` Set the submatrix A[i0:i1][j] with the values stored in a DoubleVector
`void`	`setMatrix(int i0, int i1, int j0, int j1, double s)` Set the submatrix A[i0:i1][j0:j1] with a same value
`void`	`setPlus(int i, int j, double s)` Add a value to an element and reset the element
`void`	`setRowDimension(int rowDimension)` Set the row dimenion of the matrix
`void`	`setTimes(int i, int j, double s)` Multiply a value with an element and reset the element
`void`	`steplsqr(PaceMatrix b, IntVector pvt, int ks, int j, boolean adjoin)` Stepwise least squares QR-decomposition of the problem A x = b
`double[]`	`sum2(boolean col)` Squared sum of columns or rows of a matrix
`double`	`sum2(int j, int i0, int i1, boolean col)` Squared sum of a column or row in a matrix
`double`	`times(int i, int j0, int j1, PaceMatrix B, int l)` Multiplication between a row (or part of a row) of the first matrix and a column (or part or a column) of the second matrix.
`java.lang.String`	`toString()` Converts matrix to string
`java.lang.String`	`toString(int digits, boolean trailing)` Converts matrix to string

Methods inherited from class weka.classifiers.functions.pace.Matrix

arrayLeftDivide, arrayLeftDivideEquals, arrayRightDivide, arrayRightDivideEquals, arrayTimes, arrayTimesEquals, constructWithCopy, copy, get, getArray, getArrayCopy, getColumnDimension, getColumnPackedCopy, getMatrix, getMatrix, getMatrix, getMatrix, getRowDimension, getRowPackedCopy, identity, minus, minusEquals, norm1, normF, normInf, plus, plusEquals, print, print, print, print, random, read, set, setMatrix, setMatrix, setMatrix, setMatrix, times, times, timesEquals, trace, transpose, uminus

Methods inherited from class java.lang.Object

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

Constructor Detail

PaceMatrix

public PaceMatrix(int m,
                  int n)

Construct an m-by-n PACE matrix of zeros.
Parameters:: m - Number of rows.; n - Number of colums.

PaceMatrix

public PaceMatrix(int m,
                  int n,
                  double s)

Construct an m-by-n constant PACE matrix.
Parameters:: m - Number of rows.; n - Number of colums.; s - Fill the matrix with this scalar value.

PaceMatrix

public PaceMatrix(double[][] A)

Construct a PACE matrix from a 2-D array.
Parameters:: A - Two-dimensional array of doubles.
Throws:: java.lang.IllegalArgumentException - All rows must have the same length

PaceMatrix

public PaceMatrix(double[][] A,
                  int m,
                  int n)

Construct a PACE matrix quickly without checking arguments.
Parameters:: A - Two-dimensional array of doubles.; m - Number of rows.; n - Number of colums.

PaceMatrix

public PaceMatrix(double[] vals,
                  int m)

Construct a PaceMatrix from a one-dimensional packed array
Parameters:: vals - One-dimensional array of doubles, packed by columns (ala Fortran).; m - Number of rows.
Throws:: java.lang.IllegalArgumentException - Array length must be a multiple of m.

PaceMatrix

public PaceMatrix(DoubleVector v)

Construct a PaceMatrix with a single column from a DoubleVector
Parameters:: v - DoubleVector

PaceMatrix

public PaceMatrix(Matrix X)

Construct a PaceMatrix from a Matrix
Parameters:: X - Matrix

Method Detail

setRowDimension

public void setRowDimension(int rowDimension)

Set the row dimenion of the matrix

Parameters:: rowDimension - the row dimension

setColumnDimension

public void setColumnDimension(int columnDimension)

Set the column dimenion of the matrix

Parameters:: columnDimension - the column dimension

clone

public java.lang.Object clone()

Clone the PaceMatrix object.

Overrides:: clone in class Matrix

setPlus

public void setPlus(int i,
                    int j,
                    double s)

Add a value to an element and reset the element

Parameters:: i - the row number of the element; j - the column number of the element; s - the double value to be added with

setTimes

public void setTimes(int i,
                     int j,
                     double s)

Multiply a value with an element and reset the element

Parameters:: i - the row number of the element; j - the column number of the element; s - the double value to be multiplied with

setMatrix

public void setMatrix(int i0,
                      int i1,
                      int j0,
                      int j1,
                      double s)

Set the submatrix A[i0:i1][j0:j1] with a same value

Parameters:: i0 - the index of the first element of the column; i1 - the index of the last element of the column; j0 - the index of the first column; j1 - the index of the last column; s - the value to be set to

setMatrix

public void setMatrix(int i0,
                      int i1,
                      int j,
                      DoubleVector v)

Set the submatrix A[i0:i1][j] with the values stored in a DoubleVector

Parameters:: i0 - the index of the first element of the column; i1 - the index of the last element of the column; j - the index of the column; v - the vector that stores the values

setMatrix

public void setMatrix(double[] v,
                      boolean columnFirst)

Set the whole matrix from a 1-D array

Parameters:: v - 1-D array of doubles; columnFirst - Whether to fill the column first or the row.
Throws:: java.lang.ArrayIndexOutOfBoundsException - Submatrix indices

maxAbs

public double maxAbs()

Returns the maximum absolute value of all elements

Returns:: the maximum value

maxAbs

public double maxAbs(int i0,
                     int i1,
                     int j)

Returns the maximum absolute value of some elements of a column, that is, the elements of A[i0:i1][j].

Parameters:: i0 - the index of the first element of the column; i1 - the index of the last element of the column; j - the index of the column
Returns:: the maximum value

minAbs

public double minAbs(int i0,
                     int i1,
                     int column)

Returns the minimum absolute value of some elements of a column, that is, the elements of A[i0:i1][j].

Parameters:: i0 - the index of the first element of the column; i1 - the index of the last element of the column
Returns:: the minimum value

isEmpty

public boolean isEmpty()

Check if the matrix is empty

Returns:: true if the matrix is empty

getColumn

public DoubleVector getColumn(int j)

Return a DoubleVector that stores a column of the matrix

Parameters:: j - the index of the column

getColumn

public DoubleVector getColumn(int i0,
                              int i1,
                              int j)

Return a DoubleVector that stores some elements of a column of the matrix

Parameters:: i0 - the index of the first element of the column; i1 - the index of the last element of the column; j - the index of the column
Returns:: the DoubleVector

times

public double times(int i,
                    int j0,
                    int j1,
                    PaceMatrix B,
                    int l)

Multiplication between a row (or part of a row) of the first matrix and a column (or part or a column) of the second matrix.

Parameters:: i - the index of the row in the first matrix; j0 - the index of the first column in the first matrix; j1 - the index of the last column in the first matrix; B - the second matrix; l - the index of the column in the second matrix