BaseComplexNDArray (nd4j-api 0.4-rc3.8 API)

java.lang.Object
- org.nd4j.linalg.api.ndarray.BaseNDArray
- - org.nd4j.linalg.api.complex.BaseComplexNDArray

All Implemented Interfaces:

Serializable, Iterable, IComplexNDArray, INDArray

Direct Known Subclasses:

LinearViewComplexNDArray
```
public abstract class BaseComplexNDArray
extends BaseNDArray
implements IComplexNDArray
```
ComplexNDArray for complex numbers.

Note that the indexing scheme for a complex ndarray is 2 * length not length.
The reason for this is the fact that imaginary components have to be stored alongside realComponent components.

Author:

Adam Gibson

See Also:

Serialized Form

Field Summary
- Fields inherited from class org.nd4j.linalg.api.ndarray.BaseNDArray
  attemptedToFindElementWiseStride, cleanedUp, columns, data, elementWiseStride, firstNonOneStride, isScalar, isVector, isWrapAround, length, linearStride, linearView, log, majorStride, numLeadingOnes, numTrailingOnes, offset, ordering, ref, rows, shape, stride

Constructor Summary

Constructors
Constructor and Description
`BaseComplexNDArray()`
`BaseComplexNDArray(DataBuffer data)`
`BaseComplexNDArray(DataBuffer data, int[] shape)`
`BaseComplexNDArray(DataBuffer buffer, int[] shape, int offset)`
`BaseComplexNDArray(DataBuffer data, int[] shape, int[] stride)`
`BaseComplexNDArray(DataBuffer data, int[] shape, int[] stride, int offset)`
`BaseComplexNDArray(DataBuffer buffer, int[] shape, int[] stride, int offset, char ordering)`
`BaseComplexNDArray(DataBuffer buffer, int[] shape, int offset, char ordering)`
`BaseComplexNDArray(float[] data)`
`BaseComplexNDArray(float[] data, Character order)`
`BaseComplexNDArray(float[] data, int[] shape)`
`BaseComplexNDArray(float[] data, int[] shape, char ordering)` Create this ndarray with the given data and shape and 0 offset
`BaseComplexNDArray(float[] data, int[] shape, int offset)`
`BaseComplexNDArray(float[] data, int[] shape, int[] stride)` Initialize with the given data,shape and stride
`BaseComplexNDArray(float[] data, int[] shape, int[] stride, char ordering)`
`BaseComplexNDArray(float[] data, int[] shape, int[] stride, int offset)`
`BaseComplexNDArray(float[] data, int[] shape, int[] stride, int offset, Character order)`
`BaseComplexNDArray(float[] data, int[] shape, int offset, char ordering)`
`BaseComplexNDArray(IComplexNumber[] newData, int[] shape)` Create a complex ndarray with the given complex doubles.
`BaseComplexNDArray(IComplexNumber[] newData, int[] shape, char ordering)` Create a complex ndarray with the given complex doubles.
`BaseComplexNDArray(IComplexNumber[] newData, int[] shape, int[] stride)` Create a complex ndarray with the given complex doubles.
`BaseComplexNDArray(IComplexNumber[] data, int[] shape, int[] stride, int offset)`
`BaseComplexNDArray(IComplexNumber[] data, int[] shape, int[] stride, int offset, char ordering)`
`BaseComplexNDArray(IComplexNumber[] data, int[] shape, int offset, char ordering)`
`BaseComplexNDArray(INDArray m)` Construct a complex matrix from a realComponent matrix.
`BaseComplexNDArray(INDArray m, char ordering)` Construct a complex matrix from a realComponent matrix.
`BaseComplexNDArray(INDArray m, int[] stride)` Create with the specified ndarray as the real component and the given stride
`BaseComplexNDArray(INDArray m, int[] stride, char ordering)` Initialize the given ndarray as the real component
`BaseComplexNDArray(int[] shape)`
`BaseComplexNDArray(int[] shape, char ordering)`
`BaseComplexNDArray(int[] shape, int offset)`
`BaseComplexNDArray(int[] shape, int[] stride)` Create the ndarray with the specified shape and stride and an offset of 0
`BaseComplexNDArray(int[] shape, int[] stride, char ordering)` Create the ndarray with the specified shape and stride and an offset of 0
`BaseComplexNDArray(int[] shape, int[] stride, int offset)` Construct an ndarray of the specified shape with an empty data array
`BaseComplexNDArray(int[] shape, int[] stride, int offset, char ordering)` Construct an ndarray of the specified shape with an empty data array
`BaseComplexNDArray(int[] shape, int offset, char ordering)`
`BaseComplexNDArray(int newRows, int newColumns)` Creates a new n times m `ComplexDoubleMatrix`.
`BaseComplexNDArray(int newRows, int newColumns, char ordering)` Creates a new n times m `ComplexDoubleMatrix`.
`BaseComplexNDArray(List<IComplexNDArray> slices, int[] shape)` Create an ndarray from the specified slices and the given shape
`BaseComplexNDArray(List<IComplexNDArray> slices, int[] shape, char ordering)` Create an ndarray from the specified slices and the given shape
`BaseComplexNDArray(List<IComplexNDArray> slices, int[] shape, int[] stride)` Create an ndarray from the specified slices and the given shape
`BaseComplexNDArray(List<IComplexNDArray> slices, int[] shape, int[] stride, char ordering)` Create an ndarray from the specified slices and the given shape

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`IComplexNDArray`	`add(IComplexNumber n)`
`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 ndarray
`void`	`assign(IComplexNumber aDouble)`
`INDArray`	`assign(INDArray arr)` Assign all of the elements in the given ndarray to this nedarray
`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 the ndarray if the element matches the condition 0 otherwise
`IComplexNDArray`	`condi(Condition condition)` 1 in the ndarray if the element matches the condition 0 otherwise
`IComplexNDArray`	`conj()` Compute complex conj.
`IComplexNDArray`	`conji()` Compute complex conj (in-place).
`protected void`	`copyFromReal(INDArray real)`
`protected void`	`copyImagTo(INDArray arr)` Copy imaginary numbers to the given ndarray
`protected void`	`copyRealTo(INDArray arr)` Copy real numbers to arr
`protected IComplexNDArray`	`create(BaseNDArray baseNDArray)`
`protected IComplexNDArray`	`create(DataBuffer buffer)`
`protected IComplexNDArray`	`create(DataBuffer data, int[] shape, int offset)`
`protected IComplexNDArray`	`create(DataBuffer data, int[] shape, int[] strides)`
`protected IComplexNDArray`	`create(DataBuffer data, int[] newShape, int[] newStrides, int offset)`
`protected IComplexNDArray`	`create(DataBuffer data, int[] newShape, int[] newStrides, int offset, char ordering)`
`protected IComplexNDArray`	`create(INDArray baseNDArray)`
`protected IComplexNDArray`	`create(int[] shape)`
`protected INDArray`	`create(int[] shape, char ordering)`
`protected IComplexNDArray`	`create(int[] shape, int[] strides, int offset)`
`protected IComplexNDArray`	`create(int rows, int length)`
`protected IComplexNDArray`	`createScalar(double d)`
`protected INDArray`	`createScalarForIndex(int i, boolean applyOffset)`
`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.
`double`	`distance1(INDArray other)` Returns the (1-norm) distance.
`double`	`distance2(INDArray other)` Returns the (euclidean) distance.
`IComplexNDArray`	`div(IComplexNumber n)`
`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
`protected IComplexNDArray`	`doColumnWise(INDArray columnVector, char operation)` Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide h : reverse subtraction t : reverse division
`protected IComplexNDArray`	`doRowWise(INDArray rowVector, char operation)` Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide h : reverse subtraction t : reverse division
`IComplexNDArray`	`dup()` Return a copy of this ndarray
`Object`	`element()` Returns a scalar (individual element) of a scalar ndarray
`int`	`elementStride()` Element stride (one element to the next, also called the defualt stride: 1 for normal 2 for complex)
`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
`boolean`	`equals(Object o)` Compare two matrices.
`IComplexNDArray`	`get(INDArrayIndex... indexes)` Returns a subset of this array based on the specified indexes
`IComplexNDArray`	`getColumn(int c)` Get the specified column
`IComplexNDArray`	`getColumns(int[] cindices)` Get whole columns from the passed indices.
`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 r)` Get a copy of a row.
`IComplexNDArray`	`getRows(int[] rindices)` Get whole rows from the passed indices.
`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
`protected int[]`	`getStrides(int[] shape, char ordering)`
`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()` Get imaginary part of the matrix.
`IComplexNDArray`	`linearView()` Returns a linear view reference of shape 1,length(ndarray)
`IComplexNDArray`	`linearViewColumnOrder()` Returns a linear view reference of shape 1,length(ndarray)
`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
`IComplexNumber`	`max()`
`IComplexNDArray`	`max(int... dimension)` Returns the overall max of this ndarray
`IComplexNumber`	`maxComplex()`
`Number`	`maxNumber()`
`IComplexNDArray`	`mean(int... dimension)` Returns the overall mean of this ndarray
`IComplexNumber`	`meanComplex()`
`Number`	`meanNumber()`
`IComplexNumber`	`min()`
`IComplexNDArray`	`min(int... dimension)` Returns the overall min of this ndarray
`IComplexNumber`	`minComplex()`
`Number`	`minNumber()`
`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, 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()` Negate each element.
`IComplexNDArray`	`negi()` Negate each element (in-place).
`IComplexNDArray`	`neq(IComplexNumber other)`
`IComplexNDArray`	`neq(INDArray other)`
`IComplexNDArray`	`neq(Number other)` Not equal
`IComplexNDArray`	`neqi(IComplexNumber other)`
`IComplexNDArray`	`neqi(INDArray other)`
`IComplexNDArray`	`neqi(Number other)` In place not equal
`protected IComplexNDArray`	`newShape(int[] newShape, char ordering)`
`IComplexNDArray`	`norm1(int... dimension)` Returns the norm1 along the specified dimension
`IComplexNumber`	`norm1Complex()`
`Number`	`norm1Number()`
`IComplexNDArray`	`norm2(int... dimension)` Returns the norm2 along the specified dimension
`IComplexNumber`	`norm2Complex()`
`Number`	`norm2Number()`
`IComplexNDArray`	`normmax(int... dimension)` Returns the normmax along the specified dimension
`IComplexNumber`	`normmaxComplex()`
`Number`	`normmaxNumber()`
`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
`IComplexNumber`	`prodComplex()`
`Number`	`prodNumber()`
`IComplexNDArray`	`put(INDArrayIndex[] indices, IComplexNDArray element)`
`IComplexNDArray`	`put(INDArrayIndex[] indices, IComplexNumber element)`
`IComplexNDArray`	`put(INDArrayIndex[] indices, INDArray element)` Put the elements of the ndarray in to the specified indices
`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)` Inserts the element at the specified index
`void`	`put(int i, IComplexNumber element)`
`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(int i, int j, Number 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, double value)` Insert the item at the specified indices
`IComplexNDArray`	`putScalar(int[] indexes, 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)` Assigns the given matrix (put) to the specified slice
`IComplexNDArray`	`putSlice(int slice, INDArray put)` Assigns the given matrix (put) to the specified slice
`IComplexNDArray`	`ravel()` Flattens the array for linear indexing
`IComplexNDArray`	`rdiv(IComplexNumber n)`
`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)` 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
`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()` Get realComponent part of the matrix.
`IComplexNDArray`	`repmat(int[] shape)` Replicate and tile array to fill out to the given shape
`void`	`resetLinearView()` Resets the linear view
`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... shape)` Reshape the ndarray in to the specified dimensions, possible errors being thrown for invalid shapes
`IComplexNDArray`	`reshape(int newRows, int newColumns)` Reshape the matrix.
`IComplexNDArray`	`rsub(IComplexNumber n)`
`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)` 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)`
`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 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)
`int`	`secondaryStride()` Return the second stride for an ndarray.
`IComplexNDArray`	`slice(int slice)` Returns the specified slice of this matrix.
`IComplexNDArray`	`slice(int slice, int dimension)` Returns the slice of this from the specified dimension
`double`	`squaredDistance(INDArray other)` Returns the squared (Euclidean) distance.
`IComplexNDArray`	`std(int... dimension)` Standard deviation of an ndarray along a dimension
`IComplexNumber`	`stdComplex()`
`Number`	`stdNumber()`
`IComplexNDArray`	`sub(IComplexNumber n)`
`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`	`subArray(int[] offsets, int[] shape, int[] stride)`
`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
`IComplexNumber`	`sumComplex()` Sum the entire array
`Number`	`sumNumber()` Sum the entire array
`IComplexNDArray`	`swapAxes(int dimension, int with)` Mainly here for people coming from numpy.
`String`	`toString()` Generate string representation of the matrix.
`IComplexNDArray`	`transpose()` Return transposed copy of this matrix.
`IComplexNDArray`	`transposei()` Return transposed copy of this matrix.
`IComplexNDArray`	`var(int... dimension)` Returns the overall variance of this ndarray
`IComplexNumber`	`varComplex()`
`Number`	`varNumber()`
`IComplexNDArray`	`vectorAlongDimension(int index, int dimension)` Get the vector along a particular dimension

Methods inherited from class org.nd4j.linalg.api.ndarray.BaseNDArray
add, assertColumnVector, assertRowVector, assertSlice, checkArrangeArray, cleanup, columns, data, div, doPermuteSwap, dup, elementWiseStride, getDouble, getDouble, getDouble, getDoubleUnsafe, getFloat, getFloat, getFloat, getInt, getLeadingOnes, getTrailingOnes, index, init, innerMostStride, isCleanedUp, isColumnVector, isMatrix, isRowVector, isScalar, isSquare, isValid, isVector, isView, isWrapAround, iterator, length, linearIndex, majorStride, mul, offset, ordering, putScalar, putScalar, putScalar, putScalar, putScalarUnsafe, rank, ravel, rdiv, repeat, repeat, rows, rsub, setData, setOrder, setShape, setStride, setWrapAround, shape, size, slices, sliceVectors, stride, stride, sub, subArray, tensorAlongDimension, tensorssAlongDimension, vectorsAlongDimension

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

Methods inherited from interface org.nd4j.linalg.api.complex.IComplexNDArray
add, div, mul, rdiv, rsub, sub

Methods inherited from interface org.nd4j.linalg.api.ndarray.INDArray
cleanup, columns, data, dup, elementWiseStride, getDouble, getDouble, getDouble, getDoubleUnsafe, getFloat, getFloat, getFloat, getInt, getLeadingOnes, getTrailingOnes, index, innerMostStride, isCleanedUp, isColumnVector, isMatrix, isRowVector, isScalar, isSquare, isVector, isView, isWrapAround, length, linearIndex, majorStride, offset, ordering, putScalar, putScalar, putScalar, putScalar, putScalarUnsafe, rank, ravel, repeat, repeat, rows, setData, setOrder, setShape, setStride, setWrapAround, shape, size, slices, sliceVectors, stride, stride, subArray, tensorAlongDimension, tensorssAlongDimension, vectorsAlongDimension

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - BaseComplexNDArray
```
public BaseComplexNDArray()
```
  - BaseComplexNDArray
```
public BaseComplexNDArray(DataBuffer data,
                          int[] shape,
                          int[] stride)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data)
