SameDiff (nd4j-api 1.0.0-beta2 API)

java.lang.Object
- org.nd4j.autodiff.samediff.SameDiff

```
public class SameDiff
extends Object
```
SameDiff is the entrypoint for nd4j's autodiff.
You define a graph symbolically.
That graph accumulates operations.
In order to execute the graph, you run exec() to get all the operations exec(List) for an already created set of ops execAndEndResult() for the end result only execAndEndResult(List) for a cached set of ops

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`SDVariable`	`abs(SDVariable x)` Elementwise absolute value operation: out = abs(x)
`SDVariable`	`abs(String name, SDVariable x)` Elementwise absolute value operation: out = abs(x)
`SDVariable`	`acos(SDVariable x)` Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
`SDVariable`	`acos(String name, SDVariable x)` Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
`SDVariable`	`acosh(SDVariable x)` Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
`SDVariable`	`acosh(String name, SDVariable x)` Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
`void`	`addArgsFor(SDVariable[] variables, DifferentialFunction function)` Adds incoming arguments for the specified differential function to the graph
`void`	`addArgsFor(String[] variables, DifferentialFunction function)` Adds incoming arguments for the specified differential function to the graph
`void`	`addAsPlaceHolder(String varName)` Add this vertex id as a place holder
`void`	`addOutgoingFor(SDVariable[] variables, DifferentialFunction function)` Adds outgoing arguments to the graph for the specified DifferentialFunction Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.
`void`	`addOutgoingFor(String[] varNames, DifferentialFunction function)` Adds outgoing arguments to the graph for the specified DifferentialFunction Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.
`void`	`addPropertyForFunction(DifferentialFunction functionFor, String propertyName, INDArray property)` Add a property for the given function
`void`	`addPropertyForFunction(DifferentialFunction functionFor, String propertyName, long property)` Add a property for the given function
`void`	`addPropertyToResolve(DifferentialFunction forFunction, String arrayName)` Adds a property that needs to be resolve for later.
`void`	`addVariable(SDVariable variable)` Add the specified variable to this SameDiff instance
`void`	`addVariableMappingForField(DifferentialFunction function, String fieldName, String varName)` Adds a field name -> variable name mapping for a given function. This is used for model import where there is an unresolved variable at the time of calling any `GraphMapper.importGraph(File)` .
`void`	`addVarNameForImport(String varName)` Marks a variable name as imported.
`boolean`	`allPlaceHolderVariablesResolved()` Returns true if all place holder variables are resolved. A place holder variable is resolved when `getVariable(String)` getArr() does not return null and the shape is properly resolved.
`SDVariable`	`amax(SDVariable in, int... dimensions)` Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
`SDVariable`	`amax(String name, SDVariable in, int... dimensions)` Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
`SDVariable`	`amean(SDVariable in, int... dimensions)` Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
`SDVariable`	`amean(String name, SDVariable in, int... dimensions)` Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
`SDVariable`	`amin(SDVariable in, int... dimensions)` Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
`SDVariable`	`amin(String name, SDVariable in, int... dimensions)` Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
`SDVariable`	`and(SDVariable x, SDVariable y)` Boolean AND operation: elementwise (x != 0) && (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`and(String name, SDVariable x, SDVariable y)` Boolean AND operation: elementwise (x != 0) && (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`argmax(SDVariable in, boolean keepDims, int... dimensions)`
`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
`SDVariable`	`argmax(String name, SDVariable in, boolean keepDims, int... dimensions)` Argmax array reduction operation, optionally along specified dimensions. Output values are the index of the maximum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`argmax(String name, SDVariable in, int... dimensions)` Argmax array reduction operation, optionally along specified dimensions. Output values are the index of the maximum value of each slice along the specified dimension
`SDVariable`	`argmin(SDVariable in, boolean keepDims, int... dimensions)`
`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
`SDVariable`	`argmin(String name, SDVariable in, boolean keepDims, int... dimensions)` Argmin array reduction operation, optionally along specified dimensions. Output values are the index of the minimum value of each slice along the specified dimension. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`argmin(String name, SDVariable in, int... dimensions)` Argmin array reduction operation, optionally along specified dimensions. Output values are the index of the minimum value of each slice along the specified dimension
`boolean`	`arrayAlreadyExistsForVarName(String varName)` Returns true if the given vertex id and `INDArray` already exist.
`ByteBuffer`	`asFlatBuffers()` This method exports the current SameDiff instance into FlatBuffers format, returning the array ops and all arrays as a ByteBuffer containing the FlatBuffers format data
`ByteBuffer`	`asFlatBuffers(ExecutorConfiguration configuration)` This method exports the current SameDiff instance into FlatBuffers format, returning the array ops and all arrays as a ByteBuffer containing the FlatBuffers format data
`void`	`asFlatFile(File file)` This method converts SameDiff instance to FlatBuffers and saves it to file which can be restored later
`void`	`asFlatFile(File file, ExecutorConfiguration configuration)` This method converts SameDiff instance to FlatBuffers and saves it to file which can be restored later
`protected int`	`asFlatNode(DifferentialFunction node, com.google.flatbuffers.FlatBufferBuilder bufferBuilder, List<SDVariable> variables, Map<String,Integer> reverseMap, Map<String,Integer> forwardMap, Map<String,Integer> framesMap, AtomicInteger idCounter)`
`protected int`	`asFlatNode(String name, SameDiff scope, com.google.flatbuffers.FlatBufferBuilder bufferBuilder)`
`String`	`asFlatPrint()` This method returns a text representation of the "flattened" graph.
`SDVariable`	`asin(SDVariable x)` Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
`SDVariable`	`asin(String name, SDVariable x)` Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
`SDVariable`	`asinh(SDVariable x)` Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
`SDVariable`	`asinh(String name, SDVariable x)` Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
`SDVariable`	`assign(SDVariable in, Number value)` Return an array with equal shape to the input, but all elements set to 'value'
`SDVariable`	`assign(SDVariable x, SDVariable y)` Assign/copy op: out = x.assign(y).
`SDVariable`	`assign(String name, SDVariable in, Number value)` Return an array with equal shape to the input, but all elements set to 'value'
`SDVariable`	`assign(String name, SDVariable x, SDVariable y)` Assign/copy op: out = x.assign(y).
`void`	`associateArrayWithVariable(INDArray arr, SDVariable variable)` Associate the array with the given variable.
`void`	`associateArrayWithVariable(INDArray arr, String variable)` Associate the array with the given variable.
`protected void`	`associateSameDiffWithOpsAndVariables()` Associate the current SameDiff instance with all ops and variables.
`SDVariable`	`asum(SDVariable in, int... dimensions)` Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
`SDVariable`	`asum(String name, SDVariable in, int... dimensions)` Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
`SDVariable`	`atan(SDVariable x)` Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
`SDVariable`	`atan(String name, SDVariable x)` Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
`SDVariable`	`atan2(SDVariable y, SDVariable x)` Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
`SDVariable`	`atan2(String name, SDVariable y, SDVariable x)` Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
`SDVariable`	`atanh(SDVariable x)` Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
`SDVariable`	`atanh(String name, SDVariable x)` Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
`SDVariable`	`avgPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig)` 2D Convolution layer operation - average pooling 2d
`SDVariable`	`avgPooling2d(String name, SDVariable input, Pooling2DConfig pooling2DConfig)` 2D Convolution layer operation - average pooling 2d
`SDVariable`	`avgPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig)` 3D convolution layer operation - average pooling 3d
`SDVariable`	`avgPooling3d(String name, SDVariable input, Pooling3DConfig pooling3DConfig)` 3D convolution layer operation - average pooling 3d
`SDVariable[]`	`batchMmul(SDVariable[] matricesA, SDVariable[] matricesB)` Matrix multiply a batch of matrices.
`SDVariable[]`	`batchMmul(SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB)` Matrix multiply a batch of matrices.
`SDVariable[]`	`batchMmul(String[] names, SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB)` Matrix multiply a batch of matrices.
`SDVariable`	`batchNorm(SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon)` Batch norm operation.
`SDVariable`	`batchNorm(String name, SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, boolean applyGamma, boolean applyBeta, double epsilon)` Batch norm operation.
`SDVariable`	`batchToSpace(SDVariable x, int[] blocks, int[][] crops)`
`SDVariable`	`batchToSpace(String name, SDVariable x, int[] blocks, int[][] crops)` Convolution 2d layer batch to space operation on 4d input.
`SDVariable`	`biasAdd(SDVariable input, SDVariable bias)`
`SDVariable`	`biasAdd(String name, SDVariable input, SDVariable bias)` Bias addition operation: a special case of addition, typically used with CNN 4D activations and a 1D bias vector
`SDVariable`	`ceil(SDVariable x)` Element-wise ceiling function: out = ceil(x).
`SDVariable`	`ceil(String name, SDVariable x)` Element-wise ceiling function: out = ceil(x).
`void`	`clearExecutionCache()` Clear the execution cache, if it is present
`SDVariable`	`clipByNorm(SDVariable x, double clipValue)` Clipping by L2 norm if l2Norm(x) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
`SDVariable`	`clipByNorm(SDVariable x, double clipValue, int... dimensions)` Clipping by L2 norm, optionally along dimension(s) if l2Norm(x,dimension) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according to the corresponding l2Norm along the specified dimensions
`SDVariable`	`clipByNorm(String name, SDVariable x, double clipValue)` Clipping by L2 norm if l2Norm(x) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
`SDVariable`	`clipByNorm(String name, SDVariable x, double clipValue, int... dimensions)` Clipping by L2 norm, optionally along dimension(s) if l2Norm(x,dimension) < clipValue, then input is returned unmodifed Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according to the corresponding l2Norm along the specified dimensions
`SDVariable`	`clipByValue(SDVariable x, double clipValueMin, double clipValueMax)` Element-wise clipping function: out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax out[i] = clipValueMin if in[i] < clipValueMin out[i] = clipValueMax if in[i] > clipValueMax
`SDVariable`	`clipByValue(String name, SDVariable x, double clipValueMin, double clipValueMax)` Element-wise clipping function: out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax out[i] = clipValueMin if in[i] < clipValueMin out[i] = clipValueMax if in[i] > clipValueMax
`SDVariable`	`col2Im(SDVariable in, Conv2DConfig config)` col2im operation for use in 2D convolution operations.
`SDVariable`	`col2Im(String name, SDVariable in, Conv2DConfig config)` col2im operation for use in 2D convolution operations.
`SDVariable`	`concat(int dimension, SDVariable... inputs)`
`SDVariable`	`concat(String name, int dimension, SDVariable... inputs)` Concatenate a set of inputs along the specified dimension. Note that inputs must have identical rank and identical dimensions, other than the dimension to stack on. For example, if 2 inputs have shape [a, x, c] and [a, y, c] and dimension = 1, then the output has shape [a, x+y, c]
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable predictions)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)`
`SDVariable`	`confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights)`
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred)` Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values.
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred, Integer numClasses)` Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values. For example, if labels = [0, 1, 1], predicted = [0, 2, 1], and numClasses=4 then output is: [1, 0, 0, 0] [0, 1, 1, 0] [0, 0, 0, 0] [0, 0, 0, 0]
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)` Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values. For example, if labels = [0, 1, 1], predicted = [0, 2, 1], numClasses = 4, and weights = [1, 2, 3] [1, 0, 0, 0] [0, 3, 2, 0] [0, 0, 0, 0] [0, 0, 0, 0]
`SDVariable`	`confusionMatrix(String name, SDVariable labels, SDVariable pred, SDVariable weights)` Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values.
`SDVariable`	`constant(SDVariable value, long... shape)` Return a variable of given shape in which all values have a given constant value.
`SDVariable`	`constant(String name, SDVariable value, long... shape)` Return a variable of given shape in which all values have a given constant value.
`SDVariable`	`conv1d(SDVariable input, SDVariable weights, Conv1DConfig conv1DConfig)` 1D Convolution layer operation - Conv1d
`SDVariable`	`conv1d(String name, SDVariable input, SDVariable weights, Conv1DConfig conv1DConfig)` Conv1d operation.
`SDVariable`	`conv2d(SDVariable[] inputs, Conv2DConfig config)` 2D Convolution operation with optional bias
`SDVariable`	`conv2d(SDVariable layerInput, SDVariable weights, Conv2DConfig config)` 2D Convolution operation (without bias)
`SDVariable`	`conv2d(SDVariable layerInput, SDVariable weights, SDVariable bias, Conv2DConfig config)` 2D Convolution operation with optional bias
`SDVariable`	`conv2d(String name, SDVariable[] inputs, Conv2DConfig config)` 2D Convolution operation with optional bias
`SDVariable`	`conv3d(SDVariable input, SDVariable weights, Conv3DConfig conv3DConfig)` Convolution 3D operation without bias
`SDVariable`	`conv3d(SDVariable input, SDVariable weights, SDVariable bias, Conv3DConfig conv3DConfig)` Convolution 3D operation with optional bias
`SDVariable`	`conv3d(String name, SDVariable input, SDVariable weights, Conv3DConfig conv3DConfig)` Convolution 3D operation without bias
`SDVariable`	`conv3d(String name, SDVariable input, SDVariable weights, SDVariable bias, Conv3DConfig conv3DConfig)` Convolution 3D operation with optional bias
`SDVariable`	`cos(SDVariable x)` Elementwise cosine operation: out = cos(x)
`SDVariable`	`cos(String name, SDVariable x)` Elementwise cosine operation: out = cos(x)
`SDVariable`	`cosh(SDVariable x)` Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
`SDVariable`	`cosh(String name, SDVariable x)` Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
`SDVariable`	`cosineDistance(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`cosineDistance(String name, SDVariable x, SDVariable y, int... dimensions)` Cosine distance reduction operation.
`SDVariable`	`cosineSimilarity(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`cosineSimilarity(String name, SDVariable x, SDVariable y, int... dimensions)` Cosine similarity pairwise reduction operation.
`SDVariable`	`countNonZero(SDVariable input, int... dimensions)` Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
`SDVariable`	`countNonZero(String name, SDVariable input, int... dimensions)` Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
`SDVariable`	`countZero(SDVariable input, int... dimensions)` Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
`SDVariable`	`countZero(String name, SDVariable input, int... dimensions)` Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
`static SameDiff`	`create()` Create a new (empty) SameDiff instance without any functions or variables
`static SameDiff`	`create(SameDiff originalSameDiff)` Create a new SameDiff instance from an existing instance.
`void`	`createGradFunction()` Create the gradient function (for calculating gradients via `execBackwards()`) if it is not already defined.
`SDVariable`	`cross(SDVariable a, SDVariable b)`
`SDVariable`	`cross(String name, SDVariable a, SDVariable b)` Returns the pair-wise cross product of equal size arrays a and b: a x b = \|\|a\|\|x\|\|b\|\| sin(theta).
`SDVariable`	`cube(SDVariable x)` Element-wise cube function: out = x^3
`SDVariable`	`cube(String name, SDVariable x)` Element-wise cube function: out = x^3
`SDVariable`	`cumprod(SDVariable in, boolean exclusive, boolean reverse, int... axis)`
`SDVariable`	`cumprod(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis)` Cumulative product operation. For input: [ a, b, c], output is: exclusize=false, reverse=false: [a, ab, abc] exclusive=true, reverse=false, [0, a, ab] exclusive=false, reverse=true: [abc, bc, c] exclusive=true, reverse=true: [bc, c, 0]
`SDVariable`	`cumsum(SDVariable in, boolean exclusive, boolean reverse, int... axis)`
`SDVariable`	`cumsum(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis)` Cumulative sum operation. For input: [ a, b, c], output is: exclusize=false, reverse=false: [a, a+b, a+b+c] exclusive=true, reverse=false, [0, a, a+b] exclusive=false, reverse=true: [a+b+c, b+c, c] exclusive=true, reverse=true: [b+c, c, 0]
`SDVariable`	`deconv2d(SDVariable[] inputs, DeConv2DConfig deconv2DConfig)` 2D deconvolution operation with or without optional bias
`SDVariable`	`deconv2d(SDVariable layerInput, SDVariable weights, DeConv2DConfig deconv2DConfig)` 2D deconvolution operation without bias
`SDVariable`	`deconv2d(SDVariable layerInput, SDVariable weights, SDVariable bias, DeConv2DConfig deconv2DConfig)` 2D deconvolution operation with optional bias
`SDVariable`	`deconv2d(String name, SDVariable[] inputs, DeConv2DConfig deconv2DConfig)` 2D deconvolution operation with or without optional bias
`Collection<String>`	`definedFunctionNames()` The set of defined SameDiff function names.
`void`	`defineFunction(String function, SameDiffFunctionDefinition functionDefinition)`
`void`	`defineFunction(String function, SameDiffFunctionDefinition functionDefinition, Map<String,INDArray> inputs)`
`SameDiff`	`defineFunction(String function, SameDiffFunctionDefinition functionDefinition, SDVariable[] variables)`
`SDVariable`	`depthToSpace(SDVariable x, int blockSize, String dataFormat)` Convolution 2d layer batch to space operation on 4d input. Reduces input channels dimension by rearranging data into a larger spatial dimensions Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(22), 22, 2*2] = [mb, 2, 4, 4]
`SDVariable`	`depthToSpace(String name, SDVariable x, int blockSize, String dataFormat)` Convolution 2d layer batch to space operation on 4d input. Reduces input channels dimension by rearranging data into a larger spatial dimensions Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(22), 22, 2*2] = [mb, 2, 4, 4]
`SDVariable`	`depthWiseConv2d(SDVariable[] inputs, Conv2DConfig depthConv2DConfig)` Depth-wise convolution 2D operation.
`SDVariable`	`depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights, Conv2DConfig config)` Depth-wise 2D convolution operation without bias
`SDVariable`	`depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable bias, Conv2DConfig config)` Depth-wise 2D convolution operation with optional bias
`SDVariable`	`depthWiseConv2d(String name, SDVariable[] inputs, Conv2DConfig depthConv2DConfig)` Depth-wise convolution 2D operation.
`SDVariable`	`diag(SDVariable x)`
`SDVariable`	`diag(String name, SDVariable x)` Returns an output variable with diagonal values equal to the specified values; off-diagonal values will be set to 0 For example, if input = [1,2,3], then output is given by: [ 1, 0, 0] [ 0, 2, 0] [ 0, 0, 3] Higher input ranks are also supported: if input has shape [a,...,R-1] then output[i,...,k,i,...,k] = input[i,...,k].
`SDVariable`	`diagPart(SDVariable x)`
`SDVariable`	`diagPart(String name, SDVariable x)` Extract the diagonal part from the input array. If input is [ 1, 0, 0] [ 0, 2, 0] [ 0, 0, 3] then output is [1, 2, 3]. Supports higher dimensions: in general, out[i,...,k] = in[i,...,k,i,...,k]
`SDVariable`	`dilation2D(SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)` TODO doc string
`SDVariable`	`dilation2D(String name, SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)` TODO doc string
`SameDiff`	`disableDebugging()` Clears debugging state and disables debug mode.
`SDVariable`	`dot(SDVariable x, SDVariable y, int... dimensions)` TODO doc string
`SDVariable`	`dot(String name, SDVariable x, SDVariable y, int... dimensions)` TODO doc string
`SDVariable`	`dropout(SDVariable input, double inputRetainProbability)`
`SDVariable`	`dropout(String name, SDVariable input, double inputRetainProbability)`
`SameDiff`	`dup()` Clone/duplicate the SameDiff instance, including arrays etc.
`SDVariable[]`	`dynamicPartition(SDVariable x, SDVariable partitions, int numPartitions)`
`SDVariable[]`	`dynamicPartition(String[] name, SDVariable x, SDVariable partitions, int numPartitions)` Dynamically partition the input variable values into the specified number of paritions, using the indices. Example:
`SDVariable`	`dynamicStitch(SDVariable[] indices, SDVariable[] x)`
`SDVariable`	`dynamicStitch(String name, SDVariable[] indices, SDVariable[] x)` Dynamically merge the specified input arrays into a single array, using the specified indices
`SDVariable`	`elu(SDVariable x)` Element-wise exponential linear unit (ELU) function: out = x if x > 0 out = a * (exp(x) - 1) if x <= 0 with constant a = 1.0
`SDVariable`	`elu(String name, SDVariable x)` Element-wise exponential linear unit (ELU) function: out = x if x > 0 out = a * (exp(x) - 1) if x <= 0 with constant a = 1.0
`SDVariable`	`eluDerivative(SDVariable x)` Element-wise derivative exponential linear unit (ELU) function, dOut/dIn given input.
`SDVariable`	`eluDerivative(String name, SDVariable x)` Element-wise derivative exponential linear unit (ELU) function, dOut/dIn given input.
`SameDiff`	`enableDebugMode()` Enables tracing of graphs automatically.
`SDVariable`	`entropy(SDVariable in, int... dimensions)` Entropy reduction: -sum(x * log(x))
`SDVariable`	`entropy(String name, SDVariable in, int... dimensions)` Entropy reduction: -sum(x * log(x))
`SDVariable`	`eq(SDVariable x, double y)` Equals operation: elementwise x == y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`eq(SDVariable x, SDVariable y)` Equal to operation: elementwise x == y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`eq(String name, SDVariable x, double y)` Equals operation: elementwise x == y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`eq(String name, SDVariable x, SDVariable y)` Equal to operation: elementwise x == y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`boolean`	`equals(Object o)`
`SDVariable`	`erf(SDVariable x)` Element-wise Gaussian error function - out = erf(in)
`SDVariable`	`erf(String name, SDVariable x)` Element-wise Gaussian error function - out = erf(in)
`SDVariable`	`erfc(SDVariable x)` Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
`SDVariable`	`erfc(String name, SDVariable x)` Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
`SDVariable`	`euclideanDistance(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`euclideanDistance(String name, SDVariable x, SDVariable y, int... dimensions)` Euclidean distance (l2 norm, l2 distance) reduction operation.
`INDArray[]`	`eval(Map<String,INDArray> inputs)` Evaluate the given inputs based on the current graph
`org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>`	`exec()` Execute the SameDiff instance using the current state After execution, the arrays for variables can be obtained using `getArrForVarName(String)` or `SDVariable.getArr()`
`List<DifferentialFunction>`	`exec(List<DifferentialFunction> ops)` Executes the list of operations.
`org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>`	`exec(String functionName)` Execute the specified SameDiff function instance
`List<DifferentialFunction>`	`exec(String functionName, List<DifferentialFunction> cachedOps)` Exec the given function given the ops
`INDArray`	`execAndEndResult()` Execute the graph using the current arrays/state and return the array for the final variable in the graph. After execution, the arrays for other variables can be obtained using `getArrForVarName(String)` or `SDVariable.getArr()`
`INDArray`	`execAndEndResult(int outputIndex)` Execute the graph using the current arrays/state and return the (first, and possibly only) array for the specified variable in the graph. After execution, the arrays for other variables can be obtained using `getArrForVarName(String)` or `SDVariable.getArr()`
`INDArray`	`execAndEndResult(List<DifferentialFunction> ops)` Execute the specified ops and return the output of the last one
`INDArray`	`execAndEndResult(String functionName)` Exec a given SameDiff function instance
`INDArray[]`	`execAndEndResults()` Execute the graph using the current arrays/state and return the array(s) for the final variable in the graph. After execution, the arrays for other variables can be obtained using `getArrForVarName(String)` or `SDVariable.getArr()`
`INDArray`	`execBackwardAndEndResult()` Exec a backwards operation and return the end result
`org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>`	`execBackwards()` Execute the gradient (backward pass) function on this graph. Constructs a backwards graph (differentiating the defined graph) if it does not already exist, and the executes the operations on that graph, calculating gradients for all variables. Note that after execBackwards() has completed, the gradient arrays for a each variable can be accessed using `SDVariable.getGradient()` followed by `SDVariable.getArr()` or by using `getGradForVariable(String)`
`org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>>`	`execWithPlaceHolder(Map<String,INDArray> inputs)` Creates and executes a list of operations based on the given variables passed in. `resolveVariablesWith(Map)` is called
`INDArray`	`execWithPlaceHolderAndEndResult(Map<String,INDArray> inputs)` Creates and executes a list of operations
`SDVariable`	`exp(SDVariable x)` Elementwise exponent function: out = exp(x) = 2.71828...^x
`SDVariable`	`exp(String name, SDVariable x)` Elementwise exponent function: out = exp(x) = 2.71828...^x
`SDVariable`	`expandDims(SDVariable x, int axis)`
`SDVariable`	`expandDims(String name, SDVariable x, int axis)` Reshape the input by adding a 1 at the specified location. For example, if input has shape [a, b], then output shape is: axis = 0: [1, a, b] axis = 1: [a, 1, b] axis = 2: [a, b, 1]
`SDVariable`	`expm1(SDVariable x)` Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
`SDVariable`	`expm1(String name, SDVariable x)` Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
`SDVariable`	`eye(int rows)` Generate a square identity matrix with the specified number of rows.
`SDVariable`	`eye(int rows, int cols)`
`SDVariable`	`eye(int rows, int cols, int... batchDimension)` see `eye(String, int, int, int...)`
`SDVariable`	`eye(SDVariable rows)` As per `eye(int)` but with the number of rows specified as a scalar SDVariable
`SDVariable`	`eye(SDVariable rows, SDVariable cols)` As per `eye(int, int)` bit with the number of rows/columns specified as scalar SDVariables
`SDVariable`	`eye(SDVariable rows, SDVariable cols, SDVariable batchDimension)` As per `eye(int, int, int...)` bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
`SDVariable`	`eye(String name, int rows)` Generate an identity matrix with the specified number of rows and columns.
`SDVariable`	`eye(String name, int rows, int cols)` Generate an identity matrix with the specified number of rows and columns Example:
`SDVariable`	`eye(String name, int rows, int cols, int... batchDimension)` Generate an identity matrix with the specified number of rows and columns, with optional leading dims Example: batchShape: [3,3] numRows: 2 numCols: 4 returns a tensor of shape (3, 3, 2, 4) that consists of 3 * 3 batches of (2,4)-shaped identity matrices: 1 0 0 0 0 1 0 0
`SDVariable`	`eye(String name, SDVariable rows)` As per `eye(String, int)` but with the number of rows specified as a scalar SDVariable
`SDVariable`	`eye(String name, SDVariable rows, SDVariable cols)` As per `eye(String, int, int)` bit with the number of rows/columns specified as scalar SDVariables
`SDVariable`	`eye(String name, SDVariable rows, SDVariable cols, SDVariable batchDimension)` As per `eye(String, int, int, int...)` bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
`DifferentialFunctionFactory`	`f()` Returns this samediff instance's `DifferentialFunctionFactory`
`SDVariable`	`fill(SDVariable shape, double value)` Generate an output variable with the specified (dynamic) shape with all elements set to the specified value
`SDVariable`	`fill(String name, SDVariable shape, double value)` Generate an output variable with the specified (dynamic) shape with all elements set to the specified value
`SDVariable`	`firstIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)`
`SDVariable`	`firstIndex(SDVariable in, Condition condition, int... dimensions)`
`SDVariable`	`firstIndex(String name, SDVariable in, Condition condition, boolean keepDims, int... dimensions)` First index reduction operation. Returns a variable that contains the index of the first element that matches the specified condition (for each slice along the specified dimensions) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`firstIndex(String name, SDVariable in, Condition condition, int... dimensions)` First index reduction operation. Returns a variable that contains the index of the first element that matches the specified condition (for each slice along the specified dimensions)
`SDVariable`	`floor(SDVariable x)` Element-wise floor function: out = floor(x).
`SDVariable`	`floor(String name, SDVariable x)` Element-wise floor function: out = floor(x).
`boolean`	`functionExists(String id)` Returns true if the given function id exists
`DifferentialFunction[]`	`functions()` Get an array of differential functions that have been defined for this SameDiff instance
`SDVariable`	`gather(SDVariable df, int[] indices, int axis)`
`SDVariable`	`gather(SDVariable df, SDVariable indices, int axis)`
`SDVariable`	`gather(String name, SDVariable df, int[] indices, int axis)` Gather slices from the input variable where the indices are specified as fixed int[] values. Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.
`SDVariable`	`gather(String name, SDVariable df, SDVariable indices, int axis)` Gather slices from the input variable where the indices are specified as dynamic SDVariable values. Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.
`SDVariable`	`gatherNd(SDVariable df, SDVariable indices)` TODO doc string
`SDVariable`	`gatherNd(String name, SDVariable df, SDVariable indices)` TODO doc string
`String`	`generateNewVarName(String baseName, int argIndex)` Generate a new variable name based on the uniqueness of the base name and arg index For example, if baseName = "X" will return: "X" if "X" does not already exist, or "X:argIndex" if argIndex > 0 "X_1" if "X" already exists, or "X_1:argIndex" if argIndex > 0 "X_2" if "X" and "X_1" already exists, or "X_2:argIndex" if argIndex > 0 And so on, until an unused name is found
`SDVariable[]`	`generateOutputVariableForOp(DifferentialFunction function)` Generate the variables based on the given input op and return the output variable names.
`SDVariable[]`	`generateOutputVariableForOp(DifferentialFunction function, String baseName)` Generate the variables based on the given input op and return the output variable names.
`INDArray`	`getArrForVarName(String varName)` Get an `INDArray` for a given vertex id, or null if none exists
`String`	`getBaseNameForFunction(DifferentialFunction function)` Returns the base name for the given function if any (may return null)
`static byte`	`getDataTypeAsByte(DataBuffer.Type type)` This method converts enums for DataType
`static DataBuffer.Type`	`getDataTypeFromByte(byte val)` This method converts enums for DataType
`static byte`	`getFlatOpType(Op.Type type)` This method converts an Op.Type to it's corresponding byte value
`SDVariable`	`getForwardVariableForVertexId(int vertexId)` Get the forward variable for gradient based on the gradient's vertex id
`SameDiff`	`getFunction(String functionName)` Get a SameDiff function instance given the name of the function
`DifferentialFunction`	`getFunctionById(String id)` Get the function by the `DifferentialFunction#getOwnName()`
`SDVariable`	`getGradForVariable(String varName)` Get the gradient for the given vertex id
`String[]`	`getInputsForFunction(DifferentialFunction function)` Returns the name(s) of the inputs for the given function
`SDVariable[]`	`getInputVariablesForFunction(DifferentialFunction function)` Get the input variable(s) for the specified differential function
`TensorList`	`getListByName(String name)`
`static long`	`getOpNum(String name, Op.Type type)` This method return operation ID for given op name/type pair.
`static byte`	`getOrderAsByte()` This method returns current byte order for this JVM as libnd4j enum
`static ByteOrder`	`getOrderFromByte(byte val)` This method just converts enums
`long[]`	`getOriginalShapeForPlaceHolder(String varName)` Get the original shape for the vertex id if one was set (other wise returns null). This is mainly for use in validating passed in arrays as arguments to `resolveVariablesWith(Map)` usually when executing using `execWithPlaceHolder(Map)`
`String[]`	`getOutputsForFunction(DifferentialFunction function)` Returns the name(s) of the outputs for the given function
`SDVariable[]`	`getOutputVariablesForFunction(DifferentialFunction function)` Get the output variable(s) for the specified differential function
`List<String[]>`	`getPlaceHoldersFor(String varName)` Get the place holders for a given vertex id.
`<T> T`	`getPropertyForFunction(DifferentialFunction functionInstance, String propertyName)` Get the property for a given function
`long[]`	`getShapeForVarName(String varName)` Get the shape for the given vertex id.
`static Op.Type`	`getTypeFromByte(byte type)` This method converts enums for Op.Type
`SDVariable`	`getVariable(String name)` Get the variable based on the opName
`List<DifferentialFunction>`	`getVariableArgOfFunctions(String variableName)` Return a list of differential functions (if any) that this variable is the input argument for
`DifferentialFunction`	`getVariableOutputFunction(String variableName)` Get the differential function (if any) that this variable is the output for
`List<SDVariable>`	`getVariablesAssociatedWithFunctions(List<DifferentialFunction> functions)` Get the `SDVariable` associated with each function based on the `DifferentialFunction.outputVariables()` ()}
`String`	`getVarNameForFieldAndFunction(DifferentialFunction function, String fieldName)` Get the variable name to use for resolving a given field for a given function during import time.
`SDVariable`	`grad(String varName)` Get the gradient for the variable with the specified variable name.
`SDVariable`	`gradientBackwardsMarker(SDVariable x)` Intended for internal/developer use
`SDVariable`	`gradientBackwardsMarker(String name, SDVariable x)` Intended for internal/developer use
`SDVariable`	`gru(GRUCellConfiguration configuration)` The gru cell
`SDVariable`	`gru(String baseName, GRUCellConfiguration configuration)` The gru cell
`SDVariable`	`gt(SDVariable x, double y)` Greater than operation: elementwise x > y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`gt(SDVariable x, SDVariable y)` Greater than operation: elementwise x > y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`gt(String name, SDVariable x, double y)` Greater than operation: elementwise x > y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`gt(String name, SDVariable x, SDVariable y)` Greater than operation: elementwise x > y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`gte(SDVariable x, double y)` Greater than or equals operation: elementwise x >= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`gte(SDVariable x, SDVariable y)` Greater than or equal to operation: elementwise x >= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`gte(String name, SDVariable x, double y)` Greater than or equals operation: elementwise x >= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`gte(String name, SDVariable x, SDVariable y)` Greater than or equal to operation: elementwise x >= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`hammingDistance(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`hammingDistance(String name, SDVariable x, SDVariable y, int... dimensions)` Hamming distance reduction operation.
`SDVariable`	`hardSigmoid(SDVariable in)` Element-wise hard sigmoid function: out[i] = 0 if in[i] <= -2.5 out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5 out[i] = 1 if in[i] >= 2.5
`SDVariable`	`hardSigmoid(String name, SDVariable in)` Element-wise hard sigmoid function: out[i] = 0 if in[i] <= -2.5 out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5 out[i] = 1 if in[i] >= 2.5
`SDVariable`	`hardTanh(SDVariable in)` Element-wise hard tanh function: out[i] = -1 if in[i] <= -1 out[1] = in[i] if -1 < in[i] < 1 out[i] = 1 if in[i] >= 1
`SDVariable`	`hardTanh(String name, SDVariable in)` Element-wise hard tanh function: out[i] = -1 if in[i] <= -1 out[1] = in[i] if -1 < in[i] < 1 out[i] = 1 if in[i] >= 1
`SDVariable`	`hardTanhDerivative(SDVariable x)` Derivative (dOut/dIn) of the element-wise hard Tanh function - `hardTanh(SDVariable)`
`SDVariable`	`hardTanhDerivative(String name, SDVariable x)` Derivative (dOut/dIn) of the element-wise hard Tanh function - `hardTanh(SDVariable)`
`boolean`	`hasArgs(DifferentialFunction function)` Returns true if this function already has defined arguments
`int`	`hashCode()`
`boolean`	`hasPlaceHolderVariables(String vertexId)` Returns true if the given vertex id has any placeholder variables
`boolean`	`hasPropertiesToResolve(DifferentialFunction function)` Returns true if the given function has ndarray properties to resolve.
`SDVariable`	`iamax(SDVariable in, boolean keepDims, int... dimensions)` Index of the max absolute value: argmax(abs(in))
`SDVariable`	`iamax(SDVariable in, int... dimensions)` Index of the max absolute value: argmax(abs(in))
`SDVariable`	`iamax(String name, SDVariable in, boolean keepDims, int... dimensions)` Index of the max absolute value: argmax(abs(in))
`SDVariable`	`iamax(String name, SDVariable in, int... dimensions)` Index of the max absolute value: argmax(abs(in))
`SDVariable`	`iamin(SDVariable in, boolean keepDims, int... dimensions)` Index of the min absolute value: argmin(abs(in))
`SDVariable`	`iamin(SDVariable in, int... dimensions)` Index of the min absolute value: argmin(abs(in))
`SDVariable`	`iamin(String name, SDVariable in, boolean keepDims, int... dimensions)` Index of the min absolute value: argmin(abs(in))
`SDVariable`	`iamin(String name, SDVariable in, int... dimensions)` Index of the min absolute value: argmin(abs(in))
`SDVariable`	`identity(SDVariable input)` Elementwise identity operation: out = x
`SDVariable`	`identity(String name, SDVariable input)` Elementwise identity operation: out = x
`If`	`ifStatement(SameDiffConditional conditional, SameDiffFunctionDefinition conditionBody, SameDiffFunctionDefinition trueBody, SameDiffFunctionDefinition falseBody, SDVariable[] inputVars)`
`SDVariable`	`im2Col(SDVariable in, Conv2DConfig config)` im2col operation for use in 2D convolution operations.
`SDVariable`	`im2Col(String name, SDVariable in, Conv2DConfig config)` im2col operation for use in 2D convolution operations.
`SDVariable`	`invertPermutation(SDVariable input)` Compute the inverse permutation indices for a permutation operation Example: if input is [2, 0, 1] then output is [1, 2, 0] The idea is that x.permute(input).permute(invertPermutation(input)) == x
`SDVariable`	`invertPermutation(String name, SDVariable input)` Compute the inverse permutation indices for a permutation operation Example: if input is [2, 0, 1] then output is [1, 2, 0] The idea is that x.permute(input).permute(invertPermutation(input)) == x
`SDVariable`	`invoke(Op op, SDVariable x)` Invoke an op by opName
`SDVariable`	`invoke(Op op, SDVariable x, SDVariable y)` Invoke an op by opName
`SDVariable`	`invokeFunctionOn(String functionName, SameDiff with)`
`SDVariable`	`invokeGraphOn(SameDiff sameDiff)`
`SDVariable`	`isFinite(SDVariable x)` Is finite operation: elementwise isFinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`isFinite(String name, SDVariable x)` Is finite operation: elementwise isFinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`boolean`	`isImportVariable(String variableName)` Returns true if the variable name is imported
`SDVariable`	`isInfinite(SDVariable x)` Is infinite operation: elementwise isInfinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`isInfinite(String name, SDVariable x)` Is infinite operation: elementwise isInfinite(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`isMax(SDVariable x)` Is maximum operation: elementwise x == max(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`isMax(String name, SDVariable x)` Is maximum operation: elementwise x == max(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`isNaN(SDVariable x)` Is Not a Number operation: elementwise isNaN(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`isNaN(String name, SDVariable x)` Is Not a Number operation: elementwise isNaN(x) Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`isNonDecreasing(SDVariable x)` Is the array non decreasing? An array is non-decreasing if for every valid i, x[i] <= x[i+1].
`SDVariable`	`isNonDecreasing(String name, SDVariable x)` Is the array non decreasing? An array is non-decreasing if for every valid i, x[i] <= x[i+1].
`SDVariable`	`isNumericTensor(SDVariable x)` Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1
`SDVariable`	`isNumericTensor(String name, SDVariable x)` Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1
`boolean`	`isPlaceHolder(String varName)` Returns true if this vertex id is a place holder variable or not A place holder variable is one where the array shape(s) are currently known and can't yet be calculated
`SDVariable`	`isStrictlyIncreasing(SDVariable x)` Is the array strictly increasing? An array is strictly increasing if for every valid i, x[i] < x[i+1].
`SDVariable`	`isStrictlyIncreasing(String name, SDVariable x)` Is the array strictly increasing? An array is strictly increasing if for every valid i, x[i] < x[i+1].
`SDVariable`	`jaccardDistance(SDVariable x, SDVariable y, int... dimensions)` Jaccard similarity reduction operation.
`SDVariable`	`jaccardDistance(String name, SDVariable x, SDVariable y, int... dimensions)` Jaccard similarity reduction operation.
`SDVariable`	`lastIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)`
`SDVariable`	`lastIndex(SDVariable in, Condition condition, int... dimensions)`
`SDVariable`	`lastIndex(String name, SDVariable in, Condition condition, boolean keepDims, int... dimensions)` Last index reduction operation. Returns a variable that contains the index of the last element that matches the specified condition (for each slice along the specified dimensions) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`lastIndex(String name, SDVariable in, Condition condition, int... dimensions)` Last index reduction operation. Returns a variable that contains the index of the last element that matches the specified condition (for each slice along the specified dimensions)
`SDVariable`	`leakyRelu(SDVariable x, double alpha)` Element-wise leaky ReLU function: out = x if x >= 0.0 out = alpha * x if x < cutoff Alpha value is most commonly set to 0.01
`SDVariable`	`leakyRelu(String name, SDVariable x, double alpha)` Element-wise leaky ReLU function: out = x if x >= 0.0 out = alpha * x if x < cutoff Alpha value is most commonly set to 0.01
`SDVariable`	`leakyReluDerivative(String name, SDVariable x, double alpha)` Leaky ReLU derivative: dOut/dIn given input. See `leakyRelu(String, SDVariable, double)`
`SDVariable`	`linear(SDVariable input, SDVariable weights, SDVariable bias)`
`SDVariable`	`linear(String name, SDVariable input, SDVariable weights, SDVariable bias)` Linear layer operation: out = mmul(in,w) + bias Note that bias array is optional
`SDVariable`	`linspace(double start, double stop, long number)` Create a new 1d array with values evenly spaced between values 'start' and 'stop' For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0]
`SDVariable`	`linspace(String name, double start, double stop, long number)` Create a new 1d array with values evenly spaced between values 'start' and 'stop' For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0]
`SDVariable`	`localResponseNormalization(SDVariable inputs, LocalResponseNormalizationConfig lrnConfig)` 2D convolution layer operation - local response normalization
`SDVariable`	`localResponseNormalization(String name, SDVariable input, LocalResponseNormalizationConfig lrnConfig)` 2D convolution layer operation - local response normalization
`SDVariable`	`log(SDVariable x)` Element-wise logarithm function (base e - natural logarithm): out = log(x)
`SDVariable`	`log(SDVariable in, double base)` Element-wise logarithm function (with specified base): out = log_{base}(x)
`SDVariable`	`log(String name, SDVariable x)` Element-wise logarithm function (base e - natural logarithm): out = log(x)
`SDVariable`	`log(String name, SDVariable in, double base)` Element-wise logarithm function (with specified base): out = log_{base}(x)
`SDVariable`	`log1p(SDVariable x)` Elementwise natural logarithm function: out = log_e (1 + x)
`SDVariable`	`log1p(String name, SDVariable x)` Elementwise natural logarithm function: out = log_e (1 + x)
`SDVariable`	`logEntropy(SDVariable in, int... dimensions)` Log entropy reduction: log(-sum(x * log(x)))
`SDVariable`	`logEntropy(String name, SDVariable in, int... dimensions)` Log entropy reduction: log(-sum(x * log(x)))
`SDVariable`	`logSigmoid(SDVariable x)` Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))
`SDVariable`	`logSigmoid(String name, SDVariable x)` Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))
`SDVariable`	`logSoftmax(SDVariable x)` Log softmax activation
`SDVariable`	`logSoftmax(String name, SDVariable x)` Log softmax activation
`SDVariable`	`logSumExp(SDVariable input, int... dimensions)` Log-sum-exp reduction (optionally along dimension).
`SDVariable`	`logSumExp(String name, SDVariable input, int... dimensions)` Log-sum-exp reduction (optionally along dimension).
`SDVariable`	`lossBinaryXENT(SDVariable x, SDVariable y, int... dimensions)` Binary cross entropy loss.
`SDVariable`	`lossBinaryXENT(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossCosineSimilarity(SDVariable x, SDVariable y, int... dimensions)` TODO doc string
`SDVariable`	`lossCosineSimilarity(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossHinge(SDVariable x, SDVariable y, int... dimensions)` Hinge loss
`SDVariable`	`lossHinge(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossKLD(SDVariable x, SDVariable y, int... dimensions)` Kullback-Leibler divergence loss
`SDVariable`	`lossKLD(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossL1(SDVariable x, SDVariable y, int... dimensions)` L1 loss
`SDVariable`	`lossL1(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossL2(SDVariable x, SDVariable y, int... dimensions)` L2 loss
`SDVariable`	`lossL2(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossMAE(SDVariable x, SDVariable y, int... dimensions)` Mean absolute error loss
`SDVariable`	`lossMAE(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossMCXENT(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossMCXENT(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossMSE(SDVariable x, SDVariable y, int... dimensions)` Mean squared error loss
`SDVariable`	`lossMSE(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossMSLE(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossMSLE(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossNegativeLogLikelihood(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossNegativeLogLikelihood(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossPoisson(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossPoisson(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossSquaredHinge(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lossSquaredHinge(String name, SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`lstm(String baseName, LSTMCellConfiguration configuration)` LSTM unit
`SDVariable`	`lt(SDVariable x, double y)` Less than operation: elementwise x < y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`lt(SDVariable x, SDVariable y)` Less than operation: elementwise x < y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`lt(String name, SDVariable x, double y)` Less than operation: elementwise x < y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`lt(String name, SDVariable x, SDVariable y)` Less than operation: elementwise x < y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`lte(SDVariable x, double y)` Less than or equals operation: elementwise x <= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`lte(SDVariable x, SDVariable y)` Less than or equal to operation: elementwise x <= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`lte(String name, SDVariable x, double y)` Less than or equals operation: elementwise x <= y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`lte(String name, SDVariable x, SDVariable y)` Less than or equal to operation: elementwise x <= y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`manhattanDistance(SDVariable x, SDVariable y, int... dimensions)`
`SDVariable`	`manhattanDistance(String name, SDVariable x, SDVariable y, int... dimensions)` Manhattan distance (l1 norm, l1 distance) reduction operation.
`SDVariable`	`matchCondition(SDVariable in, Condition condition)` Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwise
`SDVariable`	`matchCondition(String name, SDVariable in, Condition condition)` Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwise
`SDVariable`	`matchConditionCount(SDVariable in, Condition condition)` Returns a count of the number of elements that satisfy the condition
`SDVariable`	`matchConditionCount(String name, SDVariable in, Condition condition)` Returns a count of the number of elements that satisfy the condition
`SDVariable`	`matchConditionCount(String name, SDVariable in, Condition condition, boolean keepDim, int... dimensions)` Returns a count of the number of elements that satisfy the condition (for each slice along the specified dimensions) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`matrixDeterminant(SDVariable in)`
`SDVariable`	`matrixDeterminant(String name, SDVariable in)` Matrix determinant op.
`SDVariable`	`matrixInverse(SDVariable in)`
`SDVariable`	`matrixInverse(String name, SDVariable in)` Matrix inverse op.
`SDVariable`	`max(SDVariable x, int... dimensions)` Max array reduction operation, optionally along specified dimensions
`SDVariable`	`max(SDVariable first, SDVariable second)` Element-wise maximum operation: out[i] = max(first[i], second[i]) Supports broadcasting
`SDVariable`	`max(String name, SDVariable x, boolean keepDims, int... dimensions)` Max array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`max(String name, SDVariable x, int... dimensions)` Max array reduction operation, optionally along specified dimensions
`SDVariable`	`max(String name, SDVariable first, SDVariable second)` Element-wise maximum operation: out[i] = max(first[i], second[i]) Supports broadcasting
`SDVariable`	`maxPooling2d(SDVariable input, Pooling2DConfig pooling2DConfig)` 2D Convolution layer operation - max pooling 2d
`SDVariable`	`maxPooling2d(String name, SDVariable input, Pooling2DConfig pooling2DConfig)` 2D Convolution layer operation - max pooling 2d
`SDVariable`	`maxPooling3d(SDVariable input, Pooling3DConfig pooling3DConfig)` 3D convolution layer operation - max pooling 3d operation.
`SDVariable`	`maxPooling3d(String name, SDVariable input, Pooling3DConfig pooling3DConfig)` 3D convolution layer operation - max pooling 3d operation.
`SDVariable`	`mean(SDVariable x)` Full array mean reduction operation
`SDVariable`	`mean(SDVariable x, int... dimension)` Mean (average) array reduction operation, optionally along specified dimensions
`SDVariable`	`mean(String name, SDVariable x, boolean keepDims, int... dimension)` Mean (average) array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`mean(String name, SDVariable x, int... dimension)` Mean (average) array reduction operation, optionally along specified dimensions
`long`	`memoryForGraph()` Returns the number of bytes for the graph.
`SDVariable`	`mergeAdd(SDVariable... x)` Merge add function: merges an arbitrary number of equal shaped arrays using elementwise addition: out = sum_i in[i]
`SDVariable`	`mergeAdd(String name, SDVariable... inputs)` Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition: out = sum_i in[i]
`SDVariable`	`mergeAvg(SDVariable... inputs)` Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation: out = mean_i in[i]
`SDVariable`	`mergeAvg(String name, SDVariable... inputs)` Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation: out = mean_i in[i]
`SDVariable`	`mergeMax(SDVariable... x)` Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation: out = max_i in[i]
`SDVariable`	`mergeMax(String name, SDVariable... inputs)` Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation: out = max_i in[i]
`SDVariable[]`	`meshgrid(List<String> names, boolean cartesian, SDVariable... inputs)`
`SDVariable[]`	`meshgrid(List<String> names, SDVariable... inputs)` Broadcast the 1D input variables onto an n-dimensional grid. The resulting variable can be used for example for evaluating functions at all locations on a grid. Example:
`SDVariable[]`	`meshgrid(SDVariable... inputs)`
`SDVariable`	`min(SDVariable x, int... dimensions)` Minimum array reduction operation, optionally along specified dimensions.
`SDVariable`	`min(SDVariable first, SDVariable second)` Element-wise minimum operation: out[i] = min(first[i], second[i]) Supports broadcasting
`SDVariable`	`min(String name, SDVariable x, boolean keepDims, int... dimensions)` Minimum array reduction operation, optionally along specified dimensions.
`SDVariable`	`min(String name, SDVariable x, int... dimensions)` Minimum array reduction operation, optionally along specified dimensions.
`SDVariable`	`min(String name, SDVariable first, SDVariable second)` Element-wise minimum operation: out[i] = min(first[i], second[i]) Supports broadcasting
`SDVariable`	`mmul(SDVariable x, SDVariable y)` Matrix multiplication: out = mmul(x,y)
`SDVariable`	`mmul(SDVariable x, SDVariable y, MMulTranspose transpose)` Matrix multiplication: out = mmul(x,y) Supports specifying a `MMulTranspose` argument to perform operation such as mmul(a^T, b), etc.
`SDVariable`	`mmul(String name, SDVariable x, SDVariable y)` Matrix multiplication: out = mmul(x,y)
`SDVariable`	`mmul(String name, SDVariable x, SDVariable y, MMulTranspose transpose)` Matrix multiplication: out = mmul(x,y) Supports specifying a `MMulTranspose` argument to perform operation such as mmul(a^T, b), etc.
`SDVariable[]`	`moments(SDVariable input, int... axes)`
`SDVariable[]`	`moments(String[] name, SDVariable input, int... axes)` Calculate the mean and (population) variance for the input variable, for the specified axis
`SDVariable`	`neg(SDVariable x)` Elementwise negative operation: out = -x
`SDVariable`	`neg(String name, SDVariable x)` Elementwise negative operation: out = -x
`SDVariable`	`neq(SDVariable x, double y)` Not equals operation: elementwise x != y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`neq(SDVariable x, SDVariable y)` Not equal to operation: elementwise x != y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`neq(String name, SDVariable x, double y)` Not equals operation: elementwise x != y Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
`SDVariable`	`neq(String name, SDVariable x, SDVariable y)` Not equal to operation: elementwise x != y If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`static com.rits.cloning.Cloner`	`newCloner()`
`SDVariable`	`norm1(String name, SDVariable x, boolean keepDims, int... dimensions)` Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions: out = sum_i abs(x[i]) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`norm1(String name, SDVariable x, int... dimensions)` Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions: out = sum_i abs(x[i])
`SDVariable`	`norm2(String name, SDVariable x, boolean keepDims, int... dimensions)` Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions: out = sqrt(sum_i x[i]^2) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`norm2(String name, SDVariable x, int... dimensions)` Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions: out = sqrt(sum_i x[i]^2)
`SDVariable[]`	`normalizeMoments(SDVariable counts, SDVariable means, SDVariable variances, double shift)`
`SDVariable[]`	`normalizeMoments(String[] name, SDVariable counts, SDVariable means, SDVariable variances, double shift)` Calculate the mean and variance from the sufficient statistics
`SDVariable`	`normmax(String name, SDVariable x, boolean keepDims, int... dimensions)` Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the specified dimensions: out = max(abs(x[i])) Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`normmax(String name, SDVariable x, int... dimensions)` Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the specified dimensions
`long`	`numElements()` Count the number of elements in all arrays, according to `SDVariable.getShape()`
`SDVariable`	`one(String name, int[] shape)` Create a new variable with the specified shape, with all values initialized to 1.0
`SDVariable`	`one(String name, long[] shape)` Create a new variable with the specified shape, with all values initialized to 1.0
`SDVariable`	`oneHot(SDVariable indices, int depth)`
`SDVariable`	`oneHot(SDVariable indices, int depth, int axis, double on, double off)`
`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
`SDVariable`	`oneHot(String name, SDVariable indices, int depth, int axis, double on, double off)` Convert the array to a one-hot array with walues `on` and `off` for each entry If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with `out[i, ..., j, in[i,...,j]] = on` with other values being set to `off`
`SDVariable`	`onesLike(SDVariable input)` Return a variable of all 1s, with the same shape as the input variable.
`SDVariable`	`onesLike(String name, SDVariable input)` Return a variable of all 1s, with the same shape as the input variable.
`SDVariable`	`or(SDVariable x, SDVariable y)` Boolean OR operation: elementwise (x != 0) \|\| (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`or(String name, SDVariable x, SDVariable y)` Boolean OR operation: elementwise (x != 0) \|\| (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`parallel_stack(SDVariable[] values)`
`SDVariable`	`parallel_stack(String name, SDVariable[] values)`
`static org.nd4j.linalg.primitives.Pair<String,Integer>`	`parseVariable(String varName)` Note: INTENDED FOR DEVELOPER USE This method extract base variable name and output index (if exists) from raw variable name.
`SDVariable`	`permute(SDVariable x, int... dimensions)` Array permutation operation: permute the dimensions according to the specified permutation indices. Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]
`SDVariable`	`permute(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]
`static int[]`	`permuteDataFormatForSameDiff(String dataFormat, boolean weights)` Permute indices for the samediff/dl4j format.
`SDVariable`	`pow(SDVariable x, double value)` Element-wise power function: out = x^value
`SDVariable`	`pow(String name, SDVariable x, double value)` Element-wise power function: out = x^value
`void`	`printFunction(DifferentialFunction differentialFunction)` Print the given function for debugging (will not print functions)
`SDVariable`	`prod(SDVariable x, int... dimensions)` Product array reduction operation, optionally along specified dimensions
`SDVariable`	`prod(String name, SDVariable x, boolean keepDims, int... dimensions)` Product array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`prod(String name, SDVariable x, int... dimensions)` Product array reduction operation, optionally along specified dimensions
`List<String>`	`propertiesToResolveForFunction(DifferentialFunction function)` Return the properties to resolve for the given function.
`void`	`putArrayForVarName(String varName, INDArray arr)` Adds an INDArray for a given variable name.
`void`	`putFunctionForId(String id, DifferentialFunction function)` Put the function for the given id
`void`	`putListByName(String name, TensorList list)`
`void`	`putOrUpdateArrayForVarName(String varName, INDArray arr)` Put the array if it does not exist for the given variable name, or update it if it does
`void`	`putOrUpdateShapeForVarName(String varName, long[] shape, boolean clearArrayOnShapeMismatch)` Put or update the shape for the given variable name.
`void`	`putPlaceHolderForVariable(String varName, String... placeHolderVariables)` Add one or or more place holder variables for the given vertex id.
`void`	`putShapeForVarName(String varName, long[] shape)` Associate a vertex id with the given shape.
`void`	`putSubFunction(String name, SameDiff nameSpace)` Associate a `SameDiff` namespace as a sub function.
`SDVariable`	`randomBernoulli(double p, long... shape)`
`SDVariable`	`randomBernoulli(double p, SDVariable shape)`
`SDVariable`	`randomBernoulli(String name, double p, long... shape)` Generate a new random SDVariable, where values are randomly sampled according to a Bernoulli distribution, with the specified probability.
`SDVariable`	`randomBernoulli(String name, double p, SDVariable shape)` Generate a new random SDVariable, where values are randomly sampled according to a Bernoulli distribution, with the specified probability.
`SDVariable`	`randomBinomial(int nTrials, double p, long... shape)` Generate a new random SDVariable, where values are randomly sampled according to a Binomial distribution, with the specified number of trials and probability.
`SDVariable`	`randomBinomial(String name, int nTrials, double p, long... shape)` Generate a new random SDVariable, where values are randomly sampled according to a Binomial distribution, with the specified number of trials and probability.
`SDVariable`	`randomExponential(double lambda, SDVariable shape)` Generate a new random SDVariable, where values are randomly sampled according to a exponential distribution: P(x) = lambda * exp(-lambda * x)
`SDVariable`	`randomExponential(String name, double lambda, SDVariable shape)` Generate a new random SDVariable, where values are randomly sampled according to a exponential distribution: P(x) = lambda * exp(-lambda * x)
`SDVariable`	`randomLogNormal(double mean, double stddev, long... shape)`
`SDVariable`	`randomLogNormal(String name, double mean, double stddev, long... shape)` Generate a new random SDVariable, where values are randomly sampled according to a Log Normal distribution, i.e., `log(x) ~ N(mean, stdev)`
`SDVariable`	`randomNormal(double mean, double stddev, long... shape)`
`SDVariable`	`randomNormal(double mean, double stddev, SDVariable shape)`
`SDVariable`	`randomNormal(String name, double mean, double stddev, long... shape)` Generate a new random SDVariable, where values are randomly sampled according to a Gaussian (normal) distribution, N(mean, stdev) See `randomNormal(String, double, double, SDVariable)` for the equivalent function where the shape is specified as a long[] instead
`SDVariable`	`randomNormal(String name, double mean, double stddev, SDVariable shape)` Generate a new random SDVariable, where values are randomly sampled according to a Gaussian (normal) distribution, N(mean, stdev) See `randomNormal(String, double, double, long...)` for the equivalent function where the shape is specified as a long[] instead
`SDVariable`	`randomNormalTruncated(double mean, double stddev, long... shape)`
`SDVariable`	`randomNormalTruncated(String name, double mean, double stddev, long... shape)` Generate a new random SDVariable, where values are randomly sampled according to a Gaussian (normal) distribution, N(mean, stdev).
`SDVariable`	`randomUniform(double min, double max, long... shape)`
`SDVariable`	`randomUniform(double min, double max, SDVariable shape)`
`SDVariable`	`randomUniform(String name, double min, double max, long... shape)` Generate a new random SDVariable, where values are randomly sampled according to a uniform distribution, U(min,max) See `randomUniform(double, double, long...)` for the equivalent function where the shape is specified as a SDVariable instead
`SDVariable`	`randomUniform(String name, double min, double max, SDVariable shape)` Generate a new random SDVariable, where values are randomly sampled according to a uniform distribution, U(min,max) See `randomUniform(double, double, long...)` for the equivalent function where the shape is specified as a long[] instead
`SDVariable`	`range(double from, double to, double step)` Create a new variable with a 1d array, where the values start at `from` and increment by `step` up to (but not including) limit. For example, `range(1.0, 3.0, 0.5)` will return `[1.0, 1.5, 2.0, 2.5]`
`SDVariable`	`range(String name, double from, double to, double step)` Create a new variable with a 1d array, where the values start at `from` and increment by `step` up to (but not including) limit. For example, `range(1.0, 3.0, 0.5)` will return `[1.0, 1.5, 2.0, 2.5]`
`SDVariable`	`rank(SDVariable in)` Returns the rank (number of dimensions, i.e., length(shape)) of the specified SDVariable as a 0D scalar variable
`SDVariable`	`rank(String name, SDVariable in)` Returns the rank (number of dimensions, i.e., length(shape)) of the specified SDVariable as a 0D scalar variable
`SDVariable`	`reciprocal(SDVariable a)` Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
`SDVariable`	`reciprocal(String name, SDVariable a)` Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
`SDVariable`	`relu(SDVariable x, double cutoff)` Element-wise rectified linear function with specified cutoff: out[i] = in[i] if in[i] >= cutoff out[i] = 0 otherwise
`SDVariable`	`relu(String name, SDVariable x, double cutoff)` Element-wise rectified linear function with specified cutoff: out[i] = in[i] if in[i] >= cutoff out[i] = 0 otherwise
`SDVariable`	`relu6(SDVariable x, double cutoff)` Element-wise "rectified linear 6" function with specified cutoff: out[i] = min(max(in, cutoff), 6)
`SDVariable`	`relu6(String name, SDVariable x, double cutoff)` Element-wise "rectified linear 6" function with specified cutoff: out[i] = min(max(in, cutoff), 6)
`SDVariable`	`reluLayer(SDVariable input, SDVariable weights, SDVariable bias)`
`SDVariable`	`reluLayer(String name, SDVariable input, SDVariable weights, SDVariable bias)` ReLU (Rectified Linear Unit) layer operation: out = relu(mmul(in,w) + bias) Note that bias array is optional
`void`	`removeArgFromFunction(String varName, DifferentialFunction function)` Remove an argument for a function.
`SDVariable`	`repeat(SDVariable df, int axis)`
`SDVariable`	`repeat(String name, SDVariable df, int axis)`
`SDVariable`	`replaceWhere(SDVariable update, Number value, Condition condition)` Element-wise replace where condition: out[i] = value if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
`SDVariable`	`replaceWhere(SDVariable update, SDVariable from, Condition condition)` Element-wise replace where condition: out[i] = from[i] if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
`SDVariable`	`replaceWhere(String name, SDVariable update, Number value, Condition condition)` Element-wise replace where condition: out[i] = value if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
`SDVariable`	`replaceWhere(String name, SDVariable update, SDVariable from, Condition condition)` Element-wise replace where condition: out[i] = from[i] if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied
`SDVariable`	`reshape(SDVariable x, int... shape)` Reshape the input variable to the specified (fixed) shape.
`SDVariable`	`reshape(SDVariable x, long... shape)` Reshape the input variable to the specified (fixed) shape.
`SDVariable`	`reshape(SDVariable x, SDVariable shape)` Reshape the input variable to the specified (dynamic) shape.
`SDVariable`	`reshape(String name, SDVariable x, int... shape)` Reshape the input variable to the specified (fixed) shape.
`SDVariable`	`reshape(String name, SDVariable x, long... shape)` Reshape the input variable to the specified (fixed) shape.
`SDVariable`	`reshape(String name, SDVariable x, SDVariable shape)` Reshape the input variable to the specified (dynamic) shape.
`void`	`resolveVariablesWith(Map<String,INDArray> arrays)` Resolve all ndarrays by updating the variables for each array specified in the given map.
`SDVariable`	`reverse(SDVariable x, int... dimensions)`
`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, 0): [4, 5, 6] [1, 2 3]
`SDVariable`	`reverseSequence(SDVariable x, SDVariable seq_lengths)`
`SDVariable`	`reverseSequence(SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)`
`SDVariable`	`reverseSequence(String name, SDVariable x, SDVariable seq_lengths)`
`SDVariable`	`reverseSequence(String name, SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)` Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversed
`SDVariable`	`rollAxis(SDVariable x, int axis)`
`SDVariable`	`rollAxis(String name, SDVariable x, int axis)`
`SDVariable`	`round(SDVariable x)` Elementwise round function: out = round(x).
`SDVariable`	`round(String name, SDVariable x)` Element-wise round function: out = round(x).
`SDVariable`	`rsqrt(SDVariable x)` Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
`SDVariable`	`rsqrt(String name, SDVariable x)` Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
`SDVariable`	`scalar(String name, double value)` Create a new scalar (rank 0) SDVariable with the specified value
`SDVariable`	`scalarFloorMod(SDVariable in, Number value)` Element-wise scalar floor modulus operation: out = floorMod(in, value).
`SDVariable`	`scalarFloorMod(String name, SDVariable in, Number value)` Element-wise scalar floor modulus operation: out = floorMod(in, value).
`SDVariable`	`scalarMax(SDVariable in, Number value)` Element-wise scalar maximum operation: out = max(in, value)
`SDVariable`	`scalarMax(String name, SDVariable in, Number value)` Element-wise scalar maximum operation: out = max(in, value)
`SDVariable`	`scalarMin(SDVariable in, Number value)` Element-wise scalar minimum operation: out = min(in, value)
`SDVariable`	`scalarMin(String name, SDVariable in, Number value)` Element-wise scalar minimum operation: out = min(in, value)
`SDVariable`	`scalarSet(SDVariable in, Number set)` Return an array with equal shape to the input, but all elements set to value 'set'
`SDVariable`	`scalarSet(String name, SDVariable in, Number set)` Return an arary with equal shape to the input, but all elements set to value 'set'
`SDVariable`	`scatterAdd(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterAdd(String name, SDVariable ref, SDVariable indices, SDVariable updates)` Scatter addition operation. If indices is rank 0 (a scalar), then out[index, ...] += updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] += updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] += updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
`SDVariable`	`scatterDiv(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterDiv(String name, SDVariable ref, SDVariable indices, SDVariable updates)` Scatter division operation. If indices is rank 0 (a scalar), then out[index, ...] /= updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] /= updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] /= updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
`SDVariable`	`scatterMax(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterMax(String name, SDVariable ref, SDVariable indices, SDVariable updates)` Scatter max operation. If indices is rank 0 (a scalar), then out[index, ...] = max(updates[...], in[index,...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = max(updates[i,...], in[indices[i],...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = max(updates[i, ..., k, ...], in[indices[i], ..., indices[k], ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
`SDVariable`	`scatterMin(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterMin(String name, SDVariable ref, SDVariable indices, SDVariable updates)` Scatter min operation. If indices is rank 0 (a scalar), then out[index, ...] = min(updates[...], in[index,...]) If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = min(updates[i,...], in[indices[i],...]) If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = min(updates[i, ..., k, ...], in[indices[i], ..., indices[k], ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
`SDVariable`	`scatterMul(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterMul(String name, SDVariable ref, SDVariable indices, SDVariable updates)` Scatter multiplication operation. If indices is rank 0 (a scalar), then out[index, ...] = updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] *= updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
`SDVariable`	`scatterSub(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterSub(String name, SDVariable ref, SDVariable indices, SDVariable updates)` Scatter subtraction operation. If indices is rank 0 (a scalar), then out[index, ...] -= updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] -= updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] -= updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
`SDVariable`	`scatterUpdate(SDVariable ref, SDVariable indices, SDVariable updates)`
`SDVariable`	`scatterUpdate(String name, SDVariable ref, SDVariable indices, SDVariable updates)` Scatter update operation. If indices is rank 0 (a scalar), then out[index, ...] = updates[...] If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = updates[i, ...] If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = updates[i, ..., k, ...] Note that if multiple indices refer to the same location, the output at those locations is undefined - different updates may occur in different orders
`SDVariable`	`sconv2d(SDVariable[] inputs, Conv2DConfig conv2DConfig)` Separable 2D convolution operation with/without optional bias
`SDVariable`	`sconv2d(String name, SDVariable[] inputs, Conv2DConfig conv2DConfig)` Separable 2D convolution operation with/without optional bias
`SDVariable`	`segmentMax(SDVariable data, SDVariable segmentIds)`
`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] = [max(3,6), max(1,4,9), max(2,8)
`SDVariable`	`segmentMean(SDVariable data, SDVariable segmentIds)`
`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 = [4.5, 4.666, 5] = [mean(3,6), mean(1,4,9), mean(2,8)
`SDVariable`	`segmentMin(SDVariable data, SDVariable segmentIds)`
`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 = [3, 1, 2] = [min(3,6), min(1,4,9), min(2,8)
`SDVariable`	`segmentProd(SDVariable data, SDVariable segmentIds)`
`SDVariable`	`segmentProd(String name, SDVariable data, SDVariable segmentIds)` Segment product operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [18, 36, 16] = [prod(3,6), prod(1,4,9), prod(2,8)
`SDVariable`	`segmentSum(SDVariable data, SDVariable segmentIds)`
`SDVariable`	`segmentSum(String name, SDVariable data, SDVariable segmentIds)` Segment sum operation. If data = [3, 6, 1, 4, 9, 2, 8] segmentIds = [0, 0, 1, 1, 1, 2, 2] then output = [9, 14, 10] = [sum(3,6), sum(1,4,9), sum(2,8)
`SDVariable`	`selu(SDVariable x)` Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0 Uses default lcale and alpha values.
`SDVariable`	`selu(String name, SDVariable x)` Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0 Uses default lcale and alpha values.
`SDVariable`	`separableConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, Conv2DConfig config)` Separable 2D convolution operation without bias
`SDVariable`	`separableConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, SDVariable bias, Conv2DConfig config)` Separable 2D convolution operation with optional bias
`SDVariable`	`sequenceMask(SDVariable lengths)`
`SDVariable`	`sequenceMask(SDVariable lengths, int maxLen)`
`SDVariable`	`sequenceMask(SDVariable lengths, SDVariable maxLen)`
`SDVariable`	`sequenceMask(String name, SDVariable lengths)`
`SDVariable`	`sequenceMask(String name, SDVariable lengths, int maxLen)`
`SDVariable`	`sequenceMask(String name, SDVariable lengths, SDVariable maxLen)` Generate a sequence mask (with values 0 or 1) based on the specified lengths Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)
`void`	`setBaseNameForFunctionInstanceId(String baseName, DifferentialFunction function)` Sets a base name for the function id.
`SDVariable`	`setDiag(SDVariable in, SDVariable diag)`
`SDVariable`	`setDiag(String name, SDVariable in, SDVariable diag)` Set the diagonal value to the specified values If input is [ a, b, c] [ d, e, f] [ g, h, i] and diag = [ 1, 2, 3] then output is [ 1, b, c] [ d, 2, f] [ g, h, 3]
`void`	`setForwardVariableForVarName(String varName, SDVariable forwardVariable)`
`void`	`setGradientForVariableName(String variableName, SDVariable variable)` Assign a SDVariable to represent the gradient of the SDVariable with the specified name
`void`	`setOriginalPlaceHolderShape(String variableName, long[] shape)` Set the original shape for a given place holder. This is used to track original shapes of place holder variables. The reason we track original shapes is to validate possible candidate arrays coming in (especially with -1 as the expected shapes).
`<X extends SDVariable> X`	`setupFunction(X function)` Attempts to insert the `DifferentialFunction` reference in to this `SameDiff` instance.
`SDVariable`	`shannonEntropy(SDVariable in, int... dimensions)` Shannon Entropy reduction: -sum(x * log2(x))
`SDVariable`	`shannonEntropy(String name, SDVariable in, int... dimensions)` Shannon Entropy reduction: -sum(x * log2(x))
`SDVariable`	`shape(SDVariable input)` Returns the shape of the specified SDVariable as a 1D SDVariable
`SDVariable`	`shape(String name, SDVariable input)` Returns the shape of the specified SDVariable as a 1D SDVariable
`boolean`	`shapeAlreadyExistsForVarName(String varName)` Returns true if the given vertex id and shape already exist.
`SDVariable`	`sigmoid(SDVariable x)` Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))
`SDVariable`	`sigmoid(String name, SDVariable x)` Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))
`SDVariable`	`sigmoidCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)` TODO
`SDVariable`	`sigmoidCrossEntropyWithLogits(String name, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)` TODO
`SDVariable`	`sigmoidDerivative(SDVariable x, SDVariable wrt)` Element-wise sigmoid function derivative: dL/dIn given input and dL/dOut
`SDVariable`	`sigmoidDerivative(String name, SDVariable x, SDVariable wrt)` Element-wise sigmoid function derivative: dL/dIn given input and dL/dOut
`SDVariable`	`sign(SDVariable x)` Element-wise sign (signum) function: out = -1 if in < 0 out = 0 if in = 0 out = 1 if in > 0
`SDVariable`	`sign(String name, SDVariable x)` Element-wise sign (signum) function: out = -1 if in < 0 out = 0 if in = 0 out = 1 if in > 0
`SDVariable`	`sin(SDVariable x)` Elementwise sine operation: out = sin(x)
`SDVariable`	`sin(String name, SDVariable x)` Elementwise sine operation: out = sin(x)
`SDVariable`	`sinh(SDVariable x)` Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
`SDVariable`	`sinh(String name, SDVariable x)` Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
`SDVariable`	`size(SDVariable in)` Returns the size (number of elements, i.e., prod(shape)) of the specified SDVariable as a 0D scalar variable
`SDVariable`	`size(String name, SDVariable in)` Returns the size (number of elements, i.e., prod(shape)) of the specified SDVariable as a 0D scalar variable
`SDVariable`	`sizeAt(SDVariable in, int dimension)`
`SDVariable`	`sizeAt(String name, SDVariable in, int dimension)` Returns a rank 0 (scalar) variable for the size of the specified dimension.
`SDVariable`	`slice(SDVariable input, int[] begin, int[] size)`
`SDVariable`	`slice(String name, SDVariable input, int[] begin, int[] size)` Get a subset of the specified input, by specifying the first element and the size of the array. For example, if input is: [a, b, c] [d, e, f] then slice(input, begin=[0,1], size=[2,1] will return: [b] [e] Note that for each dimension i, begin[i] + size[i] <= input.size(i)
`SDVariable`	`softmax(SDVariable x)` Softmax activation
`SDVariable`	`softmax(String name, SDVariable x)` Softmax activation
`SDVariable`	`softmaxCrossEntropyWithLogits(SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)` TODO
`SDVariable`	`softmaxCrossEntropyWithLogits(String name, SDVariable logits, SDVariable weights, SDVariable labels, int reductionMode, double labelSmoothing)` TODO
`SDVariable`	`softmaxDerivative(String name, SDVariable x, SDVariable wrt)`
`SDVariable`	`softmaxDerivative(String name, SDVariable x, SDVariable wrt, Integer dimension)`
`SDVariable`	`softplus(SDVariable x)` Element-wise softplus function: out = log(exp(x) + 1)
`SDVariable`	`softplus(String name, SDVariable x)` Element-wise softplus function: out = log(exp(x) + 1)
`SDVariable`	`softsign(SDVariable x)` Element-wise softsign function: out = x / (abs(x) + 1)
`SDVariable`	`softsign(String name, SDVariable x)` Element-wise softsign function: out = x / (abs(x) + 1)
`SDVariable`	`softsignDerivative(SDVariable x)` Element-wise derivative (dOut/dIn) of the softsign function `softsign(SDVariable)`
`SDVariable`	`softsignDerivative(String name, SDVariable x)` Element-wise derivative (dOut/dIn) of the softsign function `softsign(SDVariable)`
`SDVariable`	`spaceToBatch(SDVariable x, int[] blocks, int[][] padding)`
`SDVariable`	`spaceToBatch(String name, SDVariable x, int[] blocks, int[][] padding)` Convolution 2d layer space to batch operation on 4d input.
`SDVariable`	`spaceToDepth(SDVariable x, int blockSize, String dataFormat)`
`SDVariable`	`spaceToDepth(String name, SDVariable x, int blockSize, String dataFormat)` Convolution 2d layer space to depth operation on 4d input. Increases input channels (reduced spatial dimensions) by rearranging data into a larger channels dimension Example: if input has shape [mb, 2, 4, 4] and block size is 2, then output size is [mb, 8/(22), 22, 2*2] = [mb, 2, 4, 4]
`SDVariable`	`sqrt(SDVariable x)` Element-wise square root function: out = sqrt(x)
`SDVariable`	`sqrt(String name, SDVariable x)` Element-wise square root function: out = sqrt(x)
`SDVariable`	`square(SDVariable x)` Element-wise square function: out = x^2
`SDVariable`	`square(String name, SDVariable x)` Element-wise square function: out = x^2
`SDVariable`	`squaredNorm(SDVariable x, boolean keepDims, int... dimensions)` Squared L2 norm: see `norm2(String, SDVariable, boolean, int...)`
`SDVariable`	`squaredNorm(SDVariable x, int... dimensions)` Squared L2 norm: see `norm2(String, SDVariable, int...)`
`SDVariable`	`squaredNorm(String name, SDVariable x, boolean keepDims, int... dimensions)` Squared L2 norm: see `norm2(String, SDVariable, boolean, int...)`
`SDVariable`	`squaredNorm(String name, SDVariable x, int... dimensions)` Squared L2 norm: see `norm2(String, SDVariable, int...)`
`SDVariable`	`squeeze(SDVariable x, int axis)`
`SDVariable`	`squeeze(String name, SDVariable x, int axis)` Remove a single dimension of size 1.
`SDVariable`	`sru(SRUConfiguration configuration)` Simple recurrent unit
`SDVariable`	`sru(String baseName, SRUConfiguration configuration)` Simiple recurrent unit
`SDVariable`	`sruCell(SRUCellConfiguration configuration)` An sru cell
`SDVariable`	`sruCell(String baseName, SRUCellConfiguration configuration)` An sru cell
`SDVariable`	`stack(int axis, SDVariable... values)`
`SDVariable`	`stack(String name, int axis, SDVariable... values)` Stack a set of N SDVariables of rank X into one rank X+1 variable.
`SDVariable`	`standardDeviation(SDVariable x, boolean biasCorrected, int... dimensions)`
`SDVariable`	`standardDeviation(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)` Stardard deviation array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`standardDeviation(String name, SDVariable x, boolean biasCorrected, int... dimensions)` Stardard deviation array reduction operation, optionally along specified dimensions
`SDVariable`	`step(SDVariable in, double cutoff)` Elementwise step function: out(x) = 1 if x >= cutoff out(x) = 0 otherwise
`SDVariable`	`step(String name, SDVariable in, double cutoff)` Elementwise step function: out(x) = 1 if x >= cutoff out(x) = 0 otherwise
`SDVariable`	`stridedSlice(SDVariable input, int[] begin, int[] end, int[] strides)`
`SDVariable`	`stridedSlice(SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)`
`SDVariable`	`stridedSlice(SDVariable input, long[] begin, long[] end, long[] strides)`
`SDVariable`	`stridedSlice(SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)`
`SDVariable`	`stridedSlice(String name, SDVariable input, int[] begin, int[] end, int[] strides)`
`SDVariable`	`stridedSlice(String name, SDVariable in, int[] begin, int[] end, int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)`
`SDVariable`	`stridedSlice(String name, SDVariable input, long[] begin, long[] end, long[] strides)` Get a subset of the specified input, by specifying the first element, last element, and the strides. For example, if input is: [a, b, c] [d, e, f] [g, h, i] then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1]) will return: [b, c] [h, i]
`SDVariable`	`stridedSlice(String name, SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)` Get a subset of the specified input, by specifying the first element, last element, and the strides. Operates as described in `stridedSlice(SDVariable, long[], long[], long[])` with some extra mask arrays as described below.
`SDVariable`	`sum(SDVariable x, boolean keepDims, int... dimensions)`
`SDVariable`	`sum(SDVariable x, int... dimensions)` Sum array reduction operation, optionally along specified dimensions
`SDVariable`	`sum(String name, SDVariable x, boolean keepDims, int... dimensions)` Sum array reduction operation, optionally along specified dimensions. Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`sum(String name, SDVariable x, int... dimensions)` Sum array reduction operation, optionally along specified dimensions
`String`	`summary()` Generate and return a String representation of the current SameDiff instance Reports variables, ops, SameDiff function instances, and (where possible) array shapes. For ops, the input and output variables are reported. For variables, the ops that they are inputs to - or outputs of - are also reported
`SDVariable`	`swish(SDVariable x)` Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0 See: https://arxiv.org/abs/1710.05941
`SDVariable`	`swish(String name, SDVariable x)` Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0 See: https://arxiv.org/abs/1710.05941
`SDVariable`	`tan(SDVariable x)` Elementwise tangent operation: out = tan(x)
`SDVariable`	`tan(String name, SDVariable x)` Elementwise tangent operation: out = tan(x)
`SDVariable`	`tanh(SDVariable x)` Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
`SDVariable`	`tanh(String name, SDVariable x)` Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
`TensorArrayV3`	`tensorArray()`
`SDVariable`	`tensorMmul(SDVariable x, SDVariable y, int[][] dimensions)`
`SDVariable`	`tensorMmul(String name, SDVariable x, SDVariable y, int[][] dimensions)`
`SDVariable`	`tile(SDVariable x, int[] repeat)`
`SDVariable`	`tile(String name, SDVariable x, int[] repeat)` Repeat (tile) the input tensor the specified number of times. For example, if input is [1, 2] [3, 4] and repeat is [2, 3] then output is [1, 2, 1, 2, 1, 2] [3, 4, 3, 4, 3, 4] [1, 2, 1, 2, 1, 2] [3, 4, 3, 4, 3, 4]
`SDVariable`	`trace(SDVariable in)`
`SDVariable`	`trace(String name, SDVariable in)` Matrix trace operation For rank 2 matrices, the output is a scalar vith the trace - i.e., sum of the main diagonal. For higher rank inputs, output[a,b,c] = trace(in[a,b,c,:,:])
`SDVariable`	`transpose(SDVariable x)` Matrix transpose operation: If input has shape [a,b] output has shape [b,a]
`SDVariable`	`transpose(String name, SDVariable x)` Matrix transpose operation: If input has shape [a,b] output has shape [b,a]
`SDVariable[]`	`unstack(SDVariable value, int axis)`
`SDVariable[]`	`unstack(SDVariable value, int axis, int num)`
`SDVariable[]`	`unstack(String[] names, SDVariable value, int axis)`
`SDVariable[]`	`unstack(String[] names, SDVariable value, int axis, int num)` Unstack a variable of rank X into N rank X-1 variables by taking slices along the specified axis.
`void`	`updateArrayForVarName(String varName, INDArray arr)` Update the INDArray for the given variable.
`void`	`updateShapeForVarName(String varName, long[] shape)` Update a vertex id with the given shape. Note that you should use `putShapeForVarName(String, long[])` if you want to add a new shape.
`void`	`updateShapeForVarName(String varName, long[] shape, boolean clearArrayOnShapeMismatch)` Update a vertex id with the given shape. Note that you should use `putShapeForVarName(String, long[])` if you want to add a new shape.
`void`	`updateVariable(String variableName, INDArray arr)` Update the `INDArray` ndarray for the given variable name
`void`	`updateVariableName(String varName, String withName)` Update the opName for the variable with the given vertex id
`SDVariable`	`updateVariableNameAndReference(SDVariable varToUpdate, String newVarName)` Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.
`SDVariable[]`	`updateVariableNamesAndReferences(SDVariable[] variablesToUpdate, String[] newVariableNames)` Updates the variable name property on the passed in variables, its reference in samediff, and returns the variable.
`SDVariable`	`upsampling2d(SDVariable input, boolean nchw, int scaleH, int scaleW)` 2D Convolution layer operation - Upsampling 2d
`SDVariable`	`upsampling2d(SDVariable input, int scale)` 2D Convolution layer operation - Upsampling 2d with same scale for both dimensions.
`SDVariable`	`upsampling2d(String name, SDVariable input, boolean nchw, int scaleH, int scaleW)` 2D Convolution layer operation - Upsampling 2d
`SDVariable`	`upsampling2d(String name, SDVariable input, int scale)` 2D Convolution layer operation - Upsampling 2d with same scale for both dimensions.
`SDVariable`	`var(INDArray arr)` Create an `SDVariable` with a generated name, and assocate the specified array with it
`SDVariable`	`var(int... shape)` Creates a `SDVariable` with the specified shape and a generated name Any array will be generated with all zeros for the values
`SDVariable`	`var(long... shape)` Creates a `SDVariable` with the specified shape and a generated name Any array will be generated with all zeros for the values
`SDVariable`	`var(SDVariable arr)` Initialize a `SDVariable` reference tying this variable to this samediff instance.
`SDVariable`	`var(String name, INDArray arr)` Create an `SDVariable` with the specified name, and assocate the specified array with it
`SDVariable`	`var(String name, int... shape)` Creates a `SDVariable` with the given shape and name Any array will be generated with all zeros for the values
`SDVariable`	`var(String name, long... shape)` Creates a `SDVariable` with the given shape and name Any array will be generated with all zeros for the values
`SDVariable`	`var(String name, long[] shape, WeightInitScheme weightInitScheme)` Variable initialization with a specified `WeightInitScheme`
`SDVariable`	`var(WeightInitScheme weightInitScheme, long... shape)` Creates a `SDVariable` with the specified shape and a generated name.
`Map<String,SDVariable>`	`variableMap()` Return the internal variable map
`List<SDVariable>`	`variables()` The list of all variables in the graph
`SDVariable`	`variance(SDVariable x, boolean biasCorrected, int... dimensions)`
`SDVariable`	`variance(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)` Variance array reduction operation, optionally along specified dimensions Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.
`SDVariable`	`variance(String name, SDVariable x, boolean biasCorrected, int... dimensions)` Variance array reduction operation, optionally along specified dimensions
`SDVariable`	`weightedCrossEntropyWithLogits(SDVariable targets, SDVariable inputs, SDVariable weights)` TODO
`SDVariable`	`weightedCrossEntropyWithLogits(String name, SDVariable targets, SDVariable inputs, SDVariable weights)` TODO
`While`	`whileStatement(SameDiffConditional sameDiffConditional, SameDiffFunctionDefinition conditionBody, SameDiffFunctionDefinition loopBody, SDVariable[] inputVars)` Creates a while statement
`SDVariable`	`xor(SDVariable x, SDVariable y)` Boolean XOR (exclusive OR) operation: elementwise (x != 0) XOR (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`SDVariable`	`xor(String name, SDVariable x, SDVariable y)` Boolean XOR (exclusive OR) operation: elementwise (x != 0) XOR (y != 0) If x and y arrays have equal shape, the output shape is the same as these inputs. Note: supports broadcasting if x and y have different shapes and are broadcastable. Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
`INDArray`	`yetAnotherExecMethod(Map<String,INDArray> inputs)`
`SDVariable`	`zero(String name, int[] shape)` Create a new variable with the specified shape, with all values initialized to 0
`SDVariable`	`zero(String name, long[] shape)` Create a new variable with the specified shape, with all values initialized to 0
`SDVariable`	`zeroFraction(SDVariable input)` Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
`SDVariable`	`zeroFraction(String name, SDVariable input)` Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
`SDVariable`	`zerosLike(SDVariable input)` Return a variable of all 0s, with the same shape as the input variable.
`SDVariable`	`zerosLike(String name, SDVariable input)` Return a variable of all 0s, with the same shape as the input variable.

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

- Method Detail
  - newCloner
```
public static com.rits.cloning.Cloner newCloner()
```
    Returns:
    
    New cloner object. NOTE: INTENDED FOR DEVELOPER USE ONLY
  - updateVariableName
```
public void updateVariableName(String varName,
                               String withName)
```
    Update the opName for the variable with the given vertex id
    
    Parameters:
    
    varName - the vertex id to update
    
    withName - thew new opName
  - disableDebugging
```
public SameDiff disableDebugging()
```
    Clears debugging state and disables debug mode.
  - enableDebugMode
```
public SameDiff enableDebugMode()
```
    Enables tracing of graphs automatically.
  - f
```
public DifferentialFunctionFactory f()
```
    Returns this samediff instance's DifferentialFunctionFactory
    
    Returns:
  - invokeGraphOn
```
public SDVariable invokeGraphOn(SameDiff sameDiff)
```
    Parameters:
    
    sameDiff -
    
    Returns:
  - functionExists
```
public boolean functionExists(String id)
```
    Returns true if the given function id exists
    
    Parameters:
    
    id - the function id to test for
    
    Returns:
    
    true if the function id exists, false otherwise
  - getFunctionById
```
public DifferentialFunction getFunctionById(String id)
```
    Get the function by the DifferentialFunction#getOwnName()
    
    Parameters:
    
    id - the id of the function
    
    Returns:
    
    the function for the given id if it exists
  - putFunctionForId
```
public void putFunctionForId(String id,
                             DifferentialFunction function)
```
    Put the function for the given id
    
    Parameters:
    
    id - the id of the function
    
    function - the function
  - getInputsForFunction
```
public String[] getInputsForFunction(DifferentialFunction function)
```
    Returns the name(s) of the inputs for the given function
    
    Parameters:
    
    function - the function to get the inputs for
    
    Returns:
    
    the input ids for a given function
  - getOutputsForFunction
```
public String[] getOutputsForFunction(DifferentialFunction function)
```
    Returns the name(s) of the outputs for the given function
    
    Parameters:
    
    function - the function to get the outputs for
    
    Returns:
    
    the outputs ids for a given function
  - getOutputVariablesForFunction
```
public SDVariable[] getOutputVariablesForFunction(DifferentialFunction function)
```
    Get the output variable(s) for the specified differential function
    
    Parameters:
    
    function - the function reference to get the output variable(s) for
    
    Returns:
    
    the output variables for the given function
  - getInputVariablesForFunction
```
public SDVariable[] getInputVariablesForFunction(DifferentialFunction function)
```
    Get the input variable(s) for the specified differential function
    
    Parameters:
    
    function - the function reference to get the input variable(s) for
    
    Returns:
    
    the input variables for the given function
  - updateArrayForVarName
```
public void updateArrayForVarName(String varName,
                                  INDArray arr)
```
    Update the INDArray for the given variable. Note that the array must exist to use this method.
    
    Parameters:
    
    varName - Name of the variable to update the array for
    
    arr - Array to update
    
    Throws:
    
    ND4JIllegalStateException - when the array does not exist.
    
    See Also:
    
    putArrayForVarName(String, INDArray), putOrUpdateShapeForVarName(String, long[], boolean)
  - putArrayForVarName
```
public void putArrayForVarName(String varName,
                               INDArray arr)
```
    Adds an INDArray for a given variable name. Use updateArrayForVarName(String, INDArray) if the array already exists.
    
    Parameters:
    
    varName - the vertex id to add
    
    arr - the array to add
    
    Throws:
    
    ND4JIllegalStateException - when the array already exists.
    
    See Also:
    
    putOrUpdateShapeForVarName(String, long[], boolean)
  - putOrUpdateArrayForVarName
```
public void putOrUpdateArrayForVarName(@NonNull
                                       String varName,
                                       INDArray arr)
```
    Put the array if it does not exist for the given variable name, or update it if it does
    
    Parameters:
    
    varName - Variable name
    
    arr - Array
  - getShapeForVarName
```
public long[] getShapeForVarName(String varName)
```
    Get the shape for the given vertex id. Note that if an array is defined, it will use the shape of the array instead.
    A shape *and* an array should not be defined at the same time. This wastes memory. The internal map used for tracking shapes for particular vertex ids should also delete redundant shapes stored to avoid redundant sources of information.
    
    Parameters:
    
    varName - the vertex id to get the shape for
    
    Returns:
    
    the shape for the given vertex if if any.
  - updateShapeForVarName
```
public void updateShapeForVarName(String varName,
                                  long[] shape)
```
    Update a vertex id with the given shape.
    Note that you should use putShapeForVarName(String, long[]) if you want to add a new shape. Update is meant to be an in place replacement of the shape for the vertex id *only*.
    
    Parameters:
    
    varName - the vertex id to associate
    
    shape - the shape to associate with
    
    See Also:
    
    putShapeForVarName(String, long[]), putOrUpdateShapeForVarName(String, long[], boolean)
  - updateShapeForVarName
```
public void updateShapeForVarName(String varName,
                                  long[] shape,
                                  boolean clearArrayOnShapeMismatch)
```
    Update a vertex id with the given shape.
    Note that you should use putShapeForVarName(String, long[]) if you want to add a new shape. Update is meant to be an in place replacement of the shape for the vertex id *only*.
    
    Parameters:
    
    varName - the vertex id to associate
    
    shape - the shape to associate with
    
    clearArrayOnShapeMismatch - boolean to indicate whether to clear the variable on shape mismatch
    
    See Also:
    
    putShapeForVarName(String, long[]), putOrUpdateShapeForVarName(String, long[], boolean)
  - putShapeForVarName
```
public void putShapeForVarName(String varName,
                               long[] shape)
```
    Associate a vertex id with the given shape.
    
    Parameters:
    
    varName - the vertex id to associate
    
    shape - the shape to associate with
    
    See Also:
    
    putShapeForVarName(String, long[]), putOrUpdateShapeForVarName(String, long[], boolean)
  - putOrUpdateShapeForVarName
```
public void putOrUpdateShapeForVarName(String varName,
                                       @NonNull
                                       long[] shape,
                                       boolean clearArrayOnShapeMismatch)
```
    Put or update the shape for the given variable name. Optionally supports clearing the specified variable's INDArray if it's shape does not match the new shape
    
    Parameters:
    
    varName - Variable name
    
    shape - Shape to put
    
    clearArrayOnShapeMismatch - If false: no change to arrays. If true: if an INDArray is defined for the specified variable name, it will be removed from the graph (to be later re-generated) if its shape does not match the specified shape
  - shapeAlreadyExistsForVarName
```
public boolean shapeAlreadyExistsForVarName(String varName)
```
    Returns true if the given vertex id and shape already exist.
    
    Parameters:
    
    varName - the vertex id
    
    Returns:
    
    true if the ndarray and vertex id already exist
  - arrayAlreadyExistsForVarName
```
public boolean arrayAlreadyExistsForVarName(String varName)
```
    Returns true if the given vertex id and INDArray already exist.
    
    Parameters:
    
    varName - the vertex id
    
    Returns:
    
    true if a vertex with the given INDArray exists, and it has an INDArray associated with it
  - getArrForVarName
```
public INDArray getArrForVarName(String varName)
```
    Get an INDArray for a given vertex id, or null if none exists
    
    Parameters:
    
    varName - Variable name to get the array for
    
    Returns:
    
    Array, or null if none exists
  - associateArrayWithVariable
```
public void associateArrayWithVariable(INDArray arr,
                                       @NonNull
                                       String variable)
```
    Associate the array with the given variable.
    
    Parameters:
    
    arr - the array to get the variable for
    
    variable - the name of the variable to associate the array with
  - associateArrayWithVariable
```
public void associateArrayWithVariable(INDArray arr,
                                       SDVariable variable)
```
    Associate the array with the given variable.
    
    Parameters:
    
    arr - the array to get the variable for
    
    variable - the variable to associate the array with
  - putSubFunction
```
public void putSubFunction(String name,
                           SameDiff nameSpace)
```
    Associate a SameDiff namespace as a sub function.
    
    Parameters:
    
    name - the opName of the function
    
    nameSpace - the namespace
  - variableMap
```
public Map<String,SDVariable> variableMap()
```
    Return the internal variable map
    
    Returns:
    
    Map of variables by name
  - invoke
```
public SDVariable invoke(Op op,
                         SDVariable x,
                         SDVariable y)
```
    Invoke an op by opName
    
    Parameters:
    
    op - the op
    
    x - the first input
    
    y - the second input
    
    Returns:
    
    the result variable
  - definedFunctionNames
```
public Collection<String> definedFunctionNames()
```
    The set of defined SameDiff function names. SameDiff function instances should not be confused with DifferentialFunction ops; an example of a SameDiff function instance is the gradient "grad" function
    
    Returns:
    
    Set of defined SameDiff function instance names
  - memoryForGraph
```
public long memoryForGraph()
```
    Returns the number of bytes for the graph. Calculated as sum_i prod(shapeOf(variable[i]))
    
    Returns:
    
    Bytes for all of the arrays in the graph for the current variable shapes
  - invoke
```
public SDVariable invoke(Op op,
                         SDVariable x)
```
    Invoke an op by opName
    
    Parameters:
    
    op - the op
    
    x - the first input
    
    Returns:
    
    the result variable
  - addPropertyToResolve
```
public void addPropertyToResolve(DifferentialFunction forFunction,
                                 String arrayName)
```
    Adds a property that needs to be resolve for later. These variables are typically values that are arrays that are named but have an unknown value till execution time.
    This is very common for model import.
    
    Parameters:
    
    forFunction - the function to add the property to resolve for
    
    arrayName - the array name
  - propertiesToResolveForFunction
```
public List<String> propertiesToResolveForFunction(DifferentialFunction function)
```
    Return the properties to resolve for the given function. This is typically used right before execution in model import in DifferentialFunction.resolvePropertiesFromSameDiffBeforeExecution()
    
    Parameters:
    
    function - the function get the properties to resolve for
    
    Returns:
    
    the properties to resolve for the given function
  - hasPropertiesToResolve
```
public boolean hasPropertiesToResolve(DifferentialFunction function)
```
    Returns true if the given function has ndarray properties to resolve.
    
    Parameters:
    
    function - the function to check
    
    Returns:
    
    true if the function has yet to be resolved properties
  - getPropertyForFunction
```
public <T> T getPropertyForFunction(DifferentialFunction functionInstance,
                                    String propertyName)
```
    Get the property for a given function
    
    Type Parameters:
    
    T - the inferred return type
    
    Parameters:
    
    functionInstance - the function to get the property for
    
    propertyName - the name of the property to get
    
    Returns:
    
    the property for the given function
  - addPropertyForFunction
```
public void addPropertyForFunction(DifferentialFunction functionFor,
                                   String propertyName,
                                   INDArray property)
```
    Add a property for the given function
    
    Parameters:
    
    functionFor - the function add a property for
    
    propertyName - the property name
    
    property - the property value
  - addPropertyForFunction
```
public void addPropertyForFunction(DifferentialFunction functionFor,
                                   String propertyName,
                                   long property)
```
    Add a property for the given function
    
    Parameters:
    
    functionFor - the function to add the property for
    
    propertyName - the name of the property to add the value for
    
    property - the property value to add
  - addVariableMappingForField
```
public void addVariableMappingForField(DifferentialFunction function,
                                       String fieldName,
                                       String varName)
```
    Adds a field name -> variable name mapping for a given function.
    This is used for model import where there is an unresolved variable at the time of calling any GraphMapper.importGraph(File) .
    This data structure is typically accessed during DifferentialFunction.resolvePropertiesFromSameDiffBeforeExecution()
    When a function attempts to resolve variables right before execution, there needs to be a way of knowing which variable in a samediff graph should map to a function's particular field name
    
    Parameters:
    
    function - the function to map
    
    fieldName - the field name for the function to map
    
    varName - the variable name of the array to get from samediff
  - getVarNameForFieldAndFunction
```
public String getVarNameForFieldAndFunction(DifferentialFunction function,
                                            String fieldName)
```
    Get the variable name to use for resolving a given field for a given function during import time. This method is u sed during DifferentialFunction.resolvePropertiesFromSameDiffBeforeExecution()
    
    Parameters:
    
    function - the function to get the variable name for
    
    fieldName - the field name to resolve for
    
    Returns:
    
    the resolve variable name if any
  - isImportVariable
```
public boolean isImportVariable(String variableName)
```
    Returns true if the variable name is imported
    
    Parameters:
    
    variableName - the imported variable name
    
    Returns:
    
    true if the name is imported, false otherwise
  - addVarNameForImport
```
public void addVarNameForImport(String varName)
```
    Marks a variable name as imported. This is used in conjunction with model import to ensure immutability when referencing graph variables mapped from an external source.
    
    Parameters:
    
    varName - the var name to add.
  - setBaseNameForFunctionInstanceId
```
public void setBaseNameForFunctionInstanceId(String baseName,
                                             DifferentialFunction function)
```
    Sets a base name for the function id. This is used for when calling generateOutputVariableForOp(DifferentialFunction, String) for ensuring original names for model import map to current samediff names when names are generated.
    
    Parameters:
    
    baseName - the base name to add
    
    function - the function to declare a base name for.
  - getBaseNameForFunction
```
public String getBaseNameForFunction(DifferentialFunction function)
```
    Returns the base name for the given function if any (may return null)
    
    Parameters:
    
    function - the function to get the base name for
    
    Returns:
    
    the base name for the given function (if any) based on the function's instance id.
  - setupFunction
```
public <X extends SDVariable> X setupFunction(X function)
```
    Attempts to insert the DifferentialFunction reference in to this SameDiff instance. If the given array field with the given index already exists, it will do a reference check to ensure that the 2 array fields are the same. If not, an exception is thrown.
    If the instances are the same (by semantics, not reference) then it will just return the original instance. This is to ensure that instances that are created are unique and reference checked.
    
    Parameters:
    
    function - the array field to attempt to create
    
    Returns:
    
    Original instance
  - addOutgoingFor
```
public void addOutgoingFor(SDVariable[] variables,
                           DifferentialFunction function)
```
    Adds outgoing arguments to the graph for the specified DifferentialFunction Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.
    
    Parameters:
    
    variables - Variables - arguments for the specified differential function
    
    function - Differential function
  - addOutgoingFor
```
public void addOutgoingFor(String[] varNames,
                           DifferentialFunction function)
```
    Adds outgoing arguments to the graph for the specified DifferentialFunction Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.
    
    Parameters:
    
    varNames - Name of the variables that are outputs of the specified differential function
    
    function - Differential function
  - addArgsFor
```
public void addArgsFor(String[] variables,
                       DifferentialFunction function)
```
    Adds incoming arguments for the specified differential function to the graph
    
    Parameters:
    
    variables - Name of the variables that are arguments (inputs) to the specified function
    
    function - Function
  - addArgsFor
```
public void addArgsFor(SDVariable[] variables,
                       DifferentialFunction function)
```
    Adds incoming arguments for the specified differential function to the graph
    
    Parameters:
    
    variables - variables that are arguments (inputs) to the specified function
    
    function - Function
  - getVariableOutputFunction
```
public DifferentialFunction getVariableOutputFunction(String variableName)
```
    Get the differential function (if any) that this variable is the output for
    
    Parameters:
    
    variableName - Name of the variable
    
    Returns:
    
    The differential function that this variable is an output of, or null if it is not the output of a function
  - getVariableArgOfFunctions
```
public List<DifferentialFunction> getVariableArgOfFunctions(String variableName)
```
    Return a list of differential functions (if any) that this variable is the input argument for
    
    Parameters:
    
    variableName - Name of the variable
    
    Returns:
    
    The differential functions that this variable is an input argument for, or null if it is not the input to any function
  - hasArgs
```
public boolean hasArgs(DifferentialFunction function)
```
    Returns true if this function already has defined arguments
    
    Parameters:
    
    function - the function to check
    
    Returns:
    
    true if the function has args, false otherwise
  - functions
```
public DifferentialFunction[] functions()
```
    Get an array of differential functions that have been defined for this SameDiff instance
    
    Returns:
    
    Array of differential functions
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - create
```
public static SameDiff create(SameDiff originalSameDiff)
```
    Create a new SameDiff instance from an existing instance. Note that state (variables and functions) is shared between the two SameDiff instance
    
    Parameters:
    
    originalSameDiff - Original SameDiff instance
    
    Returns:
    
    Copy
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - create
```
public static SameDiff create()
```
    Create a new (empty) SameDiff instance without any functions or variables
    
    Returns:
    
    New SameDiff instance
  - eval
```
public INDArray[] eval(Map<String,INDArray> inputs)
```
    Evaluate the given inputs based on the current graph
    
    Parameters:
    
    inputs - the inputs to evaluate
    
    Returns:
  - dup
```
public SameDiff dup()
```
    Clone/duplicate the SameDiff instance, including arrays etc. The returned SameDiff instance should have no shared state with the original instance
    
    Returns:
    
    The cloned SameDiff instance
  - numElements
```
public long numElements()
```
    Count the number of elements in all arrays, according to SDVariable.getShape()
    
    Returns:
    
    Number of array elements for all variables
  - variables
```
public List<SDVariable> variables()
```
    The list of all variables in the graph
    
    Returns:
    
    All variables in the graph
  - one
```
public SDVariable one(String name,
                      int[] shape)
```
    Create a new variable with the specified shape, with all values initialized to 1.0
    
    Parameters:
    
    name - the name of the variable to create
    
    shape - the shape of the array to be created
    
    Returns:
    
    the created variable
  - one
```
public SDVariable one(String name,
                      long[] shape)
```
    Create a new variable with the specified shape, with all values initialized to 1.0
    
    Parameters:
    
    name - the name of the variable to create
    
    shape - the shape of the array to be created
    
    Returns:
    
    the created variable
  - 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 SDVariable
    
    Returns:
    
    A new SDVariable with the same (dynamic) shape as the input
  - 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 of the new SDVariable
    
    input - Input SDVariable
    
    Returns:
    
    A new SDVariable with the same (dynamic) shape as the input
  - zero
```
public SDVariable zero(String name,
                       long[] shape)
```
    Create a new variable with the specified shape, with all values initialized to 0
    
    Parameters:
    
    name - the name of the variable to create
    
    shape - the shape of the array to be created
    
    Returns:
    
    the created variable
  - zero
```
public SDVariable zero(String name,
                       int[] shape)
```
    Create a new variable with the specified shape, with all values initialized to 0
    
    Parameters:
    
    name - the name of the variable to create
    
    shape - the shape of the array to be created
    
    Returns:
    
    the created variable
  - zerosLike
```
public SDVariable zerosLike(SDVariable input)
```
    Return a variable of all 0s, 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 SDVariable
    
    Returns:
    
    A new SDVariable with the same (dynamic) shape as the input
  - zerosLike
```
public SDVariable zerosLike(String name,
                            SDVariable input)
```
    Return a variable of all 0s, 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 of the new SDVariable
    
    input - Input SDVariable
    
    Returns:
    
    A new SDVariable with the same (dynamic) shape as the input
  - constant
```
public SDVariable constant(SDVariable value,
                           long... shape)
```
    Return a variable of given shape in which all values have a given constant value.
    
    Parameters:
    
    value - constant to set for each value
    
    shape - shape of the variable as long array
    
    Returns:
    
    A new SDVariable of provided shape with constant value.
  - constant
```
public SDVariable constant(String name,
                           SDVariable value,
                           long... shape)
```
    Return a variable of given shape in which all values have a given constant value.
    
    Parameters:
    
    name - Name of the new SDVariable
    
    value - constant to set for each value
    
    shape - shape of the variable as long array
    
    Returns:
    
    A new SDVariable of provided shape with constant value.
  - linspace
```
public SDVariable linspace(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:
    
    start - Start value
    
    stop - Stop value
    
    number - Number of values to generate
    
    Returns:
    
    SDVariable with linearly spaced elements
  - linspace
```
public SDVariable linspace(String name,
                           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 of the new variable
    
    start - Start value
    
    stop - Stop value
    
    number - Number of values to generate
    
    Returns:
    
    SDVariable with linearly spaced elements
  - range
```
public SDVariable range(double from,
                        double to,
                        double step)
```
    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
    
    Returns:
    
    1D SDVariable with the specified values
  - range
```
public SDVariable range(String name,
                        double from,
                        double to,
                        double step)
```
    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 of the new variable
    
    from - Initial/smallest value
    
    to - Largest value (exclusive)
    
    step - Step size
    
    Returns:
    
    1D SDVariable with the specified values
  - meshgrid
```
public SDVariable[] meshgrid(SDVariable... inputs)
```
    See Also:
    
    meshgrid(List, SDVariable...)
  - meshgrid
```
public SDVariable[] meshgrid(List<String> names,
                             SDVariable... inputs)
```
    Broadcast the 1D input variables onto an n-dimensional grid.
    The resulting variable can be used for example for evaluating functions at all locations on a grid.
    Example:
```
  input1 = [1, 2, 3]
 input2 = [4, 5, 6]
 SDVariable[] out = meshgrid(input1, input2)
 out[0]:
 [ 1, 2, 3]
 [ 1, 2, 3]
 [ 1, 2, 3]

 out[1]:
 [ 4, 4, 4]
 [ 5, 5, 5]
 [ 6, 6, 6]
 
```
    Parameters:
    
    names - List of names for the output variables. Must have exactly N names for N input arrays
    
    inputs - N x 1D input variables
    
    Returns:
    
    an array of exactly N SDVariables (for N inputs), of rank N
  - meshgrid
```
public SDVariable[] meshgrid(List<String> names,
                             boolean cartesian,
                             SDVariable... inputs)
```
    See Also:
    
    meshgrid(List, SDVariable...)
  - var
```
public SDVariable var(String name,
                      long[] shape,
                      WeightInitScheme weightInitScheme)
```
    Variable initialization with a specified WeightInitScheme
    
    Parameters:
    
    name - the name of the variable
    
    shape - the shape of the array to be created
    
    weightInitScheme - the weight initialization scheme
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(String name,
                      long... shape)
```
    Creates a SDVariable with the given shape and name
    Any array will be generated with all zeros for the values
    
    Parameters:
    
    name - the name of the variable
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(String name,
                      int... shape)
```
    Creates a SDVariable with the given shape and name
    Any array will be generated with all zeros for the values
    
    Parameters:
    
    name - the name of the variable
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(SDVariable arr)
```
    Initialize a SDVariable reference tying this variable to this samediff instance.
    NDArraySupplierInitScheme is used to ensure that if the array is allocated anywhere and SameDiff instance to exist as a copy of the variable.
    
    Parameters:
    
    arr -
    
    Returns:
  - var
```
public SDVariable var(int... shape)
```
    Creates a SDVariable with the specified shape and a generated name
    Any array will be generated with all zeros for the values
    
    Parameters:
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(long... shape)
```
    Creates a SDVariable with the specified shape and a generated name
    Any array will be generated with all zeros for the values
    
    Parameters:
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(WeightInitScheme weightInitScheme,
                      long... shape)
```
    Creates a SDVariable with the specified shape and a generated name. The associated array will then be generated using the specified weight initialization scheme
    
    Parameters:
    
    weightInitScheme - The weight initialization scheme to use when generating an INDArray
    
    shape - the shape of the variable
    
    Returns:
    
    the created variable
  - var
```
public SDVariable var(INDArray arr)
```
    Create an SDVariable with a generated name, and assocate the specified array with it
    
    Parameters:
    
    arr - Array to associate with the new variable
    
    Returns:
    
    New SDVariable
    
    See Also:
    
    var(String, INDArray)
  - var
```
public SDVariable var(String name,
                      INDArray arr)
```
    Create an SDVariable with the specified name, and assocate the specified array with it
    
    Parameters:
    
    arr - Array to associate with the new variable
    
    Returns:
    
    New SDVariable with the specified name and array
  - eye
```
public SDVariable eye(int rows)
```
    Generate a square identity matrix with the specified number of rows.
    
    Parameters:
    
    rows - Number of rows (and columns)
    
    Returns:
    
    SDVariable with an identity matrix array
  - eye
```
public SDVariable eye(String name,
                      int rows)
```
    Generate an identity matrix with the specified number of rows and columns.
    
    Parameters:
    
    rows - Number of rows
  - eye
```
public SDVariable eye(int rows,
                      int cols)
```
    See Also:
    
    eye(String, int, int)
  - eye
```
public SDVariable eye(String name,
                      int rows,
                      int cols)
```
    Generate an identity matrix with the specified number of rows and columns Example:
```
  SDVariable eye = eye(3,2)
 eye:
 [ 1, 0]
 [ 0, 1]
 [ 0, 0]
 
```
    Parameters:
    
    name - Name of the new SDVariable
    
    rows - Number of rows
    
    cols - Number of columns
    
    Returns:
    
    SDVaribable identity matrix
  - eye
```
public SDVariable eye(int rows,
                      int cols,
                      int... batchDimension)
```
    see eye(String, int, int, int...)
  - eye
```
public SDVariable eye(String name,
                      int rows,
                      int cols,
                      int... batchDimension)
```
    Generate an identity matrix with the specified number of rows and columns, with optional leading dims
    Example:
    batchShape: [3,3]
    numRows: 2
    numCols: 4
    returns a tensor of shape (3, 3, 2, 4) that consists of 3 * 3 batches of (2,4)-shaped identity matrices:
    1 0 0 0
    0 1 0 0
    
    Parameters:
    
    rows - Number of rows
    
    cols - Number of columns
    
    batchDimension - Batch dimensions. May be null
  - eye
```
public SDVariable eye(String name,
                      SDVariable rows,
                      SDVariable cols,
                      SDVariable batchDimension)
```
    As per eye(String, int, int, int...) bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
  - eye
```
public SDVariable eye(SDVariable rows,
                      SDVariable cols,
                      SDVariable batchDimension)
```
    As per eye(int, int, int...) bit with the number of rows/columns specified as scalar SDVariables, and the batch dimension specified as a 1D SDVariable
  - eye
```
public SDVariable eye(String name,
                      SDVariable rows,
                      SDVariable cols)
```
    As per eye(String, int, int) bit with the number of rows/columns specified as scalar SDVariables
  - eye
```
public SDVariable eye(SDVariable rows,
                      SDVariable cols)
```
    As per eye(int, int) bit with the number of rows/columns specified as scalar SDVariables
  - eye
```
public SDVariable eye(String name,
                      SDVariable rows)
```
    As per eye(String, int) but with the number of rows specified as a scalar SDVariable
  - eye
```
public SDVariable eye(SDVariable rows)
```
    As per eye(int) but with the number of rows specified as a scalar SDVariable
  - removeArgFromFunction
```
public void removeArgFromFunction(String varName,
                                  DifferentialFunction function)
```
    Remove an argument for a function. Note that if this function does not contain the argument, it will just be a no op.
    
    Parameters:
    
    varName - the variable name to remove
    
    function - the function to remove the argument from
  - getVariable
```
public SDVariable getVariable(String name)
```
    Get the variable based on the opName
    
    Parameters:
    
    name - the opName of the variable
    
    Returns:
    
    the variabel instance if there is one
  - getGradForVariable
```
public SDVariable getGradForVariable(String varName)
```
    Get the gradient for the given vertex id
    
    Parameters:
    
    varName - the vertex id
    
    Returns:
    
    the gradient for this variable or null
  - setGradientForVariableName
```
public void setGradientForVariableName(String variableName,
                                       SDVariable variable)
```
    Assign a SDVariable to represent the gradient of the SDVariable with the specified name
    
    Parameters:
    
    variableName - the variable name to assign the gradient variable for
    
    variable - the gradient variable
  - getForwardVariableForVertexId
```
public SDVariable getForwardVariableForVertexId(int vertexId)
```
    Get the forward variable for gradient based on the gradient's vertex id
    
    Parameters:
    
    vertexId - the vertex id
    
    Returns:
    
    the gradient for the variable or null
  - setForwardVariableForVarName
```
public void setForwardVariableForVarName(String varName,
                                         SDVariable forwardVariable)
```
    Parameters:
    
    varName -
    
    forwardVariable -
  - grad
```
public SDVariable grad(String varName)
```
    Get the gradient for the variable with the specified variable name. Note that in order to run this function, execBackwards() must be executed first. All gradient functions are obtained from the results of the execBackwards call.
    
    Parameters:
    
    varName - the variable name to get the gradient variable for.
    
    Returns:
    
    The gradient variable for the specified variable
  - randomUniform
```
public SDVariable randomUniform(double min,
                                double max,
                                SDVariable shape)
```
    See Also:
    
    randomUniform(String, double, double, SDVariable)
  - randomUniform
```
public SDVariable randomUniform(String name,
                                double min,
                                double max,
                                SDVariable shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a uniform distribution, U(min,max)
    See randomUniform(double, double, long...) for the equivalent function where the shape is specified as a long[] instead
    
    Parameters:
    
    name - Name of the new SDVariable
    
    min - Minimum value
    
    max - Maximum value. Must satisfy max >= min
    
    shape - Shape of the new random SDVariable, as a 1D array
    
    Returns:
    
    New SDVariable
  - randomUniform
```
public SDVariable randomUniform(double min,
                                double max,
                                long... shape)
```
    See Also:
    
    randomUniform(String, double, double, long...)
  - randomUniform
```
public SDVariable randomUniform(String name,
                                double min,
                                double max,
                                long... shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a uniform distribution, U(min,max)
    See randomUniform(double, double, long...) for the equivalent function where the shape is specified as a SDVariable instead
    
    Parameters:
    
    name - Name of the new SDVariable
    
    min - Minimum value
    
    max - Maximum value. Must satisfy max >= min
    
    shape - Shape of the new random SDVariable
    
    Returns:
    
    New SDVariable
  - randomNormal
```
public SDVariable randomNormal(double mean,
                               double stddev,
                               SDVariable shape)
```
    See Also:
    
    randomNormal(String, double, double, SDVariable)
  - randomNormal
```
public SDVariable randomNormal(String name,
                               double mean,
                               double stddev,
                               SDVariable shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a Gaussian (normal) distribution, N(mean, stdev)
    See randomNormal(String, double, double, long...) for the equivalent function where the shape is specified as a long[] instead
    
    Parameters:
    
    name - Name of the new SDVariable
    
    mean - Mean value for the random array
    
    stddev - Standard deviation for the random array
    
    shape - Shape of the new random SDVariable, as a 1D array
    
    Returns:
    
    New SDVariable
  - randomNormal
```
public SDVariable randomNormal(double mean,
                               double stddev,
                               long... shape)
```
    See Also:
    
    randomNormal(String, double, double, long...)
  - randomNormal
```
public SDVariable randomNormal(String name,
                               double mean,
                               double stddev,
                               long... shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a Gaussian (normal) distribution, N(mean, stdev)
    See randomNormal(String, double, double, SDVariable) for the equivalent function where the shape is specified as a long[] instead
    
    Parameters:
    
    name - Name of the new SDVariable
    
    mean - Mean value for the random array
    
    stddev - Standard deviation for the random array
    
    shape - Shape of the new random SDVariable
    
    Returns:
    
    New SDVariable
  - randomLogNormal
```
public SDVariable randomLogNormal(double mean,
                                  double stddev,
                                  long... shape)
```
    See Also:
    
    randomLogNormal(String, double, double, long...)
  - randomLogNormal
```
public SDVariable randomLogNormal(String name,
                                  double mean,
                                  double stddev,
                                  long... shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a Log Normal distribution, i.e., log(x) ~ N(mean, stdev)
    
    Parameters:
    
    name - Name of the new SDVariable
    
    mean - Mean value for the random array
    
    stddev - Standard deviation for the random array
    
    shape - Shape of the new random SDVariable
    
    Returns:
    
    New SDVariable
  - randomNormalTruncated
```
public SDVariable randomNormalTruncated(double mean,
                                        double stddev,
                                        long... shape)
```
    See Also:
    
    randomNormalTruncated(String, double, double, long...)
  - randomNormalTruncated
```
public SDVariable randomNormalTruncated(String name,
                                        double mean,
                                        double stddev,
                                        long... shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a Gaussian (normal) distribution, N(mean, stdev). However, any values more than 1 standard deviation from the mean are dropped and re-sampled
    
    Parameters:
    
    name - Name of the new SDVariable
    
    mean - Mean value for the random array
    
    stddev - Standard deviation for the random array
    
    shape - Shape of the new random SDVariable
    
    Returns:
    
    New SDVariable
  - randomBernoulli
```
public SDVariable randomBernoulli(double p,
                                  SDVariable shape)
```
    See Also:
    
    randomBernoulli(String, double, SDVariable)
  - randomBernoulli
```
public SDVariable randomBernoulli(String name,
                                  double p,
                                  SDVariable shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a Bernoulli distribution, with the specified probability. Array values will have value 1 with probability P and value 0 with probability 1-P.
    See randomBernoulli(String, double, long...) for the equivalent function where the shape is specified as a long[] instead
    
    Parameters:
    
    name - Name of the new SDVariable
    
    p - Probability of value 1
    
    shape - Shape of the new random SDVariable, as a 1D array
    
    Returns:
    
    New SDVariable
  - randomBernoulli
```
public SDVariable randomBernoulli(double p,
                                  long... shape)
```
    See Also:
    
    randomBernoulli(String, double, long...)
  - randomBernoulli
```
public SDVariable randomBernoulli(String name,
                                  double p,
                                  long... shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a Bernoulli distribution, with the specified probability. Array values will have value 1 with probability P and value 0 with probability 1-P.
    See randomBernoulli(String, double, SDVariable) for the equivalent function where the shape is specified as a SDVarible instead
    
    Parameters:
    
    name - Name of the new SDVariable
    
    p - Probability of value 1
    
    shape - Shape of the new random SDVariable, as a 1D array
    
    Returns:
    
    New SDVariable
  - randomBinomial
```
public SDVariable randomBinomial(int nTrials,
                                 double p,
                                 long... shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a Binomial distribution, with the specified number of trials and probability.
    
    Parameters:
    
    nTrials - Number of trials parameter for the binomial distribution
    
    p - Probability of success for each trial
    
    shape - Shape of the new random SDVariable, as a 1D array
    
    Returns:
    
    New SDVariable
  - randomBinomial
```
public SDVariable randomBinomial(String name,
                                 int nTrials,
                                 double p,
                                 long... shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a Binomial distribution, with the specified number of trials and probability.
    
    Parameters:
    
    name - Name of the new SDVariable
    
    nTrials - Number of trials parameter for the binomial distribution
    
    p - Probability of success for each trial
    
    shape - Shape of the new random SDVariable, as a 1D array
    
    Returns:
    
    New SDVariable
  - randomExponential
```
public SDVariable randomExponential(double lambda,
                                    SDVariable shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a exponential distribution: P(x) = lambda * exp(-lambda * x)
    
    Parameters:
    
    lambda - Must be > 0
    
    shape - Shape of the output
    
    Returns:
    
    new SDVariable
  - randomExponential
```
public SDVariable randomExponential(String name,
                                    double lambda,
                                    SDVariable shape)
```
    Generate a new random SDVariable, where values are randomly sampled according to a exponential distribution: P(x) = lambda * exp(-lambda * x)
    
    Parameters:
    
    name - Name of the output variable
    
    lambda - Must be > 0
    
    shape - Shape of the new variable
    
    Returns:
    
    new SDVaribale
  - upsampling2d
```
public SDVariable upsampling2d(SDVariable input,
                               int scale)
```
    2D Convolution layer operation - Upsampling 2d with same scale for both dimensions. NCHW input format.
    
    Parameters:
    
    input - Input - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width])
    
    scale - Scale to upsample in both H and W dimensions
    
    Returns:
    
    Upsampled input
  - upsampling2d
```
public SDVariable upsampling2d(String name,
                               SDVariable input,
                               int scale)
```
    2D Convolution layer operation - Upsampling 2d with same scale for both dimensions. NCHW input format.
    
    Parameters:
    
    input - Input - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width])
    
    scale - Scale to upsample in both H and W dimensions
    
    Returns:
    
    Upsampled input
  - upsampling2d
```
public SDVariable upsampling2d(SDVariable input,
                               boolean nchw,
                               int scaleH,
                               int scaleW)
```
    2D Convolution layer operation - Upsampling 2d
    
    Parameters:
    
    input - Input - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    nchw - If true: input is in NCHW (minibatch, channels, height, width) format. False: NHWC format
    
    scaleH - Scale to upsample in height dimension
    
    scaleW - Scale to upsample in width dimension
    
    Returns:
    
    Upsampled input
  - upsampling2d
```
public SDVariable upsampling2d(String name,
                               SDVariable input,
                               boolean nchw,
                               int scaleH,
                               int scaleW)
```
    2D Convolution layer operation - Upsampling 2d
    
    Parameters:
    
    input - Input, in NCHW format
    
    nchw - If true: input is in NCHW (minibatch, channels, height, width) format. False: NHWC format
    
    scaleH - Scale to upsample in height dimension
    
    scaleW - Scale to upsample in width dimension
    
    Returns:
    
    Upsampled input
  - avgPooling2d
```
public SDVariable avgPooling2d(SDVariable input,
                               Pooling2DConfig pooling2DConfig)
```
    2D Convolution layer operation - average pooling 2d
    
    Parameters:
    
    input - the input to average pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    pooling2DConfig - the configuration for
    
    Returns:
    
    Result after applying average pooling on the input
  - avgPooling2d
```
public SDVariable avgPooling2d(String name,
                               SDVariable input,
                               Pooling2DConfig pooling2DConfig)
```
    2D Convolution layer operation - average pooling 2d
    
    Parameters:
    
    name - name of the operation in SameDiff
    
    input - the input to average pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    pooling2DConfig - the configuration
    
    Returns:
    
    Result after applying average pooling on the input
  - maxPooling2d
```
public SDVariable maxPooling2d(SDVariable input,
                               Pooling2DConfig pooling2DConfig)
```
    2D Convolution layer operation - max pooling 2d
    
    Parameters:
    
    input - the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    pooling2DConfig - the configuration
    
    Returns:
    
    Result after applying max pooling on the input
  - maxPooling2d
```
public SDVariable maxPooling2d(String name,
                               SDVariable input,
                               Pooling2DConfig pooling2DConfig)
```
    2D Convolution layer operation - max pooling 2d
    
    Parameters:
    
    name - name of the operation in SameDiff
    
    input - the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    pooling2DConfig - the configuration
    
    Returns:
    
    Result after applying max pooling on the input
  - avgPooling3d
```
public SDVariable avgPooling3d(SDVariable input,
                               Pooling3DConfig pooling3DConfig)
```
    3D convolution layer operation - average pooling 3d
    
    Parameters:
    
    input - the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels])
    
    pooling3DConfig - the configuration
    
    Returns:
    
    Result after applying average pooling on the input
  - avgPooling3d
```
public SDVariable avgPooling3d(String name,
                               SDVariable input,
                               Pooling3DConfig pooling3DConfig)
```
    3D convolution layer operation - average pooling 3d
    
    Parameters:
    
    name - name of the operation in SameDiff
    
    input - the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels])
    
    pooling3DConfig - the configuration
    
    Returns:
    
    Result after applying average pooling on the input
  - maxPooling3d
```
public SDVariable maxPooling3d(SDVariable input,
                               Pooling3DConfig pooling3DConfig)
```
    3D convolution layer operation - max pooling 3d operation.
    
    Parameters:
    
    input - the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels])
    
    pooling3DConfig - the configuration
    
    Returns:
    
    Result after applying max pooling on the input
  - maxPooling3d
```
public SDVariable maxPooling3d(String name,
                               SDVariable input,
                               Pooling3DConfig pooling3DConfig)
```
    3D convolution layer operation - max pooling 3d operation.
    
    Parameters:
    
    name - name of the operation in SameDiff
    
    input - the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels])
    
    pooling3DConfig - the configuration
    
    Returns:
    
    Result after applying max pooling on the input
  - conv1d
```
public SDVariable conv1d(SDVariable input,
                         SDVariable weights,
                         Conv1DConfig conv1DConfig)
```
    1D Convolution layer operation - Conv1d
    
    Parameters:
    
    input - the input array/activations for the conv1d op
    
    weights - weights for conv1d op
    
    conv1DConfig - the configuration
    
    Returns:
  - conv1d
```
public SDVariable conv1d(String name,
                         SDVariable input,
                         SDVariable weights,
                         Conv1DConfig conv1DConfig)
```
    Conv1d operation.
    
    Parameters:
    
    name - name of the operation in SameDiff
    
    input - the inputs to conv1d
    
    weights - weights for conv1d op
    
    conv1DConfig - the configuration
    
    Returns:
  - localResponseNormalization
```
public SDVariable localResponseNormalization(SDVariable inputs,
                                             LocalResponseNormalizationConfig lrnConfig)
```
    2D convolution layer operation - local response normalization
    
    Parameters:
    
    inputs - the inputs to lrn
    
    lrnConfig - the configuration
    
    Returns:
  - localResponseNormalization
```
public SDVariable localResponseNormalization(String name,
                                             SDVariable input,
                                             LocalResponseNormalizationConfig lrnConfig)
```
    2D convolution layer operation - local response normalization
    
    Parameters:
    
    name - name of the operation in SameDiff
    
    input - the inputs to lrn
    
    lrnConfig - the configuration
    
    Returns:
  - conv2d
```
public SDVariable conv2d(SDVariable layerInput,
                         SDVariable weights,
                         Conv2DConfig config)
```
    2D Convolution operation (without bias)
    
    Parameters:
    
    layerInput - the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    weights - Weights for the convolution operation. 4 dimensions. If layer input data is in NCHW format, weights should have format [outputChannels, inputChannels, kernelHeight, kernelWidth]. If layer input data is in NHWC format, weight should have format [kernelHeight, kernelWidth, inputChannels, outputChannels]
    
    config - Conv2DConfig configuration
    
    Returns:
    
    result of conv2d op
  - conv2d
```
public SDVariable conv2d(SDVariable layerInput,
                         SDVariable weights,
                         SDVariable bias,
                         Conv2DConfig config)
```
    2D Convolution operation with optional bias
    
    Parameters:
    
    layerInput - the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    weights - Weights for the convolution operation. 4 dimensions. If layer input data is in NCHW format, weights should have format [outputChannels, inputChannels, kernelHeight, kernelWidth]. If layer input data is in NHWC format, weight should have format [kernelHeight, kernelWidth, inputChannels, outputChannels]
    
    bias - Optional 1D bias array with shape [outputChannels]. May be null.
    
    config - Conv2DConfig configuration
    
    Returns:
    
    result of conv2d op
  - conv2d
```
public SDVariable conv2d(SDVariable[] inputs,
                         Conv2DConfig config)
```
    2D Convolution operation with optional bias
    
    Parameters:
    
    inputs - an array with either 2 elements (layerInput, weights) or 3 elements (layerInput, weights, bias) as described in conv2d(SDVariable, SDVariable, SDVariable, Conv2DConfig)
    
    config - Conv2DConfig configuration
    
    Returns:
    
    result of convolution 2d operation
  - conv2d
```
public SDVariable conv2d(String name,
                         SDVariable[] inputs,
                         Conv2DConfig config)
```
    2D Convolution operation with optional bias
    
    Parameters:
    
    name - Name of the output SDVariable
    
    inputs - an array with either 2 elements (layerInput, weights) or 3 elements (layerInput, weights, bias) as described in conv2d(SDVariable, SDVariable, SDVariable, Conv2DConfig)
    
    config - Conv2DConfig configuration
    
    Returns:
    
    result of convolution 2d operation
  - depthWiseConv2d
```
public SDVariable depthWiseConv2d(SDVariable layerInput,
                                  SDVariable depthWeights,
                                  Conv2DConfig config)
```
    Depth-wise 2D convolution operation without bias
    
    Parameters:
    
    layerInput - the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    depthWeights - depth-wise conv 2D weights. 4 dimensions. If layer input data is in NCHW format, weights should have format [outputChannels, inputChannels, kernelHeight, kernelWidth]. If layer input data is in NHWC format, weight should have format [kernelHeight, kernelWidth, inputChannels, outputChannels]
    
    config - Conv2DConfig configuration
    
    Returns:
    
    result of conv2d op
  - depthWiseConv2d
```
public SDVariable depthWiseConv2d(SDVariable layerInput,
                                  SDVariable depthWeights,
                                  SDVariable bias,
                                  Conv2DConfig config)
```
    Depth-wise 2D convolution operation with optional bias
    
    Parameters:
    
    layerInput - the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    depthWeights - depth-wise conv 2D weights. 4 dimensions. If layer input data is in NCHW format, weights should have format [outputChannels, inputChannels, kernelHeight, kernelWidth]. If layer input data is in NHWC format, weight should have format [kernelHeight, kernelWidth, inputChannels, outputChannels]
    
    bias - Optional 1D bias array with shape [outputChannels]. May be null.
    
    config - Conv2DConfig configuration
    
    Returns:
    
    result of depthwise conv2d op
  - depthWiseConv2d
```
public SDVariable depthWiseConv2d(SDVariable[] inputs,
                                  Conv2DConfig depthConv2DConfig)
```
    Depth-wise convolution 2D operation.
    
    Parameters:
    
    inputs - the inputs to depth-wise conv2d. An array with either 2 elements (layerInput, depthWeights) or 3 elements (layerInput, depthWeights, bias) as described in depthWiseConv2d(SDVariable, SDVariable, SDVariable, Conv2DConfig)
    
    depthConv2DConfig - the configuration
    
    Returns:
    
    result of depthwise conv2d op
  - depthWiseConv2d
```
public SDVariable depthWiseConv2d(String name,
                                  SDVariable[] inputs,
                                  Conv2DConfig depthConv2DConfig)
```
    Depth-wise convolution 2D operation.
    
    Parameters:
    
    name - name of the output variable
    
    inputs - the inputs to depth-wise conv2d. An array with either 2 elements (layerInput, depthWeights) or 3 elements (layerInput, depthWeights, bias) as described in depthWiseConv2d(SDVariable, SDVariable, SDVariable, Conv2DConfig)
    
    depthConv2DConfig - the configuration
    
    Returns:
    
    result of depthwise conv2d op
  - separableConv2d
```
public SDVariable separableConv2d(SDVariable layerInput,
                                  SDVariable depthWeights,
                                  SDVariable pointWeights,
                                  Conv2DConfig config)
```
    Separable 2D convolution operation without bias
    
    Parameters:
    
    layerInput - the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    depthWeights - Depth weights, rank 4. If layer input is in NCHW format, depth weights should have format [outputChannels, depthMultiplier, kernelHeight, kernelWidth]. If layer input is in NHWC format, depth weights should have format [kernelHeight, kernelWidth, inputChannels, depthMultiplier]
    
    pointWeights - Point weights, rank 4. If layer input is in NCHW format, point weights should have format [outputChannels, inputChannels*depthMultiplier, 1, 1]. If layer input is in NHWC format, point weights should have format [1, 1, inputChannels*depthMultiplier, outputChannels]
    
    config - Conv2DConfig configuration
    
    Returns:
    
    result of separable convolution 2d operation
  - separableConv2d
```
public SDVariable separableConv2d(SDVariable layerInput,
                                  SDVariable depthWeights,
                                  SDVariable pointWeights,
                                  SDVariable bias,
                                  Conv2DConfig config)
```
    Separable 2D convolution operation with optional bias
    
    Parameters:
    
    layerInput - the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    depthWeights - Depth weights, rank 4. If layer input is in NCHW format, depth weights should have format [outputChannels, depthMultiplier, kernelHeight, kernelWidth]. If layer input is in NHWC format, depth weights should have format [kernelHeight, kernelWidth, inputChannels, depthMultiplier]
    
    pointWeights - Point weights, rank 4. If layer input is in NCHW format, point weights should have format [outputChannels, inputChannels*depthMultiplier, 1, 1]. If layer input is in NHWC format, point weights should have format [1, 1, inputChannels*depthMultiplier, outputChannels]
    
    bias - Optional bias, rank 1 with shape [outputChannels]. May be null.
    
    config - Conv2DConfig configuration
    
    Returns:
    
    result of separable convolution 2d operation
  - sconv2d
```
public SDVariable sconv2d(SDVariable[] inputs,
                          Conv2DConfig conv2DConfig)
```
    Separable 2D convolution operation with/without optional bias
    
    Parameters:
    
    inputs - the inputs to separable conv2 operation. Should be length 3 (layerInput, depthWeights, pointWeights) or length 4 (layerInput, depthWeights, pointWeights, bias) as described in separableConv2d(SDVariable, SDVariable, SDVariable, SDVariable, Conv2DConfig)
    
    conv2DConfig - the configuration
    
    Returns:
    
    result of separable convolution 2d operation
  - sconv2d
```
public SDVariable sconv2d(String name,
                          SDVariable[] inputs,
                          Conv2DConfig conv2DConfig)
```
    Separable 2D convolution operation with/without optional bias
    
    Parameters:
    
    name - name of the output variable
    
    inputs - the inputs to separable conv2 operation. Should be length 3 (layerInput, depthWeights, pointWeights) or length 4 (layerInput, depthWeights, pointWeights, bias) as described in separableConv2d(SDVariable, SDVariable, SDVariable, SDVariable, Conv2DConfig)
    
    conv2DConfig - the configuration
    
    Returns:
    
    result of separable convolution 2d operation
  - deconv2d
```
public SDVariable deconv2d(SDVariable layerInput,
                           SDVariable weights,
                           DeConv2DConfig deconv2DConfig)
```
    2D deconvolution operation without bias
    
    Parameters:
    
    layerInput - the input to deconvolution 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    weights - Weights for the 2d deconvolution operation. 4 dimensions. If layer input data is in NCHW format, weights should have format [inputChannels, outputChannels, kernelHeight, kernelWidth]. If layer input data is in NHWC format, weight should have format [kernelHeight, kernelWidth, outputChannels, inputChannels]
    
    deconv2DConfig - DeConv2DConfig configuration
    
    Returns:
    
    result of deconv2d op
  - deconv2d
```
public SDVariable deconv2d(SDVariable layerInput,
                           SDVariable weights,
                           SDVariable bias,
                           DeConv2DConfig deconv2DConfig)
```
    2D deconvolution operation with optional bias
    
    Parameters:
    
    layerInput - the input to deconvolution 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    weights - Weights for the 2d deconvolution operation. 4 dimensions. If layer input data is in NCHW format, weights should have format [inputChannels, outputChannels, kernelHeight, kernelWidth]. If layer input data is in NHWC format, weight should have format [kernelHeight, kernelWidth, outputChannels, inputChannels]
    
    bias - Optional 1D bias array with shape [outputChannels]. May be null.
    
    deconv2DConfig - DeConv2DConfig configuration
    
    Returns:
    
    result of deconv2d op
  - deconv2d
```
public SDVariable deconv2d(SDVariable[] inputs,
                           DeConv2DConfig deconv2DConfig)
```
    2D deconvolution operation with or without optional bias
    
    Parameters:
    
    inputs - Inputs to the deconvolution 2d operation - input array of length 2 (layerInput, weights) or length 3 (layerInput, weights, bias) as described in deconv2d(SDVariable[], DeConv2DConfig)
    
    deconv2DConfig - the configuration
    
    Returns:
    
    result of deconv2d op
  - deconv2d
```
public SDVariable deconv2d(String name,
                           SDVariable[] inputs,
                           DeConv2DConfig deconv2DConfig)
```
    2D deconvolution operation with or without optional bias
    
    Parameters:
    
    name - Name of the output variable
    
    inputs - Inputs to the deconvolution 2d operation - input array of length 2 (layerInput, weights) or length 3 (layerInput, weights, bias) as described in deconv2d(SDVariable[], DeConv2DConfig)
    
    deconv2DConfig - the configuration
    
    Returns:
    
    result of deconv2d op
  - conv3d
```
public SDVariable conv3d(SDVariable input,
                         SDVariable weights,
                         Conv3DConfig conv3DConfig)
```
    Convolution 3D operation without bias
    
    Parameters:
    
    input - the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels])
    
    weights - Weights for conv3d. Rank 5. If input data is in NCDHW fomat, weights should have shape [outputChannels, inputChannels, kernelDepth, kernelHeight, kernelWidth]. If input data is in NDHWC fomat, weights should have shape [kernelDepth, kernelHeight, kernelWidth, inputChannels, outputChannels].
    
    conv3DConfig - the configuration
    
    Returns:
    
    Conv3d output variable
  - conv3d
```
public SDVariable conv3d(SDVariable input,
                         SDVariable weights,
                         SDVariable bias,
                         Conv3DConfig conv3DConfig)
```
    Convolution 3D operation with optional bias
    
    Parameters:
    
    input - the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels])
    
    weights - Weights for conv3d. Rank 5. If input data is in NCDHW fomat, weights should have shape [outputChannels, inputChannels, kernelDepth, kernelHeight, kernelWidth]. If input data is in NDHWC fomat, weights should have shape [kernelDepth, kernelHeight, kernelWidth, inputChannels, outputChannels].
    
    bias - Optional 1D bias array with shape [outputChannels]. May be null.
    
    conv3DConfig - the configuration
    
    Returns:
    
    Conv3d output variable
  - conv3d
```
public SDVariable conv3d(String name,
                         SDVariable input,
                         SDVariable weights,
                         Conv3DConfig conv3DConfig)
```
    Convolution 3D operation without bias
    
    Parameters:
    
    name - Name of the output variable
    
    input - the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels])
    
    weights - Weights for conv3d. Rank 5. If input data is in NCDHW fomat, weights should have shape [outputChannels, inputChannels, kernelDepth, kernelHeight, kernelWidth]. If input data is in NDHWC fomat, weights should have shape [kernelDepth, kernelHeight, kernelWidth, inputChannels, outputChannels].
    
    conv3DConfig - the configuration
    
    Returns:
    
    Conv3d output variable
  - conv3d
```
public SDVariable conv3d(String name,
                         SDVariable input,
                         SDVariable weights,
                         SDVariable bias,
                         Conv3DConfig conv3DConfig)
```
    Convolution 3D operation with optional bias
    
    Parameters:
    
    name - Name of the output variable
    
    input - the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels])
    
    weights - Weights for conv3d. Rank 5. If input data is in NCDHW fomat, weights should have shape [outputChannels, inputChannels, kernelDepth, kernelHeight, kernelWidth]. If input data is in NDHWC fomat, weights should have shape [kernelDepth, kernelHeight, kernelWidth, inputChannels, outputChannels].
    
    bias - Optional 1D bias array with shape [outputChannels]. May be null.
    
    conv3DConfig - the configuration
    
    Returns:
    
    Conv3d output variable
  - batchNorm
```
public SDVariable batchNorm(SDVariable input,
                            SDVariable mean,
                            SDVariable variance,
                            SDVariable gamma,
                            SDVariable beta,
                            boolean applyGamma,
                            boolean applyBeta,
                            double epsilon)
```
    Batch norm operation.
  - batchNorm
```
public SDVariable batchNorm(String name,
                            SDVariable input,
                            SDVariable mean,
                            SDVariable variance,
                            SDVariable gamma,
                            SDVariable beta,
                            boolean applyGamma,
                            boolean applyBeta,
                            double epsilon)
```
    Batch norm operation.
  - im2Col
```
public SDVariable im2Col(SDVariable in,
                         Conv2DConfig config)
```
    im2col operation for use in 2D convolution operations. Outputs a 6d array with shape [minibatch, inputChannels, kernelHeight, kernelWidth, outputHeight, outputWidth]
    
    Parameters:
    
    in - Input - rank 4 input with shape [minibatch, inputChannels, height, width]
    
    config - Convolution configuration for the im2col operation
    
    Returns:
    
    Im2Col output variable
  - im2Col
```
public SDVariable im2Col(String name,
                         SDVariable in,
                         Conv2DConfig config)
```
    im2col operation for use in 2D convolution operations. Outputs a 6d array with shape [minibatch, inputChannels, kernelHeight, kernelWidth, outputHeight, outputWidth]
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input - rank 4 input with shape [minibatch, inputChannels, height, width]
    
    config - Convolution configuration for the im2col operation
    
    Returns:
    
    Im2Col output variable
  - col2Im
```
public SDVariable col2Im(SDVariable in,
                         Conv2DConfig config)
```
    col2im operation for use in 2D convolution operations. Outputs a 4d array with shape [minibatch, inputChannels, height, width]
    
    Parameters:
    
    in - Input - rank 6 input with shape [minibatch, inputChannels, kernelHeight, kernelWidth, outputHeight, outputWidth]
    
    config - Convolution configuration for the col2im operation
    
    Returns:
    
    Col2Im output variable
  - col2Im
```
public SDVariable col2Im(String name,
                         SDVariable in,
                         Conv2DConfig config)
```
    col2im operation for use in 2D convolution operations. Outputs a 4d array with shape [minibatch, inputChannels, height, width]
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input - rank 6 input with shape [minibatch, inputChannels, kernelHeight, kernelWidth, outputHeight, outputWidth]
    
    config - Convolution configuration for the col2im operation
    
    Returns:
    
    Col2Im output variable
  - scalar
```
public SDVariable scalar(String name,
                         double value)
```
    Create a new scalar (rank 0) SDVariable with the specified value
    
    Parameters:
    
    name - Name of the SDVariable
    
    value - Value to initialize the variable with
    
    Returns:
    
    SDVariable
  - gte
```
public SDVariable gte(SDVariable x,
                      double y)
```
    Greater than or equals operation: elementwise x >= y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - gte
```
public SDVariable gte(String name,
                      SDVariable x,
                      double y)
```
    Greater than or equals operation: elementwise x >= y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - lte
```
public SDVariable lte(SDVariable x,
                      double y)
```
    Less than or equals operation: elementwise x <= y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - lte
```
public SDVariable lte(String name,
                      SDVariable x,
                      double y)
```
    Less than or equals operation: elementwise x <= y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - gt
```
public SDVariable gt(SDVariable x,
                     double y)
```
    Greater than operation: elementwise x > y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - gt
```
public SDVariable gt(String name,
                     SDVariable x,
                     double y)
```
    Greater than operation: elementwise x > y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - lt
```
public SDVariable lt(SDVariable x,
                     double y)
```
    Less than operation: elementwise x < y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - lt
```
public SDVariable lt(String name,
                     SDVariable x,
                     double y)
```
    Less than operation: elementwise x < y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - neq
```
public SDVariable neq(SDVariable x,
                      double y)
```
    Not equals operation: elementwise x != y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - neq
```
public SDVariable neq(String name,
                      SDVariable x,
                      double y)
```
    Not equals operation: elementwise x != y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - eq
```
public SDVariable eq(SDVariable x,
                     double y)
```
    Equals operation: elementwise x == y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - eq
```
public SDVariable eq(String name,
                     SDVariable x,
                     double y)
```
    Equals operation: elementwise x == y
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input array
    
    y - Double value argument to use in operation
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - 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.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - or
```
public SDVariable or(SDVariable x,
                     SDVariable y)
```
    Boolean OR operation: elementwise (x != 0) || (y != 0)
    If x and y arrays have equal shape, the output shape is the same as these inputs.
    Note: supports broadcasting if x and y have different shapes and are broadcastable.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - or
```
public SDVariable or(String name,
                     SDVariable x,
                     SDVariable y)
```
    Boolean OR operation: elementwise (x != 0) || (y != 0)
    If x and y arrays have equal shape, the output shape is the same as these inputs.
    Note: supports broadcasting if x and y have different shapes and are broadcastable.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - and
```
public SDVariable and(SDVariable x,
                      SDVariable y)
```
    Boolean AND operation: elementwise (x != 0) && (y != 0)
    If x and y arrays have equal shape, the output shape is the same as these inputs.
    Note: supports broadcasting if x and y have different shapes and are broadcastable.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - and
```
public SDVariable and(String name,
                      SDVariable x,
                      SDVariable y)
```
    Boolean AND operation: elementwise (x != 0) && (y != 0)
    If x and y arrays have equal shape, the output shape is the same as these inputs.
    Note: supports broadcasting if x and y have different shapes and are broadcastable.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - xor
```
public SDVariable xor(SDVariable x,
                      SDVariable y)
```
    Boolean XOR (exclusive OR) operation: elementwise (x != 0) XOR (y != 0)
    If x and y arrays have equal shape, the output shape is the same as these inputs.
    Note: supports broadcasting if x and y have different shapes and are broadcastable.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - xor
```
public SDVariable xor(String name,
                      SDVariable x,
                      SDVariable y)
```
    Boolean XOR (exclusive OR) operation: elementwise (x != 0) XOR (y != 0)
    If x and y arrays have equal shape, the output shape is the same as these inputs.
    Note: supports broadcasting if x and y have different shapes and are broadcastable.
    Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input 1
    
    y - Input 2
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - abs
```
public SDVariable abs(SDVariable x)
```
    Elementwise absolute value operation: out = abs(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - abs
```
public SDVariable abs(String name,
                      SDVariable x)
```
    Elementwise absolute value operation: out = abs(x)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - neg
```
public SDVariable neg(SDVariable x)
```
    Elementwise negative operation: out = -x
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - neg
```
public SDVariable neg(String name,
                      SDVariable x)
```
    Elementwise negative operation: out = -x
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - cos
```
public SDVariable cos(SDVariable x)
```
    Elementwise cosine operation: out = cos(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - cos
```
public SDVariable cos(String name,
                      SDVariable x)
```
    Elementwise cosine operation: out = cos(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sin
```
public SDVariable sin(SDVariable x)
```
    Elementwise sine operation: out = sin(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sin
```
public SDVariable sin(String name,
                      SDVariable x)
```
    Elementwise sine operation: out = sin(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - tan
```
public SDVariable tan(SDVariable x)
```
    Elementwise tangent operation: out = tan(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - tan
```
public SDVariable tan(String name,
                      SDVariable x)
```
    Elementwise tangent operation: out = tan(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - identity
```
public SDVariable identity(SDVariable input)
```
    Elementwise identity operation: out = x
    
    Parameters:
    
    input - Input variable
    
    Returns:
    
    Output variable
  - identity
```
public SDVariable identity(String name,
                           SDVariable input)
```
    Elementwise identity operation: out = x
    
    Parameters:
    
    name - name of the output variable
    
    input - Input variable
    
    Returns:
    
    Output variable
  - 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
    
    Returns:
    
    1D inverted permutation
  - 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 of the output variable
    
    input - 1D indices for permutation
    
    Returns:
    
    1D inverted permutation
  - acos
```
public SDVariable acos(SDVariable x)
```
    Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - acos
```
public SDVariable acos(String name,
                       SDVariable x)
```
    Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - asin
```
public SDVariable asin(SDVariable x)
```
    Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - asin
```
public SDVariable asin(String name,
                       SDVariable x)
```
    Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - atan
```
public SDVariable atan(SDVariable x)
```
    Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - atan
```
public SDVariable atan(String name,
                       SDVariable x)
```
    Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - atan2
```
public SDVariable atan2(SDVariable y,
                        SDVariable x)
```
    Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y). Similar to atan(y/x) but sigts of x and y are used to determine the the location of the result
    
    Parameters:
    
    y - Input Y variable
    
    x - Input X variable
    
    Returns:
    
    Output variable
  - atan2
```
public SDVariable atan2(String name,
                        SDVariable y,
                        SDVariable x)
```
    Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y). Similar to atan(y/x) but sigts of x and y are used to determine the the location of the result
    
    Parameters:
    
    name - Name of the output variable
    
    y - Input Y variable
    
    x - Input X variable
    
    Returns:
    
    Output variable
  - cosh
```
public SDVariable cosh(SDVariable x)
```
    Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - cosh
```
public SDVariable cosh(String name,
                       SDVariable x)
```
    Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sinh
```
public SDVariable sinh(SDVariable x)
```
    Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sinh
```
public SDVariable sinh(String name,
                       SDVariable x)
```
    Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - tanh
```
public SDVariable tanh(SDVariable x)
```
    Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - tanh
```
public SDVariable tanh(String name,
                       SDVariable x)
```
    Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - step
```
public SDVariable step(SDVariable in,
                       double cutoff)
```
    Elementwise step function:
    out(x) = 1 if x >= cutoff
    out(x) = 0 otherwise
    
    Parameters:
    
    in - Input variable
    
    cutoff - Cutoff value for step function
    
    Returns:
    
    Output variable
  - step
```
public SDVariable step(String name,
                       SDVariable in,
                       double cutoff)
```
    Elementwise step function:
    out(x) = 1 if x >= cutoff
    out(x) = 0 otherwise
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    cutoff - Cutoff value for step function
    
    Returns:
    
    Output variable
  - acosh
```
public SDVariable acosh(SDVariable x)
```
    Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - acosh
```
public SDVariable acosh(String name,
                        SDVariable x)
```
    Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - asinh
```
public SDVariable asinh(SDVariable x)
```
    Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - asinh
```
public SDVariable asinh(String name,
                        SDVariable x)
```
    Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - atanh
```
public SDVariable atanh(SDVariable x)
```
    Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - atanh
```
public SDVariable atanh(String name,
                        SDVariable x)
```
    Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - exp
```
public SDVariable exp(SDVariable x)
```
    Elementwise exponent function: out = exp(x) = 2.71828...^x
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - exp
```
public SDVariable exp(String name,
                      SDVariable x)
```
    Elementwise exponent function: out = exp(x) = 2.71828...^x
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - rsqrt
```
public SDVariable rsqrt(SDVariable x)
```
    Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - rsqrt
```
public SDVariable rsqrt(String name,
                        SDVariable x)
```
    Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - expm1
```
public SDVariable expm1(SDVariable x)
```
    Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - expm1
```
public SDVariable expm1(String name,
                        SDVariable x)
```
    Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - log1p
```
public SDVariable log1p(SDVariable x)
```
    Elementwise natural logarithm function: out = log_e (1 + x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - log1p
```
public SDVariable log1p(String name,
                        SDVariable x)
```
    Elementwise natural logarithm function: out = log_e (1 + x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - round
```
public SDVariable round(SDVariable x)
```
    Elementwise round function: out = round(x). Rounds (up or down depending on value) to the nearest integer value.
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - round
```
public SDVariable round(String name,
                        SDVariable x)
```
    Element-wise round function: out = round(x). Rounds (up or down depending on value) to the nearest integer value.
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - isInfinite
```
public SDVariable isInfinite(SDVariable x)
```
    Is infinite operation: elementwise isInfinite(x)
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isInfinite
```
public SDVariable isInfinite(String name,
                             SDVariable x)
```
    Is infinite operation: elementwise isInfinite(x)
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    name - Output variable name
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isNaN
```
public SDVariable isNaN(SDVariable x)
```
    Is Not a Number operation: elementwise isNaN(x)
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isNaN
```
public SDVariable isNaN(String name,
                        SDVariable x)
```
    Is Not a Number operation: elementwise isNaN(x)
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    name - Output variable name
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isFinite
```
public SDVariable isFinite(SDVariable x)
```
    Is finite operation: elementwise isFinite(x)
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isFinite
```
public SDVariable isFinite(String name,
                           SDVariable x)
```
    Is finite operation: elementwise isFinite(x)
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    name - Output variable name
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isMax
```
public SDVariable isMax(SDVariable x)
```
    Is maximum operation: elementwise x == max(x)
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isMax
```
public SDVariable isMax(String name,
                        SDVariable x)
```
    Is maximum operation: elementwise x == max(x)
    Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwise
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input array
    
    Returns:
    
    Output SDVariable with values 0 and 1 based on where the condition is satisfied
  - isNonDecreasing
```
public SDVariable isNonDecreasing(SDVariable x)
```
    Is the array non decreasing?
    An array is non-decreasing if for every valid i, x[i] <= x[i+1]. For Rank 2+ arrays, values are compared in 'c' (row major) order
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Scalar variable with value 1 if non-decreasing, or 0 otherwise
  - isNonDecreasing
```
public SDVariable isNonDecreasing(String name,
                                  SDVariable x)
```
    Is the array non decreasing?
    An array is non-decreasing if for every valid i, x[i] <= x[i+1]. For Rank 2+ arrays, values are compared in 'c' (row major) order
    
    Parameters:
    
    name - Output name
    
    x - Input variable
    
    Returns:
    
    Scalar variable with value 1 if non-decreasing, or 0 otherwise
  - isStrictlyIncreasing
```
public SDVariable isStrictlyIncreasing(SDVariable x)
```
    Is the array strictly increasing?
    An array is strictly increasing if for every valid i, x[i] < x[i+1]. For Rank 2+ arrays, values are compared in 'c' (row major) order
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Scalar variable with value 1 if strictly increasing, or 0 otherwise
  - isStrictlyIncreasing
```
public SDVariable isStrictlyIncreasing(String name,
                                       SDVariable x)
```
    Is the array strictly increasing?
    An array is strictly increasing if for every valid i, x[i] < x[i+1]. For Rank 2+ arrays, values are compared in 'c' (row major) order
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Scalar variable with value 1 if strictly increasing, or 0 otherwise
  - 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
    
    Returns:
    
    Scalar variable with value 1
  - 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 - Output variable name
    
    x - Input variable
    
    Returns:
    
    Scalar variable with value 1
  - 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
    
    from - Replacement values array (used conditionally). Must be same shape as 'update' array
    
    condition - Condition to check on update array elements
    
    Returns:
    
    New array with values replaced where condition is satisfied
  - 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 of the output variable
    
    update - Source array
    
    from - Replacement values array (used conditionally). Must be same shape as 'update' array
    
    condition - Condition to check on update array elements
    
    Returns:
    
    New array with values replaced where condition is satisfied
  - replaceWhere
```
public SDVariable replaceWhere(SDVariable update,
                               Number 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
    
    value - Value to set at the output, if the condition is satisfied
    
    condition - Condition to check on update array elements
    
    Returns:
    
    New array with values replaced where condition is satisfied
  - replaceWhere
```
public SDVariable replaceWhere(String name,
                               SDVariable update,
                               Number 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 of the output variable
    
    update - Source array
    
    value - Value to set at the output, if the condition is satisfied
    
    condition - Condition to check on update array elements
    
    Returns:
    
    New array with values replaced where condition is satisfied
  - log
```
public SDVariable log(SDVariable x)
```
    Element-wise logarithm function (base e - natural logarithm): out = log(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - log
```
public SDVariable log(String name,
                      SDVariable x)
```
    Element-wise logarithm function (base e - natural logarithm): out = log(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - log
```
public SDVariable log(SDVariable in,
                      double base)
```
    Element-wise logarithm function (with specified base): out = log_{base}(x)
    
    Parameters:
    
    in - Input variable
    
    base - Logarithm base
    
    Returns:
    
    Output variable
  - log
```
public SDVariable log(String name,
                      SDVariable in,
                      double base)
```
    Element-wise logarithm function (with specified base): out = log_{base}(x)
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    base - Logarithm base
    
    Returns:
    
    Output variable
  - logSumExp
```
public SDVariable logSumExp(SDVariable input,
                            int... dimensions)
```
    Log-sum-exp reduction (optionally along dimension). Computes log(sum(exp(x))
    
    Parameters:
    
    input - Input variable
    
    dimensions - Optional dimensions to reduce along
    
    Returns:
    
    Output variable
  - logSumExp
```
public SDVariable logSumExp(String name,
                            SDVariable input,
                            int... dimensions)
```
    Log-sum-exp reduction (optionally along dimension). Computes log(sum(exp(x))
    
    Parameters:
    
    name - Name of the output variable
    
    input - Input variable
    
    dimensions - Optional dimensions to reduce along
    
    Returns:
    
    Output variable
  - cube
```
public SDVariable cube(SDVariable x)
```
    Element-wise cube function: out = x^3
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - cube
```
public SDVariable cube(String name,
                       SDVariable x)
```
    Element-wise cube function: out = x^3
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - pow
```
public SDVariable pow(SDVariable x,
                      double value)
```
    Element-wise power function: out = x^value
    
    Parameters:
    
    x - Input variable
    
    value - Power to raise each element to
    
    Returns:
    
    Output variable
  - pow
```
public SDVariable pow(String name,
                      SDVariable x,
                      double value)
```
    Element-wise power function: out = x^value
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    value - Power to raise each element to
    
    Returns:
    
    Output variable
  - sqrt
```
public SDVariable sqrt(SDVariable x)
```
    Element-wise square root function: out = sqrt(x)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sqrt
```
public SDVariable sqrt(String name,
                       SDVariable x)
```
    Element-wise square root function: out = sqrt(x)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - square
```
public SDVariable square(SDVariable x)
```
    Element-wise square function: out = x^2
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - square
```
public SDVariable square(String name,
                         SDVariable x)
```
    Element-wise square function: out = x^2
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - floor
```
public SDVariable floor(SDVariable x)
```
    Element-wise floor function: out = floor(x). Rounds each value down to the nearest integer value (if not already an integer)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - floor
```
public SDVariable floor(String name,
                        SDVariable x)
```
    Element-wise floor function: out = floor(x). Rounds each value down to the nearest integer value (if not already an integer)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - ceil
```
public SDVariable ceil(SDVariable x)
```
    Element-wise ceiling function: out = ceil(x). Rounds each value up to the nearest integer value (if not already an integer)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - ceil
```
public SDVariable ceil(String name,
                       SDVariable x)
```
    Element-wise ceiling function: out = ceil(x). Rounds each value up to the nearest integer value (if not already an integer)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - clipByValue
```
public SDVariable clipByValue(SDVariable x,
                              double clipValueMin,
                              double clipValueMax)
```
    Element-wise clipping function:
    out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax
    out[i] = clipValueMin if in[i] < clipValueMin
    out[i] = clipValueMax if in[i] > clipValueMax
    
    Parameters:
    
    x - Input variable
    
    clipValueMin - Minimum value for clipping
    
    clipValueMax - Maximum value for clipping
    
    Returns:
    
    Output variable
  - clipByValue
```
public SDVariable clipByValue(String name,
                              SDVariable x,
                              double clipValueMin,
                              double clipValueMax)
```
    Element-wise clipping function:
    out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax
    out[i] = clipValueMin if in[i] < clipValueMin
    out[i] = clipValueMax if in[i] > clipValueMax
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    clipValueMin - Minimum value for clipping
    
    clipValueMax - Maximum value for clipping
    
    Returns:
    
    Output variable
  - clipByNorm
```
public SDVariable clipByNorm(SDVariable x,
                             double clipValue)
```
    Clipping by L2 norm
    if l2Norm(x) < clipValue, then input is returned unmodifed
    Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
    
    Parameters:
    
    x - Input variable
    
    clipValue - Clipping value (maximum l2 norm)
    
    Returns:
    
    Output variable
  - clipByNorm
```
public SDVariable clipByNorm(String name,
                             SDVariable x,
                             double clipValue)
```
    Clipping by L2 norm
    if l2Norm(x) < clipValue, then input is returned unmodifed
    Otherwise, out[i] = in[i] * clipValue / l2Norm(in)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    clipValue - Clipping value (maximum l2 norm)
    
    Returns:
    
    Output variable
  - clipByNorm
```
public SDVariable clipByNorm(SDVariable x,
                             double clipValue,
                             int... dimensions)
```
    Clipping by L2 norm, optionally along dimension(s)
    if l2Norm(x,dimension) < clipValue, then input is returned unmodifed
    Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according to the corresponding l2Norm along the specified dimensions
    
    Parameters:
    
    x - Input variable
    
    clipValue - Clipping value (maximum l2 norm)
    
    dimensions - If not specified, all dimensions are used
    
    Returns:
    
    Output variable
  - clipByNorm
```
public SDVariable clipByNorm(String name,
                             SDVariable x,
                             double clipValue,
                             int... dimensions)
```
    Clipping by L2 norm, optionally along dimension(s)
    if l2Norm(x,dimension) < clipValue, then input is returned unmodifed
    Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according to the corresponding l2Norm along the specified dimensions
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    clipValue - Clipping value (maximum l2 norm)
    
    dimensions - If not specified, all dimensions are used
    
    Returns:
    
    Output variable
  - relu
```
public SDVariable relu(SDVariable x,
                       double cutoff)
```
    Element-wise rectified linear function with specified cutoff:
    out[i] = in[i] if in[i] >= cutoff out[i] = 0 otherwise
    
    Parameters:
    
    x - Input variable
    
    cutoff - Cutoff value. Usually 0
    
    Returns:
    
    Output variable
  - relu
```
public SDVariable relu(String name,
                       SDVariable x,
                       double cutoff)
```
    Element-wise rectified linear function with specified cutoff:
    out[i] = in[i] if in[i] >= cutoff out[i] = 0 otherwise
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    cutoff - Cutoff value. Usually 0
    
    Returns:
    
    Output variable
  - relu6
```
public SDVariable relu6(SDVariable x,
                        double cutoff)
```
    Element-wise "rectified linear 6" function with specified cutoff:
    out[i] = min(max(in, cutoff), 6)
    
    Parameters:
    
    x - Input variable
    
    cutoff - Cutoff value. Usually 0
    
    Returns:
    
    Output variable
  - relu6
```
public SDVariable relu6(String name,
                        SDVariable x,
                        double cutoff)
```
    Element-wise "rectified linear 6" function with specified cutoff:
    out[i] = min(max(in, cutoff), 6)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    cutoff - Cutoff value. Usually 0
    
    Returns:
    
    Output variable
  - softmax
```
public SDVariable softmax(SDVariable x)
```
    Softmax activation
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - softmax
```
public SDVariable softmax(String name,
                          SDVariable x)
```
    Softmax activation
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - logSoftmax
```
public SDVariable logSoftmax(SDVariable x)
```
    Log softmax activation
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - logSoftmax
```
public SDVariable logSoftmax(String name,
                             SDVariable x)
```
    Log softmax activation
    
    Parameters:
    
    name - Variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - selu
```
public SDVariable selu(SDVariable x)
```
    Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks
    out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0
    Uses default lcale and alpha values.
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - selu
```
public SDVariable selu(String name,
                       SDVariable x)
```
    Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks
    out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0
    Uses default lcale and alpha values.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - mergeAdd
```
public SDVariable mergeAdd(SDVariable... x)
```
    Merge add function: merges an arbitrary number of equal shaped arrays using elementwise addition: out = sum_i in[i]
    
    Parameters:
    
    x - Input variables
    
    Returns:
    
    Output variable
  - mergeAdd
```
public SDVariable mergeAdd(String name,
                           SDVariable... inputs)
```
    Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition: out = sum_i in[i]
    
    Parameters:
    
    name - Name of the output variable
    
    inputs - Input variables
    
    Returns:
    
    Output variable
  - mergeMax
```
public SDVariable mergeMax(SDVariable... x)
```
    Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation: out = max_i in[i]
    
    Parameters:
    
    x - Input variables
    
    Returns:
    
    Output variable
  - mergeMax
```
public SDVariable mergeMax(String name,
                           SDVariable... inputs)
```
    Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation: out = max_i in[i]
    
    Parameters:
    
    inputs - Input variables
    
    Returns:
    
    Output variable
  - mergeAvg
```
public SDVariable mergeAvg(SDVariable... inputs)
```
    Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation: out = mean_i in[i]
    
    Parameters:
    
    inputs - Input variables
    
    Returns:
    
    Output variable
  - mergeAvg
```
public SDVariable mergeAvg(String name,
                           SDVariable... inputs)
```
    Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation: out = mean_i in[i]
    
    Parameters:
    
    name - Name of the output variable
    
    inputs - Input variables
    
    Returns:
    
    Output variable
  - batchToSpace
```
public SDVariable batchToSpace(SDVariable x,
                               int[] blocks,
                               int[][] crops)
```
    See Also:
    
    batchToSpace(String, SDVariable, int[], int[][])
  - batchToSpace
```
public SDVariable batchToSpace(String name,
                               SDVariable x,
                               int[] blocks,
                               int[][] crops)
```
    Convolution 2d layer batch to space operation on 4d input. Reduces input batch dimension by rearranging data into a larger spatial dimensions
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable. 4d input
    
    blocks - Block size, in the height/width dimension
    
    crops - Optional 2d int[] array: values [[crop top, crop bottom], [crop left, crop right]]
    
    Returns:
    
    Output variable
    
    See Also:
    
    spaceToBatch(String, SDVariable, int[], int[][])
  - depthToSpace
```
public SDVariable depthToSpace(SDVariable x,
                               int blockSize,
                               String dataFormat)
```
    Convolution 2d layer batch to space operation on 4d input.
    Reduces input channels dimension by rearranging data into a larger spatial dimensions
    Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2] = [mb, 2, 4, 4]
    
    Parameters:
    
    x - the input to depth to space pooling 2d operation - 4d activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    blockSize - Block size, in the height/width dimension
    
    dataFormat - Data format: "NCHW" or "NHWC"
    
    Returns:
    
    Output variable
  - depthToSpace
```
public SDVariable depthToSpace(String name,
                               SDVariable x,
                               int blockSize,
                               String dataFormat)
```
    Convolution 2d layer batch to space operation on 4d input.
    Reduces input channels dimension by rearranging data into a larger spatial dimensions
    Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2] = [mb, 2, 4, 4]
    
    Parameters:
    
    name - Output variable name
    
    x - the input to depth to space pooling 2d operation - 4d activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    blockSize - Block size, in the height/width dimension
    
    dataFormat - Data format: "NCHW" or "NHWC"
    
    Returns:
    
    Output variable
    
    See Also:
    
    depthToSpace(String, SDVariable, int, String)
  - spaceToBatch
```
public SDVariable spaceToBatch(SDVariable x,
                               int[] blocks,
                               int[][] padding)
```
    See Also:
    
    spaceToBatch(String, SDVariable, int[], int[][])
  - spaceToBatch
```
public SDVariable spaceToBatch(String name,
                               SDVariable x,
                               int[] blocks,
                               int[][] padding)
```
    Convolution 2d layer space to batch operation on 4d input. Increases input batch dimension by rearranging data from spatial dimensions into batch dimension
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable. 4d input
    
    blocks - Block size, in the height/width dimension
    
    padding - Optional 2d int[] array for padding the result: values [[pad top, pad bottom], [pad left, pad right]]
    
    Returns:
    
    Output variable
    
    See Also:
    
    batchToSpace(String, SDVariable, int[], int[][])
  - spaceToDepth
```
public SDVariable spaceToDepth(SDVariable x,
                               int blockSize,
                               String dataFormat)
```
    See Also:
    
    spaceToDepth(String, SDVariable, int, String)
  - spaceToDepth
```
public SDVariable spaceToDepth(String name,
                               SDVariable x,
                               int blockSize,
                               String dataFormat)
```
    Convolution 2d layer space to depth operation on 4d input.
    Increases input channels (reduced spatial dimensions) by rearranging data into a larger channels dimension
    Example: if input has shape [mb, 2, 4, 4] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2] = [mb, 2, 4, 4]
    
    Parameters:
    
    name - Output variable name
    
    x - the input to depth to space pooling 2d operation - 4d activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels])
    
    blockSize - Block size, in the height/width dimension
    
    dataFormat - Data format: "NCHW" or "NHWC"
    
    Returns:
    
    Output variable
    
    See Also:
    
    depthToSpace(String, SDVariable, int, String)
  - dynamicPartition
```
public SDVariable[] dynamicPartition(SDVariable x,
                                     SDVariable partitions,
                                     int numPartitions)
```
    See Also:
    
    dynamicPartition(String[], SDVariable, SDVariable, int)
  - dynamicPartition
```
public SDVariable[] dynamicPartition(String[] name,
                                     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:
    
    name - Names for the output variables. Length must be equal to numPartitions
    
    x - Input variable
    
    partitions - 1D input with values 0 to numPartitions-1
    
    numPartitions - Number of partitions, >= 1
    
    Returns:
    
    Output variables (equal in number to numPartitions)
  - dynamicStitch
```
public SDVariable dynamicStitch(SDVariable[] indices,
                                SDVariable[] x)
```
    See Also:
    
    dynamicStitch(String, SDVariable[], SDVariable[])
  - 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 of the output variable
    
    indices - Indices to use when merging. Must be >= 1, same length as input variables
    
    x - Input variables.
    
    Returns:
    
    Merged output variable
  - segmentMax
```
public SDVariable segmentMax(SDVariable data,
                             SDVariable segmentIds)
```
    See Also:
    
    segmentMax(String, SDVariable, SDVariable)
  - 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] = [max(3,6), max(1,4,9), max(2,8)
    
    Parameters:
    
    name - Name of the output variable. May be null
    
    data - Data to perform segment max on
    
    segmentIds - Variable for the segment IDs
    
    Returns:
    
    Segment max output
  - segmentMin
```
public SDVariable segmentMin(SDVariable data,
                             SDVariable segmentIds)
```
    See Also:
    
    segmentMin(String, SDVariable, SDVariable)
  - 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 = [3, 1, 2] = [min(3,6), min(1,4,9), min(2,8)
    
    Parameters:
    
    name - Name of the output variable. May be null
    
    data - Data to perform segment max on
    
    segmentIds - Variable for the segment IDs
    
    Returns:
    
    Segment min output
  - segmentMean
```
public SDVariable segmentMean(SDVariable data,
                              SDVariable segmentIds)
```
    See Also:
    
    segmentMean(String, SDVariable, SDVariable)
  - 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 = [4.5, 4.666, 5] = [mean(3,6), mean(1,4,9), mean(2,8)
    
    Parameters:
    
    name - Name of the output variable. May be null
    
    data - Data to perform segment max on
    
    segmentIds - Variable for the segment IDs
    
    Returns:
    
    Segment mean output
  - segmentProd
```
public SDVariable segmentProd(SDVariable data,
                              SDVariable segmentIds)
```
    See Also:
    
    segmentProd(String, SDVariable, SDVariable)
  - segmentProd
```
public SDVariable segmentProd(String name,
                              SDVariable data,
                              SDVariable segmentIds)
```
    Segment product operation.
    If data = [3, 6, 1, 4, 9, 2, 8]
    segmentIds = [0, 0, 1, 1, 1, 2, 2]
    then output = [18, 36, 16] = [prod(3,6), prod(1,4,9), prod(2,8)
    
    Parameters:
    
    name - Name of the output variable. May be null
    
    data - Data to perform segment max on
    
    segmentIds - Variable for the segment IDs
    
    Returns:
    
    Segment product output
  - segmentSum
```
public SDVariable segmentSum(SDVariable data,
                             SDVariable segmentIds)
```
    See Also:
    
    segmentSum(String, SDVariable, SDVariable)
  - segmentSum
```
public SDVariable segmentSum(String name,
                             SDVariable data,
                             SDVariable segmentIds)
```
    Segment sum operation.
    If data = [3, 6, 1, 4, 9, 2, 8]
    segmentIds = [0, 0, 1, 1, 1, 2, 2]
    then output = [9, 14, 10] = [sum(3,6), sum(1,4,9), sum(2,8)
    
    Parameters:
    
    name - Name of the output variable. May be null
    
    data - Data to perform segment max on
    
    segmentIds - Variable for the segment IDs
    
    Returns:
    
    Segment sum output
  - dilation2D
```
public SDVariable dilation2D(SDVariable df,
                             SDVariable weights,
                             int[] strides,
                             int[] rates,
                             boolean isSameMode)
```
    TODO doc string
    
    Parameters:
    
    df -
    
    weights -
    
    strides -
    
    rates -
    
    isSameMode -
    
    Returns:
  - dilation2D
```
public SDVariable dilation2D(String name,
                             SDVariable df,
                             SDVariable weights,
                             int[] strides,
                             int[] rates,
                             boolean isSameMode)
```
    TODO doc string
    
    Parameters:
    
    name -
    
    df -
    
    weights -
    
    strides -
    
    rates -
    
    isSameMode -
    
    Returns:
  - shape
```
public SDVariable shape(SDVariable input)
```
    Returns the shape of the specified SDVariable as a 1D SDVariable
    
    Parameters:
    
    input - Input variable
    
    Returns:
    
    1D output variable with contents equal to the shape of the input
  - shape
```
public SDVariable shape(String name,
                        SDVariable input)
```
    Returns the shape of the specified SDVariable as a 1D SDVariable
    
    Parameters:
    
    name - Name of the output variable
    
    input - Input variable
    
    Returns:
    
    1D output variable with contents equal to the shape of the input
  - size
```
public SDVariable size(SDVariable in)
```
    Returns the size (number of elements, i.e., prod(shape)) of the specified SDVariable as a 0D scalar variable
    
    Parameters:
    
    in - Input variable
    
    Returns:
    
    0D (scalar) output variable with value equal to the number of elements in the specified array
  - size
```
public SDVariable size(String name,
                       SDVariable in)
```
    Returns the size (number of elements, i.e., prod(shape)) of the specified SDVariable as a 0D scalar variable
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    Returns:
    
    0D (scalar) output variable with value equal to the number of elements in the specified array
  - rank
```
public SDVariable rank(SDVariable in)
```
    Returns the rank (number of dimensions, i.e., length(shape)) of the specified SDVariable as a 0D scalar variable
    
    Parameters:
    
    in - Input variable
    
    Returns:
    
    0D (scalar) output variable with value equal to the rank of the input variable
  - rank
```
public SDVariable rank(String name,
                       SDVariable in)
```
    Returns the rank (number of dimensions, i.e., length(shape)) of the specified SDVariable as a 0D scalar variable
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    Returns:
    
    0D (scalar) output variable with value equal to the rank of the input variable
  - sizeAt
```
public SDVariable sizeAt(SDVariable in,
                         int dimension)
```
    See Also:
    
    sizeAt(String, SDVariable, int)
  - sizeAt
```
public SDVariable sizeAt(String name,
                         SDVariable in,
                         int dimension)
```
    Returns a rank 0 (scalar) variable for the size of the specified dimension. For example, if X has shape [10,20,30] then sizeAt(X,1)=20. Similarly, sizeAt(X,-1)=30
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimension - Dimension to get size of
    
    Returns:
    
    Scalar SDVariable for size at specified variable
  - cross
```
public SDVariable cross(SDVariable a,
                        SDVariable b)
```
    See Also:
    
    cross(String, SDVariable, SDVariable)
  - cross
```
public SDVariable cross(String name,
                        SDVariable a,
                        SDVariable b)
```
    Returns the pair-wise cross product of equal size arrays a and b: a x b = ||a||x||b|| sin(theta). Can take rank 1 or above inputs (of equal shapes), but note that the last dimension must have dimension 3
    
    Parameters:
    
    a - First input
    
    b - Second input
    
    Returns:
    
    Element-wise cross product
  - gather
```
public SDVariable gather(SDVariable df,
                         int[] indices,
                         int axis)
```
    See Also:
    
    gather(String, SDVariable, int[], int)
  - 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 of the output variable
    
    df - Input variable
    
    indices - Indices to get
    
    axis - Axis that the indices refer to
    
    Returns:
    
    Output variable with slices pulled from the specified axis
  - gather
```
public SDVariable gather(SDVariable df,
                         SDVariable indices,
                         int axis)
```
    See Also:
    
    gather(String, SDVariable, SDVariable, int)
  - 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 SDVariable values.
    Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.
    
    Parameters:
    
    name - name of the output variable
    
    df - Input variable
    
    indices - Indices to get slices for. Rank 0 or 1 input
    
    axis - Axis that the indices refer to
    
    Returns:
    
    Output variable with slices pulled from the specified axis
  - gatherNd
```
public SDVariable gatherNd(SDVariable df,
                           SDVariable indices)
```
    TODO doc string
    
    Parameters:
    
    df -
    
    indices -
    
    Returns:
  - gatherNd
```
public SDVariable gatherNd(String name,
                           SDVariable df,
                           SDVariable indices)
```
    TODO doc string
    
    Parameters:
    
    name -
    
    df -
    
    indices -
    
    Returns:
  - repeat
```
public SDVariable repeat(SDVariable df,
                         int axis)
```
    See Also:
    
    repeat(String, SDVariable, int)
  - repeat
```
public SDVariable repeat(String name,
                         SDVariable df,
                         int axis)
```
    See Also:
    
    repeat(String, SDVariable, int)
  - stack
```
public SDVariable stack(int axis,
                        SDVariable... values)
```
    See Also:
    
    stack(String, int, SDVariable...)
  - stack
```
public SDVariable stack(String name,
                        int axis,
                        SDVariable... values)
```
    Stack a set of N SDVariables of rank X into one rank X+1 variable. If inputs have shape [a,b,c] then output has shape:
    axis = 0: [N,a,b,c]
    axis = 1: [a,N,b,c]
    axis = 2: [a,b,N,c]
    axis = 3: [a,b,c,N]
    
    Parameters:
    
    name - Name of the output variable
    
    axis - Axis to stack on
    
    values - Input variables to stack. Must have the same shape for all inputs
    
    Returns:
    
    Output variable
    
    See Also:
    
    unstack(String[], SDVariable, int, int)
  - parallel_stack
```
public SDVariable parallel_stack(SDVariable[] values)
```
    See Also:
    
    stack(String, int, SDVariable...)
  - parallel_stack
```
public SDVariable parallel_stack(String name,
                                 SDVariable[] values)
```
    See Also:
    
    stack(String, int, SDVariable...)
  - unstack
```
public SDVariable[] unstack(SDVariable value,
                            int axis)
```
    See Also:
    
    unstack(String[], SDVariable, int, int)
  - unstack
```
public SDVariable[] unstack(String[] names,
                            SDVariable value,
                            int axis)
```
    See Also:
    
    unstack(String[], SDVariable, int, int)
  - unstack
```
public SDVariable[] unstack(SDVariable value,
                            int axis,
                            int num)
```
    See Also:
    
    unstack(String[], SDVariable, int, int)
  - unstack
```
public SDVariable[] unstack(String[] names,
                            SDVariable value,
                            int axis,
                            int num)
```
    Unstack a variable of rank X into N rank X-1 variables by taking slices along the specified axis. If input has shape [a,b,c] then output has shape: axis = 0: [b,c]
    axis = 1: [a,c]
    axis = 2: [a,b]
    
    Parameters:
    
    names - Output variable names. May be null
    
    value - Input variable to unstack
    
    axis - Axis to unstack on
    
    num - Number of output variables
    
    Returns:
    
    Output variables
    
    See Also:
    
    stack(String, int, SDVariable...)
  - erf
```
public SDVariable erf(SDVariable x)
```
    Element-wise Gaussian error function - out = erf(in)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - erf
```
public SDVariable erf(String name,
                      SDVariable x)
```
    Element-wise Gaussian error function - out = erf(in)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - erfc
```
public SDVariable erfc(SDVariable x)
```
    Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - erfc
```
public SDVariable erfc(String name,
                       SDVariable x)
```
    Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - diag
```
public SDVariable diag(SDVariable x)
```
    See Also:
    
    diag(String, SDVariable)
  - diag
```
public SDVariable diag(String name,
                       SDVariable x)
```
    Returns an output variable with diagonal values equal to the specified values; off-diagonal values will be set to 0
    For example, if input = [1,2,3], then output is given by:
    [ 1, 0, 0]
    [ 0, 2, 0]
    [ 0, 0, 3]
    
    Higher input ranks are also supported: if input has shape [a,...,R-1] then output[i,...,k,i,...,k] = input[i,...,k]. i.e., for input rank R, output has rank 2R
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - diagPart
```
public SDVariable diagPart(SDVariable x)
```
    See Also:
    
    diagPart(String, SDVariable)
  - diagPart
```
public SDVariable diagPart(String name,
                           SDVariable x)
```
    Extract the diagonal part from the input array.
    If input is
    [ 1, 0, 0]
    [ 0, 2, 0]
    [ 0, 0, 3]
    then output is [1, 2, 3].
    Supports higher dimensions: in general, out[i,...,k] = in[i,...,k,i,...,k]
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Diagonal part of the input
    
    See Also:
    
    diag(String, SDVariable)
  - setDiag
```
public SDVariable setDiag(SDVariable in,
                          SDVariable diag)
```
    See Also:
    
    setDiag(String, SDVariable, SDVariable)
  - setDiag
```
public SDVariable setDiag(String name,
                          SDVariable in,
                          SDVariable diag)
```
    Set the diagonal value to the specified values
    If input is
    [ a, b, c]
    [ d, e, f]
    [ g, h, i]
    and diag = [ 1, 2, 3] then output is
    [ 1, b, c]
    [ d, 2, f]
    [ g, h, 3]
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    diag - Diagonal
    
    Returns:
    
    Output variable
  - oneHot
```
public SDVariable oneHot(SDVariable indices,
                         int depth)
```
    See Also:
    
    oneHot(String, SDVariable, int)
  - oneHot
```
public SDVariable oneHot(SDVariable indices,
                         int depth,
                         int axis,
                         double on,
                         double off)
```
    See Also:
    
    oneHot(String, SDVariable, int, int, double, double)
  - 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
    
    Parameters:
    
    name - Output variable name
    
    indices - Indices - value 0 to depth-1
    
    depth - Number of classes
    
    Returns:
    
    Output variable
    
    See Also:
    
    oneHot(SDVariable, int, int, double, double)
  - 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 on and off for each entry
    If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth], with out[i, ..., j, in[i,...,j]] = on with other values being set to off
    
    Parameters:
    
    name - Output variable name
    
    indices - Indices - value 0 to depth-1
    
    depth - Number of classes
    
    Returns:
    
    Output variable
  - reciprocal
```
public SDVariable reciprocal(SDVariable a)
```
    Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
    
    Parameters:
    
    a - Input variable
    
    Returns:
    
    Output variable
  - reciprocal
```
public SDVariable reciprocal(String name,
                             SDVariable a)
```
    Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
    
    Parameters:
    
    name - Name of the output variable
    
    a - Input variable
    
    Returns:
    
    Output variable
  - gradientBackwardsMarker
```
public SDVariable gradientBackwardsMarker(SDVariable x)
```
    Intended for internal/developer use
  - gradientBackwardsMarker
```
public SDVariable gradientBackwardsMarker(String name,
                                          SDVariable x)
```
    Intended for internal/developer use
  - hardTanh
```
public SDVariable hardTanh(SDVariable in)
```
    Element-wise hard tanh function:
    out[i] = -1 if in[i] <= -1
    out[1] = in[i] if -1 < in[i] < 1
    out[i] = 1 if in[i] >= 1
    
    Parameters:
    
    in - Input variable
    
    Returns:
    
    Output variable
  - hardTanh
```
public SDVariable hardTanh(String name,
                           SDVariable in)
```
    Element-wise hard tanh function:
    out[i] = -1 if in[i] <= -1
    out[1] = in[i] if -1 < in[i] < 1
    out[i] = 1 if in[i] >= 1
    
    Parameters:
    
    name - Output variable name
    
    in - Input variable
    
    Returns:
    
    Output variable
  - hardSigmoid
```
public SDVariable hardSigmoid(SDVariable in)
```
    Element-wise hard sigmoid function:
    out[i] = 0 if in[i] <= -2.5
    out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5
    out[i] = 1 if in[i] >= 2.5
    
    Parameters:
    
    in - Input variable
    
    Returns:
    
    Output variable
  - hardSigmoid
```
public SDVariable hardSigmoid(String name,
                              SDVariable in)
```
    Element-wise hard sigmoid function:
    out[i] = 0 if in[i] <= -2.5
    out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5
    out[i] = 1 if in[i] >= 2.5
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    Returns:
    
    Output variable
  - hardTanhDerivative
```
public SDVariable hardTanhDerivative(SDVariable x)
```
    Derivative (dOut/dIn) of the element-wise hard Tanh function - hardTanh(SDVariable)
    
    Parameters:
    
    x - Input
    
    Returns:
    
    Output variable
  - hardTanhDerivative
```
public SDVariable hardTanhDerivative(String name,
                                     SDVariable x)
```
    Derivative (dOut/dIn) of the element-wise hard Tanh function - hardTanh(SDVariable)
    
    Parameters:
    
    name - Output variable name
    
    x - Input
    
    Returns:
    
    Output variable
  - sigmoid
```
public SDVariable sigmoid(SDVariable x)
```
    Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))
    
    Parameters:
    
    x - Input Variable
    
    Returns:
    
    Output variable
  - sigmoid
```
public SDVariable sigmoid(String name,
                          SDVariable x)
```
    Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))
    
    Parameters:
    
    name - Output variable name
    
    x - Input Variable
    
    Returns:
    
    Output variable
  - sigmoidDerivative
```
public SDVariable sigmoidDerivative(SDVariable x,
                                    SDVariable wrt)
```
    Element-wise sigmoid function derivative: dL/dIn given input and dL/dOut
    
    Parameters:
    
    x - Input Variable
    
    wrt - Gradient at the output - dL/dOut. Must have same shape as the input
    
    Returns:
    
    Output variable
  - sigmoidDerivative
```
public SDVariable sigmoidDerivative(String name,
                                    SDVariable x,
                                    SDVariable wrt)
```
    Element-wise sigmoid function derivative: dL/dIn given input and dL/dOut
    
    Parameters:
    
    name - Output variable name
    
    x - Input Variable
    
    wrt - Gradient at the output - dL/dOut. Must have same shape as the input
    
    Returns:
    
    Output variable
  - logSigmoid
```
public SDVariable logSigmoid(SDVariable x)
```
    Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))
    
    Parameters:
    
    x - Input Variable
    
    Returns:
    
    Output variable
  - logSigmoid
```
public SDVariable logSigmoid(String name,
                             SDVariable x)
```
    Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input Variable
    
    Returns:
    
    Output variable
  - sign
```
public SDVariable sign(SDVariable x)
```
    Element-wise sign (signum) function:
    out = -1 if in < 0
    out = 0 if in = 0
    out = 1 if in > 0
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - sign
```
public SDVariable sign(String name,
                       SDVariable x)
```
    Element-wise sign (signum) function:
    out = -1 if in < 0
    out = 0 if in = 0
    out = 1 if in > 0
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - softsign
```
public SDVariable softsign(SDVariable x)
```
    Element-wise softsign function: out = x / (abs(x) + 1)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - softsign
```
public SDVariable softsign(String name,
                           SDVariable x)
```
    Element-wise softsign function: out = x / (abs(x) + 1)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - softsignDerivative
```
public SDVariable softsignDerivative(SDVariable x)
```
    Element-wise derivative (dOut/dIn) of the softsign function softsign(SDVariable)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output varible
  - softsignDerivative
```
public SDVariable softsignDerivative(String name,
                                     SDVariable x)
```
    Element-wise derivative (dOut/dIn) of the softsign function softsign(SDVariable)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output varible
  - softplus
```
public SDVariable softplus(SDVariable x)
```
    Element-wise softplus function: out = log(exp(x) + 1)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - softplus
```
public SDVariable softplus(String name,
                           SDVariable x)
```
    Element-wise softplus function: out = log(exp(x) + 1)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - swish
```
public SDVariable swish(SDVariable x)
```
    Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0
    See: https://arxiv.org/abs/1710.05941
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - swish
```
public SDVariable swish(String name,
                        SDVariable x)
```
    Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0
    See: https://arxiv.org/abs/1710.05941
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    Returns:
    
    Output variable
  - elu
```
public SDVariable elu(SDVariable x)
```
    Element-wise exponential linear unit (ELU) function:
    out = x if x > 0
    out = a * (exp(x) - 1) if x <= 0
    with constant a = 1.0
    See: http://arxiv.org/abs/1511.07289
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - elu
```
public SDVariable elu(String name,
                      SDVariable x)
```
    Element-wise exponential linear unit (ELU) function:
    out = x if x > 0
    out = a * (exp(x) - 1) if x <= 0
    with constant a = 1.0
    See: http://arxiv.org/abs/1511.07289
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - eluDerivative
```
public SDVariable eluDerivative(SDVariable x)
```
    Element-wise derivative exponential linear unit (ELU) function, dOut/dIn given input. elu(SDVariable)
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable
  - eluDerivative
```
public SDVariable eluDerivative(String name,
                                SDVariable x)
```
    Element-wise derivative exponential linear unit (ELU) function, dOut/dIn given input. elu(SDVariable)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable
  - leakyRelu
```
public SDVariable leakyRelu(SDVariable x,
                            double alpha)
```
    Element-wise leaky ReLU function:
    out = x if x >= 0.0
    out = alpha * x if x < cutoff
    Alpha value is most commonly set to 0.01
    
    Parameters:
    
    x - Input variable
    
    alpha - Cutoff - usually 0.0
    
    Returns:
    
    Output variable
  - leakyRelu
```
public SDVariable leakyRelu(String name,
                            SDVariable x,
                            double alpha)
```
    Element-wise leaky ReLU function:
    out = x if x >= 0.0
    out = alpha * x if x < cutoff
    Alpha value is most commonly set to 0.01
    
    Parameters:
    
    x - Input variable
    
    alpha - Cutoff - usually 0.0
    
    Returns:
    
    Output variable
  - leakyReluDerivative
```
public SDVariable leakyReluDerivative(String name,
                                      SDVariable x,
                                      double alpha)
```
    Leaky ReLU derivative: dOut/dIn given input.
    See leakyRelu(String, SDVariable, double)
    
    Parameters:
    
    x - Input variable
    
    alpha - Alpha value
    
    Returns:
    
    Output variable
  - mean
```
public SDVariable mean(SDVariable x)
```
    Full array mean reduction operation
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable - scalar
  - mean
```
public SDVariable mean(SDVariable x,
                       int... dimension)
```
    Mean (average) array reduction operation, optionally along specified dimensions
    
    Parameters:
    
    x - Input variable
    
    dimension - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - mean
```
public SDVariable mean(String name,
                       SDVariable x,
                       int... dimension)
```
    Mean (average) array reduction operation, optionally along specified dimensions
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    dimension - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - mean
```
public SDVariable mean(String name,
                       SDVariable x,
                       boolean keepDims,
                       int... dimension)
```
    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 - Output variable name
    
    x - Input variable
    
    keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions
    
    dimension - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - standardDeviation
```
public SDVariable standardDeviation(SDVariable x,
                                    boolean biasCorrected,
                                    int... dimensions)
```
    See Also:
    
    standardDeviation(String, SDVariable, boolean, int...)
  - standardDeviation
```
public SDVariable standardDeviation(String name,
                                    SDVariable x,
                                    boolean biasCorrected,
                                    int... dimensions)
```
    Stardard deviation array reduction operation, optionally along specified dimensions
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    biasCorrected - If true: divide by (N-1) (i.e., sample stdev). If false: divide by N (population stdev)
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - standardDeviation
```
public SDVariable standardDeviation(String name,
                                    SDVariable x,
                                    boolean biasCorrected,
                                    boolean keepDims,
                                    int... dimensions)
```
    Stardard deviation array reduction operation, optionally along specified dimensions
    Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. 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
    
    biasCorrected - If true: divide by (N-1) (i.e., sample stdev). If false: divide by N (population stdev)
    
    keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - variance
```
public SDVariable variance(SDVariable x,
                           boolean biasCorrected,
                           int... dimensions)
```
    See Also:
    
    variance(String, SDVariable, boolean, int...)
  - variance
```
public SDVariable variance(String name,
                           SDVariable x,
                           boolean biasCorrected,
                           int... dimensions)
```
    Variance array reduction operation, optionally along specified dimensions
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    biasCorrected - If true: divide by (N-1) (i.e., sample variable). If false: divide by N (population variance)
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - variance
```
public SDVariable variance(String name,
                           SDVariable x,
                           boolean biasCorrected,
                           boolean keepDims,
                           int... dimensions)
```
    Variance array reduction operation, optionally along specified dimensions
    Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. 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 - Output variable name
    
    x - Input variable
    
    biasCorrected - If true: divide by (N-1) (i.e., sample variable). If false: divide by N (population variance)
    
    keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - entropy
```
public SDVariable entropy(SDVariable in,
                          int... dimensions)
```
    Entropy reduction: -sum(x * log(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null/empty for full array)
    
    Returns:
    
    Output variable
  - entropy
```
public SDVariable entropy(String name,
                          SDVariable in,
                          int... dimensions)
```
    Entropy reduction: -sum(x * log(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null/empty for full array)
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - logEntropy
```
public SDVariable logEntropy(SDVariable in,
                             int... dimensions)
```
    Log entropy reduction: log(-sum(x * log(x)))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null for full array)
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - logEntropy
```
public SDVariable logEntropy(String name,
                             SDVariable in,
                             int... dimensions)
```
    Log entropy reduction: log(-sum(x * log(x)))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null for full array)
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - shannonEntropy
```
public SDVariable shannonEntropy(SDVariable in,
                                 int... dimensions)
```
    Shannon Entropy reduction: -sum(x * log2(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null/empty for full array)
    
    Returns:
    
    Output variable
  - shannonEntropy
```
public SDVariable shannonEntropy(String name,
                                 SDVariable in,
                                 int... dimensions)
```
    Shannon Entropy reduction: -sum(x * log2(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce on (null/empty for full array)
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - sum
```
public SDVariable sum(SDVariable x,
                      int... dimensions)
```
    Sum array reduction operation, optionally along specified dimensions
    
    Parameters:
    
    x - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - sum
```
public SDVariable sum(String name,
                      SDVariable x,
                      int... dimensions)
```
    Sum array reduction operation, optionally along specified dimensions
    
    Parameters:
    
    x - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true
  - sum
```
public SDVariable sum(String name,
                      SDVariable x,
                      boolean keepDims,
                      int... dimensions)
```
    Sum array reduction operation, optionally along specified dimensions.
    Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. 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 - Output variable name
    
    x - Input variable
    
    keepDims - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true
  - sum
```
public SDVariable sum(SDVariable x,
                      boolean keepDims,
                      int... dimensions)
```
    See Also:
    
    sum(String, SDVariable, boolean, int...)
  - prod
```
public SDVariable prod(SDVariable x,
                       int... dimensions)
```
    Product array reduction operation, optionally along specified dimensions
    
    Parameters:
    
    x - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - prod
```
public SDVariable prod(String name,
                       SDVariable x,
                       int... dimensions)
```
    Product array reduction operation, optionally along specified dimensions
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - 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 - Output variable name
    
    x - Input variable
    
    keepDims - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions)
  - scalarMax
```
public SDVariable scalarMax(SDVariable in,
                            Number value)
```
    Element-wise scalar maximum operation: out = max(in, value)
    
    Parameters:
    
    in - Input variable
    
    value - Scalar value to compare
    
    Returns:
    
    Output variable
  - scalarMax
```
public SDVariable scalarMax(String name,
                            SDVariable in,
                            Number value)
```
    Element-wise scalar maximum operation: out = max(in, value)
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    value - Scalar value to compare
    
    Returns:
    
    Output variable
  - scalarMin
```
public SDVariable scalarMin(SDVariable in,
                            Number value)
```
    Element-wise scalar minimum operation: out = min(in, value)
    
    Parameters:
    
    in - Input variable
    
    value - Scalar value to compare
    
    Returns:
    
    Output variable
  - scalarMin
```
public SDVariable scalarMin(String name,
                            SDVariable in,
                            Number value)
```
    Element-wise scalar minimum operation: out = min(in, value)
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    value - Scalar value to compare
    
    Returns:
    
    Output variable
  - scalarFloorMod
```
public SDVariable scalarFloorMod(SDVariable in,
                                 Number value)
```
    Element-wise scalar floor modulus operation: out = floorMod(in, value). i.e., returns the remainder after division by 'value'
    
    Parameters:
    
    in - Input variable
    
    value - Scalar value to compare
    
    Returns:
    
    Output variable
  - scalarFloorMod
```
public SDVariable scalarFloorMod(String name,
                                 SDVariable in,
                                 Number value)
```
    Element-wise scalar floor modulus operation: out = floorMod(in, value). i.e., returns the remainder after division by 'value'
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    value - Scalar value to compare
    
    Returns:
    
    Output variable
  - scalarSet
```
public SDVariable scalarSet(SDVariable in,
                            Number set)
```
    Return an array with equal shape to the input, but all elements set to value 'set'
    
    Parameters:
    
    in - Input variable
    
    set - Value to set
    
    Returns:
    
    Output variable
  - scalarSet
```
public SDVariable scalarSet(String name,
                            SDVariable in,
                            Number set)
```
    Return an arary with equal shape to the input, but all elements set to value 'set'
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    set - Value to set
    
    Returns:
    
    Output variable
  - max
```
public SDVariable max(SDVariable x,
                      int... dimensions)
```
    Max array reduction operation, optionally along specified dimensions
    
    Parameters:
    
    x - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - max
```
public SDVariable max(String name,
                      SDVariable x,
                      int... dimensions)
```
    Max array reduction operation, optionally along specified dimensions
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - 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 - Output variable name
    
    x - Input variable
    
    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
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - max
```
public SDVariable max(SDVariable first,
                      SDVariable second)
```
    Element-wise maximum operation: out[i] = max(first[i], second[i])
    Supports broadcasting
    
    Parameters:
    
    first - First input array
    
    second - Second input array
    
    Returns:
    
    Output variable
  - max
```
public SDVariable max(String name,
                      SDVariable first,
                      SDVariable second)
```
    Element-wise maximum operation: out[i] = max(first[i], second[i])
    Supports broadcasting
    
    Parameters:
    
    name - Name of the output variable
    
    first - First input array
    
    second - Second input array
    
    Returns:
    
    Output variable
  - amax
```
public SDVariable amax(SDVariable in,
                       int... dimensions)
```
    Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - amax
```
public SDVariable amax(String name,
                       SDVariable in,
                       int... dimensions)
```
    Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - amin
```
public SDVariable amin(SDVariable in,
                       int... dimensions)
```
    Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - amin
```
public SDVariable amin(String name,
                       SDVariable in,
                       int... dimensions)
```
    Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - amean
```
public SDVariable amean(SDVariable in,
                        int... dimensions)
```
    Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - amean
```
public SDVariable amean(String name,
                        SDVariable in,
                        int... dimensions)
```
    Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - asum
```
public SDVariable asum(SDVariable in,
                       int... dimensions)
```
    Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - asum
```
public SDVariable asum(String name,
                       SDVariable in,
                       int... dimensions)
```
    Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - countZero
```
public SDVariable countZero(SDVariable input,
                            int... dimensions)
```
    Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
    
    Parameters:
    
    input - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - countZero
```
public SDVariable countZero(String name,
                            SDVariable input,
                            int... dimensions)
```
    Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
    
    Parameters:
    
    name - Name of the output variable
    
    input - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - zeroFraction
```
public SDVariable zeroFraction(SDVariable input)
```
    Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
    
    Parameters:
    
    input - Input variable
    
    Returns:
    
    Reduced array of rank 0 (scalar)
  - zeroFraction
```
public SDVariable zeroFraction(String name,
                               SDVariable input)
```
    Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
    
    Parameters:
    
    name - Name of the output variable
    
    input - Input variable
    
    Returns:
    
    Reduced array of rank 0 (scalar)
  - countNonZero
```
public SDVariable countNonZero(SDVariable input,
                               int... dimensions)
```
    Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
    
    Parameters:
    
    input - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - countNonZero
```
public SDVariable countNonZero(String name,
                               SDVariable input,
                               int... dimensions)
```
    Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
    
    Parameters:
    
    name - Name of the output variable
    
    input - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - min
```
public SDVariable min(SDVariable x,
                      int... dimensions)
```
    Minimum array reduction operation, optionally along specified dimensions. out = min(in)
    
    Parameters:
    
    x - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - min
```
public SDVariable min(String name,
                      SDVariable x,
                      int... dimensions)
```
    Minimum array reduction operation, optionally along specified dimensions. out = min(in)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - 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 - Output variable name
    
    x - Input variable
    
    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
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - min
```
public SDVariable min(SDVariable first,
                      SDVariable second)
```
    Element-wise minimum operation: out[i] = min(first[i], second[i])
    Supports broadcasting
    
    Parameters:
    
    first - First input array
    
    second - Second input array
    
    Returns:
    
    Output variable
  - min
```
public SDVariable min(String name,
                      SDVariable first,
                      SDVariable second)
```
    Element-wise minimum operation: out[i] = min(first[i], second[i])
    Supports broadcasting
    
    Parameters:
    
    name - Name of the output variable
    
    first - First input array
    
    second - Second input array
    
    Returns:
    
    Output variable
  - 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
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - argmax
```
public SDVariable argmax(SDVariable in,
                         boolean keepDims,
                         int... dimensions)
```
    See Also:
    
    argmax(String, SDVariable, boolean, int...)
  - 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
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - 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 of the output variable
    
    in - Input variable
    
    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
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true
  - 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
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - argmin
```
public SDVariable argmin(SDVariable in,
                         boolean keepDims,
                         int... dimensions)
```
    See Also:
    
    argmin(String, SDVariable, boolean, int...)
  - 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
    
    Parameters:
    
    in - Input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - 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]
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    keepDims - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Output variable: reduced array of rank (input rank - num dimensions) if keepDims = false, or of rank (input rank) if keepdims = true
  - iamax
```
public SDVariable iamax(SDVariable in,
                        int... dimensions)
```
    Index of the max absolute value: argmax(abs(in))
    
    See Also:
    
    argmax(SDVariable, int...)
  - iamax
```
public SDVariable iamax(SDVariable in,
                        boolean keepDims,
                        int... dimensions)
```
    Index of the max absolute value: argmax(abs(in))
    
    See Also:
    
    argmax(String, SDVariable, boolean, int...)
  - iamax
```
public SDVariable iamax(String name,
                        SDVariable in,
                        int... dimensions)
```
    Index of the max absolute value: argmax(abs(in))
    
    See Also:
    
    argmax(String, SDVariable, boolean, int...)
  - iamax
```
public SDVariable iamax(String name,
                        SDVariable in,
                        boolean keepDims,
                        int... dimensions)
```
    Index of the max absolute value: argmax(abs(in))
    
    See Also:
    
    argmax(String, SDVariable, boolean, int...)
  - iamin
```
public SDVariable iamin(SDVariable in,
                        int... dimensions)
```
    Index of the min absolute value: argmin(abs(in))
    
    See Also:
    
    argmin(String, SDVariable, boolean, int...)
  - iamin
```
public SDVariable iamin(SDVariable in,
                        boolean keepDims,
                        int... dimensions)
```
    Index of the min absolute value: argmin(abs(in))
    
    See Also:
    
    argmin(String, SDVariable, boolean, int...)
  - iamin
```
public SDVariable iamin(String name,
                        SDVariable in,
                        int... dimensions)
```
    Index of the min absolute value: argmin(abs(in))
    
    See Also:
    
    argmin(String, SDVariable, boolean, int...)
  - iamin
```
public SDVariable iamin(String name,
                        SDVariable in,
                        boolean keepDims,
                        int... dimensions)
```
    Index of the min absolute value: argmin(abs(in))
    
    See Also:
    
    argmin(String, SDVariable, boolean, int...)
  - firstIndex
```
public SDVariable firstIndex(SDVariable in,
                             Condition condition,
                             int... dimensions)
```
    See Also:
    
    firstIndex(String, SDVariable, Condition, int...)
  - firstIndex
```
public SDVariable firstIndex(SDVariable in,
                             Condition condition,
                             boolean keepDims,
                             int... dimensions)
```
    See Also:
    
    firstIndex(String, SDVariable, Condition, boolean, int...)
  - firstIndex
```
public SDVariable firstIndex(String name,
                             SDVariable in,
                             Condition condition,
                             int... dimensions)
```
    First index reduction operation.
    Returns a variable that contains the index of the first element that matches the specified condition (for each slice along the specified dimensions)
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    condition - Condition to check on input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - firstIndex
```
public SDVariable firstIndex(String name,
                             SDVariable in,
                             Condition condition,
                             boolean keepDims,
                             int... dimensions)
```
    First index reduction operation.
    Returns a variable that contains the index of the first element that matches the specified condition (for each slice along the specified dimensions)
    Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting the mean along a dimension).
    Example: if input has shape [a,b,c] and dimensions=[1] then output has shape: keepDims = true: [a,1,c]
    keepDims = false: [a,c]
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    condition - Condition to check on input variable
    
    keepDims - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - lastIndex
```
public SDVariable lastIndex(SDVariable in,
                            Condition condition,
                            int... dimensions)
```
    See Also:
    
    lastIndex(String, SDVariable, Condition, int...)
  - lastIndex
```
public SDVariable lastIndex(SDVariable in,
                            Condition condition,
                            boolean keepDims,
                            int... dimensions)
```
    See Also:
    
    lastIndex(String, SDVariable, Condition, boolean, int...)
  - lastIndex
```
public SDVariable lastIndex(String name,
                            SDVariable in,
                            Condition condition,
                            int... dimensions)
```
    Last index reduction operation.
    Returns a variable that contains the index of the last element that matches the specified condition (for each slice along the specified dimensions)
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    condition - Condition to check on input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - lastIndex
```
public SDVariable lastIndex(String name,
                            SDVariable in,
                            Condition condition,
                            boolean keepDims,
                            int... dimensions)
```
    Last index reduction operation.
    Returns a variable that contains the index of the last element that matches the specified condition (for each slice along the specified dimensions)
    Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting the mean along a dimension).
    Example: if input has shape [a,b,c] and dimensions=[1] then output has shape: keepDims = true: [a,1,c]
    keepDims = false: [a,c]
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    condition - Condition to check on input variable
    
    dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed
    
    Returns:
    
    Reduced array of rank (input rank - num dimensions)
  - matchConditionCount
```
public SDVariable matchConditionCount(SDVariable in,
                                      Condition condition)
```
    Returns a count of the number of elements that satisfy the condition
    
    Parameters:
    
    in - Input
    
    condition - Condition
    
    Returns:
    
    Number of elements that the condition is satisfied for
  - 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 of the output variable
    
    in - Input
    
    condition - Condition
    
    Returns:
    
    Number of elements that the condition is satisfied for
  - 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 of the output variable
    
    in - Input variable
    
    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
    
    Returns:
    
    Number of elements that the condition is satisfied for
  - 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 variable
    
    condition - Condition
    
    Returns:
    
    Boolean mask mariable
  - 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:
    
    in - Input
    
    condition - Condition
    
    Returns:
    
    Boolean mask
  - cumsum
```
public SDVariable cumsum(SDVariable in,
                         boolean exclusive,
                         boolean reverse,
                         int... axis)
```
    See Also:
    
    #cumsum(String, SDVariable, SDVariable, boolean, boolean)
  - cumsum
```
public SDVariable cumsum(String name,
                         SDVariable in,
                         boolean exclusive,
                         boolean reverse,
                         int... axis)
```
    Cumulative sum operation.
    For input: [ a, b, c], output is:
    exclusize=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 of the output variable
    
    in - Input variable
    
    axis - Scalar axis argument for dimension to perform cumululative sum operations along
    
    exclusive - If true: exclude the first value
    
    reverse - If true: reverse the direction of the accumulation
    
    Returns:
    
    Output variable
  - cumprod
```
public SDVariable cumprod(SDVariable in,
                          boolean exclusive,
                          boolean reverse,
                          int... axis)
```
    See Also:
    
    #cumprod(String, SDVariable, SDVariable, boolean, boolean)
  - cumprod
```
public SDVariable cumprod(String name,
                          SDVariable in,
                          boolean exclusive,
                          boolean reverse,
                          int... axis)
```
    Cumulative product operation.
    For input: [ a, b, c], output is:
    exclusize=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 of the output variable
    
    in - Input variable
    
    axis - Scalar axis argument for dimension to perform cumululative sum operations along
    
    exclusive - If true: exclude the first value
    
    reverse - If true: reverse the direction of the accumulation
    
    Returns:
    
    Output variable
  - biasAdd
```
public SDVariable biasAdd(SDVariable input,
                          SDVariable bias)
```
    See Also:
    
    biasAdd(String, SDVariable, SDVariable)
  - biasAdd
```
public SDVariable biasAdd(String name,
                          SDVariable input,
                          SDVariable bias)
```
    Bias addition operation: a special case of addition, typically used with CNN 4D activations and a 1D bias vector
    
    Parameters:
    
    name - Name of the output variable
    
    input - 4d input variable
    
    bias - 1d bias
    
    Returns:
    
    Output variable
  - 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
    
    shape - New shape for variable
    
    Returns:
    
    Output variable
    
    See Also:
    
    reshape(SDVariable, SDVariable)
  - 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 - Output variable name
    
    x - Input variable
    
    shape - New shape for variable
    
    Returns:
    
    Output variable
    
    See Also:
    
    reshape(SDVariable, SDVariable)
  - reshape
```
public SDVariable reshape(SDVariable x,
                          int... 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
    
    shape - New shape for variable
    
    Returns:
    
    Output variable
    
    See Also:
    
    reshape(SDVariable, SDVariable)
  - reshape
```
public SDVariable reshape(String name,
                          SDVariable x,
                          int... 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 - Output variable name
    
    x - Input variable
    
    shape - New shape for variable
    
    Returns:
    
    Output variable
    
    See Also:
    
    reshape(SDVariable, SDVariable)
  - reshape
```
public SDVariable reshape(SDVariable x,
                          SDVariable shape)
```
    Reshape the input variable to the specified (dynamic) 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
    
    shape - New shape for variable
    
    Returns:
    
    Output variable
    
    See Also:
    
    reshape(SDVariable, int[])
  - reshape
```
public SDVariable reshape(String name,
                          SDVariable x,
                          SDVariable shape)
```
    Reshape the input variable to the specified (dynamic) 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 - Output variable name
    
    x - Input variable
    
    shape - New shape for variable
    
    Returns:
    
    Output variable
    
    See Also:
    
    reshape(SDVariable, int[])
  - reverse
```
public SDVariable reverse(SDVariable x,
                          int... dimensions)
```
    See Also:
    
    reverse(String, SDVariable, int...)
  - 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, 0):
    [4, 5, 6]
    [1, 2 3]
    
    Parameters:
    
    x - Input variable
    
    dimensions - Dimensions
    
    Returns:
    
    Output variable
  - 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 of the output variable
    
    x - Input variable
    
    seq_lengths - Length of the sequences
    
    seqDim - Sequence dimension
    
    batchDim - Batch dimension
    
    Returns:
    
    Reversed sequences
  - reverseSequence
```
public SDVariable reverseSequence(String name,
                                  SDVariable x,
                                  SDVariable seq_lengths)
```
    See Also:
    
    reverseSequence(String, SDVariable, SDVariable, int, int)
  - reverseSequence
```
public SDVariable reverseSequence(SDVariable x,
                                  SDVariable seq_lengths,
                                  int seqDim,
                                  int batchDim)
```
    See Also:
    
    reverseSequence(String, SDVariable, SDVariable, int, int)
  - reverseSequence
```
public SDVariable reverseSequence(SDVariable x,
                                  SDVariable seq_lengths)
```
    See Also:
    
    reverseSequence(String, SDVariable, SDVariable, int, int)
  - sequenceMask
```
public SDVariable sequenceMask(String name,
                               SDVariable lengths,
                               SDVariable maxLen)
```
    Generate a sequence mask (with values 0 or 1) based on the specified lengths
    Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)
    
    Parameters:
    
    name - Name of the output variable
    
    lengths - Lengths of the sequences
    
    maxLen - Maximum sequence length
    
    Returns:
    
    Output variable
  - sequenceMask
```
public SDVariable sequenceMask(SDVariable lengths,
                               SDVariable maxLen)
```
    See Also:
    
    sequenceMask(String, SDVariable, SDVariable)
  - sequenceMask
```
public SDVariable sequenceMask(String name,
                               SDVariable lengths,
                               int maxLen)
```
    See Also:
    
    sequenceMask(String, SDVariable, SDVariable)
  - sequenceMask
```
public SDVariable sequenceMask(SDVariable lengths,
                               int maxLen)
```
    See Also:
    
    sequenceMask(String, SDVariable, SDVariable)
  - sequenceMask
```
public SDVariable sequenceMask(String name,
                               SDVariable lengths)
```
    See Also:
    
    sequenceMask(String, SDVariable, SDVariable)
  - sequenceMask
```
public SDVariable sequenceMask(SDVariable lengths)
```
    See Also:
    
    sequenceMask(String, SDVariable, SDVariable)
  - expandDims
```
public SDVariable expandDims(SDVariable x,
                             int axis)
```
    See Also:
    
    expandDims(String, SDVariable, int)
  - 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 of the output variable
    
    x - Input variable
    
    axis - Axis to expand
    
    Returns:
    
    Output variable
    
    See Also:
    
    squeeze(String, SDVariable, int)
  - squeeze
```
public SDVariable squeeze(SDVariable x,
                          int axis)
```
    See Also:
    
    squeeze(String, SDVariable, int)
  - squeeze
```
public SDVariable squeeze(String name,
                          SDVariable x,
                          int axis)
```
    Remove a single dimension of size 1. For example, if input has shape [a,b,1,c] then squeeze(input, 2) returns an array of shape [a,b,c]
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable
    
    axis - Size 1 dimension to remove
    
    Returns:
    
    Output variable
  - assign
```
public SDVariable assign(SDVariable x,
                         SDVariable y)
```
    Assign/copy op: out = x.assign(y). Supports broadcasting
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    Returns:
    
    Output variable
  - assign
```
public SDVariable assign(String name,
                         SDVariable x,
                         SDVariable y)
```
    Assign/copy op: out = x.assign(y). Supports broadcasting
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable x
    
    y - Input variable y
    
    Returns:
    
    Output variable
  - assign
```
public SDVariable assign(SDVariable in,
                         Number value)
```
    Return an array with equal shape to the input, but all elements set to 'value'
    
    Parameters:
    
    in - Input variable
    
    value - Value to set
    
    Returns:
    
    Output variable
  - assign
```
public SDVariable assign(String name,
                         SDVariable in,
                         Number value)
```
    Return an array with equal shape to the input, but all elements set to 'value'
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input variable
    
    value - Value to set
    
    Returns:
    
    Output variable
  - transpose
```
public SDVariable transpose(SDVariable x)
```
    Matrix transpose operation: If input has shape [a,b] output has shape [b,a]
    
    Parameters:
    
    x - Input variable
    
    Returns:
    
    Output variable (transposed input)
  - transpose
```
public SDVariable transpose(String name,
                            SDVariable x)
```
    Matrix transpose operation: If input has shape [a,b] output has shape [b,a]
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable (transposed input)
  - 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
    
    Returns:
    
    Output variable (permuted input)
  - 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 - Output variable name
    
    x - Input variable
    
    Returns:
    
    Output variable (permuted input)
  - rollAxis
```
public SDVariable rollAxis(SDVariable x,
                           int axis)
```
    Parameters:
    
    x -
    
    axis -
    
    Returns:
  - rollAxis
```
public SDVariable rollAxis(String name,
                           SDVariable x,
                           int axis)
```
    Parameters:
    
    x -
    
    axis -
    
    Returns:
  - concat
```
public SDVariable concat(int dimension,
                         SDVariable... inputs)
```
    See Also:
    
    concat(String, int, SDVariable...)
  - 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]
    
    Parameters:
    
    name - Name of the output variable
    
    dimension - Dimension to concatenate on
    
    inputs - Input variables
    
    Returns:
    
    Output variable
    
    See Also:
    
    stack(String, int, SDVariable...)
  - moments
```
public SDVariable[] moments(SDVariable input,
                            int... axes)
```
    See Also:
    
    moments(String[], SDVariable, int...)
  - moments
```
public SDVariable[] moments(String[] name,
                            SDVariable input,
                            int... axes)
```
    Calculate the mean and (population) variance for the input variable, for the specified axis
    
    Parameters:
    
    name - Name of the output variables. Can be null; if non-null, must be length 2
    
    input - Input to calculate moments for
    
    axes - Dimensions to perform calculation over
    
    Returns:
    
    Mean and variance variables
  - normalizeMoments
```
public SDVariable[] normalizeMoments(SDVariable counts,
                                     SDVariable means,
                                     SDVariable variances,
                                     double shift)
```
    See Also:
    
    normalizeMoments(String[], SDVariable, SDVariable, SDVariable, double)
  - normalizeMoments
```
public SDVariable[] normalizeMoments(String[] name,
                                     SDVariable counts,
                                     SDVariable means,
                                     SDVariable variances,
                                     double shift)
```
    Calculate the mean and variance from the sufficient statistics
    
    Parameters:
    
    name - Name of the output variables. Can be null; if non-null, must be length 2
    
    counts - Rank 0 (scalar) value with the total number of values used to calculate the sufficient statistics
    
    means - Mean-value sufficient statistics: this is the SUM of all data values
    
    variances - Variaance sufficient statistics: this is the squared sum of all data values
    
    shift - Shift value, possibly 0, used when calculating the sufficient statistics (for numerical stability)
    
    Returns:
    
    Output variables: mean and population variance
  - matrixDeterminant
```
public SDVariable matrixDeterminant(SDVariable in)
```
    See Also:
    
    matrixDeterminant(String, SDVariable)
  - matrixDeterminant
```
public SDVariable matrixDeterminant(String name,
                                    SDVariable in)
```
    Matrix determinant op. For 2D input, this returns the standard matrix determinant. For higher dimensional input with shape [..., m, m] the matrix determinant is returned for each shape [m,m] sub-matrix.
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input
    
    Returns:
    
    Matrix determinant variable
  - matrixInverse
```
public SDVariable matrixInverse(SDVariable in)
```
    See Also:
    
    matrixInverse(String, SDVariable)
  - matrixInverse
```
public SDVariable matrixInverse(String name,
                                SDVariable in)
```
    Matrix inverse op. For 2D input, this returns the standard matrix inverse. For higher dimensional input with shape [..., m, m] the matrix inverse is returned for each shape [m,m] sub-matrix.
    
    Parameters:
    
    name - Name of the output variable
    
    in - Input
    
    Returns:
    
    Matrix inverse variable
  - confusionMatrix
```
public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable predictions)
```
    See Also:
    
    confusionMatrix(String, SDVariable, SDVariable)
  - confusionMatrix
```
public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred)
```
    Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values. This version assumes the number of classes is 1 + max(max(labels), max(pred))
    For example, if labels = [0, 1, 1] and predicted = [0, 2, 1] then output is:
    [1, 0, 0]
    [0, 1, 1]
    [0, 0, 0]
    
    Parameters:
    
    name - Name of the output variable
    
    labels - Labels - 1D array of integer values representing label values
    
    pred - Predictions - 1D array of integer values representing predictions. Same length as labels
    
    Returns:
    
    Output variable (2D, shape [numClasses, numClasses})
  - confusionMatrix
```
public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable pred,
                                  Integer numClasses)
```
    See Also:
    
    confusionMatrix(String, SDVariable, SDVariable, Integer)
  - confusionMatrix
```
public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred,
                                  Integer numClasses)
```
    Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values.
    For example, if labels = [0, 1, 1], predicted = [0, 2, 1], and numClasses=4 then output is:
    [1, 0, 0, 0]
    [0, 1, 1, 0]
    [0, 0, 0, 0]
    [0, 0, 0, 0]
    
    Parameters:
    
    name - Name of the output variable
    
    labels - Labels - 1D array of integer values representing label values
    
    pred - Predictions - 1D array of integer values representing predictions. Same length as labels
    
    numClasses - Number of classes
    
    Returns:
    
    Output variable (2D, shape [numClasses, numClasses})
  - confusionMatrix
```
public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable pred,
                                  SDVariable weights)
```
    See Also:
    
    confusionMatrix(String, SDVariable, SDVariable, SDVariable)
  - confusionMatrix
```
public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred,
                                  SDVariable weights)
```
    Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values. This version assumes the number of classes is 1 + max(max(labels), max(pred))
    For example, if labels = [0, 1, 1], predicted = [0, 2, 1] and weights = [1, 2, 3] [1, 0, 0]
    [0, 3, 2]
    [0, 0, 0]
    
    Parameters:
    
    name - Name of the output variable
    
    labels - Labels - 1D array of integer values representing label values
    
    pred - Predictions - 1D array of integer values representing predictions. Same length as labels
    
    weights - Weights - 1D array of values (may be real/decimal) representing the weight/contribution of each prediction. Must be same length as both labels and predictions arrays
    
    Returns:
    
    Output variable (2D, shape [numClasses, numClasses})
  - confusionMatrix
```
public SDVariable confusionMatrix(SDVariable labels,
                                  SDVariable pred,
                                  Integer numClasses,
                                  SDVariable weights)
```
    See Also:
    
    confusionMatrix(String, SDVariable, SDVariable, Integer, SDVariable)
  - confusionMatrix
```
public SDVariable confusionMatrix(String name,
                                  SDVariable labels,
                                  SDVariable pred,
                                  Integer numClasses,
                                  SDVariable weights)
```
    Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of which are represented as integer values.
    For example, if labels = [0, 1, 1], predicted = [0, 2, 1], numClasses = 4, and weights = [1, 2, 3] [1, 0, 0, 0]
    [0, 3, 2, 0]
    [0, 0, 0, 0]
    [0, 0, 0, 0]
    
    Parameters:
    
    name - Name of the output variable
    
    labels - Labels - 1D array of integer values representing label values
    
    pred - Predictions - 1D array of integer values representing predictions. Same length as labels
    
    weights - Weights - 1D array of values (may be real/decimal) representing the weight/contribution of each prediction. Must be same length as both labels and predictions arrays
    
    Returns:
    
    Output variable (2D, shape [numClasses, numClasses})
  - tile
```
public SDVariable tile(SDVariable x,
                       int[] repeat)
```
    See Also:
    
    tile(String, SDVariable, int[])
  - tile
```
public SDVariable tile(String name,
                       SDVariable x,
                       int[] repeat)
```
    Repeat (tile) the input tensor the specified number of times.
    For example, if input is
    [1, 2]
    [3, 4]
    and repeat is [2, 3]
    then output is
    [1, 2, 1, 2, 1, 2]
    [3, 4, 3, 4, 3, 4]
    [1, 2, 1, 2, 1, 2]
    [3, 4, 3, 4, 3, 4]
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    repeat - Number of times to repeat in each axis. Must have length equal to the rank of the input array
    
    Returns:
    
    Output variable
  - fill
```
public SDVariable fill(SDVariable shape,
                       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
    
    value - Value to set all elements to
    
    Returns:
    
    Output variable
  - fill
```
public SDVariable fill(String name,
                       SDVariable shape,
                       double value)
```
    Generate an output variable with the specified (dynamic) shape with all elements set to the specified value
    
    Parameters:
    
    name - Name of the output variable
    
    shape - Shape: must be a 1D array/variable
    
    value - Value to set all elements to
    
    Returns:
    
    Output variable
  - dropout
```
public SDVariable dropout(SDVariable input,
                          double inputRetainProbability)
```
    Parameters:
    
    input - Input
    
    inputRetainProbability - Probability of retaining an input (set to 0 with probability 1-p)
    
    Returns:
  - dropout
```
public SDVariable dropout(String name,
                          SDVariable input,
                          double inputRetainProbability)
```
    Parameters:
    
    input - Input
    
    inputRetainProbability - Probability of retaining an input (set to 0 with probability 1-p)
    
    Returns:
  - linear
```
public SDVariable linear(SDVariable input,
                         SDVariable weights,
                         SDVariable bias)
```
    See Also:
    
    linear(String, SDVariable, SDVariable, SDVariable)
  - linear
```
public SDVariable linear(String name,
                         SDVariable input,
                         SDVariable weights,
                         SDVariable bias)
```
    Linear layer operation: out = mmul(in,w) + bias
    Note that bias array is optional
    
    Parameters:
    
    name - Name of the output variable
    
    input - Input data
    
    weights - Weights variable
    
    bias - Optional bias variable (may be null)
    
    Returns:
    
    Output variable
  - reluLayer
```
public SDVariable reluLayer(SDVariable input,
                            SDVariable weights,
                            SDVariable bias)
```
    See Also:
    
    reluLayer(String, SDVariable, SDVariable, SDVariable)
  - reluLayer
```
public SDVariable reluLayer(String name,
                            SDVariable input,
                            SDVariable weights,
                            SDVariable bias)
```
    ReLU (Rectified Linear Unit) layer operation: out = relu(mmul(in,w) + bias)
    Note that bias array is optional
    
    Parameters:
    
    name - Name of the output variable
    
    input - Input data
    
    weights - Weights variable
    
    bias - Optional bias variable (may be null)
    
    Returns:
    
    Output variable
  - mmul
```
public SDVariable mmul(SDVariable x,
                       SDVariable y,
                       MMulTranspose transpose)
```
    Matrix multiplication: out = mmul(x,y)
    Supports specifying a MMulTranspose argument to perform operation such as mmul(a^T, b), etc.
    
    Parameters:
    
    x - First input variable
    
    y - Second input variable
    
    transpose - Transpose arguments
    
    Returns:
    
    Output variable
  - mmul
```
public SDVariable mmul(SDVariable x,
                       SDVariable y)
```
    Matrix multiplication: out = mmul(x,y)
    
    Parameters:
    
    x - First input variable
    
    y - Second input variable
    
    Returns:
    
    Output variable
  - mmul
```
public SDVariable mmul(String name,
                       SDVariable x,
                       SDVariable y,
                       MMulTranspose transpose)
```
    Matrix multiplication: out = mmul(x,y)
    Supports specifying a MMulTranspose argument to perform operation such as mmul(a^T, b), etc.
    
    Parameters:
    
    name - Output variable name
    
    x - First input variable
    
    y - Second input variable
    
    transpose - Transpose arguments
    
    Returns:
    
    Output variable
  - mmul
```
public SDVariable mmul(String name,
                       SDVariable x,
                       SDVariable y)
```
    Matrix multiplication: out = mmul(x,y)
    
    Parameters:
    
    name - Output variable name
    
    x - First input variable
    
    y - Second input variable
    
    Returns:
    
    Output variable
  - batchMmul
```
public SDVariable[] batchMmul(String[] names,
                              SDVariable[] matricesA,
                              SDVariable[] matricesB,
                              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:
    
    matricesA - First array of input matrices, all of shape (M, N) or (N, M)
    
    matricesB - Second array of input matrices, all of shape (N, K) or (K, N)
    
    transposeA - whether first batch of matrices is transposed.
    
    transposeB - whether second batch of matrices is transposed.
    
    names - names for all provided SDVariables
    
    Returns:
    
    Array of multiplied SDVariables of shape (M, K)
  - batchMmul
```
public SDVariable[] batchMmul(SDVariable[] matricesA,
                              SDVariable[] matricesB,
                              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:
    
    matricesA - First array of input matrices, all of shape (M, N) or (N, M)
    
    matricesB - Second array of input matrices, all of shape (N, K) or (K, N)
    
    transposeA - whether first batch of matrices is transposed.
    
    transposeB - whether second batch of matrices is transposed.
    
    Returns:
    
    Array of multiplied SDVariables of shape (M, K)
  - batchMmul
```
public SDVariable[] batchMmul(SDVariable[] matricesA,
                              SDVariable[] matricesB)
```
    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. 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:
    
    matricesA - First array of input matrices, all of shape (M, N)
    
    matricesB - Second array of input matrices, all of shape (N, K)
    
    Returns:
    
    Array of multiplied SDVariables of shape (M, K)
  - tensorMmul
```
public SDVariable tensorMmul(SDVariable x,
                             SDVariable y,
                             int[][] dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - dot
```
public SDVariable dot(SDVariable x,
                      SDVariable y,
                      int... dimensions)
```
    TODO doc string
    
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - dot
```
public SDVariable dot(String name,
                      SDVariable x,
                      SDVariable y,
                      int... dimensions)
```
    TODO doc string
    
    Parameters:
    
    name -
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - 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])
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    dimensions - dimensions to reduce over
    
    Returns:
    
    Output variable
  - 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 - Output variable name
    
    x - Input variable
    
    keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions
    
    dimensions - dimensions to reduce over
    
    Returns:
    
    Output variable
  - 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)
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    dimensions - dimensions to reduce over
    
    Returns:
    
    Output variable
  - 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 - Output variable name
    
    x - Input variable
    
    keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions
    
    dimensions - dimensions to reduce over
    
    Returns:
    
    Output variable
  - squaredNorm
```
public SDVariable squaredNorm(SDVariable x,
                              int... dimensions)
```
    Squared L2 norm: see norm2(String, SDVariable, int...)
  - squaredNorm
```
public SDVariable squaredNorm(String name,
                              SDVariable x,
                              int... dimensions)
```
    Squared L2 norm: see norm2(String, SDVariable, int...)
  - squaredNorm
```
public SDVariable squaredNorm(SDVariable x,
                              boolean keepDims,
                              int... dimensions)
```
    Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
  - squaredNorm
```
public SDVariable squaredNorm(String name,
                              SDVariable x,
                              boolean keepDims,
                              int... dimensions)
```
    Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
  - 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
    
    Parameters:
    
    name - Output variable name
    
    x - Input variable
    
    dimensions - dimensions to reduce over
    
    Returns:
    
    Output variable
  - 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 - Output variable name
    
    x - Input variable
    
    keepDims - If true: keep the dimensions that are reduced on (as size 1). False: remove the reduction dimensions
    
    dimensions - dimensions to reduce over
    
    Returns:
    
    Output variable
  - cosineSimilarity
```
public SDVariable cosineSimilarity(SDVariable x,
                                   SDVariable y,
                                   int... dimensions)
```
    See Also:
    
    cosineSimilarity(String, SDVariable, SDVariable, int...)
  - cosineSimilarity
```
public SDVariable cosineSimilarity(String name,
                                   SDVariable x,
                                   SDVariable y,
                                   int... dimensions)
```
    Cosine similarity pairwise reduction operation. The output contains the cosine similarity for each tensor/subset along the specified dimensions:
    out = (sum_i x[i] * y[i]) / ( sqrt(sum_i x[i]^2) * sqrt(sum_i y[i]^2)
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Dimensions to calculate cosine similarity over
    
    Returns:
    
    Output variable
  - euclideanDistance
```
public SDVariable euclideanDistance(SDVariable x,
                                    SDVariable y,
                                    int... dimensions)
```
    See Also:
    
    euclideanDistance(String, SDVariable, SDVariable, int...)
  - euclideanDistance
```
public SDVariable euclideanDistance(String name,
                                    SDVariable x,
                                    SDVariable y,
                                    int... dimensions)
```
    Euclidean distance (l2 norm, l2 distance) reduction operation. The output contains the Euclidean distance for each tensor/subset along the specified dimensions:
    out = sqrt( sum_i (x[i] - y[i])^2 )
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Dimensions to calculate cosine similarity over
    
    Returns:
    
    Output variable
  - manhattanDistance
```
public SDVariable manhattanDistance(SDVariable x,
                                    SDVariable y,
                                    int... dimensions)
```
    See Also:
    
    manhattanDistance(String, SDVariable, SDVariable, int...)
  - manhattanDistance
```
public SDVariable manhattanDistance(String name,
                                    SDVariable x,
                                    SDVariable y,
                                    int... dimensions)
```
    Manhattan distance (l1 norm, l1 distance) reduction operation. The output contains the Manhattan distance for each tensor/subset along the specified dimensions:
    out = sum_i abs(x[i]-y[i])
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Dimensions to calculate cosine similarity over
    
    Returns:
    
    Output variable
  - cosineDistance
```
public SDVariable cosineDistance(SDVariable x,
                                 SDVariable y,
                                 int... dimensions)
```
    See Also:
    
    cosineDistance(String, SDVariable, SDVariable, int...)
  - cosineDistance
```
public SDVariable cosineDistance(String name,
                                 SDVariable x,
                                 SDVariable y,
                                 int... dimensions)
```
    Cosine distance reduction operation. The output contains the cosine distance for each tensor/subset along the specified dimensions:
    out = 1.0 - cosineSimilarity(x,y)
    See cosineSimilarity(String, SDVariable, SDVariable, int...)
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Dimensions to calculate cosine similarity over
    
    Returns:
    
    Output variable
  - hammingDistance
```
public SDVariable hammingDistance(SDVariable x,
                                  SDVariable y,
                                  int... dimensions)
```
    See Also:
    
    hammingDistance(String, SDVariable, SDVariable, int...)
  - hammingDistance
```
public SDVariable hammingDistance(String name,
                                  SDVariable x,
                                  SDVariable y,
                                  int... dimensions)
```
    Hamming distance reduction operation. The output contains the cosine distance for each tensor/subset along the specified dimensions:
    out = count( x[i] != y[i] )
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Dimensions to calculate cosine similarity over
    
    Returns:
    
    Output variable
  - jaccardDistance
```
public SDVariable jaccardDistance(SDVariable x,
                                  SDVariable y,
                                  int... dimensions)
```
    Jaccard similarity reduction operation. The output contains the Jaccard distance for each tensor along the the specified dimensions.
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Dimensions to calculate Jaccard similarity over
    
    Returns:
    
    Output variable
  - jaccardDistance
```
public SDVariable jaccardDistance(String name,
                                  SDVariable x,
                                  SDVariable y,
                                  int... dimensions)
```
    Jaccard similarity reduction operation. The output contains the Jaccard distance for each tensor along the the specified dimensions.
    
    Parameters:
    
    name - Name of the output variable
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Dimensions to calculate Jaccard similarity over
    
    Returns:
    
    Output variable
  - lossBinaryXENT
```
public SDVariable lossBinaryXENT(SDVariable x,
                                 SDVariable y,
                                 int... dimensions)
```
    Binary cross entropy loss.
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossCosineSimilarity
```
public SDVariable lossCosineSimilarity(SDVariable x,
                                       SDVariable y,
                                       int... dimensions)
```
    TODO doc string
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossHinge
```
public SDVariable lossHinge(SDVariable x,
                            SDVariable y,
                            int... dimensions)
```
    Hinge loss
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossKLD
```
public SDVariable lossKLD(SDVariable x,
                          SDVariable y,
                          int... dimensions)
```
    Kullback-Leibler divergence loss
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossL1
```
public SDVariable lossL1(SDVariable x,
                         SDVariable y,
                         int... dimensions)
```
    L1 loss
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossL2
```
public SDVariable lossL2(SDVariable x,
                         SDVariable y,
                         int... dimensions)
```
    L2 loss
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossMAE
```
public SDVariable lossMAE(SDVariable x,
                          SDVariable y,
                          int... dimensions)
```
    Mean absolute error loss
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossMSE
```
public SDVariable lossMSE(SDVariable x,
                          SDVariable y,
                          int... dimensions)
```
    Mean squared error loss
    
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossMCXENT
```
public SDVariable lossMCXENT(SDVariable x,
                             SDVariable y,
                             int... dimensions)
```
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossMSLE
```
public SDVariable lossMSLE(SDVariable x,
                           SDVariable y,
                           int... dimensions)
```
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossNegativeLogLikelihood
```
public SDVariable lossNegativeLogLikelihood(SDVariable x,
                                            SDVariable y,
                                            int... dimensions)
```
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossPoisson
```
public SDVariable lossPoisson(SDVariable x,
                              SDVariable y,
                              int... dimensions)
```
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - lossSquaredHinge
```
public SDVariable lossSquaredHinge(SDVariable x,
                                   SDVariable y,
                                   int... dimensions)
```
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - Reduction dimensions
    
    Returns:
    
    Output variable
  - softmaxDerivative
```
public SDVariable softmaxDerivative(String name,
                                    SDVariable x,
                                    SDVariable wrt)
```
    Parameters:
    
    x -
    
    Returns:
  - softmaxDerivative
```
public SDVariable softmaxDerivative(String name,
                                    SDVariable x,
                                    SDVariable wrt,
                                    Integer dimension)
```
  - tensorMmul
```
public SDVariable tensorMmul(String name,
                             SDVariable x,
                             SDVariable y,
                             int[][] dimensions)
```
    Parameters:
    
    x - Input variable x
    
    y - Input variable y
    
    dimensions - dimensions
    
    Returns:
    
    Output variable
  - sigmoidCrossEntropyWithLogits
```
public SDVariable sigmoidCrossEntropyWithLogits(SDVariable logits,
                                                SDVariable weights,
                                                SDVariable labels,
                                                int reductionMode,
                                                double labelSmoothing)
```
    TODO
    
    Parameters:
    
    logits -
    
    weights -
    
    labels -
    
    reductionMode -
    
    labelSmoothing -
    
    Returns:
  - sigmoidCrossEntropyWithLogits
```
public SDVariable sigmoidCrossEntropyWithLogits(String name,
                                                SDVariable logits,
                                                SDVariable weights,
                                                SDVariable labels,
                                                int reductionMode,
                                                double labelSmoothing)
```
    TODO
    
    Parameters:
    
    name -
    
    logits -
    
    weights -
    
    labels -
    
    reductionMode -
    
    labelSmoothing -
    
    Returns:
  - softmaxCrossEntropyWithLogits
```
public SDVariable softmaxCrossEntropyWithLogits(SDVariable logits,
                                                SDVariable weights,
                                                SDVariable labels,
                                                int reductionMode,
                                                double labelSmoothing)
```
    TODO
    
    Parameters:
    
    logits -
    
    weights -
    
    labels -
    
    reductionMode -
    
    labelSmoothing -
    
    Returns:
  - softmaxCrossEntropyWithLogits
```
public SDVariable softmaxCrossEntropyWithLogits(String name,
                                                SDVariable logits,
                                                SDVariable weights,
                                                SDVariable labels,
                                                int reductionMode,
                                                double labelSmoothing)
```
    TODO
    
    Parameters:
    
    name -
    
    logits -
    
    weights -
    
    labels -
    
    reductionMode -
    
    labelSmoothing -
    
    Returns:
  - weightedCrossEntropyWithLogits
```
public SDVariable weightedCrossEntropyWithLogits(SDVariable targets,
                                                 SDVariable inputs,
                                                 SDVariable weights)
```
    TODO
    
    Parameters:
    
    targets -
    
    inputs -
    
    weights -
    
    Returns:
  - weightedCrossEntropyWithLogits
```
public SDVariable weightedCrossEntropyWithLogits(String name,
                                                 SDVariable targets,
                                                 SDVariable inputs,
                                                 SDVariable weights)
```
    TODO
    
    Parameters:
    
    name -
    
    targets -
    
    inputs -
    
    weights -
    
    Returns:
  - lossBinaryXENT
```
public SDVariable lossBinaryXENT(String name,
                                 SDVariable x,
                                 SDVariable y,
                                 int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossCosineSimilarity
```
public SDVariable lossCosineSimilarity(String name,
                                       SDVariable x,
                                       SDVariable y,
                                       int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossHinge
```
public SDVariable lossHinge(String name,
                            SDVariable x,
                            SDVariable y,
                            int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossKLD
```
public SDVariable lossKLD(String name,
                          SDVariable x,
                          SDVariable y,
                          int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossL1
```
public SDVariable lossL1(String name,
                         SDVariable x,
                         SDVariable y,
                         int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossL2
```
public SDVariable lossL2(String name,
                         SDVariable x,
                         SDVariable y,
                         int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossMAE
```
public SDVariable lossMAE(String name,
                          SDVariable x,
                          SDVariable y,
                          int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossMSE
```
public SDVariable lossMSE(String name,
                          SDVariable x,
                          SDVariable y,
                          int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossMCXENT
```
public SDVariable lossMCXENT(String name,
                             SDVariable x,
                             SDVariable y,
                             int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossMSLE
```
public SDVariable lossMSLE(String name,
                           SDVariable x,
                           SDVariable y,
                           int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossNegativeLogLikelihood
```
public SDVariable lossNegativeLogLikelihood(String name,
                                            SDVariable x,
                                            SDVariable y,
                                            int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossPoisson
```
public SDVariable lossPoisson(String name,
                              SDVariable x,
                              SDVariable y,
                              int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - lossSquaredHinge
```
public SDVariable lossSquaredHinge(String name,
                                   SDVariable x,
                                   SDVariable y,
                                   int... dimensions)
```
    Parameters:
    
    x -
    
    y -
    
    dimensions -
    
    Returns:
  - addVariable
```
public void addVariable(SDVariable variable)
```
    Add the specified variable to this SameDiff instance
    
    Parameters:
    
    variable - Variable to add
  - generateNewVarName
```
public String generateNewVarName(String baseName,
                                 int argIndex)
```
    Generate a new variable name based on the uniqueness of the base name and arg index
    For example, if baseName = "X" will return:
    "X" if "X" does not already exist, or "X:argIndex" if argIndex > 0
    "X_1" if "X" already exists, or "X_1:argIndex" if argIndex > 0
    "X_2" if "X" and "X_1" already exists, or "X_2:argIndex" if argIndex > 0
    And so on, until an unused name is found
    
    Parameters:
    
    baseName - the base name to use (use function.opName() where function is a DifferentialFunction
    
    argIndex - the arg index
    
    Returns:
    
    the new generated name
  - lstm
```
public SDVariable lstm(String baseName,
                       LSTMCellConfiguration configuration)
```
    LSTM unit
    
    Parameters:
    
    baseName - the base name for outputs
    
    configuration - the configuration to use
    
    Returns:
  - sruCell
```
public SDVariable sruCell(SRUCellConfiguration configuration)
```
    An sru cell
    
    Parameters:
    
    configuration - the configuration for the sru cell
    
    Returns:
  - sru
```
public SDVariable sru(SRUConfiguration configuration)
```
    Simple recurrent unit
    
    Parameters:
    
    configuration - the configuration for the sru
    
    Returns:
  - gru
```
public SDVariable gru(GRUCellConfiguration configuration)
```
    The gru cell
    
    Parameters:
    
    configuration - teh configuration to use
    
    Returns:
  - sruCell
```
public SDVariable sruCell(String baseName,
                          SRUCellConfiguration configuration)
```
    An sru cell
    
    Parameters:
    
    baseName - the base name to use for the output variables
    
    configuration - the configuration for the sru cell
    
    Returns:
  - sru
```
public SDVariable sru(String baseName,
                      SRUConfiguration configuration)
```
    Simiple recurrent unit
    
    Parameters:
    
    baseName - the base name to use for output variables
    
    configuration - the configuration for the sru
    
    Returns:
  - gru
```
public SDVariable gru(String baseName,
                      GRUCellConfiguration configuration)
```
    The gru cell
    
    Parameters:
    
    baseName - the base name for the gru cell
    
    configuration - teh configuration to use
    
    Returns:
  - slice
```
public SDVariable slice(SDVariable input,
                        int[] begin,
                        int[] size)
```
    See Also:
    
    slice(String, SDVariable, int[], int[])
  - slice
```
public SDVariable slice(String name,
                        SDVariable input,
                        int[] begin,
                        int[] size)
```
    Get a subset of the specified input, by specifying the first element and the size of the array.
    For example, if input is:
    [a, b, c]
    [d, e, f]
    then slice(input, begin=[0,1], size=[2,1] will return:
    [b]
    [e]
    
    Note that for each dimension i, begin[i] + size[i] <= input.size(i)
    
    Parameters:
    
    name - Output variable name
    
    input - Variable to get subset of
    
    begin - Beginning index. Must be same length as rank of input array
    
    size - Size of the output array. Must be same length as rank of input array
    
    Returns:
    
    Subset of the input
  - stridedSlice
```
public SDVariable stridedSlice(SDVariable input,
                               int[] begin,
                               int[] end,
                               int[] strides)
```
    See Also:
    
    stridedSlice(String, SDVariable, long[], long[], long[])
  - stridedSlice
```
public SDVariable stridedSlice(String name,
                               SDVariable input,
                               int[] begin,
                               int[] end,
                               int[] strides)
```
    See Also:
    
    stridedSlice(String, SDVariable, long[], long[], long[])
  - stridedSlice
```
public SDVariable stridedSlice(SDVariable input,
                               long[] begin,
                               long[] end,
                               long[] strides)
```
    See Also:
    
    stridedSlice(String, SDVariable, long[], long[], long[])
  - stridedSlice
```
public SDVariable stridedSlice(String name,
                               SDVariable input,
                               long[] begin,
                               long[] end,
                               long[] strides)
```
    Get a subset of the specified input, by specifying the first element, last element, and the strides.
    For example, if input is:
    [a, b, c]
    [d, e, f]
    [g, h, i]
    then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1]) will return:
    [b, c]
    [h, i]
    
    Parameters:
    
    name - Output variable name
    
    input - Variable to get subset of
    
    begin - Beginning index. Must be same length as rank of input array
    
    end - End index. Must be same length as the rank of the array
    
    strides - Stride ("step size") for each dimension. Must be same length as the rank of the array. For example, stride of 2 means take every second element.
    
    Returns:
    
    Subset of the input
  - stridedSlice
```
public SDVariable stridedSlice(String name,
                               SDVariable in,
                               long[] begin,
                               long[] end,
                               long[] strides,
                               int beginMask,
                               int endMask,
                               int ellipsisMask,
                               int newAxisMask,
                               int shrinkAxisMask)
```
    Get a subset of the specified input, by specifying the first element, last element, and the strides.
    Operates as described in stridedSlice(SDVariable, long[], long[], long[]) with some extra mask arrays as described below.
    
    Parameters:
    
    name - Output variable name
    
    in - Variable to get subset of
    
    begin - Beginning index
    
    end - End index
    
    strides - Stride ("step size") for each dimension. For example, stride of 2 means take every second element.
    
    beginMask - Bit mask: If the ith bit is set to 1, then the value in the begin long[] is ignored, and a value of 0 is used instead for the beginning index for that dimension
    
    endMask - Bit mask: If the ith bit is set to 1, then the value in the end long[] is ignored, and a value of size(i)-1 is used instead for the end index for that dimension
    
    ellipsisMask - Bit mask: only one non-zero value is allowed here. If a non-zero value is set, then other dimensions are inserted as required at the specified position
    
    newAxisMask - Bit mask: if the ith bit is set to 1, then the begin/end/stride values are ignored, and a size 1 dimension is inserted at this point
    
    shrinkAxisMask - Bit mask: if the ith bit is set to 1, then the begin/end/stride values are ignored, and a size 1 dimension is removed at this point. Note that begin/end/stride values must result in a size 1 output for these dimensions
    
    Returns:
    
    A subset of the input array
  - stridedSlice
```
public SDVariable stridedSlice(SDVariable in,
                               int[] begin,
                               int[] end,
                               int[] strides,
                               int beginMask,
                               int endMask,
                               int ellipsisMask,
                               int newAxisMask,
                               int shrinkAxisMask)
```
    See Also:
    
    stridedSlice(String, SDVariable, long[], long[], long[], int, int, int, int, int)
  - stridedSlice
```
public SDVariable stridedSlice(String name,
                               SDVariable in,
                               int[] begin,
                               int[] end,
                               int[] strides,
                               int beginMask,
                               int endMask,
                               int ellipsisMask,
                               int newAxisMask,
                               int shrinkAxisMask)
```
    See Also:
    
    stridedSlice(String, SDVariable, long[], long[], long[], int, int, int, int, int)
  - stridedSlice
```
public SDVariable stridedSlice(SDVariable in,
                               long[] begin,
                               long[] end,
                               long[] strides,
                               int beginMask,
                               int endMask,
                               int ellipsisMask,
                               int newAxisMask,
                               int shrinkAxisMask)
```
    See Also:
    
    stridedSlice(String, SDVariable, long[], long[], long[], int, int, int, int, int)
  - scatterAdd
```
public SDVariable scatterAdd(SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)
```
    See Also:
    
    scatterAdd(String, SDVariable, SDVariable, SDVariable)
  - 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, ...] += updates[...]
    If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] += updates[i, ...]
    If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] += updates[i, ..., k, ...]
    Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
    
    Parameters:
    
    name - Name of the output variable
    
    ref - Initial/source variable
    
    indices - Indices array
    
    updates - Updates to add to the initial/source array
    
    Returns:
    
    The updated variable
  - scatterMul
```
public SDVariable scatterMul(SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)
```
    See Also:
    
    scatterMul(String, SDVariable, SDVariable, SDVariable)
  - 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, ...] *= updates[...]
    If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] *= updates[i, ...]
    If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] *= updates[i, ..., k, ...]
    Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
    
    Parameters:
    
    name - Name of the output variable
    
    ref - Initial/source variable
    
    indices - Indices array
    
    updates - Updates to add to the initial/source array
    
    Returns:
    
    The updated variable
  - scatterSub
```
public SDVariable scatterSub(SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)
```
    See Also:
    
    scatterSub(String, SDVariable, SDVariable, SDVariable)
  - 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, ...] -= updates[...]
    If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] -= updates[i, ...]
    If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] -= updates[i, ..., k, ...]
    Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
    
    Parameters:
    
    name - Name of the output variable
    
    ref - Initial/source variable
    
    indices - Indices array
    
    updates - Updates to add to the initial/source array
    
    Returns:
    
    The updated variable
  - scatterDiv
```
public SDVariable scatterDiv(SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)
```
    See Also:
    
    scatterDiv(String, SDVariable, SDVariable, SDVariable)
  - 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, ...] /= updates[...]
    If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] /= updates[i, ...]
    If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] /= updates[i, ..., k, ...]
    Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
    
    Parameters:
    
    name - Name of the output variable
    
    ref - Initial/source variable
    
    indices - Indices array
    
    updates - Updates to add to the initial/source array
    
    Returns:
    
    The updated variable
  - scatterMax
```
public SDVariable scatterMax(SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)
```
    See Also:
    
    scatterMax(String, SDVariable, SDVariable, SDVariable)
  - 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, ...] = max(updates[...], in[index,...])
    If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = max(updates[i,...], in[indices[i],...])
    If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = max(updates[i, ..., k, ...], in[indices[i], ..., indices[k], ...]
    Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
    
    Parameters:
    
    name - Name of the output variable
    
    ref - Initial/source variable
    
    indices - Indices array
    
    updates - Updates to add to the initial/source array
    
    Returns:
    
    The updated variable
  - scatterMin
```
public SDVariable scatterMin(SDVariable ref,
                             SDVariable indices,
                             SDVariable updates)
```
    See Also:
    
    scatterMin(String, SDVariable, SDVariable, SDVariable)
  - 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, ...] = min(updates[...], in[index,...])
    If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = min(updates[i,...], in[indices[i],...])
    If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = min(updates[i, ..., k, ...], in[indices[i], ..., indices[k], ...]
    Note that if multiple indices refer to the same location, the contributions from each is handled correctly.
    
    Parameters:
    
    name - Name of the output variable
    
    ref - Initial/source variable
    
    indices - Indices array
    
    updates - Updates to add to the initial/source array
    
    Returns:
    
    The updated variable
  - scatterUpdate
```
public SDVariable scatterUpdate(SDVariable ref,
                                SDVariable indices,
                                SDVariable updates)
```
    See Also:
    
    scatterUpdate(String, SDVariable, SDVariable, SDVariable)
  - 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, ...] = updates[...]
    If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = updates[i, ...]
    If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = updates[i, ..., k, ...]
    Note that if multiple indices refer to the same location, the output at those locations is undefined - different updates may occur in different orders
    
    Parameters:
    
    name - Name of the output variable
    
    ref - Initial/source variable
    
    indices - Indices array
    
    updates - Updates to add to the initial/source array
    
    Returns:
    
    The updated variable
  - trace
```
public SDVariable trace(SDVariable in)
```
    See Also:
    
    trace(String, SDVariable)
  - trace
```
public SDVariable trace(String name,
                        SDVariable in)
```
    Matrix trace operation For rank 2 matrices, the output is a scalar vith the trace - i.e., sum of the main diagonal.
    For higher rank inputs, output[a,b,c] = trace(in[a,b,c,:,:])
    
    Parameters:
    
    name - Name of the output variable. May be null.
    
    in - Input variable
    
    Returns:
    
    Trace
  - generateOutputVariableForOp
```
public SDVariable[] generateOutputVariableForOp(DifferentialFunction function,
                                                String baseName)
```
    Generate the variables based on the given input op and return the output variable names.
    
    Parameters:
    
    function - the function to generate the output variable names for
    
    Returns:
    
    the set of names generated for each output of the function.
  - generateOutputVariableForOp
```
public SDVariable[] generateOutputVariableForOp(DifferentialFunction function)
```
    Generate the variables based on the given input op and return the output variable names.
    
    Parameters:
    
    function - the function to generate the output variable names for
    
    Returns:
    
    the set of names generated for each output of the function.
  - getFunction
```
public SameDiff getFunction(String functionName)
```
    Get a SameDiff function instance given the name of the function
    
    Parameters:
    
    functionName - the name of the function
    
    Returns:
    
    the same diff function instance defined for the given name
  - execAndEndResult
```
public INDArray execAndEndResult(List<DifferentialFunction> ops)
```
    Execute the specified ops and return the output of the last one
    
    Parameters:
    
    ops - Ops to execute
    
    Returns:
    
    Output (or first output) of the final op in the list, after execution
  - execAndEndResult
```
public INDArray execAndEndResult()
```
    Execute the graph using the current arrays/state and return the array for the final variable in the graph.
    After execution, the arrays for other variables can be obtained using getArrForVarName(String) or SDVariable.getArr()
    
    Note: If the final operation has multiple output variables, use execAndEndResults() instead
    
    Returns:
    
    The output of the final operation in the graph after execution
  - execAndEndResults
```
public INDArray[] execAndEndResults()
```
    Execute the graph using the current arrays/state and return the array(s) for the final variable in the graph.
    After execution, the arrays for other variables can be obtained using getArrForVarName(String) or SDVariable.getArr()
    
    Returns:
    
    The outputs of the final operation in the graph, after execution
  - execAndEndResult
```
public INDArray execAndEndResult(int outputIndex)
```
    Execute the graph using the current arrays/state and return the (first, and possibly only) array for the specified variable in the graph.
    After execution, the arrays for other variables can be obtained using getArrForVarName(String) or SDVariable.getArr()
    
    Returns:
    
    The output of the final operation in the graph
  - yetAnotherExecMethod
```
public INDArray yetAnotherExecMethod(@NonNull
                                     Map<String,INDArray> inputs)
```
  - exec
```
public List<DifferentialFunction> exec(List<DifferentialFunction> ops)
```
    Executes the list of operations. This exec method is for only invoking operations rather than creating them
    
    Parameters:
    
    ops - the list of already created ops
    
    Returns:
    
    the passes in list
  - getListByName
```
public TensorList getListByName(@NonNull
                                String name)
```
  - putListByName
```
public void putListByName(@NonNull
                          String name,
                          TensorList list)
```
  - whileStatement
```
public While whileStatement(SameDiffConditional sameDiffConditional,
                            SameDiffFunctionDefinition conditionBody,
                            SameDiffFunctionDefinition loopBody,
                            SDVariable[] inputVars)
```
    Creates a while statement
    
    Parameters:
    
    sameDiffConditional -
    
    loopBody -
    
    Returns:
  - ifStatement
```
public If ifStatement(SameDiffConditional conditional,
                      SameDiffFunctionDefinition conditionBody,
                      SameDiffFunctionDefinition trueBody,
                      SameDiffFunctionDefinition falseBody,
                      SDVariable[] inputVars)
```
    Parameters:
    
    conditional -
    
    trueBody -
    
    falseBody -
    
    Returns:
  - tensorArray
```
public TensorArrayV3 tensorArray()
```
  - invokeFunctionOn
```
public SDVariable invokeFunctionOn(String functionName,
                                   SameDiff with)
```
    Parameters:
    
    functionName -
    
    with -
  - defineFunction
```
public SameDiff defineFunction(String function,
                               SameDiffFunctionDefinition functionDefinition,
                               SDVariable[] variables)
```
    Parameters:
    
    function -
  - defineFunction
```
public void defineFunction(String function,
                           SameDiffFunctionDefinition functionDefinition)
```
    Parameters:
    
    function -
  - defineFunction
```
public void defineFunction(String function,
                           SameDiffFunctionDefinition functionDefinition,
                           Map<String,INDArray> inputs)
```
    Parameters:
    
    function -
    
    functionDefinition -
    
    inputs -
  - execAndEndResult
```
public INDArray execAndEndResult(String functionName)
```
    Exec a given SameDiff function instance
    
    Parameters:
    
    functionName - the name of the SameDiff function instance to invoke
    
    Returns:
    
    Output of the final variable after execution
  - exec
```
public org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>> exec(String functionName)
```
    Execute the specified SameDiff function instance
    
    Parameters:
    
    functionName - the name of the SameDiff function instance to invoke
    
    Returns:
  - exec
```
public List<DifferentialFunction> exec(String functionName,
                                       List<DifferentialFunction> cachedOps)
```
    Exec the given function given the ops
    
    Parameters:
    
    functionName - the opName of the function to exec
    
    cachedOps - the cached operations
    
    Returns:
  - execBackwards
```
public org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>> execBackwards()
```
    Execute the gradient (backward pass) function on this graph.
    Constructs a backwards graph (differentiating the defined graph) if it does not already exist, and the executes the operations on that graph, calculating gradients for all variables.
    Note that after execBackwards() has completed, the gradient arrays for a each variable can be accessed using SDVariable.getGradient() followed by SDVariable.getArr() or by using getGradForVariable(String)
    
    Returns:
    
    Result of execution
  - createGradFunction
```
public void createGradFunction()
```
    Create the gradient function (for calculating gradients via execBackwards()) if it is not already defined. Users do not usually need to call this function manually, as it is called as required in the aforementioned method.
    
    If the gradient function already exists, this method is a no-op.
    After this method returns, the SameDiff function instance for the gradient can be accessed using getFunction(String) with name "grad" as the argument.
  - execBackwardAndEndResult
```
public INDArray execBackwardAndEndResult()
```
    Exec a backwards operation and return the end result
    
    Returns:
  - execWithPlaceHolderAndEndResult
```
public INDArray execWithPlaceHolderAndEndResult(Map<String,INDArray> inputs)
```
    Creates and executes a list of operations
    
    Returns:
  - setOriginalPlaceHolderShape
```
public void setOriginalPlaceHolderShape(String variableName,
                                        long[] shape)
```
    Set the original shape for a given place holder.
    This is used to track original shapes of place holder variables.
    The reason we track original shapes is to validate possible candidate arrays coming in (especially with -1 as the expected shapes).
    Note that if isPlaceHolder(String) returns false for the passed in vertex id, a ND4JIllegalStateException is thrown.
    A vertex id must be added first. You can do this with addAsPlaceHolder(String)
    
    Parameters:
    
    variableName - the vertex id for the original shape
    
    shape - the shape of the place holder
  - getOriginalShapeForPlaceHolder
```
public long[] getOriginalShapeForPlaceHolder(String varName)
```
    Get the original shape for the vertex id if one was set (other wise returns null).
    This is mainly for use in validating passed in arrays as arguments to resolveVariablesWith(Map) usually when executing using execWithPlaceHolder(Map)
    
    Parameters:
    
    varName - the vertex id to get the original shape for.
    
    Returns:
    
    the set vertex
  - isPlaceHolder
```
public boolean isPlaceHolder(String varName)
```
    Returns true if this vertex id is a place holder variable or not
    A place holder variable is one where the array shape(s) are currently known and can't yet be calculated
    
    Parameters:
    
    varName - the vertex id to test
    
    Returns:
    
    True if the variable is a placeholder, false otherwise
  - addAsPlaceHolder
```
public void addAsPlaceHolder(String varName)
```
    Add this vertex id as a place holder
    
    Parameters:
    
    varName - the vertex id to add
  - resolveVariablesWith
```
public void resolveVariablesWith(Map<String,INDArray> arrays)
```
    Resolve all ndarrays by updating the variables for each array specified in the given map. An IllegalStateException will be thrown if not all arrays are specified for resolution.
    
    Parameters:
    
    arrays - the arrays to resolve.
  - allPlaceHolderVariablesResolved
```
public boolean allPlaceHolderVariablesResolved()
```
    Returns true if all place holder variables are resolved.
    A place holder variable is resolved when getVariable(String) getArr() does not return null and the shape is properly resolved.
    
    Returns:
    
    true if all place holder variables are resolved.
  - putPlaceHolderForVariable
```
public void putPlaceHolderForVariable(String varName,
                                      String... placeHolderVariables)
```
    Add one or or more place holder variables for the given vertex id.
    Note that if a vertex id in placeHolderVariables isn't present in this samediff instance anyways, an ND4JIllegalStateException is thrown
    
    Parameters:
    
    varName - the vertex id to add place holders for
    
    placeHolderVariables - the place holder variables
  - hasPlaceHolderVariables
```
public boolean hasPlaceHolderVariables(String vertexId)
```
    Returns true if the given vertex id has any placeholder variables
    
    Parameters:
    
    vertexId - the vertex id to check for
    
    Returns:
    
    true if this vertex has any place holder variables or not
  - getPlaceHoldersFor
```
public List<String[]> getPlaceHoldersFor(String varName)
```
    Get the place holders for a given vertex id. May return null.
    Consider using hasPlaceHolderVariables(String)
    
    Parameters:
    
    varName - the vertex id to get the place holders for
    
    Returns:
    
    the place holder variables for the given vertex id or null
  - execWithPlaceHolder
```
public org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>> execWithPlaceHolder(Map<String,INDArray> inputs)
```
    Creates and executes a list of operations based on the given variables passed in.
    resolveVariablesWith(Map) is called
    
    Returns:
  - getVariablesAssociatedWithFunctions
```
public List<SDVariable> getVariablesAssociatedWithFunctions(List<DifferentialFunction> functions)
```
    Get the SDVariable associated with each function based on the DifferentialFunction.outputVariables() ()}
    
    Parameters:
    
    functions - the functions to get the variables for
    
    Returns:
    
    the list of variables associated with the given DifferentialFunction
  - updateVariableNameAndReference
```
public SDVariable updateVariableNameAndReference(SDVariable varToUpdate,
                                                 String newVarName)
```
    Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.
    Note that if null for the new variable is passed in, it will just return the original input variable.
    
    Parameters:
    
    varToUpdate - the variable to update
    
    newVarName - the new variable name
    
    Returns:
    
    the passed in variable
  - updateVariableNamesAndReferences
```
public SDVariable[] updateVariableNamesAndReferences(SDVariable[] variablesToUpdate,
                                                     String[] newVariableNames)
```
    Updates the variable name property on the passed in variables, its reference in samediff, and returns the variable.
    
    Parameters:
    
    variablesToUpdate - the variable to update
    
    newVariableNames - the new variable name
    
    Returns:
    
    the updated, passed in variables
  - associateSameDiffWithOpsAndVariables
```
protected void associateSameDiffWithOpsAndVariables()
```
    Associate the current SameDiff instance with all ops and variables. This is necessary to ensure that when dealing with shared state (usually with a SameDiff function such as "grad" - the backward function) we have the correct SameDiff instance set for all ops/SDVariables.
    If this is not done, arrays and shapes could be fetched from the incorrect SameDiff instance for some methods
  - clearExecutionCache
```
public void clearExecutionCache()
```
    Clear the execution cache, if it is present
  - exec
```
public org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>> exec()
```
    Execute the SameDiff instance using the current state
    After execution, the arrays for variables can be obtained using getArrForVarName(String) or SDVariable.getArr()
    
    Returns:
    
    Execution results
  - printFunction
```
public void printFunction(DifferentialFunction differentialFunction)
```
    Print the given function for debugging (will not print functions)
    
    Parameters:
    
    differentialFunction - the function to print
  - permuteDataFormatForSameDiff
```
public static int[] permuteDataFormatForSameDiff(String dataFormat,
                                                 boolean weights)
```
    Permute indices for the samediff/dl4j format. Due to the dl4j format being NCHW, this is a simple routine for returning permute indices. This is typically used for model import.
    
    Parameters:
    
    dataFormat - the data format to permute
    
    Returns:
    
    the permuted indices
  - updateVariable
```
public void updateVariable(String variableName,
                           INDArray arr)
```
    Update the INDArray ndarray for the given variable name
    
    Parameters:
    
    variableName - the variable to update
    
    arr - the array to update with
  - asFlatNode
```
protected int asFlatNode(String name,
                         @NonNull
                         SameDiff scope,
                         @NonNull
                         com.google.flatbuffers.FlatBufferBuilder bufferBuilder)
```
  - parseVariable
```
public static org.nd4j.linalg.primitives.Pair<String,Integer> parseVariable(@NonNull
                                                                            String varName)
```
    Note: INTENDED FOR DEVELOPER USE
    This method extract base variable name and output index (if exists) from raw variable name. I.e: - if variable name is "Unstack_2", result will be Pair("Unstack_2", 0) - if variable name is "Unstack_2:12", result will be Pair("Unstack_2", 12)
    
    Parameters:
    
    varName -
    
    Returns:
  - asFlatNode
```
protected int asFlatNode(@NonNull
                         DifferentialFunction node,
                         @NonNull
                         com.google.flatbuffers.FlatBufferBuilder bufferBuilder,
                         List<SDVariable> variables,
                         Map<String,Integer> reverseMap,
                         Map<String,Integer> forwardMap,
                         Map<String,Integer> framesMap,
                         AtomicInteger idCounter)
```
  - asFlatBuffers
```
public ByteBuffer asFlatBuffers(@NonNull
                                ExecutorConfiguration configuration)
```
    This method exports the current SameDiff instance into FlatBuffers format, returning the array ops and all arrays as a ByteBuffer containing the FlatBuffers format data
    
    Parameters:
    
    configuration - - ExecutorConfiguration to be embedded into serialized graph
    
    Returns:
    
    a ByteBuffer holding the exported FlatBuffers representation of the graph
  - asFlatBuffers
```
public ByteBuffer asFlatBuffers()
```
    This method exports the current SameDiff instance into FlatBuffers format, returning the array ops and all arrays as a ByteBuffer containing the FlatBuffers format data
    
    Returns:
    
    a ByteBuffer holding the exported FlatBuffers representation of the graph
  - getOrderFromByte
```
public static ByteOrder getOrderFromByte(byte val)
```
    This method just converts enums
    
    Parameters:
    
    val -
    
    Returns:
  - getOrderAsByte
```
public static byte getOrderAsByte()
```
    This method returns current byte order for this JVM as libnd4j enum
    
    Returns:
  - asFlatFile
```
public void asFlatFile(@NonNull
                       File file)
                throws IOException
```
    This method converts SameDiff instance to FlatBuffers and saves it to file which can be restored later
    
    Parameters:
    
    file - File to save the FlatBuffers serialized graph (including arrays) to
    
    Throws:
    
    IOException
  - asFlatFile
```
public void asFlatFile(@NonNull
                       File file,
                       @NonNull
                       ExecutorConfiguration configuration)
                throws IOException
```
    This method converts SameDiff instance to FlatBuffers and saves it to file which can be restored later
    
    Parameters:
    
    file - File to save the FlatBuffers serialized graph (including arrays) to
    
    Throws:
    
    IOException
  - asFlatPrint
```
public String asFlatPrint()
```
    This method returns a text representation of the "flattened" graph.
    
    Returns:
    
    String representation of the graph
    
    See Also:
    
    summary()
  - getDataTypeFromByte
```
public static DataBuffer.Type getDataTypeFromByte(byte val)
```
    This method converts enums for DataType
    
    Parameters:
    
    val -
    
    Returns:
  - getDataTypeAsByte
```
public static byte getDataTypeAsByte(DataBuffer.Type type)
```
    This method converts enums for DataType
    
    Parameters:
    
    type -
    
    Returns:
  - getOpNum
```
public static long getOpNum(String name,
                            Op.Type type)
```
    This method return operation ID for given op name/type pair.
    
    Parameters:
    
    name -
    
    type -
    
    Returns:
  - getTypeFromByte
```
public static Op.Type getTypeFromByte(byte type)
```
    This method converts enums for Op.Type
    
    Parameters:
    
    type - Byte representing the op type
    
    Returns:
    
    Op type
  - getFlatOpType
```
public static byte getFlatOpType(Op.Type type)
```
    This method converts an Op.Type to it's corresponding byte value
    
    Parameters:
    
    type - type to convert
    
    Returns:
    
    Byte representing the op type
  - summary
```
public String summary()
```
    Generate and return a String representation of the current SameDiff instance
    Reports variables, ops, SameDiff function instances, and (where possible) array shapes.
    For ops, the input and output variables are reported.
    For variables, the ops that they are inputs to - or outputs of - are also reported
    
    Returns:
    
    A String representation of the SameDiff instance

Class SameDiff

Method Summary

Methods inherited from class java.lang.Object

Method Detail

newCloner

updateVariableName

disableDebugging

enableDebugMode

f

invokeGraphOn

functionExists

getFunctionById

putFunctionForId

getInputsForFunction

getOutputsForFunction

getOutputVariablesForFunction

getInputVariablesForFunction

updateArrayForVarName

putArrayForVarName

putOrUpdateArrayForVarName

getShapeForVarName

updateShapeForVarName

updateShapeForVarName

putShapeForVarName

putOrUpdateShapeForVarName

shapeAlreadyExistsForVarName

arrayAlreadyExistsForVarName

getArrForVarName

associateArrayWithVariable

associateArrayWithVariable

putSubFunction

variableMap

invoke

definedFunctionNames

memoryForGraph

invoke

addPropertyToResolve

propertiesToResolveForFunction

hasPropertiesToResolve

getPropertyForFunction

addPropertyForFunction

addPropertyForFunction

addVariableMappingForField

getVarNameForFieldAndFunction

isImportVariable

addVarNameForImport

setBaseNameForFunctionInstanceId

getBaseNameForFunction

setupFunction

addOutgoingFor

addOutgoingFor

addArgsFor

addArgsFor

getVariableOutputFunction

getVariableArgOfFunctions

hasArgs

functions

hashCode

create

equals

create

eval

dup

numElements

variables

one

one

onesLike

onesLike

zero

zero

zerosLike

zerosLike

constant

constant

linspace

linspace

range

range

meshgrid