All Superinterfaces:

java.lang.AutoCloseable, BytesSupplier, NDResource

All Known Subinterfaces:

LazyNDArray, SparseNDArray

All Known Implementing Classes:

NDArrayAdapter
```
public interface NDArray
extends NDResource, BytesSupplier
```
An interface representing an n-dimensional array.
NDArray is the core data structure for all mathematical computations. An NDArray represents a multidimensional, fixed-size homogeneous array. It has very similar behaviour to the Numpy python package with the addition of efficient computing. To understand how to manage NDArray lifecycle, please refer to NDArray Memory Management Guide

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`NDArray`	`abs()`	Returns the absolute value of this `NDArray` element-wise.
`NDArray`	`acos()`	Returns the inverse trigonometric cosine of this `NDArray` element-wise.
`NDArray`	`acosh()`	Returns the inverse hyperbolic cosine of this `NDArray` element-wise.
`NDArray`	`add(NDArray other)`	Adds other `NDArray`s to this `NDArray` element-wise.
`NDArray`	`add(java.lang.Number n)`	Adds a number to this `NDArray` element-wise.
`NDArray`	`addi(NDArray other)`	Adds other `NDArray`s to this `NDArray` element-wise in place.
`NDArray`	`addi(java.lang.Number n)`	Adds a number to this `NDArray` element-wise in place.
`default NDArray`	`all()`	Returns `true` if all elements within this `NDArray` are non-zero or `true`.
`default boolean`	`allClose(NDArray other)`	Returns `true` if two `NDArray`s are element-wise equal within a tolerance.
`default boolean`	`allClose(NDArray other, double rtol, double atol, boolean equalNan)`	Returns `true` if two `NDArray` are element-wise equal within a tolerance.
`default NDArray`	`any()`	Returns `true` if any of the elements within this `NDArray` are non-zero or `true`.
`NDArray`	`argMax()`	Returns the indices of the maximum values into the flattened `NDArray`.
`NDArray`	`argMax(int axis)`	Returns the indices of the maximum values along given axis.
`NDArray`	`argMin()`	Returns the indices of the minimum values into the flattened `NDArray`.
`NDArray`	`argMin(int axis)`	Returns the indices of the minimum values along given axis.
`default NDArray`	`argSort()`	Returns the indices that would sort this `NDArray`.
`default NDArray`	`argSort(int axis)`	Returns the indices that would sort this `NDArray` given the axis.
`NDArray`	`argSort(int axis, boolean ascending)`	Returns the indices that would sort this `NDArray` given the axis.
`NDArray`	`asin()`	Returns the inverse trigonometric sine of this `NDArray` element-wise.
`NDArray`	`asinh()`	Returns the inverse hyperbolic sine of this `NDArray` element-wise.
`NDArray`	`atan()`	Returns the inverse trigonometric tangent of this `NDArray` element-wise.
`NDArray`	`atanh()`	Returns the inverse hyperbolic tangent of this `NDArray` element-wise.
`NDArray`	`batchDot(NDArray other)`	Batchwise product of this `NDArray` and the other `NDArray`.
`default NDArray`	`booleanMask(NDArray index)`	Returns portion of this `NDArray` given the index boolean `NDArray` along first axis.
`NDArray`	`booleanMask(NDArray index, int axis)`	Returns portion of this `NDArray` given the index boolean `NDArray` along given axis.
`default NDArray`	`broadcast(long... shape)`	Broadcasts this `NDArray` to be the given shape.
`NDArray`	`broadcast(Shape shape)`	Broadcasts this `NDArray` to be the given shape.
`NDArray`	`cbrt()`	Returns the cube-root of this `NDArray` element-wise.
`NDArray`	`ceil()`	Returns the ceiling of this `NDArray` element-wise.
`NDArray`	`clip(java.lang.Number min, java.lang.Number max)`	Clips (limit) the values in this `NDArray`.
`void`	`close()`
`default NDArray`	`concat(NDArray array)`	Joins a `NDArray` along the first axis.
`default NDArray`	`concat(NDArray array, int axis)`	Joins a `NDArray` along an existing axis.
`boolean`	`contentEquals(NDArray other)`	Returns `true` if all elements in this `NDArray` are equal to the other `NDArray`.
`boolean`	`contentEquals(java.lang.Number number)`	Returns `true` if all elements in this `NDArray` are equal to the `Number`.
`void`	`copyTo(NDArray array)`	Deep-copies the current `NDArray` to the one passed in.
`NDArray`	`cos()`	Returns the trigonometric cosine of this `NDArray` element-wise.
`NDArray`	`cosh()`	Returns the hyperbolic cosine of this `NDArray` element-wise.
`default NDArray`	`countNonzero()`	Counts the number of non-zero values in this `NDArray`.
`default NDArray`	`countNonzero(int axis)`	Counts the number of non-zero values in this `NDArray` along a given axis.
`NDArray`	`cumSum()`	Returns the cumulative sum of the elements in the flattened `NDArray`.
`NDArray`	`cumSum(int axis)`	Return the cumulative sum of the elements along a given axis.
`static NDArray`	`decode(NDManager manager, byte[] byteArray)`	Decodes `NDArray` from bytes.
`NDArray`	`div(NDArray other)`	Divides this `NDArray` by the other `NDArray` element-wise.
`NDArray`	`div(java.lang.Number n)`	Divides this `NDArray` by a number element-wise.
`NDArray`	`divi(NDArray other)`	Divides this `NDArray` by the other `NDArray` element-wise in place.
`NDArray`	`divi(java.lang.Number n)`	Divides this `NDArray` by a number element-wise in place.
`NDArray`	`dot(NDArray other)`	Dot product of this `NDArray` and the other `NDArray`.
`default NDArray`	`duplicate()`	Returns a copy of this `NDArray`.
`default byte[]`	`encode()`	Encodes `NDArray` to byte array.
`NDArray`	`eq(NDArray other)`	Returns the boolean `NDArray` for element-wise "Equals" comparison.
`NDArray`	`eq(java.lang.Number n)`	Returns the boolean `NDArray` for element-wise "Equals" comparison.
`NDArray`	`erfinv()`	Returns element-wise inverse gauss error function of the `NDArray`.
`NDArray`	`exp()`	Returns the exponential value of this `NDArray` element-wise.
`NDArray`	`expandDims(int axis)`	Expands the `Shape` of a `NDArray`.
`NDArray`	`flatten()`	Flattens this `NDArray` into a 1-D `NDArray` in row-major order.
`NDArray`	`flip(int... axes)`	Returns the reverse order of elements in an array along the given axis.
`NDArray`	`floor()`	Returns the floor of this `NDArray` element-wise.
`NDArray`	`gather(NDArray index, int axis)`	Returns a partial `NDArray` pointed by the indexed array.
`default NDArray`	`get(long... indices)`	Returns a partial `NDArray`.
`default NDArray`	`get(NDIndex index)`	Returns a partial `NDArray`.
`default NDArray`	`get(NDArray index)`	Returns a partial `NDArray`.
`default NDArray`	`get(java.lang.String indices, java.lang.Object... args)`	Returns a partial `NDArray`.
`default boolean`	`getBoolean(long... indices)`	Returns a boolean element from this `NDArray`.
`default byte`	`getByte(long... indices)`	Returns an byte element from this `NDArray`.
`DataType`	`getDataType()`	Returns the `DataType` of this `NDArray`.
`Device`	`getDevice()`	Returns the `Device` of this `NDArray`.
`default double`	`getDouble(long... indices)`	Returns a double element from this `NDArray`.
`default float`	`getFloat(long... indices)`	Returns a float element from this `NDArray`.
`NDArray`	`getGradient()`	Returns the gradient `NDArray` attached to this `NDArray`.
`default int`	`getInt(long... indices)`	Returns an int element from this `NDArray`.
`default long`	`getLong(long... indices)`	Returns a long element from this `NDArray`.
`java.lang.String`	`getName()`	Returns the name of this `NDArray`.
`ai.djl.ndarray.internal.NDArrayEx`	`getNDArrayInternal()`	Returns an internal representative of Native `NDArray`.
`default NDArray`	`getScalar(long... indices)`	Returns a scalar `NDArray` corresponding to a single element.
`Shape`	`getShape()`	Returns the `Shape` of this `NDArray`.
`SparseFormat`	`getSparseFormat()`	Returns the `SparseFormat` of this `NDArray`.
`java.lang.String`	`getUid()`	Returns unique identifier of this `NDArray`.
`default int`	`getUint8(long... indices)`	Returns an integer element from this `NDArray` that represent unsigned integer with 8 bits.
`NDArray`	`gt(NDArray other)`	Returns the boolean `NDArray` for element-wise "Greater Than" comparison.
`NDArray`	`gt(java.lang.Number n)`	Returns the boolean `NDArray` for element-wise "Greater" comparison.
`NDArray`	`gte(NDArray other)`	Returns the boolean `NDArray` for element-wise "Greater or equals" comparison.
`NDArray`	`gte(java.lang.Number n)`	Returns the boolean `NDArray` for element-wise "Greater or equals" comparison.
`boolean`	`hasGradient()`	Returns true if the gradient calculation is required for this `NDArray`.
`void`	`intern(NDArray replaced)`	Replace the handle of the NDArray with the other.
`default boolean`	`isEmpty()`	Returns `true` if this `NDArray` is special case: no-value `NDArray`.
`NDArray`	`isInfinite()`	Returns the boolean `NDArray` with value `true` where this `NDArray`'s entries are infinite, or `false` where they are not infinite.
`NDArray`	`isNaN()`	Returns the boolean `NDArray` with value `true` where this `NDArray`'s entries are NaN, or `false` where they are not NaN.
`default boolean`	`isScalar()`	Returns `true` if this `NDArray` is a scalar `NDArray` with empty `Shape`.
`default boolean`	`isSparse()`	Returns `true` if this `NDArray` is a `SparseNDArray`.
`default NDArray`	`like()`	Returns an uninitialized `NDArray` with the same `Shape`, `DataType` and `SparseFormat` as the input `NDArray`.
`NDArray`	`log()`	Returns the natural logarithmic value of this `NDArray` element-wise.
`NDArray`	`log10()`	Returns the base 10 logarithm of this `NDArray` element-wise.
`NDArray`	`log2()`	Returns the base 2 logarithm of this `NDArray` element-wise.
`NDArray`	`logicalAnd(NDArray other)`	Returns the truth value of this `NDArray` AND the other `NDArray` element-wise.
`NDArray`	`logicalNot()`	Computes the truth value of NOT this `NDArray` element-wise.
`NDArray`	`logicalOr(NDArray other)`	Computes the truth value of this `NDArray` OR the other `NDArray` element-wise.
`NDArray`	`logicalXor(NDArray other)`	Computes the truth value of this `NDArray` XOR the other `NDArray` element-wise.
`NDArray`	`logSoftmax(int axis)`	Applies the softmax function followed by a logarithm.
`NDArray`	`lt(NDArray other)`	Returns the boolean `NDArray` for element-wise "Less" comparison.
`NDArray`	`lt(java.lang.Number n)`	Returns the boolean `NDArray` for element-wise "Less" comparison.
`NDArray`	`lte(NDArray other)`	Returns the boolean `NDArray` for element-wise "Less or equals" comparison.
`NDArray`	`lte(java.lang.Number n)`	Returns the boolean `NDArray` for element-wise "Less or equals" comparison.
`NDArray`	`matMul(NDArray other)`	Product matrix of this `NDArray` and the other `NDArray`.
`NDArray`	`max()`	Returns the maximum of this `NDArray`.
`default NDArray`	`max(int[] axes)`	Returns the maximum of this `NDArray` along given axes.
`NDArray`	`max(int[] axes, boolean keepDims)`	Returns the maximum of this `NDArray` along given axes.
`NDArray`	`maximum(NDArray other)`	Returns the maximum of this `NDArray` and the other `NDArray` element-wise.
`NDArray`	`maximum(java.lang.Number n)`	Returns the maximum of this `NDArray` and a number element-wise.
`NDArray`	`mean()`	Returns the average of this `NDArray`.
`default NDArray`	`mean(int[] axes)`	Returns the average of this `NDArray` along given axes.
`NDArray`	`mean(int[] axes, boolean keepDims)`	Returns the average of this `NDArray` along given axes.
`NDArray`	`median()`	Returns median value for this `NDArray`.
`NDArray`	`median(int[] axes)`	Returns median value along given axes.
`NDArray`	`min()`	Returns the minimum of this `NDArray`.
`default NDArray`	`min(int[] axes)`	Returns the minimum of this `NDArray` along given axes.
`NDArray`	`min(int[] axes, boolean keepDims)`	Returns the minimum of this `NDArray` along given axes.
`NDArray`	`minimum(NDArray other)`	Returns the minimum of this `NDArray` and the other `NDArray` element-wise.
`NDArray`	`minimum(java.lang.Number n)`	Returns the minimum of this `NDArray` and a number element-wise.
`NDArray`	`mod(NDArray other)`	Returns element-wise remainder of division.
`NDArray`	`mod(java.lang.Number n)`	Returns element-wise remainder of division.
`NDArray`	`modi(NDArray other)`	Returns in place element-wise remainder of division in place.
`NDArray`	`modi(java.lang.Number n)`	Returns element-wise remainder of division in place.
`NDArray`	`mul(NDArray other)`	Multiplies this `NDArray` by other `NDArray`s element-wise.
`NDArray`	`mul(java.lang.Number n)`	Multiplies this `NDArray` by a number element-wise.
`NDArray`	`muli(NDArray other)`	Multiplies this `NDArray` by other `NDArray` element-wise in place.
`NDArray`	`muli(java.lang.Number n)`	Multiplies this `NDArray` by a number element-wise in place.
`NDArray`	`neg()`	Returns the numerical negative `NDArray` element-wise.
`NDArray`	`negi()`	Returns the numerical negative `NDArray` element-wise in place.
`NDArray`	`neq(NDArray other)`	Returns the boolean `NDArray` for element-wise "Not equals" comparison.
`NDArray`	`neq(java.lang.Number n)`	Returns the boolean `NDArray` for element-wise "Not equals" comparison.
`default NDArray`	`none()`	Returns `true` if none of the elements within this `NDArray` are non-zero or `true`.
`NDArray`	`nonzero()`	Returns the indices of elements that are non-zero.
`default NDArray`	`norm()`	Returns the norm of this `NDArray`.
`NDArray`	`norm(boolean keepDims)`	Returns the norm of this `NDArray`.
`default NDArray`	`norm(int[] axes)`	Returns the norm of this `NDArray`.
`default NDArray`	`norm(int[] axes, boolean keepDims)`	Returns the norm of this `NDArray`.
`NDArray`	`norm(int ord, int[] axes, boolean keepDims)`	Returns the norm of this `NDArray`.
`default NDArray`	`oneHot(int depth)`	Returns a one-hot `NDArray`.
`NDArray`	`oneHot(int depth, float onValue, float offValue, DataType dataType)`	Returns a one-hot `NDArray`.
`default NDArray`	`oneHot(int depth, 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`.
`NDArray`	`percentile(java.lang.Number percentile)`	Returns percentile for this `NDArray`.
`NDArray`	`percentile(java.lang.Number percentile, int[] axes)`	Returns median along given dimension(s).
`NDArray`	`pow(NDArray other)`	Takes the power of this `NDArray` with the other `NDArray` element-wise.
`NDArray`	`pow(java.lang.Number n)`	Takes the power of this `NDArray` with a number element-wise.
`NDArray`	`powi(NDArray other)`	Takes the power of this `NDArray` with the other `NDArray` element-wise in place.
`NDArray`	`powi(java.lang.Number n)`	Takes the power of this `NDArray` with a number element-wise in place.
`NDArray`	`prod()`	Returns the product of this `NDArray`.
`default NDArray`	`prod(int[] axes)`	Returns the product of this `NDArray` elements over the given axes.
`NDArray`	`prod(int[] axes, boolean keepDims)`	Returns the product of this `NDArray` elements over the given axes.
`NDArray`	`repeat(int axis, long repeats)`	Repeats element of this `NDArray` the number of times given repeats along given axis.
`NDArray`	`repeat(long repeats)`	Repeats element of this `NDArray` the number of times given repeats.
`NDArray`	`repeat(long[] repeats)`	Repeats element of this `NDArray` the number of times given repeats along each axis.
`NDArray`	`repeat(Shape desiredShape)`	Repeats element of this `NDArray` to match the desired shape.
`default NDArray`	`reshape(long... newShape)`	Reshapes this `NDArray` to the given `Shape`.
`NDArray`	`reshape(Shape shape)`	Reshapes this `NDArray` to the given `Shape`.
`NDArray`	`rotate90(int times, int[] axes)`	Rotates an array by 90 degrees in the plane specified by axes.
`NDArray`	`round()`	Returns the round of this `NDArray` element-wise.
`default NDArray`	`scaleGradient(double scale)`	Returns an NDArray equal to this that magnifies the gradient propagated to this by a constant.
`NDArray`	`sequenceMask(NDArray sequenceLength)`	Sets all elements outside the sequence to 0.
`NDArray`	`sequenceMask(NDArray sequenceLength, float value)`	Sets all elements outside the sequence to a constant value.
`default void`	`set(byte[] data)`	Sets this `NDArray` value from an array of bytes.
`default void`	`set(double[] data)`	Sets this `NDArray` value from an array of doubles.
`default void`	`set(float[] data)`	Sets this `NDArray` value from an array of floats.
`default void`	`set(int[] data)`	Sets this `NDArray` value from an array of ints.
`default void`	`set(long[] data)`	Sets this `NDArray` value from an array of longs.
`default void`	`set(NDIndex index, NDArray value)`	Sets the specified index in this `NDArray` with the given values.
`default void`	`set(NDIndex index, java.lang.Number value)`	Sets the specified index in this `NDArray` with the given value.
`default void`	`set(NDIndex index, java.util.function.Function<NDArray,NDArray> function)`	Sets the specific index by a function.
`default void`	`set(NDArray index, java.lang.Number value)`	Sets the `NDArray` by boolean mask.
`void`	`set(java.nio.Buffer data)`	Sets this `NDArray` value from `Buffer`.
`void`	`setName(java.lang.String name)`	Sets name of this `NDArray`.
`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 void`	`setScalar(NDIndex index, java.lang.Number value)`	Sets the specified scalar in this `NDArray` with the given value.
`default boolean`	`shapeEquals(NDArray other)`	Checks 2 `NDArray`s for equal shapes.
`NDArray`	`sign()`	Returns the element-wise sign.
`NDArray`	`signi()`	Returns the element-wise sign in-place.
`NDArray`	`sin()`	Returns the trigonometric sine of this `NDArray` element-wise.
`NDArray`	`sinh()`	Returns the hyperbolic sine of this `NDArray` element-wise.
`default long`	`size()`	Returns the total number of elements in this `NDArray`.
`default long`	`size(int axis)`	Returns the size of this `NDArray` along a given axis.
`NDArray`	`softmax(int axis)`	Applies the softmax function along the given axis.
`NDArray`	`sort()`	Sorts the flattened `NDArray`.
`NDArray`	`sort(int axis)`	Sorts the flattened `NDArray`.
`default NDList`	`split(long sections)`	Splits this `NDArray` into multiple sub`NDArray`s given sections along first axis.
`default NDList`	`split(long[] indices)`	Splits this `NDArray` into multiple sub-`NDArray`s given indices along first axis.
`NDList`	`split(long[] indices, int axis)`	Splits this `NDArray` into multiple sub-`NDArray`s given indices along given axis.
`default NDList`	`split(long sections, int axis)`	Splits this `NDArray` into multiple sub`NDArray`s given sections along the given axis.
`NDArray`	`sqrt()`	Returns the square root of this `NDArray` element-wise.
`NDArray`	`square()`	Returns the square of this `NDArray` element-wise.
`default NDArray`	`squeeze()`	Removes all singleton dimensions from this `NDArray` `Shape`.
`default NDArray`	`squeeze(int axis)`	Removes a singleton dimension at the given axis.
`NDArray`	`squeeze(int[] axes)`	Removes singleton dimensions at the given axes.
`default NDArray`	`stack(NDArray array)`	Joins a `NDArray` along the first axis.
`default NDArray`	`stack(NDArray array, int axis)`	Joins a `NDArray` along a new axis.
`NDArray`	`stopGradient()`	Returns an NDArray equal to this that stop gradient propagation through it.
`NDArray`	`sub(NDArray other)`	Subtracts the other `NDArray` from this `NDArray` element-wise.
`NDArray`	`sub(java.lang.Number n)`	Subtracts a number from this `NDArray` element-wise.
`NDArray`	`subi(NDArray other)`	Subtracts the other `NDArray` from this `NDArray` element-wise in place.
`NDArray`	`subi(java.lang.Number n)`	Subtracts a number from this `NDArray` element-wise in place.
`NDArray`	`sum()`	Returns the sum of this `NDArray`.
`default NDArray`	`sum(int[] axes)`	Returns the sum of this `NDArray` along given axes.
`NDArray`	`sum(int[] axes, boolean keepDims)`	Returns the sum of this `NDArray` along given axes.
`default NDArray`	`swapAxes(int axis1, int axis2)`	Interchanges two axes of this `NDArray`.
`NDArray`	`tan()`	Returns the trigonometric tangent of this `NDArray` element-wise.
`NDArray`	`tanh()`	Returns the hyperbolic tangent of this `NDArray` element-wise.
`NDArray`	`tile(int axis, long repeats)`	Constructs a `NDArray` by repeating this `NDArray` the number of times given by repeats along given axis.
`NDArray`	`tile(long repeats)`	Constructs a `NDArray` by repeating this `NDArray` the number of times given repeats.
`NDArray`	`tile(long[] repeats)`	Constructs a `NDArray` by repeating this `NDArray` the number of times given by repeats.
`NDArray`	`tile(Shape desiredShape)`	Constructs a `NDArray` by repeating this `NDArray` the number of times to match the desired shape.
`default java.lang.Number[]`	`toArray()`	Converts this `NDArray` to a Number array based on its `DataType`.
`default boolean[]`	`toBooleanArray()`	Converts this `NDArray` to a boolean array.
`default byte[]`	`toByteArray()`	Converts this `NDArray` to a byte array.
`default java.lang.String`	`toDebugString()`	Runs the debug string representation of this `NDArray`.
`default java.lang.String`	`toDebugString(int maxSize, int maxDepth, int maxRows, int maxColumns)`	Runs the debug string representation of this `NDArray`.
`NDArray`	`toDegrees()`	Converts this `NDArray` from radians to degrees element-wise.
`NDArray`	`toDense()`	Returns a dense representation of the sparse `NDArray`.
`NDArray`	`toDevice(Device device, boolean copy)`	Moves this `NDArray` to a different `Device`.
`default double[]`	`toDoubleArray()`	Converts this `NDArray` to a double array.
`default float[]`	`toFloatArray()`	Converts this `NDArray` to a float array.
`default int[]`	`toIntArray()`	Converts this `NDArray` to an int array.
`default long[]`	`toLongArray()`	Converts this `NDArray` to a long array.
`NDArray`	`toRadians()`	Converts this `NDArray` from degrees to radians element-wise.
`NDArray`	`toSparse(SparseFormat fmt)`	Returns a sparse representation of `NDArray`.
`default java.lang.String[]`	`toStringArray()`	Converts this `NDArray` to a String array.
`java.lang.String[]`	`toStringArray(java.nio.charset.Charset charset)`	Converts this `NDArray` to a String array with the specified charset.
`NDArray`	`toType(DataType dataType, boolean copy)`	Converts this `NDArray` to a different `DataType`.
`default int[]`	`toUint8Array()`	Converts this `NDArray` to a uint8 array.
`default NDArray`	`trace()`	Returns the sum along diagonals of this `NDArray`.
`default NDArray`	`trace(int offset)`	Returns the sum along diagonals of this `NDArray`.
`NDArray`	`trace(int offset, int axis1, int axis2)`	Returns the sum along diagonals of this `NDArray`.
`NDArray`	`transpose()`	Returns this `NDArray` with axes transposed.
`NDArray`	`transpose(int... axes)`	Returns this `NDArray` with given axes transposed.
`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.BytesSupplier
getAsBytes, getAsObject, getAsString, toByteBuffer

Methods inherited from interface ai.djl.ndarray.NDResource
attach, detach, getManager, tempAttach

Method Detail

decode
```
static NDArray decode(NDManager manager,
                      byte[] byteArray)
