Trait burn_core::tensor::ops::TensorOps

pub trait TensorOps<B>where
    B: Backend,{
    // Required methods
    fn from_data<const D: usize>(
        data: Data<<B as Backend>::FloatElem, D>,
        device: &<B as Backend>::Device
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn random<const D: usize>(
        shape: Shape<D>,
        distribution: Distribution<<B as Backend>::FloatElem>,
        device: &<B as Backend>::Device
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn shape<const D: usize>(
        tensor: &<B as Backend>::TensorPrimitive<D>
    ) -> Shape<D>;
    fn to_data<const D: usize>(
        tensor: &<B as Backend>::TensorPrimitive<D>
    ) -> Data<<B as Backend>::FloatElem, D>;
    fn into_data<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> Data<<B as Backend>::FloatElem, D>;
    fn device<const D: usize>(
        tensor: &<B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::Device;
    fn to_device<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        device: &<B as Backend>::Device
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn empty<const D: usize>(
        shape: Shape<D>,
        device: &<B as Backend>::Device
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn add<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn add_scalar<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn sub<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn sub_scalar<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn mul<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn mul_scalar<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn div<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn div_scalar<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn matmul<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn neg<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn swap_dims<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        dim1: usize,
        dim2: usize
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn reshape<const D1: usize, const D2: usize>(
        tensor: <B as Backend>::TensorPrimitive<D1>,
        shape: Shape<D2>
    ) -> <B as Backend>::TensorPrimitive<D2>;
    fn index_select<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        indexes: <B as Backend>::IntTensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn index_select_assign<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        indexes: <B as Backend>::IntTensorPrimitive<D>,
        value: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn index_select_dim<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        dim: usize,
        indexes: <B as Backend>::IntTensorPrimitive<1>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn index_select_dim_assign<const D1: usize, const D2: usize>(
        tensor: <B as Backend>::TensorPrimitive<D1>,
        dim: usize,
        indexes: <B as Backend>::IntTensorPrimitive<1>,
        value: <B as Backend>::TensorPrimitive<D2>
    ) -> <B as Backend>::TensorPrimitive<D1>;
    fn index<const D1: usize, const D2: usize>(
        tensor: <B as Backend>::TensorPrimitive<D1>,
        indexes: [Range<usize>; D2]
    ) -> <B as Backend>::TensorPrimitive<D1>;
    fn index_assign<const D1: usize, const D2: usize>(
        tensor: <B as Backend>::TensorPrimitive<D1>,
        indexes: [Range<usize>; D2],
        value: <B as Backend>::TensorPrimitive<D1>
    ) -> <B as Backend>::TensorPrimitive<D1>;
    fn mask_scatter<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        mask: <B as Backend>::BoolTensorPrimitive<D>,
        source: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn mask_fill<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        mask: <B as Backend>::BoolTensorPrimitive<D>,
        value: <B as Backend>::FloatElem
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn equal<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn equal_elem<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn greater<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn greater_elem<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn greater_equal<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn greater_equal_elem<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn lower<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn lower_elem<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn lower_equal<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn lower_equal_elem<const D: usize>(
        lhs: <B as Backend>::TensorPrimitive<D>,
        rhs: <B as Backend>::FloatElem
    ) -> <B as Backend>::BoolTensorPrimitive<D>;
    fn sum<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<1>;
    fn sum_dim<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        dim: usize
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn mean<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<1>;
    fn mean_dim<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        dim: usize
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn to_full_precision<const D: usize>(
        tensor: &<B as Backend>::TensorPrimitive<D>
    ) -> <<B as Backend>::FullPrecisionBackend as Backend>::TensorPrimitive<D>;
    fn from_full_precision<const D: usize>(
        tensor: <<B as Backend>::FullPrecisionBackend as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn argmax<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        dim: usize
    ) -> <B as Backend>::IntTensorPrimitive<D>;
    fn argmin<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        dim: usize
    ) -> <B as Backend>::IntTensorPrimitive<D>;
    fn exp<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn log<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn log1p<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn powf<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        value: f32
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn sqrt<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn cos<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn sin<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn tanh<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn erf<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn cat<const D: usize>(
        tensors: Vec<<B as Backend>::TensorPrimitive<D>, Global>,
        dim: usize
    ) -> <B as Backend>::TensorPrimitive<D>;
    fn relu<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D>;

    // Provided methods
    fn zeros<const D: usize>(
        shape: Shape<D>,
        device: &<B as Backend>::Device
    ) -> <B as Backend>::TensorPrimitive<D> { ... }
    fn ones<const D: usize>(
        shape: Shape<D>,
        device: &<B as Backend>::Device
    ) -> <B as Backend>::TensorPrimitive<D> { ... }
    fn arange(
        range: Range<usize>,
        device: &<B as Backend>::Device
    ) -> <B as Backend>::IntTensorPrimitive<1> { ... }
    fn repeat<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        dim: usize,
        times: usize
    ) -> <B as Backend>::TensorPrimitive<D> { ... }
    fn transpose<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D> { ... }
    fn detach<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>
    ) -> <B as Backend>::TensorPrimitive<D> { ... }
    fn set_require_grad<const D: usize>(
        tensor: <B as Backend>::TensorPrimitive<D>,
        _require_grad: bool
    ) -> <B as Backend>::TensorPrimitive<D> { ... }
    fn is_require_grad<const D: usize>(
        _tensor: &<B as Backend>::TensorPrimitive<D>
    ) -> bool { ... }
}

Operations on float tensors.

Required Methods

fn from_data<const D: usize>( data: Data<<B as Backend>::FloatElem, D>, device: &<B as Backend>::Device ) -> <B as Backend>::TensorPrimitive<D>

fn random<const D: usize>( shape: Shape<D>, distribution: Distribution<<B as Backend>::FloatElem>, device: &<B as Backend>::Device ) -> <B as Backend>::TensorPrimitive<D>

fn shape<const D: usize>( tensor: &<B as Backend>::TensorPrimitive<D> ) -> Shape<D>

fn to_data<const D: usize>( tensor: &<B as Backend>::TensorPrimitive<D> ) -> Data<<B as Backend>::FloatElem, D>

fn into_data<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> Data<<B as Backend>::FloatElem, D>

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

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

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

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

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

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

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

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

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

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

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

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

fn neg<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

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

fn reshape<const D1: usize, const D2: usize>( tensor: <B as Backend>::TensorPrimitive<D1>, shape: Shape<D2> ) -> <B as Backend>::TensorPrimitive<D2>

fn index_select<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, indexes: <B as Backend>::IntTensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn index_select_assign<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, indexes: <B as Backend>::IntTensorPrimitive<D>, value: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn index_select_dim<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, dim: usize, indexes: <B as Backend>::IntTensorPrimitive<1> ) -> <B as Backend>::TensorPrimitive<D>