```
    Parameters:
    
    data -
  - BaseComplexNDArray
```
public BaseComplexNDArray(DataBuffer buffer,
                          int[] shape,
                          int[] stride,
                          int offset,
                          char ordering)
```
    Parameters:
    
    buffer -
    
    shape -
    
    stride -
    
    offset -
    
    ordering -
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data,
                          int[] shape,
                          char ordering)
```
    Create this ndarray with the given data and shape and 0 offset
    
    Parameters:
    
    data - the data to use
    
    shape - the shape of the ndarray
    
    ordering -
  - BaseComplexNDArray
```
public BaseComplexNDArray(int[] shape,
                          int offset,
                          char ordering)
```
    Parameters:
    
    shape -
    
    offset -
    
    ordering -
  - BaseComplexNDArray
```
public BaseComplexNDArray(int[] shape)
```
    Parameters:
    
    shape -
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data,
                          int[] shape,
                          int[] stride,
                          char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    ordering -
  - BaseComplexNDArray
```
public BaseComplexNDArray(int[] shape,
                          char ordering)
```
  - BaseComplexNDArray
```
public BaseComplexNDArray(INDArray m,
                          int[] stride,
                          char ordering)
```
    Initialize the given ndarray as the real component
    
    Parameters:
    
    m - the real component
    
    stride - the stride of the ndarray
    
    ordering - the ordering for the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(INDArray m,
                          char ordering)
```
    Construct a complex matrix from a realComponent matrix.
  - BaseComplexNDArray
```
public BaseComplexNDArray(INDArray m)
```
    Construct a complex matrix from a realComponent matrix.
  - BaseComplexNDArray
```
public BaseComplexNDArray(INDArray m,
                          int[] stride)
```
    Create with the specified ndarray as the real component and the given stride
    
    Parameters:
    
    m - the ndarray to use as the stride
    
    stride - the stride of the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(List<IComplexNDArray> slices,
                          int[] shape,
                          int[] stride)
```
    Create an ndarray from the specified slices and the given shape
    
    Parameters:
    
    slices - the slices of the ndarray
    
    shape - the final shape of the ndarray
    
    stride - the stride of the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(List<IComplexNDArray> slices,
                          int[] shape,
                          int[] stride,
                          char ordering)
```
    Create an ndarray from the specified slices and the given shape
    
    Parameters:
    
    slices - the slices of the ndarray
    
    shape - the final shape of the ndarray
    
    stride - the stride of the ndarray
    
    ordering - the ordering for the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(List<IComplexNDArray> slices,
                          int[] shape,
                          char ordering)
```
    Create an ndarray from the specified slices and the given shape
    
    Parameters:
    
    slices - the slices of the ndarray
    
    shape - the final shape of the ndarray
    
    ordering - the ordering of the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data,
                          int[] shape,
                          int[] stride,
                          int offset,
                          Character order)
```
  - BaseComplexNDArray
```
public BaseComplexNDArray(DataBuffer data)
```
    Parameters:
    
    data -
  - BaseComplexNDArray
```
public BaseComplexNDArray(DataBuffer data,
                          int[] shape,
                          int[] stride,
                          int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    offset -
  - BaseComplexNDArray
```
public BaseComplexNDArray(IComplexNumber[] data,
                          int[] shape,
                          int[] stride,
                          int offset,
                          char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    offset -
    
    ordering -
  - BaseComplexNDArray
```
public BaseComplexNDArray(DataBuffer data,
                          int[] shape)
```
    Parameters:
    
    data -
    
    shape -
  - BaseComplexNDArray
```
public BaseComplexNDArray(IComplexNumber[] data,
                          int[] shape,
                          int[] stride,
                          int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    offset -
  - BaseComplexNDArray
```
public BaseComplexNDArray(IComplexNumber[] data,
                          int[] shape,
                          int offset,
                          char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    ordering -
  - BaseComplexNDArray
```
public BaseComplexNDArray(DataBuffer buffer,
                          int[] shape,
                          int offset,
                          char ordering)
```
    Parameters:
    
    buffer -
    
    shape -
    
    offset -
    
    ordering -
  - BaseComplexNDArray
```
public BaseComplexNDArray(DataBuffer buffer,
                          int[] shape,
                          int offset)
```
    Parameters:
    
    buffer -
    
    shape -
    
    offset -
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data,
                          Character order)
```
    Parameters:
    
    data -
    
    order -
  - BaseComplexNDArray
```
public BaseComplexNDArray(List<IComplexNDArray> slices,
                          int[] shape)
```
    Create an ndarray from the specified slices and the given shape
    
    Parameters:
    
    slices - the slices of the ndarray
    
    shape - the final shape of the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(IComplexNumber[] newData,
                          int[] shape)
```
    Create a complex ndarray with the given complex doubles. Note that this maybe an easier setup than the new float
    
    Parameters:
    
    newData - the new data for this array
    
    shape - the shape of the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(IComplexNumber[] newData,
                          int[] shape,
                          int[] stride)
```
    Create a complex ndarray with the given complex doubles. Note that this maybe an easier setup than the new float
    
    Parameters:
    
    newData - the new data for this array
    
    shape - the shape of the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(IComplexNumber[] newData,
                          int[] shape,
                          char ordering)
```
    Create a complex ndarray with the given complex doubles. Note that this maybe an easier setup than the new float
    
    Parameters:
    
    newData - the new data for this array
    
    shape - the shape of the ndarray
    
    ordering - the ordering for the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data,
                          int[] shape,
                          int[] stride)
```
    Initialize with the given data,shape and stride
    
    Parameters:
    
    data - the data to use
    
    shape - the shape of the ndarray
    
    stride - the stride of the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data,
                          int[] shape)
```
    Parameters:
    
    data -
    
    shape -
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data,
                          int[] shape,
                          int offset,
                          char ordering)
```
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data,
                          int[] shape,
                          int offset)
```
  - BaseComplexNDArray
```
public BaseComplexNDArray(int[] shape,
                          int[] stride,
                          int offset)
```
    Construct an ndarray of the specified shape with an empty data array
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride of the ndarray
    
    offset - the desired offset
  - BaseComplexNDArray
```
public BaseComplexNDArray(int[] shape,
                          int[] stride,
                          int offset,
                          char ordering)
```
    Construct an ndarray of the specified shape with an empty data array
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride of the ndarray
    
    offset - the desired offset
    
    ordering - the ordering for the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(int[] shape,
                          int[] stride,
                          char ordering)
```
    Create the ndarray with the specified shape and stride and an offset of 0
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride of the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(int[] shape,
                          int[] stride)
```
    Create the ndarray with the specified shape and stride and an offset of 0
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride of the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(int[] shape,
                          int offset)
```
    Parameters:
    
    shape -
    
    offset -
  - BaseComplexNDArray
```
public BaseComplexNDArray(int newRows,
                          int newColumns)
```
    Creates a new n times m ComplexDoubleMatrix.
    
    Parameters:
    
    newRows - the number of rows (n) of the new matrix.
    
    newColumns - the number of columns (m) of the new matrix.
  - BaseComplexNDArray
```
public BaseComplexNDArray(int newRows,
                          int newColumns,
                          char ordering)
```
    Creates a new n times m ComplexDoubleMatrix.
    
    Parameters:
    
    newRows - the number of rows (n) of the new matrix.
    
    newColumns - the number of columns (m) of the new matrix.
    
    ordering - the ordering of the ndarray
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data,
                          int[] shape,
                          int[] stride,
                          int offset)
```
- Method Detail
  - copyFromReal
```
protected void copyFromReal(INDArray real)
```
    Parameters:
    
    real -
  - create
```
protected IComplexNDArray create(DataBuffer data,
                                 int[] shape,
                                 int[] strides)
```
    Overrides:
    
    create in class BaseNDArray
  - copyRealTo
```
protected void copyRealTo(INDArray arr)
```
    Copy real numbers to arr
    
    Overrides:
    
    copyRealTo in class BaseNDArray
    
    Parameters:
    
    arr - the arr to copy to
  - copyImagTo
```
protected void copyImagTo(INDArray arr)
```
    Copy imaginary numbers to the given ndarray
    
    Parameters:
    
    arr - the array to copy imaginary numbers to
  - blasOffset
```
public int blasOffset()
```
    Description copied from interface: IComplexNDArray
    
    For blas operations, this is the offset / 2 when offset is > 0
    
    Specified by:
    
    blasOffset in interface IComplexNDArray
    
    Returns:
    
    the blas offset
  - linearViewColumnOrder
```
public IComplexNDArray linearViewColumnOrder()
```
    Description copied from interface: INDArray
    
    Returns a linear view reference of shape 1,length(ndarray)
    
    Specified by:
    
    linearViewColumnOrder in interface IComplexNDArray
    
    Specified by:
    
    linearViewColumnOrder in interface INDArray
    
    Overrides:
    
    linearViewColumnOrder in class BaseNDArray
    
    Returns:
    
    the linear view of this ndarray
  - linearView
```
public IComplexNDArray linearView()
```
    Returns a linear view reference of shape 1,length(ndarray)
    
    Specified by:
    
    linearView in interface IComplexNDArray
    
    Specified by:
    
    linearView in interface INDArray
    
    Overrides:
    
    linearView in class BaseNDArray
    
    Returns:
    
    the linear view of this ndarray
  - resetLinearView
```
public void resetLinearView()
```
    Description copied from interface: INDArray
    
    Resets the linear view
    
    Specified by:
    
    resetLinearView in interface INDArray
    
    Overrides:
    
    resetLinearView in class BaseNDArray
  - getComplex
```
public IComplexNumber getComplex(int i,
                                 IComplexNumber result)
