Trait burn::tensor::Numeric

pub trait Numeric<B>: BasicOps<B>
where
    B: Backend,
    Self::Elem: Element,
{
    // Required methods
    fn add<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Primitive<D>,
    ) -> Self::Primitive<D>;
    fn add_scalar<const D: usize, E>(
        lhs: Self::Primitive<D>,
        rhs: E,
    ) -> Self::Primitive<D>
       where E: ElementConversion;
    fn sub<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Primitive<D>,
    ) -> Self::Primitive<D>;
    fn sub_scalar<const D: usize, E>(
        lhs: Self::Primitive<D>,
        rhs: E,
    ) -> Self::Primitive<D>
       where E: ElementConversion;
    fn div<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Primitive<D>,
    ) -> Self::Primitive<D>;
    fn div_scalar<const D: usize, E>(
        lhs: Self::Primitive<D>,
        rhs: E,
    ) -> Self::Primitive<D>
       where E: ElementConversion;
    fn remainder_scalar<const D: usize, E>(
        lhs: Self::Primitive<D>,
        rhs: E,
    ) -> Self::Primitive<D>
       where E: ElementConversion;
    fn mul<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Primitive<D>,
    ) -> Self::Primitive<D>;
    fn mul_scalar<const D: usize, E>(
        lhs: Self::Primitive<D>,
        rhs: E,
    ) -> Self::Primitive<D>
       where E: ElementConversion;
    fn neg<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<D>;
    fn sign<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<D>;
    fn zeros<const D: usize>(
        shape: Shape<D>,
        device: &<B as Backend>::Device,
    ) -> Self::Primitive<D>;
    fn ones<const D: usize>(
        shape: Shape<D>,
        device: &<B as Backend>::Device,
    ) -> Self::Primitive<D>;
    fn full<const D: usize, E>(
        shape: Shape<D>,
        fill_value: E,
        device: &<B as Backend>::Device,
    ) -> Self::Primitive<D>
       where E: ElementConversion;
    fn sum<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<1>;
    fn sum_dim<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
    ) -> Self::Primitive<D>;
    fn prod<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<1>;
    fn prod_dim<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
    ) -> Self::Primitive<D>;
    fn mean<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<1>;
    fn mean_dim<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
    ) -> Self::Primitive<D>;
    fn equal_elem<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Elem,
    ) -> Tensor<B, D, Bool>;
    fn not_equal_elem<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Elem,
    ) -> Tensor<B, D, Bool>;
    fn greater<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Primitive<D>,
    ) -> Tensor<B, D, Bool>;
    fn greater_elem<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Elem,
    ) -> Tensor<B, D, Bool>;
    fn greater_equal<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Primitive<D>,
    ) -> Tensor<B, D, Bool>;
    fn greater_equal_elem<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Elem,
    ) -> Tensor<B, D, Bool>;
    fn lower<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Primitive<D>,
    ) -> Tensor<B, D, Bool>;
    fn lower_elem<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Elem,
    ) -> Tensor<B, D, Bool>;
    fn lower_equal<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Primitive<D>,
    ) -> Tensor<B, D, Bool>;
    fn lower_equal_elem<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Elem,
    ) -> Tensor<B, D, Bool>;
    fn mask_where<const D: usize>(
        tensor: Self::Primitive<D>,
        mask: Tensor<B, D, Bool>,
        source: Self::Primitive<D>,
    ) -> Self::Primitive<D>;
    fn mask_fill<const D: usize>(
        tensor: Self::Primitive<D>,
        mask: Tensor<B, D, Bool>,
        value: Self::Elem,
    ) -> Self::Primitive<D>;
    fn gather<const D: usize>(
        dim: usize,
        tensor: Self::Primitive<D>,
        indices: Tensor<B, D, Int>,
    ) -> Self::Primitive<D>;
    fn scatter<const D: usize>(
        dim: usize,
        tensor: Self::Primitive<D>,
        indices: Tensor<B, D, Int>,
        values: Self::Primitive<D>,
    ) -> Self::Primitive<D>;
    fn select<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
        indices: Tensor<B, 1, Int>,
    ) -> Self::Primitive<D>;
    fn select_assign<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
        indices: Tensor<B, 1, Int>,
        values: Self::Primitive<D>,
    ) -> Self::Primitive<D>;
    fn argmax<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
    ) -> <B as Backend>::IntTensorPrimitive<D>;
    fn argmin<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
    ) -> <B as Backend>::IntTensorPrimitive<D>;
    fn max<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<1>;
    fn max_dim<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
    ) -> Self::Primitive<D>;
    fn max_dim_with_indices<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
    ) -> (Self::Primitive<D>, <B as Backend>::IntTensorPrimitive<D>);
    fn min<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<1>;
    fn min_dim<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
    ) -> Self::Primitive<D>;
    fn min_dim_with_indices<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
    ) -> (Self::Primitive<D>, <B as Backend>::IntTensorPrimitive<D>);
    fn clamp<const D: usize>(
        tensor: Self::Primitive<D>,
        min: Self::Elem,
        max: Self::Elem,
    ) -> Self::Primitive<D>;
    fn clamp_min<const D: usize>(
        tensor: Self::Primitive<D>,
        min: Self::Elem,
    ) -> Self::Primitive<D>;
    fn clamp_max<const D: usize>(
        tensor: Self::Primitive<D>,
        max: Self::Elem,
    ) -> Self::Primitive<D>;
    fn abs<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<D>;
    fn powf<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Primitive<D>,
    ) -> Self::Primitive<D>;
    fn powi<const D: usize>(
        lhs: Self::Primitive<D>,
        rhs: Self::Primitive<D>,
    ) -> Self::Primitive<D>;
    fn powf_scalar<const D: usize, E>(
        lhs: Self::Primitive<D>,
        rhs: E,
    ) -> Self::Primitive<D>
       where E: ElementConversion;
    fn powi_scalar<const D: usize, E>(
        lhs: Self::Primitive<D>,
        rhs: E,
    ) -> Self::Primitive<D>
       where E: ElementConversion;
    fn random<const D: usize>(
        shape: Shape<D>,
        distribution: Distribution,
        device: &<B as Backend>::Device,
    ) -> Self::Primitive<D>;
    fn sort<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
        descending: bool,
    ) -> Self::Primitive<D>;
    fn sort_with_indices<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
        descending: bool,
    ) -> (Self::Primitive<D>, <Int as TensorKind<B>>::Primitive<D>);
    fn argsort<const D: usize>(
        tensor: Self::Primitive<D>,
        dim: usize,
        descending: bool,
    ) -> <Int as TensorKind<B>>::Primitive<D>;
}

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 tensor struct.

