quantwave-core 0.6.0

A high-performance, Polars-native technical analysis library for Rust.
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

//! Native O(1) volume indicators: AD, ADOSC.

use crate::indicators::incremental::talib_ema::TalibEma;
use crate::traits::Next;

/// Accumulation/Distribution Line.
#[derive(Debug, Clone)]
#[allow(non_camel_case_types)]
pub struct AD {
    cumulative: f64,
}

impl AD {
    pub fn new() -> Self {
        Self { cumulative: 0.0 }
    }
}

impl Next<(f64, f64, f64, f64)> for AD {
    type Output = f64;

    fn next(&mut self, (high, low, close, volume): (f64, f64, f64, f64)) -> Self::Output {
        let hl = high - low;
        let mfm = if hl > 0.0 {
            ((close - low) - (high - close)) / hl
        } else {
            0.0
        };
        self.cumulative += mfm * volume;
        self.cumulative
    }
}

/// Chaikin A/D Oscillator.
#[derive(Debug, Clone)]
#[allow(non_camel_case_types)]
pub struct ADOSC {
    pub fastperiod: usize,
    pub slowperiod: usize,
    ad: AD,
    fast_ema: TalibEma,
    slow_ema: TalibEma,
}

impl ADOSC {
    pub fn new(fastperiod: usize, slowperiod: usize) -> Self {
        Self {
            fastperiod,
            slowperiod,
            ad: AD::new(),
            fast_ema: TalibEma::new(fastperiod),
            slow_ema: TalibEma::new(slowperiod),
        }
    }
}

impl Next<(f64, f64, f64, f64)> for ADOSC {
    type Output = f64;

    fn next(&mut self, ohlcv: (f64, f64, f64, f64)) -> Self::Output {
        let ad_val = self.ad.next(ohlcv);
        let fast = self.fast_ema.next(ad_val);
        let slow = self.slow_ema.next(ad_val);
        if fast.is_nan() || slow.is_nan() {
            f64::NAN
        } else {
            fast - slow
        }
    }
}

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

    proptest! {
        #[test]
        fn test_ad_parity(
            h in prop::collection::vec(10.0..100.0, 1..100),
            l in prop::collection::vec(10.0..100.0, 1..100),
            c in prop::collection::vec(10.0..100.0, 1..100),
            v in prop::collection::vec(1.0..1000.0, 1..100)
        ) {
            let len = h.len().min(l.len()).min(c.len()).min(v.len());
            let mut ad = AD::new();
            let mut high = Vec::with_capacity(len);
            let mut low = Vec::with_capacity(len);
            let mut close = Vec::with_capacity(len);
            let mut vol = Vec::with_capacity(len);
            for i in 0..len {
                let v_h: f64 = h[i];
                let v_l: f64 = l[i];
                let v_c: f64 = c[i];
                let v_v: f64 = v[i];
                high.push(v_h.max(v_l).max(v_c));
                low.push(v_h.min(v_l).min(v_c));
                close.push(v_c);
                vol.push(v_v);
            }
            let streaming: Vec<f64> = (0..len)
                .map(|i| ad.next((high[i], low[i], close[i], vol[i])))
                .collect();
            let batch = talib_rs::volume::ad(&high, &low, &close, &vol)
                .unwrap_or_else(|_| vec![f64::NAN; len]);
            for (s, b) in streaming.iter().zip(batch.iter()) {
                if s.is_nan() { assert!(b.is_nan()); }
                else { approx::assert_relative_eq!(s, b, epsilon = 1e-6); }
            }
        }
    }
}