financial_indicators 0.1.0

A library providing various financial algorithms including but not limited to the following - KDJ — MACD
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

//! The `kdj` module provides functionality to calculate the KDJ indicator for stock prices.
//!
//!  The KDJ indicator consists of three components:
//! - K: Stochastic indicator
//! - D: Oscillator
//! - J: Derived from K and D
//!
//! # Example
//!
//! ```
//! use financial_indicators::kdj::{calculate_kdj, OHLC};
//!
//! let prices = vec![
//!     OHLC { close: 10.0, high: 12.0, low: 8.0 },
//!     OHLC { close: 11.0, high: 13.0, low: 9.0 },
//!     OHLC { close: 12.0, high: 14.0, low: 10.0 },
//!     OHLC { close: 11.5, high: 13.5, low: 10.5 },
//!     OHLC { close: 13.0, high: 15.0, low: 11.0 },
//! ];
//!
//! let (k_values, d_values, j_values) = calculate_kdj(&prices, 3);
//! println!("K values: {:?}", k_values);
//! println!("D values: {:?}", d_values);
//! println!("J values: {:?}", j_values);
//! ```
//!

/// Represents the open-high-low-close (OHLC) data for a single trading period.
#[derive(Debug)]
pub struct OHLC {
    pub close: f64,
    pub high: f64,
    pub low: f64,
}

/// Calculates the KDJ indicator for a given set of OHLC data over a specified period.
///
/// # Parameters
///
/// - `prices`: A slice of OHLC data points.
/// - `period`: The number of periods to use for the calculation.
///
/// # Returns
///
/// A tuple containing three vectors: K values, D values, and J values.
///
/// # Example
///
/// ```
/// use financial_indicators::kdj::{calculate_kdj, OHLC};
///
/// let prices = vec![
///     OHLC { close: 10.0, high: 12.0, low: 8.0 },
///     OHLC { close: 11.0, high: 13.0, low: 9.0 },
///     OHLC { close: 12.0, high: 14.0, low: 10.0 },
///     OHLC { close: 11.5, high: 13.5, low: 10.5 },
///     OHLC { close: 13.0, high: 15.0, low: 11.0 },
/// ];
///
/// let (k_values, d_values, j_values) = calculate_kdj(&prices, 3);
/// assert_eq!(k_values.len(), 5);
/// assert_eq!(d_values.len(), 5);
/// assert_eq!(j_values.len(), 5);
/// ```

pub fn calculate_kdj(prices: &[OHLC], period: usize) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
    let mut k_values = vec![];
    let mut d_values = vec![];
    let mut j_values = vec![];
    let mut k = 50.0;
    let mut d = 50.0;

    for i in 0..prices.len() {
        if i >= period - 1 {
            let low = prices[i + 1 - period..=i]
                .iter()
                .map(|p| p.low)
                .fold(f64::INFINITY, f64::min);
            let high = prices[i + 1 - period..=i]
                .iter()
                .map(|p| p.high)
                .fold(f64::NEG_INFINITY, f64::max);
            let close = prices[i].close;

            let rsv = if high != low {
                (close - low) / (high - low) * 100.0
            } else {
                50.0
            };

            k = (2.0 / 3.0) * k + (1.0 / 3.0) * rsv;
            d = (2.0 / 3.0) * d + (1.0 / 3.0) * k;
            let j = 3.0 * k - 2.0 * d;

            k_values.push(k);
            d_values.push(d);
            j_values.push(j);
        } else {
            k_values.push(k);
            d_values.push(d);
            j_values.push(3.0 * k - 2.0 * d);
        }
    }

    (k_values, d_values, j_values)
}

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

    #[test]
    fn test_kdj_calculation() {
        let prices = vec![
            OHLC {
                close: 10.0,
                high: 12.0,
                low: 8.0,
            },
            OHLC {
                close: 11.0,
                high: 13.0,
                low: 9.0,
            },
            OHLC {
                close: 12.0,
                high: 14.0,
                low: 10.0,
            },
            OHLC {
                close: 11.5,
                high: 13.5,
                low: 10.5,
            },
            OHLC {
                close: 13.0,
                high: 15.0,
                low: 11.0,
            },
        ];

        let (k_values, d_values, j_values) = calculate_kdj(&prices, 3);

        assert_eq!(k_values.len(), 5);
        assert_eq!(d_values.len(), 5);
        assert_eq!(j_values.len(), 5);

        println!("K values: {:?}", k_values);
        println!("D values: {:?}", d_values);
        println!("J values: {:?}", j_values);
    }
}