Required Methods

fn add<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Primitive<D>, ) -> Self::Primitive<D>

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<const D: usize, E>( lhs: Self::Primitive<D>, rhs: E, ) -> Self::Primitive<D>

where E: ElementConversion,

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<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Primitive<D>, ) -> Self::Primitive<D>

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<const D: usize, E>( lhs: Self::Primitive<D>, rhs: E, ) -> Self::Primitive<D>

where E: ElementConversion,

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<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Primitive<D>, ) -> Self::Primitive<D>

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<const D: usize, E>( lhs: Self::Primitive<D>, rhs: E, ) -> Self::Primitive<D>

where E: ElementConversion,

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_scalar<const D: usize, E>( lhs: Self::Primitive<D>, rhs: E, ) -> Self::Primitive<D>

where E: ElementConversion,

Computes the modulus element-wise. The result has the same sign as the divisor rhs and its absolute value is less than that of the divisor.

Arguments

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

Returns

The modulus 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 modulus operation, users should prefer the Tensor::remainder_scalar function, which is more high-level and designed for public use.

fn mul<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Primitive<D>, ) -> Self::Primitive<D>

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<const D: usize, E>( lhs: Self::Primitive<D>, rhs: E, ) -> Self::Primitive<D>

where E: ElementConversion,

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<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<D>

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<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<D>

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 zeros<const D: usize>( shape: Shape<D>, device: &<B as Backend>::Device, ) -> Self::Primitive<D>

Creates a tensor filled with zeros.

Arguments

• shape - The shape of the tensor.
• device - The device on which the tensor will be allocated.

Returns

The tensor filled with zeros.

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 creating a tensor filled with zeros, users should prefer the Tensor::zeros function, which is more high-level and designed for public use.

fn ones<const D: usize>( shape: Shape<D>, device: &<B as Backend>::Device, ) -> Self::Primitive<D>

Creates a tensor filled with ones.

Arguments

• shape - The shape of the tensor.
• device - The device on which the tensor will be allocated.

Returns

