FloatMatrix

java.lang.Object
- ej.numeric.FloatMatrix

All Implemented Interfaces:

Matrix, java.lang.Cloneable
```
public class FloatMatrix
extends java.lang.Object
implements Matrix
```
Implementation of matrix type of float elements

Constructor Summary

Constructors
Constructor and Description
`FloatMatrix(float[] data)` Construct a new row vector given the data
`FloatMatrix(float[][] data)` Construct a new matrix given the data as a two dimensions array
`FloatMatrix(int rows)` Construct a new row vector given the number of rows
`FloatMatrix(int rows, int cols)` Construct a new matrix given the number of rows and columns
`FloatMatrix(int rows, int cols, boolean zeroInit)` Construct a new matrix given the number of rows and columns.
`FloatMatrix(int rows, int cols, float[] data)` Construct a new matrix given the number of rows, columns and the data as a linear array

Method Summary

Methods
Modifier and Type	Method and Description
`FloatMatrix`	`add(float scalar)` Add a scalar
`FloatMatrix`	`add(FloatMatrix matrix)` Add a matrix
`FloatMatrix`	`add(FloatMatrix A, FloatMatrix B)` Make the current matrix be the result of the addition of two matrices
`FloatMatrix`	`add(FloatMatrix A, FloatMatrix B, int rows, int cols, int RrowStart, int RcolStart, int ArowStart, int AcolStart, int BrowStart, int BcolStart)` Make the current (sub) matrix be the result of the addition of two sub matrices
`FloatMatrix`	`addi(float scalar)` In place add a scalar
`FloatMatrix`	`addi(FloatMatrix matrix)` In place add a matrix
`int`	`argmax()` The linear index of the maximum element of the matrix
`int`	`argmin()` The linear index of the minimum element of the matrix
`FloatMatrix`	`arrayDiv(FloatMatrix matrix)` Element-wise divide by a matrix
`FloatMatrix`	`arrayDivi(FloatMatrix matrix)` In place element-wise divide by a matrix
`FloatMatrix`	`arrayMul(FloatMatrix matrix)` Element-wise multiply by a matrix
`FloatMatrix`	`arrayMuli(FloatMatrix matrix)` In place element-wise multiply by a matrix
`FloatMatrix`	`arrayTranspose()` Transpose.
`FloatMatrix`	`arrayTransposei()` Transpose in place.
`java.lang.Object`	`clone()` Makes a deep copy of this matrix.
`float`	`det()` Matrix determinant
`static FloatMatrix`	`diag(FloatMatrix v)` Create a diagonal matrix with vector v on the main diagonal
`static FloatMatrix`	`diag(FloatMatrix v, int k)` Create a diagonal matrix with vector v on the diagonal k
`FloatMatrix`	`diag(int k)` Return the k-th diagonal of the matrix.
`FloatMatrix`	`div(float scalar)` Divide by a scalar
`FloatMatrix`	`div(FloatMatrix matrix)` Divide by a matrix
`FloatMatrix`	`div(FloatMatrix A, FloatMatrix B)` Make the current matrix be the result of the division of two matrices
`FloatMatrix`	`divi(float scalar)` In place divide by a scalar
`FloatMatrix`	`divi(FloatMatrix matrix)` In place divide by a matrix
`FloatMatrix`	`duplicate(FloatMatrix A)` Copy the data of a matrix to the current matrix.
`FloatMatrix`	`eq(float scalar)` Element-wise equals between matrix elements and a scalar
`FloatMatrix`	`eq(FloatMatrix matrix)` Element-wise equals between matrices elements
`FloatMatrix`	`eqi(float scalar)` In place element-wise equals between matrix elements and a scalar
`FloatMatrix`	`eqi(FloatMatrix matrix)` In place element-wise equals between matrices elements
`boolean`	`equals(java.lang.Object object)` Equals between matrices
`static FloatMatrix`	`eye(int dim)` Create a square identity matrix
`static FloatMatrix`	`eye(int rows, int cols)` Create an identity matrix with the given dimensions
`FloatMatrix`	`ge(float scalar)` Element-wise greater or equals between matrix elements and a scalar
`FloatMatrix`	`ge(FloatMatrix matrix)` Element-wise greater or equals between matrices elements
`FloatMatrix`	`gei(float scalar)` In place element-wise greater or equals between matrix elements and a scalar
`FloatMatrix`	`gei(FloatMatrix matrix)` In place element-wise greater or equals between matrices elements
`float`	`get(int index)` Get the element at the given linear index
`float`	`get(int row, int col)` Get the element at the given row and column
`FloatMatrix`	`get(Range range)` Get a vector of the elements at the given linear index range
`FloatMatrix`	`get(Range rowsRange, Range colsRange)` Get a matrix of the elements at the given index ranges
`FloatMatrix`	`getColumn(int column)` Get a vector of the elements at the given column
`int`	`getColumns()` Get the number of columns
`static double`	`getEpsilon()` get epsilon
`int`	`getLength()` Get the total number of elements
`FloatMatrix`	`getRow(int row)` Get a vector of the elements at the given row
`int`	`getRows()` Get the number of rows
`FloatMatrix`	`gt(float scalar)` Element-wise greater than between matrix elements and a scalar
`FloatMatrix`	`gt(FloatMatrix matrix)` Element-wise greater than between matrices elements
`FloatMatrix`	`gti(float scalar)` In place element-wise greater than between matrix elements and a scalar
`FloatMatrix`	`gti(FloatMatrix matrix)` In place element-wise greater than between matrices elements
`boolean`	`isColumnVector()` Checks whether the matrix is a column vector
`boolean`	`isEmpty()` Checks whether the matrix is empty
`boolean`	`isRowVector()` Checks whether the matrix is a row vector
`boolean`	`isSquare()` Checks whether the matrix is square
`boolean`	`isVector()` Checks whether the matrix is a vector
`FloatMatrix`	`le(float scalar)` Element-wise lower or equals between matrix elements and a scalar
`FloatMatrix`	`le(FloatMatrix matrix)` Element-wise lower or equals between matrices elements
`FloatMatrix`	`lei(float scalar)` In place element-wise lower or equals between matrix elements and a scalar
`FloatMatrix`	`lei(FloatMatrix matrix)` In place element-wise lower or equals between matrices elements
`FloatMatrix`	`lt(float scalar)` Element-wise lower than between matrix elements and a scalar
`FloatMatrix`	`lt(FloatMatrix matrix)` Element-wise lower than between matrices elements
`FloatMatrix`	`lti(float scalar)` In place element-wise lower than between matrix elements and a scalar
`FloatMatrix`	`lti(FloatMatrix matrix)` In place element-wise lower than between matrices elements
`float`	`max()` The maximum element of the matrix
`FloatMatrix`	`max(float scalar)` Element-wise maximum between matrix elements and a scalar
`FloatMatrix`	`max(FloatMatrix matrix)` Element-wise maximum between matrices
`FloatMatrix`	`maxi(float scalar)` In place element-wise maximum between matrix elements and a scalar
`FloatMatrix`	`maxi(FloatMatrix matrix)` In place element-wise maximum between matrices
`float`	`mean()` The mean value of all elements in the matrix
`float`	`min()` The minimum element of the matrix
`FloatMatrix`	`min(float scalar)` Element-wise minimum between matrix elements and a scalar
`FloatMatrix`	`min(FloatMatrix matrix)` Element-wise minimum between matrices
`FloatMatrix`	`mini(float scalar)` In place element-wise minimum between matrix elements and a scalar
`FloatMatrix`	`mini(FloatMatrix matrix)` In place element-wise minimum between matrices
`FloatMatrix`	`mul(float scalar)` Multiply by a scalar
`FloatMatrix`	`mul(FloatMatrix matrix)` Multiply by a matrix
`FloatMatrix`	`mul(FloatMatrix A, FloatMatrix B)` Make the current matrix be the result of the multiplication of two matrices
`FloatMatrix`	`mul(FloatMatrix A, FloatMatrix B, int rows, int colsRows, int cols, int RrowStart, int RcolStart, int ArowStart, int AcolStart, int BrowStart, int BcolStart)` Make the current matrix be the result of the multiplication of two sub matrices
`FloatMatrix`	`muli(float scalar)` In place multiply by a scalar
`FloatMatrix`	`muli(FloatMatrix matrix)` In place multiply by a matrix
`FloatMatrix`	`ne(float scalar)` Element-wise not-equals between matrix elements and a scalar
`FloatMatrix`	`ne(FloatMatrix matrix)` Element-wise not-equals between matrices elements
`FloatMatrix`	`nei(float scalar)` In place element-wise not-equals between matrix elements and a scalar
`FloatMatrix`	`nei(FloatMatrix matrix)` In place element-wise not-equals between matrices elements
`float`	`norm1()` The 1-norm of the matrix
`float`	`norm2()` The 2-norm of the matrix
`float`	`normInf()` The Inf-norm of the matrix
`static FloatMatrix`	`ones(int dim)` Create a square matrix filled with ones
`static FloatMatrix`	`ones(int rows, int cols)` Create a matrix filled with ones with the given dimensions
`float`	`prod()` The product of all elements of the matrix
`static FloatMatrix`	`rand(int dim)` Create a square matrix filled with random elements uniformly distributed ont the interval (0, 1)
`static FloatMatrix`	`rand(int rows, int cols)` Create a matrix filled with random elements uniformly distributed on the interval (0, 1)
`static FloatMatrix`	`randn(int dim)` Create a square matrix filled with random elements normally distributed on the interval (0, 1)
`static FloatMatrix`	`randn(int dim, float mean, float standardDeviation)` Create a square matrix filled with random elements normally distributed on the interval [minInterval, maxInterval]
`static FloatMatrix`	`randn(int rows, int cols)` Create a matrix filled with random elements normally distributed on the interval (0, 1)
`static FloatMatrix`	`randn(int rows, int cols, float mean, float standardDeviation)` Create a matrix filled with random elements normally distributed on the interval [minInterval, maxInterval]
`static FloatMatrix`	`repmat(float scalar, int rows, int cols)` Create a matrix of dimensions rows by columns containing the given scalar
`static FloatMatrix`	`repmat(FloatMatrix matrix, int rows, int cols)` Create a matrix containing rows by columns replications of the given matrix
`FloatMatrix`	`resize(int rows, int columns)` Resize the matrix whith the given dimensions.
`FloatMatrix`	`resizei(int rows, int columns)` In-place resize the matrix whith the given dimensions.
`void`	`set(int index, float element)` Set the element at the given linear index
`void`	`set(int row, int col, float element)` Set the element at the given row and column
`void`	`set(Range range, float element)` Set the elements at the given linear index range
`void`	`set(Range rowsRange, Range colsRange, float element)` Set the elements at the given index ranges
`void`	`setColumn(int column, FloatMatrix vector)` Set the elements at the given column
`static void`	`setEpsilon(double epsilon)` Set epsilon
`void`	`setRow(int row, FloatMatrix vector)` Set the elements at the given row
`FloatMatrix`	`sub(float scalar)` Subtract a scalar
`FloatMatrix`	`sub(FloatMatrix matrix)` Subtract a matrix
`FloatMatrix`	`sub(FloatMatrix A, FloatMatrix B)` Make the current matrix be the result of the subtraction of two matrices
`FloatMatrix`	`sub(FloatMatrix A, FloatMatrix B, int rows, int cols, int RrowStart, int RcolStart, int ArowStart, int AcolStart, int BrowStart, int BcolStart)` Make the current (sub) matrix be the result of the subtraction of two sub matrices
`FloatMatrix`	`subi(float scalar)` In place subtract a scalar
`FloatMatrix`	`subi(FloatMatrix matrix)` In place subtract a matrix
`float`	`sum()` The sum of all elements of the matrix
`float[][]`	`toArray()` Convert to a 2D array of float
`ComplexDoubleMatrix`	`toComplexDoubleMatrix()` Convert the current matrix to ComplexDoubleMatrix
`ComplexFloatMatrix`	`toComplexFloatMatrix()` Convert the current matrix to ComplexFloatMatrix
`DoubleMatrix`	`toDoubleMatrix()` Convert the current matrix to DoubleMatrix
`FloatMatrix`	`toFloatMatrix()` Convert the current matrix to FloatMatrix
`java.lang.String`	`toString()` Get string representation of this complex
`float[]`	`toVector()` Convert to a 1D array of float
`FloatMatrix`	`transpose()` Transpose.
`FloatMatrix`	`transpose(FloatMatrix matrix)` Transpose a matrix and store the result into the current matrix.
`FloatMatrix`	`transposei()` Transpose in place.
`static FloatMatrix`	`zeros(int dim)` Create a square matrix filled with zeros
`static FloatMatrix`	`zeros(int rows, int cols)` Create a matrix filled with zeros with the given dimensions

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

