@ebowwa/quant-rust 0.1.0

package/src/indicators/sr.rs

@@ -0,0 +1,195 @@
+//! Support and Resistance Indicators
+//!
+//! Tools for identifying key price levels.
+
+/// Classic Pivot Points result
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct PivotPointsResult {
+    /// Central pivot point
+    pub pivot: f64,
+    /// First resistance level
+    pub r1: f64,
+    /// Second resistance level
+    pub r2: f64,
+    /// Third resistance level
+    pub r3: f64,
+    /// First support level
+    pub s1: f64,
+    /// Second support level
+    pub s2: f64,
+    /// Third support level
+    pub s3: f64,
+}
+
+/// Fibonacci Retracement/Extension levels
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct FibonacciLevels {
+    /// 0% level (swing high for retracement)
+    pub level0: f64,
+    /// 23.6% level
+    pub level236: f64,
+    /// 38.2% level
+    pub level382: f64,
+    /// 50% level
+    pub level500: f64,
+    /// 61.8% level (golden ratio)
+    pub level618: f64,
+    /// 78.6% level
+    pub level786: f64,
+    /// 100% level (swing low for retracement)
+    pub level1000: f64,
+}
+
+/// Classic Pivot Points
+///
+/// Calculates support and resistance levels based on the
+/// previous period's high, low, and close prices.
+///
+/// # Formulas
+/// - Pivot = (High + Low + Close) / 3
+/// - R1 = 2 * Pivot - Low
+/// - S1 = 2 * Pivot - High
+/// - R2 = Pivot + (High - Low)
+/// - S2 = Pivot - (High - Low)
+/// - R3 = High + 2 * (Pivot - Low)
+/// - S3 = Low - 2 * (High - Pivot)
+///
+/// # Arguments
+/// * `high` - Period high price
+/// * `low` - Period low price
+/// * `close` - Period close price
+///
+/// # Returns
+/// A PivotPointsResult with all pivot levels.
+pub fn pivot_points(high: f64, low: f64, close: f64) -> PivotPointsResult {
+    let pivot = (high + low + close) / 3.0;
+
+    PivotPointsResult {
+        pivot,
+        r1: 2.0 * pivot - low,
+        r2: pivot + (high - low),
+        r3: high + 2.0 * (pivot - low),
+        s1: 2.0 * pivot - high,
+        s2: pivot - (high - low),
+        s3: low - 2.0 * (high - pivot),
+    }
+}
+
+/// Fibonacci Pivot Points
+///
+/// Pivot points using Fibonacci ratios instead of the classic formula.
+///
+/// # Arguments
+/// * `high` - Period high price
+/// * `low` - Period low price
+/// * `close` - Period close price
+///
+/// # Returns
+/// A PivotPointsResult with Fibonacci-based levels.
+pub fn fibonacci_pivots(high: f64, low: f64, close: f64) -> PivotPointsResult {
+    let pivot = (high + low + close) / 3.0;
+    let range = high - low;
+
+    PivotPointsResult {
+        pivot,
+        r1: pivot + 0.382 * range,
+        r2: pivot + 0.618 * range,
+        r3: pivot + 1.0 * range,
+        s1: pivot - 0.382 * range,
+        s2: pivot - 0.618 * range,
+        s3: pivot - 1.0 * range,
+    }
+}
+
+/// Fibonacci Retracement Levels
+///
+/// Calculates retracement levels between a swing high and swing low.
+/// These levels often act as support/resistance in trending markets.
+///
+/// # Arguments
+/// * `swing_high` - The swing high price (0% level)
+/// * `swing_low` - The swing low price (100% level)
+///
+/// # Returns
+/// A FibonacciLevels struct with all retracement levels.
+pub fn fibonacci_retracement(swing_high: f64, swing_low: f64) -> FibonacciLevels {
+    let diff = swing_high - swing_low;
+
+    FibonacciLevels {
+        level0: swing_high,
+        level236: swing_high - 0.236 * diff,
+        level382: swing_high - 0.382 * diff,
+        level500: swing_high - 0.5 * diff,
+        level618: swing_high - 0.618 * diff,
+        level786: swing_high - 0.786 * diff,
+        level1000: swing_low,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_pivot_points() {
+        let high = 110.0;
+        let low = 100.0;
+        let close = 105.0;
+
+        let result = pivot_points(high, low, close);
+
+        // Pivot = (110 + 100 + 105) / 3 = 105
+        assert!((result.pivot - 105.0).abs() < 1e-10);
+
+        // R1 = 2 * 105 - 100 = 110
+        assert!((result.r1 - 110.0).abs() < 1e-10);
+
+        // S1 = 2 * 105 - 110 = 100
+        assert!((result.s1 - 100.0).abs() < 1e-10);
+
+        // R2 = 105 + (110 - 100) = 115
+        assert!((result.r2 - 115.0).abs() < 1e-10);
+
+        // S2 = 105 - (110 - 100) = 95
+        assert!((result.s2 - 95.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_fibonacci_pivots() {
+        let high = 110.0;
+        let low = 100.0;
+        let close = 105.0;
+
+        let result = fibonacci_pivots(high, low, close);
+
+        // Pivot should be same as classic
+        assert!((result.pivot - 105.0).abs() < 1e-10);
+
+        // Range = 10
+        // R1 = 105 + 0.382 * 10 = 108.82
+        assert!((result.r1 - 108.82).abs() < 1e-10);
+
+        // S1 = 105 - 0.382 * 10 = 101.18
+        assert!((result.s1 - 101.18).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_fibonacci_retracement() {
+        let swing_high = 100.0;
+        let swing_low = 50.0;
+
+        let result = fibonacci_retracement(swing_high, swing_low);
+
+        // 0% level should be swing high
+        assert!((result.level0 - 100.0).abs() < 1e-10);
+
+        // 100% level should be swing low
+        assert!((result.level1000 - 50.0).abs() < 1e-10);
+
+        // 50% level
+        assert!((result.level500 - 75.0).abs() < 1e-10);
+
+        // 61.8% level (golden ratio)
+        assert!((result.level618 - 69.1).abs() < 0.1);
+    }
+}

package/src/indicators/trend.rs

@@ -0,0 +1,351 @@
+//! Trend Indicators
+//!
+//! Indicators that identify the direction and strength of market trends.
+
+use crate::utils::{max, min};
+
+/// ADX (Average Directional Index) result
+#[derive(Debug, Clone, PartialEq)]
+pub struct ADXResult {
+    /// ADX line (trend strength, 0-100)
+    pub adx: Vec<f64>,
+    /// +DI (positive directional indicator)
+    pub plus_di: Vec<f64>,
+    /// -DI (negative directional indicator)
+    pub minus_di: Vec<f64>,
+}
+
+/// Ichimoku Cloud result
+#[derive(Debug, Clone, PartialEq)]
+pub struct IchimokuResult {
+    /// Tenkan-sen (Conversion Line)
+    pub tenkan: Vec<f64>,
+    /// Kijun-sen (Base Line)
+    pub kijun: Vec<f64>,
+    /// Senkou Span A (Leading Span A)
+    pub senkou_a: Vec<f64>,
+    /// Senkou Span B (Leading Span B)
+    pub senkou_b: Vec<f64>,
+    /// Chikou Span (Lagging Span)
+    pub chikou: Vec<f64>,
+}
+
+/// Parabolic SAR result
+#[derive(Debug, Clone, PartialEq)]
+pub struct SARResult {
+    /// SAR values
+    pub sar: Vec<f64>,
+    /// Trend direction (true = uptrend, false = downtrend)
+    pub trend: Vec<bool>,
+}
+
+/// Average Directional Index (ADX)
+///
+/// Measures the strength of a trend, regardless of direction.
+/// ADX > 25 indicates a strong trend, < 20 indicates weak/no trend.
+///
+/// # Arguments
+/// * `high` - High prices
+/// * `low` - Low prices
+/// * `close` - Close prices
+/// * `period` - ADX period (default: 14)
+///
+/// # Returns
+/// An ADXResult containing ADX, +DI, and -DI values.
+pub fn adx(high: &[f64], low: &[f64], close: &[f64], period: usize) -> ADXResult {
+    if high.len() < period + 1 || period == 0 {
+        return ADXResult {
+            adx: Vec::new(),
+            plus_di: Vec::new(),
+            minus_di: Vec::new(),
+        };
+    }
+
+    // Calculate +DM and -DM
+    let mut plus_dm: Vec<f64> = vec![0.0];
+    let mut minus_dm: Vec<f64> = vec![0.0];
+
+    for i in 1..high.len() {
+        let up_move = high[i] - high[i - 1];
+        let down_move = low[i - 1] - low[i];
+
+        if up_move > down_move && up_move > 0.0 {
+            plus_dm.push(up_move);
+            minus_dm.push(0.0);
+        } else if down_move > up_move && down_move > 0.0 {
+            plus_dm.push(0.0);
+            minus_dm.push(down_move);
+        } else {
+            plus_dm.push(0.0);
+            minus_dm.push(0.0);
+        }
+    }
+
+    // Calculate ATR for DI calculation
+    let atr_result = super::atr(high, low, close, 1);
+    let tr = atr_result.tr;
+
+    // Smooth DM and TR using EMA
+    let smoothed_plus_dm = super::ema(&plus_dm, period);
+    let smoothed_minus_dm = super::ema(&minus_dm, period);
+    let smoothed_tr = super::ema(&tr, period);
+
+    // Calculate DI
+    let min_len = smoothed_plus_dm.len().min(smoothed_minus_dm.len()).min(smoothed_tr.len());
+
+    let mut plus_di: Vec<f64> = Vec::new();
+    let mut minus_di: Vec<f64> = Vec::new();
+
+    for i in 0..min_len {
+        if smoothed_tr[i] > 0.0 {
+            plus_di.push((smoothed_plus_dm[i] / smoothed_tr[i]) * 100.0);
+            minus_di.push((smoothed_minus_dm[i] / smoothed_tr[i]) * 100.0);
+        } else {
+            plus_di.push(0.0);
+            minus_di.push(0.0);
+        }
+    }
+
+    // Calculate DX and ADX
+    let mut dx: Vec<f64> = Vec::new();
+    for i in 0..plus_di.len() {
+        let di_sum = plus_di[i] + minus_di[i];
+        if di_sum > 0.0 {
+            dx.push((plus_di[i] - minus_di[i]).abs() / di_sum * 100.0);
+        } else {
+            dx.push(0.0);
+        }
+    }
+
+    let adx_values = super::ema(&dx, period);
+
+    ADXResult {
+        adx: adx_values,
+        plus_di,
+        minus_di,
+    }
+}
+
+/// Ichimoku Cloud
+///
+/// A comprehensive indicator defining support/resistance,
+/// trend direction, and momentum.
+///
+/// # Arguments
+/// * `high` - High prices
+/// * `low` - Low prices
+/// * `close` - Close prices
+/// * `tenkan_period` - Tenkan-sen period (default: 9)
+/// * `kijun_period` - Kijun-sen period (default: 26)
+/// * `senkou_b_period` - Senkou Span B period (default: 52)
+///
+/// # Returns
+/// An IchimokuResult with all five components.
+pub fn ichimoku(
+    high: &[f64],
+    low: &[f64],
+    close: &[f64],
+    tenkan_period: usize,
+    kijun_period: usize,
+    senkou_b_period: usize,
+) -> IchimokuResult {
+    if high.len() < senkou_b_period || tenkan_period == 0 || kijun_period == 0 || senkou_b_period == 0 {
+        return IchimokuResult {
+            tenkan: Vec::new(),
+            kijun: Vec::new(),
+            senkou_a: Vec::new(),
+            senkou_b: Vec::new(),
+            chikou: Vec::new(),
+        };
+    }
+
+    let mut tenkan: Vec<f64> = Vec::new();
+    let mut kijun: Vec<f64> = Vec::new();
+
+    // Calculate Tenkan-sen
+    for i in (tenkan_period - 1)..close.len() {
+        let start = i + 1 - tenkan_period;
+        let highest = max(&high[start..=i]);
+        let lowest = min(&low[start..=i]);
+        tenkan.push((highest + lowest) / 2.0);
+    }
+
+    // Calculate Kijun-sen
+    for i in (kijun_period - 1)..close.len() {
+        let start = i + 1 - kijun_period;
+        let highest = max(&high[start..=i]);
+        let lowest = min(&low[start..=i]);
+        kijun.push((highest + lowest) / 2.0);
+    }
+
+    // Senkou A (Leading Span A): (Tenkan + Kijun) / 2
+    let tenkan_offset = kijun_period - tenkan_period;
+    let mut senkou_a: Vec<f64> = Vec::new();
+    for i in 0..kijun.len() {
+        if i + tenkan_offset < tenkan.len() {
+            senkou_a.push((tenkan[i + tenkan_offset] + kijun[i]) / 2.0);
+        }
+    }
+
+    // Senkou B (Leading Span B)
+    let mut senkou_b: Vec<f64> = Vec::new();
+    for i in (senkou_b_period - 1)..close.len() {
+        let start = i + 1 - senkou_b_period;
+        let highest = max(&high[start..=i]);
+        let lowest = min(&low[start..=i]);
+        senkou_b.push((highest + lowest) / 2.0);
+    }
+
+    // Chikou (Lagging Span): Close shifted back 26 periods
+    let chikou = if close.len() > 26 {
+        close[26..].to_vec()
+    } else {
+        Vec::new()
+    };
+
+    // Align outputs
+    let senkou_b_offset = senkou_b_period - kijun_period;
+
+    IchimokuResult {
+        tenkan: tenkan[tenkan_offset..].to_vec(),
+        kijun,
+        senkou_a,
+        senkou_b: if senkou_b_offset < senkou_b.len() {
+            senkou_b[senkou_b_offset..].to_vec()
+        } else {
+            senkou_b
+        },
+        chikou,
+    }
+}
+
+/// Parabolic SAR (Stop and Reverse)
+///
+/// A trend-following indicator that sets trailing price stops
+/// for long or short positions.
+///
+/// # Arguments
+/// * `high` - High prices
+/// * `low` - Low prices
+/// * `af_start` - Starting acceleration factor (default: 0.02)
+/// * `af_increment` - AF increment (default: 0.02)
+/// * `af_max` - Maximum acceleration factor (default: 0.2)
+///
+/// # Returns
+/// A SARResult containing SAR values and trend direction.
+pub fn parabolic_sar(
+    high: &[f64],
+    low: &[f64],
+    af_start: f64,
+    af_increment: f64,
+    af_max: f64,
+) -> SARResult {
+    if high.len() < 2 {
+        return SARResult {
+            sar: Vec::new(),
+            trend: Vec::new(),
+        };
+    }
+
+    let mut sar: Vec<f64> = vec![low[0]];
+    let mut trend: Vec<bool> = vec![true]; // true = uptrend
+    let mut af = af_start;
+    let mut ep = high[0];
+
+    for i in 1..high.len() {
+        let prev_sar = sar[i - 1];
+        let current_trend = trend[i - 1];
+        let mut new_sar = prev_sar + af * (ep - prev_sar);
+
+        // SAR can't be above prior lows in uptrend
+        if current_trend {
+            let constraint = if i >= 2 {
+                low[i - 1].min(low[i - 2])
+            } else {
+                low[i - 1]
+            };
+            new_sar = new_sar.min(constraint);
+        } else {
+            let constraint = if i >= 2 {
+                high[i - 1].max(high[i - 2])
+            } else {
+                high[i - 1]
+            };
+            new_sar = new_sar.max(constraint);
+        }
+
+        // Check for trend reversal
+        if current_trend && low[i] < new_sar {
+            // Uptrend to downtrend
+            trend.push(false);
+            sar.push(ep);
+            af = af_start;
+            ep = low[i];
+        } else if !current_trend && high[i] > new_sar {
+            // Downtrend to uptrend
+            trend.push(true);
+            sar.push(ep);
+            af = af_start;
+            ep = high[i];
+        } else {
+            trend.push(current_trend);
+            sar.push(new_sar);
+
+            // Update extreme point and acceleration factor
+            if current_trend && high[i] > ep {
+                ep = high[i];
+                af = (af + af_increment).min(af_max);
+            } else if !current_trend && low[i] < ep {
+                ep = low[i];
+                af = (af + af_increment).min(af_max);
+            }
+        }
+    }
+
+    SARResult { sar, trend }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_adx() {
+        let high = vec![10.0, 12.0, 15.0, 14.0, 16.0, 18.0, 17.0, 19.0, 21.0, 20.0,
+                        22.0, 24.0, 23.0, 25.0, 27.0, 26.0, 28.0, 30.0, 29.0, 31.0,
+                        33.0, 32.0, 34.0, 36.0, 35.0, 37.0, 39.0, 38.0, 40.0, 42.0];
+        let low = vec![8.0, 9.0, 11.0, 10.0, 12.0, 14.0, 13.0, 15.0, 17.0, 16.0,
+                       18.0, 20.0, 19.0, 21.0, 23.0, 22.0, 24.0, 26.0, 25.0, 27.0,
+                       29.0, 28.0, 30.0, 32.0, 31.0, 33.0, 35.0, 34.0, 36.0, 38.0];
+        let close = vec![9.0, 11.0, 14.0, 12.0, 15.0, 17.0, 15.0, 18.0, 20.0, 18.0,
+                         21.0, 23.0, 21.0, 24.0, 26.0, 24.0, 27.0, 29.0, 27.0, 30.0,
+                         32.0, 30.0, 33.0, 35.0, 33.0, 36.0, 38.0, 36.0, 39.0, 41.0];
+
+        let result = adx(&high, &low, &close, 14);
+        assert!(!result.adx.is_empty());
+        assert!(!result.plus_di.is_empty());
+        assert!(!result.minus_di.is_empty());
+    }
+
+    #[test]
+    fn test_ichimoku() {
+        // Need enough data for all periods: max(9, 26, 52) = 52 minimum + extra for chikou shift
+        let high: Vec<f64> = (1..=80).map(|x| x as f64 * 1.1).collect();
+        let low: Vec<f64> = (1..=80).map(|x| x as f64 * 0.9).collect();
+        let close: Vec<f64> = (1..=80).map(|x| x as f64).collect();
+
+        let result = ichimoku(&high, &low, &close, 9, 26, 52);
+        assert!(!result.tenkan.is_empty());
+        assert!(!result.kijun.is_empty());
+    }
+
+    #[test]
+    fn test_parabolic_sar() {
+        let high = vec![10.0, 12.0, 15.0, 14.0, 16.0, 18.0, 17.0, 19.0, 21.0, 20.0];
+        let low = vec![8.0, 9.0, 11.0, 10.0, 12.0, 14.0, 13.0, 15.0, 17.0, 16.0];
+
+        let result = parabolic_sar(&high, &low, 0.02, 0.02, 0.2);
+        assert_eq!(result.sar.len(), high.len());
+        assert_eq!(result.trend.len(), high.len());
+    }
+}