The tensor filled with ones.

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 creating a tensor filled with ones, users should prefer the Tensor::ones function, which is more high-level and designed for public use.

fn full<const D: usize, E>( shape: Shape<D>, fill_value: E, device: &<B as Backend>::Device, ) -> Self::Primitive<D>

where E: ElementConversion,

Creates a tensor filled with elements equal to the given value.

Arguments

• shape - The shape of the tensor.
• fill_value - The value with which to fill the tensor
• device - The device on which the tensor will be allocated.

Returns

The tensor filled with elements equal to the given 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.

For creating a tensor filled with a specific value, users should prefer the Tensor::full function, which is more high-level and designed for public use.

fn sum<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<1>

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<const D: usize>( tensor: Self::Primitive<D>, dim: usize, ) -> Self::Primitive<D>

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<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<1>

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<const D: usize>( tensor: Self::Primitive<D>, dim: usize, ) -> Self::Primitive<D>

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<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<1>

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<const D: usize>( tensor: Self::Primitive<D>, dim: usize, ) -> Self::Primitive<D>

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 equal_elem<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Elem, ) -> Tensor<B, D, Bool>

Element-wise equality 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 elements of the input tensors are equal, 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 equality between two tensors, users should prefer the Tensor::equal_elem function, which is more high-level and designed for public use.

fn not_equal_elem<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Elem, ) -> Tensor<B, D, Bool>

Element-wise non-equality 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 elements of the input tensors are equal, 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 non-equality between two tensors, users should prefer the Tensor::not_equal_elem function, which is more high-level and designed for public use.

fn greater<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Primitive<D>, ) -> Tensor<B, D, Bool>

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<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Elem, ) -> Tensor<B, D, Bool>

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<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Primitive<D>, ) -> Tensor<B, D, Bool>

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<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Elem, ) -> Tensor<B, D, Bool>

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<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Primitive<D>, ) -> Tensor<B, D, Bool>

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<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Elem, ) -> Tensor<B, D, Bool>

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<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Primitive<D>, ) -> Tensor<B, D, Bool>

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<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Elem, ) -> Tensor<B, D, Bool>

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 mask_where<const D: usize>( tensor: Self::Primitive<D>, mask: Tensor<B, D, Bool>, source: Self::Primitive<D>, ) -> Self::Primitive<D>

Selects elements from a tensor based on a boolean mask.

Arguments

• tensor - The tensor to select elements from if the corresponding element of the mask is true.
• mask - The boolean mask to use for selecting elements.
• source - The tensor to select elements from when the corresponding element of the mask is false.

Returns

A tensor with the same shape as the input tensors, where each element is taken from the corresponding element of the left hand side tensor if the corresponding element of the mask is true, and from the corresponding element of the right hand side tensor 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 selecting elements from a tensor based on a boolean mask, users should prefer the Tensor::mask_where function, which is more high-level and designed for public use.

fn mask_fill<const D: usize>( tensor: Self::Primitive<D>, mask: Tensor<B, D, Bool>, value: Self::Elem, ) -> Self::Primitive<D>

Fills elements of a tensor based on a boolean mask.

Arguments

• tensor - The tensor where will be overwritten with the value when the corresponding element of the mask is true.
• mask - The boolean mask to use for filling elements.
• value - The value to fill elements with when the corresponding element of the mask is true.

Returns

A tensor with the same shape as the input tensors, where each element is taken from the corresponding element unmodified if the corresponding element of the mask is false, and filled with the value 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 filling elements of a tensor based on a boolean mask, users should prefer the Tensor::mask_fill function, which is more high-level and designed for public use.

fn gather<const D: usize>( dim: usize, tensor: Self::Primitive<D>, indices: Tensor<B, D, Int>, ) -> Self::Primitive<D>

Gathers elements from a tensor along an axis.

Arguments

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

Returns

A tensor with the same shape as the input tensor, where each element is taken from the corresponding 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 gathering elements from a tensor along an axis, users should prefer the Tensor::gather function, which is more high-level and designed for public use.

fn scatter<const D: usize>( dim: usize, tensor: Self::Primitive<D>, indices: Tensor<B, D, Int>, values: Self::Primitive<D>, ) -> Self::Primitive<D>

Scatters elements into a tensor along an axis.

Arguments

• dim - The axis along which to scatter elements.
• tensor - The tensor to scatter elements into.
• indices - The indices of the elements to scatter.
• values - The values to scatter into the tensor.

