Matrix

java.lang.Object
- smile.math.matrix.IMatrix<double[]>
- - smile.math.matrix.DMatrix
  - - smile.math.matrix.Matrix

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable
```
public class Matrix
extends DMatrix
```
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Matrix.Cholesky` The Cholesky decomposition of a symmetric, positive-definite matrix.
`static class`	`Matrix.EVD` Eigenvalue decomposition.
`static class`	`Matrix.LU` The LU decomposition.
`static class`	`Matrix.QR` The QR decomposition.
`static class`	`Matrix.SVD` Singular Value Decomposition.

Constructor Summary

Constructors
Constructor and Description
`Matrix(double[] A)` Constructor of a column vector/matrix with given array as the internal storage.
`Matrix(double[][] A)` Constructor.
`Matrix(double[] A, int offset, int length)` Constructor of a column vector/matrix with given array as the internal storage.
`Matrix(int m, int n)` Constructor of zero matrix.
`Matrix(int m, int n, double a)` Constructor.
`Matrix(int m, int n, double[][] A)` Constructor.
`Matrix(int m, int n, int ld, java.nio.DoubleBuffer A)` Constructor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Matrix`	`aat()` Returns A * A'
`Matrix`	`adb(Transpose transA, Transpose transB, Matrix B, double[] diag)` Returns A * D * B, where D is a diagonal matrix.
`Matrix`	`add(double b)` A += b
`Matrix`	`add(double alpha, double[] x, double[] y)` Rank-1 update A += alpha * x * y'
`Matrix`	`add(double alpha, double beta, Matrix B)` Element-wise addition A = alpha * A + beta * B
`Matrix`	`add(double alpha, Matrix B)` Element-wise addition A += alpha * B
`Matrix`	`add(double alpha, Matrix A, double beta, Matrix B)` Element-wise addition C = alpha * A + beta * B
`double`	`add(int i, int j, double b)` A[i,j] += b
`double`	`add(int i, int j, double alpha, double beta)` A[i,j] = alpha * A[i,j] + beta
`Matrix`	`add(int i, int j, double alpha, double beta, Matrix B)` Element-wise submatrix addition A[i, j] = alpha * A[i, j] + beta * B
`Matrix`	`add(int i, int j, double alpha, Matrix B)` Element-wise submatrix addition A[i, j] += alpha * B
`Matrix`	`add(Matrix B)` Element-wise addition A += B
`Matrix`	`ata()` Returns A' * A
`Matrix.Cholesky`	`cholesky()` Cholesky decomposition for symmetric and positive definite matrix.
`Matrix.Cholesky`	`cholesky(boolean overwrite)` Cholesky decomposition for symmetric and positive definite matrix.
`Matrix`	`clone()` Returns a deep copy of matrix.
`Matrix`	`col(int... cols)` Returns the matrix of selected columns.
`double[]`	`col(int j)` Returns the j-th column.
`double[]`	`colMeans()` Returns the mean of each column.
`double[]`	`colSds()` Returns the standard deviations of each column.
`double[]`	`colSums()` Returns the sum of each column.
`static Matrix`	`diag(double[] diag)` Returns a square diagonal matrix with the elements of vector v on the main diagonal.
`Matrix`	`div(double b)` A /= b
`Matrix`	`div(double alpha, Matrix B)` Element-wise division A /= alpha * B
`Matrix`	`div(double alpha, Matrix A, Matrix B)` Element-wise division C = alpha * A / B
`double`	`div(int i, int j, double b)` A[i,j] /= b
`Matrix`	`div(int i, int j, double alpha, Matrix B)` Element-wise submatrix division A[i, j] /= alpha * B
`Matrix`	`div(Matrix B)` Element-wise division A /= B
`Matrix.EVD`	`eigen()` Eigenvalue Decomposition.
`Matrix.EVD`	`eigen(boolean vl, boolean vr, boolean overwrite)` Eigenvalue Decomposition.
`boolean`	`equals(Matrix o, double eps)` Returns if two matrices equals given an error margin.
`boolean`	`equals(java.lang.Object o)`
`static Matrix`	`eye(int n)` Returns an n-by-n identity matrix.
`static Matrix`	`eye(int m, int n)` Returns an m-by-n identity matrix.
`void`	`fill(double x)` Fill the matrix with a value.
`double`	`get(int i, int j)` Returns A[i, j].
`protected int`	`index(int i, int j)` Returns the linear index of matrix element.
`Matrix`	`inverse()` Returns the inverse matrix.
`boolean`	`isSubmatrix()` Returns if the matrix is a submatrix.
`boolean`	`isSymmetric()` Return if the matrix is symmetric (uplo != null && diag == null).
`Layout`	`layout()` Returns the matrix layout.
`int`	`ld()` Returns the leading dimension.
`Matrix.LU`	`lu()` LU decomposition.
`Matrix.LU`	`lu(boolean overwrite)` LU decomposition.
`Matrix`	`mm(Matrix B)` Returns matrix multiplication A * B.
`void`	`mm(Transpose transA, Transpose transB, double alpha, Matrix B, double beta, Matrix C)` Matrix-matrix multiplication.
`Matrix`	`mt(Matrix B)` Returns matrix multiplication A * B'.
`Matrix`	`mul(double b)` A *= b
`Matrix`	`mul(double alpha, Matrix B)` Element-wise multiplication A = alpha B
`Matrix`	`mul(double alpha, Matrix A, Matrix B)` Element-wise multiplication C = alpha * A * B
`double`	`mul(int i, int j, double b)` A[i,j] *= b
`Matrix`	`mul(int i, int j, double alpha, Matrix B)` Element-wise submatrix multiplication A[i, j] = alpha B
`Matrix`	`mul(Matrix B)` Element-wise multiplication A *= B
`void`	`mv(double[] work, int inputOffset, int outputOffset)` Matrix-vector multiplication A * x.
`void`	`mv(Transpose trans, double alpha, double[] x, double beta, double[] y)` Matrix-vector multiplication.
`void`	`mv(Transpose trans, double alpha, java.nio.DoubleBuffer x, double beta, java.nio.DoubleBuffer y)` Matrix-vector multiplication.
`int`	`ncols()` Returns the number of columns.
`double`	`norm()` L2 matrix norm.
`double`	`norm1()` L1 matrix norm.
`double`	`norm2()` L2 matrix norm.
`double`	`normFro()` Frobenius matrix norm.
`double`	`normInf()` Infinity matrix norm.
`int`	`nrows()` Returns the number of rows.
`static Matrix`	`of(Layout layout, int m, int n)` Creates a matrix.
`static Matrix`	`of(Layout layout, int m, int n, int ld, java.nio.DoubleBuffer A)` Creates a matrix.
`Matrix.QR`	`qr()` QR Decomposition.
`Matrix.QR`	`qr(boolean overwrite)` QR Decomposition.
`static Matrix`	`rand(int m, int n, Distribution distribution)` Returns a random matrix.
`static Matrix`	`rand(int m, int n, double lo, double hi)` Returns a random matrix of uniform distribution.
`static Matrix`	`randn(int m, int n)` Returns a random matrix of standard normal distribution.
`Matrix`	`replaceNaN(double x)` Replaces NaN's with given value.
`Matrix`	`row(int... rows)` Returns the matrix of selected rows.
`double[]`	`row(int i)` Returns the i-th row.
`double[]`	`rowMeans()` Returns the mean of each row.
`double[]`	`rowSds()` Returns the standard deviations of each row.
`double[]`	`rowSums()` Returns the sum of each row.
`Matrix`	`scale()` Centers and scales the columns of matrix.
`Matrix`	`scale(double[] center, double[] scale)` Centers and scales the columns of matrix.
`Matrix`	`set(int i, int j, double x)` Sets A[i, j] = x.
`Matrix`	`set(int i, int j, Matrix B)` Sets submatrix A[i,j] = B.
`long`	`size()` Returns the number of stored matrix elements.
`Matrix`	`sub(double b)` A -= b
`Matrix`	`sub(double alpha, Matrix B)` Element-wise subtraction A -= alpha * B
`Matrix`	`sub(double alpha, Matrix A, double beta, Matrix B)` Element-wise subtraction C = alpha * A - beta * B
`double`	`sub(int i, int j, double b)` A[i,j] -= b
`Matrix`	`sub(int i, int j, double alpha, Matrix B)` Element-wise submatrix subtraction A[i, j] -= alpha * B
`Matrix`	`sub(Matrix B)` Element-wise subtraction A -= B
`Matrix`	`submatrix(int i, int j, int k, int l)` Returns the submatrix which top left at (i, j) and bottom right at (k, l).
`double`	`sum()` Returns the sum of all elements in the matrix.
`Matrix.SVD`	`svd()` Singular Value Decomposition.
`Matrix.SVD`	`svd(boolean vectors, boolean overwrite)` Singular Value Decomposition.
`Matrix`	`tm(Matrix B)` Returns matrix multiplication A' * B.
`double[][]`	`toArray()` Return the two-dimensional array of matrix.
`static Matrix`	`toeplitz(double[] a)` Returns a symmetric Toeplitz matrix in which each descending diagonal from left to right is constant.
`static Matrix`	`toeplitz(double[] kl, double[] ku)` Returns a Toeplitz matrix in which each descending diagonal from left to right is constant.
`Matrix`	`transpose()` Returns the transpose of matrix.
`Diag`	`triangular()` Gets the flag if a triangular matrix has unit diagonal elements.
`Matrix`	`triangular(Diag diag)` Sets/unsets if the matrix is triangular.
`Matrix`	`tt(Matrix B)` Returns matrix multiplication A' * B'.
`void`	`tv(double[] work, int inputOffset, int outputOffset)` Matrix-vector multiplication A' * x.
`UPLO`	`uplo()` Gets the format of packed matrix.
`Matrix`	`uplo(UPLO uplo)` Sets the format of packed matrix.
`double`	`xAx(double[] x)` Returns x' * A * x.

