NDArrayAdapter (Deep Java Library 0.11.0 API specification)

All Superinterfaces:

java.lang.AutoCloseable, NDArray, NDResource
```
public interface NDArrayAdapter
extends NDArray
```
A base implementation of the NDArray that does nothing. This can be used for overriding the NDArray with only part of the interface implemented.
This interface should only be used for the NDArray implementations that do not plan to implement a large portion of the interface. For the ones that do, they should directly implement NDArray so that the unsupported operations are better highlighted in the code.

Field Summary

Fields
Modifier and Type Field and Description

static java.lang.String UNSUPPORTED_MSG

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`UNSUPPORTED_MSG`

Method Summary

All Methods Instance Methods Default Methods
Modifier and Type	Method and Description
`default NDArray`	`abs()` Returns the absolute value of this `NDArray` element-wise.
`default NDArray`	`acos()` Returns the inverse trigonometric cosine of this `NDArray` element-wise.
`default NDArray`	`acosh()` Returns the inverse hyperbolic cosine of this `NDArray` element-wise.
`default NDArray`	`add(NDArray other)` Adds other `NDArray`s to this `NDArray` element-wise.
`default NDArray`	`add(java.lang.Number n)` Adds a number to this `NDArray` element-wise.
`default NDArray`	`addi(NDArray other)` Adds other `NDArray`s to this `NDArray` element-wise in place.
`default NDArray`	`addi(java.lang.Number n)` Adds a number to this `NDArray` element-wise in place.
`default NDArray`	`argMax()` Returns the indices of the maximum values into the flattened `NDArray`.
`default NDArray`	`argMax(int axis)` Returns the indices of the maximum values along given axis.
`default NDArray`	`argMin()` Returns the indices of the minimum values into the flattened `NDArray`.
`default NDArray`	`argMin(int axis)` Returns the indices of the minimum values along given axis.
`default NDArray`	`argSort(int axis, boolean ascending)` Returns the indices that would sort this `NDArray` given the axis.
`default NDArray`	`asin()` Returns the inverse trigonometric sine of this `NDArray` element-wise.
`default NDArray`	`asinh()` Returns the inverse hyperbolic sine of this `NDArray` element-wise.
`default NDArray`	`atan()` Returns the inverse trigonometric tangent of this `NDArray` element-wise.
`default NDArray`	`atanh()` Returns the inverse hyperbolic tangent of this `NDArray` element-wise.
`default void`	`attach(NDManager manager)` Attaches this `NDResource` to the specified `NDManager`.
`default NDArray`	`batchDot(NDArray other)` Batchwise product of this `NDArray` and the other `NDArray`.
`default NDArray`	`booleanMask(NDArray index, int axis)` Returns portion of this `NDArray` given the index boolean `NDArray` along given axis.
`default NDArray`	`broadcast(Shape shape)` Broadcasts this `NDArray` to be the given shape.
`default NDArray`	`cbrt()` Returns the cube-root of this `NDArray` element-wise.
`default NDArray`	`ceil()` Returns the ceiling of this `NDArray` element-wise.
`default NDArray`	`clip(java.lang.Number min, java.lang.Number max)` Clips (limit) the values in this `NDArray`.
`default boolean`	`contentEquals(NDArray other)` Returns `true` if all elements in this `NDArray` are equal to the other `NDArray`.
`default boolean`	`contentEquals(java.lang.Number number)` Returns `true` if all elements in this `NDArray` are equal to the `Number`.
`default void`	`copyTo(NDArray array)` Deep-copies the current `NDArray` to the one passed in.
`default NDArray`	`cos()` Returns the trigonometric cosine of this `NDArray` element-wise.
`default NDArray`	`cosh()` Returns the hyperbolic cosine of this `NDArray` element-wise.
`default NDArray`	`cumSum()` Returns the cumulative sum of the elements in the flattened `NDArray`.
`default NDArray`	`cumSum(int axis)` Return the cumulative sum of the elements along a given axis.
`default void`	`detach()` Detaches the `NDResource` from current `NDManager`'s lifecycle.
`default NDArray`	`div(NDArray other)` Divides this `NDArray` by the other `NDArray` element-wise.
`default NDArray`	`div(java.lang.Number n)` Divides this `NDArray` by a number element-wise.
`default NDArray`	`divi(NDArray other)` Divides this `NDArray` by the other `NDArray` element-wise in place.
`default NDArray`	`divi(java.lang.Number n)` Divides this `NDArray` by a number element-wise in place.
`default NDArray`	`dot(NDArray other)` Dot product of this `NDArray` and the other `NDArray`.
`default NDArray`	`eq(NDArray other)` Returns the boolean `NDArray` for element-wise "Equals" comparison.
`default NDArray`	`eq(java.lang.Number n)` Returns the boolean `NDArray` for element-wise "Equals" comparison.
`default NDArray`	`erfinv()` Returns element-wise inverse gauss error function of the `NDArray`.
`default NDArray`	`exp()` Returns the exponential value of this `NDArray` element-wise.
`default NDArray`	`expandDims(int axis)` Expands the `Shape` of a `NDArray`.
`default NDArray`	`flatten()` Flattens this `NDArray` into a 1-D `NDArray` in row-major order.
`default NDArray`	`flip(int... axes)` Returns the reverse order of elements in an array along the given axis.
`default NDArray`	`floor()` Returns the floor of this `NDArray` element-wise.
`default DataType`	`getDataType()` Returns the `DataType` of this `NDArray`.
`default Device`	`getDevice()` Returns the `Device` of this `NDArray`.
`default NDArray`	`getGradient()` Returns the gradient `NDArray` attached to this `NDArray`.
`default NDManager`	`getManager()` Returns the `NDManager` that manages this.
`default java.lang.String`	`getName()` Returns the name of this `NDArray`.
`default ai.djl.ndarray.internal.NDArrayEx`	`getNDArrayInternal()` Returns an internal representative of Native `NDArray`.
`default Shape`	`getShape()` Returns the `Shape` of this `NDArray`.
`default SparseFormat`	`getSparseFormat()` Returns the `SparseFormat` of this `NDArray`.
`default java.lang.String`	`getUid()` Returns unique identifier of this `NDArray`.
`default NDArray`	`gt(NDArray other)` Returns the boolean `NDArray` for element-wise "Greater Than" comparison.
`default NDArray`	`gt(java.lang.Number n)` Returns the boolean `NDArray` for element-wise "Greater" comparison.
`default NDArray`	`gte(NDArray other)` Returns the boolean `NDArray` for element-wise "Greater or equals" comparison.
`default NDArray`	`gte(java.lang.Number n)` Returns the boolean `NDArray` for element-wise "Greater or equals" comparison.
`default boolean`	`hasGradient()` Returns true if the gradient calculation is required for this `NDArray`.
`default void`	`intern(NDArray replaced)` Replace the handle of the NDArray with the other.
`default NDArray`	`isInfinite()` Returns the boolean `NDArray` with value `true` where this `NDArray`'s entries are infinite, or `false` where they are not infinite.
`default NDArray`	`isNaN()` Returns the boolean `NDArray` with value `true` where this `NDArray`'s entries are NaN, or `false` where they are not NaN.
`default NDArray`	`log()` Returns the natural logarithmic value of this `NDArray` element-wise.
`default NDArray`	`log10()` Returns the base 10 logarithm of this `NDArray` element-wise.
`default NDArray`	`log2()` Returns the base 2 logarithm of this `NDArray` element-wise.
`default NDArray`	`logicalAnd(NDArray other)` Returns the truth value of this `NDArray` AND the other `NDArray` element-wise.
`default NDArray`	`logicalNot()` Computes the truth value of NOT this `NDArray` element-wise.
`default NDArray`	`logicalOr(NDArray other)` Computes the truth value of this `NDArray` OR the other `NDArray` element-wise.
`default NDArray`	`logicalXor(NDArray other)` Computes the truth value of this `NDArray` XOR the other `NDArray` element-wise.
`default NDArray`	`logSoftmax(int axis)` Applies the softmax function followed by a logarithm.
`default NDArray`	`lt(NDArray other)` Returns the boolean `NDArray` for element-wise "Less" comparison.
`default NDArray`	`lt(java.lang.Number n)` Returns the boolean `NDArray` for element-wise "Less" comparison.
`default NDArray`	`lte(NDArray other)` Returns the boolean `NDArray` for element-wise "Less or equals" comparison.
`default NDArray`	`lte(java.lang.Number n)` Returns the boolean `NDArray` for element-wise "Less or equals" comparison.
`default NDArray`	`matMul(NDArray other)` Product matrix of this `NDArray` and the other `NDArray`.
`default NDArray`	`max()` Returns the maximum of this `NDArray`.
`default NDArray`	`max(int[] axes, boolean keepDims)` Returns the maximum of this `NDArray` along given axes.
`default NDArray`	`maximum(NDArray other)` Returns the maximum of this `NDArray` and the other `NDArray` element-wise.
`default NDArray`	`maximum(java.lang.Number n)` Returns the maximum of this `NDArray` and a number element-wise.
`default NDArray`	`mean()` Returns the average of this `NDArray`.
`default NDArray`	`mean(int[] axes, boolean keepDims)` Returns the average of this `NDArray` along given axes.
`default NDArray`	`median()` Returns median value for this `NDArray`.
`default NDArray`	`median(int[] axes)` Returns median value along given axes.
`default NDArray`	`min()` Returns the minimum of this `NDArray`.
`default NDArray`	`min(int[] axes, boolean keepDims)` Returns the minimum of this `NDArray` along given axes.
`default NDArray`	`minimum(NDArray other)` Returns the maximum of this `NDArray` and the other `NDArray` element-wise.
`default NDArray`	`minimum(java.lang.Number n)` Returns the minimum of this `NDArray` and a number element-wise.
`default NDArray`	`mod(NDArray other)` Returns element-wise remainder of division.
`default NDArray`	`mod(java.lang.Number n)` Returns element-wise remainder of division.
`default NDArray`	`modi(NDArray other)` Returns in place element-wise remainder of division in place.
`default NDArray`	`modi(java.lang.Number n)` Returns element-wise remainder of division in place.
`default NDArray`	`mul(NDArray other)` Multiplies this `NDArray` by other `NDArray`s element-wise.
`default NDArray`	`mul(java.lang.Number n)` Multiplies this `NDArray` by a number element-wise.
`default NDArray`	`muli(NDArray other)` Multiplies this `NDArray` by other `NDArray` element-wise in place.
`default NDArray`	`muli(java.lang.Number n)` Multiplies this `NDArray` by a number element-wise in place.
`default NDArray`	`neg()` Returns the numerical negative `NDArray` element-wise.
`default NDArray`	`negi()` Returns the numerical negative `NDArray` element-wise in place.
`default NDArray`	`neq(NDArray other)` Returns the boolean `NDArray` for element-wise "Not equals" comparison.
`default NDArray`	`neq(java.lang.Number n)` Returns the boolean `NDArray` for element-wise "Not equals" comparison.
`default NDArray`	`nonzero()` Returns the indices of elements that are non-zero.
`default NDArray`	`norm(boolean keepDims)` Returns the norm of this `NDArray`.
`default NDArray`	`norm(int ord, int[] axes, boolean keepDims)` Returns the norm of this `NDArray`.
`default NDArray`	`oneHot(int depth, float onValue, float offValue, DataType dataType)` Returns a one-hot `NDArray`.
`default NDArray`	`onesLike()` Returns an `NDArray` of ones with the same `Shape`, `DataType` and `SparseFormat` as the input `NDArray`.
`default NDArray`	`percentile(java.lang.Number percentile)` Returns percentile for this `NDArray`.
`default NDArray`	`percentile(java.lang.Number percentile, int[] axes)` Returns median along given dimension(s).
`default NDArray`	`pow(NDArray other)` Takes the power of this `NDArray` with the other `NDArray` element-wise.
`default NDArray`	`pow(java.lang.Number n)` Takes the power of this `NDArray` with a number element-wise.
`default NDArray`	`powi(NDArray other)` Takes the power of this `NDArray` with the other `NDArray` element-wise in place.
`default NDArray`	`powi(java.lang.Number n)` Takes the power of this `NDArray` with a number element-wise in place.
`default NDArray`	`prod()` Returns the product of this `NDArray`.
`default NDArray`	`prod(int[] axes, boolean keepDims)` Returns the product of this `NDArray` elements over the given axes.
`default NDArray`	`repeat(int axis, long repeats)` Repeats element of this `NDArray` the number of times given repeats along given axis.
`default NDArray`	`repeat(long repeats)` Repeats element of this `NDArray` the number of times given repeats.
`default NDArray`	`repeat(long[] repeats)` Repeats element of this `NDArray` the number of times given repeats along each axis.
`default NDArray`	`repeat(Shape desiredShape)` Repeats element of this `NDArray` to match the desired shape.
`default NDArray`	`reshape(Shape shape)` Reshapes this `NDArray` to the given `Shape`.
`default NDArray`	`rotate90(int times, int[] axes)` Rotates an array by 90 degrees in the plane specified by axes.
`default NDArray`	`round()` Returns the round of this `NDArray` element-wise.
`default NDArray`	`sequenceMask(NDArray sequenceLength)` Sets all elements outside the sequence to 0.
`default NDArray`	`sequenceMask(NDArray sequenceLength, float value)` Sets all elements outside the sequence to a constant value.
`default void`	`set(java.nio.Buffer data)` Sets this `NDArray` value from `Buffer`.
`default void`	`setName(java.lang.String name)` Sets name of this `NDArray`.
`default void`	`setRequiresGradient(boolean requiresGrad)` Attaches a gradient `NDArray` to this `NDArray` and marks it so `GradientCollector.backward(NDArray)` can compute the gradient with respect to it.
`default NDArray`	`sign()` Returns the element-wise sign.
`default NDArray`	`signi()` Returns the element-wise sign in-place.
`default NDArray`	`sin()` Returns the trigonometric sine of this `NDArray` element-wise.
`default NDArray`	`sinh()` Returns the hyperbolic sine of this `NDArray` element-wise.
`default NDArray`	`softmax(int axis)` Applies the softmax function along the given axis.
`default NDArray`	`sort()` Sorts the flattened `NDArray`.
`default NDArray`	`sort(int axis)` Sorts the flattened `NDArray`.
`default NDList`	`split(long[] indices, int axis)` Splits this `NDArray` into multiple sub-`NDArray`s given indices along given axis.
`default NDArray`	`sqrt()` Returns the square root of this `NDArray` element-wise.
`default NDArray`	`square()` Returns the square of this `NDArray` element-wise.
`default NDArray`	`squeeze(int[] axes)` Removes singleton dimensions at the given axes.
`default NDArray`	`stopGradient()` Returns an NDArray equal to this that stop gradient propagation through it.
`default NDArray`	`sub(NDArray other)` Subtracts the other `NDArray` from this `NDArray` element-wise.
`default NDArray`	`sub(java.lang.Number n)` Subtracts a number from this `NDArray` element-wise.
`default NDArray`	`subi(NDArray other)` Subtracts the other `NDArray` from this `NDArray` element-wise in place.
`default NDArray`	`subi(java.lang.Number n)` Subtracts a number from this `NDArray` element-wise in place.
`default NDArray`	`sum()` Returns the sum of this `NDArray`.
`default NDArray`	`sum(int[] axes, boolean keepDims)` Returns the sum of this `NDArray` along given axes.
`default NDArray`	`tan()` Returns the trigonometric tangent of this `NDArray` element-wise.
`default NDArray`	`tanh()` Returns the hyperbolic tangent of this `NDArray` element-wise.
`default NDArray`	`tile(int axis, long repeats)` Constructs a `NDArray` by repeating this `NDArray` the number of times given by repeats along given axis.
`default NDArray`	`tile(long repeats)` Constructs a `NDArray` by repeating this `NDArray` the number of times given repeats.
`default NDArray`	`tile(long[] repeats)` Constructs a `NDArray` by repeating this `NDArray` the number of times given by repeats.
`default NDArray`	`tile(Shape desiredShape)` Constructs a `NDArray` by repeating this `NDArray` the number of times to match the desired shape.
`default java.nio.ByteBuffer`	`toByteBuffer()` Converts this `NDArray` to a ByteBuffer.
`default NDArray`	`toDegrees()` Converts this `NDArray` from radians to degrees element-wise.
`default NDArray`	`toDense()` Returns a dense representation of the sparse `NDArray`.
`default NDArray`	`toDevice(Device device, boolean copy)` Moves this `NDArray` to a different `Device`.
`default NDArray`	`toRadians()` Converts this `NDArray` from degrees to radians element-wise.
`default NDArray`	`toSparse(SparseFormat fmt)` Returns a sparse representation of `NDArray`.
`default java.lang.String[]`	`toStringArray()` Converts this `NDArray` to a String array.
`default NDArray`	`toType(DataType dataType, boolean copy)` Converts this `NDArray` to a different `DataType`.
`default NDArray`	`trace(int offset, int axis1, int axis2)` Returns the sum along diagonals of this `NDArray`.
`default NDArray`	`transpose()` Returns this `NDArray` with axes transposed.
`default NDArray`	`transpose(int... axes)` Returns this `NDArray` with given axes transposed.
`default NDArray`	`trunc()` Returns the truncated value of this `NDArray` element-wise.
`default NDArray`	`zerosLike()` Returns an `NDArray` of zeros with the same `Shape`, `DataType` and `SparseFormat` as the input `NDArray`.

