Struct random_wheel::RandomWheel

pub struct RandomWheel<T> { /* fields omitted */ }

a little implementation of a random-wheel.

Methods

impl<T> RandomWheel<T>

fn from_vec(vector: Vec<T>) -> RandomWheel<T>

create a new random-wheel from vector.

Example

use random_wheel::RandomWheel;

let numbers: Vec<_> = (0..20).collect();

// default probability is set to 1.0 for each element
let rw: RandomWheel<u8> = RandomWheel::from_vec(numbers);

fn new() -> RandomWheel<T>

create a new empty random-wheel.

Example

use random_wheel::RandomWheel;

let rw: RandomWheel<u8> = RandomWheel::new();

fn with_capacity(n: usize) -> RandomWheel<T>

Creates an empty RandomWheel with space for at least n elements.

Example

use random_wheel::RandomWheel;

let numbers: Vec<_> = (0..20).collect();
let mut rw: RandomWheel<u8> = RandomWheel::with_capacity(numbers.len());

assert_eq!(rw.len(), 0);

fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in the given Ringbuf. The collection may reserve more space to avoid frequent reallocations.

Example

use random_wheel::RandomWheel;

let mut rw: RandomWheel<u8> = RandomWheel::new();
rw.reserve(20);

assert_eq!(rw.len(), 0);

fn capacity(&self) -> usize

Returns the number of elements the RandomWheel can hold without reallocating.

Example

use random_wheel::RandomWheel;

let rw: RandomWheel<u8> = RandomWheel::new();

println!("actual capacity: {}", rw.capacity());

fn len(&self) -> usize

returns the number of elements in the wheel.

Example

use random_wheel::RandomWheel;

let mut rw = RandomWheel::new();

assert_eq!(rw.len(), 0);

rw.push(1., 'r');
rw.push(1., 'c');
rw.push(1., 'a');

assert_eq!(rw.len(), 3);

fn clear(&mut self)

remove all elements in this wheel.

Example

use random_wheel::RandomWheel;

let mut rw = RandomWheel::new();

rw.push(1., 'r');
rw.push(1., 'c');
rw.push(1., 'a');

assert_eq!(rw.len(), 3);

rw.clear();

assert_eq!(rw.len(), 0);

fn is_empty(&self) -> bool

returns true if this wheel is empty else return false.

Example

use random_wheel::RandomWheel;

let mut rw = RandomWheel::new();

assert_eq!(rw.is_empty(), true);

rw.push(1., 'r');
rw.push(1., 'c');
rw.push(1., 'a');

assert_eq!(rw.is_empty(), false);

fn iter(&self) -> Iter<(f32, T)>

Returns an iterator over the slice.

Example

use random_wheel::RandomWheel;

let mut rw = RandomWheel::new();

rw.push(1., 'r');
rw.push(1., 'c');
rw.push(1., 'a');

let mut iter = rw.iter();

assert_eq!(iter.next(), Some(&(1.0, 'r')));
assert_eq!(iter.next(), Some(&(1.0, 'c')));
assert_eq!(iter.next(), Some(&(1.0, 'a')));
assert_eq!(iter.next(), None);

fn iter_mut(&mut self) -> IterMut<(f32, T)>

Returns an iterator that allows modifying each value.

Example

use random_wheel::RandomWheel;

let mut rw = RandomWheel::new();

rw.push(1., 'r');
rw.push(1., 'c');
rw.push(1., 'a');

for a in &mut rw.iter_mut() {
    a.1 = 'm';
}

assert_eq!(rw.peek(), Some((1., &'m')));

fn push(&mut self, proba: f32, data: T)

add an element associated with a probability.

Example

use random_wheel::RandomWheel;

let mut rw = RandomWheel::new();

rw.push(1., 'r');
rw.push(1., 'c');
rw.push(1., 'a');

assert_eq!(rw.len(), 3);

fn compute_proba_sum(&mut self)

Will recompute the probabilities sum use it when you iterate through this vector and change proba values

fn proba_sum(&self) -> f32

returns total of luck you pushed.

Example

use random_wheel::RandomWheel;

let mut rw = RandomWheel::new();

rw.push(1.5, 'r');
rw.push(2., 'c');
rw.push(3., 'a');

assert_eq!(rw.proba_sum(), 6.5);

fn peek(&self) -> Option<(f32, &T)>

returns a ref to the randomly peeked element with it's probality to be peeked.

Example

use random_wheel::RandomWheel;

let mut rw = RandomWheel::new();

rw.push(1., 'r');

assert_eq!(rw.peek(), Some((1.0, &'r')));
assert_eq!(rw.peek(), Some((1.0, &'r')));

fn peek_mut(&mut self) -> Option<(f32, &mut T)>

returns a ref to the randomly peeked element with it's probality to be peeked.

Example

use random_wheel::RandomWheel;

let mut rw = RandomWheel::new();

rw.push(1., 'r');

match rw.peek_mut() {
    Some((_, val)) => *val = 'b',
    None => {}
}

assert_eq!(rw.peek(), Some((1.0, &'b')));

fn pop(&mut self) -> Option<(f32, T)>

removes a randomly peeked element and return it with it's probality to be peeked.

Example

use random_wheel::RandomWheel;

let mut rw = RandomWheel::new();

rw.push(1., 'r');

assert_eq!(rw.pop(), Some((1.0, 'r')));

// once you pop the value, it doesn't exist anymore
assert_eq!(rw.peek(), None);
assert_eq!(rw.pop(), None);

Trait Implementations

impl<T: Clone> Clone for RandomWheel<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> IntoIterator for RandomWheel<T>

type Item = (f32, T)

The type of the elements being iterated over.

type IntoIter = IntoIter<(f32, T)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<(f32, T)>

Creates a consuming iterator, that is, one that moves each value out of the randomWheel (from start to end).