NDArrayAdapter (Deep Java Library 0.10.0 API specification)

All Superinterfaces:

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

Field Summary

Fields
Modifier and Type Field and Description

static java.lang.String UNSUPPORTED_MSG

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

Method Summary

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

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

Field Detail
- UNSUPPORTED_MSG
```
static final java.lang.String UNSUPPORTED_MSG
```
  See Also:
  
  Constant Field Values

Method Detail

getManager
```
default NDManager getManager()
```
Returns the NDManager used to create this NDArray.

Specified by:

getManager in interface NDArray

Returns:

the NDManager used to create this NDArray

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

Specified by:

getName in interface NDArray

Returns:

the name of this NDArray

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

Specified by:

setName in interface NDArray

Parameters:

name - the name of this NDArray

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

Specified by:

getUid in interface NDArray

Returns:

unique identifier of this NDArray

getDataType
```
default DataType getDataType()
```
Returns the DataType of this NDArray.
DataType is a definition of the precision level of the NDArray. All values inside the same NDArray would have the same DataType.

Specified by:

getDataType in interface NDArray

Returns:

the DataType of this NDArray

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

Specified by:

getDevice in interface NDArray

Returns:

the Device of this NDArray

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

Specified by:

getShape in interface NDArray

Returns:

the Shape of this NDArray

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

Specified by:

getSparseFormat in interface NDArray

Returns:

the SparseFormat of this NDArray

attach
```
default NDManager attach(NDManager manager)
```
Attaches this NDArray to the specified NDManager.
Attached resource will be closed when the NDManager is closed.

Specified by:

attach in interface NDArray

Parameters:

manager - the NDManager to be attached

Returns:

the original NDManager

detach
```
default void detach()
```
Detaches the NDArray from current NDManager's lifecycle.
The NDArray becomes un-managed, it is the user's responsibility to close the NDArray. Failure to close the resource might cause your machine to run out of native memory.

Specified by:

detach in interface NDArray

See Also:

NDManager

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

Specified by:

toDevice in interface NDArray

Parameters:

device - the Device to be set

copy - set true if you want to return a copy of the Existing NDArray

Returns:

the result NDArray with the new Device

toType
```
default NDArray toType(DataType dataType,
                       boolean copy)
```
Converts this NDArray to a different DataType.

Specified by:

toType in interface NDArray

Parameters:

dataType - the DataType to be set

copy - set true if you want to return a copy of the Existing NDArray

Returns:

the result NDArray with the new DataType

attachGradient
```
default void attachGradient()
```
Attaches a gradient NDArray to this NDArray and marks it so GradientCollector.backward(NDArray) can compute the gradient with respect to it.

Specified by:

attachGradient in interface NDArray

attachGradient
```
default void attachGradient(SparseFormat sparseFormat)
```
Attaches a gradient NDArray with the given SparseFormat to this NDArray and marks it so GradientCollector.backward(NDArray) can compute the gradient with respect to it.

Specified by:

attachGradient in interface NDArray

Parameters:

sparseFormat - the SparseFormat for the gradient

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

Specified by:

getGradient in interface NDArray

Returns:

the gradient NDArray

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

Specified by:

hasGradient in interface NDArray

Returns:

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

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

Specified by:

stopGradient in interface NDArray

Returns:

an NDArray equal to this that stops gradient propagation through it

toByteBuffer
```
default java.nio.ByteBuffer toByteBuffer()
```
Converts this NDArray to a ByteBuffer.

Specified by:

toByteBuffer in interface NDArray

Returns:

a ByteBuffer

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

Specified by:

set in interface NDArray

Parameters:

data - the input buffered data

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

Specified by:

copyTo in interface NDArray

Parameters:

array - this NDArray prepared to be copied to

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

Specified by:

booleanMask in interface NDArray

Parameters:

index - boolean NDArray mask

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

Returns:

the result NDArray

sequenceMask
```
default NDArray sequenceMask(NDArray sequenceLength,
                             float value)
```
Sets all elements outside the sequence to a constant value.
This function takes an n-dimensional input array of the form [batch_size, max_sequence_length, ....] and returns an array of the same shape. Parameter sequenceLength is used to handle variable-length sequences. sequence_length should be an input array of positive ints of dimension [batch_size].

Specified by:

sequenceMask in interface NDArray

Parameters:

sequenceLength - used to handle variable-length sequences

value - the constant value to be set

Returns:

the result NDArray

sequenceMask
```
default NDArray sequenceMask(NDArray sequenceLength)
```
Sets all elements outside the sequence to 0.
This function takes an n-dimensional input array of the form [batch_size, max_sequence_length, ....] and returns an array of the same shape. Parameter sequenceLength is used to handle variable-length sequences. sequence_length should be an input array of positive ints of dimension [batch_size].

Specified by:

sequenceMask in interface NDArray

Parameters:

sequenceLength - used to handle variable-length sequences

Returns:

the result NDArray

zerosLike

default NDArray zerosLike()

Returns an NDArray of zeros with the same Shape, DataType and SparseFormat as the input NDArray.

Examples

 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.zerosLike();
 ND: (2, 3) cpu() float32
 [[0., 0., 0.],
  [0., 0., 0.],
 ]

Specified by:: zerosLike in interface NDArray
Returns:: a NDArray filled with zeros

onesLike

default NDArray onesLike()

Returns an NDArray of ones with the same Shape, DataType and SparseFormat as the input NDArray.

Examples

 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.onesLike();
 ND: (2, 3) cpu() float32
 [[1., 1., 1.],
  [1., 1., 1.],
 ]

Specified by:: onesLike in interface NDArray
Returns:: a NDArray filled with ones

contentEquals

default boolean contentEquals(java.lang.Number number)

Returns true if all elements in this NDArray are equal to the Number.

Examples

 jshell> NDArray array = manager.ones(new Shape(2, 3));
 jshell> array.contentEquals(1); // return true instead of boolean NDArray
 true

Specified by:: contentEquals in interface NDArray
Parameters:: number - the number to compare
Returns:: the boolean result

contentEquals

default boolean contentEquals(NDArray other)

Returns true if all elements in this NDArray are equal to the other NDArray.

Examples

 jshell> NDArray array1 = manager.arange(6f).reshape(2, 3);
 jshell> NDArray array2 = manager.create(new float[] {0f, 1f, 2f, 3f, 4f, 5f}, new Shape(2, 3));
 jshell> array1.contentEquals(array2); // return true instead of boolean NDArray
 true

Specified by:: contentEquals in interface NDArray
Parameters:: other - the other NDArray to compare
Returns:: the boolean result

eq
```
default NDArray eq(java.lang.Number n)
```
Returns the boolean NDArray for element-wise "Equals" comparison.
Examples
```
 jshell> NDArray array = manager.ones(new Shape(1));
 jshell> array.eq(1);
 ND: (1) cpu() boolean
 [ true]
 
```
Specified by:

eq in interface NDArray

Parameters:

n - the number to compare

Returns:

the boolean NDArray for element-wise "Equals" comparison

eq

default NDArray eq(NDArray other)

Returns the boolean NDArray for element-wise "Equals" comparison.

Examples

 jshell> NDArray array1 = manager.create(new float[] {0f, 1f, 3f});
 jshell> NDArray array2 = manager.arange(3f);
 jshell> array1.eq(array2);
 ND: (3) cpu() boolean
 [ true,  true, false]

Specified by:: eq in interface NDArray
Parameters:: other - the NDArray to compare
Returns:: the boolean NDArray for element-wise "Equals" comparison

neq
```
default NDArray neq(java.lang.Number n)
```
Returns the boolean NDArray for element-wise "Not equals" comparison.
Examples
```
 jshell> NDArray array = manager.arange(4f).reshape(2, 2);
 jshell> array.neq(1);
 ND: (2, 2) cpu() boolean
 [[ true, false],
  [ true,  true],
 ]
 
```
Specified by:

neq in interface NDArray

Parameters:

n - the number to compare

Returns:

the boolean NDArray for element-wise "Not equals" comparison

neq

default NDArray neq(NDArray other)

Returns the boolean NDArray for element-wise "Not equals" comparison.

