Struct NativeExpand 

pub struct NativeExpand<T: ?Sized> {
    pub expand: Value,
    /* private fields */
}

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

Fields

expand: Value

Implementations

impl NativeExpand<Barrier>

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

impl NativeExpand<Barrier>

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

impl NativeExpand<Barrier>

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

impl NativeExpand<Barrier>

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

impl NativeExpand<Barrier>

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

impl NativeExpand<Barrier>

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

impl NativeExpand<Barrier>

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

impl NativeExpand<Barrier>

pub fn __expand_tma_load_im2col_5d_method<C1: CubePrimitive, C2: CubePrimitive<Scalar = C1::Scalar>>( &self, scope: &Scope, source: &NativeExpand<TensorMap<C1, Im2col>>, destination: &mut SliceExpand<C2>, 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>, )

impl NativeExpand<Barrier>

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

Initializes a barrier with a given arrival_count. This is the number of times arrive or one of its variants needs to be called before the barrier advances.

If all units in the cube arrive on the barrier, use CUBE_DIM as the arrival count. For other purposes, only a subset may need to arrive.

Note

No synchronization or election is performed, this is raw initialization. For shared barriers ensure only one unit performs the initialization, and synchronize the cube afterwards. There may also be additional synchronization requirements for bulk copy operations, like sync_async_proxy_shared().

pub fn __expand_local(scope: &Scope) -> Self

Create a local barrier object for the current unit. Automatically initialized with an arrival count of 1.

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

Create a shared memory barrier that can be accesses by all units in the cube. Initialized by the is_elected unit with an arrival count of arrival_count. This is the number of times arrive or one of its variants needs to be called before the barrier advances.

If all units in the cube arrive on the barrier, use CUBE_DIM as the arrival count. For other purposes, only a subset may need to arrive.

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

Create a shared memory barrier that can be accesses by all units in the cube. Only declared, but not initialized.

pub fn __expand_init_manual( scope: &Scope, this: &Self, arrival_count: <u32 as CubeType>::ExpandType, )

Initializes a barrier with a given arrival_count. This is the number of times arrive or one of its variants needs to be called before the barrier advances.

If all units in the cube arrive on the barrier, use CUBE_DIM as the arrival count. For other purposes, only a subset may need to arrive.

Note

No synchronization or election is performed, this is raw initialization. For shared barriers ensure only one unit performs the initialization, and synchronize the cube afterwards. There may also be additional synchronization requirements for bulk copy operations, like sync_async_proxy_shared().

impl NativeExpand<Barrier>

pub fn __expand_memcpy_async_method<C: CubePrimitive>( &self, scope: &Scope, source: &<[C] as CubeType>::ExpandType, destination: &mut <[C] as CubeType>::ExpandType, )

Copy the source slice to destination

Safety

This will try to copy the whole source slice, so make sure source length <= destination length

pub fn __expand_memcpy_async_cooperative_method<C: CubePrimitive>( &self, scope: &Scope, source: &<[C] as CubeType>::ExpandType, destination: &mut <[C] as CubeType>::ExpandType, )

Copy the source slice to destination

Safety

This will try to copy the whole source slice, so make sure source length <= destination length

pub fn __expand_memcpy_async_tx_method<C: CubePrimitive>( &self, scope: &Scope, source: &<[C] as CubeType>::ExpandType, destination: &mut <[C] as CubeType>::ExpandType, )

Copy the source slice to destination. Uses transaction count like TMA, so use with expect_tx or arrive_and_expect_tx.

Safety

This will try to copy the whole source slice, so make sure source length <= destination length

pub fn __expand_memcpy_async<C: CubePrimitive>( scope: &Scope, this: &Self, source: &<[C] as CubeType>::ExpandType, destination: &mut <[C] as CubeType>::ExpandType, )

Copy the source slice to destination

Safety

This will try to copy the whole source slice, so make sure source length <= destination length

pub fn __expand_memcpy_async_cooperative<C: CubePrimitive>( scope: &Scope, this: &Self, source: &<[C] as CubeType>::ExpandType, destination: &mut <[C] as CubeType>::ExpandType, )

Copy the source slice to destination

Safety

This will try to copy the whole source slice, so make sure source length <= destination length

pub fn __expand_memcpy_async_tx<C: CubePrimitive>( scope: &Scope, this: &Self, source: &<[C] as CubeType>::ExpandType, destination: &mut <[C] as CubeType>::ExpandType, )

Copy the source slice to destination. Uses transaction count like TMA, so use with expect_tx or arrive_and_expect_tx.

Safety

This will try to copy the whole source slice, so make sure source length <= destination length

impl NativeExpand<Barrier>

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

Arrive at the barrier, decrementing arrival count

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

Arrive at the barrier, decrementing arrival count. Additionally increments expected count.

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

Increments the expected count of the barrier.

pub fn __expand_arrive_and_wait_method(&self, scope: &Scope)

Wait until all data is loaded

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

Wait at the barrier until all arrivals are done

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

Wait at the barrier until the phase is completed. Doesn’t require a token, but needs phase to be managed manually.

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

Arrive at the barrier, decrementing arrival count

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

Arrive at the barrier, decrementing arrival count. Additionally increments expected count.

pub fn __expand_expect_tx( scope: &Scope, this: &Self, expected_count: <u32 as CubeType>::ExpandType, )

Increments the expected count of the barrier.

pub fn __expand_arrive_and_wait(scope: &Scope, this: &Self)

Wait until all data is loaded

pub fn __expand_wait( scope: &Scope, this: &Self, token: <BarrierToken as CubeType>::ExpandType, )

Wait at the barrier until all arrivals are done

pub fn __expand_wait_parity( scope: &Scope, this: &Self, phase: <u32 as CubeType>::ExpandType, )

Wait at the barrier until the phase is completed. Doesn’t require a token, but needs phase to be managed manually.

impl NativeExpand<Barrier>

