IComplexNDArray (nd4j-api 0.0.3.5.5.3 API)

All Superinterfaces:

INDArray, Serializable

All Known Implementing Classes:

BaseComplexNDArray
```
public interface IComplexNDArray
extends INDArray
```
Complex numbers

Author:

Adam Gibson

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`IComplexNDArray`	`add(IComplexNumber n)`
`IComplexNDArray`	`add(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`add(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`add(INDArray other)` copy addition of two matrices
`IComplexNDArray`	`add(INDArray other, INDArray result)` copy addition of two matrices
`IComplexNDArray`	`add(Number n)` Scalar addition (cloning)
`IComplexNDArray`	`add(Number n, INDArray result)`
`IComplexNDArray`	`addColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`addi(IComplexNumber n)`
`IComplexNDArray`	`addi(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`addi(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`addi(INDArray other)` in place addition of two matrices
`IComplexNDArray`	`addi(INDArray other, INDArray result)` in place addition of two matrices
`IComplexNDArray`	`addi(Number n)` In place scalar addition
`IComplexNDArray`	`addi(Number n, INDArray result)` In place addition
`IComplexNDArray`	`addiColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`addiRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`addRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`assign(IComplexNDArray arr)` Assign all of the elements in the given ndarray to this nedarray
`void`	`assign(IComplexNumber aDouble)`
`IComplexNDArray`	`assign(Number value)` Set the value of the ndarray to the specified value
`int`	`blasOffset()` For blas operations, this is the offset / 2 when offset is > 0
`IComplexNDArray`	`broadcast(int[] shape)` Broadcasts this ndarray to be the specified shape
`void`	`checkDimensions(INDArray other)` Validate dimensions are equal
`IComplexNDArray`	`cond(Condition condition)` 1 in an ndarray when condition is fulfilled, 0 otherwise(copying)(
`IComplexNDArray`	`condi(Condition condition)` 1 in an ndarray when condition is fulfilled, 0 otherwise(copying)(
`IComplexNDArray`	`conj()` Compute complex conj.
`IComplexNDArray`	`conji()` Compute complex conj (in-place).
`IComplexNDArray`	`cumsum(int dimension)` Cumulative sum along a dimension (in place)
`IComplexNDArray`	`cumsumi(int dimension)` Cumulative sum along a dimension
`IComplexNDArray`	`dimShuffle(Object[] rearrange, int[] newOrder, boolean[] broadCastable)` Dimshuffle: an extension of permute that adds the ability to broadcast various dimensions.
`IComplexNDArray`	`div(IComplexNumber n)`
`IComplexNDArray`	`div(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`div(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`div(INDArray other)` in place (element wise) division of two matrices
`IComplexNDArray`	`div(INDArray other, INDArray result)` copy (element wise) division of two matrices
`IComplexNDArray`	`div(Number n)` Division by a number
`IComplexNDArray`	`div(Number n, INDArray result)`
`IComplexNDArray`	`divColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`divi(IComplexNumber n)`
`IComplexNDArray`	`divi(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`divi(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`divi(INDArray other)` in place (element wise) division of two matrices
`IComplexNDArray`	`divi(INDArray other, INDArray result)` in place (element wise) division of two matrices
`IComplexNDArray`	`divi(Number n)` In place scalar division
`IComplexNDArray`	`divi(Number n, INDArray result)` In place division of this ndarray
`IComplexNDArray`	`diviColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`diviRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`divRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`dup()` Return a copy of this ndarray
`int[]`	`endsForSlices()` Gives the indices for the ending of each slice
`IComplexNDArray`	`eps(IComplexNumber other)` Returns an ndarray with 1 if the element is epsilon equals
`IComplexNDArray`	`eps(INDArray other)` epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`IComplexNDArray`	`eps(Number other)` Returns an ndarray with 1 if the element is epsilon equals
`IComplexNDArray`	`epsi(IComplexNumber other)` Returns an ndarray with 1 if the element is epsilon equals
`IComplexNDArray`	`epsi(INDArray other)` In place epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`IComplexNDArray`	`epsi(Number other)` Returns an ndarray with 1 if the element is epsilon equals
`IComplexNDArray`	`eq(IComplexNumber other)`
`IComplexNDArray`	`eq(INDArray other)` equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`IComplexNDArray`	`eq(Number other)` Returns an ndarray with 1 if the element is less than the given element 0 other wise
`IComplexNDArray`	`eqi(IComplexNumber other)`
`IComplexNDArray`	`eqi(INDArray other)` In place equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`IComplexNDArray`	`eqi(Number other)` In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`IComplexNDArray`	`get(NDArrayIndex... indexes)` Returns a subset of this array based on the specified indexes
`IComplexNDArray`	`getColumn(int i)` Returns the specified column.
`IComplexNDArray`	`getColumns(int[] columns)` Get a list of specified columns
`IComplexNumber`	`getComplex(int... indices)` Get the complex number at the given indices
`IComplexNumber`	`getComplex(int i)`
`IComplexNumber`	`getComplex(int i, IComplexNumber result)`
`IComplexNumber`	`getComplex(int i, int j)`
`IComplexNumber`	`getComplex(int i, int j, IComplexNumber result)`
`double`	`getImag(int i)` Get the imaginary component at the specified index
`INDArray`	`getReal()` Gets the real portion of this complex ndarray
`double`	`getReal(int i)` Get the real component at the specified index
`IComplexNDArray`	`getRow(int i)` Returns the specified row.
`IComplexNDArray`	`getRows(int[] rows)` Get a list of rows
`IComplexNDArray`	`getScalar(int... indexes)` Fetch a particular number on a multi dimensional scale.
`IComplexNDArray`	`getScalar(int i)` Returns the element at the specified index
`IComplexNDArray`	`getScalar(int row, int column)` Returns the element at the specified row/column This will throw an exception if the
`IComplexNDArray`	`gt(IComplexNumber other)`
`IComplexNDArray`	`gt(INDArray other)` greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`IComplexNDArray`	`gt(Number other)` Greater than boolean (copying)(
`IComplexNDArray`	`gti(IComplexNumber other)`
`IComplexNDArray`	`gti(INDArray other)` In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`IComplexNDArray`	`gti(Number other)` In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`IComplexNDArray`	`hermitian()` a Hermitian matrix is a square matrix with complex entries that is equal to its own conjugate transpose
`INDArray`	`imag()`
`IComplexNDArray`	`linearView()` Returns a linear view reference of shape 1,length(ndarray)
`IComplexNDArray`	`linearViewColumnOrder()` Returns a linear view reference of shape length(ndarray),1
`IComplexNDArray`	`lt(IComplexNumber other)`
`IComplexNDArray`	`lt(INDArray other)` less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`IComplexNDArray`	`lt(Number other)` Returns an ndarray with 1 if the element is less than the given element 0 other wise
`IComplexNDArray`	`lti(IComplexNumber other)`
`IComplexNDArray`	`lti(INDArray other)` In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`IComplexNDArray`	`lti(Number other)` In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`IComplexNDArray`	`max(int dimension)` Returns the overall max of this ndarray
`IComplexNDArray`	`mean(int dimension)` Returns the overall mean of this ndarray
`IComplexNDArray`	`min(int dimension)` Returns the overall min of this ndarray
`IComplexNDArray`	`mmul(INDArray other)` Perform a copy matrix multiplication
`IComplexNDArray`	`mmul(INDArray other, INDArray result)` Perform an copy matrix multiplication
`IComplexNDArray`	`mmuli(INDArray other)` Perform an copy matrix multiplication
`IComplexNDArray`	`mmuli(INDArray other, INDArray result)` Perform an copy matrix multiplication
`IComplexNDArray`	`mul(IComplexNumber n)`
`IComplexNDArray`	`mul(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`mul(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`mul(INDArray other)` copy (element wise) multiplication of two matrices
`IComplexNDArray`	`mul(INDArray other, INDArray result)` copy (element wise) multiplication of two matrices
`IComplexNDArray`	`mul(Number n)` Scalar multiplication (copy)
`IComplexNDArray`	`mul(Number n, INDArray result)`
`IComplexNDArray`	`mulColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`muli(IComplexNumber n)`
`IComplexNDArray`	`muli(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`muli(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`muli(INDArray other)` in place (element wise) multiplication of two matrices
`IComplexNDArray`	`muli(INDArray other, INDArray result)` in place (element wise) multiplication of two matrices
`IComplexNDArray`	`muli(Number n)` In place scalar multiplication
`IComplexNDArray`	`muli(Number n, INDArray result)` In place multiplication of this ndarray
`IComplexNDArray`	`muliColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`muliRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`mulRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`neg()` Returns the ndarray negative (cloned)
`IComplexNDArray`	`negi()` In place setting of the negative version of this ndarray
`IComplexNDArray`	`neq(IComplexNumber other)`
`IComplexNDArray`	`neq(INDArray other)`
`IComplexNDArray`	`neq(Number other)`
`IComplexNDArray`	`neqi(IComplexNumber other)`
`IComplexNDArray`	`neqi(INDArray other)`
`IComplexNDArray`	`neqi(Number other)`
`IComplexNDArray`	`norm1(int dimension)` Returns the norm1 along the specified dimension
`IComplexNDArray`	`norm2(int dimension)` Returns the norm2 along the specified dimension
`IComplexNDArray`	`normmax(int dimension)` Returns the normmax along the specified dimension
`IComplexNDArray`	`permute(int[] rearrange)` See: http://www.mathworks.com/help/matlab/ref/permute.html
`IComplexNDArray`	`prod(int dimension)` Returns the product along a given dimension
`IComplexNDArray`	`put(int[] indexes, double value)`
`IComplexNDArray`	`put(int[] indexes, float value)`
`IComplexNDArray`	`put(int[] indices, INDArray element)` Inserts the element at the specified index
`IComplexNDArray`	`put(int i, IComplexNDArray element)` Put a scalar ndarray at the specified index
`IComplexNDArray`	`put(int i, INDArray element)` Inserts the element at the specified index
`IComplexNDArray`	`put(int i, int j, IComplexNumber complex)`
`IComplexNDArray`	`put(int i, int j, INDArray element)` Inserts the element at the specified index
`IComplexNDArray`	`put(NDArrayIndex[] indices, IComplexNDArray element)`
`IComplexNDArray`	`put(NDArrayIndex[] indices, IComplexNumber element)`
`IComplexNDArray`	`put(NDArrayIndex[] indices, Number element)` Put the elements of the ndarray in to the specified indices
`IComplexNDArray`	`putColumn(int column, INDArray toPut)` Insert a column in to this array Will throw an exception if this ndarray is not a matrix
`IComplexNDArray`	`putImag(int[] indices, double value)`
`IComplexNDArray`	`putImag(int[] indices, float value)`
`IComplexNDArray`	`putImag(int i, float v)`
`IComplexNDArray`	`putImag(int rowIndex, int columnIndex, double value)`
`IComplexNDArray`	`putImag(int rowIndex, int columnIndex, float value)`
`IComplexNDArray`	`putReal(int[] indices, double value)`
`IComplexNDArray`	`putReal(int[] indices, float value)`
`IComplexNDArray`	`putReal(int i, float v)`
`IComplexNDArray`	`putReal(int rowIndex, int columnIndex, double value)`
`IComplexNDArray`	`putReal(int rowIndex, int columnIndex, float value)`
`IComplexNDArray`	`putRow(int row, INDArray toPut)` Insert a row in to this array Will throw an exception if this ndarray is not a matrix
`INDArray`	`putScalar(int[] i, IComplexNumber complexNumber)`
`IComplexNDArray`	`putScalar(int i, double value)` Insert the number linearly in to the ndarray
`IComplexNDArray`	`putScalar(int i, IComplexNumber value)`
`IComplexNDArray`	`putScalar(int j, int i, IComplexNumber conji)`
`IComplexNDArray`	`putSlice(int slice, IComplexNDArray put)`
`IComplexNDArray`	`putSlice(int slice, INDArray put)` Assigns the given matrix (put) to the specified slice
`IComplexNDArray`	`ravel()` Returns a flattened version (row vector) of this ndarray
`IComplexNDArray`	`rdiv(IComplexNumber n)`
`IComplexNDArray`	`rdiv(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`rdiv(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`rdiv(INDArray other)` Reverse division
`IComplexNDArray`	`rdiv(INDArray other, INDArray result)` Reverse division
`IComplexNDArray`	`rdiv(Number n)` Reverse division
`IComplexNDArray`	`rdiv(Number n, INDArray result)` Reverse division (number / ndarray)
`IComplexNDArray`	`rdivColumnVector(INDArray columnVector)` In place reverse division of a column vector
`IComplexNDArray`	`rdivi(IComplexNumber n)`
`IComplexNDArray`	`rdivi(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`rdivi(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`rdivi(INDArray other)` Reverse divsion (in place)
`IComplexNDArray`	`rdivi(INDArray other, INDArray result)` Reverse division (in-place)
`IComplexNDArray`	`rdivi(Number n)` In place reverse division
`IComplexNDArray`	`rdivi(Number n, INDArray result)` Reverse in place division
`IComplexNDArray`	`rdiviColumnVector(INDArray columnVector)` In place reverse divison of a column vector
`IComplexNDArray`	`rdiviRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`rdivRowVector(INDArray rowVector)` In place addition of a column vector
`INDArray`	`real()`
`IComplexNDArray`	`repmat(int[] shape)` Replicate and tile array to fill out to the given shape
`IComplexNDArray`	`reshape(int... newShape)` Reshapes the ndarray (can't change the length of the ndarray)
`IComplexNDArray`	`reshape(int rows, int columns)` Reshapes the ndarray (can't change the length of the ndarray)
`IComplexNDArray`	`rsub(IComplexNumber n)`
`IComplexNDArray`	`rsub(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`rsub(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`rsub(INDArray other)`
`IComplexNDArray`	`rsub(INDArray other, INDArray result)` Reverse subtraction
`IComplexNDArray`	`rsub(Number n)` Reverse subtraction with duplicates
`IComplexNDArray`	`rsub(Number n, INDArray result)` Reverse subtraction
`IComplexNDArray`	`rsubColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`rsubi(IComplexNumber n)`
`IComplexNDArray`	`rsubi(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`rsubi(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`rsubi(INDArray other)`
`IComplexNDArray`	`rsubi(INDArray other, INDArray result)` Reverse subtraction (in-place)
`IComplexNDArray`	`rsubi(Number n)`
`IComplexNDArray`	`rsubi(Number n, INDArray result)` Reverse in place subtraction
`IComplexNDArray`	`rsubiColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`rsubiRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`rsubRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`slice(int i)` Returns the specified slice of this ndarray
`IComplexNDArray`	`slice(int i, int dimension)` Returns the specified slice of this ndarray
`IComplexNDArray`	`std(int dimension)` Standard deviation of an ndarray along a dimension
`IComplexNDArray`	`sub(IComplexNumber n)`
`IComplexNDArray`	`sub(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`sub(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`sub(INDArray other)` copy subtraction of two matrices
`IComplexNDArray`	`sub(INDArray other, INDArray result)` copy subtraction of two matrices
`IComplexNDArray`	`sub(Number n)` Scalar subtraction (copied)
`IComplexNDArray`	`sub(Number n, INDArray result)`
`IComplexNDArray`	`subColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`subi(IComplexNumber n)`
`IComplexNDArray`	`subi(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`subi(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`subi(INDArray other)` in place subtraction of two matrices
`IComplexNDArray`	`subi(INDArray other, INDArray result)` in place subtraction of two matrices
`IComplexNDArray`	`subi(Number n)` In place scalar subtraction
`IComplexNDArray`	`subi(Number n, INDArray result)` In place subtraction of this ndarray
`IComplexNDArray`	`subiColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`subiRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`subRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`sum(int dimension)` Returns the sum along the last dimension of this ndarray
`IComplexNDArray`	`swapAxes(int dimension, int with)` Mainly here for people coming from numpy.
`IComplexNumber[]`	`toArray()`
`IComplexNDArray`	`transpose()` Flip the rows and columns of a matrix
`IComplexNDArray`	`transposei()` Flip the rows and columns of a matrix
`IComplexNDArray`	`var(int dimension)` Returns the overall variance of this ndarray
`IComplexNDArray`	`vectorAlongDimension(int index, int dimension)` Get the vector along a particular dimension

Methods inherited from interface org.nd4j.linalg.api.ndarray.INDArray
assign, cleanup, columns, data, distance1, distance2, element, getDouble, getDouble, getDouble, getFloat, getFloat, getFloat, getInt, index, isCleanedUp, isColumnVector, isMatrix, isRowVector, isScalar, isSquare, isVector, length, linearIndex, majorStride, offset, ordering, put, put, putScalar, putScalar, putScalar, putScalar, putScalar, resetLinearView, rows, secondaryStride, setData, setData, setStride, shape, size, slices, sliceVectors, squaredDistance, stride, subArray, vectorsAlongDimension

- Method Detail
  - blasOffset
```
int blasOffset()
```
    For blas operations, this is the offset / 2 when offset is > 0
    
    Returns:
    
    the blas offset
  - linearViewColumnOrder
```
IComplexNDArray linearViewColumnOrder()
```
    Returns a linear view reference of shape length(ndarray),1
    
    Specified by:
    
    linearViewColumnOrder in interface INDArray
    
    Returns:
    
    the linear view of this ndarray
  - linearView
```
IComplexNDArray linearView()
```
    Returns a linear view reference of shape 1,length(ndarray)
    
    Specified by:
    
    linearView in interface INDArray
    
    Returns:
    
    the linear view of this ndarray
  - reshape
```
IComplexNDArray reshape(int rows,
                        int columns)
```
    Reshapes the ndarray (can't change the length of the ndarray)
    
    Specified by:
    
    reshape in interface INDArray
    
    Parameters:
    
    rows - the rows of the matrix
    
    columns - the columns of the matrix
    
    Returns:
    
    the reshaped ndarray
  - cumsumi
```
IComplexNDArray cumsumi(int dimension)
```
    Cumulative sum along a dimension
    
    Specified by:
    
    cumsumi in interface INDArray
    
    Parameters:
    
    dimension - the dimension to perform cumulative sum along
    
    Returns:
    
    the cumulative sum along the specified dimension
  - cumsum
```
IComplexNDArray cumsum(int dimension)
```
    Cumulative sum along a dimension (in place)
    
    Specified by:
    
    cumsum in interface INDArray
    
    Parameters:
    
    dimension - the dimension to perform cumulative sum along
    
    Returns:
    
    the cumulative sum along the specified dimension
  - vectorAlongDimension
```
IComplexNDArray vectorAlongDimension(int index,
                                     int dimension)
```
    Get the vector along a particular dimension
    
    Specified by:
    
    vectorAlongDimension in interface INDArray
    
    Parameters:
    
    index - the index of the vector to getScalar
    
    dimension - the dimension to getScalar the vector from
    
    Returns:
    
    the vector along a particular dimension
  - cond
```
IComplexNDArray cond(Condition condition)
```
    1 in an ndarray when condition is fulfilled, 0 otherwise(copying)(
    
    Specified by:
    
    cond in interface INDArray
    
    Parameters:
    
    condition - the condition to be fulfilled
    
    Returns:
  - condi
```
IComplexNDArray condi(Condition condition)
```
    1 in an ndarray when condition is fulfilled, 0 otherwise(copying)(
    
    Specified by:
    
    condi in interface INDArray
    
    Parameters:
    
    condition - the condition to be fulfilled
    
    Returns:
  - neq
```
IComplexNDArray neq(INDArray other)
```
    Specified by:
    
    neq in interface INDArray
  - neqi
```
IComplexNDArray neqi(INDArray other)
```
    Specified by:
    
    neqi in interface INDArray
  - neqi
```
IComplexNDArray neqi(Number other)
```
    Specified by:
    
    neqi in interface INDArray
  - neq
```
IComplexNDArray neq(Number other)
```
    Specified by:
    
    neq in interface INDArray
  - assign
```
IComplexNDArray assign(IComplexNDArray arr)
```
    Assign all of the elements in the given ndarray to this nedarray
    
    Parameters:
    
    arr - the elements to assign
    
    Returns:
    
    this
  - put
```
IComplexNDArray put(NDArrayIndex[] indices,
                    IComplexNumber element)
```
  - put
```
IComplexNDArray put(NDArrayIndex[] indices,
                    IComplexNDArray element)
```
  - put
```
IComplexNDArray put(NDArrayIndex[] indices,
                    Number element)
```
    Description copied from interface: INDArray
    
    Put the elements of the ndarray in to the specified indices
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    
    indices - the indices to put the ndarray in to
    
    element - the ndarray to put
    
    Returns:
    
    this ndarray
  - putScalar
```
IComplexNDArray putScalar(int i,
                          IComplexNumber value)
```
  - putScalar
```
IComplexNDArray putScalar(int i,
                          double value)
```
    Description copied from interface: INDArray
    
    Insert the number linearly in to the ndarray
    
    Specified by:
    
    putScalar in interface INDArray
    
    Parameters:
    
    i - the index to insert into
    
    value - the value to insert
    
    Returns:
    
    this
  - eps
```
IComplexNDArray eps(IComplexNumber other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - epsi
```
IComplexNDArray epsi(IComplexNumber other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - eps
```
IComplexNDArray eps(Number other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Specified by:
    
    eps in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - epsi
```
IComplexNDArray epsi(Number other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Specified by:
    
    epsi in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - eps
```
IComplexNDArray eps(INDArray other)
```
    epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    eps in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - epsi
```
IComplexNDArray epsi(INDArray other)
```
    In place epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    epsi in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - lt
```
IComplexNDArray lt(Number other)
```
    Description copied from interface: INDArray
    
    Returns an ndarray with 1 if the element is less than the given element 0 other wise
    
    Specified by:
    
    lt in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - lti
```
IComplexNDArray lti(Number other)
```
    Description copied from interface: INDArray
    
    In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    lti in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - eq
```
IComplexNDArray eq(Number other)
```
    Description copied from interface: INDArray
    
    Returns an ndarray with 1 if the element is less than the given element 0 other wise
    
    Specified by:
    
    eq in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - eqi
```
IComplexNDArray eqi(Number other)
```
    Description copied from interface: INDArray
    
    In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    eqi in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - gt
```
IComplexNDArray gt(Number other)
```
    Description copied from interface: INDArray
    
    Greater than boolean (copying)(
    
    Specified by:
    
    gt in interface INDArray
    
    Returns:
  - gti
```
IComplexNDArray gti(Number other)
```
    Description copied from interface: INDArray
    
    In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    gti in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - lt
```
IComplexNDArray lt(INDArray other)
```
    Description copied from interface: INDArray
    
    less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    lt in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    the result ndarray
  - lti
```
IComplexNDArray lti(INDArray other)
```
    Description copied from interface: INDArray
    
    In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    lti in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - eq
```
IComplexNDArray eq(INDArray other)
```
    Description copied from interface: INDArray
    
    equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    eq in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - eqi
```
IComplexNDArray eqi(INDArray other)
```
    Description copied from interface: INDArray
    
    In place equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    eqi in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - gt
```
IComplexNDArray gt(INDArray other)
```
    Description copied from interface: INDArray
    
    greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    gt in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - gti
```
IComplexNDArray gti(INDArray other)
```
    Description copied from interface: INDArray
    
    In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    gti in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - putScalar
```
INDArray putScalar(int[] i,
                   IComplexNumber complexNumber)
```
  - neg
```
IComplexNDArray neg()
```
    Description copied from interface: INDArray
    
    Returns the ndarray negative (cloned)
    
    Specified by:
    
    neg in interface INDArray
    
    Returns:
  - negi
```
IComplexNDArray negi()
```
    Description copied from interface: INDArray
    
    In place setting of the negative version of this ndarray
    
    Specified by:
    
    negi in interface INDArray
    
    Returns:
  - addi
```
IComplexNDArray addi(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    addi in interface INDArray
  - add
```
IComplexNDArray add(IComplexNumber n,
                    IComplexNDArray result)
```
    Specified by:
    
    add in interface INDArray
  - subi
```
IComplexNDArray subi(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    subi in interface INDArray
  - sub
```
IComplexNDArray sub(IComplexNumber n,
                    IComplexNDArray result)
```
    Specified by:
    
    sub in interface INDArray
  - muli
```
IComplexNDArray muli(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    muli in interface INDArray
  - mul
```
IComplexNDArray mul(IComplexNumber n,
                    IComplexNDArray result)
```
    Specified by:
    
    mul in interface INDArray
  - divi
```
IComplexNDArray divi(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    divi in interface INDArray
  - div
```
IComplexNDArray div(IComplexNumber n,
                    IComplexNDArray result)
```
    Specified by:
    
    div in interface INDArray
  - rsubi
```
IComplexNDArray rsubi(IComplexNumber n,
                      IComplexNDArray result)
```
    Specified by:
    
    rsubi in interface INDArray
  - rsub
```
IComplexNDArray rsub(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    rsub in interface INDArray
  - rdivi
```
IComplexNDArray rdivi(IComplexNumber n,
                      IComplexNDArray result)
```
    Specified by:
    
    rdivi in interface INDArray
  - rdiv
```
IComplexNDArray rdiv(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    rdiv in interface INDArray
  - rdiv
```
IComplexNDArray rdiv(IComplexNumber n,
                     INDArray result)
```
  - rdivi
```
IComplexNDArray rdivi(IComplexNumber n,
                      INDArray result)
```
  - rsub
```
IComplexNDArray rsub(IComplexNumber n,
                     INDArray result)
```
  - rsubi
```
IComplexNDArray rsubi(IComplexNumber n,
                      INDArray result)
```
  - rdiviColumnVector
```
IComplexNDArray rdiviColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place reverse divison of a column vector
    
    Specified by:
    
    rdiviColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - rdivColumnVector
```
IComplexNDArray rdivColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place reverse division of a column vector
    
    Specified by:
    
    rdivColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - rdiviRowVector
```
IComplexNDArray rdiviRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place addition of a column vector
    
    Specified by:
    
    rdiviRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - rdivRowVector
```
IComplexNDArray rdivRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place addition of a column vector
    
    Specified by:
    
    rdivRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - rsubiColumnVector
```
IComplexNDArray rsubiColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place addition of a column vector
    
    Specified by:
    
    rsubiColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - rsubColumnVector
```
IComplexNDArray rsubColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place addition of a column vector
    
    Specified by:
    
    rsubColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - rsubiRowVector
```
IComplexNDArray rsubiRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place addition of a column vector
    
    Specified by:
    
    rsubiRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - rsubRowVector
```
IComplexNDArray rsubRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place addition of a column vector
    
    Specified by:
    
    rsubRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - div
```
IComplexNDArray div(IComplexNumber n,
                    INDArray result)
```
  - divi
```
IComplexNDArray divi(IComplexNumber n,
                     INDArray result)
```
  - mul
```
IComplexNDArray mul(IComplexNumber n,
                    INDArray result)
```
  - muli
```
IComplexNDArray muli(IComplexNumber n,
                     INDArray result)
```
  - sub
```
IComplexNDArray sub(IComplexNumber n,
                    INDArray result)
```
  - subi
```
IComplexNDArray subi(IComplexNumber n,
                     INDArray result)
```
  - add
```
IComplexNDArray add(IComplexNumber n,
                    INDArray result)
```
  - addi
```
IComplexNDArray addi(IComplexNumber n,
                     INDArray result)
```
  - rdiv
```
IComplexNDArray rdiv(IComplexNumber n)
```
    Specified by:
    
    rdiv in interface INDArray
  - rdivi
```
IComplexNDArray rdivi(IComplexNumber n)
```
    Specified by:
    
    rdivi in interface INDArray
  - rsub
```
IComplexNDArray rsub(IComplexNumber n)
```
    Specified by:
    
    rsub in interface INDArray
  - rsubi
```
IComplexNDArray rsubi(IComplexNumber n)
```
    Specified by:
    
    rsubi in interface INDArray
  - div
```
IComplexNDArray div(IComplexNumber n)
```
    Specified by:
    
    div in interface INDArray
  - divi
```
IComplexNDArray divi(IComplexNumber n)
```
    Specified by:
    
    divi in interface INDArray
  - mul
```
IComplexNDArray mul(IComplexNumber n)
```
    Specified by:
    
    mul in interface INDArray
  - muli
```
IComplexNDArray muli(IComplexNumber n)
```
    Specified by:
    
    muli in interface INDArray
  - sub
```
IComplexNDArray sub(IComplexNumber n)
```
    Specified by:
    
    sub in interface INDArray
  - subi
```
IComplexNDArray subi(IComplexNumber n)
```
    Specified by:
    
    subi in interface INDArray
  - add
```
IComplexNDArray add(IComplexNumber n)
```
    Specified by:
    
    add in interface INDArray
  - addi
```
IComplexNDArray addi(IComplexNumber n)
```
    Specified by:
    
    addi in interface INDArray
  - rdiv
```
IComplexNDArray rdiv(Number n,
                     INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse division (number / ndarray)
    
    Specified by:
    
    rdiv in interface INDArray
    
    Parameters:
    
    n - the number to divide by
    
    Returns:
  - rdivi
```
IComplexNDArray rdivi(Number n,
                      INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse in place division
    
    Specified by:
    
    rdivi in interface INDArray
    
    Parameters:
    
    n - the number to divide by by
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - rsub
```
IComplexNDArray rsub(Number n,
                     INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse subtraction
    
    Specified by:
    
    rsub in interface INDArray
    
    Parameters:
    
    n - the number to subtract by
    
    result - the result ndarray
    
    Returns:
  - rsubi
```
IComplexNDArray rsubi(Number n,
                      INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse in place subtraction
    
    Specified by:
    
    rsubi in interface INDArray
    
    Parameters:
    
    n - the number to subtract by
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - div
```
IComplexNDArray div(Number n,
                    INDArray result)
```
    Specified by:
    
    div in interface INDArray
    
    Returns:
  - divi
```
IComplexNDArray divi(Number n,
                     INDArray result)
```
    Description copied from interface: INDArray
    
    In place division of this ndarray
    
    Specified by:
    
    divi in interface INDArray
    
    Parameters:
    
    n - the number to divide by
    
    result - the result ndarray
    
    Returns:
  - mul
```
IComplexNDArray mul(Number n,
                    INDArray result)
```
    Specified by:
    
    mul in interface INDArray
  - muli
```
IComplexNDArray muli(Number n,
                     INDArray result)
```
    Description copied from interface: INDArray
    
    In place multiplication of this ndarray
    
    Specified by:
    
    muli in interface INDArray
    
    Parameters:
    
    n - the number to divide by
    
    result - the result ndarray
    
    Returns:
  - sub
```
IComplexNDArray sub(Number n,
                    INDArray result)
```
    Specified by:
    
    sub in interface INDArray
  - subi
```
IComplexNDArray subi(Number n,
                     INDArray result)
```
    Description copied from interface: INDArray
    
    In place subtraction of this ndarray
    
    Specified by:
    
    subi in interface INDArray
    
    Parameters:
    
    n - the number to subtract by
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - add
```
IComplexNDArray add(Number n,
                    INDArray result)
```
    Specified by:
    
    add in interface INDArray
  - addi
```
IComplexNDArray addi(Number n,
                     INDArray result)
```
    Description copied from interface: INDArray
    
    In place addition
    
    Specified by:
    
    addi in interface INDArray
    
    Parameters:
    
    n - the number to add
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - rdiv
```
IComplexNDArray rdiv(Number n)
```
    Description copied from interface: INDArray
    
    Reverse division
    
    Specified by:
    
    rdiv in interface INDArray
    
    Returns:
  - rdivi
```
IComplexNDArray rdivi(Number n)
```
    Description copied from interface: INDArray
    
    In place reverse division
    
    Specified by:
    
    rdivi in interface INDArray
    
    Returns:
  - rsub
```
IComplexNDArray rsub(Number n)
```
    Description copied from interface: INDArray
    
    Reverse subtraction with duplicates
    
    Specified by:
    
    rsub in interface INDArray
    
    Returns:
  - rsubi
```
IComplexNDArray rsubi(Number n)
```
    Specified by:
    
    rsubi in interface INDArray
  - div
```
IComplexNDArray div(Number n)
```
    Description copied from interface: INDArray
    
    Division by a number
    
    Specified by:
    
    div in interface INDArray
    
    Returns:
  - divi
```
IComplexNDArray divi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar division
    
    Specified by:
    
    divi in interface INDArray
    
    Returns:
  - mul
```
IComplexNDArray mul(Number n)
```
    Description copied from interface: INDArray
    
    Scalar multiplication (copy)
    
    Specified by:
    
    mul in interface INDArray
    
    Parameters:
    
    n - the number to multiply by
    
    Returns:
    
    a copy of this ndarray multiplied by the given number
  - muli
```
IComplexNDArray muli(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar multiplication
    
    Specified by:
    
    muli in interface INDArray
    
    Returns:
  - sub
```
IComplexNDArray sub(Number n)
```
    Description copied from interface: INDArray
    
    Scalar subtraction (copied)
    
    Specified by:
    
    sub in interface INDArray
    
    Parameters:
    
    n - the number to subtract by
    
    Returns:
    
    this ndarray - the given number
  - subi
```
IComplexNDArray subi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar subtraction
    
    Specified by:
    
    subi in interface INDArray
    
    Returns:
  - add
```
IComplexNDArray add(Number n)
```
    Description copied from interface: INDArray
    
    Scalar addition (cloning)
    
    Specified by:
    
    add in interface INDArray
    
    Parameters:
    
    n - the number to add
    
    Returns:
    
    a clone with this matrix + the given number
  - addi
```
IComplexNDArray addi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar addition
    
    Specified by:
    
    addi in interface INDArray
    
    Returns:
  - get
```
IComplexNDArray get(NDArrayIndex... indexes)
```
    Returns a subset of this array based on the specified indexes
    
    Specified by:
    
    get in interface INDArray
    
    Parameters:
    
    indexes - the indexes in to the array
    
    Returns:
    
    a view of the array with the specified indices
  - getColumns
```
IComplexNDArray getColumns(int[] columns)
```
    Description copied from interface: INDArray
    
    Get a list of specified columns
    
    Specified by:
    
    getColumns in interface INDArray
    
    Returns:
  - getRows
```
IComplexNDArray getRows(int[] rows)
```
    Description copied from interface: INDArray
    
    Get a list of rows
    
    Specified by:
    
    getRows in interface INDArray
    
    Returns:
  - min
```
IComplexNDArray min(int dimension)
```
    Returns the overall min of this ndarray
    
    Specified by:
    
    min in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the mean along
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - max
```
IComplexNDArray max(int dimension)
```
    Returns the overall max of this ndarray
    
    Specified by:
    
    max in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the mean along
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - put
```
IComplexNDArray put(int i,
                    int j,
                    INDArray element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    
    i - the row insert into
    
    j - the column to insert into
    
    element - a scalar ndarray
    
    Returns:
    
    a scalar ndarray of the element at this index
  - put
```
IComplexNDArray put(int[] indices,
                    INDArray element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    
    indices - the indices to insert into
    
    element - a scalar ndarray
    
    Returns:
    
    a scalar ndarray of the element at this index
  - putSlice
```
IComplexNDArray putSlice(int slice,
                         INDArray put)
```
    Assigns the given matrix (put) to the specified slice
    
    Specified by:
    
    putSlice in interface INDArray
    
    Parameters:
    
    slice - the slice to assign
    
    put - the slice to applyTransformToDestination
    
    Returns:
    
    this for chainability
  - getImag
```
double getImag(int i)
```
    Get the imaginary component at the specified index
    
    Parameters:
    
    i -
    
    Returns:
  - getReal
```
double getReal(int i)
```
    Get the real component at the specified index
    
    Parameters:
    
    i -
    
    Returns:
  - putReal
```
IComplexNDArray putReal(int[] indices,
                        float value)
```
  - putImag
```
IComplexNDArray putImag(int[] indices,
                        float value)
```
  - putReal
```
IComplexNDArray putReal(int[] indices,
                        double value)
```
  - putImag
```
IComplexNDArray putImag(int[] indices,
                        double value)
```
  - putReal
```
IComplexNDArray putReal(int rowIndex,
                        int columnIndex,
                        float value)
```
  - putImag
```
IComplexNDArray putImag(int rowIndex,
                        int columnIndex,
                        float value)
```
  - putReal
```
IComplexNDArray putReal(int rowIndex,
                        int columnIndex,
                        double value)
```
  - putImag
```
IComplexNDArray putImag(int rowIndex,
                        int columnIndex,
                        double value)
```
  - putReal
```
IComplexNDArray putReal(int i,
                        float v)
```
  - putImag
```
IComplexNDArray putImag(int i,
                        float v)
```
  - real
```
INDArray real()
```
  - imag
```
INDArray imag()
```
  - put
```
IComplexNDArray put(int i,
                    IComplexNDArray element)
```
    Put a scalar ndarray at the specified index
    
    Parameters:
    
    i -
    
    element -
    
    Returns:
  - getScalar
```
IComplexNDArray getScalar(int... indexes)
```
    Fetch a particular number on a multi dimensional scale.
    
    Specified by:
    
    getScalar in interface INDArray
    
    Parameters:
    
    indexes - the indexes to getFromOrigin a number from
    
    Returns:
    
    the number at the specified indices
  - checkDimensions
```
void checkDimensions(INDArray other)
```
    Validate dimensions are equal
    
    Specified by:
    
    checkDimensions in interface INDArray
    
    Parameters:
    
    other - the other ndarray to compare
  - endsForSlices
```
int[] endsForSlices()
```
    Gives the indices for the ending of each slice
    
    Specified by:
    
    endsForSlices in interface INDArray
    
    Returns:
    
    the off sets for the beginning of each slice
  - assign
```
IComplexNDArray assign(Number value)
```
    Set the value of the ndarray to the specified value
    
    Specified by:
    
    assign in interface INDArray
    
    Parameters:
    
    value - the value to assign
    
    Returns:
    
    the ndarray with the values
  - rdiv
```
IComplexNDArray rdiv(INDArray other)
```
    Reverse division
    
    Specified by:
    
    rdiv in interface INDArray
    
    Parameters:
    
    other - the matrix to divide from
    
    Returns:
  - rdivi
```
IComplexNDArray rdivi(INDArray other)
```
    Reverse divsion (in place)
    
    Specified by:
    
    rdivi in interface INDArray
    
    Parameters:
    
    other -
    
    Returns:
  - rdiv
```
IComplexNDArray rdiv(INDArray other,
                     INDArray result)
```
    Reverse division
    
    Specified by:
    
    rdiv in interface INDArray
    
    Parameters:
    
    other - the matrix to subtract from
    
    result - the result ndarray
    
    Returns:
  - rdivi
```
IComplexNDArray rdivi(INDArray other,
                      INDArray result)
```
    Reverse division (in-place)
    
    Specified by:
    
    rdivi in interface INDArray
    
    Parameters:
    
    other - the other ndarray to subtract
    
    result - the result ndarray
    
    Returns:
    
    the ndarray with the operation applied
  - rsub
```
IComplexNDArray rsub(INDArray other,
                     INDArray result)
```
    Reverse subtraction
    
    Specified by:
    
    rsub in interface INDArray
    
    Parameters:
    
    other - the matrix to subtract from
    
    result - the result ndarray
    
    Returns:
  - rsub
```
IComplexNDArray rsub(INDArray other)
```
    Specified by:
    
    rsub in interface INDArray
    
    Parameters:
    
    other -
    
    Returns:
  - rsubi
```
IComplexNDArray rsubi(INDArray other)
```
    Specified by:
    
    rsubi in interface INDArray
    
    Parameters:
    
    other -
    
    Returns:
  - rsubi
```
IComplexNDArray rsubi(INDArray other,
                      INDArray result)
```
    Reverse subtraction (in-place)
    
    Specified by:
    
    rsubi in interface INDArray
    
    Parameters:
    
    other - the other ndarray to subtract
    
    result - the result ndarray
    
    Returns:
    
    the ndarray with the operation applied
  - hermitian
```
IComplexNDArray hermitian()
```
    a Hermitian matrix is a square matrix with complex entries that is equal to its own conjugate transpose
    
    Returns:
    
    the hermitian of this ndarray
  - conj
```
IComplexNDArray conj()
```
    Compute complex conj.
  - conji
```
IComplexNDArray conji()
```
    Compute complex conj (in-place).
  - getReal
```
INDArray getReal()
```
    Gets the real portion of this complex ndarray
    
    Returns:
    
    the real portion of this complex ndarray
  - repmat
```
IComplexNDArray repmat(int[] shape)
```
    Replicate and tile array to fill out to the given shape
    
    Specified by:
    
    repmat in interface INDArray
    
    Parameters:
    
    shape - the new shape of this ndarray
    
    Returns:
    
    the shape to fill out to
  - putRow
```
IComplexNDArray putRow(int row,
                       INDArray toPut)
```
    Insert a row in to this array Will throw an exception if this ndarray is not a matrix
    
    Specified by:
    
    putRow in interface INDArray
    
    Parameters:
    
    row - the row insert into
    
    toPut - the row to insert
    
    Returns:
    
    this
  - putColumn
```
IComplexNDArray putColumn(int column,
                          INDArray toPut)
```
    Insert a column in to this array Will throw an exception if this ndarray is not a matrix
    
    Specified by:
    
    putColumn in interface INDArray
    
    Parameters:
    
    column - the column to insert
    
    toPut - the array to put
    
    Returns:
    
    this
  - getScalar
```
IComplexNDArray getScalar(int row,
                          int column)
```
    Returns the element at the specified row/column This will throw an exception if the
    
    Specified by:
    
    getScalar in interface INDArray
    
    Parameters:
    
    row - the row of the element to return
    
    column - the row of the element to return
    
    Returns:
    
    a scalar indarray of the element at this index
  - getScalar
```
IComplexNDArray getScalar(int i)
```
    Returns the element at the specified index
    
    Specified by:
    
    getScalar in interface INDArray
    
    Parameters:
    
    i - the index of the element to return
    
    Returns:
    
    a scalar ndarray of the element at this index
  - put
```
IComplexNDArray put(int i,
                    INDArray element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    
    i - the index insert into
    
    element - a scalar ndarray
    
    Returns:
    
    a scalar ndarray of the element at this index
  - diviColumnVector
```
IComplexNDArray diviColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    diviColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - divColumnVector
```
IComplexNDArray divColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    divColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - diviRowVector
```
IComplexNDArray diviRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    diviRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - divRowVector
```
IComplexNDArray divRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    divRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - muliColumnVector
```
IComplexNDArray muliColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    muliColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - mulColumnVector
```
IComplexNDArray mulColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    mulColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - muliRowVector
```
IComplexNDArray muliRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    muliRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - mulRowVector
```
IComplexNDArray mulRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    mulRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - subiColumnVector
```
IComplexNDArray subiColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subiColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - subColumnVector
```
IComplexNDArray subColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - subiRowVector
```
IComplexNDArray subiRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subiRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - subRowVector
```
IComplexNDArray subRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - addiColumnVector
```
IComplexNDArray addiColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addiColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - addColumnVector
```
IComplexNDArray addColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - addiRowVector
```
IComplexNDArray addiRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addiRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - addRowVector
```
IComplexNDArray addRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - mmul
```
IComplexNDArray mmul(INDArray other)
```
    Perform a copy matrix multiplication
    
    Specified by:
    
    mmul in interface INDArray
    
    Parameters:
    
    other - the other matrix to perform matrix multiply with
    
    Returns:
    
    the result of the matrix multiplication
  - mmul
```
IComplexNDArray mmul(INDArray other,
                     INDArray result)
```
    Perform an copy matrix multiplication
    
    Specified by:
    
    mmul in interface INDArray
    
    Parameters:
    
    other - the other matrix to perform matrix multiply with
    
    result - the result ndarray
    
    Returns:
    
    the result of the matrix multiplication
  - div
```
IComplexNDArray div(INDArray other)
```
    in place (element wise) division of two matrices
    
    Specified by:
    
    div in interface INDArray
    
    Parameters:
    
    other - the second ndarray to divide
    
    Returns:
    
    the result of the divide
  - div
```
IComplexNDArray div(INDArray other,
                    INDArray result)
```
    copy (element wise) division of two matrices
    
    Specified by:
    
    div in interface INDArray
    
    Parameters:
    
    other - the second ndarray to divide
    
    result - the result ndarray
    
    Returns:
    
    the result of the divide
  - mul
```
IComplexNDArray mul(INDArray other)
```
    copy (element wise) multiplication of two matrices
    
    Specified by:
    
    mul in interface INDArray
    
    Parameters:
    
    other - the second ndarray to multiply
    
    Returns:
    
    the result of the addition
  - mul
```
IComplexNDArray mul(INDArray other,
                    INDArray result)
```
    copy (element wise) multiplication of two matrices
    
    Specified by:
    
    mul in interface INDArray
    
    Parameters:
    
    other - the second ndarray to multiply
    
    result - the result ndarray
    
    Returns:
    
    the result of the multiplication
  - sub
```
IComplexNDArray sub(INDArray other)
```
    copy subtraction of two matrices
    
    Specified by:
    
    sub in interface INDArray
    
    Parameters:
    
    other - the second ndarray to subtract
    
    Returns:
    
    the result of the addition
  - sub
```
IComplexNDArray sub(INDArray other,
                    INDArray result)
```
    copy subtraction of two matrices
    
    Specified by:
    
    sub in interface INDArray
    
    Parameters:
    
    other - the second ndarray to subtract
    
    result - the result ndarray
    
    Returns:
    
    the result of the subtraction
  - add
```
IComplexNDArray add(INDArray other)
```
    copy addition of two matrices
    
    Specified by:
    
    add in interface INDArray
    
    Parameters:
    
    other - the second ndarray to add
    
    Returns:
    
    the result of the addition
  - add
```
IComplexNDArray add(INDArray other,
                    INDArray result)
```
    copy addition of two matrices
    
    Specified by:
    
    add in interface INDArray
    
    Parameters:
    
    other - the second ndarray to add
    
    result - the result ndarray
    
    Returns:
    
    the result of the addition
  - dimShuffle
```
IComplexNDArray dimShuffle(Object[] rearrange,
                           int[] newOrder,
                           boolean[] broadCastable)
```
    Dimshuffle: an extension of permute that adds the ability to broadcast various dimensions. This will only accept integers and xs.
    An x indicates a dimension should be broadcasted rather than permuted.
    
    Specified by:
    
    dimShuffle in interface INDArray
    
    Parameters:
    
    rearrange - the dimensions to swap to
    
    newOrder - the new order (think permute)
    
    broadCastable - (whether the dimension is broadcastable) (must be same length as new order)
    
    Returns:
    
    the newly permuted array
  - mmuli
```
IComplexNDArray mmuli(INDArray other)
```
    Perform an copy matrix multiplication
    
    Specified by:
    
    mmuli in interface INDArray
    
    Parameters:
    
    other - the other matrix to perform matrix multiply with
    
    Returns:
    
    the result of the matrix multiplication
  - mmuli
```
IComplexNDArray mmuli(INDArray other,
                      INDArray result)
```
    Perform an copy matrix multiplication
    
    Specified by:
    
    mmuli in interface INDArray
    
    Parameters:
    
    other - the other matrix to perform matrix multiply with
    
    result - the result ndarray
    
    Returns:
    
    the result of the matrix multiplication
  - divi
```
IComplexNDArray divi(INDArray other)
```
    in place (element wise) division of two matrices
    
    Specified by:
    
    divi in interface INDArray
    
    Parameters:
    
    other - the second ndarray to divide
    
    Returns:
    
    the result of the divide
  - divi
```
IComplexNDArray divi(INDArray other,
                     INDArray result)
```
    in place (element wise) division of two matrices
    
    Specified by:
    
    divi in interface INDArray
    
    Parameters:
    
    other - the second ndarray to divide
    
    result - the result ndarray
    
    Returns:
    
    the result of the divide
  - muli
```
IComplexNDArray muli(INDArray other)
```
    in place (element wise) multiplication of two matrices
    
    Specified by:
    
    muli in interface INDArray
    
    Parameters:
    
    other - the second ndarray to multiply
    
    Returns:
    
    the result of the addition
  - muli
```
IComplexNDArray muli(INDArray other,
                     INDArray result)
```
    in place (element wise) multiplication of two matrices
    
    Specified by:
    
    muli in interface INDArray
    
    Parameters:
    
    other - the second ndarray to multiply
    
    result - the result ndarray
    
    Returns:
    
    the result of the multiplication
  - subi
```
IComplexNDArray subi(INDArray other)
```
    in place subtraction of two matrices
    
    Specified by:
    
    subi in interface INDArray
    
    Parameters:
    
    other - the second ndarray to subtract
    
    Returns:
    
    the result of the addition
  - subi
```
IComplexNDArray subi(INDArray other,
                     INDArray result)
```
    in place subtraction of two matrices
    
    Specified by:
    
    subi in interface INDArray
    
    Parameters:
    
    other - the second ndarray to subtract
    
    result - the result ndarray
    
    Returns:
    
    the result of the subtraction
  - addi
```
IComplexNDArray addi(INDArray other)
```
    in place addition of two matrices
    
    Specified by:
    
    addi in interface INDArray
    
    Parameters:
    
    other - the second ndarray to add
    
    Returns:
    
    the result of the addition
  - addi
```
IComplexNDArray addi(INDArray other,
                     INDArray result)
```
    in place addition of two matrices
    
    Specified by:
    
    addi in interface INDArray
    
    Parameters:
    
    other - the second ndarray to add
    
    result - the result ndarray
    
    Returns:
    
    the result of the addition
  - normmax
```
IComplexNDArray normmax(int dimension)
```
    Returns the normmax along the specified dimension
    
    Specified by:
    
    normmax in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the norm1 along
    
    Returns:
    
    the norm1 along the specified dimension
  - norm2
```
IComplexNDArray norm2(int dimension)
```
    Returns the norm2 along the specified dimension
    
    Specified by:
    
    norm2 in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the norm2 along
    
    Returns:
    
    the norm2 along the specified dimension
  - norm1
```
IComplexNDArray norm1(int dimension)
```
    Returns the norm1 along the specified dimension
    
    Specified by:
    
    norm1 in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the norm1 along
    
    Returns:
    
    the norm1 along the specified dimension
  - prod
```
IComplexNDArray prod(int dimension)
```
    Returns the product along a given dimension
    
    Specified by:
    
    prod in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the product along
    
    Returns:
    
    the product along the specified dimension
  - mean
```
IComplexNDArray mean(int dimension)
```
    Returns the overall mean of this ndarray
    
    Specified by:
    
    mean in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the mean along
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - sum
```
IComplexNDArray sum(int dimension)
```
    Returns the sum along the last dimension of this ndarray
    
    Specified by:
    
    sum in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the sum along
    
    Returns:
    
    the sum along the specified dimension of this ndarray
  - var
```
IComplexNDArray var(int dimension)
```
    Description copied from interface: INDArray
    
    Returns the overall variance of this ndarray
    
    Specified by:
    
    var in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the mean along
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - std
```
IComplexNDArray std(int dimension)
```
    Description copied from interface: INDArray
    
    Standard deviation of an ndarray along a dimension
    
    Specified by:
    
    std in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the std along
    
    Returns:
    
    the standard deviation along a particular dimension
  - getComplex
```
IComplexNumber getComplex(int i)
```
  - getComplex
```
IComplexNumber getComplex(int i,
                          int j)
```
  - getComplex
```
IComplexNumber getComplex(int i,
                          IComplexNumber result)
```
  - getComplex
```
IComplexNumber getComplex(int i,
                          int j,
                          IComplexNumber result)
```
  - dup
```
IComplexNDArray dup()
```
    Return a copy of this ndarray
    
    Specified by:
    
    dup in interface INDArray
    
    Returns:
    
    a copy of this ndarray
  - ravel
```
IComplexNDArray ravel()
```
    Returns a flattened version (row vector) of this ndarray
    
    Specified by:
    
    ravel in interface INDArray
    
    Returns:
    
    a flattened version (row vector) of this ndarray
  - slice
```
IComplexNDArray slice(int i,
                      int dimension)
```
    Returns the specified slice of this ndarray
    
    Specified by:
    
    slice in interface INDArray
    
    Parameters:
    
    i - the index of the slice to return
    
    dimension - the dimension to return the slice for
    
    Returns:
    
    the specified slice of this ndarray
  - slice
```
IComplexNDArray slice(int i)
```
    Returns the specified slice of this ndarray
    
    Specified by:
    
    slice in interface INDArray
    
    Parameters:
    
    i - the index of the slice to return
    
    Returns:
    
    the specified slice of this ndarray
  - reshape
```
IComplexNDArray reshape(int... newShape)
```
    Reshapes the ndarray (can't change the length of the ndarray)
    
    Specified by:
    
    reshape in interface INDArray
    
    Parameters:
    
    newShape - the new shape of the ndarray
    
    Returns:
    
    the reshaped ndarray
  - transpose
```
IComplexNDArray transpose()
```
    Flip the rows and columns of a matrix
    
    Specified by:
    
    transpose in interface INDArray
    
    Returns:
    
    the flipped rows and columns of a matrix
  - transposei
```
IComplexNDArray transposei()
```
    Description copied from interface: INDArray
    
    Flip the rows and columns of a matrix
    
    Specified by:
    
    transposei in interface INDArray
    
    Returns:
    
    the flipped rows and columns of a matrix
  - put
```
IComplexNDArray put(int[] indexes,
                    float value)
```
  - put
```
IComplexNDArray put(int[] indexes,
                    double value)
```
  - putSlice
```
IComplexNDArray putSlice(int slice,
                         IComplexNDArray put)
```
  - getComplex
```
IComplexNumber getComplex(int... indices)
```
    Get the complex number at the given indices
    
    Parameters:
    
    indices - the indices to get the complex number at
    
    Returns:
    
    the complex number at the given indices
  - swapAxes
```
IComplexNDArray swapAxes(int dimension,
                         int with)
```
    Mainly here for people coming from numpy. This is equivalent to a call to permute
    
    Specified by:
    
    swapAxes in interface INDArray
    
    Parameters:
    
    dimension - the dimension to swap
    
    with - the one to swap it with
    
    Returns:
    
    the swapped axes view
  - permute
```
IComplexNDArray permute(int[] rearrange)
```
    See: http://www.mathworks.com/help/matlab/ref/permute.html
    
    Specified by:
    
    permute in interface INDArray
    
    Parameters:
    
    rearrange - the dimensions to swap to
    
    Returns:
    
    the newly permuted array
  - toArray
```
IComplexNumber[] toArray()
```
  - getColumn
```
IComplexNDArray getColumn(int i)
```
    Returns the specified column. Throws an exception if its not a matrix
    
    Specified by:
    
    getColumn in interface INDArray
    
    Parameters:
    
    i - the column to getScalar
    
    Returns:
    
    the specified column
  - getRow
```
IComplexNDArray getRow(int i)
```
    Returns the specified row. Throws an exception if its not a matrix
    
    Specified by:
    
    getRow in interface INDArray
    
    Parameters:
    
    i - the row to getScalar
    
    Returns:
    
    the specified row
  - broadcast
```
IComplexNDArray broadcast(int[] shape)
```
    Broadcasts this ndarray to be the specified shape
    
    Specified by:
    
    broadcast in interface INDArray
    
    Parameters:
    
    shape - the new shape of this ndarray
    
    Returns:
    
    the broadcasted ndarray
  - putScalar
```
IComplexNDArray putScalar(int j,
                          int i,
                          IComplexNumber conji)
```
  - neqi
```
IComplexNDArray neqi(IComplexNumber other)
```
  - neq
```
IComplexNDArray neq(IComplexNumber other)
```
  - lt
```
IComplexNDArray lt(IComplexNumber other)
```
  - lti
```
IComplexNDArray lti(IComplexNumber other)
```
  - eq
```
IComplexNDArray eq(IComplexNumber other)
```
  - eqi
```
IComplexNDArray eqi(IComplexNumber other)
```
  - gt
```
IComplexNDArray gt(IComplexNumber other)
```
  - gti
```
IComplexNDArray gti(IComplexNumber other)
```
  - assign
```
void assign(IComplexNumber aDouble)
```
  - put
```
IComplexNDArray put(int i,
                    int j,
                    IComplexNumber complex)
```

Interface IComplexNDArray

Method Summary

Methods inherited from interface org.nd4j.linalg.api.ndarray.INDArray

Method Detail

blasOffset

linearViewColumnOrder

linearView

reshape

cumsumi

cumsum

vectorAlongDimension

cond

condi

neq

neqi

neqi

neq

assign

put

put

put

putScalar

putScalar

eps

epsi

eps

epsi

eps

epsi

lt

lti

eq

eqi

gt

gti

lt

lti

eq

eqi

gt

gti

putScalar

neg

negi

addi

add

subi

sub

muli

mul

divi

div

rsubi

rsub

rdivi

rdiv

rdiv

rdivi

rsub

rsubi

rdiviColumnVector

rdivColumnVector

rdiviRowVector

rdivRowVector

rsubiColumnVector

rsubColumnVector

rsubiRowVector

rsubRowVector

div

divi

mul

muli

sub

subi

add

addi

rdiv

rdivi

rsub

rsubi