BaseNDArray (nd4j-api 0.0.1 API)

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

All Implemented Interfaces:

Serializable, INDArray

Direct Known Subclasses:

BaseComplexNDArray
```
public abstract class BaseNDArray
extends Object
implements INDArray
```
NDArray: (think numpy) A few things of note. An NDArray can have any number of dimensions. An NDArray is accessed via strides. Strides are how to index over a contiguous block of data. This block of data has 2 orders(as of right now): fortran and c

Author:

Adam Gibson

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`columns`
`protected float[]`	`data`
`protected int`	`length`
`protected INDArray`	`linearView`
`protected int`	`offset`
`protected char`	`ordering`
`protected int`	`rows`
`protected int[]`	`shape`
`protected int[]`	`stride`

Constructor Summary

Constructors
Constructor and Description
`BaseNDArray()`
`BaseNDArray(double[][] data)`
`BaseNDArray(float[] data)`
`BaseNDArray(float[][] data)`
`BaseNDArray(float[] data, int[] shape)` Create this ndarray with the given data and shape and 0 offset
`BaseNDArray(float[] data, int[] shape, char ordering)` Create this ndarray with the given data and shape and 0 offset
`BaseNDArray(float[] data, int[] shape, int offset)`
`BaseNDArray(float[] data, int[] shape, int[] stride)`
`BaseNDArray(float[] data, int[] shape, int[] stride, char ordering)`
`BaseNDArray(float[] data, int[] shape, int[] stride, int offset)`
`BaseNDArray(float[] data, int[] shape, int[] stride, int offset, char ordering)`
`BaseNDArray(float[] data, int[] shape, int offset, char ordering)`
`BaseNDArray(int[] shape)`
`BaseNDArray(int[] shape, char ordering)`
`BaseNDArray(int[] shape, int offset)`
`BaseNDArray(int[] shape, int[] stride)` Create the ndarray with the specified shape and stride and an offset of 0
`BaseNDArray(int[] shape, int[] stride, char ordering)` Create the ndarray with the specified shape and stride and an offset of 0
`BaseNDArray(int[] shape, int[] stride, int offset)` Construct an ndarray of the specified shape with an empty data array
`BaseNDArray(int[] shape, int[] stride, int offset, char ordering)` Construct an ndarray of the specified shape with an empty data array
`BaseNDArray(int[] shape, int offset, char ordering)`
`BaseNDArray(int newRows, int newColumns)` Creates a new n times m `DoubleMatrix`.
`BaseNDArray(int newRows, int newColumns, char ordering)` Creates a new n times m `DoubleMatrix`.
`BaseNDArray(List<INDArray> slices, int[] shape)` Create an ndarray from the specified slices.
`BaseNDArray(List<INDArray> slices, int[] shape, char ordering)` Create an ndarray from the specified slices.
`BaseNDArray(List<INDArray> slices, int[] shape, int[] stride)` Create an ndarray from the specified slices.
`BaseNDArray(List<INDArray> slices, int[] shape, int[] stride, char ordering)` Create an ndarray from the specified slices.

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
`protected void`	`asserColumnVector(INDArray column)`
`protected void`	`assertRowVector(INDArray rowVector)`
`protected void`	`assertSlice(INDArray put, int slice)`
`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
`protected void`	`checkArrangeArray(int[] arr)`
`void`	`checkDimensions(INDArray other)` Validate dimensions are equal
`int`	`columns()` Number of columns (shape[1]), throws an exception when called when not 2d
`protected void`	`copyRealTo(INDArray arr)`
`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.
`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)`
`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
`protected INDArray`	`doColumnWise(INDArray columnVector, char operation)` Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide
`protected int[]`	`doPermuteSwap(int[] shape, int[] rearrange)`
`protected INDArray`	`doRowWise(INDArray rowVector, char operation)` Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide
`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
`boolean`	`equals(Object o)` Compare two matrices.
`float[]`	`floatData()` Returns a linear float array representation of this ndarray
`float`	`get(int... indices)` Returns the elements at the the specified indices
`float`	`get(int i)` Return the item at the linear index i
`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 c)` Get the specified column
`INDArray`	`getColumns(int[] cindices)` Get whole columns from the passed indices.
`static int`	`getIndex(int offset, int[] stride, int... indexes)` Mainly an internal method (public for testing) for given an offset and stride, and index, calculating the beginning index of a query given indices
`INDArray`	`getRow(int r)` Get a copy of a row.
`INDArray`	`getRows(int[] rindices)` Get whole rows from the passed indices.
`INDArray`	`getScalar(int... indexes)` Fetch a particular number on a multi dimensional scale.
`INDArray`	`getScalar(int i)` Returns the element at the specified index
`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
`protected void`	`initShape(int[] shape)`
`boolean`	`isColumnVector()` Checks whether the matrix is a column vector.
`boolean`	`isMatrix()` Returns true if this ndarray is 2d or 3d with a singleton element
`boolean`	`isRowVector()` Checks whether the matrix is a row vector.
`boolean`	`isScalar()` Test whether a matrix is scalar.
`boolean`	`isVector()` Checks whether the matrix 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()` Negate each element.
`INDArray`	`negi()` Negate each element (in-place).
`protected INDArray`	`newShape(int[] newShape, char ordering)`
`protected int[]`	`noCopyReshape(int[] newShape, char ordering)` Return the new strides based on the shape and ordering or null if we can't do a reshape
`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.htsliceml
`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[] indexes, 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()` Flattens the array for linear indexing
`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
`protected float`	`reduceVector(Ops.DimensionOp op, INDArray vector)`
`INDArray`	`repmat(int[] shape)` Replicate and tile array to fill out to the given shape
`INDArray`	`reshape(int[] shape)` Reshape the ndarray in to the specified dimensions, possible errors being thrown for invalid shapes
`INDArray`	`reshape(int newRows, int newColumns)` Reshape the matrix.
`int`	`rows()` Returns the number of rows in the array (only 2d) throws an exception when called when 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(dimensions) of this array
`int`	`size(int dimension)` Returns the size of this array along a particular dimension
`INDArray`	`slice(int slice)` Returns the specified slice of this matrix.
`INDArray`	`slice(int slice, int dimension)` Returns the slice of this from the specified dimension
`int`	`slices()` Number of slices: aka shape[0]
`void`	`sliceVectors(List<INDArray> list)` Flattens the array for linear indexing
`double`	`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(indices along the linear index for which each slice is accessed) of this array
`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.
`String`	`toString()` Generate string representation of the matrix.
`INDArray`	`transpose()` Return transposed copy of this 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
`DimensionSlice`	`vectorForDimensionAndOffset(int dimension, int offset)`
`int`	`vectorsAlongDimension(int dimension)` Returns the number of possible vectors for a given dimension

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

- Field Detail
  - shape
```
protected int[] shape
```
  - stride
```
protected int[] stride
```
  - offset
