online-statistics 0.2.6

Blazingly fast, generic, and serializable online statistics.
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

use crate::sorted_window::SortedWindow;
use crate::stats::Univariate;
use num::{Float, FromPrimitive};
use serde::{Deserialize, Serialize};
use std::ops::{AddAssign, SubAssign};
/// Running max.
/// # Examples
/// ```
/// use online_statistics::maximum::Max;
/// use online_statistics::stats::Univariate;
/// let mut running_max: Max<f64> = Max::new();
/// for i in 1..10{
///     running_max.update(i as f64);
/// }
/// assert_eq!(running_max.get(), 9.0);
/// ```
///
#[derive(Clone, Copy, Default, Debug, Serialize, Deserialize)]
pub struct Max<F: Float + FromPrimitive + AddAssign + SubAssign> {
    pub max: F,
}
impl<F: Float + FromPrimitive + AddAssign + SubAssign> Max<F> {
    pub fn new() -> Self {
        Self {
            max: F::min_value(),
        }
    }
}

impl<F: Float + FromPrimitive + AddAssign + SubAssign> Univariate<F> for Max<F> {
    fn update(&mut self, x: F) {
        if self.max < x {
            self.max = x;
        }
    }
    fn get(&self) -> F {
        self.max
    }
}

/// Running absolute max.
/// # Examples
/// ```
/// use online_statistics::maximum::AbsMax;
/// use online_statistics::stats::Univariate;
/// let mut running_abs_max: AbsMax<f64> = AbsMax::new();
/// for i in -17..10{
///     running_abs_max.update(i as f64);
/// }
/// assert_eq!(running_abs_max.get(), 17.0);
/// ```
///
#[derive(Default, Debug)]
pub struct AbsMax<F: Float + FromPrimitive + AddAssign + SubAssign> {
    abs_max: F,
}

impl<F: Float + FromPrimitive + AddAssign + SubAssign> AbsMax<F> {
    pub fn new() -> Self {
        Self {
            abs_max: F::from_f64(0.0).unwrap(),
        }
    }
}

impl<F: Float + FromPrimitive + AddAssign + SubAssign> Univariate<F> for AbsMax<F> {
    fn update(&mut self, x: F) {
        if self.abs_max < x.abs() {
            self.abs_max = x.abs();
        }
    }
    fn get(&self) -> F {
        self.abs_max
    }
}

/// Rolling max.
/// # Arguments
/// * `window_size` - Size of the rolling window.
/// # Examples
/// ```
/// use online_statistics::maximum::RollingMax;
/// use online_statistics::stats::Univariate;
/// let mut rolling_max: RollingMax<f64> = RollingMax::new(3);
/// for i in 1..10{
///     rolling_max.update(i as f64);
/// }
/// assert_eq!(rolling_max.get(), 9.0);
/// ```
///
#[derive(Serialize, Deserialize)]
pub struct RollingMax<F: Float + FromPrimitive + AddAssign + SubAssign> {
    sorted_window: SortedWindow<F>,
}

impl<F: Float + FromPrimitive + AddAssign + SubAssign> RollingMax<F> {
    pub fn new(window_size: usize) -> Self {
        Self {
            sorted_window: SortedWindow::new(window_size),
        }
    }
}

impl<F: Float + FromPrimitive + AddAssign + SubAssign> Univariate<F> for RollingMax<F> {
    fn update(&mut self, x: F) {
        self.sorted_window.push_back(x);
    }
    fn get(&self) -> F {
        self.sorted_window.back()
    }
}