FloatMatrix

java.lang.Object
- smile.math.matrix.IMatrix<float[]>
- - smile.math.matrix.SMatrix
  - - smile.math.matrix.FloatMatrix

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable
```
public class FloatMatrix
extends SMatrix
```
See Also:

Serialized Form

Nested Class Summary

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

Constructor Summary

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

Method Summary

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

Methods inherited from class smile.math.matrix.SMatrix
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
  - FloatMatrix
```
public FloatMatrix(int m,
                   int n)
```
    Constructor of zero matrix.
    
    Parameters:
    
    m - the number of rows.
    
    n - the number of columns.
  - FloatMatrix
```
public FloatMatrix(int m,
                   int n,
                   float a)
```
    Constructor. Fills the matrix with given value.
    
    Parameters:
    
    m - the number of rows.
    
    n - the number of columns.
    
    a - the initial value.
  - FloatMatrix
```
public FloatMatrix(int m,
                   int n,
                   float[][] A)
```
    Constructor.
    
    Parameters:
    
    m - the number of rows.
    
    n - the number of columns.
    
    A - the array of matrix.
  - FloatMatrix
```
public FloatMatrix(float[][] A)
```
    Constructor.
    
    Parameters:
    
    A - the array of matrix.
  - FloatMatrix
```
public FloatMatrix(float[] A)
```
    Constructor of a column vector/matrix with given array as the internal storage.
    
    Parameters:
    
    A - The array of column vector.
  - FloatMatrix
