Struct weighted_random_list::WeightedRandomList

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

Stores the data and keeps track of the chances. It is built so that you can add and remove elements withouth the need of recalculation.

Methods

impl<T> WeightedRandomList<T>

pub fn new() -> WeightedRandomList<T>

pub fn push(&mut self, weight: usize, new: T)

Add an element to the collection with a given weight

Panics if the sum of the weights exceed the holding datatype

pub fn get_random(&self) -> Option<&T>

Get a random value from the collection or None if it is empty.

Accsess time is O(n), however the linear storage compensates for this overhead.

Example

let mut l = WeightedRandomList::new();
assert_eq!(None, l.get_random());

l.push(100, 42usize);
assert_eq!(Some(&42), l.get_random());

impl<T> WeightedRandomList<T> where
    T: PartialEq + Clone, 

If the stored type T supports PartialEq and Clone we can manipulate the contents of this container. Therefore shifting the chances of one element to be selected.

Example adjust weight after insertion

let mut l = WeightedRandomList::new();
l.push(10, 1);
l.push(10, 2);
l.push(100, 3);
// total weights is now 120

{
    let mut three = l.entry_first(&3);
    three.set_weight(80);
}
// total weights is now 100

pub fn entry_first(&mut self, needle: &T) -> Entry<T>

Find the first entry in the list matching needle and manipulate potential entries:

let mut l = WeightedRandomList::new();

l.entry_first(&42).or_insert_with_weight(10);

Trait Implementations

impl<T> FromIterator<(usize, T)> for WeightedRandomList<T>

Enable clollect

fn from_iter<I: IntoIterator<Item = (usize, T)>>(iter: I) -> Self

Creates a value from an iterator.