Struct Float 

pub struct Float;

The three tensor kinds, used only as zero-sized compile-time markers on Tensor<D, K>. They never hold data; behaviour lives in the device ops traits.

Trait Implementations

impl<D: Device> BytesDTypeKind<D> for Float

fn from_bytes_dispatch( bytes: &[u8], shape: &Shape, device: &D, dtype: FloatDType, ) -> Result<Self::Storage>

fn to_bytes_dispatch<'a>( storage: &'a Self::Storage, layout: &Layout, ) -> Result<Cow<'a, [u8]>>

impl<D: Device> ConstructDTypeKind<D> for Float

fn zeros_dispatch( shape: &Shape, device: &D, dtype: FloatDType, ) -> Result<Self::Storage>

fn ones_dispatch( shape: &Shape, device: &D, dtype: FloatDType, ) -> Result<Self::Storage>

fn full_dispatch( shape: &Shape, value: f64, device: &D, dtype: FloatDType, ) -> Result<Self::Storage>

impl<D: Device> DTypeKind<D> for Float

const KIND: KindTag = KindTag::Float

Runtime discriminant for this kind.

type Scalar = f64

type Storage = <D as Device>::FloatStorage

type Meta = FloatMeta<D>

type DType = FloatDType

impl<D: Device> IndexingDTypeKind<D> for Float

fn index_select_dispatch( x: &Self::Storage, x_l: &Layout, idx: &D::IntStorage, idx_l: &Layout, dim: usize, ) -> Result<(Self::Storage, Shape)>

fn gather_dispatch( x: &Self::Storage, x_l: &Layout, idx: &D::IntStorage, idx_l: &Layout, dim: usize, ) -> Result<(Self::Storage, Shape)>

fn index_add_dispatch( init: &Self::Storage, init_l: &Layout, idx: &D::IntStorage, idx_l: &Layout, src: &Self::Storage, src_l: &Layout, dim: usize, ) -> Result<Self::Storage>

fn scatter_add_dispatch( init: &Self::Storage, init_l: &Layout, idx: &D::IntStorage, idx_l: &Layout, src: &Self::Storage, src_l: &Layout, dim: usize, ) -> Result<Self::Storage>

impl<D: Device, T: FloatFrom> IntoTensor<D, Float> for T

fn shape(&self) -> Result<Shape>

fn into_storage(self, device: &D) -> Result<D::FloatStorage>

impl<D: Device, T: FloatFrom> IntoTensor<D, Float> for &[T]

fn shape(&self) -> Result<Shape>

fn into_storage(self, device: &D) -> Result<D::FloatStorage>

impl<D: Device, T: FloatFrom> IntoTensor<D, Float> for Vec<T>

fn shape(&self) -> Result<Shape>

fn into_storage(self, device: &D) -> Result<D::FloatStorage>

impl<D: Device, T: FloatFrom, const N: usize> IntoTensor<D, Float> for [T; N]

fn shape(&self) -> Result<Shape>

fn into_storage(self, device: &D) -> Result<D::FloatStorage>

impl<D: Device, T: FloatFrom, const N: usize> IntoTensor<D, Float> for &[T; N]

fn shape(&self) -> Result<Shape>

fn into_storage(self, device: &D) -> Result<D::FloatStorage>

impl<D: Device, T: FloatFrom, const R: usize, const C: usize> IntoTensor<D, Float> for &[[T; C]; R]

fn shape(&self) -> Result<Shape>

fn into_storage(self, device: &D) -> Result<D::FloatStorage>

impl<D: Device, T: FloatFrom, const D1: usize, const D2: usize, const D3: usize> IntoTensor<D, Float> for &[[[T; D3]; D2]; D1]

fn shape(&self) -> Result<Shape>

fn into_storage(self, device: &D) -> Result<D::FloatStorage>

impl<D: Device, T: FloatFrom, const D1: usize, const D2: usize, const D3: usize, const D4: usize> IntoTensor<D, Float> for &[[[[T; D4]; D3]; D2]; D1]

fn shape(&self) -> Result<Shape>

fn into_storage(self, device: &D) -> Result<D::FloatStorage>

impl<D: Device> NumericDTypeKind<D> for Float

fn binary_dispatch( lhs: &Self::Storage, lhs_l: &Layout, rhs: &Self::Storage, rhs_l: &Layout, op: BinaryOp, ) -> Result<Self::Storage>

fn binary_inplace_dispatch( dst: &mut Self::Storage, dst_l: &Layout, src: &Self::Storage, src_l: &Layout, op: BinaryOp, ) -> Result<()>

fn binary_scalar_dispatch( lhs: &Self::Storage, lhs_l: &Layout, rhs: Self::Scalar, op: BinaryOp, ) -> Result<Self::Storage>