```
protected int offset
```
  - ordering
```
protected char ordering
```
  - data
```
protected float[] data
```
  - rows
```
protected int rows
```
  - columns
```
protected int columns
```
  - length
```
protected int length
```
  - linearView
```
protected INDArray linearView
```
- Constructor Detail
  - BaseNDArray
```
public BaseNDArray()
```
  - BaseNDArray
```
public BaseNDArray(double[][] data)
```
  - BaseNDArray
```
public BaseNDArray(float[] data,
           int[] shape,
           char ordering)
```
    Create this ndarray with the given data and shape and 0 offset
    
    Parameters:
    data - the data to use
    shape - the shape of the ndarray
  - BaseNDArray
```
public BaseNDArray(float[] data,
           int[] shape,
           int offset,
           char ordering)
```
    Parameters:
    data - the data to use
    shape - the shape of the ndarray
    offset - the desired offset
    ordering - the ordering of the ndarray
  - BaseNDArray
```
public BaseNDArray(int[] shape,
           int[] stride,
           int offset,
           char ordering)
```
    Construct an ndarray of the specified shape with an empty data array
    
    Parameters:
    shape - the shape of the ndarray
    stride - the stride of the ndarray
    offset - the desired offset
    ordering - the ordering of the ndarray
  - BaseNDArray
```
public BaseNDArray(int[] shape,
           int[] stride,
           char ordering)
```
    Create the ndarray with the specified shape and stride and an offset of 0
    
    Parameters:
    shape - the shape of the ndarray
    stride - the stride of the ndarray
    ordering - the ordering of the ndarray
  - BaseNDArray
```
public BaseNDArray(int[] shape,
           int offset,
           char ordering)
```
  - BaseNDArray
```
public BaseNDArray(int[] shape)
```
  - BaseNDArray
```
public BaseNDArray(int newRows,
           int newColumns,
           char ordering)
```
    Creates a new n times m DoubleMatrix.
    
    Parameters:
    newRows - the number of rows (n) of the new matrix.
    newColumns - the number of columns (m) of the new matrix.
  - BaseNDArray
```
public BaseNDArray(List<INDArray> slices,
           int[] shape,
           char ordering)
```
    Create an ndarray from the specified slices. This will go through and merge all of the data from each slice in to one ndarray which will then take the specified shape
    
    Parameters:
    slices - the slices to merge
    shape - the shape of the ndarray
  - BaseNDArray
```
public BaseNDArray(List<INDArray> slices,
           int[] shape,
           int[] stride,
           char ordering)
```
    Create an ndarray from the specified slices. This will go through and merge all of the data from each slice in to one ndarray which will then take the specified shape
    
    Parameters:
    slices - the slices to merge
    shape - the shape of the ndarray
  - BaseNDArray
```
public BaseNDArray(float[] data,
           int[] shape,
           int[] stride,
           char ordering)
```
  - BaseNDArray
```
public BaseNDArray(float[] data,
           int[] shape,
           int[] stride,
           int offset,
           char ordering)
```
  - BaseNDArray
```
public BaseNDArray(float[] data,
           int[] shape)
```
    Create this ndarray with the given data and shape and 0 offset
    
    Parameters:
    data - the data to use
    shape - the shape of the ndarray
  - BaseNDArray
```
public BaseNDArray(float[] data,
           int[] shape,
           int offset)
```
  - BaseNDArray
```
public BaseNDArray(int[] shape,
           int[] stride,
           int offset)
```
    Construct an ndarray of the specified shape with an empty data array
    
    Parameters:
    shape - the shape of the ndarray
    stride - the stride of the ndarray
    offset - the desired offset
  - BaseNDArray
```
public BaseNDArray(int[] shape,
           int[] stride)
```
    Create the ndarray with the specified shape and stride and an offset of 0
    
    Parameters:
    shape - the shape of the ndarray
    stride - the stride of the ndarray
  - BaseNDArray
```
public BaseNDArray(int[] shape,
           int offset)
```
  - BaseNDArray
```
public BaseNDArray(int[] shape,
           char ordering)
```
  - BaseNDArray
```
public BaseNDArray(int newRows,
           int newColumns)
```
    Creates a new n times m DoubleMatrix.
    
    Parameters:
    newRows - the number of rows (n) of the new matrix.
    newColumns - the number of columns (m) of the new matrix.
  - BaseNDArray
```
public BaseNDArray(List<INDArray> slices,
           int[] shape)
```
    Create an ndarray from the specified slices. This will go through and merge all of the data from each slice in to one ndarray which will then take the specified shape
    
    Parameters:
    slices - the slices to merge
    shape - the shape of the ndarray
  - BaseNDArray
```
public BaseNDArray(List<INDArray> slices,
           int[] shape,
           int[] stride)
```
    Create an ndarray from the specified slices. This will go through and merge all of the data from each slice in to one ndarray which will then take the specified shape
    
    Parameters:
    slices - the slices to merge
    shape - the shape of the ndarray
  - BaseNDArray
```
public BaseNDArray(float[] data,
           int[] shape,
           int[] stride)
```
  - BaseNDArray
```
public BaseNDArray(float[] data,
           int[] shape,
           int[] stride,
           int offset)
```
  - BaseNDArray
```
public BaseNDArray(float[] data)
```
  - BaseNDArray
```
public BaseNDArray(float[][] data)
```
- Method Detail
  - linearView
```
public INDArray linearView()
```
    Returns a linear view reference of shape 1,length(ndarray)
    
    Specified by:
    
    linearView in interface INDArray
    
    Returns:
    the linear view of this ndarray
  - floatData
```
public float[] floatData()
```
    Returns a linear float array representation of this ndarray
    
    Specified by:
    
    floatData in interface INDArray
    
    Returns:
    the linear float array representation of this ndarray
  - vectorsAlongDimension
```
public int vectorsAlongDimension(int dimension)
```
    Returns the number of possible vectors for a given dimension
    
    Specified by:
    
    vectorsAlongDimension in interface INDArray
    
    Parameters:
    dimension - the dimension to calculate the number of vectors for
    
    Returns:
    the number of possible vectors along a dimension
  - vectorAlongDimension
```
public INDArray vectorAlongDimension(int index,
                            int dimension)
```
    Get the vector along a particular dimension
    
    Specified by:
    
    vectorAlongDimension in interface INDArray
    
    Parameters:
    index - the index of the vector to getScalar
    dimension - the dimension to getScalar the vector from
    
    Returns:
    the vector along a particular dimension
  - cumsumi
```
public INDArray cumsumi(int dimension)
```
    Cumulative sum along a dimension
    
    Specified by:
    
    cumsumi in interface INDArray
    
    Parameters:
    dimension - the dimension to perform cumulative sum along
    
    Returns:
    the cumulative sum along the specified dimension
  - cumsum