pub fn __expand_commit_copy_async_method(&self, scope: &Scope)

Makes all previous copy_async operations visible on the barrier. Should be called once after all copies have been dispatched, before reading from the shared memory.

Does not count as an arrive in terms of the barrier arrival count. So arrive or arrive_and_wait should still be called afterwards.

pub fn __expand_commit_copy_async(scope: &Scope, this: &Self)

Makes all previous copy_async operations visible on the barrier. Should be called once after all copies have been dispatched, before reading from the shared memory.

Does not count as an arrive in terms of the barrier arrival count. So arrive or arrive_and_wait should still be called afterwards.

impl<E: CubePrimitive> NativeExpand<Array<E>>

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

Obtain the array length

pub fn __expand_len(scope: &Scope, this: &Self) -> usize

Obtain the array length

impl<T: CubePrimitive> NativeExpand<Shared<[T]>>

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

pub fn __expand_new_slice(scope: &Scope, len: usize) -> Self

Create a new shared slice.

Safety

Shared memory is always uninitialized by default. Reading uninitialized shared values is undefined behavior.

pub fn __expand_new_aligned_slice( scope: &Scope, len: usize, alignment: usize, ) -> Self

Create a new shared slice with a specified minimum alignment.

Safety

Shared memory is always uninitialized by default. Reading uninitialized shared values is undefined behavior.

pub fn __expand_len( scope: &Scope, this: &Self, ) -> <usize as CubeType>::ExpandType

impl<T: NativeCubeType + ?Sized> NativeExpand<Shared<T>>

pub fn __expand_map_method<U: NativeCubeType + ?Sized>( self, scope: &Scope, map: impl for<'a> FnOnce(&Scope, &'a NativeExpand<T>) -> &'a NativeExpand<U>, ) -> SharedExpand<U>

impl<T: NativeCubeType + ?Sized> NativeExpand<Shared<T>>

pub fn __expand_inner_ref_method<'infer, 'scope>( &'infer self, scope: &'scope Scope, ) -> &'infer <T as CubeType>::ExpandType

pub fn __expand_inner_mut_method<'infer, 'scope>( &'infer mut self, scope: &'scope Scope, ) -> &'infer mut <T as CubeType>::ExpandType

pub fn __expand_inner_ref<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self, ) -> &'infer <T as CubeType>::ExpandType

pub fn __expand_inner_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer mut Self, ) -> &'infer mut <T as CubeType>::ExpandType

impl<T: NativeCubeType + ?Sized> NativeExpand<Shared<T>>

pub fn __expand_free_method(&self, scope: &Scope)

Frees the shared memory for reuse, if possible on the target runtime.

Safety

Must be used in uniform control flow Must not have any dangling references to this shared memory

pub fn __expand_free(scope: &Scope, this: &Self)

Frees the shared memory for reuse, if possible on the target runtime.

Safety

Must be used in uniform control flow Must not have any dangling references to this shared memory

impl<E: CubePrimitive> NativeExpand<[E]>

pub fn __extract_list(&self, scope: &Scope) -> Value

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

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

impl<E: Scalar, N: Size> NativeExpand<[Vector<E, N>]>

pub fn __expand_with_vector_size_method<'infer, N2: Size>( &'infer self, scope: &Scope, ) -> &'infer SliceExpand<Vector<E, N2>>

pub fn __expand_with_vector_size_mut_method<'infer, N2: Size>( &'infer mut self, scope: &Scope, ) -> &'infer mut SliceExpand<Vector<E, N2>>

impl<E: CubePrimitive> NativeExpand<[E]>

pub fn __expand_as_vectorized_method( &self, _: &Scope, ) -> &SliceExpand<Vector<E::Scalar, E::Size>>

pub fn __expand_as_vectorized_mut_method( &mut self, _: &Scope, ) -> &mut SliceExpand<Vector<E::Scalar, E::Size>>

pub fn __expand_downcast_method<T: CubePrimitive>( &self, scope: &Scope, ) -> &SliceExpand<T>

pub fn __expand_downcast_mut_method<T: CubePrimitive>( &mut self, scope: &Scope, ) -> &mut SliceExpand<T>

pub fn __expand_as_ptr_method(&self, scope: &Scope) -> *const NativeExpand<E>

pub fn __expand_as_mut_ptr_method( &mut self, scope: &Scope, ) -> *mut NativeExpand<E>

pub fn __expand_as_mut_unchecked_method( &self, scope: &Scope, ) -> &mut SliceExpand<E>

impl<E: CubePrimitive> NativeExpand<[E]>

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

Get the length of the slice.

pub fn is_empty(&self, scope: &Scope) -> NativeExpand<bool>

Returns true if the slice is empty.

impl<E: CubePrimitive> NativeExpand<Array<E>>

pub fn __expand_as_slice_method<'infer, 'scope>( &'infer self, scope: &'scope Scope, ) -> &'infer <[E] as CubeType>::ExpandType

pub fn __expand_as_mut_slice_method<'infer, 'scope>( &'infer mut self, scope: &'scope Scope, ) -> &'infer mut <[E] as CubeType>::ExpandType

pub fn __expand_as_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self, ) -> &'infer <[E] as CubeType>::ExpandType

pub fn __expand_as_mut_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer mut Self, ) -> &'infer mut <[E] as CubeType>::ExpandType

impl<E: CubePrimitive> NativeExpand<Shared<[E]>>

pub fn __expand_as_slice_method<'infer, 'scope>( &'infer self, scope: &'scope Scope, ) -> &'infer <[E] as CubeType>::ExpandType

pub fn __expand_as_mut_slice_method<'infer, 'scope>( &'infer mut self, scope: &'scope Scope, ) -> &'infer mut <[E] as CubeType>::ExpandType

pub fn __expand_as_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self, ) -> &'infer <[E] as CubeType>::ExpandType

pub fn __expand_as_mut_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer mut Self, ) -> &'infer mut <[E] as CubeType>::ExpandType

