Trait burn::tensor::ops::FloatTensorOps

pub trait FloatTensorOps<B>
where
    B: Backend,
{
    // Required methods
    fn float_from_data<const D: usize>(
        data: TensorData,
        device: &<B as Backend>::Device,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_random<const D: usize>(
        shape: Shape<D>,
        distribution: Distribution,
        device: &<B as Backend>::Device,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_shape<const D: usize>(
        tensor: &<B as Backend>::FloatTensorPrimitive<D>,
    ) -> Shape<D>;
    fn float_into_data<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> impl Future<Output = TensorData> + Send;
    fn float_device<const D: usize>(
        tensor: &<B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::Device;
    fn float_to_device<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        device: &<B as Backend>::Device,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_into_int<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::IntTensorPrimitive<D>;
    fn float_empty<const D: usize>(
        shape: Shape<D>,
        device: &<B as Backend>::Device,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_add<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_add_scalar<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_sub<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_sub_scalar<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_mul<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_mul_scalar<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_div<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_div_scalar<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_remainder_scalar<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_matmul<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_recip<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_swap_dims<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim1: usize,
        dim2: usize,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_permute<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        axes: [usize; D],
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_flip<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        axes: &[usize],
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_reshape<const D1: usize, const D2: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D1>,
        shape: Shape<D2>,
    ) -> <B as Backend>::FloatTensorPrimitive<D2>;
    fn float_gather<const D: usize>(
        dim: usize,
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        indices: <B as Backend>::IntTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_scatter<const D: usize>(
        dim: usize,
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        indices: <B as Backend>::IntTensorPrimitive<D>,
        value: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_select<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
        indices: <B as Backend>::IntTensorPrimitive<1>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_select_assign<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
        indices: <B as Backend>::IntTensorPrimitive<1>,
        value: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_slice<const D1: usize, const D2: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D1>,
        ranges: [Range<usize>; D2],
    ) -> <B as Backend>::FloatTensorPrimitive<D1>;
    fn float_slice_assign<const D1: usize, const D2: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D1>,
        ranges: [Range<usize>; D2],
        value: <B as Backend>::FloatTensorPrimitive<D1>,
    ) -> <B as Backend>::FloatTensorPrimitive<D1>;
    fn float_mask_where<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        mask: <B as Backend>::BoolTensorPrimitive<D>,
        value: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_mask_fill<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        mask: <B as Backend>::BoolTensorPrimitive<D>,
        value: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_equal<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn float_equal_elem<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn float_greater<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn float_greater_elem<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn float_greater_equal<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn float_greater_equal_elem<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn float_lower<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn float_lower_elem<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn float_lower_equal<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn float_lower_equal_elem<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn float_sum<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<1>;
    fn float_sum_dim<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_mean_dim<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_exp<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_log<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_log1p<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_powf<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_powf_scalar<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        value: f32,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_sqrt<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_abs<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_cos<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_sin<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_tanh<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_erf<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D>;
    fn float_argmax<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
    ) -> <B as Backend>::IntTensorPrimitive<D>;
    fn float_argmin<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
    ) -> <B as Backend>::IntTensorPrimitive<D>;
    fn float_expand<const D1: usize, const D2: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D1>,
        shape: Shape<D2>,
    ) -> <B as Backend>::FloatTensorPrimitive<D2>;

    // Provided methods
    fn float_zeros<const D: usize>(
        shape: Shape<D>,
        device: &<B as Backend>::Device,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_ones<const D: usize>(
        shape: Shape<D>,
        device: &<B as Backend>::Device,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_full<const D: usize>(
        shape: Shape<D>,
        fill_value: <B as Backend>::FloatElem,
        device: &<B as Backend>::Device,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_repeat_dim<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
        times: usize,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_clamp_min<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        min: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_clamp_max<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        max: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_clamp<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        min: <B as Backend>::FloatElem,
        max: <B as Backend>::FloatElem,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_neg<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_transpose<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_not_equal<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::BoolTensorPrimitive<D> { ... }
    fn float_not_equal_elem<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem,
    ) -> <B as Backend>::BoolTensorPrimitive<D> { ... }
    fn float_detach<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_set_require_grad<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        _require_grad: bool,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_is_require_grad<const D: usize>(
        _tensor: &<B as Backend>::FloatTensorPrimitive<D>,
    ) -> bool { ... }
    fn float_prod<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<1> { ... }
    fn float_prod_dim<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_mean<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<1> { ... }
    fn float_into_full_precision<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <<<B as Backend>::FullPrecisionBridge as BackendBridge<B>>::Target as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_from_full_precision<const D: usize>(
        tensor: <<<B as Backend>::FullPrecisionBridge as BackendBridge<B>>::Target as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_powi<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::IntTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_powi_scalar<const D: usize>(
        lhs: <B as Backend>::FloatTensorPrimitive<D>,
        rhs: <B as Backend>::IntElem,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_cat<const D: usize>(
        tensors: Vec<<B as Backend>::FloatTensorPrimitive<D>>,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_max<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<1> { ... }
    fn float_max_dim<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_max_dim_with_indices<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
    ) -> (<B as Backend>::FloatTensorPrimitive<D>, <B as Backend>::IntTensorPrimitive<D>) { ... }
    fn float_min<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<1> { ... }
    fn float_min_dim<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_min_dim_with_indices<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
    ) -> (<B as Backend>::FloatTensorPrimitive<D>, <B as Backend>::IntTensorPrimitive<D>) { ... }
    fn float_narrow<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
        start: usize,
        length: usize,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_chunk<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        chunks: usize,
        dim: usize,
    ) -> Vec<<B as Backend>::FloatTensorPrimitive<D>> { ... }
    fn float_any<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::BoolTensorPrimitive<1> { ... }
    fn float_any_dim<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
    ) -> <B as Backend>::BoolTensorPrimitive<D> { ... }
    fn float_all<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::BoolTensorPrimitive<1> { ... }
    fn float_all_dim<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
    ) -> <B as Backend>::BoolTensorPrimitive<D> { ... }
    fn float_sign<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_sort<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
        descending: bool,
    ) -> <B as Backend>::FloatTensorPrimitive<D> { ... }
    fn float_sort_with_indices<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
        descending: bool,
    ) -> (<B as Backend>::FloatTensorPrimitive<D>, <B as Backend>::IntTensorPrimitive<D>) { ... }
    fn float_argsort<const D: usize>(
        tensor: <B as Backend>::FloatTensorPrimitive<D>,
        dim: usize,
        descending: bool,
    ) -> <B as Backend>::IntTensorPrimitive<D> { ... }
}

