Class Ops

Represents an object for carrying out tensor operations.

Inheritance

object

Ops

CPUOps

GPUCommandBufferOps

GPUComputeOps

GPUPixelOps

Implements

IDisposable

Inherited Members

object.ToString()

object.Equals(object)

object.Equals(object, object)

object.ReferenceEquals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

Namespace: Unity.Sentis

Assembly: solution.dll

Syntax

public abstract class Ops : IDisposable

Constructors

Name	Description
Ops(BackendType, ITensorAllocator)	Instantiates and returns an Ops object.

Properties

Name	Description
backendType	The backend type for the operation execution.

Methods

Name	Description
Abs(TensorFloat)	Computes an output tensor by applying the element-wise Abs math function: f(x) = f(x) = |x|.
Abs(TensorInt)	Computes an output tensor by applying the element-wise Abs math function: f(x) = f(x) = |x|.
Acos(TensorFloat)	Computes an output tensor by applying the element-wise Acos trigonometric function: f(x) = acos(x).
Acosh(TensorFloat)	Computes an output tensor by applying the element-wise Acosh trigonometric function: f(x) = acosh(x).
Add(float, TensorFloat)	Performs an element-wise Add math operation between a float and a tensor: f(a, b) = a + b.
Add(TensorFloat, float)	Performs an element-wise Add math operation between a tensor and a float: f(a, b) = a + b.
Add(TensorFloat, TensorFloat)	Performs an element-wise Add math operation: f(a, b) = a + b. This supports numpy-style broadcasting of input tensors.
Add(TensorInt, TensorInt)	Performs an element-wise Add math operation: f(a, b) = a + b. This supports numpy-style broadcasting of input tensors.
And(TensorInt, TensorInt)	Performs an element-wise And logical operation: f(a, b) = a & b. This supports numpy-style broadcasting of input tensors.
ArgMax(TensorFloat, int, bool, bool)	Computes the indices of the maximum elements of the input tensor along a given axis.
ArgMax(TensorInt, int, bool, bool)	Computes the indices of the maximum elements of the input tensor along a given axis.
ArgMin(TensorFloat, int, bool, bool)	Computes the indices of the minimum elements of the input tensor along a given axis.
ArgMin(TensorInt, int, bool, bool)	Computes the indices of the minimum elements of the input tensor along a given axis.
Asin(TensorFloat)	Computes an output tensor by applying the element-wise Asin trigonometric function: f(x) = asin(x).
Asinh(TensorFloat)	Computes an output tensor by applying the element-wise Asinh trigonometric function: f(x) = asinh(x).
Atan(TensorFloat)	Computes an output tensor by applying the element-wise Atan trigonometric function: f(x) = atan(x).
Atanh(TensorFloat)	Computes an output tensor by applying the element-wise Atanh trigonometric function: f(x) = atanh(x).
AveragePool(TensorFloat, int[], int[], int[])	Calculates an output tensor by pooling the mean values of the input tensor across its spatial dimensions according to the given pool and stride values.
Bernoulli(TensorFloat, DataType, float?)	Generates an output tensor with values 0 or 1 from a Bernoulli distribution. The input tensor contains the probabilities to use for generating the output values.
Cast(Tensor, DataType)	Computes the output tensor using an element-wise Cast function: f(x) = (float)x or f(x) = (int)x depending on the value of toType.
Ceil(TensorFloat)	Computes an output tensor by applying the element-wise Ceil math function: f(x) = ceil(x).
Celu(TensorFloat, float)	Computes an output tensor by applying the element-wise Celu activation function: f(x) = max(0, x) + min(0, alpha * (exp(x / alpha) - 1)).
Clip(TensorFloat, float, float)	Computes an output tensor by applying the element-wise Clip math function: f(x) = clamp(X, min, max).
Clip(TensorInt, int, int)	Computes an output tensor by applying the element-wise Clip math function: f(x) = clamp(X, min, max).
Concat(Tensor[], int)	Calculates an output tensor by concatenating the input tensors along a given axis.
ConstantOfShape(TensorShape, int)	Generates a tensor with a given shape filled with a given value.
ConstantOfShape(TensorShape, float)	Generates a tensor with a given shape filled with a given value.
Conv(TensorFloat, TensorFloat, TensorFloat, int, int[], int[], int[])	Applies a convolution filter to an input tensor.
ConvTranspose(TensorFloat, TensorFloat, TensorFloat, int[], int[], int[])	Applies a transpose convolution filter to an input tensor.
Copy<T>(T)	Creates a copy of a given input tensor with the same shape and values.
Cos(TensorFloat)	Computes an output tensor by applying the element-wise Cos trigonometric function: f(x) = cos(x).
Cosh(TensorFloat)	Computes an output tensor by applying the element-wise Cosh trigonometric function: f(x) = cosh(x).
CumSum(TensorFloat, int, bool, bool)	Performs the cumulative sum along a given axis.
CumSum(TensorInt, int, bool, bool)	Performs the cumulative sum along a given axis.
Dense(TensorFloat, TensorFloat, TensorFloat)	Performs a matrix multiplication operation: f(X, w, b) = X x W + B. This supports numpy-style broadcasting of input tensors.
DepthToSpace(TensorFloat, int, DepthToSpaceMode)	Computes the output tensor by permuting data from depth into blocks of spatial data.
Dispose()	Disposes of the Ops and any associated memory.
Div(TensorFloat, float)	Performs an element-wise Div math operation between a tensor and a float: f(a, b) = a / b.
Div(TensorFloat, TensorFloat)	Performs an element-wise Div math operation: f(a, b) = a / b. This supports numpy-style broadcasting of input tensors.
Div(TensorInt, TensorInt)	Performs an element-wise Div math operation: f(a, b) = a / b. This supports numpy-style broadcasting of input tensors.
Elu(TensorFloat, float)	Computes an output tensor by applying the element-wise Elu activation function: f(x) = x if x >= 0, otherwise f(x) = alpha * (e^x - 1).
Equal(TensorFloat, TensorFloat)	Performs an element-wise Equal logical comparison operation: f(a, b) = 1 if a == b, otherwise f(x) = 0. This supports numpy-style broadcasting of input tensors.
Equal(TensorInt, TensorInt)	Performs an element-wise Equal logical comparison operation: f(a, b) = 1 if a == b, otherwise f(x) = 0. This supports numpy-style broadcasting of input tensors.
Erf(TensorFloat)	Computes an output tensor by applying the element-wise Erf activation function: f(x) = erf(x).
Exp(TensorFloat)	Computes an output tensor by applying the element-wise Exp math function: f(x) = exp(x).
Expand<T>(T, TensorShape)	Calculates an output tensor by broadcasting the input tensor into a given shape.
FMod(TensorFloat, TensorFloat)	Performs an element-wise Mod math operation: f(a, b) = a % b. The sign of the remainder is the same as the sign of the dividend, as in C#. This supports numpy-style broadcasting of input tensors.
FMod(TensorInt, TensorInt)	Performs an element-wise Mod math operation: f(a, b) = a % b. The sign of the remainder is the same as the sign of the dividend, as in C#. This supports numpy-style broadcasting of input tensors.
Floor(TensorFloat)	Computes an output tensor by applying the element-wise Floor math function: f(x) = floor(x).
GatherElements<T>(T, TensorInt, int)	Takes values from the input tensor indexed by the indices tensor along a given axis and concatenates them.
GatherND<T>(T, TensorInt, int)	Takes slices of values from the batched input tensor indexed by the indices tensor.
Gather<T>(T, TensorInt, int)	Takes values from the input tensor indexed by the indices tensor along a given axis and concatenates them.
Gelu(TensorFloat)	Computes an output tensor by applying the element-wise Gelu activation function: f(x) = x / 2 * (1 + erf(x / sqrt(2))).
GlobalAveragePool(TensorFloat)	Calculates an output tensor by pooling the mean values of the input tensor across all of its spatial dimensions. The spatial dimensions of the output are size 1.
GlobalMaxPool(TensorFloat)	Calculates an output tensor by pooling the maximum values of the input tensor across all of its spatial dimensions. The spatial dimensions of the output are size 1.
Greater(TensorFloat, TensorFloat)	Performs an element-wise Greater logical comparison operation: f(a, b) = 1 if a > b, otherwise f(x) = 0. This supports numpy-style broadcasting of input tensors.
Greater(TensorInt, TensorInt)	Performs an element-wise Greater logical comparison operation: f(a, b) = 1 if a > b, otherwise f(x) = 0. This supports numpy-style broadcasting of input tensors.
GreaterOrEqual(TensorFloat, TensorFloat)	Performs an element-wise GreaterOrEqual logical comparison operation: f(a, b) = 1 if a >= b, otherwise f(x) = 0. This supports numpy-style broadcasting of input tensors.
GreaterOrEqual(TensorInt, TensorInt)	Performs an element-wise GreaterOrEqual logical comparison operation: f(a, b) = 1 if a >= b, otherwise f(x) = 0. This supports numpy-style broadcasting of input tensors.
HardSigmoid(TensorFloat, float, float)	Computes an output tensor by applying the element-wise HardSigmoid activation function: f(x) = clamp(alpha * x + beta, 0, 1).
HardSwish(TensorFloat)	Computes an output tensor by applying the element-wise HardSwish activation function: f(x) = x * max(0, min(1, 1/6 * x + 0.5)).
Hardmax(TensorFloat, int)	Computes an output tensor by applying the Hardmax activation function along an axis: f(X, axis) = 1 if x is the first maximum value along the specified axis, otherwise f(x) = 0.
InstanceNormalization(TensorFloat, TensorFloat, TensorFloat, float)	Computes the mean variance on the spatial dimensions of the input tensor and normalizes them according to scale and bias tensors.
IsInf(TensorFloat, bool, bool)	Performs an element-wise IsInf logical operation: f(x) = 1 elementwise if x is +Inf and detectPositive is true, or x is -Inf and detectNegative is true. Otherwise f(x) = 0.
IsNaN(TensorFloat)	Performs an element-wise IsNaN logical operation: f(x) = 1 if x is NaN, otherwise f(x) = 0.
LRN(TensorFloat, float, float, float, int)	Normalizes the input tensor over local input regions.
LayerNormalization(TensorFloat, TensorFloat, TensorFloat, float)	Computes the mean variance on the last dimension of the input tensor and normalizes it according to scale and bias tensors.
LeakyRelu(TensorFloat, float)	Computes an output tensor by applying the element-wise LeakyRelu activation function: f(x) = x if x >= 0, otherwise f(x) = alpha * x.
Less(TensorFloat, TensorFloat)	Performs an element-wise Less logical comparison operation: f(a, b) = 1 if a < b, otherwise f(x) = 0. This supports numpy-style broadcasting of input tensors.
Less(TensorInt, TensorInt)	Performs an element-wise Less logical comparison operation: f(a, b) = 1 if a < b, otherwise f(x) = 0. This supports numpy-style broadcasting of input tensors.
LessOrEqual(TensorFloat, TensorFloat)	Performs an element-wise LessOrEqual logical comparison operation: f(a, b) = 1 if a <= b, otherwise f(x) = 0. This supports numpy-style broadcasting of input tensors.
LessOrEqual(TensorInt, TensorInt)	Performs an element-wise LessOrEqual logical comparison operation: f(a, b) = 1 if a <= b, otherwise f(x) = 0. This supports numpy-style broadcasting of input tensors.
Log(TensorFloat)	Computes an output tensor by applying the element-wise Log math function: f(x) = log(x).
LogSoftmax(TensorFloat, int)	Computes an output tensor by applying the LogSoftmax activation function along an axis: f(X, axis) = log(Softmax(X, axis)).
Mad(TensorFloat, float, float)	Performs an element-wise Mad math operation: multiplies and adds bias to a tensor: f(A, s, b) = s * A + b.
MatMul(TensorFloat, TensorFloat)	Performs a multi-dimensional matrix multiplication operation: f(a, b) = a x b.
MatMul2D(TensorFloat, TensorFloat, bool, bool)	Performs a matrix multiplication operation with optional transposes: f(a, b) = a' x b'.
Max(params TensorFloat[])	Performs an element-wise Max math operation: f(x1, x2 ... xn) = max(x1, x2 ... xn). This supports numpy-style broadcasting of input tensors.
Max(params TensorInt[])	Performs an element-wise Max math operation: f(x1, x2 ... xn) = max(x1, x2 ... xn). This supports numpy-style broadcasting of input tensors.
MaxPool(TensorFloat, int[], int[], int[])	Calculates an output tensor by pooling the maximum values of the input tensor across its spatial dimensions according to the given pool and stride values.
Mean(params TensorFloat[])	Performs an element-wise Mean math operation: f(x1, x2 ... xn) = (x1 + x2 ... xn) / n. This supports numpy-style broadcasting of input tensors.
Min(params TensorFloat[])	Performs an element-wise Min math operation: f(x1, x2 ... xn) = min(x1, x2 ... xn). This supports numpy-style broadcasting of input tensors.
Min(params TensorInt[])	Performs an element-wise Min math operation: f(x1, x2 ... xn) = min(x1, x2 ... xn). This supports numpy-style broadcasting of input tensors.
Mod(TensorInt, TensorInt)	Performs an element-wise Mod math operation: f(a, b) = a % b. The sign of the remainder is the same as the sign of the divisor, as in Python. This supports numpy-style broadcasting of input tensors.
Mul(float, TensorFloat)	Performs an element-wise Mul math operation between a float and a tensor: f(a, b) = a * b.
Mul(TensorFloat, float)	Performs an element-wise Mul math operation between a tensor and a float: f(a, b) = a * b.
Mul(TensorFloat, TensorFloat)	Performs an element-wise Mul math operation: f(a, b) = a * b. This supports numpy-style broadcasting of input tensors.
Mul(TensorInt, TensorInt)	Performs an element-wise Mul math operation: f(a, b) = a * b. This supports numpy-style broadcasting of input tensors.
Multinomial(TensorFloat, int, float?)	Represents a Multinomial random layer. This generates an output tensor with values from a multinomial distribution according to the probabilities given by the input tensor.
Neg(TensorFloat)	Computes an output tensor by applying the element-wise Neg math function: f(x) = -x.
Neg(TensorInt)	Computes an output tensor by applying the element-wise Neg math function: f(x) = -x.
Not(TensorInt)	Performs an element-wise Not logical operation: f(x) = ~x.
OneHot(TensorInt, int, int, int, int)	Generates a one-hot tensor with a given depth, indices and on and off values.
Or(TensorInt, TensorInt)	Performs an element-wise Or logical operation: f(a, b) = a | b. This supports numpy-style broadcasting of input tensors.
PRelu(TensorFloat, TensorFloat)	Computes an output tensor by applying the element-wise PRelu activation function: f(x) = x if x >= 0, otherwise f(x) = slope * x.
Pad(TensorFloat, ReadOnlySpan<int>, PadMode, float)	Calculates the output tensor by adding padding to the input tensor according to the given padding values and mode.
Pow(TensorFloat, TensorFloat)	Performs an element-wise Pow math operation: f(a, b) = pow(a, b). This supports numpy-style broadcasting of input tensors.
Pow(TensorFloat, TensorInt)	Performs an element-wise Pow math operation: f(a, b) = pow(a, b). This supports numpy-style broadcasting of input tensors.
RandomNormal(TensorShape, float, float, float?)	Generates an output tensor of a given shape with random values in a normal distribution with given mean and scale, and an optional seed value.
RandomUniform(TensorShape, float, float, float?)	Generates an output tensor of a given shape with random values in a uniform distribution between a given low and high, and an optional seed value.
Range(int, int, int)	Generates a 1D output tensor where the values form an arithmetic progression defined by the start, limit, and delta values.
Range(float, float, float)	Generates a 1D output tensor where the values form an arithmetic progression defined by the start, limit, and delta values.
Reciprocal(TensorFloat)	Computes an output tensor by applying the element-wise Reciprocal math function: f(x) = 1 / x.
ReduceL1(TensorFloat, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceL1 operation: f(x1, x2 ... xn) = |x1| + |x2| + ... + |xn|.
ReduceL1(TensorInt, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceL1 operation: f(x1, x2 ... xn) = |x1| + |x2| + ... + |xn|.
ReduceL2(TensorFloat, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceL2 operation: f(x1, x2 ... xn) = sqrt(x1² + x2² + ... + xn²).
ReduceLogSum(TensorFloat, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceLogSum operation: f(x1, x2 ... xn) = log(x1 + x2 + ... + xn).
ReduceLogSumExp(TensorFloat, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceLogSumExp operation: f(x1, x2 ... xn) = log(e^x1 + e^x2 + ... + e^xn).
ReduceMax(TensorFloat, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceMax operation: f(x1, x2 ... xn) = max(x1, x2, ... , xn).
ReduceMax(TensorInt, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceMean operation: f(x1, x2 ... xn) = max(x1, x2, ... , xn).
ReduceMean(TensorFloat, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceMean operation: f(x1, x2 ... xn) = (x1 + x2 + ... + xn) / n.
ReduceMin(TensorFloat, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceMin operation: f(x1, x2 ... xn) = min(x1, x2, ... , xn).
ReduceMin(TensorInt, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceMin operation: f(x1, x2 ... xn) = min(x1, x2, ... , xn).
ReduceProd(TensorFloat, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceProd operation: f(x1, x2 ... xn) = x1 * x2 * ... * xn.
ReduceProd(TensorInt, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceProd operation: f(x1, x2 ... xn) = x1 * x2 * ... * xn.
ReduceSum(TensorFloat, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceSum operation: f(x1, x2 ... xn) = x1 + x2 + ... + xn.
ReduceSum(TensorInt, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceSum operation: f(x1, x2 ... xn) = x1 + x2 + ... + xn.
ReduceSumSquare(TensorFloat, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceSumSquare operation: f(x1, x2 ... xn) = x1² + x2² + ... + xn².
ReduceSumSquare(TensorInt, ReadOnlySpan<int>, bool)	Reduces an input tensor along the given axes using the ReduceSumSquare operation: f(x1, x2 ... xn) = x1² + x2² + ... + xn².
Relu(TensorFloat)	Computes an output tensor by applying the element-wise Relu activation function: f(x) = max(0, x).
Relu6(TensorFloat)	Computes an output tensor by applying the element-wise Relu6 activation function: f(x) = clamp(X, 0, 6).
Reshape<T>(T, TensorShape)	Calculates an output tensor by copying the data from the input tensor and using a given shape. The data from the input tensor is unchanged.
Resize(TensorFloat, ReadOnlySpan<float>, InterpolationMode, NearestMode, CoordTransformMode)	Calculates an output tensor by resampling the input tensor along the spatial dimensions with given scales.
RoiAlign(TensorFloat, TensorFloat, TensorInt, RoiPoolingMode, int, int, int, float)	Calculates an output tensor by pooling the input tensor across each region of interest given by the rois tensor.
Round(TensorFloat)	Computes an output tensor by applying the element-wise Round math function: f(x) = round(x). If the fractional part is equal to 0.5, rounds to the nearest even integer.
ScaleBias(TensorFloat, TensorFloat, TensorFloat)	Computes the output tensor with an element-wise ScaleBias function: f(X, s, b) = x * s + b.
ScatterElements<T>(T, TensorInt, T, int, ScatterReductionMode)	Copies the input tensor and updates values at indexes specified by the indices tensor with values specified by the updates tensor along a given axis. ScatterElements updates the values depending on the reduction mode used.
ScatterND(TensorFloat, TensorInt, TensorFloat, ScatterReductionMode)	Copies the input tensor and updates values at indexes specified by the indices tensor with values specified by the updates tensor. ScatterND updates the values depending on the reduction mode used.
ScatterND(TensorInt, TensorInt, TensorInt, ScatterReductionMode)	Copies the input tensor and updates values at indexes specified by the indices tensor with values specified by the updates tensor. ScatterND updates the values depending on the reduction mode used.
Selu(TensorFloat, float, float)	Computes an output tensor by applying the element-wise Selu activation function: f(x) = gamma * x if x >= 0, otherwise f(x) = (alpha * e^x - alpha).
Set<T>(T, T, int, int, int)	Updates values of A with values from B similar to setting a slice in numpy. A[..., start:end, ....] = B This returns a new tensor rather than working on A in-place. This supports numpy-style one-directional broadcasting of B into A.
Shrink(TensorFloat, float, float)	Computes an output tensor by applying the element-wise Shrink activation function: f(x) = x + bias if x < lambd. f(x) = x - bias if x > lambd. Otherwise f(x) = 0.
Sigmoid(TensorFloat)	Computes an output tensor by applying the element-wise Sigmoid activation function: f(x) = 1/(1 + e^(-x)).
Sign(TensorFloat)	Performs an element-wise Sign math operation: f(x) = 1 if x > 0. f(x) = -1 if x < 0. Otherwise f(x) = 0.
Sign(TensorInt)	Performs an element-wise Sign math operation: f(x) = 1 if x > 0. f(x) = -1 if x < 0. Otherwise f(x) = 0.
Sin(TensorFloat)	Computes an output tensor by applying the element-wise Sin trigonometric function: f(x) = sin(x).
Sinh(TensorFloat)	Computes an output tensor by applying the element-wise Sinh trigonometric function: f(x) = sinh(x).
Slice<T>(T, ReadOnlySpan<int>, ReadOnlySpan<int>, ReadOnlySpan<int>, ReadOnlySpan<int>)	Calculates an output tensor by slicing the input tensor along given axes with given starts, ends, and steps.
Softmax(TensorFloat, int)	Computes an output tensor by applying the Softmax activation function along an axis: f(X, axis) = exp(X) / ReduceSum(exp(X), axis).
Softplus(TensorFloat)	Computes an output tensor by applying the element-wise Softplus activation function: f(x) = ln(e^x + 1).
Softsign(TensorFloat)	Computes an output tensor by applying the element-wise Softsign activation function: f(x) = x/(|x| + 1).
SpaceToDepth(TensorFloat, int)	Computes the output tensor by permuting data from blocks of spatial data into depth.
Split<T>(T, int, int, int)	Calculates an output tensor by splitting the input tensor along a given axis between start and end.
Sqrt(TensorFloat)	Computes an output tensor by applying the element-wise Sqrt math function: f(x) = sqrt(x).
Square(TensorFloat)	Computes an output tensor by applying the element-wise Square math function: f(x) = x * x.
Sub(float, TensorFloat)	Performs an element-wise Sub math operation between a float and a tensor: f(a, b) = a - b.
Sub(TensorFloat, float)	Performs an element-wise Sub math operation between a tensor and a float: f(a, b) = a - b.
Sub(TensorFloat, TensorFloat)	Performs an element-wise Sub math operation: f(a, b) = a - b. This supports numpy-style broadcasting of input tensors.
Sub(TensorInt, TensorInt)	Performs an element-wise Sub math operation: f(a, b) = a - b. This supports numpy-style broadcasting of input tensors.
Sum(params TensorFloat[])	Performs an element-wise Sum math operation: f(x1, x2 ... xn) = x1 + x2 ... xn. This supports numpy-style broadcasting of input tensors.
Swish(TensorFloat)	Computes an output tensor by applying the element-wise Swish activation function: f(x) = sigmoid(x) * x = x / (1 + e^{-x}).
Tan(TensorFloat)	Computes an output tensor by applying the element-wise Tan trigonometric function: f(x) = tan(x).
Tanh(TensorFloat)	Computes an output tensor by applying the element-wise Tanh activation function: f(x) = tanh(x).
ThresholdedRelu(TensorFloat, float)	Computes an output tensor by applying the element-wise ThresholdedRelu activation function: f(x) = x if x > alpha, otherwise f(x) = 0.
Tile<T>(T, ReadOnlySpan<int>)	Calculates an output tensor by repeating the input layer a given number of times along each axis.
TopK(TensorFloat, int, int, bool, bool)	Calculates the top-K largest or smallest elements of an input tensor along a given axis.
Transpose<T>(T)	Calculates an output tensor by reversing the dimensions of the input tensor.
Transpose<T>(T, int[])	Calculates an output tensor by permuting the axes and data of the input tensor according to the given permutations.
Tril<T>(T, int)	Computes the output tensor by retaining the lower triangular values from an input matrix or matrix batch and setting the other values to zero.
Triu<T>(T, int)	Computes the output tensor by retaining the upper triangular values from an input matrix or matrix batch and setting the other values to zero.
Where<T>(TensorInt, T, T)	Performs an element-wise Where logical operation: f(condition, a, b) = a if condition is true, otherwise f(condition, a, b) = b.
Xor(TensorInt, TensorInt)	Performs an element-wise Xor logical operation: f(a) = a ^ b.