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
85
86
87
88
89
90
91
92
93
94
95
96

use polars::prelude::*;

/// Calculates the Williams %R oscillator
///
/// Williams %R is a momentum indicator that moves between 0 and -100 and
/// measures overbought/oversold levels. It's particularly useful for intraday trading
/// to identify potential reversals.
///
/// # Arguments
///
/// * `df` - DataFrame containing OHLCV data with "high", "low", and "close" columns
/// * `window` - Lookback period for the calculation (typically 14)
///
/// # Returns
///
/// * `PolarsResult<Series>` - Series containing Williams %R values named "williams_r_{window}"
///
/// # Formula
///
/// Williams %R = ((Highest High - Close) / (Highest High - Lowest Low)) * -100
///
/// # Example
///
/// ```
/// use polars::prelude::*;
/// use ta_lib_in_rust::indicators::oscillators::calculate_williams_r;
///
/// // Create or load a DataFrame with OHLCV data
/// let df = DataFrame::default(); // Replace with actual data
///
/// // Calculate Williams %R with period 14
/// let williams_r = calculate_williams_r(&df, 14).unwrap();
/// ```
pub fn calculate_williams_r(df: &DataFrame, window: usize) -> PolarsResult<Series> {
    // Validate required columns
    if !df.schema().contains("high")
        || !df.schema().contains("low")
        || !df.schema().contains("close")
    {
        return Err(PolarsError::ShapeMismatch(
            "Missing required columns for Williams %R calculation. Required: high, low, close"
                .to_string()
                .into(),
        ));
    }

    // Extract required columns
    let high = df.column("high")?.f64()?;
    let low = df.column("low")?.f64()?;
    let close = df.column("close")?.f64()?;

    // Calculate Williams %R
    let mut williams_r_values = Vec::with_capacity(df.height());

    // Fill initial values with NaN
    for _ in 0..window - 1 {
        williams_r_values.push(f64::NAN);
    }

    // Calculate Williams %R for the remaining data points
    for i in window - 1..df.height() {
        let mut highest_high = f64::NEG_INFINITY;
        let mut lowest_low = f64::INFINITY;
        let mut valid_data = true;

        // Find highest high and lowest low in the window
        for j in i - (window - 1)..=i {
            let h = high.get(j).unwrap_or(f64::NAN);
            let l = low.get(j).unwrap_or(f64::NAN);

            if h.is_nan() || l.is_nan() {
                valid_data = false;
                break;
            }

            highest_high = highest_high.max(h);
            lowest_low = lowest_low.min(l);
        }

        if !valid_data || (highest_high - lowest_low).abs() < 1e-10 {
            williams_r_values.push(f64::NAN);
        } else {
            let c = close.get(i).unwrap_or(f64::NAN);
            if c.is_nan() {
                williams_r_values.push(f64::NAN);
            } else {
                let williams_r = ((highest_high - c) / (highest_high - lowest_low)) * -100.0;
                williams_r_values.push(williams_r);
            }
        }
    }

    // Create Series with Williams %R values
    let name = format!("williams_r_{}", window);
    Ok(Series::new(name.into(), williams_r_values))
}