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

indicators/signal/
engine.rs
