ComplexDoubleMatrix

java.lang.Object
- ej.numeric.ComplexDoubleMatrix

All Implemented Interfaces:

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

Constructor Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ComplexDoubleMatrix

ComplexDoubleMatrix

ComplexDoubleMatrix

ComplexDoubleMatrix

ComplexDoubleMatrix

ComplexDoubleMatrix

ComplexDoubleMatrix

ComplexDoubleMatrix

ComplexDoubleMatrix

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

toDoubleVector

toDoubleArray

add

add

addi

add

addi

add

sub

sub

subi

sub

subi

sub

mul

mul

muli