Struct ReadOnlyLocalChunks 

pub struct ReadOnlyLocalChunks<T: Dist> { /* private fields */ }

An iterator over immutable (nonoverlapping) local chunks (of size chunk_size) of an ReadOnlyArray This struct is created by calling ReadOnlyArray::local_chunks

Trait Implementations

impl<T: Clone + Dist> Clone for ReadOnlyLocalChunks<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Dist + 'static> IndexedLocalIterator for ReadOnlyLocalChunks<T>

fn iterator_index(&self, index: usize) -> Option<usize>

given an local index return the corresponding local iterator index ( or None otherwise)

fn enumerate(self) -> Enumerate<Self>

yields the local (to the calling PE) index along with each element

fn chunks(self, size: usize) -> Chunks<Self>

Split an iterator into fixed-sized chunks

fn skip(self, count: usize) -> Skip<Self>

An iterator that skips the first n elements

fn step_by(self, step_size: usize) -> StepBy<Self>

An iterator that steps by step_size elements

fn take(self, count: usize) -> Take<Self>

An iterator that takes the first n elements

fn zip<I: IndexedLocalIterator>(self, iter: I) -> Zip<Self, I>

Iterates over tuples (A,B) where the A items are from this iterator and the B items are from the iter in the argument. If the two iterators are of unequal length, the returned iterator will be equal in length to the shorter of the two.

impl<T: Dist + 'static> LocalIterator for ReadOnlyLocalChunks<T>

type Item = &'static [T]

The type of item this local iterator produces

type Array = ReadOnlyArray<T>

The array to which this local iterator was created from

fn array(&self) -> Self::Array

Return the original array this local iterator belongs too

fn next(&mut self) -> Option<Self::Item>

Return the next element in the iterator, otherwise return None

fn elems(&self, in_elems: usize) -> usize

Return the maximum number of elements in the iterator

fn advance_index(&mut self, count: usize)

advance the internal iterator localtion by count elements

fn filter<F>(self, op: F) -> Filter<Self, F>

where F: Fn(&Self::Item) -> bool + Clone + 'static,

Applies op on each element of this iterator, producing a new iterator with only the elements that gave true results

fn filter_map<F, R>(self, op: F) -> FilterMap<Self, F>

where F: Fn(Self::Item) -> Option<R> + Clone + 'static, R: Send + 'static,

Applies op on each element of this iterator to get an Option, producing a new iterator with only the elements that return Some

fn map<F, R>(self, op: F) -> Map<Self, F>

where F: Fn(Self::Item) -> R + Clone + 'static, R: Send + 'static,

Applies op to each element producing a new iterator with the results

fn monotonic(self) -> Monotonic<Self>

Similar to the Enumerate iterator (which can only be applied to IndexedLocalIterators), but the yielded indicies are only guaranteed to be unique and monotonically increasing, they should not be considered to have any relation to the underlying location of data in the local array.

fn for_each<F>(&self, op: F) -> LocalIterForEachHandle

where F: Fn(Self::Item) + SyncSend + Clone + 'static,

Calls a closure on each element of a Local Iterator in parallel on the calling PE (the PE must have some local data of the array).

fn for_each_with_schedule<F>( &self, sched: Schedule, op: F, ) -> LocalIterForEachHandle

where F: Fn(Self::Item) + SyncSend + Clone + 'static,

Calls a closure on each element of a Local Iterator in parallel on the calling PE (the PE must have some local data of the array) using the specififed Scehedule policy.

fn for_each_async<F, Fut>(&self, op: F) -> LocalIterForEachHandle

where F: Fn(Self::Item) -> Fut + SyncSend + Clone + 'static, Fut: Future<Output = ()> + Send + 'static,

Calls a closure and immediately awaits the result on each element of a Local Iterator in parallel on the calling PE (the PE must have some local data of the array).

fn for_each_async_with_schedule<F, Fut>( &self, sched: Schedule, op: F, ) -> LocalIterForEachHandle

where F: Fn(Self::Item) -> Fut + SyncSend + Clone + 'static, Fut: Future<Output = ()> + Send + 'static,

Calls a closure on each element of a Local Iterator in parallel on the calling PE (the PE must have some local data of the array) using the specififed Schedule policy.

fn reduce<F>(&self, op: F) -> LocalIterReduceHandle<Self::Item, F>

where Self::Item: SyncSend + Copy, F: Fn(Self::Item, Self::Item) -> Self::Item + SyncSend + Clone + 'static,

Reduces the elements of the local iterator using the provided closure

fn reduce_with_schedule<F>( &self, sched: Schedule, op: F, ) -> LocalIterReduceHandle<Self::Item, F>

where Self::Item: SyncSend + Copy, F: Fn(Self::Item, Self::Item) -> Self::Item + SyncSend + Clone + 'static,

Reduces the elements of the local iterator using the provided closure and specififed Schedule policy

fn collect_async<A, T>(&self, d: Distribution) -> LocalIterCollectHandle<T, A>

where T: Dist + ArrayOps, Self::Item: Future<Output = T> + Send + 'static, A: AsyncTeamFrom<(Vec<T>, Distribution)> + SyncSend + Clone + 'static,

Collects the awaited elements of the local iterator into a new LamellarArray

fn collect_async_with_schedule<A, T>( &self, sched: Schedule, d: Distribution, ) -> LocalIterCollectHandle<T, A>

where T: Dist + ArrayOps, Self::Item: Future<Output = T> + Send + 'static, A: AsyncTeamFrom<(Vec<T>, Distribution)> + SyncSend + Clone + 'static,

Collects the awaited elements of the local iterator into a new LamellarArray, using the provided Schedule policy

fn count(&self) -> LocalIterCountHandle

Counts the number of the elements of the local iterator

fn count_with_schedule(&self, sched: Schedule) -> LocalIterCountHandle

Counts the number of the elements of the local iterator using the provided Schedule policy

fn sum(&self) -> LocalIterSumHandle<Self::Item>

where Self::Item: SyncSend + for<'a> Sum<&'a Self::Item> + Sum<Self::Item>,

Sums the elements of the local iterator.

fn sum_with_schedule(&self, sched: Schedule) -> LocalIterSumHandle<Self::Item>

where Self::Item: SyncSend + for<'a> Sum<&'a Self::Item> + Sum<Self::Item>,

Sums the elements of the local iterator, using the specified Schedule policy