Struct NativeExpand 

pub struct NativeExpand<T>
where
    T: CubeType,
{
    pub expand: ManagedVariable,
    /* private fields */
}

Expand type of a native GPU type, i.e. scalar primitives, arrays, shared memory.

Fields

expand: ManagedVariable

Implementations

impl NativeExpand<Barrier>

pub fn __expand_tma_load_1d_method<C1, C2>( &self, scope: &mut Scope, source: NativeExpand<TensorMap<C1, Tiled>>, destination: SliceExpand<C2, ReadWrite>, x: NativeExpand<i32>, )

where C1: CubePrimitive, C2: CubePrimitive<Scalar = <C1 as CubePrimitive>::Scalar>,

impl NativeExpand<Barrier>

pub fn __expand_tma_load_2d_method<C1, C2>( &self, scope: &mut Scope, source: NativeExpand<TensorMap<C1, Tiled>>, destination: SliceExpand<C2, ReadWrite>, y: NativeExpand<i32>, x: NativeExpand<i32>, )

where C1: CubePrimitive, C2: CubePrimitive<Scalar = <C1 as CubePrimitive>::Scalar>,

impl NativeExpand<Barrier>

pub fn __expand_tma_load_3d_method<C1, C2>( &self, scope: &mut Scope, source: NativeExpand<TensorMap<C1, Tiled>>, destination: SliceExpand<C2, ReadWrite>, z: NativeExpand<i32>, y: NativeExpand<i32>, x: NativeExpand<i32>, )

where C1: CubePrimitive, C2: CubePrimitive<Scalar = <C1 as CubePrimitive>::Scalar>,

impl NativeExpand<Barrier>

pub fn __expand_tma_load_4d_method<C1, C2>( &self, scope: &mut Scope, source: NativeExpand<TensorMap<C1, Tiled>>, destination: SliceExpand<C2, ReadWrite>, w: NativeExpand<i32>, z: NativeExpand<i32>, y: NativeExpand<i32>, x: NativeExpand<i32>, )

where C1: CubePrimitive, C2: CubePrimitive<Scalar = <C1 as CubePrimitive>::Scalar>,

impl NativeExpand<Barrier>

pub fn __expand_tma_load_5d_method<C1, C2>( &self, scope: &mut Scope, source: NativeExpand<TensorMap<C1, Tiled>>, destination: SliceExpand<C2, ReadWrite>, v: NativeExpand<i32>, w: NativeExpand<i32>, z: NativeExpand<i32>, y: NativeExpand<i32>, x: NativeExpand<i32>, )

where C1: CubePrimitive, C2: CubePrimitive<Scalar = <C1 as CubePrimitive>::Scalar>,

impl NativeExpand<Barrier>

pub fn __expand_tma_load_im2col_3d_method<C1, C2>( &self, scope: &mut Scope, source: NativeExpand<TensorMap<C1, Im2col>>, destination: SliceExpand<C2, ReadWrite>, n: NativeExpand<i32>, w: NativeExpand<i32>, c: NativeExpand<i32>, w_offset: NativeExpand<u16>, )

where C1: CubePrimitive, C2: CubePrimitive<Scalar = <C1 as CubePrimitive>::Scalar>,

impl NativeExpand<Barrier>

pub fn __expand_tma_load_im2col_4d_method<C1, C2>( &self, scope: &mut Scope, source: NativeExpand<TensorMap<C1, Im2col>>, destination: SliceExpand<C2, ReadWrite>, n: NativeExpand<i32>, h: NativeExpand<i32>, w: NativeExpand<i32>, c: NativeExpand<i32>, h_offset: NativeExpand<u16>, w_offset: NativeExpand<u16>, )

where C1: CubePrimitive, C2: CubePrimitive<Scalar = <C1 as CubePrimitive>::Scalar>,

impl NativeExpand<Barrier>

pub fn __expand_tma_load_im2col_5d_method<C1, C2>( &self, scope: &mut Scope, source: NativeExpand<TensorMap<C1, Im2col>>, destination: SliceExpand<C2, ReadWrite>, n: NativeExpand<i32>, d: NativeExpand<i32>, h: NativeExpand<i32>, w: NativeExpand<i32>, c: NativeExpand<i32>, d_offset: NativeExpand<u16>, h_offset: NativeExpand<u16>, w_offset: NativeExpand<u16>, )

where C1: CubePrimitive, C2: CubePrimitive<Scalar = <C1 as CubePrimitive>::Scalar>,

impl NativeExpand<Barrier>

