BaseNDArray (nd4j-api 1.0.0-beta API)

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

All Implemented Interfaces:

Serializable, Iterable, INDArray

Direct Known Subclasses:

BaseComplexNDArray
```
public abstract class BaseNDArray
extends Object
implements INDArray, Iterable
```
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 boolean compressed

protected DataBuffer data

protected int[] javaShapeInformation

protected DataBuffer shapeInformation

Fields
Modifier and Type	Field and Description
`protected boolean`	`compressed`
`protected DataBuffer`	`data`
`protected int[]`	`javaShapeInformation`
`protected DataBuffer`	`shapeInformation`

Constructor Summary

Constructors
Constructor and Description
`BaseNDArray()`
`BaseNDArray(DataBuffer buffer)`
`BaseNDArray(DataBuffer floatBuffer, char order)`
`BaseNDArray(DataBuffer data, int[] shape)`
`BaseNDArray(DataBuffer buffer, int[] shape, char ordering)`
`BaseNDArray(DataBuffer buffer, int[] shape, int[] strides)`
`BaseNDArray(DataBuffer data, int[] shape, int[] stride, long offset)`
`BaseNDArray(DataBuffer buffer, int[] shape, int[] stride, long offset, char ordering)`
`BaseNDArray(DataBuffer buffer, int[] shape, long offset)`
`BaseNDArray(DataBuffer buffer, int[] shape, long offset, char ordering)` Constructor for stride and offset
`BaseNDArray(double[][] data)` Initialize the ndarray as a matrix with the given data (indices preserved)
`BaseNDArray(double[][] data, char ordering)`
`BaseNDArray(double[] data, int[] shape, char ordering)`
`BaseNDArray(double[] data, int[] shape, int[] stride, long offset)`
`BaseNDArray(double[] data, int[] shape, int[] stride, long offset, char ordering)`
`BaseNDArray(float[] data)`
`BaseNDArray(float[][] data)` Initialize the ndarray with the given data
`BaseNDArray(float[][] data, char ordering)`
`BaseNDArray(float[] data, char order)`
`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[] stride)`
`BaseNDArray(float[] data, int[] shape, int[] stride, char ordering)`
`BaseNDArray(float[] data, int[] shape, int[] stride, long offset)`
`BaseNDArray(float[] data, int[] shape, int[] stride, long offset, char ordering)`
`BaseNDArray(float[] data, int[] shape, long offset)`
`BaseNDArray(float[] data, int[] shape, long offset, char ordering)`
`BaseNDArray(int[] shape)` Create an ndarray with the given shape
`BaseNDArray(int[] shape, char ordering)`
`BaseNDArray(int[] shape, DataBuffer buffer)` Create with the specified shape and buffer
`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[] data, int[] shape, int[] strides)`
`BaseNDArray(int[] shape, int[] stride, long offset)` Construct an ndarray of the specified shape with an empty data array
`BaseNDArray(int[] shape, int[] stride, long offset, char ordering)` Construct an ndarray of the specified shape with an empty data array
`BaseNDArray(int[] shape, int[] stride, long offset, char ordering, boolean initialize)` Construct an ndarray of the specified shape.
`BaseNDArray(int[] shape, long offset)`
`BaseNDArray(int[] shape, long 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

All Methods Static Methods Instance Methods Concrete Methods Deprecated 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)` In place addition of a column vector
`IComplexNDArray`	`addi(IComplexNumber n)`
`IComplexNDArray`	`addi(IComplexNumber n, IComplexNDArray result)`
`INDArray`	`addi(INDArray other)` in place addition of two matrices
`INDArray`	`addi(INDArray other, INDArray result)` in place addition of two matrices
`INDArray`	`addi(Number n)` In place scalar addition
`INDArray`	`addi(Number n, INDArray result)` In place addition
`INDArray`	`addiColumnVector(INDArray columnVector)` In place addition of a column vector
`INDArray`	`addiRowVector(INDArray rowVector)` In place addition of a column vector
`INDArray`	`addRowVector(INDArray rowVector)` In place addition of a column vector
`INDArray`	`amax(int... dimension)` Returns the absolute overall max of this ndarray along given dimensions
`Number`	`amaxNumber()` Returns maximum (absolute) value in this INDArray
`INDArray`	`amean(int... dimension)` Returns the absolute overall mean of this ndarray
`Number`	`ameanNumber()` Returns the absolute overall mean of this ndarray
`INDArray`	`amin(int... dimension)` Returns minimum (absolute) value in this INDArray, along the specified dimensions
`Number`	`aminNumber()` Returns absolute min value in this INDArray
`INDArray`	`argMax(int... dimension)` This method returns index of highest value along specified dimension(s)
`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`	`assignIf(INDArray arr, Condition condition)` Assign all elements from given ndarray that are matching given condition, ndarray to this ndarray
`protected void`	`autoProcessScalarCall()`
`INDArray`	`broadcast(INDArray result)` Broadcasts this ndarray to be the specified shape
`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
`void`	`cleanup()` Deprecated.
`int`	`columns()` Number of columns (shape[1]), throws an exception when called when not 2d
`INDArray`	`cond(Condition condition)` 1 in the ndarray if the element matches the condition 0 otherwise
`INDArray`	`condi(Condition condition)` In-place: 1 in the ndarray if the element matches the condition 0 otherwise
`INDArray`	`convertToDoubles()`
`INDArray`	`convertToFloats()`
`protected static DataBuffer.TypeEx`	`convertType(DataBuffer.Type type)`
`protected INDArray`	`create(DataBuffer buffer)`
`protected INDArray`	`create(DataBuffer data, int[] shape, int[] strides)`
`protected INDArray`	`create(DataBuffer data, int[] newShape, int[] newStrides, long offset)`
`protected INDArray`	`create(DataBuffer data, int[] newShape, int[] newStrides, long offset, char ordering)`
`protected INDArray`	`create(DataBuffer data, int[] shape, long offset)`
`protected INDArray`	`create(int[] shape)`
`protected INDArray`	`create(int[] shape, char ordering)`
`protected INDArray`	`create(int[] shape, int[] strides, long offset)`
`protected INDArray`	`create(int rows, int length)`
`protected INDArray`	`createScalar(double d)`
`protected INDArray`	`createScalarForIndex(int i, boolean applyOffset)`
`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`	`detach()` This metod detaches INDArray from Workspace, returning copy.
`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)` 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 h : reverse subtraction t : reverse division
`protected int[]`	`doPermuteSwap(DataBuffer shape, int[] rearrange)`
`protected int[]`	`doPermuteSwap(IntBuffer 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 h : reverse subtraction t : reverse division
`INDArray`	`dup()` Returns a copy of this ndarray
`INDArray`	`dup(char order)` Returns 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`	`entropy(int... dimension)` Returns entropy along dimension
`Number`	`entropyNumber()` Returns entropy value for this INDArray
`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)` Returns the binary ndarray for "Equals" comparison.
`INDArray`	`eq(Number other)` Returns the binary ndarray for "Equals" comparison.
`INDArray`	`eqi(INDArray other)` Returns the binary ndarray for "Equals" comparison.
`INDArray`	`eqi(Number other)` Returns the binary ndarray for "Equals" comparison.
`boolean`	`equals(Object o)` Compare two matrices.
`boolean`	`equalsWithEps(Object o, double eps)` This method allows you to compare INDArray against other INDArray, with variable eps
`int[]`	`flags()`
`INDArray`	`fmod(INDArray denominator)` remainder of division
`INDArray`	`fmod(INDArray denominator, INDArray result)` remainder of division
`INDArray`	`fmod(Number denominator)`
`INDArray`	`fmod(Number denominator, INDArray result)`
`INDArray`	`fmodi(INDArray denominator)` In place fmod
`INDArray`	`fmodi(Number denominator)` In place fmod
`INDArray`	`get(INDArray indices)` Get the elements from this ndarray based on the specified indices
`INDArray`	`get(INDArrayIndex... indexes)` Returns a subset of this array based on the specified indexes
`INDArray`	`get(List<List<Integer>> indices)` Get the elements from this ndarray based on the specified indices
`INDArray`	`getColumn(int c)` Get the specified column
`INDArray`	`getColumns(int... cindices)` Get whole columns from the passed indices.
`double`	`getDouble(int... indices)` Returns the elements at the the specified indices
`double`	`getDouble(int i)` Get the double value at the specified linear index in the array
`double`	`getDouble(int i, int j)` Get the double value at the specified indices.
`double`	`getDoubleUnsafe(long offset)` Get a scalar at the given linear offset
`float`	`getFloat(int... indices)` Returns the elements at the the specified indices
`float`	`getFloat(int i)` Return the item at the linear index i
`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}
`SparseFormat`	`getFormat()` Return the sparse format (i.e COO, CSR, ...)
`int`	`getInt(int... indices)` Returns the elements at the the specified indices
`int`	`getLeadingOnes()` Get the number of leading ones in the array shape.
`protected double`	`getPercentile(Number quantile, INDArray sorted)`
`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
`protected int[]`	`getStrides(int[] shape, char ordering)`
`int`	`getTrailingOnes()` Get the number of trailing ones in the array shape.
`DataBuffer`	`getVectorCoordinates()` Return a array of non-major pointers i.e.
`INDArray`	`getWhere(INDArray comp, Condition condition)` Boolean indexing: Return the element if it fulfills the condition in result array
`INDArray`	`getWhere(Number comp, Condition condition)` Boolean indexing: Return the element if it fulfills the condition in result array
`INDArray`	`gt(INDArray other)` Returns the binary ndarray for "Greter" comparison.
`INDArray`	`gt(Number other)` Returns the binary ndarray for "Greater" comparison.
`INDArray`	`gte(Number other)` Returns binary ndarray for "Greter or equals" comparison.
`INDArray`	`gtei(Number other)` Returns the binary ndarray for "Greter or equals" comparison.
`INDArray`	`gti(INDArray other)` Returns the binary ndarray for "Greter" comparison.
`INDArray`	`gti(Number other)` Returns the binary ndarray for "Greter" comparison.
`int[]`	`hiddenDimensions()`
`int`	`index(int row, int column)` Deprecated.
`protected void`	`init(int[] shape, int[] stride)`
`int`	`innerMostStride()` Get the inner most stride wrt the ordering of the array
`protected static DataBuffer`	`internalCreateBuffer(double[] data)`
`protected static DataBuffer`	`internalCreateBuffer(double[] data, long offset)`
`protected static DataBuffer`	`internalCreateBuffer(float[] data)`
`protected static DataBuffer`	`internalCreateBuffer(float[] data, long offset)`
`protected static DataBuffer`	`internalCreateBuffer(int[] data)`
`protected static DataBuffer`	`internalCreateBuffer(int[] data, long offset)`
`boolean`	`isAttached()` This method returns True, if this INDArray instance is attached to some Workspace.
`boolean`	`isCleanedUp()` Deprecated.
`boolean`	`isColumnVector()` Checks whether the matrix is a column vector.
`boolean`	`isColumnVectorOrScalar()` Returns true if the number of columns is 1
`boolean`	`isCompressed()` Returns true if this array is compressed, and false otherwise
`boolean`	`isInScope()` This method checks, if given attached INDArray is still in scope of its parent Workspace
`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`	`isRowVectorOrScalar()` Returns true if the number of rows is 1
`boolean`	`isScalar()` Test whether a matrix is scalar.
`boolean`	`isSparse()` Returns true if this array is sparse
`boolean`	`isSquare()` Returns whether the matrix has the same rows and columns
`boolean`	`isValid()` Deprecated.
`boolean`	`isVector()` Checks whether the matrix is a vector.
`boolean`	`isVectorOrScalar()` Returns true if this ndarray is a vector or scalar
`boolean`	`isView()` Returns true if this array is a view or not
`boolean`	`isWrapAround()` Deprecated.
`Iterator<Object>`	`iterator()`
`INDArray`	`javaTensorAlongDimension(int index, int... dimension)` Get the vector along a particular dimension
`int`	`length()` Returns the total number of elements in the ndarray
`long`	`lengthLong()` Returns the total number of elements in the ndarray
`INDArray`	`leverage()` This method detaches INDArray from current Workspace, and attaches it to Workspace above, if any.
`INDArray`	`leverageOrDetach(String id)` This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id, if a workspace with the given ID is open and active.
`INDArray`	`leverageTo(String id)` This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id PLEASE NOTE: If this INDArray instance is NOT attached - it will be returned unmodified.
`INDArray`	`leverageTo(String id, boolean enforceExistence)` This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id.
`int`	`linearIndex(int i)` Deprecated.
`INDArray`	`linearView()` Returns a linear view reference of shape 1,length(ndarray)
`INDArray`	`linearViewColumnOrder()` Deprecated.
`INDArray`	`logEntropy(int... dimension)` Returns log entropy along dimension
`Number`	`logEntropyNumber()` Returns log entropy value for this INDArray
`INDArray`	`lt(INDArray other)` Returns the binary ndarray for "Less" comparison.
`INDArray`	`lt(Number other)` Returns the binary ndarray for "Less" comparison.
`INDArray`	`lte(Number other)` Returns the binary ndarray for "Less or equals" comparison.
`INDArray`	`ltei(Number other)` Returns the binary ndarray for "Less or equals" comparison.
`INDArray`	`lti(INDArray other)` Returns the binary ndarray for "Less" comparison.
`INDArray`	`lti(Number other)` Returns the binary ndarray for "Less" comparison.
`int`	`majorStride()` Deprecated.
`void`	`markAsCompressed(boolean reallyCompressed)` This method marks INDArray instance as compressed PLEASE NOTE: Do not use this method unless you 100% have to
`INDArray`	`match(INDArray comp, Condition condition)` Return a mask on whether each element matches the given condition
`INDArray`	`match(Number comp, Condition condition)` Returns a mask
`INDArray`	`max(int... dimension)` Returns the overall max of this ndarray
`IComplexNumber`	`maxComplex()`
`Number`	`maxNumber()` Returns maximum value in this INDArray
`INDArray`	`mean(INDArray result, int... dimension)` Returns the overall mean of this ndarray
`INDArray`	`mean(int... dimension)` Returns the overall mean of this ndarray
`IComplexNumber`	`meanComplex()`
`Number`	`meanNumber()` Returns the overall mean of this ndarray
`INDArray`	`median(int... dimension)` This method returns median along given dimension(s)
`Number`	`medianNumber()` This method returns median value for this INDArray
`INDArray`	`migrate()` This method pulls this INDArray into current Workspace.
`INDArray`	`migrate(boolean detachOnNoWs)` This method pulls this INDArray into current Workspace, or optionally detaches if no workspace is present. That is: If current workspace is present/active, INDArray is migrated to it. If no current workspace is present/active, one of two things occur: 1.
`INDArray`	`min(int... dimension)` Returns the overall min of this ndarray
`IComplexNumber`	`minComplex()`
`Number`	`minNumber()` Returns min value in this INDArray
`INDArray`	`mmul(INDArray other)` Perform a copy matrix multiplication
`INDArray`	`mmul(INDArray other, INDArray result)` Perform an copy matrix multiplication
`INDArray`	`mmul(INDArray other, INDArray result, MMulTranspose mMulTranspose)` Perform a copy matrix multiplication
`INDArray`	`mmul(INDArray other, MMulTranspose mMulTranspose)` Perform a copy matrix multiplication
`INDArray`	`mmuli(INDArray other)` Perform an copy matrix multiplication
`INDArray`	`mmuli(INDArray other, INDArray result)` Perform an copy matrix multiplication
`INDArray`	`mmuli(INDArray other, INDArray result, MMulTranspose transpose)` Perform an in place matrix multiplication
`INDArray`	`mmuli(INDArray other, MMulTranspose transpose)` 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)` 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).
`INDArray`	`neq(INDArray other)` Returns the binary ndarray for "Not equals" comparison.
`INDArray`	`neq(Number other)` Returns the binary ndarray for "Not equals" comparison.
`INDArray`	`neqi(INDArray other)` Returns the binary ndarray for "Not equals" comparison.
`INDArray`	`neqi(Number other)` Returns the binary ndarray for "Not equals" comparison.
`protected INDArray`	`newShape(int[] newShape, char ordering)`
`int`	`nnz()` Return the number of non-null element
`INDArray`	`norm1(int... dimension)` Returns the norm1 along the specified dimension
`IComplexNumber`	`norm1Complex()` Calculate and return norm1 (L1 norm, i.e., sum of absolute values; also known as Taxicab or Manhattan norm) for the entire array
`Number`	`norm1Number()` Calculate and return norm1 (L1 norm, i.e., sum of absolute values; also known as Taxicab or Manhattan norm) for the entire array
`INDArray`	`norm2(int... dimension)` Returns the norm2 along the specified dimension
`IComplexNumber`	`norm2Complex()`
`Number`	`norm2Number()` Return the norm2 (L2 norm, sqrt(sum(x_i^2), also known as Euclidean norm) for the entire array
`INDArray`	`normmax(int... dimension)` Returns the normmax along the specified dimension
`IComplexNumber`	`normmaxComplex()`
`Number`	`normmaxNumber()` Return the max norm (aka infinity norm, equal to the maximum absolute value) for the entire array
`long`	`offset()` Returns the start of where the ndarray is for the underlying data
`char`	`ordering()` Return the ordering (fortran or c 'f' and 'c' respectively) of this ndarray
`long`	`originalOffset()` Returns the start of where the ndarray is for the original data buffer
`INDArray`	`percentile(Number quantile, int... dimension)` This method returns median along given dimension(s)
`Number`	`percentileNumber(Number quantile)` This method returns percentile value for this INDArray
`INDArray`	`permute(int... rearrange)` See: http://www.mathworks.com/help/matlab/ref/permute.html
`INDArray`	`permutei(int... rearrange)` An in-place version of permute.
`INDArray`	`prod(int... dimension)` Returns the product along a given dimension
`IComplexNumber`	`prodComplex()`
`Number`	`prodNumber()` Calculate the product of all values in the array
`INDArray`	`put(INDArray indices, INDArray element)` Put element in to the indices denoted by the indices ndarray.
`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`	`put(List<List<Integer>> indices, INDArray element)` Put element in to the indices denoted by the indices ndarray.
`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`	`putiColumnVector(INDArray columnVector)` In place assignment of a column vector
`INDArray`	`putiRowVector(INDArray rowVector)` in place assignment of row vector, to each row of this array
`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, double value)` Insert the item at the specified indices
`INDArray`	`putScalar(int[] indexes, float value)` Put the specified float value at the specified indices in this array
`INDArray`	`putScalar(int[] indexes, int value)` Put the specified integer value at the specified indices in this array
`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`	`putScalar(int row, int col, double value)` Insert the value at the specified indices, in a 2d (rank 2) NDArray Equivalent to `INDArray.putScalar(int[], double)` but avoids int[] creation
`INDArray`	`putScalar(int dim0, int dim1, int dim2, double value)` Insert the value at the specified indices, in a 3d (rank 3) NDArray Equivalent to `INDArray.putScalar(int[], double)` but avoids int[] creation
`INDArray`	`putScalar(int dim0, int dim1, int dim2, int dim3, double value)` Insert the value at the specified indices, in a 4d (rank 4) NDArray Equivalent to `INDArray.putScalar(int[], double)` but avoids int[] creation
`INDArray`	`putScalarUnsafe(long offset, double value)` Insert a scalar at the given linear offset
`INDArray`	`putSlice(int slice, INDArray put)` Assigns the given matrix (put) to the specified slice
`INDArray`	`putWhere(INDArray comp, INDArray put, Condition condition)` Assign the element according to the comparison array
`INDArray`	`putWhere(Number comp, INDArray put, Condition condition)` Assign the element according to the comparison array
`INDArray`	`putWhere(Number comp, Number put, Condition condition)` Assign the element according to the comparison array
`INDArray`	`putWhereWithMask(INDArray mask, INDArray put)` Use a pre computed mask for assigning arrays
`INDArray`	`putWhereWithMask(INDArray mask, Number put)` Use a pre computed mask for assigning arrays
`int`	`rank()` Returns the rank of the ndarray (the number of dimensions).
`INDArray`	`ravel()` Flattens the array for linear indexing
`INDArray`	`ravel(char ordering)` 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)` Reverse division with a scalar - i.e., (n / thisArrayValues)
`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 - i.e., (n / thisArrayValues)
`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)
`protected void`	`read(ObjectInputStream s)`
`INDArray`	`remainder(INDArray denominator)` Remainder operator
`INDArray`	`remainder(INDArray denominator, INDArray result)` Remainder operator
`INDArray`	`remainder(Number denominator)` The scalar denominator
`INDArray`	`remainder(Number denominator, INDArray result)`
`INDArray`	`remainderi(INDArray denominator)` In place remainder
`INDArray`	`remainderi(Number denominator)` In place remainder
`INDArray`	`repeat(int dimension, int... repeats)` Repeat elements along a specified dimension.
`INDArray`	`replaceWhere(INDArray arr, Condition condition)` Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
`INDArray`	`repmat(int[] shape)` Replicate and tile array to fill out to the given shape See: https://github.com/numpy/numpy/blob/master/numpy/matlib.py#L310-L358
`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... shape)` Reshape the ndarray in to the specified dimensions, possible errors being thrown for invalid shapes Note here that one dimension can be -1.
`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)` Element-wise reverse subtraction (copy op).
`INDArray`	`rsub(INDArray other, INDArray result)` Reverse subtraction
`INDArray`	`rsub(Number n)` Reverse subtraction with duplicates - i.e., (n - thisArrayValues)
`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)` Element-wise reverse subtraction (in the place op) - i.e., other - this
`INDArray`	`rsubi(INDArray other, INDArray result)` Reverse subtraction (in-place)
`INDArray`	`rsubi(Number n)` Reverse subtraction in place - i.e., (n - thisArrayValues)
`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)
`Number`	`scan(Condition condition)` This method takes boolean condition, and returns number of elements matching this condition
`int`	`secondaryStride()` Deprecated.
`void`	`setData(DataBuffer data)`
`void`	`setOrder(char order)` Set the ordering
`void`	`setShape(int... shape)` Shape setter
`void`	`setShapeAndStride(int[] shape, int[] stride)` Shape and stride setter
`void`	`setStride(int[] stride)` stride setter
`void`	`setWrapAround(boolean wrapAround)` Deprecated.
`INDArray`	`shannonEntropy(int... dimension)` Returns non-normalized Shannon entropy along dimension
`Number`	`shannonEntropyNumber()` Returns non-normalized Shannon entropy value for this INDArray
`int[]`	`shape()` Returns the shape(dimensions) of this array
`IntBuffer`	`shapeInfo()` Shape info
`DataBuffer`	`shapeInfoDataBuffer()` Shape info
`String`	`shapeInfoToString()` Returns the shape information debugging information
`protected DataBuffer`	`shapeOf()`
`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
`DataBuffer`	`sparseInfoDataBuffer()` Sparse info
`int[]`	`sparseOffsets()`
`double`	`squaredDistance(INDArray other)` Returns the square of the Euclidean distance.
`INDArray`	`std(boolean biasCorrected, int... dimension)` Standard deviation of an ndarray along a dimension
`INDArray`	`std(int... dimension)` Standard deviation of an ndarray along a dimension
`IComplexNumber`	`stdComplex()`
`Number`	`stdNumber()` Calculate the standard deviation for the entire array
`Number`	`stdNumber(boolean biasCorrected)` Calculate the standard deviation for the entire array, specifying whether it is bias corrected or not
`int[]`	`stride()` Returns the stride(indices along the linear index for which each slice is accessed) of this array
`int`	`stride(int dimension)` Calculate the stride along a particular dimension
`protected DataBuffer`	`strideOf()`
`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(long[] offsets, int[] shape, int[] stride)`
`INDArray`	`subArray(ShapeOffsetResolution resolution)` Sub array based on the pre calculated shape,strides, offsets
`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(INDArray result, int... dimension)` Returns the sum along the last dimension of this ndarray
`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`	`toDense()` Return a dense representation of the sparse ndarray
`double[][]`	`toDoubleMatrix()` Convert this ndarray to a 2d double matrix.
`double[]`	`toDoubleVector()` Convert this ndarray to a 1d double matrix.
`int`	`toFlatArray(com.google.flatbuffers.FlatBufferBuilder builder)` Add an `INDArray` to flatbuffers builder
`float[][]`	`toFloatMatrix()` Convert this ndarray to a 2d float matrix.
`float[]`	`toFloatVector()` Convert this ndarray to a 1d float vector.
`int[][]`	`toIntMatrix()` Convert this ndarray to a 2d int matrix.
`int[]`	`toIntVector()` Convert this ndarray to a 1d int matrix.
`String`	`toString()` Generate string representation of the matrix.
`INDArray`	`transpose()` Return transposed copy of this matrix.
`INDArray`	`transposei()` Return transposed version of this matrix.
`int`	`underlyingRank()`
`INDArray`	`var(boolean biasCorrected, int... dimension)` Returns the overall variance of this ndarray
`INDArray`	`var(int... dimension)` Returns the overall variance of this ndarray
`IComplexNumber`	`varComplex()`
`Number`	`varNumber()` Returns the overall variance of all values in this INDArray
`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
`protected void`	`write(ObjectOutputStream out)`

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

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

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