```
    Specified by:
    
    getComplex in interface IComplexNDArray
    
    Returns:
  - getComplex
```
public IComplexNumber getComplex(int i,
                                 int j,
                                 IComplexNumber result)
```
    Specified by:
    
    getComplex in interface IComplexNDArray
    
    Returns:
  - putScalar
```
public IComplexNDArray putScalar(int j,
                                 int i,
                                 IComplexNumber conji)
```
    Specified by:
    
    putScalar in interface IComplexNDArray
  - eps
```
public IComplexNDArray eps(Number other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Specified by:
    
    eps in interface IComplexNDArray
    
    Specified by:
    
    eps in interface INDArray
    
    Overrides:
    
    eps in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - eps
```
public IComplexNDArray eps(IComplexNumber other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Specified by:
    
    eps in interface IComplexNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - epsi
```
public IComplexNDArray epsi(IComplexNumber other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Specified by:
    
    epsi in interface IComplexNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - epsi
```
public IComplexNDArray epsi(Number other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Specified by:
    
    epsi in interface IComplexNDArray
    
    Specified by:
    
    epsi in interface INDArray
    
    Overrides:
    
    epsi in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - eps
```
public 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 IComplexNDArray
    
    Specified by:
    
    eps in interface INDArray
    
    Overrides:
    
    eps in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - epsi
```
public 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 IComplexNDArray
    
    Specified by:
    
    epsi in interface INDArray
    
    Overrides:
    
    epsi in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - lt
```
public 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 IComplexNDArray
    
    Specified by:
    
    lt in interface INDArray
    
    Overrides:
    
    lt in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - lti
```
public 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 IComplexNDArray
    
    Specified by:
    
    lti in interface INDArray
    
    Overrides:
    
    lti in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - eq
```
public 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 IComplexNDArray
    
    Specified by:
    
    eq in interface INDArray
    
    Overrides:
    
    eq in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - eqi
```
public 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 IComplexNDArray
    
    Specified by:
    
    eqi in interface INDArray
    
    Overrides:
    
    eqi in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - gt
```
public IComplexNDArray gt(Number other)
```
    Description copied from interface: INDArray
    
    Greater than boolean (copying)(
    
    Specified by:
    
    gt in interface IComplexNDArray
    
    Specified by:
    
    gt in interface INDArray
    
    Overrides:
    
    gt in class BaseNDArray
    
    Returns:
  - gti
```
public 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 IComplexNDArray
    
    Specified by:
    
    gti in interface INDArray
    
    Overrides:
    
    gti in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - lt
```
public 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 IComplexNDArray
    
    Specified by:
    
    lt in interface INDArray
    
    Overrides:
    
    lt in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    the result ndarray
  - lti
```
public 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 IComplexNDArray
    
    Specified by:
    
    lti in interface INDArray
    
    Overrides:
    
    lti in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - eq
```
public 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 IComplexNDArray
    
    Specified by:
    
    eq in interface INDArray
    
    Overrides:
    
    eq in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - eqi
```
public 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 IComplexNDArray
    
    Specified by:
    
    eqi in interface INDArray
    
    Overrides:
    
    eqi in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - neq
```
public IComplexNDArray neq(INDArray other)
```
    Specified by:
    
    neq in interface IComplexNDArray
    
    Specified by:
    
    neq in interface INDArray
    
    Overrides:
    
    neq in class BaseNDArray
    
    Returns:
  - neq
```
public IComplexNDArray neq(Number other)
```
    Description copied from interface: INDArray
    
    Not equal
    
    Specified by:
    
    neq in interface IComplexNDArray
    
    Specified by:
    
    neq in interface INDArray
    
    Overrides:
    
    neq in class BaseNDArray
    
    Returns:
  - neqi
```
public IComplexNDArray neqi(Number other)
```
    Description copied from interface: INDArray
    
    In place not equal
    
    Specified by:
    
    neqi in interface IComplexNDArray
    
    Specified by:
    
    neqi in interface INDArray
    
    Overrides:
    
    neqi in class BaseNDArray
    
    Returns:
  - neqi
```
public IComplexNDArray neqi(INDArray other)
```
    Specified by:
    
    neqi in interface IComplexNDArray
    
    Specified by:
    
    neqi in interface INDArray
    
    Overrides:
    
    neqi in class BaseNDArray
    
    Returns:
  - gt
```
public 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 IComplexNDArray
    
    Specified by:
    
    gt in interface INDArray
    
    Overrides:
    
    gt in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - gti
```
public 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 IComplexNDArray
    
    Specified by:
    
    gti in interface INDArray
    
    Overrides:
    
    gti in class BaseNDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - rdiv
```
public IComplexNDArray rdiv(Number n,
                            INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse division (number / ndarray)
    
    Specified by:
    
    rdiv in interface IComplexNDArray
    
    Specified by:
    
    rdiv in interface INDArray
    
    Overrides:
    
    rdiv in class BaseNDArray
    
    Parameters:
    
    n - the number to divide by
    
    Returns:
  - rdivi
```
public IComplexNDArray rdivi(Number n,
                             INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse in place division
    
    Specified by:
    
    rdivi in interface IComplexNDArray
    
    Specified by:
    
    rdivi in interface INDArray
    
    Overrides:
    
    rdivi in class BaseNDArray
    
    Parameters:
    
    n - the number to divide by by
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - rsub
```
public IComplexNDArray rsub(Number n,
                            INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse subtraction
    
    Specified by:
    
    rsub in interface IComplexNDArray
    
    Specified by:
    
    rsub in interface INDArray
    
    Overrides:
    
    rsub in class BaseNDArray
    
    Parameters:
    
    n - the number to subtract by
    
    result - the result ndarray
    
    Returns:
  - rsubi
```
public IComplexNDArray rsubi(Number n,
                             INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse in place subtraction
    
    Specified by:
    
    rsubi in interface IComplexNDArray
    
    Specified by:
    
    rsubi in interface INDArray
    
    Overrides:
    
    rsubi in class BaseNDArray
    
    Parameters:
    
    n - the number to subtract by
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - div
```
public IComplexNDArray div(Number n,
                           INDArray result)
```
    Specified by:
    
    div in interface IComplexNDArray
    
    Specified by:
    
    div in interface INDArray
    
    Overrides:
    
    div in class BaseNDArray
    
    Returns:
  - divi
```
public IComplexNDArray divi(Number n,
                            INDArray result)
```
    Description copied from interface: INDArray
    
    In place division of this ndarray
    
    Specified by:
    
    divi in interface IComplexNDArray
    
    Specified by:
    
    divi in interface INDArray
    
    Overrides:
    
    divi in class BaseNDArray
    
    Parameters:
    
    n - the number to divide by
    
    result - the result ndarray
    
    Returns:
  - mul
```
public IComplexNDArray mul(Number n,
                           INDArray result)
```
    Specified by:
    
    mul in interface IComplexNDArray
    
    Specified by:
    
    mul in interface INDArray
    
    Overrides:
    
    mul in class BaseNDArray
  - muli
```
public IComplexNDArray muli(Number n,
                            INDArray result)
```
    Description copied from interface: INDArray
    
    In place multiplication of this ndarray
    
    Specified by:
    
    muli in interface IComplexNDArray
    
    Specified by:
    
    muli in interface INDArray
    
    Overrides:
    
    muli in class BaseNDArray
    
    Parameters:
    
    n - the number to divide by
    
    result - the result ndarray
    
    Returns:
  - sub
```
public IComplexNDArray sub(Number n,
                           INDArray result)
```
    Specified by:
    
    sub in interface IComplexNDArray
    
    Specified by:
    
    sub in interface INDArray
    
    Overrides:
    
    sub in class BaseNDArray
  - subi
```
public IComplexNDArray subi(Number n,
                            INDArray result)
```
    Description copied from interface: INDArray
    
    In place subtraction of this ndarray
    
    Specified by:
    
    subi in interface IComplexNDArray
    
    Specified by:
    
    subi in interface INDArray
    
    Overrides:
    
    subi in class BaseNDArray
    
    Parameters:
    
    n - the number to subtract by
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - add
```
public IComplexNDArray add(Number n,
                           INDArray result)
```
    Specified by:
    
    add in interface IComplexNDArray
    
    Specified by:
    
    add in interface INDArray
    
    Overrides:
    
    add in class BaseNDArray
  - addi
```
public IComplexNDArray addi(Number n,
                            INDArray result)
```
    Description copied from interface: INDArray
    
    In place addition
    
    Specified by:
    
    addi in interface IComplexNDArray
    
    Specified by:
    
    addi in interface INDArray
    
    Overrides:
    
    addi in class BaseNDArray
    
    Parameters:
    
    n - the number to add
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - dup
```
public IComplexNDArray dup()
```
    Description copied from interface: INDArray
    
    Return a copy of this ndarray
    
    Specified by:
    
    dup in interface IComplexNDArray
    
    Specified by:
    
    dup in interface INDArray
    
    Overrides:
    
    dup in class BaseNDArray
    
    Returns:
    
    a copy of this ndarray
  - rsubRowVector
```
public IComplexNDArray rsubRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    Reverse subtraction of a row vector (copy)
    
    Specified by:
    
    rsubRowVector in interface IComplexNDArray
    
    Specified by:
    
    rsubRowVector in interface INDArray
    
    Overrides:
    
    rsubRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubiRowVector
```
public IComplexNDArray rsubiRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place reverse subtraction of a row vector
    
    Specified by:
    
    rsubiRowVector in interface IComplexNDArray
    
    Specified by:
    
    rsubiRowVector in interface INDArray
    
    Overrides:
    
    rsubiRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubColumnVector
```
public IComplexNDArray rsubColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    Reverse subtraction of a column vector (copy)
    
    Specified by:
    
    rsubColumnVector in interface IComplexNDArray
    
    Specified by:
    
    rsubColumnVector in interface INDArray
    
    Overrides:
    
    rsubColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubiColumnVector
```
public IComplexNDArray rsubiColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place reverse subtraction of a column vector
    
    Specified by:
    
    rsubiColumnVector in interface IComplexNDArray
    
    Specified by:
    
    rsubiColumnVector in interface INDArray
    
    Overrides:
    
    rsubiColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rdivRowVector
```
public IComplexNDArray rdivRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    Reverse division of a column vector (copy)
    
    Specified by:
    
    rdivRowVector in interface IComplexNDArray
    
    Specified by:
    
    rdivRowVector in interface INDArray
    
    Overrides:
    
    rdivRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - rdiviRowVector
```
public IComplexNDArray rdiviRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place reverse division of a column vector
    
    Specified by:
    
    rdiviRowVector in interface IComplexNDArray
    
    Specified by:
    
    rdiviRowVector in interface INDArray
    
    Overrides:
    
    rdiviRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - rdivColumnVector
```
public IComplexNDArray rdivColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    Reverse division of a column vector (copy)
    
    Specified by:
    
    rdivColumnVector in interface IComplexNDArray
    
    Specified by:
    
    rdivColumnVector in interface INDArray
    
    Overrides:
    
    rdivColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector used for division
    
    Returns:
    
    the result of the division
  - rdiviColumnVector
```
public IComplexNDArray rdiviColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place reverse divison of a column vector
    
    Specified by:
    
    rdiviColumnVector in interface IComplexNDArray
    
    Specified by:
    
    rdiviColumnVector in interface INDArray
    
    Overrides:
    
    rdiviColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector used for division
    
    Returns:
    
    the result of the division
  - doRowWise
```
protected IComplexNDArray doRowWise(INDArray rowVector,
                                    char operation)
```
    Description copied from class: BaseNDArray
    
    Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide h : reverse subtraction t : reverse division
    
    Overrides:
    
    doRowWise in class BaseNDArray
    
    Parameters:
    
    rowVector - the row vector
    
    operation - the operation
    
    Returns:
  - doColumnWise
```
protected IComplexNDArray doColumnWise(INDArray columnVector,
                                       char operation)
```
    Description copied from class: BaseNDArray
    
    Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide h : reverse subtraction t : reverse division
    
    Overrides:
    
    doColumnWise in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector
    
    operation - the operation
    
    Returns:
  - squaredDistance
```
public double squaredDistance(INDArray other)
```
    Returns the squared (Euclidean) distance.
    
    Specified by:
    
    squaredDistance in interface INDArray
    
    Overrides:
    
    squaredDistance in class BaseNDArray
  - distance2
```
public double distance2(INDArray other)
```
    Returns the (euclidean) distance.
    
    Specified by:
    
    distance2 in interface INDArray
    
    Overrides:
    
    distance2 in class BaseNDArray
  - distance1
```
public double distance1(INDArray other)
```
    Returns the (1-norm) distance.
    
    Specified by:
    
    distance1 in interface INDArray
    
    Overrides:
    
    distance1 in class BaseNDArray
  - put
```
public IComplexNDArray put(INDArrayIndex[] indices,
                           INDArray element)
```
    Description copied from interface: INDArray
    
    Put the elements of the ndarray in to the specified indices
    
    Specified by:
    
    put in interface INDArray
    
    Overrides:
    
    put in class BaseNDArray
    
    Parameters:
    
    indices - the indices to put the ndarray in to
    
    element - the ndarray to put
    
    Returns:
    
    this ndarray
  - normmax
```
public IComplexNDArray normmax(int... dimension)
```
    Description copied from class: BaseNDArray
    
    Returns the normmax along the specified dimension
    
    Specified by:
    
    normmax in interface IComplexNDArray
    
    Specified by:
    
    normmax in interface INDArray
    
    Overrides:
    
    normmax in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the norm1 along
    
    Returns:
    
    the norm1 along the specified dimension
  - normmaxNumber
```
public Number normmaxNumber()
```
    Specified by:
    
    normmaxNumber in interface INDArray
    
    Overrides:
    
    normmaxNumber in class BaseNDArray
  - normmaxComplex
```
public IComplexNumber normmaxComplex()
```
    Specified by:
    
    normmaxComplex in interface INDArray
    
    Overrides:
    
    normmaxComplex in class BaseNDArray
  - prod
```
public IComplexNDArray prod(int... dimension)
```
    Description copied from class: BaseNDArray
    
    Returns the product along a given dimension
    
    Specified by:
    
    prod in interface IComplexNDArray
    
    Specified by:
    
    prod in interface INDArray
    
    Overrides:
    
    prod in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the product along
    
    Returns:
    
    the product along the specified dimension
  - prodNumber
```
public Number prodNumber()
```
    Specified by:
    
    prodNumber in interface INDArray
    
    Overrides:
    
    prodNumber in class BaseNDArray
  - prodComplex
```
public IComplexNumber prodComplex()
```
    Specified by:
    
    prodComplex in interface INDArray
    
    Overrides:
    
    prodComplex in class BaseNDArray
  - mean
```
public IComplexNDArray mean(int... dimension)
```
    Description copied from class: BaseNDArray
    
    Returns the overall mean of this ndarray
    
    Specified by:
    
    mean in interface IComplexNDArray
    
    Specified by:
    
    mean in interface INDArray
    
    Overrides:
    
    mean in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the mean along
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - meanNumber
```
public Number meanNumber()
```
    Specified by:
    
    meanNumber in interface INDArray
    
    Overrides:
    
    meanNumber in class BaseNDArray
  - meanComplex
```
public IComplexNumber meanComplex()
```
    Specified by:
    
    meanComplex in interface INDArray
    
    Overrides:
    
    meanComplex in class BaseNDArray
  - var
```
public IComplexNDArray var(int... dimension)
```
    Description copied from class: BaseNDArray
    
    Returns the overall variance of this ndarray
    
    Specified by:
    
    var in interface IComplexNDArray
    
    Specified by:
    
    var in interface INDArray
    
    Overrides:
    
    var in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the mean along
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - varNumber
```
public Number varNumber()
```
    Specified by:
    
    varNumber in interface INDArray
    
    Overrides:
    
    varNumber in class BaseNDArray
  - varComplex
```
public IComplexNumber varComplex()
```
    Specified by:
    
    varComplex in interface INDArray
    
    Overrides:
    
    varComplex in class BaseNDArray
  - max
```
public IComplexNDArray max(int... dimension)
```
    Description copied from class: BaseNDArray
    
    Returns the overall max of this ndarray
    
    Specified by:
    
    max in interface IComplexNDArray
    
    Specified by:
    
    max in interface INDArray
    
    Overrides:
    
    max in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the mean along
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - maxNumber
```
public Number maxNumber()
```
    Specified by:
    
    maxNumber in interface INDArray
    
    Overrides:
    
    maxNumber in class BaseNDArray
  - maxComplex
```
public IComplexNumber maxComplex()
```
    Specified by:
    
    maxComplex in interface INDArray
    
    Overrides:
    
    maxComplex in class BaseNDArray
  - sum
```
public IComplexNDArray sum(int... dimension)
```
    Description copied from class: BaseNDArray
    
    Returns the sum along the last dimension of this ndarray
    
    Specified by:
    
    sum in interface IComplexNDArray
    
    Specified by:
    
    sum in interface INDArray
    
    Overrides:
    
    sum in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the sum along
    
    Returns:
    
    the sum along the specified dimension of this ndarray
  - sumNumber
```
public Number sumNumber()
```
    Description copied from interface: INDArray
    
    Sum the entire array
    
    Specified by:
    
    sumNumber in interface INDArray
    
    Overrides:
    
    sumNumber in class BaseNDArray
    
    Returns:
  - sumComplex
```
public IComplexNumber sumComplex()
```
    Description copied from interface: INDArray
    
    Sum the entire array
    
    Specified by:
    
    sumComplex in interface INDArray
    
    Overrides:
    
    sumComplex in class BaseNDArray
    
    Returns:
  - min
```
public IComplexNDArray min(int... dimension)
```
    Description copied from class: BaseNDArray
    
    Returns the overall min of this ndarray
    
    Specified by:
    
    min in interface IComplexNDArray
    
    Specified by:
    
    min in interface INDArray
    
    Overrides:
    
    min in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the mean along
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - minNumber
```
public Number minNumber()
```
    Specified by:
    
    minNumber in interface INDArray
    
    Overrides:
    
    minNumber in class BaseNDArray
  - minComplex
```
public IComplexNumber minComplex()
```
    Specified by:
    
    minComplex in interface INDArray
    
    Overrides:
    
    minComplex in class BaseNDArray
  - norm1
```
public IComplexNDArray norm1(int... dimension)
```
    Description copied from class: BaseNDArray
    
    Returns the norm1 along the specified dimension
    
    Specified by:
    
    norm1 in interface IComplexNDArray
    
    Specified by:
    
    norm1 in interface INDArray
    
    Overrides:
    
    norm1 in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the norm1 along
    
    Returns:
    
    the norm1 along the specified dimension
  - norm1Number
```
public Number norm1Number()
```
    Specified by:
    
    norm1Number in interface INDArray
    
    Overrides:
    
    norm1Number in class BaseNDArray
  - norm1Complex
```
public IComplexNumber norm1Complex()
```
    Specified by:
    
    norm1Complex in interface INDArray
    
    Overrides:
    
    norm1Complex in class BaseNDArray
  - std
```
public IComplexNDArray std(int... dimension)
```
    Description copied from class: BaseNDArray
    
    Standard deviation of an ndarray along a dimension
    
    Specified by:
    
    std in interface IComplexNDArray
    
    Specified by:
    
    std in interface INDArray
    
    Overrides:
    
    std in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the std along
    
    Returns:
    
    the standard deviation along a particular dimension
  - stdNumber
```
public Number stdNumber()
```
    Specified by:
    
    stdNumber in interface INDArray
    
    Overrides:
    
    stdNumber in class BaseNDArray
  - stdComplex
```
public IComplexNumber stdComplex()
```
    Specified by:
    
    stdComplex in interface INDArray
    
    Overrides:
    
    stdComplex in class BaseNDArray
  - norm2
```
public IComplexNDArray norm2(int... dimension)
```
    Description copied from class: BaseNDArray
    
    Returns the norm2 along the specified dimension
    
    Specified by:
    
    norm2 in interface IComplexNDArray
    
    Specified by:
    
    norm2 in interface INDArray
    
    Overrides:
    
    norm2 in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the norm2 along
    
    Returns:
    
    the norm2 along the specified dimension
  - norm2Number
```
public Number norm2Number()
```
    Specified by:
    
    norm2Number in interface INDArray
    
    Overrides:
    
    norm2Number in class BaseNDArray
  - norm2Complex
```
public IComplexNumber norm2Complex()
```
    Specified by:
    
    norm2Complex in interface INDArray
    
    Overrides:
    
    norm2Complex in class BaseNDArray
  - put
```
public IComplexNDArray put(int i,
                           int j,
                           Number element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface INDArray
    
    Overrides:
    
    put in class BaseNDArray
    
    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
```
public IComplexNDArray put(int[] indexes,
                           double value)
```
    Specified by:
    
    put in interface IComplexNDArray
    
    Parameters:
    
    indexes -
    
    value -
    
    Returns:
  - put
```
public IComplexNDArray put(int i,
                           int j,
                           IComplexNumber complex)
```
    Specified by:
    
    put in interface IComplexNDArray
  - putSlice
```
public IComplexNDArray putSlice(int slice,
                                IComplexNDArray put)
```
    Assigns the given matrix (put) to the specified slice
    
    Specified by:
    
    putSlice in interface IComplexNDArray
    
    Parameters:
    
    slice - the slice to assign
    
    put - the slice to transform
    
    Returns:
    
    this for chainability
  - swapAxes
```
public 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 IComplexNDArray
    
    Specified by:
    
    swapAxes in interface INDArray
    
    Overrides:
    
    swapAxes in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to swap
    
    with - the one to swap it with
    
    Returns:
    
    the swapped axes view
  - conji
```
public IComplexNDArray conji()
```
    Compute complex conj (in-place).
    
    Specified by:
    
    conji in interface IComplexNDArray
  - hermitian
```
public IComplexNDArray hermitian()
```
    Description copied from interface: IComplexNDArray
    
    a Hermitian matrix is a square matrix with complex entries that is equal to its own conjugate transpose
    
    Specified by:
    
    hermitian in interface IComplexNDArray
    
    Returns:
    
    the hermitian of this ndarray
  - conj
```
public IComplexNDArray conj()
```
    Compute complex conj.
    
    Specified by:
    
    conj in interface IComplexNDArray
  - getReal
```
public INDArray getReal()
```
    Description copied from interface: IComplexNDArray
    
    Gets the real portion of this complex ndarray
    
    Specified by:
    
    getReal in interface IComplexNDArray
    
    Returns:
    
    the real portion of this complex ndarray
  - getImag
```
public double getImag(int i)
```
    Description copied from interface: IComplexNDArray
    
    Get the imaginary component at the specified index
    
    Specified by:
    
    getImag in interface IComplexNDArray
    
    Returns:
  - getReal
```
public double getReal(int i)
```
    Description copied from interface: IComplexNDArray
    
    Get the real component at the specified index
    
    Specified by:
    
    getReal in interface IComplexNDArray
    
    Returns:
  - putReal
```
public IComplexNDArray putReal(int rowIndex,
                               int columnIndex,
                               double value)
```
    Specified by:
    
    putReal in interface IComplexNDArray
    
    Returns:
  - putImag
```
public IComplexNDArray putImag(int rowIndex,
                               int columnIndex,
                               double value)
```
    Specified by:
    
    putImag in interface IComplexNDArray
    
    Returns:
  - putReal
```
public IComplexNDArray putReal(int i,
                               float v)
```
    Specified by:
    
    putReal in interface IComplexNDArray
    
    Returns:
  - putImag
```
public IComplexNDArray putImag(int i,
                               float v)
```
    Specified by:
    
    putImag in interface IComplexNDArray
    
    Returns:
  - getComplex
```
public IComplexNumber getComplex(int i)
```
    Specified by:
    
    getComplex in interface IComplexNDArray
    
    Returns:
  - getComplex
```
public IComplexNumber getComplex(int i,
                                 int j)
```
    Specified by:
    
    getComplex in interface IComplexNDArray
    
    Returns:
  - getComplex
```
public IComplexNumber getComplex(int... indices)
```
    Description copied from interface: IComplexNDArray
    
    Get the complex number at the given indices
    
    Specified by:
    
    getComplex in interface IComplexNDArray
    
    Parameters:
    
    indices - the indices to get the complex number at
    
    Returns:
    
    the complex number at the given indices
  - real
```
public INDArray real()
```
    Get realComponent part of the matrix.
    
    Specified by:
    
    real in interface IComplexNDArray
    
    Returns:
  - imag
```
public INDArray imag()
```
    Get imaginary part of the matrix.
    
    Specified by:
    
    imag in interface IComplexNDArray
    
    Returns:
  - put
```
public IComplexNDArray put(int i,
                           IComplexNDArray element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface IComplexNDArray
    
    Parameters:
    
    i - the index insert into
    
    element - a scalar ndarray
    
    Returns:
    
    a scalar ndarray of the element at this index
  - getScalar
```
public IComplexNDArray getScalar(int... indexes)
```
    Fetch a particular number on a multi dimensional scale.
    
    Specified by:
    
    getScalar in interface IComplexNDArray
    
    Specified by:
    
    getScalar in interface INDArray
    
    Overrides:
    
    getScalar in class BaseNDArray
    
    Parameters:
    
    indexes - the indexes to getFromOrigin a number from
    
    Returns:
    
    the number at the specified indices
  - checkDimensions
```
public void checkDimensions(INDArray other)
```
    Validate dimensions are equal
    
    Specified by:
    
    checkDimensions in interface IComplexNDArray
    
    Specified by:
    
    checkDimensions in interface INDArray
    
    Overrides:
    
    checkDimensions in class BaseNDArray
    
    Parameters:
    
    other - the other ndarray to compare
  - putSlice
```
public IComplexNDArray putSlice(int slice,
                                INDArray put)
```
    Assigns the given matrix (put) to the specified slice
    
    Specified by:
    
    putSlice in interface IComplexNDArray
    
    Specified by:
    
    putSlice in interface INDArray
    
    Overrides:
    
    putSlice in class BaseNDArray
    
    Parameters:
    
    slice - the slice to assign
    
    put - the slice to put
    
    Returns:
    
    this for chainability
  - subArray
```
public IComplexNDArray subArray(int[] offsets,
                                int[] shape,
                                int[] stride)
```
    Specified by:
    
    subArray in interface INDArray
    
    Overrides:
    
    subArray in class BaseNDArray
    
    Returns:
  - put
```
public IComplexNDArray put(int[] indices,
                           INDArray element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface IComplexNDArray
    
    Specified by:
    
    put in interface INDArray
    
    Overrides:
    
    put in class BaseNDArray
    
    Parameters:
    
    indices - the indices to insert into
    
    element - a scalar ndarray
    
    Returns:
    
    a scalar ndarray of the element at this index
  - put
```
public IComplexNDArray put(int i,
                           int j,
                           INDArray element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface IComplexNDArray
    
    Specified by:
    
    put in interface INDArray
    
    Overrides:
    
    put in class BaseNDArray
    
    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
  - create
```
protected IComplexNDArray create(BaseNDArray baseNDArray)
```
    Overrides:
    
    create in class BaseNDArray
  - createScalar
```
protected IComplexNDArray createScalar(double d)
```
    Overrides:
    
    createScalar in class BaseNDArray
  - createScalarForIndex
```
protected INDArray createScalarForIndex(int i,
                                        boolean applyOffset)
```
    Overrides:
    
    createScalarForIndex in class BaseNDArray
  - slice
```
public IComplexNDArray slice(int slice)
```
    Returns the specified slice of this matrix. In matlab, this would be equivalent to (given a 2 x 2 x 2): A(:,:,x) where x is the slice you want to return.
    The slice is always relative to the final dimension of the matrix.
    
    Specified by:
    
    slice in interface IComplexNDArray
    
    Specified by:
    
    slice in interface INDArray
    
    Overrides:
    
    slice in class BaseNDArray
    
    Parameters:
    
    slice - the slice to return
    
    Returns:
    
    the specified slice of this matrix
  - elementStride
```
public int elementStride()
```
    Description copied from interface: INDArray
    
    Element stride (one element to the next, also called the defualt stride: 1 for normal 2 for complex)
    
    Specified by:
    
    elementStride in interface INDArray
    
    Overrides:
    
    elementStride in class BaseNDArray
    
    Returns:
  - create
```
protected IComplexNDArray create(int[] shape)
```
    Overrides:
    
    create in class BaseNDArray
  - create
```
protected IComplexNDArray create(int[] shape,
                                 int[] strides,
                                 int offset)
```
    Overrides:
    
    create in class BaseNDArray
  - getStrides
```
protected int[] getStrides(int[] shape,
                           char ordering)
```
    Overrides:
    
    getStrides in class BaseNDArray
  - create
```
protected IComplexNDArray create(DataBuffer data,
                                 int[] newShape,
                                 int[] newStrides,
                                 int offset,
                                 char ordering)
```
    Overrides:
    
    create in class BaseNDArray
  - slice
```
public IComplexNDArray slice(int slice,
                             int dimension)
```
    Returns the slice of this from the specified dimension
    
    Specified by:
    
    slice in interface IComplexNDArray
    
    Specified by:
    
    slice in interface INDArray
    
    Overrides:
    
    slice in class BaseNDArray
    
    Parameters:
    
    slice - the dimension to return from
    
    dimension - the dimension of the slice to return
    
    Returns:
    
    the slice of this matrix from the specified dimension and dimension
  - newShape
```
protected IComplexNDArray newShape(int[] newShape,
                                   char ordering)
```
    Overrides:
    
    newShape in class BaseNDArray
  - create
```
protected IComplexNDArray create(DataBuffer data,
                                 int[] newShape,
                                 int[] newStrides,
                                 int offset)
```
    Overrides:
    
    create in class BaseNDArray
  - repmat
```
public IComplexNDArray repmat(int[] shape)
```
    Replicate and tile array to fill out to the given shape
    
    Specified by:
    
    repmat in interface IComplexNDArray
    
    Specified by:
    
    repmat in interface INDArray
    
    Overrides:
    
    repmat in class BaseNDArray
    
    Parameters:
    
    shape - the new shape of this ndarray
    
    Returns:
    
    the shape to fill out to
  - assign
```
public IComplexNDArray assign(IComplexNDArray arr)
```
    Assign all of the elements in the given ndarray to this ndarray
    
    Specified by:
    
    assign in interface IComplexNDArray
    
    Parameters:
    
    arr - the elements to assign
    
    Returns:
    
    this
  - assign
```
public void assign(IComplexNumber aDouble)
```
    Specified by:
    
    assign in interface IComplexNDArray
  - getRows
```
public IComplexNDArray getRows(int[] rindices)
```
    Get whole rows from the passed indices.
    
    Specified by:
    
    getRows in interface IComplexNDArray
    
    Specified by:
    
    getRows in interface INDArray
    
    Overrides:
    
    getRows in class BaseNDArray
    
    Parameters:
    
    rindices -
    
    Returns:
  - put
```
public IComplexNDArray put(INDArrayIndex[] indices,
                           IComplexNumber element)
```
    Specified by:
    
    put in interface IComplexNDArray
    
    Returns:
  - put
```
public IComplexNDArray put(INDArrayIndex[] indices,
                           IComplexNDArray element)
```
    Specified by:
    
    put in interface IComplexNDArray
    
    Returns:
  - create
```
protected INDArray create(int[] shape,
                          char ordering)
```
    Overrides:
    
    create in class BaseNDArray
  - put
```
public 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 IComplexNDArray
    
    Specified by:
    
    put in interface INDArray
    
    Overrides:
    
    put in class BaseNDArray
    
    Parameters:
    
    indices - the indices to put the ndarray in to
    
    element - the ndarray to put
    
    Returns:
    
    this ndarray
  - putScalar
```
public IComplexNDArray putScalar(int i,
                                 IComplexNumber value)
```
    Specified by:
    
    putScalar in interface IComplexNDArray
    
    Returns:
  - create
```
protected IComplexNDArray create(DataBuffer buffer)
```
    Overrides:
    
    create in class BaseNDArray
  - create
```
protected IComplexNDArray create(int rows,
                                 int length)
```
    Overrides:
    
    create in class BaseNDArray
  - create
```
protected IComplexNDArray create(DataBuffer data,
                                 int[] shape,
                                 int offset)
```
    Overrides:
    
    create in class BaseNDArray
  - create
```
protected IComplexNDArray create(INDArray baseNDArray)
```
  - vectorAlongDimension
```
public IComplexNDArray vectorAlongDimension(int index,
                                            int dimension)
```
    Get the vector along a particular dimension
    
    Specified by:
    
    vectorAlongDimension in interface IComplexNDArray
    
    Specified by:
    
    vectorAlongDimension in interface INDArray
    
    Overrides:
    
    vectorAlongDimension in class BaseNDArray
    
    Parameters:
    
    index - the index of the vector to get
    
    dimension - the dimension to getScalar the vector from
    
    Returns:
    
    the vector along a particular dimension
  - cumsumi
```
public IComplexNDArray cumsumi(int dimension)
```
    Cumulative sum along a dimension
    
    Specified by:
    
    cumsumi in interface IComplexNDArray
    
    Specified by:
    
    cumsumi in interface INDArray
    
    Overrides:
    
    cumsumi in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to perform cumulative sum along
    
    Returns:
    
    the cumulative sum along the specified dimension
  - dimShuffle
```
public IComplexNDArray dimShuffle(Object[] rearrange,
                                  int[] newOrder,
                                  boolean[] broadCastable)
```
    Dimshuffle: an extension of permute that adds the ability to broadcast various dimensions.
    See theano for more examples. This will only accept integers and xs.
    An x indicates a dimension should be broadcasted rather than permuted.
    
    Specified by:
    
    dimShuffle in interface IComplexNDArray
    
    Specified by:
    
    dimShuffle in interface INDArray
    
    Overrides:
    
    dimShuffle in class BaseNDArray
    
    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
  - cumsum
```
public IComplexNDArray cumsum(int dimension)
```
    Cumulative sum along a dimension (in place)
    
    Specified by:
    
    cumsum in interface IComplexNDArray
    
    Specified by:
    
    cumsum in interface INDArray
    
    Overrides:
    
    cumsum in class BaseNDArray
    
    Parameters:
    
    dimension - the dimension to perform cumulative sum along
    
    Returns:
    
    the cumulative sum along the specified dimension
  - assign
```
public INDArray assign(INDArray arr)
```
    Assign all of the elements in the given ndarray to this nedarray
    
    Specified by:
    
    assign in interface INDArray
    
    Overrides:
    
    assign in class BaseNDArray
    
    Parameters:
    
    arr - the elements to assign
    
    Returns:
    
    this
  - putScalar
```
public IComplexNDArray putScalar(int i,
                                 double value)
```
    Description copied from interface: INDArray
    
    Insert the number linearly in to the ndarray
    
    Specified by:
    
    putScalar in interface IComplexNDArray
    
    Specified by:
    
    putScalar in interface INDArray
    
    Overrides:
    
    putScalar in class BaseNDArray
    
    Parameters:
    
    i - the index to insert into
    
    value - the value to insert
    
    Returns:
    
    this
  - putScalar
```
public INDArray putScalar(int[] i,
                          double value)
```
    Description copied from interface: INDArray
    
    Insert the item at the specified indices
    
    Specified by:
    
    putScalar in interface INDArray
    
    Overrides:
    
    putScalar in class BaseNDArray
    
    Parameters:
    
    i - the indices to insert at
    
    value - the number to insert
    
    Returns:
    
    this
  - putScalar
```
public IComplexNDArray putScalar(int[] indexes,
                                 IComplexNumber complexNumber)
```
    Specified by:
    
    putScalar in interface IComplexNDArray
  - neg
```
public IComplexNDArray neg()
```
    Negate each element.
    
    Specified by:
    
    neg in interface IComplexNDArray
    
    Specified by:
    
    neg in interface INDArray
    
    Overrides:
    
    neg in class BaseNDArray
    
    Returns:
  - negi
```
public IComplexNDArray negi()
```
    Negate each element (in-place).
    
    Specified by:
    
    negi in interface IComplexNDArray
    
    Specified by:
    
    negi in interface INDArray
    
    Overrides:
    
    negi in class BaseNDArray
    
    Returns:
  - rdiv
```
public IComplexNDArray rdiv(Number n)
```
    Description copied from interface: INDArray
    
    Reverse division
    
    Specified by:
    
    rdiv in interface IComplexNDArray
    
    Specified by:
    
    rdiv in interface INDArray
    
    Overrides:
    
    rdiv in class BaseNDArray
    
    Returns:
  - rdivi
```
public IComplexNDArray rdivi(Number n)
```
    Description copied from interface: INDArray
    
    In place reverse division
    
    Specified by:
    
    rdivi in interface IComplexNDArray
    
    Specified by:
    
    rdivi in interface INDArray
    
    Overrides:
    
    rdivi in class BaseNDArray
    
    Returns:
  - rsub
```
public IComplexNDArray rsub(Number n)
```
    Description copied from interface: INDArray
    
    Reverse subtraction with duplicates
    
    Specified by:
    
    rsub in interface IComplexNDArray
    
    Specified by:
    
    rsub in interface INDArray
    
    Overrides:
    
    rsub in class BaseNDArray
    
    Returns:
  - rsubi
```
public IComplexNDArray rsubi(Number n)
```
    Specified by:
    
    rsubi in interface IComplexNDArray
    
    Specified by:
    
    rsubi in interface INDArray
    
    Overrides:
    
    rsubi in class BaseNDArray
    
    Returns:
  - div
```
public IComplexNDArray div(Number n)
```
    Description copied from interface: INDArray
    
    Division by a number
    
    Specified by:
    
    div in interface IComplexNDArray
    
    Specified by:
    
    div in interface INDArray
    
    Overrides:
    
    div in class BaseNDArray
    
    Returns:
  - divi
```
public IComplexNDArray divi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar division
    
    Specified by:
    
    divi in interface IComplexNDArray
    
    Specified by:
    
    divi in interface INDArray
    
    Overrides:
    
    divi in class BaseNDArray
    
    Returns:
  - mul
```
public IComplexNDArray mul(Number n)
```
    Description copied from interface: INDArray
    
    Scalar multiplication (copy)
    
    Specified by:
    
    mul in interface IComplexNDArray
    
    Specified by:
    
    mul in interface INDArray
    
    Overrides:
    
    mul in class BaseNDArray
    
    Parameters:
    
    n - the number to multiply by
    
    Returns:
    
    a copy of this ndarray multiplied by the given number
  - muli
```
public IComplexNDArray muli(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar multiplication
    
    Specified by:
    
    muli in interface IComplexNDArray
    
    Specified by:
    
    muli in interface INDArray
    
    Overrides:
    
    muli in class BaseNDArray
    
    Returns:
  - sub
```
public IComplexNDArray sub(Number n)
```
    Description copied from interface: INDArray
    
    Scalar subtraction (copied)
    
    Specified by:
    
    sub in interface IComplexNDArray
    
    Specified by:
    
    sub in interface INDArray
    
    Overrides:
    
    sub in class BaseNDArray
    
    Parameters:
    
    n - the number to subtract by
    
    Returns:
    
    this ndarray - the given number
  - subi
```
public IComplexNDArray subi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar subtraction
    
    Specified by:
    
    subi in interface IComplexNDArray
    
    Specified by:
    
    subi in interface INDArray
    
    Overrides:
    
    subi in class BaseNDArray
    
    Returns:
  - add
```
public IComplexNDArray add(Number n)
```
    Description copied from interface: INDArray
    
    Scalar addition (cloning)
    
    Specified by:
    
    add in interface IComplexNDArray
    
    Specified by:
    
    add in interface INDArray
    
    Overrides:
    
    add in class BaseNDArray
    
    Parameters:
    
    n - the number to add
    
    Returns:
    
    a clone with this matrix + the given number
  - addi
```
public IComplexNDArray addi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar addition
    
    Specified by:
    
    addi in interface IComplexNDArray
    
    Specified by:
    
    addi in interface INDArray
    
    Overrides:
    
    addi in class BaseNDArray
    
    Returns:
  - get
```
public IComplexNDArray get(INDArrayIndex... indexes)
```
    Returns a subset of this array based on the specified indexes
    
    Specified by:
    
    get in interface IComplexNDArray
    
    Specified by:
    
    get in interface INDArray
    
    Overrides:
    
    get in class BaseNDArray
    
    Parameters:
    
    indexes - the indexes in to the array
    
    Returns:
    
    a view of the array with the specified indices
  - cond
```
public IComplexNDArray cond(Condition condition)
```
    Description copied from interface: INDArray
    
    1 in the ndarray if the element matches the condition 0 otherwise
    
    Specified by:
    
    cond in interface IComplexNDArray
    
    Specified by:
    
    cond in interface INDArray
    
    Overrides:
    
    cond in class BaseNDArray
    
    Parameters:
    
    condition - the condition to be fulfilled
    
    Returns:
  - condi
```
public IComplexNDArray condi(Condition condition)
```
    Description copied from interface: INDArray
    
    1 in the ndarray if the element matches the condition 0 otherwise
    
    Specified by:
    
    condi in interface IComplexNDArray
    
    Specified by:
    
    condi in interface INDArray
    
    Overrides:
    
    condi in class BaseNDArray
    
    Parameters:
    
    condition - the condition to be fulfilled
    
    Returns:
  - getColumns
```
public IComplexNDArray getColumns(int[] cindices)
```
    Get whole columns from the passed indices.
    
    Specified by:
    
    getColumns in interface IComplexNDArray
    
    Specified by:
    
    getColumns in interface INDArray
    
    Overrides:
    
    getColumns in class BaseNDArray
    
    Parameters:
    
    cindices -
    
    Returns:
  - putRow
```
public 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 IComplexNDArray
    
    Specified by:
    
    putRow in interface INDArray
    
    Overrides:
    
    putRow in class BaseNDArray
    
    Parameters:
    
    row - the row insert into
    
    toPut - the row to insert
    
    Returns:
    
    this
  - putColumn
```
public 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 IComplexNDArray
    
    Specified by:
    
    putColumn in interface INDArray
    
    Overrides:
    
    putColumn in class BaseNDArray
    
    Parameters:
    
    column - the column to insert
    
    toPut - the array to put
    
    Returns:
    
    this
  - getScalar
```
public 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 IComplexNDArray
    
    Specified by:
    
    getScalar in interface INDArray
    
    Overrides:
    
    getScalar in class BaseNDArray
    
    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
```
public IComplexNDArray getScalar(int i)
```
    Returns the element at the specified index
    
    Specified by:
    
    getScalar in interface IComplexNDArray
    
    Specified by:
    
    getScalar in interface INDArray
    
    Overrides:
    
    getScalar in class BaseNDArray
    
    Parameters:
    
    i - the index of the element to return
    
    Returns:
    
    a scalar ndarray of the element at this index
  - put
```
public IComplexNDArray put(int i,
                           INDArray element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface IComplexNDArray
    
    Specified by:
    
    put in interface INDArray
    
    Overrides:
    
    put in class BaseNDArray
    
    Parameters:
    
    i - the index insert into
    
    element - a scalar ndarray
    
    Returns:
    
    a scalar ndarray of the element at this index
  - put
```
public void put(int i,
                IComplexNumber element)
```
  - diviColumnVector
```
public IComplexNDArray diviColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    diviColumnVector in interface IComplexNDArray
    
    Specified by:
    
    diviColumnVector in interface INDArray
    
    Overrides:
    
    diviColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - divColumnVector
```
public IComplexNDArray divColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    divColumnVector in interface IComplexNDArray
    
    Specified by:
    
    divColumnVector in interface INDArray
    
    Overrides:
    
    divColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - diviRowVector
```
public IComplexNDArray diviRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    diviRowVector in interface IComplexNDArray
    
    Specified by:
    
    diviRowVector in interface INDArray
    
    Overrides:
    
    diviRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - divRowVector
```
public IComplexNDArray divRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    divRowVector in interface IComplexNDArray
    
    Specified by:
    
    divRowVector in interface INDArray
    
    Overrides:
    
    divRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - muliColumnVector
```
public IComplexNDArray muliColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    muliColumnVector in interface IComplexNDArray
    
    Specified by:
    
    muliColumnVector in interface INDArray
    
    Overrides:
    
    muliColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - mulColumnVector
```
public IComplexNDArray mulColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    mulColumnVector in interface IComplexNDArray
    
    Specified by:
    
    mulColumnVector in interface INDArray
    
    Overrides:
    
    mulColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - muliRowVector
```
public IComplexNDArray muliRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    muliRowVector in interface IComplexNDArray
    
    Specified by:
    
    muliRowVector in interface INDArray
    
    Overrides:
    
    muliRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - mulRowVector
```
public IComplexNDArray mulRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    mulRowVector in interface IComplexNDArray
    
    Specified by:
    
    mulRowVector in interface INDArray
    
    Overrides:
    
    mulRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - subiColumnVector
```
public IComplexNDArray subiColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subiColumnVector in interface IComplexNDArray
    
    Specified by:
    
    subiColumnVector in interface INDArray
    
    Overrides:
    
    subiColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - subColumnVector
```
public IComplexNDArray subColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subColumnVector in interface IComplexNDArray
    
    Specified by:
    
    subColumnVector in interface INDArray
    
    Overrides:
    
    subColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - subiRowVector
```
public IComplexNDArray subiRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subiRowVector in interface IComplexNDArray
    
    Specified by:
    
    subiRowVector in interface INDArray
    
    Overrides:
    
    subiRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - subRowVector
```
public IComplexNDArray subRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subRowVector in interface IComplexNDArray
    
    Specified by:
    
    subRowVector in interface INDArray
    
    Overrides:
    
    subRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - addiColumnVector
```
public IComplexNDArray addiColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addiColumnVector in interface IComplexNDArray
    
    Specified by:
    
    addiColumnVector in interface INDArray
    
    Overrides:
    
    addiColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - addColumnVector
```
public IComplexNDArray addColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addColumnVector in interface IComplexNDArray
    
    Specified by:
    
    addColumnVector in interface INDArray
    
    Overrides:
    
    addColumnVector in class BaseNDArray
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - addiRowVector
```
public IComplexNDArray addiRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addiRowVector in interface IComplexNDArray
    
    Specified by:
    
    addiRowVector in interface INDArray
    
    Overrides:
    
    addiRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - addRowVector
```
public IComplexNDArray addRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addRowVector in interface IComplexNDArray
    
    Specified by:
    
    addRowVector in interface INDArray
    
    Overrides:
    
    addRowVector in class BaseNDArray
    
    Parameters:
    
    rowVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - mmul
```
public IComplexNDArray mmul(INDArray other)
```
    Perform a copy matrix multiplication
    
    Specified by:
    
    mmul in interface IComplexNDArray
    
    Specified by:
    
    mmul in interface INDArray
    
    Overrides:
    
    mmul in class BaseNDArray
    
    Parameters:
    
    other - the other matrix to perform matrix multiply with
    
    Returns:
    
    the result of the matrix multiplication
  - mmul
```
public IComplexNDArray mmul(INDArray other,
                            INDArray result)
```
    Perform an copy matrix multiplication
    
    Specified by:
    
    mmul in interface IComplexNDArray
    
    Specified by:
    
    mmul in interface INDArray
    
    Overrides:
    
    mmul in class BaseNDArray
    
    Parameters:
    
    other - the other matrix to perform matrix multiply with
    
    result - the result ndarray
    
    Returns:
    
    the result of the matrix multiplication
  - div
```
public IComplexNDArray div(INDArray other)
```
    in place (element wise) division of two matrices
    
    Specified by:
    
    div in interface IComplexNDArray
    
    Specified by:
    
    div in interface INDArray
    
    Overrides:
    
    div in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to divide
    
    Returns:
    
    the result of the divide
  - div
```
public IComplexNDArray div(INDArray other,
                           INDArray result)
```
    copy (element wise) division of two matrices
    
    Specified by:
    
    div in interface IComplexNDArray
    
    Specified by:
    
    div in interface INDArray
    
    Overrides:
    
    div in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to divide
    
    result - the result ndarray
    
    Returns:
    
    the result of the divide
  - mul
```
public IComplexNDArray mul(INDArray other)
```
    copy (element wise) multiplication of two matrices
    
    Specified by:
    
    mul in interface IComplexNDArray
    
    Specified by:
    
    mul in interface INDArray
    
    Overrides:
    
    mul in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to multiply
    
    Returns:
    
    the result of the addition
  - mul
```
public IComplexNDArray mul(INDArray other,
                           INDArray result)
```
    copy (element wise) multiplication of two matrices
    
    Specified by:
    
    mul in interface IComplexNDArray
    
    Specified by:
    
    mul in interface INDArray
    
    Overrides:
    
    mul in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to multiply
    
    result - the result ndarray
    
    Returns:
    
    the result of the multiplication
  - sub
```
public IComplexNDArray sub(INDArray other)
```
    copy subtraction of two matrices
    
    Specified by:
    
    sub in interface IComplexNDArray
    
    Specified by:
    
    sub in interface INDArray
    
    Overrides:
    
    sub in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to subtract
    
    Returns:
    
    the result of the addition
  - sub
```
public IComplexNDArray sub(INDArray other,
                           INDArray result)
```
    copy subtraction of two matrices
    
    Specified by:
    
    sub in interface IComplexNDArray
    
    Specified by:
    
    sub in interface INDArray
    
    Overrides:
    
    sub in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to subtract
    
    result - the result ndarray
    
    Returns:
    
    the result of the subtraction
  - add
```
public IComplexNDArray add(INDArray other)
```
    copy addition of two matrices
    
    Specified by:
    
    add in interface IComplexNDArray
    
    Specified by:
    
    add in interface INDArray
    
    Overrides:
    
    add in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to add
    
    Returns:
    
    the result of the addition
  - add
```
public IComplexNDArray add(INDArray other,
                           INDArray result)
```
    copy addition of two matrices
    
    Specified by:
    
    add in interface IComplexNDArray
    
    Specified by:
    
    add in interface INDArray
    
    Overrides:
    
    add in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to add
    
    result - the result ndarray
    
    Returns:
    
    the result of the addition
  - mmuli
```
public IComplexNDArray mmuli(INDArray other)
```
    Perform an copy matrix multiplication
    
    Specified by:
    
    mmuli in interface IComplexNDArray
    
    Specified by:
    
    mmuli in interface INDArray
    
    Overrides:
    
    mmuli in class BaseNDArray
    
    Parameters:
    
    other - the other matrix to perform matrix multiply with
    
    Returns:
    
    the result of the matrix multiplication
  - mmuli
```
public IComplexNDArray mmuli(INDArray other,
                             INDArray result)
```
    Perform an copy matrix multiplication
    
    Specified by:
    
    mmuli in interface IComplexNDArray
    
    Specified by:
    
    mmuli in interface INDArray
    
    Overrides:
    
    mmuli in class BaseNDArray
    
    Parameters:
    
    other - the other matrix to perform matrix multiply with
    
    result - the result ndarray
    
    Returns:
    
    the result of the matrix multiplication
  - secondaryStride
```
public int secondaryStride()
```
    Description copied from interface: INDArray
    
    Return the second stride for an ndarray. Think of this as the stride for the next element in a column.
    
    Specified by:
    
    secondaryStride in interface INDArray
    
    Overrides:
    
    secondaryStride in class BaseNDArray
    
    Returns:
    
    the secondary stride for an ndarray
  - divi
```
public IComplexNDArray divi(INDArray other)
```
    in place (element wise) division of two matrices
    
    Specified by:
    
    divi in interface IComplexNDArray
    
    Specified by:
    
    divi in interface INDArray
    
    Overrides:
    
    divi in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to divide
    
    Returns:
    
    the result of the divide
  - divi
```
public IComplexNDArray divi(INDArray other,
                            INDArray result)
```
    in place (element wise) division of two matrices
    
    Specified by:
    
    divi in interface IComplexNDArray
    
    Specified by:
    
    divi in interface INDArray
    
    Overrides:
    
    divi in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to divide
    
    result - the result ndarray
    
    Returns:
    
    the result of the divide
  - muli
```
public IComplexNDArray muli(INDArray other)
```
    in place (element wise) multiplication of two matrices
    
    Specified by:
    
    muli in interface IComplexNDArray
    
    Specified by:
    
    muli in interface INDArray
    
    Overrides:
    
    muli in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to multiply
    
    Returns:
    
    the result of the addition
  - muli
```
public IComplexNDArray muli(INDArray other,
                            INDArray result)
```
    in place (element wise) multiplication of two matrices
    
    Specified by:
    
    muli in interface IComplexNDArray
    
    Specified by:
    
    muli in interface INDArray
    
    Overrides:
    
    muli in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to multiply
    
    result - the result ndarray
    
    Returns:
    
    the result of the multiplication
  - subi
```
public IComplexNDArray subi(INDArray other)
```
    in place subtraction of two matrices
    
    Specified by:
    
    subi in interface IComplexNDArray
    
    Specified by:
    
    subi in interface INDArray
    
    Overrides:
    
    subi in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to subtract
    
    Returns:
    
    the result of the addition
  - subi
```
public IComplexNDArray subi(INDArray other,
                            INDArray result)
```
    in place subtraction of two matrices
    
    Specified by:
    
    subi in interface IComplexNDArray
    
    Specified by:
    
    subi in interface INDArray
    
    Overrides:
    
    subi in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to subtract
    
    result - the result ndarray
    
    Returns:
    
    the result of the subtraction
  - addi
```
public IComplexNDArray addi(INDArray other)
```
    in place addition of two matrices
    
    Specified by:
    
    addi in interface IComplexNDArray
    
    Specified by:
    
    addi in interface INDArray
    
    Overrides:
    
    addi in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to add
    
    Returns:
    
    the result of the addition
  - addi
```
public IComplexNDArray addi(INDArray other,
                            INDArray result)
```
    in place addition of two matrices
    
    Specified by:
    
    addi in interface IComplexNDArray
    
    Specified by:
    
    addi in interface INDArray
    
    Overrides:
    
    addi in class BaseNDArray
    
    Parameters:
    
    other - the second ndarray to add
    
    result - the result ndarray
    
    Returns:
    
    the result of the addition
  - rdiv
```
public IComplexNDArray rdiv(IComplexNumber n,
                            INDArray result)
```
    Specified by:
    
    rdiv in interface IComplexNDArray
    
    Returns:
  - rdivi
```
public IComplexNDArray rdivi(IComplexNumber n,
                             INDArray result)
```
    Specified by:
    
    rdivi in interface IComplexNDArray
  - rsub
```
public IComplexNDArray rsub(IComplexNumber n,
                            INDArray result)
```
    Specified by:
    
    rsub in interface IComplexNDArray
  - rsubi
```
public IComplexNDArray rsubi(IComplexNumber n,
                             INDArray result)
```
    Specified by:
    
    rsubi in interface IComplexNDArray
  - div
```
public IComplexNDArray div(IComplexNumber n,
                           INDArray result)
```
    Specified by:
    
    div in interface IComplexNDArray
  - divi
```
public IComplexNDArray divi(IComplexNumber n,
                            INDArray result)
```
    Specified by:
    
    divi in interface IComplexNDArray
  - mul
```
public IComplexNDArray mul(IComplexNumber n,
                           INDArray result)
```
    Specified by:
    
    mul in interface IComplexNDArray
  - muli
```
public IComplexNDArray muli(IComplexNumber n,
                            INDArray result)
```
    Specified by:
    
    muli in interface IComplexNDArray
  - sub
```
public IComplexNDArray sub(IComplexNumber n,
                           INDArray result)
```
    Specified by:
    
    sub in interface IComplexNDArray
  - subi
```
public IComplexNDArray subi(IComplexNumber n,
                            INDArray result)
```
    Specified by:
    
    subi in interface IComplexNDArray
  - add
```
public IComplexNDArray add(IComplexNumber n,
                           INDArray result)
```
    Specified by:
    
    add in interface IComplexNDArray
  - addi
```
public IComplexNDArray addi(IComplexNumber n,
                            INDArray result)
```
    Specified by:
    
    addi in interface IComplexNDArray
  - rdiv
```
public IComplexNDArray rdiv(IComplexNumber n)
```
    Specified by:
    
    rdiv in interface IComplexNDArray
    
    Specified by:
    
    rdiv in interface INDArray
    
    Overrides:
    
    rdiv in class BaseNDArray
    
    Returns:
  - rdivi
```
public IComplexNDArray rdivi(IComplexNumber n)
```
    Specified by:
    
    rdivi in interface IComplexNDArray
    
    Specified by:
    
    rdivi in interface INDArray
    
    Overrides:
    
    rdivi in class BaseNDArray
    
    Returns:
  - rsub
```
public IComplexNDArray rsub(IComplexNumber n)
```
    Specified by:
    
    rsub in interface IComplexNDArray
    
    Specified by:
    
    rsub in interface INDArray
    
    Overrides:
    
    rsub in class BaseNDArray
    
    Returns:
  - rsubi
```
public IComplexNDArray rsubi(IComplexNumber n)
```
    Specified by:
    
    rsubi in interface IComplexNDArray
    
    Specified by:
    
    rsubi in interface INDArray
    
    Overrides:
    
    rsubi in class BaseNDArray
    
    Returns:
  - div
```
public IComplexNDArray div(IComplexNumber n)
```
    Specified by:
    
    div in interface IComplexNDArray
    
    Specified by:
    
    div in interface INDArray
    
    Overrides:
    
    div in class BaseNDArray
    
    Returns:
  - divi
```
public IComplexNDArray divi(IComplexNumber n)
```
    Specified by:
    
    divi in interface IComplexNDArray
    
    Specified by:
    
    divi in interface INDArray
    
    Overrides:
    
    divi in class BaseNDArray
    
    Returns:
  - mul
```
public IComplexNDArray mul(IComplexNumber n)
```
    Specified by:
    
    mul in interface IComplexNDArray
    
    Specified by:
    
    mul in interface INDArray
    
    Overrides:
    
    mul in class BaseNDArray
    
    Returns:
  - muli
```
public IComplexNDArray muli(IComplexNumber n)
```
    Specified by:
    
    muli in interface IComplexNDArray
    
    Specified by:
    
    muli in interface INDArray
    
    Overrides:
    
    muli in class BaseNDArray
    
    Returns:
  - sub
```
public IComplexNDArray sub(IComplexNumber n)
```
    Specified by:
    
    sub in interface IComplexNDArray
    
    Specified by:
    
    sub in interface INDArray
    
    Overrides:
    
    sub in class BaseNDArray
    
    Returns:
  - subi
```
public IComplexNDArray subi(IComplexNumber n)
```
    Specified by:
    
    subi in interface IComplexNDArray
    
    Specified by:
    
    subi in interface INDArray
    
    Overrides:
    
    subi in class BaseNDArray
    
    Returns:
  - add
```
public IComplexNDArray add(IComplexNumber n)
```
    Specified by:
    
    add in interface IComplexNDArray
    
    Specified by:
    
    add in interface INDArray
    
    Overrides:
    
    add in class BaseNDArray
    
    Returns:
  - addi
```
public IComplexNDArray addi(IComplexNumber n)
```
    Specified by:
    
    addi in interface IComplexNDArray
    
    Specified by:
    
    addi in interface INDArray
    
    Overrides:
    
    addi in class BaseNDArray
    
    Returns:
  - putReal
```
public IComplexNDArray putReal(int rowIndex,
                               int columnIndex,
                               float value)
```
    Specified by:
    
    putReal in interface IComplexNDArray
    
    Returns:
  - putReal
```
public IComplexNDArray putReal(int[] indices,
                               float value)
```
    Specified by:
    
    putReal in interface IComplexNDArray
    
    Returns:
  - putImag
```
public IComplexNDArray putImag(int[] indices,
                               float value)
```
    Specified by:
    
    putImag in interface IComplexNDArray
    
    Returns:
  - putReal
```
public IComplexNDArray putReal(int[] indices,
                               double value)
```
    Specified by:
    
    putReal in interface IComplexNDArray
    
    Returns:
  - putImag
```
public IComplexNDArray putImag(int[] indices,
                               double value)
```
    Specified by:
    
    putImag in interface IComplexNDArray
    
    Returns:
  - putImag
```
public IComplexNDArray putImag(int rowIndex,
                               int columnIndex,
                               float value)
```
    Specified by:
    
    putImag in interface IComplexNDArray
    
    Returns:
  - put
```
public IComplexNDArray put(int[] indexes,
                           float value)
```
    Specified by:
    
    put in interface IComplexNDArray
  - neqi
```
public IComplexNDArray neqi(IComplexNumber other)
```
    Specified by:
    
    neqi in interface IComplexNDArray
  - neq
```
public IComplexNDArray neq(IComplexNumber other)
```
    Specified by:
    
    neq in interface IComplexNDArray
  - lt
```
public IComplexNDArray lt(IComplexNumber other)
```
    Specified by:
    
    lt in interface IComplexNDArray
  - lti
```
public IComplexNDArray lti(IComplexNumber other)
```
    Specified by:
    
    lti in interface IComplexNDArray
  - eq
```
public IComplexNDArray eq(IComplexNumber other)
```
    Specified by:
    
    eq in interface IComplexNDArray
  - eqi
```
public IComplexNDArray eqi(IComplexNumber other)
```
    Specified by:
    
    eqi in interface IComplexNDArray
  - gt
```
public IComplexNDArray gt(IComplexNumber other)
```
    Specified by:
    
    gt in interface IComplexNDArray
  - gti
```
public IComplexNDArray gti(IComplexNumber other)
```
    Specified by:
    
    gti in interface IComplexNDArray
  - transposei
```
public IComplexNDArray transposei()
```
    Return transposed copy of this matrix.
    
    Specified by:
    
    transposei in interface IComplexNDArray
    
    Specified by:
    
    transposei in interface INDArray
    
    Overrides:
    
    transposei in class BaseNDArray
    
    Returns:
    
    the flipped rows and columns of a matrix
  - transpose
```
public IComplexNDArray transpose()
```
    Return transposed copy of this matrix.
    
    Specified by:
    
    transpose in interface IComplexNDArray
    
    Specified by:
    
    transpose in interface INDArray
    
    Overrides:
    
    transpose in class BaseNDArray
    
    Returns:
    
    the flipped rows and columns of a matrix
  - addi
```
public IComplexNDArray addi(IComplexNumber n,
                            IComplexNDArray result)
```
    Specified by:
    
    addi in interface IComplexNDArray
    
    Specified by:
    
    addi in interface INDArray
    
    Overrides:
    
    addi in class BaseNDArray
    
    Returns:
  - subi
```
public IComplexNDArray subi(IComplexNumber n,
                            IComplexNDArray result)
```
    Specified by:
    
    subi in interface IComplexNDArray
    
    Specified by:
    
    subi in interface INDArray
    
    Overrides:
    
    subi in class BaseNDArray
    
    Returns:
  - muli
```
public IComplexNDArray muli(IComplexNumber n,
                            IComplexNDArray result)
```
    Specified by:
    
    muli in interface IComplexNDArray
    
    Specified by:
    
    muli in interface INDArray
    
    Overrides:
    
    muli in class BaseNDArray
    
    Returns:
  - divi
```
public IComplexNDArray divi(IComplexNumber n,
                            IComplexNDArray result)
```
    Specified by:
    
    divi in interface IComplexNDArray
    
    Specified by:
    
    divi in interface INDArray
    
    Overrides:
    
    divi in class BaseNDArray
    
    Returns:
  - rsubi
```
public IComplexNDArray rsubi(IComplexNumber n,
                             IComplexNDArray result)
```
    Specified by:
    
    rsubi in interface IComplexNDArray
    
    Specified by:
    
    rsubi in interface INDArray
    
    Overrides:
    
    rsubi in class BaseNDArray
    
    Returns:
  - rdivi
```
public IComplexNDArray rdivi(IComplexNumber n,
                             IComplexNDArray result)
```
    Specified by:
    
    rdivi in interface IComplexNDArray
    
    Specified by:
    
    rdivi in interface INDArray
    
    Overrides:
    
    rdivi in class BaseNDArray
    
    Returns:
  - reshape
```
public IComplexNDArray reshape(int... shape)
```
    Reshape the ndarray in to the specified dimensions, possible errors being thrown for invalid shapes
    
    Specified by:
    
    reshape in interface IComplexNDArray
    
    Specified by:
    
    reshape in interface INDArray
    
    Overrides:
    
    reshape in class BaseNDArray
    
    Parameters:
    
    shape -
    
    Returns:
  - reshape
```
public IComplexNDArray reshape(char order,
                               int... newShape)
```
    Description copied from interface: INDArray
    
    Reshapes the ndarray (can't change the length of the ndarray)
    
    Specified by:
    
    reshape in interface IComplexNDArray
    
    Specified by:
    
    reshape in interface INDArray
    
    Overrides:
    
    reshape in class BaseNDArray
    
    newShape - the new shape of the ndarray
    
    Returns:
    
    the reshaped ndarray
  - reshape
```
public IComplexNDArray reshape(char order,
                               int rows,
                               int columns)
```
    Description copied from interface: INDArray
    
    Reshapes the ndarray (can't change the length of the ndarray)
    
    Specified by:
    
    reshape in interface IComplexNDArray
    
    Specified by:
    
    reshape in interface INDArray
    
    Overrides:
    
    reshape in class BaseNDArray
    
    rows - the rows of the matrix
    
    columns - the columns of the matrix
    
    Returns:
    
    the reshaped ndarray
  - assign
```
public IComplexNDArray assign(Number value)
```
    Set the value of the ndarray to the specified value
    
    Specified by:
    
    assign in interface IComplexNDArray
    
    Specified by:
    
    assign in interface INDArray
    
    Overrides:
    
    assign in class BaseNDArray
    
    Parameters:
    
    value - the value to assign
    
    Returns:
    
    the ndarray with the values
  - rdiv
```
public IComplexNDArray rdiv(INDArray other)
```
    Reverse division
    
    Specified by:
    
    rdiv in interface IComplexNDArray
    
    Specified by:
    
    rdiv in interface INDArray
    
    Overrides:
    
    rdiv in class BaseNDArray
    
    Parameters:
    
    other - the matrix to divide from
    
    Returns:
  - rdivi
```
public IComplexNDArray rdivi(INDArray other)
```
    Reverse divsion (in place)
    
    Specified by:
    
    rdivi in interface IComplexNDArray
    
    Specified by:
    
    rdivi in interface INDArray
    
    Overrides:
    
    rdivi in class BaseNDArray
    
    Parameters:
    
    other -
    
    Returns:
  - rdiv
```
public IComplexNDArray rdiv(INDArray other,
                            INDArray result)
```
    Reverse division
    
    Specified by:
    
    rdiv in interface IComplexNDArray
    
    Specified by:
    
    rdiv in interface INDArray
    
    Overrides:
    
    rdiv in class BaseNDArray
    
    Parameters:
    
    other - the matrix to subtract from
    
    result - the result ndarray
    
    Returns:
  - rdivi
```
public IComplexNDArray rdivi(INDArray other,
                             INDArray result)
```
    Reverse division (in-place)
    
    Specified by:
    
    rdivi in interface IComplexNDArray
    
    Specified by:
    
    rdivi in interface INDArray
    
    Overrides:
    
    rdivi in class BaseNDArray
    
    Parameters:
    
    other - the other ndarray to subtract
    
    result - the result ndarray
    
    Returns:
    
    the ndarray with the operation applied
  - rsub
```
public IComplexNDArray rsub(INDArray other,
                            INDArray result)
```
    Reverse subtraction
    
    Specified by:
    
    rsub in interface IComplexNDArray
    
    Specified by:
    
    rsub in interface INDArray
    
    Overrides:
    
    rsub in class BaseNDArray
    
    Parameters:
    
    other - the matrix to subtract from
    
    result - the result ndarray
    
    Returns:
  - rsub
```
public IComplexNDArray rsub(INDArray other)
```
    Specified by:
    
    rsub in interface IComplexNDArray
    
    Specified by:
    
    rsub in interface INDArray
    
    Overrides:
    
    rsub in class BaseNDArray
    
    Parameters:
    
    other -
    
    Returns:
  - rsubi
```
public IComplexNDArray rsubi(INDArray other)
```
    Specified by:
    
    rsubi in interface IComplexNDArray
    
    Specified by:
    
    rsubi in interface INDArray
    
    Overrides:
    
    rsubi in class BaseNDArray
    
    Parameters:
    
    other -
    
    Returns:
  - rsubi
```
public IComplexNDArray rsubi(INDArray other,
                             INDArray result)
```
    Reverse subtraction (in-place)
    
    Specified by:
    
    rsubi in interface IComplexNDArray
    
    Specified by:
    
    rsubi in interface INDArray
    
    Overrides:
    
    rsubi in class BaseNDArray
    
    Parameters:
    
    other - the other ndarray to subtract
    
    result - the result ndarray
    
    Returns:
    
    the ndarray with the operation applied
  - max
```
public IComplexNumber max()
```
  - min
```
public IComplexNumber min()
```
  - reshape
```
public IComplexNDArray reshape(int newRows,
                               int newColumns)
```
    Reshape the matrix. Number of elements must not change.
    
    Specified by:
    
    reshape in interface IComplexNDArray
    
    Specified by:
    
    reshape in interface INDArray
    
    Overrides:
    
    reshape in class BaseNDArray
    
    Parameters:
    
    newRows -
    
    newColumns -
    
    Returns:
    
    the reshaped ndarray
  - getColumn
```
public IComplexNDArray getColumn(int c)
```
    Get the specified column
    
    Specified by:
    
    getColumn in interface IComplexNDArray
    
    Specified by:
    
    getColumn in interface INDArray
    
    Overrides:
    
    getColumn in class BaseNDArray
    
    Parameters:
    
    c -
    
    Returns:
    
    the specified column
  - getRow
```
public IComplexNDArray getRow(int r)
```
    Get a copy of a row.
    
    Specified by:
    
    getRow in interface IComplexNDArray
    
    Specified by:
    
    getRow in interface INDArray
    
    Overrides:
    
    getRow in class BaseNDArray
    
    Parameters:
    
    r -
    
    Returns:
    
    the specified row
  - equals
```
public boolean equals(Object o)
```
    Compare two matrices. Returns true if and only if other is also a ComplexDoubleMatrix which has the same size and the maximal absolute difference in matrix elements is smaller than 1e-6.
    
    Overrides:
    
    equals in class BaseNDArray
    
    Parameters:
    
    o -
  - broadcast
```
public IComplexNDArray broadcast(int[] shape)
```
    Broadcasts this ndarray to be the specified shape
    
    Specified by:
    
    broadcast in interface IComplexNDArray
    
    Specified by:
    
    broadcast in interface INDArray
    
    Overrides:
    
    broadcast in class BaseNDArray
    
    Parameters:
    
    shape - the new shape of this ndarray
    
    Returns:
    
    the broadcasted ndarray
  - element
```
public Object element()
```
    Returns a scalar (individual element) of a scalar ndarray
    
    Specified by:
    
    element in interface INDArray
    
    Overrides:
    
    element in class BaseNDArray
    
    Returns:
    
    the individual item in this ndarray
  - permute
```
public IComplexNDArray permute(int[] rearrange)
```
    See: http://www.mathworks.com/help/matlab/ref/permute.html
    
    Specified by:
    
    permute in interface IComplexNDArray
    
    Specified by:
    
    permute in interface INDArray
    
    Overrides:
    
    permute in class BaseNDArray
    
    Parameters:
    
    rearrange - the dimensions to swap to
    
    Returns:
    
    the newly permuted array
  - ravel
```
public IComplexNDArray ravel()
```
    Flattens the array for linear indexing
    
    Specified by:
    
    ravel in interface IComplexNDArray
    
    Specified by:
    
    ravel in interface INDArray
    
    Overrides:
    
    ravel in class BaseNDArray
    
    Returns:
    
    the flattened version of this array
  - toString
```
public String toString()
```
    Generate string representation of the matrix.
    
    Overrides:
    
    toString in class BaseNDArray

Class BaseComplexNDArray

Field Summary

Fields inherited from class org.nd4j.linalg.api.ndarray.BaseNDArray

Constructor Summary

Method Summary

Methods inherited from class org.nd4j.linalg.api.ndarray.BaseNDArray

Methods inherited from class java.lang.Object

Methods inherited from interface org.nd4j.linalg.api.complex.IComplexNDArray

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

Methods inherited from interface java.lang.Iterable

Constructor Detail

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

BaseComplexNDArray

Method Detail

copyFromReal

create

copyRealTo

copyImagTo

blasOffset

linearViewColumnOrder

linearView

resetLinearView

getComplex

getComplex

putScalar

eps

eps

epsi

epsi

eps

epsi

lt

lti

eq

eqi

gt

gti

lt

lti

eq