BaseComplexNDArray (nd4j-api 0.0.3.2 API)

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

All Implemented Interfaces:

Serializable, IComplexNDArray, INDArray
```
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
  columns, data, length, linearView, offset, ordering, rows, shape, stride

Constructor Summary

Constructors
Constructor and Description
`BaseComplexNDArray()`
`BaseComplexNDArray(float[] data)`
`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(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

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)`
`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
`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
`IComplexNDArray`	`broadcast(int[] shape)` Broadcasts this ndarray to be the specified shape
`void`	`checkDimensions(INDArray other)` Validate dimensions are equal
`IComplexNDArray`	`conj()` Compute complex conj.
`IComplexNDArray`	`conji()` Compute complex conj (in-place).
`protected void`	`copyFromReal(INDArray real)`
`protected void`	`copyRealTo(INDArray arr)`
`IComplexNDArray`	`cumsum(int dimension)` Cumulative sum along a dimension (in place)
`IComplexNDArray`	`cumsumi(int dimension)` Cumulative sum along a dimension
`float[]`	`data()` Returns a copy of all of the data in this array in order
`IComplexNDArray`	`dimShuffle(Object[] rearrange, int[] newOrder, boolean[] broadCastable)` Dimshuffle: an extension of permute that adds the ability to broadcast various dimensions.
`float`	`distance1(INDArray other)` Returns the (1-norm) distance.
`float`	`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)`
`IComplexNDArray`	`div(Number n, INDArray result)`
`IComplexNDArray`	`divColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`divi(IComplexNumber n)`
`IComplexNDArray`	`divi(IComplexNumber n, IComplexNDArray result)`
`IComplexNDArray`	`divi(IComplexNumber n, INDArray result)`
`IComplexNDArray`	`divi(INDArray other)` in place (element wise) division of two matrices
`IComplexNDArray`	`divi(INDArray other, INDArray result)` in place (element wise) division of two matrices
`IComplexNDArray`	`divi(Number n)` In place scalar division
`IComplexNDArray`	`divi(Number n, INDArray result)` In place division of this ndarray
`IComplexNDArray`	`diviColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`diviRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`divRowVector(INDArray rowVector)` In place addition of a column vector
`IComplexNDArray`	`dup()` Return a copy of this ndarray
`Object`	`element()` Returns a scalar (individual element) of a scalar ndarray
`int[]`	`endsForSlices()` Gives the indices for the ending of each slice
`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(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(NDArrayIndex... 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 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)`
`INDArray`	`getReal()` Gets the real portion of this complex ndarray
`double`	`getReal(int i)`
`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
`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)`
`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.
`protected void`	`initShape(int[] shape)`
`void`	`iterateOverDimension(int dimension, SliceOp op, boolean modify)` Iterate along a dimension.
`int`	`linearIndex(int i)` Get the linear index of the data in to the array
`IComplexNDArray`	`linearView()` Returns a linear view reference of shape 1,length(ndarray)
`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(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
`IComplexNDArray`	`mean(int dimension)` Returns the overall mean of this ndarray
`IComplexNumber`	`min()`
`IComplexNDArray`	`min(int dimension)` Returns the overall min of this ndarray
`IComplexNDArray`	`mmul(INDArray other)` Perform a copy matrix multiplication
`IComplexNDArray`	`mmul(INDArray other, INDArray result)` Perform an copy matrix multiplication
`IComplexNDArray`	`mmuli(INDArray other)` Perform an copy matrix multiplication
`IComplexNDArray`	`mmuli(INDArray other, INDArray result)` Perform an copy matrix multiplication
`IComplexNDArray`	`mul(IComplexNumber n)`
`IComplexNDArray`	`mul(IComplexNumber n, 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)`
`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
`boolean`	`multipliesWith(INDArray a)` Check whether this can be multiplied with a.
`IComplexNDArray`	`neg()` Negate each element.
`IComplexNDArray`	`negi()` Negate each element (in-place).
`protected IComplexNDArray`	`newShape(int[] newShape, char ordering)`
`IComplexNDArray`	`norm1(int dimension)` Returns the norm1 along the specified dimension
`IComplexNDArray`	`norm2(int dimension)` Returns the norm2 along the specified dimension
`IComplexNDArray`	`normmax(int dimension)` Returns the normmax along the specified dimension
`IComplexNDArray`	`permute(int[] rearrange)` See: http://www.mathworks.com/help/matlab/ref/permute.html
`IComplexNDArray`	`prod(int dimension)` Returns the product along a given dimension
`IComplexNDArray`	`put(int[] indexes, 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, 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`	`put(NDArrayIndex[] indices, IComplexNDArray element)`
`IComplexNDArray`	`put(NDArrayIndex[] indices, IComplexNumber element)`
`INDArray`	`put(NDArrayIndex[] indices, INDArray element)`
`IComplexNDArray`	`put(NDArrayIndex[] indices, Number element)`
`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 i, float v)`
`IComplexNDArray`	`putImag(int rowIndex, int columnIndex, float value)`
`IComplexNDArray`	`putReal(int i, float v)`
`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[] indexes, IComplexNumber complexNumber)`
`INDArray`	`putScalar(int[] i, Number value)` Insert the item at the specified indices
`IComplexNDArray`	`putScalar(int i, IComplexNumber value)`
`IComplexNDArray`	`putScalar(int j, int i, IComplexNumber conji)`
`IComplexNDArray`	`putScalar(int i, Number value)` Insert the number linearly in to the ndarray
`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)`
`IComplexNDArray`	`rdiv(Number n, INDArray result)`
`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 divison
`IComplexNDArray`	`rdivi(Number n, INDArray result)` Reverse in place division
`INDArray`	`real()` Get realComponent part of the matrix.
`IComplexNDArray`	`reduce(Ops.DimensionOp op, int dimension)` http://docs.scipy.org/doc/numpy/reference/generated/numpy.ufunc.reduce.html
`IComplexNDArray`	`repmat(int[] shape)` Replicate and tile array to fill out to the given shape
`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)`
`IComplexNDArray`	`rsub(Number n, INDArray result)`
`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`	`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
`float`	`squaredDistance(INDArray other)` Returns the squared (Euclidean) distance.
`IComplexDouble`	`std()`
`INDArray`	`std(int dimension)` Standard deviation of an ndarray along a dimension
`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)`
`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
`IComplexNDArray`	`swapAxes(int dimension, int with)` Mainly here for people coming from numpy.
`IComplexNumber[]`	`toArray()` Converts the matrix to a one-dimensional array of doubles.
`String`	`toString()` Generate string representation of the matrix.
`IComplexNDArray`	`transpose()` Return transposed copy of this matrix.
`IComplexNDArray`	`vectorAlongDimension(int index, int dimension)` Get the vector along a particular dimension
`DimensionSlice`	`vectorForDimensionAndOffset(int dimension, int offset)`
`DimensionSlice`	`vectorForDimensionAndOffsetPair(int dimension, int offset, int currOffsetForSlice)`

Methods inherited from class org.nd4j.linalg.api.ndarray.BaseNDArray
add, asserColumnVector, assertRowVector, assertSlice, checkArrangeArray, columns, div, doColumnWise, doPermuteSwap, doRowWise, floatData, get, get, get, getIndex, index, isColumnVector, isMatrix, isRowVector, isScalar, isVector, iterateOverAllColumns, iterateOverAllRows, length, majorStride, mul, noCopyReshape, offset, ordering, rdiv, reduceVector, rows, rsub, setData, setStride, shape, size, slices, sliceVectors, stride, sub, var, 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
columns, floatData, get, get, get, index, isColumnVector, isMatrix, isRowVector, isScalar, isVector, iterateOverAllColumns, iterateOverAllRows, length, offset, ordering, rows, setData, setStride, shape, size, slices, sliceVectors, stride, var, vectorsAlongDimension

- Constructor Detail
  - BaseComplexNDArray
```
public BaseComplexNDArray()
```
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data)
```
  - 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)
