Matrix (Smile Math 1.0.4 API)

java.lang.Object
- smile.math.matrix.Matrix

All Implemented Interfaces:

IMatrix
```
public class Matrix
extends Object
implements IMatrix
```
A matrix is a rectangular array of numbers. An item in a matrix is called an entry or an element. Entries are often denoted by a variable with two subscripts. Matrices of the same size can be added and subtracted entrywise and matrices of compatible size can be multiplied. These operations have many of the properties of ordinary arithmetic, except that matrix multiplication is not commutative, that is, AB and BA are not equal in general.
Matrices are a key tool in linear algebra. One use of matrices is to represent linear transformations and matrix multiplication corresponds to composition of linear transformations. Matrices can also keep track of the coefficients in a system of linear equations. For a square matrix, the determinant and inverse matrix (when it exists) govern the behavior of solutions to the corresponding system of linear equations, and eigenvalues and eigenvectors provide insight into the geometry of the associated linear transformation.
There are several methods to render matrices into a more easily accessible form. They are generally referred to as matrix transformation or matrix decomposition techniques. The interest of all these decomposition techniques is that they preserve certain properties of the matrices in question, such as determinant, rank or inverse, so that these quantities can be calculated after applying the transformation, or that certain matrix operations are algorithmically easier to carry out for some types of matrices.
The LU decomposition factors matrices as a product of lower (L) and an upper triangular matrices (U). Once this decomposition is calculated, linear systems can be solved more efficiently, by a simple technique called forward and back substitution. Likewise, inverses of triangular matrices are algorithmically easier to calculate. The QR decomposition factors matrices as a product of an orthogonal (Q) and a right triangular matrix (R). QR decomposition is often used to solve the linear least squares problem, and is the basis for a particular eigenvalue algorithm, the QR algorithm. Singular value decomposition expresses any matrix A as a product UDV', where U and V are unitary matrices and D is a diagonal matrix. The eigendecomposition or diagonalization expresses A as a product VDV^-1, where D is a diagonal matrix and V is a suitable invertible matrix. If A can be written in this form, it is called diagonalizable.

Author:

Haifeng Li

Constructor Summary

Constructors
Constructor and Description
`Matrix(double[][] A)` Constructor.
`Matrix(double[][] A, boolean symmetric)` Constructor.
`Matrix(double[][] A, boolean symmetric, boolean positive)` Constructor.
`Matrix(int rows, int cols)` Constructor of all-zero matrix.
`Matrix(int rows, int cols, double value)` Constructor.
`Matrix(int rows, int cols, double mu, double sigma)` Constructor of matrix with normal random values with given mean and standard dev.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Matrix`	`add(Matrix b)` A = A + B
`double[][]`	`array()` Return the two-dimensional array of matrix.
`void`	`asolve(double[] b, double[] x)` Solve A_d * x = b for the preconditioner matrix A_d.
`void`	`atx(double[] x, double[] y)` y = A' * x
`void`	`atxpy(double[] x, double[] y)` y = A' * x + y
`void`	`atxpy(double[] x, double[] y, double b)` y = A' * x + b * y
`void`	`ax(double[] x, double[] y)` y = A * x
`void`	`axpy(double[] x, double[] y)` y = A * x + y
`void`	`axpy(double[] x, double[] y, double b)` y = A * x + b * y
`CholeskyDecomposition`	`cholesky()` Returns the Cholesky decomposition.
`double`	`det()` Returns the matrix determinant.
`Matrix`	`divide(double x)` Element-wise division A = A / x
`EigenValueDecomposition`	`eigen()` Returns the eigen value decomposition.
`double`	`eigen(double[] v)` Returns the largest eigen pair of matrix with the power iteration under the assumptions A has an eigenvalue that is strictly greater in magnitude than its other eigenvalues and the starting vector has a nonzero component in the direction of an eigenvector associated with the dominant eigenvalue.
`EigenValueDecomposition`	`eigen(int k)` Returns the k largest eigen pairs.
`double`	`get(int i, int j)` Returns the entry value at row i and column j.
`void`	`improve(double[] b, double[] x)` Iteratively improve a solution to linear equations.
`double[][]`	`inverse()` Returns the matrix inverse or pseudo inverse.
`LUDecomposition`	`LU()` Returns the LU decomposition.
`int`	`ncols()` Returns the number of columns.
`int`	`nrows()` Returns the number of rows.
`QRDecomposition`	`QR()` Returns the QR decomposition.
`int`	`rank()` Returns the matrix rank.
`Matrix`	`replaceNaN(double x)` Replaces NaN's with given value.
`Matrix`	`scale(double x)` Element-wise multiplication A = A * x
`Matrix`	`set(int i, int j, double x)` Set the entry value at row i and column j.
`void`	`setDiag(double[] diag)` Sets the diagonal to the values of `diag` as long as possible (i.e while there are elements left in diag or the dim of matrix is not big enough.
`double[]`	`solve(double[] b)` Solve A*x = b in place (exact solution if A is square, least squares solution otherwise), which means the results will be stored in b.
`double[][]`	`solve(double[][] B)` Solve A*X = B in place (exact solution if A is square, least squares solution otherwise), which means the results will be stored in B.
`double`	`sum()` Returns the sum of all elements in the matrix.
`SingularValueDecomposition`	`svd()` Returns the singular value decomposition.
`double`	`trace()` Returns the matrix trace.
`Matrix`	`transpose()` Returns the matrix transpose.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Matrix
```
public Matrix(double[][] A)
```
    Constructor. Note that this is a shallow copy of A.
    
    Parameters:
    
    A - the array of matrix.
  - Matrix
```
public Matrix(double[][] A,
              boolean symmetric)
