SDMath (nd4j-api 1.0.0-beta5 API)

java.lang.Object
- org.nd4j.autodiff.samediff.ops.SDOps
- - org.nd4j.autodiff.samediff.ops.SDMath

```
public class SDMath
extends SDOps
```
SameDiff math operations
Accessible via SameDiff.math()

Author:

Alex Black

Field Summary
- Fields inherited from class org.nd4j.autodiff.samediff.ops.SDOps
  sd

Constructor Summary

Constructors
Constructor and Description

SDMath(SameDiff sameDiff)

Constructors
Constructor and Description
`SDMath(SameDiff sameDiff)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`SDVariable`	`abs(SDVariable x)` Elementwise absolute value operation: out = abs(x)
`SDVariable`	`abs(String name, SDVariable x)` Elementwise absolute value operation: out = abs(x)
`SDVariable`	`acos(SDVariable x)` Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
`SDVariable`	`acos(String name, SDVariable x)` Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
`SDVariable`	`acosh(SDVariable x)` Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
`SDVariable`	`acosh(String name, SDVariable x)` Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
`SDVariable`	`amax(SDVariable in, int... dimensions)` Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
`SDVariable`	`amax(String name, SDVariable in, int... dimensions)` Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
`SDVariable`	`amean(SDVariable in, int... dimensions)` Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
`SDVariable`	`amean(String name, SDVariable in, int... dimensions)` Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
`SDVariable`	`amin(SDVariable in, int... dimensions)` Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
`SDVariable`	`amin(String name, SDVariable in, int... dimensions)` Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
`SDVariable`	`and(SDVariable x, SDVariable 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.
`SDVariable`	`and(String name, SDVariable x, SDVariable 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.
`SDVariable`	`asin(SDVariable x)` Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
`SDVariable`	`asin(String name, SDVariable x)` Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
`SDVariable`	`asinh(SDVariable x)` Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
`SDVariable`	`asinh(String name, SDVariable x)` Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
`SDVariable`	`asum(SDVariable in, int... dimensions)` Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
`SDVariable`	`asum(String name, SDVariable in, int... dimensions)` Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
`SDVariable`	`atan(SDVariable x)` Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
`SDVariable`	`atan(String name, SDVariable x)` Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
`SDVariable`	`atan2(SDVariable y, SDVariable x)` Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
`SDVariable`	`atan2(String name, SDVariable y, SDVariable x)` Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
`SDVariable`	`atanh(SDVariable x)` Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
`SDVariable`	`atanh(String name, SDVariable x)` Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
`SDVariable`	`bitRotl(String name, SDVariable x, SDVariable shift)` Roll integer bits to the left, i.e.
`SDVariable`	`bitRotr(String name, SDVariable x, SDVariable shift)` Roll integer bits to the right, i.e.
`SDVariable`	`bitShift(String name, SDVariable x, SDVariable shift)` Shift integer bits to the left, i.e.
`SDVariable`	`bitShiftRight(String name, SDVariable x, SDVariable shift)` Shift integer bits to the right, i.e.
`SDVariable`	`ceil(SDVariable x)` Element-wise ceiling function: out = ceil(x).
`SDVariable`	`ceil(String name, SDVariable x)` Element-wise ceiling function: out = ceil(x).
`SDVariable`	`clipByNorm(SDVariable x, double clipValue)` Clipping by L2 norm if l2Norm(x) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
`SDVariable`	`clipByNorm(SDVariable 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
`SDVariable`	`clipByNorm(String name, SDVariable x, double clipValue)` Clipping by L2 norm if l2Norm(x) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
`SDVariable`	`clipByNorm(String name, SDVariable 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
`SDVariable`	`clipByValue(SDVariable 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
`SDVariable`	`clipByValue(String name, SDVariable 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
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable predictions)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights)`
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred)`
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable 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.
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred, Integer 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]
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred, Integer numClasses, SDVariable 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. 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]
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred, SDVariable 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.
`SDVariable`	`cos(SDVariable x)` Elementwise cosine operation: out = cos(x)
`SDVariable`	`cos(String name, SDVariable x)` Elementwise cosine operation: out = cos(x)
`SDVariable`	`cosh(SDVariable x)` Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
`SDVariable`	`cosh(String name, SDVariable x)` Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
`SDVariable`	`cosineDistance(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`cosineDistance(String name, SDVariable x, SDVariable y, int... dimensions)` Cosine distance reduction operation.
`SDVariable`	`cosineSimilarity(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`cosineSimilarity(String name, SDVariable x, SDVariable y, int... dimensions)` Cosine similarity pairwise reduction operation.
`SDVariable`	`countNonZero(SDVariable input, int... dimensions)` Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
`SDVariable`	`countNonZero(String name, SDVariable input, int... dimensions)` Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
`SDVariable`	`countZero(SDVariable input, int... dimensions)` Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
`SDVariable`	`countZero(String name, SDVariable input, int... dimensions)` Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
`SDVariable`	`cross(SDVariable a, SDVariable b)`
`SDVariable`	`cross(String name, SDVariable a, SDVariable b)` Returns the pair-wise cross product of equal size arrays a and b: a x b = \|\|a\|\|x\|\|b\|\| sin(theta).
`SDVariable`	`cube(SDVariable x)` Element-wise cube function: out = x^3
`SDVariable`	`cube(String name, SDVariable x)` Element-wise cube function: out = x^3
`SDVariable`	`diag(SDVariable x)`
`SDVariable`	`diag(String name, SDVariable 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].
`SDVariable`	`diagPart(SDVariable x)`
`SDVariable`	`diagPart(String name, SDVariable 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]
`SDVariable`	`entropy(SDVariable in, int... dimensions)` Entropy reduction: -sum(x * log(x))
`SDVariable`	`entropy(String name, SDVariable in, int... dimensions)` Entropy reduction: -sum(x * log(x))
`SDVariable`	`erf(SDVariable x)` Element-wise Gaussian error function - out = erf(in)
`SDVariable`	`erf(String name, SDVariable x)` Element-wise Gaussian error function - out = erf(in)
`SDVariable`	`erfc(SDVariable x)` Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
`SDVariable`	`erfc(String name, SDVariable x)` Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
`SDVariable`	`euclideanDistance(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`euclideanDistance(String name, SDVariable x, SDVariable y, int... dimensions)` Euclidean distance (l2 norm, l2 distance) reduction operation.
`SDVariable`	`exp(SDVariable x)` Elementwise exponent function: out = exp(x) = 2.71828...^x
`SDVariable`	`exp(String name, SDVariable x)` Elementwise exponent function: out = exp(x) = 2.71828...^x
`SDVariable`	`expm1(SDVariable x)` Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
`SDVariable`	`expm1(String name, SDVariable x)` Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
`SDVariable`	`eye(int rows)` Generate a square identity matrix with the specified number of rows.
`SDVariable`	`eye(int rows, int cols)`
`SDVariable`	`eye(int rows, int cols, DataType dataType, int... batchDimension)` see `eye(String, int, int, DataType, int...)`
`SDVariable`	`eye(SDVariable rows)` As per `eye(int)` but with the number of rows specified as a scalar SDVariable
`SDVariable`	`eye(SDVariable rows, SDVariable cols)` As per `eye(int, int)` bit with the number of rows/columns specified as scalar SDVariables
`SDVariable`	`eye(SDVariable rows, SDVariable cols, SDVariable batchDimension)` As per `eye(int, int, DataType, int...)` bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
`SDVariable`	`eye(String name, int rows)` Generate an identity matrix with the specified number of rows and columns.
`SDVariable`	`eye(String name, int rows, int cols)` As per `eye(String, int, int, DataType)` but with the default datatype, `Eye.DEFAULT_DTYPE`
`SDVariable`	`eye(String name, int rows, int cols, DataType dataType)` Generate an identity matrix with the specified number of rows and columns Example:
`SDVariable`	`eye(String name, int rows, int cols, DataType dataType, int... batchDimension)` Generate an identity matrix with the specified number of rows and columns, with optional leading dims Example: batchShape: [3,3] numRows: 2 numCols: 4 returns a tensor of shape (3, 3, 2, 4) that consists of 3 * 3 batches of (2,4)-shaped identity matrices: 1 0 0 0 0 1 0 0
`SDVariable`	`eye(String name, SDVariable rows)` As per `eye(String, int)` but with the number of rows specified as a scalar SDVariable
`SDVariable`	`eye(String name, SDVariable rows, SDVariable cols)` As per `eye(String, int, int)` bit with the number of rows/columns specified as scalar SDVariables
`SDVariable`	`eye(String name, SDVariable rows, SDVariable cols, SDVariable batchDimension)` As per `#eye(String, int, int, int...)` bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
`SDVariable`	`firstIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)`
`SDVariable`	`firstIndex(SDVariable in, Condition condition, int... dimensions)`
`SDVariable`	`firstIndex(String name, SDVariable 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.
`SDVariable`	`firstIndex(String name, SDVariable 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)
`SDVariable`	`floor(SDVariable x)` Element-wise floor function: out = floor(x).
`SDVariable`	`floor(String name, SDVariable x)` Element-wise floor function: out = floor(x).
`SDVariable`	`hammingDistance(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`hammingDistance(String name, SDVariable x, SDVariable y, int... dimensions)` Hamming distance reduction operation.
`SDVariable`	`iamax(SDVariable in, boolean keepDims, int... dimensions)` Index of the max absolute value: argmax(abs(in))
`SDVariable`	`iamax(SDVariable in, int... dimensions)` Index of the max absolute value: argmax(abs(in))
`SDVariable`	`iamax(String name, SDVariable in, boolean keepDims, int... dimensions)` Index of the max absolute value: argmax(abs(in))
`SDVariable`	`iamax(String name, SDVariable in, int... dimensions)` Index of the max absolute value: argmax(abs(in))
`SDVariable`	`iamin(SDVariable in, boolean keepDims, int... dimensions)` Index of the min absolute value: argmin(abs(in))
`SDVariable`	`iamin(SDVariable in, int... dimensions)` Index of the min absolute value: argmin(abs(in))
`SDVariable`	`iamin(String name, SDVariable in, boolean keepDims, int... dimensions)` Index of the min absolute value: argmin(abs(in))
`SDVariable`	`iamin(String name, SDVariable in, int... dimensions)` Index of the min absolute value: argmin(abs(in))
`SDVariable`	`isFinite(SDVariable 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
`SDVariable`	`isFinite(String name, SDVariable 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
`SDVariable`	`isInfinite(SDVariable 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
`SDVariable`	`isInfinite(String name, SDVariable 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
`SDVariable`	`isMax(SDVariable 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
`SDVariable`	`isMax(String name, SDVariable 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
`SDVariable`	`isNaN(SDVariable 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
`SDVariable`	`isNaN(String name, SDVariable 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
`SDVariable`	`isNonDecreasing(SDVariable x)` Is the array non decreasing? An array is non-decreasing if for every valid i, x[i] <= x[i+1].
`SDVariable`	`isNonDecreasing(String name, SDVariable x)` Is the array non decreasing? An array is non-decreasing if for every valid i, x[i] <= x[i+1].
`SDVariable`	`isStrictlyIncreasing(SDVariable x)` Is the array strictly increasing? An array is strictly increasing if for every valid i, x[i] < x[i+1].
`SDVariable`	`isStrictlyIncreasing(String name, SDVariable x)` Is the array strictly increasing? An array is strictly increasing if for every valid i, x[i] < x[i+1].
`SDVariable`	`jaccardDistance(SDVariable x, SDVariable y, int... dimensions)` Jaccard similarity reduction operation.
`SDVariable`	`jaccardDistance(String name, SDVariable x, SDVariable y, int... dimensions)` Jaccard similarity reduction operation.
`SDVariable`	`lastIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)`
`SDVariable`	`lastIndex(SDVariable in, Condition condition, int... dimensions)`
`SDVariable`	`lastIndex(String name, SDVariable 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.
`SDVariable`	`lastIndex(String name, SDVariable 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)
`SDVariable[]`	`listDiff(SDVariable x, SDVariable y)` List diff operation computes the difference between two 1d arrays, and also returns the indices - i.e., the positions where the output appears in the input X. For inputs X and Y, listDiff returns everything in X but not in Y. For example, if `X=[1,10,3,7,6]` and Y=[10, 6]), then: output 0 (difference) = {@code [1,3,7]} output 1 (indices) = {@code [0, 2, 3]}
`SDVariable`	`log(SDVariable x)` Element-wise logarithm function (base e - natural logarithm): out = log(x)
`SDVariable`	`log(SDVariable in, double base)` Element-wise logarithm function (with specified base): out = log_{base}(x)
`SDVariable`	`log(String name, SDVariable x)` Element-wise logarithm function (base e - natural logarithm): out = log(x)
`SDVariable`	`log(String name, SDVariable in, double base)` Element-wise logarithm function (with specified base): out = log_{base}(x)
`SDVariable`	`log1p(SDVariable x)` Elementwise natural logarithm function: out = log_e (1 + x)
`SDVariable`	`log1p(String name, SDVariable x)` Elementwise natural logarithm function: out = log_e (1 + x)
`SDVariable`	`logEntropy(SDVariable in, int... dimensions)` Log entropy reduction: log(-sum(x * log(x)))
`SDVariable`	`logEntropy(String name, SDVariable in, int... dimensions)` Log entropy reduction: log(-sum(x * log(x)))
`SDVariable`	`logSumExp(SDVariable input, int... dimensions)` Log-sum-exp reduction (optionally along dimension).
`SDVariable`	`logSumExp(String name, SDVariable input, boolean keepDims, int... dimensions)`
`SDVariable`	`logSumExp(String name, SDVariable input, int... dimensions)` Log-sum-exp reduction (optionally along dimension).
`SDVariable`	`manhattanDistance(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`manhattanDistance(String name, SDVariable x, SDVariable y, int... dimensions)` Manhattan distance (l1 norm, l1 distance) reduction operation.
`SDVariable`	`matrixDeterminant(SDVariable in)`
`SDVariable`	`matrixDeterminant(String name, SDVariable in)` Matrix determinant op.
`SDVariable`	`matrixInverse(SDVariable in)`
`SDVariable`	`matrixInverse(String name, SDVariable in)` Matrix inverse op.
`SDVariable`	`mergeAdd(SDVariable... x)` Merge add function: merges an arbitrary number of equal shaped arrays using elementwise addition: out = sum_i in[i]
`SDVariable`	`mergeAdd(String name, SDVariable... inputs)` Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition: out = sum_i in[i]
`SDVariable`	`mergeAvg(SDVariable... inputs)` Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation: out = mean_i in[i]
`SDVariable`	`mergeAvg(String name, SDVariable... inputs)` Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation: out = mean_i in[i]
`SDVariable`	`mergeMax(SDVariable... x)` Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation: out = max_i in[i]
`SDVariable`	`mergeMax(String name, SDVariable... inputs)` Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation: out = max_i in[i]
`SDVariable[]`	`meshgrid(List<String> names, boolean cartesian, SDVariable... inputs)`
`SDVariable[]`	`meshgrid(List<String> names, SDVariable... inputs)` Broadcast the 1D input variables onto an n-dimensional grid. The resulting variable can be used for example for evaluating functions at all locations on a grid. Example:
`SDVariable[]`	`meshgrid(SDVariable... inputs)`
`SDVariable[]`	`moments(SDVariable input, int... axes)`
`SDVariable[]`	`moments(String[] name, SDVariable input, int... axes)` Calculate the mean and (population) variance for the input variable, for the specified axis
`SDVariable`	`neg(SDVariable x)` Elementwise negative operation: out = -x
`SDVariable`	`neg(String name, SDVariable x)` Elementwise negative operation: out = -x
`SDVariable[]`	`normalizeMoments(SDVariable counts, SDVariable means, SDVariable variances, double shift)`
`SDVariable[]`	`normalizeMoments(String[] name, SDVariable counts, SDVariable means, SDVariable variances, double shift)` Calculate the mean and variance from the sufficient statistics
`SDVariable`	`or(SDVariable x, SDVariable 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.
`SDVariable`	`or(String name, SDVariable x, SDVariable 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.
`SDVariable`	`pow(SDVariable x, double value)` Element-wise power function: out = x^value
`SDVariable`	`pow(SDVariable x, SDVariable y)` Element-wise (broadcastable) power function: out = x[i]^y[i]
`SDVariable`	`pow(String name, SDVariable x, double value)` Element-wise power function: out = x^value
`SDVariable`	`pow(String name, SDVariable x, SDVariable y)` Element-wise (broadcastable) power function: out = x[i]^y[i]
`SDVariable`	`reciprocal(SDVariable a)` Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
`SDVariable`	`reciprocal(String name, SDVariable a)` Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
`SDVariable`	`round(SDVariable x)` Elementwise round function: out = round(x).
`SDVariable`	`round(String name, SDVariable x)` Element-wise round function: out = round(x).
`SDVariable`	`rsqrt(SDVariable x)` Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
`SDVariable`	`rsqrt(String name, SDVariable x)` Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
`SDVariable`	`setDiag(SDVariable in, SDVariable diag)`
`SDVariable`	`setDiag(String name, SDVariable in, SDVariable 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]
`SDVariable`	`shannonEntropy(SDVariable in, int... dimensions)` Shannon Entropy reduction: -sum(x * log2(x))
`SDVariable`	`shannonEntropy(String name, SDVariable in, int... dimensions)` Shannon Entropy reduction: -sum(x * log2(x))
`SDVariable`	`sign(SDVariable x)` Element-wise sign (signum) function: out = -1 if in < 0 out = 0 if in = 0 out = 1 if in > 0
`SDVariable`	`sign(String name, SDVariable x)` Element-wise sign (signum) function: out = -1 if in < 0 out = 0 if in = 0 out = 1 if in > 0
`SDVariable`	`sin(SDVariable x)` Elementwise sine operation: out = sin(x)
`SDVariable`	`sin(String name, SDVariable x)` Elementwise sine operation: out = sin(x)
`SDVariable`	`sinh(SDVariable x)` Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
`SDVariable`	`sinh(String name, SDVariable x)` Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
`SDVariable`	`sqrt(SDVariable x)` Element-wise square root function: out = sqrt(x)
`SDVariable`	`sqrt(String name, SDVariable x)` Element-wise square root function: out = sqrt(x)
`SDVariable`	`square(SDVariable x)` Element-wise square function: out = x^2
`SDVariable`	`square(String name, SDVariable x)` Element-wise square function: out = x^2
`SDVariable`	`standardize(SDVariable x, int... dimensions)` Standardize input variable along given axis
`SDVariable`	`standardize(String name, SDVariable x, int... dimensions)` Standardize input variable along given axis
`SDVariable`	`step(SDVariable in, double cutoff)` Elementwise step function: out(x) = 1 if x >= cutoff out(x) = 0 otherwise
`SDVariable`	`step(String name, SDVariable in, double cutoff)` Elementwise step function: out(x) = 1 if x >= cutoff out(x) = 0 otherwise
`SDVariable`	`tan(SDVariable x)` Elementwise tangent operation: out = tan(x)
`SDVariable`	`tan(String name, SDVariable x)` Elementwise tangent operation: out = tan(x)
`SDVariable`	`tanh(SDVariable x)` Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
`SDVariable`	`tanh(String name, SDVariable x)` Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
`SDVariable`	`trace(SDVariable in)`
`SDVariable`	`trace(String name, SDVariable 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,:,:])
`SDVariable`	`xor(SDVariable x, SDVariable 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.
`SDVariable`	`xor(String name, SDVariable x, SDVariable 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.
`SDVariable`	`zeroFraction(SDVariable input)` Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
`SDVariable`	`zeroFraction(String name, SDVariable input)` Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))

Methods inherited from class org.nd4j.autodiff.samediff.ops.SDOps
f, updateVariableNameAndReference

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

- Constructor Detail
  - SDMath
```
public SDMath(SameDiff sameDiff)
```
- Method Detail
  - abs
```
public SDVariable abs(SDVariable x)
```
    Elementwise absolute value operation: out = abs(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - abs
```
public SDVariable abs(String name,
                      SDVariable x)
```
    Elementwise absolute value operation: out = abs(x)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - acos
```
public SDVariable acos(SDVariable x)
```
    Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - acos
```
public SDVariable acos(String name,
                       SDVariable x)
```
    Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - acosh
```
public SDVariable acosh(SDVariable x)
```
    Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - acosh
```
public SDVariable acosh(String name,
                        SDVariable x)
```
    Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - amax
```
public SDVariable amax(SDVariable in,
                       int... dimensions)
```
    Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - amax
```
public SDVariable amax(String name,
                       SDVariable in,
                       int... dimensions)
```
    Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - amean
```
public SDVariable amean(SDVariable in,
                        int... dimensions)
```
    Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - amean
```
public SDVariable amean(String name,
                        SDVariable in,
                        int... dimensions)
```
    Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - amin
```
public SDVariable amin(SDVariable in,
                       int... dimensions)
```
    Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - amin
```
public SDVariable amin(String name,
                       SDVariable in,
                       int... dimensions)
```
    Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - and
```
public SDVariable and(SDVariable x,
                      SDVariable 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
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - and
```
public SDVariable and(String name,
                      SDVariable x,
                      SDVariable 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:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - asin
```
public SDVariable asin(SDVariable x)
```
    Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - asin
```
public SDVariable asin(String name,
                       SDVariable x)
```
    Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - asinh
```
public SDVariable asinh(SDVariable x)
```
    Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - asinh
```
public SDVariable asinh(String name,
                        SDVariable x)
```
    Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - asum
```
public SDVariable asum(SDVariable in,
                       int... dimensions)
```
    Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - asum
```
public SDVariable asum(String name,
                       SDVariable in,
                       int... dimensions)
```
    Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - atan
```
public SDVariable atan(SDVariable x)
```
    Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - atan
```
public SDVariable atan(String name,
                       SDVariable x)
```
    Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - atan2
```
public SDVariable atan2(SDVariable y,
                        SDVariable 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
    
    x - Input X variable
    
    Returns:
    
    Output variable
  - atan2
```
public SDVariable atan2(String name,
                        SDVariable y,
                        SDVariable 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:
    
    name - Name of the output variable
    
    y - Input Y variable
    
    x - Input X variable
    
    Returns:
    
    Output variable
  - atanh
```
public SDVariable atanh(SDVariable x)
```
    Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - atanh
```
public SDVariable atanh(String name,
                        SDVariable x)
```
    Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - ceil
```
public SDVariable ceil(SDVariable 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
    
    Returns:
    
    Output variable
  - ceil
```
public SDVariable ceil(String name,
                       SDVariable x)
```
    Element-wise ceiling function: out = ceil(x). Rounds each value up to the nearest integer value (if not already an integer)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - clipByNorm
```
public SDVariable clipByNorm(SDVariable x,
                             double clipValue)
```
    Clipping by L2 norm
    if l2Norm(x) < clipValue, then input is returned unmodifed
    Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
    
    Parameters:
    
    x - Input variable
    
    clipValue - Clipping value (maximum l2 norm)
    
    Returns:
    
    Output variable
  - clipByNorm
```
public SDVariable clipByNorm(String name,
                             SDVariable x,
                             double clipValue)
```
    Clipping by L2 norm
    if l2Norm(x) < clipValue, then input is returned unmodifed
    Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    clipValue - Clipping value (maximum l2 norm)
    
    Returns:
    
    Output variable
  - clipByNorm
```
public SDVariable clipByNorm(SDVariable 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
    
    clipValue - Clipping value (maximum l2 norm)
    
    dimensions - If not specified, all dimensions are used
    
    Returns:
    
    Output variable
  - clipByNorm
```
public SDVariable clipByNorm(String name,
                             SDVariable 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:
    
    name - Output variable name
    
    x - Input variable
    
    clipValue - Clipping value (maximum l2 norm)
    
    dimensions - If not specified, all dimensions are used
    
    Returns:
    
    Output variable
  - clipByValue
```
public SDVariable clipByValue(SDVariable 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
    
    clipValueMin - Minimum value for clipping
    
    clipValueMax - Maximum value for clipping
    
    Returns:
    
    Output variable
  - clipByValue
```
public SDVariable clipByValue(String name,
                              SDVariable 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:
    
    name - Name of the output variable
    
    x - Input variable
    
    clipValueMin - Minimum value for clipping
    
    clipValueMax - Maximum value for clipping
    
    Returns:
    
    Output variable
  - confusionMatrix
```
public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable predictions)
```
    See Also:
    
    confusionMatrix(String, SDVariable, SDVariable)
  - confusionMatrix
```
public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred)
```
  - confusionMatrix
```
public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable 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:
    
    name - Name of the output variable
    
    labels - Labels - 1D array of integer values representing label values
    
    pred - Predictions - 1D array of integer values representing predictions. Same length as labels
    
    Returns:
    
    Output variable (2D, shape [numClasses, numClasses})
  - confusionMatrix
```
public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable pred,
                                  Integer numClasses)
```
    See Also:
    
    confusionMatrix(String, SDVariable, SDVariable, Integer)
  - confusionMatrix
```
public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred,
                                  Integer 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:
    
    name - Name of the output variable
    
    labels - Labels - 1D array of integer values representing label values
    
    pred - Predictions - 1D array of integer values representing predictions. Same length as labels
    
    numClasses - Number of classes
    
    Returns:
    
    Output variable (2D, shape [numClasses, numClasses})
  - confusionMatrix
```
public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable pred,
                                  SDVariable weights)
```
    See Also:
    
    confusionMatrix(String, SDVariable, SDVariable, SDVariable)
  - confusionMatrix
```
public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred,
                                  SDVariable 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:
    
    name - Name of the output variable
    
    labels - Labels - 1D array of integer values representing label values
    
    pred - Predictions - 1D array of integer values representing predictions. Same length as labels
    
    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
    
    Returns:
    
    Output variable (2D, shape [numClasses, numClasses})
  - confusionMatrix
```
public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable pred,
                                  Integer numClasses,
                                  SDVariable weights)
```
    See Also:
    
    confusionMatrix(String, SDVariable, SDVariable, Integer, SDVariable)
  - confusionMatrix
```
public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred,
                                  Integer numClasses,
                                  SDVariable 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.
    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:
    
    name - Name of the output variable
    
    labels - Labels - 1D array of integer values representing label values
    
    pred - Predictions - 1D array of integer values representing predictions. Same length as labels
    
    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
    
    Returns:
    
    Output variable (2D, shape [numClasses, numClasses})
  - cos
```
public SDVariable cos(SDVariable x)
```
    Elementwise cosine operation: out = cos(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - cos
```
public SDVariable cos(String name,
                      SDVariable x)
```
    Elementwise cosine operation: out = cos(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - cosh
```
public SDVariable cosh(SDVariable x)
```
    Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - cosh
```
public SDVariable cosh(String name,
                       SDVariable x)
```
    Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - cosineDistance
```
public SDVariable cosineDistance(SDVariable x,
                                 SDVariable y,
                                 int... dimensions)
```
    See Also:
    
    cosineDistance(String, SDVariable, SDVariable, int...)
  - cosineDistance
```
public SDVariable cosineDistance(String name,
                                 SDVariable x,
                                 SDVariable 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)
    See cosineSimilarity(String, SDVariable, SDVariable, int...)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Dimensions to calculate cosine similarity over
    
    Returns:
    
    Output variable
  - cosineSimilarity
```
public SDVariable cosineSimilarity(SDVariable x,
                                   SDVariable y,
                                   int... dimensions)
```
    See Also:
    
    cosineSimilarity(String, SDVariable, SDVariable, int...)
  - cosineSimilarity
```
public SDVariable cosineSimilarity(String name,
                                   SDVariable x,
                                   SDVariable 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
    
    y - Input variable y
    
    dimensions - Dimensions to calculate cosine similarity over
    
    Returns:
    
    Output variable
  - countNonZero
```
public SDVariable countNonZero(SDVariable input,
                               int... dimensions)
```
    Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
    
    Parameters:
    
    input - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - countNonZero
```
public SDVariable countNonZero(String name,
                               SDVariable input,
                               int... dimensions)
```
    Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
    
    Parameters:
    
    name - Name of the output variable
    
    input - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - countZero
```
public SDVariable countZero(SDVariable input,
                            int... dimensions)
```
    Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
    
    Parameters:
    
    input - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - countZero
```
public SDVariable countZero(String name,
                            SDVariable input,
                            int... dimensions)
```
    Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
    
    Parameters:
    
    name - Name of the output variable
    
    input - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - cross
```
public SDVariable cross(SDVariable a,
                        SDVariable b)
```
    See Also:
    
    cross(String, SDVariable, SDVariable)
  - cross
```
public SDVariable cross(String name,
                        SDVariable a,
                        SDVariable 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
    
    b - Second input
    
    Returns:
    
    Element-wise cross product
  - cube
```
public SDVariable cube(SDVariable x)
```
    Element-wise cube function: out = x^3
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - cube
```
public SDVariable cube(String name,
                       SDVariable x)
```
    Element-wise cube function: out = x^3
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - diag
```
public SDVariable diag(SDVariable x)
```
    See Also:
    
    diag(String, SDVariable)
  - diag
```
public SDVariable diag(String name,
                       SDVariable 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:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - diagPart
```
public SDVariable diagPart(SDVariable x)
```
    See Also:
    
    diagPart(String, SDVariable)
  - diagPart
```
public SDVariable diagPart(String name,
                           SDVariable 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
    
    Returns:
    
    Diagonal part of the input
    
    See Also:
    
    diag(String, SDVariable)
  - entropy
```
public SDVariable entropy(SDVariable in,
                          int... dimensions)
```
    Entropy reduction: -sum(x * log(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null/empty for full array)
    
    Returns:
    
    Output variable
  - entropy
```
public SDVariable entropy(String name,
                          SDVariable in,
                          int... dimensions)
```
    Entropy reduction: -sum(x * log(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null/empty for full array)
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - erf
```
public SDVariable erf(SDVariable x)
```
    Element-wise Gaussian error function - out = erf(in)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - erf
```
public SDVariable erf(String name,
                      SDVariable x)
```
    Element-wise Gaussian error function - out = erf(in)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - erfc
```
public SDVariable erfc(SDVariable x)
```
    Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - erfc
```
public SDVariable erfc(String name,
                       SDVariable x)
```
    Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - euclideanDistance
```
public SDVariable euclideanDistance(SDVariable x,
                                    SDVariable y,
                                    int... dimensions)
```
    See Also:
    
    euclideanDistance(String, SDVariable, SDVariable, int...)
  - euclideanDistance
```
public SDVariable euclideanDistance(String name,
                                    SDVariable x,
                                    SDVariable 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
    
    y - Input variable y
    
    dimensions - Dimensions to calculate cosine similarity over
    
    Returns:
    
    Output variable
  - exp
```
public SDVariable exp(SDVariable x)
```
    Elementwise exponent function: out = exp(x) = 2.71828...^x
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - exp
```
public SDVariable exp(String name,
                      SDVariable x)
```
    Elementwise exponent function: out = exp(x) = 2.71828...^x
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - expm1
```
public SDVariable expm1(SDVariable x)
```
    Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - expm1
```
public SDVariable expm1(String name,
                        SDVariable x)
```
    Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - eye
```
public SDVariable eye(int rows)
```
    Generate a square identity matrix with the specified number of rows.
    
    Parameters:
    
    rows - Number of rows (and columns)
    
    Returns:
    
    SDVariable with an identity matrix array
  - eye
```
public SDVariable eye(String name,
                      int rows)
```
    Generate an identity matrix with the specified number of rows and columns.
    
    Parameters:
    
    rows - Number of rows
  - eye
```
public SDVariable eye(int rows,
                      int cols)
```
    See Also:
    
    eye(String, int, int)
  - eye
```
public SDVariable eye(String name,
                      int rows,
                      int cols)
```
    As per eye(String, int, int, DataType) but with the default datatype, Eye.DEFAULT_DTYPE
  - eye
```
public SDVariable eye(String name,
                      int rows,
                      int cols,
                      DataType dataType)
```
    Generate an identity matrix with the specified number of rows and columns Example:
```
  SDVariable eye = eye(3,2)
 eye:
 [ 1, 0]
 [ 0, 1]
 [ 0, 0]
 
```
    Parameters:
    
    name - Name of the new SDVariable
    
    rows - Number of rows
    
    cols - Number of columns
    
    Returns:
    
    SDVaribable identity matrix
  - eye
```
public SDVariable eye(int rows,
                      int cols,
                      DataType dataType,
                      int... batchDimension)
```
    see eye(String, int, int, DataType, int...)
  - eye
```
public SDVariable eye(String name,
                      int rows,
                      int cols,
                      DataType dataType,
                      int... batchDimension)
```
    Generate an identity matrix with the specified number of rows and columns, with optional leading dims
    Example:
    batchShape: [3,3]
    numRows: 2
    numCols: 4
    returns a tensor of shape (3, 3, 2, 4) that consists of 3 * 3 batches of (2,4)-shaped identity matrices:
    1 0 0 0
    0 1 0 0
    
    Parameters:
    
    rows - Number of rows
    
    cols - Number of columns
    
    batchDimension - Batch dimensions. May be null
  - eye
```
public SDVariable eye(SDVariable rows,
                      SDVariable cols,
                      SDVariable batchDimension)
```
    As per eye(int, int, DataType, int...) bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
  - eye
```
public SDVariable eye(String name,
                      SDVariable rows,
                      SDVariable cols,
                      SDVariable batchDimension)
```
    As per #eye(String, int, int, int...) bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
  - eye
```
public SDVariable eye(String name,
                      SDVariable rows,
                      SDVariable cols)
```
    As per eye(String, int, int) bit with the number of rows/columns specified as scalar SDVariables
  - eye
```
public SDVariable eye(SDVariable rows,
                      SDVariable cols)
```
    As per eye(int, int) bit with the number of rows/columns specified as scalar SDVariables
  - eye
```
public SDVariable eye(String name,
                      SDVariable rows)
```
    As per eye(String, int) but with the number of rows specified as a scalar SDVariable
  - eye
```
public SDVariable eye(SDVariable rows)
```
    As per eye(int) but with the number of rows specified as a scalar SDVariable
  - firstIndex
```
public SDVariable firstIndex(SDVariable in,
                             Condition condition,
                             int... dimensions)
```
    See Also:
    
    firstIndex(String, SDVariable, Condition, int...)
  - firstIndex
```
public SDVariable firstIndex(String name,
                             SDVariable 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)
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    condition - Condition to check on input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - firstIndex
```
public SDVariable firstIndex(String name,
                             SDVariable 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=[1] then output has shape: keepDims = true: [a,1,c]
    keepDims = false: [a,c]
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    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
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - firstIndex
```
public SDVariable firstIndex(SDVariable in,
                             Condition condition,
                             boolean keepDims,
                             int... dimensions)
```
    See Also:
    
    firstIndex(String, SDVariable, Condition, boolean, int...)
  - floor
```
public SDVariable floor(SDVariable 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
    
    Returns:
    
    Output variable
  - floor
```
public SDVariable floor(String name,
                        SDVariable x)
```
    Element-wise floor function: out = floor(x). Rounds each value down to the nearest integer value (if not already an integer)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - hammingDistance
```
public SDVariable hammingDistance(SDVariable x,
                                  SDVariable y,
                                  int... dimensions)
```
    See Also:
    
    hammingDistance(String, SDVariable, SDVariable, int...)
  - hammingDistance
```
public SDVariable hammingDistance(String name,
                                  SDVariable x,
                                  SDVariable 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:
    
    name - Name of the output variable
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Dimensions to calculate cosine similarity over
    
    Returns:
    
    Output variable
  - iamax
```
public SDVariable iamax(SDVariable in,
                        int... dimensions)
```
    Index of the max absolute value: argmax(abs(in))
    
    See Also:
    
    SDBaseOps.argmax(SDVariable, int...)
  - iamax
```
public SDVariable iamax(String name,
                        SDVariable in,
                        int... dimensions)
```
    Index of the max absolute value: argmax(abs(in))
    
    See Also:
    
    SDBaseOps.argmax(String, SDVariable, boolean, int...)
  - iamax
```
public SDVariable iamax(String name,
                        SDVariable in,
                        boolean keepDims,
                        int... dimensions)
```
    Index of the max absolute value: argmax(abs(in))
    
    See Also:
    
    SDBaseOps.argmax(String, SDVariable, boolean, int...)
  - iamax
```
public SDVariable iamax(SDVariable in,
                        boolean keepDims,
                        int... dimensions)
```
    Index of the max absolute value: argmax(abs(in))
    
    See Also:
    
    SDBaseOps.argmax(String, SDVariable, boolean, int...)
  - iamin
```
public SDVariable iamin(SDVariable in,
                        int... dimensions)
```
    Index of the min absolute value: argmin(abs(in))
    
    See Also:
    
    SDBaseOps.argmin(String, SDVariable, boolean, int...)
  - iamin
```
public SDVariable iamin(String name,
                        SDVariable in,
                        int... dimensions)
```
    Index of the min absolute value: argmin(abs(in))
    
    See Also:
    
    SDBaseOps.argmin(String, SDVariable, boolean, int...)
  - iamin
```
public SDVariable iamin(String name,
                        SDVariable in,
                        boolean keepDims,
                        int... dimensions)
```
    Index of the min absolute value: argmin(abs(in))
    
    See Also:
    
    SDBaseOps.argmin(String, SDVariable, boolean, int...)
  - iamin
```
public SDVariable iamin(SDVariable in,
                        boolean keepDims,
                        int... dimensions)
```
    Index of the min absolute value: argmin(abs(in))
    
    See Also:
    
    SDBaseOps.argmin(String, SDVariable, boolean, int...)
  - isFinite
```
public SDVariable isFinite(SDVariable 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 array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isFinite
```
public SDVariable isFinite(String name,
                           SDVariable 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:
    
    name - Output variable name
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isInfinite
```
public SDVariable isInfinite(SDVariable 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 array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isInfinite
```
public SDVariable isInfinite(String name,
                             SDVariable 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:
    
    name - Output variable name
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isMax
```
public SDVariable isMax(SDVariable 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 array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isMax
```
public SDVariable isMax(String name,
                        SDVariable 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:
    
    name - Name of the output variable
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isNaN
```
public SDVariable isNaN(SDVariable 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 array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isNaN
```
public SDVariable isNaN(String name,
                        SDVariable 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:
    
    name - Output variable name
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isNonDecreasing
```
public SDVariable isNonDecreasing(SDVariable 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
    
    Returns:
    
    Scalar variable with value 1 if non-decreasing, or 0 otherwise
  - isNonDecreasing
```
public SDVariable isNonDecreasing(String name,
                                  SDVariable 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:
    
    name - Output name
    
    x - Input variable
    
    Returns:
    
    Scalar variable with value 1 if non-decreasing, or 0 otherwise
  - isStrictlyIncreasing
```
public SDVariable isStrictlyIncreasing(SDVariable 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
    
    Returns:
    
    Scalar variable with value 1 if strictly increasing, or 0 otherwise
  - isStrictlyIncreasing
```
public SDVariable isStrictlyIncreasing(String name,
                                       SDVariable 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:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Scalar variable with value 1 if strictly increasing, or 0 otherwise
  - jaccardDistance
```
public SDVariable jaccardDistance(SDVariable x,
                                  SDVariable 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
    
    y - Input variable y
    
    dimensions - Dimensions to calculate Jaccard similarity over
    
    Returns:
    
    Output variable
  - jaccardDistance
```
public SDVariable jaccardDistance(String name,
                                  SDVariable x,
                                  SDVariable y,
                                  int... dimensions)
```
    Jaccard similarity reduction operation. The output contains the Jaccard distance for each tensor along the specified dimensions.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Dimensions to calculate Jaccard similarity over
    
    Returns:
    
    Output variable
  - lastIndex
```
public SDVariable lastIndex(SDVariable in,
                            Condition condition,
                            int... dimensions)
```
    See Also:
    
    lastIndex(String, SDVariable, Condition, int...)
  - lastIndex
```
public SDVariable lastIndex(String name,
                            SDVariable 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)
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    condition - Condition to check on input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - lastIndex
```
public SDVariable lastIndex(String name,
                            SDVariable 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=[1] then output has shape: keepDims = true: [a,1,c]
    keepDims = false: [a,c]
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    condition - Condition to check on input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - lastIndex
```
public SDVariable lastIndex(SDVariable in,
                            Condition condition,
                            boolean keepDims,
                            int... dimensions)
```
    See Also:
    
    lastIndex(String, SDVariable, Condition, boolean, int...)
  - listDiff
```
public SDVariable[] listDiff(SDVariable x,
                             SDVariable y)
```
    List diff operation computes the difference between two 1d arrays, and also returns the indices - i.e., the positions where the output appears in the input X.
    For inputs X and Y, listDiff returns everything in X but not in Y.
    For example, if X=[1,10,3,7,6] and Y=[10, 6]), then: output 0 (difference) = {@code [1,3,7]}
    output 1 (indices) = {@code [0, 2, 3]}
    
    Parameters:
    
    x - Input 1 - input values
    
    y - Input 2 - values to remove
    
    Returns:
    
    2 outputs - difference, and indices
  - log
```
public SDVariable log(SDVariable x)
```
    Element-wise logarithm function (base e - natural logarithm): out = log(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - log
```
public SDVariable log(String name,
                      SDVariable x)
```
    Element-wise logarithm function (base e - natural logarithm): out = log(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - log
```
public SDVariable log(SDVariable in,
                      double base)
```
    Element-wise logarithm function (with specified base): out = log_{base}(x)
    
    Parameters:
    
    in - Input variable
    
    base - Logarithm base
    
    Returns:
    
    Output variable
  - log
```
public SDVariable log(String name,
                      SDVariable in,
                      double base)
```
    Element-wise logarithm function (with specified base): out = log_{base}(x)
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    base - Logarithm base
    
    Returns:
    
    Output variable
  - log1p
```
public SDVariable log1p(SDVariable x)
```
    Elementwise natural logarithm function: out = log_e (1 + x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - log1p
```
public SDVariable log1p(String name,
                        SDVariable x)
```
    Elementwise natural logarithm function: out = log_e (1 + x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - logEntropy
```
public SDVariable logEntropy(SDVariable in,
                             int... dimensions)
```
    Log entropy reduction: log(-sum(x * log(x)))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null for full array)
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - logEntropy
```
public SDVariable logEntropy(String name,
                             SDVariable in,
                             int... dimensions)
```
    Log entropy reduction: log(-sum(x * log(x)))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null for full array)
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - logSumExp
```
public SDVariable logSumExp(SDVariable input,
                            int... dimensions)
```
    Log-sum-exp reduction (optionally along dimension). Computes log(sum(exp(x))
    
    Parameters:
    
    input - Input variable
    
    dimensions - Optional dimensions to reduce along
    
    Returns:
    
    Output variable
  - logSumExp
```
public SDVariable logSumExp(String name,
                            SDVariable input,
                            int... dimensions)
```
    Log-sum-exp reduction (optionally along dimension). Computes log(sum(exp(x))
    
    Parameters:
    
    name - Name of the output variable
    
    input - Input variable
    
    dimensions - Optional dimensions to reduce along
    
    Returns:
    
    Output variable
  - logSumExp
```
public SDVariable logSumExp(String name,
                            SDVariable input,
                            boolean keepDims,
                            int... dimensions)
```
  - manhattanDistance
```
public SDVariable manhattanDistance(SDVariable x,
                                    SDVariable y,
                                    int... dimensions)
```
    See Also:
    
    manhattanDistance(String, SDVariable, SDVariable, int...)
  - manhattanDistance
```
public SDVariable manhattanDistance(String name,
                                    SDVariable x,
                                    SDVariable 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:
    
    name - Name of the output variable
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Dimensions to calculate cosine similarity over
    
    Returns:
    
    Output variable
  - matrixDeterminant
```
public SDVariable matrixDeterminant(SDVariable in)
```
    See Also:
    
    matrixDeterminant(String, SDVariable)
  - matrixDeterminant
```
public SDVariable matrixDeterminant(String name,
                                    SDVariable 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:
    
    name - Name of the output variable
    
    in - Input
    
    Returns:
    
    Matrix determinant variable
  - matrixInverse
```
public SDVariable matrixInverse(SDVariable in)
```
    See Also:
    
    matrixInverse(String, SDVariable)
  - matrixInverse
```
public SDVariable matrixInverse(String name,
                                SDVariable 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:
    
    name - Name of the output variable
    
    in - Input
    
    Returns:
    
    Matrix inverse variable
  - mergeAdd
```
public SDVariable mergeAdd(SDVariable... x)
```
    Merge add function: merges an arbitrary number of equal shaped arrays using elementwise addition: out = sum_i in[i]
    
    Parameters:
    
    x - Input variables
    
    Returns:
    
    Output variable
  - mergeAdd
```
public SDVariable mergeAdd(String name,
                           SDVariable... inputs)
```
    Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition: out = sum_i in[i]
    
    Parameters:
    
    name - Name of the output variable
    
    inputs - Input variables
    
    Returns:
    
    Output variable
  - mergeAvg
```
public SDVariable mergeAvg(SDVariable... 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
    
    Returns:
    
    Output variable
  - mergeAvg
```
public SDVariable mergeAvg(String name,
                           SDVariable... inputs)
```
    Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation: out = mean_i in[i]
    
    Parameters:
    
    name - Name of the output variable
    
    inputs - Input variables
    
    Returns:
    
    Output variable
  - mergeMax
```
public SDVariable mergeMax(SDVariable... x)
```
    Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation: out = max_i in[i]
    
    Parameters:
    
    x - Input variables
    
    Returns:
    
    Output variable
  - mergeMax
```
public SDVariable mergeMax(String name,
                           SDVariable... 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
    
    Returns:
    
    Output variable
  - meshgrid
```
public SDVariable[] meshgrid(SDVariable... inputs)
```
    See Also:
    
    meshgrid(List, SDVariable...)
  - meshgrid
```
public SDVariable[] meshgrid(List<String> names,
                             SDVariable... inputs)
```
    Broadcast the 1D input variables onto an n-dimensional grid.
    The resulting variable can be used for example for evaluating functions at all locations on a grid.
    Example:
```
  input1 = [1, 2, 3]
 input2 = [4, 5, 6]
 SDVariable[] out = meshgrid(input1, input2)
 out[0]:
 [ 1, 2, 3]
 [ 1, 2, 3]
 [ 1, 2, 3]

 out[1]:
 [ 4, 4, 4]
 [ 5, 5, 5]
 [ 6, 6, 6]
 
```
    Parameters:
    
    names - List of names for the output variables. Must have exactly N names for N input arrays
    
    inputs - N x 1D input variables
    
    Returns:
    
    an array of exactly N SDVariables (for N inputs), of rank N
  - meshgrid
```
public SDVariable[] meshgrid(List<String> names,
                             boolean cartesian,
                             SDVariable... inputs)
```
    See Also:
    
    meshgrid(List, SDVariable...)
  - moments
```
public SDVariable[] moments(SDVariable input,
                            int... axes)
```
    See Also:
    
    moments(String[], SDVariable, int...)
  - moments
```
public SDVariable[] moments(String[] name,
                            SDVariable input,
                            int... axes)
```
    Calculate the mean and (population) variance for the input variable, for the specified axis
    
    Parameters:
    
    name - Name of the output variables. Can be null; if non-null, must be length 2
    
    input - Input to calculate moments for
    
    axes - Dimensions to perform calculation over
    
    Returns:
    
    Mean and variance variables
  - neg
```
public SDVariable neg(SDVariable x)
```
    Elementwise negative operation: out = -x
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - neg
```
public SDVariable neg(String name,
                      SDVariable x)
```
    Elementwise negative operation: out = -x
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - normalizeMoments
```
public SDVariable[] normalizeMoments(SDVariable counts,
                                     SDVariable means,
                                     SDVariable variances,
                                     double shift)
```
    See Also:
    
    normalizeMoments(String[], SDVariable, SDVariable, SDVariable, double)
  - normalizeMoments
```
public SDVariable[] normalizeMoments(String[] name,
                                     SDVariable counts,
                                     SDVariable means,
                                     SDVariable variances,
                                     double shift)
```
    Calculate the mean and variance from the sufficient statistics
    
    Parameters:
    
    name - Name of the output variables. Can be null; if non-null, must be length 2
    
    counts - Rank 0 (scalar) value with the total number of values used to calculate the sufficient statistics
    
    means - Mean-value sufficient statistics: this is the SUM of all data values
    
    variances - Variaance sufficient statistics: this is the squared sum of all data values
    
    shift - Shift value, possibly 0, used when calculating the sufficient statistics (for numerical stability)
    
    Returns:
    
    Output variables: mean and population variance
  - or
```
public SDVariable or(SDVariable x,
                     SDVariable 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
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - or
```
public SDVariable or(String name,
                     SDVariable x,
                     SDVariable 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:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - pow
```
public SDVariable pow(SDVariable x,
                      double value)
```
    Element-wise power function: out = x^value
    
    Parameters:
    
    x - Input variable
    
    value - Power to raise each element to
    
    Returns:
    
    Output variable
  - pow
```
public SDVariable pow(String name,
                      SDVariable x,
                      double value)
```
    Element-wise power function: out = x^value
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    value - Power to raise each element to
    
    Returns:
    
    Output variable
  - pow
```
public SDVariable pow(SDVariable x,
                      SDVariable y)
```
    Element-wise (broadcastable) power function: out = x[i]^y[i]
    
    Parameters:
    
    x - Input variable
    
    y - Power
    
    Returns:
    
    Output variable
  - pow
```
public SDVariable pow(String name,
                      SDVariable x,
                      SDVariable y)
```
    Element-wise (broadcastable) power function: out = x[i]^y[i]
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    y - Power
    
    Returns:
    
    Output variable
  - reciprocal
```
public SDVariable reciprocal(SDVariable a)
```
    Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
    
    Parameters:
    
    a - Input variable
    
    Returns:
    
    Output variable
  - reciprocal
```
public SDVariable reciprocal(String name,
                             SDVariable a)
```
    Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
    
    Parameters:
    
    name - Name of the output variable
    
    a - Input variable
    
    Returns:
    
    Output variable
  - round
```
public SDVariable round(SDVariable x)
```
    Elementwise round function: out = round(x). Rounds (up or down depending on value) to the nearest integer value.
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - round
```
public SDVariable round(String name,
                        SDVariable x)
```
    Element-wise round function: out = round(x). Rounds (up or down depending on value) to the nearest integer value.
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - rsqrt
```
public SDVariable rsqrt(SDVariable x)
```
    Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - rsqrt
```
public SDVariable rsqrt(String name,
                        SDVariable x)
```
    Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - setDiag
```
public SDVariable setDiag(SDVariable in,
                          SDVariable diag)
```
    See Also:
    
    setDiag(String, SDVariable, SDVariable)
  - setDiag
```
public SDVariable setDiag(String name,
                          SDVariable in,
                          SDVariable 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:
    
    name - Name of the output variable
    
    in - Input variable
    
    diag - Diagonal
    
    Returns:
    
    Output variable
  - shannonEntropy
```
public SDVariable shannonEntropy(SDVariable in,
                                 int... dimensions)
```
    Shannon Entropy reduction: -sum(x * log2(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null/empty for full array)
    
    Returns:
    
    Output variable
  - shannonEntropy
```
public SDVariable shannonEntropy(String name,
                                 SDVariable in,
                                 int... dimensions)
```
    Shannon Entropy reduction: -sum(x * log2(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null/empty for full array)
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - sign
```
public SDVariable sign(SDVariable 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
    
    Returns:
    
    Output variable
  - sign
```
public SDVariable sign(String name,
                       SDVariable x)
```
    Element-wise sign (signum) function:
    out = -1 if in < 0
    out = 0 if in = 0
    out = 1 if in > 0
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sin
```
public SDVariable sin(SDVariable x)
```
    Elementwise sine operation: out = sin(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sin
```
public SDVariable sin(String name,
                      SDVariable x)
```
    Elementwise sine operation: out = sin(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sinh
```
public SDVariable sinh(SDVariable x)
```
    Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sinh
```
public SDVariable sinh(String name,
                       SDVariable x)
```
    Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sqrt
```
public SDVariable sqrt(SDVariable x)
```
    Element-wise square root function: out = sqrt(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sqrt
```
public SDVariable sqrt(String name,
                       SDVariable x)
```
    Element-wise square root function: out = sqrt(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - square
```
public SDVariable square(SDVariable x)
```
    Element-wise square function: out = x^2
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - square
```
public SDVariable square(String name,
                         SDVariable x)
```
    Element-wise square function: out = x^2
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - step
```
public SDVariable step(SDVariable in,
                       double cutoff)
```
    Elementwise step function:
    out(x) = 1 if x >= cutoff
    out(x) = 0 otherwise
    
    Parameters:
    
    in - Input variable
    
    cutoff - Cutoff value for step function
    
    Returns:
    
    Output variable
  - step
```
public SDVariable step(String name,
                       SDVariable in,
                       double cutoff)
```
    Elementwise step function:
    out(x) = 1 if x >= cutoff
    out(x) = 0 otherwise
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    cutoff - Cutoff value for step function
    
    Returns:
    
    Output variable
  - standardize
```
public SDVariable standardize(SDVariable x,
                              int... dimensions)
```
    Standardize input variable along given axis
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
    
    See Also:
    
    standardize(String, SDVariable, int...)
  - standardize
```
public SDVariable standardize(String name,
                              SDVariable 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:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - tan
```
public SDVariable tan(SDVariable x)
```
    Elementwise tangent operation: out = tan(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - tan
```
public SDVariable tan(String name,
                      SDVariable x)
```
    Elementwise tangent operation: out = tan(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - tanh
```
public SDVariable tanh(SDVariable x)
```
    Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - tanh
```
public SDVariable tanh(String name,
                       SDVariable x)
```
    Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - trace
```
public SDVariable trace(SDVariable in)
```
    See Also:
    
    trace(String, SDVariable)
  - trace
```
public SDVariable trace(String name,
                        SDVariable 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:
    
    name - Name of the output variable. May be null.
    
    in - Input variable
    
    Returns:
    
    Trace
  - xor
```
public SDVariable xor(SDVariable x,
                      SDVariable 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
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - xor
```
public SDVariable xor(String name,
                      SDVariable x,
                      SDVariable 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:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - bitShift
```
public SDVariable bitShift(String name,
                           SDVariable x,
                           SDVariable shift)
```
    Shift integer bits to the left, i.e. var << 4
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    Returns:
    
    Output SDVariable with shifted bits
  - bitShiftRight
```
public SDVariable bitShiftRight(String name,
                                SDVariable x,
                                SDVariable shift)
```
    Shift integer bits to the right, i.e. var >> 4
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    Returns:
    
    Output SDVariable with shifted bits
  - bitRotl
```
public SDVariable bitRotl(String name,
                          SDVariable x,
                          SDVariable shift)
```
    Roll integer bits to the left, i.e. var << 4 | var >> (32 - 4)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    Returns:
    
    Output SDVariable with shifted bits
  - bitRotr
```
public SDVariable bitRotr(String name,
                          SDVariable x,
                          SDVariable shift)
```
    Roll integer bits to the right, i.e. var >> 4 | var << (32 - 4)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    Returns:
    
    Output SDVariable with shifted bits
  - zeroFraction
```
public SDVariable zeroFraction(SDVariable input)
```
    Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
    
    Parameters:
    
    input - Input variable
    
    Returns:
    
    Reduced array of rank 0 (scalar)
  - zeroFraction
```
public SDVariable zeroFraction(String name,
                               SDVariable input)
```
    Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
    
    Parameters:
    
    name - Name of the output variable
    
    input - Input variable
    
    Returns:
    
    Reduced array of rank 0 (scalar)

Class SDMath

Field Summary

Fields inherited from class org.nd4j.autodiff.samediff.ops.SDOps

Constructor Summary

Method Summary

Methods inherited from class org.nd4j.autodiff.samediff.ops.SDOps

Methods inherited from class java.lang.Object

Constructor Detail

SDMath

Method Detail

abs

abs

acos

acos

acosh

acosh

amax

amax

amean

amean

amin

amin

and

and

asin

asin

asinh

asinh

asum

asum

atan

atan

atan2

atan2

atanh

atanh

ceil

ceil

clipByNorm

clipByNorm

clipByNorm

clipByNorm

clipByValue

clipByValue

confusionMatrix

confusionMatrix

confusionMatrix

confusionMatrix

confusionMatrix

confusionMatrix

confusionMatrix

confusionMatrix

confusionMatrix

cos

cos

cosh

cosh

cosineDistance

cosineDistance

cosineSimilarity

cosineSimilarity

countNonZero

countNonZero

countZero

countZero

cross

cross

cube

cube

diag

diag

diagPart

diagPart

entropy

entropy

erf

erf

erfc

erfc

euclideanDistance