fn index_select_dim_assign<const D1: usize, const D2: usize>( tensor: <B as Backend>::TensorPrimitive<D1>, dim: usize, indexes: <B as Backend>::IntTensorPrimitive<1>, value: <B as Backend>::TensorPrimitive<D2> ) -> <B as Backend>::TensorPrimitive<D1>

fn index<const D1: usize, const D2: usize>( tensor: <B as Backend>::TensorPrimitive<D1>, indexes: [Range<usize>; D2] ) -> <B as Backend>::TensorPrimitive<D1>

fn index_assign<const D1: usize, const D2: usize>( tensor: <B as Backend>::TensorPrimitive<D1>, indexes: [Range<usize>; D2], value: <B as Backend>::TensorPrimitive<D1> ) -> <B as Backend>::TensorPrimitive<D1>

fn mask_scatter<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, mask: <B as Backend>::BoolTensorPrimitive<D>, source: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn mask_fill<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, mask: <B as Backend>::BoolTensorPrimitive<D>, value: <B as Backend>::FloatElem ) -> <B as Backend>::TensorPrimitive<D>

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

fn equal_elem<const D: usize>( lhs: <B as Backend>::TensorPrimitive<D>, rhs: <B as Backend>::FloatElem ) -> <B as Backend>::BoolTensorPrimitive<D>

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

fn greater_elem<const D: usize>( lhs: <B as Backend>::TensorPrimitive<D>, rhs: <B as Backend>::FloatElem ) -> <B as Backend>::BoolTensorPrimitive<D>

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

fn greater_equal_elem<const D: usize>( lhs: <B as Backend>::TensorPrimitive<D>, rhs: <B as Backend>::FloatElem ) -> <B as Backend>::BoolTensorPrimitive<D>

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

fn lower_elem<const D: usize>( lhs: <B as Backend>::TensorPrimitive<D>, rhs: <B as Backend>::FloatElem ) -> <B as Backend>::BoolTensorPrimitive<D>

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

fn lower_equal_elem<const D: usize>( lhs: <B as Backend>::TensorPrimitive<D>, rhs: <B as Backend>::FloatElem ) -> <B as Backend>::BoolTensorPrimitive<D>

fn sum<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<1>

fn sum_dim<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, dim: usize ) -> <B as Backend>::TensorPrimitive<D>

fn mean<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<1>

fn mean_dim<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, dim: usize ) -> <B as Backend>::TensorPrimitive<D>

fn to_full_precision<const D: usize>( tensor: &<B as Backend>::TensorPrimitive<D> ) -> <<B as Backend>::FullPrecisionBackend as Backend>::TensorPrimitive<D>

fn from_full_precision<const D: usize>( tensor: <<B as Backend>::FullPrecisionBackend as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

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

fn argmin<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, dim: usize ) -> <B as Backend>::IntTensorPrimitive<D>

fn exp<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn log<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn log1p<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn powf<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, value: f32 ) -> <B as Backend>::TensorPrimitive<D>

fn sqrt<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn cos<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn sin<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn tanh<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn erf<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn cat<const D: usize>( tensors: Vec<<B as Backend>::TensorPrimitive<D>, Global>, dim: usize ) -> <B as Backend>::TensorPrimitive<D>

fn relu<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

Provided Methods

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

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

fn arange( range: Range<usize>, device: &<B as Backend>::Device ) -> <B as Backend>::IntTensorPrimitive<1>

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

fn transpose<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

fn detach<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

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

fn is_require_grad<const D: usize>( _tensor: &<B as Backend>::TensorPrimitive<D> ) -> bool

Implementors