BaseNDArray (nd4j-api 1.0.0-beta5 API)

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

All Implemented Interfaces:

Serializable, AutoCloseable, Iterable, INDArray
```
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 JvmShapeInfo`	`jvmShapeInfo`
`protected boolean`	`released`
`protected DataBuffer`	`shapeInformation`

Constructor Summary

Constructors
Constructor and Description
`BaseNDArray()`
`BaseNDArray(DataBuffer buffer)`
`BaseNDArray(DataBuffer floatBuffer, char order)`
`BaseNDArray(DataBuffer buffer, DataType dataType, long[] shape, long[] stride, long offset, char ordering)`
`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(DataBuffer data, long[] shape)`
`BaseNDArray(DataBuffer buffer, long[] shape, char ordering)`
`BaseNDArray(DataBuffer buffer, long[] shape, long[] stride, char ordering, DataType type)`
`BaseNDArray(DataBuffer buffer, long[] shape, long[] stride, char ordering, DataType type, MemoryWorkspace workspace)`
`BaseNDArray(DataBuffer buffer, long[] shape, long[] stride, long offset, char ordering)`
`BaseNDArray(DataBuffer buffer, long[] shape, long[] stride, long offset, char ordering, DataType dataType)`
`BaseNDArray(DataBuffer buffer, long[] shape, long[] stride, long offset, long ews, char ordering)`
`BaseNDArray(DataBuffer buffer, long[] shape, long[] stride, long offset, long ews, char ordering, DataType dataType)`
`BaseNDArray(DataType type, long[] shape, long[] stride, long offset, char ordering, boolean initialize)`
`BaseNDArray(DataType type, long[] shape, long[] stride, long offset, char ordering, boolean initialize, MemoryWorkspace workspace)`
`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(double[] data, long[] shape, char ordering)`
`BaseNDArray(double[] data, long[] shape, long[] stride, long offset)`
`BaseNDArray(double[] data, long[] shape, long[] stride, long offset, char ordering)`
`BaseNDArray(double[] data, long[] shape, 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(float[] data, long[] shape, char ordering)`
`BaseNDArray(float[] data, long[] shape, long[] stride, long offset)`
`BaseNDArray(float[] data, long[] shape, long[] stride, long offset, char ordering)`
`BaseNDArray(float[] data, long[] 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.
`BaseNDArray(List<INDArray> slices, long[] shape)`
`BaseNDArray(List<INDArray> slices, long[] shape, char ordering)`
`BaseNDArray(List<INDArray> slices, long[] shape, long[] stride)`
`BaseNDArray(List<INDArray> slices, long[] shape, long[] stride, char ordering)`
`BaseNDArray(long[] shape)`
`BaseNDArray(long[] shape, long[] stride, long offset)`
`BaseNDArray(long[] shape, long[] stride, long offset, char ordering)`
`BaseNDArray(long[] shape, long[] stride, long offset, char ordering, boolean initialize)`
`BaseNDArray(long[] shape, long offset, char ordering)`
`BaseNDArray(long newRows, long newColumns)`
`BaseNDArray(long newRows, long newColumns, char ordering)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`INDArray`	`add(INDArray other)` Element-wise copy addition of two NDArrays
`INDArray`	`add(INDArray other, INDArray result)` Element-wise copy addition of two NDArrays
`INDArray`	`add(Number n)` Scalar addition (cloning)
`INDArray`	`add(Number n, INDArray result)` Addition of this ndarray.
`INDArray`	`addColumnVector(INDArray columnVector)` Addition of a column vector (copy)
`INDArray`	`addi(INDArray other)` in place (element wise) addition of two NDArrays
`INDArray`	`addi(INDArray other, INDArray result)` in place (element wise) addition of two NDArrays
`INDArray`	`addi(Number n)` In place scalar addition
`INDArray`	`addi(Number n, INDArray result)` In place addition
`INDArray`	`addiColumnVector(INDArray columnVector)` In place addition of a column vector
`INDArray`	`addiRowVector(INDArray rowVector)` In place addition of a row vector
`INDArray`	`addRowVector(INDArray rowVector)` Addition of a row vector (copy)
`boolean`	`all()` This method checks if all elements within this array are non-zero (or true, in case of boolean)
`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
`boolean`	`any()` This method checks if any of the elements within this array are non-zero (or true, in case of boolean)
`INDArray`	`argMax(int... dimension)` This method returns index of highest value along specified dimension(s)
`protected void`	`assertSlice(INDArray put, long slice)`
`INDArray`	`assign(boolean value)` Set all entries of the ndarray to the specified value
`INDArray`	`assign(INDArray arr)` Assign all of the elements in the given ndarray to this ndarray
`INDArray`	`assign(Number value)` Set all entries 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(long... shape)` Broadcasts this ndarray to be the specified shape
`INDArray`	`castTo(DataType dataType)` This method cast elements of this INDArray to new data type
`protected void`	`checkArrangeArray(int[] arr)`
`void`	`close()` This method releases exclusive off-heap resources uses by this INDArray instance.
`boolean`	`closeable()` This method checks, if this INDArray instalce can use close() method
`int`	`columns()` Number of columns (shape[1]), throws an exception when called when not 2d
`INDArray`	`cond(Condition condition)` Returns a binary INDArray with value 'true' if the element matches the specified condition and 'false' otherwise
`protected static DataTypeEx`	`convertType(DataType 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(DataBuffer data, long[] newShape, long[] newStrides, long offset, char ordering)`
`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(long i, boolean applyOffset)`
`INDArray`	`cumsum(int dimension)` Returns the cumulative sum along a dimension.
`INDArray`	`cumsumi(int dimension)` Returns the cumulative sum along a dimension.
`DataBuffer`	`data()` Returns a linear double array representation of this ndarray
`DataType`	`dataType()` This method returns dtype for this INDArray
`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.
`INDArray`	`dimShuffle(Object[] rearrange, long[] 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.
`INDArray`	`div(INDArray other)` Copy (element wise) division of two NDArrays
`INDArray`	`div(INDArray other, INDArray result)` copy (element wise) division of two NDArrays
`INDArray`	`div(Number n)` Division by a number
`INDArray`	`div(Number n, INDArray result)` Division if ndarray by number
`INDArray`	`divColumnVector(INDArray columnVector)` Division of a column vector (copy)
`INDArray`	`divi(INDArray other)` in place (element wise) division of two NDArrays
`INDArray`	`divi(INDArray other, INDArray result)` in place (element wise) division of two NDArrays
`INDArray`	`divi(Number n)` In place scalar division
`INDArray`	`divi(Number n, INDArray result)` In place division of this ndarray
`INDArray`	`diviColumnVector(INDArray columnVector)` In place division of a column vector
`INDArray`	`diviRowVector(INDArray rowVector)` In place division of a row vector
`INDArray`	`divRowVector(INDArray rowVector)` Division of a row vector (copy)
`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 long[]`	`doPermuteSwap(LongBuffer 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`	`elementWiseStride()` Element wise stride
`INDArray`	`entropy(int... dimension)` Returns entropy value for this INDArray along specified dimension(s)
`Number`	`entropyNumber()` Returns entropy value for this INDArray
`INDArray`	`eps(INDArray other)` Returns the binary ndarray for "Epsilon equals" comparison.
`INDArray`	`eps(Number other)` Returns the binary ndarray for "Epsilon equals" comparison.
`INDArray`	`eq(INDArray other)` Returns the binary ndarray for "Equals" comparison.
`INDArray`	`eq(Number other)` Returns the binary ndarray for "Equals" comparison.
`boolean`	`equals(Object o)` Compare two matrices.
`boolean`	`equalShapes(INDArray other)` This method checks 2 INDArrays for equal shapes. Shapes are considered equal if: (a) Both arrays have equal rank, and (b) size(0)...size(rank()-1) are equal for both arrays
`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`	`getColumn(long c)` Get the specified column
`INDArray`	`getColumn(long c, boolean keepDim)` Returns the specified column.
`INDArray`	`getColumns(int... cindices)` Get an INDArray comprised of the specified columns only.
`double`	`getDouble(int... indices)` Returns the elements at the specified indices
`double`	`getDouble(long... indices)`
`double`	`getDouble(long i)` Get the double value at the specified linear index in the array
`double`	`getDouble(long i, long j)` Get the double value at the specified indices.
`double`	`getDoubleUnsafe(long offset)` Get a double at the given linear offset unsafe, without checks.
`float`	`getFloat(int... indices)` Returns the elements at the specified indices
`float`	`getFloat(long... indices)`
`float`	`getFloat(long i)` Return the item at the linear index i
`float`	`getFloat(long i, long 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 specified indices
`int`	`getLeadingOnes()` Get the number of leading ones in the array shape.
`long`	`getLong(long... indices)`
`long`	`getLong(long index)`
`Number`	`getNumber(long... idx)`
`Number`	`getNumber(long i)`
`protected double`	`getPercentile(Number quantile, INDArray sorted)`
`INDArray`	`getRow(long r)` Get a copy of a row.
`INDArray`	`getRow(long r, boolean keepDim)` Returns the specified row.
`INDArray`	`getRows(int[] rindices)` Get an INDArray comprised of the specified rows only.
`INDArray`	`getScalar(int[] indexes)` Fetch a particular number on a multi dimensional scale.
`INDArray`	`getScalar(long... indexes)`
`INDArray`	`getScalar(long i)` Returns the element at the specified index
`INDArray`	`getScalar(long row, long column)` Returns the element at the specified row/column
`protected int[]`	`getStrides(int[] shape, char ordering)`
`String`	`getString(long index)` Get string value at given index.
`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 "Greater Than" comparison.
`INDArray`	`gt(Number other)` Returns the binary ndarray for "Greater" comparison.
`INDArray`	`gte(Number other)` Returns binary ndarray for "Greter or equals" comparison.
`int`	`hashCode()`
`int[]`	`hiddenDimensions()`
`protected void`	`init(int[] shape, int[] stride)`
`protected void`	`init(long[] shape, long[] stride)`
`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)`
`boolean`	`isAttached()` This method returns True, if this INDArray instance is attached to some Workspace.
`boolean`	`isB()` This method checks if this INDArray instance has boolean type
`boolean`	`isColumnVector()` Checks whether the matrix is a column vector.
`boolean`	`isColumnVectorOrScalar()` Returns true if the number of columns is 1
`boolean`	`isCompressed()` Check if this array is compressed.
`boolean`	`isEmpty()` This method returns true if this INDArray is special case: no-value INDArray
`INDArray`	`isInfinite()` Returns the binary NDArray with value true where this array's entries are infinite, or false where they are not infinite
`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
`INDArray`	`isNaN()` Returns the binary NDArray with value true where this array's entries are NaN, or false where they are not infinite
`boolean`	`isR()` This method checks if this INDArray instance is one of Real types
`boolean`	`isRowVector()` Checks whether the matrix is a row vector.
`boolean`	`isRowVectorOrScalar()` Returns true if the number of rows is 1
`boolean`	`isS()` This method checks if this INDArray instance has String type
`boolean`	`isScalar()` Test whether a matrix is scalar.
`boolean`	`isSparse()` Check 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()` Check if this array is a view or not.
`boolean`	`isZ()` This method checks if this INDArray instance is one of integer types
`Iterator<Object>`	`iterator()`
`long`	`length()` 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.
`INDArray`	`like()` This method returns empty array with the same dtype/order/shape as this one
`long`	`linearIndex(long i)` Deprecated.
`INDArray`	`logEntropy(int... dimension)` Returns log entropy value for this INDArray along specified dimension(s)
`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.
`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(boolean keepDims, int... dimension)` Returns the overall max of this ndarray along given dimensions
`INDArray`	`max(int... dimension)` Returns the overall max of this ndarray along given dimensions
`Number`	`maxNumber()` Returns maximum value in this INDArray
`INDArray`	`mean(boolean keepDims, int... dimension)` Returns the overall mean of this ndarray
`INDArray`	`mean(INDArray result, boolean keepDims, int... dimension)` Returns the overall mean of this ndarray
`INDArray`	`mean(INDArray result, int... dimension)` Returns the overall mean of this ndarray
`INDArray`	`mean(int... dimension)` Returns the overall mean of this ndarray
`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(boolean keepDims, int... dimension)` Returns the overall min of this ndarray
`INDArray`	`min(int... dimension)` Returns the overall min of this ndarray
`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 an copy matrix multiplication
`INDArray`	`mmul(INDArray other, MMulTranspose mMulTranspose)` Perform a copy matrix multiplication
`INDArray`	`mmuli(INDArray other)` Perform an inplace matrix multiplication
`INDArray`	`mmuli(INDArray other, INDArray result)` Perform an inplace 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
`INDArray`	`mul(INDArray other)` copy (element wise) multiplication of two NDArrays
`INDArray`	`mul(INDArray other, INDArray result)` copy (element wise) multiplication of two NDArrays
`INDArray`	`mul(Number n)` Scalar multiplication (copy)
`INDArray`	`mul(Number n, INDArray result)` Multiplication of ndarray.
`INDArray`	`mulColumnVector(INDArray columnVector)` Multiplication of a column vector (copy)
`INDArray`	`muli(INDArray other)` in place (element wise) multiplication of two NDArrays
`INDArray`	`muli(INDArray other, INDArray result)` in place (element wise) multiplication of two NDArrays
`INDArray`	`muli(Number n)` In place scalar multiplication
`INDArray`	`muli(Number n, INDArray result)` In place multiplication of this ndarray
`INDArray`	`muliColumnVector(INDArray columnVector)` In place multiplication of a column vector
`INDArray`	`muliRowVector(INDArray rowVector)` In place multiplication of a row vector
`INDArray`	`mulRowVector(INDArray rowVector)` Multiplication of a row vector (copy)
`INDArray`	`neg()` Returns the ndarray negative (cloned)
`INDArray`	`negi()` In place setting of the negative version of this ndarray
`INDArray`	`neq(INDArray other)` Returns the binary ndarray for "Not equals" comparison.
`INDArray`	`neq(Number other)` Returns the binary ndarray for "Not equals" comparison.
`protected INDArray`	`newShape(long[] newShape, char ordering)`
`int`	`nnz()` Return the number of non-null element
`boolean`	`none()` This method checks if any of the elements within this array are non-zero (or true, in case of boolean)
`INDArray`	`norm1(boolean keepDims, int... dimension)` Returns the norm1 (L1 norm, i.e., sum of absolute values; also known as Taxicab or Manhattan norm) along the specified dimension
`INDArray`	`norm1(int... dimension)` Returns the norm1 (L1 norm, i.e., sum of absolute values; also known as Taxicab or Manhattan norm) along the specified dimension
`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(boolean keepDims, int... dimension)` Returns the norm2 (L2 norm, sqrt(sum(x_i^2), also known as Euclidean norm) along the specified dimension(s)
`INDArray`	`norm2(int... dimension)` Returns the norm2 (L2 norm, sqrt(sum(x_i^2), also known as Euclidean norm) along the specified dimension(s)
`Number`	`norm2Number()` Return the norm2 (L2 norm, sqrt(sum(x_i^2), also known as Euclidean norm) for the entire array
`INDArray`	`normmax(boolean keepDims, int... dimension)` Returns the max norm (aka infinity norm, equal to the maximum absolute value) along the specified dimension(s)
`INDArray`	`normmax(int... dimension)` Returns the max norm (aka infinity norm, equal to the maximum absolute value) along the specified dimension(s)
`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(boolean keepDims, int... dimension)` Returns the product along a given dimension
`INDArray`	`prod(int... dimension)` Returns the product along a given dimension
`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`	`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(long 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(long[] indexes, double value)` See `INDArray.putScalar(int[], double)`
`INDArray`	`putScalar(long[] indexes, float value)` See `INDArray.putScalar(int[], double)`
`INDArray`	`putScalar(long[] indexes, int value)` See `INDArray.putScalar(int[], double)`
`INDArray`	`putScalar(long i, double value)` Insert the number linearly in to the ndarray
`INDArray`	`putScalar(long i, float value)` Insert a scalar float at the specified index
`INDArray`	`putScalar(long i, int value)` Insert a scalar int at the specified index
`INDArray`	`putScalar(long row, long 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(long dim0, long dim1, long 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(long dim0, long dim1, long dim2, long 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
`INDArray`	`rdiv(INDArray other)` Reverse division, elements wise.
`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)
`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, long... 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
`INDArray`	`reshape(char order, boolean enforceView, long... newShape)` Reshapes the ndarray (note: it's not possible to change the length of the ndarray).
`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(char order, long... newShape)` 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(long... shape)` Reshapes the ndarray (can't change the length of the ndarray).
`INDArray`	`reshape(long newRows, long newColumns)` Reshape the matrix.
`int`	`rows()` Returns the number of rows in the array (only 2d) throws an exception when called when not 2d
`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)
`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
`void`	`setData(DataBuffer data)`
`void`	`setOrder(char order)` Set the ordering
`void`	`setShapeAndStride(int[] shape, int[] stride)` Shape and stride setter
`INDArray`	`shannonEntropy(int... dimension)` Returns Shannon entropy value for this INDArray along specified dimension(s)
`Number`	`shannonEntropyNumber()` Returns non-normalized Shannon entropy value for this INDArray
`long[]`	`shape()` Returns the shape(dimensions) of this array
`LongBuffer`	`shapeInfo()` Shape info
`DataBuffer`	`shapeInfoDataBuffer()` Shape info
`long[]`	`shapeInfoJava()` This method returns shapeInformation as jvm long array
`String`	`shapeInfoToString()` Returns the shape information debugging information
`protected DataBuffer`	`shapeOf()`
`long`	`size(int dimension)` Returns the size of this array along a particular dimension
`INDArray`	`slice(long slice)` Returns the specified slice of this matrix.
`INDArray`	`slice(long slice, int dimension)` Returns the slice of this from the specified dimension
`long`	`slices()` Number of slices: aka shape[0]
`void`	`sliceVectors(List<INDArray> list)` Flattens the array for linear indexing in list.
`DataBuffer`	`sparseInfoDataBuffer()` Sparse info
`int[]`	`sparseOffsets()`
`double`	`squaredDistance(INDArray other)` Returns the square of the Euclidean distance.
`INDArray`	`std(boolean biasCorrected, boolean keepDims, int... dimension)` Standard deviation of an ndarray along a dimension
`INDArray`	`std(boolean biasCorrected, int... dimension)` Standard deviation of an ndarray along a dimension
`INDArray`	`std(int... dimension)` Standard deviation of an INDArray along one or more dimensions
`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
`long[]`	`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()`
`protected int`	`stringBuffer(com.google.flatbuffers.FlatBufferBuilder builder, DataBuffer buffer)`
`INDArray`	`sub(INDArray other)` copy subtraction of two NDArrays
`INDArray`	`sub(INDArray other, INDArray result)` copy subtraction of two NDArrays
`INDArray`	`sub(Number n)` Scalar subtraction (copied)
`INDArray`	`sub(Number n, INDArray result)` Subtraction of this ndarray
`INDArray`	`subColumnVector(INDArray columnVector)` Subtraction of a column vector (copy)
`INDArray`	`subi(INDArray other)` in place (element wise) subtraction of two NDArrays
`INDArray`	`subi(INDArray other, INDArray result)` in place subtraction of two matrices
`INDArray`	`subi(Number n)` In place scalar subtraction
`INDArray`	`subi(Number n, INDArray result)` In place subtraction of this ndarray
`INDArray`	`subiColumnVector(INDArray columnVector)` In place subtraction of a column vector
`INDArray`	`subiRowVector(INDArray rowVector)` In place subtraction of a row vector
`INDArray`	`subRowVector(INDArray rowVector)` Subtraction of a row vector (copy)
`INDArray`	`sum(boolean keepDim, int... dimension)` Returns the sum along the last dimension of this ndarray
`INDArray`	`sum(INDArray result, boolean keepDims, int... dimension)` Returns the sum along the last dimension of this ndarray
`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
`Number`	`sumNumber()` Sum the entire array
`INDArray`	`swapAxes(int dimension, int with)` Mainly here for people coming from numpy.
`INDArray`	`tensorAlongDimension(long index, int... dimension)` Get the vector along a particular dimension
`long`	`tensorsAlongDimension(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.
`long[][]`	`toLongMatrix()` Convert this ndarray to a 2d int matrix.
`long[]`	`toLongVector()` Convert this ndarray to a 1d long matrix.
`String`	`toString()` Generate string representation of the matrix.
`String`	`toString(long maxElements, boolean forceSummarize, int precision)` Get a string representation of the array
`String`	`toString(NDArrayStrings options)` Get a string representation of the array with configurable formatting
`String`	`toStringFull()` ToString with unlimited elements and precision
`INDArray`	`transpose()` Return transposed copy of this matrix.
`INDArray`	`transposei()` Return transposed version of this matrix.
`INDArray`	`ulike()` This method returns uninitialized array with the same dtype/order/shape as this one
`int`	`underlyingRank()`
`protected void`	`validateNumericalArray(String opName, boolean allowEmpty)` Validate that the operation is being applied on a numerical array (not boolean or utf8).
`INDArray`	`var(boolean biasCorrected, int... dimension)` Returns the overall variance of this ndarray
`INDArray`	`var(int... dimension)` Returns the overall variance of this ndarray
`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
`long`	`vectorsAlongDimension(int dimension)` Returns the number of possible vectors for a given dimension
`boolean`	`wasClosed()` This method checks if array or its buffer was closed before
`protected void`	`write(ObjectOutputStream out)`

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

Methods inherited from interface org.nd4j.linalg.api.ndarray.INDArray
shapeDescriptor, 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
```
  - released
```
protected transient boolean released
```
  - jvmShapeInfo
```
protected transient JvmShapeInfo jvmShapeInfo
```
- 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(DataBuffer buffer,
                   long[] shape,
                   long[] stride,
                   long offset,
                   char ordering)
```
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer,
                   long[] shape,
                   long[] stride,
                   long offset,
                   long ews,
                   char ordering)
```
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer,
                   long[] shape,
                   long[] stride,
                   long offset,
                   char ordering,
                   DataType dataType)
```
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer,
                   long[] shape,
                   long[] stride,
                   long offset,
                   long ews,
                   char ordering,
                   DataType dataType)
```
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer,
                   long[] shape,
                   long[] stride,
                   char ordering,
                   DataType type)
```
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer,
                   long[] shape,
                   long[] stride,
                   char ordering,
                   DataType type,
                   MemoryWorkspace workspace)
```
  - BaseNDArray
```
public BaseNDArray(DataBuffer buffer,
                   DataType dataType,
                   long[] shape,
                   long[] stride,
                   long offset,
                   char 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(double[] data,
                   long[] shape,
                   long offset,
                   char ordering)
```
  - BaseNDArray
```
public BaseNDArray(float[] data,
                   long[] shape,
                   long offset,
                   char ordering)
```
  - 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(long[] shape,
                   long[] stride,
                   long offset,
                   char ordering)
```
  - 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(long[] shape,
                   long[] stride,
                   long offset,
                   char ordering,
                   boolean initialize)
```
  - BaseNDArray
```
public BaseNDArray(DataType type,
                   long[] shape,
                   long[] stride,
                   long offset,
                   char ordering,
                   boolean initialize)
```
  - BaseNDArray
```
public BaseNDArray(DataType type,
                   long[] shape,
                   long[] stride,
                   long offset,
                   char ordering,
                   boolean initialize,
                   MemoryWorkspace workspace)
```
  - 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(long[] shape,
                   long offset,
                   char ordering)
```
  - BaseNDArray
```
public BaseNDArray(int[] shape)
```
    Create an ndarray with the given shape
    
    Parameters:
    
    shape -
  - BaseNDArray
```
public BaseNDArray(long[] 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(long newRows,
                   long newColumns,
                   char ordering)
```
  - 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,
                   long[] shape,
                   char ordering)
```
  - 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(List<INDArray> slices,
                   long[] shape,
                   long[] stride,
                   char ordering)
```
  - 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(float[] data,
                   long[] shape,
                   long[] stride,
                   long offset,
                   char ordering)
```
  - BaseNDArray
```
public BaseNDArray(double[] data,
                   long[] shape,
                   long[] stride,
                   long offset,
                   char 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 data,
                   long[] 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(DataBuffer buffer,
                   long[] shape,
                   char ordering)
```
  - BaseNDArray
```
public BaseNDArray(double[] data,
                   int[] shape,
                   char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    ordering -
  - BaseNDArray
```
public BaseNDArray(double[] data,
                   long[] shape,
                   char ordering)
```
  - BaseNDArray
```
public BaseNDArray(float[] data,
                   long[] shape,
                   char 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(long[] shape,
                   long[] stride,
                   long 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(long newRows,
                   long newColumns)
```
  - 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,
                   long[] shape)
```
  - 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(List<INDArray> slices,
                   long[] shape,
                   long[] stride)
```
  - 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(double[] data,
                   long[] shape,
                   long[] stride,
                   long offset)
```
  - BaseNDArray
```
public BaseNDArray(float[] data,
                   long[] shape,
                   long[] stride,
                   long 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()
```
    Description copied from interface: INDArray
    
    Check if this array is compressed.
    
    Specified by:
    
    isCompressed in interface INDArray
    
    Returns:
    
    true if this array is compressed.
  - markAsCompressed
```
public void markAsCompressed(boolean reallyCompressed)
```
    Description copied from interface: INDArray
    
    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 - new value for compressed.
  - 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)
```
  - isValid
```
@Deprecated
public boolean isValid()
```
    Deprecated.
    
    Returns whether the ndarray is valid or not
    
    Returns:
    
    true if the ndarray is valid false otherwise
  - create
```
protected INDArray create(DataBuffer data,
                          int[] shape,
                          long offset)
```
  - elementWiseStride
```
public int elementWiseStride()
```
    Description copied from interface: INDArray
    
    Element wise stride
    
    Specified by:
    
    elementWiseStride in interface INDArray
    
    Returns:
    
    the element wise stride
  - tensorsAlongDimension
```
public long tensorsAlongDimension(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the number of possible vectors for a given dimension
    
    Specified by:
    
    tensorsAlongDimension 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(long 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
  - vectorsAlongDimension
```
public long vectorsAlongDimension(int dimension)
```
    Description copied from interface: INDArray
    
    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)
```
    Description copied from interface: INDArray
    
    Get the vector along a particular dimension
    
    Specified by:
    
    vectorAlongDimension in interface INDArray
    
    Parameters:
    
    index - the index of the vector to getScalar
    
    dimension - the dimension to getScalar the vector from
    
    Returns:
    
    the vector along a particular dimension
  - 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
  - setShapeAndStride
```
public void setShapeAndStride(int[] shape,
                              int[] stride)
```
    Description copied from interface: INDArray
    
    Shape and stride setter
    
    Specified by:
    
    setShapeAndStride in interface INDArray
    
    Parameters:
    
    shape - new value for shape
    
    stride - new value for stride
  - cumsumi
```
public INDArray cumsumi(int dimension)
```
    Description copied from interface: INDArray
    
    Returns the cumulative sum along a dimension. In-place method.
    
    Specified by:
    
    cumsumi in interface INDArray
    
    Parameters:
    
    dimension - the dimension to perform cumulative sum along.
    
    Returns:
    
    this object.
  - 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
  - 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
  - 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
  - stdNumber
```
public Number stdNumber()
```
    Description copied from interface: INDArray
    
    Calculate the standard deviation for the entire array
    
    Specified by:
    
    stdNumber in interface INDArray
    
    Returns:
    
    standard deviation
  - 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
  - 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
  - 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
  - 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
  - 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
  - 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()
```
    Description copied from interface: INDArray
    
    Returns entropy value for this INDArray
    
    Specified by:
    
    entropyNumber in interface INDArray
    
    Returns:
    
    entropy value
  - shannonEntropyNumber
```
public Number shannonEntropyNumber()
```
    Description copied from interface: INDArray
    
    Returns non-normalized Shannon entropy value for this INDArray
    
    Specified by:
    
    shannonEntropyNumber in interface INDArray
    
    Returns:
    
    non-normalized Shannon entropy
  - logEntropyNumber
```
public Number logEntropyNumber()
```
    Description copied from interface: INDArray
    
    Returns log entropy value for this INDArray
    
    Specified by:
    
    logEntropyNumber in interface INDArray
    
    Returns:
    
    log entropy value
  - cumsum
```
public INDArray cumsum(int dimension)
```
    Description copied from interface: INDArray
    
    Returns the cumulative sum along a dimension.
    
    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)
```
    Description copied from interface: INDArray
    
    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(long 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(long 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(long 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(long[] indexes,
                          double value)
```
    Description copied from interface: INDArray
    
    See INDArray.putScalar(int[], double)
    
    Specified by:
    
    putScalar in interface INDArray
  - putScalar
```
public INDArray putScalar(long[] indexes,
                          float value)
```
    Description copied from interface: INDArray
    
    See INDArray.putScalar(int[], double)
    
    Specified by:
    
    putScalar in interface INDArray
  - putScalar
```
public INDArray putScalar(long row,
                          long 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(long dim0,
                          long dim1,
                          long 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(long dim0,
                          long dim1,
                          long dim2,
                          long 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
  - putScalar
```
public INDArray putScalar(long[] indexes,
                          int value)
```
    Description copied from interface: INDArray
    
    See INDArray.putScalar(int[], double)
    
    Specified by:
    
    putScalar in interface INDArray
  - eps
```
public INDArray eps(Number other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Epsilon equals" comparison.
    
    Specified by:
    
    eps in interface INDArray
    
    Parameters:
    
    other - the number to compare.
    
    Returns:
    
    the binary ndarray for "Epsilon equals" comparison.
  - eps
```
public INDArray eps(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Epsilon equals" comparison.
    
    Specified by:
    
    eps in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    the binary ndarray for "Epsilon equals" comparison.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - gt
```
public INDArray gt(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the binary ndarray for "Greater Than" comparison.
    
    Specified by:
    
    gt in interface INDArray
    
    Parameters:
    
    other - the ndarray to compare.
    
    Returns:
    
    the binary ndarray for "Greater Than" comparison.
  - isInfinite
```
public INDArray isInfinite()
```
    Description copied from interface: INDArray
    
    Returns the binary NDArray with value true where this array's entries are infinite, or false where they are not infinite
    
    Specified by:
    
    isInfinite in interface INDArray
  - isNaN
```
public INDArray isNaN()
```
    Description copied from interface: INDArray
    
    Returns the binary NDArray with value true where this array's entries are NaN, or false where they are not infinite
    
    Specified by:
    
    isNaN in interface INDArray
  - neg
```
public INDArray neg()
```
    Description copied from interface: INDArray
    
    Returns the ndarray negative (cloned)
    
    Specified by:
    
    neg in interface INDArray
    
    Returns:
    
    Array copy with all values negated
  - negi
```
public INDArray negi()
```
    Description copied from interface: INDArray
    
    In place setting of the negative version of this ndarray
    
    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
    
    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:
    
    the result ndarray
  - 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)
```
    Description copied from interface: INDArray
    
    Division if ndarray by number
    
    Specified by:
    
    div in interface INDArray
    
    Parameters:
    
    n - the number to divide by
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - 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:
    
    the result ndarray
  - mul
```
public INDArray mul(Number n,
                    INDArray result)
```
    Description copied from interface: INDArray
    
    Multiplication of ndarray.
    
    Specified by:
    
    mul in interface INDArray
    
    Parameters:
    
    n - the number to multiply by
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - 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:
    
    the result ndarray
  - sub
```
public INDArray sub(Number n,
                    INDArray result)
```
    Description copied from interface: INDArray
    
    Subtraction of this ndarray
    
    Specified by:
    
    sub in interface INDArray
    
    Parameters:
    
    n - the number to subtract by
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - 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)
```
    Description copied from interface: INDArray
    
    Addition of this ndarray.
    
    Specified by:
    
    add in interface INDArray
    
    Parameters:
    
    n - the number to add
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - 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(long row,
                          long column)
```
    Description copied from interface: INDArray
    
    Returns the element at the specified row/column
    
    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 specified indices
    
    Specified by:
    
    getInt in interface INDArray
    
    Parameters:
    
    indices - the indices to getScalar
    
    Returns:
    
    the array with the specified elements
  - getLong
```
public long getLong(long index)
```
    Specified by:
    
    getLong in interface INDArray
  - getLong
```
public long getLong(long... indices)
```
    Specified by:
    
    getLong in interface INDArray
  - getDouble
```
public double getDouble(int... indices)
```
    Returns the elements at the specified indices
    
    Specified by:
    
    getDouble in interface INDArray
    
    Parameters:
    
    indices - the indices to get
    
    Returns:
    
    the array with the specified elements
  - getDouble
```
public double getDouble(long... indices)
```
    Specified by:
    
    getDouble in interface INDArray
  - getFloat
```
public float getFloat(int... indices)
```
    Returns the elements at the specified indices
    
    Specified by:
    
    getFloat in interface INDArray
    
    Parameters:
    
    indices - the indices to get
    
    Returns:
    
    the array with the specified elements
  - getFloat
```
public float getFloat(long... indices)
```
    Specified by:
    
    getFloat in interface INDArray
  - 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)
```
    Description copied from interface: INDArray
    
    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:
    
    a copy of this array with the conditional assignments.
  - 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:
    
    a copy of this array with the conditional assignments.
  - 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:
    
    a copy of this array with the conditional assignments.
  - 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:
    
    a copy of this array with the conditional assignments.
  - 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:
    
    a copy of this array with the conditional assignments.
  - put
```
public INDArray put(int i,
                    int j,
                    INDArray element)
```
    Description copied from interface: INDArray
    
    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)
```
    Description copied from interface: INDArray
    
    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)
```
    Description copied from interface: INDArray
    
    Assigns the given matrix (put) to the specified slice
    
    Specified by:
    
    putSlice in interface INDArray
    
    Parameters:
    
    slice - the slice to assign
    
    put - the slice to applyTransformToDestination
    
    Returns:
    
    this for chainability
  - assertSlice
```
protected void assertSlice(INDArray put,
                           long slice)
```
  - isMatrix
```
public boolean isMatrix()
```
    Returns true if this ndarray is 2d
    
    Specified by:
    
    isMatrix in interface INDArray
    
    Returns:
    
    true if the element is a matrix, false otherwise
  - newShape
```
protected INDArray newShape(long[] newShape,
                            char ordering)
```
  - create
```
protected INDArray create(DataBuffer data,
                          int[] newShape,
                          int[] newStrides,
                          long offset,
                          char ordering)
```
  - create
```
protected INDArray create(DataBuffer data,
                          long[] newShape,
                          long[] 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)
```
    Description copied from interface: INDArray
    
    Returns the square of the Euclidean distance.
    
    Specified by:
    
    squaredDistance in interface INDArray
  - distance2
```
public double distance2(INDArray other)
```
    Description copied from interface: INDArray
    
    Returns the (euclidean) distance.
    
    Specified by:
    
    distance2 in interface INDArray
  - distance1
```
public double distance1(INDArray other)
```
    Description copied from interface: INDArray
    
    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
  - put
```
public INDArray put(INDArray indices,
                    INDArray element)
```
    Description copied from interface: INDArray
    
    Put element in to the indices denoted by the indices ndarray. In numpy this is equivalent to: a[indices] = element
    
    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
    
    Check if this array is a view or not.
    
    Specified by:
    
    isView in interface INDArray
    
    Returns:
    
    true if array is a view.
  - isSparse
```
public boolean isSparse()
```
    Description copied from interface: INDArray
    
    Check if this array is sparse
    
    Specified by:
    
    isSparse in interface INDArray
    
    Returns:
    
    true if this array is sparse.
  - 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 long slices()
```
    Number of slices: aka shape[0]
    
    Specified by:
    
    slices in interface INDArray
    
    Returns:
    
    the number of slices for this nd array
  - create
```
protected INDArray create(DataBuffer buffer)
```
  - cond
```
public INDArray cond(Condition condition)
```
    Description copied from interface: INDArray
    
    Returns a binary INDArray with value 'true' if the element matches the specified condition and 'false' 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)
  - init
```
protected void init(int[] shape,
                    int[] stride)
```
  - init
```
protected void init(long[] shape,
                    long[] stride)
```
  - getScalar
```
public INDArray getScalar(long 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:
  - 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)
```
    Description copied from interface: INDArray
    
    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)
```
    Description copied from interface: INDArray
    
    In place division of a column vector
    
    Specified by:
    
    diviColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector used for division
    
    Returns:
    
    the result of the division
  - divColumnVector
```
public INDArray divColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    Division of a column vector (copy)
    
    Specified by:
    
    divColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector used for division
    
    Returns:
    
    the result of the division
  - diviRowVector
```
public INDArray diviRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place division of a row vector
    
    Specified by:
    
    diviRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - divRowVector
```
public INDArray divRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    Division of a row vector (copy)
    
    Specified by:
    
    divRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector used for division
    
    Returns:
    
    the result of the division
  - muliColumnVector
```
public INDArray muliColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place multiplication of a column vector
    
    Specified by:
    
    muliColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector used for multiplication
    
    Returns:
    
    the result of the multiplication
  - mulColumnVector
```
public INDArray mulColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    Multiplication of a column vector (copy)
    
    Specified by:
    
    mulColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector used for multiplication
    
    Returns:
    
    the result of the multiplication
  - muliRowVector
```
public INDArray muliRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place multiplication of a row vector
    
    Specified by:
    
    muliRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector used for multiplication
    
    Returns:
    
    the result of the multiplication
  - mulRowVector
```
public INDArray mulRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    Multiplication of a row vector (copy)
    
    Specified by:
    
    mulRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector used for multiplication
    
    Returns:
    
    the result of the multiplication
  - subiColumnVector
```
public INDArray subiColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    In place subtraction of a column vector
    
    Specified by:
    
    subiColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - subColumnVector
```
public INDArray subColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    Subtraction of a column vector (copy)
    
    Specified by:
    
    subColumnVector in interface INDArray
    
    Parameters:
    
    columnVector - the column vector to subtract
    
    Returns:
    
    the result of the subtraction
  - subiRowVector
```
public INDArray subiRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    In place subtraction of a row vector
    
    Specified by:
    
    subiRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - subRowVector
```
public INDArray subRowVector(INDArray rowVector)
```
    Description copied from interface: INDArray
    
    Subtraction of a row vector (copy)
    
    Specified by:
    
    subRowVector in interface INDArray
    
    Parameters:
    
    rowVector - the row vector to subtract
    
    Returns:
    
    the result of the subtraction
  - addiColumnVector
```
public INDArray addiColumnVector(INDArray columnVector)
```
    Description copied from interface: INDArray
    
    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)
```
    Description copied from interface: INDArray
    
    Addition of a column vector (copy)
    
    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)
```
    Description copied from interface: INDArray
    
    In place addition of a row 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)
```
    Description copied from interface: INDArray
    
    Addition of a row vector (copy)
    
    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)
```
    Description copied from interface: INDArray
    
    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
    
    mMulTranspose - the transpose status of each array
    
    Returns:
    
    the result of the matrix multiplication
  - mmul
```
public INDArray mmul(INDArray other,
                     MMulTranspose mMulTranspose)
```
    Description copied from interface: INDArray
    
    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)
```
    Description copied from interface: INDArray
    
    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
  - toLongVector
```
public long[] toLongVector()
```
    Description copied from interface: INDArray
    
    Convert this ndarray to a 1d long 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:
    
    toLongVector in interface INDArray
    
    Returns:
    
    a copy of this array as a 1d long array
  - toLongMatrix
```
public long[][] toLongMatrix()
```
    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:
    
    toLongMatrix in interface INDArray
    
    Returns:
    
    a copy of this array as a 2d 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)
```
    Description copied from interface: INDArray
    
    Copy (element wise) division of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    copy (element wise) division of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    copy (element wise) multiplication of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    copy (element wise) multiplication of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    copy subtraction of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    copy subtraction of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    Element-wise copy addition of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    Element-wise copy addition of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    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)
```
    Description copied from interface: INDArray
    
    Perform an inplace 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)
```
    Description copied from interface: INDArray
    
    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)
```
    Description copied from interface: INDArray
    
    Perform an inplace 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)