Examples

 jshell> NDArray array1 = manager.create(new float[] {1f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {1f, 3f});
 jshell> array1.neq(array2);
 ND: (2) cpu() boolean
 [false,  true]
 jshell> NDArray array1 = manager.create(new float[] {1f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {1f, 3f, 1f, 4f}, new Shape(2, 2));
 jshell> array1.neq(array2); // broadcasting
 ND: (2, 2) cpu() boolean
 [[false,  true],
  [false,  true],
 ]

Specified by:: neq in interface NDArray
Parameters:: other - the NDArray to compare
Returns:: the boolean NDArray for element-wise "Not equals" comparison

gt
```
default NDArray gt(java.lang.Number n)
```
Returns the boolean NDArray for element-wise "Greater" comparison.
Examples
```
 jshell> NDArray array = manager.create(new float[] {4f, 2f});
 jshell> array.gt(2f);
 ND: (2) cpu() boolean
 [ true, false]
 
```
Specified by:

gt in interface NDArray

Parameters:

n - the number to compare

Returns:

the boolean NDArray for element-wise "Greater" comparison

gt

default NDArray gt(NDArray other)

Returns the boolean NDArray for element-wise "Greater Than" comparison.

Examples

 jshell> NDArray array1 = manager.create(new float[] {4f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 2f});
 jshell> array1.neq(array2);
 ND: (2) cpu() boolean
 [ true, false]

Specified by:: gt in interface NDArray
Parameters:: other - the NDArray to compare
Returns:: the boolean NDArray for element-wis "Greater Than" comparison

gte
```
default NDArray gte(java.lang.Number n)
```
Returns the boolean NDArray for element-wise "Greater or equals" comparison.
```
 jshell> NDArray array = manager.create(new float[] {4f, 2f});
 jshell> array.gte(2f);
 ND: (2) cpu() boolean
 [ true, true]
 
```
Specified by:

gte in interface NDArray

Parameters:

n - the number to compare

Returns:

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

gte

default NDArray gte(NDArray other)

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

Examples

 jshell> NDArray array1 = manager.create(new float[] {4f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 2f});
 jshell> array1.gte(array2);
 ND: (2) cpu() boolean
 [ true, true]

Specified by:: gte in interface NDArray
Parameters:: other - the number to compare
Returns:: the boolean NDArray for "Greater or equals" comparison

lt
```
default NDArray lt(java.lang.Number n)
```
Returns the boolean NDArray for element-wise "Less" comparison.
Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array.lt(2f);
 ND: (2) cpu() boolean
 [ true, false]
 
```
Specified by:

lt in interface NDArray

Parameters:

n - the number to compare

Returns:

the boolean NDArray for element-wise "Less" comparison

lt

default NDArray lt(NDArray other)

Returns the boolean NDArray for element-wise "Less" comparison.

Examples

 jshell> NDArray array1 = manager.create(new float[] {1f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 2f});
 jshell> array1.lt(array2);
 ND: (2) cpu() boolean
 [ true, false]

Specified by:: lt in interface NDArray
Parameters:: other - the NDArray to compare
Returns:: the boolean NDArray for element-wise "Less" comparison

lte
```
default NDArray lte(java.lang.Number n)
```
Returns the boolean NDArray for element-wise "Less or equals" comparison.
Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array.lte(2f);
 ND: (2) cpu() boolean
 [ true, true]
 
```
Specified by:

lte in interface NDArray

Parameters:

n - the number to compare

Returns:

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

lte

default NDArray lte(NDArray other)

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

Examples

 jshell> NDArray array1 = manager.create(new float[] {1f, 2f});
 jshell> NDArray array2 = manager.create(new float[] {2f, 2f});
 jshell> array1.lte(array2);
 ND: (2) cpu() boolean
 [ true, true]

Specified by:: lte in interface NDArray
Parameters:: other - the NDArray to compare
Returns:: the boolean NDArray for element-wise "Less or equals" comparison

add

default NDArray add(java.lang.Number n)

Adds a number to this NDArray element-wise.

Examples

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

Specified by:: add in interface NDArray
Parameters:: n - the number to add
Returns:: the result NDArray

add

default NDArray add(NDArray other)

Adds other NDArrays to this NDArray element-wise.

The shapes of this NDArray and other NDArray must be broadcastable.

Examples

 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.arange(3f);
 jshell> array1.add(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[ 0.,  2.,  4.],
  [ 3.,  5.,  7.],
  [ 6.,  8., 10.],
 ]

Specified by:: add in interface NDArray
Parameters:: other - the other NDArrays to add
Returns:: the result NDArray

sub

default NDArray sub(java.lang.Number n)

Subtracts a number from this NDArray element-wise.

Examples

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

Specified by:: sub in interface NDArray
Parameters:: n - the number to subtract from
Returns:: the result NDArray

sub

default NDArray sub(NDArray other)

Subtracts the other NDArray from this NDArray element-wise.

The shapes of this NDArray and other NDArrays must be broadcastable.

Examples

 jshell> NDArray array1 = manager.arange(9).reshape(3, 3);
 jshell> NDArray array2 = manager.arange(3);
 jshell> array1.sub(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[0., 0., 0.],
  [3., 3., 3.],
  [6., 6., 6.],
 ]

Specified by:: sub in interface NDArray
Parameters:: other - the other NDArray to subtract from
Returns:: the result NDArray

mul

default NDArray mul(java.lang.Number n)

Multiplies this NDArray by a number element-wise.

Examples

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

Specified by:: mul in interface NDArray
Parameters:: n - the number to multiply by
Returns:: the result NDArray

mul

default NDArray mul(NDArray other)

Multiplies this NDArray by other NDArrays element-wise.

The shapes of this NDArray and other NDArray must be broadcastable.

Examples

 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.arange(3f);
 jshell> array1.mul(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[ 0.,  1.,  4.],
  [ 0.,  4., 10.],
  [ 0.,  7., 16.],
 ]

Specified by:: mul in interface NDArray
Parameters:: other - the other NDArrays to multiply by
Returns:: the result NDArray

div

default NDArray div(java.lang.Number n)

Divides this NDArray by a number element-wise.

Examples

 jshell> NDArray array = manager.arange(5f);
 jshell> array.div(4f);
 ND: (5) cpu() float32
 [0.  , 0.25, 0.5 , 0.75, 1.  ]

Specified by:: div in interface NDArray
Parameters:: n - the number to divide by
Returns:: the result NDArray

div

default NDArray div(NDArray other)

Divides this NDArray by the other NDArray element-wise.

The shapes of this NDArray and the other NDArray must be broadcastable.

Examples

 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.ones(new Shape(3)).mul(10);
 jshell> array1.div(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[0. , 0.1, 0.2],
  [0.3, 0.4, 0.5],
  [0.6, 0.7, 0.8],
 ]

Specified by:: div in interface NDArray
Parameters:: other - the other NDArray to divide by
Returns:: the result NDArray

mod

default NDArray mod(java.lang.Number n)

Returns element-wise remainder of division.

Examples

 jshell> NDArray array = manager.arange(7f);
 jshell> array.mod(5f);
 ND: (7) cpu() float32
 [0., 1., 2., 3., 4., 0., 1.]

Specified by:: mod in interface NDArray
Parameters:: n - the divisor number
Returns:: the result NDArray

mod

default NDArray mod(NDArray other)

Returns element-wise remainder of division.

The shapes of this NDArray and the other NDArray must be broadcastable.

Examples

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

Specified by:: mod in interface NDArray
Parameters:: other - the divisor NDArray
Returns:: the result NDArray

pow

default NDArray pow(java.lang.Number n)

Takes the power of this NDArray with a number element-wise.

Examples

 jshell> NDArray array = manager.arange(5f);
 jshell> array.pow(4f);
 ND: (6) cpu() float32
 [  0.,   1.,   8.,  27.,  64., 125.]

Specified by:: pow in interface NDArray
Parameters:: n - the number to take the power with
Returns:: the result NDArray

pow

default NDArray pow(NDArray other)

Takes the power of this NDArray with the other NDArray element-wise.

Examples

 jshell> NDArray array1 = manager.arange(6f).reshape(3, 2);
 jshell> NDArray array2 = manager.create(new float[] {2f, 3f});
 jshell> array1.pow(array2); // broadcasting
 ND: (3, 2) cpu() float32
 [[  0.,   1.],
  [  4.,  27.],
  [ 16., 125.],
 ]

Specified by:: pow in interface NDArray
Parameters:: other - the other NDArray to take the power with
Returns:: the result NDArray

addi

default NDArray addi(java.lang.Number n)

Adds a number to this NDArray element-wise in place.

Examples

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

Specified by:: addi in interface NDArray
Parameters:: n - the number to add
Returns:: the result NDArray

addi

default NDArray addi(NDArray other)

Adds other NDArrays to this NDArray element-wise in place.

The shapes of this NDArray and other NDArrays must be broadcastable.

Examples

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

Specified by:: addi in interface NDArray
Parameters:: other - the other NDArrays to add
Returns:: the result NDArray

subi

default NDArray subi(java.lang.Number n)

Subtracts a number from this NDArray element-wise in place.

Examples

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

Specified by:: subi in interface NDArray
Parameters:: n - the number to subtract
Returns:: the result NDArray

subi

default NDArray subi(NDArray other)

Subtracts the other NDArray from this NDArray element-wise in place.

The shapes of this NDArray and other NDArrays must be broadcastable.

Examples

 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.arange(3f);
 jshell> array1.subi(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[0., 0., 0.],
  [3., 3., 3.],
  [6., 6., 6.],
 ]
 jshell> array1;
 [[0., 0., 0.],
  [3., 3., 3.],
  [6., 6., 6.],
 ]

Specified by:: subi in interface NDArray
Parameters:: other - the other NDArray to subtract from
Returns:: the result NDArray

muli

default NDArray muli(java.lang.Number n)

Multiplies this NDArray by a number element-wise in place.

Examples

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

Specified by:: muli in interface NDArray
Parameters:: n - the number to multiply by
Returns:: the result NDArray

muli

default NDArray muli(NDArray other)

Multiplies this NDArray by other NDArray element-wise in place.

The shapes of this NDArray and other NDArrays must be broadcastable.

Examples

 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.arange(3f);
 jshell> array1.muli(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[ 0.,  1.,  4.],
  [ 0.,  4., 10.],
  [ 0.,  7., 16.],
 ]
 jshell> array1;
 ND: (3, 3) cpu() float32
 [[ 0.,  1.,  4.],
  [ 0.,  4., 10.],
  [ 0.,  7., 16.],
 ]

Specified by:: muli in interface NDArray
Parameters:: other - the other NDArrays to multiply with
Returns:: the result NDArray

divi

default NDArray divi(java.lang.Number n)

Divides this NDArray by a number element-wise in place.

Examples

 jshell> NDArray array = manager.arange(5f);
 jshell> array.divi(4f);
 ND: (5) cpu() float32
 [0.  , 0.25, 0.5 , 0.75, 1.  ]
 jshell> array;
 ND: (5) cpu() float32
 [0.  , 0.25, 0.5 , 0.75, 1.  ]

Specified by:: divi in interface NDArray
Parameters:: n - the number to divide values by
Returns:: the array after applying division operation

divi

default NDArray divi(NDArray other)

Divides this NDArray by the other NDArray element-wise in place.

The shapes of this NDArray and the other NDArray must be broadcastable.

Examples

 jshell> NDArray array1 = manager.arange(9f).reshape(3, 3);
 jshell> NDArray array2 = manager.ones(new Shape(3)).mul(10);
 jshell> array1.divi(array2); // broadcasting
 ND: (3, 3) cpu() float32
 [[0. , 0.1, 0.2],
  [0.3, 0.4, 0.5],
  [0.6, 0.7, 0.8],
 ]
 jshell> array1;
 [[0. , 0.1, 0.2],
  [0.3, 0.4, 0.5],
  [0.6, 0.7, 0.8],
 ]

Specified by:: divi in interface NDArray
Parameters:: other - the other NDArray to divide by
Returns:: the result of the divide

modi

default NDArray modi(java.lang.Number n)

Returns element-wise remainder of division in place.

Examples

 jshell> NDArray array = manager.arange(7f);
 jshell> array.modi(5f);
 ND: (7) cpu() float32
 [0., 1., 2., 3., 4., 0., 1.]
 jshell> array;
 ND: (7) cpu() float32
 [0., 1., 2., 3., 4., 0., 1.]

Specified by:: modi in interface NDArray
Parameters:: n - the divisor number
Returns:: the result NDArray

modi

default NDArray modi(NDArray other)

Returns in place element-wise remainder of division in place.

The shapes of this NDArray and the other NDArray must be broadcastable.

Examples

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

Specified by:: modi in interface NDArray
Parameters:: other - the divisor NDArray
Returns:: the result of the divide

powi

default NDArray powi(java.lang.Number n)

Takes the power of this NDArray with a number element-wise in place.

Examples

 jshell> NDArray array = manager.arange(5f);
 jshell> array.powi(4f);
 ND: (6) cpu() float32
 [  0.,   1.,   8.,  27.,  64., 125.]
 jshell> array;
 ND: (6) cpu() float32
 [  0.,   1.,   8.,  27.,  64., 125.]

Specified by:: powi in interface NDArray
Parameters:: n - the number to raise the power to
Returns:: the result NDArray

powi

default NDArray powi(NDArray other)

Takes the power of this NDArray with the other NDArray element-wise in place.

The shapes of this NDArray and the other NDArray must be broadcastable.

Examples

 jshell> NDArray array1 = manager.arange(6f).reshape(3, 2);
 jshell> NDArray array2 = manager.create(new float[] {2f, 3f});
 jshell> array1.powi(array2); // broadcasting
 ND: (3, 2) cpu() float32
 [[  0.,   1.],
  [  4.,  27.],
  [ 16., 125.],
 ]
 jshell> array1;
 ND: (3, 2) cpu() float32
 [[  0.,   1.],
  [  4.,  27.],
  [ 16., 125.],
 ]

Specified by:: powi in interface NDArray
Parameters:: other - the other NDArray to take the power with
Returns:: the result NDArray

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

Specified by:

sign in interface NDArray

Returns:

the result NDArray

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

Specified by:

signi in interface NDArray

Returns:

the result NDArray

maximum
```
default NDArray maximum(java.lang.Number n)
```
Returns the maximum of this NDArray and a number element-wise.
Examples
```
 jshell> NDArray array = manager.create(new float[] {2f, 3f, 4f});
 jshell> array.maximum(3f);
 ND: (3) cpu() float32
 [3., 3., 4.]
 
```
Specified by:

maximum in interface NDArray

Parameters:

n - the number to be compared

Returns:

the maximum of this NDArray and a number element-wise

maximum

default NDArray maximum(NDArray other)

Returns the maximum of this NDArray and the other NDArray element-wise.

The shapes of this NDArray and the other NDArray must be broadcastable.

Examples

 jshell> NDArray array1 = manager.create(new float[] {2f, 3f, 4f});
 jshell> NDArray array2 = manager.create(new float[] {1f, 5f, 2f});
 jshell> array1.maximum(array2);
 ND: (3) cpu() float32
 [2., 5., 4.]
 jshell> NDArray array1 = manager.eye(2);
 jshell> NDArray array2 = manager.create(new float[] {0.5f, 2f});
 jshell> array1.maximum(array2); // broadcasting
 ND: (2, 2) cpu() float32
 [[1. , 2. ],
  [0.5, 2. ],
 ]

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

minimum
```
default NDArray minimum(java.lang.Number n)
```
Returns the minimum of this NDArray and a number element-wise.
Examples
```
 jshell> NDArray array = manager.create(new float[] {2f, 3f, 4f});
 jshell> array.minimum(3f);
 ND: (3) cpu() float32
 [2., 3., 3.]
 
```
Specified by:

minimum in interface NDArray

Parameters:

n - the number to be compared

Returns:

the minimum of this NDArray and a number element-wise

minimum

default NDArray minimum(NDArray other)

Returns the maximum of this NDArray and the other NDArray element-wise.

The shapes of this NDArray and the other NDArray must be broadcastable.

Examples

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

Specified by:: minimum in interface NDArray
Parameters:: other - the NDArray to be compared
Returns:: the maximum of this NDArray and the other NDArray element-wise

neg

default NDArray neg()

Returns the numerical negative NDArray element-wise.

 jshell> NDArray array = manager.arange(5f);
 jshell> array.neg();
 ND: (5) cpu() float32
 [-0., -1., -2., -3., -4.]

Specified by:: neg in interface NDArray
Returns:: the result NDArray

negi

default NDArray negi()

Returns the numerical negative NDArray element-wise in place.

 jshell> NDArray array = manager.arange(5f);
 jshell> array.negi();
 jshell> array;
 ND: (5) cpu() float32
 [-0., -1., -2., -3., -4.]

Specified by:: negi in interface NDArray
Returns:: the result NDArray

abs

default NDArray abs()

Returns the absolute value of this NDArray element-wise.

Examples

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

Specified by:: abs in interface NDArray
Returns:: the result NDArray

square

default NDArray square()

Returns the square of this NDArray element-wise.

Examples

 jshell> NDArray array = manager.create(new float[] {2f, -3f});
 jshell> array.square();
 ND: (2) cpu() float32
 [4., 9.]

Specified by:: square in interface NDArray
Returns:: the result NDArray

sqrt

default NDArray sqrt()

Returns the square root of this NDArray element-wise.

Examples

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

Specified by:: sqrt in interface NDArray
Returns:: the result NDArray

cbrt

default NDArray cbrt()

Returns the cube-root of this NDArray element-wise.

Examples

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

Specified by:: cbrt in interface NDArray
Returns:: the result NDArray

floor

default NDArray floor()

Returns the floor of this NDArray element-wise.

The floor of the scalar x is the largest integer i, such that i <= x.

Examples

 jshell> NDArray array = manager.create(new float[] {-1.7f, -1.5f, -0.2f, 0.2f, 1.5f, 1.7f, 2.0f});
 jshell> array.floor();
 ND: (7) cpu() float32
 [-2., -2., -1.,  0.,  1.,  1.,  2.]

Specified by:: floor in interface NDArray
Returns:: the result NDArray

ceil

default NDArray ceil()

Returns the ceiling of this NDArray element-wise.

The ceil of the scalar x is the smallest integer i, such that i >= x.

Examples

 jshell> NDArray array = manager.create(new float[] {-1.7f, -1.5f, -0.2f, 0.2f, 1.5f, 1.7f, 2.0f});
 jshell> array.ceil();
 ND: (7) cpu() float32
 [-1., -1., -0.,  1.,  2.,  2.,  2.]

Specified by:: ceil in interface NDArray
Returns:: the result NDArray

round

default NDArray round()

Returns the round of this NDArray element-wise.

Examples

 jshell> NDArray array = manager.create(new float[] {-1.7f, -1.5f, -0.2f, 0.2f, 1.5f, 1.7f, 2.0f});
 jshell> array.round();
 ND: (7) cpu() float32
 [-2., -2., -0.,  0.,  2.,  2.,  2.]

Specified by:: round in interface NDArray
Returns:: the result NDArray

trunc

default NDArray trunc()

Returns the truncated value of this NDArray element-wise.

Examples

 jshell> NDArray array = manager.create(new float[] {-1.7f, -1.5f, -0.2f, 0.2f, 1.5f, 1.7f, 2.0f});
 jshell> array.trunc();
 ND: (7) cpu() float32
 [-1., -1., -0.,  0.,  1.,  1.,  2.]

Specified by:: trunc in interface NDArray
Returns:: the result NDArray

exp

default NDArray exp()

Returns the exponential value of this NDArray element-wise.

Examples

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

Specified by:: exp in interface NDArray
Returns:: the result NDArray

log

default NDArray log()

Returns the natural logarithmic value of this NDArray element-wise.

Examples

 jshell> NDArray array = manager.create(new float[] {0f, 2.5f});
 jshell> array.log();
 ND: (2) cpu() float32
 [  -inf, 0.9163]

Specified by:: log in interface NDArray
Returns:: the result NDArray

log10

default NDArray log10()

Returns the base 10 logarithm of this NDArray element-wise.

Examples

 jshell> NDArray array = manager.create(new float[] {1000f, 1f, 150f});
 jshell> array.log10();
 ND: (3) cpu() float32
 [3.    , 0.    , 2.1761]

Specified by:: log10 in interface NDArray
Returns:: the result NDArray

log2

default NDArray log2()

Returns the base 2 logarithm of this NDArray element-wise.

Examples

 jshell> NDArray array = manager.create(new float[] {8, 1f, 5f});
 jshell> array.log2();
 ND: (3) cpu() float32
 [3.    , 0.    , 2.3219]

Specified by:: log2 in interface NDArray
Returns:: the result NDArray

sin

default NDArray sin()

Returns the trigonometric sine of this NDArray element-wise.

The input should be in radians (2 Pi radians equals 360 degrees).

Examples

 jshell> NDArray array = manager.create(new float[] {0f, 30f, 45f, 60f, 90f});
 jshell> array = array.mul(Math.PI).div(180f);
 jshell> array.sin();
 ND: (5) cpu() float32
 [0.    , 0.5   , 0.7071, 0.866 , 1.    ]

Specified by:: sin in interface NDArray
Returns:: the result NDArray

cos

default NDArray cos()

Returns the trigonometric cosine of this NDArray element-wise.

The input should be in radians (2 Pi radians equals 360 degrees).

Examples

 jshell> NDArray array = manager.create(new double[] {0, Math.PI/2, Math.PI});
 jshell> array.cos();
 ND: (3) cpu() float64
 [  1.0000000e+00,   6.1232340e-17,  -1.0000000e+00],

Specified by:: cos in interface NDArray
Returns:: the result NDArray

tan

default NDArray tan()

Returns the trigonometric tangent of this NDArray element-wise.

The input should be in radians (2 Pi radians equals 360 degrees).

Examples

 jshell> NDArray array = manager.create(new double[] {-Math.PI, Math.PI/2, Math.PI});
 jshell> array.tan();
 ND: (3) cpu() float64
 [  1.2246468e-16,   1.6331239e+16,  -1.2246468e-16],

Specified by:: tan in interface NDArray
Returns:: the result NDArray

asin
```
default NDArray asin()
```
Returns the inverse trigonometric sine of this NDArray element-wise.
The input should be in the range [-1, 1]. The output is in the closed interval of [-Pi/2, Pi/2].
Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, -1f, 0f});
 jshell> array.asin();
 ND: (3) cpu() float64
 [ 1.5708, -1.5708,  0.    ]
 