Methods inherited from class smile.math.matrix.DMatrix
apply, diag, market, mv, mv, mv, trace, tv, tv, tv, update

Methods inherited from class smile.math.matrix.IMatrix
colName, colNames, colNames, rowName, rowNames, rowNames, toString, toString, toString

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

- Constructor Detail
  - Matrix
```
public Matrix(int m,
              int n)
```
    Constructor of zero matrix.
    
    Parameters:
    
    m - the number of rows.
    
    n - the number of columns.
  - Matrix
```
public Matrix(int m,
              int n,
              double a)
```
    Constructor. Fills the matrix with given value.
    
    Parameters:
    
    m - the number of rows.
    
    n - the number of columns.
    
    a - the initial value.
  - Matrix
```
public Matrix(int m,
              int n,
              double[][] A)
```
    Constructor.
    
    Parameters:
    
    m - the number of rows.
    
    n - the number of columns.
    
    A - the array of matrix.
  - Matrix
```
public Matrix(double[][] A)
```
    Constructor.
    
    Parameters:
    
    A - the array of matrix.
  - Matrix
```
public Matrix(double[] A)
```
    Constructor of a column vector/matrix with given array as the internal storage.
    
    Parameters:
    
    A - The array of column vector.
  - Matrix
```
public Matrix(double[] A,
              int offset,
              int length)
```
    Constructor of a column vector/matrix with given array as the internal storage.
    
    Parameters:
    
    A - The array of column vector.
    
    offset - The offset of the subarray to be used; must be non-negative and no larger than array.length.
    
    length - The length of the subarray to be used; must be non-negative and no larger than array.length - offset.
  - Matrix