impl<E: CubePrimitive> NativeExpand<[E]>

pub fn __expand_copy_from_slice_method( &mut self, scope: &Scope, source: &SliceExpand<E>, )

impl<T: CubePrimitive, K: TensorMapKind> NativeExpand<TensorMap<T, K>>

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

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

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

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

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

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

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

Expand method of TensorMap::downcast.

impl<P: Scalar, N: Size> NativeExpand<Vector<P, N>>

pub fn __expand_extract_method( self, scope: &Scope, index: <usize as CubeType>::ExpandType, ) -> <P as CubeType>::ExpandType

pub fn __expand_insert_method( &mut self, scope: &Scope, index: <usize as CubeType>::ExpandType, value: <P as CubeType>::ExpandType, )

pub fn __expand_extract( scope: &Scope, this: Self, index: <usize as CubeType>::ExpandType, ) -> <P as CubeType>::ExpandType

pub fn __expand_insert( scope: &Scope, this: &mut Self, index: <usize as CubeType>::ExpandType, value: <P as CubeType>::ExpandType, )

impl<P: Scalar, N: Size> NativeExpand<Vector<P, N>>

pub fn __expand_fill_method( self, scope: &Scope, value: <P as CubeType>::ExpandType, ) -> Self

Fill the vector with the given value.

If you want to fill the vector with different values, consider using the index API instead.

let mut vector = Vector::<u32>::empty(2);
vector[0] = 1;
vector[1] = 2;

pub fn __expand_fill( scope: &Scope, this: Self, value: <P as CubeType>::ExpandType, ) -> Self

Fill the vector with the given value.

If you want to fill the vector with different values, consider using the index API instead.

let mut vector = Vector::<u32>::empty(2);
vector[0] = 1;
vector[1] = 2;

impl<P: Scalar, N: Size> NativeExpand<Vector<P, N>>

pub fn size(&self) -> VectorSize

Comptime version of size.

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

Expand method of size.

impl<P: Scalar, N: Size> NativeExpand<Vector<P, N>>

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

Return a new vector with the element-wise comparison of the first vector being equal to the second vector.

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

Return a new vector with the element-wise comparison of the first vector being equal to the second vector.

impl<P: Scalar, N: Size> NativeExpand<Vector<P, N>>

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

Return a new vector with the element-wise comparison of the first vector being not equal to the second vector.

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

Return a new vector with the element-wise comparison of the first vector being not equal to the second vector.

impl<P: Scalar, N: Size> NativeExpand<Vector<P, N>>

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

Return a new vector with the element-wise comparison of the first vector being less than the second vector.

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

Return a new vector with the element-wise comparison of the first vector being less than the second vector.

impl<P: Scalar, N: Size> NativeExpand<Vector<P, N>>

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

Return a new vector with the element-wise comparison of the first vector being greater than the second vector.

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

Return a new vector with the element-wise comparison of the first vector being greater than the second vector.

impl<P: Scalar, N: Size> NativeExpand<Vector<P, N>>

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

Return a new vector with the element-wise comparison of the first vector being less than or equal to the second vector.

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

Return a new vector with the element-wise comparison of the first vector being less than or equal to the second vector.

impl<P: Scalar, N: Size> NativeExpand<Vector<P, N>>

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

Return a new vector with the element-wise comparison of the first vector being greater than or equal to the second vector.

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

Return a new vector with the element-wise comparison of the first vector being greater than or equal to the second vector.

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

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

Return a new vector with the element-wise and of the vectors

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

Return a new vector with the element-wise and of the vectors

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

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

Return a new vector with the element-wise and of the vectors

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

Return a new vector with the element-wise and of the vectors

impl<P: CountOnes + Scalar, N: Size> NativeExpand<Vector<P, N>>

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

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

impl<Inner: CubePrimitive<Scalar: Numeric>> NativeExpand<Atomic<Inner>>

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

Load the value of the atomic.

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

Store the value of the atomic.

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

Atomically stores the value into the atomic and returns the old value.

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

Atomically add a number to the atomic variable. Returns the old value.

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

Atomically subtracts a number from the atomic variable. Returns the old value.

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

Atomically sets the value of the atomic variable to max(current_value, value). Returns the old value.

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

Atomically sets the value of the atomic variable to min(current_value, value). Returns the old value.

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

Load the value of the atomic.

pub fn __expand_store( scope: &Scope, this: &Self, value: <Inner as CubeType>::ExpandType, )

Store the value of the atomic.

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

Atomically stores the value into the atomic and returns the old value.

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

Atomically add a number to the atomic variable. Returns the old value.

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

Atomically subtracts a number from the atomic variable. Returns the old value.

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

Atomically sets the value of the atomic variable to max(current_value, value). Returns the old value.

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

Atomically sets the value of the atomic variable to min(current_value, value). Returns the old value.

impl<Inner: CubePrimitive<Scalar: Int>> NativeExpand<Atomic<Inner>>

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

Compare the value at pointer to cmp and set it to value only if they are the same. Returns the old value of the pointer before the store.

Tip

Compare the returned value to cmp to determine whether the store was successful.

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

Executes an atomic bitwise and operation on the atomic variable. Returns the old value.

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

Executes an atomic bitwise or operation on the atomic variable. Returns the old value.

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

Executes an atomic bitwise xor operation on the atomic variable. Returns the old value.

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

Compare the value at pointer to cmp and set it to value only if they are the same. Returns the old value of the pointer before the store.

Tip

Compare the returned value to cmp to determine whether the store was successful.

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

Executes an atomic bitwise and operation on the atomic variable. Returns the old value.

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

Executes an atomic bitwise or operation on the atomic variable. Returns the old value.

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

Executes an atomic bitwise xor operation on the atomic variable. Returns the old value.

impl<T: ?Sized> NativeExpand<T>

pub fn new(expand: Value) -> Self

Constructs a new NativeExpand.

impl<T: ?Sized> NativeExpand<T>

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

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

