Trait FloatTensorOps

pub trait FloatTensorOps<B>
where
    B: Backend,
{
    // Required methods
    fn float_from_data(
        data: TensorData,
        device: &<B as Backend>::Device,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_random(
        shape: Shape,
        distribution: Distribution,
        device: &<B as Backend>::Device,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_into_data(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> impl Future<Output = TensorData> + Send;
    fn float_device(
        tensor: &<B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::Device;
    fn float_to_device(
        tensor: <B as Backend>::FloatTensorPrimitive,
        device: &<B as Backend>::Device,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_into_int(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::IntTensorPrimitive;
    fn float_empty(
        shape: Shape,
        device: &<B as Backend>::Device,
        dtype: FloatDType,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_add(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_add_scalar(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_sub(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_sub_scalar(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_mul(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_mul_scalar(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_div(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_div_scalar(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_remainder(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_remainder_scalar(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_matmul(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_cross(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_recip(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_swap_dims(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim1: usize,
        dim2: usize,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_permute(
        tensor: <B as Backend>::FloatTensorPrimitive,
        axes: &[usize],
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_flip(
        tensor: <B as Backend>::FloatTensorPrimitive,
        axes: &[usize],
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_reshape(
        tensor: <B as Backend>::FloatTensorPrimitive,
        shape: Shape,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_gather(
        dim: usize,
        tensor: <B as Backend>::FloatTensorPrimitive,
        indices: <B as Backend>::IntTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_scatter(
        dim: usize,
        tensor: <B as Backend>::FloatTensorPrimitive,
        indices: <B as Backend>::IntTensorPrimitive,
        value: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_select(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
        indices: <B as Backend>::IntTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_select_assign(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
        indices: <B as Backend>::IntTensorPrimitive,
        value: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_slice(
        tensor: <B as Backend>::FloatTensorPrimitive,
        slices: &[Slice],
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_slice_assign(
        tensor: <B as Backend>::FloatTensorPrimitive,
        slices: &[Slice],
        value: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_mask_where(
        tensor: <B as Backend>::FloatTensorPrimitive,
        mask: <B as Backend>::BoolTensorPrimitive,
        value: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_mask_fill(
        tensor: <B as Backend>::FloatTensorPrimitive,
        mask: <B as Backend>::BoolTensorPrimitive,
        value: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_equal(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::BoolTensorPrimitive;
    fn float_equal_elem(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive;
    fn float_greater(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::BoolTensorPrimitive;
    fn float_greater_elem(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive;
    fn float_greater_equal(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::BoolTensorPrimitive;
    fn float_greater_equal_elem(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive;
    fn float_lower(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::BoolTensorPrimitive;
    fn float_lower_elem(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive;
    fn float_lower_equal(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::BoolTensorPrimitive;
    fn float_lower_equal_elem(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive;
    fn float_sum(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_sum_dim(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_mean_dim(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_cumsum(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_cumprod(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_cummin(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_cummax(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_cast(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dtype: FloatDType,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_exp(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_log(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_log1p(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_powf(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_powf_scalar_impl(
        tensor: <B as Backend>::FloatTensorPrimitive,
        value: f32,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_sqrt(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_abs(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_cos(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_sin(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_round(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_floor(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_ceil(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_trunc(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_erf(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_argmax(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::IntTensorPrimitive;
    fn float_argmin(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::IntTensorPrimitive;
    fn float_expand(
        tensor: <B as Backend>::FloatTensorPrimitive,
        shape: Shape,
    ) -> <B as Backend>::FloatTensorPrimitive;
    fn float_unfold(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
        size: usize,
        step: usize,
    ) -> <B as Backend>::FloatTensorPrimitive;

    // Provided methods
    fn float_zeros(
        shape: Shape,
        device: &<B as Backend>::Device,
        dtype: FloatDType,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_ones(
        shape: Shape,
        device: &<B as Backend>::Device,
        dtype: FloatDType,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_full(
        shape: Shape,
        fill_value: <B as Backend>::FloatElem,
        device: &<B as Backend>::Device,
        dtype: FloatDType,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_repeat_dim(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
        times: usize,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_clamp_min(
        tensor: <B as Backend>::FloatTensorPrimitive,
        min: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_clamp_max(
        tensor: <B as Backend>::FloatTensorPrimitive,
        max: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_clamp(
        tensor: <B as Backend>::FloatTensorPrimitive,
        min: <B as Backend>::FloatElem,
        max: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_neg(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_transpose(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_not_equal(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::BoolTensorPrimitive { ... }
    fn float_not_equal_elem(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive { ... }
    fn float_detach(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_set_require_grad(
        tensor: <B as Backend>::FloatTensorPrimitive,
        _require_grad: bool,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_is_require_grad(
        _tensor: &<B as Backend>::FloatTensorPrimitive,
    ) -> bool { ... }
    fn float_prod(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_prod_dim(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_mean(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_powi(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::IntTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_powi_scalar(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::IntElem,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_powi_scalar_impl(
        lhs: <B as Backend>::FloatTensorPrimitive,
        rhs: <B as Backend>::IntElem,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_powf_scalar(
        tensor: <B as Backend>::FloatTensorPrimitive,
        value: f32,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_tan(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_cosh(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_sinh(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_tanh(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_cat(
        tensors: Vec<<B as Backend>::FloatTensorPrimitive>,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_max(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_max_dim(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_max_dim_with_indices(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> (<B as Backend>::FloatTensorPrimitive, <B as Backend>::IntTensorPrimitive) { ... }
    fn float_min(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_min_dim(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_min_dim_with_indices(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> (<B as Backend>::FloatTensorPrimitive, <B as Backend>::IntTensorPrimitive) { ... }
    fn float_max_abs(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_max_abs_dim(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_any(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::BoolTensorPrimitive { ... }
    fn float_any_dim(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::BoolTensorPrimitive { ... }
    fn float_all(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::BoolTensorPrimitive { ... }
    fn float_all_dim(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
    ) -> <B as Backend>::BoolTensorPrimitive { ... }
    fn float_sign(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_sort(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
        descending: bool,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_sort_with_indices(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
        descending: bool,
    ) -> (<B as Backend>::FloatTensorPrimitive, <B as Backend>::IntTensorPrimitive) { ... }
    fn float_argsort(
        tensor: <B as Backend>::FloatTensorPrimitive,
        dim: usize,
        descending: bool,
    ) -> <B as Backend>::IntTensorPrimitive { ... }
    fn float_grid_sample_2d(
        tensor: <B as Backend>::FloatTensorPrimitive,
        grid: <B as Backend>::FloatTensorPrimitive,
        method: InterpolateMode,
    ) -> <B as Backend>::FloatTensorPrimitive { ... }
    fn float_is_nan(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::BoolTensorPrimitive { ... }
    fn float_is_inf(
        tensor: <B as Backend>::FloatTensorPrimitive,
    ) -> <B as Backend>::BoolTensorPrimitive { ... }
}

Operations on float tensors.

Required Methods

fn float_from_data( data: TensorData, device: &<B as Backend>::Device, ) -> <B as Backend>::FloatTensorPrimitive

Creates a new tensor from the data structure.

Arguments

• data - The data structure.
• device - The device to create the tensor on.

Returns

The tensor with the given data.

fn float_random( shape: Shape, distribution: Distribution, device: &<B as Backend>::Device, ) -> <B as Backend>::FloatTensorPrimitive

Creates a new tensor with random values.

Arguments

• shape - The shape of the tensor.
• distribution - The distribution to sample from.
• device - The device to create the tensor on.

Returns

The tensor with the given shape and random values.

fn float_into_data( tensor: <B as Backend>::FloatTensorPrimitive, ) -> impl Future<Output = TensorData> + Send

Converts the tensor to a data structure.

Arguments

• tensor - The tensor.

Returns

The data structure with the tensor’s data.

fn float_device( tensor: &<B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::Device

Gets the device of the tensor.

Arguments

• tensor - The tensor.

Returns

The device of the tensor.

fn float_to_device( tensor: <B as Backend>::FloatTensorPrimitive, device: &<B as Backend>::Device, ) -> <B as Backend>::FloatTensorPrimitive

Moves the tensor to the given device.

Arguments

• tensor - The tensor.
• device - The device to move the tensor to.

Returns

The tensor on the given device.

fn float_into_int( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::IntTensorPrimitive

Converts float tensor to int tensor.

Arguments

• tensor - The tensor.

Returns

The int tensor with the same data as the float tensor.

fn float_empty( shape: Shape, device: &<B as Backend>::Device, dtype: FloatDType, ) -> <B as Backend>::FloatTensorPrimitive

Creates an empty tensor with the given shape.

Arguments

• shape - The shape of the tensor.
• device - The device to create the tensor on.
• dtype - The target data type.

Returns

The empty tensor with the given shape.

fn float_add( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Adds two tensors together.

Arguments

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

Returns

The result of adding the two tensors together.

fn float_add_scalar( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Adds a scalar to a tensor.

Arguments

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

Returns

The result of adding the scalar to the tensor.

fn float_sub( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Subtracts two tensors.

Arguments

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

Returns

The result of subtracting the two tensors.

fn float_sub_scalar( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Subtracts a scalar from a tensor.

Arguments

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

Returns

The result of subtracting the scalar from the tensor.

fn float_mul( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Multiplies two tensors together element-wise.

fn float_mul_scalar( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Multiplies a tensor by a scalar.

Arguments

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

Returns

The result of multiplying the tensor by the scalar.

fn float_div( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Divides two tensors element-wise.

Arguments

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

Returns

The result of dividing the two tensors.

fn float_div_scalar( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Divides a tensor by a scalar.

Arguments

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

Returns

The result of dividing the tensor by the scalar.

fn float_remainder( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Computes the remainder of division between two tensors element-wise.

Arguments

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

Returns

The element-wise remainder when dividing lhs by rhs.

fn float_remainder_scalar( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Computes the modulus of a tensor given a scalar.

Arguments

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

Returns

The result of applying the modulus of the scalar to the tensor.

fn float_matmul( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Multiplies two tensors together using matrix multiplication.

Arguments

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

Returns

The result of multiplying the two tensors together using matrix multiplication.

fn float_cross( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

Computes the cross product of two tensors along a given dimension.

Arguments

• lhs - The left-hand side tensor.
• rhs - The right-hand side tensor.
• dim - The dimension to compute the cross product along.

Returns

The cross product of the two tensors.

fn float_recip( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Calculates the reciprocals element-wise

fn float_swap_dims( tensor: <B as Backend>::FloatTensorPrimitive, dim1: usize, dim2: usize, ) -> <B as Backend>::FloatTensorPrimitive

Swaps two dimensions of a tensor.

Arguments

• tensor - The tensor to swap the dimensions of.
• dim1 - The first dimension to swap.
• dim2 - The second dimension to swap.

Returns

The tensor with the dimensions swapped.

fn float_permute( tensor: <B as Backend>::FloatTensorPrimitive, axes: &[usize], ) -> <B as Backend>::FloatTensorPrimitive

Permutes the dimensions of a tensor.

Arguments

• tensor - The tensor to permute the dimensions of.
• axes - The new order of the dimensions.

Returns

The tensor with the dimensions permuted.

fn float_flip( tensor: <B as Backend>::FloatTensorPrimitive, axes: &[usize], ) -> <B as Backend>::FloatTensorPrimitive

Reverse the order of elements in a tensor along the given axes.

Arguments

• tensor - The tensor to reverse.
• axes - The axes to reverse.

The tensor with the elements reversed.

fn float_reshape( tensor: <B as Backend>::FloatTensorPrimitive, shape: Shape, ) -> <B as Backend>::FloatTensorPrimitive

Reshapes a tensor.

Arguments

• tensor - The tensor to reshape.
• shape - The new shape of the tensor.

Returns

The tensor with the new shape.

fn float_gather( dim: usize, tensor: <B as Backend>::FloatTensorPrimitive, indices: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Gather elements from a tensor.

Arguments

• dim - The dimension to gather from.
• tensor - The tensor to gather from.
• indices - The indices to gather.

Returns

The gathered elements.

fn float_scatter( dim: usize, tensor: <B as Backend>::FloatTensorPrimitive, indices: <B as Backend>::IntTensorPrimitive, value: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Scatter elements into a tensor.

Arguments

• dim - The dimension to scatter into.
• tensor - The tensor to scatter into.
• indices - The indices to scatter into.
• value - The value to scatter.

Returns

The tensor with the scattered elements.

fn float_select( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, indices: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

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

Arguments

• tensor - The tensor to select from.
• dim - The dimension to select from.
• indices - The indices to select.

Returns

The selected elements.

fn float_select_assign( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, indices: <B as Backend>::IntTensorPrimitive, value: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

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

Arguments

• tensor - The tensor to select from.
• dim - The dimension to select from.
• indices - The indices to select.
• value - The value to assign.

Returns

The tensor with the selected elements assigned to the given value.

fn float_slice( tensor: <B as Backend>::FloatTensorPrimitive, slices: &[Slice], ) -> <B as Backend>::FloatTensorPrimitive

Select tensor elements corresponding to the given slices.

Arguments

• tensor - The tensor to select from.
• slices - The slices specifying ranges and steps for each dimension.

Returns

The selected elements in a new tensor.

fn float_slice_assign( tensor: <B as Backend>::FloatTensorPrimitive, slices: &[Slice], value: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Assign the selected elements corresponding to the given slices to the given value.

Arguments

• tensor - The tensor to select from.
• ranges - The ranges to select.
• value - The value to assign.

Returns

The tensor with the selected elements assigned to the given value.

fn float_mask_where( tensor: <B as Backend>::FloatTensorPrimitive, mask: <B as Backend>::BoolTensorPrimitive, value: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Update the given tensor with the value tensor where the mask is true.

Arguments

• tensor - The tensor to select from.
• mask - The boolean mask to select with.
• value - The value to assign to the selected elements from the value tensor.

Returns

The tensor with the selected elements assigned to the given value.

fn float_mask_fill( tensor: <B as Backend>::FloatTensorPrimitive, mask: <B as Backend>::BoolTensorPrimitive, value: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Update the given tensor with the value where the mask is true.

Arguments

• tensor - The tensor to select from.
• mask - The boolean mask to select with.
• value - The value to assign to the selected elements.

Returns

The tensor with the selected elements assigned to the given value.

fn float_equal( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Equal comparison of two tensors.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_equal_elem( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive

Equal comparison of a tensor and a scalar.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_greater( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Greater than comparison of two tensors.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_greater_elem( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive

Greater than comparison of a tensor and a scalar.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_greater_equal( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Greater than or equal comparison of two tensors.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_greater_equal_elem( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive

Greater than or equal comparison of a tensor and a scalar.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_lower( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Less than comparison of two tensors.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_lower_elem( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive

Less than comparison of a tensor and a scalar.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_lower_equal( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Less than or equal comparison of two tensors.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_lower_equal_elem( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive

Less than or equal comparison of a tensor and a scalar.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_sum( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Sum of all elements in a tensor.

Arguments

• tensor - The tensor to sum.

Returns

A scalar tensor with the sum of all elements in tensor.

fn float_sum_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

Sum of all elements in a tensor along a dimension.

Arguments

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

Returns

A tensor with the sum of all elements in tensor along dim.

fn float_mean_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

Mean of all elements in a tensor along a dimension.

Arguments

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

Returns

A tensor with the mean of all elements in tensor along dim.

fn float_cumsum( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

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 where each element is the cumulative sum of all elements up to and including that position along the dimension.

fn float_cumprod( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

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 where each element is the cumulative product of all elements up to and including that position along the dimension.

fn float_cummin( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

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 where each element is the minimum of all elements up to and including that position along the dimension.

fn float_cummax( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

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 where each element is the maximum of all elements up to and including that position along the dimension.

fn float_cast( tensor: <B as Backend>::FloatTensorPrimitive, dtype: FloatDType, ) -> <B as Backend>::FloatTensorPrimitive

Converts a tensor to another floating point data type.

Arguments

• tensor - The tensor to convert.
• dtype - The target data type.

Returns

A tensor with the same values as tensor but in the target floating point data type.

fn float_exp( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with exponential values.

Arguments

• tensor - The tensor to exponentiate.

Returns

A tensor with the same shape as tensor with exponential values.

fn float_log( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with natural logarithm values.

Arguments

• tensor - The tensor to take the logarithm of.

Returns

A tensor with the same shape as tensor with natural logarithm values.

fn float_log1p( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with logarithm values of (1 + Xi).

Arguments

• tensor - The tensor to take the logarithm of.

Returns

A tensor with the same shape as tensor with logarithm values of (1 + Xi).

fn float_powf( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Element-wise power with a FloatTensor.

Arguments

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

Returns

The elements of lhs raised to the power of the elements of rhs.

fn float_powf_scalar_impl( tensor: <B as Backend>::FloatTensorPrimitive, value: f32, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with values raised to the power of float value.

Backend Implementors Note

This is the generic implementation of integer exponentiation called by Self::float_powf_scalar in the fallback case.

This is the minimal required support a Backend must implement for exponentiation.

As a general rule, this should not be called directly.

Arguments

• tensor - The tensor to exponentiate.
• value - The exponent.

Returns

A tensor with the same shape as tensor with values raised to the power of value.

fn float_sqrt( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with square root values.

Arguments

• tensor - The tensor to take the square root of.

Returns

A tensor with the same shape as tensor with square root values.

fn float_abs( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with absolute values.

Arguments

• tensor - The tensor to take absolute value of.

Returns

A tensor with the same shape as tensor with absolute values.

fn float_cos( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with cosine values.

Arguments

• tensor - The tensor to take the cosine of.

Returns

A tensor with the same shape as tensor with cosine values.

fn float_sin( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with sine values.

Arguments

• tensor - The tensor to take the sine of.

Returns

A tensor with the same shape as tensor with sine values.

fn float_round( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with rounded values.

This function should implement the round half to even strategy, with halfway cases rounded to the nearest even integer value.

Arguments

• tensor - The tensor to be rounded.

Returns

A tensor with the same shape as tensor with rounded values.

fn float_floor( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with floored values.

Arguments

• tensor - The tensor to be floored.

Returns

A tensor with the same shape as tensor with floored values.

fn float_ceil( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with ceiled values.

Arguments

• tensor - The tensor to be ceiled.

Returns

A tensor with the same shape as tensor with ceiled values.

fn float_trunc( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with truncated values.

Arguments

• tensor - The tensor to be truncated.

Returns

A tensor with the same shape as tensor with truncated values.

fn float_erf( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with the error function values.

Arguments

• tensor - The tensor to take the error function of.

Returns

A tensor with the same shape as tensor with error function values.

fn float_argmax( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::IntTensorPrimitive

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

Arguments

• tensor - The tensor to get the maximum elements of.
• dim - The dimension along which to get the maximum elements.

Returns

A tensor with the indices of the maximum elements of tensor along dim.

fn float_argmin( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::IntTensorPrimitive

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

Arguments

• tensor - The tensor to get the minimum elements of.
• dim - The dimension along which to get the minimum elements.

Returns

A tensor with the indices of the minimum elements of tensor along dim.

fn float_expand( tensor: <B as Backend>::FloatTensorPrimitive, shape: Shape, ) -> <B as Backend>::FloatTensorPrimitive

Broadcasts the float tensor to the given shape.

fn float_unfold( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, size: usize, step: usize, ) -> <B as Backend>::FloatTensorPrimitive

Unfold windows along a dimension.

Returns a view of the tensor with all complete windows of size size in dimension dim; where windows are advanced by step at each index.

The number of windows is max(0, (shape[dim] - size).ceil_div(step)).

Arguments

• tensor - The input tensor to unfold; of shape [pre=..., dim shape, post=...]
• dim - the selected dim.
• size - the size of each unfolded window.
• step - the step between each window.

Returns

A tensor view with shape [pre=..., windows, size, post=...].

Provided Methods

fn float_zeros( shape: Shape, device: &<B as Backend>::Device, dtype: FloatDType, ) -> <B as Backend>::FloatTensorPrimitive

Creates a new tensor with zeros.

Arguments

• shape - The shape of the tensor.
• device - The device to create the tensor on.
• dtype - The target data type.

Returns

The tensor with the given shape and zeros.

fn float_ones( shape: Shape, device: &<B as Backend>::Device, dtype: FloatDType, ) -> <B as Backend>::FloatTensorPrimitive

Creates a new tensor with ones.

Arguments

• shape - The shape of the tensor.
• device - The device to create the tensor on.
• dtype - The target data type.

Returns

The tensor with the given shape and ones.

fn float_full( shape: Shape, fill_value: <B as Backend>::FloatElem, device: &<B as Backend>::Device, dtype: FloatDType, ) -> <B as Backend>::FloatTensorPrimitive

Creates a tensor filled with given value.

Arguments

• shape - The shape of the tensor.
• fill_value - The value with which to fill the tensor.
• device - The device to create the tensor on.
• dtype - The target data type.

Returns

The tensor filled with given value

fn float_repeat_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, times: usize, ) -> <B as Backend>::FloatTensorPrimitive

Repeat the tensor along the given dimension.

Arguments

• tensor - The tensor.
• dim - The dimension to repeat.
• times - The number of times to repeat the dimension.

Returns

The tensor with the given dimension repeated.

fn float_clamp_min( tensor: <B as Backend>::FloatTensorPrimitive, min: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Clamps a tensor under a minimum value.

Arguments

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

Returns

The clamped tensor.

fn float_clamp_max( tensor: <B as Backend>::FloatTensorPrimitive, max: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Clamps a tensor over a maximum value.

Arguments

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

Returns

The clamped tensor.

fn float_clamp( tensor: <B as Backend>::FloatTensorPrimitive, min: <B as Backend>::FloatElem, max: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Clamps a tensor between a minimum and maximum value.

Arguments

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

Returns

The clamped tensor.

fn float_neg( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Negates a tensor element-wise.

fn float_transpose( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Transposes a tensor.

Arguments

• tensor - The tensor to transpose.

Returns

The transposed tensor.

fn float_not_equal( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Element-wise non-equality comparison.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_not_equal_elem( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive

Element-wise non-equality comparison with a scalar.

Arguments

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

Returns

A boolean tensor with the result of the comparison.

fn float_detach( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Detaches a tensor from the computation graph.

fn float_set_require_grad( tensor: <B as Backend>::FloatTensorPrimitive, _require_grad: bool, ) -> <B as Backend>::FloatTensorPrimitive

Sets the require_grad flag of a tensor.

fn float_is_require_grad(_tensor: &<B as Backend>::FloatTensorPrimitive) -> bool

Returns the require_grad flag of a tensor.

fn float_prod( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Product of all elements in a tensor.

Arguments

• tensor - The tensor to product.

Returns

A scalar tensor with the product of all elements in tensor.

fn float_prod_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

Product of all elements in a tensor along a dimension.

Arguments

• tensor - The tensor to product.

Returns

A tensor with the product of all elements in tensor along dim.

fn float_mean( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Mean of all elements in a tensor.

Arguments

• tensor - The tensor to mean.

Returns

A scalar tensor with the mean of all elements in tensor.

fn float_powi( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Element-wise power with an IntTensor.

Arguments

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

Returns

The elements of lhs raised to the value of rhs. Result is an IntTensor.

fn float_powi_scalar( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::IntElem, ) -> <B as Backend>::FloatTensorPrimitive

Raises a tensor to the power of an int scalar.

Backend Implementors Note

A number of common exponent cases can be implemented with operations which are much cheaper than generic exponentiation.

This (Backend impl overridable) operation handles generic optimizations for several common integer exponent cases; and then dispatches to the (Backend impl overridable) Self::float_powi_scalar_impl operation to handle the generic case.

Arguments

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

Returns

The elements of lhs raised to the value of rhs.

fn float_powi_scalar_impl( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::IntElem, ) -> <B as Backend>::FloatTensorPrimitive

Raises a tensor to the power of an int scalar.

Backend Implementors Note

This is the generic implementation of integer exponentiation called by Self::float_powi_scalar in the fallback case.

As a general rule, this should not be called directly.

Arguments

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

Returns

The elements of lhs raised to the value of rhs.

fn float_powf_scalar( tensor: <B as Backend>::FloatTensorPrimitive, value: f32, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with values raised to the power of float value.

Backend Implementors Note

This (Backend impl overridable) operation dispatches integer exponentiation to Self::float_powi_scalar, and the remaining non-integer exponent cases to the (Backend impl overridable) Self::float_powf_scalar_impl operation to handle the generic case.

Arguments

• tensor - The tensor to exponentiate.
• value - The exponent.

Returns

A tensor with the same shape as tensor with values raised to the power of value.

fn float_tan( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with tangent values.

Arguments

• tensor - The tensor to take the tangent of.

Returns

A tensor with the same shape as tensor with tangent values.

fn float_cosh( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with hyperbolic cosine values.

Arguments

• tensor - The tensor to take the hyperbolic cosine of.

Returns

A tensor with the same shape as tensor with hyperbolic cosine values.

fn float_sinh( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with hyperbolic sine values.

Arguments

• tensor - The tensor to take the hyperbolic sine of.

Returns

A tensor with the same shape as tensor with hyperbolic sine values.

fn float_tanh( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with hyperbolic tangent values.

Arguments

• tensor - The tensor to take the hyperbolic tangent of.

Returns

A tensor with the same shape as tensor with hyperbolic tangent values.

fn float_cat( tensors: Vec<<B as Backend>::FloatTensorPrimitive>, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

Concatenates tensors along a dimension.

Arguments

• tensors - The tensors to concatenate.
• dim - The dimension along which to concatenate.

Returns

A tensor with the concatenated tensors along dim.

fn float_max( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Gets the maximum element of a tensor.

Arguments

• tensor - The tensor to get the maximum elements of.

Returns

A tensor with the maximum element of tensor.

fn float_max_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

Gets the maximum elements of a tensor along an axis.

Arguments

• tensor - The tensor to get the maximum elements of.
• dim - The dimension along which to get the maximum elements.

Returns

A tensor with the maximum elements of tensor along dim.

fn float_max_dim_with_indices( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> (<B as Backend>::FloatTensorPrimitive, <B as Backend>::IntTensorPrimitive)

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

Arguments

• tensor - The tensor to get the maximum elements of.
• dim - The dimension along which to get the maximum elements.

Returns

A tuple with the maximum elements of tensor along dim and their indices.

fn float_min( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Gets the minimum element of a tensor.

Arguments

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

Returns

A tensor with the minimum element of tensor.

fn float_min_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

Gets the minimum elements of a tensor along an axis.

Arguments

• tensor - The tensor to get the minimum elements of.
• dim - The dimension along which to get the minimum elements.

Returns

A tensor with the minimum elements of tensor along dim.

fn float_min_dim_with_indices( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> (<B as Backend>::FloatTensorPrimitive, <B as Backend>::IntTensorPrimitive)

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

Arguments

• tensor - The tensor to get the minimum elements of.
• dim - The dimension along which to get the minimum elements.

Returns

A tuple with the minimum elements of tensor along dim and their indices.

fn float_max_abs( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Gets the maximum absolute element of a tensor.

Arguments

• tensor - The tensor to get the maximum elements of.

Returns

A tensor with the maximum element of tensor.

fn float_max_abs_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

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

Arguments

• tensor - The tensor to get the maximum elements of.
• dim - The dimension along which to get the maximum elements.

Returns

A tensor with the maximum elements of tensor along dim.

fn float_any( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Tests if any element in the float tensor evaluates to True.

Arguments

• tensor - The tensor to test.

Returns

A boolean tensor with a single element, True if any element in the tensor is True, False otherwise.

fn float_any_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::BoolTensorPrimitive

Tests if any element in the float tensor evaluates to True along a given dimension dim.

Arguments

• tensor - The tensor to test.
• dim - The axis along which to test.

Returns

A boolean tensor Tensor<B, D, Bool> with the same size as input tensor, except in the dim axis where the size is 1. The elem in the dim axis is True if any element along this dim in the input evaluates to True, False otherwise.

fn float_all( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Tests if all elements in the float tensor evaluate to True.

Arguments

• tensor - The tensor to test.

Returns

A boolean tensor Tensor<B, 1, Bool> with a single element, True if all elements in the input tensor evaluate to True, False otherwise.

fn float_all_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::BoolTensorPrimitive

Tests if all elements in the float tensor evaluate to True along a given dimension dim.

Arguments

• tensor - The tensor to test.
• dim - The axis along which to test.

Returns

A boolean tensor Tensor<B, D, Bool> with the same size as input tensor, except in the dim axis where the size is 1. The elem in the dim axis is True if all elements along this dim in the input evaluates to True, False otherwise.

fn float_sign( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns the signs of the float tensor.

Arguments

• tensor - The tensor to extract the signs from.

Returns

A tensor with the same shape as tensor containing the signs of the elements of tensor.

fn float_sort( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, descending: bool, ) -> <B as Backend>::FloatTensorPrimitive

Sort the elements of the input tensor by value in 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.

fn float_sort_with_indices( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, descending: bool, ) -> (<B as Backend>::FloatTensorPrimitive, <B as Backend>::IntTensorPrimitive)

Sort the elements of the input tensor by value in 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.

fn float_argsort( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, descending: bool, ) -> <B as Backend>::IntTensorPrimitive

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.

fn float_grid_sample_2d( tensor: <B as Backend>::FloatTensorPrimitive, grid: <B as Backend>::FloatTensorPrimitive, method: InterpolateMode, ) -> <B as Backend>::FloatTensorPrimitive

Samples tensor as a two-dimensional spatial grid of (possibly multi-channel) values, using the given locations in [-1, 1].

Interpolation is bilinear. Padding is border: out of bounds locations will be clamped to the nearest border

• tensor - The tensor being sampled from, shape (N, C, H_in, W_in)
• grid - A tensor of locations, with shape (N, H_out, W_out, 2). Values are [-1, 1]. A [x = -1, y = -1] means top-left, and [x = 1, y = 1] means bottom-right
• method - How to interpolate between samples

Returns

A tensor with shape (N, C, H_out, W_out)

fn float_is_nan( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Returns a new tensor with boolean elements indicating whether each element of the input is NaN.

Returns

A boolean tensor where true indicates NaN and false indicates a non-NaN value.

fn float_is_inf( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Returns a new tensor with boolean elements indicating whether each element of the input is infinite (either +INF or -INF).

Returns

A boolean tensor where true indicates that the value is infinite

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.

Implementations on Foreign Types

impl<E, I, Q> FloatTensorOps<NdArray<E, I, Q>> for NdArray<E, I, Q>

where E: FloatNdArrayElement, I: IntNdArrayElement, Q: QuantElement, NdArrayTensor: From<ArrayBase<OwnedArcRepr<E>, Dim<IxDynImpl>>> + From<ArrayBase<OwnedArcRepr<I>, Dim<IxDynImpl>>>,

fn float_from_data( data: TensorData, _device: &NdArrayDevice, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_random( shape: Shape, distribution: Distribution, device: &NdArrayDevice, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

async fn float_into_data( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> TensorData

fn float_device( _tensor: &<NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> NdArrayDevice

fn float_to_device( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, _device: &NdArrayDevice, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_empty( shape: Shape, device: &<NdArray<E> as Backend>::Device, dtype: FloatDType, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_add( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_add_scalar( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: E, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_sub( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_sub_scalar( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: E, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_mul( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_mul_scalar( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: E, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_div( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_div_scalar( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: E, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_remainder( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_remainder_scalar( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: E, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_matmul( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_cross( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_neg( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_recip( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_swap_dims( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim1: usize, dim2: usize, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_reshape( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, shape: Shape, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_gather( dim: usize, tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, indices: NdArrayTensor, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_scatter( dim: usize, tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, indices: NdArrayTensor, value: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_select( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, indices: NdArrayTensor, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_select_assign( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, indices: NdArrayTensor, value: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_slice( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, slices: &[Slice], ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_slice_assign( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, slices: &[Slice], value: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_mask_where( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, mask: NdArrayTensor, value: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_mask_fill( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, mask: NdArrayTensor, value: E, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_equal( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> NdArrayTensor

fn float_equal_elem( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: E, ) -> NdArrayTensor

fn float_greater( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> NdArrayTensor

fn float_greater_elem( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: E, ) -> NdArrayTensor

fn float_greater_equal( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> NdArrayTensor

fn float_greater_equal_elem( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: E, ) -> NdArrayTensor

fn float_lower( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> NdArrayTensor

fn float_lower_elem( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: E, ) -> NdArrayTensor

fn float_lower_equal( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> NdArrayTensor

fn float_lower_equal_elem( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: E, ) -> NdArrayTensor

fn float_detach( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_mean( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_sum( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_mean_dim( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_cumsum( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_cumprod( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_cummin( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_cummax( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_sum_dim( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_argmax( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, ) -> NdArrayTensor

fn float_argmin( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, ) -> NdArrayTensor

fn float_exp( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_log( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_prod( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_prod_dim( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_log1p( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_powf_scalar_impl( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, value: f32, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_sqrt( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_abs( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_cos( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_sin( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_tanh( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_round( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_floor( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_ceil( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_trunc( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_erf( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_cat( tensors: Vec<<NdArray<E, I, Q> as Backend>::FloatTensorPrimitive>, dim: usize, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_clamp_min( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, min: E, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_clamp_max( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, max: E, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_clamp( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, min: E, max: E, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_into_int( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> NdArrayTensor

fn float_powf( lhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, rhs: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_permute( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, axes: &[usize], ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_flip( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, axes: &[usize], ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_sign( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_expand( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, shape: Shape, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_cast( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dtype: FloatDType, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_grid_sample_2d( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, grid: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, method: InterpolateMode, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

fn float_unfold( tensor: <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive, dim: usize, size: usize, step: usize, ) -> <NdArray<E, I, Q> as Backend>::FloatTensorPrimitive

Implementors

impl<B, C> FloatTensorOps<Autodiff<B, C>> for Autodiff<B, C>

where B: Backend, C: CheckpointStrategy,