Operations on float tensors.

Required Methods

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

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

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_shape<const D: usize>( tensor: &<B as Backend>::FloatTensorPrimitive<D>, ) -> Shape<D>

Gets the shape of the tensor.

Arguments

• tensor - The tensor.

Returns

The shape of the tensor.

fn float_into_data<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> 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<const D: usize>( tensor: &<B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::Device

Gets the device of the tensor.

Arguments

• tensor - The tensor.

Returns

The device of the tensor.

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

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

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

Creates an empty tensor with the given shape.

Arguments

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

Returns

The empty tensor with the given shape.

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

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Multiplies two tensors together element-wise.

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

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

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_scalar<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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_recip<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Calculates the reciprocals element-wise

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

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, axes: [usize; D], ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, axes: &[usize], ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D1: usize, const D2: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D1>, shape: Shape<D2>, ) -> <B as Backend>::FloatTensorPrimitive<D2>

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

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

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

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, dim: usize, indices: <B as Backend>::IntTensorPrimitive<1>, value: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D1: usize, const D2: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D1>, ranges: [Range<usize>; D2], ) -> <B as Backend>::FloatTensorPrimitive<D1>

Select tensor elements corresponding for the given ranges.

Arguments

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

Returns

The selected elements in a new tensor.

fn float_slice_assign<const D1: usize, const D2: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D1>, ranges: [Range<usize>; D2], value: <B as Backend>::FloatTensorPrimitive<D1>, ) -> <B as Backend>::FloatTensorPrimitive<D1>

Assign the selected elements corresponding for the given ranges 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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, mask: <B as Backend>::BoolTensorPrimitive<D>, value: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, mask: <B as Backend>::BoolTensorPrimitive<D>, value: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<1>

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

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

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_exp<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, value: f32, ) -> <B as Backend>::FloatTensorPrimitive<D>

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

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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_tanh<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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_erf<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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

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

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<const D1: usize, const D2: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D1>, shape: Shape<D2>, ) -> <B as Backend>::FloatTensorPrimitive<D2>

Broadcasts the float tensor to the given shape.

Provided Methods

fn float_zeros<const D: usize>( shape: Shape<D>, device: &<B as Backend>::Device, ) -> <B as Backend>::FloatTensorPrimitive<D>

Creates a new tensor with zeros.

Arguments

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

Returns

The tensor with the given shape and zeros.

fn float_ones<const D: usize>( shape: Shape<D>, device: &<B as Backend>::Device, ) -> <B as Backend>::FloatTensorPrimitive<D>

Creates a new tensor with ones.

Arguments

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

Returns

The tensor with the given shape and ones.

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

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.

Returns

The tensor filled with given value

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

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, min: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, max: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

Clamps a tensor over a maximum value.

Arguments

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

Returns

The clamped tensor.

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

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Negates a tensor element-wise.

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

Transposes a tensor.

Arguments

• tensor - The tensor to transpose.

Returns

The transposed tensor.

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

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Detaches a tensor from the computation graph.

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

Sets the require_grad flag of a tensor.

fn float_is_require_grad<const D: usize>( _tensor: &<B as Backend>::FloatTensorPrimitive<D>, ) -> bool

Returns the require_grad flag of a tensor.