Safety

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

pub unsafe fn as_type_mut_unchecked<E: ?Sized>( &mut self, ) -> &mut NativeExpand<E>

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

Safety

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

impl<T> NativeExpand<T>

pub fn vector_size(&self) -> VectorSize

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

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

pub fn into_variable(self) -> Value

impl<T: Scalar + Into<ConstantValue>> NativeExpand<T>

pub fn from_lit(scope: &Scope, lit: T) -> Self

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: &Scope) -> T

impl<E: Int> NativeExpand<E>

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

Trait Implementations

impl<T: Abs + CubePrimitive> AbsExpand for NativeExpand<T>

fn __expand_abs_method(self, scope: &Scope) -> Self

impl<T: AddAssign + CubePrimitive> AddAssignExpand for NativeExpand<T>

fn __expand_add_assign_method(&mut self, scope: &Scope, rhs: Self)

impl<T: Add<Output = T> + CubePrimitive> AddExpand for NativeExpand<T>

fn __expand_add_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: CubeAnd + CubePrimitive> AndExpand for NativeExpand<T>

fn __expand_and_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: ArcCos + CubePrimitive> ArcCosExpand for NativeExpand<T>

fn __expand_acos_method(self, scope: &Scope) -> Self

impl<T: ArcCosh + CubePrimitive> ArcCoshExpand for NativeExpand<T>

fn __expand_acosh_method(self, scope: &Scope) -> Self

impl<T: ArcSin + CubePrimitive> ArcSinExpand for NativeExpand<T>

fn __expand_asin_method(self, scope: &Scope) -> Self

impl<T: ArcSinh + CubePrimitive> ArcSinhExpand for NativeExpand<T>

fn __expand_asinh_method(self, scope: &Scope) -> Self

impl<T: CubePrimitive + ArcTan2> ArcTan2Expand for NativeExpand<T>

fn __expand_atan2_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: ArcTan + CubePrimitive> ArcTanExpand for NativeExpand<T>

fn __expand_atan_method(self, scope: &Scope) -> Self

impl<T: ArcTanh + CubePrimitive> ArcTanhExpand for NativeExpand<T>

fn __expand_atanh_method(self, scope: &Scope) -> Self

impl AsMutExpand for NativeExpand<BarrierToken>

fn __expand_ref_mut_method(&mut self, _: &Scope) -> &mut Self

fn __expand_as_mut_method(&mut self, scope: &Scope) -> &mut T

impl<E> AsMutExpand for NativeExpand<Array<E>>

fn __expand_ref_mut_method(&mut self, _: &Scope) -> &mut Self

fn __expand_as_mut_method(&mut self, scope: &Scope) -> &mut T

impl<E: CubePrimitive> AsMutExpand for NativeExpand<Box<[E]>>

fn __expand_ref_mut_method(&mut self, _: &Scope) -> &mut Self

fn __expand_as_mut_method(&mut self, scope: &Scope) -> &mut T

impl<E: CubePrimitive, K: TensorMapKind> AsMutExpand for NativeExpand<TensorMap<E, K>>

fn __expand_ref_mut_method(&mut self, _: &Scope) -> &mut Self

fn __expand_as_mut_method(&mut self, scope: &Scope) -> &mut T

impl<T: CubePrimitive> AsMutExpand for NativeExpand<T>

fn __expand_ref_mut_method(&mut self, _scope: &Scope) -> &mut Self

fn __expand_as_mut_method(&mut self, scope: &Scope) -> &mut T

impl<T: ?Sized> AsRefExpand for NativeExpand<T>

fn __expand_ref_method(&self, _: &Scope) -> &Self

fn __expand_as_ref_method(&self, scope: &Scope) -> &T

impl<C: CubePrimitive> Assign for NativeExpand<Array<C>>

fn __expand_assign_method(&mut self, scope: &Scope, value: Self)

Assign value to self in scope.

impl<T: NativeAssign> Assign for NativeExpand<T>

fn __expand_assign_method(&mut self, scope: &Scope, value: Self)

Assign value to self in scope.

impl<T: CubePrimitive> Assign<NativeExpand<T>> for SharedExpand<T>

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

Assign value to self in scope.

impl<T: BitAndAssign + CubePrimitive> BitAndAssignExpand for NativeExpand<T>

fn __expand_bitand_assign_method(&mut self, scope: &Scope, rhs: Self)

impl<T: BitAnd<Output = T> + CubePrimitive> BitAndExpand for NativeExpand<T>

fn __expand_bitand_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: BitOrAssign + CubePrimitive> BitOrAssignExpand for NativeExpand<T>

fn __expand_bitor_assign_method(&mut self, scope: &Scope, rhs: Self)

impl<T: BitOr<Output = T> + CubePrimitive> BitOrExpand for NativeExpand<T>

fn __expand_bitor_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: BitXorAssign + CubePrimitive> BitXorAssignExpand for NativeExpand<T>

fn __expand_bitxor_assign_method(&mut self, scope: &Scope, rhs: Self)

impl<T: BitXor<Output = T> + CubePrimitive> BitXorExpand for NativeExpand<T>

fn __expand_bitxor_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: Ceil + CubePrimitive> CeilExpand for NativeExpand<T>

fn __expand_ceil_method(self, scope: &Scope) -> Self

impl<T: Clone + ?Sized> Clone for NativeExpand<T>

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: Copy + ?Sized> Copy for NativeExpand<T>

impl<T: Cos + CubePrimitive> CosExpand for NativeExpand<T>

fn __expand_cos_method(self, scope: &Scope) -> Self

impl<T: Cosh + CubePrimitive> CoshExpand for NativeExpand<T>

fn __expand_cosh_method(self, scope: &Scope) -> Self

impl<T: CountOnes + CubePrimitive> CountOnesExpand for NativeExpand<T>

fn __expand_count_ones_method(self, scope: &Scope) -> Self::WithScalar<u32>

