indicators-ta 0.1.1

Technical analysis indicators and market regime detection for algorithmic trading
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

//! Accumulation/Distribution Line (ADL).
//!
//! Python source: `indicators/trend/accumulation_distribution_line.py :: class ADLineIndicator`
//!
//! # Python algorithm (to port)
//! ```python
//! # Money Flow Multiplier (MFM):
//! mfm = ((close - low) - (high - close)) / (high - low)
//! mfm[high == low] = 0          # avoid division by zero
//!
//! # Money Flow Volume:
//! mfv = mfm * volume
//!
//! # ADL = cumulative sum of MFV
//! adl = mfv.cumsum()
//! ```
//!
//! Output column: `"ADL"`.

use std::collections::HashMap;

use crate::error::IndicatorError;
use crate::indicator::{Indicator, IndicatorOutput};
use crate::types::Candle;

// ── Indicator struct ──────────────────────────────────────────────────────────

/// Accumulation/Distribution Line.  No configurable parameters.
#[derive(Debug, Clone, Default)]
pub struct Adl;

impl Adl {
    pub fn new() -> Self {
        Self
    }
}

impl Indicator for Adl {
    fn name(&self) -> &str {
        "ADL"
    }
    fn required_len(&self) -> usize {
        1
    }
    fn required_columns(&self) -> &[&'static str] {
        &["high", "low", "close", "volume"]
    }

    /// TODO: port Python ADL cumsum logic.
    fn calculate(&self, candles: &[Candle]) -> Result<IndicatorOutput, IndicatorError> {
        self.check_len(candles)?;

        let mut adl = 0.0f64;
        let values: Vec<f64> = candles.iter().map(|c| {
            let range = c.high - c.low;
            // TODO: port Python mfm formula
            let mfm = if range == 0.0 {
                0.0
            } else {
                ((c.close - c.low) - (c.high - c.close)) / range
            };
            adl += mfm * c.volume;
            adl
        }).collect();

        Ok(IndicatorOutput::from_pairs([("ADL".to_string(), values)]))
    }
}

// ── Registry factory ──────────────────────────────────────────────────────────

pub fn factory(_params: &HashMap<String, String>) -> Result<Box<dyn Indicator>, IndicatorError> {
    Ok(Box::new(Adl::new()))
}

// ── Tests ─────────────────────────────────────────────────────────────────────

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

    fn candle(h: f64, l: f64, c: f64, v: f64) -> Candle {
        Candle { time: 0, open: c, high: h, low: l, close: c, volume: v }
    }

    #[test]
    fn adl_zero_range_no_panic() {
        // high == low should produce mfm=0, not a divide-by-zero
        let bars = vec![candle(5.0, 5.0, 5.0, 1000.0)];
        let out = Adl::new().calculate(&bars).unwrap();
        let vals = out.get("ADL").unwrap();
        assert_eq!(vals[0], 0.0);
    }

    #[test]
    fn adl_full_positive_bar() {
        // close==high → mfm=1, mfv=volume, adl=volume
        let bars = vec![candle(10.0, 8.0, 10.0, 500.0)];
        let out = Adl::new().calculate(&bars).unwrap();
        let vals = out.get("ADL").unwrap();
        // mfm = ((10-8)-(10-10))/(10-8) = 2/2 = 1; mfv = 500
        assert!((vals[0] - 500.0).abs() < 1e-9, "got {}", vals[0]);
    }

    #[test]
    fn adl_is_cumulative() {
        // Two identical bars: ADL[1] = 2 * ADL[0]
        let bars = vec![candle(10.0, 8.0, 9.0, 100.0); 2];
        let out = Adl::new().calculate(&bars).unwrap();
        let vals = out.get("ADL").unwrap();
        assert!((vals[1] - 2.0 * vals[0]).abs() < 1e-9);
    }

    #[test]
    fn factory_creates_adl() {
        let ind = factory(&HashMap::new()).unwrap();
        assert_eq!(ind.name(), "ADL");
    }
}