Field Detail

• sd

  protected SameDiff sd

Constructor Detail

• SDBaseOps

  public SDBaseOps(SameDiff sameDiff)

Method Detail

• all

  public SDVariable all(SDVariable x,
                        int... dimensions)

  Boolean and array reduction operation, optionally along specified dimensions
  

  Parameters:

  x - Input variable (NDARRAY type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) (BOOL type)

• all

  public SDVariable all(String name,
                        SDVariable x,
                        int... dimensions)

  Boolean and array reduction operation, optionally along specified dimensions
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NDARRAY type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) (BOOL type)

• any

  public SDVariable any(SDVariable x,
                        int... dimensions)

  Boolean or array reduction operation, optionally along specified dimensions
  

  Parameters:

  x - Input variable (NDARRAY type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) (BOOL type)

• any

  public SDVariable any(String name,
                        SDVariable x,
                        int... dimensions)

  Boolean or array reduction operation, optionally along specified dimensions
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NDARRAY type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) (BOOL type)

• argmax

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  in - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true (NUMERIC type)

• argmax

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true (NUMERIC type)

• argmax

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  in - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true (NUMERIC type)

• argmax

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true (NUMERIC type)

• argmin

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  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
  

  Parameters:

  in - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true (NUMERIC type)

• argmin

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  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
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true (NUMERIC type)

• argmin

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  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
  

  Parameters:

  in - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true (NUMERIC type)

• argmin

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  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
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true (NUMERIC type)

• batchMmul

  public SDVariable[] batchMmul(SDVariable[] inputsA,
                                SDVariable[] inputsB,
                                boolean transposeA,
                                boolean transposeB)

  Matrix multiply a batch of matrices. matricesA and matricesB have to be arrays of same
  length and each pair taken from these sets has to have dimensions (M, N) and (N, K),
  respectively. If transposeA is true, matrices from matricesA will have shape (N, M) instead.
  Likewise, if transposeB is true, matrices from matricesB will have shape (K, N).
  
  The result of this operation will be a batch of multiplied matrices. The
  result has the same length as both input batches and each output matrix is of shape (M, K).
  

  Parameters:

  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 not

  transposeB - Whether to transpose B arrays or not

• batchMmul

  public SDVariable[] batchMmul(String[] names,
                                SDVariable[] inputsA,
                                SDVariable[] inputsB,
                                boolean transposeA,
                                boolean transposeB)

  Matrix multiply a batch of matrices. matricesA and matricesB have to be arrays of same
  length and each pair taken from these sets has to have dimensions (M, N) and (N, K),
  respectively. If transposeA is true, matrices from matricesA will have shape (N, M) instead.
  Likewise, if transposeB is true, matrices from matricesB will have shape (K, N).
  
  The result of this operation will be a batch of multiplied matrices. The
  result has the same length as both input batches and each output matrix is of shape (M, K).
  

  Parameters:

  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 not

  transposeB - Whether to transpose B arrays or not

• batchMmul

  public SDVariable[] batchMmul(SDVariable[] inputsA,
                                SDVariable... inputsB)

  Matrix multiply a batch of matrices. matricesA and matricesB have to be arrays of same
  length and each pair taken from these sets has to have dimensions (M, N) and (N, K),
  respectively. If transposeA is true, matrices from matricesA will have shape (N, M) instead.
  Likewise, if transposeB is true, matrices from matricesB will have shape (K, N).
  
  The result of this operation will be a batch of multiplied matrices. The
  result has the same length as both input batches and each output matrix is of shape (M, K).
  

  Parameters:

  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)

• batchMmul

  public SDVariable[] batchMmul(String[] names,
                                SDVariable[] inputsA,
                                SDVariable... inputsB)

  Matrix multiply a batch of matrices. matricesA and matricesB have to be arrays of same
  length and each pair taken from these sets has to have dimensions (M, N) and (N, K),
  respectively. If transposeA is true, matrices from matricesA will have shape (N, M) instead.
  Likewise, if transposeB is true, matrices from matricesB will have shape (K, N).
  
  The result of this operation will be a batch of multiplied matrices. The
  result has the same length as both input batches and each output matrix is of shape (M, K).
  

  Parameters:

  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)

