Struct StridedMapMut

pub struct StridedMapMut<'a, T>
where
    T: Copy + TypeCommon,
{ /* private fields */ }

A non SIMD-optimized mutable mapped strided iterator over tensor elements.

This struct provides mutable access to tensor elements,

Implementations

impl<'a, T> StridedMapMut<'a, T>

where T: CommonBounds, T::Vec: Send,

pub fn new<U: TensorInfo<T>>(res_tensor: U) -> Self

Creates a new StridedMapMut instance from a given tensor.

Arguments

• res_tensor - The tensor implementing the TensorInfo<T> trait to iterate over mutably.

Returns

A new instance of StridedMapMut initialized with the provided tensor.

pub fn zip<C>(self, other: C) -> StridedZip<'a, Self, C>

where C: 'a + IterGetSet, <C as IterGetSet>::Item: Send,

Combines this StridedMapMut iterator with another iterator, enabling simultaneous iteration.

This method zips together self and other into a StridedZip iterator, allowing for synchronized iteration over both iterators. This is particularly useful for operations that require processing elements from two tensors in parallel, such as element-wise arithmetic operations.

Arguments

• other - The other iterator to zip with. It must implement the IterGetSet trait, and its associated Item type must be Send.

Returns

A StridedZip instance that encapsulates both self and other, allowing for synchronized iteration over their elements.

Trait Implementations

impl<'a, T: 'a + CommonBounds> IterGetSet for StridedMapMut<'a, T>

where T::Vec: Send,

type Item = &'a mut T

The type of the iterator’s elements.

fn set_end_index(&mut self, _: usize)

set the end index of the iterator, this is used when rayon perform data splitting

fn set_intervals(&mut self, _: Arc<Vec<(usize, usize)>>)

set the chunk intervals of the iterator, we chunk the outer loop

fn set_strides(&mut self, strides: Strides)

set the strides for the iterator, we call this method normally when we do broadcasting

fn set_shape(&mut self, shape: Shape)

set the shape for the iterator, we call this method normally when we do broadcasting

fn set_prg(&mut self, prg: Vec<i64>)

set the loop progress for the iterator

fn intervals(&self) -> &Arc<Vec<(usize, usize)>>

get the intervals of the iterator

fn strides(&self) -> &Strides

get the strides of the iterator

fn shape(&self) -> &Shape

get the shape of the iterator

fn layout(&self) -> &Layout

get the layout of the iterator

fn broadcast_set_strides(&mut self, shape: &Shape)

set the strides for all the iterators

fn outer_loop_size(&self) -> usize

get the outer loop size

fn inner_loop_size(&self) -> usize

get the inner loop size

fn next(&mut self)

update the loop progress

fn inner_loop_next(&mut self, index: usize) -> Self::Item

get the next element of the inner loop

impl<'a, T> StridedIterator for StridedMapMut<'a, T>

where T: 'a + CommonBounds,

fn for_each<F>(self, func: F)

where F: Fn(Self::Item),

perform scalar iteration, this method is for single thread iterator

fn for_each_init<F, INIT, T>(self, init: INIT, func: F)

where F: Fn(&mut T, Self::Item), INIT: Fn() -> T,

perform scalar iteration with init, this method is for single thread iterator