Methods inherited from interface ai.djl.ndarray.NDArray
all, allClose, allClose, any, argSort, argSort, booleanMask, broadcast, close, concat, concat, countNonzero, countNonzero, decode, duplicate, encode, get, get, get, get, getBoolean, getByte, getDouble, getFloat, getInt, getLong, getScalar, getUint8, isEmpty, isScalar, isSparse, like, max, mean, min, none, norm, norm, norm, oneHot, prod, reshape, scaleGradient, set, set, set, set, set, set, set, set, set, setScalar, shapeEquals, size, size, split, split, split, squeeze, squeeze, stack, stack, sum, swapAxes, toArray, toBooleanArray, toByteArray, toDebugString, toDoubleArray, toFloatArray, toIntArray, toLongArray, toUint8Array, trace, trace

Methods inherited from interface ai.djl.ndarray.NDResource
tempAttach

- Field Detail
  - UNSUPPORTED_MSG
```
static final java.lang.String UNSUPPORTED_MSG
```
    See Also:
    
    Constant Field Values
- Method Detail
  - getManager
```
default NDManager getManager()
```
    Returns the NDManager that manages this.
    
    Specified by:
    
    getManager in interface NDResource
    
    Returns:
    
    the NDManager that manages this.
  - getName
```
default java.lang.String getName()
```
    Returns the name of this NDArray.
    
    Specified by:
    
    getName in interface NDArray
    
    Returns:
    
    the name of this NDArray
  - setName
```
default void setName(java.lang.String name)
```
    Sets name of this NDArray.
    
    Specified by:
    
    setName in interface NDArray
    
    Parameters:
    
    name - the name of this NDArray
  - getUid
```
default java.lang.String getUid()
```
    Returns unique identifier of this NDArray.
    
    Specified by:
    
    getUid in interface NDArray
    
    Returns:
    
    unique identifier of this NDArray
  - getDataType
```
default DataType getDataType()
```
    Returns the DataType of this NDArray.
    DataType is a definition of the precision level of the NDArray. All values inside the same NDArray would have the same DataType.
    
    Specified by:
    
    getDataType in interface NDArray
    
    Returns:
    
    the DataType of this NDArray
  - getDevice
```
default Device getDevice()
```
    Returns the Device of this NDArray.
    Device class contains the information where this NDArray stored in memory, like CPU/GPU.
    
    Specified by:
    
    getDevice in interface NDArray
    
    Returns:
    
    the Device of this NDArray
  - getShape
```
default Shape getShape()
```
    Returns the Shape of this NDArray.
    Shape defines how this NDArray is represented multi-dimensionally.
    
    Specified by:
    
    getShape in interface NDArray
    
    Returns:
    
    the Shape of this NDArray
  - getSparseFormat
```
default SparseFormat getSparseFormat()
```
    Returns the SparseFormat of this NDArray.
    
    Specified by:
    
    getSparseFormat in interface NDArray
    
    Returns:
    
    the SparseFormat of this NDArray
  - attach
```
default void attach(NDManager manager)
```
    Attaches this NDResource to the specified NDManager.
    Attached resource will be closed when the NDManager is closed.
    
    Specified by:
    
    attach in interface NDResource
    
    Parameters:
    
    manager - the NDManager to be attached to
  - detach
```
default void detach()
```
    Detaches the NDResource from current NDManager's lifecycle.
    This becomes un-managed and it is the user's responsibility to close this. Failure to close the resource might cause your machine to run out of native memory.
    
    Specified by:
    
    detach in interface NDResource
    
    See Also:
    
    NDManager
  - toDevice
```
default NDArray toDevice(Device device,
                         boolean copy)
```
    Moves this NDArray to a different Device.
    
    Specified by:
    
    toDevice in interface NDArray
    
    Parameters:
    
    device - the Device to be set
    
    copy - set true if you want to return a copy of the Existing NDArray
    
    Returns:
    
    the result NDArray with the new Device
  - toType
```
default NDArray toType(DataType dataType,
                       boolean copy)
```
    Converts this NDArray to a different DataType.
    
    Specified by:
    
    toType in interface NDArray
    
    Parameters:
    
    dataType - the DataType to be set
    
    copy - set true if you want to return a copy of the Existing NDArray
    
    Returns:
    
    the result NDArray with the new DataType
  - setRequiresGradient
```
default void setRequiresGradient(boolean requiresGrad)
```
    Attaches a gradient NDArray to this NDArray and marks it so GradientCollector.backward(NDArray) can compute the gradient with respect to it.
    
    Specified by:
    
    setRequiresGradient in interface NDArray
    
    Parameters:
    
    requiresGrad - if NDArray requires gradient or not
  - getGradient
```
default NDArray getGradient()
```
    Returns the gradient NDArray attached to this NDArray.
    
    Specified by:
    
    getGradient in interface NDArray
    
    Returns:
    
    the gradient NDArray
  - hasGradient
```
default boolean hasGradient()
```
    Returns true if the gradient calculation is required for this NDArray.
    
    Specified by:
    
    hasGradient in interface NDArray
    
    Returns:
    
    true if the gradient calculation is required for this NDArray else false
  - stopGradient
```
default NDArray stopGradient()
```
    Returns an NDArray equal to this that stop gradient propagation through it.
    
    Specified by:
    
    stopGradient in interface NDArray
    
    Returns:
    
    an NDArray equal to this that stops gradient propagation through it
  - toStringArray
```
default java.lang.String[] toStringArray()
```
    Converts this NDArray to a String array.
    This method is only applicable to the String typed NDArray and not for printing purpose
    
    Specified by:
    
    toStringArray in interface NDArray
    
    Returns:
    
    Array of Strings
  - toByteBuffer
```
default java.nio.ByteBuffer toByteBuffer()
```
    Converts this NDArray to a ByteBuffer.
    
    Specified by:
    
    toByteBuffer in interface NDArray
    
    Returns:
    
    a ByteBuffer
  - set
```
default void set(java.nio.Buffer data)
```
    Sets this NDArray value from Buffer.
    
    Specified by:
    
    set in interface NDArray
    
    Parameters:
    
    data - the input buffered data
  - copyTo
```
default void copyTo(NDArray array)
```
    Deep-copies the current NDArray to the one passed in.
    
    Specified by:
    
    copyTo in interface NDArray
    
    Parameters:
    
    array - this NDArray prepared to be copied to
  - booleanMask
```
default NDArray booleanMask(NDArray index,
                            int axis)
```
    Returns portion of this NDArray given the index boolean NDArray along given axis.
    
    Specified by:
    
    booleanMask in interface NDArray
    
    Parameters:
    
    index - boolean NDArray mask
    
    axis - an integer that represents the axis of NDArray to mask from
    
    Returns:
    
    the result NDArray
  - sequenceMask
```
default NDArray sequenceMask(NDArray sequenceLength,
                             float value)
```
    Sets all elements outside the sequence to a constant value.
    This function takes an n-dimensional input array of the form [batch_size, max_sequence_length, ....] and returns an array of the same shape. Parameter sequenceLength is used to handle variable-length sequences. sequence_length should be an input array of positive ints of dimension [batch_size].
    
    Specified by:
    
    sequenceMask in interface NDArray
    
    Parameters:
    
    sequenceLength - used to handle variable-length sequences
    
    value - the constant value to be set
    
    Returns:
    
    the result NDArray
  - sequenceMask
```
default NDArray sequenceMask(NDArray sequenceLength)
```
    Sets all elements outside the sequence to 0.
    This function takes an n-dimensional input array of the form [batch_size, max_sequence_length, ....] and returns an array of the same shape. Parameter sequenceLength is used to handle variable-length sequences. sequence_length should be an input array of positive ints of dimension [batch_size].
    
    Specified by:
    
    sequenceMask in interface NDArray
    
    Parameters:
    
    sequenceLength - used to handle variable-length sequences
    
    Returns:
    
    the result NDArray
  - zerosLike