```
    Constructor. Note that this is a shallow copy of A. If the matrix is updated, no check on if the matrix is symmetric.
    
    Parameters:
    
    A - the array of matrix.
    
    symmetric - true if the matrix is symmetric.
  - Matrix
```
public Matrix(double[][] A,
              boolean symmetric,
              boolean positive)
```
    Constructor. Note that this is a shallow copy of A. If the matrix is updated, no check on if the matrix is symmetric and/or positive definite. The symmetric and positive definite properties are intended for read-only matrices.
    
    Parameters:
    
    A - the array of matrix.
    
    symmetric - true if the matrix is symmetric.
    
    positive - true if the matrix is positive definite.
  - Matrix
```
public Matrix(int rows,
              int cols)
```
    Constructor of all-zero matrix.
  - Matrix
```
public Matrix(int rows,
              int cols,
              double value)
```
    Constructor. Fill the matrix with given value.
  - Matrix
```
public Matrix(int rows,
              int cols,
              double mu,
              double sigma)
```
    Constructor of matrix with normal random values with given mean and standard dev.
- Method Detail
  - array
```
public double[][] array()
```
    Return the two-dimensional array of matrix.
    
    Returns:
    
    the two-dimensional array of matrix.
  - setDiag
```
public void setDiag(double[] diag)
```
    Sets the diagonal to the values of diag as long as possible (i.e while there are elements left in diag or the dim of matrix is not big enough.
  - nrows
```
public int nrows()
```
    Description copied from interface: IMatrix
    
    Returns the number of rows.
    
    Specified by:
    
    nrows in interface IMatrix
  - ncols
```
public int ncols()
```
    Description copied from interface: IMatrix
    
    Returns the number of columns.
    
    Specified by:
    
    ncols in interface IMatrix
  - get
```
public double get(int i,
                  int j)
```
    Description copied from interface: IMatrix
    
    Returns the entry value at row i and column j.
    
    Specified by:
    
    get in interface IMatrix
  - set
```
public Matrix set(int i,
                  int j,
                  double x)
```
    Description copied from interface: IMatrix
    
    Set the entry value at row i and column j.
    
    Specified by:
    
    set in interface IMatrix
  - ax
```
public void ax(double[] x,
               double[] y)
```
    Description copied from interface: IMatrix
    
    y = A * x
    
    Specified by:
    
    ax in interface IMatrix
  - axpy
```
public void axpy(double[] x,
                 double[] y)
```
    Description copied from interface: IMatrix
    
    y = A * x + y
    
    Specified by:
    
    axpy in interface IMatrix
  - axpy
```
public void axpy(double[] x,
                 double[] y,
                 double b)
```
    Description copied from interface: IMatrix
    
    y = A * x + b * y
    
    Specified by:
    
    axpy in interface IMatrix
  - atx
```
public void atx(double[] x,
                double[] y)
