Struct StridedZip

pub struct StridedZip<'a, A: 'a, B: 'a> { /* private fields */ }

A single thread non SIMD-optimized zipped iterator combining two iterators over tensor elements.

Implementations

impl<'a, A, B> StridedZip<'a, A, B>

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

pub fn new(a: A, b: B) -> Self

Creates a new StridedZip instance by zipping two iterators.

Arguments

• a - The first iterator to zip.
• b - The second iterator to zip.

Returns

A new StridedZip instance that combines both iterators for synchronized iteration.

Trait Implementations

impl<'a, A: Clone + 'a, B: Clone + 'a> Clone for StridedZip<'a, A, B>

fn clone(&self) -> StridedZip<'a, A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, A, B> IterGetSet for StridedZip<'a, A, B>

where A: IterGetSet, B: IterGetSet,

type Item = (<A as IterGetSet>::Item, <B as IterGetSet>::Item)

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, last_stride: 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, A, B> StridedIterator for StridedZip<'a, A, B>

where A: IterGetSet, B: IterGetSet,

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, A, B> StridedIteratorMap for StridedZip<'a, A, B>

fn map<'a, T, F, U>(self, f: F) -> StridedMap<'a, Self, T, F>

where F: Fn(T) -> U + Sync + Send + 'a, U: CommonBounds, Self: IterGetSet<Item = T>,

Transforms the strided iterators by applying a provided function to their items.

impl<'a, A, B> StridedIteratorZip for StridedZip<'a, A, B>