```
  - BaseComplexNDArray
```
public BaseComplexNDArray(int[] shape)
```
  - BaseComplexNDArray
```
public BaseComplexNDArray(float[] data,
                  int[] shape,
                  int[] stride,
                  char 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(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)
```
  - 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)
```
  - copyRealTo
```
protected void copyRealTo(INDArray arr)
```
    Overrides:
    
    copyRealTo in class BaseNDArray
  - 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
  - getComplex
```
public IComplexNumber getComplex(int i,
                        IComplexNumber result)
```
    Specified by:
    
    getComplex in interface IComplexNDArray
  - getComplex
```
public IComplexNumber getComplex(int i,
                        int j,
                        IComplexNumber result)
```
    Specified by:
    
    getComplex in interface IComplexNDArray
  - putScalar
```
public IComplexNDArray putScalar(int j,
                        int i,
                        IComplexNumber conji)
```
    Specified by:
    
    putScalar in interface IComplexNDArray
  - 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)
```
    Specified by:
    
    gt in interface IComplexNDArray
    
    Specified by:
    
    gt in interface INDArray
    
    Overrides:
    
    gt in class BaseNDArray
  - 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:
  - 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)
```
    Specified by:
    
    rdiv in interface IComplexNDArray
    
    Specified by:
    
    rdiv in interface INDArray
    
    Overrides:
    
    rdiv in class BaseNDArray
  - 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)
