compute 0.2.3

A crate for statistical computing.
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

use crate::statistics::mean;

/// Calculates the covariance between two vectors x and y. This is a two-pass algorithm which
/// centers the data before computing the covariance, which improves stability but does not
/// change the result as covariance is invariant with respect to shifts.
pub fn covariance(x: &[f64], y: &[f64]) -> f64 {
    assert_eq!(x.len(), y.len());
    let mean_x = mean(x);
    let mean_y = mean(y);
    let n = x.len();

    (0..n)
        .into_iter()
        .map(|i| (x[i] - mean_x) * (y[i] - mean_y))
        .sum::<f64>()
        / n as f64
}
///
/// Calculates the sample covariance between two vectors x and y. This is a two-pass algorithm which
/// centers the data before computing the covariance, which improves stability but does not
/// change the result as covariance is invariant with respect to shifts.
pub fn sample_covariance(x: &[f64], y: &[f64]) -> f64 {
    assert_eq!(x.len(), y.len());
    let mean_x = mean(x);
    let mean_y = mean(y);
    let n = x.len();

    (0..n)
        .into_iter()
        .map(|i| (x[i] - mean_x) * (y[i] - mean_y))
        .sum::<f64>()
        / (n - 1) as f64
}

/// Calculates the covariance between two vectors x and y. This is a one-pass algorithm which
/// shifts the data by the first element in each vector before computing the covariance,
/// which improves stability but does not change the result as covariance is invariant with respect to shifts.
pub fn sample_covariance_onepass(x: &[f64], y: &[f64]) -> f64 {
    assert_eq!(x.len(), y.len());
    let n = x.len();
    (0..n)
        .into_iter()
        .map(|i| (x[i] - x[0]) * (y[i] - y[0]))
        .sum::<f64>()
        / (n - 1) as f64
}

/// Calculates the covariance between two vectors x and y. This is a stable one-pass online algorithm.
/// See <https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Covariance>
pub fn sample_covariance_online(x: &[f64], y: &[f64]) -> f64 {
    assert_eq!(x.len(), y.len());
    let mut meanx = 0.;
    let mut meany = 0.;
    let mut c = 0.;
    let mut n = 0.;

    for (i, j) in x.iter().zip(y.iter()) {
        n += 1.;
        let dx = i - meanx;
        let dy = j - meany;
        meanx += dx / n;
        meany += dy / n;
        c += dx * dy;
    }

    c / n
}

#[cfg(test)]
mod tests {
    use super::*;
    use approx_eq::assert_approx_eq;

    #[test]
    fn test_covariance() {
        let x1: Vec<f64> = vec![-2.1, -1., 4.3];
        let y1: Vec<f64> = vec![3., 1.1, 0.12];
        assert_approx_eq!(covariance(&x1, &y1), -2.8573333);
        assert_approx_eq!(sample_covariance(&x1, &y1), -4.286);

        let x2: Vec<f64> = vec![1.1, 1.7, 2.1, 1.4, 0.2];
        let y2: Vec<f64> = vec![3.0, 4.2, 4.9, 4.1, 2.5];
        assert_approx_eq!(covariance(&x2, &y2), 0.532);
        assert_approx_eq!(sample_covariance(&x2, &y2), 0.665);
    }
}