rsi 0.1.2

A lightweight RSI library in 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

//! Relative Strength Index for technical analysis.
//!
//! Written by Xylex AI, 2024
//!
use polars::prelude::*;

pub mod rsi;
pub mod errors;
pub mod helper;

use helper::Helpers;
use rsi::{
    PriceChange,
    RollingMean,
    FinalRS,
    FinalRSI
};


#[derive(Clone)]
pub struct RelativeStrengthIndexLazyFrame {
    pub lazyframe: LazyFrame,
    pub period: usize
}


#[derive(Clone)]
pub struct RelativeStrengthIndexDataFrame {
    pub dataframe: DataFrame,
    pub period: usize
}


impl RelativeStrengthIndexLazyFrame {
    pub fn new(
        lazyframe: LazyFrame,
        period: usize
    ) -> Self {
        Self {
            lazyframe,
            period
        }
    }
}


impl RelativeStrengthIndexDataFrame {
    pub fn new(
        dataframe: DataFrame,
        period: usize
    ) -> Self {
        let lazyframe: LazyFrame = Helpers::convert_dataframe_to_lazyframe(dataframe)
            .expect("Failed to convert DataFrame to LazyFrame");
        Self {
            dataframe: lazyframe.collect().unwrap(),
            period
        }
    }
}


#[derive(Clone)]
pub struct RelativeStrengthIndex {
    pub lazyframe: LazyFrame,
    pub period: usize
}


impl RelativeStrengthIndex {
    pub fn new(
        dataframe: DataFrame,
        period: usize
    ) -> Self {

        let dataframe_normalized: DataFrame = Helpers::normalize_dataframe(dataframe.clone());
        let lazyframe: LazyFrame = Helpers::convert_dataframe_to_lazyframe(dataframe_normalized)
            .expect("Failed to convert DataFrame to LazyFrame");

        let lazyframe: LazyFrame = PriceChange::calculate_price_change(lazyframe.clone())
            .expect("Failed to calculate price change");

        let lazyframe: LazyFrame = RollingMean::period_rolling_mean(lazyframe.clone(), period as i64)
            .expect("Failed to calculate rolling mean");

        let lazyframe: LazyFrame = FinalRS::calculate_final_rs(lazyframe.clone())
            .expect("Failed to calculate final RS");

        let lazyframe: LazyFrame = FinalRSI::calculate_final_rsi(lazyframe.clone()).expect("Failed to calculate final RSI");

        let lazyframe: LazyFrame = remerge_dataframe(
            dataframe.clone(),
            lazyframe.clone().collect().unwrap()
        ).expect("Failed to remerge dataframe");

        Self {
            lazyframe,
            period
        }
    }
}


fn remerge_dataframe(
    mut dataframe: DataFrame,
    dataframe_normalized: DataFrame
) -> Result<LazyFrame, PolarsError> {

    // Drop the first row of the original dataframe
    dataframe = dataframe.slice(1, dataframe.height() - 1);

    // remerge the normalized dataframe with the original dataframe
    // take the rsi column from the normalized dataframe and add it to the original dataframe
    let rsi_column: Series = dataframe_normalized.column("rsi").unwrap().clone();


    // hstack
    let dataframe: DataFrame = dataframe.hstack(
        &[
            rsi_column
        ])?;

    let lazyframe: LazyFrame = dataframe.lazy();

    Ok(lazyframe)
}