• castTo

  public SDVariable castTo(SDVariable arg,
                           DataType datatype)

  Cast the array to a new datatype - for example, Integer -> Float
  

  Parameters:

  arg - Input variable to cast (NDARRAY type)

  datatype - Datatype to cast to

  Returns:

  output Output array (after casting) (NDARRAY type)

• castTo

  public SDVariable castTo(String name,
                           SDVariable arg,
                           DataType datatype)

  Cast the array to a new datatype - for example, Integer -> Float
  

  Parameters:

  name - name May be null. Name for the output variable

  arg - Input variable to cast (NDARRAY type)

  datatype - Datatype to cast to

  Returns:

  output Output array (after casting) (NDARRAY type)

• concat

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

  Parameters:

  inputs - Input variables (NUMERIC type)

  dimension - Dimension to concatenate on

  Returns:

  output (NUMERIC type)

• concat

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

  Parameters:

  name - name May be null. Name for the output variable

  dimension - Dimension to concatenate on

  inputs - Input variables (NUMERIC type)

  Returns:

  output (NUMERIC type)

• cumprod

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

  Parameters:

  in - Input variable (NUMERIC type)

  exclusive - If true: exclude the first value

  reverse - If true: reverse the direction of the accumulation

  axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))

  Returns:

  output Output variable (NUMERIC type)

• cumprod

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

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  exclusive - If true: exclude the first value

  reverse - If true: reverse the direction of the accumulation

  axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))

  Returns:

  output Output variable (NUMERIC type)

• cumprod

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

  Parameters:

  in - Input variable (NUMERIC type)

  axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))

  Returns:

  output Output variable (NUMERIC type)

• cumprod

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

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))

  Returns:

  output Output variable (NUMERIC type)

• cumsum

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

  Parameters:

  in - Input variable (NUMERIC type)

  exclusive - If true: exclude the first value

  reverse - If true: reverse the direction of the accumulation

  axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))

  Returns:

  output (NUMERIC type)

• cumsum

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

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  exclusive - If true: exclude the first value

  reverse - If true: reverse the direction of the accumulation

  axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))

  Returns:

  output (NUMERIC type)

• cumsum

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

  Parameters:

  in - Input variable (NUMERIC type)

  axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))

  Returns:

  output (NUMERIC type)

• cumsum

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

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  axis - Scalar axis argument for dimension to perform cumululative sum operations along (Size: AtLeast(min=1))

  Returns:

  output (NUMERIC type)

• dot

  public SDVariable dot(SDVariable x,
                        SDVariable y,
                        int... dimensions)

  Pairwise dot product reduction along dimension
  output = sum(i=0 ... size(dim)-1) x[i] * y[i]
  

  Parameters:

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

  Returns:

  output output variable (NUMERIC type)

• dot

  public SDVariable dot(String name,
                        SDVariable x,
                        SDVariable y,
                        int... dimensions)

  Pairwise dot product reduction along dimension
  output = sum(i=0 ... size(dim)-1) x[i] * y[i]
  

  Parameters:

  name - name May be null. Name for the output variable

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

  Returns:

  output output variable (NUMERIC type)

• dynamicPartition

  public SDVariable[] dynamicPartition(SDVariable x,
                                       SDVariable partitions,
                                       int numPartitions)

  Dynamically partition the input variable values into the specified number of paritions, using the indices.
  Example:
  

  
  
   input = [1,2,3,4,5]
  
   numPartitions = 2
  
   partitions = [1,0,0,1,0]
  
   out[0] = [2,3,5]
  
   out[1] = [1,4] }
  
   

  
  

  Parameters:

  x - Input variable (NUMERIC type)

  partitions - 1D input with values 0 to numPartitions-1 (INT type)

  numPartitions - Number of partitions, >= 1

• dynamicPartition

  public 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:
  

  
  
   input = [1,2,3,4,5]
  
   numPartitions = 2
  
   partitions = [1,0,0,1,0]
  
   out[0] = [2,3,5]
  
   out[1] = [1,4] }
  
   

  
  

  Parameters:

  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, >= 1

• dynamicStitch

  public SDVariable dynamicStitch(SDVariable[] indices,
                                  SDVariable... x)

  Dynamically merge the specified input arrays into a single array, using the specified indices
  

  Parameters:

  indices - Indices to use when merging. Must be >= 1, same length as input variables (INT type)

  x - Input variables. (NUMERIC type)

  Returns:

  output Merged output variable (NUMERIC type)

