INDArray (nd4j-api 0.4-rc3 API)

All Superinterfaces:

Serializable

All Known Subinterfaces:

IComplexNDArray

All Known Implementing Classes:

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

Author:

Adam Gibson

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`IComplexNDArray`	`add(IComplexNumber n)`
`IComplexNDArray`	`add(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`add(INDArray other)` copy addition of two matrices
`INDArray`	`add(INDArray other, INDArray result)` copy addition of two matrices
`INDArray`	`add(Number n)` Scalar addition (cloning)
`INDArray`	`add(Number n, INDArray result)`
`INDArray`	`addColumnVector(INDArray columnVector)` Addition of a column vector (copy)
`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 row vector
`INDArray`	`addRowVector(INDArray rowVector)` Addition of a row vector (copy)
`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
`void`	`cleanup()` Cleanup resources
`int`	`columns()` Returns the number of columns in this matrix (throws exception if not 2d)
`INDArray`	`cond(Condition condition)` 1 in the ndarray if the element matches the condition 0 otherwise
`INDArray`	`condi(Condition condition)` 1 in the ndarray if the element matches the condition 0 otherwise
`INDArray`	`cumsum(int dimension)` Cumulative sum along a dimension (in place)
`INDArray`	`cumsumi(int dimension)` Cumulative sum along a dimension
`DataBuffer`	`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.
`double`	`distance1(INDArray other)` Returns the (1-norm) distance.
`double`	`distance2(INDArray other)` Returns the (euclidean) distance.
`IComplexNDArray`	`div(IComplexNumber n)`
`IComplexNDArray`	`div(IComplexNumber n, 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)` Division by a number
`INDArray`	`div(Number n, INDArray result)`
`INDArray`	`divColumnVector(INDArray columnVector)` Division of a column vector (copy)
`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 division of a column vector
`INDArray`	`diviRowVector(INDArray rowVector)` In place division of a row vector
`INDArray`	`divRowVector(INDArray rowVector)` Division of a row vector (copy)
`INDArray`	`dup()` Return a copy of this ndarray
`INDArray`	`dup(char order)` Return a copy of this ndarray, where the returned ndarray has the specified order
`Object`	`element()` Returns a scalar (individual element) of a scalar ndarray
`int`	`elementStride()` Element stride (one element to the next, also called the defualt stride: 1 for normal 2 for complex)
`int`	`elementWiseStride()` Element wise stride
`INDArray`	`eps(INDArray other)` epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`INDArray`	`eps(Number other)` Returns an ndarray with 1 if the element is epsilon equals
`INDArray`	`epsi(INDArray other)` In place epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
`INDArray`	`epsi(Number other)` Returns an ndarray with 1 if the element is epsilon equals
`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
`INDArray`	`get(INDArrayIndex... 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
`double`	`getDouble(int... indices)`
`double`	`getDouble(int i)`
`double`	`getDouble(int i, int j)`
`float`	`getFloat(int i)` Return the item at the linear index i
`float`	`getFloat(int[] indices)` Returns the elements at the the specified indices
`float`	`getFloat(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}
`int`	`getInt(int... indices)`
`int`	`getLeadingOnes()`
`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
`int`	`getTrailingOnes()`
`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)` Greater than boolean (copying)(
`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
`int`	`innerMostStride()` Get the inner most stride wrt the ordering of the array
`boolean`	`isCleanedUp()` Returns true if the ndarray has already been freed
`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`	`isSquare()` Returns whether the matrix has the same rows and columns
`boolean`	`isVector()` Returns true if this ndarray is a vector
`boolean`	`isWrapAround()` Returns true if the ndarray on linear indexing wraps around based on the stride(1) of the ndarray This is a useful optimization in linear view where strides that might otherwise go out of bounds but wrap around instead.
`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`	`linearViewColumnOrder()` 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
`int`	`majorStride()` Return the major stride for an ndarray
`INDArray`	`max(int... dimension)` Returns the overall max of this ndarray
`IComplexNumber`	`maxComplex()`
`Number`	`maxNumber()`
`INDArray`	`mean(int... dimension)` Returns the overall mean of this ndarray
`IComplexNumber`	`meanComplex()`
`Number`	`meanNumber()`
`INDArray`	`min(int... dimension)` Returns the overall min of this ndarray
`IComplexNumber`	`minComplex()`
`Number`	`minNumber()`
`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)` Scalar multiplication (copy)
`INDArray`	`mul(Number n, INDArray result)`
`INDArray`	`mulColumnVector(INDArray columnVector)` Multiplication of a column vector (copy)
`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 multiplication of a column vector
`INDArray`	`muliRowVector(INDArray rowVector)` In place multiplication of a row vector
`INDArray`	`mulRowVector(INDArray rowVector)` Multiplication of a row vector (copy)
`INDArray`	`neg()` Returns the ndarray negative (cloned)
`INDArray`	`negi()` In place setting of the negative version of this ndarray
`INDArray`	`neq(INDArray other)`
`INDArray`	`neq(Number other)` Not equal
`INDArray`	`neqi(INDArray other)`
`INDArray`	`neqi(Number other)` In place not equal
`INDArray`	`norm1(int... dimension)` Returns the norm1 along the specified dimension
`IComplexNumber`	`norm1Complex()`
`Number`	`norm1Number()`
`INDArray`	`norm2(int... dimension)` Returns the norm2 along the specified dimension
`IComplexNumber`	`norm2Complex()`
`Number`	`norm2Number()`
`INDArray`	`normmax(int... dimension)` Returns the normmax along the specified dimension
`IComplexNumber`	`normmaxComplex()`
`Number`	`normmaxNumber()`
`int`	`offset()` Returns the start of where the ndarray is for the underlying data
`char`	`ordering()` Return the ordering (fortran or c) of this ndarray
`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
`IComplexNumber`	`prodComplex()`
`Number`	`prodNumber()`
`INDArray`	`put(INDArrayIndex[] indices, INDArray element)` Put the elements of the ndarray in to the specified indices
`INDArray`	`put(INDArrayIndex[] indices, Number element)` Put the elements of the ndarray in to the specified indices
`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`	`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, double value)` Insert the item at the specified indices
`INDArray`	`putScalar(int[] indexes, float value)`
`INDArray`	`putScalar(int[] indexes, int value)`
`INDArray`	`putScalar(int i, double value)` Insert the number linearly in to the ndarray
`INDArray`	`putScalar(int i, float value)` Insert a scalar float at the specified index
`INDArray`	`putScalar(int i, int value)` Insert a scalar int at the specified index
`INDArray`	`putSlice(int slice, INDArray put)` Assigns the given matrix (put) to the specified slice
`int`	`rank()` The rank of the ndarray (the number of dimensions
`INDArray`	`ravel()` Returns a flattened version (row vector) of this ndarray
`INDArray`	`ravel(char order)` 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)` Reverse division
`INDArray`	`rdiv(Number n, INDArray result)` Reverse division (number / ndarray)
`INDArray`	`rdivColumnVector(INDArray columnVector)` Reverse division of a column vector (copy)
`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 division
`INDArray`	`rdivi(Number n, INDArray result)` Reverse in place division
`INDArray`	`rdiviColumnVector(INDArray columnVector)` In place reverse divison of a column vector
`INDArray`	`rdiviRowVector(INDArray rowVector)` In place reverse division of a column vector
`INDArray`	`rdivRowVector(INDArray rowVector)` Reverse division of a column vector (copy)
`INDArray`	`repeat(int... repeats)` Returns a flat array with the elements repeated k times along each given dimension
`INDArray`	`repeat(int dimension, int... repeats)` Repeat elements along a specified dimension.
`INDArray`	`repmat(int... shape)` Replicate and tile array to fill out to the given shape
`void`	`resetLinearView()` Resets the linear view
`INDArray`	`reshape(char order, int... newShape)` Reshapes the ndarray (can't change the length of the ndarray)
`INDArray`	`reshape(char order, int rows, int columns)` Reshapes the ndarray (can't change the length of the ndarray)
`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)` Reverse subtraction with duplicates
`INDArray`	`rsub(Number n, INDArray result)` Reverse subtraction
`INDArray`	`rsubColumnVector(INDArray columnVector)` Reverse subtraction of a column vector (copy)
`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
`INDArray`	`rsubiColumnVector(INDArray columnVector)` In place reverse subtraction of a column vector
`INDArray`	`rsubiRowVector(INDArray rowVector)` In place reverse subtraction of a row vector
`INDArray`	`rsubRowVector(INDArray rowVector)` Reverse subtraction of a row vector (copy)
`int`	`secondaryStride()` Return the second stride for an ndarray.
`void`	`setData(DataBuffer data)`
`void`	`setOrder(char order)` Set the ordering
`void`	`setShape(int... shape)` Shape setter
`void`	`setStride(int... stride)` stride setter
`void`	`setWrapAround(boolean wrapAround)` Set the ndarray to wrap around
`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)`
`double`	`squaredDistance(INDArray other)` Returns the squared (Euclidean) distance.
`INDArray`	`std(int... dimension)` Standard deviation of an ndarray along a dimension
`IComplexNumber`	`stdComplex()`
`Number`	`stdNumber()`
`int[]`	`stride()` Returns the stride of this ndarray
`int`	`stride(int dimension)` Calculate the stride along a particular dimension
`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)` Scalar subtraction (copied)
`INDArray`	`sub(Number n, INDArray result)`
`INDArray`	`subArray(int[] offsets, int[] shape, int[] stride)`
`INDArray`	`subArray(ShapeOffsetResolution resolution)` Sub array based on the pre calculated shape,strides, offsets
`INDArray`	`subColumnVector(INDArray columnVector)` Subtraction of a column vector (copy)
`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 subtraction of a column vector
`INDArray`	`subiRowVector(INDArray rowVector)` In place subtraction of a row vector
`INDArray`	`subRowVector(INDArray rowVector)` Subtraction of a row vector (copy)
`INDArray`	`sum(int... dimension)` Returns the sum along the last dimension of this ndarray
`IComplexNumber`	`sumComplex()` Sum the entire array
`Number`	`sumNumber()` Sum the entire array
`INDArray`	`swapAxes(int dimension, int with)` Mainly here for people coming from numpy.
`INDArray`	`tensorAlongDimension(int index, int... dimension)` Get the vector along a particular dimension
`int`	`tensorssAlongDimension(int... dimension)` Returns the number of possible vectors for a given dimension
`INDArray`	`transpose()` Flip the rows and columns of a matrix
`INDArray`	`transposei()` Flip the rows and columns of a matrix
`INDArray`	`var(int... dimension)` Returns the overall variance of this ndarray
`IComplexNumber`	`varComplex()`
`Number`	`varNumber()`
`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
  - setWrapAround
```
void setWrapAround(boolean wrapAround)
```
    Set the ndarray to wrap around
    
    Parameters:
    
    wrapAround - thewrap around
  - isWrapAround
```
boolean isWrapAround()
```
    Returns true if the ndarray on linear indexing wraps around based on the stride(1) of the ndarray This is a useful optimization in linear view where strides that might otherwise go out of bounds but wrap around instead.
    
    Returns:
    
    true if this ndarray wraps around on linear indexing, false otherwise
  - rank
```
int rank()
```
    The rank of the ndarray (the number of dimensions
    
    Returns:
    
    the rank for the ndarray
  - stride
```
int stride(int dimension)
```
    Calculate the stride along a particular dimension
    
    Parameters:
    
    dimension - the dimension to get the stride for
    
    Returns:
    
    the stride for a particular dimension
  - elementStride
```
int elementStride()
```
    Element stride (one element to the next, also called the defualt stride: 1 for normal 2 for complex)
    
    Returns:
  - elementWiseStride
```
int elementWiseStride()
```
    Element wise stride
  - isCleanedUp
```
boolean isCleanedUp()
```
    Returns true if the ndarray has already been freed
    
    Returns:
  - cleanup
```
void cleanup()
```
    Cleanup resources
  - resetLinearView
```
void resetLinearView()
```
    Resets the linear view
  - secondaryStride
```
int secondaryStride()
```
    Return the second stride for an ndarray. Think of this as the stride for the next element in a column.
    
    Returns:
    
    the secondary stride for an ndarray
  - majorStride
```
int majorStride()
```
    Return the major stride for an ndarray
    
    Returns:
    
    the major stride for an ndarray
  - innerMostStride
```
int innerMostStride()
```
    Get the inner most stride wrt the ordering of the array
    
    Returns:
  - linearView
```
INDArray linearView()
```
    Returns a linear view reference of shape 1,length(ndarray)
    
    Returns:
    
    the linear view of this ndarray
  - linearViewColumnOrder
```
INDArray linearViewColumnOrder()
```
    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
  - tensorssAlongDimension
```
int tensorssAlongDimension(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
  - tensorAlongDimension
```
INDArray tensorAlongDimension(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,
                   double 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,
                   float value)
```
    Insert a scalar float at the specified index
    
    Parameters:
    
    i -
    
    value -
    
    Returns:
  - putScalar
```
INDArray putScalar(int i,
                   int value)
```
    Insert a scalar int at the specified index
    
    Parameters:
    
    i -
    
    value -
    
    Returns:
  - putScalar
```
INDArray putScalar(int[] i,
                   double 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:
  - putScalar
```
INDArray putScalar(int[] indexes,
                   float value)
```
    Parameters:
    
    indexes -
    
    value -
    
    Returns:
  - putScalar
```
INDArray putScalar(int[] indexes,
                   int value)
```
    Parameters:
    
    indexes -
    
    value -
    
    Returns:
  - eps
```
INDArray eps(Number other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - epsi
```
INDArray epsi(Number other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - 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)
```
    Greater than boolean (copying)(
    
    Parameters:
    
    other -
    
    Returns:
  - 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:
  - eps
```
INDArray eps(INDArray other)
```
    epsilon equals 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:
  - epsi
```
INDArray epsi(INDArray other)
```
    In place epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - neq
```
INDArray neq(Number other)
```
    Not equal
    
    Parameters:
    
    other -
    
    Returns:
  - neqi
```
INDArray neqi(Number other)
```
    In place not equal
    
    Parameters:
    
    other -
    
    Returns:
  - neq
```
INDArray neq(INDArray other)
```
    Parameters:
    
    other -
    
    Returns:
  - neqi
```
INDArray neqi(INDArray other)
```
    Parameters:
    
    other -
    
    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)
```
    Reverse division
    
    Parameters:
    
    n -
    
    Returns:
  - rdivi
```
INDArray rdivi(Number n)
```
    In place reverse division
    
    Parameters:
    
    n -
    
    Returns:
  - rsub
```
INDArray rsub(Number n)
```
    Reverse subtraction with duplicates
    
    Parameters:
    
    n -
    
    Returns:
  - rsubi
```
INDArray rsubi(Number n)
```
    Parameters:
    
    n -
    
    Returns:
  - div
```
INDArray div(Number n)
```
    Division by a number
    
    Parameters:
    
    n -
    
    Returns:
  - divi
```
INDArray divi(Number n)
```
    In place scalar division
    
    Parameters:
    
    n -
    
    Returns:
  - mul
```
INDArray mul(Number n)
```
    Scalar multiplication (copy)
    
    Parameters:
    
    n - the number to multiply by
    
    Returns:
    
    a copy of this ndarray multiplied by the given number
  - muli
```
INDArray muli(Number n)
```
    In place scalar multiplication
    
    Parameters:
    
    n -
    
    Returns:
  - sub
```
INDArray sub(Number n)
```
    Scalar subtraction (copied)
    
    Parameters:
    
    n - the number to subtract by
    
    Returns:
    
    this ndarray - the given number
  - subi
```
INDArray subi(Number n)
```
    In place scalar subtraction
    
    Parameters:
    
    n -
    
    Returns:
  - add
```
INDArray add(Number n)
```
    Scalar addition (cloning)
    
    Parameters:
    
    n - the number to add
    
    Returns:
    
    a clone with this matrix + the given number
  - addi
```
INDArray addi(Number n)
```
    In place scalar addition
    
    Parameters:
    
    n -
    
    Returns:
  - rdiv
```
INDArray rdiv(Number n,
              INDArray result)
```
    Reverse division (number / ndarray)
    
    Parameters:
    
    n - the number to divide by
    
    result -
    
    Returns:
  - 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)
```
    Reverse subtraction
    
    Parameters:
    
    n - the number to subtract by
    
    result - the result ndarray
    
    Returns:
  - 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)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - 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(INDArrayIndex... 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
  - checkDimensions
```
void checkDimensions(INDArray other)
```
    Validate dimensions are equal
    
    Parameters:
    
    other - the other ndarray to compare
  - sliceVectors
```
void sliceVectors(List<INDArray> list)
```
    Parameters:
    
    list -
  - 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
  - cond
```
INDArray cond(Condition condition)
```
    1 in the ndarray if the element matches the condition 0 otherwise
    
    Parameters:
    
    condition -
    
    Returns:
  - condi
```
INDArray condi(Condition condition)
```
    1 in the ndarray if the element matches the condition 0 otherwise
    
    Parameters:
    
    condition -
    
    Returns:
  - 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
  - repeat
```
INDArray repeat(int dimension,
                int... repeats)
```
    Repeat elements along a specified dimension.
    
    Parameters:
    
    dimension - the dimension to repeat
    
    repeats - the number of elements to repeat on each element
    
    Returns:
  - repeat
```
INDArray repeat(int... repeats)
```
    Returns a flat array with the elements repeated k times along each given dimension
    
    Parameters:
    
    repeats -
    
    Returns:
  - 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
```
double squaredDistance(INDArray other)
```
    Returns the squared (Euclidean) distance.
  - distance2
```
double distance2(INDArray other)
```
    Returns the (euclidean) distance.
  - distance1
```
double distance1(INDArray other)
```
    Returns the (1-norm) distance.
  - put
```
INDArray put(INDArrayIndex[] indices,
             INDArray element)
```
    Put the elements of the ndarray in to the specified indices
    
    Parameters:
    
    indices - the indices to put the ndarray in to
    
    element - the ndarray to put
    
    Returns:
    
    this ndarray
  - put
```
INDArray put(INDArrayIndex[] indices,
             Number element)
```
    Put the elements of the ndarray in to the specified indices
    
    Parameters:
    
    indices - the indices to put the ndarray in to
    
    element - the ndarray to put
    
    Returns:
    
    this ndarray
  - 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 division of a column vector
    
    Parameters:
    
    columnVector - the column vector used for division
    
    Returns:
    
    the result of the division
  - divColumnVector
```
INDArray divColumnVector(INDArray columnVector)
```
    Division of a column vector (copy)
    
    Parameters:
    
    columnVector - the column vector used for division
    
    Returns:
    
    the result of the division
  - diviRowVector
```
INDArray diviRowVector(INDArray rowVector)
```
    In place division of a row vector
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - divRowVector
```
INDArray divRowVector(INDArray rowVector)
```
    Division of a row vector (copy)
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - rdiviColumnVector
```
INDArray rdiviColumnVector(INDArray columnVector)
```
    In place reverse divison of a column vector
    
    Parameters:
    
    columnVector - the column vector used for division
    
    Returns:
    
    the result of the division
  - rdivColumnVector
```
INDArray rdivColumnVector(INDArray columnVector)
```
    Reverse division of a column vector (copy)
    
    Parameters:
    
    columnVector - the column vector used for division
    
    Returns:
    
    the result of the division
  - rdiviRowVector
```
INDArray rdiviRowVector(INDArray rowVector)
```
    In place reverse division of a column vector
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - rdivRowVector
```
INDArray rdivRowVector(INDArray rowVector)
```
    Reverse division of a column vector (copy)
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - muliColumnVector
```
INDArray muliColumnVector(INDArray columnVector)
```
    In place multiplication of a column vector
    
    Parameters:
    
    columnVector - the column vector used for multiplication
    
    Returns:
    
    the result of the multiplication
  - mulColumnVector
```
INDArray mulColumnVector(INDArray columnVector)
```
    Multiplication of a column vector (copy)
    
    Parameters:
    
    columnVector - the column vector used for multiplication
    
    Returns:
    
    the result of the multiplication
  - muliRowVector
```
INDArray muliRowVector(INDArray rowVector)
```
    In place multiplication of a row vector
    
    Parameters:
    
    rowVector - the row vector used for multiplication
    
    Returns:
    
    the result of the multiplication
  - mulRowVector
```
INDArray mulRowVector(INDArray rowVector)
```
    Multiplication of a row vector (copy)
    
    Parameters:
    
    rowVector - the row vector used for multiplication
    
    Returns:
    
    the result of the multiplication
  - rsubiColumnVector
```
INDArray rsubiColumnVector(INDArray columnVector)
```
    In place reverse subtraction of a column vector
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubColumnVector
```
INDArray rsubColumnVector(INDArray columnVector)
```
    Reverse subtraction of a column vector (copy)
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubiRowVector
```
INDArray rsubiRowVector(INDArray rowVector)
```
    In place reverse subtraction of a row vector
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubRowVector
```
INDArray rsubRowVector(INDArray rowVector)
```
    Reverse subtraction of a row vector (copy)
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - subiColumnVector
```
INDArray subiColumnVector(INDArray columnVector)
```
    In place subtraction of a column vector
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - subColumnVector
```
INDArray subColumnVector(INDArray columnVector)
```
    Subtraction of a column vector (copy)
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - subiRowVector
```
INDArray subiRowVector(INDArray rowVector)
```
    In place subtraction of a row vector
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - subRowVector
```
INDArray subRowVector(INDArray rowVector)
```
    Subtraction of a row vector (copy)
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - 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)
```
    Addition of a column vector (copy)
    
    Parameters:
    
    columnVector - the column vector to add
    
    Returns:
    
    the result of the addition
  - addiRowVector
```
INDArray addiRowVector(INDArray rowVector)
```
    In place addition of a row vector
    
    Parameters:
    
    rowVector - the row vector to add
    
    Returns:
    
    the result of the addition
  - addRowVector
```
INDArray addRowVector(INDArray rowVector)
```
    Addition of a row vector (copy)
    
    Parameters:
    
    rowVector - the row 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
  - normmaxNumber
```
Number normmaxNumber()
```
  - normmaxComplex
```
IComplexNumber normmaxComplex()
```
  - 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
  - norm2Number
```
Number norm2Number()
```
  - norm2Complex
```
IComplexNumber norm2Complex()
```
  - 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
  - norm1Number
```
Number norm1Number()
```
  - norm1Complex
```
IComplexNumber norm1Complex()
```
  - 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
  - stdNumber
```
Number stdNumber()
```
  - stdComplex
```
IComplexNumber stdComplex()
```
  - 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
  - prodNumber
```
Number prodNumber()
```
  - prodComplex
```
IComplexNumber prodComplex()
```
  - 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
  - meanNumber
```
Number meanNumber()
```
  - meanComplex
```
IComplexNumber meanComplex()
```
  - 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
  - varNumber
```
Number varNumber()
```
  - varComplex
```
IComplexNumber varComplex()
```
  - 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
  - maxNumber
```
Number maxNumber()
```
  - maxComplex
```
IComplexNumber maxComplex()
```
  - 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
  - minNumber
```
Number minNumber()
```
  - minComplex
```
IComplexNumber minComplex()
```
  - 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
  - sumNumber
```
Number sumNumber()
```
    Sum the entire array
    
    Returns:
  - sumComplex
```
IComplexNumber sumComplex()
```
    Sum the entire array
    
    Returns:
  - setStride
```
void setStride(int... stride)
```
    stride setter
    
    Parameters:
    
    stride -
  - setShape
```
void setShape(int... shape)
```
    Shape setter
    
    Parameters:
    
    shape -
  - setOrder
```
void setOrder(char order)
```
    Set the ordering
    
    Parameters:
    
    order - the ordering to set
  - subArray
```
INDArray subArray(ShapeOffsetResolution resolution)
```
    Sub array based on the pre calculated shape,strides, offsets
    
    Parameters:
    
    resolution - the resolution to use
    
    Returns:
    
    the sub array based on the calculations from the resolution
  - 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
  - getInt
```
int getInt(int... indices)
```
    Parameters:
    
    indices -
    
    Returns:
  - getDouble
```
double getDouble(int... indices)
```
    Parameters:
    
    indices -
    
    Returns:
  - getFloat
```
float getFloat(int[] indices)
```
    Returns the elements at the the specified indices
    
    Parameters:
    
    indices - the indices to getScalar
    
    Returns:
    
    the array with the specified elements
  - getDouble
```
double getDouble(int i)
```
    Parameters:
    
    i -
    
    Returns:
  - getDouble
```
double getDouble(int i,
                 int j)
```
    Parameters:
    
    i -
    
    j -
    
    Returns:
  - getFloat
```
float getFloat(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
  - getFloat
```
float getFloat(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
  - dup
```
INDArray dup(char order)
```
    Return a copy of this ndarray, where the returned ndarray has the specified order
    
    Parameters:
    
    order - Order of the NDArray. 'f' or 'c'
    
    Returns:
    
    copy of ndarray with specified order
  - ravel
```
INDArray ravel()
```
    Returns a flattened version (row vector) of this ndarray
    
    Returns:
    
    a flattened version (row vector) of this ndarray
  - ravel
```
INDArray ravel(char order)
```
    Returns a flattened version (row vector) of this ndarray
    
    Returns:
    
    a flattened version (row vector) of this ndarray
  - setData
```
void setData(DataBuffer data)
```
    Parameters:
    
    data -
  - slices
```
int slices()
```
    Returns the number of slices in this ndarray
    
    Returns:
    
    the number of slices in this ndarray
  - getTrailingOnes
```
int getTrailingOnes()
```
    Returns:
  - getLeadingOnes
```
int getLeadingOnes()
```
    Returns:
  - 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(char order,
                 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(char order,
                 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
  - 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
  - transposei
```
INDArray transposei()
```
    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. Examples originally from the theano docs: http://deeplearning.net/software/theano/library/tensor/basic.html Returns a view of this tensor with permuted dimensions. Typically the pattern will include the integers 0, 1, ... ndim-1, and any number of ‘x’ characters in dimensions where this tensor should be broadcasted. A few examples of patterns and their effect: (‘x’) -> make a 0d (scalar) into a 1d vector (0, 1) -> identity for 2d vectors (1, 0) -> inverts the first and second dimensions (‘x’, 0) -> make a row out of a 1d vector (N to 1xN) (0, ‘x’) -> make a column out of a 1d vector (N to Nx1) (2, 0, 1) -> AxBxC to CxAxB (0, ‘x’, 1) -> AxB to Ax1xB (1, ‘x’, 0) -> AxB to Bx1xA (1,) -> This remove dimensions 0. It must be a broadcastable dimension (1xA to A)
    
    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
  - isSquare
```
boolean isSquare()
```
    Returns whether the matrix has the same rows and columns
    
    Returns:
    
    true if the matrix has the same rows and columns false otherwise
  - 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()
```
    Return the ordering (fortran or c) of this ndarray
    
    Returns:
    
    the ordering of this ndarray
  - 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
```
DataBuffer data()
```
    Returns a linear double array representation of this ndarray
    
    Returns:
    
    the linear double array representation of this ndarray
  - rdiv
```
IComplexNDArray rdiv(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - rdivi
```
IComplexNDArray rdivi(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - rsub
```
IComplexNDArray rsub(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - rsubi
```
IComplexNDArray rsubi(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - div
```
IComplexNDArray div(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - divi
```
IComplexNDArray divi(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - mul
```
IComplexNDArray mul(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - muli
```
IComplexNDArray muli(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - sub
```
IComplexNDArray sub(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - subi
```
IComplexNDArray subi(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - add
```
IComplexNDArray add(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - addi
```
IComplexNDArray addi(IComplexNumber n)
```
    Parameters:
    
    n -
    
    Returns:
  - rdiv
```
IComplexNDArray rdiv(IComplexNumber n,
                     IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - rdivi
```
IComplexNDArray rdivi(IComplexNumber n,
                      IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - rsub
```
IComplexNDArray rsub(IComplexNumber n,
                     IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - rsubi
```
IComplexNDArray rsubi(IComplexNumber n,
                      IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - div
```
IComplexNDArray div(IComplexNumber n,
                    IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - divi
```
IComplexNDArray divi(IComplexNumber n,
                     IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - mul
```
IComplexNDArray mul(IComplexNumber n,
                    IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - muli
```
IComplexNDArray muli(IComplexNumber n,
                     IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - sub
```
IComplexNDArray sub(IComplexNumber n,
                    IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - subi
```
IComplexNDArray subi(IComplexNumber n,
                     IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - add
```
IComplexNDArray add(IComplexNumber n,
                    IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:
  - addi
```
IComplexNDArray addi(IComplexNumber n,
                     IComplexNDArray result)
```
    Parameters:
    
    n -
    
    result -
    
    Returns:

Interface INDArray

Method Summary

Method Detail

setWrapAround

isWrapAround

rank

stride

elementStride

elementWiseStride

isCleanedUp

cleanup

resetLinearView

secondaryStride

majorStride

innerMostStride

linearView

linearViewColumnOrder

vectorsAlongDimension

vectorAlongDimension

tensorssAlongDimension

tensorAlongDimension

cumsumi

cumsum

assign

putScalar

putScalar

putScalar

putScalar

lt

lti

putScalar

putScalar

eps

epsi

eq

eqi

gt

gti

lt

lti

eps

epsi

neq

neqi

neq

neqi

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