```
Specified by:

asin in interface NDArray

Returns:

the result NDArray

acos
```
default NDArray acos()
```
Returns the inverse trigonometric cosine of this NDArray element-wise.
The input should be in the range [-1, 1]. The output is in the closed interval of [-Pi/2, Pi/2].
Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, -1f});
 jshell> array.acos();
 ND: (2) cpu() float64
 [0.    , 3.1416]
 
```
Specified by:

acos in interface NDArray

Returns:

the result NDArray

atan
```
default NDArray atan()
```
Returns the inverse trigonometric tangent of this NDArray element-wise.
The input should be in the range [-1, 1]. The output is in the closed interval of [-Pi/2, Pi/2].
Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f});
 jshell> array.atan();
 ND: (2) cpu() float64
 [0.    , 0.7854]
 
```
Specified by:

atan in interface NDArray

Returns:

the result NDArray

sinh

default NDArray sinh()

Returns the hyperbolic sine of this NDArray element-wise.

sinh(x)=0.5*(exp(x) - exp(-x))

Examples

 jshell> NDArray array = manager.create(new double[] {0, Math.PI});
 jshell> array.sinh();
 ND: (2) cpu() float64
 [ 0.    , 11.5487]

Specified by:: sinh in interface NDArray
Returns:: the result NDArray

cosh

default NDArray cosh()

Returns the hyperbolic cosine of this NDArray element-wise.

cosh(x)=0.5*(exp(x)+exp(-x))

Examples

 jshell> NDArray array = manager.create(new double[] {0, Math.PI});
 jshell> array.cosh();
 ND: (2) cpu() float64
 [ 1.    , 11.592 ]

Specified by:: cosh in interface NDArray
Returns:: the result NDArray

tanh

default NDArray tanh()

Returns the hyperbolic tangent of this NDArray element-wise.

tanh(x)=sinh(x)/cosh(x)

Examples

 jshell> NDArray array = manager.create(new double[] {0, Math.PI});
 jshell> array.tanh();
 ND: (2) cpu() float64
 [0.    , 0.9963]

Specified by:: tanh in interface NDArray
Returns:: the result NDArray

asinh

default NDArray asinh()

Returns the inverse hyperbolic sine of this NDArray element-wise.

Examples

 jshell> NDArray array = manager.create(new double[] {Math.E, 10});
 jshell> array.asinh();
 ND: (2) cpu() float64
 [1.7254, 2.9982]

Specified by:: asinh in interface NDArray
Returns:: the result NDArray

acosh

default NDArray acosh()

Returns the inverse hyperbolic cosine of this NDArray element-wise.

Examples

 jshell> NDArray array = manager.create(new double[] {Math.E, 10});
 jshell> array.acosh();
 ND: (2) cpu() float64
 [1.6575, 2.9932]

Specified by:: acosh in interface NDArray
Returns:: the result NDArray

atanh

default NDArray atanh()

Returns the inverse hyperbolic tangent of this NDArray element-wise.

Examples

 jshell> NDArray array = manager.create(new double[] {0, -0.5});
 jshell> array.atanh();
 ND: (2) cpu() float64
 [ 0.    , -0.5493]

Specified by:: atanh in interface NDArray
Returns:: the result NDArray

toDegrees

default NDArray toDegrees()

Converts this NDArray from radians to degrees element-wise.

Examples

 jshell> NDArray array = manager.arange(6f).mul(Math.PI / 3);
 jshell> array.toDegrees();
 ND: (6) cpu() float32
 [  0.,  60., 120., 180., 240., 300.]

Specified by:: toDegrees in interface NDArray
Returns:: the result NDArray

toRadians

default NDArray toRadians()

Converts this NDArray from degrees to radians element-wise.

Examples

 jshell> NDArray array = manager.arange(6f).mul(60);
 jshell> array.toRadians();
 ND: (6) cpu() float32
 [0.    , 1.0472, 2.0944, 3.1416, 4.1888, 5.236 ]

Specified by:: toRadians in interface NDArray
Returns:: the result NDArray

max

default NDArray max()

Returns the maximum of this NDArray.

Examples

 jshell> NDArray array = manager.arange(4f).reshape(2,2);
 jshell> array;
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [2., 3.],
 ]
 jshell> array.max(); // Maximum of the flattened array
 ND: () cpu() float32
 3.
 jshell> array.max().getFloat() // Use getFloat() to get native float
 3.0

Specified by:: max in interface NDArray
Returns:: the maximum of this NDArray

max

default NDArray max(int[] axes,
                    boolean keepDims)

Returns the maximum of this NDArray along given axes.

Examples

 jshell> NDArray array = manager.arange(4f).reshape(2,2);
 jshell> array;
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [2., 3.],
 ]
 jshell> array.max(new int[]{0}, true); // Maximum along the first axis and keep dimension
 ND: (1, 2) cpu() float32
 [[2., 3.],
 ]
 jshell> array.max(new int[]{1}, true); // Maximum along the second axis and keep dimension
 ND: (2, 1) cpu() float32
 [[1.],
  [3.],
 ]

Specified by:: max in interface NDArray
Parameters:: axes - the axes along which to operate; keepDims - true to keep the specified axes as size 1 in the output array, false to squeeze the values out of the output array.
Returns:: the maximum of this NDArray

min

default NDArray min()

Returns the minimum of this NDArray.

Examples

 jshell> NDArray array = manager.arange(4f).reshape(2,2);
 jshell> array;
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [2., 3.],
 ]
 jshell> array.min(); // Minimum of the flattened array
 ND: () cpu() float32
 0.
 jshell> array.min().getFloat(); // Use getFloat() to get native float
 0.0

Specified by:: min in interface NDArray
Returns:: the minimum of this NDArray

min

default NDArray min(int[] axes,
                    boolean keepDims)

Returns the minimum of this NDArray along given axes.

Examples

 jshell> NDArray array = manager.arange(4f).reshape(2,2);
 jshell> array
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [2., 3.],
 ]
 jshell> array.min(new int[]{0}, true) // Minimum along the first axis and keep dimension
 ND: (1, 2) cpu() float32
 [[0., 1.],
 ]
 jshell> array.min(new int[]{1}, true) // Minimum along the second axis and keep dimension
 ND: (2, 1) cpu() float32
 [[0.],
  [2.],
 ]

Specified by:: min in interface NDArray
Parameters:: axes - the axes along which to operate; keepDims - true to keep the specified axes as size 1 in the output array, false to squeeze the values out of the output array
Returns:: the minimum of this NDArray

sum

default NDArray sum()

Returns the sum of this NDArray.

Examples

 jshell> NDArray array = manager.create(new float[] {0.5f, 1.5f});
 jshell> array.sum();
 ND: () cpu() float32
 2.
 jshell> array.sum().getFloat(); // Use getFloat() to get native float
 2.0
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 0f, 5f}, new Shape(2, 2));
 jshell> array.sum();
 ND: () cpu() float32
 6.

Specified by:: sum in interface NDArray
Returns:: the sum of this NDArray

sum

default NDArray sum(int[] axes,
                    boolean keepDims)

Returns the sum of this NDArray along given axes.

Examples

 jshell> NDArray array = manager.create(new float[] {0f, 1f, 0f, 5f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [0., 5.],
 ]
 jshell> array.sum(new int[] {0}, true);
 ND: (1, 2) cpu() float32
 [[0., 6.],
 ]
 jshell> array.sum(new int[] {1}, true);
 ND: (2, 2) cpu() float32
 [[0., 1.],
  [0., 5.],
 ]

Specified by:: sum in interface NDArray
Parameters:: axes - the axes along which to operate; keepDims - true to keep the specified axes as size 1 in the output array, false to squeeze the values out of the output array
Returns:: the sum of this NDArray

prod

default NDArray prod()

Returns the product of this NDArray.

Examples

 jshell> NDArray array = manager.create(new float[] {2f, 3f});
 jshell> array.prod();
 ND: () cpu() float32
 6.
 jshell> array.prod().getFloat(); // Use getFloat to get native float
 6.0
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.prod();
 ND: () cpu() float32
 24.

Specified by:: prod in interface NDArray
Returns:: the product of this NDArray

prod

default NDArray prod(int[] axes,
                     boolean keepDims)

Returns the product of this NDArray elements over the given axes.

Examples

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

Specified by:: prod in interface NDArray
Parameters:: axes - the axes along which to operate; keepDims - true to keep the specified axes as size 1 in the output array, false to squeeze the values out of the output array
Returns:: the product of this NDArray

mean

default NDArray mean()

Returns the average of this NDArray.

Examples

 jshell> NDArray array = manager.create(new float[] {2f, 3f});
 jshell> array.mean();
 ND: () cpu() float32
 2.5
 jshell> array.mean().getFloat(); // Use getFloat() to get native float
 2.5
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.mean();
 ND: () cpu() float32
 2.5

Specified by:: mean in interface NDArray
Returns:: the average of this NDArray

mean

default NDArray mean(int[] axes,
                     boolean keepDims)

Returns the average of this NDArray along given axes.

Examples

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

Specified by:: mean in interface NDArray
Parameters:: axes - the axes along which to operate; keepDims - true to keep the specified axes as size 1 in the output array, false to squeeze the values out of the output array
Returns:: the average of this NDArray

rotate90
```
default NDArray rotate90(int times,
                         int[] axes)