- Constructor Detail
  - FloatMatrix
```
public FloatMatrix(int rows,
           int cols)
```
    Construct a new matrix given the number of rows and columns
    
    Parameters:
    rows - Number of rows
    cols - Number of columns
  - FloatMatrix
```
public FloatMatrix(int rows,
           int cols,
           boolean zeroInit)
```
    Construct a new matrix given the number of rows and columns. The content of the matrix is initialized with 0.
    
    Parameters:
    rows - Number of rows
    cols - Number of columns
    zeroInit - set to true to initialize to zero the content of the matrix. If false the content is not cleared.
  - FloatMatrix
```
public FloatMatrix(int rows,
           int cols,
           float[] data)
```
    Construct a new matrix given the number of rows, columns and the data as a linear array
    
    Parameters:
    rows - Number of rows
    cols - Number of columns
    data - The data as a one dimension array
  - FloatMatrix
```
public FloatMatrix(float[][] data)
```
    Construct a new matrix given the data as a two dimensions array
    
    Parameters:
    data - The data as a two dimensions array
  - FloatMatrix
```
public FloatMatrix(int rows)
```
    Construct a new row vector given the number of rows
    
    Parameters:
    rows - Number of rows
  - FloatMatrix
```
public FloatMatrix(float[] data)
```
    Construct a new row vector given the data
    
    Parameters:
    data - The data