```
default NDArray zerosLike()
```
    Returns an NDArray of zeros with the same Shape, DataType and SparseFormat as the input NDArray.
    Examples
```
 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.zerosLike();
 ND: (2, 3) cpu() float32
 [[0., 0., 0.],
  [0., 0., 0.],
 ]
 
```
    Specified by:
    
    zerosLike in interface NDArray
    
    Returns:
    
    a NDArray filled with zeros
  - onesLike
```
default NDArray onesLike()
```
    Returns an NDArray of ones with the same Shape, DataType and SparseFormat as the input NDArray.
    Examples
```
 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.onesLike();
 ND: (2, 3) cpu() float32
 [[1., 1., 1.],
  [1., 1., 1.],
 ]
 
```
    Specified by:
    
    onesLike in interface NDArray
    
    Returns:
    
    a NDArray filled with ones
  - contentEquals
```
default boolean contentEquals(java.lang.Number number)
```
    Returns true if all elements in this NDArray are equal to the Number.
    Examples
```
 jshell> NDArray array = manager.ones(new Shape(2, 3));
 jshell> array.contentEquals(1); // return true instead of boolean NDArray
 true
 
```
    Specified by:
    
    contentEquals in interface NDArray
    
    Parameters:
    
    number - the number to compare
    
    Returns:
    
    the boolean result
  - contentEquals
```
default boolean contentEquals(NDArray other)
```
    Returns true if all elements in this NDArray are equal to the other NDArray.
    Examples
```
 jshell> NDArray array1 = manager.arange(6f).reshape(2, 3);
 jshell> NDArray array2 = manager.create(new float[] {0f, 1f, 2f, 3f, 4f, 5f}, new Shape(2, 3));
 jshell> array1.contentEquals(array2); // return true instead of boolean NDArray
 true
 
```
    Specified by:
    
    contentEquals in interface NDArray
    
    Parameters:
    
    other - the other NDArray to compare
    
    Returns:
    
    the boolean result
  - eq
```
default NDArray eq(java.lang.Number n)
```
    Returns the boolean NDArray for element-wise "Equals" comparison.
    Examples
```
 jshell> NDArray array = manager.ones(new Shape(1));
 jshell> array.eq(1);
 ND: (1) cpu() boolean
 [ true]
 
```
    Specified by:
    
    eq in interface NDArray
    
    Parameters:
    
    n - the number to compare
    
    Returns:
    
    the boolean NDArray for element-wise "Equals" comparison
  - eq
```
default NDArray eq(NDArray other)
```
    Returns the boolean NDArray for element-wise "Equals" comparison.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {0f, 1f, 3f});
 jshell> NDArray array2 = manager.arange(3f);
 jshell> array1.eq(array2);
 ND: (3) cpu() boolean
 [ true,  true, false]
 
```
    Specified by:
    
    eq in interface NDArray
    
    Parameters:
    
    other - the NDArray to compare
    
    Returns:
    
    the boolean NDArray for element-wise "Equals" comparison
  - neq
```
default NDArray neq(java.lang.Number n)
```
    Returns the boolean NDArray for element-wise "Not equals" comparison.
    Examples
```
 jshell> NDArray array = manager.arange(4f).reshape(2, 2);
 jshell> array.neq(1);
 ND: (2, 2) cpu() boolean
 [[ true, false],
  [ true,  true],
 ]
 
```
    Specified by:
    
    neq in interface NDArray
    
    Parameters:
    
    n - the number to compare
    
    Returns:
    
    the boolean NDArray for element-wise "Not equals" comparison
  - neq
```
default NDArray neq(NDArray other)
```
    Returns the boolean NDArray for element-wise "Not equals" comparison.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {1f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {1f, 3f});
 jshell> array1.neq(array2);
 ND: (2) cpu() boolean
 [false,  true]
 jshell> NDArray array1 = manager.create(new float[] {1f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {1f, 3f, 1f, 4f}, new Shape(2, 2));
 jshell> array1.neq(array2); // broadcasting
 ND: (2, 2) cpu() boolean
 [[false,  true],
  [false,  true],
 ]
 
```
    Specified by:
    
    neq in interface NDArray
    
    Parameters:
    
    other - the NDArray to compare
    
    Returns:
    
    the boolean NDArray for element-wise "Not equals" comparison
  - gt
```
default NDArray gt(java.lang.Number n)
```
    Returns the boolean NDArray for element-wise "Greater" comparison.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {4f, 2f});
 jshell> array.gt(2f);
 ND: (2) cpu() boolean
 [ true, false]
 
```
    Specified by:
    
    gt in interface NDArray
    
    Parameters:
    
    n - the number to compare
    
    Returns:
    
    the boolean NDArray for element-wise "Greater" comparison
  - gt
```
default NDArray gt(NDArray other)
```
    Returns the boolean NDArray for element-wise "Greater Than" comparison.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {4f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 2f});
 jshell> array1.neq(array2);
 ND: (2) cpu() boolean
 [ true, false]
 
```
    Specified by:
    
    gt in interface NDArray
    
    Parameters:
    
    other - the NDArray to compare
    
    Returns:
    
    the boolean NDArray for element-wis "Greater Than" comparison
  - gte
```
default NDArray gte(java.lang.Number n)
```
    Returns the boolean NDArray for element-wise "Greater or equals" comparison.
```
 jshell> NDArray array = manager.create(new float[] {4f, 2f});
 jshell> array.gte(2f);
 ND: (2) cpu() boolean
 [ true, true]
 
```
    Specified by:
    
    gte in interface NDArray
    
    Parameters:
    
    n - the number to compare
    
    Returns:
    
    the boolean NDArray for element-wise "Greater or equals" comparison
  - gte
```
default NDArray gte(NDArray other)
```
    Returns the boolean NDArray for element-wise "Greater or equals" comparison.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {4f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 2f});
 jshell> array1.gte(array2);
 ND: (2) cpu() boolean
 [ true, true]
 
```
    Specified by:
    
    gte in interface NDArray
    
    Parameters:
    
    other - the number to compare
    
    Returns:
    
    the boolean NDArray for "Greater or equals" comparison
  - lt
```
default NDArray lt(java.lang.Number n)
```
    Returns the boolean NDArray for element-wise "Less" comparison.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array.lt(2f);
 ND: (2) cpu() boolean
 [ true, false]
 
```
    Specified by:
    
    lt in interface NDArray
    
    Parameters:
    
    n - the number to compare
    
    Returns:
    
    the boolean NDArray for element-wise "Less" comparison
  - lt
```
default NDArray lt(NDArray other)
```
    Returns the boolean NDArray for element-wise "Less" comparison.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {1f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 2f});
 jshell> array1.lt(array2);
 ND: (2) cpu() boolean
 [ true, false]
 
```
    Specified by:
    
    lt in interface NDArray
    
    Parameters:
    
    other - the NDArray to compare
    
    Returns:
    
    the boolean NDArray for element-wise "Less" comparison
  - lte
```
default NDArray lte(java.lang.Number n)
```
    Returns the boolean NDArray for element-wise "Less or equals" comparison.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array.lte(2f);
 ND: (2) cpu() boolean
 [ true, true]
 
```
    Specified by:
    
    lte in interface NDArray
    
    Parameters:
    
    n - the number to compare
    
    Returns:
    
    the boolean NDArray for element-wise "Less or equals" comparison
  - lte
```
default NDArray lte(NDArray other)
```
    Returns the boolean NDArray for element-wise "Less or equals" comparison.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {1f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 2f});
 jshell> array1.lte(array2);
 ND: (2) cpu() boolean
 [ true, true]
 
```
    Specified by:
    
    lte in interface NDArray
    
    Parameters:
    
    other - the NDArray to compare
    
    Returns:
    
    the boolean NDArray for element-wise "Less or equals" comparison
  - add
```
default NDArray add(java.lang.Number n)
```
    Adds a number to this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array.add(2f);
 ND: (2) cpu() float32
 [3., 4.]
 
```
    Specified by:
    
    add in interface NDArray
    
    Parameters:
    
    n - the number to add
    
    Returns:
    
    the result NDArray
  - add
```
default NDArray add(NDArray other)
```
    Adds other NDArrays to this NDArray element-wise.
    The shapes of this NDArray and other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.arange(3f);
 jshell> array1.add(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[ 0.,  2.,  4.],
  [ 3.,  5.,  7.],
  [ 6.,  8., 10.],
 ]
 
```
    Specified by:
    
    add in interface NDArray
    
    Parameters:
    
    other - the other NDArrays to add
    
    Returns:
    
    the result NDArray
  - sub
```
default NDArray sub(java.lang.Number n)
```
    Subtracts a number from this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array.sub(2f);
 ND: (2) cpu() float32
 [-1.,  0.]
 
```
    Specified by:
    
    sub in interface NDArray
    
    Parameters:
    
    n - the number to subtract from
    
    Returns:
    
    the result NDArray
  - sub
```
default NDArray sub(NDArray other)
```
    Subtracts the other NDArray from this NDArray element-wise.
    The shapes of this NDArray and other NDArrays must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.arange(9).reshape(3, 3);
 jshell> NDArray array2 = manager.arange(3);
 jshell> array1.sub(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[0., 0., 0.],
  [3., 3., 3.],
  [6., 6., 6.],
 ]
 
```
    Specified by:
    
    sub in interface NDArray
    
    Parameters:
    
    other - the other NDArray to subtract from
    
    Returns:
    
    the result NDArray
  - mul
```
default NDArray mul(java.lang.Number n)
```
    Multiplies this NDArray by a number element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array.mul(3f);
 ND: (2) cpu() float32
 [3., 6.]
 
```
    Specified by:
    
    mul in interface NDArray
    
    Parameters:
    
    n - the number to multiply by
    
    Returns:
    
    the result NDArray
  - mul
```
default NDArray mul(NDArray other)
```
    Multiplies this NDArray by other NDArrays element-wise.
    The shapes of this NDArray and other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.arange(3f);
 jshell> array1.mul(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[ 0.,  1.,  4.],
  [ 0.,  4., 10.],
  [ 0.,  7., 16.],
 ]
 
```
    Specified by:
    
    mul in interface NDArray
    
    Parameters:
    
    other - the other NDArrays to multiply by
    
    Returns:
    
    the result NDArray
  - div
```
default NDArray div(java.lang.Number n)
```
    Divides this NDArray by a number element-wise.
    Examples
```
 jshell> NDArray array = manager.arange(5f);
 jshell> array.div(4f);
 ND: (5) cpu() float32
 [0.  , 0.25, 0.5 , 0.75, 1.  ]
 
```
    Specified by:
    
    div in interface NDArray
    
    Parameters:
    
    n - the number to divide by
    
    Returns:
    
    the result NDArray
  - div
```
default NDArray div(NDArray other)
```
    Divides this NDArray by the other NDArray element-wise.
    The shapes of this NDArray and the other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.ones(new Shape(3)).mul(10);
 jshell> array1.div(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[0. , 0.1, 0.2],
  [0.3, 0.4, 0.5],
  [0.6, 0.7, 0.8],
 ]
 
```
    Specified by:
    
    div in interface NDArray
    
    Parameters:
    
    other - the other NDArray to divide by
    
    Returns:
    
    the result NDArray
  - mod
```
default NDArray mod(java.lang.Number n)
```
    Returns element-wise remainder of division.
    Examples
```
 jshell> NDArray array = manager.arange(7f);
 jshell> array.mod(5f);
 ND: (7) cpu() float32
 [0., 1., 2., 3., 4., 0., 1.]
 
```
    Specified by:
    
    mod in interface NDArray
    
    Parameters:
    
    n - the divisor number
    
    Returns:
    
    the result NDArray
  - mod
```
default NDArray mod(NDArray other)
```
    Returns element-wise remainder of division.
    The shapes of this NDArray and the other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {4f, 7f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 3f});
 jshell> array1.mod(array2);
 ND: (2) cpu() float32
 [0., 1.]
 
```
    Specified by:
    
    mod in interface NDArray
    
    Parameters:
    
    other - the divisor NDArray
    
    Returns:
    
    the result NDArray
  - pow
```
default NDArray pow(java.lang.Number n)
```
    Takes the power of this NDArray with a number element-wise.
    Examples
```
 jshell> NDArray array = manager.arange(5f);
 jshell> array.pow(4f);
 ND: (6) cpu() float32
 [  0.,   1.,   8.,  27.,  64., 125.]
 