fn binary_scalar_inplace_dispatch( dst: &mut Self::Storage, dst_l: &Layout, rhs: Self::Scalar, op: BinaryOp, ) -> Result<()>

fn binary_scalar_lhs_dispatch( scalar: Self::Scalar, rhs: &Self::Storage, rhs_l: &Layout, op: BinaryOp, ) -> Result<Self::Storage>

fn cmp_dispatch( lhs: &Self::Storage, lhs_l: &Layout, rhs: &Self::Storage, rhs_l: &Layout, op: CmpOp, ) -> Result<D::BoolStorage>

fn cmp_scalar_dispatch( lhs: &Self::Storage, lhs_l: &Layout, rhs: Self::Scalar, op: CmpOp, ) -> Result<D::BoolStorage>

fn unary_dispatch( x: &Self::Storage, l: &Layout, op: UnaryOp<Self::Scalar>, ) -> Result<Self::Storage>

fn unary_inplace_dispatch( dst: &mut Self::Storage, dst_l: &Layout, op: UnaryOp<Self::Scalar>, ) -> Result<()>

impl<D: Device> ReduceDTypeKind<D> for Float

fn arg_reduce_dispatch( x: &Self::Storage, layout: &Layout, dim: usize, keepdim: bool, take_max: bool, ) -> Result<(D::IntStorage, Shape)>

fn reduce_dispatch( x: &Self::Storage, l: &Layout, dims: &[usize], keepdim: bool, op: ReduceOp, ) -> Result<(Self::Storage, Shape)>

impl<D: Device> ShapeDTypeKind<D> for Float

fn contiguous_dispatch(s: &Self::Storage, l: &Layout) -> Result<Self::Storage>

fn cat_dispatch( srcs: &[(&Self::Storage, &Layout)], dim: usize, ) -> Result<(Self::Storage, Shape)>

fn view_dispatch( src: &Self::Storage, src_l: &Layout, dst_l: &Layout, view: ViewOp, ) -> Result<Option<Self::Storage>>

impl Storage<Cpu, Float> for CpuFloatStorage

fn dtype(&self) -> FloatDType

fn device(&self) -> &Cpu

impl<D: Device> TensorMeta<D, Float> for FloatMeta<D>

fn on_binary( lhs: &Tensor<D, Float>, rhs: &Tensor<D, Float>, op: BinaryOp, ) -> Self

fn on_binary_scalar(lhs: &Tensor<D, Float>, rhs: f64, op: BinaryOp) -> Self

fn on_unary(t: &Tensor<D, Float>, op: UnaryOp<f64>) -> Self

fn on_float_unary(t: &Tensor<D, Float>, op: FloatUnaryOp) -> Self

fn on_reduce(t: &Tensor<D, Float>, dims: &[usize], op: ReduceOp) -> Self

fn on_matmul(lhs: &Tensor<D, Float>, rhs: &Tensor<D, Float>) -> Self

fn on_broadcast(t: &Tensor<D, Float>) -> Self

fn on_narrow(t: &Tensor<D, Float>, dim: usize, start: usize, len: usize) -> Self

fn on_slice( t: &Tensor<D, Float>, dim: usize, start: usize, end: usize, step: usize, ) -> Self

fn on_reshape(t: &Tensor<D, Float>) -> Self

fn on_transpose(t: &Tensor<D, Float>, dim1: usize, dim2: usize) -> Self

fn on_permute(t: &Tensor<D, Float>, dims: Vec<usize>) -> Self

fn on_cat<A: AsRef<Tensor<D, Float>>>(args: &[A], dim: usize) -> Self

fn on_copy(t: &Tensor<D, Float>) -> Self

fn on_cast(t: &Tensor<D, Float>) -> Self

fn on_index_select( t: &Tensor<D, Float>, idx: &Tensor<D, Int>, dim: usize, ) -> Self

fn on_gather(src: &Tensor<D, Float>, idx: &Tensor<D, Int>, dim: usize) -> Self

fn on_index_add( init: &Tensor<D, Float>, idx: &Tensor<D, Int>, src: &Tensor<D, Float>, dim: usize, ) -> Self

fn on_scatter_add( init: &Tensor<D, Float>, idx: &Tensor<D, Int>, src: &Tensor<D, Float>, dim: usize, ) -> Self

fn on_pick( mask: &Tensor<D, Bool>, tv: Option<&Tensor<D, Float>>, fv: Option<&Tensor<D, Float>>, ) -> Self

fn on_rms_norm( input: &Tensor<D, Float>, weight: &Tensor<D, Float>, eps: f64, ) -> Self

fn on_softmax(input: &Tensor<D, Float>, dim: usize) -> Self

impl<D: Device, D2: Device> TransferDTypeKind<D, D2> for Float

fn transfer(src: &Tensor<D, Float>, device: &D2) -> Result<Tensor<D2, Float>>