INDArray (nd4j-api 0.0.3.1 API)

All Superinterfaces:

Serializable

All Known Subinterfaces:

IComplexNDArray

All Known Implementing Classes:

BaseComplexNDArray, BaseNDArray
```
public interface INDArray
extends Serializable
```
Interface for an ndarray

Author:

Adam Gibson

Method Summary

Methods
Modifier and Type	Method and Description
`IComplexNDArray`	`add(IComplexNumber n)`
`IComplexNDArray`	`add(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`add(INDArray other)` copy addition of two matrices
`INDArray`	`add(INDArray other, INDArray result)` copy addition of two matrices
`INDArray`	`add(Number n)`
`INDArray`	`add(Number n, INDArray result)`
`INDArray`	`addColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`addi(IComplexNumber n)`
`IComplexNDArray`	`addi(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`addi(INDArray other)` in place addition of two matrices
`INDArray`	`addi(INDArray other, INDArray result)` in place addition of two matrices
`INDArray`	`addi(Number n)` In place scalar addition
`INDArray`	`addi(Number n, INDArray result)` In place addition
`INDArray`	`addiColumnVector(INDArray columnVector)` In place addition of a column vector
`INDArray`	`addiRowVector(INDArray rowVector)` In place addition of a column vector
`INDArray`	`addRowVector(INDArray rowVector)` In place addition of a column vector
`INDArray`	`assign(INDArray arr)` Assign all of the elements in the given ndarray to this ndarray
`INDArray`	`assign(Number value)` Set the value of the ndarray to the specified value
`INDArray`	`broadcast(int[] shape)` Broadcasts this ndarray to be the specified shape
`void`	`checkDimensions(INDArray other)` Validate dimensions are equal
`int`	`columns()` Returns the number of columns in this matrix (throws exception if not 2d)
`INDArray`	`cumsum(int dimension)` Cumulative sum along a dimension (in place)
`INDArray`	`cumsumi(int dimension)` Cumulative sum along a dimension
`float[]`	`data()` Returns a linear double array representation of this ndarray
`INDArray`	`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, IComplexNDArray result)`
`INDArray`	`div(INDArray other)` in place (element wise) division of two matrices
`INDArray`	`div(INDArray other, INDArray result)` copy (element wise) division of two matrices
`INDArray`	`div(Number n)`
`INDArray`	`div(Number n, INDArray result)`
`INDArray`	`divColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`divi(IComplexNumber n)`
`IComplexNDArray`	`divi(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`divi(INDArray other)` in place (element wise) division of two matrices
`INDArray`	`divi(INDArray other, INDArray result)` in place (element wise) division of two matrices
`INDArray`	`divi(Number n)` In place scalar division
`INDArray`	`divi(Number n, INDArray result)` In place division of this ndarray
`INDArray`	`diviColumnVector(INDArray columnVector)` In place addition of a column vector
`INDArray`	`diviRowVector(INDArray rowVector)` In place addition of a column vector
`INDArray`	`divRowVector(INDArray rowVector)` In place addition of a column vector
`INDArray`	`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
`INDArray`	`eq(INDArray other)` equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`INDArray`	`eq(Number other)` Returns an ndarray with 1 if the element is less than the given element 0 other wise
`INDArray`	`eqi(INDArray other)` In place equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`INDArray`	`eqi(Number other)` In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`float[]`	`floatData()` Returns a linear float array representation of this ndarray
`float`	`get(int i)` Return the item at the linear index i
`float`	`get(int[] indices)` Returns the elements at the the specified indices
`float`	`get(int i, int j)` Return the item at row i column j Note that this is the same as calling getScalar(new int[]{i,j}
`INDArray`	`get(NDArrayIndex... indexes)` Returns a subset of this array based on the specified indexes
`INDArray`	`getColumn(int i)` Returns the specified column.
`INDArray`	`getColumns(int[] columns)` Get a list of specified columns
`INDArray`	`getRow(int i)` Returns the specified row.
`INDArray`	`getRows(int[] rows)` Get a list of rows
`INDArray`	`getScalar(int i)` Returns the element at the specified index
`INDArray`	`getScalar(int[] indices)` Returns the elements at the the specified indices
`INDArray`	`getScalar(int row, int column)` Returns the element at the specified row/column This will throw an exception if the
`INDArray`	`gt(INDArray other)` greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`INDArray`	`gt(Number other)`
`INDArray`	`gti(INDArray other)` In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`INDArray`	`gti(Number other)` In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`int`	`index(int row, int column)` Return the linear index of the specified row and column
`boolean`	`isColumnVector()` Returns true if the number of columns is 1
`boolean`	`isMatrix()` Returns true if this ndarray is a matrix
`boolean`	`isRowVector()` Returns true if the number of rows is 1
`boolean`	`isScalar()` Returns true if this ndarray is a scalar
`boolean`	`isVector()` Returns true if this ndarray is a vector
`void`	`iterateOverAllColumns(SliceOp op)` Iterate over every column of every slice
`void`	`iterateOverAllRows(SliceOp op)` Iterate over every row of every slice
`void`	`iterateOverDimension(int dimension, SliceOp op, boolean modify)` Iterate along a dimension.
`int`	`length()` Returns the total number of elements in the ndarray
`int`	`linearIndex(int i)` Get the linear index of the data in to the array
`INDArray`	`linearView()` Returns a linear view reference of shape 1,length(ndarray)
`INDArray`	`lt(INDArray other)` less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`INDArray`	`lt(Number other)` Returns an ndarray with 1 if the element is less than the given element 0 other wise
`INDArray`	`lti(INDArray other)` In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`INDArray`	`lti(Number other)` In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`INDArray`	`max(int dimension)` Returns the overall max of this ndarray
`INDArray`	`mean(int dimension)` Returns the overall mean of this ndarray
`INDArray`	`min(int dimension)` Returns the overall min of this ndarray
`INDArray`	`mmul(INDArray other)` Perform a copy matrix multiplication
`INDArray`	`mmul(INDArray other, INDArray result)` Perform an copy matrix multiplication
`INDArray`	`mmuli(INDArray other)` Perform an copy matrix multiplication
`INDArray`	`mmuli(INDArray other, INDArray result)` Perform an copy matrix multiplication
`IComplexNDArray`	`mul(IComplexNumber n)`
`IComplexNDArray`	`mul(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`mul(INDArray other)` copy (element wise) multiplication of two matrices
`INDArray`	`mul(INDArray other, INDArray result)` copy (element wise) multiplication of two matrices
`INDArray`	`mul(Number n)`
`INDArray`	`mul(Number n, INDArray result)`
`INDArray`	`mulColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`muli(IComplexNumber n)`
`IComplexNDArray`	`muli(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`muli(INDArray other)` in place (element wise) multiplication of two matrices
`INDArray`	`muli(INDArray other, INDArray result)` in place (element wise) multiplication of two matrices
`INDArray`	`muli(Number n)` In place scalar multiplication
`INDArray`	`muli(Number n, INDArray result)` In place multiplication of this ndarray
`INDArray`	`muliColumnVector(INDArray columnVector)` In place addition of a column vector
`INDArray`	`muliRowVector(INDArray rowVector)` In place addition of a column vector
`INDArray`	`mulRowVector(INDArray rowVector)` In place addition of a column vector
`INDArray`	`neg()` Returns the ndarray negative (cloned)
`INDArray`	`negi()` In place setting of the negative version of this ndarray
`INDArray`	`norm1(int dimension)` Returns the norm1 along the specified dimension
`INDArray`	`norm2(int dimension)` Returns the norm2 along the specified dimension
`INDArray`	`normmax(int dimension)` Returns the normmax along the specified dimension
`int`	`offset()` Returns the start of where the ndarray is for the underlying data
`char`	`ordering()`
`INDArray`	`permute(int... rearrange)` See: http://www.mathworks.com/help/matlab/ref/permute.html
`INDArray`	`prod(int dimension)` Returns the product along a given dimension
`INDArray`	`put(int[] indices, INDArray element)` Inserts the element at the specified index
`INDArray`	`put(int i, INDArray element)` Inserts the element at the specified index
`INDArray`	`put(int i, int j, INDArray element)` Inserts the element at the specified index
`INDArray`	`put(int i, int j, Number element)` Inserts the element at the specified index
`INDArray`	`put(NDArrayIndex[] indices, INDArray element)`
`INDArray`	`put(NDArrayIndex[] indices, Number element)`
`INDArray`	`putColumn(int column, INDArray toPut)` Insert a column in to this array Will throw an exception if this ndarray is not a matrix
`INDArray`	`putRow(int row, INDArray toPut)` Insert a row in to this array Will throw an exception if this ndarray is not a matrix
`INDArray`	`putScalar(int[] i, Number value)` Insert the item at the specified indices
`INDArray`	`putScalar(int i, Number value)` Insert the number linearly in to the ndarray
`INDArray`	`putSlice(int slice, INDArray put)` Assigns the given matrix (put) to the specified slice
`INDArray`	`ravel()` Returns a flattened version (row vector) of this ndarray
`IComplexNDArray`	`rdiv(IComplexNumber n)`
`IComplexNDArray`	`rdiv(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`rdiv(INDArray other)` Reverse division
`INDArray`	`rdiv(INDArray other, INDArray result)` Reverse division
`INDArray`	`rdiv(Number n)`
`INDArray`	`rdiv(Number n, INDArray result)`
`IComplexNDArray`	`rdivi(IComplexNumber n)`
`IComplexNDArray`	`rdivi(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`rdivi(INDArray other)` Reverse divsion (in place)
`INDArray`	`rdivi(INDArray other, INDArray result)` Reverse division (in-place)
`INDArray`	`rdivi(Number n)` In place reverse divison
`INDArray`	`rdivi(Number n, INDArray result)` Reverse in place division
`INDArray`	`reduce(Ops.DimensionOp op, int dimension)` http://docs.scipy.org/doc/numpy/reference/generated/numpy.ufunc.reduce.html
`INDArray`	`repmat(int[] shape)` Replicate and tile array to fill out to the given shape
`INDArray`	`reshape(int... newShape)` Reshapes the ndarray (can't change the length of the ndarray)
`INDArray`	`reshape(int rows, int columns)` Reshapes the ndarray (can't change the length of the ndarray)
`int`	`rows()` Returns the number of rows in this matrix (throws exception if not 2d)
`IComplexNDArray`	`rsub(IComplexNumber n)`
`IComplexNDArray`	`rsub(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`rsub(INDArray other)`
`INDArray`	`rsub(INDArray other, INDArray result)` Reverse subtraction
`INDArray`	`rsub(Number n)`
`INDArray`	`rsub(Number n, INDArray result)`
`IComplexNDArray`	`rsubi(IComplexNumber n)`
`IComplexNDArray`	`rsubi(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`rsubi(INDArray other)`
`INDArray`	`rsubi(INDArray other, INDArray result)` Reverse subtraction (in-place)
`INDArray`	`rsubi(Number n)`
`INDArray`	`rsubi(Number n, INDArray result)` Reverse in place subtraction
`void`	`setData(float[] data)`
`void`	`setStride(int[] stride)`
`int[]`	`shape()` Returns the shape of this ndarray
`int`	`size(int dimension)` Returns the size along a specified dimension
`INDArray`	`slice(int i)` Returns the specified slice of this ndarray
`INDArray`	`slice(int i, int dimension)` Returns the specified slice of this ndarray
`int`	`slices()` Returns the number of slices in this ndarray
`void`	`sliceVectors(List<INDArray> list)`
`float`	`squaredDistance(INDArray other)` Returns the squared (Euclidean) distance.
`INDArray`	`std(int dimension)` Standard deviation of an ndarray along a dimension
`int[]`	`stride()` Returns the stride of this ndarray
`IComplexNDArray`	`sub(IComplexNumber n)`
`IComplexNDArray`	`sub(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`sub(INDArray other)` copy subtraction of two matrices
`INDArray`	`sub(INDArray other, INDArray result)` copy subtraction of two matrices
`INDArray`	`sub(Number n)`
`INDArray`	`sub(Number n, INDArray result)`
`INDArray`	`subArray(int[] offsets, int[] shape, int[] stride)`
`INDArray`	`subColumnVector(INDArray columnVector)` In place addition of a column vector
`IComplexNDArray`	`subi(IComplexNumber n)`
`IComplexNDArray`	`subi(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`subi(INDArray other)` in place subtraction of two matrices
`INDArray`	`subi(INDArray other, INDArray result)` in place subtraction of two matrices
`INDArray`	`subi(Number n)` In place scalar subtraction
`INDArray`	`subi(Number n, INDArray result)` In place subtraction of this ndarray
`INDArray`	`subiColumnVector(INDArray columnVector)` In place addition of a column vector
`INDArray`	`subiRowVector(INDArray rowVector)` In place addition of a column vector
`INDArray`	`subRowVector(INDArray rowVector)` In place addition of a column vector
`INDArray`	`sum(int dimension)` Returns the sum along the last dimension of this ndarray
`INDArray`	`swapAxes(int dimension, int with)` Mainly here for people coming from numpy.
`INDArray`	`transpose()` Flip the rows and columns of a matrix
`INDArray`	`var(int dimension)` Returns the overall variance of this ndarray
`INDArray`	`vectorAlongDimension(int index, int dimension)` Get the vector along a particular dimension
`int`	`vectorsAlongDimension(int dimension)` Returns the number of possible vectors for a given dimension

- Method Detail
  - linearView
```
INDArray linearView()
```
    Returns a linear view reference of shape 1,length(ndarray)
    
    Returns:
    the linear view of this ndarray
  - vectorsAlongDimension
```
int vectorsAlongDimension(int dimension)
```
    Returns the number of possible vectors for a given dimension
    
    Parameters:
    dimension - the dimension to calculate the number of vectors for
    
    Returns:
    the number of possible vectors along a dimension
  - vectorAlongDimension
```
INDArray vectorAlongDimension(int index,
                            int dimension)
```
    Get the vector along a particular dimension
    
    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
```
INDArray cumsumi(int dimension)
```
    Cumulative sum along a dimension
    
    Parameters:
    dimension - the dimension to perform cumulative sum along
    
    Returns:
    the cumulative sum along the specified dimension
  - cumsum
```
INDArray cumsum(int dimension)
```
    Cumulative sum along a dimension (in place)
    
    Parameters:
    dimension - the dimension to perform cumulative sum along
    
    Returns:
    the cumulative sum along the specified dimension
  - assign
```
INDArray assign(INDArray arr)
```
    Assign all of the elements in the given ndarray to this ndarray
    
    Parameters:
    arr - the elements to assign
    
    Returns:
    this
  - putScalar
```
INDArray putScalar(int i,
                 Number value)
```
    Insert the number linearly in to the ndarray
    
    Parameters:
    i - the index to insert into
    value - the value to insert
    
    Returns:
    this
  - putScalar
```
INDArray putScalar(int[] i,
                 Number value)
```
    Insert the item at the specified indices
    
    Parameters:
    i - the indices to insert at
    value - the number to insert
    
    Returns:
    this
  - lt
```
INDArray lt(Number other)
```
    Returns an ndarray with 1 if the element is less than the given element 0 other wise
    
    Parameters:
    other - the number to compare
    
    Returns:
    a copied ndarray with the given binary conditions
  - lti
```
INDArray lti(Number other)
```
    In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Parameters:
    other - the number to compare
    
    Returns:
  - eq
```
INDArray eq(Number other)
```
    Returns an ndarray with 1 if the element is less than the given element 0 other wise
    
    Parameters:
    other - the number to compare
    
    Returns:
    a copied ndarray with the given binary conditions
  - eqi
```
INDArray eqi(Number other)
```
    In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Parameters:
    other - the number to compare
    
    Returns:
  - gt
```
INDArray gt(Number other)
```
  - gti
```
INDArray gti(Number other)
```
    In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Parameters:
    other - the number to compare
    
    Returns:
  - lt
```
INDArray lt(INDArray other)
```
    less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Parameters:
    other - the number to compare
    
    Returns:
    the result ndarray
  - lti
```
INDArray lti(INDArray other)
```
    In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Parameters:
    other - the number to compare
    
    Returns:
  - eq
```
INDArray eq(INDArray other)
```
    equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Parameters:
    other - the number to compare
    
    Returns:
  - eqi
```
INDArray eqi(INDArray other)
```
    In place equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Parameters:
    other - the number to compare
    
    Returns:
  - gt
```
INDArray gt(INDArray other)
```
    greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Parameters:
    other - the number to compare
    
    Returns:
  - gti
```
INDArray gti(INDArray other)
```
    In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Parameters:
    other - the number to compare
    
    Returns:
  - neg
```
INDArray neg()
```
    Returns the ndarray negative (cloned)
    
    Returns:
  - negi
```
INDArray negi()
```
    In place setting of the negative version of this ndarray
    
    Returns:
  - rdiv
```
INDArray rdiv(Number n)
```
  - rdivi
```
INDArray rdivi(Number n)
```
    In place reverse divison
    
    Parameters:
    n -
    
    Returns:
  - rsub
```
INDArray rsub(Number n)
```
  - rsubi
```
INDArray rsubi(Number n)
```
  - div
```
INDArray div(Number n)
```
  - divi
```
INDArray divi(Number n)
```
    In place scalar division
    
    Parameters:
    n -
    
    Returns:
  - mul
```
INDArray mul(Number n)
```
  - muli
```
INDArray muli(Number n)
```
    In place scalar multiplication
    
    Parameters:
    n -
    
    Returns:
  - sub
```
INDArray sub(Number n)
```
  - subi
```
INDArray subi(Number n)
```
    In place scalar subtraction
    
    Parameters:
    n -
    
    Returns:
  - add
```
INDArray add(Number n)
```
  - addi
```
INDArray addi(Number n)
```
    In place scalar addition
    
    Parameters:
    n -
    
    Returns:
  - rdiv
```
INDArray rdiv(Number n,
            INDArray result)
```
  - rdivi
```
INDArray rdivi(Number n,
             INDArray result)
```
    Reverse in place division
    
    Parameters:
    n - the number to divide by by
    result - the result ndarray
    
    Returns:
    the result ndarray
  - rsub
```
INDArray rsub(Number n,
            INDArray result)
```
  - rsubi
```
INDArray rsubi(Number n,
             INDArray result)
```
    Reverse in place subtraction
    
    Parameters:
    n - the number to subtract by
    result - the result ndarray
    
    Returns:
    the result ndarray
  - div
```
INDArray div(Number n,
           INDArray result)
```
  - divi
```
INDArray divi(Number n,
            INDArray result)
```
    In place division of this ndarray
    
    Parameters:
    n - the number to divide by
    result - the result ndarray
    
    Returns:
  - mul
```
INDArray mul(Number n,
           INDArray result)
```
  - muli
```
INDArray muli(Number n,
            INDArray result)
```
    In place multiplication of this ndarray
    
    Parameters:
    n - the number to divide by
    result - the result ndarray
    
    Returns:
  - sub
```
INDArray sub(Number n,
           INDArray result)
```
  - subi
```
INDArray subi(Number n,
            INDArray result)
```
    In place subtraction of this ndarray
    
    Parameters:
    n - the number to subtract by
    result - the result ndarray
    
    Returns:
    the result ndarray
  - add
```
INDArray add(Number n,
           INDArray result)
```
  - addi
```
INDArray addi(Number n,
            INDArray result)
```
    In place addition
    
    Parameters:
    n - the number to add
    result - the result ndarray
    
    Returns:
    the result ndarray
  - get
```
INDArray get(NDArrayIndex... indexes)
```
    Returns a subset of this array based on the specified indexes
    
    Parameters:
    indexes - the indexes in to the array
    
    Returns:
    a view of the array with the specified indices
  - getColumns
```
INDArray getColumns(int[] columns)
```
    Get a list of specified columns
    
    Parameters:
    columns -
    
    Returns:
  - getRows
```
INDArray getRows(int[] rows)
```
    Get a list of rows
    
    Parameters:
    rows -
    
    Returns:
  - rdiv
```
INDArray rdiv(INDArray other)
```
    Reverse division
    
    Parameters:
    other - the matrix to divide from
    
    Returns:
  - rdivi
```
INDArray rdivi(INDArray other)
```
    Reverse divsion (in place)
    
    Parameters:
    other -
    
    Returns:
  - rdiv
```
INDArray rdiv(INDArray other,
            INDArray result)
```
    Reverse division
    
    Parameters:
    other - the matrix to subtract from
    result - the result ndarray
    
    Returns:
  - rdivi
```
INDArray rdivi(INDArray other,
             INDArray result)
```
    Reverse division (in-place)
    
    Parameters:
    other - the other ndarray to subtract
    result - the result ndarray
    
    Returns:
    the ndarray with the operation applied
  - rsub
```
INDArray rsub(INDArray other,
            INDArray result)
```
    Reverse subtraction
    
    Parameters:
    other - the matrix to subtract from
    result - the result ndarray
    
    Returns:
  - rsub
```
INDArray rsub(INDArray other)
```
    Parameters:
    other -
    
    Returns:
  - rsubi
```
INDArray rsubi(INDArray other)
```
    Parameters:
    other -
    
    Returns:
  - rsubi
```
INDArray rsubi(INDArray other,
             INDArray result)
```
    Reverse subtraction (in-place)
    
    Parameters:
    other - the other ndarray to subtract
    result - the result ndarray
    
    Returns:
    the ndarray with the operation applied
  - assign
```
INDArray assign(Number value)
```
    Set the value of the ndarray to the specified value
    
    Parameters:
    value - the value to assign
    
    Returns:
    the ndarray with the values
  - linearIndex
```
int linearIndex(int i)
```
    Get the linear index of the data in to the array
    
    Parameters:
    i - the index to getScalar
    
    Returns:
    the linear index in to the data
  - iterateOverAllRows
```
void iterateOverAllRows(SliceOp op)
```
    Iterate over every row of every slice
    
    Parameters:
    op - the operation to apply
  - iterateOverAllColumns
```
void iterateOverAllColumns(SliceOp op)
```
    Iterate over every column of every slice
    
    Parameters:
    op - the operation to apply
  - checkDimensions
```
void checkDimensions(INDArray other)
```
    Validate dimensions are equal
    
    Parameters:
    other - the other ndarray to compare
  - endsForSlices
```
int[] endsForSlices()
```
    Gives the indices for the ending of each slice
    
    Returns:
    the off sets for the beginning of each slice
  - sliceVectors
```
void sliceVectors(List<INDArray> list)
```
  - reduce
```
INDArray reduce(Ops.DimensionOp op,
              int dimension)
```
    http://docs.scipy.org/doc/numpy/reference/generated/numpy.ufunc.reduce.html
    
    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
```
INDArray putSlice(int slice,
                INDArray put)
```
    Assigns the given matrix (put) to the specified slice
    
    Parameters:
    slice - the slice to assign
    put - the slice to applyTransformToDestination
    
    Returns:
    this for chainability
  - iterateOverDimension
```
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.
    
    Parameters:
    dimension - the dimension to iterate over
    op - the operation to apply
    modify - whether to modify this array while iterating
  - repmat
```
INDArray repmat(int[] shape)
```
    Replicate and tile array to fill out to the given shape
    
    Parameters:
    shape - the new shape of this ndarray
    
    Returns:
    the shape to fill out to
  - putRow
```
INDArray putRow(int row,
              INDArray toPut)
```
    Insert a row in to this array Will throw an exception if this ndarray is not a matrix
    
    Parameters:
    row - the row insert into
    toPut - the row to insert
    
    Returns:
    this
  - putColumn
```
INDArray putColumn(int column,
                 INDArray toPut)
```
    Insert a column in to this array Will throw an exception if this ndarray is not a matrix
    
    Parameters:
    column - the column to insert
    toPut - the array to put
    
    Returns:
    this
  - getScalar
```
INDArray getScalar(int row,
                 int column)
```
    Returns the element at the specified row/column This will throw an exception if the
    
    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
```
INDArray getScalar(int i)
```
    Returns the element at the specified index
    
    Parameters:
    i - the index of the element to return
    
    Returns:
    a scalar ndarray of the element at this index
  - index
```
int index(int row,
        int column)
```
    Return the linear index of the specified row and column
    
    Parameters:
    row - the row to getScalar the linear index for
    column - the column to getScalar the linear index for
    
    Returns:
    the linear index of the given row and column
  - squaredDistance
```
float squaredDistance(INDArray other)
```
    Returns the squared (Euclidean) distance.
  - distance2
```
float distance2(INDArray other)
```
    Returns the (euclidean) distance.
  - distance1
```
float distance1(INDArray other)
```
    Returns the (1-norm) distance.
  - put
```
INDArray put(NDArrayIndex[] indices,
           INDArray element)
```
  - put
```
INDArray put(NDArrayIndex[] indices,
           Number element)
```
  - put
```
INDArray put(int[] indices,
           INDArray element)
```
    Inserts the element at the specified index
    
    Parameters:
    indices - the indices to insert into
    element - a scalar ndarray
    
    Returns:
    a scalar ndarray of the element at this index
  - put
```
INDArray put(int i,
           int j,
           INDArray element)
```
    Inserts the element at the specified index
    
    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
```
INDArray put(int i,
           int j,
           Number element)
```
    Inserts the element at the specified index
    
    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
```
INDArray put(int i,
           INDArray element)
```
    Inserts the element at the specified index
    
    Parameters:
    i - the index insert into
    element - a scalar ndarray
    
    Returns:
    a scalar ndarray of the element at this index
  - diviColumnVector
```
INDArray diviColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - divColumnVector
```
INDArray divColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - diviRowVector
```
INDArray diviRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - divRowVector
```
INDArray divRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - muliColumnVector
```
INDArray muliColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - mulColumnVector
```
INDArray mulColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - muliRowVector
```
INDArray muliRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - mulRowVector
```
INDArray mulRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - subiColumnVector
```
INDArray subiColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - subColumnVector
```
INDArray subColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - subiRowVector
```
INDArray subiRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - subRowVector
```
INDArray subRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - addiColumnVector
```
INDArray addiColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - addColumnVector
```
INDArray addColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - addiRowVector
```
INDArray addiRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - addRowVector
```
INDArray addRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - mmul
```
INDArray mmul(INDArray other)
```
    Perform a copy matrix multiplication
    
    Parameters:
    other - the other matrix to perform matrix multiply with
    
    Returns:
    the result of the matrix multiplication
  - mmul
```
INDArray mmul(INDArray other,
            INDArray result)
```
    Perform an copy matrix multiplication
    
    Parameters:
    other - the other matrix to perform matrix multiply with
    result - the result ndarray
    
    Returns:
    the result of the matrix multiplication
  - div
```
INDArray div(INDArray other)
```
    in place (element wise) division of two matrices
    
    Parameters:
    other - the second ndarray to divide
    
    Returns:
    the result of the divide
  - div
```
INDArray div(INDArray other,
           INDArray result)
```
    copy (element wise) division of two matrices
    
    Parameters:
    other - the second ndarray to divide
    result - the result ndarray
    
    Returns:
    the result of the divide
  - mul
```
INDArray mul(INDArray other)
```
    copy (element wise) multiplication of two matrices
    
    Parameters:
    other - the second ndarray to multiply
    
    Returns:
    the result of the addition
  - mul
```
INDArray mul(INDArray other,
           INDArray result)
```
    copy (element wise) multiplication of two matrices
    
    Parameters:
    other - the second ndarray to multiply
    result - the result ndarray
    
    Returns:
    the result of the multiplication
  - sub
```
INDArray sub(INDArray other)
```
    copy subtraction of two matrices
    
    Parameters:
    other - the second ndarray to subtract
    
    Returns:
    the result of the addition
  - sub
```
INDArray sub(INDArray other,
           INDArray result)
```
    copy subtraction of two matrices
    
    Parameters:
    other - the second ndarray to subtract
    result - the result ndarray
    
    Returns:
    the result of the subtraction
  - add
```
INDArray add(INDArray other)
```
    copy addition of two matrices
    
    Parameters:
    other - the second ndarray to add
    
    Returns:
    the result of the addition
  - add
```
INDArray add(INDArray other,
           INDArray result)
```
    copy addition of two matrices
    
    Parameters:
    other - the second ndarray to add
    result - the result ndarray
    
    Returns:
    the result of the addition
  - mmuli
```
INDArray mmuli(INDArray other)
```
    Perform an copy matrix multiplication
    
    Parameters:
    other - the other matrix to perform matrix multiply with
    
    Returns:
    the result of the matrix multiplication
  - mmuli
```
INDArray mmuli(INDArray other,
             INDArray result)
```
    Perform an copy matrix multiplication
    
    Parameters:
    other - the other matrix to perform matrix multiply with
    result - the result ndarray
    
    Returns:
    the result of the matrix multiplication
  - divi
```
INDArray divi(INDArray other)
```
    in place (element wise) division of two matrices
    
    Parameters:
    other - the second ndarray to divide
    
    Returns:
    the result of the divide
  - divi
```
INDArray divi(INDArray other,
            INDArray result)
```
    in place (element wise) division of two matrices
    
    Parameters:
    other - the second ndarray to divide
    result - the result ndarray
    
    Returns:
    the result of the divide
  - muli
```
INDArray muli(INDArray other)
```
    in place (element wise) multiplication of two matrices
    
    Parameters:
    other - the second ndarray to multiply
    
    Returns:
    the result of the addition
  - muli
```
INDArray muli(INDArray other,
            INDArray result)
```
    in place (element wise) multiplication of two matrices
    
    Parameters:
    other - the second ndarray to multiply
    result - the result ndarray
    
    Returns:
    the result of the multiplication
  - subi
```
INDArray subi(INDArray other)
```
    in place subtraction of two matrices
    
    Parameters:
    other - the second ndarray to subtract
    
    Returns:
    the result of the addition
  - subi
```
INDArray subi(INDArray other,
            INDArray result)
```
    in place subtraction of two matrices
    
    Parameters:
    other - the second ndarray to subtract
    result - the result ndarray
    
    Returns:
    the result of the subtraction
  - addi
```
INDArray addi(INDArray other)
```
    in place addition of two matrices
    
    Parameters:
    other - the second ndarray to add
    
    Returns:
    the result of the addition
  - addi
```
INDArray addi(INDArray other,
            INDArray result)
```
    in place addition of two matrices
    
    Parameters:
    other - the second ndarray to add
    result - the result ndarray
    
    Returns:
    the result of the addition
  - normmax
```
INDArray normmax(int dimension)
```
    Returns the normmax along the specified dimension
    
    Parameters:
    dimension - the dimension to getScalar the norm1 along
    
    Returns:
    the norm1 along the specified dimension
  - norm2
```
INDArray norm2(int dimension)
```
    Returns the norm2 along the specified dimension
    
    Parameters:
    dimension - the dimension to getScalar the norm2 along
    
    Returns:
    the norm2 along the specified dimension
  - norm1
```
INDArray norm1(int dimension)
```
    Returns the norm1 along the specified dimension
    
    Parameters:
    dimension - the dimension to getScalar the norm1 along
    
    Returns:
    the norm1 along the specified dimension
  - std
```
INDArray std(int dimension)
```
    Standard deviation of an ndarray along a dimension
    
    Parameters:
    dimension - the dimension to getScalar the std along
    
    Returns:
    the standard deviation along a particular dimension
  - prod
```
INDArray prod(int dimension)
```
    Returns the product along a given dimension
    
    Parameters:
    dimension - the dimension to getScalar the product along
    
    Returns:
    the product along the specified dimension
  - mean
```
INDArray mean(int dimension)
```
    Returns the overall mean of this ndarray
    
    Parameters:
    dimension - the dimension to getScalar the mean along
    
    Returns:
    the mean along the specified dimension of this ndarray
  - var
```
INDArray var(int dimension)
```
    Returns the overall variance of this ndarray
    
    Parameters:
    dimension - the dimension to getScalar the mean along
    
    Returns:
    the mean along the specified dimension of this ndarray
  - max
```
INDArray max(int dimension)
```
    Returns the overall max of this ndarray
    
    Parameters:
    dimension - the dimension to getScalar the mean along
    
    Returns:
    the mean along the specified dimension of this ndarray
  - min
```
INDArray min(int dimension)
```
    Returns the overall min of this ndarray
    
    Parameters:
    dimension - the dimension to getScalar the mean along
    
    Returns:
    the mean along the specified dimension of this ndarray
  - sum
```
INDArray sum(int dimension)
```
    Returns the sum along the last dimension of this ndarray
    
    Parameters:
    dimension - the dimension to getScalar the sum along
    
    Returns:
    the sum along the specified dimension of this ndarray
  - setStride
```
void setStride(int[] stride)
```
  - subArray
```
INDArray subArray(int[] offsets,
                int[] shape,
                int[] stride)
```
    Parameters:
    offsets -
    shape -
    stride -
    
    Returns:
  - getScalar
```
INDArray getScalar(int[] indices)
```
    Returns the elements at the the specified indices
    
    Parameters:
    indices - the indices to getScalar
    
    Returns:
    the array with the specified elements
  - get
```
float get(int[] indices)
```
    Returns the elements at the the specified indices
    
    Parameters:
    indices - the indices to getScalar
    
    Returns:
    the array with the specified elements
  - get
```
float get(int i)
```
    Return the item at the linear index i
    
    Parameters:
    i - the index of the item to getScalar
    
    Returns:
    the item at index j
  - get
```
float get(int i,
        int j)
```
    Return the item at row i column j Note that this is the same as calling getScalar(new int[]{i,j}
    
    Parameters:
    i - the row to getScalar
    j - the column to getScalar
    
    Returns:
    the item at row i column j
  - dup
```
INDArray dup()
```
    Return a copy of this ndarray
    
    Returns:
    a copy of this ndarray
  - ravel
```
INDArray ravel()
```
    Returns a flattened version (row vector) of this ndarray
    
    Returns:
    a flattened version (row vector) of this ndarray
  - slices
```
int slices()
```
    Returns the number of slices in this ndarray
    
    Returns:
    the number of slices in this ndarray
  - slice
```
INDArray slice(int i,
             int dimension)
```
    Returns the specified slice of this ndarray
    
    Parameters:
    i - the index of the slice to return
    dimension - the dimension to return the slice for
    
    Returns:
    the specified slice of this ndarray
  - slice
```
INDArray slice(int i)
```
    Returns the specified slice of this ndarray
    
    Parameters:
    i - the index of the slice to return
    
    Returns:
    the specified slice of this ndarray
  - offset
```
int offset()
```
    Returns the start of where the ndarray is for the underlying data
    
    Returns:
    the starting offset
  - reshape
```
INDArray reshape(int... newShape)
```
    Reshapes the ndarray (can't change the length of the ndarray)
    
    Parameters:
    newShape - the new shape of the ndarray
    
    Returns:
    the reshaped ndarray
  - reshape
```
INDArray reshape(int rows,
               int columns)
```
    Reshapes the ndarray (can't change the length of the ndarray)
    
    Parameters:
    rows - the rows of the matrix
    columns - the columns of the matrix
    
    Returns:
    the reshaped ndarray
  - transpose
```
INDArray transpose()
```
    Flip the rows and columns of a matrix
    
    Returns:
    the flipped rows and columns of a matrix
  - swapAxes
```
INDArray swapAxes(int dimension,
                int with)
```
    Mainly here for people coming from numpy. This is equivalent to a call to permute
    
    Parameters:
    dimension - the dimension to swap
    with - the one to swap it with
    
    Returns:
    the swapped axes view
  - permute
```
INDArray permute(int... rearrange)
```
    See: http://www.mathworks.com/help/matlab/ref/permute.html
    
    Parameters:
    rearrange - the dimensions to swap to
    
    Returns:
    the newly permuted array
  - dimShuffle
```
INDArray dimShuffle(Object[] rearrange,
                  int[] newOrder,
                  boolean[] broadCastable)
```
    Dimshuffle: an extension of permute that adds the ability to broadcast various dimensions. This will only accept integers and xs. An x indicates a dimension should be broadcasted rather than permuted.
    
    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
  - getColumn
```
INDArray getColumn(int i)
```
    Returns the specified column. Throws an exception if its not a matrix
    
    Parameters:
    i - the column to getScalar
    
    Returns:
    the specified column
  - getRow
```
INDArray getRow(int i)
```
    Returns the specified row. Throws an exception if its not a matrix
    
    Parameters:
    i - the row to getScalar
    
    Returns:
    the specified row
  - columns
```
int columns()
```
    Returns the number of columns in this matrix (throws exception if not 2d)
    
    Returns:
    the number of columns in this matrix
  - rows
```
int rows()
```
    Returns the number of rows in this matrix (throws exception if not 2d)
    
    Returns:
    the number of rows in this matrix
  - isColumnVector
```
boolean isColumnVector()
```
    Returns true if the number of columns is 1
    
    Returns:
    true if the number of columns is 1
  - isRowVector
```
boolean isRowVector()
```
    Returns true if the number of rows is 1
    
    Returns:
    true if the number of rows is 1
  - isVector
```
boolean isVector()
```
    Returns true if this ndarray is a vector
    
    Returns:
    whether this ndarray is a vector
  - isMatrix
```
boolean isMatrix()
```
    Returns true if this ndarray is a matrix
    
    Returns:
    whether this ndarray is a matrix
  - isScalar
```
boolean isScalar()
```
    Returns true if this ndarray is a scalar
    
    Returns:
    whether this ndarray is a scalar
  - shape
```
int[] shape()
```
    Returns the shape of this ndarray
    
    Returns:
    the shape of this ndarray
  - stride
```
int[] stride()
```
    Returns the stride of this ndarray
    
    Returns:
    the stride of this ndarray
  - ordering
```
char ordering()
```
  - size
```
int size(int dimension)
```
    Returns the size along a specified dimension
    
    Parameters:
    dimension - the dimension to return the size for
    
    Returns:
    the size of the array along the specified dimension
  - length
```
int length()
```
    Returns the total number of elements in the ndarray
    
    Returns:
    the number of elements in the ndarray
  - broadcast
```
INDArray broadcast(int[] shape)
```
    Broadcasts this ndarray to be the specified shape
    
    Parameters:
    shape - the new shape of this ndarray
    
    Returns:
    the broadcasted ndarray
  - element
```
Object element()
```
    Returns a scalar (individual element) of a scalar ndarray
    
    Returns:
    the individual item in this ndarray
  - data
```
float[] data()
```
    Returns a linear double array representation of this ndarray
    
    Returns:
    the linear double array representation of this ndarray
  - setData
```
void setData(float[] data)
```
  - floatData
```
float[] floatData()
```
    Returns a linear float array representation of this ndarray
    
    Returns:
    the linear float array representation of this ndarray
  - rdiv
```
IComplexNDArray rdiv(IComplexNumber n)
```
  - rdivi
```
IComplexNDArray rdivi(IComplexNumber n)
```
  - rsub
```
IComplexNDArray rsub(IComplexNumber n)
```
  - rsubi
```
IComplexNDArray rsubi(IComplexNumber n)
```
  - div
```
IComplexNDArray div(IComplexNumber n)
```
  - divi
```
IComplexNDArray divi(IComplexNumber n)
```
  - mul
```
IComplexNDArray mul(IComplexNumber n)
```
  - muli
```
IComplexNDArray muli(IComplexNumber n)
```
  - sub
```
IComplexNDArray sub(IComplexNumber n)
```
  - subi
```
IComplexNDArray subi(IComplexNumber n)
```
  - add
```
IComplexNDArray add(IComplexNumber n)
```
  - addi
```
IComplexNDArray addi(IComplexNumber n)
```
  - rdiv
```
IComplexNDArray rdiv(IComplexNumber n,
                   IComplexNDArray result)
```
  - rdivi
```
IComplexNDArray rdivi(IComplexNumber n,
                    IComplexNDArray result)
```
  - rsub
```
IComplexNDArray rsub(IComplexNumber n,
                   IComplexNDArray result)
```
  - rsubi
```
IComplexNDArray rsubi(IComplexNumber n,
                    IComplexNDArray result)
```
  - div
```
IComplexNDArray div(IComplexNumber n,
                  IComplexNDArray result)
```
  - divi
```
IComplexNDArray divi(IComplexNumber n,
                   IComplexNDArray result)
```
  - mul
```
IComplexNDArray mul(IComplexNumber n,
                  IComplexNDArray result)
```
  - muli
```
IComplexNDArray muli(IComplexNumber n,
                   IComplexNDArray result)
```
  - sub
```
IComplexNDArray sub(IComplexNumber n,
                  IComplexNDArray result)
```
  - subi
```
IComplexNDArray subi(IComplexNumber n,
                   IComplexNDArray result)
```
  - add
```
IComplexNDArray add(IComplexNumber n,
                  IComplexNDArray result)
```
  - addi
```
IComplexNDArray addi(IComplexNumber n,
                   IComplexNDArray result)
```

Interface INDArray

Method Summary

Method Detail

linearView

vectorsAlongDimension

vectorAlongDimension

cumsumi

cumsum

assign

putScalar

putScalar

lt

lti

eq

eqi

gt

gti

lt

lti

eq

eqi

gt

gti

neg

negi

rdiv

rdivi

rsub

rsubi

div

divi

mul

muli

sub

subi

add

addi

rdiv

rdivi

rsub

rsubi

div

divi

mul

muli

sub

subi

add

addi

get

getColumns

getRows

rdiv

rdivi

rdiv

rdivi

rsub

rsub

rsubi

rsubi

assign

linearIndex

iterateOverAllRows

iterateOverAllColumns

checkDimensions

endsForSlices

sliceVectors

reduce

putSlice

iterateOverDimension

repmat

putRow

putColumn

getScalar

getScalar

index

squaredDistance

distance2

distance1

put