Struct droprate::FairlyRandomTable

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

FairlyRandomTable aims to create results which a human might create when asked to create a random sequence from a weighted table. It is human nature to generate a more evenly-distributed list of random values because we are aware of the the history of options chosen.

Calling this a "random" table strains the definition -- it is certainly going to give you "mixed up" results, but ultimately they will be far more predictable. That said, they will also feel much more "fair" to users who experience them.

For example: Given a result with a 1-in-10 odds ratio, there is still a 30% chance that you won't get that result within 10 trials. There is a 12% chance that you won't even see the result within 20 trials. This is where players start to complain that the devs hate them.

With FairlyRandomTable, every trial which doesn't give a certain result increases the probability of that result on the next trial (proportional to its initial probability) until it is selected, which decreases its probability dramatically (however it's not impossible to get multiple results in a row -- in fact, allowing for multiple results in a row of even unlikely options is a design goal; you just won't seem them as frequently).

Methods

impl<T: Eq + Hash + Clone> FairlyRandomTable<T>

pub fn new() -> FairlyRandomTable<T>

Create a new instance of FairlyRandomTable with no options.

pub fn from_map(in_table: HashMap<T, f64>) -> FairlyRandomTable<T>

Create a new FairlyRandomTable from a HashMap.

Examples

use droprate::{FairlyRandomTable, ProbabilityTable};
use std::collections::HashMap;
 
let map: HashMap<&'static str, f64> =
    [("A", 1f64),
    ("B", 1f64),
    ("C", 3f64)]
    .iter().cloned().collect();
 
let mut table = FairlyRandomTable::<&'static str>::from_map(map);
 
assert_eq!(3, table.count());

use droprate::{FairlyRandomTable, ProbabilityTable};
use std::collections::HashMap;
 
let mut map = HashMap::new();
map.insert("A", 1f64);
map.insert("B", 1f64);
map.insert("C", 3f64);
 
let mut table = FairlyRandomTable::<&'static str>::from_map(map);
 
assert_eq!(3, table.count());

pub fn pure_random(&self) -> Result<T, String>

Run a trial from this as though it were a RandomTable. The table's results memory will not be affected, and as such future results from calling random() will not account for this trial.

Trait Implementations

impl<T: Eq + Hash + Clone> ProbabilityTable<T> for FairlyRandomTable<T>

fn push(&mut self, ident: T, weight: f64) -> &mut dyn ProbabilityTable<T>

Add an option to the random table with the assigned weight value.

fn count(&self) -> usize

Get the number of possible items in the table.

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

Get a vector of all of the options in the list. There is no guarantee over the order in which items are returned.

fn random(&mut self) -> Result<T, String>

Choose an option from the list of options, using the supplied weights to map the odds. The actual odds for each trial may differ when using tables other than RandomTable (e.g., FairlyRandomTable tracks results from previous trials in order to deliver a more evenly distributed set of results than one would fine from a more "true" random generator)