```
public FloatMatrix(float[] 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.
  - FloatMatrix
```
public FloatMatrix(int m,
                   int n,
                   int ld,
                   java.nio.FloatBuffer 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 FloatMatrix 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 FloatMatrix of(Layout layout,
                             int m,
                             int n,
                             int ld,
                             java.nio.FloatBuffer 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 FloatMatrix eye(int n)
```
    Returns an n-by-n identity matrix.
    
    Parameters:
    
    n - the number of rows/columns.
  - eye
```
public static FloatMatrix 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 FloatMatrix randn(int m,
                                int n)
```
    Returns a random matrix of standard normal distribution.
  - rand
```
public static FloatMatrix rand(int m,
                               int n,
                               Distribution distribution)
```
    Returns a random matrix.
    
    Parameters:
    
    distribution - the distribution of random number.
  - rand
```
public static FloatMatrix rand(int m,
                               int n,
                               float lo,
                               float 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 FloatMatrix diag(float[] diag)
```
    Returns a square diagonal matrix with the elements of vector v on the main diagonal.
    
    Parameters:
    
    diag - the diagonal elements.
  - toeplitz
```
public static FloatMatrix toeplitz(float[] 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 FloatMatrix toeplitz(float[] kl,
                                   float[] 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<float[]>
  - ncols
```
public int ncols()
```
    Description copied from class: IMatrix
    
    Returns the number of columns.
    
    Specified by:
    
    ncols in class IMatrix<float[]>
  - 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<float[]>
  - 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 FloatMatrix uplo(UPLO uplo)
```
    Sets the format of packed matrix.
  - uplo
```
public UPLO uplo()
```
    Gets the format of packed matrix.
  - triangular
```
public FloatMatrix 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 FloatMatrix clone()
```
    Returns a deep copy of matrix.
    
    Overrides:
    
    clone in class java.lang.Object
  - toArray
```
public float[][] 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 FloatMatrix row(int... rows)
```
    Returns the matrix of selected rows.
  - col
```
public FloatMatrix col(int... cols)
```
    Returns the matrix of selected columns.
  - submatrix
```
public FloatMatrix 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(float x)
```
    Fill the matrix with a value.
  - transpose
```
public FloatMatrix 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(FloatMatrix o,
                      float 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 float get(int i,
                 int j)
```
    Description copied from class: SMatrix
    
    Returns A[i, j].
    
    Specified by:
    
    get in class SMatrix
  - set
```
public FloatMatrix set(int i,
                       int j,
                       float x)
```
    Description copied from class: SMatrix
    
    Sets A[i,j] = x.
    
    Specified by:
    
    set in class SMatrix
  - set
```
public FloatMatrix set(int i,
                       int j,
                       FloatMatrix B)
```
    Sets submatrix A[i,j] = B.
  - add
```
public float add(int i,
                 int j,
                 float b)
```
    A[i,j] += b
  - sub
```
public float sub(int i,
                 int j,
                 float b)
```
    A[i,j] -= b
  - mul
```
public float mul(int i,
                 int j,
                 float b)
```
    A[i,j] *= b
  - div
```
public float div(int i,
                 int j,
                 float b)
```
    A[i,j] /= b
  - add
```
public FloatMatrix add(float b)
```
    A += b
  - sub
```
public FloatMatrix sub(float b)
```
    A -= b
  - mul
```
public FloatMatrix mul(float b)
```
    A *= b
  - div
```
public FloatMatrix div(float b)
```
    A /= b
  - add
```
public FloatMatrix add(int i,
                       int j,
                       float alpha,
                       FloatMatrix B)
```
    Element-wise submatrix addition A[i, j] += alpha * B
  - sub
```
public FloatMatrix sub(int i,
                       int j,
                       float alpha,
                       FloatMatrix B)
```
    Element-wise submatrix subtraction A[i, j] -= alpha * B
  - mul
```
public FloatMatrix mul(int i,
                       int j,
                       float alpha,
                       FloatMatrix B)
```
    Element-wise submatrix multiplication A[i, j] *= alpha * B
  - div
```
public FloatMatrix div(int i,
                       int j,
                       float alpha,
                       FloatMatrix B)
```
    Element-wise submatrix division A[i, j] /= alpha * B
  - add
```
public FloatMatrix add(FloatMatrix B)
```
    Element-wise addition A += B
  - sub
```
public FloatMatrix sub(FloatMatrix B)
```
    Element-wise subtraction A -= B
  - mul
```
public FloatMatrix mul(FloatMatrix B)
```
    Element-wise multiplication A *= B
  - div
```
public FloatMatrix div(FloatMatrix B)
```
    Element-wise division A /= B
  - add
```
public FloatMatrix add(float alpha,
                       FloatMatrix B)
```
    Element-wise addition A += alpha * B
  - sub
```
public FloatMatrix sub(float alpha,
                       FloatMatrix B)
```
    Element-wise subtraction A -= alpha * B
  - mul
```
public FloatMatrix mul(float alpha,
                       FloatMatrix B)
```
    Element-wise multiplication A *= alpha * B
  - div
```
public FloatMatrix div(float alpha,
                       FloatMatrix B)
```
    Element-wise division A /= alpha * B
  - add
```
public FloatMatrix add(float alpha,
                       FloatMatrix A,
                       float beta,
                       FloatMatrix B)
```
    Element-wise addition C = alpha * A + beta * B
  - sub
```
public FloatMatrix sub(float alpha,
                       FloatMatrix A,
                       float beta,
                       FloatMatrix B)
```
    Element-wise subtraction C = alpha * A - beta * B
  - mul
```
public FloatMatrix mul(float alpha,
                       FloatMatrix A,
                       FloatMatrix B)
```
    Element-wise multiplication C = alpha * A * B
  - div
```
public FloatMatrix div(float alpha,
                       FloatMatrix A,
                       FloatMatrix B)
```
    Element-wise division C = alpha * A / B
  - add
```
public double add(int i,
                  int j,
                  float alpha,
                  float beta)
```
    A[i,j] = alpha * A[i,j] + beta
  - add
```
public FloatMatrix add(int i,
                       int j,
                       float alpha,
                       float beta,
                       FloatMatrix B)
```
    Element-wise submatrix addition A[i, j] = alpha * A[i, j] + beta * B
  - add
```
public FloatMatrix add(float alpha,
                       float beta,
                       FloatMatrix B)
```
    Element-wise addition A = alpha * A + beta * B
  - add
```
public FloatMatrix add(float alpha,
                       float[] x,
                       float[] y)
```
    Rank-1 update A += alpha * x * y'
  - replaceNaN
```
public FloatMatrix replaceNaN(float x)
```
    Replaces NaN's with given value.
  - sum
```
public float sum()
```
    Returns the sum of all elements in the matrix.
    
    Returns:
    
    the sum of all elements.
  - norm1
```
public float norm1()
```
    L1 matrix norm. Maximum column sum.
  - norm2
```
public float norm2()
```
    L2 matrix norm. Maximum singular value.
  - norm
```
public float norm()
```
    L2 matrix norm. Maximum singular value.
  - normInf
```
public float normInf()
```
    Infinity matrix norm. Maximum row sum.
  - normFro
```
public float normFro()
```
    Frobenius matrix norm. Sqrt of sum of squares of all elements.
  - xAx
```
public float xAx(float[] x)
```
    Returns x' * A * x. The left upper submatrix of A is used in the computation based on the size of x.
  - rowSums
```
public float[] rowSums()
```
    Returns the sum of each row.
  - rowMeans
```
public float[] rowMeans()
```
    Returns the mean of each row.
  - rowSds
```
public float[] rowSds()
```
    Returns the standard deviations of each row.
  - colSums
```
public float[] colSums()
```
    Returns the sum of each column.
  - colMeans
```
public float[] colMeans()
```
    Returns the mean of each column.
  - colSds
```
public float[] colSds()
```
    Returns the standard deviations of each column.
  - scale
```
public FloatMatrix scale()
```
    Centers and scales the columns of matrix.
    
    Returns:
    
    a new matrix with zero mean and unit variance for each column.
  - scale
```
public FloatMatrix scale(float[] center,
                         float[] 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 FloatMatrix inverse()
```
    Returns the inverse matrix.
  - mv
```
public void mv(Transpose trans,
               float alpha,
               java.nio.FloatBuffer x,
               float beta,
               java.nio.FloatBuffer y)
```
    Matrix-vector multiplication.
```
     y = alpha * A * x + beta * y
 
```
  - mv
```
public void mv(Transpose trans,
               float alpha,
               float[] x,
               float beta,
               float[] y)
```
    Description copied from class: SMatrix
    Matrix-vector multiplication.
```
     y = alpha * op(A) * x + beta * y
 
```
    where op is the transpose operation.
    Specified by:
    
    mv in class SMatrix
  - mv
```
public void mv(float[] work,
               int inputOffset,
               int outputOffset)
```
    Description copied from class: IMatrix
    
    Matrix-vector multiplication A * x.
    
    Specified by:
    
    mv in class IMatrix<float[]>
    
    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(float[] work,
               int inputOffset,
               int outputOffset)
```
    Description copied from class: IMatrix
    
    Matrix-vector multiplication A' * x.
    
    Specified by:
    
    tv in class IMatrix<float[]>
    
    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,
               float alpha,
               FloatMatrix B,
               float beta,
               FloatMatrix C)
```
    Matrix-matrix multiplication.
```
     C := alpha*A*B + beta*C
 
```
  - ata
```
public FloatMatrix ata()
```
    Returns A' * A
  - aat
```
public FloatMatrix aat()
```
    Returns A * A'
  - adb
```
public FloatMatrix adb(Transpose transA,
                       Transpose transB,
                       FloatMatrix B,
                       float[] diag)
```
    Returns A * D * B, where D is a diagonal matrix.
  - mm
```
public FloatMatrix mm(FloatMatrix B)
```
    Returns matrix multiplication A * B.
  - mt
```
public FloatMatrix mt(FloatMatrix B)
```
    Returns matrix multiplication A * B'.
  - tm
```
public FloatMatrix tm(FloatMatrix B)
```
    Returns matrix multiplication A' * B.
  - tt
```
public FloatMatrix tt(FloatMatrix B)
```
    Returns matrix multiplication A' * B'.
  - lu
```
public FloatMatrix.LU lu()
```
    LU decomposition.
  - lu
```
public FloatMatrix.LU lu(boolean overwrite)
```
    LU decomposition.
    
    Parameters:
    
    overwrite - The flag if the decomposition overwrites this matrix.
  - cholesky
```
public FloatMatrix.Cholesky cholesky()
```
    Cholesky decomposition for symmetric and positive definite matrix.
    
    Throws:
    
    java.lang.ArithmeticException - if the matrix is not positive definite.
  - cholesky
```
public FloatMatrix.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 FloatMatrix.QR qr()
```
    QR Decomposition.
  - qr
```
public FloatMatrix.QR qr(boolean overwrite)
```
    QR Decomposition.
    
    Parameters:
    
    overwrite - The flag if the decomposition overwrites this matrix.
  - svd
```
public FloatMatrix.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 FloatMatrix.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 FloatMatrix.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 FloatMatrix.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 FloatMatrix

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class smile.math.matrix.SMatrix

Methods inherited from class smile.math.matrix.IMatrix

Methods inherited from class java.lang.Object

Constructor Detail

FloatMatrix

FloatMatrix

FloatMatrix

FloatMatrix

FloatMatrix

FloatMatrix

FloatMatrix

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