- Method Detail
  - clone
```
public java.lang.Object clone()
```
    Makes a deep copy of this matrix. The elements are also different instances so changing the result matrix will not affect the original matrix.
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
    The copied matrix.
  - duplicate
```
public FloatMatrix duplicate(FloatMatrix A)
```
    Copy the data of a matrix to the current matrix. Matrices must be the same size.
    
    Parameters:
    A - matrix to copy the data from
    
    Returns:
    the current matrix with new data
    
    Throws:
    
    IllegalArguementException - if matrices are not the same size
  - get
```
public float get(int row,
        int col)
```
    Get the element at the given row and column
    
    Parameters:
    row - The row
    col - The column
    
    Returns:
    The element at the given row and column
  - set
```
public void set(int row,
       int col,
       float element)
```
    Set the element at the given row and column
    
    Parameters:
    row - The row
    col - The column
    element - The element to set
  - get
```
public float get(int index)
```
    Get the element at the given linear index
    
    Parameters:
    index - The linear index
    
    Returns:
    The element at the given linear index
  - set
```
public void set(int index,
       float element)
```
    Set the element at the given linear index
    
    Parameters:
    index - The linear index
    element - The element to set
  - get
```
public FloatMatrix get(Range rowsRange,
              Range colsRange)
```
    Get a matrix of the elements at the given index ranges
    
    Parameters:
    rowsRange - Index range of the rows to get
    colsRange - Index range of the columns to get
    
    Returns:
    Matrix of the extracted elements
  - set