```
public INDArray cumsum(int dimension)
```
    Cumulative sum along a dimension (in place)
    
    Specified by:
    
    cumsum in interface INDArray
    
    Parameters:
    dimension - the dimension to perform cumulative sum along
    
    Returns:
    the cumulative sum along the specified dimension
  - assign
```
public INDArray assign(INDArray arr)
```
    Assign all of the elements in the given ndarray to this ndarray
    
    Specified by:
    
    assign in interface INDArray
    
    Parameters:
    arr - the elements to assign
    
    Returns:
    this
  - putScalar
```
public INDArray putScalar(int i,
                 Number value)
```
    Description copied from interface: INDArray
    
    Insert the number linearly in to the ndarray
    
    Specified by:
    
    putScalar in interface INDArray
    
    Parameters:
    i - the index to insert into
    value - the value to insert
    
    Returns:
    this
  - putScalar
```
public INDArray putScalar(int[] indexes,
                 Number value)
```
    Description copied from interface: INDArray
    
    Insert the item at the specified indices
    
    Specified by:
    
    putScalar in interface INDArray
    
    Parameters:
    indexes - the indices to insert at
    value - the number to insert
    
    Returns:
    this
  - lt
```
public INDArray lt(Number other)
```
    Description copied from interface: INDArray
    
    Returns an ndarray with 1 if the element is less than the given element 0 other wise
    
    Specified by:
    
    lt in interface INDArray
    
    Parameters:
    other - the number to compare
    
    Returns:
    a copied ndarray with the given binary conditions
  - lti
```
public INDArray lti(Number other)
```
    Description copied from interface: INDArray
    
    In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    lti in interface INDArray
    
    Parameters:
    other - the number to compare
    
    Returns:
  - eq
```
public INDArray eq(Number other)
```
    Description copied from interface: INDArray
    
    Returns an ndarray with 1 if the element is less than the given element 0 other wise
    
    Specified by:
    
    eq in interface INDArray
    
    Parameters:
    other - the number to compare
    
    Returns:
    a copied ndarray with the given binary conditions
  - eqi
```
public INDArray eqi(Number other)
```
    Description copied from interface: INDArray
    
    In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    eqi in interface INDArray
    
    Parameters:
    other - the number to compare
    
    Returns:
  - gt
```
public INDArray gt(Number other)
```
    Specified by:
    
    gt in interface INDArray
  - gti
```
public INDArray gti(Number other)
```
    Description copied from interface: INDArray
    
    In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    gti in interface INDArray
    
    Parameters:
    other - the number to compare
    
    Returns:
  - lt
```
public INDArray lt(INDArray other)
```
    Description copied from interface: INDArray
    
    less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    lt in interface INDArray
    
    Parameters:
    other - the number to compare
    
    Returns:
    the result ndarray
  - lti
```
public INDArray lti(INDArray other)
```
    Description copied from interface: INDArray
    
    In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    lti in interface INDArray
    
    Parameters:
    other - the number to compare
    
    Returns:
  - eq
```
public INDArray eq(INDArray other)
```
    Description copied from interface: INDArray
    
    equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    eq in interface INDArray
    
    Parameters:
    other - the number to compare
    
    Returns:
  - eqi
```
public INDArray eqi(INDArray other)
```
    Description copied from interface: INDArray
    
    In place equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    eqi in interface INDArray
    
    Parameters:
    other - the number to compare
    
    Returns:
  - gt
```
public INDArray gt(INDArray other)
```
    Description copied from interface: INDArray
    
    greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    gt in interface INDArray
    
    Parameters:
    other - the number to compare
    
    Returns:
  - gti
```
public INDArray gti(INDArray other)
```
    Description copied from interface: INDArray
    
    In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    gti in interface INDArray
    
    Parameters:
    other - the number to compare
    
    Returns:
  - neg
```
public INDArray neg()
```
    Negate each element.
    
    Specified by:
    
    neg in interface INDArray
    
    Returns:
  - negi
```
public INDArray negi()
```
    Negate each element (in-place).
    
    Specified by:
    
    negi in interface INDArray
    
    Returns:
  - rdiv
```
public INDArray rdiv(Number n,
            INDArray result)
```
    Specified by:
    
    rdiv in interface INDArray
  - rdivi
```
public INDArray rdivi(Number n,
             INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse in place division
    
    Specified by:
    
    rdivi in interface INDArray
    
    Parameters:
    n - the number to divide by by
    result - the result ndarray
    
    Returns:
    the result ndarray
  - rsub
```
public INDArray rsub(Number n,
            INDArray result)