• dynamicStitch

  public SDVariable dynamicStitch(String name,
                                  SDVariable[] indices,
                                  SDVariable... x)

  Dynamically merge the specified input arrays into a single array, using the specified indices
  

  Parameters:

  name - name May be null. Name for the output variable

  indices - Indices to use when merging. Must be >= 1, same length as input variables (INT type)

  x - Input variables. (NUMERIC type)

  Returns:

  output Merged output variable (NUMERIC type)

• eq

  public SDVariable eq(SDVariable x,
                       double y)

  Equals operation: elementwise x == y
  Return boolean array with values true where satisfied, or false otherwise.
  

  Parameters:

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• eq

  public SDVariable eq(String name,
                       SDVariable x,
                       double y)

  Equals operation: elementwise x == y
  Return boolean array with values true where satisfied, or false otherwise.
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• eq

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

  Parameters:

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• eq

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• expandDims

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

  Parameters:

  x - Input variable (NDARRAY type)

  axis - Axis to expand

  Returns:

  output Output variable (NUMERIC type)

• expandDims

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NDARRAY type)

  axis - Axis to expand

  Returns:

  output Output variable (NUMERIC type)

• fill

  public 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
  

  Parameters:

  shape - Shape: must be a 1D array/variable (INT type)

  dataType - Datatype of the output array

  value - Value to set all elements to

  Returns:

  output Output variable (NUMERIC type)

• fill

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  shape - Shape: must be a 1D array/variable (INT type)

  dataType - Datatype of the output array

  value - Value to set all elements to

  Returns:

  output Output variable (NUMERIC type)

• gather

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

  Parameters:

  df - Input variable (NUMERIC type)

  indices - Indices to get (Size: AtLeast(min=1))

  axis - Axis that the indices refer to

  Returns:

  output Output variable with slices pulled from the specified axis (NUMERIC type)

• gather

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

  Parameters:

  name - name May be null. Name for the output variable

  df - Input variable (NUMERIC type)

  indices - Indices to get (Size: AtLeast(min=1))

  axis - Axis that the indices refer to

  Returns:

  output Output variable with slices pulled from the specified axis (NUMERIC type)

• gather

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

  Parameters:

  df - Input variable (NUMERIC type)

  indices - Indices to get slices for. Rank 0 or 1 input (INT type)

  axis - Axis that the indices refer to

  Returns:

  output Output variable with slices pulled from the specified axis (NUMERIC type)

• gather

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

  Parameters:

  name - name May be null. Name for the output variable

  df - Input variable (NUMERIC type)

  indices - Indices to get slices for. Rank 0 or 1 input (INT type)

  axis - Axis that the indices refer to

  Returns:

  output Output variable with slices pulled from the specified axis (NUMERIC type)

• gatherNd

  public SDVariable gatherNd(SDVariable df,
                             SDVariable indices)

  Gather slices from df with shape specified by indices.
  

  Parameters:

  df - (NUMERIC type)

  indices - (NUMERIC type)

  Returns:

  output (NUMERIC type)

• gatherNd

  public SDVariable gatherNd(String name,
                             SDVariable df,
                             SDVariable indices)

  Gather slices from df with shape specified by indices.
  

  Parameters:

  name - name May be null. Name for the output variable

  df - (NUMERIC type)

  indices - (NUMERIC type)

  Returns:

  output (NUMERIC type)

• gt

  public SDVariable gt(SDVariable x,
                       double y)

  Greater than operation: elementwise x > y
  Return boolean array with values true where satisfied, or false otherwise.
  

  Parameters:

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• gt

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• gt

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

  Parameters:

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output Output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• gt

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output Output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• gte

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

  Parameters:

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• gte

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• gte

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

  Parameters:

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output (NUMERIC type)

• gte

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output (NUMERIC type)

• identity

  public SDVariable identity(SDVariable input)

  Elementwise identity operation: out = x
  

  Parameters:

  input - Input variable (NUMERIC type)

  Returns:

  output Output variable (NUMERIC type)

• identity

  public SDVariable identity(String name,
                             SDVariable input)

  Elementwise identity operation: out = x
  

  Parameters:

  name - name May be null. Name for the output variable

  input - Input variable (NUMERIC type)

  Returns:

  output Output variable (NUMERIC type)

