Trait Numeric 

pub trait Numeric<B: Backend>: BasicOps<B>
where
    Self::Elem: Element,
{
    // Required methods
    fn add(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    fn add_scalar<E: ElementConversion>(
        lhs: Self::Primitive,
        rhs: E,
    ) -> Self::Primitive;
    fn sub(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    fn sub_scalar<E: ElementConversion>(
        lhs: Self::Primitive,
        rhs: E,
    ) -> Self::Primitive;
    fn div(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    fn div_scalar<E: ElementConversion>(
        lhs: Self::Primitive,
        rhs: E,
    ) -> Self::Primitive;
    fn remainder(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    fn remainder_scalar<E: ElementConversion>(
        lhs: Self::Primitive,
        rhs: E,
    ) -> Self::Primitive;
    fn mul(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    fn mul_scalar<E: ElementConversion>(
        lhs: Self::Primitive,
        rhs: E,
    ) -> Self::Primitive;
    fn neg(tensor: Self::Primitive) -> Self::Primitive;
    fn sign(tensor: Self::Primitive) -> Self::Primitive;
    fn sum(tensor: Self::Primitive) -> Self::Primitive;
    fn sum_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    fn prod(tensor: Self::Primitive) -> Self::Primitive;
    fn prod_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    fn mean(tensor: Self::Primitive) -> Self::Primitive;
    fn mean_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    fn cumsum(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    fn cumprod(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    fn cummin(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    fn cummax(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    fn greater(
        lhs: Self::Primitive,
        rhs: Self::Primitive,
    ) -> B::BoolTensorPrimitive;
    fn greater_elem(
        lhs: Self::Primitive,
        rhs: Self::Elem,
    ) -> B::BoolTensorPrimitive;
    fn greater_equal(
        lhs: Self::Primitive,
        rhs: Self::Primitive,
    ) -> B::BoolTensorPrimitive;
    fn greater_equal_elem(
        lhs: Self::Primitive,
        rhs: Self::Elem,
    ) -> B::BoolTensorPrimitive;
    fn lower(
        lhs: Self::Primitive,
        rhs: Self::Primitive,
    ) -> B::BoolTensorPrimitive;
    fn lower_elem(
        lhs: Self::Primitive,
        rhs: Self::Elem,
    ) -> B::BoolTensorPrimitive;
    fn lower_equal(
        lhs: Self::Primitive,
        rhs: Self::Primitive,
    ) -> B::BoolTensorPrimitive;
    fn lower_equal_elem(
        lhs: Self::Primitive,
        rhs: Self::Elem,
    ) -> B::BoolTensorPrimitive;
    fn argmax(tensor: Self::Primitive, dim: usize) -> IntTensor<B>;
    fn argmin(tensor: Self::Primitive, dim: usize) -> IntTensor<B>;
    fn max(tensor: Self::Primitive) -> Self::Primitive;
    fn max_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    fn max_dim_with_indices(
        tensor: Self::Primitive,
        dim: usize,
    ) -> (Self::Primitive, IntTensor<B>);
    fn max_abs(tensor: Self::Primitive) -> Self::Primitive;
    fn max_abs_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    fn min(tensor: Self::Primitive) -> Self::Primitive;
    fn min_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive;
    fn min_dim_with_indices(
        tensor: Self::Primitive,
        dim: usize,
    ) -> (Self::Primitive, IntTensor<B>);
    fn clamp(
        tensor: Self::Primitive,
        min: Self::Elem,
        max: Self::Elem,
    ) -> Self::Primitive;
    fn clamp_min(tensor: Self::Primitive, min: Self::Elem) -> Self::Primitive;
    fn clamp_max(tensor: Self::Primitive, max: Self::Elem) -> Self::Primitive;
    fn abs(tensor: Self::Primitive) -> Self::Primitive;
    fn powf(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    fn powi(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
    fn powf_scalar<E: ElementConversion>(
        lhs: Self::Primitive,
        rhs: E,
    ) -> Self::Primitive;
    fn powi_scalar<E: ElementConversion>(
        lhs: Self::Primitive,
        rhs: E,
    ) -> Self::Primitive;
    fn random(
        shape: Shape,
        distribution: Distribution,
        device: &B::Device,
    ) -> Self::Primitive;
    fn sort(
        tensor: Self::Primitive,
        dim: usize,
        descending: bool,
    ) -> Self::Primitive;
    fn sort_with_indices(
        tensor: Self::Primitive,
        dim: usize,
        descending: bool,
    ) -> (Self::Primitive, IntTensor<B>);
    fn argsort(
        tensor: Self::Primitive,
        dim: usize,
        descending: bool,
    ) -> IntTensor<B>;
    fn matmul(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive;
}

Trait that list all operations that can be applied on all numerical tensors.

Warnings

This is an internal trait, use the public API provided by the Tensor struct.

Required Methods

fn add(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive

Adds two tensors together.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side tensor.

Returns

The sum of the two tensors.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For adding tensors, users should prefer the Tensor::add function, which is more high-level and designed for public use.

fn add_scalar<E: ElementConversion>( lhs: Self::Primitive, rhs: E, ) -> Self::Primitive

Adds a scalar to a tensor element-wise.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side scalar.

Returns

The sum of the tensor and the scalar.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For adding a scalar to a tensor, users should prefer the Tensor::add_scalar function, which is more high-level and designed for public use.

fn sub(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive

Subtracts two tensors.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side tensor.

Returns

The difference of the two tensors.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For subtracting tensors, users should prefer the Tensor::sub function, which is more high-level and designed for public use.

fn sub_scalar<E: ElementConversion>( lhs: Self::Primitive, rhs: E, ) -> Self::Primitive

Subtracts a scalar from a tensor element-wise.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side scalar.

Returns

The difference of the tensor and the scalar.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For subtracting a scalar from a tensor, users should prefer the Tensor::sub_scalar function, which is more high-level and designed for public use.

fn div(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive

Divides two tensors.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side tensor.

Returns

The quotient of the two tensors.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For dividing tensors, users should prefer the Tensor::div function, which is more high-level and designed for public use.

fn div_scalar<E: ElementConversion>( lhs: Self::Primitive, rhs: E, ) -> Self::Primitive

Divides a tensor by a scalar element-wise.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side scalar.

Returns

The quotient of the tensor and the scalar.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For dividing a tensor by a scalar, users should prefer the Tensor::div_scalar function, which is more high-level and designed for public use.

fn remainder(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive

Computes the modulo element-wise. The result is the signed remainder of the division and its absolute value is less than that of the divisor.

Arguments

• lhs - The dividend.
• rhs - The divisor.

Returns

The modulo of the input tensor with the divisor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For performing the modulo operation, users should prefer the Tensor::remainder function, which is more high-level and designed for public use.

fn remainder_scalar<E: ElementConversion>( lhs: Self::Primitive, rhs: E, ) -> Self::Primitive

Computes the modulo element-wise. The result is the signed remainder of the division and its absolute value is less than that of the divisor.

Arguments

• lhs - The dividend.
• rhs - The divisor.

Returns

The modulo of the input tensor with the divisor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For performing the modulo operation, users should prefer the Tensor::remainder_scalar function, which is more high-level and designed for public use.

fn mul(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive

Multiplies two tensors.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side tensor.

Returns

The product of the two tensors.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For multiplying tensors, users should prefer the Tensor::mul function, which is more high-level and designed for public use.

fn mul_scalar<E: ElementConversion>( lhs: Self::Primitive, rhs: E, ) -> Self::Primitive

Multiplies a tensor by a scalar element-wise.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side scalar.

Returns

The product of the tensor and the scalar.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For multiplying a tensor by a scalar, users should prefer the Tensor::mul_scalar function, which is more high-level and designed for public use.

fn neg(tensor: Self::Primitive) -> Self::Primitive

Negates a tensor.

Arguments

• tensor - The tensor to negate.

Returns

The negated tensor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For negating a tensor, users should prefer the Tensor::neg function, which is more high-level and designed for public use.

fn sign(tensor: Self::Primitive) -> Self::Primitive

Returns the signs of the elements of a tensor.

Arguments

• tensor - The tensor.

Returns

The signs of the elements of the tensor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For getting the signs of the elements of a tensor, users should prefer the Tensor::sign function, which is more high-level and designed for public use.

fn sum(tensor: Self::Primitive) -> Self::Primitive

Sums all the elements of the tensor.

Arguments

• tensor - The tensor to sum.

Returns

The sum of all the elements of the tensor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For summing all the elements of a tensor, users should prefer the Tensor::sum function, which is more high-level and designed for public use.

fn sum_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive

Sums all the elements of the tensor along a dimension.

Arguments

• tensor - The tensor to sum.
• dim - The dimension along which to sum.

Returns

The sum of all the elements of the tensor along the specified dimension.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For summing all the elements of a tensor along a dimension, users should prefer the Tensor::sum_dim function, which is more high-level and designed for public use.

fn prod(tensor: Self::Primitive) -> Self::Primitive

Computes the product of all the elements of the tensor.

Arguments

• tensor - The tensor to compute the product of.

Returns

The product of all the elements of the tensor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For computing the product of all the elements of a tensor, users should prefer the Tensor::prod function, which is more high-level and designed for public use.

fn prod_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive

Computes the product of all the elements of the tensor along a dimension.

Arguments

• tensor - The tensor to compute the product of.
• dim - The dimension along which to compute the product.

Returns

The product of all the elements of the tensor along the specified dimension.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For computing the product of all the elements of a tensor along a dimension, users should prefer the Tensor::prod_dim function, which is more high-level and designed for public use.

fn mean(tensor: Self::Primitive) -> Self::Primitive

Computes the mean of all the elements of the tensor.

Arguments

• tensor - The tensor to compute the mean of.

Returns

The mean of all the elements of the tensor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For computing the mean of all the elements of a tensor, users should prefer the Tensor::mean function, which is more high-level and designed for public use.

fn mean_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive

Computes the mean of all the elements of the tensor along a dimension.

Arguments

• tensor - The tensor to compute the mean of.
• dim - The dimension along which to compute the mean.

Returns

The mean of all the elements of the tensor along the specified dimension.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For computing the mean of all the elements of a tensor along a dimension, users should prefer the Tensor::mean_dim function, which is more high-level and designed for public use.

fn cumsum(tensor: Self::Primitive, dim: usize) -> Self::Primitive

Computes the cumulative sum of elements along a dimension.

Arguments

• tensor - The tensor to compute the cumulative sum of.
• dim - The dimension along which to compute the cumulative sum.

Returns

A tensor with the same shape as the input tensor, where each element is the cumulative sum of all elements up to and including that position along the specified dimension.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For computing the cumulative sum of elements along a dimension, users should prefer the Tensor::cumsum function, which is more high-level and designed for public use.

fn cumprod(tensor: Self::Primitive, dim: usize) -> Self::Primitive

Computes the cumulative product of elements along a dimension.

Arguments

• tensor - The tensor to compute the cumulative product of.
• dim - The dimension along which to compute the cumulative product.

Returns

A tensor with the same shape as the input tensor, where each element is the cumulative product of all elements up to and including that position along the specified dimension.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For computing the cumulative product of elements along a dimension, users should prefer the Tensor::cumprod function, which is more high-level and designed for public use.

fn cummin(tensor: Self::Primitive, dim: usize) -> Self::Primitive

Computes the cumulative minimum of elements along a dimension.

Arguments

• tensor - The tensor to compute the cumulative minimum of.
• dim - The dimension along which to compute the cumulative minimum.

Returns

A tensor with the same shape as the input tensor, where each element is the minimum of all elements up to and including that position along the specified dimension.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For computing the cumulative minimum of elements along a dimension, users should prefer the Tensor::cummin function, which is more high-level and designed for public use.

fn cummax(tensor: Self::Primitive, dim: usize) -> Self::Primitive

Computes the cumulative maximum of elements along a dimension.

Arguments

• tensor - The tensor to compute the cumulative maximum of.
• dim - The dimension along which to compute the cumulative maximum.

Returns

A tensor with the same shape as the input tensor, where each element is the maximum of all elements up to and including that position along the specified dimension.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For computing the cumulative maximum of elements along a dimension, users should prefer the Tensor::cummax function, which is more high-level and designed for public use.

fn greater(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTensorPrimitive

Element-wise greater than comparison between two tensors.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side tensor.

Returns

A boolean tensor with the same shape as the input tensors, where each element is true if the corresponding element of the left hand side tensor is greater than the corresponding element of the right hand side tensor, and false otherwise.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For element-wise greater than comparison between two tensors, users should prefer the Tensor::greater function, which is more high-level and designed for public use.

fn greater_elem(lhs: Self::Primitive, rhs: Self::Elem) -> B::BoolTensorPrimitive

Element-wise greater than comparison between a tensor and a scalar.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side scalar.

Returns

A boolean tensor with the same shape as the input tensor, where each element is true if the corresponding element of the left hand side tensor is greater than the right hand side scalar, and false otherwise.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For element-wise greater than comparison between a tensor and a scalar, users should prefer the Tensor::greater_elem function, which is more high-level and designed for public use.

fn greater_equal( lhs: Self::Primitive, rhs: Self::Primitive, ) -> B::BoolTensorPrimitive

Element-wise greater than or equal comparison between two tensors.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side tensor.

Returns

A boolean tensor with the same shape as the input tensors, where each element is true if the corresponding element of the left hand side tensor is greater than or equal to the corresponding element of the right hand side tensor, and false otherwise.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For element-wise greater than or equal comparison between two tensors, users should prefer the Tensor::greater_equal function, which is more high-level and designed for public use.

fn greater_equal_elem( lhs: Self::Primitive, rhs: Self::Elem, ) -> B::BoolTensorPrimitive

Element-wise greater than or equal comparison between a tensor and a scalar.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side scalar.

Returns

A boolean tensor with the same shape as the input tensor, where each element is true if the corresponding element of the left hand side tensor is greater than or equal to the right hand side scalar, and false otherwise.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For element-wise greater than or equal comparison between a tensor and a scalar, users should prefer the Tensor::greater_equal_elem function, which is more high-level and designed for public use.

fn lower(lhs: Self::Primitive, rhs: Self::Primitive) -> B::BoolTensorPrimitive

Element-wise less than comparison between two tensors.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side tensor.

Returns

A boolean tensor with the same shape as the input tensors, where each element is true if the corresponding element of the left hand side tensor is less than the corresponding element of the right hand side tensor, and false otherwise.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For element-wise less than comparison between two tensors, users should prefer the Tensor::lower function, which is more high-level and designed for public use.

fn lower_elem(lhs: Self::Primitive, rhs: Self::Elem) -> B::BoolTensorPrimitive

Element-wise less than comparison between a tensor and a scalar.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side scalar.

Returns

A boolean tensor with the same shape as the input tensor, where each element is true if the corresponding element of the left hand side tensor is less than the right hand side scalar, and false otherwise.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For element-wise less than comparison between a tensor and a scalar, users should prefer the Tensor::lower_elem function, which is more high-level and designed for public use.

fn lower_equal( lhs: Self::Primitive, rhs: Self::Primitive, ) -> B::BoolTensorPrimitive

Element-wise less than or equal comparison between two tensors.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side tensor.

Returns

A boolean tensor with the same shape as the input tensors, where each element is true if the corresponding element of the left hand side tensor is less than or equal to the corresponding element of the right hand side tensor, and false otherwise.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For element-wise less than or equal comparison between two tensors, users should prefer the Tensor::lower_equal function, which is more high-level and designed for public use.

fn lower_equal_elem( lhs: Self::Primitive, rhs: Self::Elem, ) -> B::BoolTensorPrimitive

Element-wise less than or equal comparison between a tensor and a scalar.

Arguments

• lhs - The left hand side tensor.
• rhs - The right hand side scalar.

Returns

A boolean tensor with the same shape as the input tensor, where each element is true if the corresponding element of the left hand side tensor is less than or equal to the right hand side scalar, and false otherwise.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For element-wise less than or equal comparison between a tensor and a scalar, users should prefer the Tensor::lower_equal_elem function, which is more high-level and designed for public use.

fn argmax(tensor: Self::Primitive, dim: usize) -> IntTensor<B>

Gets the indices of the maximum elements of a tensor along an axis.

Arguments

• dim - The axis along which to get the indices of the maximum elements.
• tensor - The tensor to get the indices of the maximum elements from.

Returns

A tensor with the same shape as the input tensor, where each element is the index of the maximum element of the input tensor at the corresponding index along the specified axis.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For getting the indices of the maximum elements of a tensor along an axis, users should prefer the Tensor::argmax function, which is more high-level and designed for public use.

fn argmin(tensor: Self::Primitive, dim: usize) -> IntTensor<B>

Gets the indices of the minimum elements of a tensor along an axis.

Arguments

• dim - The axis along which to get the indices of the minimum elements.
• tensor - The tensor to get the indices of the minimum elements from.

Returns

A tensor with the same shape as the input tensor, where each element is the index of the minimum element of the input tensor at the corresponding index along the specified axis.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For getting the indices of the minimum elements of a tensor along an axis, users should prefer the Tensor::argmin function, which is more high-level and designed for public use.

fn max(tensor: Self::Primitive) -> Self::Primitive

Gets the maximum elements of a tensor along an axis.

Arguments

• dim - The axis along which to get the maximum elements.

Returns

A single-element tensor containing the maximum element of the input tensor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For getting the maximum elements of a tensor along an axis, users should prefer the Tensor::max function, which is more high-level and designed for public use.

fn max_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive

Gets the maximum elements of a tensor along an axis.

Arguments

• tensor - The tensor to get the maximum elements from.
• dim - The axis along which to get the maximum elements.

Returns

A tensor with the same rank as the input tensor, but the given dim set to a shape of 1. Each element is the maximum element of the corresponding input dim.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For getting the maximum elements of a tensor along an axis, users should prefer the Tensor::max_dim function, which is more high-level and designed for public use.

fn max_dim_with_indices( tensor: Self::Primitive, dim: usize, ) -> (Self::Primitive, IntTensor<B>)

Gets the maximum elements of a tensor along an axis.

Arguments

• tensor - The tensor to get the maximum elements from.
• dim - The axis along which to get the maximum elements.

Returns

A tuple containing the maximum element of the input tensor, and a tensor with the same shape as the input tensor, where each element is the index of the maximum element of the input tensor at the corresponding index along the specified axis.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For getting the maximum elements of a tensor along an axis, users should prefer the Tensor::max_dim_with_indices function, which is more high-level and designed for public use.

fn max_abs(tensor: Self::Primitive) -> Self::Primitive

Gets the maximum elements of a tensor along an axis.

Arguments

• dim - The axis along which to get the maximum elements.

Returns

A single-element tensor containing the maximum absolute element of the input tensor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For getting the maximum absolute elements of a tensor, users should prefer the Tensor::max_abs function, which is more high-level and designed for public use.

fn max_abs_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive

Gets the maximum elements of a tensor along an axis.

Arguments

• tensor - The tensor to get the maximum elements from.
• dim - The axis along which to get the maximum elements.

Returns

A tensor with the same rank as the input tensor, but the given dim set to a shape of 1. Each element is the maximum absolute element of the corresponding input dim.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For getting the maximum elements of a tensor along an axis, users should prefer the Tensor::max_abs_dim function, which is more high-level and designed for public use.

fn min(tensor: Self::Primitive) -> Self::Primitive

Gets the minimum elements of a tensor along an axis.

Arguments

• tensor - The tensor to get the minimum elements from.

Returns

A single-element tensor containing the minimum element of the input tensor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For getting the minimum elements of a tensor along an axis, users should prefer the Tensor::min function, which is more high-level and designed for public use.

fn min_dim(tensor: Self::Primitive, dim: usize) -> Self::Primitive

Gets the minimum elements of a tensor along an axis.

Arguments

• tensor - The tensor to get the minimum elements from.
• dim - The axis along which to get the minimum elements.

Returns

A tensor with the same rank as the input tensor, but the given dim set to a shape of 1. Each element is the minimum element of the corresponding input dim.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For getting the minimum elements of a tensor along an axis, users should prefer the Tensor::min_dim function, which is more high-level and designed for public use.

fn min_dim_with_indices( tensor: Self::Primitive, dim: usize, ) -> (Self::Primitive, IntTensor<B>)

Gets the minimum elements and indices of a tensor along an axis.

Arguments

• tensor - The tensor to get the minimum elements from.

Returns

A tensor with the same shape as the input tensor and corresponding indices, where each element is the minimum element of the input tensor at the corresponding index along the specified axis.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For getting the minimum elements of a tensor along an axis, users should prefer the Tensor::min_dim_with_indices function, which is more high-level and designed for public use.

fn clamp( tensor: Self::Primitive, min: Self::Elem, max: Self::Elem, ) -> Self::Primitive

Clamp the tensor between the given min and max values.

Arguments

• min - The minimum value.
• max - The maximum value.

Returns

A new tensor with the values clamped between the given min and max values.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users.

For clamping a tensor between the given min and max values, users should prefer the Tensor::clamp function, which is more high-level and designed for public use.

fn clamp_min(tensor: Self::Primitive, min: Self::Elem) -> Self::Primitive

Clamps a tensor under a minimum value.

Arguments

• tensor - The tensor to clamp.
• min - The minimum value.

Returns

A new tensor with the values clamped under the given min value.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users.

For clamping a tensor under a minimum value, users should prefer the Tensor::clamp_min function, which is more high-level and designed for public use.

fn clamp_max(tensor: Self::Primitive, max: Self::Elem) -> Self::Primitive

Clamps a tensor over a maximum value.

Arguments

• tensor - The tensor to clamp.
• max - The maximum value.

Returns

A new tensor with the values clamped over the given max value.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users.

For clamping a tensor over a maximum value, users should prefer the Tensor::clamp_max function, which is more high-level and designed for public use.

fn abs(tensor: Self::Primitive) -> Self::Primitive

Calculate absolute value on all elements of a tensor

Arguments

• tensor - The tensor to apply abs to.

Returns

A tensor with absolute values.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For calculating abs of the elements of a tensor, users should prefer the Tensor::abs function, which is more high-level and designed for public use.

fn powf(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive

Element-wise power of a tensor to a float tensor

Arguments

• tensor - The tensor to apply power to.
• power - The power to apply to the tensor.

fn powi(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive

Element-wise power of a tensor

Arguments

• tensor - The tensor to apply power to.
• power - The power to apply to the tensor.

fn powf_scalar<E: ElementConversion>( lhs: Self::Primitive, rhs: E, ) -> Self::Primitive

Element-wise power of a tensor to a scalar float

Arguments

• tensor - The tensor to apply power to.
• power - The power to apply to the tensor.

fn powi_scalar<E: ElementConversion>( lhs: Self::Primitive, rhs: E, ) -> Self::Primitive

Element-wise power of a tensor to a scalar int

Arguments

• tensor - The tensor to apply power to.
• power - The power to apply to the tensor.

fn random( shape: Shape, distribution: Distribution, device: &B::Device, ) -> Self::Primitive

Create a random tensor.

Arguments

• shape - The shape of the output tensor.
• distribution - The distribution used to sample.
• device - The device to use.

Returns

A new tensor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

Users should prefer the Tensor::random function, which is more high-level and designed for public use.

fn sort( tensor: Self::Primitive, dim: usize, descending: bool, ) -> Self::Primitive

Sort the elements of the input tensor by value along a given dimension.

This sort is unstable (i.e., may reorder equal elements).

Arguments

• tensor - The input tensor.
• dim - The axis along which to sort.
• descending - The sorting order.

Returns

A tensor with the same shape as the input tensor, where the elements are sorted by value.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

Users should prefer the Tensor::sort function, which is more high-level and designed for public use.

fn sort_with_indices( tensor: Self::Primitive, dim: usize, descending: bool, ) -> (Self::Primitive, IntTensor<B>)

Sort the elements of the input tensor by value along a given dimension.

This sort is unstable (i.e., may reorder equal elements).

Arguments

• tensor - The input tensor.
• dim - The axis along which to sort.
• descending - The sorting order.

Returns

A tensor with the same shape as the input tensor and corresponding indices, where the elements are sorted by value and the indices map back to the original input tensor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

For sorting the elements of a tensor, users should prefer the Tensor::sort_with_indices function, which is more high-level and designed for public use.

fn argsort( tensor: Self::Primitive, dim: usize, descending: bool, ) -> IntTensor<B>

Returns the indices that sort the elements of the input tensor by value along a given dimension.

This sort is unstable (i.e., may reorder equal elements).

Arguments

• tensor - The input tensor.
• dim - The axis along which to sort.
• descending - The sorting order.

Returns

A tensor with the same shape as the input tensor the indices map back to the original input tensor.

Remarks

This is a low-level function used internally by the library to call different backend functions with static dispatch. It is not designed for direct usage by users, and not recommended to import or use this function directly.

Users should prefer the Tensor::argsort function, which is more high-level and designed for public use.

fn matmul(lhs: Self::Primitive, rhs: Self::Primitive) -> Self::Primitive

Applies the matrix multiplication operation.

C = AB

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<B: Backend> Numeric<B> for Float

impl<B: Backend> Numeric<B> for Int