```
    Description copied from interface: INDArray
    
    in place (element wise) division of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    in place (element wise) division of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    in place (element wise) multiplication of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    in place (element wise) multiplication of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    in place (element wise) subtraction of two NDArrays
    
    Specified by:
    
    subi in interface INDArray
    
    Parameters:
    
    other - the second ndarray to subtract
    
    Returns:
    
    the result of the subtraction
  - 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)
```
    Description copied from interface: INDArray
    
    in place (element wise) addition of two NDArrays
    
    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)
```
    Description copied from interface: INDArray
    
    in place (element wise) addition of two NDArrays
    
    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(boolean keepDims,
                        int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the max norm (aka infinity norm, equal to the maximum absolute value) along the specified dimension(s)
    
    Specified by:
    
    normmax in interface INDArray
    
    Parameters:
    
    keepDims - whether to keep reduced dimensions as dimensions of size 1
    
    dimension - the dimension to the max norm along
    
    Returns:
    
    Max norm along the specified dimension
  - normmax
```
public INDArray normmax(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the max norm (aka infinity norm, equal to the maximum absolute value) along the specified dimension(s)
    
    Specified by:
    
    normmax in interface INDArray
    
    Parameters:
    
    dimension - the dimension to the max norm along
    
    Returns:
    
    Max norm along the specified dimension
  - rdiv
```
public INDArray rdiv(INDArray other)
```
    Description copied from interface: INDArray
    
    Reverse division, elements wise. i.e., other / this
    
    Specified by:
    
    rdiv in interface INDArray
    
    Parameters:
    
    other - the matrix to divide from
    
    Returns:
    
    Copy of this array after performing element wise reverse division
  - rdivi
```
public INDArray rdivi(INDArray other)
```
    Description copied from interface: INDArray
    
    Reverse divsion (in place). i.e., other / this
    
    Specified by:
    
    rdivi in interface INDArray
    
    Parameters:
    
    other - The matrix to divide from
    
    Returns:
    
    This array after performing element wise reverse division
  - rdiv
```
public INDArray rdiv(INDArray other,
                     INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse division
    
    Specified by:
    
    rdiv in interface INDArray
    
    Parameters:
    
    other - the matrix to divide from
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - rdivi
```
public INDArray rdivi(INDArray other,
                      INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse division (in-place)
    
    Specified by:
    
    rdivi in interface INDArray
    
    Parameters:
    
    other - the matrix to divide from
    
    result - the result ndarray
    
    Returns:
    
    the ndarray with the operation applied
  - rsub
```
public INDArray rsub(INDArray other,
                     INDArray result)
```
    Description copied from interface: INDArray
    
    Reverse subtraction
    
    Specified by:
    
    rsub in interface INDArray
    
    Parameters:
    
    other - the matrix to subtract from
    
    result - the result ndarray
    
    Returns:
    
    the result ndarray
  - 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 - Other array to use in reverse subtraction
    
    Returns:
    
    Copy of this array, after applying reverse subtraction
  - 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 - Other way to use in reverse subtraction operation
    
    Returns:
    
    This array, after applying reverse subtraction
  - rsubi
```
public INDArray rsubi(INDArray other,
                      INDArray result)
```
    Description copied from interface: INDArray
    
    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)
```
    Description copied from interface: INDArray
    
    Set all entries 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
  - assign
```
public INDArray assign(boolean value)
```
    Description copied from interface: INDArray
    
    Set all entries 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)
```
    Description copied from interface: INDArray
    
    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
    
    Returns:
    
    this
  - replaceWhere
```
public INDArray replaceWhere(INDArray arr,
                             Condition condition)
```
    Description copied from interface: INDArray
    
    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 - Source array
    
    condition - Condition to apply
    
    Returns:
    
    New array with values conditionally replaced
  - linearIndex
```
@Deprecated
public long linearIndex(long 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(long 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(long 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(long 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
  - getScalar
```
public INDArray getScalar(long... indexes)
```
    Specified by:
    
    getScalar in interface INDArray
  - 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)
```
    Description copied from interface: INDArray
    
    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,
                       long... 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:
    
    Repeated array
  - putRow
```
public INDArray putRow(long row,
                       INDArray toPut)
```
    Description copied from interface: INDArray
    
    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)