```
    Specified by:
    
    pow in interface NDArray
    
    Parameters:
    
    n - the number to take the power with
    
    Returns:
    
    the result NDArray
  - pow
```
default NDArray pow(NDArray other)
```
    Takes the power of this NDArray with the other NDArray element-wise.
    Examples
```
 jshell> NDArray array1 = manager.arange(6f).reshape(3, 2);
 jshell> NDArray array2 = manager.create(new float[] {2f, 3f});
 jshell> array1.pow(array2); // broadcasting
 ND: (3, 2) cpu() float32
 [[  0.,   1.],
  [  4.,  27.],
  [ 16., 125.],
 ]
 
```
    Specified by:
    
    pow in interface NDArray
    
    Parameters:
    
    other - the other NDArray to take the power with
    
    Returns:
    
    the result NDArray
  - addi
```
default NDArray addi(java.lang.Number n)
```
    Adds a number to this NDArray element-wise in place.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array.addi(2f);
 ND: (2) cpu() float32
 [3., 4.]
 jshell> array;
 ND: (2) cpu() float32
 [3., 4.]
 
```
    Specified by:
    
    addi in interface NDArray
    
    Parameters:
    
    n - the number to add
    
    Returns:
    
    the result NDArray
  - addi
```
default NDArray addi(NDArray other)
```
    Adds other NDArrays to this NDArray element-wise in place.
    The shapes of this NDArray and other NDArrays must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {1f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {3f, 4f});
 jshell> array1.addi(array2);
 ND: (2) cpu() float32
 [4., 6.]
 jshell> array;
 ND: (2) cpu() float32
 [4., 6.]
 
```
    Specified by:
    
    addi in interface NDArray
    
    Parameters:
    
    other - the other NDArrays to add
    
    Returns:
    
    the result NDArray
  - subi
```
default NDArray subi(java.lang.Number n)
```
    Subtracts a number from this NDArray element-wise in place.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array.subi(2f);
 ND: (2) cpu() float32
 [-1.,  0.]
 jshell> array;
 ND: (2) cpu() float32
 [-1.,  0.]
 
```
    Specified by:
    
    subi in interface NDArray
    
    Parameters:
    
    n - the number to subtract
    
    Returns:
    
    the result NDArray
  - subi
```
default NDArray subi(NDArray other)
```
    Subtracts the other NDArray from this NDArray element-wise in place.
    The shapes of this NDArray and other NDArrays must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.arange(3f);
 jshell> array1.subi(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[0., 0., 0.],
  [3., 3., 3.],
  [6., 6., 6.],
 ]
 jshell> array1;
 [[0., 0., 0.],
  [3., 3., 3.],
  [6., 6., 6.],
 ]
 
```
    Specified by:
    
    subi in interface NDArray
    
    Parameters:
    
    other - the other NDArray to subtract from
    
    Returns:
    
    the result NDArray
  - muli
```
default NDArray muli(java.lang.Number n)
```
    Multiplies this NDArray by a number element-wise in place.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array.muli(3f);
 ND: (2) cpu() float32
 [3., 6.]
 jshell> array;
 ND: (2) cpu() float32
 [3., 6.]
 
```
    Specified by:
    
    muli in interface NDArray
    
    Parameters:
    
    n - the number to multiply by
    
    Returns:
    
    the result NDArray
  - muli
```
default NDArray muli(NDArray other)
```
    Multiplies this NDArray by other NDArray element-wise in place.
    The shapes of this NDArray and other NDArrays must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.arange(3f);
 jshell> array1.muli(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[ 0.,  1.,  4.],
  [ 0.,  4., 10.],
  [ 0.,  7., 16.],
 ]
 jshell> array1;
 ND: (3, 3) cpu() float32
 [[ 0.,  1.,  4.],
  [ 0.,  4., 10.],
  [ 0.,  7., 16.],
 ]
 
```
    Specified by:
    
    muli in interface NDArray
    
    Parameters:
    
    other - the other NDArrays to multiply with
    
    Returns:
    
    the result NDArray
  - divi
```
default NDArray divi(java.lang.Number n)
```
    Divides this NDArray by a number element-wise in place.
    Examples
```
 jshell> NDArray array = manager.arange(5f);
 jshell> array.divi(4f);
 ND: (5) cpu() float32
 [0.  , 0.25, 0.5 , 0.75, 1.  ]
 jshell> array;
 ND: (5) cpu() float32
 [0.  , 0.25, 0.5 , 0.75, 1.  ]
 
```
    Specified by:
    
    divi in interface NDArray
    
    Parameters:
    
    n - the number to divide values by
    
    Returns:
    
    the array after applying division operation
  - divi
```
default NDArray divi(NDArray other)
```
    Divides this NDArray by the other NDArray element-wise in place.
    The shapes of this NDArray and the other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.ones(new Shape(3)).mul(10);
 jshell> array1.divi(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[0. , 0.1, 0.2],
  [0.3, 0.4, 0.5],
  [0.6, 0.7, 0.8],
 ]
 jshell> array1;
 [[0. , 0.1, 0.2],
  [0.3, 0.4, 0.5],
  [0.6, 0.7, 0.8],
 ]
 
```
    Specified by:
    
    divi in interface NDArray
    
    Parameters:
    
    other - the other NDArray to divide by
    
    Returns:
    
    the result of the divide
  - modi
```
default NDArray modi(java.lang.Number n)
```
    Returns element-wise remainder of division in place.
    Examples
```
 jshell> NDArray array = manager.arange(7f);
 jshell> array.modi(5f);
 ND: (7) cpu() float32
 [0., 1., 2., 3., 4., 0., 1.]
 jshell> array;
 ND: (7) cpu() float32
 [0., 1., 2., 3., 4., 0., 1.]
 
```
    Specified by:
    
    modi in interface NDArray
    
    Parameters:
    
    n - the divisor number
    
    Returns:
    
    the result NDArray
  - modi
```
default NDArray modi(NDArray other)
```
    Returns in place element-wise remainder of division in place.
    The shapes of this NDArray and the other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {4f, 7f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 3f});
 jshell> array1.modi(array2);
 ND: (2) cpu() float32
 [0., 1.]
 jshell> array1;
 ND: (2) cpu() float32
 [0., 1.]
 
```
    Specified by:
    
    modi in interface NDArray
    
    Parameters:
    
    other - the divisor NDArray
    
    Returns:
    
    the result of the divide
  - powi
```
default NDArray powi(java.lang.Number n)
```
    Takes the power of this NDArray with a number element-wise in place.
    Examples
```
 jshell> NDArray array = manager.arange(5f);
 jshell> array.powi(4f);
 ND: (6) cpu() float32
 [  0.,   1.,   8.,  27.,  64., 125.]
 jshell> array;
 ND: (6) cpu() float32
 [  0.,   1.,   8.,  27.,  64., 125.]
 
```
    Specified by:
    
    powi in interface NDArray
    
    Parameters:
    
    n - the number to raise the power to
    
    Returns:
    
    the result NDArray
  - powi
```
default NDArray powi(NDArray other)
```
    Takes the power of this NDArray with the other NDArray element-wise in place.
    The shapes of this NDArray and the other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.arange(6f).reshape(3, 2);
 jshell> NDArray array2 = manager.create(new float[] {2f, 3f});
 jshell> array1.powi(array2); // broadcasting
 ND: (3, 2) cpu() float32
 [[  0.,   1.],
  [  4.,  27.],
  [ 16., 125.],
 ]
 jshell> array1;
 ND: (3, 2) cpu() float32
 [[  0.,   1.],
  [  4.,  27.],
  [ 16., 125.],
 ]
 
```
    Specified by:
    
    powi in interface NDArray
    
    Parameters:
    
    other - the other NDArray to take the power with
    
    Returns:
    
    the result NDArray
  - sign
```
default NDArray sign()
```
    Returns the element-wise sign.
    
    Specified by:
    
    sign in interface NDArray
    
    Returns:
    
    the result NDArray
  - signi
```
default NDArray signi()
```
    Returns the element-wise sign in-place.
    
    Specified by:
    
    signi in interface NDArray
    
    Returns:
    
    the result NDArray
  - maximum
```
default NDArray maximum(java.lang.Number n)
```
    Returns the maximum of this NDArray and a number element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {2f, 3f, 4f});
 jshell> array.maximum(3f);
 ND: (3) cpu() float32
 [3., 3., 4.]
 
```
    Specified by:
    
    maximum in interface NDArray
    
    Parameters:
    
    n - the number to be compared
    
    Returns:
    
    the maximum of this NDArray and a number element-wise
  - maximum
```
default NDArray maximum(NDArray other)
```
    Returns the maximum of this NDArray and the other NDArray element-wise.
    The shapes of this NDArray and the other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {2f, 3f, 4f});
 jshell> NDArray array2 = manager.create(new float[] {1f, 5f, 2f});
 jshell> array1.maximum(array2);
 ND: (3) cpu() float32
 [2., 5., 4.]
 jshell> NDArray array1 = manager.eye(2);
 jshell> NDArray array2 = manager.create(new float[] {0.5f, 2f});
 jshell> array1.maximum(array2); // broadcasting
 ND: (2, 2) cpu() float32
 [[1. , 2. ],
  [0.5, 2. ],
 ]
 
```
    Specified by:
    
    maximum in interface NDArray
    
    Parameters:
    
    other - the NDArray to be compared
    
    Returns:
    
    the maximum of this NDArray and the other NDArray element-wise
  - minimum
```
default NDArray minimum(java.lang.Number n)
```
    Returns the minimum of this NDArray and a number element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {2f, 3f, 4f});
 jshell> array.minimum(3f);
 ND: (3) cpu() float32
 [2., 3., 3.]
 
```
    Specified by:
    
    minimum in interface NDArray
    
    Parameters:
    
    n - the number to be compared
    
    Returns:
    
    the minimum of this NDArray and a number element-wise
  - minimum
```
default NDArray minimum(NDArray other)
```
    Returns the maximum of this NDArray and the other NDArray element-wise.
    The shapes of this NDArray and the other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {2f, 3f, 4f});
 jshell> NDArray array2 = manager.create(new float[] {1f, 5f, 2f});
 jshell> array1.minimum(array2);
 ND: (3) cpu() float32
 [1., 3., 2.]
 jshell> NDArray array1 = manager.eye(2);
 jshell> NDArray array2 = manager.create(new float[] {0.5f, 2f});
 jshell> array1.minimum(array2); // broadcasting
 ND: (2, 2) cpu() float32
 [[0.5, 0. ],
  [0. , 1. ],
 ]
 
```
    Specified by:
    
    minimum in interface NDArray
    
    Parameters:
    
    other - the NDArray to be compared
    
    Returns:
    
    the maximum of this NDArray and the other NDArray element-wise
  - neg
```
default NDArray neg()
```
    Returns the numerical negative NDArray element-wise.
```
 jshell> NDArray array = manager.arange(5f);
 jshell> array.neg();
 ND: (5) cpu() float32
 [-0., -1., -2., -3., -4.]
 
```
    Specified by:
    
    neg in interface NDArray
    
    Returns:
    
    the result NDArray
  - negi
```
default NDArray negi()
```
    Returns the numerical negative NDArray element-wise in place.
```
 jshell> NDArray array = manager.arange(5f);
 jshell> array.negi();
 jshell> array;
 ND: (5) cpu() float32
 [-0., -1., -2., -3., -4.]
 
```
    Specified by:
    
    negi in interface NDArray
    
    Returns:
    
    the result NDArray
  - abs
```
default NDArray abs()
```
    Returns the absolute value of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {-1f, -2f});
 jshell> array.abs();
 ND: (2) cpu() float32
 [1., 2.]
 
```
    Specified by:
    
    abs in interface NDArray
    
    Returns:
    
    the result NDArray
  - square
```
default NDArray square()
```
    Returns the square of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {2f, -3f});
 jshell> array.square();
 ND: (2) cpu() float32
 [4., 9.]
 
```
    Specified by:
    
    square in interface NDArray
    
    Returns:
    
    the result NDArray
  - sqrt
```
default NDArray sqrt()
```
    Returns the square root of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {4f});
 jshell> array.sqrt();
 ND: (1) cpu() float32
 [2., ]
 
```
    Specified by:
    
    sqrt in interface NDArray
    
    Returns:
    
    the result NDArray
  - cbrt
```
default NDArray cbrt()
```
    Returns the cube-root of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 8f, 27f});
 jshell> array.cbrt();
 ND: (3) cpu() float32
 [1., 2., 3.]
 
```
    Specified by:
    
    cbrt in interface NDArray
    
    Returns:
    
    the result NDArray
  - floor
```
default NDArray floor()
```
    Returns the floor of this NDArray element-wise.
    The floor of the scalar x is the largest integer i, such that i <= x.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {-1.7f, -1.5f, -0.2f, 0.2f, 1.5f, 1.7f, 2.0f});
 jshell> array.floor();
 ND: (7) cpu() float32
 [-2., -2., -1.,  0.,  1.,  1.,  2.]
 