```
public void set(Range rowsRange,
       Range colsRange,
       float element)
```
    Set the elements at the given index ranges
    
    Parameters:
    rowsRange - Index range of the rows to set
    colsRange - Index range of the columns to set
    element - Element to set
  - get
```
public FloatMatrix get(Range range)
```
    Get a vector of the elements at the given linear index range
    
    Parameters:
    range - Linear range of the elements to get
    
    Returns:
    Vector of the extracted elements
  - set
```
public void set(Range range,
       float element)
```
    Set the elements at the given linear index range
    
    Parameters:
    range - Linear range of the elements to set
    element - Element to set
  - getRow
```
public FloatMatrix getRow(int row)
```
    Get a vector of the elements at the given row
    
    Parameters:
    row - Row of the elements to get
    
    Returns:
    Vector of the extracted elements
  - setRow
```
public void setRow(int row,
          FloatMatrix vector)
```
    Set the elements at the given row
    
    Parameters:
    row - Row of the elements to set
    vector - Vector of the elements to set
  - getColumn
```
public FloatMatrix getColumn(int column)
```
    Get a vector of the elements at the given column
    
    Parameters:
    column - Column of the elements to get
    
    Returns:
    Vector of the extracted elements
  - setColumn
```
public void setColumn(int column,
             FloatMatrix vector)
```
    Set the elements at the given column
    
    Parameters:
    column - Column of the elements to set
    vector - Vector of the elements to set
  - getRows
```
public int getRows()
```
    Get the number of rows
    
    Returns:
    The number of rows
  - getColumns
```
public int getColumns()
```
    Get the number of columns
    
    Returns:
    The number of columns
  - getLength
```
public int getLength()
```
    Get the total number of elements
    
    Returns:
    The total number of elements
  - isEmpty
```
public boolean isEmpty()
```
    Checks whether the matrix is empty
    
    Returns:
    True if the matrix is empty
  - isSquare
```
public boolean isSquare()
```
    Checks whether the matrix is square
    
    Returns:
    True if the matrix is square
  - isVector
```
public boolean isVector()
```
    Checks whether the matrix is a vector
    
    Returns:
    True if the matrix is a vector
  - isRowVector
```
public boolean isRowVector()
```
    Checks whether the matrix is a row vector
    
    Returns:
    True if the matrix is a row vector
  - isColumnVector
```
public boolean isColumnVector()
```
    Checks whether the matrix is a column vector
    
    Returns:
    True if the matrix is a column vector
  - eye
```
public static FloatMatrix eye(int dim)
```
    Create a square identity matrix
    
    Parameters:
    dim - Dimension of the square matrix to create
    
    Returns:
    Created square identity matrix
  - eye
```
public static FloatMatrix eye(int rows,
              int cols)
```
    Create an identity matrix with the given dimensions
    
    Parameters:
    rows - Number of rows
    cols - Number of columns
    
    Returns:
    Created square identity matrix
  - zeros
```
public static FloatMatrix zeros(int dim)
```
    Create a square matrix filled with zeros
    
    Parameters:
    dim - Dimension of the square matrix to create
    
    Returns:
    Created square matrix filled with zeros
  - zeros
```
public static FloatMatrix zeros(int rows,
                int cols)
```
    Create a matrix filled with zeros with the given dimensions
    
    Parameters:
    rows - Number of rows
    cols - Number of columns
    
    Returns:
    Created square matrix filled with zeros
  - ones
```
public static FloatMatrix ones(int dim)
```
    Create a square matrix filled with ones
    
    Parameters:
    dim - Dimension of the square matrix to create
    
    Returns:
    Created square matrix filled with ones
  - ones
```
public static FloatMatrix ones(int rows,
               int cols)
```
    Create a matrix filled with ones with the given dimensions
    
    Parameters:
    rows - Number of rows
    cols - Number of columns
    
    Returns:
    Created square matrix filled with ones
  - diag
```
public static FloatMatrix diag(FloatMatrix v,
               int k)
```
    Create a diagonal matrix with vector v on the diagonal k
    
    Parameters:
    v - Vector of k elements
    k - If k is positive, the vector is placed on the k-th super diagonal. If it is negative, it is placed on the -k-th sub-diagonal.
    
    Returns:
    Created diagonal matrix
  - diag
```
public static FloatMatrix diag(FloatMatrix v)
```
    Create a diagonal matrix with vector v on the main diagonal
    
    Parameters:
    v - Vector of elements
    
    Returns:
    Created diagonal matrix
  - repmat
```
public static FloatMatrix repmat(FloatMatrix matrix,
                 int rows,
                 int cols)
```
    Create a matrix containing rows by columns replications of the given matrix
    
    Parameters:
    matrix - The matrix to replicate
    rows - The number of horizontal replications of the matrix
    cols - The number of vertical replications of the matrix
    
    Returns:
    Created replication matrix
  - repmat
```
public static FloatMatrix repmat(float scalar,
                 int rows,
                 int cols)
```
    Create a matrix of dimensions rows by columns containing the given scalar
    
    Parameters:
    scalar - The scalar to replicate
    rows - Number of rows
    cols - Number of columns
    
    Returns:
    Created matrix
  - rand
