Rusty-talib

Rusty-talib is a technical analysis library written in pure Rust, providing various methods for calculating technical indicators.

Features

• Provides various technical analysis tools including overlap studies, momentum indicators, volume indicators, and more.
• Allows enabling or disabling specific feature modules as needed.

Usage

To use Rusty-talib, you can add it as a dependency and select specific feature modules to enable as needed. For example:

[dependencies]
rusty-talib = { version = "0.1.0", features = ["overlap_studies"] }

Feature Modules

Rusty-talib includes the following feature modules:

• Overlap Studies
• Momentum Indicators
• Volume Indicators
• Volatility Indicators
• Price Transform
• Cycle Indicators
• Pattern Recognition
• Statistical Functions
• Math Transform
• Math Operators

Overlap Studies

Momentum Indicators

Volume Indicators

Volatility Indicators

Price Transform

Cycle Indicators

Pattern Recognition

Statistic Functions

Math Transform Functions

Math Operator Functions

Example

use rand;
use rusty_talib;
use rusty_talib::ErrorMsg;
use polars::prelude::*;

fn main(){
    let random_data: [i32; 7] = [23, 25, 12, 28, 33, 31, 35];
    let close = Series::new("data",random_data);
    let ma = rusty_talib::moving_average(&close,Some(3));
    match res {
        Ok(ma) => {
            assert_eq!(ma.len(),close.len());
            eprintln!("{:?}",ma);
        },
        Err(e) => {
            if let Some(my_error) = e.downcast_ref::<ErrorMsg>() {
                eprintln!("{}", my_error.0);
            } else {
                eprintln!("An error occurred");
            }
        }
    }
    

}

// import polars lib 
use polars::prelude::*;
// Import the rusty-talib library in your Rust project
use rusty_talib;

let random_data: [i32; 7] = [23, 25, 12, 28, 33, 31, 35];
let close = Series::new("data",random_data);
// Use a specific function from the overlap studies feature module
let result = rusty_talib::moving_average(close,2);
// Series type 
eprintln!("{:?}",result);

Casting Series to Vec< f64>

// import Float64Array
use polars::export::arrow::array::{Float64Array};

let array = result.to_arrow(0);

let vec_values = match array.as_any().downcast_ref::<Float64Array>() {
    Some(float_array) => {
        let values: &[f64] = float_array.values();
        let vec_values: Vec<f64> = values.to_vec();
        vec_values
    }
    None => return Err("Failed to downcast to Float64Array".into()),
};
eprintln!("{:?}",vec_values);

Casting Series to single data

// pull single data from Series type result
for i in 1..result.len() {
    let elem :f64= src.get(i)?.try_extract::<f64>()?;
    eprintln!("{:?}",elem);
}

License

This project is licensed under the MIT License.

Feel free to customize the content further as needed.