first commit

This is code written by claude for a static stock analysis page
generator.  I intend to test difference analysis indicators to see if
some claims make any sense.

1 files changed, 248 insertions, 0 deletions

diff --git a/src/signals.rs b/src/signals.rs
new file mode 100644
index 0000000..4b91d8e
--- /dev/null
+++ b/src/signals.rs
@@ -0,0 +1,248 @@
+use crate::data::Candle;
+use serde::Serialize;
+
+#[derive(Serialize)]
+pub struct Cross {
+    pub index: usize,
+    /// "golden" (K crosses above D) or "death" (K crosses below D)
+    pub kind: &'static str,
+    /// true when the cross happens in the extreme zone (<20 golden, >80 death)
+    pub strong: bool,
+}
+
+#[derive(Serialize)]
+pub struct Divergence {
+    /// "bullish" or "bearish"
+    pub kind: &'static str,
+    /// "regular" (reversal signal) or "hidden" (trend-continuation signal)
+    pub class: &'static str,
+    /// "RSI" or "K"
+    pub indicator: &'static str,
+    /// bars of the two price swings
+    pub i1: usize,
+    pub i2: usize,
+    /// price at the swings (swing low's Low / swing high's High)
+    pub p1: f64,
+    pub p2: f64,
+    /// bars where the indicator has its extreme near each swing
+    pub j1: usize,
+    pub j2: usize,
+    /// bar at which the second swing was confirmed (earliest the signal was knowable)
+    pub confirmed: usize,
+}
+
+pub fn crosses(k: &[Option<f64>], d: &[Option<f64>]) -> Vec<Cross> {
+    let mut out = Vec::new();
+    for i in 1..k.len() {
+        if let (Some(k0), Some(d0), Some(k1), Some(d1)) = (k[i - 1], d[i - 1], k[i], d[i]) {
+            if k0 <= d0 && k1 > d1 {
+                out.push(Cross { index: i, kind: "golden", strong: k1 < 20.0 });
+            } else if k0 >= d0 && k1 < d1 {
+                out.push(Cross { index: i, kind: "death", strong: k1 > 80.0 });
+            }
+        }
+    }
+    out
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Swing {
+    pub index: usize,
+    pub is_high: bool,
+    pub price: f64,
+    /// bar where price had reversed by `pct` from the extreme
+    pub confirmed_at: usize,
+}
+
+/// ZigZag swings: a swing high (low) is confirmed once price falls (rises) by at
+/// least `pct` percent from the running extreme. The last, unconfirmed extreme is dropped.
+pub fn zigzag(candles: &[Candle], pct: f64) -> Vec<Swing> {
+    let f = pct / 100.0;
+    let mut out = Vec::new();
+    if candles.is_empty() {
+        return out;
+    }
+    // Some(true): tracking a high (rising); Some(false): tracking a low; None: undecided.
+    let mut dir: Option<bool> = None;
+    let mut hi = (0, candles[0].high);
+    let mut lo = (0, candles[0].low);
+    for (i, c) in candles.iter().enumerate().skip(1) {
+        match dir {
+            None => {
+                if c.high > hi.1 { hi = (i, c.high); }
+                if c.low < lo.1 { lo = (i, c.low); }
+                if c.low <= hi.1 * (1.0 - f) && hi.0 < i {
+                    out.push(Swing { index: hi.0, is_high: true, price: hi.1, confirmed_at: i });
+                    dir = Some(false);
+                    lo = (i, c.low);
+                } else if c.high >= lo.1 * (1.0 + f) && lo.0 < i {
+                    out.push(Swing { index: lo.0, is_high: false, price: lo.1, confirmed_at: i });
+                    dir = Some(true);
+                    hi = (i, c.high);
+                }
+            }
+            Some(true) => {
+                if c.high > hi.1 {
+                    hi = (i, c.high);
+                } else if c.low <= hi.1 * (1.0 - f) {
+                    out.push(Swing { index: hi.0, is_high: true, price: hi.1, confirmed_at: i });
+                    dir = Some(false);
+                    lo = (i, c.low);
+                }
+            }
+            Some(false) => {
+                if c.low < lo.1 {
+                    lo = (i, c.low);
+                } else if c.high >= lo.1 * (1.0 + f) {
+                    out.push(Swing { index: lo.0, is_high: false, price: lo.1, confirmed_at: i });
+                    dir = Some(true);
+                    hi = (i, c.high);
+                }
+            }
+        }
+    }
+    out
+}
+
+/// Indicator extreme (min for lows, max for highs) within +-`slack` bars of `idx`.
+fn indicator_extreme(ind: &[Option<f64>], idx: usize, is_high: bool, slack: usize) -> Option<(usize, f64)> {
+    let lo = idx.saturating_sub(slack);
+    let hi = (idx + slack).min(ind.len() - 1);
+    (lo..=hi).filter_map(|j| ind[j].map(|v| (j, v))).reduce(|a, b| {
+        if (b.1 > a.1) == is_high && b.1 != a.1 { b } else { a }
+    })
+}
+
+/// Divergences between price swings and an indicator, using consecutive swings of the
+/// same kind (low->low, high->high):
+///   regular bullish: price lower low,  indicator higher low   (reversal up)
+///   regular bearish: price higher high, indicator lower high  (reversal down)
+///   hidden  bullish: price higher low, indicator lower low    (uptrend continues)
+///   hidden  bearish: price lower high, indicator higher high  (downtrend continues)
+pub fn divergences(
+    swings: &[Swing],
+    ind: &[Option<f64>],
+    name: &'static str,
+) -> Vec<Divergence> {
+    let mut out = Vec::new();
+    for is_high in [false, true] {
+        let same: Vec<&Swing> = swings.iter().filter(|s| s.is_high == is_high).collect();
+        for w in same.windows(2) {
+            let (a, b) = (w[0], w[1]);
+            let (Some((ja, ia)), Some((jb, ib))) = (
+                indicator_extreme(ind, a.index, is_high, 2),
+                indicator_extreme(ind, b.index, is_high, 2),
+            ) else { continue };
+            let (price_up, ind_up) = (b.price > a.price, ib > ia);
+            if price_up == ind_up || b.price == a.price || ib == ia {
+                continue;
+            }
+            // lows: price down & ind up is regular; highs: price up & ind down is regular.
+            let regular = if is_high { price_up } else { !price_up };
+            out.push(Divergence {
+                kind: if is_high { "bearish" } else { "bullish" },
+                class: if regular { "regular" } else { "hidden" },
+                indicator: name,
+                i1: a.index, i2: b.index, p1: a.price, p2: b.price,
+                j1: ja, j2: jb, confirmed: b.confirmed_at,
+            });
+        }
+    }
+    out.sort_by_key(|d| d.confirmed);
+    out
+}
+
+/// Rough forward-return summary per (class, kind, indicator): count, then for each
+/// horizon the mean close-to-close return after the confirmation bar and the share of
+/// signals that moved in the signal's direction.
+pub fn forward_stats(candles: &[Candle], divs: &[Divergence], horizons: &[usize]) -> String {
+    use std::collections::BTreeMap;
+    let mut groups: BTreeMap<(&str, &str, &str), Vec<&Divergence>> = BTreeMap::new();
+    for d in divs {
+        groups.entry((d.class, d.kind, d.indicator)).or_default().push(d);
+    }
+    let mut out = String::new();
+    for ((class, kind, ind), ds) in groups {
+        out += &format!("{class:8} {kind:8} {ind:4} n={:<3}", ds.len());
+        for &h in horizons {
+            let rets: Vec<f64> = ds
+                .iter()
+                .filter(|d| d.confirmed + h < candles.len())
+                .map(|d| {
+                    let r = candles[d.confirmed + h].close / candles[d.confirmed].close - 1.0;
+                    if kind == "bullish" { r } else { -r } // positive = moved the signalled way
+                })
+                .collect();
+            if rets.is_empty() {
+                out += &format!("  +{h}d: n/a");
+            } else {
+                let mean = rets.iter().sum::<f64>() / rets.len() as f64 * 100.0;
+                let win = rets.iter().filter(|&&r| r > 0.0).count() as f64 / rets.len() as f64 * 100.0;
+                out += &format!("  +{h}d: {mean:+.2}% win {win:.0}% (n={})", rets.len());
+            }
+        }
+        out.push('\n');
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn flat(closes: &[f64]) -> Vec<Candle> {
+        closes
+            .iter()
+            .map(|&c| Candle { date: "2024-01-01".into(), open: c, high: c, low: c, close: c, volume: 1.0 })
+            .collect()
+    }
+
+    const PRICES: [f64; 9] = [100.0, 95.0, 90.0, 95.0, 100.0, 97.0, 95.0, 100.0, 105.0];
+
+    #[test]
+    fn zigzag_finds_confirmed_swings() {
+        let sw = zigzag(&flat(&PRICES), 5.0);
+        let lows: Vec<_> = sw.iter().filter(|s| !s.is_high).map(|s| (s.index, s.confirmed_at)).collect();
+        assert_eq!(lows, vec![(2, 3), (6, 7)]);
+        assert!(sw.iter().any(|s| s.is_high && s.index == 4));
+    }
+
+    #[test]
+    fn hidden_bullish_not_regular() {
+        // price: lows 90 then 95 (higher low); indicator lows 30 then 20 (lower low)
+        let sw = zigzag(&flat(&PRICES), 5.0);
+        let mut ind = vec![Some(50.0); PRICES.len()];
+        ind[2] = Some(30.0);
+        ind[6] = Some(20.0);
+        let d = divergences(&sw, &ind, "RSI");
+        assert_eq!(d.len(), 1);
+        assert_eq!((d[0].class, d[0].kind, d[0].i1, d[0].i2), ("hidden", "bullish", 2, 6));
+    }
+
+    #[test]
+    fn regular_bullish() {
+        // price: lower low needs 90 then 85
+        let p = [100.0, 95.0, 90.0, 95.0, 100.0, 95.0, 85.0, 90.0, 95.0];
+        let sw = zigzag(&flat(&p), 5.0);
+        let mut ind = vec![Some(50.0); p.len()];
+        ind[2] = Some(20.0);
+        ind[6] = Some(30.0);
+        let d = divergences(&sw, &ind, "K");
+        assert_eq!(d.len(), 1);
+        assert_eq!((d[0].class, d[0].kind), ("regular", "bullish"));
+    }
+
+    #[test]
+    fn hidden_bearish() {
+        // price highs 100 then 95 (lower high); indicator highs 60 then 80 (higher high)
+        let p = [90.0, 95.0, 100.0, 95.0, 90.0, 92.0, 95.0, 90.0, 85.0];
+        let sw = zigzag(&flat(&p), 5.0);
+        let mut ind = vec![Some(50.0); p.len()];
+        ind[2] = Some(60.0);
+        ind[6] = Some(80.0);
+        let d = divergences(&sw, &ind, "RSI");
+        assert_eq!(d.len(), 1);
+        assert_eq!((d[0].class, d[0].kind), ("hidden", "bearish"));
+    }
+}
+