Struct StridedMut

pub struct StridedMut<'a, T> { /* private fields */ }

A mutable strided iterator over tensor elements.

This struct provides mutable access to tensor elements with strided access patterns in single thread.

Implementations

impl<'a, T: CommonBounds> StridedMut<'a, T>

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

Creates a new StridedMut instance from a given tensor.

Arguments

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

Returns

A new instance of StridedMut 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 StridedMut iterator with another iterator, enabling simultaneous iteration.

This method performs shape broadcasting between self and other to ensure that both iterators iterate over tensors with compatible shapes. It adjusts the strides and shapes of both iterators to match the broadcasted shape and then returns a StridedZip that allows for synchronized iteration over both iterators.

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 zips together self and other, enabling synchronized iteration over their elements.

Panics

This method will panic if the shapes of self and other cannot be broadcasted together. Ensure that the shapes are compatible before calling this method.

Trait Implementations

impl<'a, T> IterGetSet for StridedMut<'a, T>

where T: CommonBounds + 'a,

type Item = &'a mut T

The type of the iterator’s elements.

fn set_end_index(&mut self, end_index: usize)

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

fn set_intervals(&mut self, intervals: 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: CommonBounds> StridedIterator for StridedMut<'a, T>

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

impl<'a, T: CommonBounds> StridedIteratorZip for StridedMut<'a, T>