@ebowwa/quant-rust 0.1.0

package/src/patterns/breakout.rs

@@ -0,0 +1,431 @@
+//! Breakout Detection
+//!
+//! Functions for detecting breakouts from support/resistance levels.
+
+use serde::{Deserialize, Serialize};
+
+use super::sr::SupportResistanceLevel;
+
+/// Direction of a breakout
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum BreakoutDirection {
+    Up,
+    Down,
+}
+
+/// A detected breakout
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Breakout {
+    /// The price level that was broken
+    pub level: f64,
+    /// Direction of the breakout
+    pub direction: BreakoutDirection,
+    /// Volume ratio compared to average
+    pub volume_ratio: f64,
+    /// Whether the breakout has been confirmed (follow-through)
+    pub confirmed: bool,
+    /// Index where breakout occurred
+    pub index: usize,
+    /// The support/resistance level that was broken
+    pub sr_level: Option<SupportResistanceLevel>,
+}
+
+impl Breakout {
+    /// Create a new breakout
+    pub fn new(level: f64, direction: BreakoutDirection, index: usize) -> Self {
+        Self {
+            level,
+            direction,
+            volume_ratio: 1.0,
+            confirmed: false,
+            index,
+            sr_level: None,
+        }
+    }
+
+    /// Add volume ratio
+    pub fn with_volume(mut self, ratio: f64) -> Self {
+        self.volume_ratio = ratio;
+        self
+    }
+
+    /// Set confirmation status
+    pub fn with_confirmation(mut self, confirmed: bool) -> Self {
+        self.confirmed = confirmed;
+        self
+    }
+
+    /// Attach the original support/resistance level
+    pub fn with_sr_level(mut self, level: SupportResistanceLevel) -> Self {
+        self.sr_level = Some(level);
+        self
+    }
+}
+
+/// Detect breakouts from support/resistance levels
+///
+/// # Arguments
+/// * `close` - Array of close prices
+/// * `levels` - Support/resistance levels to check for breakouts
+/// * `volume` - Array of volume data
+/// * `volume_threshold` - Multiple of average volume required for valid breakout
+///
+/// # Returns
+/// Vector of detected breakouts
+pub fn detect_breakouts(
+    close: &[f64],
+    levels: &[SupportResistanceLevel],
+    volume: &[f64],
+    volume_threshold: f64,
+) -> Vec<Breakout> {
+    let mut breakouts = Vec::new();
+
+    if close.len() < 2 || volume.is_empty() {
+        return breakouts;
+    }
+
+    // Calculate average volume
+    let avg_volume = volume.iter().sum::<f64>() / volume.len() as f64;
+    if avg_volume <= 0.0 {
+        return breakouts;
+    }
+
+    for i in 1..close.len() {
+        for level in levels {
+            let prev_close = close[i - 1];
+            let curr_close = close[i];
+
+            // Bullish breakout (resistance broken)
+            if prev_close < level.price && curr_close > level.price {
+                let vol_idx = i.min(volume.len() - 1);
+                let vol_ratio = volume[vol_idx] / avg_volume;
+
+                if vol_ratio >= volume_threshold {
+                    breakouts.push(
+                        Breakout::new(level.price, BreakoutDirection::Up, i)
+                            .with_volume(vol_ratio)
+                            .with_sr_level(level.clone()),
+                    );
+                }
+            }
+
+            // Bearish breakout (support broken)
+            if prev_close > level.price && curr_close < level.price {
+                let vol_idx = i.min(volume.len() - 1);
+                let vol_ratio = volume[vol_idx] / avg_volume;
+
+                if vol_ratio >= volume_threshold {
+                    breakouts.push(
+                        Breakout::new(level.price, BreakoutDirection::Down, i)
+                            .with_volume(vol_ratio)
+                            .with_sr_level(level.clone()),
+                    );
+                }
+            }
+        }
+    }
+
+    // Check for confirmation (follow-through)
+    let close_len = close.len();
+    for breakout in &mut breakouts {
+        let look_ahead = (breakout.index + 3).min(close_len - 1);
+        if look_ahead > breakout.index {
+            match breakout.direction {
+                BreakoutDirection::Up => {
+                    breakout.confirmed = close[look_ahead] > breakout.level;
+                }
+                BreakoutDirection::Down => {
+                    breakout.confirmed = close[look_ahead] < breakout.level;
+                }
+            }
+        }
+    }
+
+    breakouts
+}
+
+/// Detect breakouts from simple price levels
+///
+/// Simplified version that detects breakouts from a list of price levels
+/// without requiring SupportResistanceLevel structs.
+///
+/// # Arguments
+/// * `close` - Array of close prices
+/// * `levels` - Price levels to check for breakouts
+/// * `volume` - Array of volume data
+/// * `volume_threshold` - Multiple of average volume required for valid breakout
+///
+/// # Returns
+/// Vector of detected breakouts (without sr_level populated)
+pub fn detect_breakouts_from_levels(
+    close: &[f64],
+    levels: &[f64],
+    volume: &[f64],
+    volume_threshold: f64,
+) -> Vec<Breakout> {
+    let mut breakouts = Vec::new();
+
+    if close.len() < 2 || volume.is_empty() {
+        return breakouts;
+    }
+
+    // Calculate average volume
+    let avg_volume = volume.iter().sum::<f64>() / volume.len() as f64;
+    if avg_volume <= 0.0 {
+        return breakouts;
+    }
+
+    for i in 1..close.len() {
+        for &level in levels {
+            let prev_close = close[i - 1];
+            let curr_close = close[i];
+
+            // Bullish breakout (resistance broken)
+            if prev_close < level && curr_close > level {
+                let vol_idx = i.min(volume.len() - 1);
+                let vol_ratio = volume[vol_idx] / avg_volume;
+
+                if vol_ratio >= volume_threshold {
+                    breakouts.push(
+                        Breakout::new(level, BreakoutDirection::Up, i).with_volume(vol_ratio),
+                    );
+                }
+            }
+
+            // Bearish breakout (support broken)
+            if prev_close > level && curr_close < level {
+                let vol_idx = i.min(volume.len() - 1);
+                let vol_ratio = volume[vol_idx] / avg_volume;
+
+                if vol_ratio >= volume_threshold {
+                    breakouts.push(
+                        Breakout::new(level, BreakoutDirection::Down, i).with_volume(vol_ratio),
+                    );
+                }
+            }
+        }
+    }
+
+    // Check for confirmation (follow-through)
+    let close_len = close.len();
+    for breakout in &mut breakouts {
+        let look_ahead = (breakout.index + 3).min(close_len - 1);
+        if look_ahead > breakout.index {
+            match breakout.direction {
+                BreakoutDirection::Up => {
+                    breakout.confirmed = close[look_ahead] > breakout.level;
+                }
+                BreakoutDirection::Down => {
+                    breakout.confirmed = close[look_ahead] < breakout.level;
+                }
+            }
+        }
+    }
+
+    breakouts
+}
+
+/// Detect all-time high breakouts
+///
+/// Detects when price breaks above all previous highs.
+///
+/// # Arguments
+/// * `high` - Array of high prices
+/// * `close` - Array of close prices
+///
+/// # Returns
+/// Vector of detected breakouts (direction always Up)
+pub fn detect_all_time_high_breakouts(high: &[f64], close: &[f64]) -> Vec<Breakout> {
+    let mut breakouts = Vec::new();
+
+    if high.len() < 2 || close.len() < 2 {
+        return breakouts;
+    }
+
+    let mut running_high = high[0];
+
+    for i in 1..high.len() {
+        if high[i] > running_high {
+            // New all-time high
+            breakouts.push(Breakout::new(running_high, BreakoutDirection::Up, i));
+            running_high = high[i];
+        }
+    }
+
+    breakouts
+}
+
+/// Detect all-time low breakouts (breakdown)
+///
+/// Detects when price breaks below all previous lows.
+///
+/// # Arguments
+/// * `low` - Array of low prices
+/// * `close` - Array of close prices
+///
+/// # Returns
+/// Vector of detected breakouts (direction always Down)
+pub fn detect_all_time_low_breakouts(low: &[f64], close: &[f64]) -> Vec<Breakout> {
+    let mut breakouts = Vec::new();
+
+    if low.len() < 2 || close.len() < 2 {
+        return breakouts;
+    }
+
+    let mut running_low = low[0];
+
+    for i in 1..low.len() {
+        if low[i] < running_low {
+            // New all-time low
+            breakouts.push(Breakout::new(running_low, BreakoutDirection::Down, i));
+            running_low = low[i];
+        }
+    }
+
+    breakouts
+}
+
+/// Detect consolidation breakouts
+///
+/// Detects breakouts from a period of low volatility (consolidation).
+///
+/// # Arguments
+/// * `high` - Array of high prices
+/// * `low` - Array of low prices
+/// * `close` - Array of close prices
+/// * `consolidation_periods` - Minimum number of periods for consolidation
+/// * `range_threshold` - Maximum range (as % of price) to consider consolidation
+///
+/// # Returns
+/// Vector of detected breakouts
+pub fn detect_consolidation_breakouts(
+    high: &[f64],
+    low: &[f64],
+    close: &[f64],
+    consolidation_periods: usize,
+    range_threshold: f64,
+) -> Vec<Breakout> {
+    let mut breakouts = Vec::new();
+
+    if high.len() < consolidation_periods + 1 {
+        return breakouts;
+    }
+
+    for i in consolidation_periods..high.len() {
+        // Check if the previous periods were consolidating
+        let consolidation_start = i - consolidation_periods;
+        let window_high = &high[consolidation_start..i];
+        let window_low = &low[consolidation_start..i];
+
+        let highest = window_high.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
+        let lowest = window_low.iter().cloned().fold(f64::INFINITY, f64::min);
+
+        let mid_price = (highest + lowest) / 2.0;
+        let range_pct = (highest - lowest) / mid_price;
+
+        // Check if we were in consolidation
+        if range_pct < range_threshold {
+            // Check for breakout above consolidation
+            if close[i] > highest {
+                breakouts.push(
+                    Breakout::new(highest, BreakoutDirection::Up, i).with_confirmation(true),
+                );
+            }
+            // Check for breakdown below consolidation
+            else if close[i] < lowest {
+                breakouts.push(
+                    Breakout::new(lowest, BreakoutDirection::Down, i).with_confirmation(true),
+                );
+            }
+        }
+    }
+
+    breakouts
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use super::super::sr::LevelType;
+
+    fn create_test_sr_level(price: f64, level_type: LevelType) -> SupportResistanceLevel {
+        SupportResistanceLevel {
+            price,
+            strength: 1,
+            touches: 1,
+            first_touch: 0,
+            last_touch: 0,
+            level_type,
+        }
+    }
+
+    #[test]
+    fn test_detect_breakouts_basic() {
+        let close = vec![95.0, 98.0, 99.0, 102.0, 105.0]; // Crosses above 100 at index 3
+        let volume = vec![100.0, 110.0, 120.0, 150.0, 140.0];
+        let levels = vec![create_test_sr_level(100.0, LevelType::Resistance)];
+
+        let breakouts = detect_breakouts(&close, &levels, &volume, 1.0);
+
+        assert!(!breakouts.is_empty());
+        assert_eq!(breakouts[0].direction, BreakoutDirection::Up);
+    }
+
+    #[test]
+    fn test_detect_breakouts_from_levels() {
+        let close = vec![95.0, 98.0, 99.0, 102.0, 105.0]; // Crosses above 100 at index 3
+        let volume = vec![100.0, 110.0, 120.0, 150.0, 140.0];
+        let levels = vec![100.0, 105.0];
+
+        let breakouts = detect_breakouts_from_levels(&close, &levels, &volume, 1.0);
+
+        assert!(!breakouts.is_empty());
+    }
+
+    #[test]
+    fn test_detect_all_time_high_breakouts() {
+        let high = vec![100.0, 102.0, 101.0, 105.0, 103.0, 108.0];
+        let close = vec![99.0, 101.0, 100.0, 104.0, 102.0, 107.0];
+
+        let breakouts = detect_all_time_high_breakouts(&high, &close);
+
+        assert!(!breakouts.is_empty());
+        // Should detect breakouts at indices where new highs are made
+    }
+
+    #[test]
+    fn test_detect_consolidation_breakouts() {
+        // Consolidation then breakout
+        let high = vec![
+            100.0, 101.0, 100.5, 101.0, // Consolidation (range ~1%)
+            105.0, // Breakout
+        ];
+        let low = vec![
+            99.0, 99.5, 99.5, 99.8,
+            102.0,
+        ];
+        let close = vec![
+            99.5, 100.5, 100.0, 100.5,
+            104.0, // Closes above consolidation
+        ];
+
+        let breakouts = detect_consolidation_breakouts(&high, &low, &close, 4, 0.03);
+
+        assert!(!breakouts.is_empty());
+        assert_eq!(breakouts[0].direction, BreakoutDirection::Up);
+    }
+
+    #[test]
+    fn test_breakout_confirmation() {
+        let close = vec![95.0, 100.0, 102.0, 101.0, 103.0]; // Stays above 100
+        let volume = vec![100.0, 150.0, 120.0, 110.0, 130.0];
+        let levels = vec![create_test_sr_level(100.0, LevelType::Resistance)];
+
+        let breakouts = detect_breakouts(&close, &levels, &volume, 1.0);
+
+        // Breakout should be confirmed since price stays above level
+        if !breakouts.is_empty() {
+            assert!(breakouts[0].confirmed);
+        }
+    }
+}