rsta 0.1.0

Technical analysis indicators, streaming signals, and a single-asset backtesting engine for Rust
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use crate::indicators::utils::{validate_data_length, validate_period};
use crate::indicators::{Candle, Indicator, IndicatorError};
use std::collections::VecDeque;

/// Weighted Moving Average (WMA) indicator.
///
/// Linearly weighted: the most recent value gets weight `period`, the oldest
/// gets weight `1`. Weights sum to `period * (period + 1) / 2`.
///
/// # Example
/// ```
/// use rsta::indicators::trend::Wma;
/// use rsta::indicators::Indicator;
///
/// let mut wma = Wma::new(3).unwrap();
/// // Weights are 1, 2, 3 → (1*1 + 2*2 + 3*3) / 6 = 14/6 ≈ 2.333.
/// let out = wma.calculate(&[1.0_f64, 2.0, 3.0]).unwrap();
/// assert!((out[0] - (14.0 / 6.0)).abs() < 1e-12);
/// ```
#[derive(Debug)]
pub struct Wma {
    period: usize,
    buffer: VecDeque<f64>,
}

impl Wma {
    /// Create a new WMA. `period >= 1`.
    pub fn new(period: usize) -> Result<Self, IndicatorError> {
        validate_period(period, 1)?;
        Ok(Self {
            period,
            buffer: VecDeque::with_capacity(period),
        })
    }

    /// Reset internal state without dropping the configured period.
    pub fn reset_state(&mut self) {
        self.buffer.clear();
    }

    fn weighted(buffer: &VecDeque<f64>, period: usize) -> f64 {
        let n = period as f64;
        let denom = n * (n + 1.0) / 2.0;
        let mut numer = 0.0;
        for (i, v) in buffer.iter().enumerate() {
            // Most-recent value (last in buffer) gets the highest weight.
            numer += (i as f64 + 1.0) * v;
        }
        numer / denom
    }

    fn step(&mut self, value: f64) -> Option<f64> {
        self.buffer.push_back(value);
        if self.buffer.len() > self.period {
            self.buffer.pop_front();
        }
        if self.buffer.len() < self.period {
            return None;
        }
        Some(Self::weighted(&self.buffer, self.period))
    }
}

impl Indicator<f64, f64> for Wma {
    fn calculate(&mut self, data: &[f64]) -> Result<Vec<f64>, IndicatorError> {
        validate_data_length(data, self.period)?;
        self.reset_state();
        let mut out = Vec::with_capacity(data.len() - self.period + 1);
        for &v in data {
            if let Some(x) = self.step(v) {
                out.push(x);
            }
        }
        Ok(out)
    }

    fn next(&mut self, value: f64) -> Result<Option<f64>, IndicatorError> {
        Ok(self.step(value))
    }

    fn reset(&mut self) {
        self.reset_state();
    }

    fn name(&self) -> &'static str {
        "Wma"
    }

    fn period(&self) -> Option<usize> {
        Some(self.period)
    }
}

impl Indicator<Candle, f64> for Wma {
    fn calculate(&mut self, data: &[Candle]) -> Result<Vec<f64>, IndicatorError> {
        validate_data_length(data, self.period)?;
        self.reset_state();
        let mut out = Vec::with_capacity(data.len() - self.period + 1);
        for c in data {
            if let Some(x) = self.step(c.close) {
                out.push(x);
            }
        }
        Ok(out)
    }

    fn next(&mut self, candle: Candle) -> Result<Option<f64>, IndicatorError> {
        Ok(self.step(candle.close))
    }

    fn reset(&mut self) {
        self.reset_state();
    }

    fn name(&self) -> &'static str {
        "Wma"
    }

    fn period(&self) -> Option<usize> {
        Some(self.period)
    }
}

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

    #[test]
    fn validates_period() {
        assert!(Wma::new(0).is_err());
        assert!(Wma::new(1).is_ok());
    }

    #[test]
    fn weighting_is_linear() {
        let mut wma = Wma::new(3).unwrap();
        let out = <Wma as Indicator<f64, f64>>::calculate(&mut wma, &[1.0, 2.0, 3.0]).unwrap();
        assert!((out[0] - (14.0 / 6.0)).abs() < 1e-12);
    }

    #[test]
    fn batch_matches_streaming() {
        let prices: Vec<f64> = (1..=20).map(|i| i as f64).collect();
        let mut batch = Wma::new(5).unwrap();
        let batch_out = <Wma as Indicator<f64, f64>>::calculate(&mut batch, &prices).unwrap();
        let mut stream = Wma::new(5).unwrap();
        let stream_out: Vec<_> = prices
            .iter()
            .filter_map(|&p| <Wma as Indicator<f64, f64>>::next(&mut stream, p).unwrap())
            .collect();
        assert_eq!(batch_out, stream_out);
    }
}