```
public Matrix(int m,
              int n,
              int ld,
              java.nio.DoubleBuffer A)
```
    Constructor.
    
    Parameters:
    
    m - the number of rows.
    
    n - the number of columns.
    
    ld - the leading dimension.
    
    A - the matrix storage.
- Method Detail
  - of
```
public static Matrix of(Layout layout,
                        int m,
                        int n)
```
    Creates a matrix.
    
    Parameters:
    
    layout - the matrix layout.
    
    m - the number of rows.
    
    n - the number of columns.
  - of
```
public static Matrix of(Layout layout,
                        int m,
                        int n,
                        int ld,
                        java.nio.DoubleBuffer A)
```
    Creates a matrix.
    
    Parameters:
    
    layout - the matrix layout.
    
    m - the number of rows.
    
    n - the number of columns.
    
    ld - the leading dimension.
    
    A - the matrix storage.
  - eye
```
public static Matrix eye(int n)
```
    Returns an n-by-n identity matrix.
    
    Parameters:
    
    n - the number of rows/columns.
  - eye
```
public static Matrix eye(int m,
                         int n)
```
    Returns an m-by-n identity matrix.
    
    Parameters:
    
    m - the number of rows.
    
    n - the number of columns.
  - randn
```
public static Matrix randn(int m,
                           int n)
```
    Returns a random matrix of standard normal distribution.
  - rand