Returns

A tensor with the same shape as the input tensor, where each element is taken from the corresponding element of the input tensor at the corresponding index along the specified axis, except for the elements at the specified indices, which are taken from the corresponding element of the values 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 scattering elements into a tensor along an axis, users should prefer the Tensor::scatter function, which is more high-level and designed for public use.

fn select<const D: usize>( tensor: Self::Primitive<D>, dim: usize, indices: Tensor<B, 1, Int>, ) -> Self::Primitive<D>

Select tensor elements along the given dimension corresponding for the given indices.

Arguments

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

Returns

A tensor with the same shape as the input tensor, where each element is taken from the corresponding 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 selecting elements from a tensor along an axis, users should prefer the Tensor::select function, which is more high-level and designed for public use.

fn select_assign<const D: usize>( tensor: Self::Primitive<D>, dim: usize, indices: Tensor<B, 1, Int>, values: Self::Primitive<D>, ) -> Self::Primitive<D>

Assign the selected elements along the given dimension corresponding to the given indices from the value tensor.

Arguments

• tensor - The tensor to assign elements to.
• dim - The axis along which to assign elements.
• indices - The indices of the elements to assign.
• values - The values to assign to the tensor.

Returns

A tensor with the same shape as the input tensor, where each element is taken from the corresponding element of the input tensor at the corresponding index along the specified axis, except for the elements at the specified indices, which are taken from the corresponding element of the values 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 assigning elements to a tensor along an axis, users should prefer the Tensor::select_assign function, which is more high-level and designed for public use.

fn argmax<const D: usize>( tensor: Self::Primitive<D>, dim: usize, ) -> <B as Backend>::IntTensorPrimitive<D>

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<const D: usize>( tensor: Self::Primitive<D>, dim: usize, ) -> <B as Backend>::IntTensorPrimitive<D>

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<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<1>

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<const D: usize>( tensor: Self::Primitive<D>, dim: usize, ) -> Self::Primitive<D>

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 shape as the input tensor, where each element is the maximum element

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<const D: usize>( tensor: Self::Primitive<D>, dim: usize, ) -> (Self::Primitive<D>, <B as Backend>::IntTensorPrimitive<D>)

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 min<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<1>

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<const D: usize>( tensor: Self::Primitive<D>, dim: usize, ) -> Self::Primitive<D>

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 shape as the input tensor, 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 function, which is more high-level and designed for public use.

fn min_dim_with_indices<const D: usize>( tensor: Self::Primitive<D>, dim: usize, ) -> (Self::Primitive<D>, <B as Backend>::IntTensorPrimitive<D>)

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<const D: usize>( tensor: Self::Primitive<D>, min: Self::Elem, max: Self::Elem, ) -> Self::Primitive<D>

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<const D: usize>( tensor: Self::Primitive<D>, min: Self::Elem, ) -> Self::Primitive<D>

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<const D: usize>( tensor: Self::Primitive<D>, max: Self::Elem, ) -> Self::Primitive<D>

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<const D: usize>(tensor: Self::Primitive<D>) -> Self::Primitive<D>

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<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Primitive<D>, ) -> Self::Primitive<D>

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<const D: usize>( lhs: Self::Primitive<D>, rhs: Self::Primitive<D>, ) -> Self::Primitive<D>

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<const D: usize, E>( lhs: Self::Primitive<D>, rhs: E, ) -> Self::Primitive<D>

where E: ElementConversion,

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<const D: usize, E>( lhs: Self::Primitive<D>, rhs: E, ) -> Self::Primitive<D>

where E: ElementConversion,

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<const D: usize>( shape: Shape<D>, distribution: Distribution, device: &<B as Backend>::Device, ) -> Self::Primitive<D>

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<const D: usize>( tensor: Self::Primitive<D>, dim: usize, descending: bool, ) -> Self::Primitive<D>

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<const D: usize>( tensor: Self::Primitive<D>, dim: usize, descending: bool, ) -> (Self::Primitive<D>, <Int as TensorKind<B>>::Primitive<D>)

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<const D: usize>( tensor: Self::Primitive<D>, dim: usize, descending: bool, ) -> <Int as TensorKind<B>>::Primitive<D>

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.

Object Safety

This trait is not object safe.

Implementors

impl<B> Numeric<B> for Float

where B: Backend,

impl<B> Numeric<B> for Int

where B: Backend,