• invertPermutation

  public 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
  

  Parameters:

  input - 1D indices for permutation (INT type)

  Returns:

  output 1D inverted permutation (INT type)

• invertPermutation

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  input - 1D indices for permutation (INT type)

  Returns:

  output 1D inverted permutation (INT type)

• isNumericTensor

  public SDVariable isNumericTensor(SDVariable x)

  Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1
  

  Parameters:

  x - Input variable (NUMERIC type)

  Returns:

  output scalar boolean with value true or false (NDARRAY type)

• isNumericTensor

  public SDVariable isNumericTensor(String name,
                                    SDVariable x)

  Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  Returns:

  output scalar boolean with value true or false (NDARRAY type)

• linspace

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

  Parameters:

  dataType - Data type of the output array

  start - Start value

  stop - Stop value

  number - Number of values to generate

  Returns:

  output INDArray with linearly spaced elements (NUMERIC type)

• linspace

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

  Parameters:

  name - name May be null. Name for the output variable

  dataType - Data type of the output array

  start - Start value

  stop - Stop value

  number - Number of values to generate

  Returns:

  output INDArray with linearly spaced elements (NUMERIC type)

• linspace

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

  Parameters:

  start - Start value (NUMERIC type)

  stop - Stop value (NUMERIC type)

  number - Number of values to generate (LONG type)

  dataType - Data type of the output array

  Returns:

  output INDArray with linearly spaced elements (NUMERIC type)

• linspace

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

  Parameters:

  name - name May be null. Name for the output variable

  start - Start value (NUMERIC type)

  stop - Stop value (NUMERIC type)

  number - Number of values to generate (LONG type)

  dataType - Data type of the output array

  Returns:

  output INDArray with linearly spaced elements (NUMERIC type)

• lt

  public SDVariable lt(SDVariable x,
                       double y)

  Less than operation: elementwise x < y
  Return boolean array with values true where satisfied, or false otherwise.
  

  Parameters:

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• lt

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• lt

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

  Parameters:

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output Output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• lt

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output Output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• lte

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

  Parameters:

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• lte

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• lte

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

  Parameters:

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output Output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• lte

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output Output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• matchCondition

  public 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
  

  Parameters:

  in - Input (NUMERIC type)

  condition - Condition

  Returns:

  output Boolean mask (NUMERIC type)

• matchCondition

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input (NUMERIC type)

  condition - Condition

  Returns:

  output Boolean mask (NUMERIC type)

• matchConditionCount

  public SDVariable matchConditionCount(SDVariable in,
                                        Condition condition)

  Returns a count of the number of elements that satisfy the condition
  

  Parameters:

  in - Input (NUMERIC type)

  condition - Condition

  Returns:

  output Number of elements that the condition is satisfied for (NUMERIC type)

• matchConditionCount

  public SDVariable matchConditionCount(String name,
                                        SDVariable in,
                                        Condition condition)

  Returns a count of the number of elements that satisfy the condition
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input (NUMERIC type)

  condition - Condition

  Returns:

  output Number of elements that the condition is satisfied for (NUMERIC type)

• matchConditionCount

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  in - Input variable (NUMERIC type)

  condition - Condition

  keepDim - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Number of elements that the condition is satisfied for (NUMERIC type)

• matchConditionCount

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  condition - Condition

  keepDim - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Number of elements that the condition is satisfied for (NUMERIC type)

• matchConditionCount

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  in - Input variable (NUMERIC type)

  condition - Condition

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Number of elements that the condition is satisfied for (NUMERIC type)

• matchConditionCount

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  condition - Condition

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Number of elements that the condition is satisfied for (NUMERIC type)

• max

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• max

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• max

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• max

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• max

  public 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
  

  Parameters:

  first - First input array (NUMERIC type)

  second - Second input array (NUMERIC type)

  Returns:

  output Output variable (NUMERIC type)

• max

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  first - First input array (NUMERIC type)

  second - Second input array (NUMERIC type)

  Returns:

  output Output variable (NUMERIC type)

• mean

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• mean

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• mean

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• mean

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• merge

  public 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. If both are available, the output is undefined (either input could
  be forwarded to the output)
  

  Parameters:

  x - Input variable (NUMERIC type)

  y - Input variable (NUMERIC type)

  Returns:

  output Output (NUMERIC type)

