kestrel-chartkit 0.1.0

High-performance Rust technical analysis library for indicator math, market regime classification, composite scoring, and SVG visualization.
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 super::{Indicator, IndicatorAlert, IndicatorOutput};
use crate::model::Bar;

/// Negative Volume Index (NVI) Engine.
/// Updates index value only on days when volume decreases.
#[derive(Debug, Clone)]
pub struct NviEngine {
    nvi: f64,
    prev_bar: Option<Bar>,
}

impl NviEngine {
    pub fn new() -> Self {
        Self {
            nvi: 1000.0,
            prev_bar: None,
        }
    }
}

impl Default for NviEngine {
    fn default() -> Self {
        Self::new()
    }
}

impl Indicator for NviEngine {
    fn name(&self) -> &str {
        "nvi"
    }

    fn warmup_period(&self) -> usize {
        1
    }

    fn reset(&mut self) {
        self.nvi = 1000.0;
        self.prev_bar = None;
    }

    fn on_bar(&mut self, bar: &Bar) -> Option<IndicatorOutput> {
        let prev = match &self.prev_bar {
            Some(p) => p.clone(),
            None => {
                self.prev_bar = Some(bar.clone());
                return Some(IndicatorOutput::new(self.nvi));
            }
        };
        self.prev_bar = Some(bar.clone());

        if bar.volume < prev.volume {
            let roc = if prev.close > 0.0 {
                (bar.close - prev.close) / prev.close
            } else {
                0.0
            };
            self.nvi += self.nvi * roc;
        }

        Some(IndicatorOutput::new(self.nvi))
    }

    fn alerts(&self) -> Vec<IndicatorAlert> {
        Vec::new()
    }
}

/// Positive Volume Index (PVI) Engine.
/// Updates index value only on days when volume increases.
#[derive(Debug, Clone)]
pub struct PviEngine {
    pvi: f64,
    prev_bar: Option<Bar>,
}

impl PviEngine {
    pub fn new() -> Self {
        Self {
            pvi: 1000.0,
            prev_bar: None,
        }
    }
}

impl Default for PviEngine {
    fn default() -> Self {
        Self::new()
    }
}

impl Indicator for PviEngine {
    fn name(&self) -> &str {
        "pvi"
    }

    fn warmup_period(&self) -> usize {
        1
    }

    fn reset(&mut self) {
        self.pvi = 1000.0;
        self.prev_bar = None;
    }

    fn on_bar(&mut self, bar: &Bar) -> Option<IndicatorOutput> {
        let prev = match &self.prev_bar {
            Some(p) => p.clone(),
            None => {
                self.prev_bar = Some(bar.clone());
                return Some(IndicatorOutput::new(self.pvi));
            }
        };
        self.prev_bar = Some(bar.clone());

        if bar.volume > prev.volume {
            let roc = if prev.close > 0.0 {
                (bar.close - prev.close) / prev.close
            } else {
                0.0
            };
            self.pvi += self.pvi * roc;
        }

        Some(IndicatorOutput::new(self.pvi))
    }

    fn alerts(&self) -> Vec<IndicatorAlert> {
        Vec::new()
    }
}

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

    #[test]
    fn test_nvi_pvi() {
        let mut nvi = NviEngine::new();
        let mut pvi = PviEngine::new();

        let b1 = Bar::new(1, 100.0, 105.0, 95.0, 100.0, 1000.0);
        let b2 = Bar::new(2, 100.0, 105.0, 95.0, 105.0, 500.0); // Volume decreased -> NVI updates

        nvi.on_bar(&b1);
        pvi.on_bar(&b1);

        let out_nvi = nvi.on_bar(&b2).unwrap();
        let out_pvi = pvi.on_bar(&b2).unwrap();

        assert_eq!(out_nvi.value, 1050.0);
        assert_eq!(out_pvi.value, 1000.0);
    }
}