```
    Specified by:
    
    floor in interface NDArray
    
    Returns:
    
    the result NDArray
  - ceil
```
default NDArray ceil()
```
    Returns the ceiling of this NDArray element-wise.
    The ceil of the scalar x is the smallest integer i, such that i >= x.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {-1.7f, -1.5f, -0.2f, 0.2f, 1.5f, 1.7f, 2.0f});
 jshell> array.ceil();
 ND: (7) cpu() float32
 [-1., -1., -0.,  1.,  2.,  2.,  2.]
 
```
    Specified by:
    
    ceil in interface NDArray
    
    Returns:
    
    the result NDArray
  - round
```
default NDArray round()
```
    Returns the round of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {-1.7f, -1.5f, -0.2f, 0.2f, 1.5f, 1.7f, 2.0f});
 jshell> array.round();
 ND: (7) cpu() float32
 [-2., -2., -0.,  0.,  2.,  2.,  2.]
 
```
    Specified by:
    
    round in interface NDArray
    
    Returns:
    
    the result NDArray
  - trunc
```
default NDArray trunc()
```
    Returns the truncated value of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {-1.7f, -1.5f, -0.2f, 0.2f, 1.5f, 1.7f, 2.0f});
 jshell> array.trunc();
 ND: (7) cpu() float32
 [-1., -1., -0.,  0.,  1.,  1.,  2.]
 
```
    Specified by:
    
    trunc in interface NDArray
    
    Returns:
    
    the result NDArray
  - exp
```
default NDArray exp()
```
    Returns the exponential value of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 2.5f});
 jshell> array.exp();
 ND: (2) cpu() float32
 [ 1.    , 12.1825]
 
```
    Specified by:
    
    exp in interface NDArray
    
    Returns:
    
    the result NDArray
  - log
```
default NDArray log()
```
    Returns the natural logarithmic value of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 2.5f});
 jshell> array.log();
 ND: (2) cpu() float32
 [  -inf, 0.9163]
 
```
    Specified by:
    
    log in interface NDArray
    
    Returns:
    
    the result NDArray
  - log10
```
default NDArray log10()
```
    Returns the base 10 logarithm of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1000f, 1f, 150f});
 jshell> array.log10();
 ND: (3) cpu() float32
 [3.    , 0.    , 2.1761]
 
```
    Specified by:
    
    log10 in interface NDArray
    
    Returns:
    
    the result NDArray
  - log2
```
default NDArray log2()
```
    Returns the base 2 logarithm of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {8, 1f, 5f});
 jshell> array.log2();
 ND: (3) cpu() float32
 [3.    , 0.    , 2.3219]
 
```
    Specified by:
    
    log2 in interface NDArray
    
    Returns:
    
    the result NDArray
  - sin
```
default NDArray sin()
```
    Returns the trigonometric sine of this NDArray element-wise.
    The input should be in radians (2 Pi radians equals 360 degrees).
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 30f, 45f, 60f, 90f});
 jshell> array = array.mul(Math.PI).div(180f);
 jshell> array.sin();
 ND: (5) cpu() float32
 [0.    , 0.5   , 0.7071, 0.866 , 1.    ]
 
```
    Specified by:
    
    sin in interface NDArray
    
    Returns:
    
    the result NDArray
  - cos
```
default NDArray cos()
```
    Returns the trigonometric cosine of this NDArray element-wise.
    The input should be in radians (2 Pi radians equals 360 degrees).
    Examples
```
 jshell> NDArray array = manager.create(new double[] {0, Math.PI/2, Math.PI});
 jshell> array.cos();
 ND: (3) cpu() float64
 [  1.0000000e+00,   6.1232340e-17,  -1.0000000e+00],
 
```
    Specified by:
    
    cos in interface NDArray
    
    Returns:
    
    the result NDArray
  - tan
```
default NDArray tan()
```
    Returns the trigonometric tangent of this NDArray element-wise.
    The input should be in radians (2 Pi radians equals 360 degrees).
    Examples
```
 jshell> NDArray array = manager.create(new double[] {-Math.PI, Math.PI/2, Math.PI});
 jshell> array.tan();
 ND: (3) cpu() float64
 [  1.2246468e-16,   1.6331239e+16,  -1.2246468e-16],
 
```
    Specified by:
    
    tan in interface NDArray
    
    Returns:
    
    the result NDArray
  - asin
```
default NDArray asin()
```
    Returns the inverse trigonometric sine of this NDArray element-wise.
    The input should be in the range [-1, 1]. The output is in the closed interval of [-Pi/2, Pi/2].
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, -1f, 0f});
 jshell> array.asin();
 ND: (3) cpu() float64
 [ 1.5708, -1.5708,  0.    ]
 
```
    Specified by:
    
    asin in interface NDArray
    
    Returns:
    
    the result NDArray
  - acos
```
default NDArray acos()
```
    Returns the inverse trigonometric cosine of this NDArray element-wise.
    The input should be in the range [-1, 1]. The output is in the closed interval of [-Pi/2, Pi/2].
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, -1f});
 jshell> array.acos();
 ND: (2) cpu() float64
 [0.    , 3.1416]
 
```
    Specified by:
    
    acos in interface NDArray
    
    Returns:
    
    the result NDArray
  - atan
```
default NDArray atan()
```
    Returns the inverse trigonometric tangent of this NDArray element-wise.
    The input should be in the range [-1, 1]. The output is in the closed interval of [-Pi/2, Pi/2].
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f});
 jshell> array.atan();
 ND: (2) cpu() float64
 [0.    , 0.7854]
 
```
    Specified by:
    
    atan in interface NDArray
    
    Returns:
    
    the result NDArray
  - sinh
```
default NDArray sinh()
```
    Returns the hyperbolic sine of this NDArray element-wise.
    sinh(x)=0.5*(exp(x) - exp(-x))
    Examples
```
 jshell> NDArray array = manager.create(new double[] {0, Math.PI});
 jshell> array.sinh();
 ND: (2) cpu() float64
 [ 0.    , 11.5487]
 
```
    Specified by:
    
    sinh in interface NDArray
    
    Returns:
    
    the result NDArray
  - cosh
```
default NDArray cosh()
```
    Returns the hyperbolic cosine of this NDArray element-wise.
    cosh(x)=0.5*(exp(x)+exp(-x))
    Examples
```
 jshell> NDArray array = manager.create(new double[] {0, Math.PI});
 jshell> array.cosh();
 ND: (2) cpu() float64
 [ 1.    , 11.592 ]
 
```
    Specified by:
    
    cosh in interface NDArray
    
    Returns:
    
    the result NDArray
  - tanh
```
default NDArray tanh()
```
    Returns the hyperbolic tangent of this NDArray element-wise.
    tanh(x)=sinh(x)/cosh(x)
    Examples
```
 jshell> NDArray array = manager.create(new double[] {0, Math.PI});
 jshell> array.tanh();
 ND: (2) cpu() float64
 [0.    , 0.9963]
 
```
    Specified by:
    
    tanh in interface NDArray
    
    Returns:
    
    the result NDArray
  - asinh
```
default NDArray asinh()
```
    Returns the inverse hyperbolic sine of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new double[] {Math.E, 10});
 jshell> array.asinh();
 ND: (2) cpu() float64
 [1.7254, 2.9982]
 
```
    Specified by:
    
    asinh in interface NDArray
    
    Returns:
    
    the result NDArray
  - acosh
```
default NDArray acosh()
```
    Returns the inverse hyperbolic cosine of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new double[] {Math.E, 10});
 jshell> array.acosh();
 ND: (2) cpu() float64
 [1.6575, 2.9932]
 
```
    Specified by:
    
    acosh in interface NDArray
    
    Returns:
    
    the result NDArray
  - atanh
```
default NDArray atanh()
```
    Returns the inverse hyperbolic tangent of this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new double[] {0, -0.5});
 jshell> array.atanh();
 ND: (2) cpu() float64
 [ 0.    , -0.5493]
 
```
    Specified by:
    
    atanh in interface NDArray
    
    Returns:
    
    the result NDArray
  - toDegrees
```
default NDArray toDegrees()
```
    Converts this NDArray from radians to degrees element-wise.
    Examples
```
 jshell> NDArray array = manager.arange(6f).mul(Math.PI / 3);
 jshell> array.toDegrees();
 ND: (6) cpu() float32
 [  0.,  60., 120., 180., 240., 300.]
 
```
    Specified by:
    
    toDegrees in interface NDArray
    
    Returns:
    
    the result NDArray
  - toRadians
```
default NDArray toRadians()
```
    Converts this NDArray from degrees to radians element-wise.
    Examples
```
 jshell> NDArray array = manager.arange(6f).mul(60);
 jshell> array.toRadians();
 ND: (6) cpu() float32
 [0.    , 1.0472, 2.0944, 3.1416, 4.1888, 5.236 ]
 
```
    Specified by:
    
    toRadians in interface NDArray
    
    Returns:
    
    the result NDArray
  - max
```
default NDArray max()
```
    Returns the maximum of this NDArray.
    Examples
```
 jshell> NDArray array = manager.arange(4f).reshape(2,2);
 jshell> array;
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [2., 3.],
 ]
 jshell> array.max(); // Maximum of the flattened array
 ND: () cpu() float32
 3.
 jshell> array.max().getFloat() // Use getFloat() to get native float
 3.0
 
```
    Specified by:
    
    max in interface NDArray
    
    Returns:
    
    the maximum of this NDArray
  - max
```
default NDArray max(int[] axes,
                    boolean keepDims)
```
    Returns the maximum of this NDArray along given axes.
    Examples
```
 jshell> NDArray array = manager.arange(4f).reshape(2,2);
 jshell> array;
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [2., 3.],
 ]
 jshell> array.max(new int[]{0}, true); // Maximum along the first axis and keep dimension
 ND: (1, 2) cpu() float32
 [[2., 3.],
 ]
 jshell> array.max(new int[]{1}, true); // Maximum along the second axis and keep dimension
 ND: (2, 1) cpu() float32
 [[1.],
  [3.],
 ]
 
```
    Specified by:
    
    max in interface NDArray
    
    Parameters:
    
    axes - the axes along which to operate
    
    keepDims - true to keep the specified axes as size 1 in the output array, false to squeeze the values out of the output array.
    
    Returns:
    
    the maximum of this NDArray
  - min
```
default NDArray min()
```
    Returns the minimum of this NDArray.
    Examples
```
 jshell> NDArray array = manager.arange(4f).reshape(2,2);
 jshell> array;
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [2., 3.],
 ]
 jshell> array.min(); // Minimum of the flattened array
 ND: () cpu() float32
 0.
 jshell> array.min().getFloat(); // Use getFloat() to get native float
 0.0
 
```
    Specified by:
    
    min in interface NDArray
    
    Returns:
    
    the minimum of this NDArray
  - min
```
default NDArray min(int[] axes,
                    boolean keepDims)
```
    Returns the minimum of this NDArray along given axes.
    Examples
```
 jshell> NDArray array = manager.arange(4f).reshape(2,2);
 jshell> array
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [2., 3.],
 ]
 jshell> array.min(new int[]{0}, true) // Minimum along the first axis and keep dimension
 ND: (1, 2) cpu() float32
 [[0., 1.],
 ]
 jshell> array.min(new int[]{1}, true) // Minimum along the second axis and keep dimension
 ND: (2, 1) cpu() float32
 [[0.],
  [2.],
 ]
 
```
    Specified by:
    
    min in interface NDArray
    
    Parameters:
    
    axes - the axes along which to operate
    
    keepDims - true to keep the specified axes as size 1 in the output array, false to squeeze the values out of the output array
    
    Returns:
    
    the minimum of this NDArray
  - sum
```
default NDArray sum()
```
    Returns the sum of this NDArray.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0.5f, 1.5f});
 jshell> array.sum();
 ND: () cpu() float32
 2.
 jshell> array.sum().getFloat(); // Use getFloat() to get native float
 2.0
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 0f, 5f}, new Shape(2, 2));
 jshell> array.sum();
 ND: () cpu() float32
 6.
 
```
    Specified by:
    
    sum in interface NDArray
    
    Returns:
    
    the sum of this NDArray
  - sum
```
default NDArray sum(int[] axes,
                    boolean keepDims)
```
    Returns the sum of this NDArray along given axes.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 0f, 5f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [0., 5.],
 ]
 jshell> array.sum(new int[] {0}, true);
 ND: (1, 2) cpu() float32
 [[0., 6.],
 ]
 jshell> array.sum(new int[] {1}, true);
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [0., 5.],
 ]
 
