Struct WeightedTable 

pub struct WeightedTable<T>
where
    T: PartialEq + Clone,
{ /* private fields */ }

WeightedTable

This is a simple implementation of a weighted table. It is designed to be used with a random number generator. It can be used as follows:

use rantz_random::prelude::{WeightedTable, RandomContainer};

let mut table = WeightedTable::new();
  
table.insert("Bob", 10); // Bob has a weight of 10
table.insert("Alice", 20); // Alice has a weight of 20
table.remove(&"Bob"); // Bob is removed

table.random(); // Returns a random element from the table based on the weights

The table is iterable and returns owned tuples of (value, weight) For references, use the iter method For mutable references, use the [iter_mut](WeightedTable::iter_mut) method

use rantz_random::prelude::WeightedTable;

let mut table = WeightedTable::new();

table.insert("Bob".to_string(), 10); // Bob has a weight of 10
table.insert("Alice".to_string(), 20); // Alice has a weight of 20


for (value, weight) in table.iter() {
  println!("Reference {} has a weight of {}", value, weight);
}

for (value, weight) in table.iter_mut() {
  *value += " Test";
  *weight += 10;
  println!("Reference {} has a weight of {}", value, weight);
}

for value in table { // Must be done last as consumes the table
  println!("Owned {}", value);
}

Adding an element that already exists will update the weight of the existing element.

Implementations

impl<T> WeightedTable<T>

where T: PartialEq + Clone,

pub fn new() -> WeightedTable<T>

Creates a new empty WeightedTable

pub fn from_vec(vec: Vec<(T, u32)>) -> WeightedTable<T>

Creates a new WeightedTable from a vector of tuples of (value, weight)

pub fn insert(&mut self, value: T, weight: u32)

Inserts a new element into the table

pub fn remove(&mut self, value: &T)

Removes an element from the table

pub fn clear(&mut self)

Clears the table

pub fn get_entry(&self, index: usize) -> Option<(T, u32)>

Returns the entry at the specified index

pub fn get_entry_ref(&self, index: usize) -> Option<(&T, &u32)>

Returns the entry at the specified index as a reference

pub fn get_entry_mut(&mut self, index: usize) -> Option<(&mut T, &mut u32)>

Returns the entry at the specified index as a mutable reference

pub fn get_weight(&self, value: &T) -> Option<u32>

Returns the weight of the specified value

pub fn get_weight_mut(&mut self, value: &T) -> Option<&mut u32>

Returns the weight of the specified value as a mutable reference

pub fn random_with(&self, n: u32) -> (T, u32)

Returns a random element with the specified weight

pub fn iter(&self) -> impl Iterator<Item = (&T, &u32)>

Returns an iterator over the table

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&mut T, &mut u32)>

Returns an iterator over the table mutably

pub fn combine(&mut self, other: WeightedTable<T>)

Combines two tables (in place)

Trait Implementations

impl<T> Clone for WeightedTable<T>

where T: Clone + PartialEq,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for WeightedTable<T>

where T: Debug + PartialEq + Clone,

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

Formats the value using the given formatter.

impl<T> Default for WeightedTable<T>

where T: PartialEq + Clone,

fn default() -> WeightedTable<T>

Returns the “default value” for a type.

impl<'a, T> FromIterator<(T, &'a u32)> for WeightedTable<T>

where T: PartialEq + Clone,

fn from_iter<I>(iter: I) -> WeightedTable<T>

where I: IntoIterator<Item = (T, &'a u32)>,

Creates a value from an iterator.

impl<T> FromIterator<(T, u32)> for WeightedTable<T>

where T: PartialEq + Clone,

fn from_iter<I>(iter: I) -> WeightedTable<T>

where I: IntoIterator<Item = (T, u32)>,

Creates a value from an iterator.

impl<T> IntoIterator for WeightedTable<T>

where T: PartialEq + Clone,

type Item = T

The type of the elements being iterated over.

type IntoIter = WeightedTableTupleIntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <WeightedTable<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> RandomWeightedContainer<T> for WeightedTable<T>

where T: Clone + PartialEq,

fn max_weight(&self) -> u32

Returns the maximum weight of all elements in the container

fn weights(&self) -> &Vec<u32>

Returns the weights of all elements in the container as a vector

fn values(&self) -> &Vec<T>

Returns the values of all elements in the container as a vector

fn random_weight(&self) -> Option<u32>

Returns a random weight below the maximum weight or None if the container is empty

fn weighted_random_with_weight(&self, weight: u32) -> Option<Self::Item>

Returns a random element mapping to the specified weight

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

Returns a random element based on the weights