```
Rotates an array by 90 degrees in the plane specified by axes.
Rotation direction is from the first towards the second axis.

Specified by:

rotate90 in interface NDArray

Parameters:

times - Number of times the array is rotated by 90 degrees.

axes - The array is rotated in the plane defined by the axes. Axes must be different.

Returns:

the rotated NDArray

trace
```
default NDArray trace(int offset,
                      int axis1,
                      int axis2)
```
Returns the sum along diagonals of this NDArray.
If this NDArray is 2-D, the sum along its diagonal with the given offset is returned, i.e., the sum of elements a[i,i+offset] for all i. If this NDArray has more than two dimensions, then the axes specified by axis1 and axis2 are used to determine the 2-D sub-arrays whose traces are returned. The Shape of the resulting array is the same as this NDArray with axis1 and axis2 removed.
Examples
```
 jshell> NDArray array = manager.arange(8f).reshape(2, 2, 2);
 jshell> array;
 ND: (2, 2, 2) cpu() float32
 [[[0., 1.],
   [2., 3.],
  ],
  [[4., 5.],
   [6., 7.],
  ],
 ]
 jshell> array.trace(1,1,2);
 ND: (2) cpu() float32
 [1., 5.]
 
```
Specified by:

trace in interface NDArray

Parameters:

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

axis1 - axes to be used as the first axis of the 2-D sub-arrays from which the diagonals should be taken

axis2 - axes to be used as the second axis of the 2-D sub-arrays from which the diagonals should be taken

Returns:

the sum along diagonals of this NDArray

split

default NDList split(long[] indices,
                     int axis)

Splits this NDArray into multiple sub-NDArrays given indices along given axis.

Examples

 jshell> NDArray array = manager.arange(18f).reshape(2, 9);
 jshell> array;
 ND: (2, 9) cpu() float32
 [[ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.],
  [ 9., 10., 11., 12., 13., 14., 15., 16., 17.],
 ]
 jshell> array.split(new int[] {2,4,5}, 1).forEach(System.out::println);
 ND: (2, 2) cpu() float32
 [[ 0.,  1.],
  [ 9., 10.],
 ]

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

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

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

Specified by:: split in interface NDArray
Parameters:: indices - the entries indicate where along axis this NDArray is split. If an index exceeds the dimension of this NDArray along axis, an empty sub-array is returned correspondingly; axis - the axis to split along
Returns:: an NDList with numOutputs NDArrays with Shape (this.shape.axis /= axis)

flatten
```
default NDArray flatten()
```
Flattens this NDArray into a 1-D NDArray in row-major order.
To flatten in column-major order, first transpose this NDArray
Examples
```
 jshell> NDArray array = manager.create(new float[]{1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.flatten();
 ND: (4) cpu() float32
 [1., 2., 3., 4.]
 
```
Specified by:

flatten in interface NDArray

Returns:

a 1-D NDArray of equal size

reshape
```
default NDArray reshape(Shape shape)
```
Reshapes this NDArray to the given Shape.
You can reshape it to match another NDArray by calling a.reshape(b.getShape())
Examples
```
 jshell> NDArray array = manager.arange(6f);
 jshell> array;
 ND: (6) cpu() float32
 [0., 1., 2., 3., 4., 5.]
 jshell> array.reshape(new Shape(2, 3));
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 
```
Specified by:

reshape in interface NDArray

Parameters:

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

Returns:

a reshaped NDArray

expandDims
```
default NDArray expandDims(int axis)
```
Expands the Shape of a NDArray.
Inserts a new axis that will appear at the axis position in the expanded NDArray shape.
Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f});
 jshell> array;
 ND: (2) cpu() float32
 [1., 2.]
 jshell> array.expandDims(0);
 ND: (1, 2) cpu() float32
 [[1., 2.],
 ]
 jshell> array.expandDims(1);
 ND: (2, 1) cpu() float32
 [[1.],
  [2.],
 ]
 
```
Specified by:

expandDims in interface NDArray

Parameters:

axis - the position in the expanded axes where the new axis is placed

Returns:

the result NDArray. The number of dimensions is one greater than that of the NDArray

squeeze

default NDArray squeeze(int[] axes)

Removes singleton dimensions at the given axes.

Examples

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

Specified by:: squeeze in interface NDArray
Parameters:: axes - the axes at which to remove the singleton dimensions
Returns:: a result NDArray of same size and data without the axes at part of the shape

logicalAnd

default NDArray logicalAnd(NDArray other)

Returns the truth value of this NDArray AND the other NDArray element-wise.

The shapes of this NDArray and the other NDArray must be broadcastable.

Examples

 jshell> NDArray array1 = manager.create(new boolean[] {true});
 jshell> NDArray array2 = manager.create(new boolean[] {false});
 jshell> array1.logicalAnd(array2);
 ND: (1) cpu() boolean
 [false]
 jshell> array1 = manager.create(new boolean[] {true, false});
 jshell> array2 = manager.create(new boolean[] {false, false});
 jshell> array1.logicalAnd(array2);
 ND: (2) cpu() boolean
 [false, false]

 jshell> NDArray array = manager.arange(5f);
 jshell> array.gt(1).logicalAnd(array.lt(4));
 ND: (5) cpu() boolean
 [false, false,  true,  true, false]

Specified by:: logicalAnd in interface NDArray
Parameters:: other - the other NDArray to operate on
Returns:: the boolean NDArray of the logical AND operation applied to the elements of this NDArray and the other NDArray

logicalOr

default NDArray logicalOr(NDArray other)

Computes the truth value of this NDArray OR the other NDArray element-wise.

The shapes of this NDArray and the other NDArray must be broadcastable.

Examples

 jshell> NDArray array1 = manager.create(new boolean[] {true});
 jshell> NDArray array2 = manager.create(new boolean[] {false});
 jshell> array1.logicalOr(array2);
 ND: (1) cpu() boolean
 [ true]
 jshell> array1 = manager.create(new boolean[] {true, false});
 jshell> array2 = manager.create(new boolean[] {false, false});
 jshell> array1.logicalOr(array2);
 ND: (2) cpu() boolean
 [ true, false]

 jshell> NDArray array = manager.arange(5f);
 jshell> array.lt(1).logicalOr(array.gt(3));
 ND: (5) cpu() boolean
 [ true, false, false, false,  true]

Specified by:: logicalOr in interface NDArray
Parameters:: other - the other NDArray to operate on
Returns:: the boolean NDArray of the logical OR operation applied to the elements of this NDArray and the other NDArray

logicalXor

default NDArray logicalXor(NDArray other)

Computes the truth value of this NDArray XOR the other NDArray element-wise.

The shapes of this NDArray and the other NDArray must be broadcastable.

Examples

 jshell> NDArray array = manager.create(new boolean[] {true});
 jshell> array1.logicalXor(array2);
 ND: (1) cpu() boolean
 [ true]
 jshell> array1 = manager.create(new boolean[] {true, false});
 jshell> array2 = manager.create(new boolean[] {false, false});
 jshell> array1.logicalXor(array2);
 ND: (2) cpu() boolean
 [ true, false]

 jshell> NDArray array = manager.arange(5f);
 jshell> array.lt(1).logicalXor(array.gt(3));
 ND: (5) cpu() boolean
 [ true, false, false, false,  true]

Specified by:: logicalXor in interface NDArray
Parameters:: other - the other NDArray to operate on
Returns:: the boolean NDArray of the logical XOR operation applied to the elements of this NDArray and the other NDArray

logicalNot

default NDArray logicalNot()

Computes the truth value of NOT this NDArray element-wise.

Examples

 jshell> NDArray array = manager.create(new boolean[] {true});
 jshell> array.logicalNot();
 ND: (1) cpu() boolean
 [ false]

 jshell> NDArray array = manager.arange(5f);
 jshell> array.lt(1).logicalNot();
 ND: (5) cpu() boolean
 [false, true, true,  true,  true]

Specified by:: logicalNot in interface NDArray
Returns:: the boolean NDArray

argSort
```
default NDArray argSort(int axis,
                        boolean ascending)
```
Returns the indices that would sort this NDArray given the axis.
Perform an indirect sort along the given axis. It returns a NDArray of indices of the same Shape as this NDArray.
Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 3f, 2f, 2f}, new Shape(2, 2));
 jshell> array.argSort(0, false);
 ND: (2, 2) cpu() int64
 [[ 1,  0],
  [ 0,  1],
 ]
 
