rustalib 1.0.9

A library of technical indicators for financial analysis, similar to TA-Lib
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

use crate::indicators::moving_averages::calculate_ema;
use crate::util::dataframe_utils::check_window_size;
use polars::prelude::*;

/// Calculates Moving Average Convergence Divergence (MACD)
///
/// # Arguments
///
/// * `df` - DataFrame containing the price data
/// * `fast_period` - Fast EMA period (typically 12)
/// * `slow_period` - Slow EMA period (typically 26)
/// * `signal_period` - Signal line period (typically 9)
/// * `column` - Column name to use for calculations (default "close")
///
/// # Returns
///
/// Returns a PolarsResult containing tuple of (MACD, Signal) Series
pub fn calculate_macd(
    df: &DataFrame,
    fast_period: usize,
    slow_period: usize,
    signal_period: usize,
    column: &str,
) -> PolarsResult<(Series, Series)> {
    // Check we have enough data for the longest period (slow_period)
    check_window_size(df, slow_period, "MACD")?;

    let ema_fast = calculate_ema(df, column, fast_period)?;
    let ema_slow = calculate_ema(df, column, slow_period)?;

    let macd = (&ema_fast - &ema_slow)?;

    // Create a temporary DataFrame with MACD series for calculating the signal
    let macd_series = macd.clone();
    let temp_df = DataFrame::new(vec![macd_series.with_name(column.into()).into()])?;

    // Calculate the signal line as an EMA of the MACD
    let signal = calculate_ema(&temp_df, column, signal_period)?;

    // Replace NaN values in signal with zeros at positions where MACD has values
    let macd_ca = macd.f64()?;
    let signal_ca = signal.f64()?;

    let mut signal_vec: Vec<f64> = Vec::with_capacity(signal.len());

    for i in 0..signal.len() {
        if i < slow_period - 1 {
            // Keep first slow_period-1 values as NaN to match MACD
            signal_vec.push(f64::NAN);
        } else if i < slow_period - 1 + signal_period {
            // For index positions where signal might be NaN but MACD has values,
            // use non-NaN values or 0.0
            if let Some(macd_val) = macd_ca.get(i) {
                if !macd_val.is_nan() {
                    // Signal might be NaN here, use 0.0 as initial value
                    signal_vec.push(0.0);
                } else {
                    signal_vec.push(f64::NAN);
                }
            } else {
                signal_vec.push(f64::NAN);
            }
        } else {
            // For positions where signal should have valid values
            let val = signal_ca.get(i).unwrap_or(0.0);
            if val.is_nan() && macd_ca.get(i).is_some_and(|v| !v.is_nan()) {
                signal_vec.push(0.0);
            } else {
                signal_vec.push(val);
            }
        }
    }

    let macd_name = format!("macd_{0}_{1}", fast_period, slow_period);
    let signal_name = format!(
        "macd_signal_{0}_{1}_{2}",
        fast_period, slow_period, signal_period
    );

    Ok((
        macd.with_name(macd_name.into()),
        Series::new(signal_name.into(), signal_vec),
    ))
}