add helper

Author: uyplayer

Cargo.lock

@@ -20,4 +20,4 @@ path = "src/main.rs"
 
 [dependencies]
 polars = { version = "^0.32.1", features = ["lazy","describe"] }
-
+rand = "0.8.5"

Cargo.toml

@@ -19,5 +19,6 @@
 
 
 mod lorentzian_classification;
-pub use lorentzian_classification::{rational_quadratic,rational_quadratic_tv,gaussian,gaussian_tv};
+pub use lorentzian_classification::{rational_quadratic,rational_quadratic_tv,gaussian,gaussian_tv,normalizer,rescale,rma_indicator,Settings,Filters,KernelFilter,Direction};
+
 

src/lib.rs

@@ -7,4 +7,148 @@
  * @Dir: tech_analysis / src/lorentzian_classification
  * @Project_Name: tech_analysis
  * @Description:
- */
+ */
+
+//! Helper functions for data manipulation
+
+use polars::export::arrow::array::{Float64Array};
+use polars::prelude::*;
+
+
+/// Normalizes the values of the input series to a given range.
+///
+/// # Arguments
+/// * `src` - The input series
+/// * `min_val` - The minimum value of the range to normalize to
+/// * `max_val` - The maximum value of the range to normalize to
+///
+/// # Returns
+/// The normalized series.s
+pub fn normalizer<'a>(src: &'a Series, min_val: f64, max_val: f64) -> Result<Series, Box<dyn std::error::Error>> {
+    let array = src.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 or Int64Array".into()),
+    };
+    let actual_min_val = vec_values
+        .iter()
+        .min_by(|x, y| x.partial_cmp(y).unwrap())
+        .ok_or("Failed to find the minimum value in vec_values")?;
+
+    let actual_max_val = vec_values
+        .iter()
+        .max_by(|x, y| x.partial_cmp(y).unwrap())
+        .ok_or("Failed to find the maximum value in vec_values")?;
+
+    let scaled_values: Vec<f64> = vec_values
+        .iter()
+        .map(|&x| (x - actual_min_val) / (actual_max_val - actual_min_val) * (max_val - min_val) + min_val)
+        .collect();
+
+    Ok(Series::new("date", scaled_values))
+
+
+}
+
+/// Rescales the values of the input series from one bounded range to another bounded range.
+///
+/// # Arguments
+/// * `src` - The input series
+/// * `old_min` - The minimum value of the range to rescale from
+/// * `old_max` - The maximum value of the range to rescale from
+/// * `new_min` - The minimum value of the range to rescale to
+/// * `new_max` - The maximum value of the range to rescale to
+///
+/// # Returns
+/// The rescaled series
+pub  fn rescale<'a>(src: &'a Series, old_min: f64, old_max: f64, new_min: f64, new_max: f64) -> Result<Series, Box<dyn std::error::Error>>  {
+    let array = src.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 or Int64Array".into()),
+    };
+    let epsilon = 10e-10;
+    let vec_values = vec_values.iter()
+        .map(|x| new_min + (new_max - new_min) * (x - old_min) / f64::max(old_max - old_min, epsilon))
+        .collect::<Vec<f64>>();
+    Ok(Series::new("date", vec_values))
+}
+
+
+/// Computes the Rolling Moving Average (RMA) of the input series and then calculates the Exponential
+/// Weighted Moving Average (EWMA) using the RMA values.
+///
+/// # Arguments
+///
+/// * `src` - The input series.
+/// * `length` - The length of the rolling window.
+///
+/// # Returns
+///
+/// The series containing the EWMA values.
+pub fn rma_indicator(src: &Series, length: i32)->Result<Series, Box<dyn std::error::Error>> {
+
+    let rolling = src.rolling_mean( length as usize)?;
+    let mut ewma: Vec<Option<f64>> = vec![];
+    let alpha = 2.0 / (length + 1) as f64;
+
+    let mut prev_ema = None;
+    for opt in rolling.into_iter() {
+        if let Some(val) = opt {
+            match prev_ema {
+                Some(prev) => {
+                    let ema = alpha * val + (1.0 - alpha) * prev;
+                    ewma.push(Some(ema));
+                    prev_ema = Some(ema);
+                }
+                None => {
+                    ewma.push(Some(val));
+                    prev_ema = Some(val);
+                }
+            }
+        } else {
+            ewma.push(None);
+            prev_ema = None;
+        }
+    }
+    Ok(Series::new("data", &ewma))
+
+}
+
+#[cfg(test)]
+mod tests {
+    use rand::Rng;
+    use super::*;
+
+    #[test]
+    fn test_normalizer()->Result<(), Box<dyn std::error::Error>>{
+        let mut rng = rand::thread_rng();
+        let random_data: Vec<f64> = (0..1000).map(|_| rng.gen_range(1.0..2000.0)).collect();
+        let src =  Series::new("data", random_data);
+        let res = normalizer(&src, -2.0, 2.0)?;
+        eprintln!("{:?}", res);
+        Ok(())
+    }
+    #[test]
+    fn test_rescale()->Result<(), Box<dyn std::error::Error>>{
+        let mut rng = rand::thread_rng();
+        let random_data: Vec<f64> = (0..1000).map(|_| rng.gen_range(1.0..2000.0)).collect();
+        let old_min = 1.0;
+        let old_max = 5.0;
+        let new_min = 0.0;
+        let new_max = 1.0;
+        let src =  Series::new("data", random_data);
+        let res  = rescale(&src, old_min, old_max, new_min, new_max)?;
+        eprintln!("{:?}", res);
+        Ok(())
+    }
+
+}