```
public static FloatMatrix rand(int dim)
```
    Create a square matrix filled with random elements uniformly distributed ont the interval (0, 1)
    
    Parameters:
    dim - Dimension of the square matrix to create
    
    Returns:
    Created square matrix filled with random elements uniformly distributed ont the interval (0, 1)
  - rand
```
public static FloatMatrix rand(int rows,
               int cols)
```
    Create a matrix filled with random elements uniformly distributed on the interval (0, 1)
    
    Parameters:
    rows - Number of rows
    cols - Number of columns
    
    Returns:
    Created matrix filled with random elements uniformly distributed on the interval (0, 1)
  - randn
```
public static FloatMatrix randn(int dim)
```
    Create a square matrix filled with random elements normally distributed on the interval (0, 1)
    
    Parameters:
    dim - Dimension of the square matrix to create
    
    Returns:
    Created square matrix filled with random elements normally distributed ont the interval (0, 1)
  - randn
```
public static FloatMatrix randn(int dim,
                float mean,
                float standardDeviation)
```
    Create a square matrix filled with random elements normally distributed on the interval [minInterval, maxInterval]
    
    Parameters:
    dim - Dimension of the square matrix to create
    mean - the mean value for the generated numbers
    standardDeviation - the standard deviation for the generated numbers
    
    Returns:
    Created square matrix filled with random elements normally distributed on the interval [minInterval, maxInterval]
  - randn
```
public static FloatMatrix randn(int rows,
                int cols)
```
    Create a matrix filled with random elements normally distributed on the interval (0, 1)
    
    Parameters:
    rows - Number of rows
    cols - Number of columns
    
    Returns:
    Created matrix filled with random elements normally distributed ont the interval (0, 1)
  - randn
```
public static FloatMatrix randn(int rows,
                int cols,
                float mean,
                float standardDeviation)
```
    Create a matrix filled with random elements normally distributed on the interval [minInterval, maxInterval]
    
    Parameters:
    rows - Number of rows
    cols - Number of columns
    mean - the mean value for the generated numbers
    standardDeviation - the standard deviation for the generated numbers
    
    Returns:
    Created matrix filled with random elements normally distributed using mean and standardDeviation
  - toVector
```
public float[] toVector()
```
    Convert to a 1D array of float
    
    Returns:
    New array with a copy of the matrix's data
  - toArray
```
public float[][] toArray()
```
    Convert to a 2D array of float
    
    Returns:
    New array with a copy of the matrix's data
  - add
```
public FloatMatrix add(FloatMatrix matrix)
```
    Add a matrix
    
    Parameters:
    matrix - The matrix to add to the current matrix
    
    Returns:
    New matrix with the result of the operation
  - add
```
public FloatMatrix add(FloatMatrix A,
              FloatMatrix B)
```
    Make the current matrix be the result of the addition of two matrices
    
    Parameters:
    A - One the matrices to add
    B - The other matrix to add
    
    Returns:
    The current matrix which is now the result of the operation
  - addi
```
public FloatMatrix addi(FloatMatrix matrix)
```
    In place add a matrix
    
    Parameters:
    matrix - The matrix to add to the current matrix
    
    Returns:
    The current matrix
  - add
```
public FloatMatrix add(float scalar)
```
    Add a scalar
    
    Parameters:
    scalar - The scalar to add to the current matrix
    
    Returns:
    New matrix with the result of the operation
  - addi
```
public FloatMatrix addi(float scalar)
```
    In place add a scalar
    
    Parameters:
    scalar - The scalar to add to the current matrix
    
    Returns:
    The current matrix
  - add
```
public FloatMatrix add(FloatMatrix A,
              FloatMatrix B,
              int rows,
              int cols,
              int RrowStart,
              int RcolStart,
              int ArowStart,
              int AcolStart,
              int BrowStart,
              int BcolStart)
```
    Make the current (sub) matrix be the result of the addition of two sub matrices
    
    Parameters:
    A - One the matrices to add
    B - The other matrix to add
    
    Returns:
    The current matrix which contains in its sub matrix the result of the operation subThis = subA + subB subThis is a sub matrix of this which starts at the (RrowStart,RcolStart) subA is a sub matrix of A which starts at the (ArowStart,AcolStart) subB is a sub matrix of B which starts at the (BrowStart,BcolStart) All sub matrices are the same size: (rows,cols)
  - sub
```
public FloatMatrix sub(FloatMatrix matrix)
```
    Subtract a matrix
    
    Parameters:
    matrix - The matrix to subtract to the current matrix
    
    Returns:
    New matrix with the result of the operation
  - sub
```
public FloatMatrix sub(FloatMatrix A,
              FloatMatrix B)
```
    Make the current matrix be the result of the subtraction of two matrices
    
    Parameters:
    A - One the matrices to subtract
    B - The other matrix to subtract
    
    Returns:
    The current matrix which is now the result of the operation
  - subi
```
public FloatMatrix subi(FloatMatrix matrix)
```
    In place subtract a matrix
    
    Parameters:
    matrix - The matrix to subtract to the current matrix
    
    Returns:
    The current matrix
  - sub
```
public FloatMatrix sub(float scalar)
```
    Subtract a scalar
    
    Parameters:
    scalar - The scalar to subtract to the current matrix
    
    Returns:
    New matrix with the result of the operation
  - subi