• merge

  public 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. If both are available, the output is undefined (either input could
  be forwarded to the output)
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  y - Input variable (NUMERIC type)

  Returns:

  output Output (NUMERIC type)

• min

  public SDVariable min(SDVariable x,
                        boolean keepDims,
                        int... dimensions)

  Minimum array reduction operation, optionally along specified dimensions. out = min(in)
  Note that if keepDims = true, the output variable has the same rank as the input variable,
  with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• min

  public SDVariable min(String name,
                        SDVariable x,
                        boolean keepDims,
                        int... dimensions)

  Minimum array reduction operation, optionally along specified dimensions. out = min(in)
  Note that if keepDims = true, the output variable has the same rank as the input variable,
  with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• min

  public SDVariable min(SDVariable x,
                        int... dimensions)

  Minimum array reduction operation, optionally along specified dimensions. out = min(in)
  Note that if keepDims = true, the output variable has the same rank as the input variable,
  with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• min

  public SDVariable min(String name,
                        SDVariable x,
                        int... dimensions)

  Minimum array reduction operation, optionally along specified dimensions. out = min(in)
  Note that if keepDims = true, the output variable has the same rank as the input variable,
  with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output Reduced array of rank (input rank - num dimensions) (NUMERIC type)

• min

  public 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
  

  Parameters:

  first - First input array (NUMERIC type)

  second - Second input array (NUMERIC type)

  Returns:

  output Second input array (NUMERIC type)

• min

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  first - First input array (NUMERIC type)

  second - Second input array (NUMERIC type)

  Returns:

  output Second input array (NUMERIC type)

• mmul

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

  Parameters:

  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 array

  Returns:

  output (NUMERIC type)

• mmul

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

  Parameters:

  name - name May be null. Name for the output variable

  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 array

  Returns:

  output (NUMERIC type)

• mmul

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

  Parameters:

  x - First input variable (NUMERIC type)

  y - Second input variable (NUMERIC type)

  Returns:

  output (NUMERIC type)

• mmul

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

  Parameters:

  name - name May be null. Name for the output variable

  x - First input variable (NUMERIC type)

  y - Second input variable (NUMERIC type)

  Returns:

  output (NUMERIC type)

• neq

  public SDVariable neq(SDVariable x,
                        double y)

  Not equals operation: elementwise x != y
  Return boolean array with values true where satisfied, or false otherwise.
  

  Parameters:

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• neq

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input array (NUMERIC type)

  y - Double value argument to use in operation

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• neq

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

  Parameters:

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• neq

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input 1 (NUMERIC type)

  y - Input 2 (NUMERIC type)

  Returns:

  output Boolean array out, with values true/false based on where the condition is satisfied (NUMERIC type)

• norm1

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• norm1

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• norm1

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  dimensions - dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• norm1

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  dimensions - dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• norm2

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - dimensions dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• norm2

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - dimensions dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• norm2

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  dimensions - dimensions dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• norm2

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  dimensions - dimensions dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• normmax

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• normmax

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• normmax

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  dimensions - dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• normmax

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  dimensions - dimensions to reduce over (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• oneHot

  public SDVariable oneHot(SDVariable indices,
                           int depth,
                           int axis,
                           double on,
                           double off,
                           DataType dataType)

  Convert the array to a one-hot array with walues 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
  

  Parameters:

  indices - Indices - value 0 to depth-1 (NUMERIC type)

  depth - Number of classes

  axis -

  on -

  off -

  dataType - Output data type

  Returns:

  output Output variable (NUMERIC type)

• oneHot

  public 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 walues 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
  

  Parameters:

  name - name May be null. Name for the output variable

  indices - Indices - value 0 to depth-1 (NUMERIC type)

  depth - Number of classes

  axis -

  on -

  off -

  dataType - Output data type

  Returns:

  output Output variable (NUMERIC type)

• oneHot

  public SDVariable oneHot(SDVariable indices,
                           int depth,
                           int axis,
                           double on,
                           double off)

  Convert the array to a one-hot array with walues 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
  

  Parameters:

  indices - Indices - value 0 to depth-1 (NUMERIC type)

  depth - Number of classes

  axis -

  on -

  off -

  Returns:

  output Output variable (NUMERIC type)

• oneHot

  public SDVariable oneHot(String name,
                           SDVariable indices,
                           int depth,
                           int axis,
                           double on,
                           double off)

  Convert the array to a one-hot array with walues 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
  

  Parameters:

  name - name May be null. Name for the output variable

  indices - Indices - value 0 to depth-1 (NUMERIC type)

  depth - Number of classes

  axis -

  on -

  off -

  Returns:

  output Output variable (NUMERIC type)

• oneHot

  public SDVariable oneHot(SDVariable indices,
                           int depth)

  Convert the array to a one-hot array with walues 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)
  

  Parameters:

  indices - Indices - value 0 to depth-1 (NUMERIC type)

  depth - Number of classes

  Returns:

  output Output variable (NUMERIC type)