src/lorentzian_classification/helper.rs

@@ -11,6 +11,17 @@
 
 
 mod kernel;
-pub use kernel::{rational_quadratic,rational_quadratic_tv,gaussian,gaussian_tv};
+mod types;
 mod helper;
 
+pub use kernel::{rational_quadratic,rational_quadratic_tv,gaussian,gaussian_tv};
+pub use types::{Settings,Filters,KernelFilter,Direction};
+pub use helper::{normalizer,rescale,rma_indicator};
+
+
+
+
+
+
+
+

src/lorentzian_classification/mod.rs

@@ -9,13 +9,34 @@
  * @Description:
  */
 
+
 //! all type declared here using in lorentzian classification
 
 
 
+
+
+/// A trait for checking the configuration.
+///
+/// This trait provides a method for checking the configuration. The associated type `Output` represents
+/// the type of the output of the configuration check.
+pub trait ConfigCheck {
+    /// The type of the output of the configuration check.
+    type Output;
+
+    /// Checks the configuration.
+    ///
+    /// # Returns
+    ///
+    /// The result of the configuration check.
+    fn configuration_check(&self) -> Self::Output;
+}
+
+
+
 // settings
 /// Settings struct representing settings for a certain functionality for classification.
-# [derive(Debug)]
+# [derive(Debug,Clone,Copy,Eq, PartialEq)]
 pub struct Settings<'a>{
     /// The data source for the functionality.
     pub source:&'a str,
@@ -39,28 +60,27 @@ pub struct Settings<'a>{
 }
 // check setting params
 /// checking  Settings params validation
-impl<'a> Settings<'a> {
-    fn check_settings(&self) {
+impl ConfigCheck for Settings<'_>{
+    type Output = ();
+    fn configuration_check(&self) -> Self::Output {
         // Access each member to trigger compile-time checks
         let source  =  ["close","open","high","low","volume","vol"];
         assert!(source.contains(&self.source));
         if self.neighbors_count <= 0 {
-            panic!(" neighbors_count must be bigger than zero ")
+            panic!(" neighbors_count must be bigger than zero ");
         }
         if self.max_bars_back <= 0 {
-            panic!(" max_bars_back must be bigger than zero ")
+            panic!(" max_bars_back must be bigger than zero ");
         }
         if self.ema_period <= 1 {
-            panic!(" ema_period must be bigger than one ")
+            panic!(" ema_period must be bigger than one ");
         }
         if self.sma_period <= 1 {
-            panic!(" sma_period must be bigger than one ")
+            panic!(" sma_period must be bigger than one ");
         }
     }
-}
-
-// test for settings
 
+}
 
 // filter setting
 /// a set of filters struct  used for classification.
@@ -77,8 +97,9 @@ pub struct Filters{
     pub adx_threshold: i32,
 }
 
-impl Filters {
-    fn check_filters(&self) {
+impl ConfigCheck for Filters {
+    type Output =();
+    fn configuration_check(&self)->Self::Output {
         // Access each member to trigger compile-time checks
         if !(self.regime_threshold >= -10.0 && self.regime_threshold <= 10.0) {
             panic!("regime_threshold must be between -10.0 and 10.0");
@@ -107,6 +128,27 @@ pub struct KernelFilter {
     pub crossover_lag: i32,
 }
 
+impl  ConfigCheck for KernelFilter{
+    
+    type Output = ();
+    fn configuration_check(&self) -> Self::Output {
+
+        if self.look_back_window < 0 {
+            panic!("look_back_window must be greater tha 0");
+        }
+        if self.relative_weight < 0.0 {
+            panic!("relative_weight must be greater tha 0");
+        }
+        if self.regression_level < 0.0 {
+            panic!("regression_level must be greater tha 0");
+        }
+        if self.crossover_lag < 0 {
+            panic!("regression_level must be greater tha 0");
+        }
+
+    }
+    
+}
 
 // market trend direction
 pub enum Direction{
@@ -115,8 +157,9 @@ pub enum Direction{
     NEUTRAL = 0,
 }
 
+// unit tes
 #[cfg(test)]
-mod test{
+mod tests {
     use super::*;
 
     #[test]
@@ -132,7 +175,7 @@ mod test{
             use_sma_filter: true,
             sma_period: 20,
         };
-        settings.check_settings();
+        settings.configuration_check();
     }
     #[test]
     fn test_filters() {
@@ -143,23 +186,29 @@ mod test{
             regime_threshold: 0.0,
             adx_threshold: 10,
         };
-        filters.check_filters();
+        filters.configuration_check();
     }
     #[test]
     fn test_kernel_filter(){
-        let _ = KernelFilter{
+        let kernel = KernelFilter{
             show_kernel_estimate: false,
             use_kernel_smoothing: false,
             look_back_window: 0,
             relative_weight: 0.0,
             regression_level: 0.0,
             crossover_lag: 0,
         };
+        kernel.configuration_check();
     }
     #[test]
     fn test_direction(){
         let _ = Direction::LONG;
         let _ = Direction::SHORT;
         let _ = Direction::NEUTRAL;
     }
+
+    #[test]
+    fn test_finish(){
+        eprintln!("finished");
+    }
 }