IComplexNDArray (nd4j-api 1.0.0-beta 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
`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)` Returns the binary ndarray for "Equals" comparison.
`IComplexNDArray`	`eq(Number other)` Returns the binary ndarray for "Equals" comparison.
`IComplexNDArray`	`eqi(IComplexNumber other)`
`IComplexNDArray`	`eqi(INDArray other)` Returns the binary ndarray for "Equals" comparison.
`IComplexNDArray`	`eqi(Number other)` Returns the binary ndarray for "Equals" comparison.
`IComplexNDArray`	`get(INDArrayIndex... 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 an INDArray comprised of the specified columns only.
`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 an INDArray comprised of the specified rows only.
`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)` Returns the binary ndarray for "Greter" comparison.
`IComplexNDArray`	`gt(Number other)` Returns the binary ndarray for "Greater" comparison.
`IComplexNDArray`	`gti(IComplexNumber other)`
`IComplexNDArray`	`gti(INDArray other)` Returns the binary ndarray for "Greter" comparison.
`IComplexNDArray`	`gti(Number other)` Returns the binary ndarray for "Greter" comparison.
`IComplexNDArray`	`hermitian()` a Hermitian matrix is a square matrix with complex entries that is equal to its own conjugate transpose
`INDArray`	`imag()` Return all of the imaginary components in this ndarray
`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)` Returns the binary ndarray for "Less" comparison.
`IComplexNDArray`	`lt(Number other)` Returns the binary ndarray for "Less" comparison.
`IComplexNDArray`	`lti(IComplexNumber other)`
`IComplexNDArray`	`lti(INDArray other)` Returns the binary ndarray for "Less" comparison.
`IComplexNDArray`	`lti(Number other)` Returns the binary ndarray for "Less" comparison.
`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)` Returns the binary ndarray for "Not equals" comparison.
`IComplexNDArray`	`neq(Number other)` Returns the binary ndarray for "Not equals" comparison.
`IComplexNDArray`	`neqi(IComplexNumber other)`
`IComplexNDArray`	`neqi(INDArray other)` Returns the binary ndarray for "Not equals" comparison.
`IComplexNDArray`	`neqi(Number other)` Returns the binary ndarray for "Not equals" comparison.
`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(INDArrayIndex[] indices, IComplexNDArray element)`
`IComplexNDArray`	`put(INDArrayIndex[] indices, IComplexNumber element)`
`IComplexNDArray`	`put(INDArrayIndex[] indices, Number element)` Put the elements of the ndarray in to the specified indices
`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`	`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 with a scalar - i.e., (n / thisArrayValues)
`IComplexNDArray`	`rdiv(Number n, INDArray result)` Reverse division (number / ndarray)
`IComplexNDArray`	`rdivColumnVector(INDArray columnVector)` Reverse division of a column vector (copy)
`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 - i.e., (n / thisArrayValues)
`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 reverse division of a column vector
`IComplexNDArray`	`rdivRowVector(INDArray rowVector)` Reverse division of a column vector (copy)
`INDArray`	`real()` Return all the real components in this ndarray
`IComplexNDArray`	`repmat(int... shape)` Replicate and tile array to fill out to the given shape
`IComplexNDArray`	`reshape(char order, int... newShape)` Reshapes the ndarray (can't change the length of the ndarray).
`IComplexNDArray`	`reshape(char order, int rows, int columns)` Reshapes the ndarray (can't change the length of the ndarray).
`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)` Element-wise reverse subtraction (copy op).
`IComplexNDArray`	`rsub(INDArray other, INDArray result)` Reverse subtraction
`IComplexNDArray`	`rsub(Number n)` Reverse subtraction with duplicates - i.e., (n - thisArrayValues)
`IComplexNDArray`	`rsub(Number n, INDArray result)` Reverse subtraction
`IComplexNDArray`	`rsubColumnVector(INDArray columnVector)` Reverse subtraction of a column vector (copy)
`IComplexNDArray`	`rsubi(IComplexNumber n)`
`IComplexNDArray`	`rsubi(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`rsubi(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`rsubi(INDArray other)` Element-wise reverse subtraction (in the place op) - i.e., other - this
`IComplexNDArray`	`rsubi(INDArray other, INDArray result)` Reverse subtraction (in-place)
`IComplexNDArray`	`rsubi(Number n)` Reverse subtraction in place - i.e., (n - thisArrayValues)
`IComplexNDArray`	`rsubi(Number n, INDArray result)` Reverse in place subtraction
`IComplexNDArray`	`rsubiColumnVector(INDArray columnVector)` In place reverse subtraction of a column vector
`IComplexNDArray`	`rsubiRowVector(INDArray rowVector)` In place reverse subtraction of a row vector
`IComplexNDArray`	`rsubRowVector(INDArray rowVector)` Reverse subtraction of a row vector (copy)
`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 INDArray along one or more dimensions
`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.
`IComplexNDArray`	`transpose()` Flip the rows and columns of a matrix
`IComplexNDArray`	`transposei()` Flip the rows and columns of a matrix, in-place
`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
amax, amaxNumber, amean, ameanNumber, amin, aminNumber, argMax, assign, assignIf, broadcast, cleanup, columns, convertToDoubles, convertToFloats, data, detach, distance1, distance2, dup, element, elementStride, elementWiseStride, entropy, entropyNumber, equalsWithEps, flags, fmod, fmod, fmod, fmod, fmodi, fmodi, get, get, getDouble, getDouble, getDouble, getDoubleUnsafe, getFloat, getFloat, getFloat, getFormat, getInt, getLeadingOnes, getTrailingOnes, getVectorCoordinates, getWhere, getWhere, gte, gtei, hiddenDimensions, index, innerMostStride, isAttached, isCleanedUp, isColumnVector, isColumnVectorOrScalar, isCompressed, isInScope, isMatrix, isRowVector, isRowVectorOrScalar, isScalar, isSparse, isSquare, isVector, isVectorOrScalar, isView, isWrapAround, javaTensorAlongDimension, length, lengthLong, leverage, leverageOrDetach, leverageTo, leverageTo, linearIndex, logEntropy, logEntropyNumber, lte, ltei, majorStride, markAsCompressed, match, match, maxComplex, maxNumber, mean, meanComplex, meanNumber, median, medianNumber, migrate, migrate, minComplex, minNumber, mmul, mmul, mmuli, mmuli, nnz, norm1Complex, norm1Number, norm2Complex, norm2Number, normmaxComplex, normmaxNumber, offset, ordering, originalOffset, percentile, percentileNumber, permutei, prodComplex, prodNumber, put, put, put, put, putiColumnVector, putiRowVector, putScalar, putScalar, putScalar, putScalar, putScalar, putScalar, putScalar, putScalar, putScalarUnsafe, putWhere, putWhere, putWhere, putWhereWithMask, putWhereWithMask, rank, ravel, remainder, remainder, remainder, remainder, remainderi, remainderi, repeat, replaceWhere, resetLinearView, rows, scan, secondaryStride, setData, setOrder, setShape, setShapeAndStride, setStride, setWrapAround, shannonEntropy, shannonEntropyNumber, shape, shapeInfo, shapeInfoDataBuffer, shapeInfoToString, size, slices, sliceVectors, sparseInfoDataBuffer, sparseOffsets, squaredDistance, std, stdComplex, stdNumber, stdNumber, stride, stride, subArray, subArray, sum, sumComplex, sumNumber, tensorAlongDimension, tensorssAlongDimension, toDense, toDoubleMatrix, toDoubleVector, toFlatArray, toFloatMatrix, toFloatVector, toIntMatrix, toIntVector, underlyingRank, unsafeDuplication, unsafeDuplication, var, varComplex, varNumber, 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)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Not equals" comparison.
    
    Specified by:
    
    neq in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    the binary ndarray for "Not equals" comparison.
  - neqi
