| Modifier and Type | Method and Description |
|---|---|
SDVariable |
all(SDVariable x,
int... dimensions)
Boolean and array reduction operation, optionally along specified dimensions
|
SDVariable |
all(String name,
SDVariable x,
int... dimensions)
Boolean and array reduction operation, optionally along specified dimensions
|
SDVariable |
any(SDVariable x,
int... dimensions)
Boolean or array reduction operation, optionally along specified dimensions
|
SDVariable |
any(String name,
SDVariable x,
int... dimensions)
Boolean or array reduction operation, optionally along specified dimensions
|
SDVariable |
argmax(SDVariable in,
boolean keepDims,
int... dimensions)
Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
argmax(SDVariable in,
int... dimensions)
Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
argmax(String name,
SDVariable in,
boolean keepDims,
int... dimensions)
Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
argmax(String name,
SDVariable in,
int... dimensions)
Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
argmin(SDVariable in,
boolean keepDims,
int... dimensions)
Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
argmin(SDVariable in,
int... dimensions)
Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
argmin(String name,
SDVariable in,
boolean keepDims,
int... dimensions)
Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
argmin(String name,
SDVariable in,
int... dimensions)
Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
assign(SDVariable x,
SDVariable y)
Assign the contents of y to x.
Y must be broadcastable to x or the same shape. |
SDVariable |
assign(String name,
SDVariable x,
SDVariable y)
Assign the contents of y to x.
Y must be broadcastable to x or the same shape. |
SDVariable[] |
batchMmul(SDVariable[] inputsA,
SDVariable... inputsB)
Matrix multiply a batch of matrices.
|
SDVariable[] |
batchMmul(SDVariable[] inputsA,
SDVariable[] inputsB,
boolean transposeA,
boolean transposeB)
Matrix multiply a batch of matrices.
|
SDVariable[] |
batchMmul(String[] names,
SDVariable[] inputsA,
SDVariable... inputsB)
Matrix multiply a batch of matrices.
|
SDVariable[] |
batchMmul(String[] names,
SDVariable[] inputsA,
SDVariable[] inputsB,
boolean transposeA,
boolean transposeB)
Matrix multiply a batch of matrices.
|
SDVariable |
castTo(SDVariable arg,
DataType datatype)
Cast the array to a new datatype - for example, Integer -> Float
|
SDVariable |
castTo(String name,
SDVariable arg,
DataType datatype)
Cast the array to a new datatype - for example, Integer -> Float
|
SDVariable |
clipByNorm(SDVariable x,
double clipValue)
Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value. |
SDVariable |
clipByNorm(SDVariable x,
SDVariable clipValue,
SDVariable dimensions)
Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value. |
SDVariable |
clipByNorm(String name,
SDVariable x,
double clipValue)
Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value. |
SDVariable |
clipByNorm(String name,
SDVariable x,
SDVariable clipValue,
SDVariable dimensions)
Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value. |
SDVariable |
clipByValue(SDVariable x,
double clipValueMin,
double clipValueMax)
Return the clipped ndarray containing values no smaller or larger than the given min and max.
|
SDVariable |
clipByValue(SDVariable x,
SDVariable clipValueMin,
SDVariable clipValueMax)
Return the clipped ndarray containing values no smaller or larger than the given min and max.
|
SDVariable |
clipByValue(String name,
SDVariable x,
double clipValueMin,
double clipValueMax)
Return the clipped ndarray containing values no smaller or larger than the given min and max.
|
SDVariable |
clipByValue(String name,
SDVariable x,
SDVariable clipValueMin,
SDVariable clipValueMax)
Return the clipped ndarray containing values no smaller or larger than the given min and max.
|
SDVariable |
concat(int dimension,
SDVariable... inputs)
Concatenate a set of inputs along the specified dimension.
Note that inputs must have identical rank and identical dimensions, other than the dimension to stack on. For example, if 2 inputs have shape [a, x, c] and [a, y, c] and dimension = 1, then the output has shape [a, x+y, c] Inputs must satisfy the following constraints: Input arrays must all be the same datatype: isSameType(inputs) |
SDVariable |
concat(String name,
int dimension,
SDVariable... inputs)
Concatenate a set of inputs along the specified dimension.
Note that inputs must have identical rank and identical dimensions, other than the dimension to stack on. For example, if 2 inputs have shape [a, x, c] and [a, y, c] and dimension = 1, then the output has shape [a, x+y, c] Inputs must satisfy the following constraints: Input arrays must all be the same datatype: isSameType(inputs) |
SDVariable |
create(SDVariable shape,
DataType dataType)
Return a newly created variable, with the specified shape and data type.
|
SDVariable |
create(SDVariable shape,
DataType dataType,
String order,
boolean initialize)
Return a newly created variable, with the specified shape and data type.
|
SDVariable |
create(String name,
SDVariable shape,
DataType dataType)
Return a newly created variable, with the specified shape and data type.
|
SDVariable |
create(String name,
SDVariable shape,
DataType dataType,
String order,
boolean initialize)
Return a newly created variable, with the specified shape and data type.
|
SDVariable |
cumprod(SDVariable in,
boolean exclusive,
boolean reverse,
int... axis)
Cumulative product operation.
For input: [ a, b, c], output is: exclusive=false, reverse=false: [a, a*b, a*b*c] exclusive=true, reverse=false, [0, a, a*b] exclusive=false, reverse=true: [a*b*c, b*c, c] exclusive=true, reverse=true: [b*c, c, 0] |
SDVariable |
cumprod(SDVariable in,
int... axis)
Cumulative product operation.
For input: [ a, b, c], output is: exclusive=false, reverse=false: [a, a*b, a*b*c] exclusive=true, reverse=false, [0, a, a*b] exclusive=false, reverse=true: [a*b*c, b*c, c] exclusive=true, reverse=true: [b*c, c, 0] |
SDVariable |
cumprod(String name,
SDVariable in,
boolean exclusive,
boolean reverse,
int... axis)
Cumulative product operation.
For input: [ a, b, c], output is: exclusive=false, reverse=false: [a, a*b, a*b*c] exclusive=true, reverse=false, [0, a, a*b] exclusive=false, reverse=true: [a*b*c, b*c, c] exclusive=true, reverse=true: [b*c, c, 0] |
SDVariable |
cumprod(String name,
SDVariable in,
int... axis)
Cumulative product operation.
For input: [ a, b, c], output is: exclusive=false, reverse=false: [a, a*b, a*b*c] exclusive=true, reverse=false, [0, a, a*b] exclusive=false, reverse=true: [a*b*c, b*c, c] exclusive=true, reverse=true: [b*c, c, 0] |
SDVariable |
cumsum(SDVariable in,
boolean exclusive,
boolean reverse,
int... axis)
Cumulative sum operation.
For input: [ a, b, c], output is: exclusive=false, reverse=false: [a, a+b, a+b+c] exclusive=true, reverse=false, [0, a, a+b] exclusive=false, reverse=true: [a+b+c, b+c, c] exclusive=true, reverse=true: [b+c, c, 0] |
SDVariable |
cumsum(SDVariable in,
int... axis)
Cumulative sum operation.
For input: [ a, b, c], output is: exclusive=false, reverse=false: [a, a+b, a+b+c] exclusive=true, reverse=false, [0, a, a+b] exclusive=false, reverse=true: [a+b+c, b+c, c] exclusive=true, reverse=true: [b+c, c, 0] |
SDVariable |
cumsum(String name,
SDVariable in,
boolean exclusive,
boolean reverse,
int... axis)
Cumulative sum operation.
For input: [ a, b, c], output is: exclusive=false, reverse=false: [a, a+b, a+b+c] exclusive=true, reverse=false, [0, a, a+b] exclusive=false, reverse=true: [a+b+c, b+c, c] exclusive=true, reverse=true: [b+c, c, 0] |
SDVariable |
cumsum(String name,
SDVariable in,
int... axis)
Cumulative sum operation.
For input: [ a, b, c], output is: exclusive=false, reverse=false: [a, a+b, a+b+c] exclusive=true, reverse=false, [0, a, a+b] exclusive=false, reverse=true: [a+b+c, b+c, c] exclusive=true, reverse=true: [b+c, c, 0] |
SDVariable |
dot(SDVariable x,
SDVariable y,
int... dimensions)
Pairwise dot product reduction along dimension
output = sum(i=0 ... |
SDVariable |
dot(String name,
SDVariable x,
SDVariable y,
int... dimensions)
Pairwise dot product reduction along dimension
output = sum(i=0 ... |
SDVariable[] |
dynamicPartition(SDVariable x,
SDVariable partitions,
int numPartitions)
Dynamically partition the input variable values into the specified number of paritions, using the indices.
Example: |
SDVariable[] |
dynamicPartition(String[] names,
SDVariable x,
SDVariable partitions,
int numPartitions)
Dynamically partition the input variable values into the specified number of paritions, using the indices.
Example: |
SDVariable |
dynamicStitch(SDVariable[] indices,
SDVariable... x)
Dynamically merge the specified input arrays into a single array, using the specified indices
|
SDVariable |
dynamicStitch(String name,
SDVariable[] indices,
SDVariable... x)
Dynamically merge the specified input arrays into a single array, using the specified indices
|
SDVariable |
eq(SDVariable x,
double y)
Equals operation: elementwise x == y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
eq(SDVariable x,
SDVariable y)
Equal to operation: elementwise x == y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
eq(String name,
SDVariable x,
double y)
Equals operation: elementwise x == y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
eq(String name,
SDVariable x,
SDVariable y)
Equal to operation: elementwise x == y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
expandDims(SDVariable x,
int axis)
Reshape the input by adding a 1 at the specified location.
For example, if input has shape [a, b], then output shape is: axis = 0: [1, a, b] axis = 1: [a, 1, b] axis = 2: [a, b, 1] |
SDVariable |
expandDims(String name,
SDVariable x,
int axis)
Reshape the input by adding a 1 at the specified location.
For example, if input has shape [a, b], then output shape is: axis = 0: [1, a, b] axis = 1: [a, 1, b] axis = 2: [a, b, 1] |
SDVariable |
fill(SDVariable shape,
DataType dataType,
double value)
Generate an output variable with the specified (dynamic) shape with all elements set to the specified value
|
SDVariable |
fill(String name,
SDVariable shape,
DataType dataType,
double value)
Generate an output variable with the specified (dynamic) shape with all elements set to the specified value
|
SDVariable |
gather(SDVariable df,
int[] indices,
int axis)
Gather slices from the input variable where the indices are specified as fixed int[] values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length. |
SDVariable |
gather(SDVariable df,
SDVariable indices,
int axis)
Gather slices from the input variable where the indices are specified as dynamic array values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length. |
SDVariable |
gather(String name,
SDVariable df,
int[] indices,
int axis)
Gather slices from the input variable where the indices are specified as fixed int[] values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length. |
SDVariable |
gather(String name,
SDVariable df,
SDVariable indices,
int axis)
Gather slices from the input variable where the indices are specified as dynamic array values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length. |
SDVariable |
gatherNd(SDVariable df,
SDVariable indices)
Gather slices from df with shape specified by indices.
|
SDVariable |
gatherNd(String name,
SDVariable df,
SDVariable indices)
Gather slices from df with shape specified by indices.
|
SDVariable |
gt(SDVariable x,
double y)
Greater than operation: elementwise x > y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
gt(SDVariable x,
SDVariable y)
Greater than operation: elementwise x > y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
gt(String name,
SDVariable x,
double y)
Greater than operation: elementwise x > y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
gt(String name,
SDVariable x,
SDVariable y)
Greater than operation: elementwise x > y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
gte(SDVariable x,
double y)
Greater than or equals operation: elementwise x >= y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
gte(SDVariable x,
SDVariable y)
Greater than or equal to operation: elementwise x >= y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
gte(String name,
SDVariable x,
double y)
Greater than or equals operation: elementwise x >= y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
gte(String name,
SDVariable x,
SDVariable y)
Greater than or equal to operation: elementwise x >= y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
identity(SDVariable input)
Elementwise identity operation: out = x
|
SDVariable |
identity(String name,
SDVariable input)
Elementwise identity operation: out = x
|
SDVariable |
invertPermutation(SDVariable input)
Compute the inverse permutation indices for a permutation operation
Example: if input is [2, 0, 1] then output is [1, 2, 0] The idea is that x.permute(input).permute(invertPermutation(input)) == x |
SDVariable |
invertPermutation(String name,
SDVariable input)
Compute the inverse permutation indices for a permutation operation
Example: if input is [2, 0, 1] then output is [1, 2, 0] The idea is that x.permute(input).permute(invertPermutation(input)) == x |
SDVariable |
isNumericTensor(SDVariable x)
Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1
|
SDVariable |
isNumericTensor(String name,
SDVariable x)
Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1
|
SDVariable |
linspace(DataType dataType,
double start,
double stop,
long number)
Create a new 1d array with values evenly spaced between values 'start' and 'stop'
For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0] |
SDVariable |
linspace(SDVariable start,
SDVariable stop,
SDVariable number,
DataType dataType)
Create a new 1d array with values evenly spaced between values 'start' and 'stop'
For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0] |
SDVariable |
linspace(String name,
DataType dataType,
double start,
double stop,
long number)
Create a new 1d array with values evenly spaced between values 'start' and 'stop'
For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0] |
SDVariable |
linspace(String name,
SDVariable start,
SDVariable stop,
SDVariable number,
DataType dataType)
Create a new 1d array with values evenly spaced between values 'start' and 'stop'
For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0] |
SDVariable |
lt(SDVariable x,
double y)
Less than operation: elementwise x < y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
lt(SDVariable x,
SDVariable y)
Less than operation: elementwise x < y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
lt(String name,
SDVariable x,
double y)
Less than operation: elementwise x < y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
lt(String name,
SDVariable x,
SDVariable y)
Less than operation: elementwise x < y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
lte(SDVariable x,
double y)
Less than or equals operation: elementwise x <= y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
lte(SDVariable x,
SDVariable y)
Less than or equal to operation: elementwise x <= y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
lte(String name,
SDVariable x,
double y)
Less than or equals operation: elementwise x <= y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
lte(String name,
SDVariable x,
SDVariable y)
Less than or equal to operation: elementwise x <= y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
matchCondition(SDVariable in,
Condition condition)
Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwise
|
SDVariable |
matchCondition(String name,
SDVariable in,
Condition condition)
Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwise
|
SDVariable |
matchConditionCount(SDVariable in,
Condition condition)
Returns a count of the number of elements that satisfy the condition
|
SDVariable |
matchConditionCount(SDVariable in,
Condition condition,
boolean keepDim,
int... dimensions)
Returns a count of the number of elements that satisfy the 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 |
matchConditionCount(SDVariable in,
Condition condition,
int... dimensions)
Returns a count of the number of elements that satisfy the 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 |
matchConditionCount(String name,
SDVariable in,
Condition condition)
Returns a count of the number of elements that satisfy the condition
|
SDVariable |
matchConditionCount(String name,
SDVariable in,
Condition condition,
boolean keepDim,
int... dimensions)
Returns a count of the number of elements that satisfy the 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 |
matchConditionCount(String name,
SDVariable in,
Condition condition,
int... dimensions)
Returns a count of the number of elements that satisfy the 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 |
max(SDVariable x,
boolean keepDims,
int... dimensions)
Max array reduction operation, optionally along 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 |
max(SDVariable x,
int... dimensions)
Max array reduction operation, optionally along 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 |
max(SDVariable first,
SDVariable second)
Element-wise maximum operation: out[i] = max(first[i], second[i])
Note: supports broadcasting if x and y have different shapes and are broadcastable. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html |
SDVariable |
max(String name,
SDVariable x,
boolean keepDims,
int... dimensions)
Max array reduction operation, optionally along 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 |
max(String name,
SDVariable x,
int... dimensions)
Max array reduction operation, optionally along 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 |
max(String name,
SDVariable first,
SDVariable second)
Element-wise maximum operation: out[i] = max(first[i], second[i])
Note: supports broadcasting if x and y have different shapes and are broadcastable. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html |
SDVariable |
mean(SDVariable x,
boolean keepDims,
int... dimensions)
Mean (average) array reduction operation, optionally along 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 |
mean(SDVariable x,
int... dimensions)
Mean (average) array reduction operation, optionally along 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 |
mean(SDVariable x,
SDVariable dimensions)
Mean (average) array reduction operation, optionally along 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 |
mean(SDVariable x,
SDVariable dimensions,
boolean keepDims)
Mean (average) array reduction operation, optionally along 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 |
mean(String name,
SDVariable x,
boolean keepDims,
int... dimensions)
Mean (average) array reduction operation, optionally along 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 |
mean(String name,
SDVariable x,
int... dimensions)
Mean (average) array reduction operation, optionally along 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 |
mean(String name,
SDVariable x,
SDVariable dimensions)
Mean (average) array reduction operation, optionally along 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 |
mean(String name,
SDVariable x,
SDVariable dimensions,
boolean keepDims)
Mean (average) array reduction operation, optionally along 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 |
merge(SDVariable x,
SDVariable y)
The merge operation is a control operation that forwards the either of the inputs to the output, when
the first of them becomes available. |
SDVariable |
merge(String name,
SDVariable x,
SDVariable y)
The merge operation is a control operation that forwards the either of the inputs to the output, when
the first of them becomes available. |
SDVariable |
min(SDVariable x,
boolean keepDims,
int... dimensions)
Minimum array reduction operation, optionally along specified dimensions.
|
SDVariable |
min(SDVariable x,
int... dimensions)
Minimum array reduction operation, optionally along specified dimensions.
|
SDVariable |
min(SDVariable first,
SDVariable second)
Element-wise minimum operation: out[i] = min(first[i], second[i])
Note: supports broadcasting if x and y have different shapes and are broadcastable. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html |
SDVariable |
min(String name,
SDVariable x,
boolean keepDims,
int... dimensions)
Minimum array reduction operation, optionally along specified dimensions.
|
SDVariable |
min(String name,
SDVariable x,
int... dimensions)
Minimum array reduction operation, optionally along specified dimensions.
|
SDVariable |
min(String name,
SDVariable first,
SDVariable second)
Element-wise minimum operation: out[i] = min(first[i], second[i])
Note: supports broadcasting if x and y have different shapes and are broadcastable. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html |
SDVariable |
minMax(int datatype,
int minOrMax)
Return a scalar array reflecting the min or max value for a given data type.
|
SDVariable |
minMax(String name,
int datatype,
int minOrMax)
Return a scalar array reflecting the min or max value for a given data type.
|
SDVariable |
mmul(SDVariable x,
SDVariable y)
Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc. |
SDVariable |
mmul(SDVariable x,
SDVariable y,
boolean transposeX,
boolean transposeY,
boolean transposeZ)
Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc. |
SDVariable |
mmul(String name,
SDVariable x,
SDVariable y)
Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc. |
SDVariable |
mmul(String name,
SDVariable x,
SDVariable y,
boolean transposeX,
boolean transposeY,
boolean transposeZ)
Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc. |
SDVariable |
neq(SDVariable x,
double y)
Not equals operation: elementwise x != y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
neq(SDVariable x,
SDVariable y)
Not equal to operation: elementwise x != y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
neq(String name,
SDVariable x,
double y)
Not equals operation: elementwise x != y
Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
neq(String name,
SDVariable x,
SDVariable y)
Not equal to operation: elementwise x != y
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. For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10] Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html Return boolean array with values true where satisfied, or false otherwise. |
SDVariable |
norm1(SDVariable x,
boolean keepDims,
int... dimensions)
Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i]) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
norm1(SDVariable x,
int... dimensions)
Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i]) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
norm1(String name,
SDVariable x,
boolean keepDims,
int... dimensions)
Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i]) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
norm1(String name,
SDVariable x,
int... dimensions)
Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i]) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
norm2(SDVariable x,
boolean keepDims,
int... dimensions)
Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
norm2(SDVariable x,
int... dimensions)
Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
norm2(String name,
SDVariable x,
boolean keepDims,
int... dimensions)
Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
norm2(String name,
SDVariable x,
int... dimensions)
Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
normmax(SDVariable x,
boolean keepDims,
int... dimensions)
Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions: out = max(abs(x[i])) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
normmax(SDVariable x,
int... dimensions)
Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions: out = max(abs(x[i])) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
normmax(String name,
SDVariable x,
boolean keepDims,
int... dimensions)
Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions: out = max(abs(x[i])) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
normmax(String name,
SDVariable x,
int... dimensions)
Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions: out = max(abs(x[i])) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
oneHot(SDVariable indices,
int depth)
Convert the array to a one-hot array with values 0 and 1 for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with out[i, ..., j, in[i,...,j]] = 1 with other values being set to 0 see oneHot(SDVariable, int, int, double, double) |
SDVariable |
oneHot(SDVariable indices,
int depth,
int axis,
double on,
double off)
Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with {out[i, ..., j, in[i,...,j]] with other values being set to |
SDVariable |
oneHot(SDVariable indices,
int depth,
int axis,
double on,
double off,
DataType dataType)
Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with {out[i, ..., j, in[i,...,j]] with other values being set to |
SDVariable |
oneHot(String name,
SDVariable indices,
int depth)
Convert the array to a one-hot array with values 0 and 1 for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with out[i, ..., j, in[i,...,j]] = 1 with other values being set to 0 see oneHot(SDVariable, int, int, double, double) |
SDVariable |
oneHot(String name,
SDVariable indices,
int depth,
int axis,
double on,
double off)
Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with {out[i, ..., j, in[i,...,j]] with other values being set to |
SDVariable |
oneHot(String name,
SDVariable indices,
int depth,
int axis,
double on,
double off,
DataType dataType)
Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with {out[i, ..., j, in[i,...,j]] with other values being set to |
SDVariable |
onesLike(SDVariable input)
Return a variable of all 1s, with the same shape as the input variable.
|
SDVariable |
onesLike(SDVariable input,
DataType dataType)
As per onesLike(String, SDVariable) but the output datatype may be specified
|
SDVariable |
onesLike(String name,
SDVariable input)
Return a variable of all 1s, with the same shape as the input variable.
|
SDVariable |
onesLike(String name,
SDVariable input,
DataType dataType)
As per onesLike(String, SDVariable) but the output datatype may be specified
|
SDVariable |
permute(SDVariable x,
int... dimensions)
Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b] |
SDVariable |
permute(SDVariable x,
SDVariable dimensions)
Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b] |
SDVariable |
permute(String name,
SDVariable x,
int... dimensions)
Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b] |
SDVariable |
permute(String name,
SDVariable x,
SDVariable dimensions)
Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b] |
SDVariable |
prod(SDVariable x,
boolean keepDims,
int... dimensions)
Product array reduction operation, optionally along 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 |
prod(SDVariable x,
int... dimensions)
Product array reduction operation, optionally along 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 |
prod(SDVariable x,
SDVariable dimensions)
Product array reduction operation, optionally along 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 |
prod(SDVariable x,
SDVariable dimensions,
boolean keepDims)
Product array reduction operation, optionally along 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 |
prod(String name,
SDVariable x,
boolean keepDims,
int... dimensions)
Product array reduction operation, optionally along 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 |
prod(String name,
SDVariable x,
int... dimensions)
Product array reduction operation, optionally along 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 |
prod(String name,
SDVariable x,
SDVariable dimensions)
Product array reduction operation, optionally along 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 |
prod(String name,
SDVariable x,
SDVariable dimensions,
boolean keepDims)
Product array reduction operation, optionally along 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 |
range(double from,
double to,
double step,
DataType dataType)
Create a new variable with a 1d array, where the values start at from and increment by step
up to (but not including) limit. For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5] |
SDVariable |
range(SDVariable from,
SDVariable to,
SDVariable step,
DataType dataType)
Create a new variable with a 1d array, where the values start at from and increment by step
up to (but not including) limit. For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5] |
SDVariable |
range(String name,
double from,
double to,
double step,
DataType dataType)
Create a new variable with a 1d array, where the values start at from and increment by step
up to (but not including) limit. For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5] |
SDVariable |
range(String name,
SDVariable from,
SDVariable to,
SDVariable step,
DataType dataType)
Create a new variable with a 1d array, where the values start at from and increment by step
up to (but not including) limit. For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5] |
SDVariable |
rank(SDVariable in)
Returns the rank (number of dimensions, i.e., length(shape)) of the specified INDArray as a 0D scalar variable
|
SDVariable |
rank(String name,
SDVariable in)
Returns the rank (number of dimensions, i.e., length(shape)) of the specified INDArray as a 0D scalar variable
|
SDVariable |
repeat(SDVariable input,
SDVariable repeats,
int axis)
A tensor with the shape of input minus the specified axis with elements repeated along the specified axis.
|
SDVariable |
repeat(String name,
SDVariable input,
SDVariable repeats,
int axis)
A tensor with the shape of input minus the specified axis with elements repeated along the specified axis.
|
SDVariable |
replaceWhere(SDVariable update,
double value,
Condition condition)
Element-wise replace where condition:
out[i] = value if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied |
SDVariable |
replaceWhere(SDVariable update,
SDVariable from,
Condition condition)
Element-wise replace where condition:
out[i] = from[i] if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied |
SDVariable |
replaceWhere(String name,
SDVariable update,
double value,
Condition condition)
Element-wise replace where condition:
out[i] = value if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied |
SDVariable |
replaceWhere(String name,
SDVariable update,
SDVariable from,
Condition condition)
Element-wise replace where condition:
out[i] = from[i] if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied |
SDVariable |
reshape(SDVariable x,
long... shape)
Reshape the input variable to the specified (fixed) shape.
|
SDVariable |
reshape(SDVariable x,
SDVariable shape)
Reshape the input variable to the specified (fixed) shape.
|
SDVariable |
reshape(String name,
SDVariable x,
long... shape)
Reshape the input variable to the specified (fixed) shape.
|
SDVariable |
reshape(String name,
SDVariable x,
SDVariable shape)
Reshape the input variable to the specified (fixed) shape.
|
SDVariable |
reverse(SDVariable x,
int... dimensions)
Reverse the values of an array for the specified dimensions
If input is: [ 1, 2, 3] [ 4, 5, 6] then reverse(in, 0): [3, 2, 1] [6, 5, 4] reverse(in, 1): [4, 5, 6] [1, 2 3] |
SDVariable |
reverse(String name,
SDVariable x,
int... dimensions)
Reverse the values of an array for the specified dimensions
If input is: [ 1, 2, 3] [ 4, 5, 6] then reverse(in, 0): [3, 2, 1] [6, 5, 4] reverse(in, 1): [4, 5, 6] [1, 2 3] |
SDVariable |
reverseSequence(SDVariable x,
SDVariable seq_lengths)
Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversed
|
SDVariable |
reverseSequence(SDVariable x,
SDVariable seq_lengths,
int seqDim,
int batchDim)
Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversed
|
SDVariable |
reverseSequence(String name,
SDVariable x,
SDVariable seq_lengths)
Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversed
|
SDVariable |
reverseSequence(String name,
SDVariable x,
SDVariable seq_lengths,
int seqDim,
int batchDim)
Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversed
|
SDVariable |
scalarFloorMod(SDVariable in,
double value)
Element-wise scalar floor modulus operation: out = floorMod(in, value).
i.e., returns the remainder after division by 'value' |
SDVariable |
scalarFloorMod(String name,
SDVariable in,
double value)
Element-wise scalar floor modulus operation: out = floorMod(in, value).
i.e., returns the remainder after division by 'value' |
SDVariable |
scalarMax(SDVariable in,
double value)
Element-wise scalar maximum operation: out = max(in, value)
|
SDVariable |
scalarMax(String name,
SDVariable in,
double value)
Element-wise scalar maximum operation: out = max(in, value)
|
SDVariable |
scalarMin(SDVariable in,
double value)
Element-wise scalar minimum operation: out = min(in, value)
|
SDVariable |
scalarMin(String name,
SDVariable in,
double value)
Element-wise scalar minimum operation: out = min(in, value)
|
SDVariable |
scalarSet(SDVariable in,
double set)
Return a variable with equal shape to the input, but all elements set to value 'set'
|
SDVariable |
scalarSet(String name,
SDVariable in,
double set)
Return a variable with equal shape to the input, but all elements set to value 'set'
|
SDVariable |
scatterAdd(SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter addition operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterAdd(String name,
SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter addition operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterDiv(SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter division operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterDiv(String name,
SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter division operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterMax(SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter max operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterMax(String name,
SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter max operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterMin(SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter min operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterMin(String name,
SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter min operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterMul(SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter multiplication operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterMul(String name,
SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter multiplication operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterSub(SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter subtraction operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterSub(String name,
SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter subtraction operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterUpdate(SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter update operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
scatterUpdate(String name,
SDVariable ref,
SDVariable indices,
SDVariable updates)
Scatter update operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...]) Note that if multiple indices refer to the same location, the contributions from each is handled correctly. |
SDVariable |
segmentMax(SDVariable data,
SDVariable segmentIds)
Segment max operation.
If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)] Note that the segment IDs must be sorted from smallest to largest segment. See {unsortedSegment (String, SDVariable, SDVariable, int) ops for the same op without this sorted requirement |
SDVariable |
segmentMax(String name,
SDVariable data,
SDVariable segmentIds)
Segment max operation.
If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)] Note that the segment IDs must be sorted from smallest to largest segment. See {unsortedSegment (String, SDVariable, SDVariable, int) ops for the same op without this sorted requirement |
SDVariable |
segmentMean(SDVariable data,
SDVariable segmentIds)
Segment mean operation.
If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)] Note that the segment IDs must be sorted from smallest to largest segment. See {unsortedSegment (String, SDVariable, SDVariable, int) ops for the same op without this sorted requirement |
SDVariable |
segmentMean(String name,
SDVariable data,
SDVariable segmentIds)
Segment mean operation.
If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)] Note that the segment IDs must be sorted from smallest to largest segment. See {unsortedSegment (String, SDVariable, SDVariable, int) ops for the same op without this sorted requirement |
SDVariable |
segmentMin(SDVariable data,
SDVariable segmentIds)
Segment min operation.
If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)] Note that the segment IDs must be sorted from smallest to largest segment. See {unsortedSegment (String, SDVariable, SDVariable, int) ops for the same op without this sorted requirement |
SDVariable |
segmentMin(String name,
SDVariable data,
SDVariable segmentIds)
Segment min operation.
If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)] Note that the segment IDs must be sorted from smallest to largest segment. See {unsortedSegment (String, SDVariable, SDVariable, int) ops for the same op without this sorted requirement |
SDVariable |
segmentProd(SDVariable data,
SDVariable segmentIds)
Segment product operation.
If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)] Note that the segment IDs must be sorted from smallest to largest segment. See {unsortedSegment (String, SDVariable, SDVariable, int) ops for the same op without this sorted requirement |
SDVariable |
segmentProd(String name,
SDVariable data,
SDVariable segmentIds)
Segment product operation.
If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)] Note that the segment IDs must be sorted from smallest to largest segment. See {unsortedSegment (String, SDVariable, SDVariable, int) ops for the same op without this sorted requirement |
SDVariable |
segmentSum(SDVariable data,
SDVariable segmentIds)
Segment sum operation.
If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)] Note that the segment IDs must be sorted from smallest to largest segment. See {unsortedSegment (String, SDVariable, SDVariable, int) ops for the same op without this sorted requirement |
SDVariable |
segmentSum(String name,
SDVariable data,
SDVariable segmentIds)
Segment sum operation.
If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)] Note that the segment IDs must be sorted from smallest to largest segment. See {unsortedSegment (String, SDVariable, SDVariable, int) ops for the same op without this sorted requirement |
SDVariable |
sequenceMask(SDVariable lengths,
DataType dataType)
see sequenceMask(String, SDVariable, SDVariable, DataType)
|
SDVariable |
sequenceMask(SDVariable lengths,
int maxLen,
DataType dataType)
Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0) |
SDVariable |
sequenceMask(SDVariable lengths,
SDVariable maxLen,
DataType dataType)
Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0) |
SDVariable |
sequenceMask(String name,
SDVariable lengths,
DataType dataType)
see sequenceMask(String, SDVariable, SDVariable, DataType)
|
SDVariable |
sequenceMask(String name,
SDVariable lengths,
int maxLen,
DataType dataType)
Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0) |
SDVariable |
sequenceMask(String name,
SDVariable lengths,
SDVariable maxLen,
DataType dataType)
Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0) |
SDVariable[] |
setShape(SDVariable input,
SDVariable shape)
Sets an inplace shape on the passed in input.
|
SDVariable[] |
setShape(String[] names,
SDVariable input,
SDVariable shape)
Sets an inplace shape on the passed in input.
|
SDVariable |
shape(SDVariable input)
Returns the shape of the specified INDArray as a 1D INDArray
|
SDVariable |
shape(String name,
SDVariable input)
Returns the shape of the specified INDArray as a 1D INDArray
|
SDVariable |
size(SDVariable in)
Returns the size (number of elements, i.e., prod(shape)) of the specified INDArray as a 0D scalar variable
|
SDVariable |
size(String name,
SDVariable in)
Returns the size (number of elements, i.e., prod(shape)) of the specified INDArray as a 0D scalar variable
|
SDVariable |
sizeAt(SDVariable in,
int dimension)
Returns a rank 0 (scalar) variable for the size of the specified dimension.
For example, if X has shape [10,20,30] then sizeAt(X,1)=20. |
SDVariable |
sizeAt(String name,
SDVariable in,
int dimension)
Returns a rank 0 (scalar) variable for the size of the specified dimension.
For example, if X has shape [10,20,30] then sizeAt(X,1)=20. |
SDVariable |
slice(SDVariable input,
int[] begin,
int... size)
Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is: [a, b, c] [d, e, f] then slice(input, begin=[0,1], size=[2,1] will return: [b] [e] Note that for each dimension i, begin[i] + size[i] <= input.size(i) |
SDVariable |
slice(SDVariable input,
SDVariable begin,
SDVariable size)
Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is: [a, b, c] [d, e, f] then slice(input, begin=[0,1], size=[2,1] will return: [b] [e] Note that for each dimension i, begin[i] + size[i] <= input.size(i) |
SDVariable |
slice(String name,
SDVariable input,
int[] begin,
int... size)
Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is: [a, b, c] [d, e, f] then slice(input, begin=[0,1], size=[2,1] will return: [b] [e] Note that for each dimension i, begin[i] + size[i] <= input.size(i) |
SDVariable |
slice(String name,
SDVariable input,
SDVariable begin,
SDVariable size)
Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is: [a, b, c] [d, e, f] then slice(input, begin=[0,1], size=[2,1] will return: [b] [e] Note that for each dimension i, begin[i] + size[i] <= input.size(i) |
SDVariable |
sparseToDense(SDVariable indices,
SDVariable shape,
SDVariable values)
Create a dense matrix equivalent of a sparse matrix based on the given input.
|
SDVariable |
sparseToDense(SDVariable indices,
SDVariable shape,
SDVariable values,
SDVariable defaultValue)
Create a dense matrix equivalent of a sparse matrix based on the given input.
|
SDVariable |
sparseToDense(String name,
SDVariable indices,
SDVariable shape,
SDVariable values)
Create a dense matrix equivalent of a sparse matrix based on the given input.
|
SDVariable |
sparseToDense(String name,
SDVariable indices,
SDVariable shape,
SDVariable values,
SDVariable defaultValue)
Create a dense matrix equivalent of a sparse matrix based on the given input.
|
SDVariable[] |
split(SDVariable input,
int numSplit,
int splitDim)
Split a value in to a list of ndarrays.
|
SDVariable[] |
split(SDVariable input,
SDVariable numSplit,
int splitDim)
Split a value in to a list of ndarrays.
|
SDVariable[] |
split(String[] names,
SDVariable input,
int numSplit,
int splitDim)
Split a value in to a list of ndarrays.
|
SDVariable[] |
split(String[] names,
SDVariable input,
SDVariable numSplit,
int splitDim)
Split a value in to a list of ndarrays.
|
SDVariable[] |
splitV(SDVariable input,
SDVariable sizes,
int numSplit,
int splitDim)
Split a value in to a list of ndarrays with varying sizes
according to the sizes parameter. |
SDVariable[] |
splitV(String[] names,
SDVariable input,
SDVariable sizes,
int numSplit,
int splitDim)
Split a value in to a list of ndarrays with varying sizes
according to the sizes parameter. |
SDVariable |
squaredNorm(SDVariable x,
boolean keepDims,
int... dimensions)
Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
squaredNorm(SDVariable x,
int... dimensions)
Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
squaredNorm(String name,
SDVariable x,
boolean keepDims,
int... dimensions)
Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
squaredNorm(String name,
SDVariable x,
int... dimensions)
Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
squeeze(SDVariable x,
int axis)
Remove a single dimension of size 1.
For example, if input has shape [a,b,1,c] then squeeze(input, 2) returns an array of shape [a,b,c] |
SDVariable |
squeeze(String name,
SDVariable x,
int axis)
Remove a single dimension of size 1.
For example, if input has shape [a,b,1,c] then squeeze(input, 2) returns an array of shape [a,b,c] |
SDVariable |
stack(int axis,
SDVariable... values)
Stack a set of N INDArray of rank X into one rank X+1 variable.
If inputs have shape [a,b,c] then output has shape: axis = 0: [N,a,b,c] axis = 1: [a,N,b,c] axis = 2: [a,b,N,c] axis = 3: [a,b,c,N] see unstack(String[], SDVariable, int, int) |
SDVariable |
stack(String name,
int axis,
SDVariable... values)
Stack a set of N INDArray of rank X into one rank X+1 variable.
If inputs have shape [a,b,c] then output has shape: axis = 0: [N,a,b,c] axis = 1: [a,N,b,c] axis = 2: [a,b,N,c] axis = 3: [a,b,c,N] see unstack(String[], SDVariable, int, int) |
SDVariable |
standardDeviation(SDVariable x,
boolean biasCorrected,
boolean keepDims,
int... dimensions)
Standard deviation array reduction operation, optionally along 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 |
standardDeviation(SDVariable x,
boolean biasCorrected,
int... dimensions)
Standard deviation array reduction operation, optionally along 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 |
standardDeviation(String name,
SDVariable x,
boolean biasCorrected,
boolean keepDims,
int... dimensions)
Standard deviation array reduction operation, optionally along 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 |
standardDeviation(String name,
SDVariable x,
boolean biasCorrected,
int... dimensions)
Standard deviation array reduction operation, optionally along 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 |
stridedSlice(SDVariable in,
long[] begin,
long[] end,
long... strides)
Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is: [a, b, c] [d, e, f] [g, h, i] then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return: [b, c] [h, i] |
SDVariable |
stridedSlice(SDVariable in,
long[] begin,
long[] end,
long[] strides,
int beginMask,
int endMask,
int ellipsisMask,
int newAxisMask,
int shrinkAxisMask)
Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is: [a, b, c] [d, e, f] [g, h, i] then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return: [b, c] [h, i] |
SDVariable |
stridedSlice(SDVariable in,
SDVariable begin,
SDVariable end,
SDVariable strides)
Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is: [a, b, c] [d, e, f] [g, h, i] then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return: [b, c] [h, i] |
SDVariable |
stridedSlice(SDVariable in,
SDVariable begin,
SDVariable end,
SDVariable strides,
int beginMask,
int endMask,
int ellipsisMask,
int newAxisMask,
int shrinkAxisMask)
Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is: [a, b, c] [d, e, f] [g, h, i] then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return: [b, c] [h, i] |
SDVariable |
stridedSlice(String name,
SDVariable in,
long[] begin,
long[] end,
long... strides)
Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is: [a, b, c] [d, e, f] [g, h, i] then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return: [b, c] [h, i] |
SDVariable |
stridedSlice(String name,
SDVariable in,
long[] begin,
long[] end,
long[] strides,
int beginMask,
int endMask,
int ellipsisMask,
int newAxisMask,
int shrinkAxisMask)
Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is: [a, b, c] [d, e, f] [g, h, i] then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return: [b, c] [h, i] |
SDVariable |
stridedSlice(String name,
SDVariable in,
SDVariable begin,
SDVariable end,
SDVariable strides)
Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is: [a, b, c] [d, e, f] [g, h, i] then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return: [b, c] [h, i] |
SDVariable |
stridedSlice(String name,
SDVariable in,
SDVariable begin,
SDVariable end,
SDVariable strides,
int beginMask,
int endMask,
int ellipsisMask,
int newAxisMask,
int shrinkAxisMask)
Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is: [a, b, c] [d, e, f] [g, h, i] then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return: [b, c] [h, i] |
SDVariable |
sum(SDVariable x,
boolean keepDims,
int... dimensions)
Sum array reduction operation, optionally along 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 |
sum(SDVariable x,
int... dimensions)
Sum array reduction operation, optionally along 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 |
sum(String name,
SDVariable x,
boolean keepDims,
int... dimensions)
Sum array reduction operation, optionally along 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 |
sum(String name,
SDVariable x,
int... dimensions)
Sum array reduction operation, optionally along 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[] |
switchOp(SDVariable x,
SDVariable predicate)
Switch operation
Predicate - if false, values are output to left (first) branch/output; if true, to right (second) branch/output |
SDVariable[] |
switchOp(String[] names,
SDVariable x,
SDVariable predicate)
Switch operation
Predicate - if false, values are output to left (first) branch/output; if true, to right (second) branch/output |
SDVariable |
tensorMmul(SDVariable x,
SDVariable y,
int[] dimensionsX,
int... dimensionsY)
//TODO: Ops must be documented.
|
SDVariable |
tensorMmul(SDVariable x,
SDVariable y,
int[] dimensionsX,
int[] dimensionsY,
boolean transposeX,
boolean transposeY,
boolean transposeZ)
//TODO: Ops must be documented.
|
SDVariable |
tensorMmul(String name,
SDVariable x,
SDVariable y,
int[] dimensionsX,
int... dimensionsY)
//TODO: Ops must be documented.
|
SDVariable |
tensorMmul(String name,
SDVariable x,
SDVariable y,
int[] dimensionsX,
int[] dimensionsY,
boolean transposeX,
boolean transposeY,
boolean transposeZ)
//TODO: Ops must be documented.
|
SDVariable |
tile(SDVariable x,
int... repeat)
see tile(String, SDVariable, int...)
|
SDVariable |
tile(SDVariable x,
SDVariable repeat)
Repeat (tile) the input tensor the specified number of times.
For example, if input is [1, 2] [3, 4] and repeat is [2, 3] then output is [1, 2, 1, 2, 1, 2] [3, 4, 3, 4, 3, 4] [1, 2, 1, 2, 1, 2] [3, 4, 3, 4, 3, 4] |
SDVariable |
tile(String name,
SDVariable x,
int... repeat)
see tile(String, SDVariable, int...)
|
SDVariable |
tile(String name,
SDVariable x,
SDVariable repeat)
Repeat (tile) the input tensor the specified number of times.
For example, if input is [1, 2] [3, 4] and repeat is [2, 3] then output is [1, 2, 1, 2, 1, 2] [3, 4, 3, 4, 3, 4] [1, 2, 1, 2, 1, 2] [3, 4, 3, 4, 3, 4] |
SDVariable |
transpose(SDVariable x)
Matrix transpose operation: If input has shape [a,b] output has shape [b,a]
|
SDVariable |
transpose(String name,
SDVariable x)
Matrix transpose operation: If input has shape [a,b] output has shape [b,a]
|
SDVariable |
unsortedSegmentMax(SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment max operation.
|
SDVariable |
unsortedSegmentMax(String name,
SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment max operation.
|
SDVariable |
unsortedSegmentMean(SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment mean operation.
|
SDVariable |
unsortedSegmentMean(String name,
SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment mean operation.
|
SDVariable |
unsortedSegmentMin(SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment min operation.
|
SDVariable |
unsortedSegmentMin(String name,
SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment min operation.
|
SDVariable |
unsortedSegmentProd(SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment product operation.
|
SDVariable |
unsortedSegmentProd(String name,
SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment product operation.
|
SDVariable |
unsortedSegmentSqrtN(SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment sqrtN operation.
|
SDVariable |
unsortedSegmentSqrtN(String name,
SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment sqrtN operation.
|
SDVariable |
unsortedSegmentSum(SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment sum operation.
|
SDVariable |
unsortedSegmentSum(String name,
SDVariable data,
SDVariable segmentIds,
int numSegments)
Unsorted segment sum operation.
|
SDVariable[] |
unstack(SDVariable value,
int axis,
int num)
Unstack a variable of rank X into N rank X-1 variables by taking slices along the specified axis.
If input has shape [a,b,c] then output has shape: axis = 0: [b,c] axis = 1: [a,c] axis = 2: [a,b] |
SDVariable[] |
unstack(String[] names,
SDVariable value,
int axis,
int num)
Unstack a variable of rank X into N rank X-1 variables by taking slices along the specified axis.
If input has shape [a,b,c] then output has shape: axis = 0: [b,c] axis = 1: [a,c] axis = 2: [a,b] |
SDVariable |
variance(SDVariable x,
boolean biasCorrected,
boolean keepDims,
int... dimensions)
Variance array reduction operation, optionally along 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 |
variance(SDVariable x,
boolean biasCorrected,
int... dimensions)
Variance array reduction operation, optionally along 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 |
variance(String name,
SDVariable x,
boolean biasCorrected,
boolean keepDims,
int... dimensions)
Variance array reduction operation, optionally along 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 |
variance(String name,
SDVariable x,
boolean biasCorrected,
int... dimensions)
Variance array reduction operation, optionally along 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 |
where(SDVariable condition)
Returns elements that are true from the given condition array
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
where(SDVariable x,
SDVariable condition)
Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
where(SDVariable x,
SDVariable y,
SDVariable condition)
Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
where(String name,
SDVariable condition)
Returns elements that are true from the given condition array
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
where(String name,
SDVariable x,
SDVariable condition)
Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
where(String name,
SDVariable x,
SDVariable y,
SDVariable condition)
Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
whereNumpy(SDVariable x,
SDVariable y,
SDVariable condition)
As implemented in numpy, Return elements chosen from x or y depending on condition.
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
whereNumpy(String name,
SDVariable x,
SDVariable y,
SDVariable condition)
As implemented in numpy, Return elements chosen from x or y depending on condition.
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
zerosLike(SDVariable input)
Return a variable of all 0s, with the same shape as the input variable.
|
SDVariable |
zerosLike(String name,
SDVariable input)
Return a variable of all 0s, with the same shape as the input variable.
|
protected SameDiff sd
public SDBaseOps(SameDiff sameDiff)
public SDVariable all(SDVariable x, int... dimensions)
x - Input variable (NDARRAY type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable all(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable any(SDVariable x, int... dimensions)
x - Input variable (NDARRAY type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable any(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable argmax(SDVariable in, boolean keepDims, int... dimensions)
in - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable argmax(String name, SDVariable in, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable argmax(SDVariable in, int... dimensions)
in - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable argmax(String name, SDVariable in, int... dimensions)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable argmin(SDVariable in, boolean keepDims, int... dimensions)
in - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable argmin(String name, SDVariable in, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable argmin(SDVariable in, int... dimensions)
in - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable argmin(String name, SDVariable in, int... dimensions)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable assign(SDVariable x, SDVariable y)
x - The variable to assign to (NDARRAY type)y - The variable to assign (NDARRAY type)public SDVariable assign(String name, SDVariable x, SDVariable y)
name - name May be null. Name for the output variablex - The variable to assign to (NDARRAY type)y - The variable to assign (NDARRAY type)public SDVariable[] batchMmul(SDVariable[] inputsA, SDVariable[] inputsB, boolean transposeA, boolean transposeB)
inputsA - First array of input matrices, all of shape (M, N) or (N, M) (NUMERIC type)inputsB - Second array of input matrices, all of shape (N, K) or (K, N) (NUMERIC type)transposeA - Whether to transpose A arrays or nottransposeB - Whether to transpose B arrays or notpublic SDVariable[] batchMmul(String[] names, SDVariable[] inputsA, SDVariable[] inputsB, boolean transposeA, boolean transposeB)
names - names May be null. Arrays of names for the output variables.inputsA - First array of input matrices, all of shape (M, N) or (N, M) (NUMERIC type)inputsB - Second array of input matrices, all of shape (N, K) or (K, N) (NUMERIC type)transposeA - Whether to transpose A arrays or nottransposeB - Whether to transpose B arrays or notpublic SDVariable[] batchMmul(SDVariable[] inputsA, SDVariable... inputsB)
inputsA - First array of input matrices, all of shape (M, N) or (N, M) (NUMERIC type)inputsB - Second array of input matrices, all of shape (N, K) or (K, N) (NUMERIC type)public SDVariable[] batchMmul(String[] names, SDVariable[] inputsA, SDVariable... inputsB)
names - names May be null. Arrays of names for the output variables.inputsA - First array of input matrices, all of shape (M, N) or (N, M) (NUMERIC type)inputsB - Second array of input matrices, all of shape (N, K) or (K, N) (NUMERIC type)public SDVariable castTo(SDVariable arg, DataType datatype)
arg - Input variable to cast (NDARRAY type)datatype - Datatype to cast topublic SDVariable castTo(String name, SDVariable arg, DataType datatype)
name - name May be null. Name for the output variablearg - Input variable to cast (NDARRAY type)datatype - Datatype to cast topublic SDVariable clipByNorm(SDVariable x, double clipValue)
x - Input variable to clip (NUMERIC type)clipValue - The value max for clippingpublic SDVariable clipByNorm(String name, SDVariable x, double clipValue)
name - name May be null. Name for the output variablex - Input variable to clip (NUMERIC type)clipValue - The value max for clippingpublic SDVariable clipByNorm(SDVariable x, SDVariable clipValue, SDVariable dimensions)
x - Input variable to clip (NUMERIC type)clipValue - The value max value for clipping (NUMERIC type)dimensions - The dimensions to clip (NUMERIC type)public SDVariable clipByNorm(String name, SDVariable x, SDVariable clipValue, SDVariable dimensions)
name - name May be null. Name for the output variablex - Input variable to clip (NUMERIC type)clipValue - The value max value for clipping (NUMERIC type)dimensions - The dimensions to clip (NUMERIC type)public SDVariable clipByValue(SDVariable x, double clipValueMin, double clipValueMax)
x - Input variable to cip (NUMERIC type)clipValueMin - The value min for clippingclipValueMax - The max value to clip topublic SDVariable clipByValue(String name, SDVariable x, double clipValueMin, double clipValueMax)
name - name May be null. Name for the output variablex - Input variable to cip (NUMERIC type)clipValueMin - The value min for clippingclipValueMax - The max value to clip topublic SDVariable clipByValue(SDVariable x, SDVariable clipValueMin, SDVariable clipValueMax)
x - Input variable to cip (NUMERIC type)clipValueMin - The value min for clipping (NUMERIC type)clipValueMax - The max value to clip to (NUMERIC type)public SDVariable clipByValue(String name, SDVariable x, SDVariable clipValueMin, SDVariable clipValueMax)
name - name May be null. Name for the output variablex - Input variable to cip (NUMERIC type)clipValueMin - The value min for clipping (NUMERIC type)clipValueMax - The max value to clip to (NUMERIC type)public SDVariable concat(int dimension, SDVariable... inputs)
inputs - Input variables (NUMERIC type)dimension - Dimension to concatenate onpublic SDVariable concat(String name, int dimension, SDVariable... inputs)
name - name May be null. Name for the output variabledimension - Dimension to concatenate oninputs - Input variables (NUMERIC type)public SDVariable create(SDVariable shape, DataType dataType, String order, boolean initialize)
shape - Input INDArray (NUMERIC type)dataType - Data type of arrayorder - Order of arrayinitialize - Whether to initialize the array or notpublic SDVariable create(String name, SDVariable shape, DataType dataType, String order, boolean initialize)
name - name May be null. Name for the output variableshape - Input INDArray (NUMERIC type)dataType - Data type of arrayorder - Order of arrayinitialize - Whether to initialize the array or notpublic SDVariable create(SDVariable shape, DataType dataType)
shape - Input INDArray (NUMERIC type)dataType - Data type of arraypublic SDVariable create(String name, SDVariable shape, DataType dataType)
name - name May be null. Name for the output variableshape - Input INDArray (NUMERIC type)dataType - Data type of arraypublic SDVariable cumprod(SDVariable in, boolean exclusive, boolean reverse, int... axis)
in - Input variable (NUMERIC type)exclusive - If true: exclude the first valuereverse - If true: reverse the direction of the accumulationaxis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))public SDVariable cumprod(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)exclusive - If true: exclude the first valuereverse - If true: reverse the direction of the accumulationaxis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))public SDVariable cumprod(SDVariable in, int... axis)
in - Input variable (NUMERIC type)axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))public SDVariable cumprod(String name, SDVariable in, int... axis)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))public SDVariable cumsum(SDVariable in, boolean exclusive, boolean reverse, int... axis)
in - Input variable (NUMERIC type)exclusive - If true: exclude the first valuereverse - If true: reverse the direction of the accumulationaxis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))public SDVariable cumsum(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)exclusive - If true: exclude the first valuereverse - If true: reverse the direction of the accumulationaxis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))public SDVariable cumsum(SDVariable in, int... axis)
in - Input variable (NUMERIC type)axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))public SDVariable cumsum(String name, SDVariable in, int... axis)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))public SDVariable dot(SDVariable x, SDVariable y, int... dimensions)
x - first input (NUMERIC type)y - second input (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable dot(String name, SDVariable x, SDVariable y, int... dimensions)
name - name May be null. Name for the output variablex - first input (NUMERIC type)y - second input (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable[] dynamicPartition(SDVariable x, SDVariable partitions, int numPartitions)
input = [1,2,3,4,5]
numPartitions = 2
partitions = [1,0,0,1,0]
out[0] = [2,3,5]
out[1] = [1,4] }
x - Input variable (NUMERIC type)partitions - 1D input with values 0 to numPartitions-1 (INT type)numPartitions - Number of partitions, >= 1public SDVariable[] dynamicPartition(String[] names, SDVariable x, SDVariable partitions, int numPartitions)
input = [1,2,3,4,5]
numPartitions = 2
partitions = [1,0,0,1,0]
out[0] = [2,3,5]
out[1] = [1,4] }
names - names May be null. Arrays of names for the output variables.x - Input variable (NUMERIC type)partitions - 1D input with values 0 to numPartitions-1 (INT type)numPartitions - Number of partitions, >= 1public SDVariable dynamicStitch(SDVariable[] indices, SDVariable... x)
indices - Indices to use when merging. Must be >= 1, same length as input variables (INT type)x - Input variables. (NUMERIC type)public SDVariable dynamicStitch(String name, SDVariable[] indices, SDVariable... x)
name - name May be null. Name for the output variableindices - Indices to use when merging. Must be >= 1, same length as input variables (INT type)x - Input variables. (NUMERIC type)public SDVariable eq(SDVariable x, double y)
x - Input array (NUMERIC type)y - Double value argument to use in operationpublic SDVariable eq(String name, SDVariable x, double y)
name - name May be null. Name for the output variablex - Input array (NUMERIC type)y - Double value argument to use in operationpublic SDVariable eq(SDVariable x, SDVariable y)
x - Input 1 (NDARRAY type)y - Input 2 (NDARRAY type)public SDVariable eq(String name, SDVariable x, SDVariable y)
name - name May be null. Name for the output variablex - Input 1 (NDARRAY type)y - Input 2 (NDARRAY type)public SDVariable expandDims(SDVariable x, int axis)
x - Input variable (NDARRAY type)axis - Axis to expandpublic SDVariable expandDims(String name, SDVariable x, int axis)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)axis - Axis to expandpublic SDVariable fill(SDVariable shape, DataType dataType, double value)
shape - Shape: must be a 1D array/variable (INT type)dataType - Datatype of the output arrayvalue - Value to set all elements topublic SDVariable fill(String name, SDVariable shape, DataType dataType, double value)
name - name May be null. Name for the output variableshape - Shape: must be a 1D array/variable (INT type)dataType - Datatype of the output arrayvalue - Value to set all elements topublic SDVariable gather(SDVariable df, int[] indices, int axis)
df - Input variable (NUMERIC type)indices - Indices to get (Size: AtLeast(min=1))axis - Axis that the indices refer topublic SDVariable gather(String name, SDVariable df, int[] indices, int axis)
name - name May be null. Name for the output variabledf - Input variable (NUMERIC type)indices - Indices to get (Size: AtLeast(min=1))axis - Axis that the indices refer topublic SDVariable gather(SDVariable df, SDVariable indices, int axis)
df - Input variable (NUMERIC type)indices - Indices to get slices for. Rank 0 or 1 input (INT type)axis - Axis that the indices refer topublic SDVariable gather(String name, SDVariable df, SDVariable indices, int axis)
name - name May be null. Name for the output variabledf - Input variable (NUMERIC type)indices - Indices to get slices for. Rank 0 or 1 input (INT type)axis - Axis that the indices refer topublic SDVariable gatherNd(SDVariable df, SDVariable indices)
df - (NUMERIC type)indices - (NUMERIC type)public SDVariable gatherNd(String name, SDVariable df, SDVariable indices)
name - name May be null. Name for the output variabledf - (NUMERIC type)indices - (NUMERIC type)public SDVariable gt(SDVariable x, double y)
x - Input array (NDARRAY type)y - Double value argument to use in operationpublic SDVariable gt(String name, SDVariable x, double y)
name - name May be null. Name for the output variablex - Input array (NDARRAY type)y - Double value argument to use in operationpublic SDVariable gt(SDVariable x, SDVariable y)
x - Input 1 (NDARRAY type)y - Input 2 (NDARRAY type)public SDVariable gt(String name, SDVariable x, SDVariable y)
name - name May be null. Name for the output variablex - Input 1 (NDARRAY type)y - Input 2 (NDARRAY type)public SDVariable gte(SDVariable x, double y)
x - Input array (NDARRAY type)y - Double value argument to use in operationpublic SDVariable gte(String name, SDVariable x, double y)
name - name May be null. Name for the output variablex - Input array (NDARRAY type)y - Double value argument to use in operationpublic SDVariable gte(SDVariable x, SDVariable y)
x - Input 1 (NDARRAY type)y - Input 2 (NDARRAY type)public SDVariable gte(String name, SDVariable x, SDVariable y)
name - name May be null. Name for the output variablex - Input 1 (NDARRAY type)y - Input 2 (NDARRAY type)public SDVariable identity(SDVariable input)
input - Input variable (NDARRAY type)public SDVariable identity(String name, SDVariable input)
name - name May be null. Name for the output variableinput - Input variable (NDARRAY type)public SDVariable invertPermutation(SDVariable input)
input - 1D indices for permutation (INT type)public SDVariable invertPermutation(String name, SDVariable input)
name - name May be null. Name for the output variableinput - 1D indices for permutation (INT type)public SDVariable isNumericTensor(SDVariable x)
x - Input variable (NUMERIC type)public SDVariable isNumericTensor(String name, SDVariable x)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)public SDVariable linspace(DataType dataType, double start, double stop, long number)
dataType - Data type of the output arraystart - Start valuestop - Stop valuenumber - Number of values to generatepublic SDVariable linspace(String name, DataType dataType, double start, double stop, long number)
name - name May be null. Name for the output variabledataType - Data type of the output arraystart - Start valuestop - Stop valuenumber - Number of values to generatepublic SDVariable linspace(SDVariable start, SDVariable stop, SDVariable number, DataType dataType)
start - Start value (NUMERIC type)stop - Stop value (NUMERIC type)number - Number of values to generate (LONG type)dataType - Data type of the output arraypublic SDVariable linspace(String name, SDVariable start, SDVariable stop, SDVariable number, DataType dataType)
name - name May be null. Name for the output variablestart - Start value (NUMERIC type)stop - Stop value (NUMERIC type)number - Number of values to generate (LONG type)dataType - Data type of the output arraypublic SDVariable lt(SDVariable x, double y)
x - Input array (NDARRAY type)y - Double value argument to use in operationpublic SDVariable lt(String name, SDVariable x, double y)
name - name May be null. Name for the output variablex - Input array (NDARRAY type)y - Double value argument to use in operationpublic SDVariable lt(SDVariable x, SDVariable y)
x - Input 1 (NDARRAY type)y - Input 2 (NDARRAY type)public SDVariable lt(String name, SDVariable x, SDVariable y)
name - name May be null. Name for the output variablex - Input 1 (NDARRAY type)y - Input 2 (NDARRAY type)public SDVariable lte(SDVariable x, double y)
x - Input array (NDARRAY type)y - Double value argument to use in operationpublic SDVariable lte(String name, SDVariable x, double y)
name - name May be null. Name for the output variablex - Input array (NDARRAY type)y - Double value argument to use in operationpublic SDVariable lte(SDVariable x, SDVariable y)
x - Input 1 (NUMERIC type)y - Input 2 (NUMERIC type)public SDVariable lte(String name, SDVariable x, SDVariable y)
name - name May be null. Name for the output variablex - Input 1 (NUMERIC type)y - Input 2 (NUMERIC type)public SDVariable matchCondition(SDVariable in, Condition condition)
in - Input (NUMERIC type)condition - Conditionpublic SDVariable matchCondition(String name, SDVariable in, Condition condition)
name - name May be null. Name for the output variablein - Input (NUMERIC type)condition - Conditionpublic SDVariable matchConditionCount(SDVariable in, Condition condition)
in - Input (NUMERIC type)condition - Conditionpublic SDVariable matchConditionCount(String name, SDVariable in, Condition condition)
name - name May be null. Name for the output variablein - Input (NUMERIC type)condition - Conditionpublic SDVariable matchConditionCount(SDVariable in, Condition condition, boolean keepDim, int... dimensions)
in - Input variable (NUMERIC type)condition - ConditionkeepDim - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable matchConditionCount(String name, SDVariable in, Condition condition, boolean keepDim, int... dimensions)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)condition - ConditionkeepDim - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable matchConditionCount(SDVariable in, Condition condition, int... dimensions)
in - Input variable (NUMERIC type)condition - Conditiondimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable matchConditionCount(String name, SDVariable in, Condition condition, int... dimensions)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)condition - Conditiondimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable max(SDVariable x, boolean keepDims, int... dimensions)
x - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable max(String name, SDVariable x, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable max(SDVariable x, int... dimensions)
x - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable max(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable max(SDVariable first, SDVariable second)
first - First input array (NUMERIC type)second - Second input array (NUMERIC type)public SDVariable max(String name, SDVariable first, SDVariable second)
name - name May be null. Name for the output variablefirst - First input array (NUMERIC type)second - Second input array (NUMERIC type)public SDVariable mean(SDVariable x, boolean keepDims, int... dimensions)
x - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable mean(String name, SDVariable x, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable mean(SDVariable x, int... dimensions)
x - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable mean(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable mean(SDVariable x, SDVariable dimensions, boolean keepDims)
x - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (INT type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionspublic SDVariable mean(String name, SDVariable x, SDVariable dimensions, boolean keepDims)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (INT type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionspublic SDVariable mean(SDVariable x, SDVariable dimensions)
x - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (INT type)public SDVariable mean(String name, SDVariable x, SDVariable dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (INT type)public SDVariable merge(SDVariable x, SDVariable y)
x - Input variable (NDARRAY type)y - Input variable (NDARRAY type)public SDVariable merge(String name, SDVariable x, SDVariable y)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)y - Input variable (NDARRAY type)public SDVariable min(SDVariable x, boolean keepDims, int... dimensions)
x - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable min(String name, SDVariable x, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable min(SDVariable x, int... dimensions)
x - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable min(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable min(SDVariable first, SDVariable second)
first - First input array (NUMERIC type)second - Second input array (NUMERIC type)public SDVariable min(String name, SDVariable first, SDVariable second)
name - name May be null. Name for the output variablefirst - First input array (NUMERIC type)second - Second input array (NUMERIC type)public SDVariable minMax(int datatype, int minOrMax)
datatype - The input target data type represented as an intminOrMax - The min or max (0 or 1) value to returnpublic SDVariable minMax(String name, int datatype, int minOrMax)
name - name May be null. Name for the output variabledatatype - The input target data type represented as an intminOrMax - The min or max (0 or 1) value to returnpublic SDVariable mmul(SDVariable x, SDVariable y, boolean transposeX, boolean transposeY, boolean transposeZ)
x - First input variable (NUMERIC type)y - Second input variable (NUMERIC type)transposeX - Transpose x (first argument)transposeY - Transpose y (second argument)transposeZ - Transpose result arraypublic SDVariable mmul(String name, SDVariable x, SDVariable y, boolean transposeX, boolean transposeY, boolean transposeZ)
name - name May be null. Name for the output variablex - First input variable (NUMERIC type)y - Second input variable (NUMERIC type)transposeX - Transpose x (first argument)transposeY - Transpose y (second argument)transposeZ - Transpose result arraypublic SDVariable mmul(SDVariable x, SDVariable y)
x - First input variable (NUMERIC type)y - Second input variable (NUMERIC type)public SDVariable mmul(String name, SDVariable x, SDVariable y)
name - name May be null. Name for the output variablex - First input variable (NUMERIC type)y - Second input variable (NUMERIC type)public SDVariable neq(SDVariable x, double y)
x - Input array (NDARRAY type)y - Double value argument to use in operationpublic SDVariable neq(String name, SDVariable x, double y)
name - name May be null. Name for the output variablex - Input array (NDARRAY type)y - Double value argument to use in operationpublic SDVariable neq(SDVariable x, SDVariable y)
x - Input 1 (NDARRAY type)y - Input 2 (NDARRAY type)public SDVariable neq(String name, SDVariable x, SDVariable y)
name - name May be null. Name for the output variablex - Input 1 (NDARRAY type)y - Input 2 (NDARRAY type)public SDVariable norm1(SDVariable x, boolean keepDims, int... dimensions)
x - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - dimensions to reduce over (Size: AtLeast(min=0))public SDVariable norm1(String name, SDVariable x, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - dimensions to reduce over (Size: AtLeast(min=0))public SDVariable norm1(SDVariable x, int... dimensions)
x - Input variable (NUMERIC type)dimensions - dimensions to reduce over (Size: AtLeast(min=0))public SDVariable norm1(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - dimensions to reduce over (Size: AtLeast(min=0))public SDVariable norm2(SDVariable x, boolean keepDims, int... dimensions)
x - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - dimensions dimensions to reduce over (Size: AtLeast(min=0))public SDVariable norm2(String name, SDVariable x, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - dimensions dimensions to reduce over (Size: AtLeast(min=0))public SDVariable norm2(SDVariable x, int... dimensions)
x - Input variable (NUMERIC type)dimensions - dimensions dimensions to reduce over (Size: AtLeast(min=0))public SDVariable norm2(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - dimensions dimensions to reduce over (Size: AtLeast(min=0))public SDVariable normmax(SDVariable x, boolean keepDims, int... dimensions)
x - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - dimensions to reduce over (Size: AtLeast(min=0))public SDVariable normmax(String name, SDVariable x, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - dimensions to reduce over (Size: AtLeast(min=0))public SDVariable normmax(SDVariable x, int... dimensions)
x - Input variable (NUMERIC type)dimensions - dimensions to reduce over (Size: AtLeast(min=0))public SDVariable normmax(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - dimensions to reduce over (Size: AtLeast(min=0))public SDVariable oneHot(SDVariable indices, int depth, int axis, double on, double off, DataType dataType)
indices - Indices - value 0 to depth-1 (NUMERIC type)depth - Number of classesaxis - on - off - dataType - Output data typepublic SDVariable oneHot(String name, SDVariable indices, int depth, int axis, double on, double off, DataType dataType)
name - name May be null. Name for the output variableindices - Indices - value 0 to depth-1 (NUMERIC type)depth - Number of classesaxis - on - off - dataType - Output data typepublic SDVariable oneHot(SDVariable indices, int depth, int axis, double on, double off)
indices - Indices - value 0 to depth-1 (NUMERIC type)depth - Number of classesaxis - on - off - public SDVariable oneHot(String name, SDVariable indices, int depth, int axis, double on, double off)
name - name May be null. Name for the output variableindices - Indices - value 0 to depth-1 (NUMERIC type)depth - Number of classesaxis - on - off - public SDVariable oneHot(SDVariable indices, int depth)
indices - Indices - value 0 to depth-1 (NUMERIC type)depth - Number of classespublic SDVariable oneHot(String name, SDVariable indices, int depth)
name - name May be null. Name for the output variableindices - Indices - value 0 to depth-1 (NUMERIC type)depth - Number of classespublic SDVariable onesLike(SDVariable input)
input - Input INDArray (NDARRAY type)public SDVariable onesLike(String name, SDVariable input)
name - name May be null. Name for the output variableinput - Input INDArray (NDARRAY type)public SDVariable onesLike(SDVariable input, DataType dataType)
input - (NDARRAY type)dataType - public SDVariable onesLike(String name, SDVariable input, DataType dataType)
name - name May be null. Name for the output variableinput - (NDARRAY type)dataType - public SDVariable permute(SDVariable x, SDVariable dimensions)
x - Input variable (NDARRAY type)dimensions - Permute dimensions (INT type)public SDVariable permute(String name, SDVariable x, SDVariable dimensions)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)dimensions - Permute dimensions (INT type)public SDVariable permute(SDVariable x, int... dimensions)
x - Input variable (NDARRAY type)dimensions - (Size: AtLeast(min=0))public SDVariable permute(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)dimensions - (Size: AtLeast(min=0))public SDVariable prod(SDVariable x, boolean keepDims, int... dimensions)
x - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable prod(String name, SDVariable x, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable prod(SDVariable x, int... dimensions)
x - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable prod(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable prod(SDVariable x, SDVariable dimensions, boolean keepDims)
x - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (INT type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionspublic SDVariable prod(String name, SDVariable x, SDVariable dimensions, boolean keepDims)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (INT type)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionspublic SDVariable prod(SDVariable x, SDVariable dimensions)
x - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (INT type)public SDVariable prod(String name, SDVariable x, SDVariable dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (INT type)public SDVariable range(double from, double to, double step, DataType dataType)
from - Initial/smallest valueto - Largest value (exclusive)step - Step sizedataType - public SDVariable range(String name, double from, double to, double step, DataType dataType)
name - name May be null. Name for the output variablefrom - Initial/smallest valueto - Largest value (exclusive)step - Step sizedataType - public SDVariable range(SDVariable from, SDVariable to, SDVariable step, DataType dataType)
from - Initial/smallest value (NUMERIC type)to - Largest value (exclusive) (NUMERIC type)step - Step size (NUMERIC type)dataType - public SDVariable range(String name, SDVariable from, SDVariable to, SDVariable step, DataType dataType)
name - name May be null. Name for the output variablefrom - Initial/smallest value (NUMERIC type)to - Largest value (exclusive) (NUMERIC type)step - Step size (NUMERIC type)dataType - public SDVariable rank(SDVariable in)
in - Input variable (NDARRAY type)public SDVariable rank(String name, SDVariable in)
name - name May be null. Name for the output variablein - Input variable (NDARRAY type)public SDVariable repeat(SDVariable input, SDVariable repeats, int axis)
input - Input value to repeat (NUMERIC type)repeats - A 1d input representing the number of inputs of repeats for each element. (NUMERIC type)axis - Data type of the output arraypublic SDVariable repeat(String name, SDVariable input, SDVariable repeats, int axis)
name - name May be null. Name for the output variableinput - Input value to repeat (NUMERIC type)repeats - A 1d input representing the number of inputs of repeats for each element. (NUMERIC type)axis - Data type of the output arraypublic SDVariable replaceWhere(SDVariable update, SDVariable from, Condition condition)
update - Source array (NUMERIC type)from - Replacement values array (used conditionally). Must be same shape as 'update' array (NUMERIC type)condition - Condition to check on update array elementspublic SDVariable replaceWhere(String name, SDVariable update, SDVariable from, Condition condition)
name - name May be null. Name for the output variableupdate - Source array (NUMERIC type)from - Replacement values array (used conditionally). Must be same shape as 'update' array (NUMERIC type)condition - Condition to check on update array elementspublic SDVariable replaceWhere(SDVariable update, double value, Condition condition)
update - Source array (NUMERIC type)value - Value to set at the output, if the condition is satisfiedcondition - Condition to check on update array elementspublic SDVariable replaceWhere(String name, SDVariable update, double value, Condition condition)
name - name May be null. Name for the output variableupdate - Source array (NUMERIC type)value - Value to set at the output, if the condition is satisfiedcondition - Condition to check on update array elementspublic SDVariable reshape(SDVariable x, SDVariable shape)
x - Input variable (NDARRAY type)shape - New shape for variable (NUMERIC type)public SDVariable reshape(String name, SDVariable x, SDVariable shape)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)shape - New shape for variable (NUMERIC type)public SDVariable reshape(SDVariable x, long... shape)
x - Input variable (NDARRAY type)shape - New shape for variable (Size: AtLeast(min=0))public SDVariable reshape(String name, SDVariable x, long... shape)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)shape - New shape for variable (Size: AtLeast(min=0))public SDVariable reverse(SDVariable x, int... dimensions)
x - Input variable (NDARRAY type)dimensions - Input variable (Size: AtLeast(min=0))public SDVariable reverse(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)dimensions - Input variable (Size: AtLeast(min=0))public SDVariable reverseSequence(SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)
x - Input variable (NDARRAY type)seq_lengths - Length of the sequences (INT type)seqDim - Sequence dimensionbatchDim - Batch dimensionpublic SDVariable reverseSequence(String name, SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)seq_lengths - Length of the sequences (INT type)seqDim - Sequence dimensionbatchDim - Batch dimensionpublic SDVariable reverseSequence(SDVariable x, SDVariable seq_lengths)
x - Input variable (NDARRAY type)seq_lengths - Length of the sequences (INT type)public SDVariable reverseSequence(String name, SDVariable x, SDVariable seq_lengths)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)seq_lengths - Length of the sequences (INT type)public SDVariable scalarFloorMod(SDVariable in, double value)
in - Input variable (NUMERIC type)value - Scalar value to comparepublic SDVariable scalarFloorMod(String name, SDVariable in, double value)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)value - Scalar value to comparepublic SDVariable scalarMax(SDVariable in, double value)
in - Input variable (NUMERIC type)value - Scalar value to comparepublic SDVariable scalarMax(String name, SDVariable in, double value)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)value - Scalar value to comparepublic SDVariable scalarMin(SDVariable in, double value)
in - Input variable (NUMERIC type)value - Scalar value to comparepublic SDVariable scalarMin(String name, SDVariable in, double value)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)value - Scalar value to comparepublic SDVariable scalarSet(SDVariable in, double set)
in - Input variable (NUMERIC type)set - Value to setpublic SDVariable scalarSet(String name, SDVariable in, double set)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)set - Value to setpublic SDVariable scatterAdd(SDVariable ref, SDVariable indices, SDVariable updates)
ref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterAdd(String name, SDVariable ref, SDVariable indices, SDVariable updates)
name - name May be null. Name for the output variableref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterDiv(SDVariable ref, SDVariable indices, SDVariable updates)
ref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterDiv(String name, SDVariable ref, SDVariable indices, SDVariable updates)
name - name May be null. Name for the output variableref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterMax(SDVariable ref, SDVariable indices, SDVariable updates)
ref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterMax(String name, SDVariable ref, SDVariable indices, SDVariable updates)
name - name May be null. Name for the output variableref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterMin(SDVariable ref, SDVariable indices, SDVariable updates)
ref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterMin(String name, SDVariable ref, SDVariable indices, SDVariable updates)
name - name May be null. Name for the output variableref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterMul(SDVariable ref, SDVariable indices, SDVariable updates)
ref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterMul(String name, SDVariable ref, SDVariable indices, SDVariable updates)
name - name May be null. Name for the output variableref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterSub(SDVariable ref, SDVariable indices, SDVariable updates)
ref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterSub(String name, SDVariable ref, SDVariable indices, SDVariable updates)
name - name May be null. Name for the output variableref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterUpdate(SDVariable ref, SDVariable indices, SDVariable updates)
ref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable scatterUpdate(String name, SDVariable ref, SDVariable indices, SDVariable updates)
name - name May be null. Name for the output variableref - Initial/source variable (NUMERIC type)indices - Indices array (NUMERIC type)updates - Updates to add to the initial/source array (NUMERIC type)public SDVariable segmentMax(SDVariable data, SDVariable segmentIds)
data - Data to perform segment max on (NDARRAY type)segmentIds - Variable for the segment IDs (NUMERIC type)public SDVariable segmentMax(String name, SDVariable data, SDVariable segmentIds)
name - name May be null. Name for the output variabledata - Data to perform segment max on (NDARRAY type)segmentIds - Variable for the segment IDs (NUMERIC type)public SDVariable segmentMean(SDVariable data, SDVariable segmentIds)
data - Data to perform segment max on (NDARRAY type)segmentIds - Variable for the segment IDs (NUMERIC type)public SDVariable segmentMean(String name, SDVariable data, SDVariable segmentIds)
name - name May be null. Name for the output variabledata - Data to perform segment max on (NDARRAY type)segmentIds - Variable for the segment IDs (NUMERIC type)public SDVariable segmentMin(SDVariable data, SDVariable segmentIds)
data - Data to perform segment max on (NDARRAY type)segmentIds - Variable for the segment IDs (NUMERIC type)public SDVariable segmentMin(String name, SDVariable data, SDVariable segmentIds)
name - name May be null. Name for the output variabledata - Data to perform segment max on (NDARRAY type)segmentIds - Variable for the segment IDs (NUMERIC type)public SDVariable segmentProd(SDVariable data, SDVariable segmentIds)
data - Data to perform segment max on (NDARRAY type)segmentIds - Variable for the segment IDs (NUMERIC type)public SDVariable segmentProd(String name, SDVariable data, SDVariable segmentIds)
name - name May be null. Name for the output variabledata - Data to perform segment max on (NDARRAY type)segmentIds - Variable for the segment IDs (NUMERIC type)public SDVariable segmentSum(SDVariable data, SDVariable segmentIds)
data - Data to perform segment max on (NDARRAY type)segmentIds - Variable for the segment IDs (NUMERIC type)public SDVariable segmentSum(String name, SDVariable data, SDVariable segmentIds)
name - name May be null. Name for the output variabledata - Data to perform segment max on (NDARRAY type)segmentIds - Variable for the segment IDs (NUMERIC type)public SDVariable sequenceMask(SDVariable lengths, int maxLen, DataType dataType)
lengths - Lengths of the sequences (NUMERIC type)maxLen - Maximum sequence lengthdataType - public SDVariable sequenceMask(String name, SDVariable lengths, int maxLen, DataType dataType)
name - name May be null. Name for the output variablelengths - Lengths of the sequences (NUMERIC type)maxLen - Maximum sequence lengthdataType - public SDVariable sequenceMask(SDVariable lengths, SDVariable maxLen, DataType dataType)
lengths - Lengths of the sequences (NUMERIC type)maxLen - Maximum sequence length (INT type)dataType - public SDVariable sequenceMask(String name, SDVariable lengths, SDVariable maxLen, DataType dataType)
name - name May be null. Name for the output variablelengths - Lengths of the sequences (NUMERIC type)maxLen - Maximum sequence length (INT type)dataType - public SDVariable sequenceMask(SDVariable lengths, DataType dataType)
lengths - (NUMERIC type)dataType - public SDVariable sequenceMask(String name, SDVariable lengths, DataType dataType)
name - name May be null. Name for the output variablelengths - (NUMERIC type)dataType - public SDVariable[] setShape(SDVariable input, SDVariable shape)
input - The input to set the shape of (NUMERIC type)shape - The shape to set the input to (NUMERIC type)public SDVariable[] setShape(String[] names, SDVariable input, SDVariable shape)
names - names May be null. Arrays of names for the output variables.input - The input to set the shape of (NUMERIC type)shape - The shape to set the input to (NUMERIC type)public SDVariable shape(SDVariable input)
input - Input variable (NUMERIC type)public SDVariable shape(String name, SDVariable input)
name - name May be null. Name for the output variableinput - Input variable (NUMERIC type)public SDVariable size(SDVariable in)
in - Input variable (NUMERIC type)public SDVariable size(String name, SDVariable in)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)public SDVariable sizeAt(SDVariable in, int dimension)
in - Input variable (NUMERIC type)dimension - Dimension to get size ofpublic SDVariable sizeAt(String name, SDVariable in, int dimension)
name - name May be null. Name for the output variablein - Input variable (NUMERIC type)dimension - Dimension to get size ofpublic SDVariable slice(SDVariable input, int[] begin, int... size)
input - input Variable to get subset of (NDARRAY type)begin - Beginning index. Must be same length as rank of input array (Size: AtLeast(min=1))size - Size of the output array. Must be same length as rank of input array (Size: AtLeast(min=1))public SDVariable slice(String name, SDVariable input, int[] begin, int... size)
name - name May be null. Name for the output variableinput - input Variable to get subset of (NDARRAY type)begin - Beginning index. Must be same length as rank of input array (Size: AtLeast(min=1))size - Size of the output array. Must be same length as rank of input array (Size: AtLeast(min=1))public SDVariable slice(SDVariable input, SDVariable begin, SDVariable size)
input - input Variable to get subset of (NDARRAY type)begin - Beginning index. Must be same length as rank of input array (INT type)size - Size of the output array. Must be same length as rank of input array (INT type)public SDVariable slice(String name, SDVariable input, SDVariable begin, SDVariable size)
name - name May be null. Name for the output variableinput - input Variable to get subset of (NDARRAY type)begin - Beginning index. Must be same length as rank of input array (INT type)size - Size of the output array. Must be same length as rank of input array (INT type)public SDVariable sparseToDense(SDVariable indices, SDVariable shape, SDVariable values)
indices - The indices of the sparse matrix (NUMERIC type)shape - The output shape (NUMERIC type)values - The values for the array (NUMERIC type)public SDVariable sparseToDense(String name, SDVariable indices, SDVariable shape, SDVariable values)
name - name May be null. Name for the output variableindices - The indices of the sparse matrix (NUMERIC type)shape - The output shape (NUMERIC type)values - The values for the array (NUMERIC type)public SDVariable sparseToDense(SDVariable indices, SDVariable shape, SDVariable values, SDVariable defaultValue)
indices - The indices of the sparse matrix (NUMERIC type)shape - The output shape (NUMERIC type)values - The values for the array (NUMERIC type)defaultValue - Default value (NUMERIC type)public SDVariable sparseToDense(String name, SDVariable indices, SDVariable shape, SDVariable values, SDVariable defaultValue)
name - name May be null. Name for the output variableindices - The indices of the sparse matrix (NUMERIC type)shape - The output shape (NUMERIC type)values - The values for the array (NUMERIC type)defaultValue - Default value (NUMERIC type)public SDVariable[] split(SDVariable input, int numSplit, int splitDim)
input - Input to split (NDARRAY type)numSplit - Number of splitssplitDim - The dimension to split onpublic SDVariable[] split(String[] names, SDVariable input, int numSplit, int splitDim)
names - names May be null. Arrays of names for the output variables.input - Input to split (NDARRAY type)numSplit - Number of splitssplitDim - The dimension to split onpublic SDVariable[] split(SDVariable input, SDVariable numSplit, int splitDim)
input - Input to split (NUMERIC type)numSplit - Number of splits (NUMERIC type)splitDim - The dimension to split onpublic SDVariable[] split(String[] names, SDVariable input, SDVariable numSplit, int splitDim)
names - names May be null. Arrays of names for the output variables.input - Input to split (NUMERIC type)numSplit - Number of splits (NUMERIC type)splitDim - The dimension to split onpublic SDVariable[] splitV(SDVariable input, SDVariable sizes, int numSplit, int splitDim)
input - Input to split (NDARRAY type)sizes - The sizes to split by (NDARRAY type)numSplit - Number of splitssplitDim - The dimension to split onpublic SDVariable[] splitV(String[] names, SDVariable input, SDVariable sizes, int numSplit, int splitDim)
names - names May be null. Arrays of names for the output variables.input - Input to split (NDARRAY type)sizes - The sizes to split by (NDARRAY type)numSplit - Number of splitssplitDim - The dimension to split onpublic SDVariable squaredNorm(SDVariable x, boolean keepDims, int... dimensions)
x - (NUMERIC type)keepDims - dimensions - (Size: AtLeast(min=0))public SDVariable squaredNorm(String name, SDVariable x, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablex - (NUMERIC type)keepDims - dimensions - (Size: AtLeast(min=0))public SDVariable squaredNorm(SDVariable x, int... dimensions)
x - (NUMERIC type)dimensions - (Size: AtLeast(min=0))public SDVariable squaredNorm(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - (NUMERIC type)dimensions - (Size: AtLeast(min=0))public SDVariable squeeze(SDVariable x, int axis)
x - Input variable (NUMERIC type)axis - Size 1 dimension to removepublic SDVariable squeeze(String name, SDVariable x, int axis)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)axis - Size 1 dimension to removepublic SDVariable stack(int axis, SDVariable... values)
values - Input variables to stack. Must have the same shape for all inputs (NDARRAY type)axis - Axis to stack onpublic SDVariable stack(String name, int axis, SDVariable... values)
name - name May be null. Name for the output variableaxis - Axis to stack onvalues - Input variables to stack. Must have the same shape for all inputs (NDARRAY type)public SDVariable standardDeviation(SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)
x - Input variable (NUMERIC type)biasCorrected - If true: divide by (N-1) (i.e., sample stdev). If false: divide by N (population stdev)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable standardDeviation(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)biasCorrected - If true: divide by (N-1) (i.e., sample stdev). If false: divide by N (population stdev)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable standardDeviation(SDVariable x, boolean biasCorrected, int... dimensions)
x - Input variable (NUMERIC type)biasCorrected - If true: divide by (N-1) (i.e., sample stdev). If false: divide by N (population stdev)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable standardDeviation(String name, SDVariable x, boolean biasCorrected, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)biasCorrected - If true: divide by (N-1) (i.e., sample stdev). If false: divide by N (population stdev)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable stridedSlice(SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
in - Variable to get subset of (NDARRAY type)begin - Beginning index (Size: AtLeast(min=1))end - End index (Size: AtLeast(min=1))strides - Stride ("step size") for each dimension. For example, stride of 2 means take every second element. (Size: AtLeast(min=1))beginMask - Bit mask: If the ith bit is set to 1, then the value in the begin long[] is ignored, and a value of 0 is used instead for the beginning index for that dimensionendMask - Bit mask: If the ith bit is set to 1, then the value in the end long[] is ignored, and a value of size(i)-1 is used instead for the end index for that dimensionellipsisMask - Bit mask: only one non-zero value is allowed here. If a non-zero value is set, then other dimensions are inserted as required at the specified positionnewAxisMask - Bit mask: if the ith bit is set to 1, then the begin/end/stride values are ignored, and a size 1 dimension is inserted at this pointshrinkAxisMask - Bit mask: if the ith bit is set to 1, then the begin/end/stride values are ignored, and a size 1 dimension is removed at this point. Note that begin/end/stride values must result in a size 1 output for these dimensionspublic SDVariable stridedSlice(String name, SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
name - name May be null. Name for the output variablein - Variable to get subset of (NDARRAY type)begin - Beginning index (Size: AtLeast(min=1))end - End index (Size: AtLeast(min=1))strides - Stride ("step size") for each dimension. For example, stride of 2 means take every second element. (Size: AtLeast(min=1))beginMask - Bit mask: If the ith bit is set to 1, then the value in the begin long[] is ignored, and a value of 0 is used instead for the beginning index for that dimensionendMask - Bit mask: If the ith bit is set to 1, then the value in the end long[] is ignored, and a value of size(i)-1 is used instead for the end index for that dimensionellipsisMask - Bit mask: only one non-zero value is allowed here. If a non-zero value is set, then other dimensions are inserted as required at the specified positionnewAxisMask - Bit mask: if the ith bit is set to 1, then the begin/end/stride values are ignored, and a size 1 dimension is inserted at this pointshrinkAxisMask - Bit mask: if the ith bit is set to 1, then the begin/end/stride values are ignored, and a size 1 dimension is removed at this point. Note that begin/end/stride values must result in a size 1 output for these dimensionspublic SDVariable stridedSlice(SDVariable in, long[] begin, long[] end, long... strides)
in - Variable to get subset of (NDARRAY type)begin - Beginning index (Size: AtLeast(min=1))end - End index (Size: AtLeast(min=1))strides - Stride ("step size") for each dimension. For example, stride of 2 means take every second element. (Size: AtLeast(min=1))public SDVariable stridedSlice(String name, SDVariable in, long[] begin, long[] end, long... strides)
name - name May be null. Name for the output variablein - Variable to get subset of (NDARRAY type)begin - Beginning index (Size: AtLeast(min=1))end - End index (Size: AtLeast(min=1))strides - Stride ("step size") for each dimension. For example, stride of 2 means take every second element. (Size: AtLeast(min=1))public SDVariable stridedSlice(SDVariable in, SDVariable begin, SDVariable end, SDVariable strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
in - Variable to get subset of (NDARRAY type)begin - The beginning indices for the slice (NUMERIC type)end - The ending indicesof the slice (NUMERIC type)strides - The strides for each dimension (NUMERIC type)beginMask - Bit mask: If the ith bit is set to 1, then the value in the begin long[] is ignored, and a value of 0 is used instead for the beginning index for that dimensionendMask - Bit mask: If the ith bit is set to 1, then the value in the end long[] is ignored, and a value of size(i)-1 is used instead for the end index for that dimensionellipsisMask - Bit mask: only one non-zero value is allowed here. If a non-zero value is set, then other dimensions are inserted as required at the specified positionnewAxisMask - Bit mask: if the ith bit is set to 1, then the begin/end/stride values are ignored, and a size 1 dimension is inserted at this pointshrinkAxisMask - Bit mask: if the ith bit is set to 1, then the begin/end/stride values are ignored, and a size 1 dimension is removed at this point. Note that begin/end/stride values must result in a size 1 output for these dimensionspublic SDVariable stridedSlice(String name, SDVariable in, SDVariable begin, SDVariable end, SDVariable strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)
name - name May be null. Name for the output variablein - Variable to get subset of (NDARRAY type)begin - The beginning indices for the slice (NUMERIC type)end - The ending indicesof the slice (NUMERIC type)strides - The strides for each dimension (NUMERIC type)beginMask - Bit mask: If the ith bit is set to 1, then the value in the begin long[] is ignored, and a value of 0 is used instead for the beginning index for that dimensionendMask - Bit mask: If the ith bit is set to 1, then the value in the end long[] is ignored, and a value of size(i)-1 is used instead for the end index for that dimensionellipsisMask - Bit mask: only one non-zero value is allowed here. If a non-zero value is set, then other dimensions are inserted as required at the specified positionnewAxisMask - Bit mask: if the ith bit is set to 1, then the begin/end/stride values are ignored, and a size 1 dimension is inserted at this pointshrinkAxisMask - Bit mask: if the ith bit is set to 1, then the begin/end/stride values are ignored, and a size 1 dimension is removed at this point. Note that begin/end/stride values must result in a size 1 output for these dimensionspublic SDVariable stridedSlice(SDVariable in, SDVariable begin, SDVariable end, SDVariable strides)
in - Variable to get subset of (NDARRAY type)begin - The beginning indices for the slice (NUMERIC type)end - The ending indicesof the slice (NUMERIC type)strides - The strides for each dimension (NUMERIC type)public SDVariable stridedSlice(String name, SDVariable in, SDVariable begin, SDVariable end, SDVariable strides)
name - name May be null. Name for the output variablein - Variable to get subset of (NDARRAY type)begin - The beginning indices for the slice (NUMERIC type)end - The ending indicesof the slice (NUMERIC type)strides - The strides for each dimension (NUMERIC type)public SDVariable sum(SDVariable x, boolean keepDims, int... dimensions)
x - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable sum(String name, SDVariable x, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)keepDims - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable sum(SDVariable x, int... dimensions)
x - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable sum(String name, SDVariable x, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable[] switchOp(SDVariable x, SDVariable predicate)
x - Input variable (NDARRAY type)predicate - Predictate - if false, values are output to left (first) branch/output; if true, to right (second) branch/output (BOOL type)public SDVariable[] switchOp(String[] names, SDVariable x, SDVariable predicate)
names - names May be null. Arrays of names for the output variables.x - Input variable (NDARRAY type)predicate - Predictate - if false, values are output to left (first) branch/output; if true, to right (second) branch/output (BOOL type)public SDVariable tensorMmul(SDVariable x, SDVariable y, int[] dimensionsX, int[] dimensionsY, boolean transposeX, boolean transposeY, boolean transposeZ)
x - Input variable x (NUMERIC type)y - Input variable y (NUMERIC type)dimensionsX - dimensions for first input array (x) (Size: AtLeast(min=1))dimensionsY - dimensions for second input array (y) (Size: AtLeast(min=1))transposeX - Transpose x (first argument)transposeY - Transpose y (second argument)transposeZ - Transpose result arraypublic SDVariable tensorMmul(String name, SDVariable x, SDVariable y, int[] dimensionsX, int[] dimensionsY, boolean transposeX, boolean transposeY, boolean transposeZ)
name - name May be null. Name for the output variablex - Input variable x (NUMERIC type)y - Input variable y (NUMERIC type)dimensionsX - dimensions for first input array (x) (Size: AtLeast(min=1))dimensionsY - dimensions for second input array (y) (Size: AtLeast(min=1))transposeX - Transpose x (first argument)transposeY - Transpose y (second argument)transposeZ - Transpose result arraypublic SDVariable tensorMmul(SDVariable x, SDVariable y, int[] dimensionsX, int... dimensionsY)
x - Input variable x (NUMERIC type)y - Input variable y (NUMERIC type)dimensionsX - dimensions for first input array (x) (Size: AtLeast(min=1))dimensionsY - dimensions for second input array (y) (Size: AtLeast(min=1))public SDVariable tensorMmul(String name, SDVariable x, SDVariable y, int[] dimensionsX, int... dimensionsY)
name - name May be null. Name for the output variablex - Input variable x (NUMERIC type)y - Input variable y (NUMERIC type)dimensionsX - dimensions for first input array (x) (Size: AtLeast(min=1))dimensionsY - dimensions for second input array (y) (Size: AtLeast(min=1))public SDVariable tile(SDVariable x, SDVariable repeat)
x - Input variable (NDARRAY type)repeat - Number of times to repeat in each axis. Must have length equal to the rank of the input array (INT type)public SDVariable tile(String name, SDVariable x, SDVariable repeat)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)repeat - Number of times to repeat in each axis. Must have length equal to the rank of the input array (INT type)public SDVariable tile(SDVariable x, int... repeat)
x - (NDARRAY type)repeat - (Size: AtLeast(min=1))public SDVariable tile(String name, SDVariable x, int... repeat)
name - name May be null. Name for the output variablex - (NDARRAY type)repeat - (Size: AtLeast(min=1))public SDVariable transpose(SDVariable x)
x - Input variable (NDARRAY type)public SDVariable transpose(String name, SDVariable x)
name - name May be null. Name for the output variablex - Input variable (NDARRAY type)public SDVariable unsortedSegmentMax(SDVariable data, SDVariable segmentIds, int numSegments)
data - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable unsortedSegmentMax(String name, SDVariable data, SDVariable segmentIds, int numSegments)
name - name May be null. Name for the output variabledata - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable unsortedSegmentMean(SDVariable data, SDVariable segmentIds, int numSegments)
data - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable unsortedSegmentMean(String name, SDVariable data, SDVariable segmentIds, int numSegments)
name - name May be null. Name for the output variabledata - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable unsortedSegmentMin(SDVariable data, SDVariable segmentIds, int numSegments)
data - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable unsortedSegmentMin(String name, SDVariable data, SDVariable segmentIds, int numSegments)
name - name May be null. Name for the output variabledata - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable unsortedSegmentProd(SDVariable data, SDVariable segmentIds, int numSegments)
data - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable unsortedSegmentProd(String name, SDVariable data, SDVariable segmentIds, int numSegments)
name - name May be null. Name for the output variabledata - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable unsortedSegmentSqrtN(SDVariable data, SDVariable segmentIds, int numSegments)
data - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable unsortedSegmentSqrtN(String name, SDVariable data, SDVariable segmentIds, int numSegments)
name - name May be null. Name for the output variabledata - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable unsortedSegmentSum(SDVariable data, SDVariable segmentIds, int numSegments)
data - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable unsortedSegmentSum(String name, SDVariable data, SDVariable segmentIds, int numSegments)
name - name May be null. Name for the output variabledata - Data (variable) to perform unsorted segment max on (NUMERIC type)segmentIds - Variable for the segment IDs (NUMERIC type)numSegments - Number of segmentspublic SDVariable[] unstack(SDVariable value, int axis, int num)
value - Input variable to unstack (NDARRAY type)axis - Axis to unstack onnum - Number of output variablespublic SDVariable[] unstack(String[] names, SDVariable value, int axis, int num)
names - names May be null. Arrays of names for the output variables.value - Input variable to unstack (NDARRAY type)axis - Axis to unstack onnum - Number of output variablespublic SDVariable variance(SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)
x - Input variable (NUMERIC type)biasCorrected - If true: divide by (N-1) (i.e., sample variable). If false: divide by N (population variance)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable variance(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)biasCorrected - If true: divide by (N-1) (i.e., sample variable). If false: divide by N (population variance)keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensionsdimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable variance(SDVariable x, boolean biasCorrected, int... dimensions)
x - Input variable (NUMERIC type)biasCorrected - If true: divide by (N-1) (i.e., sample variable). If false: divide by N (population variance)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable variance(String name, SDVariable x, boolean biasCorrected, int... dimensions)
name - name May be null. Name for the output variablex - Input variable (NUMERIC type)biasCorrected - If true: divide by (N-1) (i.e., sample variable). If false: divide by N (population variance)dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))public SDVariable where(SDVariable x, SDVariable y, SDVariable condition)
x - The first array (NDARRAY type)y - The second array (NDARRAY type)condition - Condition array determining which elements at which indices should be picked from. If true, picks from x, other wise y (BOOL type)public SDVariable where(String name, SDVariable x, SDVariable y, SDVariable condition)
name - name May be null. Name for the output variablex - The first array (NDARRAY type)y - The second array (NDARRAY type)condition - Condition array determining which elements at which indices should be picked from. If true, picks from x, other wise y (BOOL type)public SDVariable where(SDVariable x, SDVariable condition)
x - The first array (NUMERIC type)condition - Condition array determining which elements at which indices should be picked from. If true, picks from x, other wise y (BOOL type)public SDVariable where(String name, SDVariable x, SDVariable condition)
name - name May be null. Name for the output variablex - The first array (NUMERIC type)condition - Condition array determining which elements at which indices should be picked from. If true, picks from x, other wise y (BOOL type)public SDVariable where(SDVariable condition)
condition - Condition array determining which elements at which indices should be picked from. If true, picks from x, other wise y (BOOL type)public SDVariable where(String name, SDVariable condition)
name - name May be null. Name for the output variablecondition - Condition array determining which elements at which indices should be picked from. If true, picks from x, other wise y (BOOL type)public SDVariable whereNumpy(SDVariable x, SDVariable y, SDVariable condition)
x - The first array (NDARRAY type)y - The second array (NDARRAY type)condition - Condition array determining which elements at which indices should be picked from. If true, picks from x, other wise y (NUMERIC type)public SDVariable whereNumpy(String name, SDVariable x, SDVariable y, SDVariable condition)
name - name May be null. Name for the output variablex - The first array (NDARRAY type)y - The second array (NDARRAY type)condition - Condition array determining which elements at which indices should be picked from. If true, picks from x, other wise y (NUMERIC type)public SDVariable zerosLike(SDVariable input)
input - Input (NDARRAY type)public SDVariable zerosLike(String name, SDVariable input)
name - name May be null. Name for the output variableinput - Input (NDARRAY type)Copyright © 2022. All rights reserved.