```
public static Matrix rand(int m,
                          int n,
                          Distribution distribution)
```
    Returns a random matrix.
    
    Parameters:
    
    distribution - the distribution of random number.
  - rand
```
public static Matrix rand(int m,
                          int n,
                          double lo,
                          double hi)
```
    Returns a random matrix of uniform distribution.
    
    Parameters:
    
    lo - the lower bound of uniform distribution.
    
    hi - the upper bound of uniform distribution.
  - diag
```
public static Matrix diag(double[] diag)
```
    Returns a square diagonal matrix with the elements of vector v on the main diagonal.
    
    Parameters:
    
    diag - the diagonal elements.
  - toeplitz
```
public static Matrix toeplitz(double[] a)
```
    Returns a symmetric Toeplitz matrix in which each descending diagonal from left to right is constant.
    
    Parameters:
    
    a - A[i, j] = a[i - j] for i >= j (or a[j - i] when j > i)
  - toeplitz
```
public static Matrix toeplitz(double[] kl,
                              double[] ku)
```
    Returns a Toeplitz matrix in which each descending diagonal from left to right is constant.
    
    Parameters:
    
    kl - A[i, j] = kl[i - j] for i > j
    
    ku - A[i, j] = ku[j - i] for i <= j
  - nrows
```
public int nrows()
```
    Description copied from class: IMatrix
    
    Returns the number of rows.
    
    Specified by:
    
    nrows in class IMatrix<double[]>
  - ncols
```
public int ncols()
```
    Description copied from class: IMatrix
    
    Returns the number of columns.
    
    Specified by:
    
    ncols in class IMatrix<double[]>
  - size
```
public long size()
```
    Description copied from class: IMatrix
    
    Returns the number of stored matrix elements. For conventional matrix, it is simplify nrows * ncols. But it is usually much less for band, packed or sparse matrix.
    
    Specified by:
    
    size in class IMatrix<double[]>
  - layout
```
public Layout layout()
```
    Returns the matrix layout.
  - ld
```
public int ld()
```
    Returns the leading dimension.
  - isSubmatrix
```
public boolean isSubmatrix()
```
    Returns if the matrix is a submatrix.
  - isSymmetric
```
public boolean isSymmetric()
```
    Return if the matrix is symmetric (uplo != null && diag == null).
  - uplo
```
public Matrix uplo(UPLO uplo)
```
    Sets the format of packed matrix.
  - uplo
```
public UPLO uplo()
```
    Gets the format of packed matrix.
  - triangular
```
public Matrix triangular(Diag diag)
```
    Sets/unsets if the matrix is triangular.
    
    Parameters:
    
    diag - if not null, it specifies if the triangular matrix has unit diagonal elements.
  - triangular
```
public Diag triangular()
```
    Gets the flag if a triangular matrix has unit diagonal elements. Returns null if the matrix is not triangular.
  - clone
```
public Matrix clone()
```
    Returns a deep copy of matrix.
    
    Overrides:
    
    clone in class java.lang.Object
  - toArray
```
public double[][] toArray()
```
    Return the two-dimensional array of matrix.
    
    Returns:
    
    the two-dimensional array of matrix.
  - row
```
public double[] row(int i)
```
    Returns the i-th row.
  - col
```
public double[] col(int j)
```
    Returns the j-th column.
  - row
```
public Matrix row(int... rows)
```
    Returns the matrix of selected rows.
  - col
```
public Matrix col(int... cols)
```
    Returns the matrix of selected columns.
  - submatrix
```
public Matrix submatrix(int i,
                        int j,
                        int k,
                        int l)
```
    Returns the submatrix which top left at (i, j) and bottom right at (k, l). The content of the submatrix will be that of this matrix. Changes to this matrix's content will be visible in the submatrix, and vice versa.
    
    Parameters:
    
    i - the beginning row, inclusive.
    
    j - the beginning column, inclusive,
    
    k - the ending row, inclusive.
    
    l - the ending column, inclusive.
  - fill