```
Decodes NDArray from bytes.

Parameters:

manager - NDManager used to create this NDArray

byteArray - data used to decode

Returns:

decoded NDArray

getName
```
java.lang.String getName()
```
Returns the name of this NDArray.

Returns:

the name of this NDArray

setName
```
void setName(java.lang.String name)
```
Sets name of this NDArray.

Parameters:

name - the name of this NDArray

getUid
```
java.lang.String getUid()
```
Returns unique identifier of this NDArray.

Returns:

unique identifier of this NDArray

getDataType
```
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.

Returns:

the DataType of this NDArray

getDevice
```
Device getDevice()
```
Returns the Device of this NDArray.
Device class contains the information where this NDArray stored in memory, like CPU/GPU.

Returns:

the Device of this NDArray

getShape
```
Shape getShape()
```
Returns the Shape of this NDArray.
Shape defines how this NDArray is represented multi-dimensionally.

Returns:

the Shape of this NDArray

getSparseFormat
```
SparseFormat getSparseFormat()
```
Returns the SparseFormat of this NDArray.

Returns:

the SparseFormat of this NDArray

isSparse
```
default boolean isSparse()
```
Returns true if this NDArray is a SparseNDArray.

Returns:

true if this NDArray is a SparseNDArray

isScalar
```
default boolean isScalar()
```
Returns true if this NDArray is a scalar NDArray with empty Shape.