```
public FloatMatrix subi(float scalar)
```
    In place subtract a scalar
    
    Parameters:
    scalar - The scalar to subtract to the current matrix
    
    Returns:
    The current matrix
  - sub
```
public FloatMatrix sub(FloatMatrix A,
              FloatMatrix B,
              int rows,
              int cols,
              int RrowStart,
              int RcolStart,
              int ArowStart,
              int AcolStart,
              int BrowStart,
              int BcolStart)
```
    Make the current (sub) matrix be the result of the subtraction of two sub matrices
    
    Parameters:
    A - One the matrices to subtract
    B - The other matrix to subtract
    
    Returns:
    The current matrix which contains in its sub matrix the result of the operation subThis = subA - subB subThis is a sub matrix of this which starts at the (RrowStart,RcolStart) subA is a sub matrix of A which starts at the (ArowStart,AcolStart) subB is a sub matrix of B which starts at the (BrowStart,BcolStart) All sub matrices are the same size: (rows,cols)
  - mul
```
public FloatMatrix mul(FloatMatrix matrix)
```
    Multiply by a matrix
    
    Parameters:
    matrix - The matrix to multiply the current matrix by
    
    Returns:
    New matrix with the result of the operation
  - mul
```
public FloatMatrix mul(FloatMatrix A,
              FloatMatrix B)
```
    Make the current matrix be the result of the multiplication of two matrices
    
    Parameters:
    A - One the matrices to multiply
    B - The other matrix to multiply
    
    Returns:
    The current matrix which is now the result of the operation
    
    Throws:
    
    java.lang.IllegalArgumentException - if B == this
  - muli
```
public FloatMatrix muli(FloatMatrix matrix)
```
    In place multiply by a matrix
    
    Parameters:
    matrix - The matrix to multiply the current matrix by
    
    Returns:
    The current matrix
  - mul
```
public FloatMatrix mul(float scalar)
```
    Multiply by a scalar
    
    Parameters:
    scalar - The scalar to multiply the current matrix by
    
    Returns:
    New matrix with the result of the operation
  - muli
```
public FloatMatrix muli(float scalar)
```
    In place multiply by a scalar
    
    Parameters:
    scalar - The scalar to multiply the current matrix by
    
    Returns:
    The current matrix
  - mul
```
public FloatMatrix mul(FloatMatrix A,
              FloatMatrix B,
              int rows,
              int colsRows,
              int cols,
              int RrowStart,
              int RcolStart,
              int ArowStart,
              int AcolStart,
              int BrowStart,
              int BcolStart)
```
    Make the current matrix be the result of the multiplication of two sub matrices
    
    Parameters:
    A - One the matrices to multiply
    B - The other matrix to multiply
    
    Returns:
    The current matrix which contains in its sub matrix the result of the operation
    
    Throws:
    
    java.lang.IllegalArgumentException - if B == this subThis = subA * subB subThis is a sub matrix of this which starts at the (RrowStart,RcolStart) and its size is (rows,cols) subA is a sub matrix of A which starts at the (ArowStart,AcolStart) and its size is (rows,colsRows) subB is a sub matrix of B which starts at the (BrowStart,BcolStart) and its size is (colsRows, cols)
  - arrayMul
```
public FloatMatrix arrayMul(FloatMatrix matrix)
```
    Element-wise multiply by a matrix
    
    Parameters:
    matrix - The matrix to element-wise multiply the current matrix by
    
    Returns:
    New matrix with the result of the operation
  - arrayMuli
```
public FloatMatrix arrayMuli(FloatMatrix matrix)
```
    In place element-wise multiply by a matrix
    
    Parameters:
    matrix - The matrix to element-wise multiply the current matrix by
    
    Returns:
    The current matrix
  - div
```
public FloatMatrix div(FloatMatrix matrix)
```
    Divide by a matrix
    
    Parameters:
    matrix - The matrix to divide the current matrix by
    
    Returns:
    New matrix with the result of the operation
  - div
```
public FloatMatrix div(FloatMatrix A,
              FloatMatrix B)
```
    Make the current matrix be the result of the division of two matrices
    
    Parameters:
    A - matrix for numerator (dividend)
    B - matrix for denominator (divisor)
    
    Returns:
    The current matrix which is now the result of the operation
    
    Throws:
    
    java.lang.IllegalArgumentException - if B == this if 'this' and 'A*B' are not the same size
  - divi
```
public FloatMatrix divi(FloatMatrix matrix)
```
    In place divide by a matrix
    
    Parameters:
    matrix - The matrix to divide the current matrix by
    
    Returns:
    The current matrix
  - div
```
public FloatMatrix div(float scalar)
```
    Divide by a scalar
    
    Parameters:
    scalar - The scalar to divide the current matrix by
    
    Returns:
    New matrix with the result of the operation
  - divi
```
public FloatMatrix divi(float scalar)
```
    In place divide by a scalar
    
    Parameters:
    scalar - The scalar to divide the current matrix by
    
    Returns:
    The current matrix
  - arrayDiv
```
public FloatMatrix arrayDiv(FloatMatrix matrix)
```
    Element-wise divide by a matrix
    
    Parameters:
    matrix - The matrix to element-wise divide the current matrix by
    
    Returns:
    New matrix with the result of the operation
  - arrayDivi