```
    Specified by:
    
    rsub in interface IComplexNDArray
    
    Specified by:
    
    rsub in interface INDArray
    
    Overrides:
    
    rsub in class BaseNDArray
  - 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
  - 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
  - squaredDistance
```
public float squaredDistance(INDArray other)
```
    Returns the squared (Euclidean) distance.
    
    Specified by:
    
    squaredDistance in interface INDArray
    
    Overrides:
    
    squaredDistance in class BaseNDArray
  - distance2
```
public float distance2(INDArray other)
```
    Returns the (euclidean) distance.
    
    Specified by:
    
    distance2 in interface INDArray
    
    Overrides:
    
    distance2 in class BaseNDArray
  - distance1
```
public float distance1(INDArray other)
```
    Returns the (1-norm) distance.
    
    Specified by:
    
    distance1 in interface INDArray
    
    Overrides:
    
    distance1 in class BaseNDArray
  - put
```
public INDArray put(NDArrayIndex[] indices,
           INDArray element)
```
    Specified by:
    
    put in interface INDArray
    
    Overrides:
    
    put 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,
                  float value)
```
    Specified by:
    
    put in interface IComplexNDArray
    
    Parameters:
    indexes -
    value -
    
    Returns:
  - 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 applyTransformToDestination
    
    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)
```
    Specified by:
    
    getImag in interface IComplexNDArray
  - getReal
```
public double getReal(int i)
```
    Specified by:
    
    getReal in interface IComplexNDArray
  - putReal
```
public IComplexNDArray putReal(int rowIndex,
                      int columnIndex,
                      float value)
```
    Specified by:
    
    putReal in interface IComplexNDArray
  - linearIndex
```
public int linearIndex(int i)
```
    Description copied from interface: INDArray
    
    Get the linear index of the data in to the array
    
    Specified by:
    
    linearIndex in interface INDArray
    
    Overrides:
    
    linearIndex in class BaseNDArray
    
    Parameters:
    i - the index to getScalar
    
    Returns:
    the linear index in to the data
  - putImag
```
public IComplexNDArray putImag(int rowIndex,
                      int columnIndex,
                      float value)
```
    Specified by:
    
    putImag in interface IComplexNDArray
  - putReal
```
public IComplexNDArray putReal(int i,
                      float v)
```
    Specified by:
    
    putReal in interface IComplexNDArray
  - putImag
```
public IComplexNDArray putImag(int i,
                      float v)
```
    Specified by:
    
    putImag in interface IComplexNDArray
  - getComplex
```
public IComplexNumber getComplex(int i)
```
    Specified by:
    
    getComplex in interface IComplexNDArray
  - getComplex
```
public IComplexNumber getComplex(int i,
                        int j)
```
    Specified by:
    
    getComplex in interface IComplexNDArray
  - real
```
public INDArray real()
```
    Get realComponent part of the matrix.
    
    Specified by:
    
    real in interface IComplexNDArray
  - imag
```
public INDArray imag()
```
    Get imaginary part of the matrix.
    
    Specified by:
    
    imag in interface IComplexNDArray
  - iterateOverDimension
```
public void iterateOverDimension(int dimension,
                        SliceOp op,
                        boolean modify)
```
    Iterate along a dimension. This encapsulates the process of sum, mean, and other processes take when iterating over a dimension.
    
    Specified by:
    
    iterateOverDimension in interface IComplexNDArray
    
    Specified by:
    
    iterateOverDimension in interface INDArray
    
    Overrides:
    
    iterateOverDimension in class BaseNDArray
    
    Parameters:
    dimension - the dimension to iterate over
    op - the operation to apply
    modify - whether to modify this array or not based on the results
  - vectorForDimensionAndOffsetPair
```
public DimensionSlice vectorForDimensionAndOffsetPair(int dimension,
                                             int offset,
                                             int currOffsetForSlice)
```
  - vectorForDimensionAndOffset
```
public DimensionSlice vectorForDimensionAndOffset(int dimension,
                                         int offset)