impl<T: ?Sized> CubeDebug for NativeExpand<T>

fn set_debug_name(&self, scope: &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: CubePrimitive> CubePrimitiveExpand for NativeExpand<T>

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

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

impl<T: Debug + ?Sized> Debug for NativeExpand<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Degrees + CubePrimitive> DegreesExpand for NativeExpand<T>

fn __expand_to_degrees_method(self, scope: &Scope) -> Self

impl<T: CubePrimitive> Deref for NativeExpand<Array<T>>

type Target = NativeExpand<[T]>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<E> Deref for NativeExpand<Box<[E]>>

type Target = NativeExpand<[E]>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: CubePrimitive> DerefExpand for NativeExpand<T>

type Target = NativeExpand<T>

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

impl<T: CubePrimitive> DerefMut for NativeExpand<Array<T>>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<E> DerefMut for NativeExpand<Box<[E]>>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: DivAssign + CubePrimitive> DivAssignExpand for NativeExpand<T>

fn __expand_div_assign_method(&mut self, scope: &Scope, rhs: Self)

impl<E: DivCeil> DivCeilExpand<E> for NativeExpand<E>

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

impl<T: Div<Output = T> + CubePrimitive> DivExpand for NativeExpand<T>

fn __expand_div_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: CubePrimitive + Dot> DotExpand for NativeExpand<T>

fn __expand_dot_method(self, scope: &Scope, rhs: Self) -> Self::Scalar

impl<T: Erf + CubePrimitive> ErfExpand for NativeExpand<T>

fn __expand_erf_method(self, scope: &Scope) -> Self

impl<T: Exp + CubePrimitive> ExpExpand for NativeExpand<T>

fn __expand_exp_method(self, scope: &Scope) -> Self

impl<T: ?Sized> ExpandTypeClone for NativeExpand<T>

fn clone_unchecked(&self) -> Self

Unchecked clone that only clones the conceptual runtime value. Should only be used in cases where each copy is used in a mutually exclusive branch (i.e. match, runtime enums). This is intentionally separated from Rust’s Clone semantics and should only be used for the conceptual expand values, never real data. Using two values in the same branch is undefined behaviour.

impl<T: Expm1 + CubePrimitive> Expm1Expand for NativeExpand<T>

fn __expand_exp_m1_method(self, scope: &Scope) -> Self

impl<T: FindFirstSet + CubePrimitive> FindFirstSetExpand for NativeExpand<T>

fn __expand_find_first_set_method(self, scope: &Scope) -> Self::WithScalar<u32>

impl<F: FloatBits> FloatBitsExpand for NativeExpand<F>

type Bits = <F as FloatBits>::Bits

fn __expand_to_bits_method(self, scope: &Scope) -> NativeExpand<Self::Bits>

impl<T: FloatOps + CubePrimitive> FloatOpsExpand for NativeExpand<T>

fn __expand_min_method(self, scope: &Scope, other: Self) -> Self

fn __expand_max_method(self, scope: &Scope, other: Self) -> Self

fn __expand_clamp_method(self, scope: &Scope, min: Self, max: Self) -> Self

impl<T: Floor + CubePrimitive> FloorExpand for NativeExpand<T>

fn __expand_floor_method(self, scope: &Scope) -> Self

impl<'a, E: CubePrimitive> From<&'a NativeExpand<Box<[E]>>> for &'a NativeExpand<[E]>

fn from(value: &'a NativeExpand<Box<[E]>>) -> Self

Converts to this type from the input type.

impl<'a, T: NativeCubeType + ?Sized> From<&'a NativeExpand<Shared<T>>> for &'a NativeExpand<T>

fn from(value: &'a SharedExpand<T>) -> Self

Converts to this type from the input type.

impl<'a, E: CubePrimitive> From<&'a mut NativeExpand<Box<[E]>>> for &'a mut NativeExpand<[E]>

fn from(value: &'a mut NativeExpand<Box<[E]>>) -> Self

Converts to this type from the input type.

impl<'a, T: NativeCubeType + ?Sized> From<&'a mut NativeExpand<Shared<T>>> for &'a mut NativeExpand<T>

fn from(value: &'a mut SharedExpand<T>) -> Self

Converts to this type from the input type.

impl<Marker: 'static> From<DynamicScalar<Marker>> for NativeExpand<DynamicScalar<Marker>>

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

Converts to this type from the input type.

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

fn from(value: SharedExpand<Barrier>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<NativeExpand<T>> for Value

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

Converts to this type from the input type.

impl<T: ?Sized> From<Value> for NativeExpand<T>

fn from(expand: Value) -> Self

Converts to this type from the input type.

impl From<bf16> for NativeExpand<bf16>

fn from(value: bf16) -> Self

Converts to this type from the input type.

impl From<bool> for NativeExpand<bool>

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<e2m1> for NativeExpand<e2m1>

fn from(value: e2m1) -> Self

Converts to this type from the input type.

impl From<e2m1x2> for NativeExpand<e2m1x2>

fn from(value: e2m1x2) -> Self

Converts to this type from the input type.

impl From<e2m3> for NativeExpand<e2m3>

fn from(value: e2m3) -> Self

Converts to this type from the input type.

impl From<e3m2> for NativeExpand<e3m2>

fn from(value: e3m2) -> Self

Converts to this type from the input type.

impl From<e4m3> for NativeExpand<e4m3>

fn from(value: e4m3) -> Self

Converts to this type from the input type.

impl From<e5m2> for NativeExpand<e5m2>

fn from(value: e5m2) -> Self

Converts to this type from the input type.

impl From<f16> for NativeExpand<f16>

fn from(value: f16) -> Self

Converts to this type from the input type.

impl From<f32> for NativeExpand<f32>

fn from(value: f32) -> Self

Converts to this type from the input type.

impl From<f64> for NativeExpand<f64>

fn from(value: f64) -> Self

Converts to this type from the input type.

impl From<flex32> for NativeExpand<flex32>

fn from(value: flex32) -> Self

Converts to this type from the input type.

impl From<i8> for NativeExpand<i8>

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<i16> for NativeExpand<i16>

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i32> for NativeExpand<i32>

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for NativeExpand<i64>

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<isize> for NativeExpand<isize>

fn from(value: isize) -> Self

Converts to this type from the input type.

impl From<tf32> for NativeExpand<tf32>

fn from(value: tf32) -> Self

Converts to this type from the input type.

impl From<u8> for NativeExpand<u8>

fn from(value: u8) -> Self

Converts to this type from the input type.

impl From<u16> for NativeExpand<u16>

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for NativeExpand<u32>

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for NativeExpand<u64>

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<ue8m0> for NativeExpand<ue8m0>

fn from(value: ue8m0) -> Self

Converts to this type from the input type.

impl From<usize> for NativeExpand<usize>

fn from(value: usize) -> Self

Converts to this type from the input type.

impl<T: CubePrimitive + Hypot> HypotExpand for NativeExpand<T>

fn __expand_hypot_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: CubeType> IndexExpand<NativeExpand<usize>> for SequenceExpand<T>

type Output = <T as CubeType>::ExpandType

fn __expand_index_method( &self, scope: &Scope, index: NativeExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<NativeExpand<usize>> for SliceExpand<E>

type Output = <E as CubeType>::ExpandType

fn __expand_index_method( &self, scope: &Scope, index: NativeExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<NativeExpand<usize>> for NativeExpand<Array<E>>

type Output = NativeExpand<E>

fn __expand_index_method( &self, scope: &Scope, index: NativeExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<NativeExpand<usize>> for TensorExpand<E>

type Output = NativeExpand<E>

fn __expand_index_method( &self, scope: &Scope, index: NativeExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<NativeExpand<usize>> for NativeExpand<Shared<[E]>>

type Output = NativeExpand<E>

fn __expand_index_method( &self, scope: &Scope, index: NativeExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeExpand<usize>> for NativeExpand<Array<E>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeExpand<usize>> for NativeExpand<Shared<[E]>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeFromExpand<usize>> for NativeExpand<Array<E>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeFromExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeFromExpand<usize>> for NativeExpand<Shared<[E]>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeFromExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeFullExpand> for NativeExpand<Array<E>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeFullExpand, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeFullExpand> for NativeExpand<Shared<[E]>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeFullExpand, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeInclusiveExpand<usize>> for NativeExpand<Array<E>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeInclusiveExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeInclusiveExpand<usize>> for NativeExpand<Shared<[E]>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeInclusiveExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeToExpand<usize>> for NativeExpand<Array<E>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeToExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeToExpand<usize>> for NativeExpand<Shared<[E]>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeToExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeToInclusiveExpand<usize>> for NativeExpand<Array<E>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeToInclusiveExpand<usize>, ) -> &Self::Output

impl<E: CubePrimitive> IndexExpand<RangeToInclusiveExpand<usize>> for NativeExpand<Shared<[E]>>

type Output = NativeExpand<[E]>

fn __expand_index_method( &self, scope: &Scope, index: RangeToInclusiveExpand<usize>, ) -> &Self::Output

impl<T: CubeType> IndexMutExpand<NativeExpand<usize>> for SequenceExpand<T>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: NativeExpand<usize>, ) -> &mut T::ExpandType

impl<E: CubePrimitive> IndexMutExpand<NativeExpand<usize>> for SliceExpand<E>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: NativeExpand<usize>, ) -> &mut Self::Output

impl<E: CubePrimitive> IndexMutExpand<NativeExpand<usize>> for NativeExpand<Array<E>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: NativeExpand<usize>, ) -> &mut E::ExpandType

impl<E: CubePrimitive> IndexMutExpand<NativeExpand<usize>> for TensorExpand<E>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: NativeExpand<usize>, ) -> &mut E::ExpandType

impl<E: CubePrimitive> IndexMutExpand<NativeExpand<usize>> for NativeExpand<Shared<[E]>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: NativeExpand<usize>, ) -> &mut E::ExpandType

impl<E: CubePrimitive> IndexMutExpand<RangeExpand<usize>> for NativeExpand<Array<E>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeExpand<usize>, ) -> &mut <Self as IndexExpand<RangeExpand<usize>>>::Output

impl<E: CubePrimitive> IndexMutExpand<RangeExpand<usize>> for NativeExpand<Shared<[E]>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeExpand<usize>, ) -> &mut <Self as IndexExpand<RangeExpand<usize>>>::Output

impl<E: CubePrimitive> IndexMutExpand<RangeFromExpand<usize>> for NativeExpand<Array<E>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeFromExpand<usize>, ) -> &mut <Self as IndexExpand<RangeFromExpand<usize>>>::Output

impl<E: CubePrimitive> IndexMutExpand<RangeFromExpand<usize>> for NativeExpand<Shared<[E]>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeFromExpand<usize>, ) -> &mut <Self as IndexExpand<RangeFromExpand<usize>>>::Output

impl<E: CubePrimitive> IndexMutExpand<RangeFullExpand> for NativeExpand<Array<E>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeFullExpand, ) -> &mut <Self as IndexExpand<RangeFullExpand>>::Output

