Struct random_wheel::RandomWheel
[−]
[src]
pub struct RandomWheel<T> { // some fields omitted }
a little implementation of a random-wheel.
Methods
impl<T> RandomWheel<T>
[src]
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(&'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 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<&T>
returns a ref to the randomly peeked element.
Example
use random_wheel::RandomWheel; let mut rw = RandomWheel::new(); rw.push(1., 'r'); assert_eq!(rw.peek(), Some(&'r')); assert_eq!(rw.peek(), Some(&'r'));
fn peek_mut(&mut self) -> Option<&mut T>
returns a ref to the randomly peeked element.
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(&'b'));
fn peek_with_proba(&self) -> Option<(f32, &T)>
returns a ref to the randomly peeked element.
Example
use random_wheel::RandomWheel; let mut rw = RandomWheel::new(); rw.push(1., 'r'); assert_eq!(rw.peek_with_proba(), Some((1.0, &'r'))); assert_eq!(rw.peek_with_proba(), Some((1.0, &'r')));
fn peek_mut_with_proba(&mut self) -> Option<(f32, &mut T)>
returns a ref to the randomly peeked element.
Example
use random_wheel::RandomWheel; let mut rw = RandomWheel::new(); rw.push(1., 'r'); match rw.peek_mut_with_proba() { Some((_, val)) => *val = 'b', None => {} } assert_eq!(rw.peek_with_proba(), Some((1.0, &'b')));
fn pop(&mut self) -> Option<T>
removes a randomly peeked element and return it.
Example
use random_wheel::RandomWheel; let mut rw = RandomWheel::new(); rw.push(1., 'r'); assert_eq!(rw.peek(), Some(&'r')); assert_eq!(rw.pop(), Some('r')); // once you pop the value, it doesn't exist anymore assert_eq!(rw.peek(), None); assert_eq!(rw.pop(), None);
fn pop_with_proba(&mut self) -> Option<(f32, T)>
removes a randomly peeked element and return it.
Example
use random_wheel::RandomWheel; let mut rw = RandomWheel::new(); rw.push(1., 'r'); assert_eq!(rw.pop_with_proba(), Some((1.0, 'r'))); // once you pop the value, it doesn't exist anymore assert_eq!(rw.peek(), None); assert_eq!(rw.pop(), None); assert_eq!(rw.pop_with_proba(), None);
Trait Implementations
impl<T: Clone> Clone for RandomWheel<T>
[src]
fn clone(&self) -> RandomWheel<T>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl<T> IntoIterator for RandomWheel<T>
[src]
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).