```
public FloatMatrix arrayDivi(FloatMatrix matrix)
```
    In place element-wise divide by a matrix
    
    Parameters:
    matrix - The matrix to element-wise divide the current matrix by
    
    Returns:
    The current matrix
  - equals
```
public boolean equals(java.lang.Object object)
```
    Equals between matrices
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    object - The object to compare with
    
    Returns:
    true if the object is an instance of FloatMatrix with equal elements
  - eq
```
public FloatMatrix eq(FloatMatrix matrix)
```
    Element-wise equals between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    New matrix with the result of the operation
  - eqi
```
public FloatMatrix eqi(FloatMatrix matrix)
```
    In place element-wise equals between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    The current matrix
  - eq
```
public FloatMatrix eq(float scalar)
```
    Element-wise equals between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    New matrix with the result of the operation
  - eqi
```
public FloatMatrix eqi(float scalar)
```
    In place element-wise equals between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    The current matrix
  - ne
```
public FloatMatrix ne(FloatMatrix matrix)
```
    Element-wise not-equals between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    New matrix with the result of the operation
  - nei
```
public FloatMatrix nei(FloatMatrix matrix)
```
    In place element-wise not-equals between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    The current matrix
  - ne
```
public FloatMatrix ne(float scalar)
```
    Element-wise not-equals between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    New matrix with the result of the operation
  - nei
```
public FloatMatrix nei(float scalar)
```
    In place element-wise not-equals between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    The current matrix
  - gt
```
public FloatMatrix gt(FloatMatrix matrix)
```
    Element-wise greater than between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    New matrix with the result of the operation
  - gti
```
public FloatMatrix gti(FloatMatrix matrix)
```
    In place element-wise greater than between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    The current matrix
  - gt
```
public FloatMatrix gt(float scalar)
```
    Element-wise greater than between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    New matrix with the result of the operation
  - gti
```
public FloatMatrix gti(float scalar)
```
    In place element-wise greater than between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    The current matrix
  - lt
```
public FloatMatrix lt(FloatMatrix matrix)
```
    Element-wise lower than between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    New matrix with the result of the operation
  - lti
```
public FloatMatrix lti(FloatMatrix matrix)
```
    In place element-wise lower than between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    The current matrix
  - lt
```
public FloatMatrix lt(float scalar)
```
    Element-wise lower than between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    New matrix with the result of the operation
  - lti
```
public FloatMatrix lti(float scalar)
```
    In place element-wise lower than between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    The current matrix
  - ge
```
public FloatMatrix ge(FloatMatrix matrix)
```
    Element-wise greater or equals between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    New matrix with the result of the operation
  - gei
```
public FloatMatrix gei(FloatMatrix matrix)
```
    In place element-wise greater or equals between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    The current matrix
  - ge
```
public FloatMatrix ge(float scalar)
```
    Element-wise greater or equals between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    New matrix with the result of the operation
  - gei
```
public FloatMatrix gei(float scalar)
```
    In place element-wise greater or equals between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    The current matrix
  - le
```
public FloatMatrix le(FloatMatrix matrix)
```
    Element-wise lower or equals between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    New matrix with the result of the operation
  - lei
```
public FloatMatrix lei(FloatMatrix matrix)
```
    In place element-wise lower or equals between matrices elements
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    The current matrix
  - le
```
public FloatMatrix le(float scalar)
```
    Element-wise lower or equals between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    New matrix with the result of the operation
  - lei
```
public FloatMatrix lei(float scalar)
```
    In place element-wise lower or equals between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    The current matrix
  - diag
```
public FloatMatrix diag(int k)
```
    Return the k-th diagonal of the matrix.
    
    Parameters:
    k - If k is positive, returns the k-th super diagonal. If it is negative, returns the -k-th sub-diagonal. If k is zero, returns the main diagonal.
    
    Returns:
    New vector containing the k-th diagonal elements
  - transpose
```
public FloatMatrix transpose()
```
    Transpose. For complex matrices, this is the complex conjugate transpose.
    
    Returns:
    New matrix with the result of the operation
  - transpose
```
public FloatMatrix transpose(FloatMatrix matrix)
```
    Transpose a matrix and store the result into the current matrix. For complex matrices, this is the complex conjugate transpose.
    
    Parameters:
    matrix - the matrix where the result will be stored
    
    Returns:
    'this' that now contains the transpose
    
    Throws:
    
    java.lang.IllegalArgumentException - if the size of result is not compatible with the size of the transpose
  - transposei
```
public FloatMatrix transposei()
```
    Transpose in place. For complex matrices, this is the complex conjugate transpose.
    
    Returns:
    The current matrix
  - arrayTranspose
```
public FloatMatrix arrayTranspose()
```
    Transpose. For complex matrices, this does not involve conjugation.
    
    Returns:
    New matrix with the result of the operation
  - arrayTransposei
```
public FloatMatrix arrayTransposei()
```
    Transpose in place. For complex matrices, this does not involve conjugation.
    
    Returns:
    The current matrix
  - det
```
public float det()
```
    Matrix determinant
    
    Returns:
    The determinant of the square matrix
  - sum
```
public float sum()
```
    The sum of all elements of the matrix
    
    Returns:
    The sum of all elements of the matrix
  - prod
```
public float prod()
```
    The product of all elements of the matrix
    
    Returns:
    The product of all elements of the matrix
  - mean