```
Specified by:

argSort in interface NDArray

Parameters:

axis - the axis to sort along

ascending - whether to sort ascending

Returns:

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

sort

default NDArray sort()

Sorts the flattened NDArray.

Examples

 jshell> NDArray array = manager.create(new float[] {1f, 4f, 3f, 1f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[1., 4.],
  [3., 1.],
 ]
 jshell> array.sort(); // sort the flattened array
 ND: (2, 2) cpu() float32
 [[1., 4.],
  [1., 3.],
 ]

Specified by:: sort in interface NDArray
Returns:: the sorted NDArray

sort

default NDArray sort(int axis)

Sorts the flattened NDArray.

Examples

 jshell> NDArray array = manager.create(new float[] {1f, 4f, 3f, 1f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[1., 4.],
  [3., 1.],
 ]
 jshell> array.sort(0); // sort along the first axis
 ND: (2, 2) cpu() float32
 [[1., 4.],
  [1., 3.],
 ]

Specified by:: sort in interface NDArray
Parameters:: axis - the axis to sort along
Returns:: the sorted NDArray

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

Specified by:

softmax in interface NDArray

Parameters:

axis - the axis along which to apply

Returns:

the result NDArray

See Also:

softmax, NDArray.softmax(int)

logSoftmax
```
default NDArray logSoftmax(int axis)
```
Applies the softmax function followed by a logarithm.
Mathematically equivalent to calling softmax and then log. This single operator is faster than calling two operators and numerically more stable when computing gradients.

Specified by:

logSoftmax in interface NDArray

Parameters:

axis - the axis along which to apply

Returns:

the result NDArray

cumSum

default NDArray cumSum()

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

Examples

 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f, 5f, 6f}, new Shape(2, 3));
 jshell> array;
 ND: (2, 3) cpu() float32
 [[1., 2., 3.],
  [4., 5., 6.],
 ]
 jshell> array.cumSum(); // cumSum on flattened array
 ND: (6) cpu() float32
 [ 1.,  3.,  6., 10., 15., 21.]

Specified by:: cumSum in interface NDArray
Returns:: the cumulative sum of the elements in the flattened NDArray

cumSum

default NDArray cumSum(int axis)

Return the cumulative sum of the elements along a given axis.

Examples

 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f, 5f, 6f}, new Shape(2, 3));
 jshell> array;
 ND: (2, 3) cpu() float32
 [[1., 2., 3.],
  [4., 5., 6.],
 ]
 jshell> array.cumSum(0);
 ND: (2, 3) cpu() float32
 [[1., 2., 3.],
  [5., 7., 9.],
 ]
 jshell> array.cumSum(1);
 ND: (2, 3) cpu() float32
 [[ 1.,  3.,  6.],
  [ 4.,  9., 15.],
 ]

Specified by:: cumSum in interface NDArray
Parameters:: axis - the axis along which the cumulative sum is computed
Returns:: the cumulative sum along the specified axis

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

Specified by:

isInfinite in interface NDArray

Returns:

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

isNaN
```
default NDArray isNaN()
```
Returns the boolean NDArray with value true where this NDArray's entries are NaN, or false where they are not NaN.
Examples
```
 jshell> NDArray array = manager.create(new float[] {Float.POSITIVE_INFINITY, 0, Float.NaN});
 jshell> array.isNaN();
 ND: (3) cpu() boolean
 [false, false,  true]
 
