incr_stats 1.0.2

Fast, scalable, incremental descriptive statistics in Rust
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

use crate::batch;
use crate::chk;
use crate::incr;
use crate::vec;

// Check that the incremental and batch functions return identical results.
fn check_incr_v_batch(d: &incr::Stats, a: &[f64]) {
    chk!(batch::count(&a), d.count());
    chk!(batch::min(&a), d.min());
    chk!(batch::max(&a), d.max());
    chk!(batch::sum(&a), d.sum());
    chk!(batch::mean(&a), d.mean());
    chk!(batch::population_variance(&a), d.population_variance());
    chk!(batch::sample_variance(&a), d.sample_variance());
    chk!(
        batch::population_standard_deviation(&a),
        d.population_standard_deviation()
    );
    chk!(
        batch::sample_standard_deviation(&a),
        d.sample_standard_deviation()
    );
    chk!(batch::population_skewness(&a), d.population_skewness());
    chk!(batch::sample_skewness(&a), d.sample_skewness());
    chk!(batch::population_kurtosis(&a), d.population_kurtosis());
    chk!(batch::sample_kurtosis(&a), d.sample_kurtosis());
}

// Check that the incremental and vec_stats functions return identical results.
fn check_incr_v_vec(s: &incr::Stats, d: &mut vec::Stats) {
    chk!(s.count(), d.count());
    chk!(s.min(), d.min());
    chk!(s.max(), d.max());
    chk!(s.sum(), d.sum());
    chk!(s.mean(), d.mean());
    chk!(s.population_variance(), d.population_variance());
    chk!(s.sample_variance(), d.sample_variance());
    chk!(
        s.population_standard_deviation(),
        d.population_standard_deviation()
    );
    chk!(s.sample_standard_deviation(), d.sample_standard_deviation());
    chk!(s.population_skewness(), d.population_skewness());
    chk!(s.sample_skewness(), d.sample_skewness());
    chk!(s.population_kurtosis(), d.population_kurtosis());
    chk!(s.sample_kurtosis(), d.sample_kurtosis());
}

// Calculate statistics with empty data.
#[test]
fn test_incr_vs_batch_update_empty() {
    let inc_stats = incr::Stats::new();
    let mut emp = vec![];
    let mut vec_stats = vec::Stats::new(&mut emp).unwrap();
    check_incr_v_batch(&inc_stats, &vec![]);
    check_incr_v_vec(&inc_stats, &mut vec_stats);
}

#[test]
// Calculate statistics with 0 to 10 values.
fn test_incr_vs_batch_update_10_slices() {
    let a = vec![
        1.0, -2.0, 13.0, 47.0, 115.0, -0.03, -123.4, 23.0, -23.04, 12.3,
    ];
    // Confirm the incremental and batch versions match for all slices of a.
    for i in 0..a.len() {
        let mut inc_stats = incr::Stats::new();
        a[..i].iter().for_each(|v| inc_stats.update(*v).unwrap());
        let mut vec_stats = vec::Stats::new(&a[..i]).unwrap();
        check_incr_v_batch(&inc_stats, &a[..i]);
        check_incr_v_vec(&inc_stats, &mut vec_stats);
    }
}

// Calculate statistics with 0 to 10 zeros.
#[test]
fn test_incr_vs_batch_update_for_zeros() {
    let a = vec![0.0; 10];
    // Confirm the incremental and batch versions match for all slices of a.
    for i in 0..a.len() {
        let mut inc_stats = incr::Stats::new();
        a[..i].iter().for_each(|v| inc_stats.update(*v).unwrap());
        let mut vec_stats = vec::Stats::new(&a[..i]).unwrap();
        check_incr_v_batch(&inc_stats, &a[..i]);
        check_incr_v_vec(&inc_stats, &mut vec_stats);
    }
}

// Calculate statistics with 0 to 10 ones.
#[test]
fn test_incr_vs_batch_update_for_ones() {
    let a = vec![1.0; 10];
    // Confirm the incremental and batch versions match for all slices of a.
    for i in 0..a.len() {
        let mut inc_stats = incr::Stats::new();
        a[..i].iter().for_each(|v| inc_stats.update(*v).unwrap());
        let mut vec_stats = vec::Stats::new(&a[..i]).unwrap();
        check_incr_v_batch(&inc_stats, &a[..i]);
        check_incr_v_vec(&inc_stats, &mut vec_stats);
    }
}