weighted-list 0.6.0

Data structures for weighted randomisation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::{
    fmt,
};

use crate::*;


pub type FWItem<V,W> = FrozenWeightedItem<V,W>;


#[derive(Debug, Clone, Hash)]
pub struct FrozenWeightedItem<V, W: Weight>
{
    cumulative_weight: W,
    weight: W,
    value: V,
}

// == CONSTRUCTORS == //
impl<V, W: Weight> FrozenWeightedItem<V,W>
{
    pub fn new(
        cumulative_weight: W,
        weight: W,
        value: V
    ) -> Self
    {
        Self { cumulative_weight, weight, value }
    }
}

/// Construct a `FrozenWeightedItem` from a `(weight, value)`` pair.
/// 
/// # Usage
/// 
/// ```
/// # use weighted_list::*;
/// let item = fwit!(2.0, "sup");
/// assert_eq!(item, FrozenWeightedItem::new(2.0, 2.0, "sup"));
/// 
/// let item = fwit!(3.0, "nova");
/// assert_eq!(item, FrozenWeightedItem::new(3.0, 3.0, "nova"));
/// ```
#[macro_export]
macro_rules! fwit {
    ( $weight: expr, $value: expr ) => {
        FrozenWeightedItem::new($weight, $weight, $value)
    };
    ( $cweight: expr, $weight: expr, $value: expr ) => {
        FrozenWeightedItem::new($cweight, $weight, $value)
    };
}

// == ACCESSORS == //
impl<V, W: Weight> FrozenWeightedItem<V,W>
{
    #[allow(dead_code)]
    pub(crate) fn c_weight(&self) -> W {
        self.cumulative_weight
    }

    pub fn cumulative_weight(&self) -> W {
        self.cumulative_weight
    }
    
    pub fn weight(&self) -> W {
        self.weight
    }
    
    pub fn value(&self) -> &V {
        &self.value
    }

    pub fn value_mut(&mut self) -> &mut V {
        &mut self.value
    }
}

// == CONVERSIONS == //
impl<V, W: Weight> Into<WeightedItem<V,W>> for FrozenWeightedItem<V,W>
{
    fn into(self) -> WeightedItem<V,W> {
        WeightedItem::new(self.weight, self.value)
    }
}

// == TRAITS == //
impl<V: fmt::Display, W: Weight> fmt::Display for FrozenWeightedItem<V,W>
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result
    {
        write!(f, "{{ {:?}, {} }}", self.weight, self.value)
    }
}

impl<V: Eq, W: Weight> Eq for FrozenWeightedItem<V,W> {}

impl<V: PartialEq, W: Weight> PartialEq for FrozenWeightedItem<V,W>
{
    fn eq(&self, other: &Self) -> bool {
        self.value == other.value
        && self.weight == other.weight
    }
}

impl<V: Eq, W: Weight + Ord> Ord for FrozenWeightedItem<V,W>
{
    fn cmp(&self, other: &Self) -> std::cmp::Ordering
    {
        self.weight.cmp(&other.weight)
    }
}

impl<V: Eq, W: Weight> PartialOrd for FrozenWeightedItem<V,W>
{
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering>
    {
        self.weight.partial_cmp(&other.weight)
    }
}