```
Specified by:

isNaN in interface NDArray

Returns:

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

tile
```
default NDArray tile(long repeats)
```
Constructs a NDArray by repeating this NDArray the number of times given repeats.
Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f});
 jshell> array.tile(2);
 ND: (6) cpu() float32
 [0., 1., 2., 0., 1., 2.]
 
```
Specified by:

tile in interface NDArray

Parameters:

repeats - the number of times to repeat for each dimension

Returns:

a NDArray that has been tiled

tile
```
default NDArray tile(int axis,
                     long repeats)
```
Constructs a NDArray by repeating this NDArray the number of times given by repeats along given axis.
Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f});
 jshell> array.tile(1, 2);
 ND: (1, 6) cpu() float32
 [[0., 1., 2., 0., 1., 2.],
 ]
 
```
Specified by:

tile in interface NDArray

Parameters:

axis - the axis to repeat

repeats - the number of times to repeat for each axis

Returns:

a NDArray that has been tiled

tile

default NDArray tile(long[] repeats)

Constructs a NDArray by repeating this NDArray the number of times given by repeats.

Examples

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

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

tile
```
default NDArray tile(Shape desiredShape)
```
Constructs a NDArray by repeating this NDArray the number of times to match the desired shape.
If the desired Shapehas fewer dimensions than this NDArray, it will tile against the last axis.
Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f});
 jshell> array.tile(new Shape(6));
 ND: (6) cpu() float32
 [0., 1., 2., 0., 1., 2.]
 
```
Specified by:

tile in interface NDArray

Parameters:

desiredShape - the Shapethat should be converted to

Returns:

a NDArray that has been tiled

repeat
```
default NDArray repeat(long repeats)
```
Repeats element of this NDArray the number of times given repeats.
Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f});
 jshell> array.repeat(2);
 ND: (6) cpu() float32
 [0., 0., 1., 1., 2., 2.]
 
```
Specified by:

repeat in interface NDArray

Parameters:

repeats - the number of times to repeat for each axis

Returns:

an NDArray that has been repeated

repeat
```
default NDArray repeat(int axis,
                       long repeats)
```
Repeats element of this NDArray the number of times given repeats along given axis.
Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f, 3f}, new Shape(2, 2));
 jshell> array.repeat(1, 2);
 ND: (6) cpu() float32
 [0., 0., 1., 1., 2., 2.]
 
```
Specified by:

repeat in interface NDArray

Parameters:

axis - the axis to repeat

repeats - the number of times to repeat for each axis

Returns:

an NDArray that has been repeated

repeat

default NDArray repeat(long[] repeats)

Repeats element of this NDArray the number of times given repeats along each axis.

Examples

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

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

repeat
```
default NDArray repeat(Shape desiredShape)
```
Repeats element of this NDArray to match the desired shape.
If the desired Shape has fewer dimensions that the array, it will repeat against the last axis.
Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 1f, 2f, 3f}, new Shape(2, 2));
 jshell> array.repeat(new Shape(4, 4));
 ND: (4, 4) cpu() float32
 [[0., 0., 1., 1.],
  [0., 0., 1., 1.],
  [2., 2., 3., 3.],
  [2., 2., 3., 3.],
 ]
 
```
Specified by:

repeat in interface NDArray

Parameters:

desiredShape - the Shape that should be converted to

Returns:

an NDArray that has been repeated

dot

default NDArray dot(NDArray other)

Dot product of this NDArray and the other NDArray.

If both this NDArray and the other NDArray are 1-D NDArrays, it is inner product of vectors (without complex conjugation).
If both this NDArray and the other NDArray are 2-D NDArrays, it is matrix multiplication.
If either this NDArray or the other NDArray is 0-D NDArray (scalar), it is equivalent to mul.
If this NDArray is N-D NDArray and the other NDArray is 1-D NDArray, it is a sum product over the last axis of those.
If this NDArray is N-D NDArray and the other NDArray is M-D NDArray(where M>=2), it is a sum product over the last axis of this NDArray and the second-to-last axis of the other NDArray

Examples

 jshell> NDArray array1 = manager.create(new float[] {1f, 2f, 3f});
 jshell> NDArray array2 = manager.create(new float[] {4f, 5f, 6f});
 jshell> array1.dot(array2); // inner product
 ND: () cpu() float32
 32.
 jshell> array1 = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array2 = manager.create(new float[] {5f, 6f, 7f, 8f}, new Shape(2, 2));
 jshell> array1.dot(array2); // matrix multiplication
 ND: (2, 2) cpu() float32
 [[19., 22.],
  [43., 50.],
 ]
 jshell> array1 = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array2 = manager.create(5f);
 jshell> array1.dot(array2);
 ND: (2, 2) cpu() float32
 [[ 5., 10.],
  [15., 20.],
 ]
 jshell> array1 = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array2 = manager.create(new float[] {1f, 2f});
 jshell> array1.dot(array2);
 ND: (2) cpu() float32
 [ 5., 11.]
 jshell> array1 = manager.create(new float[] {1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f}, new Shape(2, 2, 2));
 jshell> array2 = manager.create(new float[] {1f, 2f, 3f ,4f}, new Shape(2, 2));
 jshell> array1.dot(array2);
 ND: (2, 2, 2) cpu() float32
 [[[ 7., 10.],
   [15., 22.],
  ],
  [[23., 34.],
   [31., 46.],
  ],
 ]

Specified by:: dot in interface NDArray
Parameters:: other - the other NDArray to perform dot product with
Returns:: the result NDArray

matMul

default NDArray matMul(NDArray other)

Product matrix of this NDArray and the other NDArray.

The behavior depends on the arguments in the following way.

If both this NDArray and the other NDArray are 2-D NDArrays, they are multiplied like conventional matrices
If either this NDArray or the other NDArray is N-D NDArray, N > 2 , it is treated as a stack of matrices residing in the last two indexes and broadcast accordingly.
If this NDArray is 1-D NDArray, it is promoted to a matrix by prepending a 1 to its dimensions. After matrix multiplication the prepended 1 is removed.
If other NDArray is 1-D NDArray, it is promoted to a matrix by appending a 1 to its dimensions. After matrix multiplication the appended 1 is removed.

Examples

 jshell> NDArray array1 = manager.create(new float[] {1f, 0f, 0f, 1f}, new Shape(2, 2));
 jshell> NDArray array2 = manager.create(new float[] {4f, 1f, 2f, 2f}, new Shape(2, 2));
 jshell> array1.matMul(array2); // for 2-D arrays, it is the matrix product
 ND: (2, 2) cpu() float32
 [[4., 1.],
  [2., 2.],
 ]
 jshell> array1 = manager.create(new float[] {1f, 0f, 0f, 1f}, new Shape(2, 2));
 jshell> array2 = manager.create(new float[] {1f, 2f});
 jshell> array1.matMul(array2);
 ND: (2) cpu() float32
 [1., 2.]
 jshell> array1 = manager.create(new float[] {1f, 0f, 0f, 1f}, new Shape(2, 2));
 jshell> array2 = manager.create(new float[] {1f, 2f});
 jshell> array1.matMul(array2);
 ND: (2) cpu() float32
 [1., 2.]
 jshell> array1 = manager.arange(2f * 2f * 4f).reshape(2, 2, 4);
 jshell> array2 = manager.arange(2f * 2f * 4f).reshape(2, 4, 2);
 jshell> array1.matMul(array2).get("0, 1, 1");
 ND: () cpu() float32
 98.

Specified by:: matMul in interface NDArray
Parameters:: other - the other NDArray to perform matrix product with
Returns:: the result NDArray

clip
```
default NDArray clip(java.lang.Number min,
                     java.lang.Number max)