Returns:

true if this NDArray is a scalar NDArray with empty Shape

encode
```
default byte[] encode()
```
Encodes NDArray to byte array.

Returns:

byte array

toDevice
```
NDArray toDevice(Device device,
                 boolean copy)
```
Moves this NDArray to a different Device.

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
```
NDArray toType(DataType dataType,
               boolean copy)
```
Converts this NDArray to a different DataType.

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
```
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.

Parameters:

requiresGrad - if NDArray requires gradient or not

getGradient
```
NDArray getGradient()
```
Returns the gradient NDArray attached to this NDArray.

Returns:

the gradient NDArray

Throws:

java.lang.NullPointerException - when gradient is not initialized

hasGradient
```
boolean hasGradient()
```
Returns true if the gradient calculation is required for this NDArray.

Returns:

true if the gradient calculation is required for this NDArray else false

stopGradient
```
NDArray stopGradient()
```
Returns an NDArray equal to this that stop gradient propagation through it.

Returns:

an NDArray equal to this that stops gradient propagation through it

scaleGradient
```
default NDArray scaleGradient(double scale)
```
Returns an NDArray equal to this that magnifies the gradient propagated to this by a constant.

Parameters:

scale - how to much to magnify the gradient propagated to this

Returns:

an NDArray equal to this that magnifies the gradient propagated to this by a constant

size
```
default long size(int axis)
```
Returns the size of this NDArray along a given axis.

Parameters:

axis - the axis to return the size for

Returns:

the size of this NDArray along a given axis

size
```
default long size()
```
Returns the total number of elements in this NDArray.

Returns:

the number of elements in this NDArray

toDoubleArray
```
default double[] toDoubleArray()
```
Converts this NDArray to a double array.

Returns:

a double array

Throws:

java.lang.IllegalStateException - when DataType of this NDArray mismatches

toFloatArray
```
default float[] toFloatArray()
```
Converts this NDArray to a float array.

Returns:

a float array

Throws:

java.lang.IllegalStateException - when DataType of this NDArray mismatches

toIntArray
```
default int[] toIntArray()
```
Converts this NDArray to an int array.

Returns:

an int array

Throws:

java.lang.IllegalStateException - when DataType of this NDArray mismatches

toLongArray
```
default long[] toLongArray()
```
Converts this NDArray to a long array.

Returns:

a long array

Throws:

java.lang.IllegalStateException - when DataType of this NDArray mismatches

toByteArray
```
default byte[] toByteArray()
```
Converts this NDArray to a byte array.

Returns:

a byte array

Throws:

java.lang.IllegalStateException - when DataType of this NDArray mismatches

toUint8Array
```
default int[] toUint8Array()
```
Converts this NDArray to a uint8 array.

Returns:

a uint8 array

Throws:

java.lang.IllegalStateException - when DataType of this NDArray mismatches

toBooleanArray
```
default boolean[] toBooleanArray()
```
Converts this NDArray to a boolean array.

Returns:

a boolean array

Throws:

java.lang.IllegalStateException - when DataType of this NDArray mismatches

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

Returns:

Array of Strings

toStringArray
```
java.lang.String[] toStringArray(java.nio.charset.Charset charset)
```
Converts this NDArray to a String array with the specified charset.
This method is only applicable to the String typed NDArray and not for printing purpose

Parameters:

charset - to charset for the string

Returns:

Array of Strings

toArray
```
default java.lang.Number[] toArray()
```
Converts this NDArray to a Number array based on its DataType.

Returns:

a Number array

set
```
void set(java.nio.Buffer data)
```
Sets this NDArray value from Buffer.

Parameters:

data - the input buffered data

set
```
default void set(float[] data)
```
Sets this NDArray value from an array of floats.

Parameters:

data - the array of floats to set

set
```
default void set(int[] data)
```
Sets this NDArray value from an array of ints.

Parameters:

data - the array of integers to set

set
```
default void set(double[] data)
```
Sets this NDArray value from an array of doubles.

Parameters:

data - the array of doubles to set

set
```
default void set(long[] data)
```
Sets this NDArray value from an array of longs.

Parameters:

data - the array of longs to set

set
```
default void set(byte[] data)
```
Sets this NDArray value from an array of bytes.

Parameters:

data - the array of bytes to set

set
```
default void set(NDIndex index,
                 NDArray value)