- Field Detail
  - shapeInformation
```
protected transient volatile DataBuffer shapeInformation
```
  - data
```
protected transient volatile DataBuffer data
```
  - compressed
```
protected transient boolean compressed
```
  - javaShapeInformation
```
protected int[] javaShapeInformation
```
- Constructor Detail
  - BaseNDArray
```
public BaseNDArray()
```
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer)
```
    Parameters:
    
    buffer -
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer,
                   int[] shape,
                   int[] stride,
                   long offset,
                   char ordering)
```
    Parameters:
    
    buffer -
    
    shape -
    
    stride -
    
    offset -
    
    ordering -
  - BaseNDArray
```
public BaseNDArray(double[][] data)
```
    Initialize the ndarray as a matrix with the given data (indices preserved)
    
    Parameters:
    
    data -
  - BaseNDArray
```
public BaseNDArray(double[][] data,
                   char ordering)
```
    Parameters:
    
    data -
    
    ordering -
  - BaseNDArray
```
public BaseNDArray(int[] shape,
                   DataBuffer buffer)
```
    Create with the specified shape and buffer
    
    Parameters:
    
    shape - the shape
    
    buffer - the buffer
  - 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,
                   long 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,
                   long 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,
                   long offset,
                   char ordering,
                   boolean initialize)
