quantwave_core/indicators/incremental/
stoch.rs

1//! Native O(1) Stochastic family — TA-Lib parity (STOCH, STOCHF, STOCHRSI).
2
3use crate::indicators::incremental::ma_stream::MaStream;
4use crate::indicators::incremental::rsi::RSI;
5use crate::traits::Next;
6use crate::utils::RingBuffer;
7use talib_rs::MaType;
8
9/// Rolling highest high / lowest low over `period` bars.
10#[derive(Debug, Clone)]
11struct HlWindow {
12    highs: RingBuffer<f64>,
13    lows: RingBuffer<f64>,
14    period: usize,
15}
16
17impl HlWindow {
18    fn new(period: usize) -> Self {
19        Self {
20            highs: RingBuffer::with_capacity(period),
21            lows: RingBuffer::with_capacity(period),
22            period,
23        }
24    }
25
26    fn push(&mut self, high: f64, low: f64) -> Option<(f64, f64, f64)> {
27        if self.highs.len() >= self.period {
28            let _ = self.highs.pop_front();
29            let _ = self.lows.pop_front();
30        }
31        self.highs.push_back(high);
32        self.lows.push_back(low);
33        if self.highs.len() < self.period {
34            return None;
35        }
36        let mut hh = f64::NEG_INFINITY;
37        let mut ll = f64::INFINITY;
38        for (&h, &l) in self.highs.iter().zip(self.lows.iter()) {
39            if h > hh {
40                hh = h;
41            }
42            if l < ll {
43                ll = l;
44            }
45        }
46        let range = hh - ll;
47        Some((hh, ll, range))
48    }
49}
50
51fn fastk_from_hlc(close: f64, ll: f64, range: f64) -> f64 {
52    if range > 0.0 {
53        100.0 * (close - ll) / range
54    } else {
55        50.0
56    }
57}
58
59/// Stochastic Oscillator (STOCH) — default SMA smoothing on %K and %D.
60#[derive(Debug, Clone)]
61#[allow(non_camel_case_types)]
62pub struct STOCH {
63    pub fastk_period: usize,
64    pub slowk_period: usize,
65    pub slowk_matype: MaType,
66    pub slowd_period: usize,
67    pub slowd_matype: MaType,
68    hl: HlWindow,
69    slowk_ma: MaStream,
70    slowd_ma: MaStream,
71    slowk_valid: Vec<f64>,
72    bar_index: usize,
73    out_start: usize,
74}
75
76impl STOCH {
77    pub fn new(
78        fastk_period: usize,
79        slowk_period: usize,
80        slowk_matype: MaType,
81        slowd_period: usize,
82        slowd_matype: MaType,
83    ) -> Self {
84        Self {
85            fastk_period,
86            slowk_period,
87            slowk_matype,
88            slowd_period,
89            slowd_matype,
90            hl: HlWindow::new(fastk_period),
91            slowk_ma: MaStream::new(slowk_period, slowk_matype),
92            slowd_ma: MaStream::new(slowd_period, slowd_matype),
93            slowk_valid: Vec::new(),
94            bar_index: 0,
95            out_start: fastk_period - 1 + slowk_period - 1 + slowd_period - 1,
96        }
97    }
98}
99
100impl Next<(f64, f64, f64)> for STOCH {
101    type Output = (f64, f64);
102
103    fn next(&mut self, (high, low, close): (f64, f64, f64)) -> Self::Output {
104        let i = self.bar_index;
105        self.bar_index += 1;
106
107        let Some((_, ll, range)) = self.hl.push(high, low) else {
108            return (f64::NAN, f64::NAN);
109        };
110        let fastk = fastk_from_hlc(close, ll, range);
111        let slowk_raw = self.slowk_ma.next(fastk);
112        if !slowk_raw.is_nan() {
113            self.slowk_valid.push(slowk_raw);
114        }
115        let slowd_raw = if slowk_raw.is_nan() {
116            f64::NAN
117        } else {
118            self.slowd_ma.next(slowk_raw)
119        };
120
121        if i < self.out_start {
122            return (f64::NAN, f64::NAN);
123        }
124
125        let k_skip = self.slowd_period - 1;
126        let j = i - self.out_start;
127        let idx = k_skip + j;
128        let slowk_out = self.slowk_valid.get(idx).copied().unwrap_or(f64::NAN);
129        let slowd_out = if slowd_raw.is_nan() {
130            f64::NAN
131        } else {
132            slowd_raw
133        };
134
135        (slowk_out, slowd_out)
136    }
137}
138
139/// Fast Stochastic (STOCHF).
140#[derive(Debug, Clone)]
141#[allow(non_camel_case_types)]
142pub struct STOCHF {
143    pub fastk_period: usize,
144    pub fastd_period: usize,
145    pub fastd_matype: MaType,
146    hl: HlWindow,
147    fastd_ma: MaStream,
148    fastk_values: Vec<f64>,
149    bar_index: usize,
150    out_start: usize,
151}
152
153impl STOCHF {
154    pub fn new(fastk_period: usize, fastd_period: usize, fastd_matype: MaType) -> Self {
155        Self {
156            fastk_period,
157            fastd_period,
158            fastd_matype,
159            hl: HlWindow::new(fastk_period),
160            fastd_ma: MaStream::new(fastd_period, fastd_matype),
161            fastk_values: Vec::new(),
162            bar_index: 0,
163            out_start: fastk_period - 1 + fastd_period - 1,
164        }
165    }
166}
167
168impl Next<(f64, f64, f64)> for STOCHF {
169    type Output = (f64, f64);
170
171    fn next(&mut self, (high, low, close): (f64, f64, f64)) -> Self::Output {
172        let i = self.bar_index;
173        self.bar_index += 1;
174
175        let Some((_, ll, range)) = self.hl.push(high, low) else {
176            return (f64::NAN, f64::NAN);
177        };
178        let fastk = fastk_from_hlc(close, ll, range);
179        self.fastk_values.push(fastk);
180
181        let fastd_raw = self.fastd_ma.next(fastk);
182
183        if i < self.out_start {
184            return (f64::NAN, f64::NAN);
185        }
186
187        let k_skip = self.fastd_period - 1;
188        let j = i - self.out_start;
189        let idx = k_skip + j;
190        let fastk_out = self.fastk_values.get(idx).copied().unwrap_or(f64::NAN);
191        let fastd_out = if fastd_raw.is_nan() {
192            f64::NAN
193        } else {
194            fastd_raw
195        };
196
197        (fastk_out, fastd_out)
198    }
199}
200
201/// Stochastic RSI (STOCHRSI).
202#[derive(Debug, Clone)]
203#[allow(non_camel_case_types)]
204pub struct STOCHRSI {
205    pub timeperiod: usize,
206    pub fastk_period: usize,
207    pub fastd_period: usize,
208    pub fastd_matype: MaType,
209    rsi: RSI,
210    rsi_valid: Vec<f64>,
211    fastd_ma: MaStream,
212    fastk_values: Vec<f64>,
213    bar_index: usize,
214    d_start: usize,
215}
216
217impl STOCHRSI {
218    pub fn new(
219        timeperiod: usize,
220        fastk_period: usize,
221        fastd_period: usize,
222        fastd_matype: MaType,
223    ) -> Self {
224        let d_start = timeperiod + fastk_period - 1 + fastd_period - 1;
225        Self {
226            timeperiod,
227            fastk_period,
228            fastd_period,
229            fastd_matype,
230            rsi: RSI::new(timeperiod),
231            rsi_valid: Vec::new(),
232            fastd_ma: MaStream::new(fastd_period, fastd_matype),
233            fastk_values: Vec::new(),
234            bar_index: 0,
235            d_start,
236        }
237    }
238}
239
240impl Next<f64> for STOCHRSI {
241    type Output = (f64, f64);
242
243    fn next(&mut self, input: f64) -> Self::Output {
244        let i = self.bar_index;
245        self.bar_index += 1;
246
247        let rsi_v = self.rsi.next(input);
248        if !rsi_v.is_nan() {
249            self.rsi_valid.push(rsi_v);
250        }
251
252        if self.rsi_valid.len() < self.fastk_period {
253            return (f64::NAN, f64::NAN);
254        }
255
256        let idx = self.rsi_valid.len() - 1;
257        let start = idx + 1 - self.fastk_period;
258        let mut hh = f64::NEG_INFINITY;
259        let mut ll = f64::INFINITY;
260        for j in start..=idx {
261            let v = self.rsi_valid[j];
262            if v > hh {
263                hh = v;
264            }
265            if v < ll {
266                ll = v;
267            }
268        }
269        let range = hh - ll;
270        let fastk = if range > 0.0 {
271            100.0 * (self.rsi_valid[idx] - ll) / range
272        } else {
273            50.0
274        };
275        self.fastk_values.push(fastk);
276
277        let fastd_raw = self.fastd_ma.next(fastk);
278
279        if i < self.d_start {
280            return (f64::NAN, f64::NAN);
281        }
282
283        let k_skip = self.fastd_period - 1;
284        let j = i - self.d_start;
285        let idx = k_skip + j;
286        let fastk_out = self.fastk_values.get(idx).copied().unwrap_or(f64::NAN);
287        let fastd_out = if fastd_raw.is_nan() {
288            f64::NAN
289        } else {
290            fastd_raw
291        };
292
293        (fastk_out, fastd_out)
294    }
295}
296
297#[cfg(test)]
298mod tests {
299    use super::*;
300    use proptest::prelude::*;
301
302    proptest! {
303        #[test]
304        fn test_stoch_parity(
305            highs in prop::collection::vec(1.0..100.0, 1..100),
306            lows in prop::collection::vec(1.0..100.0, 1..100),
307            closes in prop::collection::vec(1.0..100.0, 1..100)
308        ) {
309            let len = highs.len().min(lows.len()).min(closes.len());
310            if len < 20 { return Ok(()); }
311            let mut high = Vec::with_capacity(len);
312            let mut low = Vec::with_capacity(len);
313            let mut close = Vec::with_capacity(len);
314            for i in 0..len {
315                let val_h: f64 = highs[i];
316                let val_l: f64 = lows[i];
317                let val_c: f64 = closes[i];
318                high.push(val_h.max(val_l).max(val_c));
319                low.push(val_h.min(val_l).min(val_c));
320                close.push(val_c);
321            }
322
323            let fastk = 5;
324            let slowk = 3;
325            let slowk_ma = MaType::Sma;
326            let slowd = 3;
327            let slowd_ma = MaType::Sma;
328
329            let mut stoch = STOCH::new(fastk, slowk, slowk_ma, slowd, slowd_ma);
330            let streaming: Vec<(f64, f64)> = (0..len)
331                .map(|i| stoch.next((high[i], low[i], close[i])))
332                .collect();
333            let (b_k, b_d) = talib_rs::momentum::stoch(
334                &high, &low, &close, fastk, slowk, slowk_ma, slowd, slowd_ma,
335            )
336            .unwrap_or_else(|_| (vec![f64::NAN; len], vec![f64::NAN; len]));
337
338            for (i, (s_k, s_d)) in streaming.into_iter().enumerate() {
339                if s_k.is_nan() { assert!(b_k[i].is_nan()); }
340                else { approx::assert_relative_eq!(s_k, b_k[i], epsilon = 1e-6); }
341                if s_d.is_nan() { assert!(b_d[i].is_nan()); }
342                else { approx::assert_relative_eq!(s_d, b_d[i], epsilon = 1e-6); }
343            }
344        }
345    }
346}
quantwave_core/indicators/incremental/stoch.rs

quantwave_core/indicators/incremental/
stoch.rs