```
Sets the specified index in this NDArray with the given values.

Parameters:

index - the locations to update

value - the value to replace with. Can broadcast if given smaller dimensions than the index

set
```
default void set(NDIndex index,
                 java.lang.Number value)
```
Sets the specified index in this NDArray with the given value.

Parameters:

index - the locations to update

value - the value to replace with

set
```
default void set(NDIndex index,
                 java.util.function.Function<NDArray,NDArray> function)
```
Sets the specific index by a function.

Parameters:

index - the locations to update

function - the function to change the value

set
```
default void set(NDArray index,
                 java.lang.Number value)
```
Sets the NDArray by boolean mask.

Parameters:

index - the boolean NDArray that indicates what to get

value - the value to replace with

setScalar
```
default void setScalar(NDIndex index,
                       java.lang.Number value)
```
Sets the specified scalar in this NDArray with the given value.

Parameters:

index - the single index to update

value - the value to replace with

Throws:

java.lang.IllegalArgumentException - thrown if the index does not correspond to a single element

get
```
default NDArray get(NDIndex index)
```
Returns a partial NDArray.

Parameters:

index - the section of this NDArray to return

Returns:

the partial NDArray

get
```
default NDArray get(java.lang.String indices,
                    java.lang.Object... args)
```
Returns a partial NDArray.

Parameters:

indices - the indices used to indicate what to get

args - arguments to replace the varaible "{}" in the indices string. Can be an integer, long, boolean NDArray, or integer NDArray.

Returns:

the partial NDArray

See Also:

NDIndex(String, Object...)

get
```
default NDArray get(long... indices)
```
Returns a partial NDArray.

Parameters:

indices - the indices with each index corresponding to the dimensions and negative indices starting from the end

Returns:

the partial NDArray

get
```
default NDArray get(NDArray index)
```
Returns a partial NDArray.

Parameters:

index - the boolean NDArray that indicates what to get

Returns:

the partial NDArray

gather
```
NDArray gather(NDArray index,
               int axis)
```
Returns a partial NDArray pointed by the indexed array. Given NDArray arr, NDArray idx, and long axis, the output is out_{ijk} = arr_{idx_{ijk}, j, k} if axis=0 or arr_{i, idx_{ijk}, k} if axis=1 or arr_{i, j, idx_{ijk}} if axis=2

Parameters:

index - picks the elements of an NDArray to the same position as index

axis - the entries of index are indices of axis

Returns:

the partial NDArray of the same shape as index

getScalar
```
default NDArray getScalar(long... indices)
```
Returns a scalar NDArray corresponding to a single element.

Parameters:

indices - the indices of the scalar to return. Must return only a single element

Returns:

a scalar NDArray corresponding to the element

Throws:

java.lang.IllegalArgumentException - thrown if the result is not a single element

getLong
```
default long getLong(long... indices)
```
Returns a long element from this NDArray.

Parameters:

indices - the indices of the long element to return

Returns:

the element in the specified index as a long

Throws:

java.lang.IllegalArgumentException - thrown if the result is not a single element

getDouble
```
default double getDouble(long... indices)
```
Returns a double element from this NDArray.

Parameters:

indices - the indices of the double element to return

Returns:

the element in the specified index as a double

Throws:

java.lang.IllegalArgumentException - thrown if the result is not a single element

getFloat
```
default float getFloat(long... indices)
```
Returns a float element from this NDArray.

Parameters:

indices - the indices of the long element to return

Returns:

the element in the specified index as a float

Throws:

java.lang.IllegalArgumentException - thrown if the result is not a single element

getInt
```
default int getInt(long... indices)
```
Returns an int element from this NDArray.

Parameters:

indices - the indices of the int element to return

Returns:

the element in the specified index as an integer

Throws:

java.lang.IllegalArgumentException - thrown if the result is not a single element

getByte
```
default byte getByte(long... indices)
```
Returns an byte element from this NDArray.

Parameters:

indices - the indices of the byte element to return

Returns:

the element in the specified index as a byte

Throws:

java.lang.IllegalArgumentException - thrown if the result is not a single element

getUint8
```
default int getUint8(long... indices)
```
Returns an integer element from this NDArray that represent unsigned integer with 8 bits.

Parameters:

indices - the indices of the unsigned 8 bits integer element to return

Returns:

the element in the specified index as a uint8

Throws:

java.lang.IllegalArgumentException - thrown if the result is not a single element

getBoolean
```
default boolean getBoolean(long... indices)
```
Returns a boolean element from this NDArray.

Parameters:

indices - the indices of the int element to return

Returns:

the element in the specified index as a boolean

Throws:

java.lang.IllegalArgumentException - thrown if the result is not a single element

copyTo
```
void copyTo(NDArray array)
```
Deep-copies the current NDArray to the one passed in.

Parameters:

array - this NDArray prepared to be copied to

duplicate
```
default NDArray duplicate()
```
Returns a copy of this NDArray.

Returns:

a copy of this NDArray

booleanMask

default NDArray booleanMask(NDArray index)

Returns portion of this NDArray given the index boolean NDArray along first axis.

Examples

 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f, 5f, 6f}, new Shape(3, 2));
 jshell> NDArray mask = manager.create(new boolean[] {true, false, true});
 jshell> array.booleanMask(mask);
 ND: (2, 2) cpu() float32
 [[1., 2.],
  [5., 6.],
 ]

Parameters:: index - boolean NDArray mask
Returns:: the result NDArray

booleanMask
```
NDArray booleanMask(NDArray index,
                    int axis)