```
public float mean()
```
    The mean value of all elements in the matrix
    
    Returns:
    The mean value of all elements in the matrix
  - norm1
```
public float norm1()
```
    The 1-norm of the matrix
    
    Returns:
    The 1-norm of the matrix as vector (the maximun of the sum of absolute values of elements on each column)
  - norm2
```
public float norm2()
```
    The 2-norm of the matrix
    
    Returns:
    The Euclidean norm of a vector (i.e. sqrt(sum(x)) ), or the Frobenius norm of a matrix (i.e. sqrt(sum(diag(x'*x))) ).
  - normInf
```
public float normInf()
```
    The Inf-norm of the matrix
    
    Returns:
    The Inf-norm of the matrix as vector (the maximun of the sum of absolute values of elements on each row).
  - min
```
public float min()
```
    The minimum element of the matrix
    
    Returns:
    The minimum element of the matrix
  - argmin
```
public int argmin()
```
    The linear index of the minimum element of the matrix
    
    Returns:
    The linear index of the minimum element of the matrix
  - min
```
public FloatMatrix min(FloatMatrix matrix)
```
    Element-wise minimum between matrices
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    New matrix with the result of the operation
  - mini
```
public FloatMatrix mini(FloatMatrix matrix)
```
    In place element-wise minimum between matrices
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    The current matrix
  - min
```
public FloatMatrix min(float scalar)
```
    Element-wise minimum between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    New matrix with the result of the operation
  - mini
```
public FloatMatrix mini(float scalar)
```
    In place element-wise minimum between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    The current matrix
  - max
```
public float max()
```
    The maximum element of the matrix
    
    Returns:
    The maximum element of the matrix
  - argmax
```
public int argmax()
```
    The linear index of the maximum element of the matrix
    
    Returns:
    The linear index of the maximum element of the matrix
  - max
```
public FloatMatrix max(FloatMatrix matrix)
```
    Element-wise maximum between matrices
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    New matrix with the result of the operation
  - maxi
```
public FloatMatrix maxi(FloatMatrix matrix)
```
    In place element-wise maximum between matrices
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    The current matrix
  - max
```
public FloatMatrix max(float scalar)
```
    Element-wise maximum between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    New matrix with the result of the operation
  - maxi
```
public FloatMatrix maxi(float scalar)
```
    In place element-wise maximum between matrix elements and a scalar
    
    Parameters:
    scalar - The scalar to compare the elements of the matrix with
    
    Returns:
    The current matrix
  - resize
```
public FloatMatrix resize(int rows,
                 int columns)
```
    Resize the matrix whith the given dimensions. Added elements will be set to zero.
    
    Parameters:
    rows - New number of rows
    columns - New number of columns
    
    Returns:
    New matrix with the given dimensions
  - resizei
```
public FloatMatrix resizei(int rows,
                  int columns)
```
    In-place resize the matrix whith the given dimensions. Added elements will be set to zero.
    
    Parameters:
    rows - New number of rows
    columns - New number of columns
    
    Returns:
    The current matrix
  - getEpsilon
```
public static double getEpsilon()
```
    get epsilon
  - setEpsilon
```
public static void setEpsilon(double epsilon)
```
    Set epsilon
  - toString
```
public java.lang.String toString()
```
    Get string representation of this complex
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    String representation of this complex
  - toFloatMatrix
```
public FloatMatrix toFloatMatrix()
```
    Convert the current matrix to FloatMatrix
    
    Specified by:
    
    toFloatMatrix in interface Matrix
    
    Returns:
    Converted matrix to FloatMatrix type
  - toDoubleMatrix
```
public DoubleMatrix toDoubleMatrix()
```
    Convert the current matrix to DoubleMatrix
    
    Specified by:
    
    toDoubleMatrix in interface Matrix
    
    Returns:
    Converted matrix to DoubleMatrix type
  - toComplexFloatMatrix
```
public ComplexFloatMatrix toComplexFloatMatrix()
```
    Convert the current matrix to ComplexFloatMatrix
    
    Specified by:
    
    toComplexFloatMatrix in interface Matrix
    
    Returns:
    Converted matrix to ComplexFloatMatrix type
  - toComplexDoubleMatrix
```
public ComplexDoubleMatrix toComplexDoubleMatrix()
```
    Convert the current matrix to ComplexDoubleMatrix
    
    Specified by:
    
    toComplexDoubleMatrix in interface Matrix
    
    Returns:
    Converted matrix to ComplexDoubleMatrix type

Class FloatMatrix

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FloatMatrix

FloatMatrix

FloatMatrix

FloatMatrix

FloatMatrix

FloatMatrix

Method Detail

clone

duplicate

get

set

get

set

get

set

get

set

getRow

setRow

getColumn

setColumn

getRows

getColumns

getLength

isEmpty

isSquare

isVector

isRowVector

isColumnVector

eye

eye

zeros

zeros

ones

ones

diag

diag

repmat

repmat

rand

rand

randn

randn

randn

randn

toVector

toArray

add

add

addi

add

addi

add

sub

sub

subi

sub

subi

sub

mul

mul

muli

mul

muli

mul

arrayMul

arrayMuli

div

div

divi

div

divi

arrayDiv

arrayDivi

equals