```
    Description copied from interface: IMatrix
    
    y = A' * x
    
    Specified by:
    
    atx in interface IMatrix
  - atxpy
```
public void atxpy(double[] x,
                  double[] y)
```
    Description copied from interface: IMatrix
    
    y = A' * x + y
    
    Specified by:
    
    atxpy in interface IMatrix
  - atxpy
```
public void atxpy(double[] x,
                  double[] y,
                  double b)
```
    Description copied from interface: IMatrix
    
    y = A' * x + b * y
    
    Specified by:
    
    atxpy in interface IMatrix
  - asolve
```
public void asolve(double[] b,
                   double[] x)
```
    Description copied from interface: IMatrix
    
    Solve A_d * x = b for the preconditioner matrix A_d. The preconditioner matrix A_d is close to A and should be easy to solve for linear systems. This method is useful for preconditioned conjugate gradient method. The preconditioner matrix could be as simple as the trivial diagonal part of A in some cases.
    
    Specified by:
    
    asolve in interface IMatrix
  - add
```
public Matrix add(Matrix b)
```
    A = A + B
    
    Returns:
    
    this matrix
  - scale
```
public Matrix scale(double x)
```
    Element-wise multiplication A = A * x
  - divide
```
public Matrix divide(double x)
```
    Element-wise division A = A / x
  - replaceNaN
```
public Matrix replaceNaN(double x)
```
    Replaces NaN's with given value.
  - sum
```
public double sum()
```
    Returns the sum of all elements in the matrix.
    
    Returns:
    
    the sum of all elements.
  - transpose
```
public Matrix transpose()
```
    Returns the matrix transpose.
  - inverse
```
public double[][] inverse()
```
    Returns the matrix inverse or pseudo inverse.
    
    Returns:
    
    inverse of A if A is square, pseudo inverse otherwise.
  - trace
```
public double trace()
```
    Returns the matrix trace. The sum of the diagonal elements.
  - det
```
public double det()
```
    Returns the matrix determinant.
  - rank
```
public int rank()
```
    Returns the matrix rank.
    
    Returns:
    
    effective numerical rank.
  - eigen
```
public double eigen(double[] v)
```
    Returns the largest eigen pair of matrix with the power iteration under the assumptions A has an eigenvalue that is strictly greater in magnitude than its other eigenvalues and the starting vector has a nonzero component in the direction of an eigenvector associated with the dominant eigenvalue.
    
    Parameters:
    
    v - on input, it is the non-zero initial guess of the eigen vector. On output, it is the eigen vector corresponding largest eigen value.
    
    Returns:
    
    the largest eigen value.
  - eigen
```
public EigenValueDecomposition eigen()
```
    Returns the eigen value decomposition.
  - eigen
```
public EigenValueDecomposition eigen(int k)
```
    Returns the k largest eigen pairs. Only works for symmetric matrix.
  - svd
```
public SingularValueDecomposition svd()
```
    Returns the singular value decomposition.
  - LU
```
public LUDecomposition LU()
```
    Returns the LU decomposition.
  - cholesky
```
public CholeskyDecomposition cholesky()
```
    Returns the Cholesky decomposition.
  - QR
```
public QRDecomposition QR()
```
    Returns the QR decomposition.
  - solve
```
public double[] solve(double[] b)
```
    Solve A*x = b in place (exact solution if A is square, least squares solution otherwise), which means the results will be stored in b.
    
    Returns:
    
    the solution matrix, actually b.
  - solve
```
public double[][] solve(double[][] B)
```
    Solve A*X = B in place (exact solution if A is square, least squares solution otherwise), which means the results will be stored in B.
    
    Returns:
    
    the solution matrix, actually B.
  - improve
```
public void improve(double[] b,
                    double[] x)
```
    Iteratively improve a solution to linear equations.
    
    Parameters:
    
    b - right hand side of linear equations.
    
    x - a solution to linear equations.

Class Matrix

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Matrix

Matrix

Matrix

Matrix

Matrix

Matrix

Method Detail

array

setDiag

nrows

ncols

get

set

ax

axpy

axpy

atx

atxpy

atxpy

asolve

add

scale

divide

replaceNaN

sum

transpose

inverse

trace

det

rank

eigen

eigen

eigen

svd

LU

cholesky

QR

solve

solve

improve