```
Clips (limit) the values in this NDArray.
Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of [0, 1] is specified, values smaller than 0 become 0, and values larger than 1 become 1.
Examples
```
 jshell> NDArray array = manager.arange(10f);
 jshell> array.clip(1, 8);
 ND: (10) cpu() float32
 [1., 1., 2., 3., 4., 5., 6., 7., 8., 8.]
 
```
Specified by:

clip in interface NDArray

Parameters:

min - the minimum value

max - the maximum value

Returns:

an NDArray with the elements of this NDArray, but where values < min are replaced with min, and those > max with max

flip
```
default NDArray flip(int... axes)
```
Returns the reverse order of elements in an array along the given axis.
The shape of the array is preserved, but the elements are reordered.

Specified by:

flip in interface NDArray

Parameters:

axes - the axes to flip on

Returns:

the newly flipped array

transpose

default NDArray transpose()

Returns this NDArray with axes transposed.

Examples

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

Specified by:: transpose in interface NDArray
Returns:: the newly permuted array

transpose

default NDArray transpose(int... axes)

Returns this NDArray with given axes transposed.

Examples

 jshell> NDArray array = manager.create(new float[] {1f, 2f ,3f, 4f}, new Shape(2, 2));
 jshell> array;
 ND: (2, 2) cpu() float32
 [[1., 2.],
  [3., 4.],
 ]
 jshell> array.transpose(1, 0);
 ND: (2, 2) cpu() float32
 [[1., 3.],
  [2., 4.],
 ]
 jshell> array = manager.arange(8f).reshape(2, 2, 2);
 jshell> array;
 ND: (2, 2, 2) cpu() float32
 [[[0., 1.],
   [2., 3.],
  ],
  [[4., 5.],
   [6., 7.],
  ],
 ]
 jshell> array.transpose(1, 0, 2);
 ND: (2, 2, 2) cpu() float32
 [[[0., 1.],
   [4., 5.],
  ],
  [[2., 3.],
   [6., 7.],
  ],
 ]

Specified by:: transpose in interface NDArray
Parameters:: axes - the axes to swap to
Returns:: the transposed NDArray

broadcast

default NDArray broadcast(Shape shape)

Broadcasts this NDArray to be the given shape.

Examples

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

Specified by:: broadcast in interface NDArray
Parameters:: shape - the new Shape of this NDArray
Returns:: the broadcasted NDArray

argMax

default NDArray argMax()

Returns the indices of the maximum values into the flattened NDArray.

Examples

 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.argMax();
 ND: () cpu() int64
 5.

Specified by:: argMax in interface NDArray
Returns:: a NDArray containing indices

argMax

default NDArray argMax(int axis)

Returns the indices of the maximum values along given axis.

Examples

 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.argMax(0);
 ND: (3) cpu() int64
 [1, 1, 1]
 jshell> array.argMax(1);
 ND: (2) cpu() int64
 [2, 2]

Specified by:: argMax in interface NDArray
Parameters:: axis - the axis along which to find maximum values
Returns:: a NDArray containing indices

argMin

default NDArray argMin()

Returns the indices of the minimum values into the flattened NDArray.

Examples

 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.argMin();
 ND: () cpu() int64
 0.

Specified by:: argMin in interface NDArray
Returns:: a NDArray containing indices

argMin

default NDArray argMin(int axis)

Returns the indices of the minimum values along given axis.

Examples

 jshell> NDArray array = manager.arange(6f).reshape(2, 3);
 jshell> array;
 ND: (2, 3) cpu() float32
 [[0., 1., 2.],
  [3., 4., 5.],
 ]
 jshell> array.argMin(0);
 ND: (3) cpu() int64
 [0, 0, 0]
 jshell> array.argMin(1);
 ND: (2) cpu() int64
 [0, 0]

Specified by:: argMin in interface NDArray
Parameters:: axis - the axis along which to find minimum values
Returns:: a NDArray containing indices

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

Specified by:

percentile in interface NDArray

Parameters:

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

Returns:

the result NDArray

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

Specified by:

percentile in interface NDArray

Parameters:

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

axes - the dimension to calculate percentile for

Returns:

the result NDArray NDArray

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

Specified by:

median in interface NDArray

Returns:

the median NDArray

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

Specified by:

median in interface NDArray

Parameters:

axes - the axes along which to perform the median operation

Returns:

the median NDArray along the specified axes

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

Specified by:

toDense in interface NDArray

Returns:

the result NDArray

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

Specified by:

toSparse in interface NDArray

Parameters:

fmt - the SparseFormat of this NDArray

Returns:

the result NDArray

nonzero

default NDArray nonzero()

Returns the indices of elements that are non-zero.

Note that the behavior is slightly different from numpy.nonzero. Numpy returns a tuple of NDArray, one for each dimension of NDArray. DJL nonzero returns only one NDArray with last dimension containing all dimension of indices.

Examples

 jshell> NDArray array = manager.create(new float[] {1f, 1f, 1f, 0f, 1f});
 jshell> array.nonzero();
 ND: (4, 1) cpu() int64
 [[ 0],
  [ 1],
  [ 2],
  [ 4],
 ]
 jshell> array = manager.create(new float[] {3f, 0f, 0f, 0f, 4f, 0f, 5f, 6f, 0f}).reshape(3, 3);
 jshell> array;
 ND: (3, 3) cpu() float32
 [[3., 0., 0.],
  [0., 4., 0.],
  [5., 6., 0.],
 ]
 jshell> array.nonzero();
 ND: (4, 2) cpu() int64
 [[ 0,  0],
  [ 1,  1],
  [ 2,  0],
  [ 2,  1],
 ]

Specified by:: nonzero in interface NDArray
Returns:: the indices of the elements that are non-zero

erfinv
```
default NDArray erfinv()
```
Returns element-wise inverse gauss error function of the NDArray.
Examples
```
 jshell> NDArray array = manager.create(new float[] {0f, 0.5f, -1f});
 jshell> array.erfinv();
 ND: (3) cpu() float32
 [0., 0.4769, -inf]
 
```
Specified by:

erfinv in interface NDArray

Returns:

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

norm
```
default NDArray norm(boolean keepDims)
```
Returns the norm of this NDArray.
Examples
```
 jshell> NDArray array = manager.create(new float[] {-3f, -4f});
 jshell> array.norm(true);
 ND: () cpu() float32
 5.
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.norm(true);
 ND: () cpu() float32
 [[5.4772],
 ]
 
```
Specified by:

norm in interface NDArray

Parameters:

keepDims - If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original x.

Returns:

the norm of this NDArray

norm
```
default NDArray norm(int ord,
                     int[] axes,
                     boolean keepDims)
```
Returns the norm of this NDArray.
Examples
```
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.norm(2, new int[] {0}, true);
 ND: (1, 2) cpu() float32
 [[3.1623, 4.4721],
 ]
 jshell> NDArray array = manager.create(new float[] {1f, 2f, 3f, 4f}, new Shape(2, 2));
 jshell> array.norm(2, new int[] {0}, false);
 ND: (2) cpu() float32
 [3.1623, 4.4721]
 
```
Specified by:

norm in interface NDArray

Parameters:

ord - Order of the norm.

axes - If axes contains an integer, it specifies the axis of x along which to compute the vector norms. If axis contains 2 integers, it specifies the axes that hold 2-D matrices, and the matrix norms of these matrices are computed.

keepDims - keepDims If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original x.

Returns:

the norm of this NDArray

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

Specified by:

getNDArrayInternal in interface NDArray

Returns:

an internal representative of Native NDArray

Interface NDArrayAdapter

Field Summary

Method Summary

Methods inherited from interface ai.djl.ndarray.NDArray

Field Detail

UNSUPPORTED_MSG

Method Detail

getManager

getName

setName

getUid

getDataType

getDevice

getShape

getSparseFormat

attach

detach

toDevice

toType

attachGradient

attachGradient

getGradient

hasGradient

stopGradient

toByteBuffer

set

copyTo

booleanMask

sequenceMask

sequenceMask

zerosLike

onesLike

contentEquals

contentEquals

eq

eq

neq

neq

gt

gt

gte

gte

lt

lt

lte

lte

add

add

sub

sub

mul

mul

div

div

mod

mod

pow

pow

addi

addi

subi

subi

muli

muli

divi

divi

modi

modi

powi

powi

sign

signi

maximum

maximum

minimum

minimum

neg

negi

abs

square