Matrix (Smile Math 1.0.3 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.

Method Summary

Methods
Modifier and Type	Method and Description
`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.
`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.
`void`	`set(int i, int j, double x)` Set the entry value at row i and column j.
`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.
`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.
    
    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.
    
    Parameters:
    A - the array of matrix.
    symmetric - true if the matrix is symmetric.
    positive - true if the matrix is positive definite.
- Method Detail
  - 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 void 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
  - 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

Method Detail

nrows

ncols

get

set

ax

axpy

axpy

atx

atxpy

atxpy

asolve

transpose

inverse

trace

det

rank

eigen

eigen

eigen

svd

LU

cholesky

QR

solve

solve

improve