org.nd4j.linalg.factory.ops

## Class NDMath

• ```public class NDMath
extends Object```
• ### Constructor Summary

Constructors
Constructor and Description
`NDMath()`
• ### Method Summary

All Methods
Modifier and Type Method and Description
`INDArray` `abs(INDArray x)`
Elementwise absolute value operation: out = abs(x)
`INDArray` `acos(INDArray x)`
Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
`INDArray` `acosh(INDArray x)`
Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
`INDArray` ```add(INDArray x, double value)```
Scalar add operation, out = in + scalar
`INDArray` ```add(INDArray x, INDArray y)```
Pairwise addition operation, out = x + y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray` ```amax(INDArray in, int... dimensions)```
Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
`INDArray` ```amean(INDArray in, int... dimensions)```
Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
`INDArray` ```amin(INDArray in, int... dimensions)```
Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
`INDArray` ```and(INDArray x, INDArray y)```
Boolean AND operation: elementwise (x != 0) && (y != 0)
If x and y arrays have equal shape, the output shape is the same as these inputs.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`INDArray` `asin(INDArray x)`
Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
`INDArray` `asinh(INDArray x)`
Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
`INDArray` ```asum(INDArray in, int... dimensions)```
Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
`INDArray` `atan(INDArray x)`
Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
`INDArray` ```atan2(INDArray y, INDArray x)```
Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
Similar to atan(y/x) but sigts of x and y are used to determine the location of the result
`INDArray` `atanh(INDArray x)`
Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
`INDArray` ```bitShift(INDArray x, INDArray shift)```
Bit shift operation
`INDArray` ```bitShiftRight(INDArray x, INDArray shift)```
Right bit shift operation
`INDArray` ```bitShiftRotl(INDArray x, INDArray shift)```
Cyclic bit shift operation
`INDArray` ```bitShiftRotr(INDArray x, INDArray shift)```
Cyclic right shift operation
`INDArray` `ceil(INDArray x)`
Element-wise ceiling function: out = ceil(x).
Rounds each value up to the nearest integer value (if not already an integer)
`INDArray` ```clipByAvgNorm(INDArray x, double clipValue, int... dimensions)```
Clips tensor values to a maximum average L2-norm.
`INDArray` ```clipByNorm(INDArray x, double clipValue, int... dimensions)```
Clipping by L2 norm, optionally along dimension(s)
if l2Norm(x,dimension) < clipValue, then input is returned unmodifed
Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according
to the corresponding l2Norm along the specified dimensions
`INDArray` ```clipByValue(INDArray x, double clipValueMin, double clipValueMax)```
Element-wise clipping function:
out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax
out[i] = clipValueMin if in[i] < clipValueMin
out[i] = clipValueMax if in[i] > clipValueMax
`INDArray` ```confusionMatrix(INDArray labels, INDArray pred, DataType dataType)```
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.
`INDArray` ```confusionMatrix(INDArray labels, INDArray pred, INDArray weights)```
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.
`INDArray` ```confusionMatrix(INDArray labels, INDArray pred, INDArray weights, int numClasses)```
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.
For example, if labels = [0, 1, 1], predicted = [0, 2, 1], numClasses = 4, and weights = [1, 2, 3]
[1, 0, 0, 0]
[0, 3, 2, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
`INDArray` ```confusionMatrix(INDArray labels, INDArray pred, int numClasses)```
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.
For example, if labels = [0, 1, 1], predicted = [0, 2, 1], and numClasses=4 then output is:
[1, 0, 0, 0]
[0, 1, 1, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
`INDArray` `cos(INDArray x)`
Elementwise cosine operation: out = cos(x)
`INDArray` `cosh(INDArray x)`
Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
`INDArray` ```cosineDistance(INDArray x, INDArray y, int... dimensions)```
Cosine distance reduction operation.
`INDArray` ```cosineSimilarity(INDArray x, INDArray y, int... dimensions)```
Cosine similarity pairwise reduction operation.
`INDArray` ```countNonZero(INDArray in, int... dimensions)```
Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
`INDArray` ```countZero(INDArray in, int... dimensions)```
Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
`INDArray` ```cross(INDArray a, INDArray b)```
Returns the pair-wise cross product of equal size arrays a and b: a x b = ||a||x||b|| sin(theta).
Can take rank 1 or above inputs (of equal shapes), but note that the last dimension must have dimension 3
`INDArray` `cube(INDArray x)`
Element-wise cube function: out = x^3
`INDArray` `diag(INDArray x)`
Returns an output variable with diagonal values equal to the specified values; off-diagonal values will be set to 0
For example, if input = [1,2,3], then output is given by:
[ 1, 0, 0]
[ 0, 2, 0]
[ 0, 0, 3]

Higher input ranks are also supported: if input has shape [a,...,R-1] then output[i,...,k,i,...,k] = input[i,...,k].
i.e., for input rank R, output has rank 2R
`INDArray` `diagPart(INDArray x)`
Extract the diagonal part from the input array.
If input is
[ 1, 0, 0]
[ 0, 2, 0]
[ 0, 0, 3]
then output is [1, 2, 3].
Supports higher dimensions: in general, out[i,...,k] = in[i,...,k,i,...,k]
`INDArray` ```div(INDArray x, double value)```
Scalar division operation, out = in / scalar
`INDArray` ```div(INDArray x, INDArray y)```
Pairwise division operation, out = x / y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray` ```embeddingLookup(INDArray x, INDArray indices, PartitionMode PartitionMode)```
Looks up ids in a list of embedding tensors.
`INDArray` ```entropy(INDArray in, int... dimensions)```
Entropy reduction: -sum(x * log(x))
`INDArray` `erf(INDArray x)`
Element-wise Gaussian error function - out = erf(in)
`INDArray` `erfc(INDArray x)`
Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
`INDArray` ```euclideanDistance(INDArray x, INDArray y, int... dimensions)```
Euclidean distance (l2 norm, l2 distance) reduction operation.
`INDArray` `exp(INDArray x)`
Elementwise exponent function: out = exp(x) = 2.71828...^x
`INDArray` `expm1(INDArray x)`
Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
`INDArray` `eye(INDArray rows)`
As per eye(String, int) but with the number of rows specified as a scalar INDArray
`INDArray` ```eye(INDArray rows, INDArray cols)```
As per eye(int, int) bit with the number of rows/columns specified as scalar INDArrays
`INDArray` `eye(int rows)`
Generate an identity matrix with the specified number of rows and columns.
`INDArray` ```eye(int rows, int cols)```
As per eye(String, int, int, DataType) but with the default datatype, Eye.DEFAULT_DTYPE
`INDArray` ```eye(int rows, int cols, DataType dataType, int... dimensions)```
Generate an identity matrix with the specified number of rows and columns
Example:
`INDArray` ```firstIndex(INDArray in, Condition condition, boolean keepDims, int... dimensions)```
First index reduction operation.
Returns a variable that contains the index of the first element that matches the specified condition (for each
slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.
`INDArray` ```firstIndex(INDArray in, Condition condition, int... dimensions)```
First index reduction operation.
Returns a variable that contains the index of the first element that matches the specified condition (for each
slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.
`INDArray` `floor(INDArray x)`
Element-wise floor function: out = floor(x).
Rounds each value down to the nearest integer value (if not already an integer)
`INDArray` ```floorDiv(INDArray x, INDArray y)```
Pairwise floor division operation, out = floor(x / y)
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray` ```floorMod(INDArray x, double value)```
Scalar floor modulus operation
`INDArray` ```floorMod(INDArray x, INDArray y)```
Pairwise Modulus division operation
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray` ```hammingDistance(INDArray x, INDArray y, int... dimensions)```
Hamming distance reduction operation.
`INDArray` ```iamax(INDArray in, boolean keepDims, int... dimensions)```
Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)
`INDArray` ```iamax(INDArray in, int... dimensions)```
Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)
`INDArray` ```iamin(INDArray in, boolean keepDims, int... dimensions)```
Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)
`INDArray` ```iamin(INDArray in, int... dimensions)```
Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)
`INDArray` `isFinite(INDArray x)`
Is finite operation: elementwise isFinite(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
`INDArray` `isInfinite(INDArray x)`
Is infinite operation: elementwise isInfinite(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
`INDArray` `isMax(INDArray x)`
Is maximum operation: elementwise x == max(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
`INDArray` `isNaN(INDArray x)`
Is Not a Number operation: elementwise isNaN(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
`INDArray` `isNonDecreasing(INDArray x)`
Is the array non decreasing?
An array is non-decreasing if for every valid i, x[i] <= x[i+1].
`INDArray` `isStrictlyIncreasing(INDArray x)`
Is the array strictly increasing?
An array is strictly increasing if for every valid i, x[i] < x[i+1].
`INDArray` ```jaccardDistance(INDArray x, INDArray y, int... dimensions)```
Jaccard similarity reduction operation.
`INDArray` ```lastIndex(INDArray in, Condition condition, boolean keepDims, int... dimensions)```
Last index reduction operation.
Returns a variable that contains the index of the last element that matches the specified condition (for each
slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.
`INDArray` ```lastIndex(INDArray in, Condition condition, int... dimensions)```
Last index reduction operation.
Returns a variable that contains the index of the last element that matches the specified condition (for each
slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.
`INDArray[]` ```listDiff(INDArray x, INDArray y)```
Calculates difference between inputs X and Y.
`INDArray` `log(INDArray x)`
Element-wise logarithm function (base e - natural logarithm): out = log(x)
`INDArray` ```log(INDArray x, double base)```
Element-wise logarithm function (with specified base): out = log_{base}(x)
`INDArray` `log1p(INDArray x)`
Elementwise natural logarithm function: out = log_e (1 + x)
`INDArray` ```logEntropy(INDArray in, int... dimensions)```
Log entropy reduction: log(-sum(x * log(x)))
`INDArray` ```logSumExp(INDArray input, int... dimensions)```
Log-sum-exp reduction (optionally along dimension).
Computes log(sum(exp(x))
`INDArray` ```manhattanDistance(INDArray x, INDArray y, int... dimensions)```
Manhattan distance (l1 norm, l1 distance) reduction operation.
`INDArray` `matrixDeterminant(INDArray in)`
Matrix determinant op.
`INDArray` `matrixInverse(INDArray in)`
Matrix inverse op.
`INDArray` ```max(INDArray x, INDArray y)```
Pairwise max operation, out = max(x, y)
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray` `mergeAdd(INDArray... inputs)`
Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition:
out = sum_i in[i]
`INDArray` `mergeAvg(INDArray... inputs)`
Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation:
out = mean_i in[i]
`INDArray` `mergeMax(INDArray... inputs)`
Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation:
out = max_i in[i]
`INDArray` `mergeMaxIndex(INDArray... x)`
Return array of max elements indices with along tensor dimensions
`INDArray` ```mergeMaxIndex(INDArray[] x, DataType dataType)```
Return array of max elements indices with along tensor dimensions
`INDArray[]` ```meshgrid(INDArray[] inputs, boolean cartesian)```
Broadcasts parameters for evaluation on an N-D grid.
`INDArray` ```min(INDArray x, INDArray y)```
Pairwise max operation, out = min(x, y)
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray` ```mod(INDArray x, INDArray y)```
Pairwise modulus (remainder) operation, out = x % y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray[]` ```moments(INDArray input, int... axes)```
Calculate the mean and (population) variance for the input variable, for the specified axis
`INDArray` ```mul(INDArray x, double value)```
Scalar multiplication operation, out = in * scalar
`INDArray` ```mul(INDArray x, INDArray y)```
Pairwise multiplication operation, out = x * y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray` `neg(INDArray x)`
Elementwise negative operation: out = -x
`INDArray[]` ```normalizeMoments(INDArray counts, INDArray means, INDArray variances, double shift)```
Calculate the mean and variance from the sufficient statistics
`INDArray` ```or(INDArray x, INDArray y)```
Boolean OR operation: elementwise (x != 0) || (y != 0)
If x and y arrays have equal shape, the output shape is the same as these inputs.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`INDArray` ```pow(INDArray x, double value)```
Element-wise power function: out = x^value
`INDArray` ```pow(INDArray x, INDArray y)```
Element-wise (broadcastable) power function: out = x[i]^y[i]
`INDArray` `rationalTanh(INDArray x)`
Rational Tanh Approximation elementwise function, as described in the paper:
Compact Convolutional Neural Network Cascade for Face Detection
This is a faster Tanh approximation
`INDArray` ```rdiv(INDArray x, double value)```
Scalar reverse division operation, out = scalar / in
`INDArray` ```rdiv(INDArray x, INDArray y)```
Pairwise reverse division operation, out = y / x
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray` `reciprocal(INDArray x)`
Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
`INDArray` `rectifiedTanh(INDArray x)`
Rectified tanh operation: max(0, tanh(in))
`INDArray` `round(INDArray x)`
Element-wise round function: out = round(x).
Rounds (up or down depending on value) to the nearest integer value.
`INDArray` `rsqrt(INDArray x)`
Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
`INDArray` ```rsub(INDArray x, double value)```
Scalar reverse subtraction operation, out = scalar - in
`INDArray` ```rsub(INDArray x, INDArray y)```
Pairwise reverse subtraction operation, out = y - x
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray` ```setDiag(INDArray in, INDArray diag)```
Set the diagonal value to the specified values
If input is
[ a, b, c]
[ d, e, f]
[ g, h, i]
and diag = [ 1, 2, 3] then output is
[ 1, b, c]
[ d, 2, f]
[ g, h, 3]
`INDArray` ```shannonEntropy(INDArray in, int... dimensions)```
Shannon Entropy reduction: -sum(x * log2(x))
`INDArray` `sign(INDArray x)`
Element-wise sign (signum) function:
out = -1 if in < 0
out = 0 if in = 0
out = 1 if in > 0
`INDArray` `sin(INDArray x)`
Elementwise sine operation: out = sin(x)
`INDArray` `sinh(INDArray x)`
Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
`INDArray` `sqrt(INDArray x)`
Element-wise square root function: out = sqrt(x)
`INDArray` `square(INDArray x)`
Element-wise square function: out = x^2
`INDArray` ```squaredDifference(INDArray x, INDArray y)```
Pairwise squared difference operation.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray` ```standardize(INDArray x, int... dimensions)```
Standardize input variable along given axis
`INDArray` ```step(INDArray x, double value)```
Elementwise step function:
out(x) = 1 if x >= cutoff
out(x) = 0 otherwise
`INDArray` ```sub(INDArray x, double value)```
Scalar subtraction operation, out = in - scalar
`INDArray` ```sub(INDArray x, INDArray y)```
Pairwise subtraction operation, out = x - y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
`INDArray` `tan(INDArray x)`
Elementwise tangent operation: out = tan(x)
`INDArray` `tanh(INDArray x)`
Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
`INDArray` `trace(INDArray in)`
Matrix trace operation
For rank 2 matrices, the output is a scalar vith the trace - i.e., sum of the main diagonal.
For higher rank inputs, output[a,b,c] = trace(in[a,b,c,:,:])
`INDArray` ```xor(INDArray x, INDArray y)```
Boolean XOR (exclusive OR) operation: elementwise (x != 0) XOR (y != 0)
If x and y arrays have equal shape, the output shape is the same as these inputs.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`INDArray` `zeroFraction(INDArray input)`
Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
• ### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ### Constructor Detail

• #### NDMath

`public NDMath()`
• ### Method Detail

• #### clipByAvgNorm

```public INDArray clipByAvgNorm(INDArray x,
double clipValue,
int... dimensions)```
Clips tensor values to a maximum average L2-norm.
Parameters:
`x` - Input variable (NUMERIC type)
`clipValue` - Value for clipping
`dimensions` - Dimensions to reduce over (Size: AtLeast(min=0))
Returns:
output Output variable (NUMERIC type)
• #### embeddingLookup

```public INDArray embeddingLookup(INDArray x,
INDArray indices,
PartitionMode PartitionMode)```
Looks up ids in a list of embedding tensors.
Parameters:
`x` - Input tensor (NUMERIC type)
`indices` - A Tensor containing the ids to be looked up. (INT type)
`PartitionMode` - partition_mode == 0 - i.e. 'mod' , 1 - 'div'
Returns:
output Shifted output (NUMERIC type)
• #### mergeMaxIndex

```public INDArray mergeMaxIndex(INDArray[] x,
DataType dataType)```
Return array of max elements indices with along tensor dimensions
Parameters:
`x` - Input tensor (NUMERIC type)
`dataType` - Data type
Returns:
output Array max elements indices with along dimensions. (INT type)
• #### mergeMaxIndex

`public INDArray mergeMaxIndex(INDArray... x)`
Return array of max elements indices with along tensor dimensions
Parameters:
`x` - Input tensor (NUMERIC type)
Returns:
output Array max elements indices with along dimensions. (INT type)
• #### abs

`public INDArray abs(INDArray x)`
Elementwise absolute value operation: out = abs(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### acos

`public INDArray acos(INDArray x)`
Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### acosh

`public INDArray acosh(INDArray x)`
Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)

```public INDArray add(INDArray x,
INDArray y)```
Pairwise addition operation, out = x + y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - Input variable (NUMERIC type)
`y` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)

```public INDArray add(INDArray x,
double value)```
Scalar add operation, out = in + scalar
Parameters:
`x` - Input variable (NUMERIC type)
`value` - Scalar value for op
Returns:
output Output variable (NUMERIC type)
• #### amax

```public INDArray amax(INDArray in,
int... dimensions)```
Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
Parameters:
`in` - Input variable (NUMERIC type)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### amean

```public INDArray amean(INDArray in,
int... dimensions)```
Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
Parameters:
`in` - Input variable (NUMERIC type)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### amin

```public INDArray amin(INDArray in,
int... dimensions)```
Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
Parameters:
`in` - Input variable (NUMERIC type)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### and

```public INDArray and(INDArray x,
INDArray y)```
Boolean AND operation: elementwise (x != 0) && (y != 0)
If x and y arrays have equal shape, the output shape is the same as these inputs.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
Parameters:
`x` - Input 1 (BOOL type)
`y` - Input 2 (BOOL type)
Returns:
output INDArray with values 0 and 1 based on where the condition is satisfied (BOOL type)
• #### asin

`public INDArray asin(INDArray x)`
Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### asinh

`public INDArray asinh(INDArray x)`
Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### asum

```public INDArray asum(INDArray in,
int... dimensions)```
Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
Parameters:
`in` - Input variable (NUMERIC type)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### atan

`public INDArray atan(INDArray x)`
Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### atan2

```public INDArray atan2(INDArray y,
INDArray x)```
Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
Similar to atan(y/x) but sigts of x and y are used to determine the location of the result
Parameters:
`y` - Input Y variable (NUMERIC type)
`x` - Input X variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### atanh

`public INDArray atanh(INDArray x)`
Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### bitShift

```public INDArray bitShift(INDArray x,
INDArray shift)```
Bit shift operation
Parameters:
`x` - input (NUMERIC type)
`shift` - shift value (NUMERIC type)
Returns:
output shifted output (NUMERIC type)
• #### bitShiftRight

```public INDArray bitShiftRight(INDArray x,
INDArray shift)```
Right bit shift operation
Parameters:
`x` - Input tensor (NUMERIC type)
`shift` - shift argument (NUMERIC type)
Returns:
output shifted output (NUMERIC type)
• #### bitShiftRotl

```public INDArray bitShiftRotl(INDArray x,
INDArray shift)```
Cyclic bit shift operation
Parameters:
`x` - Input tensor (NUMERIC type)
`shift` - shift argy=ument (NUMERIC type)
Returns:
output shifted output (NUMERIC type)
• #### bitShiftRotr

```public INDArray bitShiftRotr(INDArray x,
INDArray shift)```
Cyclic right shift operation
Parameters:
`x` - Input tensor (NUMERIC type)
`shift` - Shift argument (NUMERIC type)
Returns:
output Shifted output (NUMERIC type)
• #### ceil

`public INDArray ceil(INDArray x)`
Element-wise ceiling function: out = ceil(x).
Rounds each value up to the nearest integer value (if not already an integer)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### clipByNorm

```public INDArray clipByNorm(INDArray x,
double clipValue,
int... dimensions)```
Clipping by L2 norm, optionally along dimension(s)
if l2Norm(x,dimension) < clipValue, then input is returned unmodifed
Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according
to the corresponding l2Norm along the specified dimensions
Parameters:
`x` - Input variable (NUMERIC type)
`clipValue` - Clipping value (maximum l2 norm)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
Returns:
output Output variable (NUMERIC type)
• #### clipByValue

```public INDArray clipByValue(INDArray x,
double clipValueMin,
double clipValueMax)```
Element-wise clipping function:
out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax
out[i] = clipValueMin if in[i] < clipValueMin
out[i] = clipValueMax if in[i] > clipValueMax
Parameters:
`x` - Input variable (NUMERIC type)
`clipValueMin` - Minimum value for clipping
`clipValueMax` - Maximum value for clipping
Returns:
output Output variable (NUMERIC type)
• #### confusionMatrix

```public INDArray confusionMatrix(INDArray labels,
INDArray pred,
DataType dataType)```
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. This version assumes the number of classes is 1 + max(max(labels), max(pred))
For example, if labels = [0, 1, 1] and predicted = [0, 2, 1] then output is:
[1, 0, 0]
[0, 1, 1]
[0, 0, 0]
Parameters:
`labels` - Labels - 1D array of integer values representing label values (NUMERIC type)
`pred` - Predictions - 1D array of integer values representing predictions. Same length as labels (NUMERIC type)
`dataType` - Data type
Returns:
output variable (2D, shape [numClasses, numClasses}) (NUMERIC type)
• #### confusionMatrix

```public INDArray confusionMatrix(INDArray labels,
INDArray pred,
int numClasses)```
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.
For example, if labels = [0, 1, 1], predicted = [0, 2, 1], and numClasses=4 then output is:
[1, 0, 0, 0]
[0, 1, 1, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
Parameters:
`labels` - Labels - 1D array of integer values representing label values (NUMERIC type)
`pred` - Predictions - 1D array of integer values representing predictions. Same length as labels (NUMERIC type)
`numClasses` - Number of classes
Returns:
output variable (2D, shape [numClasses, numClasses}) (NUMERIC type)
• #### confusionMatrix

```public INDArray confusionMatrix(INDArray labels,
INDArray pred,
INDArray weights)```
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. This version assumes the number of classes is 1 + max(max(labels), max(pred))
For example, if labels = [0, 1, 1], predicted = [0, 2, 1] and weights = [1, 2, 3]
[1, 0, 0]
[0, 3, 2]
[0, 0, 0]
Parameters:
`labels` - Labels - 1D array of integer values representing label values (NUMERIC type)
`pred` - Predictions - 1D array of integer values representing predictions. Same length as labels (NUMERIC type)
`weights` - Weights - 1D array of values (may be real/decimal) representing the weight/contribution of each prediction. Must be same length as both labels and predictions arrays (NUMERIC type)
Returns:
output variable (2D, shape [numClasses, numClasses}) (NUMERIC type)
• #### confusionMatrix

```public INDArray confusionMatrix(INDArray labels,
INDArray pred,
INDArray weights,
int numClasses)```
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.
For example, if labels = [0, 1, 1], predicted = [0, 2, 1], numClasses = 4, and weights = [1, 2, 3]
[1, 0, 0, 0]
[0, 3, 2, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
Parameters:
`labels` - Labels - 1D array of integer values representing label values (NUMERIC type)
`pred` - Predictions - 1D array of integer values representing predictions. Same length as labels (NUMERIC type)
`weights` - Weights - 1D array of values (may be real/decimal) representing the weight/contribution of each prediction. Must be same length as both labels and predictions arrays (NUMERIC type)
`numClasses` -
Returns:
output Output variable (2D, shape [numClasses, numClasses}) (NUMERIC type)
• #### cos

`public INDArray cos(INDArray x)`
Elementwise cosine operation: out = cos(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### cosh

`public INDArray cosh(INDArray x)`
Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### cosineDistance

```public INDArray cosineDistance(INDArray x,
INDArray y,
int... dimensions)```
Cosine distance reduction operation. The output contains the cosine distance for each
tensor/subset along the specified dimensions:
out = 1.0 - cosineSimilarity(x,y)
Parameters:
`x` - Input variable x (NUMERIC type)
`y` - Input variable y (NUMERIC type)
`dimensions` - Dimensions to calculate cosineDistance over (Size: AtLeast(min=0))
Returns:
output Output variable (NUMERIC type)
• #### cosineSimilarity

```public INDArray cosineSimilarity(INDArray x,
INDArray y,
int... dimensions)```
Cosine similarity pairwise reduction operation. The output contains the cosine similarity for each tensor/subset
along the specified dimensions:
out = (sum_i x[i] * y[i]) / ( sqrt(sum_i x[i]^2) * sqrt(sum_i y[i]^2)
Parameters:
`x` - Input variable x (NUMERIC type)
`y` - Input variable y (NUMERIC type)
`dimensions` - Dimensions to calculate cosineSimilarity over (Size: AtLeast(min=0))
Returns:
output Output variable (NUMERIC type)
• #### countNonZero

```public INDArray countNonZero(INDArray in,
int... dimensions)```
Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
Parameters:
`in` - Input variable (NUMERIC type)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### countZero

```public INDArray countZero(INDArray in,
int... dimensions)```
Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
Parameters:
`in` - Input variable (NUMERIC type)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### cross

```public INDArray cross(INDArray a,
INDArray b)```
Returns the pair-wise cross product of equal size arrays a and b: a x b = ||a||x||b|| sin(theta).
Can take rank 1 or above inputs (of equal shapes), but note that the last dimension must have dimension 3
Parameters:
`a` - First input (NUMERIC type)
`b` - Second input (NUMERIC type)
Returns:
output Element-wise cross product (NUMERIC type)
• #### cube

`public INDArray cube(INDArray x)`
Element-wise cube function: out = x^3
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### diag

`public INDArray diag(INDArray x)`
Returns an output variable with diagonal values equal to the specified values; off-diagonal values will be set to 0
For example, if input = [1,2,3], then output is given by:
[ 1, 0, 0]
[ 0, 2, 0]
[ 0, 0, 3]

Higher input ranks are also supported: if input has shape [a,...,R-1] then output[i,...,k,i,...,k] = input[i,...,k].
i.e., for input rank R, output has rank 2R
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### diagPart

`public INDArray diagPart(INDArray x)`
Extract the diagonal part from the input array.
If input is
[ 1, 0, 0]
[ 0, 2, 0]
[ 0, 0, 3]
then output is [1, 2, 3].
Supports higher dimensions: in general, out[i,...,k] = in[i,...,k,i,...,k]
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Diagonal part of the input (NUMERIC type)
• #### div

```public INDArray div(INDArray x,
INDArray y)```
Pairwise division operation, out = x / y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - Input variable (NUMERIC type)
`y` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### div

```public INDArray div(INDArray x,
double value)```
Scalar division operation, out = in / scalar
Parameters:
`x` - Input variable (NUMERIC type)
`value` - Scalar value for op
Returns:
output Output variable (NUMERIC type)
• #### entropy

```public INDArray entropy(INDArray in,
int... dimensions)```
Entropy reduction: -sum(x * log(x))
Parameters:
`in` - Input variable (NUMERIC type)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### erf

`public INDArray erf(INDArray x)`
Element-wise Gaussian error function - out = erf(in)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### erfc

`public INDArray erfc(INDArray x)`
Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### euclideanDistance

```public INDArray euclideanDistance(INDArray x,
INDArray y,
int... dimensions)```
Euclidean distance (l2 norm, l2 distance) reduction operation. The output contains the Euclidean distance for each
tensor/subset along the specified dimensions:
out = sqrt( sum_i (x[i] - y[i])^2 )
Parameters:
`x` - Input variable x (NUMERIC type)
`y` - Input variable y (NUMERIC type)
`dimensions` - Dimensions to calculate euclideanDistance over (Size: AtLeast(min=0))
Returns:
output Output variable (NUMERIC type)
• #### exp

`public INDArray exp(INDArray x)`
Elementwise exponent function: out = exp(x) = 2.71828...^x
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### expm1

`public INDArray expm1(INDArray x)`
Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### eye

`public INDArray eye(int rows)`
Generate an identity matrix with the specified number of rows and columns.
Parameters:
`rows` - Number of rows
Returns:
output Identity matrix (NUMERIC type)
• #### eye

```public INDArray eye(int rows,
int cols)```
As per eye(String, int, int, DataType) but with the default datatype, Eye.DEFAULT_DTYPE
Parameters:
`rows` - Number of rows
`cols` - Number of columns
Returns:
output (NUMERIC type)
• #### eye

```public INDArray eye(int rows,
int cols,
DataType dataType,
int... dimensions)```
Generate an identity matrix with the specified number of rows and columns
Example:
```
``` INDArray eye = eye(3,2)<br>
eye:<br>
[ 1, 0]<br>
[ 0, 1]<br>
[ 0, 0]```
```

Parameters:
`rows` - Number of rows
`cols` - Number of columns
`dataType` - Data type
`dimensions` - (Size: AtLeast(min=0))
Returns:
output Identity matrix (NUMERIC type)
• #### eye

```public INDArray eye(INDArray rows,
INDArray cols)```
As per eye(int, int) bit with the number of rows/columns specified as scalar INDArrays
Parameters:
`rows` - Number of rows (INT type)
`cols` - Number of columns (INT type)
Returns:
output Identity matrix (NUMERIC type)
• #### eye

`public INDArray eye(INDArray rows)`
As per eye(String, int) but with the number of rows specified as a scalar INDArray
Parameters:
`rows` - Number of rows (INT type)
Returns:
output SDVaribable identity matrix (NUMERIC type)
• #### firstIndex

```public INDArray firstIndex(INDArray in,
Condition condition,
int... dimensions)```
First index reduction operation.
Returns a variable that contains the index of the first element that matches the specified condition (for each
slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting
the mean along a dimension).
Example: if input has shape [a,b,c] and dimensions= then output has shape:
keepDims = true: [a,1,c]
keepDims = false: [a,c]
Parameters:
`in` - Input variable (NUMERIC type)
`condition` - Condition to check on input variable
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### firstIndex

```public INDArray firstIndex(INDArray in,
Condition condition,
boolean keepDims,
int... dimensions)```
First index reduction operation.
Returns a variable that contains the index of the first element that matches the specified condition (for each
slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting
the mean along a dimension).
Example: if input has shape [a,b,c] and dimensions= then output has shape:
keepDims = true: [a,1,c]
keepDims = false: [a,c]
Parameters:
`in` - Input variable (NUMERIC type)
`condition` - Condition to check on input variable
`keepDims` - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### floor

`public INDArray floor(INDArray x)`
Element-wise floor function: out = floor(x).
Rounds each value down to the nearest integer value (if not already an integer)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### floorDiv

```public INDArray floorDiv(INDArray x,
INDArray y)```
Pairwise floor division operation, out = floor(x / y)
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - Input variable (NUMERIC type)
`y` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### floorMod

```public INDArray floorMod(INDArray x,
INDArray y)```
Pairwise Modulus division operation
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - Input variable (NUMERIC type)
`y` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### floorMod

```public INDArray floorMod(INDArray x,
double value)```
Scalar floor modulus operation
Parameters:
`x` - Input variable (NUMERIC type)
`value` - Scalar value for op
Returns:
output Output variable (NUMERIC type)
• #### hammingDistance

```public INDArray hammingDistance(INDArray x,
INDArray y,
int... dimensions)```
Hamming distance reduction operation. The output contains the cosine distance for each
tensor/subset along the specified dimensions:
out = count( x[i] != y[i] )
Parameters:
`x` - Input variable x (NUMERIC type)
`y` - Input variable y (NUMERIC type)
`dimensions` - Dimensions to calculate hammingDistance over (Size: AtLeast(min=0))
Returns:
output Output variable (NUMERIC type)
• #### iamax

```public INDArray iamax(INDArray in,
int... dimensions)```
Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)
Parameters:
`in` - Input variable (NUMERIC type)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### iamax

```public INDArray iamax(INDArray in,
boolean keepDims,
int... dimensions)```
Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)
Parameters:
`in` - Input variable (NUMERIC type)
`keepDims` - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### iamin

```public INDArray iamin(INDArray in,
int... dimensions)```
Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)
Parameters:
`in` - Input variable (NUMERIC type)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### iamin

```public INDArray iamin(INDArray in,
boolean keepDims,
int... dimensions)```
Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)
Parameters:
`in` - Input variable (NUMERIC type)
`keepDims` - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### isFinite

`public INDArray isFinite(INDArray x)`
Is finite operation: elementwise isFinite(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### isInfinite

`public INDArray isInfinite(INDArray x)`
Is infinite operation: elementwise isInfinite(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### isMax

`public INDArray isMax(INDArray x)`
Is maximum operation: elementwise x == max(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### isNaN

`public INDArray isNaN(INDArray x)`
Is Not a Number operation: elementwise isNaN(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### isNonDecreasing

`public INDArray isNonDecreasing(INDArray x)`
Is the array non decreasing?
An array is non-decreasing if for every valid i, x[i] <= x[i+1]. For Rank 2+ arrays, values are compared
in 'c' (row major) order
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Scalar variable with value 1 if non-decreasing, or 0 otherwise (NUMERIC type)
• #### isStrictlyIncreasing

`public INDArray isStrictlyIncreasing(INDArray x)`
Is the array strictly increasing?
An array is strictly increasing if for every valid i, x[i] < x[i+1]. For Rank 2+ arrays, values are compared
in 'c' (row major) order
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Scalar variable with value 1 if strictly increasing, or 0 otherwise (NUMERIC type)
• #### jaccardDistance

```public INDArray jaccardDistance(INDArray x,
INDArray y,
int... dimensions)```
Jaccard similarity reduction operation. The output contains the Jaccard distance for each
tensor along the specified dimensions.
Parameters:
`x` - Input variable x (NUMERIC type)
`y` - Input variable y (NUMERIC type)
`dimensions` - Dimensions to calculate jaccardDistance over (Size: AtLeast(min=0))
Returns:
output Output variable (NUMERIC type)
• #### lastIndex

```public INDArray lastIndex(INDArray in,
Condition condition,
int... dimensions)```
Last index reduction operation.
Returns a variable that contains the index of the last element that matches the specified condition (for each
slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting
the mean along a dimension).
Example: if input has shape [a,b,c] and dimensions= then output has shape:
keepDims = true: [a,1,c]
keepDims = false: [a,c]
Parameters:
`in` - Input variable (NUMERIC type)
`condition` - Condition to check on input variable
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### lastIndex

```public INDArray lastIndex(INDArray in,
Condition condition,
boolean keepDims,
int... dimensions)```
Last index reduction operation.
Returns a variable that contains the index of the last element that matches the specified condition (for each
slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting
the mean along a dimension).
Example: if input has shape [a,b,c] and dimensions= then output has shape:
keepDims = true: [a,1,c]
keepDims = false: [a,c]
Parameters:
`in` - Input variable (NUMERIC type)
`condition` - Condition to check on input variable
`keepDims` - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### listDiff

```public INDArray[] listDiff(INDArray x,
INDArray y)```
Calculates difference between inputs X and Y.
Parameters:
`x` - Input variable X (NUMERIC type)
`y` - Input variable Y (NUMERIC type)
• #### log

`public INDArray log(INDArray x)`
Element-wise logarithm function (base e - natural logarithm): out = log(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### log

```public INDArray log(INDArray x,
double base)```
Element-wise logarithm function (with specified base): out = log_{base}(x)
Parameters:
`x` - Input variable (NUMERIC type)
`base` - Logarithm base
Returns:
output Output variable (NUMERIC type)
• #### log1p

`public INDArray log1p(INDArray x)`
Elementwise natural logarithm function: out = log_e (1 + x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### logEntropy

```public INDArray logEntropy(INDArray in,
int... dimensions)```
Log entropy reduction: log(-sum(x * log(x)))
Parameters:
`in` - Input variable (NUMERIC type)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### logSumExp

```public INDArray logSumExp(INDArray input,
int... dimensions)```
Log-sum-exp reduction (optionally along dimension).
Computes log(sum(exp(x))
Parameters:
`input` - Input variable (NUMERIC type)
`dimensions` - Optional dimensions to reduce along (Size: AtLeast(min=0))
Returns:
output Output variable (NUMERIC type)
• #### manhattanDistance

```public INDArray manhattanDistance(INDArray x,
INDArray y,
int... dimensions)```
Manhattan distance (l1 norm, l1 distance) reduction operation. The output contains the Manhattan distance for each
tensor/subset along the specified dimensions:
out = sum_i abs(x[i]-y[i])
Parameters:
`x` - Input variable x (NUMERIC type)
`y` - Input variable y (NUMERIC type)
`dimensions` - Dimensions to calculate manhattanDistance over (Size: AtLeast(min=0))
Returns:
output Output variable (NUMERIC type)
• #### matrixDeterminant

`public INDArray matrixDeterminant(INDArray in)`
Matrix determinant op. For 2D input, this returns the standard matrix determinant.
For higher dimensional input with shape [..., m, m] the matrix determinant is returned for each
shape [m,m] sub-matrix.
Parameters:
`in` - Input (NUMERIC type)
Returns:
output Matrix determinant variable (NUMERIC type)
• #### matrixInverse

`public INDArray matrixInverse(INDArray in)`
Matrix inverse op. For 2D input, this returns the standard matrix inverse.
For higher dimensional input with shape [..., m, m] the matrix inverse is returned for each
shape [m,m] sub-matrix.
Parameters:
`in` - Input (NUMERIC type)
Returns:
output Matrix inverse variable (NUMERIC type)
• #### max

```public INDArray max(INDArray x,
INDArray y)```
Pairwise max operation, out = max(x, y)
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - First input variable, x (NUMERIC type)
`y` - Second input variable, y (NUMERIC type)
Returns:
out Output (NUMERIC type)

`public INDArray mergeAdd(INDArray... inputs)`
Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition:
out = sum_i in[i]
Parameters:
`inputs` - Input variables (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### mergeAvg

`public INDArray mergeAvg(INDArray... inputs)`
Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation:
out = mean_i in[i]
Parameters:
`inputs` - Input variables (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### mergeMax

`public INDArray mergeMax(INDArray... inputs)`
Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation:
out = max_i in[i]
Parameters:
`inputs` - Input variables (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### meshgrid

```public INDArray[] meshgrid(INDArray[] inputs,
boolean cartesian)```
Broadcasts parameters for evaluation on an N-D grid.
Parameters:
`inputs` - (NUMERIC type)
`cartesian` -
• #### min

```public INDArray min(INDArray x,
INDArray y)```
Pairwise max operation, out = min(x, y)
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - First input variable, x (NUMERIC type)
`y` - Second input variable, y (NUMERIC type)
Returns:
out Output (NUMERIC type)
• #### mod

```public INDArray mod(INDArray x,
INDArray y)```
Pairwise modulus (remainder) operation, out = x % y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - Input variable (NUMERIC type)
`y` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### moments

```public INDArray[] moments(INDArray input,
int... axes)```
Calculate the mean and (population) variance for the input variable, for the specified axis
Parameters:
`input` - Input to calculate moments for (NUMERIC type)
`axes` - Dimensions to perform calculation over (Size: AtLeast(min=0))
• #### mul

```public INDArray mul(INDArray x,
INDArray y)```
Pairwise multiplication operation, out = x * y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - Input variable (NUMERIC type)
`y` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### mul

```public INDArray mul(INDArray x,
double value)```
Scalar multiplication operation, out = in * scalar
Parameters:
`x` - Input variable (NUMERIC type)
`value` - Scalar value for op
Returns:
output Output variable (NUMERIC type)
• #### neg

`public INDArray neg(INDArray x)`
Elementwise negative operation: out = -x
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### normalizeMoments

```public INDArray[] normalizeMoments(INDArray counts,
INDArray means,
INDArray variances,
double shift)```
Calculate the mean and variance from the sufficient statistics
Parameters:
`counts` - Rank 0 (scalar) value with the total number of values used to calculate the sufficient statistics (NUMERIC type)
`means` - Mean-value sufficient statistics: this is the SUM of all data values (NUMERIC type)
`variances` - Variaance sufficient statistics: this is the squared sum of all data values (NUMERIC type)
`shift` - Shift value, possibly 0, used when calculating the sufficient statistics (for numerical stability)
• #### or

```public INDArray or(INDArray x,
INDArray y)```
Boolean OR operation: elementwise (x != 0) || (y != 0)
If x and y arrays have equal shape, the output shape is the same as these inputs.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
Parameters:
`x` - Input 1 (BOOL type)
`y` - Input 2 (BOOL type)
Returns:
output INDArray with values 0 and 1 based on where the condition is satisfied (BOOL type)
• #### pow

```public INDArray pow(INDArray x,
double value)```
Element-wise power function: out = x^value
Parameters:
`x` - Input variable (NUMERIC type)
`value` - Scalar value for op
Returns:
output Output variable (NUMERIC type)
• #### pow

```public INDArray pow(INDArray x,
INDArray y)```
Element-wise (broadcastable) power function: out = x[i]^y[i]
Parameters:
`x` - Input variable (NUMERIC type)
`y` - Power (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### rationalTanh

`public INDArray rationalTanh(INDArray x)`
Rational Tanh Approximation elementwise function, as described in the paper:
Compact Convolutional Neural Network Cascade for Face Detection
This is a faster Tanh approximation
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### rdiv

```public INDArray rdiv(INDArray x,
INDArray y)```
Pairwise reverse division operation, out = y / x
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - Input variable (NUMERIC type)
`y` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### rdiv

```public INDArray rdiv(INDArray x,
double value)```
Scalar reverse division operation, out = scalar / in
Parameters:
`x` - Input variable (NUMERIC type)
`value` - Scalar value for op
Returns:
output Output variable (NUMERIC type)
• #### reciprocal

`public INDArray reciprocal(INDArray x)`
Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### rectifiedTanh

`public INDArray rectifiedTanh(INDArray x)`
Rectified tanh operation: max(0, tanh(in))
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### round

`public INDArray round(INDArray x)`
Element-wise round function: out = round(x).
Rounds (up or down depending on value) to the nearest integer value.
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### rsqrt

`public INDArray rsqrt(INDArray x)`
Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### rsub

```public INDArray rsub(INDArray x,
INDArray y)```
Pairwise reverse subtraction operation, out = y - x
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - Input variable (NUMERIC type)
`y` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### rsub

```public INDArray rsub(INDArray x,
double value)```
Scalar reverse subtraction operation, out = scalar - in
Parameters:
`x` - Input variable (NUMERIC type)
`value` - Scalar value for op
Returns:
output Output variable (NUMERIC type)
• #### setDiag

```public INDArray setDiag(INDArray in,
INDArray diag)```
Set the diagonal value to the specified values
If input is
[ a, b, c]
[ d, e, f]
[ g, h, i]
and diag = [ 1, 2, 3] then output is
[ 1, b, c]
[ d, 2, f]
[ g, h, 3]
Parameters:
`in` - Input variable (NUMERIC type)
`diag` - Diagonal (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### shannonEntropy

```public INDArray shannonEntropy(INDArray in,
int... dimensions)```
Shannon Entropy reduction: -sum(x * log2(x))
Parameters:
`in` - Input variable (NUMERIC type)
`dimensions` - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
Returns:
output Reduced array of rank (input rank - num dimensions) (NUMERIC type)
• #### sign

`public INDArray sign(INDArray x)`
Element-wise sign (signum) function:
out = -1 if in < 0
out = 0 if in = 0
out = 1 if in > 0
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### sin

`public INDArray sin(INDArray x)`
Elementwise sine operation: out = sin(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### sinh

`public INDArray sinh(INDArray x)`
Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### sqrt

`public INDArray sqrt(INDArray x)`
Element-wise square root function: out = sqrt(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### square

`public INDArray square(INDArray x)`
Element-wise square function: out = x^2
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### squaredDifference

```public INDArray squaredDifference(INDArray x,
INDArray y)```
Pairwise squared difference operation.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - Input variable (NUMERIC type)
`y` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### standardize

```public INDArray standardize(INDArray x,
int... dimensions)```
Standardize input variable along given axis

out = (x - mean) / stdev

with mean and stdev being calculated along the given dimension.

For example: given x as a mini batch of the shape [numExamples, exampleLength]:

• use dimension 1 too use the statistics (mean, stdev) for each example

• use dimension 0 if you want to use the statistics for each column across all examples

• use dimensions 0,1 if you want to use the statistics across all columns and examples

Parameters:
`x` - Input variable (NUMERIC type)
`dimensions` - (Size: AtLeast(min=1))
Returns:
output Output variable (NUMERIC type)
• #### step

```public INDArray step(INDArray x,
double value)```
Elementwise step function:
out(x) = 1 if x >= cutoff
out(x) = 0 otherwise
Parameters:
`x` - Input variable (NUMERIC type)
`value` - Scalar value for op
Returns:
output Output variable (NUMERIC type)
• #### sub

```public INDArray sub(INDArray x,
INDArray y)```
Pairwise subtraction operation, out = x - y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Parameters:
`x` - Input variable (NUMERIC type)
`y` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### sub

```public INDArray sub(INDArray x,
double value)```
Scalar subtraction operation, out = in - scalar
Parameters:
`x` - Input variable (NUMERIC type)
`value` - Scalar value for op
Returns:
output Output variable (NUMERIC type)
• #### tan

`public INDArray tan(INDArray x)`
Elementwise tangent operation: out = tan(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### tanh

`public INDArray tanh(INDArray x)`
Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
Parameters:
`x` - Input variable (NUMERIC type)
Returns:
output Output variable (NUMERIC type)
• #### trace

`public INDArray trace(INDArray in)`
Matrix trace operation
For rank 2 matrices, the output is a scalar vith the trace - i.e., sum of the main diagonal.
For higher rank inputs, output[a,b,c] = trace(in[a,b,c,:,:])
Parameters:
`in` - Input variable (NUMERIC type)
Returns:
output Trace (NUMERIC type)
• #### xor

```public INDArray xor(INDArray x,
INDArray y)```
Boolean XOR (exclusive OR) operation: elementwise (x != 0) XOR (y != 0)
If x and y arrays have equal shape, the output shape is the same as these inputs.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
Parameters:
`x` - Input 1 (BOOL type)
`y` - Input 2 (BOOL type)
Returns:
output INDArray with values 0 and 1 based on where the condition is satisfied (BOOL type)
• #### zeroFraction

`public INDArray zeroFraction(INDArray input)`
Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
Parameters:
`input` - Input variable (NUMERIC type)
Returns:
output Reduced array of rank 0 (scalar) (NUMERIC type)