Merge pull request #1 from Flicker-Finance/0.1.1.r.c

feat(improvements): changing logic, fixing bugs and adding tests and docs

Author: grep-o

.github/workflows/rust.yml

@@ -0,0 +1,22 @@
+name: Rust
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose

src/lib.rs

@@ -1,47 +1,54 @@
 pub mod v1 {
     pub mod atr {
+        mod __tests__;
         pub mod main;
     }
     pub mod bollinger {
+        mod __tests__;
         pub mod main;
         pub mod types;
     }
     pub mod ema {
-        pub mod __tests__;
+        mod __tests__;
         pub mod main;
     }
     pub mod ma {
+        mod __tests__;
         pub mod main;
     }
     pub mod macd {
-        pub mod __tests__;
+        mod __tests__;
         pub mod main;
         pub mod types;
     }
 
     pub mod rsi {
-        pub mod __tests__;
+        mod __tests__;
         pub mod main;
         pub mod types;
     }
     pub mod sma {
-        pub mod __tests__;
+        mod __tests__;
         pub mod main;
         pub mod types;
     }
     pub mod roc {
+        mod __tests__;
         pub mod main;
         pub mod types;
     }
     pub mod momentum {
+        mod __tests__;
         pub mod main;
         pub mod types;
     }
     pub mod stochastic {
+        mod __tests__;
         pub mod main;
         pub mod types;
     }
     pub mod support_resistance {
+        mod _tests__;
         pub mod main;
         pub mod types;
     }

src/v1/atr/__tests__.rs

@@ -0,0 +1,49 @@
+#[cfg(test)]
+mod tests {
+    use crate::v1::atr::main::ATR;
+
+    #[test]
+    fn test_insufficient_data() {
+        let mut atr = ATR::new(5);
+        // Feed fewer than 5 values.
+        for price in [100.0, 101.0, 102.0, 103.0] {
+            assert!(atr.calculate(price).is_none());
+        }
+    }
+
+    #[test]
+    fn test_atr_calculation() {
+        let mut atr = ATR::new(3);
+        // For a period of 3, we need exactly 3 true range values.
+        // Let’s feed: first price: 100.0 (no true range), then 102.0, then 101.0, then 103.0.
+        // True ranges will be:
+        // - When 102.0 is fed: |102.0 - 100.0| = 2.0
+        // - When 101.0 is fed: |101.0 - 102.0| = 1.0
+        // - When 103.0 is fed: |103.0 - 101.0| = 2.0
+        // The sliding window will then be [2.0, 1.0, 2.0] and ATR = (2+1+2)/3 = 1.67 approximately.
+        let prices = vec![100.0, 102.0, 101.0, 103.0];
+        let mut result = None;
+        for price in prices {
+            result = atr.calculate(price);
+        }
+        let atr_value = result.unwrap();
+        assert!((atr_value - 1.67).abs() < 0.05);
+    }
+
+    #[test]
+    fn test_sliding_window_update() {
+        let mut atr = ATR::new(3);
+        // Feed more than 3 values to ensure the window slides correctly.
+        let prices = vec![100.0, 102.0, 101.0, 103.0, 104.0];
+        let mut last_atr = None;
+        for price in prices {
+            last_atr = atr.calculate(price);
+        }
+        // When the window has slid, the ATR should be calculated using the latest 3 true ranges.
+        // Let's compute them:
+        // For prices: [101.0, 103.0, 104.0]
+        // True ranges: |103.0 - 101.0| = 2.0, |104.0 - 103.0| = 1.0, and the first true range (for price 101.0) would be from the previous sliding window.
+        // However, for this test we simply check that an ATR is produced.
+        assert!(last_atr.is_some());
+    }
+}

src/v1/atr/main.rs

@@ -1,26 +1,89 @@
+//! # Average True Range (ATR) Module
+//!
+//! This module implements a simplified Average True Range (ATR) indicator.
+//! In this version, the true range is calculated as the absolute difference between the
+//! current closing price and the previous closing price. (Note that the full ATR calculation
+//! typically uses the high, low, and previous close values, but this simplified version
+//! uses only the close values.)
+//!
+//! The ATR is computed as the average of the true range over a specified period.
+//!
+//! # Examples
+//!
+//! ```rust
+//! use indexes_rs::v1::atr::main::ATR;
+//!
+//! // Create an ATR indicator with a period of 14
+//! let mut atr = ATR::new(14);
+//!
+//! // Feed a series of closing prices
+//! let prices = vec![100.0, 101.0, 100.5, 102.0, 101.5, 102.5, 103.0, 102.0, 101.0, 100.0,
+//!                   100.5, 101.0, 102.0, 101.5, 102.5];
+//!
+//! for price in prices {
+//!     if let Some(atr_value) = atr.calculate(price) {
+//!         println!("ATR: {:.2}", atr_value);
+//!     }
+//! }
+//! ```
+
+use std::collections::VecDeque;
+
+/// A simplified Average True Range (ATR) indicator.
+///
+/// This ATR calculates the true range as the absolute difference between the current closing price and the previous closing price.
+/// It then computes the ATR as the average of these true ranges over a specified period.
 pub struct ATR {
+    /// The period over which to calculate the ATR.
     period: usize,
+    /// A sliding window of true range values.
+    values: VecDeque<f64>,
+    /// The previous closing price.
     prev_close: Option<f64>,
-    values: Vec<f64>,
 }
 
 impl ATR {
+    /// Creates a new ATR indicator with the specified period.
+    ///
+    /// # Arguments
+    ///
+    /// * `period` - The number of periods over which to calculate the ATR.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use indexes_rs::v1::atr::main::ATR;
+    ///
+    /// let atr = ATR::new(14);
+    /// ```
     pub fn new(period: usize) -> Self {
         ATR {
             period,
+            values: VecDeque::with_capacity(period),
             prev_close: None,
-            values: Vec::new(),
         }
     }
 
+    /// Calculates the current ATR value using the latest closing price.
+    ///
+    /// The true range is computed as the absolute difference between the current closing price and the previous closing price.
+    /// This true range is stored in a sliding window; once the window contains `period` values, the ATR is returned as their average.
+    ///
+    /// # Arguments
+    ///
+    /// * `close` - The latest closing price.
+    ///
+    /// # Returns
+    ///
+    /// * `Some(f64)` containing the ATR value if enough data is available.
+    /// * `None` if there aren't enough values yet.
     pub fn calculate(&mut self, close: f64) -> Option<f64> {
-        let true_range = self.prev_close.map_or(0.0, |prev| {
-            (close - prev).abs() // Using price change as true range
-        });
+        // Compute the true range based on the previous close, or 0.0 if none exists.
+        let true_range = self.prev_close.map_or(0.0, |prev| (close - prev).abs());
 
-        self.values.push(true_range);
+        self.values.push_back(true_range);
         if self.values.len() > self.period {
-            self.values.remove(0);
+            self.values.pop_front();
         }
 
         self.prev_close = Some(close);

src/v1/bollinger/__tests__.rs

@@ -0,0 +1,33 @@
+#[cfg(test)]
+mod tests {
+    use crate::v1::bollinger::{main::BollingerBands, types::BBResult};
+
+    #[test]
+    fn test_insufficient_data() {
+        let mut bb = BollingerBands::new(5, 2.0).unwrap();
+        // Feed fewer than 5 prices.
+        for price in [100.0, 101.0, 102.0, 103.0] {
+            assert!(bb.calculate(price).is_none());
+        }
+    }
+
+    #[test]
+    fn test_bollinger_bands_calculation() {
+        let mut bb = BollingerBands::new(3, 2.0).unwrap();
+        // Provide exactly 3 prices.
+        let prices = vec![100.0, 102.0, 104.0];
+        let mut result = None;
+        for price in prices {
+            result = bb.calculate(price);
+        }
+        let res: BBResult = result.unwrap();
+        // The middle band should be the SMA of [100, 102, 104] which is 102.0.
+        // Standard deviation = sqrt(((100-102)² + (102-102)² + (104-102)²)/3)
+        //                  = sqrt((4 + 0 + 4) / 3) = sqrt(8/3) ≈ 1.633
+        // Band width = 1.633 * 2.0 ≈ 3.266
+        // Upper band ≈ 102 + 3.266 = 105.266, Lower band ≈ 102 - 3.266 = 98.734.
+        assert!((res.middle - 102.0).abs() < 1e-6);
+        assert!((res.upper - 105.266).abs() < 0.01);
+        assert!((res.lower - 98.734).abs() < 0.01);
+    }
+}