pumpkin-core 0.4.0

The core of the Pumpkin constraint programming solver.
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

use std::fmt::Debug;
use std::fmt::Display;

use num::cast::AsPrimitive;
use num::traits::NumAssign;

use super::MovingAverage;

#[derive(Default, Debug, Copy, Clone)]
pub struct CumulativeMovingAverage<Term> {
    sum: Term,
    num_terms: u64,
}

impl<Term> Display for CumulativeMovingAverage<Term>
where
    Term: Debug + NumAssign + AsPrimitive<f64>,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.value())
    }
}

impl<Term> MovingAverage<Term> for CumulativeMovingAverage<Term>
where
    Term: Debug + NumAssign + AsPrimitive<f64>,
{
    fn add_term(&mut self, new_term: Term) {
        self.sum += new_term;
        self.num_terms += 1
    }

    fn value(&self) -> f64 {
        if self.num_terms > 0 {
            self.sum.as_() / (self.num_terms as f64)
        } else {
            0.0
        }
    }

    fn adapt(&mut self, _interval_length: u64) {
        // do nothing
    }
}

#[cfg(test)]
mod tests {
    use super::CumulativeMovingAverage;
    use crate::statistics::moving_averages::MovingAverage;

    #[test]
    fn test_constant_value() {
        let constant_value = 100;
        let mut constant_average = CumulativeMovingAverage::default();
        for _i in 0..1000 {
            constant_average.add_term(constant_value);
            assert!(constant_average.value() == constant_value as f64);
        }
    }

    #[test]
    fn test_empty() {
        let empty_sum: CumulativeMovingAverage<u64> = CumulativeMovingAverage::default();
        assert!(empty_sum.value() == 0.0);
    }

    #[test]
    fn test_simple1() {
        let mut constant_average = CumulativeMovingAverage::default();
        constant_average.add_term(10);
        assert!(constant_average.value() == 10.0);
        constant_average.add_term(20);
        assert!(constant_average.value() == 15.0);
        constant_average.add_term(30);
        assert!(constant_average.value() == 20.0);
    }
}