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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Native streaming CCI — TA-Lib parity (`talib_rs::momentum::cci`).
//!
//! O(1) sliding sum for typical price SMA; O(period) mean deviation per bar (same as talib-rs).

use crate::traits::Next;

#[inline]
fn cci_value(tp: f64, average: f64, circ_buf: &[f64], timeperiod: usize) -> f64 {
    let tp_f = timeperiod as f64;
    let mut mean_dev_sum = 0.0_f64;
    for j in 0..timeperiod {
        mean_dev_sum += (circ_buf[j] - average).abs();
    }
    let mean_dev = mean_dev_sum / tp_f;
    if mean_dev > 0.0 {
        (tp - average) / (0.015 * mean_dev)
    } else {
        0.0
    }
}

/// Commodity Channel Index — input `(high, low, close)`.
#[derive(Debug, Clone)]
#[allow(non_camel_case_types)]
pub struct CCI {
    pub timeperiod: usize,
    circ_buf: Vec<f64>,
    circ_idx: usize,
    running_sum: f64,
    bars_seen: usize,
}

impl CCI {
    pub fn new(timeperiod: usize) -> Self {
        Self {
            timeperiod,
            circ_buf: vec![0.0; timeperiod.max(1)],
            circ_idx: 0,
            running_sum: 0.0,
            bars_seen: 0,
        }
    }
}

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

    fn next(&mut self, (high, low, close): (f64, f64, f64)) -> Self::Output {
        let timeperiod = self.timeperiod;
        if timeperiod < 2 {
            return f64::NAN;
        }
        let lookback = timeperiod - 1;
        let tp = (high + low + close) / 3.0;
        self.bars_seen += 1;
        let i = self.bars_seen - 1;

        if i < timeperiod {
            self.circ_buf[i] = tp;
            self.running_sum += tp;
            if i < lookback {
                return f64::NAN;
            }
            let last_value = self.circ_buf[lookback];
            let the_average = self.running_sum / timeperiod as f64;
            return cci_value(last_value, the_average, &self.circ_buf[..timeperiod], timeperiod);
        }

        let new_tp = tp;
        self.running_sum += new_tp - self.circ_buf[self.circ_idx];
        self.circ_buf[self.circ_idx] = new_tp;
        let the_average = self.running_sum / timeperiod as f64;
        let out = cci_value(new_tp, the_average, &self.circ_buf[..timeperiod], timeperiod);
        self.circ_idx += 1;
        if self.circ_idx >= timeperiod {
            self.circ_idx = 0;
        }
        out
    }
}

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

    fn ordered_hlc(
        h: &[f64],
        l: &[f64],
        c: &[f64],
    ) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
        let len = h.len().min(l.len()).min(c.len());
        let mut high = Vec::with_capacity(len);
        let mut low = Vec::with_capacity(len);
        let mut close = Vec::with_capacity(len);
        for i in 0..len {
            let vh = h[i];
            let vl = l[i];
            let vc = c[i];
            high.push(vh.max(vl).max(vc));
            low.push(vh.min(vl).min(vc));
            close.push(vc);
        }
        (high, low, close)
    }

    proptest! {
        #[test]
        fn test_cci_parity(
            h in prop::collection::vec(1.0..100.0, 10..100),
            l in prop::collection::vec(1.0..100.0, 10..100),
            c in prop::collection::vec(1.0..100.0, 10..100),
        ) {
            let (high, low, close) = ordered_hlc(&h, &l, &c);
            let len = high.len();
            if len == 0 { return Ok(()); }
            let period = 14;
            let mut cci = CCI::new(period);
            let streaming: Vec<f64> =
                (0..len).map(|i| cci.next((high[i], low[i], close[i]))).collect();
            let batch = talib_rs::momentum::cci(&high, &low, &close, period)
                .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 if !b.is_nan() {
                    approx::assert_relative_eq!(s, b, epsilon = 1e-6);
                }
            }
        }
    }
}