```
    Specified by:
    
    rsub in interface INDArray
  - rsubi
```
public INDArray rsubi(Number n,
             INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse in place subtraction
    
    Specified by:
    
    rsubi in interface INDArray
    
    Parameters:
    n - the number to subtract by
    result - the result ndarray
    
    Returns:
    the result ndarray
  - div
```
public INDArray div(Number n,
           INDArray result)
```
    Specified by:
    
    div in interface INDArray
  - divi
```
public INDArray divi(Number n,
            INDArray result)
```
    Description copied from interface: INDArray
    
    In place division of this ndarray
    
    Specified by:
    
    divi in interface INDArray
    
    Parameters:
    n - the number to divide by
    result - the result ndarray
    
    Returns:
  - mul
```
public INDArray mul(Number n,
           INDArray result)
```
    Specified by:
    
    mul in interface INDArray
  - muli
```
public INDArray muli(Number n,
            INDArray result)
```
    Description copied from interface: INDArray
    
    In place multiplication of this ndarray
    
    Specified by:
    
    muli in interface INDArray
    
    Parameters:
    n - the number to divide by
    result - the result ndarray
    
    Returns:
  - sub
```
public INDArray sub(Number n,
           INDArray result)
```
    Specified by:
    
    sub in interface INDArray
  - subi
```
public INDArray subi(Number n,
            INDArray result)
```
    Description copied from interface: INDArray
    
    In place subtraction of this ndarray
    
    Specified by:
    
    subi in interface INDArray
    
    Parameters:
    n - the number to subtract by
    result - the result ndarray
    
    Returns:
    the result ndarray
  - add
```
public INDArray add(Number n,
           INDArray result)
```
    Specified by:
    
    add in interface INDArray
  - addi
```
public INDArray addi(Number n,
            INDArray result)
```
    Description copied from interface: INDArray
    
    In place addition
    
    Specified by:
    
    addi in interface INDArray
    
    Parameters:
    n - the number to add
    result - the result ndarray
    
    Returns:
    the result ndarray
  - getScalar
```
public INDArray getScalar(int row,
                 int column)
```
    Returns the element at the specified row/column This will throw an exception if the
    
    Specified by:
    
    getScalar in interface INDArray
    
    Parameters:
    row - the row of the element to return
    column - the row of the element to return
    
    Returns:
    a scalar indarray of the element at this index
  - dup
```
public INDArray dup()
```
    Description copied from interface: INDArray
    
    Return a copy of this ndarray
    
    Specified by:
    
    dup in interface INDArray
    
    Returns:
    a copy of this ndarray
  - get
```
public float get(int... indices)
```
    Returns the elements at the the specified indices
    
    Specified by:
    
    get in interface INDArray
    
    Parameters:
    indices - the indices to getScalar
    
    Returns:
    the array with the specified elements
  - isScalar
```
public boolean isScalar()
```
    Test whether a matrix is scalar.
    
    Specified by:
    
    isScalar in interface INDArray
    
    Returns:
    whether this ndarray is a scalar
  - put
```
public INDArray put(int[] indices,
           INDArray element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    indices - the indices to insert into
    element - a scalar ndarray
    
    Returns:
    a scalar ndarray of the element at this index
  - put
```
public INDArray put(int i,
           int j,
           INDArray element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    i - the row insert into
    j - the column to insert into
    element - a scalar ndarray
    
    Returns:
    a scalar ndarray of the element at this index
  - put
```
public INDArray put(int i,
           int j,
           Number element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    i - the row insert into
    j - the column to insert into
    element - a scalar ndarray
    
    Returns:
    a scalar ndarray of the element at this index
  - putSlice
```
public INDArray putSlice(int slice,
                INDArray put)
```
    Assigns the given matrix (put) to the specified slice
    
    Specified by:
    
    putSlice in interface INDArray
    
    Parameters:
    slice - the slice to assign
    put - the slice to applyTransformToDestination
    
    Returns:
    this for chainability
  - assertSlice
```
protected void assertSlice(INDArray put,
               int slice)
```
  - isMatrix
```
public boolean isMatrix()
```
    Returns true if this ndarray is 2d or 3d with a singleton element
    
    Specified by:
    
    isMatrix in interface INDArray
    
    Returns:
    true if the element is a matrix, false otherwise
  - reduce
```
public INDArray reduce(Ops.DimensionOp op,
              int dimension)
```
    http://docs.scipy.org/doc/numpy/reference/generated/numpy.ufunc.reduce.html
    
    Specified by:
    
    reduce in interface INDArray
    
    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)
  - vectorForDimensionAndOffset
```
public DimensionSlice vectorForDimensionAndOffset(int dimension,
                                         int offset)
```
  - index
```
public int index(int row,
        int column)
```
    Description copied from interface: INDArray
    
    Return the linear index of the specified row and column
    
    Specified by:
    
    index in interface INDArray
    
    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
  - newShape
```
protected INDArray newShape(int[] newShape,
                char ordering)
```
  - noCopyReshape
```
protected int[] noCopyReshape(int[] newShape,
                  char ordering)
```
    Return the new strides based on the shape and ordering or null if we can't do a reshape
    
    Parameters:
    newShape - the new shape
    ordering - the ordering of the new shape
    
    Returns:
    the new strides or null if we can't reshape
  - reduceVector
```
protected float reduceVector(Ops.DimensionOp op,
                 INDArray vector)
```
  - squaredDistance
```
public double squaredDistance(INDArray other)
```
    Returns the squared (Euclidean) distance.
    
    Specified by:
    
    squaredDistance in interface INDArray
  - distance2
```
public double distance2(INDArray other)
```
    Returns the (euclidean) distance.
    
    Specified by:
    
    distance2 in interface INDArray
  - distance1
```
public double distance1(INDArray other)
```
    Returns the (1-norm) distance.
    
    Specified by:
    
    distance1 in interface INDArray
  - put
```
public INDArray put(NDArrayIndex[] indices,
           INDArray element)
```
    Specified by:
    
    put in interface INDArray
  - put
```
public INDArray put(NDArrayIndex[] indices,
           Number element)
```
    Specified by:
    
    put in interface INDArray
  - iterateOverAllColumns
```
public void iterateOverAllColumns(SliceOp op)
```
    Iterate over every column of every slice
    
    Specified by:
    
    iterateOverAllColumns in interface INDArray
    
    Parameters:
    op - the operation to apply
  - iterateOverAllRows
```
public void iterateOverAllRows(SliceOp op)
```
    Iterate over every row of every slice
    
    Specified by:
    
    iterateOverAllRows in interface INDArray
    
    Parameters:
    op - the operation to apply
  - swapAxes
```
public INDArray swapAxes(int dimension,
                int with)
```
    Mainly here for people coming from numpy. This is equivalent to a call to permute
    
    Specified by:
    
    swapAxes in interface INDArray
    
    Parameters:
    dimension - the dimension to swap
    with - the one to swap it with
    
    Returns:
    the swapped axes view
  - endsForSlices
```
public int[] endsForSlices()
```
    Gives the indices for the ending of each slice
    
    Specified by:
    
    endsForSlices in interface INDArray
    
    Returns:
    the off sets for the beginning of each slice
  - data
```
public float[] data()
```
    Description copied from interface: INDArray
    
    Returns a linear double array representation of this ndarray
    
    Specified by:
    
    data in interface INDArray
    
    Returns:
    the linear double array representation of this ndarray
  - setData
```
public void setData(float[] data)
```
    Specified by:
    
    setData in interface INDArray
  - slices
```
public int slices()
```
    Number of slices: aka shape[0]
    
    Specified by:
    
    slices in interface INDArray
    
    Returns:
    the number of slices for this nd array
  - subArray
```
public INDArray subArray(int[] offsets,
                int[] shape,
                int[] stride)
```
    Specified by:
    
    subArray in interface INDArray
    
    Returns:
  - iterateOverDimension
```
public void iterateOverDimension(int dimension,
                        SliceOp op,
                        boolean modify)
```
    Iterate along a dimension. This encapsulates the process of sum, mean, and other processes take when iterating over a dimension.
    
    Specified by:
    
    iterateOverDimension in interface INDArray
    
    Parameters:
    dimension - the dimension to iterate over
    op - the operation to apply
    modify - whether to modify this array while iterating
  - setStride
```
public void setStride(int[] stride)
```
    Specified by:
    
    setStride in interface INDArray
  - initShape
```
protected void initShape(int[] shape)
```
  - getScalar
```
public INDArray getScalar(int i)
```
    Description copied from interface: INDArray
    
    Returns the element at the specified index
    
    Specified by:
    
    getScalar in interface INDArray
    
    Parameters:
    i - the index of the element to return
    
    Returns:
    a scalar ndarray of the element at this index
  - asserColumnVector
```
protected void asserColumnVector(INDArray column)
```
  - doColumnWise
```
protected INDArray doColumnWise(INDArray columnVector,
                    char operation)
```
    Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide
    
    Parameters:
    columnVector - the column vector
    operation - the operation
    
    Returns:
  - assertRowVector
```
protected void assertRowVector(INDArray rowVector)
```
  - doRowWise
```
protected INDArray doRowWise(INDArray rowVector,
                 char operation)
```
    Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide
    
    Parameters:
    rowVector - the row vector
    operation - the operation
    
    Returns:
  - put
```
public INDArray put(int i,
           INDArray element)
```
    Inserts the element at the specified index
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    i - the index insert into
    element - a scalar ndarray
    
    Returns:
    a scalar ndarray of the element at this index
  - diviColumnVector
```
public INDArray diviColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    diviColumnVector in interface INDArray
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - divColumnVector
```
public INDArray divColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    divColumnVector in interface INDArray
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - diviRowVector
```
public INDArray diviRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    diviRowVector in interface INDArray
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - divRowVector
```
public INDArray divRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    divRowVector in interface INDArray
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - muliColumnVector
```
public INDArray muliColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    muliColumnVector in interface INDArray
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - mulColumnVector
```
public INDArray mulColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    mulColumnVector in interface INDArray
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - muliRowVector
```
public INDArray muliRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    muliRowVector in interface INDArray
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - mulRowVector
```
public INDArray mulRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    mulRowVector in interface INDArray
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - subiColumnVector
```
public INDArray subiColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subiColumnVector in interface INDArray
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - subColumnVector
```
public INDArray subColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subColumnVector in interface INDArray
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - subiRowVector
```
public INDArray subiRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subiRowVector in interface INDArray
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - subRowVector
```
public INDArray subRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    subRowVector in interface INDArray
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - addiColumnVector
```
public INDArray addiColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addiColumnVector in interface INDArray
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - addColumnVector
```
public INDArray addColumnVector(INDArray columnVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addColumnVector in interface INDArray
    
    Parameters:
    columnVector - the column vector to add
    
    Returns:
    the result of the addition
  - addiRowVector
```
public INDArray addiRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addiRowVector in interface INDArray
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - addRowVector
```
public INDArray addRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addRowVector in interface INDArray
    
    Parameters:
    rowVector - the column vector to add
    
    Returns:
    the result of the addition
  - mmul
```
public INDArray mmul(INDArray other)
```
    Perform a copy matrix multiplication
    
    Specified by:
    
    mmul in interface INDArray
    
    Parameters:
    other - the other matrix to perform matrix multiply with
    
    Returns:
    the result of the matrix multiplication
  - mmul
```
public INDArray mmul(INDArray other,
            INDArray result)
```
    Perform an copy matrix multiplication
    
    Specified by:
    
    mmul in interface INDArray
    
    Parameters:
    other - the other matrix to perform matrix multiply with
    result - the result ndarray
    
    Returns:
    the result of the matrix multiplication
  - div
```
public INDArray div(INDArray other)
```
    in place (element wise) division of two matrices
    
    Specified by:
    
    div in interface INDArray
    
    Parameters:
    other - the second ndarray to divide
    
    Returns:
    the result of the divide
  - div
```
public INDArray div(INDArray other,
           INDArray result)
```
    copy (element wise) division of two matrices
    
    Specified by:
    
    div in interface INDArray
    
    Parameters:
    other - the second ndarray to divide
    result - the result ndarray
    
    Returns:
    the result of the divide
  - mul
```
public INDArray mul(INDArray other)
```
    copy (element wise) multiplication of two matrices
    
    Specified by:
    
    mul in interface INDArray
    
    Parameters:
    other - the second ndarray to multiply
    
    Returns:
    the result of the addition
  - mul
```
public INDArray mul(INDArray other,
           INDArray result)
```
    copy (element wise) multiplication of two matrices
    
    Specified by:
    
    mul in interface INDArray
    
    Parameters:
    other - the second ndarray to multiply
    result - the result ndarray
    
    Returns:
    the result of the multiplication
  - sub
```
public INDArray sub(INDArray other)
```
    copy subtraction of two matrices
    
    Specified by:
    
    sub in interface INDArray
    
    Parameters:
    other - the second ndarray to subtract
    
    Returns:
    the result of the addition
  - sub
```
public INDArray sub(INDArray other,
           INDArray result)
```
    copy subtraction of two matrices
    
    Specified by:
    
    sub in interface INDArray
    
    Parameters:
    other - the second ndarray to subtract
    result - the result ndarray
    
    Returns:
    the result of the subtraction
  - add
```
public INDArray add(INDArray other)
```
    copy addition of two matrices
    
    Specified by:
    
    add in interface INDArray
    
    Parameters:
    other - the second ndarray to add
    
    Returns:
    the result of the addition
  - add
```
public INDArray add(INDArray other,
           INDArray result)
```
    copy addition of two matrices
    
    Specified by:
    
    add in interface INDArray
    
    Parameters:
    other - the second ndarray to add
    result - the result ndarray
    
    Returns:
    the result of the addition
  - mmuli
```
public INDArray mmuli(INDArray other)
```
    Perform an copy matrix multiplication
    
    Specified by:
    
    mmuli in interface INDArray
    
    Parameters:
    other - the other matrix to perform matrix multiply with
    
    Returns:
    the result of the matrix multiplication
  - mmuli
```
public INDArray mmuli(INDArray other,
             INDArray result)
```
    Perform an copy matrix multiplication
    
    Specified by:
    
    mmuli in interface INDArray
    
    Parameters:
    other - the other matrix to perform matrix multiply with
    result - the result ndarray
    
    Returns:
    the result of the matrix multiplication
  - divi
```
public INDArray divi(INDArray other)
```
    in place (element wise) division of two matrices
    
    Specified by:
    
    divi in interface INDArray
    
    Parameters:
    other - the second ndarray to divide
    
    Returns:
    the result of the divide
  - divi
```
public INDArray divi(INDArray other,
            INDArray result)
```
    in place (element wise) division of two matrices
    
    Specified by:
    
    divi in interface INDArray
    
    Parameters:
    other - the second ndarray to divide
    result - the result ndarray
    
    Returns:
    the result of the divide
  - muli
```
public INDArray muli(INDArray other)
```
    in place (element wise) multiplication of two matrices
    
    Specified by:
    
    muli in interface INDArray
    
    Parameters:
    other - the second ndarray to multiply
    
    Returns:
    the result of the addition
  - muli
```
public INDArray muli(INDArray other,
            INDArray result)
```
    in place (element wise) multiplication of two matrices
    
    Specified by:
    
    muli in interface INDArray
    
    Parameters:
    other - the second ndarray to multiply
    result - the result ndarray
    
    Returns:
    the result of the multiplication
  - subi
```
public INDArray subi(INDArray other)
```
    in place subtraction of two matrices
    
    Specified by:
    
    subi in interface INDArray
    
    Parameters:
    other - the second ndarray to subtract
    
    Returns:
    the result of the addition
  - subi
```
public INDArray subi(INDArray other,
            INDArray result)
```
    in place subtraction of two matrices
    
    Specified by:
    
    subi in interface INDArray
    
    Parameters:
    other - the second ndarray to subtract
    result - the result ndarray
    
    Returns:
    the result of the subtraction
  - addi
```
public INDArray addi(INDArray other)
```
    in place addition of two matrices
    
    Specified by:
    
    addi in interface INDArray
    
    Parameters:
    other - the second ndarray to add
    
    Returns:
    the result of the addition
  - addi
```
public INDArray addi(INDArray other,
            INDArray result)
```
    in place addition of two matrices
    
    Specified by:
    
    addi in interface INDArray
    
    Parameters:
    other - the second ndarray to add
    result - the result ndarray
    
    Returns:
    the result of the addition
  - normmax
```
public INDArray normmax(int dimension)
```
    Returns the normmax along the specified dimension
    
    Specified by:
    
    normmax in interface INDArray
    
    Parameters:
    dimension - the dimension to getScalar the norm1 along
    
    Returns:
    the norm1 along the specified dimension
  - rdiv
```
public INDArray rdiv(INDArray other)
```
    Reverse division
    
    Specified by:
    
    rdiv in interface INDArray
    
    Parameters:
    other - the matrix to divide from
    
    Returns:
  - rdivi
```
public INDArray rdivi(INDArray other)
```
    Reverse divsion (in place)
    
    Specified by:
    
    rdivi in interface INDArray
    
    Parameters:
    other -
    
    Returns:
  - rdiv
```
public INDArray rdiv(INDArray other,
            INDArray result)
```
    Reverse division
    
    Specified by:
    
    rdiv in interface INDArray
    
    Parameters:
    other - the matrix to subtract from
    result - the result ndarray
    
    Returns:
  - rdivi
```
public INDArray rdivi(INDArray other,
             INDArray result)
```
    Reverse division (in-place)
    
    Specified by:
    
    rdivi in interface INDArray
    
    Parameters:
    other - the other ndarray to subtract
    result - the result ndarray
    
    Returns:
    the ndarray with the operation applied
  - rsub
```
public INDArray rsub(INDArray other,
            INDArray result)
```
    Reverse subtraction
    
    Specified by:
    
    rsub in interface INDArray
    
    Parameters:
    other - the matrix to subtract from
    result - the result ndarray
    
    Returns:
  - rsub
```
public INDArray rsub(INDArray other)
```
    Specified by:
    
    rsub in interface INDArray
    
    Parameters:
    other -
    
    Returns:
  - rsubi
```
public INDArray rsubi(INDArray other)
```
    Specified by:
    
    rsubi in interface INDArray
    
    Parameters:
    other -
    
    Returns:
  - rsubi
```
public INDArray rsubi(INDArray other,
             INDArray result)
```
    Reverse subtraction (in-place)
    
    Specified by:
    
    rsubi in interface INDArray
    
    Parameters:
    other - the other ndarray to subtract
    result - the result ndarray
    
    Returns:
    the ndarray with the operation applied
  - assign
```
public INDArray assign(Number value)
```
    Set the value of the ndarray to the specified value
    
    Specified by:
    
    assign in interface INDArray
    
    Parameters:
    value - the value to assign
    
    Returns:
    the ndarray with the values
  - linearIndex
```
public int linearIndex(int i)
```
    Description copied from interface: INDArray
    
    Get the linear index of the data in to the array
    
    Specified by:
    
    linearIndex in interface INDArray
    
    Parameters:
    i - the index to getScalar
    
    Returns:
    the linear index in to the data
  - slice
```
public INDArray slice(int slice)
```
    Returns the specified slice of this matrix. In matlab, this would be equivalent to (given a 2 x 2 x 2): A(:,:,x) where x is the slice you want to return. The slice is always relative to the final dimension of the matrix.
    
    Specified by:
    
    slice in interface INDArray
    
    Parameters:
    slice - the slice to return
    
    Returns:
    the specified slice of this matrix
  - slice
```
public INDArray slice(int slice,
             int dimension)
```
    Returns the slice of this from the specified dimension
    
    Specified by:
    
    slice in interface INDArray
    
    Parameters:
    slice - the dimension to return from
    dimension - the dimension of the slice to return
    
    Returns:
    the slice of this matrix from the specified dimension and dimension
  - getScalar
```
public INDArray getScalar(int... indexes)
```
    Fetch a particular number on a multi dimensional scale.
    
    Specified by:
    
    getScalar in interface INDArray
    
    Parameters:
    indexes - the indexes to getFromOrigin a number from
    
    Returns:
    the number at the specified indices
  - rdiv
```
public INDArray rdiv(Number n)
```
    Specified by:
    
    rdiv in interface INDArray
  - rdivi
```
public INDArray rdivi(Number n)
```
    Description copied from interface: INDArray
    
    In place reverse divison
    
    Specified by:
    
    rdivi in interface INDArray
    
    Returns:
  - rsub
```
public INDArray rsub(Number n)
```
    Specified by:
    
    rsub in interface INDArray
  - rsubi
```
public INDArray rsubi(Number n)
```
    Specified by:
    
    rsubi in interface INDArray
  - div
```
public INDArray div(Number n)
```
    Specified by:
    
    div in interface INDArray
  - divi
```
public INDArray divi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar division
    
    Specified by:
    
    divi in interface INDArray
    
    Returns:
  - mul
```
public INDArray mul(Number n)
```
    Specified by:
    
    mul in interface INDArray
  - muli
```
public INDArray muli(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar multiplication
    
    Specified by:
    
    muli in interface INDArray
    
    Returns:
  - sub
```
public INDArray sub(Number n)
```
    Specified by:
    
    sub in interface INDArray
  - subi
```
public INDArray subi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar subtraction
    
    Specified by:
    
    subi in interface INDArray
    
    Returns:
  - add
```
public INDArray add(Number n)
```
    Specified by:
    
    add in interface INDArray
  - addi
```
public INDArray addi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar addition
    
    Specified by:
    
    addi in interface INDArray
    
    Returns:
  - repmat
```
public INDArray repmat(int[] shape)
```
    Replicate and tile array to fill out to the given shape
    
    Specified by:
    
    repmat in interface INDArray
    
    Parameters:
    shape - the new shape of this ndarray
    
    Returns:
    the shape to fill out to
  - putRow
```
public INDArray putRow(int row,
              INDArray toPut)
```
    Insert a row in to this array Will throw an exception if this ndarray is not a matrix
    
    Specified by:
    
    putRow in interface INDArray
    
    Parameters:
    row - the row insert into
    toPut - the row to insert
    
    Returns:
    this
  - putColumn
```
public INDArray putColumn(int column,
                 INDArray toPut)
```
    Insert a column in to this array Will throw an exception if this ndarray is not a matrix
    
    Specified by:
    
    putColumn in interface INDArray
    
    Parameters:
    column - the column to insert
    toPut - the array to put
    
    Returns:
    this
  - get
```
public float get(int i)
```
    Description copied from interface: INDArray
    
    Return the item at the linear index i
    
    Specified by:
    
    get in interface INDArray
    
    Parameters:
    i - the index of the item to getScalar
    
    Returns:
    the item at index j
  - get
```
public float get(int i,
        int j)
```
    Description copied from interface: INDArray
    
    Return the item at row i column j Note that this is the same as calling getScalar(new int[]{i,j}
    
    Specified by:
    
    get in interface INDArray
    
    Parameters:
    i - the row to getScalar
    j - the column to getScalar
    
    Returns:
    the item at row i column j
  - getIndex
```
public static int getIndex(int offset,
           int[] stride,
           int... indexes)
```
    Mainly an internal method (public for testing) for given an offset and stride, and index, calculating the beginning index of a query given indices
    
    Parameters:
    offset - the desired offset
    stride - the desired stride
    indexes - the desired indexes to test on
    
    Returns:
    the index for a query given stride and offset
  - transpose
```
public INDArray transpose()
```
    Return transposed copy of this matrix.
    
    Specified by:
    
    transpose in interface INDArray
    
    Returns:
    the flipped rows and columns of a matrix
  - reshape
```
public INDArray reshape(int[] shape)
```
    Reshape the ndarray in to the specified dimensions, possible errors being thrown for invalid shapes
    
    Specified by:
    
    reshape in interface INDArray
    
    Parameters:
    shape -
    
    Returns:
  - checkDimensions
```
public void checkDimensions(INDArray other)
```
    Description copied from interface: INDArray
    
    Validate dimensions are equal
    
    Specified by:
    
    checkDimensions in interface INDArray
    
    Parameters:
    other - the other ndarray to compare
  - prod
```
public INDArray prod(int dimension)
```
    Returns the product along a given dimension
    
    Specified by:
    
    prod in interface INDArray
    
    Parameters:
    dimension - the dimension to getScalar the product along
    
    Returns:
    the product along the specified dimension
  - mean
```
public INDArray mean(int dimension)
```
    Returns the overall mean of this ndarray
    
    Specified by:
    
    mean in interface INDArray
    
    Parameters:
    dimension - the dimension to getScalar the mean along
    
    Returns:
    the mean along the specified dimension of this ndarray
  - var
```
public INDArray var(int dimension)
```
    Returns the overall variance of this ndarray
    
    Specified by:
    
    var in interface INDArray
    
    Parameters:
    dimension - the dimension to getScalar the mean along
    
    Returns:
    the mean along the specified dimension of this ndarray
  - max
```
public INDArray max(int dimension)
```
    Returns the overall max of this ndarray
    
    Specified by:
    
    max in interface INDArray
    
    Parameters:
    dimension - the dimension to getScalar the mean along
    
    Returns:
    the mean along the specified dimension of this ndarray
  - min
```
public INDArray min(int dimension)
```
    Returns the overall min of this ndarray
    
    Specified by:
    
    min in interface INDArray
    
    Parameters:
    dimension - the dimension to getScalar the mean along
    
    Returns:
    the mean along the specified dimension of this ndarray
  - sum
```
public INDArray sum(int dimension)
```
    Returns the sum along the last dimension of this ndarray
    
    Specified by:
    
    sum in interface INDArray
    
    Parameters:
    dimension - the dimension to getScalar the sum along
    
    Returns:
    the sum along the specified dimension of this ndarray
  - norm1
```
public INDArray norm1(int dimension)
```
    Returns the norm1 along the specified dimension
    
    Specified by:
    
    norm1 in interface INDArray
    
    Parameters:
    dimension - the dimension to getScalar the norm1 along
    
    Returns:
    the norm1 along the specified dimension
  - std
```
public INDArray std(int dimension)
```
    Standard deviation of an ndarray along a dimension
    
    Specified by:
    
    std in interface INDArray
    
    Parameters:
    dimension - the dimension to getScalar the std along
    
    Returns:
    the standard deviation along a particular dimension
  - norm2
```
public INDArray norm2(int dimension)
```
    Returns the norm2 along the specified dimension
    
    Specified by:
    
    norm2 in interface INDArray
    
    Parameters:
    dimension - the dimension to getScalar the norm2 along
    
    Returns:
    the norm2 along the specified dimension
  - columns
```
public int columns()
```
    Number of columns (shape[1]), throws an exception when called when not 2d
    
    Specified by:
    
    columns in interface INDArray
    
    Returns:
    the number of columns in the array (only 2d)
  - rows
```
public int rows()
```
    Returns the number of rows in the array (only 2d) throws an exception when called when not 2d
    
    Specified by:
    
    rows in interface INDArray
    
    Returns:
    the number of rows in the matrix
  - ravel
```
public INDArray ravel()
```
    Flattens the array for linear indexing
    
    Specified by:
    
    ravel in interface INDArray
    
    Returns:
    the flattened version of this array
  - sliceVectors
```
public void sliceVectors(List<INDArray> list)
```
    Flattens the array for linear indexing
    
    Specified by:
    
    sliceVectors in interface INDArray
  - reshape
```
public INDArray reshape(int newRows,
               int newColumns)
```
    Reshape the matrix. Number of elements must not change.
    
    Specified by:
    
    reshape in interface INDArray
    
    Parameters:
    newRows -
    newColumns -
    
    Returns:
    the reshaped ndarray
  - getColumn
```
public INDArray getColumn(int c)
```
    Get the specified column
    
    Specified by:
    
    getColumn in interface INDArray
    
    Parameters:
    c -
    
    Returns:
    the specified column
  - getRows
```
public INDArray getRows(int[] rindices)
```
    Get whole rows from the passed indices.
    
    Specified by:
    
    getRows in interface INDArray
    
    Parameters:
    rindices -
    
    Returns:
  - get
```
public INDArray get(NDArrayIndex... indexes)
```
    Returns a subset of this array based on the specified indexes
    
    Specified by:
    
    get in interface INDArray
    
    Parameters:
    indexes - the indexes in to the array
    
    Returns:
    a view of the array with the specified indices
  - getColumns
```
public INDArray getColumns(int[] cindices)
```
    Get whole columns from the passed indices.
    
    Specified by:
    
    getColumns in interface INDArray
    
    Parameters:
    cindices -
    
    Returns:
  - getRow
```
public INDArray getRow(int r)
```
    Get a copy of a row.
    
    Specified by:
    
    getRow in interface INDArray
    
    Parameters:
    r -
    
    Returns:
    the specified row
  - equals
```
public boolean equals(Object o)
```
    Compare two matrices. Returns true if and only if other is also a DoubleMatrix which has the same size and the maximal absolute difference in matrix elements is smaller than 1e-6.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    o -
  - shape
```
public int[] shape()
```
    Returns the shape(dimensions) of this array
    
    Specified by:
    
    shape in interface INDArray
    
    Returns:
    the shape of this matrix
  - stride
```
public int[] stride()
```
    Returns the stride(indices along the linear index for which each slice is accessed) of this array
    
    Specified by:
    
    stride in interface INDArray
    
    Returns:
    the stride of this array
  - offset
```
public int offset()
```
    Description copied from interface: INDArray
    
    Returns the start of where the ndarray is for the underlying data
    
    Specified by:
    
    offset in interface INDArray
    
    Returns:
    the starting offset
  - ordering
```
public char ordering()
```
    Specified by:
    
    ordering in interface INDArray
  - size
```
public int size(int dimension)
```
    Returns the size of this array along a particular dimension
    
    Specified by:
    
    size in interface INDArray
    
    Parameters:
    dimension - the dimension to return from
    
    Returns:
    the shape of the specified dimension
  - length
```
public int length()
```
    Returns the total number of elements in the ndarray
    
    Specified by:
    
    length in interface INDArray
    
    Returns:
    the number of elements in the ndarray
  - broadcast
```
public INDArray broadcast(int[] shape)
```
    Broadcasts this ndarray to be the specified shape
    
    Specified by:
    
    broadcast in interface INDArray
    
    Parameters:
    shape - the new shape of this ndarray
    
    Returns:
    the broadcasted ndarray
  - dimShuffle
```
public INDArray dimShuffle(Object[] rearrange,
                  int[] newOrder,
                  boolean[] broadCastable)
```
    Dimshuffle: an extension of permute that adds the ability to broadcast various dimensions. See theano for more examples. This will only accept integers and xs.
    An x indicates a dimension should be broadcasted rather than permuted.
    
    Specified by:
    
    dimShuffle in interface INDArray
    
    Parameters:
    rearrange - the dimensions to swap to
    newOrder - the new order (think permute)
    broadCastable - (whether the dimension is broadcastable) (must be same length as new order)
    
    Returns:
    the newly permuted array
  - permute
```
public INDArray permute(int[] rearrange)
```
    See: http://www.mathworks.com/help/matlab/ref/permute.htsliceml
    
    Specified by:
    
    permute in interface INDArray
    
    Parameters:
    rearrange - the dimensions to swap to
    
    Returns:
    the newly permuted array
  - copyRealTo
```
protected void copyRealTo(INDArray arr)
```
  - doPermuteSwap
```
protected int[] doPermuteSwap(int[] shape,
                  int[] rearrange)
```
  - checkArrangeArray
```
protected void checkArrangeArray(int[] arr)
```
  - isVector
```
public boolean isVector()
```
    Checks whether the matrix is a vector.
    
    Specified by:
    
    isVector in interface INDArray
    
    Returns:
    whether this ndarray is a vector
  - isRowVector
```
public boolean isRowVector()
```
    Checks whether the matrix is a row vector.
    
    Specified by:
    
    isRowVector in interface INDArray
    
    Returns:
    true if the number of rows is 1
  - isColumnVector
```
public boolean isColumnVector()
```
    Checks whether the matrix is a column vector.
    
    Specified by:
    
    isColumnVector in interface INDArray
    
    Returns:
    true if the number of columns is 1
  - toString
```
public String toString()
```
    Generate string representation of the matrix.
    
    Overrides:
    
    toString in class Object
  - element
```
public Object element()
```
    Returns a scalar (individual element) of a scalar ndarray
    
    Specified by:
    
    element in interface INDArray
    
    Returns:
    the individual item in this ndarray
  - rdiv
```
public IComplexNDArray rdiv(IComplexNumber n)
```
    Specified by:
    
    rdiv in interface INDArray
  - rdivi
```
public IComplexNDArray rdivi(IComplexNumber n)
```
    Specified by:
    
    rdivi in interface INDArray
  - rsub
```
public IComplexNDArray rsub(IComplexNumber n)
```
    Specified by:
    
    rsub in interface INDArray
  - rsubi
```
public IComplexNDArray rsubi(IComplexNumber n)
```
    Specified by:
    
    rsubi in interface INDArray
  - div
```
public IComplexNDArray div(IComplexNumber n)
```
    Specified by:
    
    div in interface INDArray
  - divi
```
public IComplexNDArray divi(IComplexNumber n)
```
    Specified by:
    
    divi in interface INDArray
  - mul
```
public IComplexNDArray mul(IComplexNumber n)
```
    Specified by:
    
    mul in interface INDArray
  - muli
```
public IComplexNDArray muli(IComplexNumber n)
```
    Specified by:
    
    muli in interface INDArray
  - sub
```
public IComplexNDArray sub(IComplexNumber n)
```
    Specified by:
    
    sub in interface INDArray
  - subi
```
public IComplexNDArray subi(IComplexNumber n)
```
    Specified by:
    
    subi in interface INDArray
  - add
```
public IComplexNDArray add(IComplexNumber n)
```
    Specified by:
    
    add in interface INDArray
  - addi
```
public IComplexNDArray addi(IComplexNumber n)
```
    Specified by:
    
    addi in interface INDArray
  - rdiv
```
public IComplexNDArray rdiv(IComplexNumber n,
                   IComplexNDArray result)
```
    Specified by:
    
    rdiv in interface INDArray
  - rdivi
```
public IComplexNDArray rdivi(IComplexNumber n,
                    IComplexNDArray result)
```
    Specified by:
    
    rdivi in interface INDArray
  - rsub
```
public IComplexNDArray rsub(IComplexNumber n,
                   IComplexNDArray result)
```
    Specified by:
    
    rsub in interface INDArray
  - rsubi
```
public IComplexNDArray rsubi(IComplexNumber n,
                    IComplexNDArray result)
```
    Specified by:
    
    rsubi in interface INDArray
  - div
```
public IComplexNDArray div(IComplexNumber n,
                  IComplexNDArray result)
```
    Specified by:
    
    div in interface INDArray
  - divi
```
public IComplexNDArray divi(IComplexNumber n,
                   IComplexNDArray result)
```
    Specified by:
    
    divi in interface INDArray
  - mul
```
public IComplexNDArray mul(IComplexNumber n,
                  IComplexNDArray result)
```
    Specified by:
    
    mul in interface INDArray
  - muli
```
public IComplexNDArray muli(IComplexNumber n,
                   IComplexNDArray result)
```
    Specified by:
    
    muli in interface INDArray
  - sub
```
public IComplexNDArray sub(IComplexNumber n,
                  IComplexNDArray result)
```
    Specified by:
    
    sub in interface INDArray
  - subi
```
public IComplexNDArray subi(IComplexNumber n,
                   IComplexNDArray result)
```
    Specified by:
    
    subi in interface INDArray
  - add
```
public IComplexNDArray add(IComplexNumber n,
                  IComplexNDArray result)
```
    Specified by:
    
    add in interface INDArray
  - addi
```
public IComplexNDArray addi(IComplexNumber n,
                   IComplexNDArray result)
```
    Specified by:
    
    addi in interface INDArray

Class BaseNDArray

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

shape

stride

offset

ordering

data

rows

columns

length

linearView

Constructor Detail

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

Method Detail

linearView

floatData

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

getScalar

dup