```
    Specified by:
    
    sum in interface NDArray
    
    Parameters:
    
    axes - the axes along which to operate
    
    keepDims - true to keep the specified axes as size 1 in the output array, false to squeeze the values out of the output array
    
    Returns:
    
    the sum of this NDArray
  - prod
```
default NDArray prod()
```
    Returns the product of this NDArray.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {2f, 3f});
 jshell> array.prod();
 ND: () cpu() float32
 6.
 jshell> array.prod().getFloat(); // Use getFloat to get native float
 6.0
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.prod();
 ND: () cpu() float32
 24.
 
```
    Specified by:
    
    prod in interface NDArray
    
    Returns:
    
    the product of this NDArray
  - prod
```
default NDArray prod(int[] axes,
                     boolean keepDims)
```
    Returns the product of this NDArray elements over the given axes.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[1., 2.],
  [3., 4.],
 ]
 jshell> array.prod(new int[] {0}, true);
 ND: (1, 2) cpu() float32
 [[3., 8.],
 ]
 jshell> array.prod(new int[] {1}, true);
 ND: (2, 1) cpu() float32
 [[ 2.],
  [12.],
 ]
 
```
    Specified by:
    
    prod in interface NDArray
    
    Parameters:
    
    axes - the axes along which to operate
    
    keepDims - true to keep the specified axes as size 1 in the output array, false to squeeze the values out of the output array
    
    Returns:
    
    the product of this NDArray
  - mean
```
default NDArray mean()
```
    Returns the average of this NDArray.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {2f, 3f});
 jshell> array.mean();
 ND: () cpu() float32
 2.5
 jshell> array.mean().getFloat(); // Use getFloat() to get native float
 2.5
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.mean();
 ND: () cpu() float32
 2.5
 
```
    Specified by:
    
    mean in interface NDArray
    
    Returns:
    
    the average of this NDArray
  - mean
```
default NDArray mean(int[] axes,
                     boolean keepDims)
```
    Returns the average of this NDArray along given axes.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[1., 2.],
  [3., 4.],
 ]
 jshell> array.mean(new int[] {0}, true);
 ND: (1, 2) cpu() float32
 [[2., 3.],
 ]
 jshell> array.mean(new int[] {1}, true);
 ND: (2, 1) cpu() float32
 [[1.5],
  [3.5],
 ]
 
```
    Specified by:
    
    mean in interface NDArray
    
    Parameters:
    
    axes - the axes along which to operate
    
    keepDims - true to keep the specified axes as size 1 in the output array, false to squeeze the values out of the output array
    
    Returns:
    
    the average of this NDArray
  - rotate90
```
default NDArray rotate90(int times,
                         int[] axes)
```
    Rotates an array by 90 degrees in the plane specified by axes.
    Rotation direction is from the first towards the second axis.
    
    Specified by:
    
    rotate90 in interface NDArray
    
    Parameters:
    
    times - Number of times the array is rotated by 90 degrees.
    
    axes - The array is rotated in the plane defined by the axes. Axes must be different.
    
    Returns:
    
    the rotated NDArray
  - trace
```
default NDArray trace(int offset,
                      int axis1,
                      int axis2)
```
    Returns the sum along diagonals of this NDArray.
    If this NDArray is 2-D, the sum along its diagonal with the given offset is returned, i.e., the sum of elements a[i,i+offset] for all i. If this NDArray has more than two dimensions, then the axes specified by axis1 and axis2 are used to determine the 2-D sub-arrays whose traces are returned. The Shape of the resulting array is the same as this NDArray with axis1 and axis2 removed.
    Examples
```
 jshell> NDArray array = manager.arange(8f).reshape(2, 2, 2);
 jshell> array;
 ND: (2, 2, 2) cpu() float32
 [[[0., 1.],
   [2., 3.],
  ],
  [[4., 5.],
   [6., 7.],
  ],
 ]
 jshell> array.trace(1,1,2);
 ND: (2) cpu() float32
 [1., 5.]
 
```
    Specified by:
    
    trace in interface NDArray
    
    Parameters:
    
    offset - offset of the diagonal from the main diagonal. Can be both positive and negative.
    
    axis1 - axes to be used as the first axis of the 2-D sub-arrays from which the diagonals should be taken
    
    axis2 - axes to be used as the second axis of the 2-D sub-arrays from which the diagonals should be taken
    
    Returns:
    
    the sum along diagonals of this NDArray
  - split
```
default NDList split(long[] indices,
                     int axis)
```
    Splits this NDArray into multiple sub-NDArrays given indices along given axis.
    Examples
```
 jshell> NDArray array = manager.arange(18f).reshape(2, 9);
 jshell> array;
 ND: (2, 9) cpu() float32
 [[ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.],
  [ 9., 10., 11., 12., 13., 14., 15., 16., 17.],
 ]
 jshell> array.split(new int[] {2,4,5}, 1).forEach(System.out::println);
 ND: (2, 2) cpu() float32
 [[ 0.,  1.],
  [ 9., 10.],
 ]

 ND: (2, 2) cpu() float32
 [[ 2.,  3.],
  [11., 12.],
 ]

 ND: (2, 1) cpu() float32
 [[ 4.],
  [13.],
 ]

 ND: (2, 4) cpu() float32
 [[ 5.,  6.,  7.,  8.],
  [14., 15., 16., 17.],
 ]
 
```
    Specified by:
    
    split in interface NDArray
    
    Parameters:
    
    indices - the entries indicate where along axis this NDArray is split. If an index exceeds the dimension of this NDArray along axis, an empty sub-array is returned correspondingly
    
    axis - the axis to split along
    
    Returns:
    
    an NDList with numOutputs NDArrays with Shape (this.shape.axis /= axis)
  - flatten
```
default NDArray flatten()
```
    Flattens this NDArray into a 1-D NDArray in row-major order.
    To flatten in column-major order, first transpose this NDArray
    Examples
```
 jshell> NDArray array = manager.create(new float[]{1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.flatten();
 ND: (4) cpu() float32
 [1., 2., 3., 4.]
 
```
    Specified by:
    
    flatten in interface NDArray
    
    Returns:
    
    a 1-D NDArray of equal size
  - reshape
```
default NDArray reshape(Shape shape)
```
    Reshapes this NDArray to the given Shape.
    You can reshape it to match another NDArray by calling a.reshape(b.getShape())
    Examples
```
 jshell> NDArray array = manager.arange(6f);
 jshell> array;
 ND: (6) cpu() float32
 [0., 1., 2., 3., 4., 5.]
 jshell> array.reshape(new Shape(2, 3));
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 
```
    Specified by:
    
    reshape in interface NDArray
    
    Parameters:
    
    shape - the Shape to reshape into. Must have equal size to the current shape
    
    Returns:
    
    a reshaped NDArray
  - expandDims
```
default NDArray expandDims(int axis)
```
    Expands the Shape of a NDArray.
    Inserts a new axis that will appear at the axis position in the expanded NDArray shape.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array;
 ND: (2) cpu() float32
 [1., 2.]
 jshell> array.expandDims(0);
 ND: (1, 2) cpu() float32
 [[1., 2.],
 ]
 jshell> array.expandDims(1);
 ND: (2, 1) cpu() float32
 [[1.],
  [2.],
 ]
 
```
    Specified by:
    
    expandDims in interface NDArray
    
    Parameters:
    
    axis - the position in the expanded axes where the new axis is placed
    
    Returns:
    
    the result NDArray. The number of dimensions is one greater than that of the NDArray
  - squeeze
```
default NDArray squeeze(int[] axes)
```
    Removes singleton dimensions at the given axes.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f}, new Shape(1, 3, 1));
 jshell> array;
 ND: (1, 3, 1) cpu() float32
 [[[0.],
   [1.],
   [2.],
  ],
 ]
 jshell> array.squeeze(new int[] {0, 2});
 ND: (3) cpu() float32
 [0., 1., 2.]
 
```
    Specified by:
    
    squeeze in interface NDArray
    
    Parameters:
    
    axes - the axes at which to remove the singleton dimensions
    
    Returns:
    
    a result NDArray of same size and data without the axes at part of the shape
  - logicalAnd
```
default NDArray logicalAnd(NDArray other)
```
    Returns the truth value of this NDArray AND the other NDArray element-wise.
    The shapes of this NDArray and the other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.create(new boolean[] {true});
 jshell> NDArray array2 = manager.create(new boolean[] {false});
 jshell> array1.logicalAnd(array2);
 ND: (1) cpu() boolean
 [false]
 jshell> array1 = manager.create(new boolean[] {true, false});
 jshell> array2 = manager.create(new boolean[] {false, false});
 jshell> array1.logicalAnd(array2);
 ND: (2) cpu() boolean
 [false, false]
 
```
```
 jshell> NDArray array = manager.arange(5f);
 jshell> array.gt(1).logicalAnd(array.lt(4));
 ND: (5) cpu() boolean
 [false, false,  true,  true, false]
 
```
    Specified by:
    
    logicalAnd in interface NDArray
    
    Parameters:
    
    other - the other NDArray to operate on
    
    Returns:
    
    the boolean NDArray of the logical AND operation applied to the elements of this NDArray and the other NDArray
  - logicalOr
```
default NDArray logicalOr(NDArray other)
```
    Computes the truth value of this NDArray OR the other NDArray element-wise.
    The shapes of this NDArray and the other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array1 = manager.create(new boolean[] {true});
 jshell> NDArray array2 = manager.create(new boolean[] {false});
 jshell> array1.logicalOr(array2);
 ND: (1) cpu() boolean
 [ true]
 jshell> array1 = manager.create(new boolean[] {true, false});
 jshell> array2 = manager.create(new boolean[] {false, false});
 jshell> array1.logicalOr(array2);
 ND: (2) cpu() boolean
 [ true, false]
 
```
```
 jshell> NDArray array = manager.arange(5f);
 jshell> array.lt(1).logicalOr(array.gt(3));
 ND: (5) cpu() boolean
 [ true, false, false, false,  true]
 
```
    Specified by:
    
    logicalOr in interface NDArray
    
    Parameters:
    
    other - the other NDArray to operate on
    
    Returns:
    
    the boolean NDArray of the logical OR operation applied to the elements of this NDArray and the other NDArray
  - logicalXor
```
default NDArray logicalXor(NDArray other)
```
    Computes the truth value of this NDArray XOR the other NDArray element-wise.
    The shapes of this NDArray and the other NDArray must be broadcastable.
    Examples
```
 jshell> NDArray array = manager.create(new boolean[] {true});
 jshell> array1.logicalXor(array2);
 ND: (1) cpu() boolean
 [ true]
 jshell> array1 = manager.create(new boolean[] {true, false});
 jshell> array2 = manager.create(new boolean[] {false, false});
 jshell> array1.logicalXor(array2);
 ND: (2) cpu() boolean
 [ true, false]
 
```
```
 jshell> NDArray array = manager.arange(5f);
 jshell> array.lt(1).logicalXor(array.gt(3));
 ND: (5) cpu() boolean
 [ true, false, false, false,  true]
 
```
    Specified by:
    
    logicalXor in interface NDArray
    
    Parameters:
    
    other - the other NDArray to operate on
    
    Returns:
    
    the boolean NDArray of the logical XOR operation applied to the elements of this NDArray and the other NDArray
  - logicalNot
```
default NDArray logicalNot()
```
    Computes the truth value of NOT this NDArray element-wise.
    Examples
```
 jshell> NDArray array = manager.create(new boolean[] {true});
 jshell> array.logicalNot();
 ND: (1) cpu() boolean
 [ false]
 
```
```
 jshell> NDArray array = manager.arange(5f);
 jshell> array.lt(1).logicalNot();
 ND: (5) cpu() boolean
 [false, true, true,  true,  true]
 
```
    Specified by:
    
    logicalNot in interface NDArray
    
    Returns:
    
    the boolean NDArray
  - argSort
```
default NDArray argSort(int axis,
                        boolean ascending)
```
    Returns the indices that would sort this NDArray given the axis.
    Perform an indirect sort along the given axis. It returns a NDArray of indices of the same Shape as this NDArray.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 3f, 2f, 2f}, new Shape(2, 2));
 jshell> array.argSort(0, false);
 ND: (2, 2) cpu() int64
 [[ 1,  0],
  [ 0,  1],
 ]
 
```
    Specified by:
    
    argSort in interface NDArray
    
    Parameters:
    
    axis - the axis to sort along
    
    ascending - whether to sort ascending
    
    Returns:
    
    a NDArray of indices corresponding to elements in this NDArray on the axis, the output DataType is always DataType.INT64
  - sort