```
public void fill(double x)
```
    Fill the matrix with a value.
  - transpose
```
public Matrix transpose()
```
    Returns the transpose of matrix.
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - equals
```
public boolean equals(Matrix o,
                      double eps)
```
    Returns if two matrices equals given an error margin.
    
    Parameters:
    
    o - the other matrix.
    
    eps - the error margin.
  - index
```
protected int index(int i,
                    int j)
```
    Returns the linear index of matrix element.
  - get
```
public double get(int i,
                  int j)
```
    Description copied from class: DMatrix
    
    Returns A[i, j].
    
    Specified by:
    
    get in class DMatrix
  - set
```
public Matrix set(int i,
                  int j,
                  double x)
```
    Description copied from class: DMatrix
    
    Sets A[i, j] = x.
    
    Specified by:
    
    set in class DMatrix
  - set
```
public Matrix set(int i,
                  int j,
                  Matrix B)
```
    Sets submatrix A[i,j] = B.
  - add
```
public double add(int i,
                  int j,
                  double b)
```
    A[i,j] += b
  - sub
```
public double sub(int i,
                  int j,
                  double b)
```
    A[i,j] -= b
  - mul
```
public double mul(int i,
                  int j,
                  double b)
```
    A[i,j] *= b
  - div
```
public double div(int i,
                  int j,
                  double b)
```
    A[i,j] /= b
  - add
```
public Matrix add(double b)
```
    A += b
  - sub
```
public Matrix sub(double b)
```
    A -= b
  - mul
```
public Matrix mul(double b)
```
    A *= b
  - div
```
public Matrix div(double b)
```
    A /= b
  - add
```
public Matrix add(int i,
                  int j,
                  double alpha,
                  Matrix B)
```
    Element-wise submatrix addition A[i, j] += alpha * B
  - sub
```
public Matrix sub(int i,
                  int j,
                  double alpha,
                  Matrix B)
```
    Element-wise submatrix subtraction A[i, j] -= alpha * B
  - mul
```
public Matrix mul(int i,
                  int j,
                  double alpha,
                  Matrix B)
```
    Element-wise submatrix multiplication A[i, j] *= alpha * B
  - div
```
public Matrix div(int i,
                  int j,
                  double alpha,
                  Matrix B)
```
    Element-wise submatrix division A[i, j] /= alpha * B
  - add
```
public Matrix add(Matrix B)
```
    Element-wise addition A += B
  - sub
```
public Matrix sub(Matrix B)
```
    Element-wise subtraction A -= B
  - mul
```
public Matrix mul(Matrix B)
```
    Element-wise multiplication A *= B
  - div
```
public Matrix div(Matrix B)
```
    Element-wise division A /= B
  - add
```
public Matrix add(double alpha,
                  Matrix B)
```
    Element-wise addition A += alpha * B
  - sub
```
public Matrix sub(double alpha,
                  Matrix B)
```
    Element-wise subtraction A -= alpha * B
  - mul
```
public Matrix mul(double alpha,
                  Matrix B)
```
    Element-wise multiplication A *= alpha * B
  - div
```
public Matrix div(double alpha,
                  Matrix B)
```
    Element-wise division A /= alpha * B
  - add
```
public Matrix add(double alpha,
                  Matrix A,
                  double beta,
                  Matrix B)
```
    Element-wise addition C = alpha * A + beta * B
  - sub
```
public Matrix sub(double alpha,
                  Matrix A,
                  double beta,
                  Matrix B)
```
    Element-wise subtraction C = alpha * A - beta * B
  - mul
```
public Matrix mul(double alpha,
                  Matrix A,
                  Matrix B)
```
    Element-wise multiplication C = alpha * A * B
  - div
```
public Matrix div(double alpha,
                  Matrix A,
                  Matrix B)
```
    Element-wise division C = alpha * A / B
  - add
```
public double add(int i,
                  int j,
                  double alpha,
                  double beta)
```
    A[i,j] = alpha * A[i,j] + beta
  - add
```
public Matrix add(int i,
                  int j,
                  double alpha,
                  double beta,
                  Matrix B)
```
    Element-wise submatrix addition A[i, j] = alpha * A[i, j] + beta * B
  - add
```
public Matrix add(double alpha,
                  double beta,
                  Matrix B)
```
    Element-wise addition A = alpha * A + beta * B
  - add