pub fn __expand_init_manual_method( &self, scope: &mut Scope, arrival_count: <u32 as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

pub fn __expand_local(scope: &mut Scope) -> NativeExpand<Barrier>

pub fn __expand_shared( scope: &mut Scope, arrival_count: <u32 as CubeType>::ExpandType, is_elected: <bool as CubeType>::ExpandType, ) -> <Shared<Barrier> as CubeType>::ExpandType

pub fn __expand_shared_uninit( scope: &mut Scope, ) -> <Shared<Barrier> as CubeType>::ExpandType

pub fn __expand_init_manual( scope: &mut Scope, this: &NativeExpand<Barrier>, arrival_count: <u32 as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl NativeExpand<Barrier>

pub fn __expand_memcpy_async_method<C>( &self, scope: &mut Scope, source: <Slice<C> as CubeType>::ExpandType, destination: <Slice<C, ReadWrite> as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

where C: CubePrimitive,

pub fn __expand_memcpy_async_cooperative_method<C>( &self, scope: &mut Scope, source: <Slice<C> as CubeType>::ExpandType, destination: <Slice<C, ReadWrite> as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

where C: CubePrimitive,

pub fn __expand_memcpy_async_tx_method<C>( &self, scope: &mut Scope, source: <Slice<C> as CubeType>::ExpandType, destination: <Slice<C, ReadWrite> as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

where C: CubePrimitive,

pub fn __expand_memcpy_async<C>( scope: &mut Scope, this: &NativeExpand<Barrier>, source: <Slice<C> as CubeType>::ExpandType, destination: <Slice<C, ReadWrite> as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

where C: CubePrimitive,

pub fn __expand_memcpy_async_cooperative<C>( scope: &mut Scope, this: &NativeExpand<Barrier>, source: <Slice<C> as CubeType>::ExpandType, destination: <Slice<C, ReadWrite> as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

where C: CubePrimitive,

pub fn __expand_memcpy_async_tx<C>( scope: &mut Scope, this: &NativeExpand<Barrier>, source: <Slice<C> as CubeType>::ExpandType, destination: <Slice<C, ReadWrite> as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

where C: CubePrimitive,

impl NativeExpand<Barrier>

pub fn __expand_arrive_method( &self, scope: &mut Scope, ) -> <BarrierToken as CubeType>::ExpandType

pub fn __expand_arrive_and_expect_tx_method( &self, scope: &mut Scope, arrival_count: <u32 as CubeType>::ExpandType, transaction_count: <u32 as CubeType>::ExpandType, ) -> <BarrierToken as CubeType>::ExpandType

pub fn __expand_expect_tx_method( &self, scope: &mut Scope, expected_count: <u32 as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

pub fn __expand_arrive_and_wait_method( &self, scope: &mut Scope, ) -> <() as CubeType>::ExpandType

pub fn __expand_wait_method( &self, scope: &mut Scope, token: <BarrierToken as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

pub fn __expand_wait_parity_method( &self, scope: &mut Scope, phase: <u32 as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

pub fn __expand_arrive( scope: &mut Scope, this: &NativeExpand<Barrier>, ) -> <BarrierToken as CubeType>::ExpandType

pub fn __expand_arrive_and_expect_tx( scope: &mut Scope, this: &NativeExpand<Barrier>, arrival_count: <u32 as CubeType>::ExpandType, transaction_count: <u32 as CubeType>::ExpandType, ) -> <BarrierToken as CubeType>::ExpandType

pub fn __expand_expect_tx( scope: &mut Scope, this: &NativeExpand<Barrier>, expected_count: <u32 as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

pub fn __expand_arrive_and_wait( scope: &mut Scope, this: &NativeExpand<Barrier>, ) -> <() as CubeType>::ExpandType

pub fn __expand_wait( scope: &mut Scope, this: &NativeExpand<Barrier>, token: <BarrierToken as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

pub fn __expand_wait_parity( scope: &mut Scope, this: &NativeExpand<Barrier>, phase: <u32 as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl NativeExpand<Barrier>

pub fn __expand_commit_copy_async_method( &self, scope: &mut Scope, ) -> <() as CubeType>::ExpandType

pub fn __expand_commit_copy_async( scope: &mut Scope, this: &NativeExpand<Barrier>, ) -> <() as CubeType>::ExpandType

impl<T> NativeExpand<Array<T>>

where T: CubePrimitive + Clone,

pub fn __expand_to_vectorized_method<N>( self, scope: &mut Scope, ) -> <T as CubeType>::ExpandType

where N: Size,

pub fn __expand_to_vectorized<N>( scope: &mut Scope, this: NativeExpand<Array<T>>, ) -> <T as CubeType>::ExpandType

where N: Size,

impl<E> NativeExpand<Array<E>>

where E: CubeType,

pub fn __expand_len_method( self, scope: &mut Scope, ) -> <usize as CubeType>::ExpandType

pub fn __expand_buffer_len_method( self, scope: &mut Scope, ) -> <usize as CubeType>::ExpandType

pub fn __expand_len( scope: &mut Scope, this: NativeExpand<Array<E>>, ) -> <usize as CubeType>::ExpandType

pub fn __expand_buffer_len( scope: &mut Scope, this: NativeExpand<Array<E>>, ) -> <usize as CubeType>::ExpandType

impl<E> NativeExpand<Array<E>>

where E: CubePrimitive,

pub fn __expand_index_unchecked_method( self, scope: &mut Scope, i: <usize as CubeType>::ExpandType, ) -> <E as CubeType>::ExpandType

pub fn __expand_index_assign_unchecked_method( self, scope: &mut Scope, i: <usize as CubeType>::ExpandType, value: <E as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

pub fn __expand_index_unchecked( scope: &mut Scope, this: NativeExpand<Array<E>>, i: <usize as CubeType>::ExpandType, ) -> <E as CubeType>::ExpandType

pub fn __expand_index_assign_unchecked( scope: &mut Scope, this: NativeExpand<Array<E>>, i: <usize as CubeType>::ExpandType, value: <E as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T> NativeExpand<SharedMemory<T>>

where T: CubePrimitive + Clone,

pub fn __expand_len_method( self, scope: &mut Scope, ) -> <usize as CubeType>::ExpandType

pub fn __expand_buffer_len_method( self, scope: &mut Scope, ) -> <usize as CubeType>::ExpandType

pub fn __expand_new( scope: &mut Scope, size: usize, ) -> NativeExpand<SharedMemory<T>>

pub fn __expand_len( scope: &mut Scope, this: NativeExpand<SharedMemory<T>>, ) -> <usize as CubeType>::ExpandType

pub fn __expand_buffer_len( scope: &mut Scope, this: NativeExpand<SharedMemory<T>>, ) -> <usize as CubeType>::ExpandType

impl<T> NativeExpand<SharedMemory<T>>

where T: CubePrimitive + Clone,

pub fn __expand_free_method( self, scope: &mut Scope, ) -> <() as CubeType>::ExpandType

pub fn __expand_new_aligned( scope: &mut Scope, size: usize, alignment: usize, ) -> <SharedMemory<T> as CubeType>::ExpandType

pub fn __expand_free( scope: &mut Scope, this: NativeExpand<SharedMemory<T>>, ) -> <() as CubeType>::ExpandType

impl<E> NativeExpand<SharedMemory<E>>

where E: CubePrimitive,

pub fn __expand_index_unchecked_method( self, scope: &mut Scope, i: <usize as CubeType>::ExpandType, ) -> <E as CubeType>::ExpandType

pub fn __expand_index_assign_unchecked_method( self, scope: &mut Scope, i: <usize as CubeType>::ExpandType, value: <E as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

pub fn __expand_index_unchecked( scope: &mut Scope, this: NativeExpand<SharedMemory<E>>, i: <usize as CubeType>::ExpandType, ) -> <E as CubeType>::ExpandType

pub fn __expand_index_assign_unchecked( scope: &mut Scope, this: NativeExpand<SharedMemory<E>>, i: <usize as CubeType>::ExpandType, value: <E as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T> NativeExpand<Tensor<T>>

where T: CubeType,

pub fn __expand_stride_method( self, scope: &mut Scope, dim: <usize as CubeType>::ExpandType, ) -> <usize as CubeType>::ExpandType

pub fn __expand_shape_method( self, scope: &mut Scope, dim: <usize as CubeType>::ExpandType, ) -> <usize as CubeType>::ExpandType

pub fn __expand_coordinate_method( self, scope: &mut Scope, index: <usize as CubeType>::ExpandType, dim: <usize as CubeType>::ExpandType, ) -> <usize as CubeType>::ExpandType

pub fn __expand_len_method( self, scope: &mut Scope, ) -> <usize as CubeType>::ExpandType

pub fn __expand_buffer_len_method( self, scope: &mut Scope, ) -> <usize as CubeType>::ExpandType

pub fn __expand_rank_method( self, scope: &mut Scope, ) -> <usize as CubeType>::ExpandType

pub fn __expand_stride( scope: &mut Scope, this: NativeExpand<Tensor<T>>, dim: <usize as CubeType>::ExpandType, ) -> <usize as CubeType>::ExpandType

pub fn __expand_shape( scope: &mut Scope, this: NativeExpand<Tensor<T>>, dim: <usize as CubeType>::ExpandType, ) -> <usize as CubeType>::ExpandType

pub fn __expand_coordinate( scope: &mut Scope, this: NativeExpand<Tensor<T>>, index: <usize as CubeType>::ExpandType, dim: <usize as CubeType>::ExpandType, ) -> <usize as CubeType>::ExpandType

pub fn __expand_len( scope: &mut Scope, this: NativeExpand<Tensor<T>>, ) -> <usize as CubeType>::ExpandType

pub fn __expand_buffer_len( scope: &mut Scope, this: NativeExpand<Tensor<T>>, ) -> <usize as CubeType>::ExpandType

pub fn __expand_rank( scope: &mut Scope, this: NativeExpand<Tensor<T>>, ) -> <usize as CubeType>::ExpandType

impl<E> NativeExpand<Tensor<E>>

where E: CubePrimitive,

pub fn __expand_index_unchecked_method( self, scope: &mut Scope, i: <usize as CubeType>::ExpandType, ) -> <E as CubeType>::ExpandType

pub fn __expand_index_assign_unchecked_method( self, scope: &mut Scope, i: <usize as CubeType>::ExpandType, value: <E as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

pub fn __expand_index_unchecked( scope: &mut Scope, this: NativeExpand<Tensor<E>>, i: <usize as CubeType>::ExpandType, ) -> <E as CubeType>::ExpandType

pub fn __expand_index_assign_unchecked( scope: &mut Scope, this: NativeExpand<Tensor<E>>, i: <usize as CubeType>::ExpandType, value: <E as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T, K> NativeExpand<TensorMap<T, K>>

where T: CubePrimitive, K: TensorMapKind,

pub fn __expand_buffer_method( self, scope: &mut Scope, ) -> NativeExpand<Tensor<T>>

pub fn __expand_stride_method( self, scope: &mut Scope, dim: NativeExpand<usize>, ) -> NativeExpand<usize>

pub fn __expand_shape_method( self, scope: &mut Scope, dim: NativeExpand<usize>, ) -> NativeExpand<usize>

pub fn __expand_coordinate_method( self, scope: &mut Scope, index: NativeExpand<usize>, dim: NativeExpand<usize>, ) -> NativeExpand<usize>

pub fn __expand_len_method(self, scope: &mut Scope) -> NativeExpand<usize>

pub fn __expand_buffer_len_method( self, scope: &mut Scope, ) -> NativeExpand<usize>

pub fn __expand_rank_method(self, scope: &mut Scope) -> NativeExpand<usize>

pub fn __expand_downcast_method<E>( self, scope: &mut Scope, ) -> NativeExpand<TensorMap<E, K>>

where E: CubePrimitive,

Expand method of TensorMap::downcast.

impl<P, N> NativeExpand<Vector<P, N>>

where P: Scalar, N: Size,

pub fn __expand_fill_method( self, scope: &mut Scope, value: <P as CubeType>::ExpandType, ) -> NativeExpand<Vector<P, N>>

pub fn __expand_fill( scope: &mut Scope, this: NativeExpand<Vector<P, N>>, value: <P as CubeType>::ExpandType, ) -> NativeExpand<Vector<P, N>>

impl<P, N> NativeExpand<Vector<P, N>>

where P: Scalar, N: Size,

pub fn size(&self) -> usize

Comptime version of size.

pub fn __expand_size_method(&self, _scope: &mut Scope) -> usize

Expand method of size.

impl<P, N> NativeExpand<Vector<P, N>>

where P: Scalar, N: Size,

pub fn __expand_equal_method( self, scope: &mut Scope, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

pub fn __expand_equal( scope: &mut Scope, this: NativeExpand<Vector<P, N>>, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> NativeExpand<Vector<P, N>>

where P: Scalar, N: Size,

pub fn __expand_not_equal_method( self, scope: &mut Scope, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

pub fn __expand_not_equal( scope: &mut Scope, this: NativeExpand<Vector<P, N>>, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> NativeExpand<Vector<P, N>>

where P: Scalar, N: Size,

pub fn __expand_less_than_method( self, scope: &mut Scope, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

pub fn __expand_less_than( scope: &mut Scope, this: NativeExpand<Vector<P, N>>, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> NativeExpand<Vector<P, N>>

where P: Scalar, N: Size,

pub fn __expand_greater_than_method( self, scope: &mut Scope, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

pub fn __expand_greater_than( scope: &mut Scope, this: NativeExpand<Vector<P, N>>, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> NativeExpand<Vector<P, N>>

where P: Scalar, N: Size,

pub fn __expand_less_equal_method( self, scope: &mut Scope, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

pub fn __expand_less_equal( scope: &mut Scope, this: NativeExpand<Vector<P, N>>, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> NativeExpand<Vector<P, N>>

where P: Scalar, N: Size,

pub fn __expand_greater_equal_method( self, scope: &mut Scope, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

pub fn __expand_greater_equal( scope: &mut Scope, this: NativeExpand<Vector<P, N>>, other: NativeExpand<Vector<P, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<N> NativeExpand<Vector<bool, N>>

where N: Size,

pub fn __expand_and_method( self, scope: &mut Scope, other: NativeExpand<Vector<bool, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

pub fn __expand_and( scope: &mut Scope, this: NativeExpand<Vector<bool, N>>, other: NativeExpand<Vector<bool, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<N> NativeExpand<Vector<bool, N>>

where N: Size,

pub fn __expand_or_method( self, scope: &mut Scope, other: NativeExpand<Vector<bool, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

pub fn __expand_or( scope: &mut Scope, this: NativeExpand<Vector<bool, N>>, other: NativeExpand<Vector<bool, N>>, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> NativeExpand<Vector<P, N>>

where P: CountOnes + Scalar, N: Size,

pub fn __expand_count_ones_method( self, scope: &mut Scope, ) -> <Vector<u32, N> as CubeType>::ExpandType

pub fn __expand_count_ones( scope: &mut Scope, this: NativeExpand<Vector<P, N>>, ) -> <Vector<u32, N> as CubeType>::ExpandType

impl<Inner> NativeExpand<Atomic<Inner>>

where Inner: CubePrimitive, <Inner as CubePrimitive>::Scalar: Numeric,

pub fn __expand_load_method( self, scope: &mut Scope, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_store_method( self, scope: &mut Scope, value: <Inner as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

pub fn __expand_swap_method( self, scope: &mut Scope, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_add_method( self, scope: &mut Scope, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_sub_method( self, scope: &mut Scope, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_max_method( self, scope: &mut Scope, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_min_method( self, scope: &mut Scope, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_load( scope: &mut Scope, this: NativeExpand<Atomic<Inner>>, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_store( scope: &mut Scope, this: NativeExpand<Atomic<Inner>>, value: <Inner as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

pub fn __expand_swap( scope: &mut Scope, this: NativeExpand<Atomic<Inner>>, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_add( scope: &mut Scope, this: NativeExpand<Atomic<Inner>>, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_sub( scope: &mut Scope, this: NativeExpand<Atomic<Inner>>, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_max( scope: &mut Scope, this: NativeExpand<Atomic<Inner>>, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_min( scope: &mut Scope, this: NativeExpand<Atomic<Inner>>, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

impl<Inner> NativeExpand<Atomic<Inner>>

where Inner: CubePrimitive, <Inner as CubePrimitive>::Scalar: Int,

pub fn __expand_compare_exchange_weak_method( self, scope: &mut Scope, cmp: <Inner as CubeType>::ExpandType, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_and_method( self, scope: &mut Scope, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_or_method( self, scope: &mut Scope, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_xor_method( self, scope: &mut Scope, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_compare_exchange_weak( scope: &mut Scope, this: NativeExpand<Atomic<Inner>>, cmp: <Inner as CubeType>::ExpandType, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_and( scope: &mut Scope, this: NativeExpand<Atomic<Inner>>, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_or( scope: &mut Scope, this: NativeExpand<Atomic<Inner>>, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

pub fn __expand_fetch_xor( scope: &mut Scope, this: NativeExpand<Atomic<Inner>>, value: <Inner as CubeType>::ExpandType, ) -> <Inner as CubeType>::ExpandType

impl<T> NativeExpand<T>

where T: CubeType,

pub fn new(expand: ManagedVariable) -> NativeExpand<T>

Constructs a new NativeExpand.

impl<T> NativeExpand<T>

where T: CubeType,

pub unsafe fn as_type_ref_unchecked<E>(&self) -> &NativeExpand<E>

where E: CubeType,

Casts a reference of this expand element to a different type.

Safety

There’s no guarantee the new type is valid for the ManagedVariable

pub unsafe fn as_type_mut_unchecked<E>(&mut self) -> &mut NativeExpand<E>

where E: CubeType,

Casts a mutable reference of this expand element to a different type.

Safety

There’s no guarantee the new type is valid for the ManagedVariable

impl<T> NativeExpand<T>

where T: CubeType,

pub fn vector_size(&self) -> usize

Comptime version of crate::frontend::Array::vector_size.

pub fn __expand_vector_size_method(self, _scope: &mut Scope) -> usize

pub fn into_variable(self) -> Variable

impl<T> NativeExpand<T>

where T: CubePrimitive,

pub fn from_lit<L>(scope: &Scope, lit: L) -> NativeExpand<T>

where L: Into<ConstantValue>,

Create an NativeExpand from a value that is normally a literal.

pub fn constant(&self) -> Option<ConstantValue>

Get the ConstantValue from the variable.

pub fn __expand_into_lit_unchecked_method(self, _scope: &mut Scope) -> T

impl<E> NativeExpand<E>

where E: Int,

pub fn __expand_is_multiple_of_method( self, scope: &mut Scope, factor: NativeExpand<E>, ) -> NativeExpand<bool>

Trait Implementations

impl<T> AbsExpand for NativeExpand<T>

where T: Abs + CubePrimitive,

fn __expand_abs_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> AddAssignExpand for NativeExpand<T>

where T: AddAssign + CubePrimitive,

fn __expand_add_assign_method(self, scope: &mut Scope, rhs: NativeExpand<T>)

impl<T> AddExpand for NativeExpand<T>

where T: Add<Output = T> + CubePrimitive,

fn __expand_add_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> ArcCosExpand for NativeExpand<T>

where T: ArcCos + CubePrimitive,

fn __expand_acos_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> ArcCoshExpand for NativeExpand<T>

where T: ArcCosh + CubePrimitive,

fn __expand_acosh_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> ArcSinExpand for NativeExpand<T>

where T: ArcSin + CubePrimitive,

fn __expand_asin_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> ArcSinhExpand for NativeExpand<T>

where T: ArcSinh + CubePrimitive,

fn __expand_asinh_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> ArcTan2Expand for NativeExpand<T>

where T: CubePrimitive + ArcTan2,

fn __expand_atan2_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> ArcTanExpand for NativeExpand<T>

where T: ArcTan + CubePrimitive,

fn __expand_atan_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> ArcTanhExpand for NativeExpand<T>

where T: ArcTanh + CubePrimitive,

fn __expand_atanh_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> AsMutExpand<T> for NativeExpand<Shared<T>>

where T: CubePrimitive,

fn __expand_as_mut_method( self, _scope: &mut Scope, ) -> <T as CubeType>::ExpandType

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsMutExpand<T> for NativeExpand<T>

where T: CubePrimitive,

fn __expand_as_mut_method( self, _scope: &mut Scope, ) -> <T as CubeType>::ExpandType

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRefExpand<T> for NativeExpand<Shared<T>>

where T: CubePrimitive,

fn __expand_as_ref_method( self, _scope: &mut Scope, ) -> <T as CubeType>::ExpandType

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRefExpand<T> for NativeExpand<T>

where T: CubePrimitive,

fn __expand_as_ref_method(self, _scope: &mut Scope) -> NativeExpand<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<E> AsTensorViewExpand<E> for NativeExpand<TensorMap<E, Tiled>>

where E: CubePrimitive,

fn __expand_view_1d_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, usize>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn __expand_view_2d_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (u32, u32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn __expand_view_3d_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (u32, u32, u32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn __expand_view_4d_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (u32, u32, u32, u32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn __expand_view_5d_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (u32, u32, u32, u32, u32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn __expand_view_1i_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, i32>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn __expand_view_2i_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (i32, i32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn __expand_view_3i_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (i32, i32, i32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn __expand_view_4i_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (i32, i32, i32, i32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn __expand_view_5i_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (i32, i32, i32, i32, i32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

impl<E> AsTensorViewMutExpand<E> for NativeExpand<TensorMap<E, Tiled>>

where E: CubePrimitive,

fn __expand_view_mut_1d_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, usize>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

fn __expand_view_mut_2d_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (u32, u32)>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

fn __expand_view_mut_3d_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (u32, u32, u32)>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

fn __expand_view_mut_4d_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (u32, u32, u32, u32)>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

fn __expand_view_mut_5d_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (u32, u32, u32, u32, u32)>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

fn __expand_view_mut_1i_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, i32>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

fn __expand_view_mut_2i_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (i32, i32)>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

fn __expand_view_mut_3i_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (i32, i32, i32)>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

fn __expand_view_mut_4i_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (i32, i32, i32, i32)>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

fn __expand_view_mut_5i_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, (i32, i32, i32, i32, i32)>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

impl<E> AsViewExpand<E> for NativeExpand<Array<E>>

where E: CubePrimitive,

type SourceCoords = usize

fn __expand_view_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, usize>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

impl<E> AsViewExpand<E> for NativeExpand<SharedMemory<E>>

where E: CubePrimitive,

type SourceCoords = usize

fn __expand_view_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, usize>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

impl<E> AsViewExpand<E> for NativeExpand<Tensor<E>>

where E: CubePrimitive,

type SourceCoords = usize

fn __expand_view_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, usize>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

impl<E> AsViewMutExpand<E> for NativeExpand<Array<E>>

where E: CubePrimitive,

fn __expand_view_mut_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, usize>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

impl<E> AsViewMutExpand<E> for NativeExpand<SharedMemory<E>>

where E: CubePrimitive,

fn __expand_view_mut_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, usize>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

impl<E> AsViewMutExpand<E> for NativeExpand<Tensor<E>>

where E: CubePrimitive,

fn __expand_view_mut_method<C>( self, scope: &mut Scope, layout: VirtualLayoutExpand<C, usize>, ) -> ViewExpand<E, C, ReadWrite>

where C: Coordinates + 'static,

impl<T> Assign for NativeExpand<T>

where T: NativeAssign,

fn expand_assign(&mut self, scope: &mut Scope, value: NativeExpand<T>)

Assign value to self in scope.

fn init_mut(&self, scope: &mut Scope) -> NativeExpand<T>

Create a new mutable variable of this type in scope.

impl<T> CeilExpand for NativeExpand<T>

where T: Ceil + CubePrimitive,

fn __expand_ceil_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> Clone for NativeExpand<T>

where T: CubeType,

fn clone(&self) -> NativeExpand<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> CosExpand for NativeExpand<T>

where T: Cos + CubePrimitive,

fn __expand_cos_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> CoshExpand for NativeExpand<T>

where T: Cosh + CubePrimitive,

fn __expand_cosh_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> CountOnesExpand for NativeExpand<T>

where T: CountOnes + CubePrimitive,

fn __expand_count_ones_method( self, scope: &mut Scope, ) -> <NativeExpand<T> as CubePrimitiveExpand>::WithScalar<u32>

impl<T> CubeDebug for &NativeExpand<T>

where T: CubeType,

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<T> CubeDebug for &mut NativeExpand<T>

where T: CubeType,

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<T> CubeDebug for NativeExpand<T>

where T: CubeType,

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<E> CubeIndexExpand for NativeExpand<Array<E>>

where E: CubePrimitive,

type Output = NativeExpand<E>

type Idx = NativeExpand<usize>

fn expand_index( self, scope: &mut Scope, index: NativeExpand<usize>, ) -> <NativeExpand<Array<E>> as CubeIndexExpand>::Output

fn expand_index_unchecked( self, scope: &mut Scope, index: NativeExpand<usize>, ) -> <NativeExpand<Array<E>> as CubeIndexExpand>::Output

impl<E> CubeIndexExpand for NativeExpand<SharedMemory<E>>

where E: CubePrimitive,

type Output = NativeExpand<E>

type Idx = NativeExpand<usize>

fn expand_index( self, scope: &mut Scope, index: NativeExpand<usize>, ) -> <NativeExpand<SharedMemory<E>> as CubeIndexExpand>::Output

fn expand_index_unchecked( self, scope: &mut Scope, index: NativeExpand<usize>, ) -> <NativeExpand<SharedMemory<E>> as CubeIndexExpand>::Output

impl<E> CubeIndexExpand for NativeExpand<Tensor<E>>

where E: CubePrimitive,

type Output = NativeExpand<E>

type Idx = NativeExpand<usize>

fn expand_index( self, scope: &mut Scope, index: NativeExpand<usize>, ) -> <NativeExpand<Tensor<E>> as CubeIndexExpand>::Output

fn expand_index_unchecked( self, scope: &mut Scope, index: NativeExpand<usize>, ) -> <NativeExpand<Tensor<E>> as CubeIndexExpand>::Output

impl<E, N> CubeIndexExpand for NativeExpand<Vector<E, N>>

where E: Scalar, N: Size,

type Output = NativeExpand<E>

type Idx = NativeExpand<usize>

fn expand_index( self, scope: &mut Scope, index: NativeExpand<usize>, ) -> <NativeExpand<Vector<E, N>> as CubeIndexExpand>::Output

fn expand_index_unchecked( self, scope: &mut Scope, index: NativeExpand<usize>, ) -> <NativeExpand<Vector<E, N>> as CubeIndexExpand>::Output

impl<E> CubeIndexMutExpand for NativeExpand<Array<E>>

where E: CubePrimitive,

fn expand_index_mut( self, scope: &mut Scope, index: NativeExpand<usize>, value: <NativeExpand<Array<E>> as CubeIndexExpand>::Output, )

impl<E> CubeIndexMutExpand for NativeExpand<SharedMemory<E>>

where E: CubePrimitive,

fn expand_index_mut( self, scope: &mut Scope, index: NativeExpand<usize>, value: <NativeExpand<SharedMemory<E>> as CubeIndexExpand>::Output, )

impl<E> CubeIndexMutExpand for NativeExpand<Tensor<E>>

where E: CubePrimitive,

fn expand_index_mut( self, scope: &mut Scope, index: NativeExpand<usize>, value: <NativeExpand<Tensor<E>> as CubeIndexExpand>::Output, )

impl<E, N> CubeIndexMutExpand for NativeExpand<Vector<E, N>>

where E: Scalar, N: Size,

fn expand_index_mut( self, scope: &mut Scope, index: NativeExpand<usize>, value: <NativeExpand<Vector<E, N>> as CubeIndexExpand>::Output, )

impl<T> CubePrimitiveExpand for NativeExpand<T>

where T: CubePrimitive,

type Scalar = NativeExpand<<T as CubePrimitive>::Scalar>

type WithScalar<S: Scalar> = NativeExpand<<T as CubePrimitive>::WithScalar<S>>

impl<T> DegreesExpand for NativeExpand<T>

where T: Degrees + CubePrimitive,

fn __expand_to_degrees_method(self, scope: &mut Scope) -> NativeExpand<T>

impl Deref for NativeExpand<Shared<Barrier>>

type Target = NativeExpand<Barrier>

The resulting type after dereferencing.

fn deref(&self) -> &<NativeExpand<Shared<Barrier>> as Deref>::Target

Dereferences the value.

impl DerefMut for NativeExpand<Shared<Barrier>>

fn deref_mut(&mut self) -> &mut <NativeExpand<Shared<Barrier>> as Deref>::Target

Mutably dereferences the value.

impl<T> DivAssignExpand for NativeExpand<T>

where T: DivAssign + CubePrimitive,

fn __expand_div_assign_method(self, scope: &mut Scope, rhs: NativeExpand<T>)

impl<E> DivCeilExpand<E> for NativeExpand<E>

where E: DivCeil,

fn __expand_div_ceil_method( self, scope: &mut Scope, divisor: NativeExpand<E>, ) -> NativeExpand<E>

impl<T> DivExpand for NativeExpand<T>

where T: Div<Output = T> + CubePrimitive,

fn __expand_mul_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> DotExpand for NativeExpand<T>

where T: CubePrimitive + Dot,

fn __expand_dot_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> <NativeExpand<T> as CubePrimitiveExpand>::Scalar

impl<T> ErfExpand for NativeExpand<T>

where T: Erf + CubePrimitive,

fn __expand_erf_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> ExpExpand for NativeExpand<T>

where T: Exp + CubePrimitive,

fn __expand_exp_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> FindFirstSetExpand for NativeExpand<T>

where T: FindFirstSet + CubePrimitive,

fn __expand_find_first_set_method( self, scope: &mut Scope, ) -> <NativeExpand<T> as CubePrimitiveExpand>::WithScalar<u32>

impl<F> FloatBitsExpand for NativeExpand<F>

where F: FloatBits,

type Bits = <F as FloatBits>::Bits

fn __expand_to_bits_method( self, scope: &mut Scope, ) -> NativeExpand<<NativeExpand<F> as FloatBitsExpand>::Bits>

impl<T> FloatOpsExpand for NativeExpand<T>

where T: FloatOps + CubePrimitive,

fn __expand_min_method( self, scope: &mut Scope, other: NativeExpand<T>, ) -> NativeExpand<T>

fn __expand_max_method( self, scope: &mut Scope, other: NativeExpand<T>, ) -> NativeExpand<T>

fn __expand_clamp_method( self, scope: &mut Scope, min: NativeExpand<T>, max: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> FloorExpand for NativeExpand<T>

where T: Floor + CubePrimitive,

fn __expand_floor_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> From<&NativeExpand<T>> for NativeExpand<T>

where T: CubeType,

fn from(value: &NativeExpand<T>) -> NativeExpand<T>

Converts to this type from the input type.

impl<T> From<&mut NativeExpand<T>> for NativeExpand<T>

where T: CubeType,

fn from(value: &mut NativeExpand<T>) -> NativeExpand<T>

Converts to this type from the input type.

impl<Marker> From<DynamicScalar<Marker>> for NativeExpand<DynamicScalar<Marker>>

where Marker: 'static,

fn from(value: DynamicScalar<Marker>) -> NativeExpand<DynamicScalar<Marker>>

Converts to this type from the input type.

impl<T> From<ManagedVariable> for NativeExpand<T>

where T: CubeType,

fn from(expand: ManagedVariable) -> NativeExpand<T>

Converts to this type from the input type.

impl From<NativeExpand<Shared<Barrier>>> for NativeExpand<Barrier>

fn from(value: NativeExpand<Shared<Barrier>>) -> NativeExpand<Barrier>

Converts to this type from the input type.

impl<T> From<NativeExpand<T>> for ManagedVariable

where T: CubeType,

fn from(value: NativeExpand<T>) -> ManagedVariable

Converts to this type from the input type.

impl<T> From<NativeExpand<T>> for Variable

where T: CubeType,

fn from(value: NativeExpand<T>) -> Variable

Converts to this type from the input type.

impl From<bf16> for NativeExpand<bf16>

fn from(value: bf16) -> NativeExpand<bf16>

Converts to this type from the input type.

impl From<bool> for NativeExpand<bool>

fn from(value: bool) -> NativeExpand<bool>

Converts to this type from the input type.

impl From<e2m1> for NativeExpand<e2m1>

fn from(value: e2m1) -> NativeExpand<e2m1>

Converts to this type from the input type.

impl From<e2m1x2> for NativeExpand<e2m1x2>

fn from(value: e2m1x2) -> NativeExpand<e2m1x2>

Converts to this type from the input type.

impl From<e2m3> for NativeExpand<e2m3>

fn from(value: e2m3) -> NativeExpand<e2m3>

Converts to this type from the input type.

impl From<e3m2> for NativeExpand<e3m2>

fn from(value: e3m2) -> NativeExpand<e3m2>

Converts to this type from the input type.

impl From<e4m3> for NativeExpand<e4m3>

fn from(value: e4m3) -> NativeExpand<e4m3>

Converts to this type from the input type.

impl From<e5m2> for NativeExpand<e5m2>

fn from(value: e5m2) -> NativeExpand<e5m2>

Converts to this type from the input type.

impl From<f16> for NativeExpand<f16>

fn from(value: f16) -> NativeExpand<f16>

Converts to this type from the input type.

impl From<f32> for NativeExpand<f32>

fn from(value: f32) -> NativeExpand<f32>

Converts to this type from the input type.

impl From<f64> for NativeExpand<f64>

fn from(value: f64) -> NativeExpand<f64>

Converts to this type from the input type.

impl From<flex32> for NativeExpand<flex32>

fn from(value: flex32) -> NativeExpand<flex32>

Converts to this type from the input type.

impl From<i16> for NativeExpand<i16>

fn from(value: i16) -> NativeExpand<i16>

Converts to this type from the input type.

impl From<i32> for NativeExpand<i32>

fn from(value: i32) -> NativeExpand<i32>

Converts to this type from the input type.

impl From<i64> for NativeExpand<i64>

fn from(value: i64) -> NativeExpand<i64>

Converts to this type from the input type.

impl From<i8> for NativeExpand<i8>

fn from(value: i8) -> NativeExpand<i8>

Converts to this type from the input type.

impl From<isize> for NativeExpand<isize>

fn from(value: isize) -> NativeExpand<isize>

Converts to this type from the input type.

impl From<tf32> for NativeExpand<tf32>

fn from(value: tf32) -> NativeExpand<tf32>

Converts to this type from the input type.

impl From<u16> for NativeExpand<u16>

fn from(value: u16) -> NativeExpand<u16>

Converts to this type from the input type.

impl From<u32> for NativeExpand<u32>

fn from(value: u32) -> NativeExpand<u32>

Converts to this type from the input type.

impl From<u64> for NativeExpand<u64>

fn from(value: u64) -> NativeExpand<u64>

Converts to this type from the input type.

impl From<u8> for NativeExpand<u8>

fn from(value: u8) -> NativeExpand<u8>

Converts to this type from the input type.

impl From<ue8m0> for NativeExpand<ue8m0>

fn from(value: ue8m0) -> NativeExpand<ue8m0>

Converts to this type from the input type.

impl From<usize> for NativeExpand<usize>

fn from(value: usize) -> NativeExpand<usize>

Converts to this type from the input type.

impl<T> HypotExpand for NativeExpand<T>

where T: CubePrimitive + Hypot,

fn __expand_hypot_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<P, N> Into<NativeExpand<Vector<P, N>>> for Vector<P, N>

where P: Scalar + Into<NativeExpand<P>>, N: Size,

fn into(self) -> NativeExpand<Vector<P, N>>

Converts this type into the (usually inferred) input type.

impl<C> IntoMut for NativeExpand<Array<C>>

where C: CubeType,

fn into_mut(self, _scope: &mut Scope) -> NativeExpand<Array<C>>

Convert the variable into a potentially new mutable variable in scope, copying if needed.

impl<T> IntoMut for NativeExpand<Shared<T>>

where T: CubePrimitive,

fn into_mut(self, _scope: &mut Scope) -> NativeExpand<Shared<T>>

Convert the variable into a potentially new mutable variable in scope, copying if needed.

impl<T> IntoMut for NativeExpand<SharedMemory<T>>

where T: CubePrimitive,

fn into_mut(self, _scope: &mut Scope) -> NativeExpand<SharedMemory<T>>

Convert the variable into a potentially new mutable variable in scope, copying if needed.

impl<T> IntoMut for NativeExpand<T>

where T: NativeAssign,

fn into_mut(self, scope: &mut Scope) -> NativeExpand<T>

Convert the variable into a potentially new mutable variable in scope, copying if needed.

impl<C> IntoMut for NativeExpand<Tensor<C>>

where C: CubeType,

fn into_mut(self, _scope: &mut Scope) -> NativeExpand<Tensor<C>>

Convert the variable into a potentially new mutable variable in scope, copying if needed.

impl<E, K> IntoMut for NativeExpand<TensorMap<E, K>>

where E: CubePrimitive, K: TensorMapKind,

fn into_mut(self, _scope: &mut Scope) -> NativeExpand<TensorMap<E, K>>

Convert the variable into a potentially new mutable variable in scope, copying if needed.

impl<T> InverseSqrtExpand for NativeExpand<T>

where T: InverseSqrt + CubePrimitive,

fn __expand_inverse_sqrt_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> IsInfExpand for NativeExpand<T>

where T: IsInf + CubePrimitive,

fn __expand_is_inf_method( self, scope: &mut Scope, ) -> <NativeExpand<T> as CubePrimitiveExpand>::WithScalar<bool>

impl<T> IsNanExpand for NativeExpand<T>

where T: IsNan + CubePrimitive,

fn __expand_is_nan_method( self, scope: &mut Scope, ) -> <NativeExpand<T> as CubePrimitiveExpand>::WithScalar<bool>

impl<T> Iterable<<T as SizedContainer>::Item> for NativeExpand<T>

where T: SizedContainer<ExpandType = NativeExpand<T>> + CubeType,

fn expand( self, scope: &mut Scope, body: impl FnMut(&mut Scope, <<T as SizedContainer>::Item as CubeType>::ExpandType), )

Expand a runtime loop without unrolling

fn expand_unroll( self, _scope: &mut Scope, _body: impl FnMut(&mut Scope, <<T as SizedContainer>::Item as CubeType>::ExpandType), )

Expand an unrolled loop. The body should be invoced n times, where n is the number of iterations.

fn const_len(&self) -> Option<usize>

Return the comptime length of this iterable, if possible

impl<T> LeadingZerosExpand for NativeExpand<T>

where T: LeadingZeros + CubePrimitive,

fn __expand_leading_zeros_method( self, scope: &mut Scope, ) -> <NativeExpand<T> as CubePrimitiveExpand>::WithScalar<u32>

impl<T> ListExpand<T> for NativeExpand<Array<T>>

where T: CubePrimitive,

fn __expand_read_method( &self, scope: &mut Scope, idx: NativeExpand<usize>, ) -> NativeExpand<T>

fn __expand_read_unchecked_method( &self, scope: &mut Scope, idx: NativeExpand<usize>, ) -> NativeExpand<T>

fn __expand_len_method(&self, scope: &mut Scope) -> NativeExpand<usize>

impl<T> ListExpand<T> for NativeExpand<SharedMemory<T>>

where T: CubePrimitive,

fn __expand_read_method( &self, scope: &mut Scope, idx: NativeExpand<usize>, ) -> NativeExpand<T>

fn __expand_read_unchecked_method( &self, scope: &mut Scope, idx: NativeExpand<usize>, ) -> NativeExpand<T>

fn __expand_len_method(&self, scope: &mut Scope) -> NativeExpand<usize>

impl<T> ListExpand<T> for NativeExpand<Tensor<T>>

where T: CubePrimitive,

fn __expand_read_method( &self, scope: &mut Scope, idx: NativeExpand<usize>, ) -> NativeExpand<T>

fn __expand_read_unchecked_method( &self, scope: &mut Scope, idx: NativeExpand<usize>, ) -> NativeExpand<T>

fn __expand_len_method(&self, scope: &mut Scope) -> NativeExpand<usize>

impl<T> ListMutExpand<T> for NativeExpand<Array<T>>

where T: CubePrimitive,

fn __expand_write_method( &self, scope: &mut Scope, idx: NativeExpand<usize>, value: NativeExpand<T>, )

impl<T> ListMutExpand<T> for NativeExpand<SharedMemory<T>>

where T: CubePrimitive,

fn __expand_write_method( &self, scope: &mut Scope, idx: NativeExpand<usize>, value: NativeExpand<T>, )

impl<T> ListMutExpand<T> for NativeExpand<Tensor<T>>

where T: CubePrimitive,

fn __expand_write_method( &self, scope: &mut Scope, idx: NativeExpand<usize>, value: NativeExpand<T>, )

impl<T> Log1pExpand for NativeExpand<T>

where T: Log1p + CubePrimitive,

fn __expand_log1p_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> LogExpand for NativeExpand<T>

where T: Log + CubePrimitive,

fn __expand_ln_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> MagnitudeExpand for NativeExpand<T>

where T: Magnitude + CubePrimitive,

fn __expand_magnitude_method( self, scope: &mut Scope, ) -> <NativeExpand<T> as CubePrimitiveExpand>::Scalar

impl<T> MulAssignExpand for NativeExpand<T>

where T: MulAssign + CubePrimitive,

fn __expand_mul_assign_method(self, scope: &mut Scope, rhs: NativeExpand<T>)

impl<T> MulExpand for NativeExpand<T>

where T: Mul<Output = T> + CubePrimitive,

fn __expand_mul_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> MulHiExpand for NativeExpand<T>

where T: CubePrimitive + MulHi,

fn __expand_mul_hi_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> NormalizeExpand for NativeExpand<T>

where T: Normalize + CubePrimitive,

fn __expand_normalize_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> NotExpand for NativeExpand<T>

where T: CubeNot + CubePrimitive,

fn __expand_not_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> OrdExpand for NativeExpand<T>

where T: Ord + CubePrimitive,

fn __expand_cmp_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> OrderingExpand

fn __expand_min_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

fn __expand_max_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

fn __expand_clamp_method( self, scope: &mut Scope, min: NativeExpand<T>, max: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> PowfExpand for NativeExpand<T>

where T: CubePrimitive + Powf,

fn __expand_powf_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<Rhs, T> PowiExpand<Rhs> for NativeExpand<T>

where Rhs: CubePrimitive, T: CubePrimitive + Powi<Rhs>,

fn __expand_powi_method( self, scope: &mut Scope, rhs: NativeExpand<Rhs>, ) -> NativeExpand<T>

impl<T> RadiansExpand for NativeExpand<T>

where T: Radians + CubePrimitive,

fn __expand_to_radians_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> RecipExpand for NativeExpand<T>

where T: Recip + CubePrimitive,

fn __expand_recip_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> RemAssignExpand for NativeExpand<T>

where T: RemAssign + CubePrimitive,

fn __expand_rem_assign_method(self, scope: &mut Scope, rhs: NativeExpand<T>)

impl<T> RemExpand for NativeExpand<T>

where T: Rem<Output = T> + CubePrimitive,

fn __expand_rem_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> RemainderExpand for NativeExpand<T>

where T: CubePrimitive + Remainder,

fn __expand_rem_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> ReverseBitsExpand for NativeExpand<T>

where T: ReverseBits + CubePrimitive,

fn __expand_reverse_bits_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> RhypotExpand for NativeExpand<T>

where T: CubePrimitive + Rhypot,

fn __expand_rhypot_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> RoundExpand for NativeExpand<T>

where T: Round + CubePrimitive,

fn __expand_round_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> SaturatingAddExpand for NativeExpand<T>

where T: CubePrimitive + SaturatingAdd,

fn __expand_saturating_add_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> SaturatingSubExpand for NativeExpand<T>

where T: CubePrimitive + SaturatingSub,

fn __expand_saturating_sub_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> SinExpand for NativeExpand<T>

where T: Sin + CubePrimitive,

fn __expand_sin_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> SinhExpand for NativeExpand<T>

where T: Sinh + CubePrimitive,

fn __expand_sinh_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<E> SliceMutOperatorExpand<E> for NativeExpand<Array<E>>

where E: CubePrimitive,

fn __expand_slice_mut_method( &self, scope: &mut Scope, start: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<E, ReadWrite>

fn __expand_to_slice_mut_method( &self, scope: &mut Scope, ) -> SliceExpand<E, ReadWrite>

impl<E> SliceMutOperatorExpand<E> for NativeExpand<SharedMemory<E>>

where E: CubePrimitive,

fn __expand_slice_mut_method( &self, scope: &mut Scope, start: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<E, ReadWrite>

fn __expand_to_slice_mut_method( &self, scope: &mut Scope, ) -> SliceExpand<E, ReadWrite>

impl<E> SliceMutOperatorExpand<E> for NativeExpand<Tensor<E>>

where E: CubePrimitive,

fn __expand_slice_mut_method( &self, scope: &mut Scope, start: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<E, ReadWrite>

fn __expand_to_slice_mut_method( &self, scope: &mut Scope, ) -> SliceExpand<E, ReadWrite>

impl<E> SliceOperatorExpand<E> for NativeExpand<Array<E>>

where E: CubePrimitive,

fn __expand_slice_method( &self, scope: &mut Scope, start: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<E, ReadOnly>

fn __expand_to_slice_method( &self, scope: &mut Scope, ) -> SliceExpand<E, ReadOnly>

impl<E> SliceOperatorExpand<E> for NativeExpand<SharedMemory<E>>

where E: CubePrimitive,

fn __expand_slice_method( &self, scope: &mut Scope, start: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<E, ReadOnly>

fn __expand_to_slice_method( &self, scope: &mut Scope, ) -> SliceExpand<E, ReadOnly>

impl<E> SliceOperatorExpand<E> for NativeExpand<Tensor<E>>

where E: CubePrimitive,

fn __expand_slice_method( &self, scope: &mut Scope, start: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<E, ReadOnly>

fn __expand_to_slice_method( &self, scope: &mut Scope, ) -> SliceExpand<E, ReadOnly>

impl<T> SqrtExpand for NativeExpand<T>

where T: Sqrt + CubePrimitive,

fn __expand_sqrt_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> SubAssignExpand for NativeExpand<T>

where T: SubAssign + CubePrimitive,

fn __expand_sub_assign_method(self, scope: &mut Scope, rhs: NativeExpand<T>)

impl<T> SubExpand for NativeExpand<T>

where T: Sub<Output = T> + CubePrimitive,

fn __expand_sub_method( self, scope: &mut Scope, rhs: NativeExpand<T>, ) -> NativeExpand<T>

impl<T> TanExpand for NativeExpand<T>

where T: Tan + CubePrimitive,

fn __expand_tan_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> TanhExpand for NativeExpand<T>

where T: Tanh + CubePrimitive,

fn __expand_tanh_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> TrailingZerosExpand for NativeExpand<T>

where T: TrailingZeros + CubePrimitive,

fn __expand_trailing_zeros_method( self, scope: &mut Scope, ) -> <NativeExpand<T> as CubePrimitiveExpand>::WithScalar<u32>

impl<T> TruncExpand for NativeExpand<T>

where T: Trunc + CubePrimitive,

fn __expand_trunc_method(self, scope: &mut Scope) -> NativeExpand<T>

impl<T> VectorSumExpand for NativeExpand<T>

where T: VectorSum + CubePrimitive,

fn __expand_vector_sum_method( self, scope: &mut Scope, ) -> <NativeExpand<T> as CubePrimitiveExpand>::Scalar

impl<T> VectorizedExpand for NativeExpand<Array<T>>

where T: CubePrimitive,

fn vector_size(&self) -> usize

fn __expand_vector_size_method(&self, _scope: &mut Scope) -> usize

impl<T> VectorizedExpand for NativeExpand<SharedMemory<T>>

where T: CubePrimitive,

fn vector_size(&self) -> usize

fn __expand_vector_size_method(&self, _scope: &mut Scope) -> usize

impl<T> VectorizedExpand for NativeExpand<Tensor<T>>

where T: CubePrimitive,

fn vector_size(&self) -> usize

fn __expand_vector_size_method(&self, _scope: &mut Scope) -> usize

impl<E, K> VectorizedExpand for NativeExpand<TensorMap<E, K>>

where E: CubePrimitive, K: TensorMapKind,

fn vector_size(&self) -> usize

fn __expand_vector_size_method(&self, _scope: &mut Scope) -> usize

impl<T> ViewOperationsExpand<T, ((i32, i32, i32), usize)> for NativeExpand<TensorMap<T, Im2col>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32), usize) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32), usize) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32), usize) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32), usize) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32), usize) as CubeType>::ExpandType, _end: <((i32, i32, i32), usize) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <((i32, i32, i32), usize) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32), usize) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <((i32, i32, i32), usize) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, ((i32, i32, i32, i32), (u32, u32))> for NativeExpand<TensorMap<T, Im2col>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32), (u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32), (u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32), (u32, u32)) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32), (u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32), (u32, u32)) as CubeType>::ExpandType, _end: <((i32, i32, i32, i32), (u32, u32)) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <((i32, i32, i32, i32), (u32, u32)) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32), (u32, u32)) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <((i32, i32, i32, i32), (u32, u32)) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, ((i32, i32, i32, i32, i32), (u32, u32, u32))> for NativeExpand<TensorMap<T, Im2col>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32, i32), (u32, u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32, i32), (u32, u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32, i32), (u32, u32, u32)) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32, i32), (u32, u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32, i32), (u32, u32, u32)) as CubeType>::ExpandType, _end: <((i32, i32, i32, i32, i32), (u32, u32, u32)) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <((i32, i32, i32, i32, i32), (u32, u32, u32)) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <((i32, i32, i32, i32, i32), (u32, u32, u32)) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <((i32, i32, i32, i32, i32), (u32, u32, u32)) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, ((u32, u32, u32), usize)> for NativeExpand<TensorMap<T, Im2col>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32), usize) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32), usize) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32), usize) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32), usize) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32), usize) as CubeType>::ExpandType, _end: <((u32, u32, u32), usize) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <((u32, u32, u32), usize) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32), usize) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <((u32, u32, u32), usize) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, ((u32, u32, u32, u32), (u32, u32))> for NativeExpand<TensorMap<T, Im2col>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32), (u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32), (u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32), (u32, u32)) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32), (u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32), (u32, u32)) as CubeType>::ExpandType, _end: <((u32, u32, u32, u32), (u32, u32)) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <((u32, u32, u32, u32), (u32, u32)) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32), (u32, u32)) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <((u32, u32, u32, u32), (u32, u32)) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, ((u32, u32, u32, u32, u32), (u32, u32, u32))> for NativeExpand<TensorMap<T, Im2col>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32, u32), (u32, u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32, u32), (u32, u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32, u32), (u32, u32, u32)) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32, u32), (u32, u32, u32)) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32, u32), (u32, u32, u32)) as CubeType>::ExpandType, _end: <((u32, u32, u32, u32, u32), (u32, u32, u32)) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <((u32, u32, u32, u32, u32), (u32, u32, u32)) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <((u32, u32, u32, u32, u32), (u32, u32, u32)) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <((u32, u32, u32, u32, u32), (u32, u32, u32)) as CubeType>::ExpandType, )

impl<T, P, O> ViewOperationsExpand<T, (Sequence<P>, Sequence<O>)> for NativeExpand<TensorMap<T, Im2col>>

where T: CubePrimitive, P: CubePrimitive + Coordinates, O: CubePrimitive + Coordinates,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: (SequenceExpand<P>, SequenceExpand<O>), ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: (SequenceExpand<P>, SequenceExpand<O>), ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: (SequenceExpand<P>, SequenceExpand<O>), _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: (SequenceExpand<P>, SequenceExpand<O>), ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: (SequenceExpand<P>, SequenceExpand<O>), _end: (SequenceExpand<P>, SequenceExpand<O>), ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> (SequenceExpand<P>, SequenceExpand<O>)

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: (SequenceExpand<P>, SequenceExpand<O>), ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: (SequenceExpand<P>, SequenceExpand<O>), )

impl<T> ViewOperationsExpand<T, (i32, i32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <(i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <(i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <(i32, i32) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <(i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <(i32, i32) as CubeType>::ExpandType, _end: <(i32, i32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <(i32, i32) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <(i32, i32) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <(i32, i32) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, (i32, i32, i32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32) as CubeType>::ExpandType, _end: <(i32, i32, i32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <(i32, i32, i32) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <(i32, i32, i32) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, (i32, i32, i32, i32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32) as CubeType>::ExpandType, _end: <(i32, i32, i32, i32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <(i32, i32, i32, i32) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <(i32, i32, i32, i32) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, (i32, i32, i32, i32, i32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, _end: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <(i32, i32, i32, i32, i32) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, (u32, u32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <(u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <(u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <(u32, u32) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <(u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <(u32, u32) as CubeType>::ExpandType, _end: <(u32, u32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <(u32, u32) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <(u32, u32) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <(u32, u32) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, (u32, u32, u32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32) as CubeType>::ExpandType, _end: <(u32, u32, u32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <(u32, u32, u32) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <(u32, u32, u32) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, (u32, u32, u32, u32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32) as CubeType>::ExpandType, _end: <(u32, u32, u32, u32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <(u32, u32, u32, u32) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <(u32, u32, u32, u32) as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, (u32, u32, u32, u32, u32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, _end: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <(u32, u32, u32, u32, u32) as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, )

impl<T, N> ViewOperationsExpand<T, Sequence<N>> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive, N: CubePrimitive + Coordinates,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: SequenceExpand<N>, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: SequenceExpand<N>, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: SequenceExpand<N>, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: SequenceExpand<N>, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: SequenceExpand<N>, _end: SequenceExpand<N>, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method(&self, _scope: &mut Scope) -> SequenceExpand<N>

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: SequenceExpand<N>, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: SequenceExpand<N>, )

impl<T> ViewOperationsExpand<T, i32> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <i32 as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <i32 as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <i32 as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <i32 as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <i32 as CubeType>::ExpandType, _end: <i32 as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <i32 as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <i32 as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <i32 as CubeType>::ExpandType, )

impl<T> ViewOperationsExpand<T, usize> for NativeExpand<Array<T>>

where T: CubePrimitive,

fn __expand_read_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method(&self, scope: &mut Scope) -> NativeExpand<usize>

fn __expand_is_in_bounds_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, _scope: &mut Scope, _barrier: NativeExpand<Barrier>, _shared_memory: SliceExpand<T, ReadWrite>, _pos: NativeExpand<usize>, )

impl<T> ViewOperationsExpand<T, usize> for NativeExpand<SharedMemory<T>>

where T: CubePrimitive,

fn __expand_read_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method(&self, scope: &mut Scope) -> NativeExpand<usize>

fn __expand_is_in_bounds_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, _scope: &mut Scope, _barrier: NativeExpand<Barrier>, _shared_memory: SliceExpand<T, ReadWrite>, _pos: NativeExpand<usize>, )

impl<T> ViewOperationsExpand<T, usize> for NativeExpand<Tensor<T>>

where T: CubePrimitive,

fn __expand_read_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method(&self, scope: &mut Scope) -> NativeExpand<usize>

fn __expand_is_in_bounds_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, _scope: &mut Scope, _barrier: NativeExpand<Barrier>, _shared_memory: SliceExpand<T, ReadWrite>, _pos: NativeExpand<usize>, )

impl<T> ViewOperationsExpand<T, usize> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_read_method( &self, _scope: &mut Scope, _pos: <usize as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked_method( &self, _scope: &mut Scope, _pos: <usize as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked_method( &self, _scope: &mut Scope, _pos: <usize as CubeType>::ExpandType, _mask_value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _pos: <usize as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice_method( &self, _scope: &mut Scope, _pos: <usize as CubeType>::ExpandType, _end: <usize as CubeType>::ExpandType, ) -> SliceExpand<T, ReadOnly>

fn __expand_shape_method( &self, _scope: &mut Scope, ) -> <usize as CubeType>::ExpandType

fn __expand_is_in_bounds_method( &self, _scope: &mut Scope, _pos: <usize as CubeType>::ExpandType, ) -> NativeExpand<bool>

fn __expand_tensor_map_load_method( &self, scope: &mut Scope, barrier: NativeExpand<Barrier>, shared_memory: SliceExpand<T, ReadWrite>, pos: <usize as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, (i32, i32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_write_method( &self, _scope: &mut Scope, _pos: <(i32, i32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, _scope: &mut Scope, _pos: <(i32, i32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, _scope: &mut Scope, _pos: <(i32, i32) as CubeType>::ExpandType, _end: <(i32, i32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, scope: &mut Scope, shared_memory: SliceExpand<T, ReadOnly>, pos: <(i32, i32) as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, (i32, i32, i32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_write_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32) as CubeType>::ExpandType, _end: <(i32, i32, i32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, scope: &mut Scope, shared_memory: SliceExpand<T, ReadOnly>, pos: <(i32, i32, i32) as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, (i32, i32, i32, i32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_write_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32) as CubeType>::ExpandType, _end: <(i32, i32, i32, i32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, scope: &mut Scope, shared_memory: SliceExpand<T, ReadOnly>, pos: <(i32, i32, i32, i32) as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, (i32, i32, i32, i32, i32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_write_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, _scope: &mut Scope, _pos: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, _end: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, scope: &mut Scope, shared_memory: SliceExpand<T, ReadOnly>, pos: <(i32, i32, i32, i32, i32) as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, (u32, u32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_write_method( &self, _scope: &mut Scope, _pos: <(u32, u32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, _scope: &mut Scope, _pos: <(u32, u32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, _scope: &mut Scope, _pos: <(u32, u32) as CubeType>::ExpandType, _end: <(u32, u32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, scope: &mut Scope, shared_memory: SliceExpand<T, ReadOnly>, pos: <(u32, u32) as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, (u32, u32, u32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_write_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32) as CubeType>::ExpandType, _end: <(u32, u32, u32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, scope: &mut Scope, shared_memory: SliceExpand<T, ReadOnly>, pos: <(u32, u32, u32) as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, (u32, u32, u32, u32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_write_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32) as CubeType>::ExpandType, _end: <(u32, u32, u32, u32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, scope: &mut Scope, shared_memory: SliceExpand<T, ReadOnly>, pos: <(u32, u32, u32, u32) as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, (u32, u32, u32, u32, u32)> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_write_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, _scope: &mut Scope, _pos: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, _end: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, scope: &mut Scope, shared_memory: SliceExpand<T, ReadOnly>, pos: <(u32, u32, u32, u32, u32) as CubeType>::ExpandType, )

impl<T, N> ViewOperationsMutExpand<T, Sequence<N>> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive, N: CubePrimitive + Coordinates,

fn __expand_write_method( &self, _scope: &mut Scope, _pos: SequenceExpand<N>, _value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, _scope: &mut Scope, _pos: SequenceExpand<N>, _value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, _scope: &mut Scope, _pos: SequenceExpand<N>, _end: SequenceExpand<N>, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, scope: &mut Scope, shared_memory: SliceExpand<T, ReadOnly>, pos: SequenceExpand<N>, )

impl<T> ViewOperationsMutExpand<T, i32> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_write_method( &self, _scope: &mut Scope, _pos: <i32 as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, _scope: &mut Scope, _pos: <i32 as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, _scope: &mut Scope, _pos: <i32 as CubeType>::ExpandType, _end: <i32 as CubeType>::ExpandType, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, scope: &mut Scope, shared_memory: SliceExpand<T, ReadOnly>, pos: <i32 as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, usize> for NativeExpand<Array<T>>

where T: CubePrimitive,

fn __expand_write_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, _scope: &mut Scope, _shared_memory: SliceExpand<T, ReadOnly>, _pos: <usize as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, usize> for NativeExpand<SharedMemory<T>>

where T: CubePrimitive,

fn __expand_write_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, _scope: &mut Scope, _shared_memory: SliceExpand<T, ReadOnly>, _pos: <usize as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, usize> for NativeExpand<Tensor<T>>

where T: CubePrimitive,

fn __expand_write_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, scope: &mut Scope, pos: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, _scope: &mut Scope, _shared_memory: SliceExpand<T, ReadOnly>, _pos: <usize as CubeType>::ExpandType, )

impl<T> ViewOperationsMutExpand<T, usize> for NativeExpand<TensorMap<T, Tiled>>

where T: CubePrimitive,

fn __expand_write_method( &self, _scope: &mut Scope, _pos: <usize as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_write_checked_method( &self, _scope: &mut Scope, _pos: <usize as CubeType>::ExpandType, _value: <T as CubeType>::ExpandType, )

fn __expand_to_linear_slice_mut_method( &self, _scope: &mut Scope, _pos: <usize as CubeType>::ExpandType, _end: <usize as CubeType>::ExpandType, ) -> SliceExpand<T, ReadWrite>

fn __expand_tensor_map_store_method( &self, scope: &mut Scope, shared_memory: SliceExpand<T, ReadOnly>, pos: <usize as CubeType>::ExpandType, )

impl<E, N> VirtualTensorOperationsExpand<E, N> for NativeExpand<Tensor<Vector<E, N>>>

where E: Numeric, N: Size,

fn __expand_read_method( &self, scope: &mut Scope, index: NativeExpand<usize>, ) -> NativeExpand<Vector<E, N>>

fn __expand_read_window_method( &self, context: &mut Scope, start: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<Vector<E, N>, ReadOnly>

fn __expand_write_method( &self, scope: &mut Scope, index: NativeExpand<usize>, value: NativeExpand<Vector<E, N>>, )

fn __expand_shape_method( &self, scope: &mut Scope, axis: NativeExpand<usize>, ) -> NativeExpand<usize>

fn __expand_stride_method( &self, scope: &mut Scope, axis: NativeExpand<usize>, ) -> NativeExpand<usize>

fn __expand_rank_method(&self, scope: &mut Scope) -> NativeExpand<usize>

fn __expand_len_method(&self, scope: &mut Scope) -> NativeExpand<usize>

fn __expand_buffer_len_method(&self, scope: &mut Scope) -> NativeExpand<usize>

fn __expand_as_tensor_map_method( &self, scope: &mut Scope, ) -> ComptimeOptionExpand<TensorMap<E, Tiled>>

impl<E, N> VirtualTensorOperationsExpand<E, N> for NativeExpand<TensorMap<E, Tiled>>

where E: Numeric, N: Size,

fn __expand_read_method( &self, _scope: &mut Scope, _index: NativeExpand<usize>, ) -> NativeExpand<Vector<E, N>>

fn __expand_read_window_method( &self, _context: &mut Scope, _start: NativeExpand<usize>, _end: NativeExpand<usize>, ) -> SliceExpand<Vector<E, N>, ReadOnly>

fn __expand_write_method( &self, _scope: &mut Scope, _index: NativeExpand<usize>, _value: NativeExpand<Vector<E, N>>, )

fn __expand_shape_method( &self, _scope: &mut Scope, _axis: NativeExpand<usize>, ) -> NativeExpand<usize>

fn __expand_stride_method( &self, _scope: &mut Scope, _axis: NativeExpand<usize>, ) -> NativeExpand<usize>

fn __expand_rank_method(&self, _scope: &mut Scope) -> NativeExpand<usize>

fn __expand_len_method(&self, _scope: &mut Scope) -> NativeExpand<usize>

fn __expand_buffer_len_method(&self, _scope: &mut Scope) -> NativeExpand<usize>

fn __expand_as_tensor_map_method( &self, scope: &mut Scope, ) -> ComptimeOptionExpand<TensorMap<E, Tiled>>