```
default NDArray sort()
```
    Sorts the flattened NDArray.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 4f, 3f, 1f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[1., 4.],
  [3., 1.],
 ]
 jshell> array.sort(); // sort the flattened array
 ND: (2, 2) cpu() float32
 [[1., 4.],
  [1., 3.],
 ]
 
```
    Specified by:
    
    sort in interface NDArray
    
    Returns:
    
    the sorted NDArray
  - sort
```
default NDArray sort(int axis)
```
    Sorts the flattened NDArray.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 4f, 3f, 1f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[1., 4.],
  [3., 1.],
 ]
 jshell> array.sort(0); // sort along the first axis
 ND: (2, 2) cpu() float32
 [[1., 4.],
  [1., 3.],
 ]
 
```
    Specified by:
    
    sort in interface NDArray
    
    Parameters:
    
    axis - the axis to sort along
    
    Returns:
    
    the sorted NDArray
  - softmax
```
default NDArray softmax(int axis)
```
    Applies the softmax function along the given axis.
    
    Specified by:
    
    softmax in interface NDArray
    
    Parameters:
    
    axis - the axis along which to apply
    
    Returns:
    
    the result NDArray
    
    See Also:
    
    softmax, NDArray.softmax(int)
  - logSoftmax
```
default NDArray logSoftmax(int axis)
```
    Applies the softmax function followed by a logarithm.
    Mathematically equivalent to calling softmax and then log. This single operator is faster than calling two operators and numerically more stable when computing gradients.
    
    Specified by:
    
    logSoftmax in interface NDArray
    
    Parameters:
    
    axis - the axis along which to apply
    
    Returns:
    
    the result NDArray
  - cumSum
```
default NDArray cumSum()
```
    Returns the cumulative sum of the elements in the flattened NDArray.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f, 5f, 6f}, new Shape(2, 3));
 jshell> array;
 ND: (2, 3) cpu() float32
 [[1., 2., 3.],
  [4., 5., 6.],
 ]
 jshell> array.cumSum(); // cumSum on flattened array
 ND: (6) cpu() float32
 [ 1.,  3.,  6., 10., 15., 21.]
 
```
    Specified by:
    
    cumSum in interface NDArray
    
    Returns:
    
    the cumulative sum of the elements in the flattened NDArray
  - cumSum
```
default NDArray cumSum(int axis)
```
    Return the cumulative sum of the elements along a given axis.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f, 5f, 6f}, new Shape(2, 3));
 jshell> array;
 ND: (2, 3) cpu() float32
 [[1., 2., 3.],
  [4., 5., 6.],
 ]
 jshell> array.cumSum(0);
 ND: (2, 3) cpu() float32
 [[1., 2., 3.],
  [5., 7., 9.],
 ]
 jshell> array.cumSum(1);
 ND: (2, 3) cpu() float32
 [[ 1.,  3.,  6.],
  [ 4.,  9., 15.],
 ]
 
```
    Specified by:
    
    cumSum in interface NDArray
    
    Parameters:
    
    axis - the axis along which the cumulative sum is computed
    
    Returns:
    
    the cumulative sum along the specified axis
  - intern
```
default void intern(NDArray replaced)
```
    Replace the handle of the NDArray with the other. The NDArray used for replacement will be killed.
    Please use with caution, this method will make the input argument unusable.
    
    Specified by:
    
    intern in interface NDArray
    
    Parameters:
    
    replaced - the handle provider that will be killed
  - isInfinite
```
default NDArray isInfinite()
```
    Returns the boolean NDArray with value true where this NDArray's entries are infinite, or false where they are not infinite.
    
    Specified by:
    
    isInfinite in interface NDArray
    
    Returns:
    
    the boolean NDArray with value true if this NDArray's entries are infinite
  - isNaN
```
default NDArray isNaN()
```
    Returns the boolean NDArray with value true where this NDArray's entries are NaN, or false where they are not NaN.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {Float.POSITIVE_INFINITY, 0, Float.NaN});
 jshell> array.isNaN();
 ND: (3) cpu() boolean
 [false, false,  true]
 
```
    Specified by:
    
    isNaN in interface NDArray
    
    Returns:
    
    the boolean NDArray with value true if this NDArray's NDArray are NaN
  - tile
```
default NDArray tile(long repeats)
```
    Constructs a NDArray by repeating this NDArray the number of times given repeats.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f});
 jshell> array.tile(2);
 ND: (6) cpu() float32
 [0., 1., 2., 0., 1., 2.]
 
```
    Specified by:
    
    tile in interface NDArray
    
    Parameters:
    
    repeats - the number of times to repeat for each dimension
    
    Returns:
    
    a NDArray that has been tiled
  - tile
```
default NDArray tile(int axis,
                     long repeats)
```
    Constructs a NDArray by repeating this NDArray the number of times given by repeats along given axis.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f});
 jshell> array.tile(1, 2);
 ND: (1, 6) cpu() float32
 [[0., 1., 2., 0., 1., 2.],
 ]
 
```
    Specified by:
    
    tile in interface NDArray
    
    Parameters:
    
    axis - the axis to repeat
    
    repeats - the number of times to repeat for each axis
    
    Returns:
    
    a NDArray that has been tiled
  - tile
```
default NDArray tile(long[] repeats)
```
    Constructs a NDArray by repeating this NDArray the number of times given by repeats.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f});
 jshell> array.tile(new long[] {2, 2});
 ND: (2, 6) cpu() float32
 [[0., 1., 2., 0., 1., 2.],
  [0., 1., 2., 0., 1., 2.],
 ]
 
```
    Specified by:
    
    tile in interface NDArray
    
    Parameters:
    
    repeats - the number of times to repeat along each axis
    
    Returns:
    
    a NDArray that has been tiled
  - tile
```
default NDArray tile(Shape desiredShape)
```
    Constructs a NDArray by repeating this NDArray the number of times to match the desired shape.
    If the desired Shapehas fewer dimensions than this NDArray, it will tile against the last axis.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f});
 jshell> array.tile(new Shape(6));
 ND: (6) cpu() float32
 [0., 1., 2., 0., 1., 2.]
 
```
    Specified by:
    
    tile in interface NDArray
    
    Parameters:
    
    desiredShape - the Shapethat should be converted to
    
    Returns:
    
    a NDArray that has been tiled
  - repeat
```
default NDArray repeat(long repeats)
```
    Repeats element of this NDArray the number of times given repeats.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f});
 jshell> array.repeat(2);
 ND: (6) cpu() float32
 [0., 0., 1., 1., 2., 2.]
 
```
    Specified by:
    
    repeat in interface NDArray
    
    Parameters:
    
    repeats - the number of times to repeat for each axis
    
    Returns:
    
    an NDArray that has been repeated
  - repeat
```
default NDArray repeat(int axis,
                       long repeats)
```
    Repeats element of this NDArray the number of times given repeats along given axis.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f, 3f}, new Shape(2, 2));
 jshell> array.repeat(1, 2);
 ND: (6) cpu() float32
 [0., 0., 1., 1., 2., 2.]
 
```
    Specified by:
    
    repeat in interface NDArray
    
    Parameters:
    
    axis - the axis to repeat
    
    repeats - the number of times to repeat for each axis
    
    Returns:
    
    an NDArray that has been repeated
  - repeat
```
default NDArray repeat(long[] repeats)
```
    Repeats element of this NDArray the number of times given repeats along each axis.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f, 3f}, new Shape(2, 2));
 jshell> array.repeat(new long[] {2, 2});
 ND: (12) cpu() float32
 [0., 0., 0., 0., 1., 1., 1., 1., 2., 2., 2., 2.]
 
```
    Specified by:
    
    repeat in interface NDArray
    
    Parameters:
    
    repeats - the number of times to repeat along each axis
    
    Returns:
    
    a NDArray that has been repeated
  - repeat
```
default NDArray repeat(Shape desiredShape)
```
    Repeats element of this NDArray to match the desired shape.
    If the desired Shape has fewer dimensions that the array, it will repeat against the last axis.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f, 3f}, new Shape(2, 2));
 jshell> array.repeat(new Shape(4, 4));
 ND: (4, 4) cpu() float32
 [[0., 0., 1., 1.],
  [0., 0., 1., 1.],
  [2., 2., 3., 3.],
  [2., 2., 3., 3.],
 ]
 
```
    Specified by:
    
    repeat in interface NDArray
    
    Parameters:
    
    desiredShape - the Shape that should be converted to
    
    Returns:
    
    an NDArray that has been repeated
  - dot
```
default NDArray dot(NDArray other)
```
    Dot product of this NDArray and the other NDArray.
    - If both this NDArray and the other NDArray are 1-D NDArrays, it is inner product of vectors (without complex conjugation).
    - If both this NDArray and the other NDArray are 2-D NDArrays, it is matrix multiplication.
    - If either this NDArray or the other NDArray is 0-D NDArray (scalar), it is equivalent to mul.
    - If this NDArray is N-D NDArray and the other NDArray is 1-D NDArray, it is a sum product over the last axis of those.
    - If this NDArray is N-D NDArray and the other NDArray is M-D NDArray(where M>=2), it is a sum product over the last axis of this NDArray and the second-to-last axis of the other NDArray
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {1f, 2f, 3f});
 jshell> NDArray array2 = manager.create(new float[] {4f, 5f, 6f});
 jshell> array1.dot(array2); // inner product
 ND: () cpu() float32
 32.
 jshell> array1 = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array2 = manager.create(new float[] {5f, 6f, 7f, 8f}, new Shape(2, 2));
 jshell> array1.dot(array2); // matrix multiplication
 ND: (2, 2) cpu() float32
 [[19., 22.],
  [43., 50.],
 ]
 jshell> array1 = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array2 = manager.create(5f);
 jshell> array1.dot(array2);
 ND: (2, 2) cpu() float32
 [[ 5., 10.],
  [15., 20.],
 ]
 jshell> array1 = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array2 = manager.create(new float[] {1f, 2f});
 jshell> array1.dot(array2);
 ND: (2) cpu() float32
 [ 5., 11.]
 jshell> array1 = manager.create(new float[] {1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f}, new Shape(2, 2, 2));
 jshell> array2 = manager.create(new float[] {1f, 2f, 3f ,4f}, new Shape(2, 2));
 jshell> array1.dot(array2);
 ND: (2, 2, 2) cpu() float32
 [[[ 7., 10.],
   [15., 22.],
  ],
  [[23., 34.],
   [31., 46.],
  ],
 ]
 
```
    Specified by:
    
    dot in interface NDArray
    
    Parameters:
    
    other - the other NDArray to perform dot product with
    
    Returns:
    
    the result NDArray
  - matMul
```
default NDArray matMul(NDArray other)
```
    Product matrix of this NDArray and the other NDArray.
    The behavior depends on the arguments in the following way.
    - If both this NDArray and the other NDArray are 2-D NDArrays, they are multiplied like conventional matrices
    - If either this NDArray or the other NDArray is N-D NDArray, N > 2 , it is treated as a stack of matrices residing in the last two indexes and broadcast accordingly.
    - If this NDArray is 1-D NDArray, it is promoted to a matrix by prepending a 1 to its dimensions. After matrix multiplication the prepended 1 is removed.
    - If other NDArray is 1-D NDArray, it is promoted to a matrix by appending a 1 to its dimensions. After matrix multiplication the appended 1 is removed.
    Examples
```
 jshell> NDArray array1 = manager.create(new float[] {1f, 0f, 0f, 1f}, new Shape(2, 2));
 jshell> NDArray array2 = manager.create(new float[] {4f, 1f, 2f, 2f}, new Shape(2, 2));
 jshell> array1.matMul(array2); // for 2-D arrays, it is the matrix product
 ND: (2, 2) cpu() float32
 [[4., 1.],
  [2., 2.],
 ]
 jshell> array1 = manager.create(new float[] {1f, 0f, 0f, 1f}, new Shape(2, 2));
 jshell> array2 = manager.create(new float[] {1f, 2f});
 jshell> array1.matMul(array2);
 ND: (2) cpu() float32
 [1., 2.]
 jshell> array1 = manager.create(new float[] {1f, 0f, 0f, 1f}, new Shape(2, 2));
 jshell> array2 = manager.create(new float[] {1f, 2f});
 jshell> array1.matMul(array2);
 ND: (2) cpu() float32
 [1., 2.]
 jshell> array1 = manager.arange(2f * 2f * 4f).reshape(2, 2, 4);
 jshell> array2 = manager.arange(2f * 2f * 4f).reshape(2, 4, 2);
 jshell> array1.matMul(array2).get("0, 1, 1");
 ND: () cpu() float32
 98.
 
```
    Specified by:
    
    matMul in interface NDArray
    
    Parameters:
    
    other - the other NDArray to perform matrix product with
    
    Returns:
    
    the result NDArray
  - clip
