@ebowwa/quant-rust 0.1.0

package/src/patterns/sr.rs

@@ -0,0 +1,423 @@
+//! Support and Resistance Detection
+//!
+//! Functions for finding support/resistance levels and trend lines
+//! using swing point analysis.
+
+use serde::{Deserialize, Serialize};
+
+use crate::utils::{max, min};
+
+/// Type of support/resistance level
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum LevelType {
+    Support,
+    Resistance,
+}
+
+/// A support or resistance level
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SupportResistanceLevel {
+    /// Price level
+    pub price: f64,
+    /// Strength score (number of touches * weight)
+    pub strength: usize,
+    /// Number of times price has touched this level
+    pub touches: usize,
+    /// Index of first touch
+    pub first_touch: usize,
+    /// Index of last touch
+    pub last_touch: usize,
+    /// Whether this is support or resistance
+    pub level_type: LevelType,
+}
+
+impl SupportResistanceLevel {
+    /// Create a new support/resistance level
+    pub fn new(price: f64, level_type: LevelType, index: usize) -> Self {
+        Self {
+            price,
+            strength: 1,
+            touches: 1,
+            first_touch: index,
+            last_touch: index,
+            level_type,
+        }
+    }
+
+    /// Merge another level into this one
+    pub fn merge(&mut self, other: &SupportResistanceLevel) {
+        let total_touches = self.touches + other.touches;
+        self.price = (self.price * self.touches as f64 + other.price * other.touches as f64)
+            / total_touches as f64;
+        self.touches = total_touches;
+        self.strength += other.strength;
+        self.last_touch = self.last_touch.max(other.last_touch);
+    }
+}
+
+/// A trend line
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TrendLine {
+    /// Slope of the line (price change per bar)
+    pub slope: f64,
+    /// Y-intercept (price at index 0)
+    pub intercept: f64,
+    /// Start index of the trend line
+    pub start_index: usize,
+    /// End index of the trend line
+    pub end_index: usize,
+    /// R-squared value (goodness of fit)
+    pub r2: f64,
+    /// Whether this is a support or resistance trend line
+    pub trend_type: LevelType,
+}
+
+impl TrendLine {
+    /// Get the price at a given index
+    pub fn price_at(&self, index: usize) -> f64 {
+        self.slope * index as f64 + self.intercept
+    }
+}
+
+/// A swing point (peak or trough)
+#[derive(Debug, Clone, Copy)]
+struct SwingPoint {
+    index: usize,
+    value: f64,
+}
+
+/// Find support and resistance levels using swing points
+///
+/// # Arguments
+/// * `high` - Array of high prices
+/// * `low` - Array of low prices
+/// * `lookback` - Number of bars on each side to define a swing point
+/// * `threshold` - Price threshold for merging nearby levels (as decimal, e.g., 0.02 = 2%)
+///
+/// # Returns
+/// Vector of support/resistance levels sorted by strength (most touches first)
+pub fn find_support_resistance(
+    high: &[f64],
+    low: &[f64],
+    lookback: usize,
+    threshold: f64,
+) -> Vec<SupportResistanceLevel> {
+    if high.len() != low.len() || high.is_empty() {
+        return vec![];
+    }
+
+    let n = high.len();
+    let mut levels: Vec<SupportResistanceLevel> = Vec::new();
+
+    // Find swing highs (resistance)
+    for i in lookback..(n - lookback) {
+        let left_start = i - lookback;
+        let left_highs = &high[left_start..i];
+        let right_highs = &high[(i + 1)..=(i + lookback).min(n - 1)];
+
+        let left_max = max(left_highs);
+        let right_max = max(right_highs);
+
+        if high[i] >= left_max && high[i] >= right_max {
+            levels.push(SupportResistanceLevel::new(high[i], LevelType::Resistance, i));
+        }
+    }
+
+    // Find swing lows (support)
+    for i in lookback..(n - lookback) {
+        let left_start = i - lookback;
+        let left_lows = &low[left_start..i];
+        let right_lows = &low[(i + 1)..=(i + lookback).min(n - 1)];
+
+        let left_min = min(left_lows);
+        let right_min = min(right_lows);
+
+        if low[i] <= left_min && low[i] <= right_min {
+            levels.push(SupportResistanceLevel::new(low[i], LevelType::Support, i));
+        }
+    }
+
+    // Merge nearby levels
+    merge_levels(&mut levels, threshold);
+
+    // Sort by strength (most touches first)
+    levels.sort_by(|a, b| b.touches.cmp(&a.touches));
+
+    levels
+}
+
+/// Merge levels that are close together
+fn merge_levels(levels: &mut Vec<SupportResistanceLevel>, threshold: f64) {
+    if levels.is_empty() {
+        return;
+    }
+
+    // Sort by price
+    levels.sort_by(|a, b| {
+        a.price
+            .partial_cmp(&b.price)
+            .unwrap_or(std::cmp::Ordering::Equal)
+    });
+
+    let mut merged: Vec<SupportResistanceLevel> = Vec::with_capacity(levels.len());
+    merged.push(levels[0].clone());
+
+    for current in levels.iter().skip(1) {
+        let last = merged.last_mut().unwrap();
+
+        // Check if levels should be merged
+        let price_diff = (current.price - last.price).abs() / last.price;
+        if price_diff < threshold {
+            last.merge(current);
+        } else {
+            merged.push(current.clone());
+        }
+    }
+
+    *levels = merged;
+}
+
+/// Find trend lines by connecting swing points
+///
+/// # Arguments
+/// * `high` - Array of high prices
+/// * `low` - Array of low prices
+/// * `min_points` - Minimum number of points to form a trend line
+/// * `tolerance` - Price tolerance for point alignment (as decimal)
+///
+/// # Returns
+/// Vector of trend lines
+pub fn find_trend_lines(
+    high: &[f64],
+    low: &[f64],
+    min_points: usize,
+    tolerance: f64,
+) -> Vec<TrendLine> {
+    let mut lines = Vec::new();
+
+    // Find support trend lines (connecting lows)
+    let low_points = find_swing_points(low, SwingType::Low, 3);
+    lines.extend(fit_trend_lines(
+        &low_points,
+        high.len(),
+        LevelType::Support,
+        min_points,
+        tolerance,
+    ));
+
+    // Find resistance trend lines (connecting highs)
+    let high_points = find_swing_points(high, SwingType::High, 3);
+    lines.extend(fit_trend_lines(
+        &high_points,
+        high.len(),
+        LevelType::Resistance,
+        min_points,
+        tolerance,
+    ));
+
+    lines
+}
+
+/// Type of swing point
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SwingType {
+    High,
+    Low,
+}
+
+/// Find swing points (peaks or troughs)
+fn find_swing_points(data: &[f64], swing_type: SwingType, lookback: usize) -> Vec<SwingPoint> {
+    let mut points = Vec::new();
+
+    for i in lookback..(data.len() - lookback) {
+        let left = &data[(i - lookback)..i];
+        let right = &data[(i + 1)..=(i + lookback).min(data.len() - 1)];
+
+        let is_swing = match swing_type {
+            SwingType::High => {
+                data[i] >= max(left) && data[i] >= max(right)
+            }
+            SwingType::Low => {
+                data[i] <= min(left) && data[i] <= min(right)
+            }
+        };
+
+        if is_swing {
+            points.push(SwingPoint { index: i, value: data[i] });
+        }
+    }
+
+    points
+}
+
+/// Fit trend lines to a set of swing points
+fn fit_trend_lines(
+    points: &[SwingPoint],
+    _data_length: usize,
+    trend_type: LevelType,
+    min_points: usize,
+    tolerance: f64,
+) -> Vec<TrendLine> {
+    let mut lines = Vec::new();
+
+    if points.len() < min_points {
+        return lines;
+    }
+
+    // Try all combinations of points
+    for i in 0..=(points.len() - min_points) {
+        for j in ((i + min_points - 1)..points.len()).rev() {
+            let subset = &points[i..=j];
+            let line = fit_line(subset);
+
+            if line.r2 > 0.8 {
+                // Check if all points are within tolerance
+                let all_points_fit = subset.iter().all(|p| {
+                    let predicted = line.slope * p.index as f64 + line.intercept;
+                    let diff = (predicted - p.value).abs() / p.value;
+                    diff < tolerance
+                });
+
+                if all_points_fit {
+                    lines.push(TrendLine {
+                        slope: line.slope,
+                        intercept: line.intercept,
+                        start_index: subset.first().unwrap().index,
+                        end_index: subset.last().unwrap().index,
+                        r2: line.r2,
+                        trend_type,
+                    });
+                }
+            }
+        }
+    }
+
+    lines
+}
+
+/// Result of linear regression
+struct LineFit {
+    slope: f64,
+    intercept: f64,
+    r2: f64,
+}
+
+/// Perform linear regression on swing points
+fn fit_line(points: &[SwingPoint]) -> LineFit {
+    let n = points.len();
+    if n < 2 {
+        return LineFit {
+            slope: 0.0,
+            intercept: 0.0,
+            r2: 0.0,
+        };
+    }
+
+    let mut sum_x = 0.0_f64;
+    let mut sum_y = 0.0_f64;
+    let mut sum_xy = 0.0_f64;
+    let mut sum_x2 = 0.0_f64;
+    let mut sum_y2 = 0.0_f64;
+
+    for p in points {
+        let x = p.index as f64;
+        let y = p.value;
+        sum_x += x;
+        sum_y += y;
+        sum_xy += x * y;
+        sum_x2 += x * x;
+        sum_y2 += y * y;
+    }
+
+    let denom = n as f64 * sum_x2 - sum_x * sum_x;
+    if denom.abs() < 1e-10 {
+        return LineFit {
+            slope: 0.0,
+            intercept: sum_y / n as f64,
+            r2: 0.0,
+        };
+    }
+
+    let slope = (n as f64 * sum_xy - sum_x * sum_y) / denom;
+    let intercept = (sum_y - slope * sum_x) / n as f64;
+
+    // R-squared calculation
+    let ss_tot = sum_y2 - sum_y * sum_y / n as f64;
+
+    let ss_res: f64 = points
+        .iter()
+        .map(|p| {
+            let predicted = slope * p.index as f64 + intercept;
+            let residual = p.value - predicted;
+            residual * residual
+        })
+        .sum();
+
+    let r2 = if ss_tot > 1e-10 {
+        1.0 - ss_res / ss_tot
+    } else {
+        0.0
+    };
+
+    LineFit {
+        slope,
+        intercept,
+        r2: r2.max(0.0),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_find_support_resistance() {
+        // Create a simple price series with obvious levels
+        let high = vec![
+            100.0, 102.0, 105.0, 103.0, 101.0, // Down
+            98.0, 100.0, 103.0, 105.0, 103.0, // Up and down
+            101.0, 98.0, 100.0, 103.0, 105.0, // Up again
+        ];
+        let low = vec![
+            98.0, 100.0, 103.0, 100.0, 98.0,
+            95.0, 97.0, 100.0, 102.0, 100.0,
+            98.0, 95.0, 97.0, 100.0, 102.0,
+        ];
+
+        let levels = find_support_resistance(&high, &low, 2, 0.02);
+
+        // Should find at least one level
+        assert!(!levels.is_empty());
+    }
+
+    #[test]
+    fn test_trend_line_price_at() {
+        let line = TrendLine {
+            slope: 1.0,
+            intercept: 100.0,
+            start_index: 0,
+            end_index: 10,
+            r2: 0.95,
+            trend_type: LevelType::Support,
+        };
+
+        assert!((line.price_at(0) - 100.0).abs() < 1e-10);
+        assert!((line.price_at(5) - 105.0).abs() < 1e-10);
+        assert!((line.price_at(10) - 110.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_fit_line() {
+        let points = vec![
+            SwingPoint { index: 0, value: 100.0 },
+            SwingPoint { index: 5, value: 105.0 },
+            SwingPoint { index: 10, value: 110.0 },
+        ];
+
+        let line = fit_line(&points);
+
+        assert!((line.slope - 1.0).abs() < 1e-10);
+        assert!((line.intercept - 100.0).abs() < 1e-10);
+        assert!((line.r2 - 1.0).abs() < 1e-10); // Perfect fit
+    }
+}