bund_stdlib_analysis 0.2.0

Numeric and text analysis for BUND programming language
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

use anomaly_detection;
use rust_dynamic::value::Value;
use augurs::outlier::{MADDetector, DbscanDetector, OutlierDetector};
use easy_error::{Error, bail};

pub fn detect_anomalies(source: Vec<f64>, period: usize) -> Result<Vec<f64>, Error> {
    let mut src: Vec<f32> = Vec::new();
    let mut dst: Vec<f64> = Vec::new();
    for i in &source {
        src.push(*i as f32);
    }
    let _ = match anomaly_detection::AnomalyDetector::fit(&src, period) {
        Ok(res_ix) => {
            for ix in res_ix.anomalies() {
                dst.push(src[*ix].into());
            }
        }
        Err(err) => bail!("ANOMALY DETECTION returns error: {}", err),
    };
    Ok(dst)
}

pub fn detect_outliers(source1: Vec<f64>, source2: Vec<f64>, sensitivity: f64) -> Result<Value, Error> {
    let series: &[&[f64]] = &[
        source1.as_slice(),
        source2.as_slice(),
    ];
    let detector = match MADDetector::with_sensitivity(sensitivity) {
        Ok(detector) => detector,
        Err(err) => bail!("DETECT_OUTLIERS: detector create returns: {}", err),
    };
    let processed = match detector.preprocess(&series) {
        Ok(processed) => processed,
        Err(err) => bail!("DETECT_OUTLIERS: detector processor returns: {}", err),
    };
    let outliers = match detector.detect(&processed) {
        Ok(outliers) => outliers,
        Err(err) => bail!("DETECT_OUTLIERS: detector detector returns: {}", err),
    };
    let mut s = 0;
    let mut res = Value::dict();
    for r in outliers.series_results {
        let mut row  = Value::list();
        for i in r.outlier_intervals.intervals {
            let mut data_set = Value::list();
            let start = i.start;
            let end = match i.end {
                Some(end) => end,
                None => continue,
            };
            for v in &series[s][start..end] {
                data_set = data_set.push(Value::from_float(*v));
            }
            row = row.push(data_set);
        }
        res = res.set(format!("{}", s), row);
        s = s + 1
    }
    Ok(res)
}

pub fn detect_outliers_dbscan(source1: Vec<f64>, source2: Vec<f64>, sensitivity: f64) -> Result<Value, Error> {
    let series: &[&[f64]] = &[
        source1.as_slice(),
        source2.as_slice(),
    ];
    let detector = match DbscanDetector::with_sensitivity(sensitivity) {
        Ok(detector) => detector,
        Err(err) => bail!("DETECT_OUTLIERS: detector create returns: {}", err),
    };
    let processed = match detector.preprocess(&series) {
        Ok(processed) => processed,
        Err(err) => bail!("DETECT_OUTLIERS: detector processor returns: {}", err),
    };
    let outliers = match detector.detect(&processed) {
        Ok(outliers) => outliers,
        Err(err) => bail!("DETECT_OUTLIERS: detector detector returns: {}", err),
    };
    let mut s = 0;
    let mut res = Value::dict();
    for r in outliers.series_results {
        let mut row  = Value::list();
        for i in r.outlier_intervals.intervals {
            let mut data_set = Value::list();
            let start = i.start;
            let end = match i.end {
                Some(end) => end,
                None => continue,
            };
            for v in &series[s][start..end] {
                data_set = data_set.push(Value::from_float(*v));
            }
            row = row.push(data_set);
        }
        res = res.set(format!("{}", s), row);
        s = s + 1
    }
    Ok(res)
}