```
IComplexNDArray neqi(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Not equals" comparison. In-place method.
    
    Specified by:
    
    neqi in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    this object.
  - neqi
```
IComplexNDArray neqi(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Not equals" comparison. In-place method.
    
    Specified by:
    
    neqi in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    this object.
  - neq
```
IComplexNDArray neq(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Not equals" comparison.
    
    Specified by:
    
    neq in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    the binary ndarray for "Not equals" comparison.
  - 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(INDArrayIndex[] indices,
                    IComplexNumber element)
```
    Parameters:
    
    indices -
    
    element -
    
    Returns:
  - put
```
IComplexNDArray put(INDArrayIndex[] indices,
                    IComplexNDArray element)
```
    Parameters:
    
    indices -
    
    element -
    
    Returns:
  - put
```
IComplexNDArray put(INDArrayIndex[] 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:
  - putScalar
```
IComplexNDArray putScalar(int i,
                          IComplexNumber value)
```
    Parameters:
    
    i -
    
    value -
    
    Returns:
  - 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:
  - 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 the binary ndarray for "Less" comparison.
    
    Specified by:
    
    lt in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    the binary ndarray for "Less" comparison.
  - lti
```
IComplexNDArray lti(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Less" comparison. In-place method.
    
    Specified by:
    
    lti in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    this object.
  - eq
```
IComplexNDArray eq(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Equals" comparison.
    
    Specified by:
    
    eq in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    the binary ndarray for "Equals" comparison.
  - eqi
```
IComplexNDArray eqi(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Equals" comparison. In-place method.
    
    Specified by:
    
    eqi in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    this object.
  - gt
```
IComplexNDArray gt(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Greater" comparison.
    
    Specified by:
    
    gt in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    the binary ndarray for "Greater" comparison.
  - gti
```
IComplexNDArray gti(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Greter" comparison. In-place method.
    
    Specified by:
    
    gti in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    this object.
  - lt
```
IComplexNDArray lt(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Less" comparison.
    
    Specified by:
    
    lt in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    the binary ndarray for "Less" comparison.
  - lti
```
IComplexNDArray lti(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Less" comparison. In-place method.
    
    Specified by:
    
    lti in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    this object.
  - eq
```
IComplexNDArray eq(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Equals" comparison.
    
    Specified by:
    
    eq in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    the binary ndarray for "Equals" comparison.
  - eqi
```
IComplexNDArray eqi(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Equals" comparison. In-place method.
    
    Specified by:
    
    eqi in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    this object.
  - gt
```
IComplexNDArray gt(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Greter" comparison.
    
    Specified by:
    
    gt in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    the binary ndarray for "Greter" comparison.
  - gti
```
IComplexNDArray gti(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Greter" comparison. In-place method.
    
    Specified by:
    
    gti in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    this object.
  - 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:
    
    Array copy with all values negated
  - 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:
    
    This array with all values negated
  - addi
```
IComplexNDArray addi(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    addi in interface INDArray
    
    Returns:
  - add
```
IComplexNDArray add(IComplexNumber n,
                    IComplexNDArray result)
```
    Specified by:
    
    add in interface INDArray
    
    Returns:
  - subi
```
IComplexNDArray subi(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    subi in interface INDArray
    
    Returns:
  - sub
```
IComplexNDArray sub(IComplexNumber n,
                    IComplexNDArray result)
```
    Specified by:
    
    sub in interface INDArray
    
    Returns:
  - muli
```
IComplexNDArray muli(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    muli in interface INDArray
    
    Returns:
  - mul
```
IComplexNDArray mul(IComplexNumber n,
                    IComplexNDArray result)
```
    Specified by:
    
    mul in interface INDArray
    
    Returns:
  - divi
```
IComplexNDArray divi(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    divi in interface INDArray
    
    Returns:
  - div
```
IComplexNDArray div(IComplexNumber n,
                    IComplexNDArray result)
```
    Specified by:
    
    div in interface INDArray
    
    Returns:
  - rsubi
```
IComplexNDArray rsubi(IComplexNumber n,
                      IComplexNDArray result)
```
    Specified by:
    
    rsubi in interface INDArray
    
    Returns:
  - rsub
```
IComplexNDArray rsub(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    rsub in interface INDArray
    
    Returns:
  - rdivi
```
IComplexNDArray rdivi(IComplexNumber n,
                      IComplexNDArray result)
```
    Specified by:
    
    rdivi in interface INDArray
    
    Returns:
  - rdiv
```
IComplexNDArray rdiv(IComplexNumber n,
                     IComplexNDArray result)
```
    Specified by:
    
    rdiv in interface INDArray
    
    Returns:
  - rdiv
```
IComplexNDArray rdiv(IComplexNumber n,
                     INDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - 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 used for division
    
    Returns:
    
    the result of the division
  - rdivColumnVector
```
IComplexNDArray rdivColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    Reverse division of a column vector (copy)
    
    Specified by:
    
    rdivColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector used for division
    
    Returns:
    
    the result of the division
  - rdiviRowVector
```
IComplexNDArray rdiviRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place reverse division of a column vector
    
    Specified by:
    
    rdiviRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - rdivRowVector
```
IComplexNDArray rdivRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    Reverse division of a column vector (copy)
    
    Specified by:
    
    rdivRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - rsubiColumnVector
```
IComplexNDArray rsubiColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place reverse subtraction of a column vector
    
    Specified by:
    
    rsubiColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubColumnVector
```
IComplexNDArray rsubColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    Reverse subtraction of a column vector (copy)
    
    Specified by:
    
    rsubColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubiRowVector
```
IComplexNDArray rsubiRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place reverse subtraction of a row vector
    
    Specified by:
    
    rsubiRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubRowVector
```
IComplexNDArray rsubRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    Reverse subtraction of a row vector (copy)
    
    Specified by:
    
    rsubRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - 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
    
    Returns:
  - rdivi
```
IComplexNDArray rdivi(IComplexNumber n)
```
    Specified by:
    
    rdivi in interface INDArray
    
    Returns:
  - rsub
```
IComplexNDArray rsub(IComplexNumber n)
```
    Specified by:
    
    rsub in interface INDArray
    
    Returns:
  - rsubi
```
IComplexNDArray rsubi(IComplexNumber n)
```
    Specified by:
    
    rsubi in interface INDArray
    
    Returns:
  - div
```
IComplexNDArray div(IComplexNumber n)
```
    Specified by:
    
    div in interface INDArray
    
    Returns:
  - divi
```
IComplexNDArray divi(IComplexNumber n)
```
    Specified by:
    
    divi in interface INDArray
    
    Returns:
  - mul
```
IComplexNDArray mul(IComplexNumber n)
```
    Specified by:
    
    mul in interface INDArray
    
    Returns:
  - muli
```
IComplexNDArray muli(IComplexNumber n)
```
    Specified by:
    
    muli in interface INDArray
    
    Returns:
  - sub
```
IComplexNDArray sub(IComplexNumber n)
```
    Specified by:
    
    sub in interface INDArray
    
    Returns:
  - subi
```
IComplexNDArray subi(IComplexNumber n)
```
    Specified by:
    
    subi in interface INDArray
    
    Returns:
  - add
```
IComplexNDArray add(IComplexNumber n)
```
    Specified by:
    
    add in interface INDArray
    
    Returns:
  - addi
```
IComplexNDArray addi(IComplexNumber n)
```
    Specified by:
    
    addi in interface INDArray
    
    Returns:
  - 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
    
    result - Array to place the result in. Must match shape of this array
    
    Returns:
    
    Result array
  - 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 with a scalar - i.e., (n / thisArrayValues)
    
    Specified by:
    
    rdiv in interface INDArray
    
    Parameters:
    
    n - Value to use for reverse division
    
    Returns:
    
    Copy of array after applying reverse division
  - rdivi
```
IComplexNDArray rdivi(Number n)
```
    Description copied from interface: INDArray
    
    In place reverse division - i.e., (n / thisArrayValues)
    
    Specified by:
    
    rdivi in interface INDArray
    
    Parameters:
    
    n - Value to use for reverse division
    
    Returns:
    
    This array after applying reverse division
  - rsub
```
IComplexNDArray rsub(Number n)
```
    Description copied from interface: INDArray
    
    Reverse subtraction with duplicates - i.e., (n - thisArrayValues)
    
    Specified by:
    
    rsub in interface INDArray
    
    Parameters:
    
    n - Value to use for reverse subtraction
    
    Returns:
    
    Copy of array after reverse subtraction
  - rsubi
```
IComplexNDArray rsubi(Number n)
```
    Description copied from interface: INDArray
    
    Reverse subtraction in place - i.e., (n - thisArrayValues)
    
    Specified by:
    
    rsubi in interface INDArray
    
    Parameters:
    
    n - Value to use for reverse subtraction
    
    Returns:
    
    This array after reverse subtraction
  - div
```
IComplexNDArray div(Number n)
```
    Description copied from interface: INDArray
    
    Division by a number
    
    Specified by:
    
    div in interface INDArray
    
    Parameters:
    
    n - Number to divide values by
    
    Returns:
    
    Copy of array after division
  - divi
```
IComplexNDArray divi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar division
    
    Specified by:
    
    divi in interface INDArray
    
    Parameters:
    
    n - Number to divide values by
    
    Returns:
    
    This array, after applying division operation
  - 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
    
    Parameters:
    
    n - The number to multiply by
    
    Returns:
    
    This array, after applying scaler multiplication
  - 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:
    
    Copy of this array after applying subtraction operation
  - subi
```
IComplexNDArray subi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar subtraction
    
    Specified by:
    
    subi in interface INDArray
    
    Parameters:
    
    n - Number to subtract
    
    Returns:
    
    This array, after applying subtraction operation
  - 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
    
    Parameters:
    
    n - Number to add
    
    Returns:
    
    This array, after adding value
  - get
```
IComplexNDArray get(INDArrayIndex... 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 an INDArray comprised of the specified columns only. Copy operation.
    
    Specified by:
    
    getColumns in interface INDArray
    
    Parameters:
    
    columns - Columns to extract out of the current array
    
    Returns:
    
    Array with only the specified columns
  - getRows
```
IComplexNDArray getRows(int[] rows)
```
    Description copied from interface: INDArray
    
    Get an INDArray comprised of the specified rows only. Copy operation
    
    Specified by:
    
    getRows in interface INDArray
    
    Parameters:
    
    rows - Rose to extract from this array
    
    Returns:
    
    Array with only the specified rows
  - 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)
```
    Parameters:
    
    indices -
    
    value -
    
    Returns:
  - putImag
```
IComplexNDArray putImag(int[] indices,
                        float value)
```
    Parameters:
    
    indices -
    
    value -
    
    Returns:
  - putReal
```
IComplexNDArray putReal(int[] indices,
                        double value)
```
    Parameters:
    
    indices -
    
    value -
    
    Returns:
  - putImag
```
IComplexNDArray putImag(int[] indices,
                        double value)
```
    Parameters:
    
    indices -
    
    value -
    
    Returns:
  - putReal
```
IComplexNDArray putReal(int rowIndex,
                        int columnIndex,
                        float value)
```
    Parameters:
    
    rowIndex -
    
    columnIndex -
    
    value -
    
    Returns:
  - putImag
```
IComplexNDArray putImag(int rowIndex,
                        int columnIndex,
                        float value)
```
    Parameters:
    
    rowIndex -
    
    columnIndex -
    
    value -
    
    Returns:
  - putReal
```
IComplexNDArray putReal(int rowIndex,
                        int columnIndex,
                        double value)
```
    Parameters:
    
    rowIndex -
    
    columnIndex -
    
    value -
    
    Returns:
  - putImag
```
IComplexNDArray putImag(int rowIndex,
                        int columnIndex,
                        double value)
```
    Parameters:
    
    rowIndex -
    
    columnIndex -
    
    value -
    
    Returns:
  - putReal
```
IComplexNDArray putReal(int i,
                        float v)
```
    Parameters:
    
    i -
    
    v -
    
    Returns:
  - putImag
```
IComplexNDArray putImag(int i,
                        float v)
```
    Parameters:
    
    i -
    
    v -
    
    Returns:
  - real
```
INDArray real()
```
    Return all the real components in this ndarray
    
    Returns:
  - imag
```
INDArray imag()
```
    Return all of the imaginary components in this ndarray
    
    Returns:
  - 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
  - reshape
```
IComplexNDArray reshape(char order,
                        int... newShape)
```
    Description copied from interface: INDArray
    
    Reshapes the ndarray (can't change the length of the ndarray). Typically this will be a view, unless reshaping without copying is impossible.
    
    Specified by:
    
    reshape in interface INDArray
    
    newShape - the new shape of the ndarray
    
    Returns:
    
    the reshaped ndarray
  - reshape
```
IComplexNDArray reshape(char order,
                        int rows,
                        int columns)
```
    Description copied from interface: INDArray
    
    Reshapes the ndarray (can't change the length of the ndarray). Typically this will be a view, unless reshaping without copying is impossible.
    
    Specified by:
    
    reshape in interface INDArray
    
    rows - the rows of the matrix
    
    columns - the columns of the matrix
    
    Returns:
    
    the reshaped ndarray
  - 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)
```
    Description copied from interface: INDArray
    
    Element-wise reverse subtraction (copy op). i.e., other - this
    
    Specified by:
    
    rsub in interface INDArray
    
    Parameters:
    
    other -
    
    Returns:
  - rsubi
```
IComplexNDArray rsubi(INDArray other)
```
    Description copied from interface: INDArray
    
    Element-wise reverse subtraction (in the place op) - i.e., other - this
    
    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 INDArray along one or more dimensions
    
    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)
```
    Parameters:
    
    i -
    
    Returns:
  - getComplex
```
IComplexNumber getComplex(int i,
                          int j)
```
    Parameters:
    
    i -
    
    j -
    
    Returns:
  - getComplex
```
IComplexNumber getComplex(int i,
                          IComplexNumber result)
```
    Parameters:
    
    i -
    
    result -
    
    Returns:
  - getComplex
```
IComplexNumber getComplex(int i,
                          int j,
                          IComplexNumber result)
```
    Parameters:
    
    i -
    
    j -
    
    result -
    
    Returns:
  - 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, in-place
    
    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
  - 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