impl<E: CubePrimitive> IndexMutExpand<RangeFullExpand> for NativeExpand<Shared<[E]>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeFullExpand, ) -> &mut <Self as IndexExpand<RangeFullExpand>>::Output

impl<E: CubePrimitive> IndexMutExpand<RangeInclusiveExpand<usize>> for NativeExpand<Array<E>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeInclusiveExpand<usize>, ) -> &mut <Self as IndexExpand<RangeInclusiveExpand<usize>>>::Output

impl<E: CubePrimitive> IndexMutExpand<RangeInclusiveExpand<usize>> for NativeExpand<Shared<[E]>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeInclusiveExpand<usize>, ) -> &mut <Self as IndexExpand<RangeInclusiveExpand<usize>>>::Output

impl<E: CubePrimitive> IndexMutExpand<RangeToExpand<usize>> for NativeExpand<Array<E>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeToExpand<usize>, ) -> &mut <Self as IndexExpand<RangeToExpand<usize>>>::Output

impl<E: CubePrimitive> IndexMutExpand<RangeToExpand<usize>> for NativeExpand<Shared<[E]>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeToExpand<usize>, ) -> &mut <Self as IndexExpand<RangeToExpand<usize>>>::Output

impl<E: CubePrimitive> IndexMutExpand<RangeToInclusiveExpand<usize>> for NativeExpand<Array<E>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeToInclusiveExpand<usize>, ) -> &mut <Self as IndexExpand<RangeToInclusiveExpand<usize>>>::Output