```
    Overrides:
    
    vectorForDimensionAndOffset in class BaseNDArray
  - 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
  - endsForSlices
```
public int[] endsForSlices()
```
    Gives the indices for the ending of each slice
    
    Specified by:
    
    endsForSlices in interface IComplexNDArray
    
    Specified by:
    
    endsForSlices in interface INDArray
    
    Overrides:
    
    endsForSlices in class BaseNDArray
    
    Returns:
    the off sets for the beginning of each slice
  - reduce
```
public IComplexNDArray reduce(Ops.DimensionOp op,
                     int dimension)
```
    http://docs.scipy.org/doc/numpy/reference/generated/numpy.ufunc.reduce.html
    
    Specified by:
    
    reduce in interface IComplexNDArray
    
    Specified by:
    
    reduce in interface INDArray
    
    Overrides:
    
    reduce in class BaseNDArray
    
    Parameters:
    op - the operation to do
    dimension - the dimension to return from
    
    Returns:
    the results of the reduce (applying the operation along the specified dimension)t
  - 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 applyTransformToDestination
    
    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
  - 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
  - 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
  - initShape
```
protected void initShape(int[] shape)
```
    Overrides:
    
    initShape in class BaseNDArray
  - newShape
```
protected IComplexNDArray newShape(int[] newShape,
                       char ordering)
```
    Overrides:
    
    newShape 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
  - 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(NDArrayIndex[] indices,
                  IComplexNumber element)
```
    Specified by:
    
    put in interface IComplexNDArray
  - put
```
public IComplexNDArray put(NDArrayIndex[] indices,
                  IComplexNDArray element)
```
    Specified by:
    
    put in interface IComplexNDArray
  - put
```
public IComplexNDArray put(NDArrayIndex[] indices,
                  Number element)
```
    Specified by:
    
    put in interface IComplexNDArray
    
    Specified by:
    
    put in interface INDArray
    
    Overrides:
    
    put in class BaseNDArray
  - putScalar
```
public IComplexNDArray putScalar(int i,
                        IComplexNumber value)
```
    Specified by:
    
    putScalar in interface IComplexNDArray
  - 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 getScalar
    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,
                        Number 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,
                 Number 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 INDArray 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)
```
    Specified by:
    
    rdiv in interface IComplexNDArray
    
    Specified by:
    
    rdiv in interface INDArray
    
    Overrides:
    
    rdiv in class BaseNDArray
  - rdivi
```
public IComplexNDArray rdivi(Number n)
```
    Description copied from interface: INDArray
    
    In place reverse divison
    
    Specified by:
    
    rdivi in interface IComplexNDArray
    
    Specified by:
    
    rdivi in interface INDArray
    
    Overrides:
    
    rdivi in class BaseNDArray
    
    Returns:
  - rsub
```
public IComplexNDArray rsub(Number n)
```
    Specified by:
    
    rsub in interface IComplexNDArray
    
    Specified by:
    
    rsub in interface INDArray
    
    Overrides:
    
    rsub in class BaseNDArray
  - rsubi
```
public IComplexNDArray rsubi(Number n)
```
    Specified by:
    
    rsubi in interface IComplexNDArray
    
    Specified by:
    
    rsubi in interface INDArray
    
    Overrides:
    
    rsubi in class BaseNDArray
  - div
```
public IComplexNDArray div(Number n)
```
    Specified by:
    
    div in interface IComplexNDArray
    
    Specified by:
    
    div in interface INDArray
    
    Overrides:
    
    div in class BaseNDArray
  - 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)
```
    Specified by:
    
    mul in interface IComplexNDArray
    
    Specified by:
    
    mul in interface INDArray
    
    Overrides:
    
    mul in class BaseNDArray
  - 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)