```
Returns portion of this NDArray given the index boolean NDArray along given axis.

Parameters:

index - boolean NDArray mask

axis - an integer that represents the axis of NDArray to mask from

Returns:

the result NDArray

sequenceMask
```
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].

Parameters:

sequenceLength - used to handle variable-length sequences

value - the constant value to be set

Returns:

the result NDArray

sequenceMask
```
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].

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.],
 ]

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.],
 ]

Returns:: a NDArray filled with ones

like

default NDArray like()

Returns an uninitialized NDArray 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.like(); // uninitialized NDArray
 ND: (2, 3) cpu() float32
 [[ 9.80908925e-45,  0.00000000e+00,  0.00000000e+00],
  [ 0.00000000e+00,  7.61595174e-07,  2.80259693e-44],
 ]

Returns:: the result NDArray

contentEquals

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

Parameters:: number - the number to compare
Returns:: the boolean result

contentEquals

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

Parameters:: other - the other NDArray to compare
Returns:: the boolean result

shapeEquals

default boolean shapeEquals(NDArray other)

Checks 2 NDArrays for equal shapes.

Shapes are considered equal if:

Both NDArrays have equal rank, and
size(0)...size(rank()-1) are equal for both NDArrays

Examples

 jshell> NDArray array1 = manager.ones(new Shape(1, 2, 3));
 jshell> NDArray array2 = manager.create(new Shape(1, 2, 3));
 jshell> array1.shapeEquals(array2); // return true instead of boolean NDArray
 true

Parameters:: other - the other NDArray
Returns:: true if the Shapes are the same

allClose

default boolean allClose(NDArray other)

Returns true if two NDArrays are element-wise equal within a tolerance.

Examples

 jshell> NDArray array1 = manager.create(new double[] {1e10, 1e-7});
 jshell> NDArray array2 = manager.create(new double[] {1.00001e10, 1e-8});
 jshell> array1.allClose(array2); // return false instead of boolean NDArray
 false
 jshell> NDArray array1 = manager.create(new double[] {1e10, 1e-8});
 jshell> NDArray array2 = manager.create(new double[] {1.00001e10, 1e-9});
 jshell> array1.allClose(array2); // return true instead of boolean NDArray
 true

Parameters:: other - the NDArray to compare with
Returns:: the boolean result

allClose

default boolean allClose(NDArray other,
                         double rtol,
                         double atol,
                         boolean equalNan)

Returns true if two NDArray are element-wise equal within a tolerance.

Examples

 jshell> NDArray array1 = manager.create(new double[] {1e10, 1e-7});
 jshell> NDArray array2 = manager.create(new double[] {1.00001e10, 1e-8});
 jshell> array1.allClose(array2, 1e-05, 1e-08, false); // return false instead of boolean NDArray
 false
 jshell> NDArray array1 = manager.create(new double[] {1e10, 1e-8});
 jshell> NDArray array2 = manager.create(new double[] {1.00001e10, 1e-9});
 jshell> array1.allClose(array2, 1e-05, 1e-08, false); // return true instead of boolean NDArray
 true
 jshell> NDArray array1 = manager.create(new float[] {1f, Float.NaN});
 jshell> NDArray array2 = manager.create(new float[] {1f, Float.NaN});
 jshell> array1.allClose(array2, 1e-05, 1e-08, true); // return true instead of boolean NDArray
 true

Parameters:: other - the NDArray to compare with; rtol - the relative tolerance parameter; atol - the absolute tolerance parameter; equalNan - whether to compare NaN’s as equal. If true, NaN’s in the NDArray will be considered equal to NaN’s in the other NDArray
Returns:: the boolean result

eq
```
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]
 
```
Parameters:

n - the number to compare

Returns:

the boolean NDArray for element-wise "Equals" comparison

eq

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]

Parameters:: other - the NDArray to compare
Returns:: the boolean NDArray for element-wise "Equals" comparison

neq

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],
 ]

Parameters:: n - the number to compare
Returns:: the boolean NDArray for element-wise "Not equals" comparison

neq

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],
 ]

Parameters:: other - the NDArray to compare
Returns:: the boolean NDArray for element-wise "Not equals" comparison

gt
```
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]
 
```
Parameters:

n - the number to compare

Returns:

the boolean NDArray for element-wise "Greater" comparison

gt

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]

Parameters:: other - the NDArray to compare
Returns:: the boolean NDArray for element-wis "Greater Than" comparison

gte
```
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]
 
```
Parameters:

n - the number to compare

Returns:

the boolean NDArray for element-wise "Greater or equals" comparison

gte

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]

Parameters:: other - the number to compare
Returns:: the boolean NDArray for "Greater or equals" comparison

lt

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]

Parameters:: n - the number to compare
Returns:: the boolean NDArray for element-wise "Less" comparison

lt

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]

Parameters:: other - the NDArray to compare
Returns:: the boolean NDArray for element-wise "Less" comparison

lte
```
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]
 
```
Parameters:

n - the number to compare

Returns:

the boolean NDArray for element-wise "Less or equals" comparison

lte

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]

Parameters:: other - the NDArray to compare
Returns:: the boolean NDArray for element-wise "Less or equals" comparison

add

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.]

Parameters:: n - the number to add
Returns:: the result NDArray

add

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.],
 ]

Parameters:: other - the other NDArrays to add
Returns:: the result NDArray
Throws:: java.lang.IllegalArgumentException - others arrays must have at least one element

sub

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.]

Parameters:: n - the number to subtract from
Returns:: the result NDArray

sub

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.],
 ]

Parameters:: other - the other NDArray to subtract from
Returns:: the result NDArray

mul

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.]

Parameters:: n - the number to multiply by
Returns:: the result NDArray

mul
```
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.],
 ]
 
```
Parameters:

other - the other NDArrays to multiply by

Returns:

the result NDArray

Throws:

java.lang.IllegalArgumentException - others arrays must have at least one element

div

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.  ]

Parameters:: n - the number to divide by
Returns:: the result NDArray

div

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],
 ]

Parameters:: other - the other NDArray to divide by
Returns:: the result NDArray

mod

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.]

Parameters:: n - the divisor number
Returns:: the result NDArray

mod

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.]

Parameters:: other - the divisor NDArray
Returns:: the result NDArray

pow

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.]

Parameters:: n - the number to take the power with
Returns:: the result NDArray

pow

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.],
 ]

Parameters:: other - the other NDArray to take the power with
Returns:: the result NDArray

addi

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.]

Parameters:: n - the number to add
Returns:: the result NDArray

addi

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.]

Parameters:: other - the other NDArrays to add
Returns:: the result NDArray

subi

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.]

Parameters:: n - the number to subtract
Returns:: the result NDArray

subi

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.],
 ]

Parameters:: other - the other NDArray to subtract from
Returns:: the result NDArray

muli

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.]

Parameters:: n - the number to multiply by
Returns:: the result NDArray

muli

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.],
 ]

Parameters:: other - the other NDArrays to multiply with
Returns:: the result NDArray

divi

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.  ]

Parameters:: n - the number to divide values by
Returns:: the array after applying division operation

divi

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],
 ]

Parameters:: other - the other NDArray to divide by
Returns:: the result of the divide

modi

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.]

Parameters:: n - the divisor number
Returns:: the result NDArray

modi

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.]

Parameters:: other - the divisor NDArray
Returns:: the result of the divide

powi

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.]

Parameters:: n - the number to raise the power to
Returns:: the result NDArray

powi

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.],
 ]

Parameters:: other - the other NDArray to take the power with
Returns:: the result NDArray

sign
```
NDArray sign()
```
Returns the element-wise sign.

Returns:

the result NDArray

signi
```
NDArray signi()
```
Returns the element-wise sign in-place.

Returns:

the result NDArray

maximum

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.]

Parameters:: n - the number to be compared
Returns:: the maximum of this NDArray and a number element-wise

maximum

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. ],
 ]

Parameters:: other - the NDArray to be compared
Returns:: the maximum of this NDArray and the other NDArray element-wise

minimum

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.]

Parameters:: n - the number to be compared
Returns:: the minimum of this NDArray and a number element-wise

minimum

NDArray minimum(NDArray other)

Returns the minimum 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. ],
 ]

Parameters:: other - the NDArray to be compared
Returns:: the minimum of this NDArray and the other NDArray element-wise

neg

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.]

Returns:: the result NDArray

negi

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.]

Returns:: the result NDArray

abs

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.]

Returns:: the result NDArray

square

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.]

Returns:: the result NDArray

sqrt

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., ]

Returns:: the result NDArray

cbrt

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.]

Returns:: the result NDArray

floor

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.]

Returns:: the result NDArray

ceil

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.]

Returns:: the result NDArray

round

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.]

Returns:: the result NDArray

trunc

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.]

Returns:: the result NDArray

exp

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]

Returns:: the result NDArray

log

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]

Returns:: the result NDArray

log10

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]

Returns:: the result NDArray

log2

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]

Returns:: the result NDArray

sin

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.    ]

Returns:: the result NDArray

cos

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],

Returns:: the result NDArray

tan

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],

Returns:: the result NDArray

asin
```
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.    ]
 