• oneHot

  public SDVariable oneHot(String name,
                           SDVariable indices,
                           int depth)

  Convert the array to a one-hot array with walues 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)
  

  Parameters:

  name - name May be null. Name for the output variable

  indices - Indices - value 0 to depth-1 (NUMERIC type)

  depth - Number of classes

  Returns:

  output Output variable (NUMERIC type)

• onesLike

  public SDVariable onesLike(SDVariable input)

  Return a variable of all 1s, with the same shape as the input variable. Note that this is dynamic:
  if the input shape changes in later execution, the returned variable's shape will also be updated
  

  Parameters:

  input - Input INDArray (NUMERIC type)

  Returns:

  output A new INDArray with the same (dynamic) shape as the input (NUMERIC type)

• onesLike

  public SDVariable onesLike(String name,
                             SDVariable input)

  Return a variable of all 1s, with the same shape as the input variable. Note that this is dynamic:
  if the input shape changes in later execution, the returned variable's shape will also be updated
  

  Parameters:

  name - name May be null. Name for the output variable

  input - Input INDArray (NUMERIC type)

  Returns:

  output A new INDArray with the same (dynamic) shape as the input (NUMERIC type)

• onesLike

  public SDVariable onesLike(SDVariable input,
                             DataType dataType)

  As per onesLike(String, SDVariable) but the output datatype may be specified
  

  Parameters:

  input - (NUMERIC type)

  dataType -

  Returns:

  output (NUMERIC type)

• onesLike

  public SDVariable onesLike(String name,
                             SDVariable input,
                             DataType dataType)

  As per onesLike(String, SDVariable) but the output datatype may be specified
  

  Parameters:

  name - name May be null. Name for the output variable

  input - (NUMERIC type)

  dataType -

  Returns:

  output (NUMERIC type)

• permute

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

  Parameters:

  x - Input variable (NUMERIC type)

  dimensions - Permute dimensions (INT type)

  Returns:

  output Output variable (permuted input) (NUMERIC type)

• permute

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  dimensions - Permute dimensions (INT type)

  Returns:

  output Output variable (permuted input) (NUMERIC type)

• permute

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

  Parameters:

  x - Input variable (NUMERIC type)

  dimensions - (Size: AtLeast(min=0))

  Returns:

  output Output variable (permuted input) (NUMERIC type)

• permute

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  dimensions - (Size: AtLeast(min=0))

  Returns:

  output Output variable (permuted input) (NUMERIC type)

• prod

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output (NUMERIC type)

• prod

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output (NUMERIC type)

• prod

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  x - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output (NUMERIC type)

• prod

  public 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. This can be useful for later broadcast operations (such as subtracting
  the mean along a dimension).
  Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
  keepDims = true: [a,1,c]
  keepDims = false: [a,c]
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))

  Returns:

  output (NUMERIC type)

• range

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

  Parameters:

  from - Initial/smallest value

  to - Largest value (exclusive)

  step - Step size

  dataType -

  Returns:

  output INDArray with the specified values (NUMERIC type)

• range

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

  Parameters:

  name - name May be null. Name for the output variable

  from - Initial/smallest value

  to - Largest value (exclusive)

  step - Step size

  dataType -

  Returns:

  output INDArray with the specified values (NUMERIC type)

• range

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

  Parameters:

  from - Initial/smallest value (NUMERIC type)

  to - Largest value (exclusive) (NUMERIC type)

  step - Step size (NUMERIC type)

  dataType -

  Returns:

  output INDArray with the specified values (NUMERIC type)

• range

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

  Parameters:

  name - name May be null. Name for the output variable

  from - Initial/smallest value (NUMERIC type)

  to - Largest value (exclusive) (NUMERIC type)

  step - Step size (NUMERIC type)

  dataType -

  Returns:

  output INDArray with the specified values (NUMERIC type)

