mylittleindicators 0.1.2

Multi-stream financial indicators library — 559 bar indicators + 21 event primitives across 35 categories. Consumes OHLCV bars, ticks, orderbook (snapshot/delta), funding, mark price, open interest, liquidations, ticker, agg trades, and 12+ extended stream types from digdigdig3 exchange connectors.
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

// Rolling window (ring buffer) version of Efficiency Ratio
// Fast, memory efficient, classic ER

use crate::bar_indicators::indicator_value::IndicatorValue;
#[derive(Debug, Clone)]
pub struct EfficiencyRatioRingWindow {
    pub period: usize,
    buf: Vec<f64>,
    deltas: Vec<f64>,
    head: usize,
    len: usize,
    value: f64,
    initialized: bool,
}

impl EfficiencyRatioRingWindow {
    pub fn new(period: usize) -> Self {
        assert!(period > 1);
        Self {
            period,
            buf: vec![0.0; period],
            deltas: vec![0.0; period - 1],
            head: 0,
            len: 0,
            value: 0.0,
            initialized: false,
        }
    }

    pub fn update_raw(&mut self, value: f64) -> f64 {
        let idx = (self.head + self.len) % self.period;
        if self.len < self.period {
            self.buf[idx] = value;
            self.len += 1;
            if self.len == 1 {
                self.value = 0.0;
                self.initialized = false;
                return self.value;
            }
        } else {
            self.buf[self.head] = value;
            self.head = (self.head + 1) % self.period;
        }
        // Compute deltas for the current window
        for i in 0..(self.len.min(self.period) - 1) {
            let idx0 = (self.head + i) % self.period;
            let idx1 = (self.head + i + 1) % self.period;
            self.deltas[i] = (self.buf[idx1] - self.buf[idx0]).abs();
        }
        self.initialized = self.len >= self.period;
        let net_diff = (self.buf[(self.head + self.len - 1) % self.period] - self.buf[self.head]).abs();
        let sum_deltas: f64 = self.deltas[..self.len.min(self.period) - 1].iter().sum();
        self.value = if sum_deltas == 0.0 { 0.0 } else { net_diff / sum_deltas };
        self.value
    }

    pub fn value(&self) -> IndicatorValue {
        IndicatorValue::Single(self.value)
    }
    pub fn is_initialized(&self) -> bool {
        self.initialized
    }
    pub fn get_buf(&self) -> Vec<f64> {
        let mut out = Vec::with_capacity(self.len);
        for i in 0..self.len {
            let idx = (self.head + i) % self.period;
            out.push(self.buf[idx]);
        }
        out
    }
    pub fn get_deltas(&self) -> Vec<f64> {
        let mut out = Vec::with_capacity(self.len.saturating_sub(1));
        for i in 0..self.len.saturating_sub(1) {
            out.push(self.deltas[i]);
        }
        out
    }
    pub fn reset(&mut self) {
        for v in &mut self.buf { *v = 0.0; }
        for d in &mut self.deltas { *d = 0.0; }
        self.head = 0;
        self.len = 0;
        self.value = 0.0;
        self.initialized = false;
    }

    #[inline]
    pub fn is_ready(&self) -> bool {
        self.initialized
    }
}

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

    #[test]
    fn test_efficiency_ratio_ring_creation() {
        let ind = EfficiencyRatioRingWindow::new(10);
        assert!(!ind.is_ready());
        assert_eq!(ind.value().main(), 0.0);
    }

    #[test]
    fn test_efficiency_ratio_ring_warmup() {
        let mut ind = EfficiencyRatioRingWindow::new(10);
        for i in 0..15 {
            let price = 100.0 + i as f64;
            ind.update_raw(price);
        }
        assert!(ind.is_ready());
    }

    #[test]
    fn test_efficiency_ratio_ring_values() {
        let mut ind = EfficiencyRatioRingWindow::new(10);
        for i in 0..20 {
            let price = 100.0 + i as f64;
            ind.update_raw(price);
        }
        assert!(ind.value().main().is_finite());
        assert!(ind.value().main() >= 0.0);
    }

    #[test]
    fn test_efficiency_ratio_ring_reset() {
        let mut ind = EfficiencyRatioRingWindow::new(10);
        for i in 0..15 {
            let price = 100.0 + i as f64;
            ind.update_raw(price);
        }
        ind.reset();
        assert!(!ind.is_ready());
        assert_eq!(ind.value().main(), 0.0);
    }
}