```
Returns:

the result NDArray

acos
```
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]
 
```
Returns:

the result NDArray

atan
```
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]
 
```
Returns:

the result NDArray

sinh

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]

Returns:: the result NDArray

cosh

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 ]

Returns:: the result NDArray

tanh

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]

Returns:: the result NDArray

asinh

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]

Returns:: the result NDArray

acosh

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]

Returns:: the result NDArray

atanh

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]

Returns:: the result NDArray

toDegrees

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.]

Returns:: the result NDArray

toRadians

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 ]

Returns:: the result NDArray

max

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

Returns:: the maximum of this NDArray

max

default NDArray max(int[] axes)

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}); // Maximum along the first axis
 ND: (2) cpu() float32
 [2., 3.]
 jshell> array.max(new int[]{1}); // Maximum along the second axis
 ND: (2) cpu() float32
 [1., 3.]

Parameters:: axes - the axes along which to operate
Returns:: the maximum of this NDArray with the specified axes removed from the Shape containing the max
See Also:: max(int[], boolean)

max

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.],
 ]

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

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

Returns:: the minimum of this NDArray

min

default NDArray min(int[] axes)

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}); // Minimum along the first axis
 ND: (2) cpu() float32
 [0., 1.]
 jshell> array.min(new int[]{1}); // Minimum along the second axis
 ND: (2) cpu() float32
 [0., 2.]

Parameters:: axes - the axes along which to operate
Returns:: the minimum of this NDArray with the specified axes removed from the Shape containing the min
See Also:: min(int[], boolean)

min

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.],
 ]

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

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.

Returns:: the sum of this NDArray

sum

default NDArray sum(int[] axes)

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});
 ND: (2) cpu() float32
 [0., 6.]
 jshell> array.sum(new int[] {1});
 ND: (2) cpu() float32
 [1., 5.]

Parameters:: axes - the axes along which to operate
Returns:: the sum of this NDArray with the specified axes removed from the Shape containing the sum
See Also:: sum(int[], boolean)

sum

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.],
 ]

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

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.

Returns:: the product of this NDArray

prod

default NDArray prod(int[] axes)

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});
 ND: (2) cpu() float32
 [3., 8.]
 jshell> array.prod(new int[] {1});
 ND: (2) cpu() float32
 [ 2., 12.]

Parameters:: axes - the axes along which to operate
Returns:: the product of this NDArray with the specified axes removed from the Shape containing the prod
See Also:: prod(int[], boolean)

prod

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.],
 ]

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

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

Returns:: the average of this NDArray

mean

default NDArray mean(int[] axes)

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});
 ND: (2) cpu() float32
 [2., 3.]
 jshell> array.mean(new int[] {1});
 ND: (2) cpu() float32
 [1.5, 3.5]

Parameters:: axes - the axes along which to operate
Returns:: the average of this NDArray with the specified axes removed from the Shape containing the mean
See Also:: mean(int[], boolean)

mean

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],
 ]

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
```
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.

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()

Returns the sum along diagonals of this NDArray.

If this NDArray is 2-D, the sum along its diagonal is returned. If the 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 NDArray is the same as that of a with axis1 and axis2 removed.

Examples

 jshell> NDArray array = manager.eye(3);
 jshell> array;
 ND: (3, 3) cpu() float32
 [[1., 0., 0.],
  [0., 1., 0.],
  [0., 0., 1.],
 ]
 jshell> array.trace();
 ND: () cpu() float32
 3.
 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();
 ND: (2) cpu() float32
 [6., 8.]

Returns:: the sum along diagonals of this NDArray

trace
```
default NDArray trace(int offset)
```
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.eye(3);
 jshell> array;
 ND: (3, 3) cpu() float32
 [[1., 0., 0.],
  [0., 1., 0.],
  [0., 0., 1.],
 ]
 jshell> array.trace(1);
 ND: () cpu() float32
 0.
 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);
 ND: (2) cpu() float32
 [2., 3.]
 
```
Parameters:

offset - offset of the diagonal from the main diagonal. Can be both positive and negative.

Returns:

the sum along diagonals of this NDArray

trace
```
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.]
 
```
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 sections)
```
Splits this NDArray into multiple subNDArrays given sections along first axis.
Examples
```
 jshell> NDArray array = manager.arange(9f);
 jshell> array.split(3).forEach(System.out::println);
 ND: (3) cpu() float32
 [0., 1., 2.]

 ND: (3) cpu() float32
 [3., 4., 5.]

 ND: (3) cpu() float32
 [6., 7., 8.]
 
```
Parameters:

sections - this NDArray will be divided into N (sections) equal NDArray

Returns:

an NDList with size(axis) NDArrays with Shape this.shape.remove(axis)

See Also:

split(long, int)

split
```
default NDList split(long[] indices)
```
Splits this NDArray into multiple sub-NDArrays given indices along first axis.
Examples
```
 jshell> NDArray array = manager.arange(8f);
 jshell> array.split(new int[] {3, 5, 6}).forEach(System.out::println);
 ND: (3) cpu() float32
 [0., 1., 2.]

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

 ND: (1) cpu() float32
 [5.]

 ND: (2) cpu() float32
 [6., 7.]
 
```
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-NDArray is returned correspondingly.

Returns:

an NDList with size(axis) NDArrays with Shape this.shape.remove(axis)

See Also:

split(long[], int)

split

default NDList split(long sections,
                     int axis)

Splits this NDArray into multiple subNDArrays given sections along the 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(3, 1).forEach(System.out::println);
 ND: (2, 3) cpu() float32
 [[ 0.,  1.,  2.],
  [ 9., 10., 11.],
 ]

 ND: (2, 3) cpu() float32
 [[ 3.,  4.,  5.],
  [12., 13., 14.],
 ]

 ND: (2, 3) cpu() float32
 [[ 6.,  7.,  8.],
  [15., 16., 17.],
 ]

Parameters:: sections - this NDArray will be divided into N (sections) equal arrays along axis; axis - the axis to split along
Returns:: an NDList with numOutputs NDArrays with Shape (this.shape.axis /= axis)
Throws:: java.lang.IllegalArgumentException - thrown if the numOutputs does not equally divide the given axis

split

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.],
 ]

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

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.]

Returns:: a 1-D NDArray of equal size

reshape
```
default NDArray reshape(long... newShape)
```
Reshapes this NDArray to the given Shape.
Examples
```
 jshell> NDArray array = manager.arange(6f);
 jshell> array;
 ND: (6) cpu() float32
 [0., 1., 2., 3., 4., 5.]
 jshell> array.reshape(2, 3);
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 
```
Parameters:

newShape - the long array to reshape into. Must have equal size to the current shape

Returns:

a reshaped NDArray

Throws:

java.lang.IllegalArgumentException - thrown if the given Shape does not match the size of the current shape

reshape
```
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.],
 ]
 
```
Parameters:

shape - the Shape to reshape into. Must have equal size to the current shape

Returns:

a reshaped NDArray

Throws:

java.lang.IllegalArgumentException - thrown if the given Shape does not match the size of the current shape

expandDims
```
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.],
 ]
 
```
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()