```
public Matrix add(double alpha,
                  double[] x,
                  double[] y)
```
    Rank-1 update A += alpha * x * y'
  - 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.
  - norm1
```
public double norm1()
```
    L1 matrix norm. Maximum column sum.
  - norm2
```
public double norm2()
```
    L2 matrix norm. Maximum singular value.
  - norm
```
public double norm()
```
    L2 matrix norm. Maximum singular value.
  - normInf
```
public double normInf()
```
    Infinity matrix norm. Maximum row sum.
  - normFro
```
public double normFro()
```
    Frobenius matrix norm. Sqrt of sum of squares of all elements.
  - xAx
```
public double xAx(double[] x)
```
    Returns x' * A * x. The left upper submatrix of A is used in the computation based on the size of x.
  - rowSums
```
public double[] rowSums()
```
    Returns the sum of each row.
  - rowMeans
```
public double[] rowMeans()
```
    Returns the mean of each row.
  - rowSds
```
public double[] rowSds()
```
    Returns the standard deviations of each row.
  - colSums
```
public double[] colSums()
```
    Returns the sum of each column.
  - colMeans
```
public double[] colMeans()
```
    Returns the mean of each column.
  - colSds
```
public double[] colSds()
```
    Returns the standard deviations of each column.
  - scale
```
public Matrix scale()
```
    Centers and scales the columns of matrix.
    
    Returns:
    
    a new matrix with zero mean and unit variance for each column.
  - scale
```
public Matrix scale(double[] center,
                    double[] scale)
```
    Centers and scales the columns of matrix.
    
    Parameters:
    
    center - column center. If null, no centering.
    
    scale - column scale. If null, no scaling.
    
    Returns:
    
    a new matrix with zero mean and unit variance for each column.
  - inverse
```
public Matrix inverse()
```
    Returns the inverse matrix.
  - mv
```
public void mv(Transpose trans,
               double alpha,
               java.nio.DoubleBuffer x,
               double beta,
               java.nio.DoubleBuffer y)
```
    Matrix-vector multiplication.
```
     y = alpha * A * x + beta * y
 
```
  - mv
```
public void mv(Transpose trans,
               double alpha,
               double[] x,
               double beta,
               double[] y)
```
    Description copied from class: DMatrix
    Matrix-vector multiplication.
```
     y = alpha * op(A) * x + beta * y
 
```
    where op is the transpose operation.
    Specified by:
    
    mv in class DMatrix
  - mv
```
public void mv(double[] work,
               int inputOffset,
               int outputOffset)
```
    Description copied from class: IMatrix
    
    Matrix-vector multiplication A * x.
    
    Specified by:
    
    mv in class IMatrix<double[]>
    
    Parameters:
    
    work - the workspace for both input and output vector.
    
    inputOffset - the offset of input vector in workspace.
    
    outputOffset - the offset of output vector in workspace.
  - tv
```
public void tv(double[] work,
               int inputOffset,
               int outputOffset)
```
    Description copied from class: IMatrix
    
    Matrix-vector multiplication A' * x.
    
    Specified by:
    
    tv in class IMatrix<double[]>
    
    Parameters:
    
    work - the workspace for both input and output vector.
    
    inputOffset - the offset of input vector in workspace.
    
    outputOffset - the offset of output vector in workspace.
  - mm
```
public void mm(Transpose transA,
               Transpose transB,
               double alpha,
               Matrix B,
               double beta,
               Matrix C)
```
    Matrix-matrix multiplication.
```
     C := alpha*A*B + beta*C
 
```
  - ata
```
public Matrix ata()
```
    Returns A' * A
  - aat
```
public Matrix aat()
```
    Returns A * A'
  - adb
```
public Matrix adb(Transpose transA,
                  Transpose transB,
                  Matrix B,
                  double[] diag)
```
    Returns A * D * B, where D is a diagonal matrix.
  - mm
```
public Matrix mm(Matrix B)
```
    Returns matrix multiplication A * B.
  - mt
```
public Matrix mt(Matrix B)
```
    Returns matrix multiplication A * B'.
  - tm
```
public Matrix tm(Matrix B)
```
    Returns matrix multiplication A' * B.
  - tt
```
public Matrix tt(Matrix B)
```
    Returns matrix multiplication A' * B'.
  - lu
