Struct iterative_methods::ReservoirSample

pub struct ReservoirSample<I, T> {
    pub reservoir: Vec<T>,
    // some fields omitted
}

Adaptor to reservoir sample.

ReservoirSample wraps a StreamingIterator, I and produces a StreamingIterator whose items are samples of size capacity from the stream of I. (This is not the capacity of the Vec which holds the reservoir; Rather, the length of the reservoir is normally referred to as its capacity.) To produce a reservoir of length capacity on the first call, the first call of the advance method automatically advances the input iterator capacity steps. Subsequent calls of advance on ReservoirIterator advance I by skip + 1 steps and will at most replace a single element of the reservoir. The random rng is of type Pcg64 by default, which allows seeded rng. This should be extended to generic type bound by traits for implementing seeding. See Algorithm L in https://en.wikipedia.org/wiki/Reservoir_sampling#An_optimal_algorithm and https://dl.acm.org/doi/abs/10.1145/198429.198435

Fields

reservoir: Vec<T>

Trait Implementations

impl<I: Clone, T: Clone> Clone for ReservoirSample<I, T>

fn clone(&self) -> ReservoirSample<I, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug, T: Debug> Debug for ReservoirSample<I, T>

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

Formats the value using the given formatter.

impl<I, T> StreamingIterator for ReservoirSample<I, T> where
    T: Clone + Debug,
    I: StreamingIterator<Item = T>, 

type Item = Vec<T>

The type of the elements being iterated over.

fn advance(&mut self)

Advances the iterator to the next element.

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

Returns a reference to the current element of the iterator.

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

Advances the iterator and returns the next value.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn all<F>(&mut self, f: F) -> bool where
    F: FnMut(&Self::Item) -> bool, 

Determines if all elements of the iterator satisfy a predicate.

fn any<F>(&mut self, f: F) -> bool where
    F: FnMut(&Self::Item) -> bool, 

Determines if any elements of the iterator satisfy a predicate.

fn by_ref(&mut self) -> &mut Self

Borrows an iterator, rather than consuming it.

fn chain<I>(self, other: I) -> Chain<Self, I> where
    I: StreamingIterator<Item = Self::Item>, 

Consumes two iterators and returns a new iterator that iterates over both in sequence.

fn cloned(self) -> Cloned<Self> where
    Self::Item: Clone, 

Produces a normal, non-streaming, iterator by cloning the elements of this iterator.

fn count(self) -> usize

Consumes the iterator, counting the number of remaining elements and returning it.

fn filter<F>(self, f: F) -> Filter<Self, F> where
    F: FnMut(&Self::Item) -> bool, 

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, B, F> where
    F: FnMut(&Self::Item) -> Option<B>, 

Creates an iterator which both filters and maps by applying a closure to elements.

fn flat_map<J, F>(self, f: F) -> FlatMap<Self, J, F> where
    F: FnMut(&Self::Item) -> J,
    J: StreamingIterator, 

Creates an iterator which flattens iterators obtained by applying a closure to elements. Note that the returned iterators must be streaming iterators.

fn filter_map_deref<B, F>(self, f: F) -> FilterMapDeref<Self, F> where
    F: FnMut(&Self::Item) -> Option<B>, 

Creates a regular, non-streaming iterator which both filters and maps by applying a closure to elements.

fn find<F>(&mut self, f: F) -> Option<&Self::Item> where
    F: FnMut(&Self::Item) -> bool, 

Returns the first element of the iterator that satisfies the predicate.

fn fuse(self) -> Fuse<Self>

Creates an iterator which is “well behaved” at the beginning and end of iteration.

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    F: FnMut(&Self::Item), 

Call a closure on each element, passing the element on. The closure is called upon calls to advance or advance_back, and exactly once per element regardless of how many times (if any) get is called.

fn map<B, F>(self, f: F) -> Map<Self, B, F> where
    F: FnMut(&Self::Item) -> B, 

Creates an iterator which transforms elements of this iterator by passing them to a closure.

fn map_deref<B, F>(self, f: F) -> MapDeref<Self, F> where
    F: FnMut(&Self::Item) -> B, 

Creates a regular, non-streaming iterator which transforms elements of this iterator by passing them to a closure.

fn map_ref<B, F>(self, f: F) -> MapRef<Self, F> where
    F: Fn(&Self::Item) -> &B,
    B: ?Sized, 

Creates an iterator which transforms elements of this iterator by passing them to a closure.

fn nth(&mut self, n: usize) -> Option<&Self::Item>

Consumes the first n elements of the iterator, returning the next one.

fn position<F>(&mut self, f: F) -> Option<usize> where
    F: FnMut(&Self::Item) -> bool, 

Returns the index of the first element of the iterator matching a predicate.

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

Creates an iterator which skips the first n elements.

fn skip_while<F>(self, f: F) -> SkipWhile<Self, F> where
    F: FnMut(&Self::Item) -> bool, 

Creates an iterator that skips initial elements matching a predicate.

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

Creates an iterator which only returns the first n elements.

fn take_while<F>(self, f: F) -> TakeWhile<Self, F> where
    F: FnMut(&Self::Item) -> bool, 

Creates an iterator which only returns initial elements matching a predicate.

fn rev(self) -> Rev<Self> where
    Self: DoubleEndedStreamingIterator, 

Creates an iterator which returns elemens in the opposite order.

fn fold<B, F>(self, init: B, f: F) -> B where
    F: FnMut(B, &Self::Item) -> B, 

Reduces the iterator’s elements to a single, final value.

fn for_each<F>(self, f: F) where
    F: FnMut(&Self::Item), 

Calls a closure on each element of an iterator.