Removes all singleton dimensions from this NDArray Shape.

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();
 ND: (3) cpu() float32
 [0., 1., 2.]

Returns:: a result NDArray of same size and data without singleton dimensions

squeeze

default NDArray squeeze(int axis)

Removes a singleton dimension at the given axis.

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(0);
 ND: (3, 1) cpu() float32
 [[0.],
  [1.],
  [2.],
 ]
 jshell> array.squeeze(2);
 ND: (1, 3) cpu() float32
 [[0., 1., 2.],
 ]

Parameters:: axis - the axis at which to remove the singleton dimension
Returns:: a result NDArray of same size and data without the axis at part of the shape
Throws:: java.lang.IllegalArgumentException - thrown if the given axis is not a singleton dimension

squeeze
```
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.]
 
```
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

Throws:

java.lang.IllegalArgumentException - thrown if any of the given axes are not a singleton dimension

stack

default NDArray stack(NDArray array)

Joins a NDArray along the first axis.

Examples

 jshell> NDArray array1 = manager.create(new float[] {0f, 1f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 3f});
 jshell> array1.stack(array2)
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [2., 3.],
 ]

Parameters:: array - the input NDArray which must have the same Shapeas this NDArray
Returns:: the result NDArray. The stacked NDArray has one more dimension than the input NDArray.

stack

default NDArray stack(NDArray array,
                      int axis)

Joins a NDArray along a new axis.

Examples

 jshell> NDArray array1 = manager.create(new float[] {0f, 1f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 3f});
 jshell> array1.stack(array2, 0);
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [2., 3.],
 ]
 jshell> array1.stack(array2, 1);
 ND: (2, 2) cpu() float32
 [[0., 2.],
  [1., 3.],
 ]

Parameters:: array - the input NDArray which must have the same Shapeas this NDArray; axis - the axis in the result NDArray along which the input NDArray are stacked
Returns:: the result NDArray. The stacked NDArray has one more dimension than the input NDArray.

concat

default NDArray concat(NDArray array)

Joins a NDArray along the first axis.

Examples

 jshell> NDArray array1 = manager.create(new float[] {0f, 1f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 3f});
 jshell> array1.concat(array2)
 ND: (4) cpu() float32
 [0., 1., 2., 3.]

Parameters:: array - a NDArray which have the same Shapeas this NDArray, except in the dimension corresponding to axis
Returns:: the concatenated NDArray

concat

default NDArray concat(NDArray array,
                       int axis)

Joins a NDArray along an existing axis.

Examples

 jshell> NDArray array1 = manager.create(new float[] {0f, 1f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 3f});
 jshell> array1.concat(array2, 0);
 ND: (4) cpu() float32
 [0., 1., 2., 3.]

Parameters:: array - a NDArray which have the same Shapeas this NDArray, except in the dimension corresponding to axis; axis - the axis along which this NDArray will be joined
Returns:: the concatenated NDArray

logicalAnd

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]

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

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]

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

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]

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

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]

Returns:: the boolean NDArray

argSort
```
default NDArray argSort()
```
Returns the indices that would sort this NDArray.
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[] {3f, 1f, 2f});
 jshell> array.argSort();
 ND: (3) cpu() int64
 [ 1,  2,  0]

 jshell> array = manager.create(new float[] {0f, 3f, 2f, 2f}, new Shape(2, 2));
 jshell> array.argSort();
 ND: (2, 2) cpu() int64
 [[ 0,  1],
  [ 0,  1],
 ]
 
```
Returns:

a NDArray of indices corresponding to elements in this NDArray on the axis, the output DataType is always DataType.INT64

See Also:

argSort(int, boolean)

argSort
```
default NDArray argSort(int axis)
```
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);
 ND: (2, 2) cpu() int64
 [[ 0,  1],
  [ 1,  0],
 ]
 jshell> array.argSort(1);
 ND: (2, 2) cpu() int64
 [[ 0,  1],
  [ 0,  1],
 ]
 
```
Parameters:

axis - the axis to sort along

Returns:

a NDArray of indices corresponding to elements in this NDArray on the axis, the output DataType is always DataType.INT64

See Also:

argSort(int, boolean)

argSort
```
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],
 ]
 
```
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

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.],
 ]

Returns:: the sorted NDArray

sort

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., 1.],
  [3., 4.],
 ]

Parameters:: axis - the axis to sort along
Returns:: the sorted NDArray

softmax
```
NDArray softmax(int axis)
```
Applies the softmax function along the given axis.

Parameters:

axis - the axis along which to apply

Returns:

the result NDArray

See Also:

softmax, softmax(int)

logSoftmax
```
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.

Parameters:

axis - the axis along which to apply

Returns:

the result NDArray

cumSum

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.]

Returns:: the cumulative sum of the elements in the flattened NDArray

cumSum

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.],
 ]

Parameters:: axis - the axis along which the cumulative sum is computed
Returns:: the cumulative sum along the specified axis

intern
```
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.

Parameters:

replaced - the handle provider that will be killed

isInfinite
```
NDArray isInfinite()
```
Returns the boolean NDArray with value true where this NDArray's entries are infinite, or false where they are not infinite.

Returns:

the boolean NDArray with value true if this NDArray's entries are infinite

isNaN
```
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]
 
```
Returns:

the boolean NDArray with value true if this NDArray's NDArray are NaN

tile
```
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.]
 
```
Parameters:

repeats - the number of times to repeat for each dimension

Returns:

a NDArray that has been tiled

tile
```
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.],
 ]
 
```
Parameters:

axis - the axis to repeat

repeats - the number of times to repeat for each axis

Returns:

a NDArray that has been tiled

Throws:

java.lang.IllegalArgumentException - thrown for invalid axis

tile

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.],
 ]

Parameters:: repeats - the number of times to repeat along each axis
Returns:: a NDArray that has been tiled

tile
```
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.]
 
```
Parameters:

desiredShape - the Shapethat should be converted to

Returns:

a NDArray that has been tiled

repeat

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.]

Parameters:: repeats - the number of times to repeat for each axis
Returns:: an NDArray that has been repeated

repeat
```
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.]
 
```
Parameters:

axis - the axis to repeat

repeats - the number of times to repeat for each axis

Returns:

an NDArray that has been repeated

Throws:

java.lang.IllegalArgumentException - thrown for invalid axis

repeat

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.]

Parameters:: repeats - the number of times to repeat along each axis
Returns:: a NDArray that has been repeated

repeat

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.],
 ]

Parameters:: desiredShape - the Shape that should be converted to
Returns:: an NDArray that has been repeated

dot

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.],
  ],
 ]

Parameters:: other - the other NDArray to perform dot product with
Returns:: the result NDArray

matMul

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.

Parameters:: other - the other NDArray to perform matrix product with
Returns:: the result NDArray

clip
```
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.]
 
```
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

swapAxes

default NDArray swapAxes(int axis1,
                         int axis2)

Interchanges two axes of this NDArray.

Examples

 jshell> NDArray array = manager.create(new float[] {1f, 2f ,3f}, new Shape(1, 3));
 jshell> array;
 ND: (1, 3) cpu() float32
 [[1., 2., 3.],
 ]
 jshell> array.swapAxes(0, 1);
 ND: (3, 1) cpu() float32
 [[1.],
  [2.],
  [3.],
 ]

Parameters:: axis1 - the first axis; axis2 - the second axis
Returns:: the swapped axes NDArray

flip
```
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.

Parameters:

axes - the axes to flip on

Returns:

the newly flipped array

transpose

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.],
 ]

Returns:: the newly permuted array

transpose

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.],
  ],
 ]

Parameters:: axes - the axes to swap to
Returns:: the transposed NDArray
Throws:: java.lang.IllegalArgumentException - thrown when passing a axis that is greater than the actual number of dimensions

broadcast

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.],
  ],
 ]

Parameters:: shape - the new Shape of this NDArray
Returns:: the broadcasted NDArray

broadcast

default NDArray broadcast(long... 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(2, 2, 2);
 ND: (2, 2, 2) cpu() float32
 [[[1., 2.],
   [3., 4.],
  ],
  [[1., 2.],
   [3., 4.],
  ],
 ]

Parameters:: shape - the new Shape of this NDArray
Returns:: the broadcasted NDArray

argMax

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.

Returns:: a NDArray containing indices

argMax

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]

Parameters:: axis - the axis along which to find maximum values
Returns:: a NDArray containing indices

argMin

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.

Returns:: a NDArray containing indices

argMin

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]

Parameters:: axis - the axis along which to find minimum values
Returns:: a NDArray containing indices

percentile
```
NDArray percentile(java.lang.Number percentile)
```
Returns percentile for this NDArray.

Parameters:

percentile - the target percentile in range of 0..100

Returns:

the result NDArray

percentile
```
NDArray percentile(java.lang.Number percentile,
                   int[] axes)