• rank

  public SDVariable rank(SDVariable in)

  Returns the rank (number of dimensions, i.e., length(shape)) of the specified INDArray as a 0D scalar variable
  

  Parameters:

  in - Input variable (NUMERIC type)

  Returns:

  output (scalar) output variable with value equal to the rank of the input variable (NUMERIC type)

• rank

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  Returns:

  output (scalar) output variable with value equal to the rank of the input variable (NUMERIC type)

• replaceWhere

  public 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
  

  Parameters:

  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 elements

  Returns:

  output New array with values replaced where condition is satisfied (NUMERIC type)

• replaceWhere

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  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 elements

  Returns:

  output New array with values replaced where condition is satisfied (NUMERIC type)

• replaceWhere

  public 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
  

  Parameters:

  update - Source array (NUMERIC type)

  value - Value to set at the output, if the condition is satisfied

  condition - Condition to check on update array elements

  Returns:

  output New array with values replaced where condition is satisfied (NUMERIC type)

• replaceWhere

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  update - Source array (NUMERIC type)

  value - Value to set at the output, if the condition is satisfied

  condition - Condition to check on update array elements

  Returns:

  output New array with values replaced where condition is satisfied (NUMERIC type)

• reshape

  public SDVariable reshape(SDVariable x,
                            SDVariable shape)

  Reshape the input variable to the specified (fixed) shape. The output variable will have the same values as the
  input, but with the specified shape.
  Note that prod(shape) must match length(input) == prod(input.shape)
  

  Parameters:

  x - Input variable (NUMERIC type)

  shape - New shape for variable (NUMERIC type)

  Returns:

  output Output variable (NUMERIC type)

• reshape

  public SDVariable reshape(String name,
                            SDVariable x,
                            SDVariable shape)

  Reshape the input variable to the specified (fixed) shape. The output variable will have the same values as the
  input, but with the specified shape.
  Note that prod(shape) must match length(input) == prod(input.shape)
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  shape - New shape for variable (NUMERIC type)

  Returns:

  output Output variable (NUMERIC type)