fn float_prod<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<1>

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

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<1>

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_into_full_precision<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <<<B as Backend>::FullPrecisionBridge as BackendBridge<B>>::Target as Backend>::FloatTensorPrimitive<D>

Converts a tensor to full precision.

Arguments

• tensor - The tensor to convert.

Returns

A tensor with the same values as tensor but with full precision.

fn float_from_full_precision<const D: usize>( tensor: <<<B as Backend>::FullPrecisionBridge as BackendBridge<B>>::Target as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Converts a tensor from full precision.

Arguments

• tensor - The tensor to convert.

Returns

A tensor with the same values as tensor but with the precision of the backend.

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

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<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::IntElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

raises a tensor to the power of an int scalar.

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_cat<const D: usize>( tensors: Vec<<B as Backend>::FloatTensorPrimitive<D>>, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<1>

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

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

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<1>

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

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

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_narrow<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, dim: usize, start: usize, length: usize, ) -> <B as Backend>::FloatTensorPrimitive<D>

Returns a new tensor with the given dimension narrowed to the given range.

Arguments

• dim - The dimension along which the tensor will be narrowed.
• start - The starting point of the given range.
• length - The ending point of the given range.

Panics

• If the dimension is greater than the number of dimensions of the tensor.
• If the given range exceeds the number of elements on the given dimension.

Returns

A new tensor with the given dimension narrowed to the given range.

fn float_chunk<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, chunks: usize, dim: usize, ) -> Vec<<B as Backend>::FloatTensorPrimitive<D>>

Split the tensor along the given dimension into chunks.

Arguments

• tensor - The tensor.
• chunks - The number of chunks to be produced
• times - The dimension along which the tensor will be split.

Returns

A vector of tensors

fn float_any<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<1>

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

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<1>

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

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, dim: usize, descending: bool, ) -> <B as Backend>::FloatTensorPrimitive<D>

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

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<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, dim: usize, descending: bool, ) -> <B as Backend>::IntTensorPrimitive<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.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<B> FloatTensorOps<Fusion<B>> for Fusion<B>

where B: FusionBackend,

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

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

fn float_zeros<const D: usize>( shape: Shape<D>, device: &<Fusion<B> as Backend>::Device, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_ones<const D: usize>( shape: Shape<D>, device: &<Fusion<B> as Backend>::Device, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_full<const D: usize>( shape: Shape<D>, fill_value: <Fusion<B> as Backend>::FloatElem, device: &<Fusion<B> as Backend>::Device, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_shape<const D: usize>( tensor: &<Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> Shape<D>

async fn float_into_data<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> TensorData

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

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

fn float_into_int<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::IntTensorPrimitive<D>

fn float_empty<const D: usize>( shape: Shape<D>, device: &<Fusion<B> as Backend>::Device, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_add<const D: usize>( lhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, rhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

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

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

fn float_sub<const D: usize>( lhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, rhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

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

fn float_mul<const D: usize>( lhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, rhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

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

fn float_div<const D: usize>( lhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, rhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

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

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

fn float_matmul<const D: usize>( lhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, rhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

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

fn float_reshape<const D1: usize, const D2: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D1>, shape: Shape<D2>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D2>

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

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

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

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

fn float_slice<const D1: usize, const D2: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D1>, ranges: [Range<usize>; D2], ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D1>

fn float_slice_assign<const D1: usize, const D2: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D1>, ranges: [Range<usize>; D2], value: <Fusion<B> as Backend>::FloatTensorPrimitive<D1>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D1>

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

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

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

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

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

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

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

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

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

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

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

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

fn float_sum<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<1>

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

fn float_mean<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<1>

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

fn float_exp<const D: usize>( lhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_log<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_log1p<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_powf_scalar<const D: usize>( lhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, rhs: f32, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_sqrt<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_abs<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_cos<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_sin<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_tanh<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_recip<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_erf<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

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

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

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

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

fn float_max<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<1>

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

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

fn float_min<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<1>

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

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

fn float_powf<const D: usize>( lhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, rhs: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_permute<const D: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D>, axes: [usize; D], ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D>

fn float_expand<const D1: usize, const D2: usize>( tensor: <Fusion<B> as Backend>::FloatTensorPrimitive<D1>, shape: Shape<D2>, ) -> <Fusion<B> as Backend>::FloatTensorPrimitive<D2>

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

Implementors

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

where B: Backend, C: CheckpointStrategy,

impl<E, Q> FloatTensorOps<LibTorch<E, Q>> for LibTorch<E, Q>

where E: TchElement, Q: QuantElement,

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

where E: FloatNdArrayElement, Q: QuantElement,

impl<F, I> FloatTensorOps<Candle<F, I>> for Candle<F, I>

where F: FloatCandleElement, I: IntCandleElement,

impl<R, F, I> FloatTensorOps<JitBackend<R, F, I>> for JitBackend<R, F, I>

where R: JitRuntime, F: FloatElement, I: IntElement,