Enum InputScalar 

pub enum InputScalar {
    F64(f64),
    F32(f32),
    F16(f16),
    BF16(bf16),
    I64(i64),
    I32(i32),
    I16(i16),
    I8(i8),
    U64(u64),
    U32(u32),
    U16(u16),
    U8(u8),
}

A way to define an input scalar without a generic attached to it.

It uses comptime enum with zero-cost runtime abstraction for kernel generation.

Variants

F64(f64)

F32(f32)

F16(f16)

BF16(bf16)

I64(i64)

I32(i32)

I16(i16)

I8(i8)

U64(u64)

U32(u32)

U16(u16)

U8(u8)

Implementations

impl InputScalar

pub fn new_F64(_0: f64) -> Self

pub fn __expand_new_F64( _: &mut Scope, _0: <f64 as CubeType>::ExpandType, ) -> InputScalarExpand

pub fn new_F32(_0: f32) -> Self

pub fn __expand_new_F32( _: &mut Scope, _0: <f32 as CubeType>::ExpandType, ) -> InputScalarExpand

pub fn new_F16(_0: f16) -> Self

pub fn __expand_new_F16( _: &mut Scope, _0: <f16 as CubeType>::ExpandType, ) -> InputScalarExpand

pub fn new_BF16(_0: bf16) -> Self

pub fn __expand_new_BF16( _: &mut Scope, _0: <bf16 as CubeType>::ExpandType, ) -> InputScalarExpand

pub fn new_I64(_0: i64) -> Self

pub fn __expand_new_I64( _: &mut Scope, _0: <i64 as CubeType>::ExpandType, ) -> InputScalarExpand

pub fn new_I32(_0: i32) -> Self

pub fn __expand_new_I32( _: &mut Scope, _0: <i32 as CubeType>::ExpandType, ) -> InputScalarExpand

pub fn new_I16(_0: i16) -> Self

pub fn __expand_new_I16( _: &mut Scope, _0: <i16 as CubeType>::ExpandType, ) -> InputScalarExpand

pub fn new_I8(_0: i8) -> Self

pub fn __expand_new_I8( _: &mut Scope, _0: <i8 as CubeType>::ExpandType, ) -> InputScalarExpand

pub fn new_U64(_0: u64) -> Self

pub fn __expand_new_U64( _: &mut Scope, _0: <u64 as CubeType>::ExpandType, ) -> InputScalarExpand

pub fn new_U32(_0: u32) -> Self

pub fn __expand_new_U32( _: &mut Scope, _0: <u32 as CubeType>::ExpandType, ) -> InputScalarExpand

pub fn new_U16(_0: u16) -> Self

pub fn __expand_new_U16( _: &mut Scope, _0: <u16 as CubeType>::ExpandType, ) -> InputScalarExpand

pub fn new_U8(_0: u8) -> Self

pub fn __expand_new_U8( _: &mut Scope, _0: <u8 as CubeType>::ExpandType, ) -> InputScalarExpand

impl InputScalar

pub fn new<E: Numeric>(val: E, dtype: impl Into<ElemType>) -> Self

Creates an InputScalar from the given element and dtype.

Panics

If the given numeric element can’t be transformed into the passed ElemType.

impl InputScalar

pub fn get<C: CubePrimitive>(&self) -> C

Reads the scalar with the given element type.

Performs casting if necessary.

pub fn __expand_get<C: CubePrimitive>( scope: &mut Scope, this: <Self as CubeType>::ExpandType, ) -> <C as CubeType>::ExpandType

Trait Implementations

impl<R: Runtime> ArgSettings<R> for InputScalar

fn register(&self, launcher: &mut KernelLauncher<R>)

Register the information of an argument to the KernelLauncher.

impl Clone for InputScalar

fn clone(&self) -> InputScalar

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CubeDebug for InputScalar

fn set_debug_name(&self, scope: &mut Scope, name: &'static str)

Set the debug name of this type’s expansion. Should do nothing for types that don’t appear at runtime

impl CubeType for InputScalar

type ExpandType = InputScalarExpand

fn into_mut(scope: &mut Scope, expand: Self::ExpandType) -> Self::ExpandType

Wrapper around the init method, necessary to type inference.

impl LaunchArg for InputScalar

type RuntimeArg<'a, R: Runtime> = InputScalar

The runtime argument for the kernel.

type CompilationArg = InputScalarCompilationArg

Compilation argument.

fn compilation_arg<R: Runtime>( arg: &Self::RuntimeArg<'_, R>, ) -> Self::CompilationArg

fn expand( arg: &Self::CompilationArg, builder: &mut KernelBuilder, ) -> <Self as CubeType>::ExpandType

Register an input variable during compilation that fill the KernelBuilder.

fn expand_output( arg: &Self::CompilationArg, builder: &mut KernelBuilder, ) -> Self::ExpandType

Register an output variable during compilation that fill the KernelBuilder.