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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

extern crate log;
use easy_error::{bail, Error};

use bundcore::{common, common_get_data};
use rust_dynamic::value::Value;
use rust_multistackvm::multistackvm::{VM, StackOps};

use crate::{anomalies, breakout};

#[derive(Debug, Clone)]
pub enum OutliersMode {
    MAD,
    DBSCAN,
}

pub fn analysis_anomalies(vm: &mut VM) -> std::result::Result<&mut VM, Error> {
    if vm.stack.current_stack_len() < 2 {
        bail!("Stack is too shallow for inline ANALYSIS.ANOMALIES");
    }

    let period_value = match vm.stack.pull() {
        Some(period_value) => period_value,
        None => bail!("ANOMALIES: error getting period"),
    };

    let period = match period_value.cast_int() {
        Ok(period) => period,
        Err(err) => {
            bail!("analysis.anomalies returned for #1: {}", err);
        }
    };

    let data = match common_get_data::get_data(vm, StackOps::FromStack, common::SourceMode::Consume, "ANALYSIS.ANOMALIES".to_string()) {
        Ok(data) => data,
        Err(err) => {
            bail!("ANOMALIES: error getting data: {}", err);
        }
    };

    if data.len() == 0 {
        bail!("ANOMALIES: NO DATA for analysis");
    }

    let anomalies_data = match anomalies::detect_anomalies(data, period as usize) {
        Ok(anomalies_data) => anomalies_data,
        Err(err) => bail!("{}", err),
    };

    let mut res = Value::list();
    for n in anomalies_data.iter() {
        res = res.push(Value::from_float(*n as f64));
    }
    vm.stack.push(res);
    Ok(vm)
}

pub fn analysis_outliers_generic(vm: &mut VM, op: OutliersMode) -> std::result::Result<&mut VM, Error> {
    if vm.stack.current_stack_len() < 3 {
        bail!("Stack is too shallow for inline ANALYSIS.OUTLIERS");
    }

    let sensitivity_value = match vm.stack.pull() {
        Some(period_value) => period_value,
        None => bail!("OUTLIERS: error getting sensitivity"),
    };

    let sensitivity = match sensitivity_value.cast_float() {
        Ok(period) => period,
        Err(err) => {
            bail!("analysis.outliers returned for #1: {}", err);
        }
    };

    let data1 = match common_get_data::get_data(vm, StackOps::FromStack, common::SourceMode::Consume, "ANALYSIS.OUTLIERS".to_string()) {
        Ok(data) => data,
        Err(err) => {
            bail!("OUTLIERS: error getting data #1: {}", err);
        }
    };

    if data1.len() == 0 {
        bail!("OUTLIERS: NO DATA #1 for analysis");
    }

    let data2 = match common_get_data::get_data(vm, StackOps::FromStack, common::SourceMode::Consume, "ANALYSIS.OUTLIERS".to_string()) {
        Ok(data) => data,
        Err(err) => {
            bail!("OUTLIERS: error getting data #2: {}", err);
        }
    };

    if data2.len() == 0 {
        bail!("OUTLIERS: NO DATA #2 for analysis");
    }

    match op {
        OutliersMode::MAD => {
            let outliers_data = match anomalies::detect_outliers(data1, data2, sensitivity) {
                Ok(outliers_data) => outliers_data,
                Err(err) => bail!("{}", err),
            };
            vm.stack.push(outliers_data);
        }
        OutliersMode::DBSCAN => {
            let outliers_data = match anomalies::detect_outliers_dbscan(data1, data2, sensitivity) {
                Ok(outliers_data) => outliers_data,
                Err(err) => bail!("{}", err),
            };
            vm.stack.push(outliers_data);
        }
    }
    Ok(vm)
}

pub fn analysis_outliers(vm: &mut VM) -> std::result::Result<&mut VM, Error> {
    analysis_outliers_generic(vm, OutliersMode::MAD)
}

pub fn analysis_outliers_dbscan(vm: &mut VM) -> std::result::Result<&mut VM, Error> {
    analysis_outliers_generic(vm, OutliersMode::DBSCAN)
}

pub fn analysis_breakouts(vm: &mut VM) -> std::result::Result<&mut VM, Error> {
    if vm.stack.current_stack_len() < 2 {
        bail!("Stack is too shallow for inline ANALYSIS.BREAKOUTS");
    }

    let ms_value = match vm.stack.pull() {
        Some(ms_value) => ms_value,
        None => bail!("ANOMALIES: error getting min-size"),
    };

    let ms = match ms_value.cast_int() {
        Ok(ms) => ms,
        Err(err) => {
            bail!("analysis.breakouts returned for #1: {}", err);
        }
    };

    let data = match common_get_data::get_data(vm, StackOps::FromStack, common::SourceMode::Consume, "ANALYSIS.BREAKOUTS".to_string()) {
        Ok(data) => data,
        Err(err) => {
            bail!("ANOMALIES: error getting data: {}", err);
        }
    };

    if data.len() == 0 {
        bail!("ANOMALIES: NO DATA for analysis");
    }

    let breakouts_data = match breakout::detect_breakouts(data, ms as usize) {
        Ok(breakouts_data) => breakouts_data,
        Err(err) => bail!("{}", err),
    };
    let mut res = Value::list();
    for n in breakouts_data.iter() {
        res = res.push(Value::from_float(*n as f64));
    }
    vm.stack.push(res);
    Ok(vm)
}