```
    Construct an ndarray of the specified shape.
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride of the ndarray
    
    offset - the desired offset
    
    ordering - the ordering of the ndarray
    
    initialize - Whether to initialize the INDArray. If true: initialize. If false: don't.
  - 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,
                   long offset,
                   char ordering)
```
    Parameters:
    
    shape -
    
    offset -
    
    ordering -
  - BaseNDArray
```
public BaseNDArray(int[] shape)
```
    Create an ndarray with the given shape
    
    Parameters:
    
    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)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    ordering -
  - BaseNDArray
```
public BaseNDArray(float[] data,
                   int[] shape,
                   int[] stride,
                   long offset,
                   char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    offset -
    
    ordering -
  - BaseNDArray
```
public BaseNDArray(DataBuffer data,
                   int[] shape,
                   int[] stride,
                   long offset)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    offset -
  - BaseNDArray
```
public BaseNDArray(int[] data,
                   int[] shape,
                   int[] strides)
```
    Parameters:
    
    data -
    
    shape -
    
    strides -
  - BaseNDArray
```
public BaseNDArray(DataBuffer data,
                   int[] shape)
```
    Parameters:
    
    data -
    
    shape -
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer,
                   int[] shape,
                   long offset)
```
    Parameters:
    
    buffer -
    
    shape -
    
    offset -
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer,
                   int[] shape,
                   char ordering)
```
    Parameters:
    
    buffer -
    
    shape -
    
    ordering -
  - BaseNDArray
```
public BaseNDArray(double[] data,
                   int[] shape,
                   char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    ordering -
  - BaseNDArray
```
public BaseNDArray(double[] data,
                   int[] shape,
                   int[] stride,
                   long offset,
                   char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    offset -
    
    ordering -
  - BaseNDArray
```
public BaseNDArray(float[] data,
                   char order)
```
    Parameters:
    
    data -
    
    order -
  - BaseNDArray
```
public BaseNDArray(DataBuffer floatBuffer,
                   char order)
```
    Parameters:
    
    floatBuffer -
    
    order -
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer,
                   int[] shape,
                   int[] strides)
```
    Parameters:
    
    buffer -
    
    shape -
    
    strides -
  - 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,
                   long offset)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
  - BaseNDArray
```
public BaseNDArray(int[] shape,
                   int[] stride,
                   long 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,
                   long offset)
```
    Parameters:
    
    shape -
    
    offset -
  - BaseNDArray
```
public BaseNDArray(int[] shape,
                   char ordering)
```
    Parameters:
    
    shape -
    
    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)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
  - BaseNDArray
```
public BaseNDArray(float[] data,
                   int[] shape,
                   int[] stride,
                   long offset)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    offset -
  - BaseNDArray
```
public BaseNDArray(float[] data)
```
    Parameters:
    
    data -
  - BaseNDArray
```
public BaseNDArray(float[][] data)
```
    Initialize the ndarray with the given data
    
    Parameters:
    
    data -
  - BaseNDArray
```
public BaseNDArray(float[][] data,
                   char ordering)
```
    Parameters:
    
    data -
    
    ordering -
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer,
                   int[] shape,
                   long offset,
                   char ordering)
```
    Constructor for stride and offset
    
    Parameters:
    
    buffer -
    
    shape -
    
    offset -
    
    ordering -
  - BaseNDArray
```
public BaseNDArray(double[] data,
                   int[] shape,
                   int[] stride,
                   long offset)
```
- Method Detail
  - isCompressed
```
public boolean isCompressed()
```
    Returns true if this array is compressed, and false otherwise
    
    Specified by:
    
    isCompressed in interface INDArray
    
    Returns:
  - markAsCompressed
```
public void markAsCompressed(boolean reallyCompressed)
```
    This method marks INDArray instance as compressed PLEASE NOTE: Do not use this method unless you 100% have to
    
    Specified by:
    
    markAsCompressed in interface INDArray
    
    Parameters:
    
    reallyCompressed -
  - internalCreateBuffer
```
protected static DataBuffer internalCreateBuffer(float[] data)
```
  - internalCreateBuffer
```
protected static DataBuffer internalCreateBuffer(double[] data)
```
  - internalCreateBuffer
```
protected static DataBuffer internalCreateBuffer(int[] data)
```
  - internalCreateBuffer
```
protected static DataBuffer internalCreateBuffer(float[] data,
                                                 long offset)
```
  - internalCreateBuffer
```
protected static DataBuffer internalCreateBuffer(double[] data,
                                                 long offset)
```
  - internalCreateBuffer
```
protected static DataBuffer internalCreateBuffer(int[] data,
                                                 long offset)
```
  - setWrapAround
```
@Deprecated
public void setWrapAround(boolean wrapAround)
```
    Deprecated.
    
    Description copied from interface: INDArray
    
    Set the ndarray to wrap around
    
    Specified by:
    
    setWrapAround in interface INDArray
    
    Parameters:
    
    wrapAround - thewrap around
  - isWrapAround
```
@Deprecated
public boolean isWrapAround()
```
    Deprecated.
    
    Description copied from interface: INDArray
    
    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.
    
    Specified by:
    
    isWrapAround in interface INDArray
    
    Returns:
    
    true if this ndarray wraps around on linear indexing, false otherwise
  - isValid
```
@Deprecated
public boolean isValid()
```
    Deprecated.
    
    Returns whether the ndarray is valid or not
    
    Returns:
    
    true if the ndarray is valid false otherwise
  - linearViewColumnOrder
```
@Deprecated
public INDArray linearViewColumnOrder()
```
    Deprecated.
    
    Description copied from interface: INDArray
    
    Returns a linear view reference of shape 1,length(ndarray)
    
    Specified by:
    
    linearViewColumnOrder in interface INDArray
    
    Returns:
    
    the linear view of this ndarray
  - create
```
protected INDArray create(DataBuffer data,
                          int[] shape,
                          long offset)
