tesser-indicators 0.2.3

Technical indicators and signal helpers for Tesser strategies
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

//! Average True Range indicator implementation.

use rust_decimal::Decimal;
use tesser_core::Candle;

use crate::core::{Indicator, IndicatorError};

/// Average True Range indicator.
pub struct Atr {
    period: usize,
    prev_close: Option<Decimal>,
    atr: Option<Decimal>,
    warmup_sum: Decimal,
    warmup_count: usize,
}

impl Atr {
    /// Create a new ATR indicator with the provided period.
    pub fn new(period: usize) -> Result<Self, IndicatorError> {
        if period == 0 {
            return Err(IndicatorError::invalid_period("ATR", period));
        }
        Ok(Self {
            period,
            prev_close: None,
            atr: None,
            warmup_sum: Decimal::ZERO,
            warmup_count: 0,
        })
    }

    fn true_range(&self, candle: &Candle, prev_close: Decimal) -> Decimal {
        let high_low = candle.high - candle.low;
        let high_close = (candle.high - prev_close).abs();
        let low_close = (candle.low - prev_close).abs();
        high_low.max(high_close).max(low_close)
    }
}

impl Indicator for Atr {
    type Input = Candle;
    type Output = Decimal;

    fn next(&mut self, input: Self::Input) -> Option<Self::Output> {
        let prev_close = self.prev_close.unwrap_or(input.close);
        let tr = self.true_range(&input, prev_close);
        self.prev_close = Some(input.close);

        if let Some(current) = self.atr {
            let factor = Decimal::from(self.period as i64 - 1);
            let next = (current * factor + tr) / Decimal::from(self.period as i64);
            self.atr = Some(next);
            Some(next)
        } else {
            self.warmup_sum += tr;
            self.warmup_count += 1;
            if self.warmup_count == self.period {
                let init = self.warmup_sum / Decimal::from(self.period as i64);
                self.atr = Some(init);
                self.warmup_sum = Decimal::ZERO;
                Some(init)
            } else {
                None
            }
        }
    }

    fn reset(&mut self) {
        self.prev_close = None;
        self.atr = None;
        self.warmup_sum = Decimal::ZERO;
        self.warmup_count = 0;
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::Utc;
    use tesser_core::{Interval, Symbol};

    fn candle(close: f64) -> Candle {
        Candle {
            symbol: Symbol::from("BTCUSDT"),
            interval: Interval::OneMinute,
            open: Decimal::from_f64_retain(close).unwrap(),
            high: Decimal::from_f64_retain(close + 5.0).unwrap(),
            low: Decimal::from_f64_retain(close - 5.0).unwrap(),
            close: Decimal::from_f64_retain(close).unwrap(),
            volume: Decimal::ONE,
            timestamp: Utc::now(),
        }
    }

    #[test]
    fn atr_warms_up() {
        let mut atr = Atr::new(3).unwrap();
        assert!(atr.next(candle(100.0)).is_none());
        assert!(atr.next(candle(101.0)).is_none());
        assert!(atr.next(candle(102.0)).is_some());
    }
}