impl<E: CubePrimitive> IndexMutExpand<RangeToInclusiveExpand<usize>> for NativeExpand<Shared<[E]>>

fn __expand_index_mut_method( &mut self, scope: &Scope, index: RangeToInclusiveExpand<usize>, ) -> &mut <Self as IndexExpand<RangeToInclusiveExpand<usize>>>::Output

impl<P: Scalar + Into<NativeExpand<P>>, N: Size> Into<NativeExpand<Vector<P, N>>> for Vector<P, N>

fn into(self) -> NativeExpand<Self>

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

impl<T: ?Sized> IntoExpand for NativeExpand<T>

type Expand = NativeExpand<T>

fn into_expand(self, _: &Scope) -> Self::Expand

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

fn into_mut(self, _scope: &Scope) -> Self

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

impl<T: NativeCubeType + ?Sized> IntoMut for NativeExpand<Shared<T>>

fn into_mut(self, _scope: &Scope) -> Self

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

impl<E: CubePrimitive> IntoMut for NativeExpand<Box<[E]>>

fn into_mut(self, _scope: &Scope) -> Self

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

impl<E: CubePrimitive, K: TensorMapKind> IntoMut for NativeExpand<TensorMap<E, K>>

fn into_mut(self, _scope: &Scope) -> Self

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

impl<T: NativeAssign> IntoMut for NativeExpand<T>

fn into_mut(self, scope: &Scope) -> Self

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

impl<T: InverseSqrt + CubePrimitive> InverseSqrtExpand for NativeExpand<T>

fn __expand_inverse_sqrt_method(self, scope: &Scope) -> Self

impl<T: IsInf + CubePrimitive> IsInfExpand for NativeExpand<T>

fn __expand_is_inf_method(self, scope: &Scope) -> Self::WithScalar<bool>

impl<T: IsNan + CubePrimitive> IsNanExpand for NativeExpand<T>

fn __expand_is_nan_method(self, scope: &Scope) -> Self::WithScalar<bool>

impl<T: CubeIndex<usize> + SizedContainer<usize> + CubeType<ExpandType = NativeExpand<T>>> Iterable for NativeExpand<T>

where <T::Output as CubeType>::ExpandType: DerefExpand<Target = <T::Output as CubeType>::ExpandType>,

type Item = <<T as Index<usize>>::Output as CubeType>::ExpandType

fn expand(self, scope: &Scope, body: impl FnMut(&Scope, Self::Item))

Expand a runtime loop without unrolling

fn expand_unroll(self, _scope: &Scope, _body: impl FnMut(&Scope, Self::Item))

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: LeadingZeros + CubePrimitive> LeadingZerosExpand for NativeExpand<T>

fn __expand_leading_zeros_method(self, scope: &Scope) -> Self::WithScalar<u32>

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

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

impl<T: CubePrimitive> ListExpand<T> for NativeExpand<Shared<[T]>>

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

impl<T: Log1p + CubePrimitive> Log1pExpand for NativeExpand<T>

fn __expand_log1p_method(self, scope: &Scope) -> Self

impl<T: Log + CubePrimitive> LogExpand for NativeExpand<T>

fn __expand_ln_method(self, scope: &Scope) -> Self

impl<T: Magnitude + CubePrimitive> MagnitudeExpand for NativeExpand<T>

fn __expand_magnitude_method(self, scope: &Scope) -> Self::Scalar

impl<T: CubePrimitive + ModFloor> ModFloorExpand for NativeExpand<T>

fn __expand_mod_floor_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: MulAssign + CubePrimitive> MulAssignExpand for NativeExpand<T>

fn __expand_mul_assign_method(&mut self, scope: &Scope, rhs: Self)

impl<T: Mul<Output = T> + CubePrimitive> MulExpand for NativeExpand<T>

fn __expand_mul_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: CubePrimitive + MulHi> MulHiExpand for NativeExpand<T>

fn __expand_mul_hi_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: Neg<Output = T> + CubePrimitive> NegExpand for NativeExpand<T>

fn __expand_neg_method(self, scope: &Scope) -> Self

impl<T: Normalize + CubePrimitive> NormalizeExpand for NativeExpand<T>

fn __expand_normalize_method(self, scope: &Scope) -> Self

impl<T: CubeNot + CubePrimitive> NotExpand for NativeExpand<T>

fn __expand_not_method(self, scope: &Scope) -> Self

impl<T: CubeOr + CubePrimitive> OrExpand for NativeExpand<T>

fn __expand_or_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: Ord + CubePrimitive> OrdExpand for NativeExpand<T>

fn __expand_cmp_method(&self, scope: &Scope, rhs: &Self) -> OrderingExpand

fn __expand_min_method(self, scope: &Scope, rhs: Self) -> Self

fn __expand_max_method(self, scope: &Scope, rhs: Self) -> Self

fn __expand_clamp_method(self, scope: &Scope, min: Self, max: Self) -> Self

impl<T: PartialEq + CubePrimitive> PartialEqExpand for NativeExpand<T>

fn __expand_eq_method(&self, scope: &Scope, rhs: &Self) -> NativeExpand<bool>