• reshape

  public SDVariable reshape(SDVariable x,
                            long... shape)

  Reshape the input variable to the specified (fixed) shape. The output variable will have the same values as the
  input, but with the specified shape.
  Note that prod(shape) must match length(input) == prod(input.shape)
  

  Parameters:

  x - Input variable (NUMERIC type)

  shape - New shape for variable (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• reshape

  public SDVariable reshape(String name,
                            SDVariable x,
                            long... shape)

  Reshape the input variable to the specified (fixed) shape. The output variable will have the same values as the
  input, but with the specified shape.
  Note that prod(shape) must match length(input) == prod(input.shape)
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  shape - New shape for variable (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• reverse

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

  Parameters:

  x - Input variable (NUMERIC type)

  dimensions - Input variable (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• reverse

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

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  dimensions - Input variable (Size: AtLeast(min=0))

  Returns:

  output Output variable (NUMERIC type)

• reverseSequence

  public 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
  

  Parameters:

  x - Input variable (NUMERIC type)

  seq_lengths - Length of the sequences (INT type)

  seqDim - Sequence dimension

  batchDim - Batch dimension

  Returns:

  output Reversed sequences (NUMERIC type)

• reverseSequence

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  seq_lengths - Length of the sequences (INT type)

  seqDim - Sequence dimension

  batchDim - Batch dimension

  Returns:

  output Reversed sequences (NUMERIC type)

• reverseSequence

  public SDVariable reverseSequence(SDVariable x,
                                    SDVariable seq_lengths)

  Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversed
  

  Parameters:

  x - Input variable (NUMERIC type)

  seq_lengths - Length of the sequences (INT type)

  Returns:

  output Reversed sequences (NUMERIC type)

• reverseSequence

  public SDVariable reverseSequence(String name,
                                    SDVariable x,
                                    SDVariable seq_lengths)

  Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversed
  

  Parameters:

  name - name May be null. Name for the output variable

  x - Input variable (NUMERIC type)

  seq_lengths - Length of the sequences (INT type)

  Returns:

  output Reversed sequences (NUMERIC type)

• scalarFloorMod

  public 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'
  

  Parameters:

  in - Input variable (NUMERIC type)

  value - Scalar value to compare

  Returns:

  output Output variable (NUMERIC type)

• scalarFloorMod

  public 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'
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  value - Scalar value to compare

  Returns:

  output Output variable (NUMERIC type)

• scalarMax

  public SDVariable scalarMax(SDVariable in,
                              double value)

  Element-wise scalar maximum operation: out = max(in, value)
  

  Parameters:

  in - Input variable (NUMERIC type)

  value - Scalar value to compare

  Returns:

  output Scalar value to compare (NUMERIC type)

• scalarMax

  public SDVariable scalarMax(String name,
                              SDVariable in,
                              double value)

  Element-wise scalar maximum operation: out = max(in, value)
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  value - Scalar value to compare

  Returns:

  output Scalar value to compare (NUMERIC type)

• scalarMin

  public SDVariable scalarMin(SDVariable in,
                              double value)

  Element-wise scalar minimum operation: out = min(in, value)
  

  Parameters:

  in - Input variable (NUMERIC type)

  value - Scalar value to compare

  Returns:

  output Output variable (NUMERIC type)

• scalarMin

  public SDVariable scalarMin(String name,
                              SDVariable in,
                              double value)

  Element-wise scalar minimum operation: out = min(in, value)
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  value - Scalar value to compare

  Returns:

  output Output variable (NUMERIC type)

• scalarSet

  public SDVariable scalarSet(SDVariable in,
                              double set)

  Return a variable with equal shape to the input, but all elements set to value 'set'
  

  Parameters:

  in - Input variable (NUMERIC type)

  set - Value to set

  Returns:

  output Output variable (NUMERIC type)

• scalarSet

  public SDVariable scalarSet(String name,
                              SDVariable in,
                              double set)

  Return a variable with equal shape to the input, but all elements set to value 'set'
  

  Parameters:

  name - name May be null. Name for the output variable

  in - Input variable (NUMERIC type)

  set - Value to set

  Returns:

  output Output variable (NUMERIC type)

• scatterAdd

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

  Parameters:

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterAdd

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

  Parameters:

  name - name May be null. Name for the output variable

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterDiv

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

  Parameters:

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterDiv

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

  Parameters:

  name - name May be null. Name for the output variable

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterMax

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

  Parameters:

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterMax

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

  Parameters:

  name - name May be null. Name for the output variable

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterMin

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

  Parameters:

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterMin

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

  Parameters:

  name - name May be null. Name for the output variable

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterMul

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

  Parameters:

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterMul

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

  Parameters:

  name - name May be null. Name for the output variable

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterSub

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

  Parameters:

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterSub

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

  Parameters:

  name - name May be null. Name for the output variable

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterUpdate

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

  Parameters:

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• scatterUpdate

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

  Parameters:

  name - name May be null. Name for the output variable

  ref - Initial/source variable (NUMERIC type)

  indices - Indices array (NUMERIC type)

  updates - Updates to add to the initial/source array (NUMERIC type)

  Returns:

  output The updated variable (NUMERIC type)

• segmentMax

  public 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
  

  Parameters:

  data - Data to perform segment max on (NDARRAY type)

  segmentIds - Variable for the segment IDs (NUMERIC type)

  Returns:

  output Segment output (NUMERIC type)

• segmentMax

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  data - Data to perform segment max on (NDARRAY type)

  segmentIds - Variable for the segment IDs (NUMERIC type)

  Returns:

  output Segment output (NUMERIC type)

• segmentMean

  public 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
  

  Parameters:

  data - Data to perform segment max on (NDARRAY type)

  segmentIds - Variable for the segment IDs (NUMERIC type)

  Returns:

  output Segment output (NUMERIC type)

• segmentMean

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  data - Data to perform segment max on (NDARRAY type)

  segmentIds - Variable for the segment IDs (NUMERIC type)

  Returns:

  output Segment output (NUMERIC type)

• segmentMin

  public 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
  

  Parameters:

  data - Data to perform segment max on (NDARRAY type)

  segmentIds - Variable for the segment IDs (NUMERIC type)

  Returns:

  output Segment output (NUMERIC type)

• segmentMin

  public 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
  

  Parameters:

  name - name May be null. Name for the output variable

  data - Data to perform segment max on (NDARRAY type)

  segmentIds - Variable for the segment IDs (NUMERIC type)

  Returns:

  output Segment output (NUMERIC type)