indicators/signal/
engine.rs

1//! Core Indicators Engine — Layers 1–4, 9–11.
2//!
3//! Faithful port of the Python `Indicators` class from `indicators.py`.
4//!
5//! Layers:
6//! - **L1** VWAP (daily reset)
7//! - **L2** EMA (configurable period)
8//! - **L3** ML SuperTrend — KMeans-adaptive ATR multiplier
9//! - **L4** Trend Speed — dynamic EMA + RMA wave tracking + HMA
10//! - **L9** Awesome Oscillator + wave/momentum percentile gates
11//! - **L10** Hurst exponent (R/S analysis, recomputed every 10 bars)
12//! - **L11** Price acceleration (2nd derivative, normalised)
13
14use std::collections::{HashMap, VecDeque};
15
16use chrono::{NaiveDate, TimeZone, Utc};
17
18// Safely importing from your unified config file
19use crate::error::IndicatorError;
20use crate::indicator::{Indicator, IndicatorOutput};
21use crate::indicator_config::IndicatorConfig;
22use crate::registry::param_usize;
23use crate::signal::vol_regime::PercentileTracker;
24use crate::types::Candle;
25
26// ── Indicator wrapper ─────────────────────────────────────────────────────────
27
28/// Batch `Indicator` adapter for [`Indicators`].
29///
30/// Replays candles through the full engine (L1–L4, L9–L11) and emits per-bar
31/// columns for every published field.
32#[derive(Debug, Clone)]
33pub struct EngineIndicator {
34    pub config: IndicatorConfig,
35}
36
37impl EngineIndicator {
38    pub fn new(config: IndicatorConfig) -> Self {
39        Self { config }
40    }
41    pub fn with_defaults() -> Self {
42        Self::new(IndicatorConfig::default())
43    }
44}
45
46impl Indicator for EngineIndicator {
47    fn name(&self) -> &'static str {
48        "Engine"
49    }
50    fn required_len(&self) -> usize {
51        self.config.training_period
52    }
53    fn required_columns(&self) -> &[&'static str] {
54        &["open", "high", "low", "close", "volume"]
55    }
56
57    fn calculate(&self, candles: &[Candle]) -> Result<IndicatorOutput, IndicatorError> {
58        self.check_len(candles)?;
59        let mut ind = Indicators::new(self.config.clone());
60        let n = candles.len();
61        let mut vwap_out = vec![f64::NAN; n];
62        let mut ema_out = vec![f64::NAN; n];
63        let mut st_out = vec![f64::NAN; n];
64        let mut st_dir_out = vec![f64::NAN; n];
65        let mut ts_norm_out = vec![f64::NAN; n];
66        let mut ts_bullish_out = vec![f64::NAN; n];
67        let mut hurst_out = vec![f64::NAN; n];
68        let mut accel_out = vec![f64::NAN; n];
69        let mut ao_out = vec![f64::NAN; n];
70        let mut dominance_out = vec![f64::NAN; n];
71        for (i, c) in candles.iter().enumerate() {
72            ind.update(c);
73            vwap_out[i] = ind.vwap.unwrap_or(f64::NAN);
74            ema_out[i] = ind.ema.unwrap_or(f64::NAN);
75            st_out[i] = ind.st.unwrap_or(f64::NAN);
76            st_dir_out[i] = ind.st_dir_pub as f64;
77            ts_norm_out[i] = ind.ts_norm;
78            ts_bullish_out[i] = if ind.ts_bullish { 1.0 } else { 0.0 };
79            hurst_out[i] = ind.hurst;
80            accel_out[i] = ind.price_accel;
81            ao_out[i] = ind.ao;
82            dominance_out[i] = ind.dominance;
83        }
84        Ok(IndicatorOutput::from_pairs([
85            ("engine_vwap", vwap_out),
86            ("engine_ema", ema_out),
87            ("engine_st", st_out),
88            ("engine_st_dir", st_dir_out),
89            ("engine_ts_norm", ts_norm_out),
90            ("engine_ts_bullish", ts_bullish_out),
91            ("engine_hurst", hurst_out),
92            ("engine_accel", accel_out),
93            ("engine_ao", ao_out),
94            ("engine_dominance", dominance_out),
95        ]))
96    }
97}
98
99// ── Registry factory ──────────────────────────────────────────────────────────
100
101pub fn factory<S: ::std::hash::BuildHasher>(
102    params: &HashMap<String, String, S>,
103) -> Result<Box<dyn Indicator>, IndicatorError> {
104    let training_period = param_usize(params, "training_period", 100)?;
105    let ema_len = param_usize(params, "ema_len", 9)?;
106    let atr_len = param_usize(params, "atr_len", 10)?;
107    let config = IndicatorConfig {
108        ema_len,
109        atr_len,
110        training_period,
111        ..IndicatorConfig::default()
112    };
113    Ok(Box::new(EngineIndicator::new(config)))
114}
115
116// ── Helpers ───────────────────────────────────────────────────────────────────
117
118#[inline]
119fn rma_step(prev: Option<f64>, val: f64, len: usize) -> f64 {
120    let k = 1.0 / len as f64;
121    prev.map_or(val, |p| val * k + p * (1.0 - k))
122}
123
124fn wma(arr: &[f64]) -> f64 {
125    if arr.is_empty() {
126        return 0.0;
127    }
128    let n = arr.len() as f64;
129    let weights_sum = n * (n + 1.0) / 2.0;
130    arr.iter()
131        .enumerate()
132        .map(|(i, &v)| v * (i as f64 + 1.0))
133        .sum::<f64>()
134        / weights_sum
135}
136
137/// R/S Hurst exponent for a single window of closes.
138fn hurst_scalar(closes: &[f64], max_lag: usize) -> f64 {
139    let n = closes.len();
140    if n < max_lag * 2 + 1 {
141        return 0.5;
142    }
143    let mut log_lags: Vec<f64> = Vec::new();
144    let mut log_rs: Vec<f64> = Vec::new();
145
146    for lag in 2..=max_lag {
147        let chunks = n / lag;
148        if chunks < 1 {
149            continue;
150        }
151        let mut rs_vals: Vec<f64> = Vec::new();
152        for ci in 0..chunks {
153            let chunk = &closes[ci * lag..(ci + 1) * lag];
154            if chunk.len() < 2 {
155                continue;
156            }
157            let _mean = chunk.iter().sum::<f64>() / chunk.len() as f64;
158            let rets: Vec<f64> = chunk.windows(2).map(|w| w[1] - w[0]).collect();
159            let ret_mean = rets.iter().sum::<f64>() / rets.len() as f64;
160            let devs: Vec<f64> = {
161                let mut cum = 0.0;
162                rets.iter()
163                    .map(|&r| {
164                        cum += r - ret_mean;
165                        cum
166                    })
167                    .collect()
168            };
169            let r = devs.iter().copied().fold(f64::NEG_INFINITY, f64::max)
170                - devs.iter().copied().fold(f64::INFINITY, f64::min);
171            let ddof = rets.len() as f64 - 1.0;
172            let s = if ddof > 0.0 {
173                let var = rets.iter().map(|&x| (x - ret_mean).powi(2)).sum::<f64>() / ddof;
174                var.sqrt()
175            } else {
176                0.0
177            };
178            if s > 1e-12 {
179                rs_vals.push(r / s);
180            }
181        }
182        if !rs_vals.is_empty() {
183            log_lags.push((lag as f64).ln());
184            log_rs.push(rs_vals.iter().sum::<f64>().ln() - (rs_vals.len() as f64).ln());
185        }
186    }
187
188    if log_lags.len() < 3 {
189        return 0.5;
190    }
191    let n = log_lags.len() as f64;
192    let mx = log_lags.iter().sum::<f64>() / n;
193    let my = log_rs.iter().sum::<f64>() / n;
194    let num: f64 = log_lags
195        .iter()
196        .zip(log_rs.iter())
197        .map(|(&x, &y)| (x - mx) * (y - my))
198        .sum();
199    let den: f64 = log_lags.iter().map(|&x| (x - mx).powi(2)).sum();
200    if den < 1e-12 {
201        return 0.5;
202    }
203    (num / den).clamp(0.0, 1.0)
204}
205
206// ── Indicators ────────────────────────────────────────────────────────────────
207
208/// Full indicator engine (Layers 1–4, 9–11).
209///
210/// Call [`Indicators::update`] once per closed candle.
211/// After `training_period` candles, [`Indicators::st`] and related fields become `Some`.
212pub struct Indicators {
213    cfg: IndicatorConfig,
214    maxlen: usize,
215
216    pub opens: VecDeque<f64>,
217    pub highs: VecDeque<f64>,
218    pub lows: VecDeque<f64>,
219    pub closes: VecDeque<f64>,
220    pub volumes: VecDeque<f64>,
221    pub times: VecDeque<i64>,
222    bar: usize,
223
224    // L1 VWAP
225    vwap_vol: f64,
226    vwap_tpv: f64,
227    vwap_date: Option<NaiveDate>,
228
229    // L2 EMA
230    ema9: Option<f64>,
231
232    // L3 SuperTrend
233    rma_atr: Option<f64>,
234    st_upper: Option<f64>,
235    st_lower: Option<f64>,
236    st_dir: i8,
237    st_value: Option<f64>,
238    kmeans_centroids: Option<[f64; 3]>,
239    kmeans_last_bar: usize,
240
241    // L4 TrendSpeed
242    dyn_ema: Option<f64>,
243    prev_close: Option<f64>,
244    max_abs_buf: VecDeque<f64>,
245    delta_buf: VecDeque<f64>,
246    rma_c: Option<f64>,
247    rma_o: Option<f64>,
248    wave_speed: f64,
249    wave_pos: i8,
250    speed_norm: VecDeque<f64>,
251    hma_buf: VecDeque<f64>,
252    bull_waves: VecDeque<f64>,
253    bear_waves: VecDeque<f64>,
254    wr_tracker: PercentileTracker,
255    mom_tracker: PercentileTracker,
256    cur_ratio: f64,
257
258    // L10 Hurst
259    hurst_last_bar: usize,
260    /// Close price at the last Hurst recompute — used to skip redundant R/S runs.
261    hurst_last_close: f64,
262
263    // L11 Price acceleration
264    vel_buf: VecDeque<f64>,
265
266    // ── Published fields ─────────────────────────────────────────────────────
267    /// Layer 1 — intraday VWAP, resets at UTC midnight.
268    pub vwap: Option<f64>,
269    /// Layer 2 — EMA of configurable period.
270    pub ema: Option<f64>,
271    /// Layer 3 — SuperTrend line value.
272    pub st: Option<f64>,
273    /// Layer 3 — SuperTrend direction: `-1` = bullish (price above ST), `+1` = bearish.
274    pub st_dir_pub: i8,
275    /// Layer 3 — RMA ATR used for SuperTrend.
276    pub atr: Option<f64>,
277    /// Layer 3 — KMeans cluster index (0 = high vol, 1 = mid, 2 = low vol).
278    pub cluster: usize,
279    /// Layer 4 — dynamic EMA.
280    pub dyn_ema_pub: Option<f64>,
281    /// Layer 4 — HMA-smoothed wave speed.
282    pub ts_speed: f64,
283    /// Layer 4 — wave speed normalised 0–1.
284    pub ts_norm: f64,
285    /// Layer 4 — true when wave speed is positive.
286    pub ts_bullish: bool,
287    /// Layer 4 — average bull wave magnitude.
288    pub bull_avg: f64,
289    /// Layer 4 — average bear wave magnitude.
290    pub bear_avg: f64,
291    /// Layer 4 — bull_avg - |bear_avg|.
292    pub dominance: f64,
293    /// Layer 9 — Awesome Oscillator value.
294    pub ao: f64,
295    /// Layer 9 — true when AO is rising.
296    pub ao_rising: bool,
297    /// Layer 9 — wave ratio percentile.
298    pub wr_pct: f64,
299    /// Layer 9 — momentum percentile.
300    pub mom_pct: f64,
301    pub wave_ok_long: bool,
302    pub wave_ok_short: bool,
303    pub mom_ok_long: bool,
304    pub mom_ok_short: bool,
305    /// Layer 10 — Hurst exponent (0.5 = random, >0.52 = trending).
306    pub hurst: f64,
307    /// Layer 11 — normalised price acceleration (−1 to +1).
308    pub price_accel: f64,
309}
310
311impl Indicators {
312    pub fn new(cfg: IndicatorConfig) -> Self {
313        let maxlen = cfg.history_candles.max(cfg.training_period + 50).max(300);
314        let ts_collen = cfg.ts_collen;
315        let ts_lookback = cfg.ts_lookback;
316
317        let mut wr_tracker = PercentileTracker::new(200);
318        for i in 0..100 {
319            wr_tracker.push(if i % 2 == 0 { 0.5 } else { 2.0 });
320        }
321
322        Self {
323            cfg,
324            maxlen,
325            opens: VecDeque::with_capacity(maxlen),
326            highs: VecDeque::with_capacity(maxlen),
327            lows: VecDeque::with_capacity(maxlen),
328            closes: VecDeque::with_capacity(maxlen),
329            volumes: VecDeque::with_capacity(maxlen),
330            times: VecDeque::with_capacity(maxlen),
331            bar: 0,
332            vwap_vol: 0.0,
333            vwap_tpv: 0.0,
334            vwap_date: None,
335            ema9: None,
336            rma_atr: None,
337            st_upper: None,
338            st_lower: None,
339            st_dir: 1,
340            st_value: None,
341            kmeans_centroids: None,
342            kmeans_last_bar: 0,
343            dyn_ema: None,
344            prev_close: None,
345            max_abs_buf: VecDeque::with_capacity(200),
346            delta_buf: VecDeque::with_capacity(200),
347            rma_c: None,
348            rma_o: None,
349            wave_speed: 0.0,
350            wave_pos: 0,
351            speed_norm: VecDeque::with_capacity(ts_collen),
352            hma_buf: VecDeque::new(),
353            bull_waves: VecDeque::with_capacity(ts_lookback * 4),
354            bear_waves: VecDeque::with_capacity(ts_lookback * 4),
355            wr_tracker,
356            mom_tracker: PercentileTracker::seeded(200, 0.5, 0.5),
357            cur_ratio: 0.0,
358            hurst_last_bar: 0,
359            hurst_last_close: f64::NAN,
360            vel_buf: VecDeque::with_capacity(110),
361            vwap: None,
362            ema: None,
363            st: None,
364            st_dir_pub: 1,
365            atr: None,
366            cluster: 1,
367            dyn_ema_pub: None,
368            ts_speed: 0.0,
369            ts_norm: 0.5,
370            ts_bullish: false,
371            bull_avg: 0.0,
372            bear_avg: 0.0,
373            dominance: 0.0,
374            ao: 0.0,
375            ao_rising: false,
376            wr_pct: 0.5,
377            mom_pct: 0.5,
378            wave_ok_long: true,
379            wave_ok_short: true,
380            mom_ok_long: true,
381            mom_ok_short: true,
382            hurst: 0.5,
383            price_accel: 0.0,
384        }
385    }
386
387    // ── L1 VWAP ───────────────────────────────────────────────────────────────
388
389    fn upd_vwap(&mut self, candle: &Candle) -> f64 {
390        let dt = Utc
391            .timestamp_millis_opt(candle.time)
392            .single()
393            .unwrap_or_else(Utc::now)
394            .date_naive();
395        if Some(dt) != self.vwap_date {
396            self.vwap_vol = 0.0;
397            self.vwap_tpv = 0.0;
398            self.vwap_date = Some(dt);
399        }
400        let tp = candle.typical_price();
401        self.vwap_vol += candle.volume;
402        self.vwap_tpv += tp * candle.volume;
403        if self.vwap_vol > 0.0 {
404            self.vwap_tpv / self.vwap_vol
405        } else {
406            candle.close
407        }
408    }
409
410    // ── L3 RMA ATR ────────────────────────────────────────────────────────────
411
412    fn upd_atr(&mut self, candle: &Candle) -> f64 {
413        let prev_c = self
414            .closes
415            .iter()
416            .rev()
417            .nth(1)
418            .copied()
419            .unwrap_or(candle.close);
420        let tr = (candle.high - candle.low)
421            .max((candle.high - prev_c).abs())
422            .max((candle.low - prev_c).abs());
423        self.rma_atr = Some(rma_step(self.rma_atr, tr, self.cfg.atr_len));
424        self.rma_atr.unwrap()
425    }
426
427    // ── L3 KMeans ─────────────────────────────────────────────────────────────
428
429    fn kmeans_atr(&mut self, atr_val: f64) -> f64 {
430        if self.kmeans_centroids.is_none() || (self.bar - self.kmeans_last_bar) >= 10 {
431            self.kmeans_centroids = Some(self.compute_kmeans_centroids());
432            self.kmeans_last_bar = self.bar;
433        }
434        let [c_h, c_m, c_l] = self.kmeans_centroids.unwrap();
435        let dists = [
436            (c_h - atr_val).abs(),
437            (c_m - atr_val).abs(),
438            (c_l - atr_val).abs(),
439        ];
440        self.cluster = dists
441            .iter()
442            .enumerate()
443            .min_by(|a, b| a.1.partial_cmp(b.1).unwrap())
444            .map_or(1, |(i, _)| i);
445        [c_h, c_m, c_l][self.cluster]
446    }
447
448    fn compute_kmeans_centroids(&self) -> [f64; 3] {
449        let n = self.cfg.training_period.min(self.closes.len());
450        let ha: Vec<f64> = self.highs.iter().rev().take(n).copied().collect();
451        let la: Vec<f64> = self.lows.iter().rev().take(n).copied().collect();
452        let ca: Vec<f64> = self.closes.iter().rev().take(n).copied().collect();
453
454        let mut trs = vec![ha[0] - la[0]];
455        for i in 1..n {
456            trs.push(
457                (ha[i] - la[i])
458                    .max((ha[i] - ca[i - 1]).abs())
459                    .max((la[i] - ca[i - 1]).abs()),
460            );
461        }
462        let alpha = 1.0 / self.cfg.atr_len as f64;
463        let mut atr_w = vec![trs[0]];
464        for i in 1..trs.len() {
465            atr_w.push(alpha * trs[i] + (1.0 - alpha) * atr_w[i - 1]);
466        }
467
468        let lo = atr_w.iter().copied().fold(f64::INFINITY, f64::min);
469        let hi = atr_w.iter().copied().fold(f64::NEG_INFINITY, f64::max);
470        let rng = if (hi - lo).abs() > 1e-9 {
471            hi - lo
472        } else {
473            1e-9
474        };
475
476        let mut c_h = lo + rng * self.cfg.highvol_pct;
477        let mut c_m = lo + rng * self.cfg.midvol_pct;
478        let mut c_l = lo + rng * self.cfg.lowvol_pct;
479
480        for _ in 0..100 {
481            let mut g: [Vec<f64>; 3] = [Vec::new(), Vec::new(), Vec::new()];
482            for &v in &atr_w {
483                let dists = [(v - c_h).abs(), (v - c_m).abs(), (v - c_l).abs()];
484                let idx = dists
485                    .iter()
486                    .enumerate()
487                    .min_by(|a, b| a.1.partial_cmp(b.1).unwrap())
488                    .map_or(1, |(i, _)| i);
489                g[idx].push(v);
490            }
491            let nh = if g[0].is_empty() {
492                c_h
493            } else {
494                g[0].iter().sum::<f64>() / g[0].len() as f64
495            };
496            let nm = if g[1].is_empty() {
497                c_m
498            } else {
499                g[1].iter().sum::<f64>() / g[1].len() as f64
500            };
501            let nl = if g[2].is_empty() {
502                c_l
503            } else {
504                g[2].iter().sum::<f64>() / g[2].len() as f64
505            };
506            if (nh - c_h).abs() < 1e-9 && (nm - c_m).abs() < 1e-9 && (nl - c_l).abs() < 1e-9 {
507                break;
508            }
509            c_h = nh;
510            c_m = nm;
511            c_l = nl;
512        }
513        [c_h, c_m, c_l]
514    }
515
516    // ── L3 SuperTrend ─────────────────────────────────────────────────────────
517
518    fn upd_supertrend(&mut self, adaptive_atr: f64, close: f64) -> (f64, i8) {
519        let hl2 = (self.highs.back().copied().unwrap_or(close)
520            + self.lows.back().copied().unwrap_or(close))
521            / 2.0;
522        let factor = self.cfg.st_factor;
523        let raw_upper = hl2 + factor * adaptive_atr;
524        let raw_lower = hl2 - factor * adaptive_atr;
525
526        let prev_u = self.st_upper.unwrap_or(raw_upper);
527        let prev_l = self.st_lower.unwrap_or(raw_lower);
528        let prev_st = self.st_value.unwrap_or(raw_upper);
529        let prev_c = self.closes.iter().rev().nth(1).copied().unwrap_or(close);
530
531        let lower = if raw_lower > prev_l || prev_c < prev_l {
532            raw_lower
533        } else {
534            prev_l
535        };
536        let upper = if raw_upper < prev_u || prev_c > prev_u {
537            raw_upper
538        } else {
539            prev_u
540        };
541
542        let direction = if prev_st == prev_u {
543            if close > upper { -1 } else { 1 }
544        } else {
545            if close < lower { 1 } else { -1 }
546        };
547
548        let st_val = if direction == -1 { lower } else { upper };
549        self.st_upper = Some(upper);
550        self.st_lower = Some(lower);
551        self.st_dir = direction;
552        self.st_value = Some(st_val);
553        (st_val, direction)
554    }
555
556    // ── L4 Trend Speed ────────────────────────────────────────────────────────
557
558    fn upd_trend_speed(&mut self, candle: &Candle) {
559        let cl = candle.close;
560        let op = candle.open;
561
562        let abs_cd = (cl - op).abs();
563        if self.max_abs_buf.len() == 200 {
564            self.max_abs_buf.pop_front();
565        }
566        self.max_abs_buf.push_back(abs_cd);
567        let max_abs = self
568            .max_abs_buf
569            .iter()
570            .copied()
571            .fold(f64::NEG_INFINITY, f64::max)
572            .max(1.0);
573        let cd_norm = (abs_cd + max_abs) / (2.0 * max_abs);
574        let dyn_len = 5.0 + cd_norm * (self.cfg.ts_max_length as f64 - 5.0);
575
576        let prev_c = self.prev_close.unwrap_or(cl);
577        let delta = (cl - prev_c).abs();
578        if self.delta_buf.len() == 200 {
579            self.delta_buf.pop_front();
580        }
581        self.delta_buf.push_back(delta);
582        let max_d = self
583            .delta_buf
584            .iter()
585            .copied()
586            .fold(f64::NEG_INFINITY, f64::max)
587            .max(1.0);
588        let accel = delta / max_d;
589
590        let alpha = (2.0 / (dyn_len + 1.0) * (1.0 + accel * self.cfg.ts_accel_mult)).min(1.0);
591        self.dyn_ema = Some(match self.dyn_ema {
592            None => cl,
593            Some(prev) => alpha * cl + (1.0 - alpha) * prev,
594        });
595        self.dyn_ema_pub = self.dyn_ema;
596
597        self.rma_c = Some(rma_step(self.rma_c, cl, self.cfg.ts_rma_len));
598        self.rma_o = Some(rma_step(self.rma_o, op, self.cfg.ts_rma_len));
599
600        let trend = self.dyn_ema.unwrap();
601        let prev_cl = self.closes.iter().rev().nth(1).copied().unwrap_or(cl);
602        let c_rma = self.rma_c.unwrap_or(0.0);
603        let o_rma = self.rma_o.unwrap_or(0.0);
604        let lookback_cap = self.cfg.ts_lookback * 4;
605
606        if cl > trend && prev_cl <= trend {
607            if self.wave_pos != 0 {
608                if self.bear_waves.len() == lookback_cap {
609                    self.bear_waves.pop_front();
610                }
611                self.bear_waves.push_back(self.wave_speed);
612            }
613            self.wave_pos = 1;
614            self.wave_speed = c_rma - o_rma;
615        } else if cl < trend && prev_cl >= trend {
616            if self.wave_pos != 0 {
617                if self.bull_waves.len() == lookback_cap {
618                    self.bull_waves.pop_front();
619                }
620                self.bull_waves.push_back(self.wave_speed);
621            }
622            self.wave_pos = -1;
623            self.wave_speed = c_rma - o_rma;
624        } else {
625            self.wave_speed += c_rma - o_rma;
626        }
627
628        if self.speed_norm.len() == self.cfg.ts_collen {
629            self.speed_norm.pop_front();
630        }
631        self.speed_norm.push_back(self.wave_speed);
632
633        self.ts_speed = self.hma_smooth(self.cfg.ts_hma_len);
634        self.ts_bullish = self.ts_speed > 0.0;
635
636        let sp_min = self
637            .speed_norm
638            .iter()
639            .copied()
640            .fold(f64::INFINITY, f64::min);
641        let sp_max = self
642            .speed_norm
643            .iter()
644            .copied()
645            .fold(f64::NEG_INFINITY, f64::max);
646        let sp_rng = if (sp_max - sp_min).abs() > 1e-9 {
647            sp_max - sp_min
648        } else {
649            1.0
650        };
651        self.ts_norm = (self.wave_speed - sp_min) / sp_rng;
652
653        let lb = self.cfg.ts_lookback;
654        let bull_r: Vec<f64> = self.bull_waves.iter().rev().take(lb).copied().collect();
655        let bear_r: Vec<f64> = self.bear_waves.iter().rev().take(lb).copied().collect();
656        self.bull_avg = if bull_r.is_empty() {
657            0.0
658        } else {
659            bull_r.iter().sum::<f64>() / bull_r.len() as f64
660        };
661        self.bear_avg = if bear_r.is_empty() {
662            0.0
663        } else {
664            bear_r.iter().sum::<f64>() / bear_r.len() as f64
665        };
666        self.dominance = self.bull_avg - self.bear_avg.abs();
667        self.prev_close = Some(cl);
668
669        let bear_abs = self.bear_avg.abs().max(1e-9);
670        let wave_ratio = if self.bull_avg > 0.0 {
671            self.bull_avg / bear_abs
672        } else {
673            1.0 / bear_abs
674        };
675        self.wr_tracker.push(wave_ratio);
676        self.wr_pct = self.wr_tracker.pct(wave_ratio);
677
678        self.cur_ratio = if self.wave_speed > 0.0 && self.bull_avg > 0.0 {
679            self.wave_speed / self.bull_avg
680        } else if self.wave_speed < 0.0 && bear_abs > 0.0 {
681            -self.wave_speed.abs() / bear_abs
682        } else {
683            0.0
684        };
685        self.mom_tracker.push(self.cur_ratio.abs());
686        self.mom_pct = self.mom_tracker.pct(self.cur_ratio.abs());
687
688        let wl = self.cfg.wave_pct_l.clamp(0.01, 0.99);
689        let ws = (1.0 - self.cfg.wave_pct_s).clamp(0.01, 0.99);
690        let ml = self.cfg.mom_pct_min.clamp(0.01, 0.99);
691
692        self.wave_ok_long = self.wr_pct >= wl;
693        self.wave_ok_short = self.wr_pct <= ws;
694        self.mom_ok_long = self.mom_pct >= ml && self.cur_ratio > 0.0;
695        self.mom_ok_short = self.mom_pct >= ml && self.cur_ratio < 0.0;
696    }
697
698    /// HMA: 2*WMA(n/2) - WMA(n), then WMA(√n) of that.
699    fn hma_smooth(&mut self, length: usize) -> f64 {
700        let sn: Vec<f64> = self.speed_norm.iter().copied().collect();
701        if sn.len() < 2 {
702            return *sn.last().unwrap_or(&0.0);
703        }
704        let half = (length / 2).max(1);
705        let sqrt_n = (length as f64).sqrt().round() as usize;
706        let raw = 2.0 * wma(&sn[sn.len().saturating_sub(half)..])
707            - wma(&sn[sn.len().saturating_sub(length)..]);
708        if self.hma_buf.len() == sqrt_n {
709            self.hma_buf.pop_front();
710        }
711        self.hma_buf.push_back(raw);
712        let hma_arr: Vec<f64> = self.hma_buf.iter().copied().collect();
713        wma(&hma_arr)
714    }
715
716    // ── L9 Awesome Oscillator ─────────────────────────────────────────────────
717
718    fn upd_ao(&mut self) {
719        if self.highs.len() < 34 {
720            return;
721        }
722        let hs: Vec<f64> = self.highs.iter().copied().collect();
723        let ls: Vec<f64> = self.lows.iter().copied().collect();
724        let hl2: Vec<f64> = hs
725            .iter()
726            .zip(ls.iter())
727            .map(|(h, l)| (h + l) / 2.0)
728            .collect();
729        let n = hl2.len();
730        let ao_new =
731            hl2[n - 5..].iter().sum::<f64>() / 5.0 - hl2[n - 34..].iter().sum::<f64>() / 34.0;
732        self.ao_rising = ao_new > self.ao;
733        self.ao = ao_new;
734    }
735
736    // ── L10 Hurst ─────────────────────────────────────────────────────────────
737
738    fn upd_hurst(&mut self) {
739        let lb = self.cfg.hurst_lookback;
740        let min_bars = lb * 2 + 1;
741        if self.closes.len() < min_bars || (self.bar - self.hurst_last_bar) < 10 {
742            return;
743        }
744        // Skip the O(N log N) R/S loop when the close has barely moved since
745        // the last recompute (< 0.01 % change).  The Hurst exponent is stable
746        // over such tiny price moves, so the cached value remains valid.
747        let cur_close = *self.closes.back().unwrap_or(&0.0);
748        let pct_move = if self.hurst_last_close.is_nan() || self.hurst_last_close.abs() < 1e-10 {
749            f64::INFINITY // force first compute
750        } else {
751            (cur_close - self.hurst_last_close).abs() / self.hurst_last_close
752        };
753        if pct_move < 1e-4 {
754            // Price hasn't moved enough to shift the Hurst estimate — reuse cache.
755            self.hurst_last_bar = self.bar;
756            return;
757        }
758        let cl_arr: Vec<f64> = self.closes.iter().rev().take(min_bars).copied().collect();
759        self.hurst = hurst_scalar(&cl_arr, lb);
760        self.hurst_last_bar = self.bar;
761        self.hurst_last_close = cur_close;
762    }
763
764    // ── L11 Price acceleration ────────────────────────────────────────────────
765
766    fn upd_accel(&mut self) {
767        let k = 3usize;
768        let n = self.closes.len();
769        if n <= k * 2 {
770            return;
771        }
772        let cl: Vec<f64> = self.closes.iter().copied().collect();
773        let vel_now = (cl[n - 1] - cl[n - 1 - k]) / (cl[n - 1 - k] + 1e-10);
774        let vel_prev = (cl[n - 1 - k] - cl[n - 1 - k * 2]) / (cl[n - 1 - k * 2] + 1e-10);
775        if self.vel_buf.len() == 110 {
776            self.vel_buf.pop_front();
777        }
778        self.vel_buf.push_back(vel_now);
779        let accel = vel_now - vel_prev;
780        let vel_std = if self.vel_buf.len() > 1 {
781            let vv: Vec<f64> = self.vel_buf.iter().copied().collect();
782            let mean = vv.iter().sum::<f64>() / vv.len() as f64;
783            let var = vv.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / vv.len() as f64;
784            var.sqrt()
785        } else {
786            1.0
787        };
788        self.price_accel = (accel / (vel_std + 1e-10) / 3.0).clamp(-1.0, 1.0);
789    }
790
791    // ── Main update ───────────────────────────────────────────────────────────
792
793    /// Feed one closed candle. Returns `true` once SuperTrend is ready.
794    pub fn update(&mut self, candle: &Candle) -> bool {
795        let cap = self.maxlen;
796        macro_rules! push {
797            ($buf:expr, $val:expr) => {
798                if $buf.len() == cap {
799                    $buf.pop_front();
800                }
801                $buf.push_back($val);
802            };
803        }
804        push!(self.opens, candle.open);
805        push!(self.highs, candle.high);
806        push!(self.lows, candle.low);
807        push!(self.closes, candle.close);
808        push!(self.volumes, candle.volume);
809        push!(self.times, candle.time);
810        self.bar += 1;
811
812        self.vwap = Some(self.upd_vwap(candle));
813
814        let k = 2.0 / (self.cfg.ema_len as f64 + 1.0);
815        self.ema9 = Some(match self.ema9 {
816            None => candle.close,
817            Some(e) => candle.close * k + e * (1.0 - k),
818        });
819        self.ema = self.ema9;
820
821        let atr_val = self.upd_atr(candle);
822        self.atr = Some(atr_val);
823
824        self.upd_trend_speed(candle);
825        self.upd_ao();
826        self.upd_hurst();
827        self.upd_accel();
828
829        if self.closes.len() < self.cfg.training_period {
830            return false;
831        }
832
833        let adaptive_atr = self.kmeans_atr(atr_val);
834        let (st, dir) = self.upd_supertrend(adaptive_atr, candle.close);
835        self.st = Some(st);
836        self.st_dir_pub = dir;
837
838        true
839    }
840
841    /// Returns `true` if a speed-exit condition is triggered for the given position.
842    ///
843    /// `position`: `+1` = long, `-1` = short.
844    /// Returns `false` when `ts_speed_exit_threshold` is `None`.
845    pub fn check_speed_exit(&self, position: i32) -> bool {
846        let Some(thr) = self.cfg.ts_speed_exit_threshold else {
847            return false;
848        };
849        if position > 0 && self.ts_speed < -thr.abs() {
850            return true;
851        }
852        position < 0 && self.ts_speed > thr.abs()
853    }
854}
indicators/signal/engine.rs

indicators/signal/
engine.rs