```
public Matrix.LU lu()
```
    LU decomposition.
  - lu
```
public Matrix.LU lu(boolean overwrite)
```
    LU decomposition.
    
    Parameters:
    
    overwrite - The flag if the decomposition overwrites this matrix.
  - cholesky
```
public Matrix.Cholesky cholesky()
```
    Cholesky decomposition for symmetric and positive definite matrix.
    
    Throws:
    
    java.lang.ArithmeticException - if the matrix is not positive definite.
  - cholesky
```
public Matrix.Cholesky cholesky(boolean overwrite)
```
    Cholesky decomposition for symmetric and positive definite matrix.
    
    Parameters:
    
    overwrite - The flag if the decomposition overwrites this matrix.
    
    Throws:
    
    java.lang.ArithmeticException - if the matrix is not positive definite.
  - qr
```
public Matrix.QR qr()
```
    QR Decomposition.
  - qr
```
public Matrix.QR qr(boolean overwrite)
```
    QR Decomposition.
    
    Parameters:
    
    overwrite - The flag if the decomposition overwrites this matrix.
  - svd
```
public Matrix.SVD svd()
```
    Singular Value Decomposition. Returns an compact SVD of m-by-n matrix A:
    - m > n — Only the first n columns of U are computed, and S is n-by-n.
    - m = n — Equivalent to full SVD.
    - m < n — Only the first m columns of V are computed, and S is m-by-m.
    The compact decomposition removes extra rows or columns of zeros from the diagonal matrix of singular values, S, along with the columns in either U or V that multiply those zeros in the expression A = U*S*V'. Removing these zeros and columns can improve execution time and reduce storage requirements without compromising the accuracy of the decomposition.
  - svd
```
public Matrix.SVD svd(boolean vectors,
                      boolean overwrite)
```
    Singular Value Decomposition. Returns an compact SVD of m-by-n matrix A:
    - m > n — Only the first n columns of U are computed, and S is n-by-n.
    - m = n — Equivalent to full SVD.
    - m < n — Only the first m columns of V are computed, and S is m-by-m.
    The compact decomposition removes extra rows or columns of zeros from the diagonal matrix of singular values, S, along with the columns in either U or V that multiply those zeros in the expression A = U*S*V'. Removing these zeros and columns can improve execution time and reduce storage requirements without compromising the accuracy of the decomposition.
    Parameters:
    
    vectors - The flag if computing the singular vectors.
    
    overwrite - The flag if the decomposition overwrites this matrix.
  - eigen
```
public Matrix.EVD eigen()
```
    Eigenvalue Decomposition. For a symmetric matrix, all eigenvalues are real values. Otherwise, the eigenvalues may be complex numbers.
    By default eigen does not always return the eigenvalues and eigenvectors in sorted order. Use the EVD.sort function to put the eigenvalues in descending order and reorder the corresponding eigenvectors.
  - eigen
```
public Matrix.EVD eigen(boolean vl,
                        boolean vr,
                        boolean overwrite)
```
    Eigenvalue Decomposition. For a symmetric matrix, all eigenvalues are real values. Otherwise, the eigenvalues may be complex numbers.
    By default eigen does not always return the eigenvalues and eigenvectors in sorted order. Use the sort function to put the eigenvalues in descending order and reorder the corresponding eigenvectors.
    
    Parameters:
    
    vl - The flag if computing the left eigenvectors.
    
    vr - The flag if computing the right eigenvectors.
    
    overwrite - The flag if the decomposition overwrites this matrix.

Class Matrix

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class smile.math.matrix.DMatrix

Methods inherited from class smile.math.matrix.IMatrix

Methods inherited from class java.lang.Object

Constructor Detail

Matrix

Matrix

Matrix

Matrix

Matrix

Matrix

Matrix

Method Detail

of

of

eye

eye

randn

rand

rand

diag

toeplitz

toeplitz

nrows

ncols

size

layout

ld

isSubmatrix

isSymmetric

uplo

uplo

triangular

triangular

clone

toArray

row

col

row

col

submatrix

fill

transpose

equals

equals

index

get

set

set

add

sub

mul

div

add

sub

mul

div

add

sub

mul

div

add

sub

mul

div

add

sub

mul

div

add

sub

mul

div

add

add

add

add