```
Returns median along given dimension(s).

Parameters:

percentile - the target percentile in range of 0..100

axes - the dimension to calculate percentile for

Returns:

the result NDArray NDArray

median
```
NDArray median()
```
Returns median value for this NDArray.

Returns:

the median NDArray

median
```
NDArray median(int[] axes)
```
Returns median value along given axes.

Parameters:

axes - the axes along which to perform the median operation

Returns:

the median NDArray along the specified axes

toDense
```
NDArray toDense()
```
Returns a dense representation of the sparse NDArray.

Returns:

the result NDArray

toSparse
```
NDArray toSparse(SparseFormat fmt)
```
Returns a sparse representation of NDArray.

Parameters:

fmt - the SparseFormat of this NDArray

Returns:

the result NDArray

nonzero

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],
 ]

Returns:: the indices of the elements that are non-zero

isEmpty

default boolean isEmpty()

Returns true if this NDArray is special case: no-value NDArray.

Examples

 jshell> NDArray array = manager.create(new Shape(2, 0, 1));
 jshell> array;
 ND: (2, 0, 1) cpu() float32
 []
 jshell> array.isEmpty();
 true

Returns:: true if this NDArray is empty

all

default NDArray all()

Returns true if all elements within this NDArray are non-zero or


 true

.

Examples

 jshell> NDArray array = manager.create(new boolean[] {true, false, true, true}, new Shape(2, 2));
 jshell> array.all();
 ND: () cpu() boolean
 false
 jshell> NDArray array = manager.create(new float[] {-1f, 4f, 5f});
 jshell> array.all(); // all elements are non-zero
 ND: () cpu() boolean
 true

Returns:: true if all elements within this NDArray are non-zero or true

any

default NDArray any()

Returns true if any of the elements within this NDArray are non-zero or true.

Examples

 jshell> NDArray array = manager.create(new boolean[] {true, false, true, true}, new Shape(2, 2));
 jshell> array.any();
 ND: () cpu() boolean
  true
 jshell> NDArray array = manager.create(new float[] {-1, 0, 5});
 jshell> array.any() // all elements are non-zero
 ND: () cpu() boolean
  true

Returns:: true if any of the elements within this NDArray are non-zero or true

none

default NDArray none()

Returns true if none of the elements within this NDArray are non-zero or true.

Examples

 jshell> NDArray array = manager.create(new boolean[] {false, false});
 jshell> array.none();
 ND: () cpu() boolean
  true
 jshell> NDArray array = manager.create(new float[] {-1f, 0f, 5f});
 jshell> array.none() // all elements are non-zero
 ND: () cpu() boolean
 false

Returns:: true if none of the elements within this NDArray are non-zero or true

countNonzero

default NDArray countNonzero()

Counts the number of non-zero values in this NDArray.

Examples

 jshell> NDArray array = manager.create(new float[] {0f, 0f, 1f, 2f, 7f, 0f}, new Shape(2, 3));
 jshell> array.countNonzero()
 ND: () cpu() int64
 3

Returns:: the number of non-zero values in this NDArray

countNonzero

default NDArray countNonzero(int axis)

Counts the number of non-zero values in this NDArray along a given axis.

Examples

 jshell> NDArray array = manager.create(new float[] {0f, 0f, 1f, 2f, 7f, 0f}, new Shape(2, 3));
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 0., 1.],
  [2., 7., 0.],
 ]
 jshell> array.countNonzero(0);
 ND: (3) cpu() int64
 [ 1,  1,  1]
 jshell> array.countNonzero(1);
 ND: (2) cpu() int64
 [ 1,  2]

Parameters:: axis - the axis to operate on
Returns:: the number of non-zero values in this NDArray along a given axis

erfinv

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]

Returns:: The inverse of gauss error of the NDArray, element-wise

getNDArrayInternal
```
ai.djl.ndarray.internal.NDArrayEx getNDArrayInternal()
```
Returns an internal representative of Native NDArray.
This method should only be used by Engine provider

Returns:

an internal representative of Native NDArray

toDebugString
```
default java.lang.String toDebugString()
```
Runs the debug string representation of this NDArray.

Returns:

the debug string representation of this NDArray

toDebugString
```
default java.lang.String toDebugString(int maxSize,
                                       int maxDepth,
                                       int maxRows,
                                       int maxColumns)
```
Runs the debug string representation of this NDArray.

Parameters:

maxSize - the maximum elements to print out

maxDepth - the maximum depth to print out

maxRows - the maximum rows to print out

maxColumns - the maximum columns to print out

Returns:

the debug string representation of this NDArray

close
```
void close()
```
Specified by:

close in interface java.lang.AutoCloseable

Specified by:

close in interface NDResource

norm

default NDArray norm()

Returns the norm of this NDArray.

Examples

 jshell> NDArray array = manager.create(new float[] {-3f, -4f});
 jshell> array.norm();
 ND: () cpu() float32
 5.
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.norm();
 ND: () cpu() float32
 5.4472

Returns:: the norm of this NDArray

norm

default NDArray norm(int[] axes)

Returns the norm of this NDArray.

Examples

 jshell> NDArray array = manager.create(new float[] {-3f, -4f});
 jshell> array.norm(new int[] {0});
 ND: () cpu() float32
 5.
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.norm(new int[] {0});
 ND: (2) cpu() float32
 [3.1623, 4.4721]

Parameters:: 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.
Returns:: the norm of this NDArray

norm

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],
 ]

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[] 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(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(new int[] {0}, false);
 ND: (2) cpu() float32
 [3.1623, 4.4721]
 
```
Parameters:

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

norm
```
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]
 
```
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)
```
Returns a one-hot NDArray.
- The locations represented by indices take value 1, while all other locations take value 0.
- 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);
 ND: (4, 3) cpu() float32
 [[0., 1., 0.],
  [1., 0., 0.],
  [0., 0., 1.],
  [1., 0., 0.],
 ]
 jshell> NDArray array = manager.create(new int[][] {{1, 0}, {1, 0}, {2, 0}});
 jshell> array.oneHot(3);
 ND: (3, 2, 3) cpu() float32
 [[[0., 1., 0.],
   [1., 0., 0.],
  ],
  [[0., 1., 0.],
   [1., 0., 0.],
  ],
  [[0., 0., 1.],
   [1., 0., 0.],
  ],
 ]
 
```
Parameters:

depth - Depth of the one hot dimension.

Returns:

one-hot encoding of this NDArray

See Also:

Classification-problems

oneHot
```
default NDArray oneHot(int depth,
                       DataType dataType)
```
Returns a one-hot NDArray.
- The locations represented by indices take value 1, while all other locations take value 0.
- 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);
 ND: (4, 3) cpu() float32
 [[0., 1., 0.],
  [1., 0., 0.],
  [0., 0., 1.],
  [1., 0., 0.],
 ]
 jshell> NDArray array = manager.create(new int[][] {{1, 0}, {1, 0}, {2, 0}});
 jshell> array.oneHot(3);
 ND: (3, 2, 3) cpu() float32
 [[[0., 1., 0.],
   [1., 0., 0.],
  ],
  [[0., 1., 0.],
   [1., 0., 0.],
  ],
  [[0., 0., 1.],
   [1., 0., 0.],
  ],
 ]
 
```
Parameters:

depth - Depth of the one hot dimension.

dataType - dataType of the output.

Returns:

one-hot encoding of this NDArray

See Also:

Classification-problems

oneHot
```
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],
 ]
 
```
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
```
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.],
  ],
 ]
 
```
Parameters:

other - the other NDArray to perform batch dot product with

Returns:

the result NDArray

Interface NDArray

Method Summary

Methods inherited from interface ai.djl.ndarray.BytesSupplier

Methods inherited from interface ai.djl.ndarray.NDResource

Method Detail

decode

getName

setName

getUid

getDataType

getDevice

getShape

getSparseFormat

isSparse

isScalar

encode

toDevice

toType

setRequiresGradient

getGradient

hasGradient

stopGradient

scaleGradient

size

size

toDoubleArray

toFloatArray

toIntArray

toLongArray

toByteArray

toUint8Array

toBooleanArray

toStringArray

toStringArray

toArray

set

set

set

set

set

set

set

set

set

set

setScalar

get

get

get

get

gather

getScalar

getLong

getDouble

getFloat

getInt

getByte

getUint8

getBoolean

copyTo

duplicate

booleanMask

booleanMask

sequenceMask

sequenceMask

zerosLike

onesLike

like

contentEquals

contentEquals

shapeEquals

allClose

allClose

eq

eq

neq

neq

gt

gt

gte