```
  - 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
  - resetLinearView
```
public void resetLinearView()
```
    Description copied from interface: INDArray
    
    Resets the linear view
    
    Specified by:
    
    resetLinearView in interface INDArray
  - elementWiseStride
```
public int elementWiseStride()
```
    Description copied from interface: INDArray
    
    Element wise stride
    
    Specified by:
    
    elementWiseStride in interface INDArray
  - elementStride
```
public int elementStride()
```
    Description copied from interface: INDArray
    
    Element stride (one element to the next, also called the defualt stride: 1 for normal 2 for complex)
    
    Specified by:
    
    elementStride in interface INDArray
    
    Returns:
  - majorStride
```
@Deprecated
public int majorStride()
```
    Deprecated.
    
    Description copied from interface: INDArray
    
    Return the major stride for an ndarray
    
    Specified by:
    
    majorStride in interface INDArray
    
    Returns:
    
    the major stride for an ndarray
  - secondaryStride
```
@Deprecated
public int secondaryStride()
```
    Deprecated.
    
    Description copied from interface: INDArray
    
    Return the second stride for an ndarray. Think of this as the stride for the next element in a column.
    
    Specified by:
    
    secondaryStride in interface INDArray
    
    Returns:
    
    the secondary stride for an ndarray
  - tensorssAlongDimension
```
public int tensorssAlongDimension(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the number of possible vectors for a given dimension
    
    Specified by:
    
    tensorssAlongDimension in interface INDArray
    
    Parameters:
    
    dimension - the dimension to calculate the number of vectors for
    
    Returns:
    
    the number of possible vectors along a dimension
  - tensorAlongDimension
```
public INDArray tensorAlongDimension(int index,
                                     int... dimension)
```
    Description copied from interface: INDArray
    
    Get the vector along a particular dimension
    
    Specified by:
    
    tensorAlongDimension 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
  - javaTensorAlongDimension
```
public INDArray javaTensorAlongDimension(int index,
                                         int... dimension)
```
    Get the vector along a particular dimension
    
    Specified by:
    
    javaTensorAlongDimension 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
  - 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 get
    
    dimension - the dimension to get the vector from
    
    Returns:
    
    the vector along a particular dimension
  - setOrder
```
public void setOrder(char order)
```
    Description copied from interface: INDArray
    
    Set the ordering
    
    Specified by:
    
    setOrder in interface INDArray
    
    Parameters:
    
    order - the ordering to set
  - setShape
```
public void setShape(int... shape)
```
    Description copied from interface: INDArray
    
    Shape setter
    
    Specified by:
    
    setShape in interface INDArray
  - setStride
```
public void setStride(int[] stride)
```
    Description copied from interface: INDArray
    
    stride setter
    
    Specified by:
    
    setStride in interface INDArray
  - setShapeAndStride
```
public void setShapeAndStride(int[] shape,
                              int[] stride)
```
    Description copied from interface: INDArray
    
    Shape and stride setter
    
    Specified by:
    
    setShapeAndStride in interface INDArray
  - 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
  - normmaxNumber
```
public Number normmaxNumber()
```
    Description copied from interface: INDArray
    
    Return the max norm (aka infinity norm, equal to the maximum absolute value) for the entire array
    
    Specified by:
    
    normmaxNumber in interface INDArray
    
    Returns:
    
    Max norm for the entire array
  - normmaxComplex
```
public IComplexNumber normmaxComplex()
```
    Specified by:
    
    normmaxComplex in interface INDArray
    
    Returns:
  - norm2Number
```
public Number norm2Number()
```
    Description copied from interface: INDArray
    
    Return the norm2 (L2 norm, sqrt(sum(x_i^2), also known as Euclidean norm) for the entire array
    
    Specified by:
    
    norm2Number in interface INDArray
    
    Returns:
    
    L2 norm for the array
  - norm2Complex
```
public IComplexNumber norm2Complex()
```
    Specified by:
    
    norm2Complex in interface INDArray
    
    Returns:
  - norm1Number
```
public Number norm1Number()
```
    Description copied from interface: INDArray
    
    Calculate and return norm1 (L1 norm, i.e., sum of absolute values; also known as Taxicab or Manhattan norm) for the entire array
    
    Specified by:
    
    norm1Number in interface INDArray
    
    Returns:
    
    Norm 1 for the array
  - norm1Complex
```
public IComplexNumber norm1Complex()
```
    Description copied from interface: INDArray
    
    Calculate and return norm1 (L1 norm, i.e., sum of absolute values; also known as Taxicab or Manhattan norm) for the entire array
    
    Specified by:
    
    norm1Complex in interface INDArray
    
    Returns:
  - stdNumber
```
public Number stdNumber()
```
    Description copied from interface: INDArray
    
    Calculate the standard deviation for the entire array
    
    Specified by:
    
    stdNumber in interface INDArray
    
    Returns:
  - stdComplex
```
public IComplexNumber stdComplex()
```
    Specified by:
    
    stdComplex in interface INDArray
    
    Returns:
  - prodNumber
```
public Number prodNumber()
```
    Description copied from interface: INDArray
    
    Calculate the product of all values in the array
    
    Specified by:
    
    prodNumber in interface INDArray
    
    Returns:
    
    Product of all values in the array
  - prodComplex
```
public IComplexNumber prodComplex()
```
    Specified by:
    
    prodComplex in interface INDArray
    
    Returns:
  - meanNumber
```
public Number meanNumber()
```
    Description copied from interface: INDArray
    
    Returns the overall mean of this ndarray
    
    Specified by:
    
    meanNumber in interface INDArray
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - ameanNumber
```
public Number ameanNumber()
```
    Description copied from interface: INDArray
    
    Returns the absolute overall mean of this ndarray
    
    Specified by:
    
    ameanNumber in interface INDArray
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - meanComplex
```
public IComplexNumber meanComplex()
```
    Specified by:
    
    meanComplex in interface INDArray
  - varNumber
```
public Number varNumber()
```
    Description copied from interface: INDArray
    
    Returns the overall variance of all values in this INDArray
    
    Specified by:
    
    varNumber in interface INDArray
    
    Returns:
    
    variance
  - varComplex
```
public IComplexNumber varComplex()
```
    Specified by:
    
    varComplex in interface INDArray
    
    Returns:
  - maxNumber
```
public Number maxNumber()
```
    Description copied from interface: INDArray
    
    Returns maximum value in this INDArray
    
    Specified by:
    
    maxNumber in interface INDArray
    
    Returns:
    
    maximum value
  - amaxNumber
```
public Number amaxNumber()
```
    Description copied from interface: INDArray
    
    Returns maximum (absolute) value in this INDArray
    
    Specified by:
    
    amaxNumber in interface INDArray
    
    Returns:
    
    Max absolute value
  - maxComplex
```
public IComplexNumber maxComplex()
```
    Specified by:
    
    maxComplex in interface INDArray
    
    Returns:
  - minNumber
```
public Number minNumber()
```
    Description copied from interface: INDArray
    
    Returns min value in this INDArray
    
    Specified by:
    
    minNumber in interface INDArray
    
    Returns:
    
    Minimum value in the array
  - aminNumber
```
public Number aminNumber()
```
    Description copied from interface: INDArray
    
    Returns absolute min value in this INDArray
    
    Specified by:
    
    aminNumber in interface INDArray
    
    Returns:
    
    Absolute min value
  - scan
```
public Number scan(Condition condition)
```
    Description copied from interface: INDArray
    
    This method takes boolean condition, and returns number of elements matching this condition
    
    Specified by:
    
    scan in interface INDArray
    
    Parameters:
    
    condition - Condition to calculate matches for
    
    Returns:
    
    Number of elements matching condition
  - minComplex
```
public IComplexNumber minComplex()
```
    Specified by:
    
    minComplex in interface INDArray
  - sumNumber
```
public Number sumNumber()
```
    Description copied from interface: INDArray
    
    Sum the entire array
    
    Specified by:
    
    sumNumber in interface INDArray
    
    Returns:
    
    Sum of array
  - entropyNumber
```
public Number entropyNumber()
```
    Returns entropy value for this INDArray
    
    Specified by:
    
    entropyNumber in interface INDArray
    
    Returns:
  - shannonEntropyNumber
```
public Number shannonEntropyNumber()
```
    Returns non-normalized Shannon entropy value for this INDArray
    
    Specified by:
    
    shannonEntropyNumber in interface INDArray
    
    Returns:
  - logEntropyNumber
```
public Number logEntropyNumber()
```
    Returns log entropy value for this INDArray
    
    Specified by:
    
    logEntropyNumber in interface INDArray
    
    Returns:
  - sumComplex
```
public IComplexNumber sumComplex()
```
    Description copied from interface: INDArray
    
    Sum the entire array
    
    Specified by:
    
    sumComplex in interface INDArray
    
    Returns:
  - 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,
                          double 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 i,
                          float value)
```
    Description copied from interface: INDArray
    
    Insert a scalar float at the specified index
    
    Specified by:
    
    putScalar in interface INDArray
    
    Parameters:
    
    i - The index to insert into
    
    value - Value to insert
    
    Returns:
    
    This array
  - putScalar
```
public INDArray putScalar(int i,
                          int value)
```
    Description copied from interface: INDArray
    
    Insert a scalar int at the specified index
    
    Specified by:
    
    putScalar in interface INDArray
    
    Parameters:
    
    i - The index to insert into
    
    value - Value to insert
    
    Returns:
    
    This array
  - putScalar
```
public INDArray putScalar(int[] indexes,
                          double 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
  - putScalar
```
public INDArray putScalar(int row,
                          int col,
                          double value)
```
    Description copied from interface: INDArray
    
    Insert the value at the specified indices, in a 2d (rank 2) NDArray
    Equivalent to INDArray.putScalar(int[], double) but avoids int[] creation
    
    Specified by:
    
    putScalar in interface INDArray
    
    Parameters:
    
    row - Row (dimension 0) index
    
    col - Column (dimension 1) index
    
    value - Value to put
    
    Returns:
    
    This INDArray
  - putScalar
```
public INDArray putScalar(int dim0,
                          int dim1,
                          int dim2,
                          double value)
```
    Description copied from interface: INDArray
    
    Insert the value at the specified indices, in a 3d (rank 3) NDArray
    Equivalent to INDArray.putScalar(int[], double) but avoids int[] creation
    
    Specified by:
    
    putScalar in interface INDArray
    
    Parameters:
    
    dim0 - Dimension 0 index
    
    dim1 - Dimension 1 index
    
    dim2 - Dimension 2 index
    
    value - Value to put
    
    Returns:
    
    This INDArray
  - putScalar
```
public INDArray putScalar(int dim0,
                          int dim1,
                          int dim2,
                          int dim3,
                          double value)
```
    Description copied from interface: INDArray
    
    Insert the value at the specified indices, in a 4d (rank 4) NDArray
    Equivalent to INDArray.putScalar(int[], double) but avoids int[] creation
    
    Specified by:
    
    putScalar in interface INDArray
    
    Parameters:
    
    dim0 - Dimension 0 index
    
    dim1 - Dimension 1 index
    
    dim2 - Dimension 2 index
    
    dim3 - Dimension 3 index
    
    value - Value to put
    
    Returns:
    
    This INDArray
  - putScalar
```
public INDArray putScalar(int[] indexes,
                          float value)
```
    Description copied from interface: INDArray
    
    Put the specified float value at the specified indices in this array
    
    Specified by:
    
    putScalar in interface INDArray
    
    Parameters:
    
    indexes - Indices to place the value
    
    value - Value to insert
    
    Returns:
    
    This array
  - putScalar
```
public INDArray putScalar(int[] indexes,
                          int value)
```
    Description copied from interface: INDArray
    
    Put the specified integer value at the specified indices in this array
    
    Specified by:
    
    putScalar in interface INDArray
    
    Parameters:
    
    indexes - Indices to place the value
    
    value - Value to insert
    
    Returns:
    
    This array
  - eps
```
public INDArray eps(Number other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Specified by:
    
    eps in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a copied ndarray with the given binary conditions
  - epsi
```
public INDArray epsi(Number other)
```
    Returns an ndarray with 1 if the element is epsilon equals
    
    Specified by:
    
    epsi in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    a ndarray with the given binary conditions
  - eps
```
public INDArray eps(INDArray other)
```
    epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
    
    Specified by:
    
    eps in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - epsi
```
public 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
    
    Specified by:
    
    epsi in interface INDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
  - lt
```
public INDArray lt(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Less" comparison.
    
    Specified by:
    
    lt in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    the binary ndarray for "Less" comparison.
  - lte
```
public INDArray lte(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Less or equals" comparison.
    
    Specified by:
    
    lte in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    the binary ndarray for "Less or equals" comparison.
  - lti
```
public INDArray lti(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Less" comparison. In-place method.
    
    Specified by:
    
    lti in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    this object.
  - ltei
```
public INDArray ltei(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Less or equals" comparison. In-place method.
    
    Specified by:
    
    ltei in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    this object.
  - eq
```
public INDArray eq(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Equals" comparison.
    
    Specified by:
    
    eq in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    the binary ndarray for "Equals" comparison.
  - eqi
```
public INDArray eqi(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Equals" comparison. In-place method.
    
    Specified by:
    
    eqi in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    this object.
  - gt
```
public INDArray gt(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Greater" comparison.
    
    Specified by:
    
    gt in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    the binary ndarray for "Greater" comparison.
  - gte
```
public INDArray gte(Number other)
```
    Description copied from interface: INDArray
    
    Returns binary ndarray for "Greter or equals" comparison.
    
    Specified by:
    
    gte in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    binary ndarray for "Greter or equals" comparison.
  - gtei
```
public INDArray gtei(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Greter or equals" comparison. In-place method.
    
    Specified by:
    
    gtei in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    this object.
  - gti
```
public INDArray gti(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Greter" comparison. In-place method.
    
    Specified by:
    
    gti in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    this object.
  - lt
```
public INDArray lt(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Less" comparison.
    
    Specified by:
    
    lt in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    the binary ndarray for "Less" comparison.
  - lti
```
public INDArray lti(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Less" comparison. In-place method.
    
    Specified by:
    
    lti in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    this object.
  - neq
```
public INDArray neq(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Not equals" comparison.
    
    Specified by:
    
    neq in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    the binary ndarray for "Not equals" comparison.
  - neqi
```
public INDArray neqi(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Not equals" comparison. In-place method.
    
    Specified by:
    
    neqi in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    this object.
  - neq
```
public INDArray neq(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Not equals" comparison.
    
    Specified by:
    
    neq in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    the binary ndarray for "Not equals" comparison.
  - neqi
```
public INDArray neqi(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Not equals" comparison. In-place method.
    
    Specified by:
    
    neqi in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    this object.
  - eq
```
public INDArray eq(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Equals" comparison.
    
    Specified by:
    
    eq in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    the binary ndarray for "Equals" comparison.
  - eqi
```
public INDArray eqi(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Equals" comparison. In-place method.
    
    Specified by:
    
    eqi in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    this object.
  - gt
```
public INDArray gt(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Greter" comparison.
    
    Specified by:
    
    gt in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    the binary ndarray for "Greter" comparison.
  - gti
```
public INDArray gti(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Greter" comparison. In-place method.
    
    Specified by:
    
    gti in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    this object.
  - neg
```
public INDArray neg()
```
    Negate each element.
    
    Specified by:
    
    neg in interface INDArray
    
    Returns:
    
    Array copy with all values negated
  - negi
```
public INDArray negi()
```
    Negate each element (in-place).
    
    Specified by:
    
    negi in interface INDArray
    
    Returns:
    
    This array with all values negated
  - rdiv
```
public INDArray rdiv(Number n,
                     INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse division (number / ndarray)
    
    Specified by:
    
    rdiv in interface INDArray
    
    Parameters:
    
    n - the number to divide by
    
    result - Array to place the result in. Must match shape of this array
    
    Returns:
    
    Result array
  - 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)
```
    Description copied from interface: INDArray
    
    Reverse subtraction
    
    Specified by:
    
    rsub in interface INDArray
    
    Parameters:
    
    n - the number to subtract by
    
    result - the result ndarray
    
    Returns:
  - 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
    
    Returns:
  - 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
    
    Returns a copy of this ndarray
    
    Specified by:
    
    dup in interface INDArray
    
    Returns:
    
    a copy of this ndarray
  - dup
```
public INDArray dup(char order)
```
    Description copied from interface: INDArray
    
    Returns a copy of this ndarray, where the returned ndarray has the specified order
    
    Specified by:
    
    dup in interface INDArray
    
    Parameters:
    
    order - order of the NDArray. 'f' or 'c'
    
    Returns:
    
    copy of ndarray with specified order
  - getInt
```
public int getInt(int... indices)
```
    Returns the elements at the the specified indices
    
    Specified by:
    
    getInt in interface INDArray
    
    Parameters:
    
    indices - the indices to getScalar
    
    Returns:
    
    the array with the specified elements
  - getDouble
```
public double getDouble(int... indices)
```
    Returns the elements at the the specified indices
    
    Specified by:
    
    getDouble in interface INDArray
    
    Parameters:
    
    indices - the indices to get
    
    Returns:
    
    the array with the specified elements
  - getFloat
```
public float getFloat(int... indices)
```
    Returns the elements at the the specified indices
    
    Specified by:
    
    getFloat in interface INDArray
    
    Parameters:
    
    indices - the indices to get
    
    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
  - match
```
public INDArray match(INDArray comp,
                      Condition condition)
```
    Description copied from interface: INDArray
    
    Return a mask on whether each element matches the given condition
    
    Specified by:
    
    match in interface INDArray
    
    Returns:
  - match
```
public INDArray match(Number comp,
                      Condition condition)
```
    Description copied from interface: INDArray
    
    Returns a mask
    
    Specified by:
    
    match in interface INDArray
    
    Returns:
  - getWhere
```
public INDArray getWhere(INDArray comp,
                         Condition condition)
```
    Description copied from interface: INDArray
    
    Boolean indexing: Return the element if it fulfills the condition in result array
    
    Specified by:
    
    getWhere in interface INDArray
    
    Parameters:
    
    comp - the comparison array
    
    condition - the condition to apply
    
    Returns:
    
    the array fulfilling the criteria
  - getWhere
```
public INDArray getWhere(Number comp,
                         Condition condition)
```
    Description copied from interface: INDArray
    
    Boolean indexing: Return the element if it fulfills the condition in result array
    
    Specified by:
    
    getWhere in interface INDArray
    
    Parameters:
    
    comp - the comparison array
    
    condition - the condition to apply
    
    Returns:
    
    the array fulfilling the criteria
  - putWhere
```
public INDArray putWhere(INDArray comp,
                         INDArray put,
                         Condition condition)
```
    Description copied from interface: INDArray
    
    Assign the element according to the comparison array
    
    Specified by:
    
    putWhere in interface INDArray
    
    Parameters:
    
    comp - the comparison array
    
    put - the elements to put
    
    condition - the condition for masking on
    
    Returns:
  - putWhere
```
public INDArray putWhere(Number comp,
                         INDArray put,
                         Condition condition)
```
    Description copied from interface: INDArray
    
    Assign the element according to the comparison array
    
    Specified by:
    
    putWhere in interface INDArray
    
    Parameters:
    
    comp - the comparison array
    
    put - the elements to put
    
    condition - the condition for masking on
    
    Returns:
  - putWhere
```
public INDArray putWhere(Number comp,
                         Number put,
                         Condition condition)
```
    Description copied from interface: INDArray
    
    Assign the element according to the comparison array
    
    Specified by:
    
    putWhere in interface INDArray
    
    Parameters:
    
    comp - the comparison array
    
    put - the elements to put
    
    condition - the condition for masking on
    
    Returns:
  - putWhereWithMask
```
public INDArray putWhereWithMask(INDArray mask,
                                 INDArray put)
```
    Description copied from interface: INDArray
    
    Use a pre computed mask for assigning arrays
    
    Specified by:
    
    putWhereWithMask in interface INDArray
    
    Parameters:
    
    mask - the mask to use
    
    put - the array to put
    
    Returns:
    
    the resulting array
  - putWhereWithMask
```
public INDArray putWhereWithMask(INDArray mask,
                                 Number put)
```
    Description copied from interface: INDArray
    
    Use a pre computed mask for assigning arrays
    
    Specified by:
    
    putWhereWithMask in interface INDArray
    
    Parameters:
    
    mask - the mask to use
    
    put - the array to put
    
    Returns:
    
    the resulting array
  - 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 put
    
    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
  - index
```
@Deprecated
public int index(int row,
                             int column)
```
    Deprecated.
    
    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)
```
  - create
```
protected INDArray create(DataBuffer data,
                          int[] newShape,
                          int[] newStrides,
                          long offset,
                          char ordering)
```
  - create
```
protected INDArray create(DataBuffer data,
                          int[] newShape,
                          int[] newStrides,
                          long offset)
```
  - create
```
protected INDArray create(int[] shape)
```
  - create
```
protected INDArray create(int[] shape,
                          int[] strides,
                          long offset)
```
  - getStrides
```
protected int[] getStrides(int[] shape,
                           char ordering)
```
  - squaredDistance
```
public double squaredDistance(INDArray other)
```
    Returns the square of the 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
  - get
```
public INDArray get(INDArray indices)
```
    Description copied from interface: INDArray
    
    Get the elements from this ndarray based on the specified indices
    
    Specified by:
    
    get in interface INDArray
    
    Parameters:
    
    indices - an ndaray of the indices to get the elements for
    
    Returns:
    
    the elements to get the array for
  - get
```
public INDArray get(List<List<Integer>> indices)
```
    Description copied from interface: INDArray
    
    Get the elements from this ndarray based on the specified indices
    
    Specified by:
    
    get in interface INDArray
    
    Parameters:
    
    indices - an ndaray of the indices to get the elements for
    
    Returns:
    
    the elements to get the array for
  - put
```
public INDArray put(List<List<Integer>> indices,
                    INDArray element)
```
    Description copied from interface: INDArray
    
    Put element in to the indices denoted by the indices ndarray. This is equivalent to: a[indices] = element in numpy.
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    
    indices - the indices to put
    
    element - the element array to put
    
    Returns:
    
    this array
  - put
```
public INDArray put(INDArray indices,
                    INDArray element)
```
    Description copied from interface: INDArray
    
    Put element in to the indices denoted by the indices ndarray. This is equivalent to: a[indices] = element in numpy.
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    
    indices - the indices to put
    
    element - the element array to put
    
    Returns:
    
    this array
  - put
```
public INDArray put(INDArrayIndex[] indices,
                    INDArray element)
```
    Description copied from interface: INDArray
    
    Put the elements of the ndarray in to the specified indices
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    
    indices - the indices to put the ndarray in to
    
    element - the ndarray to put
    
    Returns:
    
    this ndarray
  - put
```
public INDArray put(INDArrayIndex[] indices,
                    Number element)
```
    Description copied from interface: INDArray
    
    Put the elements of the ndarray in to the specified indices
    
    Specified by:
    
    put in interface INDArray
    
    Parameters:
    
    indices - the indices to put the ndarray in to
    
    element - the ndarray to put
    
    Returns:
    
    this ndarray
  - 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
  - isView
```
public boolean isView()
```
    Description copied from interface: INDArray
    
    Returns true if this array is a view or not
    
    Specified by:
    
    isView in interface INDArray
    
    Returns:
  - isSparse
```
public boolean isSparse()
```
    Description copied from interface: INDArray
    
    Returns true if this array is sparse
    
    Specified by:
    
    isSparse in interface INDArray
    
    Returns:
  - data
```
public DataBuffer 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(DataBuffer 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(ShapeOffsetResolution resolution)
```
    Description copied from interface: INDArray
    
    Sub array based on the pre calculated shape,strides, offsets
    
    Specified by:
    
    subArray in interface INDArray
    
    Parameters:
    
    resolution - the resolution to use
    
    Returns:
    
    the sub array based on the calculations from the resolution
  - subArray
```
public INDArray subArray(long[] offsets,
                         int[] shape,
                         int[] stride)
```
    Specified by:
    
    subArray in interface INDArray
    
    Returns:
  - create
```
protected INDArray create(DataBuffer buffer)
```
  - cond
```
public INDArray cond(Condition condition)
```
    Description copied from interface: INDArray
    
    1 in the ndarray if the element matches the condition 0 otherwise
    
    Specified by:
    
    cond in interface INDArray
    
    Parameters:
    
    condition - Condition to apply
    
    Returns:
    
    Copy of this array with values 0 (condition does not apply), or one (condition applies)
  - condi
```
public INDArray condi(Condition condition)
```
    Description copied from interface: INDArray
    
    In-place: 1 in the ndarray if the element matches the condition 0 otherwise
    
    Specified by:
    
    condi in interface INDArray
    
    Parameters:
    
    condition - Condition to apply
    
    Returns:
    
    This array, modified with values 0 (condition does not apply), or one (condition applies)
  - init
```
protected void init(int[] shape,
                    int[] stride)
```
  - 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
  - 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 h : reverse subtraction t : reverse division
    
    Parameters:
    
    columnVector - the column vector
    
    operation - the operation
    
    Returns:
  - isCleanedUp
```
@Deprecated
public boolean isCleanedUp()
```
    Deprecated.
    
    Description copied from interface: INDArray
    
    Returns true if the ndarray has already been freed
    
    Specified by:
    
    isCleanedUp in interface INDArray
    
    Returns:
  - cleanup
```
@Deprecated
public void cleanup()
```
    Deprecated.
    
    Description copied from interface: INDArray
    
    Cleanup resources
    
    Specified by:
    
    cleanup in interface INDArray
  - 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 h : reverse subtraction t : reverse division
    
    Parameters:
    
    rowVector - the row vector
    
    operation - the operation
    
    Returns:
  - shapeOf
```
protected DataBuffer shapeOf()
```
  - strideOf
```
protected DataBuffer strideOf()
```
  - stride
```
public int stride(int dimension)
```
    Description copied from interface: INDArray
    
    Calculate the stride along a particular dimension
    
    Specified by:
    
    stride in interface INDArray
    
    Parameters:
    
    dimension - the dimension to get the stride for
    
    Returns:
    
    the stride for a particular dimension
  - rdiviColumnVector
```
public INDArray rdiviColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place reverse divison of a column vector
    
    Specified by:
    
    rdiviColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector used for division
    
    Returns:
    
    the result of the division
  - rdivColumnVector
```
public INDArray rdivColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    Reverse division of a column vector (copy)
    
    Specified by:
    
    rdivColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector used for division
    
    Returns:
    
    the result of the division
  - rdiviRowVector
```
public INDArray rdiviRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place reverse division of a column vector
    
    Specified by:
    
    rdiviRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - rdivRowVector
```
public INDArray rdivRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    Reverse division of a column vector (copy)
    
    Specified by:
    
    rdivRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - rsubiColumnVector
```
public INDArray rsubiColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place reverse subtraction of a column vector
    
    Specified by:
    
    rsubiColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubColumnVector
```
public INDArray rsubColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    Reverse subtraction of a column vector (copy)
    
    Specified by:
    
    rsubColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubiRowVector
```
public INDArray rsubiRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place reverse subtraction of a row vector
    
    Specified by:
    
    rsubiRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - rsubRowVector
```
public INDArray rsubRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    Reverse subtraction of a row vector (copy)
    
    Specified by:
    
    rsubRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - 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 row 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 row 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 row 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 row 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 row 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 row 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
  - putiColumnVector
```
public INDArray putiColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place assignment of a column vector
    
    Specified by:
    
    putiColumnVector 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 row vector to add
    
    Returns:
    
    the result of the addition
  - putiRowVector
```
public INDArray putiRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    in place assignment of row vector, to each row of this array
    
    Specified by:
    
    putiRowVector in interface INDArray
    
    Parameters:
    
    rowVector - Row vector to put
    
    Returns:
    
    This array, after assigning every road to the specified value
  - addRowVector
```
public INDArray addRowVector(INDArray rowVector)
```
    In place addition of a column vector
    
    Specified by:
    
    addRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector to add
    
    Returns:
    
    the result of the addition
  - mmul
```
public INDArray mmul(INDArray other,
                     INDArray result,
                     MMulTranspose mMulTranspose)
```
    Perform a copy matrix multiplication
    
    Specified by:
    
    mmul in interface INDArray
    
    Parameters:
    
    other - the other matrix to perform matrix multiply with
    
    result - the result ndarray
    
    mMulTranspose - the transpose status of each array
    
    Returns:
    
    the result of the matrix multiplication
  - mmul
```
public INDArray mmul(INDArray other,
                     MMulTranspose mMulTranspose)
```
    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)
```
    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
  - create
```
protected INDArray create(int[] shape,
                          char ordering)
```
  - toDoubleMatrix
```
public double[][] toDoubleMatrix()
```
    Description copied from interface: INDArray
    
    Convert this ndarray to a 2d double matrix. Note that THIS SHOULD NOT BE USED FOR SPEED. This is mainly used for integrations with other libraries. Due to nd4j's off heap nature, moving data on heap is very expensive and should not be used if possible.
    
    Specified by:
    
    toDoubleMatrix in interface INDArray
    
    Returns:
    
    a copy of this array as a 2d double array
  - toDoubleVector
```
public double[] toDoubleVector()
```
    Description copied from interface: INDArray
    
    Convert this ndarray to a 1d double matrix. Note that THIS SHOULD NOT BE USED FOR SPEED. This is mainly used for integrations with other libraries. Due to nd4j's off heap nature, moving data on heap is very expensive and should not be used if possible.
    
    Specified by:
    
    toDoubleVector in interface INDArray
    
    Returns:
    
    a copy of this array as a 1d double array
  - toFloatVector
```
public float[] toFloatVector()
```
    Description copied from interface: INDArray
    
    Convert this ndarray to a 1d float vector. Note that THIS SHOULD NOT BE USED FOR SPEED. This is mainly used for integrations with other libraries. Due to nd4j's off heap nature, moving data on heap is very expensive and should not be used if possible.
    
    Specified by:
    
    toFloatVector in interface INDArray
    
    Returns:
    
    a copy of this array as a 1d float array
  - toFloatMatrix
```
public float[][] toFloatMatrix()
```
    Description copied from interface: INDArray
    
    Convert this ndarray to a 2d float matrix. Note that THIS SHOULD NOT BE USED FOR SPEED. This is mainly used for integrations with other libraries. Due to nd4j's off heap nature, moving data on heap is very expensive and should not be used if possible.
    
    Specified by:
    
    toFloatMatrix in interface INDArray
    
    Returns:
    
    a copy of this array as a 2d float array
  - toIntVector
```
public int[] toIntVector()
```
    Description copied from interface: INDArray
    
    Convert this ndarray to a 1d int matrix. Note that THIS SHOULD NOT BE USED FOR SPEED. This is mainly used for integrations with other libraries. Due to nd4j's off heap nature, moving data on heap is very expensive and should not be used if possible.
    
    Specified by:
    
    toIntVector in interface INDArray
    
    Returns:
    
    a copy of this array as a 1d int array
  - toIntMatrix
```
public int[][] toIntMatrix()
```
    Description copied from interface: INDArray
    
    Convert this ndarray to a 2d int matrix. Note that THIS SHOULD NOT BE USED FOR SPEED. This is mainly used for integrations with other libraries. Due to nd4j's off heap nature, moving data on heap is very expensive and should not be used if possible.
    
    Specified by:
    
    toIntMatrix in interface INDArray
    
    Returns:
    
    a copy of this array as a 2d int array
  - 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,
                      MMulTranspose transpose)
```
    Perform an copy matrix multiplication
    
    Specified by:
    
    mmuli in interface INDArray
    
    Parameters:
    
    other - the other matrix to perform matrix multiply with
    
    transpose - the transpose status of each ndarray
    
    Returns:
    
    the result of the matrix multiplication
  - 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,
                      MMulTranspose transpose)
```
    Perform an in place 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
  - 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 multiplication
  - 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)
```
    Description copied from interface: INDArray
    
    Element-wise reverse subtraction (copy op). i.e., other - this
    
    Specified by:
    
    rsub in interface INDArray
    
    Parameters:
    
    other -
    
    Returns:
  - rsubi
```
public INDArray rsubi(INDArray other)
```
    Description copied from interface: INDArray
    
    Element-wise reverse subtraction (in the place op) - i.e., other - this
    
    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
  - assignIf
```
public INDArray assignIf(INDArray arr,
                         Condition condition)
```
    Assign all elements from given ndarray that are matching given condition, ndarray to this ndarray
    
    Specified by:
    
    assignIf in interface INDArray
    
    Parameters:
    
    arr - the elements to assign
    
    condition -
    
    Returns:
    
    this
  - replaceWhere
```
public INDArray replaceWhere(INDArray arr,
                             Condition condition)
```
    Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
    
    Specified by:
    
    replaceWhere in interface INDArray
    
    Parameters:
    
    arr -
    
    condition -
    
    Returns:
  - linearIndex
```
@Deprecated
public int linearIndex(int i)
```
    Deprecated.
    
    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
  - createScalarForIndex
```
protected INDArray createScalarForIndex(int i,
                                        boolean applyOffset)
```
  - createScalar
```
protected INDArray createScalar(double d)
```
  - getTrailingOnes
```
public int getTrailingOnes()
```
    Description copied from interface: INDArray
    
    Get the number of trailing ones in the array shape. For example, a rank 3 array with shape [10, 1, 1] would return 2 for this method
    
    Specified by:
    
    getTrailingOnes in interface INDArray
    
    Returns:
    
    Number of trailing ones in shape
  - getLeadingOnes
```
public int getLeadingOnes()
```
    Description copied from interface: INDArray
    
    Get the number of leading ones in the array shape. For example, a rank 3 array with shape [1, 10, 1] would return value 1 for this method
    
    Specified by:
    
    getLeadingOnes in interface INDArray
    
    Returns:
    
    Number of leading ones in shape
  - 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 get a number from
    
    Returns:
    
    the number at the specified indices
  - rdiv
```
public INDArray rdiv(Number n)
```
    Description copied from interface: INDArray
    
    Reverse division with a scalar - i.e., (n / thisArrayValues)
    
    Specified by:
    
    rdiv in interface INDArray
    
    Parameters:
    
    n - Value to use for reverse division
    
    Returns:
    
    Copy of array after applying reverse division
  - rdivi
```
public INDArray rdivi(Number n)
```
    Description copied from interface: INDArray
    
    In place reverse division - i.e., (n / thisArrayValues)
    
    Specified by:
    
    rdivi in interface INDArray
    
    Parameters:
    
    n - Value to use for reverse division
    
    Returns:
    
    This array after applying reverse division
  - rsub
```
public INDArray rsub(Number n)
```
    Description copied from interface: INDArray
    
    Reverse subtraction with duplicates - i.e., (n - thisArrayValues)
    
    Specified by:
    
    rsub in interface INDArray
    
    Parameters:
    
    n - Value to use for reverse subtraction
    
    Returns:
    
    Copy of array after reverse subtraction
  - rsubi
```
public INDArray rsubi(Number n)
```
    Description copied from interface: INDArray
    
    Reverse subtraction in place - i.e., (n - thisArrayValues)
    
    Specified by:
    
    rsubi in interface INDArray
    
    Parameters:
    
    n - Value to use for reverse subtraction
    
    Returns:
    
    This array after reverse subtraction
  - div
```
public INDArray div(Number n)
```
    Description copied from interface: INDArray
    
    Division by a number
    
    Specified by:
    
    div in interface INDArray
    
    Parameters:
    
    n - Number to divide values by
    
    Returns:
    
    Copy of array after division
  - divi
```
public INDArray divi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar division
    
    Specified by:
    
    divi in interface INDArray
    
    Parameters:
    
    n - Number to divide values by
    
    Returns:
    
    This array, after applying division operation
  - mul
```
public INDArray mul(Number n)
```
    Description copied from interface: INDArray
    
    Scalar multiplication (copy)
    
    Specified by:
    
    mul in interface INDArray
    
    Parameters:
    
    n - the number to multiply by
    
    Returns:
    
    a copy of this ndarray multiplied by the given number
  - muli
```
public INDArray muli(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar multiplication
    
    Specified by:
    
    muli in interface INDArray
    
    Parameters:
    
    n - The number to multiply by
    
    Returns:
    
    This array, after applying scaler multiplication
  - sub
```
public INDArray sub(Number n)
```
    Description copied from interface: INDArray
    
    Scalar subtraction (copied)
    
    Specified by:
    
    sub in interface INDArray
    
    Parameters:
    
    n - the number to subtract by
    
    Returns:
    
    Copy of this array after applying subtraction operation
  - subi
```
public INDArray subi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar subtraction
    
    Specified by:
    
    subi in interface INDArray
    
    Parameters:
    
    n - Number to subtract
    
    Returns:
    
    This array, after applying subtraction operation
  - add
```
public INDArray add(Number n)
```
    Description copied from interface: INDArray
    
    Scalar addition (cloning)
    
    Specified by:
    
    add in interface INDArray
    
    Parameters:
    
    n - the number to add
    
    Returns:
    
    a clone with this matrix + the given number
  - addi
```
public INDArray addi(Number n)
```
    Description copied from interface: INDArray
    
    In place scalar addition
    
    Specified by:
    
    addi in interface INDArray
    
    Parameters:
    
    n - Number to add
    
    Returns:
    
    This array, after adding value
  - repmat
```
public INDArray repmat(int[] shape)
```
    Replicate and tile array to fill out to the given shape See: https://github.com/numpy/numpy/blob/master/numpy/matlib.py#L310-L358
    
    Specified by:
    
    repmat in interface INDArray
    
    Parameters:
    
    shape - the new shape of this ndarray
    
    Returns:
    
    the shape to fill out to
  - repeat
```
public INDArray repeat(int dimension,
                       int... repeats)
```
    Description copied from interface: INDArray
    
    Repeat elements along a specified dimension.
    
    Specified by:
    
    repeat in interface INDArray
    
    Parameters:
    
    dimension - the dimension to repeat
    
    repeats - the number of elements to repeat on each element
    
    Returns:
  - 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
  - getDouble
```
public double getDouble(int i)
```
    Description copied from interface: INDArray
    
    Get the double value at the specified linear index in the array
    
    Specified by:
    
    getDouble in interface INDArray
    
    Parameters:
    
    i - Index
    
    Returns:
    
    Double value at the specified index
  - getDouble
```
public double getDouble(int i,
                        int j)
```
    Description copied from interface: INDArray
    
    Get the double value at the specified indices. Can only be used for 2D (rank 2) arrays.
    
    Specified by:
    
    getDouble in interface INDArray
    
    Parameters:
    
    i - Dimension 0 (row) index
    
    j - Dimension 1 (column) index
    
    Returns:
  - getFloat
```
public float getFloat(int i)
```
    Description copied from interface: INDArray
    
    Return the item at the linear index i
    
    Specified by:
    
    getFloat in interface INDArray
    
    Parameters:
    
    i - the index of the item to getScalar
    
    Returns:
    
    the item at index j
  - getFloat
```
public float getFloat(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:
    
    getFloat in interface INDArray
    
    Parameters:
    
    i - the row to getScalar
    
    j - the column to getScalar
    
    Returns:
    
    the item at row i column j
  - 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
  - transposei
```
public INDArray transposei()
```
    Return transposed version of this matrix. PLEASE NOTE: This method is NOT in place, it will return transposed copy instead.
    
    Specified by:
    
    transposei in interface INDArray
    
    Returns:
    
    the flipped rows and columns of a matrix
  - create
```
protected INDArray create(DataBuffer data,
                          int[] shape,
                          int[] strides)
```
  - reshape
```
public INDArray reshape(char order,
                        int... newShape)
```
    Description copied from interface: INDArray
    
    Reshapes the ndarray (can't change the length of the ndarray). Typically this will be a view, unless reshaping without copying is impossible.
    
    Specified by:
    
    reshape in interface INDArray
    
    newShape - the new shape of the ndarray
    
    Returns:
    
    the reshaped ndarray
  - getDoubleUnsafe
```
public double getDoubleUnsafe(long offset)
```
    Description copied from interface: INDArray
    
    Get a scalar at the given linear offset
    
    Specified by:
    
    getDoubleUnsafe in interface INDArray
    
    Parameters:
    
    offset - the offset to get at
    
    Returns:
    
    this
  - putScalarUnsafe
```
public INDArray putScalarUnsafe(long offset,
                                double value)
```
    Description copied from interface: INDArray
    
    Insert a scalar at the given linear offset
    
    Specified by:
    
    putScalarUnsafe in interface INDArray
    
    Parameters:
    
    offset - the offset to insert at
    
    value - the value to insert
    
    Returns:
    
    this
  - innerMostStride
```
public int innerMostStride()
```
    Description copied from interface: INDArray
    
    Get the inner most stride wrt the ordering of the array
    
    Specified by:
    
    innerMostStride in interface INDArray
    
    Returns:
  - reshape
```
public INDArray reshape(char order,
                        int rows,
                        int columns)
```
    Description copied from interface: INDArray
    
    Reshapes the ndarray (can't change the length of the ndarray). Typically this will be a view, unless reshaping without copying is impossible.
    
    Specified by:
    
    reshape in interface INDArray
    
    rows - the rows of the matrix
    
    columns - the columns of the matrix
    
    Returns:
    
    the reshaped ndarray
  - reshape
```
public INDArray reshape(int... shape)
```
    Reshape the ndarray in to the specified dimensions, possible errors being thrown for invalid shapes Note here that one dimension can be -1. The dimension that is -1 will be inferred from the shape and the length of the ndarray
    
    Specified by:
    
    reshape in interface INDArray
    
    Parameters:
    
    shape - the shape of the ndarray.
    
    Returns:
    
    the new reshaped nd array
  - 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
  - amean
```
public INDArray amean(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the absolute overall mean of this ndarray
    
    Specified by:
    
    amean in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the mean along
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - mean
```
public INDArray mean(@NonNull
                     INDArray result,
                     int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the overall mean of this ndarray
    
    Specified by:
    
    mean in interface INDArray
    
    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
  - var
```
public INDArray var(boolean biasCorrected,
                    int... dimension)
```
    Returns the overall variance of this ndarray
    
    Specified by:
    
    var in interface INDArray
    
    Parameters:
    
    biasCorrected - boolean on whether to apply corrected bias
    
    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
  - amax
```
public INDArray amax(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the absolute overall max of this ndarray along given dimensions
    
    Specified by:
    
    amax 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
  - amin
```
public INDArray amin(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns minimum (absolute) value in this INDArray, along the specified dimensions
    
    Specified by:
    
    amin in interface INDArray
    
    Returns:
    
    Minimum absolute value
  - 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
  - entropy
```
public INDArray entropy(int... dimension)
```
    Returns entropy along dimension
    
    Specified by:
    
    entropy in interface INDArray
    
    Parameters:
    
    dimension -
    
    Returns:
  - shannonEntropy
```
public INDArray shannonEntropy(int... dimension)
```
    Returns non-normalized Shannon entropy along dimension
    
    Specified by:
    
    shannonEntropy in interface INDArray
    
    Parameters:
    
    dimension -
    
    Returns:
  - logEntropy
```
public INDArray logEntropy(int... dimension)
```
    Returns log entropy along dimension
    
    Specified by:
    
    logEntropy in interface INDArray
    
    Parameters:
    
    dimension -
    
    Returns:
  - sum
```
public INDArray sum(@NonNull
                    INDArray result,
                    int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the sum along the last dimension of this ndarray
    
    Specified by:
    
    sum in interface INDArray
    
    Parameters:
    
    result - result of this operation will be stored here
    
    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
  - std
```
public INDArray std(boolean biasCorrected,
                    int... dimension)
```
    Description copied from interface: INDArray
    
    Standard deviation of an ndarray along a dimension
    
    Specified by:
    
    std in interface INDArray
    
    dimension - the dimension to getScalar the std along
    
    Returns:
    
    the standard deviation along a particular dimension
  - stdNumber
```
public Number stdNumber(boolean biasCorrected)
```
    Description copied from interface: INDArray
    
    Calculate the standard deviation for the entire array, specifying whether it is bias corrected or not
    
    Specified by:
    
    stdNumber in interface INDArray
    
    Parameters:
    
    biasCorrected - If true: bias corrected standard deviation. False: not bias corrected
    
    Returns:
    
    Standard dev
  - 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(char ordering)
```
    Flattens the array for linear indexing
    
    Specified by:
    
    ravel in interface INDArray
    
    Returns:
    
    the flattened version of this array
  - 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:
    
    Array with only the specified rows
  - get
```
public INDArray get(INDArrayIndex... 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:
    
    Array with only the specified columns
  - create
```
protected INDArray create(int rows,
                          int length)
```
  - getRow
```
public INDArray getRow(int r)
```
    Get a copy of a row.
    
    Specified by:
    
    getRow in interface INDArray
    
    Parameters:
    
    r - the row to get
    
    Returns:
    
    the specified row
  - equalsWithEps
```
public boolean equalsWithEps(Object o,
                             double eps)
```
    This method allows you to compare INDArray against other INDArray, with variable eps
    
    Specified by:
    
    equalsWithEps in interface INDArray
    
    Parameters:
    
    o -
    
    eps -
    
    Returns:
  - 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-5.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    o -
  - shapeInfoDataBuffer
```
public DataBuffer shapeInfoDataBuffer()
```
    Description copied from interface: INDArray
    
    Shape info
    
    Specified by:
    
    shapeInfoDataBuffer in interface INDArray
    
    Returns:
  - shapeInfo
```
public IntBuffer shapeInfo()
```
    Description copied from interface: INDArray
    
    Shape info
    
    Specified by:
    
    shapeInfo in interface INDArray
    
    Returns:
  - shape
```
public int[] shape()
```
    Returns the shape(dimensions) of this array
    
    Specified by:
    
    shape in interface INDArray
    
    Returns:
    
    the shape of this matrix
  - shapeInfoToString
```
public String shapeInfoToString()
```
    Returns the shape information debugging information
    
    Specified by:
    
    shapeInfoToString in interface INDArray
    
    Returns:
    
    the shape information debugging information
  - 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 long 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()
```
    Description copied from interface: INDArray
    
    Return the ordering (fortran or c 'f' and 'c' respectively) of this ndarray
    
    Specified by:
    
    ordering in interface INDArray
    
    Returns:
    
    the ordering of this ndarray
  - 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
  - rank
```
public int rank()
```
    Description copied from interface: INDArray
    
    Returns the rank of the ndarray (the number of dimensions).
    
    Specified by:
    
    rank in interface INDArray
    
    Returns:
    
    the rank for the ndarray.
  - 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
  - lengthLong
```
public long lengthLong()
```
    Returns the total number of elements in the ndarray
    
    Specified by:
    
    lengthLong in interface INDArray
    
    Returns:
    
    the number of elements in the ndarray
  - broadcast
```
public INDArray broadcast(INDArray result)
```
    Description copied from interface: INDArray
    
    Broadcasts this ndarray to be the specified shape
    
    Specified by:
    
    broadcast in interface INDArray
    
    Returns:
    
    the broadcasted 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.html
    
    Specified by:
    
    permute in interface INDArray
    
    Parameters:
    
    rearrange - the dimensions to swap to
    
    Returns:
    
    the newly permuted array
  - permutei
```
public INDArray permutei(int... rearrange)
```
    An in-place version of permute. The array shape information (shape, strides) is modified by this operation (but not the data itself) See: http://www.mathworks.com/help/matlab/ref/permute.html
    
    Specified by:
    
    permutei in interface INDArray
    
    Parameters:
    
    rearrange - the dimensions to swap to
    
    Returns:
    
    the current array
  - doPermuteSwap
```
protected int[] doPermuteSwap(IntBuffer shape,
                              int[] rearrange)
```
  - doPermuteSwap
```
protected int[] doPermuteSwap(DataBuffer shape,
                              int[] rearrange)
```
  - checkArrangeArray
```
protected void checkArrangeArray(int[] arr)
```
  - autoProcessScalarCall
```
protected void autoProcessScalarCall()
```
  - isVector
```
public boolean isVector()
```
    Checks whether the matrix is a vector.
    
    Specified by:
    
    isVector in interface INDArray
    
    Returns:
    
    whether this ndarray is a vector
  - isVectorOrScalar
```
public boolean isVectorOrScalar()
```
    Description copied from interface: INDArray
    
    Returns true if this ndarray is a vector or scalar
    
    Specified by:
    
    isVectorOrScalar in interface INDArray
    
    Returns:
    
    whether this ndarray is a vector or scalar
  - isSquare
```
public boolean isSquare()
```
    Description copied from interface: INDArray
    
    Returns whether the matrix has the same rows and columns
    
    Specified by:
    
    isSquare in interface INDArray
    
    Returns:
    
    true if the matrix has the same rows and columns false otherwise
  - 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
  - isColumnVectorOrScalar
```
public boolean isColumnVectorOrScalar()
```
    Description copied from interface: INDArray
    
    Returns true if the number of columns is 1
    
    Specified by:
    
    isColumnVectorOrScalar in interface INDArray
    
    Returns:
    
    true if the number of columns is 1
  - isRowVectorOrScalar
```
public boolean isRowVectorOrScalar()
```
    Description copied from interface: INDArray
    
    Returns true if the number of rows is 1
    
    Specified by:
    
    isRowVectorOrScalar in interface INDArray
    
    Returns:
    
    true if the number of rows is 1
  - toString
```
public String toString()
```
    Generate string representation of the matrix. Printing will switch to scientific notation on a per element basis - when abs value is greater than or equal to 10000 - when abs value is less than or equal to 0.0001 and not zero If the number of elements in the array is greater than 1000 only the first and last three elements in a dimension are included
    
    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
    
    Returns:
  - rdivi
```
public IComplexNDArray rdivi(IComplexNumber n)
```
    Specified by:
    
    rdivi in interface INDArray
    
    Returns:
  - rsub
```
public IComplexNDArray rsub(IComplexNumber n)
```
    Specified by:
    
    rsub in interface INDArray
    
    Returns:
  - rsubi
```
public IComplexNDArray rsubi(IComplexNumber n)
```
    Specified by:
    
    rsubi in interface INDArray
    
    Returns:
  - div
```
public IComplexNDArray div(IComplexNumber n)
```
    Specified by:
    
    div in interface INDArray
    
    Returns:
  - divi
```
public IComplexNDArray divi(IComplexNumber n)
```
    Specified by:
    
    divi in interface INDArray
    
    Returns:
  - mul
```
public IComplexNDArray mul(IComplexNumber n)
```
    Specified by:
    
    mul in interface INDArray
    
    Returns:
  - muli
```
public IComplexNDArray muli(IComplexNumber n)
```
    Specified by:
    
    muli in interface INDArray
    
    Returns:
  - sub
```
public IComplexNDArray sub(IComplexNumber n)
```
    Specified by:
    
    sub in interface INDArray
    
    Returns:
  - subi
```
public IComplexNDArray subi(IComplexNumber n)
```
    Specified by:
    
    subi in interface INDArray
    
    Returns:
  - add
```
public IComplexNDArray add(IComplexNumber n)
```
    Specified by:
    
    add in interface INDArray
    
    Returns:
  - addi
```
public IComplexNDArray addi(IComplexNumber n)
```
    Specified by:
    
    addi in interface INDArray
    
    Returns:
  - rdiv
```
public IComplexNDArray rdiv(IComplexNumber n,
                            IComplexNDArray result)
```
    Specified by:
    
    rdiv in interface INDArray
    
    Returns:
  - rdivi
```
public IComplexNDArray rdivi(IComplexNumber n,
                             IComplexNDArray result)
```
    Specified by:
    
    rdivi in interface INDArray
    
    Returns:
  - rsub
```
public IComplexNDArray rsub(IComplexNumber n,
                            IComplexNDArray result)
```
    Specified by:
    
    rsub in interface INDArray
    
    Returns:
  - rsubi
```
public IComplexNDArray rsubi(IComplexNumber n,
                             IComplexNDArray result)
```
    Specified by:
    
    rsubi in interface INDArray
    
    Returns:
  - div
```
public IComplexNDArray div(IComplexNumber n,
                           IComplexNDArray result)
```
    Specified by:
    
    div in interface INDArray
    
    Returns:
  - divi
```
public IComplexNDArray divi(IComplexNumber n,
                            IComplexNDArray result)
```
    Specified by:
    
    divi in interface INDArray
    
    Returns:
  - mul
```
public IComplexNDArray mul(IComplexNumber n,
                           IComplexNDArray result)
```
    Specified by:
    
    mul in interface INDArray
    
    Returns:
  - muli
```
public IComplexNDArray muli(IComplexNumber n,
                            IComplexNDArray result)
```
    Specified by:
    
    muli in interface INDArray
    
    Returns:
  - sub
```
public IComplexNDArray sub(IComplexNumber n,
                           IComplexNDArray result)
```
    Specified by:
    
    sub in interface INDArray
    
    Returns:
  - subi
```
public IComplexNDArray subi(IComplexNumber n,
                            IComplexNDArray result)
```
    Specified by:
    
    subi in interface INDArray
    
    Returns:
  - add
```
public IComplexNDArray add(IComplexNumber n,
                           IComplexNDArray result)
```
    Specified by:
    
    add in interface INDArray
    
    Returns:
  - addi
```
public IComplexNDArray addi(IComplexNumber n,
                            IComplexNDArray result)
```
    Specified by:
    
    addi in interface INDArray
    
    Returns:
  - remainder
```
public INDArray remainder(INDArray denominator)
```
    Description copied from interface: INDArray
    
    Remainder operator
    
    Specified by:
    
    remainder in interface INDArray
    
    Parameters:
    
    denominator - the denominator
    
    Returns:
  - remainder
```
public INDArray remainder(INDArray denominator,
                          INDArray result)
```
    Description copied from interface: INDArray
    
    Remainder operator
    
    Specified by:
    
    remainder in interface INDArray
    
    Parameters:
    
    denominator - the denominator
    
    result - the result array to put this in
    
    Returns:
  - remainder
```
public INDArray remainder(Number denominator)
```
    Description copied from interface: INDArray
    
    The scalar denominator
    
    Specified by:
    
    remainder in interface INDArray
    
    Parameters:
    
    denominator - the denominator as a scalar
    
    Returns:
  - remainder
```
public INDArray remainder(Number denominator,
                          INDArray result)
```
    Specified by:
    
    remainder in interface INDArray
    
    Returns:
  - remainderi
```
public INDArray remainderi(INDArray denominator)
```
    Description copied from interface: INDArray
    
    In place remainder
    
    Specified by:
    
    remainderi in interface INDArray
    
    Returns:
  - remainderi
```
public INDArray remainderi(Number denominator)
```
    Description copied from interface: INDArray
    
    In place remainder
    
    Specified by:
    
    remainderi in interface INDArray
    
    Returns:
  - fmod
```
public INDArray fmod(INDArray denominator)
```
    Description copied from interface: INDArray
    
    remainder of division
    
    Specified by:
    
    fmod in interface INDArray
    
    Parameters:
    
    denominator - the array of denominators for each element in this array
    
    Returns:
  - fmod
```
public INDArray fmod(INDArray denominator,
                     INDArray result)
```
    Description copied from interface: INDArray
    
    remainder of division
    
    Specified by:
    
    fmod in interface INDArray
    
    Parameters:
    
    denominator - the
    
    result - the result array
    
    Returns:
  - fmod
```
public INDArray fmod(Number denominator)
```
    Specified by:
    
    fmod in interface INDArray
    
    Returns:
  - fmod
```
public INDArray fmod(Number denominator,
                     INDArray result)
```
    Specified by:
    
    fmod in interface INDArray
  - fmodi
```
public INDArray fmodi(INDArray denominator)
```
    Description copied from interface: INDArray
    
    In place fmod
    
    Specified by:
    
    fmodi in interface INDArray
    
    Returns:
  - fmodi
```
public INDArray fmodi(Number denominator)
```
    Description copied from interface: INDArray
    
    In place fmod
    
    Specified by:
    
    fmodi in interface INDArray
    
    Returns:
  - iterator
```
public Iterator<Object> iterator()
```
    Specified by:
    
    iterator in interface Iterable
  - originalOffset
```
public long originalOffset()
```
    Returns the start of where the ndarray is for the original data buffer
    
    Specified by:
    
    originalOffset in interface INDArray
    
    Returns:
  - write
```
protected void write(ObjectOutputStream out)
              throws IOException
```
    Throws:
    
    IOException
  - read
```
protected void read(ObjectInputStream s)
```
  - argMax
```
public INDArray argMax(int... dimension)
```
    This method returns index of highest value along specified dimension(s)
    
    Specified by:
    
    argMax in interface INDArray
    
    Parameters:
    
    dimension -
    
    Returns:
  - isAttached
```
public boolean isAttached()
```
    This method returns True, if this INDArray instance is attached to some Workspace. False otherwise.
    
    Specified by:
    
    isAttached in interface INDArray
    
    Returns:
  - isInScope
```
public boolean isInScope()
```
    This method checks, if given attached INDArray is still in scope of its parent Workspace
    PLEASE NOTE: if this INDArray isn't attached to any Workspace, this method will return true
    
    Specified by:
    
    isInScope in interface INDArray
    
    Returns:
  - detach
```
public INDArray detach()
```
    This metod detaches INDArray from Workspace, returning copy. Basically it's dup() into new memory chunk.
    PLEASE NOTE: If this INDArray instance is NOT attached - it will be returned unmodified.
    
    Specified by:
    
    detach in interface INDArray
    
    Returns:
  - leverage
```
public INDArray leverage()
```
    This method detaches INDArray from current Workspace, and attaches it to Workspace above, if any.
    PLEASE NOTE: If this INDArray instance is NOT attached - it will be returned unmodified. PLEASE NOTE: If current Workspace is the top-tier one, effect will be equal to detach() call - detached copy will be returned
    
    Specified by:
    
    leverage in interface INDArray
    
    Returns:
  - leverageTo
```
public INDArray leverageTo(String id)
```
    This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id PLEASE NOTE: If this INDArray instance is NOT attached - it will be returned unmodified. PLEASE NOTE: If Workspace with target Id wasn't created before - this array will be returned unmodified. PLEASE NOTE: If target workspace is the current one - this array will be returned unmodified.
    
    Specified by:
    
    leverageTo in interface INDArray
    
    Parameters:
    
    id -
    
    Returns:
    
    See Also:
    
    INDArray.leverageTo(String, boolean)
  - leverageTo
```
public INDArray leverageTo(String id,
                           boolean enforceExistence)
                    throws Nd4jNoSuchWorkspaceException
```
    This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id. If enforceExistence == true, and no workspace with the specified ID exists, then an Nd4jNoSuchWorkspaceException is thrown. Otherwise, if enforceExistance == false and no workspace with the specified ID exists, then the current INDArray is returned unmodified (same as leverage()
    
    Specified by:
    
    leverageTo in interface INDArray
    
    Parameters:
    
    id - ID of the workspace to leverage to
    
    enforceExistence - If true, and the specified workspace does not exist: an Nd4jNoSuchWorkspaceException will be thrown.
    
    Returns:
    
    The INDArray, leveraged to the specified workspace
    
    Throws:
    
    Nd4jNoSuchWorkspaceException
    
    See Also:
    
    leverageTo(String)
  - leverageOrDetach
```
public INDArray leverageOrDetach(String id)
```
    This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id, if a workspace with the given ID is open and active. If the workspace does not exist, or is not active, the array is detached from any workspaces.
    
    Specified by:
    
    leverageOrDetach in interface INDArray
    
    Parameters:
    
    id - ID of the workspace to leverage to
    
    Returns:
    
    The INDArray, leveraged to the specified workspace (if it exists and is active) otherwise the detached array
    
    See Also:
    
    leverageTo(String)
  - migrate
```
public INDArray migrate()
```
    This method pulls this INDArray into current Workspace. PLEASE NOTE: If there's no current Workspace - INDArray returned as is
    
    Specified by:
    
    migrate in interface INDArray
    
    Returns:
    
    Migrated INDArray or this if no current workspace
    
    See Also:
    
    migrate(boolean)
  - migrate
```
public INDArray migrate(boolean detachOnNoWs)
```
    This method pulls this INDArray into current Workspace, or optionally detaches if no workspace is present.
    That is:
    If current workspace is present/active, INDArray is migrated to it.
    If no current workspace is present/active, one of two things occur: 1. If detachOnNoWs arg is true: if there is no current workspace, INDArray is detached 2. If detachOnNoWs arg is false: this INDArray is returned as-is (no-op) - equivalent to migrate()
    
    Specified by:
    
    migrate in interface INDArray
    
    Parameters:
    
    detachOnNoWs - If true: detach on no WS. If false and no workspace: return this.
    
    Returns:
    
    Migrated INDArray
  - percentileNumber
```
public Number percentileNumber(Number quantile)
```
    Description copied from interface: INDArray
    
    This method returns percentile value for this INDArray
    
    Specified by:
    
    percentileNumber in interface INDArray
    
    Parameters:
    
    quantile - target percentile in range of 0..100
    
    Returns:
  - medianNumber
```
public Number medianNumber()
```
    Description copied from interface: INDArray
    
    This method returns median value for this INDArray
    
    Specified by:
    
    medianNumber in interface INDArray
    
    Returns:
    
    Median value for array
  - median
```
public INDArray median(int... dimension)
```
    Description copied from interface: INDArray
    
    This method returns median along given dimension(s)
    
    Specified by:
    
    median in interface INDArray
    
    Returns:
    
    Median along specified dimensions
  - getPercentile
```
protected double getPercentile(Number quantile,
                               INDArray sorted)
```
  - percentile
```
public INDArray percentile(Number quantile,
                           int... dimension)
```
    Description copied from interface: INDArray
    
    This method returns median along given dimension(s)
    
    Specified by:
    
    percentile in interface INDArray
    
    Parameters:
    
    quantile - target percentile in range of 0..100
    
    dimension - Dimension to calculate percentile for
    
    Returns:
  - toFlatArray
```
public int toFlatArray(com.google.flatbuffers.FlatBufferBuilder builder)
```
    Description copied from interface: INDArray
    
    Add an INDArray to flatbuffers builder
    
    Specified by:
    
    toFlatArray in interface INDArray
    
    Parameters:
    
    builder - the builder to use
    
    Returns:
    
    the offset to add
  - getVectorCoordinates
```
public DataBuffer getVectorCoordinates()
```
    Description copied from interface: INDArray
    
    Return a array of non-major pointers i.e. return the column indexes in case of row-major ndarray
    
    Specified by:
    
    getVectorCoordinates in interface INDArray
    
    Returns:
    
    a DataBuffer of indexes
  - toDense
```
public INDArray toDense()
```
    Description copied from interface: INDArray
    
    Return a dense representation of the sparse ndarray
    
    Specified by:
    
    toDense in interface INDArray
  - nnz
```
public int nnz()
```
    Description copied from interface: INDArray
    
    Return the number of non-null element
    
    Specified by:
    
    nnz in interface INDArray
    
    Returns:
    
    nnz
  - getFormat
```
public SparseFormat getFormat()
```
    Description copied from interface: INDArray
    
    Return the sparse format (i.e COO, CSR, ...)
    
    Specified by:
    
    getFormat in interface INDArray
    
    Returns:
    
    format
    
    See Also:
    
    SparseFormat
  - sparseInfoDataBuffer
```
public DataBuffer sparseInfoDataBuffer()
```
    Description copied from interface: INDArray
    
    Sparse info
    
    Specified by:
    
    sparseInfoDataBuffer in interface INDArray
    
    Returns:
  - flags
```
public int[] flags()
```
    Specified by:
    
    flags in interface INDArray
  - hiddenDimensions
```
public int[] hiddenDimensions()
```
    Specified by:
    
    hiddenDimensions in interface INDArray
  - sparseOffsets
```
public int[] sparseOffsets()
```
    Specified by:
    
    sparseOffsets in interface INDArray
  - underlyingRank
```
public int underlyingRank()
```
    Specified by:
    
    underlyingRank in interface INDArray
  - convertToFloats
```
public INDArray convertToFloats()
```
    Specified by:
    
    convertToFloats in interface INDArray
  - convertToDoubles
```
public INDArray convertToDoubles()
```
    Specified by:
    
    convertToDoubles in interface INDArray
  - convertType
```
protected static DataBuffer.TypeEx convertType(DataBuffer.Type type)
```

Class BaseNDArray

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.Iterable

Field Detail

shapeInformation

data

compressed

javaShapeInformation

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

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

Method Detail

isCompressed

markAsCompressed

internalCreateBuffer

internalCreateBuffer

internalCreateBuffer

internalCreateBuffer

internalCreateBuffer

internalCreateBuffer

setWrapAround

isWrapAround

isValid

linearViewColumnOrder

create

linearView

resetLinearView

elementWiseStride

elementStride

majorStride

secondaryStride

tensorssAlongDimension

tensorAlongDimension

javaTensorAlongDimension