```
default NDArray clip(java.lang.Number min,
                     java.lang.Number max)
```
    Clips (limit) the values in this NDArray.
    Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of [0, 1] is specified, values smaller than 0 become 0, and values larger than 1 become 1.
    Examples
```
 jshell> NDArray array = manager.arange(10f);
 jshell> array.clip(1, 8);
 ND: (10) cpu() float32
 [1., 1., 2., 3., 4., 5., 6., 7., 8., 8.]
 
```
    Specified by:
    
    clip in interface NDArray
    
    Parameters:
    
    min - the minimum value
    
    max - the maximum value
    
    Returns:
    
    an NDArray with the elements of this NDArray, but where values < min are replaced with min, and those > max with max
  - flip
```
default NDArray flip(int... axes)
```
    Returns the reverse order of elements in an array along the given axis.
    The shape of the array is preserved, but the elements are reordered.
    
    Specified by:
    
    flip in interface NDArray
    
    Parameters:
    
    axes - the axes to flip on
    
    Returns:
    
    the newly flipped array
  - transpose
```
default NDArray transpose()
```
    Returns this NDArray with axes transposed.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f ,3f, 4f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[1., 2.],
  [3., 4.],
 ]
 jshell> array.transpose();
 ND: (2, 2) cpu() float32
 [[1., 3.],
  [2., 4.],
 ]
 
```
    Specified by:
    
    transpose in interface NDArray
    
    Returns:
    
    the newly permuted array
  - transpose
```
default NDArray transpose(int... axes)
```
    Returns this NDArray with given axes transposed.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f ,3f, 4f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[1., 2.],
  [3., 4.],
 ]
 jshell> array.transpose(1, 0);
 ND: (2, 2) cpu() float32
 [[1., 3.],
  [2., 4.],
 ]
 jshell> array = manager.arange(8f).reshape(2, 2, 2);
 jshell> array;
 ND: (2, 2, 2) cpu() float32
 [[[0., 1.],
   [2., 3.],
  ],
  [[4., 5.],
   [6., 7.],
  ],
 ]
 jshell> array.transpose(1, 0, 2);
 ND: (2, 2, 2) cpu() float32
 [[[0., 1.],
   [4., 5.],
  ],
  [[2., 3.],
   [6., 7.],
  ],
 ]
 
```
    Specified by:
    
    transpose in interface NDArray
    
    Parameters:
    
    axes - the axes to swap to
    
    Returns:
    
    the transposed NDArray
  - broadcast
```
default NDArray broadcast(Shape shape)
```
    Broadcasts this NDArray to be the given shape.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f ,3f, 4f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[1., 2.],
  [3., 4.],
 ]
 jshell> array.broadcast(new Shape(2, 2, 2));
 ND: (2, 2, 2) cpu() float32
 [[[1., 2.],
   [3., 4.],
  ],
  [[1., 2.],
   [3., 4.],
  ],
 ]
 
```
    Specified by:
    
    broadcast in interface NDArray
    
    Parameters:
    
    shape - the new Shape of this NDArray
    
    Returns:
    
    the broadcasted NDArray
  - argMax
```
default NDArray argMax()
```
    Returns the indices of the maximum values into the flattened NDArray.
    Examples
```
 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.argMax();
 ND: () cpu() int64
 5.
 
```
    Specified by:
    
    argMax in interface NDArray
    
    Returns:
    
    a NDArray containing indices
  - argMax
```
default NDArray argMax(int axis)
```
    Returns the indices of the maximum values along given axis.
    Examples
```
 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.argMax(0);
 ND: (3) cpu() int64
 [1, 1, 1]
 jshell> array.argMax(1);
 ND: (2) cpu() int64
 [2, 2]
 
```
    Specified by:
    
    argMax in interface NDArray
    
    Parameters:
    
    axis - the axis along which to find maximum values
    
    Returns:
    
    a NDArray containing indices
  - argMin
```
default NDArray argMin()
```
    Returns the indices of the minimum values into the flattened NDArray.
    Examples
```
 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.argMin();
 ND: () cpu() int64
 0.
 
```
    Specified by:
    
    argMin in interface NDArray
    
    Returns:
    
    a NDArray containing indices
  - argMin
```
default NDArray argMin(int axis)
```
    Returns the indices of the minimum values along given axis.
    Examples
```
 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.argMin(0);
 ND: (3) cpu() int64
 [0, 0, 0]
 jshell> array.argMin(1);
 ND: (2) cpu() int64
 [0, 0]
 
```
    Specified by:
    
    argMin in interface NDArray
    
    Parameters:
    
    axis - the axis along which to find minimum values
    
    Returns:
    
    a NDArray containing indices
  - percentile
```
default NDArray percentile(java.lang.Number percentile)
```
    Returns percentile for this NDArray.
    
    Specified by:
    
    percentile in interface NDArray
    
    Parameters:
    
    percentile - the target percentile in range of 0..100
    
    Returns:
    
    the result NDArray
  - percentile
```
default NDArray percentile(java.lang.Number percentile,
                           int[] axes)
```
    Returns median along given dimension(s).
    
    Specified by:
    
    percentile in interface NDArray
    
    Parameters:
    
    percentile - the target percentile in range of 0..100
    
    axes - the dimension to calculate percentile for
    
    Returns:
    
    the result NDArray NDArray
  - median
```
default NDArray median()
```
    Returns median value for this NDArray.
    
    Specified by:
    
    median in interface NDArray
    
    Returns:
    
    the median NDArray
  - median
```
default NDArray median(int[] axes)
```
    Returns median value along given axes.
    
    Specified by:
    
    median in interface NDArray
    
    Parameters:
    
    axes - the axes along which to perform the median operation
    
    Returns:
    
    the median NDArray along the specified axes
  - toDense
```
default NDArray toDense()
```
    Returns a dense representation of the sparse NDArray.
    
    Specified by:
    
    toDense in interface NDArray
    
    Returns:
    
    the result NDArray
  - toSparse
```
default NDArray toSparse(SparseFormat fmt)
```
    Returns a sparse representation of NDArray.
    
    Specified by:
    
    toSparse in interface NDArray
    
    Parameters:
    
    fmt - the SparseFormat of this NDArray
    
    Returns:
    
    the result NDArray
  - nonzero
```
default NDArray nonzero()
```
    Returns the indices of elements that are non-zero.
    Note that the behavior is slightly different from numpy.nonzero. Numpy returns a tuple of NDArray, one for each dimension of NDArray. DJL nonzero returns only one NDArray with last dimension containing all dimension of indices.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 1f, 1f, 0f, 1f});
 jshell> array.nonzero();
 ND: (4, 1) cpu() int64
 [[ 0],
  [ 1],
  [ 2],
  [ 4],
 ]
 jshell> array = manager.create(new float[] {3f, 0f, 0f, 0f, 4f, 0f, 5f, 6f, 0f}).reshape(3, 3);
 jshell> array;
 ND: (3, 3) cpu() float32
 [[3., 0., 0.],
  [0., 4., 0.],
  [5., 6., 0.],
 ]
 jshell> array.nonzero();
 ND: (4, 2) cpu() int64
 [[ 0,  0],
  [ 1,  1],
  [ 2,  0],
  [ 2,  1],
 ]
 
```
    Specified by:
    
    nonzero in interface NDArray
    
    Returns:
    
    the indices of the elements that are non-zero
  - erfinv
```
default NDArray erfinv()
```
    Returns element-wise inverse gauss error function of the NDArray.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 0.5f, -1f});
 jshell> array.erfinv();
 ND: (3) cpu() float32
 [0., 0.4769, -inf]
 
```
    Specified by:
    
    erfinv in interface NDArray
    
    Returns:
    
    The inverse of gauss error of the NDArray, element-wise
  - norm
```
default NDArray norm(boolean keepDims)
```
    Returns the norm of this NDArray.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {-3f, -4f});
 jshell> array.norm(true);
 ND: () cpu() float32
 5.
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.norm(true);
 ND: () cpu() float32
 [[5.4772],
 ]
 
```
    Specified by:
    
    norm in interface NDArray
    
    Parameters:
    
    keepDims - If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original x.
    
    Returns:
    
    the norm of this NDArray
  - norm
```
default NDArray norm(int ord,
                     int[] axes,
                     boolean keepDims)
```
    Returns the norm of this NDArray.
    Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.norm(2, new int[] {0}, true);
 ND: (1, 2) cpu() float32
 [[3.1623, 4.4721],
 ]
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.norm(2, new int[] {0}, false);
 ND: (2) cpu() float32
 [3.1623, 4.4721]
 
```
    Specified by:
    
    norm in interface NDArray
    
    Parameters:
    
    ord - Order of the norm.
    
    axes - If axes contains an integer, it specifies the axis of x along which to compute the vector norms. If axis contains 2 integers, it specifies the axes that hold 2-D matrices, and the matrix norms of these matrices are computed.
    
    keepDims - keepDims If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original x.
    
    Returns:
    
    the norm of this NDArray
  - oneHot
```
default NDArray oneHot(int depth,
                       float onValue,
                       float offValue,
                       DataType dataType)
```
    Returns a one-hot NDArray.
    - The locations represented by indices take value onValue, while all other locations take value offValue.
    - If the input NDArray is rank N, the output will have rank N+1. The new axis is appended at the end.
    - If NDArray is a scalar the output shape will be a vector of length depth.
    - If NDArray is a vector of length features, the output shape will be features x depth.
    - If NDArray is a matrix with shape [batch, features], the output shape will be batch x features x depth.
    Examples
```
 jshell> NDArray array = manager.create(new int[] {1, 0, 2, 0});
 jshell> array.oneHot(3, 8f, 1f, array.getDataType());
 ND: (4, 3) cpu() int32
 [[ 1,  8,  1],
  [ 8,  1,  1],
  [ 1,  1,  8],
  [ 8,  1,  1],
 ]
 
```
    Specified by:
    
    oneHot in interface NDArray
    
    Parameters:
    
    depth - Depth of the one hot dimension.
    
    onValue - The value assigned to the locations represented by indices.
    
    offValue - The value assigned to the locations not represented by indices.
    
    dataType - dataType of the output.
    
    Returns:
    
    one-hot encoding of this NDArray
    
    See Also:
    
    Classification-problems
  - batchDot
```
default NDArray batchDot(NDArray other)
```
    Batchwise product of this NDArray and the other NDArray.
    - batchDot is used to compute dot product of x and y when x and y are data in batch, namely N-D (N greater or equal to 3) arrays in shape of (B0, …, B_i, :, :). For example, given x with shape (B_0, …, B_i, N, M) and y with shape (B_0, …, B_i, M, K), the result array will have shape (B_0, …, B_i, N, K), which is computed by: batch_dot(x,y)[b_0, ..., b_i, :, :] = dot(x[b_0, ..., b_i, :, :], y[b_0, ..., b_i, :, :])
    Examples
```
 jshell> NDArray array1 = manager.ones(new Shape(2, 1, 4));
 jshell> NDArray array2 = manager.ones(new Shape(2, 4, 6));
 jshell> array1.batchDot(array2);
 ND: (2, 1, 6) cpu() float32
 [[[4., 4., 4., 4., 4., 4.],
  ],
  [[4., 4., 4., 4., 4., 4.],
  ],
 ]
 
```
    Specified by:
    
    batchDot in interface NDArray
    
    Parameters:
    
    other - the other NDArray to perform batch dot product with
    
    Returns:
    
    the result NDArray
  - getNDArrayInternal
```
default ai.djl.ndarray.internal.NDArrayEx getNDArrayInternal()
```
    Returns an internal representative of Native NDArray.
    This method should only be used by Engine provider
    
    Specified by:
    
    getNDArrayInternal in interface NDArray
    
    Returns:
    
    an internal representative of Native NDArray

Interface NDArrayAdapter

Field Summary

Method Summary

Methods inherited from interface ai.djl.ndarray.NDArray

Methods inherited from interface ai.djl.ndarray.NDResource

Field Detail

UNSUPPORTED_MSG

Method Detail

getManager

getName

setName

getUid

getDataType

getDevice

getShape

getSparseFormat

attach

detach

toDevice

toType

setRequiresGradient

getGradient

hasGradient

stopGradient

toStringArray

toByteBuffer

set

copyTo

booleanMask

sequenceMask

sequenceMask

zerosLike

onesLike

contentEquals

contentEquals

eq

eq

neq

neq

gt

gt

gte

gte

lt

lt

lte

lte

add

add

sub

sub

mul

mul

div

div

mod

mod

pow

pow

addi

addi

subi

subi

muli

muli

divi

divi

modi

modi

powi

powi

sign

signi

maximum

maximum

minimum

minimum

neg

negi

abs