mathbox 0.2.0

A math toolbox
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

use crate::stats::estimator::{mean, std};

/// The simplist method to detect the outliers from a signal.
pub fn iqr_outlier<X: Into<f64> + Copy, Y: Into<f64> + Copy>(
    signal: &[X],
    iqr_factor: Y,
) -> (Vec<usize>, Vec<usize>) {
    let mut outlier_lo = vec![];
    let mut outlier_hi = vec![];
    let mut sorted = signal.iter().map(|&x| x.into()).collect::<Vec<f64>>(); //signal.to_vec();
    sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());
    let q1 = sorted[(sorted.len() as f64 * 0.25) as usize];
    let q3 = sorted[(sorted.len() as f64 * 0.75) as usize];
    let iqr = q3 - q1;
    for (i, &item) in signal.iter().enumerate() {
        if item.into() < q1 - iqr_factor.into() * iqr {
            outlier_lo.push(i);
        }
        if item.into() > q3 + iqr_factor.into() * iqr {
            outlier_hi.push(i);
        }
    }
    (outlier_lo, outlier_hi)
}

/// Detect the outliers from a signal. The signal should be normal distributed. So it's better to decompose the signal first. 
///
/// # Examples
///
/// ```
/// use mathbox::app::signal::outlier::normal_outlier;
/// let signal: Vec<i32> = vec![-100000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100000000];
/// let (lower, upper) = normal_outlier(&signal, 3);
/// assert_eq!(lower, [0]);
/// assert_eq!(upper, [21]);
/// ```
pub fn normal_outlier<X: Into<f64> + Copy, Y: Into<f64> + Copy>(
    normal: &[X],
    std_factor: Y,
) -> (Vec<usize>, Vec<usize>) {
    let mut outlier_lo = vec![];
    let mut outlier_hi = vec![];
    let mean = mean(normal);
    let std = std(normal, false);
    for (i, &item) in normal.iter().enumerate() {
        if item.into() > mean + std_factor.into() * std {
            outlier_hi.push(i);
        } else if item.into() < mean - std_factor.into() * std {
            outlier_lo.push(i);
        }
    }
    (outlier_lo, outlier_hi)
}

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

    #[test]
    fn test_iqr_outlier() {
        let signal = vec![
            1.0, 20000.0, 20000.0, 20000.0, 20000.0, 20000.0, 20000.0, 20000.0, 20000.0, 20000.0,
            20000.0, 1000000.,
        ];
        let (lower, upper) = iqr_outlier(&signal, 1.5);
        assert_eq!(lower, [0]);
        assert_eq!(upper, [11]);
        let signal =
            vec![1, 20000, 20000, 20000, 20000, 20000, 20000, 20000, 20000, 20000, 20000, 1000000];
        let (lower, upper) = iqr_outlier(&signal, 3);
        assert_eq!(lower, [0]);
        assert_eq!(upper, [11]);
    }

    #[test]
    fn test_normal_outlier() {
        let signal = vec![
            -100000000000.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.0,
            100000000000.,
        ];
        let (lower, upper) = normal_outlier(&signal, 3.);
        assert_eq!(lower, [0]);
        assert_eq!(upper, [21]);
        let signal: Vec<i32> =
            vec![-100000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100000000];
        let (lower, upper) = normal_outlier(&signal, 3);
        assert_eq!(lower, [0]);
        assert_eq!(upper, [21]);
    }
}