ComplexFloatMatrix

java.lang.Object
- ej.numeric.ComplexFloatMatrix

All Implemented Interfaces:

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

Constructor Summary

Constructors
Constructor and Description
`ComplexFloatMatrix(ComplexFloat[] data)` Construct a new row vector given the data
`ComplexFloatMatrix(ComplexFloat[][] data)` Construct a new matrix given the data as a two dimensions array
`ComplexFloatMatrix(float[] data)` Construct a new row vector given the data
`ComplexFloatMatrix(float[][] data)` Construct a new matrix given the data as a two dimensions array
`ComplexFloatMatrix(int rows)` Construct a new row vector given the number of rows
`ComplexFloatMatrix(int rows, int cols)` Construct a new matrix given the number of rows and columns
`ComplexFloatMatrix(int rows, int cols, boolean zeroInit)` Construct a new matrix given the number of rows and columns.
`ComplexFloatMatrix(int rows, int cols, ComplexFloat[] data)` Construct a new matrix given the number of rows, columns and the data as a linear array
`ComplexFloatMatrix(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
`ComplexFloatMatrix`	`add(ComplexFloat scalar)` Add a scalar
`ComplexFloatMatrix`	`add(ComplexFloatMatrix matrix)` Add a matrix
`ComplexFloatMatrix`	`add(ComplexFloatMatrix A, ComplexFloatMatrix B)` Make the current matrix be the result of the addition of two matrices
`ComplexFloatMatrix`	`add(ComplexFloatMatrix A, ComplexFloatMatrix 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
`ComplexFloatMatrix`	`addi(ComplexFloat scalar)` In place add a scalar
`ComplexFloatMatrix`	`addi(ComplexFloatMatrix 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
`ComplexFloatMatrix`	`arrayDiv(ComplexFloatMatrix matrix)` Element-wise divide by a matrix
`ComplexFloatMatrix`	`arrayDivi(ComplexFloatMatrix matrix)` In place element-wise divide by a matrix
`ComplexFloatMatrix`	`arrayMul(ComplexFloatMatrix matrix)` Element-wise multiply by a matrix
`ComplexFloatMatrix`	`arrayMuli(ComplexFloatMatrix matrix)` In place element-wise multiply by a matrix
`ComplexFloatMatrix`	`arrayTranspose()` Transpose.
`ComplexFloatMatrix`	`arrayTransposei()` Transpose in place.
`java.lang.Object`	`clone()` Makes a deep copy of this matrix.
`ComplexFloat`	`det()` Matrix determinant
`static ComplexFloatMatrix`	`diag(ComplexFloatMatrix v)` Create a diagonal matrix with vector v on the main diagonal
`static ComplexFloatMatrix`	`diag(ComplexFloatMatrix v, int k)` Create a diagonal matrix with vector v on the diagonal k
`ComplexFloatMatrix`	`diag(int k)` Return the k-th diagonal of the matrix.
`ComplexFloatMatrix`	`div(ComplexFloat scalar)` Divide by a scalar
`ComplexFloatMatrix`	`div(ComplexFloatMatrix matrix)` Divide by a matrix
`ComplexFloatMatrix`	`div(ComplexFloatMatrix A, ComplexFloatMatrix B)` Make the current matrix be the result of the division of two matrices
`ComplexFloatMatrix`	`divi(ComplexFloat scalar)` In place divide by a scalar
`ComplexFloatMatrix`	`divi(ComplexFloatMatrix matrix)` In place divide by a matrix
`ComplexFloatMatrix`	`duplicate(ComplexFloatMatrix A)` Copy the data of a matrix to the current matrix.
`ComplexFloatMatrix`	`eq(ComplexFloat scalar)` Element-wise equals between matrix elements and a scalar
`ComplexFloatMatrix`	`eq(ComplexFloatMatrix matrix)` Element-wise equals between matrices elements
`ComplexFloatMatrix`	`eqi(ComplexFloat scalar)` In place element-wise equals between matrix elements and a scalar
`ComplexFloatMatrix`	`eqi(ComplexFloatMatrix matrix)` In place element-wise equals between matrices elements
`boolean`	`equals(java.lang.Object object)` Equals between matrices
`static ComplexFloatMatrix`	`eye(int dim)` Create a square identity matrix
`static ComplexFloatMatrix`	`eye(int rows, int cols)` Create an identity matrix with the given dimensions
`ComplexFloatMatrix`	`ge(ComplexFloat scalar)` Element-wise greater or equals between matrix elements and a scalar
`ComplexFloatMatrix`	`ge(ComplexFloatMatrix matrix)` Element-wise greater or equals between matrices elements
`ComplexFloatMatrix`	`gei(ComplexFloat scalar)` In place element-wise greater or equals between matrix elements and a scalar
`ComplexFloatMatrix`	`gei(ComplexFloatMatrix matrix)` In place element-wise greater or equals between matrices elements
`ComplexFloat`	`get(int index)` Get the element at the given linear index
`ComplexFloat`	`get(int row, int col)` Get the element at the given row and column
`ComplexFloatMatrix`	`get(Range range)` Get a vector of the elements at the given linear index range
`ComplexFloatMatrix`	`get(Range rowsRange, Range colsRange)` Get a matrix of the elements at the given index ranges
`ComplexFloatMatrix`	`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
`float`	`getImaginary(int index)` Get the imaginary part of the element at the given linear index
`float`	`getImaginary(int row, int col)` Get the imaginary part of the element at the given row and column
`int`	`getLength()` Get the total number of elements
`float`	`getReal(int index)` Get the real part of the element at the given linear index
`float`	`getReal(int row, int col)` Get the real part of the element at the given row and column
`ComplexFloatMatrix`	`getRow(int row)` Get a vector of the elements at the given row
`int`	`getRows()` Get the number of rows
`ComplexFloatMatrix`	`gt(ComplexFloat scalar)` Element-wise greater than between matrix elements and a scalar
`ComplexFloatMatrix`	`gt(ComplexFloatMatrix matrix)` Element-wise greater than between matrices elements
`ComplexFloatMatrix`	`gti(ComplexFloat scalar)` In place element-wise greater than between matrix elements and a scalar
`ComplexFloatMatrix`	`gti(ComplexFloatMatrix 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
`ComplexFloatMatrix`	`le(ComplexFloat scalar)` Element-wise lower or equals between matrix elements and a scalar
`ComplexFloatMatrix`	`le(ComplexFloatMatrix matrix)` Element-wise lower or equals between matrices elements
`ComplexFloatMatrix`	`lei(ComplexFloat scalar)` In place element-wise lower or equals between matrix elements and a scalar
`ComplexFloatMatrix`	`lei(ComplexFloatMatrix matrix)` In place element-wise lower or equals between matrices elements
`ComplexFloatMatrix`	`lt(ComplexFloat scalar)` Element-wise lower than between matrix elements and a scalar
`ComplexFloatMatrix`	`lt(ComplexFloatMatrix matrix)` Element-wise lower than between matrices elements
`ComplexFloatMatrix`	`lti(ComplexFloat scalar)` In place element-wise lower than between matrix elements and a scalar
`ComplexFloatMatrix`	`lti(ComplexFloatMatrix matrix)` In place element-wise lower than between matrices elements
`ComplexFloat`	`max()` The maximum element of the matrix
`ComplexFloatMatrix`	`max(ComplexFloat scalar)` Element-wise maximum between matrix elements and a scalar
`ComplexFloatMatrix`	`max(ComplexFloatMatrix matrix)` Element-wise maximum between matrices
`ComplexFloatMatrix`	`maxi(ComplexFloat scalar)` In place element-wise maximum between matrix elements and a scalar
`ComplexFloatMatrix`	`maxi(ComplexFloatMatrix matrix)` In place element-wise maximum between matrices
`ComplexFloat`	`mean()` The mean value of all elements in the matrix
`ComplexFloat`	`min()` The minimum element of the matrix
`ComplexFloatMatrix`	`min(ComplexFloat scalar)` Element-wise minimum between matrix elements and a scalar
`ComplexFloatMatrix`	`min(ComplexFloatMatrix matrix)` Element-wise minimum between matrices
`ComplexFloatMatrix`	`mini(ComplexFloat scalar)` In place element-wise minimum between matrix elements and a scalar
`ComplexFloatMatrix`	`mini(ComplexFloatMatrix matrix)` In place element-wise minimum between matrices
`ComplexFloatMatrix`	`mul(ComplexFloat scalar)` Multiply by a scalar
`ComplexFloatMatrix`	`mul(ComplexFloatMatrix matrix)` Multiply by a matrix
`ComplexFloatMatrix`	`mul(ComplexFloatMatrix A, ComplexFloatMatrix B)` Make the current matrix be the result of the multiplication of two matrices
`ComplexFloatMatrix`	`mul(ComplexFloatMatrix A, ComplexFloatMatrix 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
`ComplexFloatMatrix`	`muli(ComplexFloat scalar)` In place multiply by a scalar
`ComplexFloatMatrix`	`muli(ComplexFloatMatrix matrix)` In place multiply by a matrix
`ComplexFloatMatrix`	`ne(ComplexFloat scalar)` Element-wise not-equals between matrix elements and a scalar
`ComplexFloatMatrix`	`ne(ComplexFloatMatrix matrix)` Element-wise not-equals between matrices elements
`ComplexFloatMatrix`	`nei(ComplexFloat scalar)` In place element-wise not-equals between matrix elements and a scalar
`ComplexFloatMatrix`	`nei(ComplexFloatMatrix 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 ComplexFloatMatrix`	`ones(int dim)` Create a square matrix filled with ones
`static ComplexFloatMatrix`	`ones(int rows, int cols)` Create a matrix filled with ones with the given dimensions
`ComplexFloat`	`prod()` The product of all elements of the matrix
`static ComplexFloatMatrix`	`rand(int dim)` Create a square matrix filled with random elements uniformly distributed ont the interval (0, 1)
`static ComplexFloatMatrix`	`rand(int rows, int cols)` Create a matrix filled with random elements uniformly distributed on the interval (0, 1)
`static ComplexFloatMatrix`	`randn(int dim)` Create a square matrix filled with random elements normally distributed on the interval (0, 1)
`static ComplexFloatMatrix`	`randn(int dim, ComplexFloat realMean, ComplexFloat realStandardDeviation, ComplexFloat imaginaryMean, ComplexFloat imaginaryStandardDeviation)` Create a square matrix filled with random elements normally distributed on the interval [minInterval, maxInterval]
`static ComplexFloatMatrix`	`randn(int rows, int cols)` Create a matrix filled with random elements normally distributed on the interval (0, 1)
`static ComplexFloatMatrix`	`randn(int rows, int cols, ComplexFloat realMean, ComplexFloat realStandardDeviation, ComplexFloat imaginaryMean, ComplexFloat imaginaryStandardDeviation)` Create a matrix filled with random elements normally distributed on the interval [minInterval, maxInterval]
`static ComplexFloatMatrix`	`repmat(ComplexFloat scalar, int rows, int cols)` Create a matrix of dimensions rows by columns containing the given scalar
`static ComplexFloatMatrix`	`repmat(ComplexFloatMatrix matrix, int rows, int cols)` Create a matrix containing rows by columns replications of the given matrix
`ComplexFloatMatrix`	`resize(int rows, int columns)` Resize the matrix whith the given dimensions.
`ComplexFloatMatrix`	`resizei(int rows, int columns)` In-place resize the matrix whith the given dimensions.
`void`	`set(int index, ComplexFloat element)` Set the element at the given linear index
`void`	`set(int row, int col, ComplexFloat element)` Set the element at the given row and column
`void`	`set(Range range, ComplexFloat element)` Set the elements at the given linear index range
`void`	`set(Range rowsRange, Range colsRange, ComplexFloat element)` Set the elements at the given index ranges
`void`	`setColumn(int column, ComplexFloatMatrix vector)` Set the elements at the given column
`static void`	`setEpsilon(double epsilon)` Set epsilon
`void`	`setImaginary(int index, float imag)` Set the imaginary part of the element at the given linear index
`void`	`setImaginary(int row, int col, float imag)` Set the imaginary part of the element at the given row and column
`void`	`setReal(int index, float real)` Set the real part of the element at the given linear index
`void`	`setReal(int row, int col, float real)` Set the real part of the element at the given row and column
`void`	`setRow(int row, ComplexFloatMatrix vector)` Set the elements at the given row
`ComplexFloatMatrix`	`sub(ComplexFloat scalar)` Subtract a scalar
`ComplexFloatMatrix`	`sub(ComplexFloatMatrix matrix)` Subtract a matrix
`ComplexFloatMatrix`	`sub(ComplexFloatMatrix A, ComplexFloatMatrix B)` Make the current matrix be the result of the subtraction of two matrices
`ComplexFloatMatrix`	`sub(ComplexFloatMatrix A, ComplexFloatMatrix 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
`ComplexFloatMatrix`	`subi(ComplexFloat scalar)` In place subtract a scalar
`ComplexFloatMatrix`	`subi(ComplexFloatMatrix matrix)` In place subtract a matrix
`ComplexFloat`	`sum()` The sum of all elements of the matrix
`ComplexFloat[][]`	`toArray()` Convert to a 2D array of ComplexFloat
`ComplexDoubleMatrix`	`toComplexDoubleMatrix()` Convert the current matrix to ComplexDoubleMatrix
`ComplexFloatMatrix`	`toComplexFloatMatrix()` Convert the current matrix to ComplexFloatMatrix
`DoubleMatrix`	`toDoubleMatrix()` Convert the current matrix to DoubleMatrix
`float[][]`	`toFloatArray()` Convert to a 2D array of float
`FloatMatrix`	`toFloatMatrix()` Convert the current matrix to FloatMatrix
`float[]`	`toFloatVector()` Convert to a 1D array of float
`java.lang.String`	`toString()` Get string representation of this complex
`ComplexFloat[]`	`toVector()` Convert to a 1D array of ComplexFloat
`ComplexFloatMatrix`	`transpose()` Transpose.
`ComplexFloatMatrix`	`transpose(ComplexFloatMatrix matrix)` Transpose a matrix and store the result into the current matrix.
`ComplexFloatMatrix`	`transposei()` Transpose in place.
`static ComplexFloatMatrix`	`zeros(int dim)` Create a square matrix filled with zeros
`static ComplexFloatMatrix`	`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
  - ComplexFloatMatrix
```
public ComplexFloatMatrix(int rows,
                  int cols)
```
    Construct a new matrix given the number of rows and columns
    
    Parameters:
    rows - Number of rows
    cols - Number of columns
  - ComplexFloatMatrix
```
public ComplexFloatMatrix(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.
  - ComplexFloatMatrix
```
public ComplexFloatMatrix(int rows,
                  int cols,
                  ComplexFloat[] 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
  - ComplexFloatMatrix
```
public ComplexFloatMatrix(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 (real and imaginary data are interleaved)
  - ComplexFloatMatrix
```
public ComplexFloatMatrix(ComplexFloat[][] data)
```
    Construct a new matrix given the data as a two dimensions array
    
    Parameters:
    data - The data as a two dimensions array
  - ComplexFloatMatrix
```
public ComplexFloatMatrix(float[][] data)
```
    Construct a new matrix given the data as a two dimensions array
    
    Parameters:
    data - The data as a two dimensions array (real and imaginary data are interleaved)
  - ComplexFloatMatrix
```
public ComplexFloatMatrix(int rows)
```
    Construct a new row vector given the number of rows
    
    Parameters:
    rows - Number of rows
  - ComplexFloatMatrix
```
public ComplexFloatMatrix(ComplexFloat[] data)
```
    Construct a new row vector given the data
    
    Parameters:
    data - The data
  - ComplexFloatMatrix
```
public ComplexFloatMatrix(float[] data)
```
    Construct a new row vector given the data
    
    Parameters:
    data - The data (real and imaginary data are interleaved)
- 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 ComplexFloatMatrix duplicate(ComplexFloatMatrix 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 ComplexFloat 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,
       ComplexFloat element)
```
    Set the element at the given row and column
    
    Parameters:
    row - The row
    col - The column
    element - The element to set
  - get
```
public ComplexFloat 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,
       ComplexFloat element)
```
    Set the element at the given linear index
    
    Parameters:
    index - The linear index
    element - The element to set
  - getReal
```
public float getReal(int row,
            int col)
```
    Get the real part of the element at the given row and column
    
    Parameters:
    row - The row
    col - The column
    
    Returns:
    The real part of the element at the given row and column
  - setReal
```
public void setReal(int row,
           int col,
           float real)
```
    Set the real part of the element at the given row and column
    
    Parameters:
    row - The row
    col - The column
    real - The real part of the element to set
  - getImaginary
```
public float getImaginary(int row,
                 int col)
```
    Get the imaginary part of the element at the given row and column
    
    Parameters:
    row - The row
    col - The column
    
    Returns:
    The imaginary part of the element at the given row and column
  - setImaginary
```
public void setImaginary(int row,
                int col,
                float imag)
```
    Set the imaginary part of the element at the given row and column
    
    Parameters:
    row - The row
    col - The column
    imag - The imaginary part of the element to set
  - getReal
```
public float getReal(int index)
```
    Get the real part of the element at the given linear index
    
    Parameters:
    index - The linear index
    
    Returns:
    The real part of the element at the given linear index
  - setReal
```
public void setReal(int index,
           float real)
```
    Set the real part of the element at the given linear index
    
    Parameters:
    index - The linear index
    real - The real part of the element to set
  - getImaginary
```
public float getImaginary(int index)
```
    Get the imaginary part of the element at the given linear index
    
    Parameters:
    index - The linear index
    
    Returns:
    The imaginary part of the element at the given linear index
  - setImaginary
```
public void setImaginary(int index,
                float imag)
```
    Set the imaginary part of the element at the given linear index
    
    Parameters:
    index - The linear index
    imag - The imaginary part of the element to set
  - get
```
public ComplexFloatMatrix 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,
       ComplexFloat 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 ComplexFloatMatrix 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,
       ComplexFloat 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 ComplexFloatMatrix 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,
          ComplexFloatMatrix 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 ComplexFloatMatrix 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,
             ComplexFloatMatrix 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 ComplexFloatMatrix 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 ComplexFloatMatrix 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 ComplexFloatMatrix 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 ComplexFloatMatrix 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 ComplexFloatMatrix 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 ComplexFloatMatrix 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 ComplexFloatMatrix diag(ComplexFloatMatrix 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 ComplexFloatMatrix diag(ComplexFloatMatrix v)
```
    Create a diagonal matrix with vector v on the main diagonal
    
    Parameters:
    v - Vector of elements
    
    Returns:
    Created diagonal matrix
  - repmat
```
public static ComplexFloatMatrix repmat(ComplexFloatMatrix 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 ComplexFloatMatrix repmat(ComplexFloat 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 ComplexFloatMatrix 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 ComplexFloatMatrix 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 ComplexFloatMatrix 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 ComplexFloatMatrix randn(int dim,
                       ComplexFloat realMean,
                       ComplexFloat realStandardDeviation,
                       ComplexFloat imaginaryMean,
                       ComplexFloat imaginaryStandardDeviation)
```
    Create a square matrix filled with random elements normally distributed on the interval [minInterval, maxInterval]
    
    Parameters:
    dim - Dimension of the square matrix to create
    realMean - the mean value for the generated real numbers
    realStandardDeviation - the standard deviation for the generated real numbers
    imaginaryMean - the mean value for the generated imaginary numbers
    imaginaryStandardDeviation - the standard deviation for the generated imaginary numbers
    
    Returns:
    Created square matrix filled with random elements normally distributed on the interval [minInterval, maxInterval]
  - randn
```
public static ComplexFloatMatrix 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 ComplexFloatMatrix randn(int rows,
                       int cols,
                       ComplexFloat realMean,
                       ComplexFloat realStandardDeviation,
                       ComplexFloat imaginaryMean,
                       ComplexFloat imaginaryStandardDeviation)
```
    Create a matrix filled with random elements normally distributed on the interval [minInterval, maxInterval]
    
    Parameters:
    rows - Number of rows
    cols - Number of columns
    realMean - the mean value for the generated real part
    realStandardDeviation - the standard deviation for the generated real part
    imaginaryMean - the mean value for the generated imaginary number
    imaginaryStandardDeviation - the standard deviation for the generated imaginary number
    
    Returns:
    Created matrix filled with random elements normally distributed using mean and standardDeviation
  - toVector
```
public ComplexFloat[] toVector()
```
    Convert to a 1D array of ComplexFloat
    
    Returns:
    New array with a copy of the matrix's data
  - toArray
```
public ComplexFloat[][] toArray()
```
    Convert to a 2D array of ComplexFloat
    
    Returns:
    New array with a copy of the matrix's data
  - toFloatVector
```
public float[] toFloatVector()
```
    Convert to a 1D array of float
    
    Returns:
    New array with a copy of the matrix's data (real and imaginary data are interleaved)
  - toFloatArray
```
public float[][] toFloatArray()
```
    Convert to a 2D array of float
    
    Returns:
    New array with a copy of the matrix's data (real and imaginary data are interleaved)
  - add
```
public ComplexFloatMatrix add(ComplexFloatMatrix 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 ComplexFloatMatrix add(ComplexFloatMatrix A,
                     ComplexFloatMatrix 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 ComplexFloatMatrix addi(ComplexFloatMatrix matrix)
```
    In place add a matrix
    
    Parameters:
    matrix - The matrix to add to the current matrix
    
    Returns:
    The current matrix
  - add
```
public ComplexFloatMatrix add(ComplexFloat 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 ComplexFloatMatrix addi(ComplexFloat scalar)
```
    In place add a scalar
    
    Parameters:
    scalar - The scalar to add to the current matrix
    
    Returns:
    The current matrix
  - add
```
public ComplexFloatMatrix add(ComplexFloatMatrix A,
                     ComplexFloatMatrix 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 ComplexFloatMatrix sub(ComplexFloatMatrix 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 ComplexFloatMatrix sub(ComplexFloatMatrix A,
                     ComplexFloatMatrix 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 ComplexFloatMatrix subi(ComplexFloatMatrix matrix)
```
    In place subtract a matrix
    
    Parameters:
    matrix - The matrix to subtract to the current matrix
    
    Returns:
    The current matrix
  - sub
```
public ComplexFloatMatrix sub(ComplexFloat 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 ComplexFloatMatrix subi(ComplexFloat scalar)
```
    In place subtract a scalar
    
    Parameters:
    scalar - The scalar to subtract to the current matrix
    
    Returns:
    The current matrix
  - sub
```
public ComplexFloatMatrix sub(ComplexFloatMatrix A,
                     ComplexFloatMatrix 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 ComplexFloatMatrix mul(ComplexFloatMatrix 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 ComplexFloatMatrix mul(ComplexFloatMatrix A,
                     ComplexFloatMatrix 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 ComplexFloatMatrix muli(ComplexFloatMatrix matrix)
```
    In place multiply by a matrix
    
    Parameters:
    matrix - The matrix to multiply the current matrix by
    
    Returns:
    The current matrix
  - mul
```
public ComplexFloatMatrix mul(ComplexFloat 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 ComplexFloatMatrix muli(ComplexFloat scalar)
```
    In place multiply by a scalar
    
    Parameters:
    scalar - The scalar to multiply the current matrix by
    
    Returns:
    The current matrix
  - mul
```
public ComplexFloatMatrix mul(ComplexFloatMatrix A,
                     ComplexFloatMatrix 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 ComplexFloatMatrix arrayMul(ComplexFloatMatrix 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 ComplexFloatMatrix arrayMuli(ComplexFloatMatrix 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 ComplexFloatMatrix div(ComplexFloatMatrix 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 ComplexFloatMatrix div(ComplexFloatMatrix A,
                     ComplexFloatMatrix 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 ComplexFloatMatrix divi(ComplexFloatMatrix matrix)
```
    In place divide by a matrix
    
    Parameters:
    matrix - The matrix to divide the current matrix by
    
    Returns:
    The current matrix
  - div
```
public ComplexFloatMatrix div(ComplexFloat 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 ComplexFloatMatrix divi(ComplexFloat scalar)
```
    In place divide by a scalar
    
    Parameters:
    scalar - The scalar to divide the current matrix by
    
    Returns:
    The current matrix
  - arrayDiv
```
public ComplexFloatMatrix arrayDiv(ComplexFloatMatrix 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 ComplexFloatMatrix arrayDivi(ComplexFloatMatrix 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 ComplexFloatMatrix with equal elements
  - eq
```
public ComplexFloatMatrix eq(ComplexFloatMatrix 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 ComplexFloatMatrix eqi(ComplexFloatMatrix 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 ComplexFloatMatrix eq(ComplexFloat 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 ComplexFloatMatrix eqi(ComplexFloat 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 ComplexFloatMatrix ne(ComplexFloatMatrix 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 ComplexFloatMatrix nei(ComplexFloatMatrix 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 ComplexFloatMatrix ne(ComplexFloat 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 ComplexFloatMatrix nei(ComplexFloat 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 ComplexFloatMatrix gt(ComplexFloatMatrix 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 ComplexFloatMatrix gti(ComplexFloatMatrix 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 ComplexFloatMatrix gt(ComplexFloat 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 ComplexFloatMatrix gti(ComplexFloat 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 ComplexFloatMatrix lt(ComplexFloatMatrix 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 ComplexFloatMatrix lti(ComplexFloatMatrix 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 ComplexFloatMatrix lt(ComplexFloat 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 ComplexFloatMatrix lti(ComplexFloat 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 ComplexFloatMatrix ge(ComplexFloatMatrix 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 ComplexFloatMatrix gei(ComplexFloatMatrix 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 ComplexFloatMatrix ge(ComplexFloat 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 ComplexFloatMatrix gei(ComplexFloat 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 ComplexFloatMatrix le(ComplexFloatMatrix 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 ComplexFloatMatrix lei(ComplexFloatMatrix 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 ComplexFloatMatrix le(ComplexFloat 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 ComplexFloatMatrix lei(ComplexFloat 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 ComplexFloatMatrix 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 ComplexFloatMatrix transpose()
```
    Transpose. For complex matrices, this is the complex conjugate transpose.
    
    Returns:
    New matrix with the result of the operation
  - transpose
```
public ComplexFloatMatrix transpose(ComplexFloatMatrix 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 ComplexFloatMatrix transposei()
```
    Transpose in place. For complex matrices, this is the complex conjugate transpose.
    
    Returns:
    The current matrix
  - arrayTranspose
```
public ComplexFloatMatrix arrayTranspose()
```
    Transpose. For complex matrices, this does not involve conjugation.
    
    Returns:
    New matrix with the result of the operation
  - arrayTransposei
```
public ComplexFloatMatrix arrayTransposei()
```
    Transpose in place. For complex matrices, this does not involve conjugation.
    
    Returns:
    The current matrix
  - det
```
public ComplexFloat det()
```
    Matrix determinant
    
    Returns:
    The determinant of the square matrix
  - sum
```
public ComplexFloat sum()
```
    The sum of all elements of the matrix
    
    Returns:
    The sum of all elements of the matrix
  - prod
```
public ComplexFloat prod()
```
    The product of all elements of the matrix
    
    Returns:
    The product of all elements of the matrix
  - mean
```
public ComplexFloat 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 ComplexFloat 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 ComplexFloatMatrix min(ComplexFloatMatrix 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 ComplexFloatMatrix mini(ComplexFloatMatrix matrix)
```
    In place element-wise minimum between matrices
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    The current matrix
  - min
```
public ComplexFloatMatrix min(ComplexFloat 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 ComplexFloatMatrix mini(ComplexFloat 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 ComplexFloat 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 ComplexFloatMatrix max(ComplexFloatMatrix 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 ComplexFloatMatrix maxi(ComplexFloatMatrix matrix)
```
    In place element-wise maximum between matrices
    
    Parameters:
    matrix - The matrix to compare the current matrix with
    
    Returns:
    The current matrix
  - max
```
public ComplexFloatMatrix max(ComplexFloat 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 ComplexFloatMatrix maxi(ComplexFloat 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 ComplexFloatMatrix 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 ComplexFloatMatrix 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 ComplexFloatMatrix

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ComplexFloatMatrix

ComplexFloatMatrix

ComplexFloatMatrix

ComplexFloatMatrix

ComplexFloatMatrix

ComplexFloatMatrix

ComplexFloatMatrix

ComplexFloatMatrix

ComplexFloatMatrix

Method Detail

clone

duplicate

get

set

get

set

getReal

setReal

getImaginary

setImaginary

getReal

setReal

getImaginary

setImaginary

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

toFloatVector

toFloatArray

add

add

addi

add

addi

add

sub

sub

subi

sub

subi

sub

mul

mul

muli