fn __expand_ne_method(&self, scope: &Scope, rhs: &Self) -> NativeExpand<bool>

impl<T: PartialOrd + CubePrimitive> PartialOrdExpand for NativeExpand<T>

fn __expand_partial_cmp_method( &self, scope: &Scope, rhs: &Self, ) -> OptionExpand<Ordering>

fn __expand_lt_method(&self, scope: &Scope, rhs: &Self) -> NativeExpand<bool>

fn __expand_le_method(&self, scope: &Scope, rhs: &Self) -> NativeExpand<bool>

fn __expand_gt_method(&self, scope: &Scope, rhs: &Self) -> NativeExpand<bool>

fn __expand_ge_method(&self, scope: &Scope, rhs: &Self) -> NativeExpand<bool>

impl<T: CubePrimitive + Powf> PowfExpand for NativeExpand<T>

fn __expand_powf_method(self, scope: &Scope, rhs: Self) -> Self

impl<Rhs: CubePrimitive, T: CubePrimitive + Powi<Rhs>> PowiExpand<Rhs> for NativeExpand<T>

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

impl<T: Radians + CubePrimitive> RadiansExpand for NativeExpand<T>

fn __expand_to_radians_method(self, scope: &Scope) -> Self

impl<T: Recip + CubePrimitive> RecipExpand for NativeExpand<T>

fn __expand_recip_method(self, scope: &Scope) -> Self

impl<T: RemAssign + CubePrimitive> RemAssignExpand for NativeExpand<T>

fn __expand_rem_assign_method(&mut self, scope: &Scope, rhs: Self)

impl<T: Rem<Output = T> + CubePrimitive> RemExpand for NativeExpand<T>

fn __expand_rem_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: ReverseBits + CubePrimitive> ReverseBitsExpand for NativeExpand<T>

fn __expand_reverse_bits_method(self, scope: &Scope) -> Self

impl<T: CubePrimitive + Rhypot> RhypotExpand for NativeExpand<T>

fn __expand_rhypot_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: Round + CubePrimitive> RoundExpand for NativeExpand<T>

fn __expand_round_method(self, scope: &Scope) -> Self

impl<C: CubePrimitive> RuntimeAssign for NativeExpand<Array<C>>

fn init_mut(&self, scope: &Scope) -> Self::Expand

Create a new mutable variable of this type in scope.

impl<T: NativeAssign> RuntimeAssign for NativeExpand<T>

fn init_mut(&self, scope: &Scope) -> Self::Expand

Create a new mutable variable of this type in scope.

impl<T: CubePrimitive> RuntimeAssign<NativeExpand<T>> for SharedExpand<T>

fn init_mut(&self, scope: &Scope) -> Self::Expand

Create a new mutable variable of this type in scope.

impl<T: CubePrimitive + SaturatingAdd> SaturatingAddExpand for NativeExpand<T>

fn __expand_saturating_add_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: CubePrimitive + SaturatingSub> SaturatingSubExpand for NativeExpand<T>

fn __expand_saturating_sub_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: ShlAssign + CubePrimitive> ShlAssignExpand for NativeExpand<T>

fn __expand_shl_assign_method(&mut self, scope: &Scope, rhs: Self)

impl<T: Shl<Output = T> + CubePrimitive> ShlExpand for NativeExpand<T>

fn __expand_shl_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: ShrAssign + CubePrimitive> ShrAssignExpand for NativeExpand<T>

fn __expand_shr_assign_method(&mut self, scope: &Scope, rhs: Self)

impl<T: Shr<Output = T> + CubePrimitive> ShrExpand for NativeExpand<T>

fn __expand_shr_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: Sin + CubePrimitive> SinExpand for NativeExpand<T>

fn __expand_sin_method(self, scope: &Scope) -> Self

impl<T: Sinh + CubePrimitive> SinhExpand for NativeExpand<T>

fn __expand_sinh_method(self, scope: &Scope) -> Self

impl<T: CubePrimitive> SizedContainerExpand<usize> for NativeExpand<Array<T>>

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

impl<T: Sqrt + CubePrimitive> SqrtExpand for NativeExpand<T>

fn __expand_sqrt_method(self, scope: &Scope) -> Self

impl<T: SubAssign + CubePrimitive> SubAssignExpand for NativeExpand<T>

fn __expand_sub_assign_method(&mut self, scope: &Scope, rhs: Self)

impl<T: Sub<Output = T> + CubePrimitive> SubExpand for NativeExpand<T>

fn __expand_sub_method(self, scope: &Scope, rhs: Self) -> Self

impl<T: Tan + CubePrimitive> TanExpand for NativeExpand<T>

fn __expand_tan_method(self, scope: &Scope) -> Self

impl<T: Tanh + CubePrimitive> TanhExpand for NativeExpand<T>

fn __expand_tanh_method(self, scope: &Scope) -> Self

impl<T: TrailingZeros + CubePrimitive> TrailingZerosExpand for NativeExpand<T>

fn __expand_trailing_zeros_method(self, scope: &Scope) -> Self::WithScalar<u32>

impl<T: Trunc + CubePrimitive> TruncExpand for NativeExpand<T>

fn __expand_trunc_method(self, scope: &Scope) -> Self

impl<T: VectorSum + CubePrimitive> VectorSumExpand for NativeExpand<T>

fn __expand_vector_sum_method(self, scope: &Scope) -> Self::Scalar

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

fn vector_size(&self) -> VectorSize

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

impl<T: CubePrimitive> VectorizedExpand for NativeExpand<Shared<[T]>>

fn vector_size(&self) -> VectorSize

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

impl<E: CubePrimitive> VectorizedExpand for NativeExpand<Box<[E]>>

fn vector_size(&self) -> VectorSize

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

impl<E: CubePrimitive, K: TensorMapKind> VectorizedExpand for NativeExpand<TensorMap<E, K>>

fn vector_size(&self) -> VectorSize

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