```
    Specified by:
    
    sub in interface IComplexNDArray
    
    Specified by:
    
    sub in interface INDArray
    
    Overrides:
    
    sub in class BaseNDArray
  - 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)
```
    Specified by:
    
    add in interface IComplexNDArray
    
    Specified by:
    
    add in interface INDArray
    
    Overrides:
    
    add in class BaseNDArray
  - 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(NDArrayIndex... 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
  - 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
  - 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
  - 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
  - rdivi
```
public IComplexNDArray rdivi(IComplexNumber n)
```
    Specified by:
    
    rdivi in interface IComplexNDArray
    
    Specified by:
    
    rdivi in interface INDArray
    
    Overrides:
    
    rdivi in class BaseNDArray
  - rsub
```
public IComplexNDArray rsub(IComplexNumber n)
```
    Specified by:
    
    rsub in interface IComplexNDArray
    
    Specified by:
    
    rsub in interface INDArray
    
    Overrides:
    
    rsub in class BaseNDArray
  - rsubi
```
public IComplexNDArray rsubi(IComplexNumber n)
```
    Specified by:
    
    rsubi in interface IComplexNDArray
    
    Specified by:
    
    rsubi in interface INDArray
    
    Overrides:
    
    rsubi in class BaseNDArray
  - div
```
public IComplexNDArray div(IComplexNumber n)
```
    Specified by:
    
    div in interface IComplexNDArray
    
    Specified by:
    
    div in interface INDArray
    
    Overrides:
    
    div in class BaseNDArray
  - divi
```
public IComplexNDArray divi(IComplexNumber n)
```
    Specified by:
    
    divi in interface IComplexNDArray
    
    Specified by:
    
    divi in interface INDArray
    
    Overrides:
    
    divi in class BaseNDArray
  - mul
```
public IComplexNDArray mul(IComplexNumber n)
```
    Specified by:
    
    mul in interface IComplexNDArray
    
    Specified by:
    
    mul in interface INDArray
    
    Overrides:
    
    mul in class BaseNDArray
  - muli
```
public IComplexNDArray muli(IComplexNumber n)
```
    Specified by:
    
    muli in interface IComplexNDArray
    
    Specified by:
    
    muli in interface INDArray
    
    Overrides:
    
    muli in class BaseNDArray
  - sub
```
public IComplexNDArray sub(IComplexNumber n)
```
    Specified by:
    
    sub in interface IComplexNDArray
    
    Specified by:
    
    sub in interface INDArray
    
    Overrides:
    
    sub in class BaseNDArray
  - subi
```
public IComplexNDArray subi(IComplexNumber n)
```
    Specified by:
    
    subi in interface IComplexNDArray
    
    Specified by:
    
    subi in interface INDArray
    
    Overrides:
    
    subi in class BaseNDArray
  - add
```
public IComplexNDArray add(IComplexNumber n)
```
    Specified by:
    
    add in interface IComplexNDArray
    
    Specified by:
    
    add in interface INDArray
    
    Overrides:
    
    add in class BaseNDArray
  - addi
```
public IComplexNDArray addi(IComplexNumber n)
```
    Specified by:
    
    addi in interface IComplexNDArray
    
    Specified by:
    
    addi in interface INDArray
    
    Overrides:
    
    addi in class BaseNDArray
  - 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
  - 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
  - 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
  - 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
  - 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
  - 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
  - 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:
  - multipliesWith
```
public boolean multipliesWith(INDArray a)
```
    Check whether this can be multiplied with a.
    
    Parameters:
    a - right-hand-side of the multiplication.
    
    Returns:
    true iff this.columns == a.rows
  - data
```
public float[] data()
```
    Returns a copy of all of the data in this array in order
    
    Specified by:
    
    data in interface IComplexNDArray
    
    Specified by:
    
    data in interface INDArray
    
    Overrides:
    
    data in class BaseNDArray
    
    Returns:
    all of the data in order
  - prod
```
public IComplexNDArray prod(int dimension)
```
    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
  - mean
```
public IComplexNDArray mean(int dimension)
```
    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
  - 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()
```
  - max
```
public IComplexNDArray max(int dimension)
```
    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
  - min
```
public IComplexNDArray min(int dimension)
```
    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
  - normmax
```
public IComplexNDArray normmax(int dimension)
```
    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
  - sum
```
public IComplexNDArray sum(int dimension)
```
    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
  - norm1
```
public IComplexNDArray norm1(int dimension)
```
    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
  - std
```
public IComplexDouble std()
```
  - std
```
public INDArray std(int dimension)
```
    Standard deviation of an ndarray along a dimension
    
    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
  - norm2
```
public IComplexNDArray norm2(int dimension)
```
    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
  - toArray
```
public IComplexNumber[] toArray()
```
    Converts the matrix to a one-dimensional array of doubles.
    
    Specified by:
    
    toArray in interface IComplexNDArray
  - 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

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

Method Detail

copyFromReal

copyRealTo

linearView

getComplex

getComplex

putScalar

lt

lti

eq

eqi

gt

gti

lt

lti

eq

eqi

gt

gti

rdiv

rdivi

rsub

rsubi

div

divi

mul

muli

sub

subi

add

addi

dup

squaredDistance

distance2

distance1

put

put

put

putSlice