```
    Description copied from interface: INDArray
    
    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
  - getNumber
```
public Number getNumber(long i)
```
    Specified by:
    
    getNumber in interface INDArray
  - getNumber
```
public Number getNumber(long... idx)
```
    Specified by:
    
    getNumber in interface INDArray
  - getDouble
```
public double getDouble(long 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(long i,
                        long 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(long 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(long i,
                      long 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
  - reshape
```
public INDArray reshape(char order,
                        long... 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
  - reshape
```
public INDArray reshape(char order,
                        boolean enforceView,
                        long... newShape)
```
    Description copied from interface: INDArray
    
    Reshapes the ndarray (note: it's not possible to change the length of the ndarray). Typically this will be a view, unless reshaping without copying (i.e., returning a view) is impossible.
    In that case, the behaviour will depend on the enforceView argument: enforceView == true: throw an exception
    enforceView == false: return a copy
    
    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 double at the given linear offset unsafe, without checks.
    
    Specified by:
    
    getDoubleUnsafe in interface INDArray
    
    Parameters:
    
    offset - the offset to get at
    
    Returns:
    
    double value at offset
  - 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
  - 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
  - reshape
```
public INDArray reshape(long... shape)
```
    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
    
    Parameters:
    
    shape - the new shape of the ndarray
    
    Returns:
    
    the reshaped ndarray
  - prod
```
public INDArray prod(boolean keepDims,
                     int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the product along a given dimension
    
    Specified by:
    
    prod in interface INDArray
    
    Parameters:
    
    keepDims - whether to keep reduced dimensions as dimensions of size 1
    
    dimension - the dimension to getScalar the product along
    
    Returns:
    
    the product along the specified dimension
  - prod
```
public INDArray prod(int... dimension)
```
    Description copied from interface: INDArray
    
    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(boolean keepDims,
                     int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the overall mean of this ndarray
    
    Specified by:
    
    mean in interface INDArray
    
    Parameters:
    
    keepDims - whether to keep reduced dimensions as dimensions of size 1
    
    dimension - the dimension to getScalar the mean along
    
    Returns:
    
    the mean along the specified dimension of this ndarray
  - mean
```
public INDArray mean(int... dimension)
```
    Description copied from interface: INDArray
    
    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 absolute mean along the specified dimension of this ndarray
  - mean
```
public INDArray mean(@NonNull
                     INDArray result,
                     boolean keepDims,
                     int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the overall mean of this ndarray
    
    Specified by:
    
    mean in interface INDArray
    
    keepDims - whether to keep reduced dimensions as dimensions of size 1
    
    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)
```
    Description copied from interface: INDArray
    
    Returns the overall variance of this ndarray
    
    Specified by:
    
    var in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the variance along
    
    Returns:
    
    the variance along the specified dimension of this ndarray
  - var
```
public INDArray var(boolean biasCorrected,
                    int... dimension)
```
    Description copied from interface: INDArray
    
    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 variance along
    
    Returns:
    
    the variance along the specified dimension of this ndarray
  - max
```
public INDArray max(boolean keepDims,
                    int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the overall max of this ndarray along given dimensions
    
    Specified by:
    
    max in interface INDArray
    
    Parameters:
    
    keepDims - whether to keep reduced dimensions as dimensions of size 1
    
    dimension - the dimension to getScalar the max along
    
    Returns:
    
    the max along the specified dimension of this ndarray
  - max
```
public INDArray max(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the overall max of this ndarray along given dimensions
    
    Specified by:
    
    max in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the max along
    
    Returns:
    
    the max 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 amax along
    
    Returns:
    
    the amax along the specified dimension of this ndarray
  - min
```
public INDArray min(boolean keepDims,
                    int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the overall min of this ndarray
    
    Specified by:
    
    min in interface INDArray
    
    Parameters:
    
    keepDims - whether to keep reduced dimensions as dimensions of size 1
    
    dimension - the dimension to getScalar the min along
    
    Returns:
    
    the min along the specified dimension of this ndarray
  - min
```
public INDArray min(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the overall min of this ndarray
    
    Specified by:
    
    min in interface INDArray
    
    Parameters:
    
    dimension - the dimension to getScalar the min along
    
    Returns:
    
    the min 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)
```
    Description copied from interface: INDArray
    
    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
  - sum
```
public INDArray sum(boolean keepDim,
                    int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the sum along the last dimension of this ndarray
    
    Specified by:
    
    sum in interface INDArray
    
    Parameters:
    
    keepDim - whether to keep reduced dimensions as dimensions of size 1
    
    dimension - the dimension to getScalar the sum along
    
    Returns:
    
    the sum along the specified dimension of this ndarray
  - entropy
```
public INDArray entropy(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns entropy value for this INDArray along specified dimension(s)
    
    Specified by:
    
    entropy in interface INDArray
    
    Parameters:
    
    dimension - specified dimension(s)
    
    Returns:
    
    entropy value
  - shannonEntropy
```
public INDArray shannonEntropy(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns Shannon entropy value for this INDArray along specified dimension(s)
    
    Specified by:
    
    shannonEntropy in interface INDArray
    
    Parameters:
    
    dimension - specified dimension(s)
    
    Returns:
    
    Shannon entropy
  - logEntropy
```
public INDArray logEntropy(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns log entropy value for this INDArray along specified dimension(s)
    
    Specified by:
    
    logEntropy in interface INDArray
    
    Parameters:
    
    dimension - specified dimension(s)
    
    Returns:
    
    log entropy value
  - sum
```
public INDArray sum(@NonNull
                    INDArray result,
                    boolean keepDims,
                    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
    
    keepDims - whether to keep reduced dimensions as dimensions of size 1
    
    dimension - the dimension to getScalar the sum along
    
    Returns:
    
    the sum along the specified dimension of this ndarray
  - 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)
```
    Description copied from interface: INDArray
    
    Returns the norm1 (L1 norm, i.e., sum of absolute values; also known as Taxicab or Manhattan norm) 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
  - norm1
```
public INDArray norm1(boolean keepDims,
                      int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the norm1 (L1 norm, i.e., sum of absolute values; also known as Taxicab or Manhattan norm) along the specified dimension
    
    Specified by:
    
    norm1 in interface INDArray
    
    Parameters:
    
    keepDims - whether to keep reduced dimensions as dimensions of size 1
    
    dimension - the dimension to getScalar the norm1 along
    
    Returns:
    
    the norm1 along the specified dimension
  - std
```
public INDArray std(int... dimension)
```
    Description copied from interface: INDArray
    
    Standard deviation of an INDArray along one or more dimensions
    
    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
  - std
```
public INDArray std(boolean biasCorrected,
                    boolean keepDims,
                    int... dimension)
```
    Description copied from interface: INDArray
    
    Standard deviation of an ndarray along a dimension
    
    Specified by:
    
    std in interface INDArray
    
    keepDims - whether to keep reduced dimensions as dimensions of size 1
    
    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(boolean keepDims,
                      int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the norm2 (L2 norm, sqrt(sum(x_i^2), also known as Euclidean norm) along the specified dimension(s)
    
    Specified by:
    
    norm2 in interface INDArray
    
    Parameters:
    
    keepDims - whether to keep reduced dimensions as dimensions of size 1
    
    dimension - the dimension to getScalar the norm2 along
    
    Returns:
    
    the norm2 along the specified dimension
  - norm2
```
public INDArray norm2(int... dimension)
```
    Description copied from interface: INDArray
    
    Returns the norm2 (L2 norm, sqrt(sum(x_i^2), also known as Euclidean norm) along the specified dimension(s)
    
    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)
```
    Description copied from interface: INDArray
    
    Flattens the array for linear indexing in list.
    
    Specified by:
    
    sliceVectors in interface INDArray
  - reshape
```
public INDArray reshape(long newRows,
                        long 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(long c)
```
    Get the specified column
    
    Specified by:
    
    getColumn in interface INDArray
    
    Parameters:
    
    c -
    
    Returns:
    
    the specified column
  - getColumn
```
public INDArray getColumn(long c,
                          boolean keepDim)
```
    Description copied from interface: INDArray
    
    Returns the specified column. Throws an exception if its not a matrix (rank 2). Returned array will either be 1D (keepDim = false) or 2D (keepDim = true) with shape [length, 1]
    
    Specified by:
    
    getColumn in interface INDArray
    
    Parameters:
    
    c - the row to get
    
    keepDim - If true: return [length, 1] array. Otherwise: return [length] array
    
    Returns:
    
    the specified row
  - getRows
```
public INDArray getRows(int[] rindices)
```
    Description copied from interface: INDArray
    
    Get an INDArray comprised of the specified rows only. Copy operation
    
    Specified by:
    
    getRows in interface INDArray
    
    Parameters:
    
    rindices - Rose to extract from this array
    
    Returns:
    
    Array with only the specified rows
  - get
```
public INDArray get(INDArrayIndex... indexes)
```
    Description copied from interface: INDArray
    
    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)
```
    Description copied from interface: INDArray
    
    Get an INDArray comprised of the specified columns only. Copy operation.
    
    Specified by:
    
    getColumns in interface INDArray
    
    Parameters:
    
    cindices - Columns to extract out of the current array
    
    Returns:
    
    Array with only the specified columns
  - create
```
protected INDArray create(int rows,
                          int length)
```
  - getRow
```
public INDArray getRow(long r)
```
    Get a copy of a row.
    
    Specified by:
    
    getRow in interface INDArray
    
    Parameters:
    
    r - the row to get
    
    Returns:
    
    the specified row
  - getRow
```
public INDArray getRow(long r,
                       boolean keepDim)
```
    Description copied from interface: INDArray
    
    Returns the specified row. Throws an exception if its not a matrix. Returned array will either be 1D (keepDim = false) or 2D (keepDim = true) with shape [1, length]
    
    Specified by:
    
    getRow in interface INDArray
    
    Parameters:
    
    r - the row to get
    
    keepDim - If true: return [1,length] array. Otherwise: return [length] array
    
    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:
  - equalShapes
```
public boolean equalShapes(@NonNull
                           INDArray other)
```
    Description copied from interface: INDArray
    
    This method checks 2 INDArrays for equal shapes.
    Shapes are considered equal if:
    (a) Both arrays have equal rank, and
    (b) size(0)...size(rank()-1) are equal for both arrays
    
    Specified by:
    
    equalShapes in interface INDArray
    
    Parameters:
    
    other - Other
    
    Returns:
    
    True if shap
  - 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 -
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - shapeInfoDataBuffer
```
public DataBuffer shapeInfoDataBuffer()
```
    Description copied from interface: INDArray
    
    Shape info
    
    Specified by:
    
    shapeInfoDataBuffer in interface INDArray
    
    Returns:
    
    Shape info
  - shapeInfo
```
public LongBuffer shapeInfo()
```
    Description copied from interface: INDArray
    
    Shape info
    
    Specified by:
    
    shapeInfo in interface INDArray
    
    Returns:
    
    Shape info
  - shape
```
public long[] shape()
```
    Returns the shape(dimensions) of this array
    
    Specified by:
    
    shape in interface INDArray
    
    Returns:
    
    the shape of this matrix
  - shapeInfoToString
```
public String shapeInfoToString()
```
    Description copied from interface: INDArray
    
    Returns the shape information debugging information
    
    Specified by:
    
    shapeInfoToString in interface INDArray
    
    Returns:
    
    the shape information.
  - stride
```
public long[] 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 long 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 long length()
```
    Returns the total number of elements in the ndarray
    
    Specified by:
    
    length in interface INDArray
    
    Returns:
    
    the number of elements in the ndarray
  - broadcast
```
public INDArray broadcast(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(long... 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)
```
    Description copied from interface: INDArray
    
    Dimshuffle: an extension of permute that adds the ability to broadcast various dimensions. This will only accept integers and xs.
    An x indicates a dimension should be broadcasted rather than permuted. Examples originally from the theano docs: http://deeplearning.net/software/theano/library/tensor/basic.html Returns a view of this tensor with permuted dimensions. Typically the pattern will include the integers 0, 1, ... ndim-1, and any number of 'x' characters in dimensions where this tensor should be broadcasted. A few examples of patterns and their effect: ('x') -> make a 0d (scalar) into a 1d vector (0, 1) -> identity for 2d vectors (1, 0) -> inverts the first and second dimensions ('x', 0) -> make a row out of a 1d vector (N to 1xN) (0, 'x') -> make a column out of a 1d vector (N to Nx1) (2, 0, 1) -> AxBxC to CxAxB (0, 'x', 1) -> AxB to Ax1xB (1, 'x', 0) -> AxB to Bx1xA (1,) -> This remove dimensions 0. It must be a broadcastable dimension (1xA to A)
    
    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
  - dimShuffle
```
public INDArray dimShuffle(Object[] rearrange,
                           long[] 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
    
    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 long[] doPermuteSwap(LongBuffer shape,
                               int[] rearrange)
```
  - 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 (by default) only the first and last three elements in a dimension are included. This can be changed globally using NDArrayStrings#setMaxPrintElements(long)
    
    Overrides:
    
    toString in class Object
  - toString
```
public String toString(@NonNull
                       NDArrayStrings options)
```
    Description copied from interface: INDArray
    
    Get a string representation of the array with configurable formatting
    
    Specified by:
    
    toString in interface INDArray
    
    Parameters:
    
    options - format options
  - toString
```
public String toString(long maxElements,
                       boolean forceSummarize,
                       int precision)
```
    Description copied from interface: INDArray
    
    Get a string representation of the array
    
    Specified by:
    
    toString in interface INDArray
    
    Parameters:
    
    maxElements - Summarize if more than maxElements in the array
    
    forceSummarize - Force a summary instead of a full print
    
    precision - The number of decimals to print. Doesn't print trailing 0s if negative
  - toStringFull
```
public String toStringFull()
```
    Description copied from interface: INDArray
    
    ToString with unlimited elements and precision
    
    Specified by:
    
    toStringFull in interface INDArray
    
    See Also:
    
    toString(long, boolean, int)
  - 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
  - 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:
  - stringBuffer
```
protected int stringBuffer(com.google.flatbuffers.FlatBufferBuilder builder,
                           DataBuffer buffer)
```
  - 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:
    
    Sparse info.
  - 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
  - convertType
```
protected static DataTypeEx convertType(DataType type)
```
  - isEmpty
```
public boolean isEmpty()
```
    This method returns true if this INDArray is special case: no-value INDArray
    
    Specified by:
    
    isEmpty in interface INDArray
    
    Returns:
  - shapeInfoJava
```
public long[] shapeInfoJava()
```
    Description copied from interface: INDArray
    
    This method returns shapeInformation as jvm long array
    
    Specified by:
    
    shapeInfoJava in interface INDArray
    
    Returns:
  - dataType
```
public DataType dataType()
```
    Description copied from interface: INDArray
    
    This method returns dtype for this INDArray
    
    Specified by:
    
    dataType in interface INDArray
    
    Returns:
  - isR
```
public boolean isR()
```
    Description copied from interface: INDArray
    
    This method checks if this INDArray instance is one of Real types
    
    Specified by:
    
    isR in interface INDArray
    
    Returns:
    
    true if data type is floating point, false otherwise
  - isZ
```
public boolean isZ()
```
    Description copied from interface: INDArray
    
    This method checks if this INDArray instance is one of integer types
    
    Specified by:
    
    isZ in interface INDArray
    
    Returns:
  - isB
```
public boolean isB()
```
    Description copied from interface: INDArray
    
    This method checks if this INDArray instance has boolean type
    
    Specified by:
    
    isB in interface INDArray
    
    Returns:
  - isS
```
public boolean isS()
```
    Description copied from interface: INDArray
    
    This method checks if this INDArray instance has String type
    
    Specified by:
    
    isS in interface INDArray
    
    Returns:
  - castTo
```
public INDArray castTo(DataType dataType)
```
    Description copied from interface: INDArray
    
    This method cast elements of this INDArray to new data type
    
    Specified by:
    
    castTo in interface INDArray
    
    Returns:
  - all
```
public boolean all()
```
    Description copied from interface: INDArray
    
    This method checks if all elements within this array are non-zero (or true, in case of boolean)
    
    Specified by:
    
    all in interface INDArray
    
    Returns:
  - any
```
public boolean any()
```
    Description copied from interface: INDArray
    
    This method checks if any of the elements within this array are non-zero (or true, in case of boolean)
    
    Specified by:
    
    any in interface INDArray
    
    Returns:
  - none
```
public boolean none()
```
    Description copied from interface: INDArray
    
    This method checks if any of the elements within this array are non-zero (or true, in case of boolean)
    
    Specified by:
    
    none in interface INDArray
    
    Returns:
  - getString
```
public String getString(long index)
```
    Description copied from interface: INDArray
    
    Get string value at given index.
    
    Specified by:
    
    getString in interface INDArray
    
    Parameters:
    
    index - index to retreive
    
    Returns:
    
    string value at index.
  - validateNumericalArray
```
protected void validateNumericalArray(String opName,
                                      boolean allowEmpty)
```
    Validate that the operation is being applied on a numerical array (not boolean or utf8). Some operations (such as sum, norm2, add(Number) etc don't make sense when applied to boolean/utf8 arrays
    
    Parameters:
    
    opName - Operation name to print in the exception
  - closeable
```
public boolean closeable()
```
    Description copied from interface: INDArray
    
    This method checks, if this INDArray instalce can use close() method
    
    Specified by:
    
    closeable in interface INDArray
    
    Returns:
    
    true if array can be released, false otherwise
  - close
```
public void close()
```
    Description copied from interface: INDArray
    
    This method releases exclusive off-heap resources uses by this INDArray instance. If INDArray relies on shared resources, exception will be thrown instead PLEASE NOTE: This method is NOT safe by any means
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface INDArray
  - like
```
public INDArray like()
```
    Description copied from interface: INDArray
    
    This method returns empty array with the same dtype/order/shape as this one
    
    Specified by:
    
    like in interface INDArray
    
    Returns:
  - ulike
```
public INDArray ulike()
```
    Description copied from interface: INDArray
    
    This method returns uninitialized array with the same dtype/order/shape as this one
    
    Specified by:
    
    ulike in interface INDArray
    
    Returns:
  - wasClosed
```
public boolean wasClosed()
```
    Description copied from interface: INDArray
    
    This method checks if array or its buffer was closed before
    
    Specified by:
    
    wasClosed in interface INDArray
    
    Returns:
    
    true if was closed, false otherwise

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

released

jvmShapeInfo

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

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray

BaseNDArray