@ebowwa/quant-rust 0.1.0

package/src/patterns/mod.rs

@@ -0,0 +1,394 @@
+//! Pattern Recognition Module
+//!
+//! Provides candlestick and chart pattern recognition, support/resistance detection,
+//! trend line analysis, and breakout detection.
+//!
+//! ## Sub-modules
+//! - `sr`: Support and resistance level detection, trend line finding
+//! - `chart`: Chart pattern detection (double tops/bottoms, head and shoulders, triangles, etc.)
+//! - `breakout`: Breakout detection from levels and consolidations
+//!
+//! ## Usage
+//! ```ignore
+//! use quant_rust::patterns::{
+//!     find_support_resistance, detect_all_patterns, detect_breakouts,
+//!     SupportResistanceLevel, PatternMatch, Breakout
+//! };
+//! ```
+
+pub mod breakout;
+pub mod chart;
+pub mod sr;
+
+// Re-export types from sub-modules
+pub use breakout::{Breakout, BreakoutDirection};
+pub use chart::{
+    detect_all_patterns, detect_channels, detect_double_bottom, detect_double_top,
+    detect_gaps, detect_head_and_shoulders, detect_inverse_head_and_shoulders, detect_triangles,
+    PatternDirection, PatternMatch, PatternType,
+};
+pub use sr::{find_support_resistance, find_trend_lines, LevelType, SupportResistanceLevel, TrendLine};
+
+// Re-export candlestick pattern types for backward compatibility
+use crate::types::{CandlePattern, OHLCV, PatternResult};
+use serde::{Deserialize, Serialize};
+
+// Re-export breakout functions
+pub use breakout::{
+    detect_all_time_high_breakouts, detect_all_time_low_breakouts,
+    detect_breakouts_from_levels, detect_consolidation_breakouts, detect_breakouts,
+};
+
+/// Pattern recognition configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PatternConfig {
+    /// Doji threshold (body / range ratio)
+    pub doji_threshold: f64,
+    /// Minimum pattern confidence to report
+    pub min_confidence: f64,
+}
+
+impl Default for PatternConfig {
+    fn default() -> Self {
+        Self {
+            doji_threshold: 0.1,
+            min_confidence: 0.5,
+        }
+    }
+}
+
+/// Detect candlestick patterns in OHLCV data
+///
+/// This is a convenience function for detecting candlestick patterns.
+/// For chart patterns, use the functions from the `chart` module.
+pub fn detect_patterns(data: &[OHLCV], config: &PatternConfig) -> Vec<PatternResult> {
+    if data.len() < 3 {
+        return vec![];
+    }
+
+    let mut results = Vec::new();
+
+    for i in 2..data.len() {
+        // Check single-candle patterns
+        if let Some(pattern) = detect_doji(&data[i], config) {
+            results.push(pattern);
+        }
+        if let Some(pattern) = detect_hammer(&data[i], config) {
+            results.push(pattern);
+        }
+
+        // Check two-candle patterns
+        if i >= 1 {
+            if let Some(pattern) = detect_engulfing(&data[i - 1], &data[i], config) {
+                results.push(pattern);
+            }
+        }
+
+        // Check three-candle patterns
+        if let Some(pattern) = detect_morning_star(&data[i - 2], &data[i - 1], &data[i], config) {
+            results.push(pattern);
+        }
+        if let Some(pattern) = detect_evening_star(&data[i - 2], &data[i - 1], &data[i], config) {
+            results.push(pattern);
+        }
+        if let Some(pattern) = detect_three_soldiers(&data[i - 2], &data[i - 1], &data[i], config)
+        {
+            results.push(pattern);
+        }
+        if let Some(pattern) = detect_three_crows(&data[i - 2], &data[i - 1], &data[i], config) {
+            results.push(pattern);
+        }
+    }
+
+    // Filter by confidence
+    results
+        .into_iter()
+        .filter(|r| r.confidence >= config.min_confidence)
+        .collect()
+}
+
+/// Detect Doji pattern
+fn detect_doji(candle: &OHLCV, config: &PatternConfig) -> Option<PatternResult> {
+    let range = candle.range();
+    if range == 0.0 {
+        return None;
+    }
+
+    let body_ratio = candle.body_size() / range;
+
+    if body_ratio < config.doji_threshold {
+        Some(PatternResult {
+            pattern: CandlePattern::Doji,
+            confidence: 1.0 - body_ratio,
+            index: 0, // Will be set by caller
+            is_bullish: false, // Doji is neutral
+        })
+    } else {
+        None
+    }
+}
+
+/// Detect Hammer pattern
+fn detect_hammer(candle: &OHLCV, _config: &PatternConfig) -> Option<PatternResult> {
+    let range = candle.range();
+    if range == 0.0 {
+        return None;
+    }
+
+    let body = candle.body_size();
+    let lower_wick = (candle.close.min(candle.open)) - candle.low;
+    let upper_wick = candle.high - (candle.close.max(candle.open));
+
+    // Hammer: long lower wick (2x body), small upper wick, small body
+    if lower_wick >= body * 2.0 && upper_wick < body * 0.5 {
+        Some(PatternResult {
+            pattern: CandlePattern::Hammer,
+            confidence: (lower_wick / body / 3.0).min(1.0),
+            index: 0,
+            is_bullish: true,
+        })
+    } else if upper_wick >= body * 2.0 && lower_wick < body * 0.5 {
+        Some(PatternResult {
+            pattern: CandlePattern::InvertedHammer,
+            confidence: (upper_wick / body / 3.0).min(1.0),
+            index: 0,
+            is_bullish: true,
+        })
+    } else {
+        None
+    }
+}
+
+/// Detect Engulfing pattern
+fn detect_engulfing(prev: &OHLCV, curr: &OHLCV, _config: &PatternConfig) -> Option<PatternResult> {
+    let prev_body = prev.body_size();
+    let curr_body = curr.body_size();
+
+    // Bullish engulfing: prev bearish, curr bullish, curr engulfs prev
+    if prev.is_bearish() && curr.is_bullish() {
+        if curr_body > prev_body && curr.open < prev.close && curr.close > prev.open {
+            return Some(PatternResult {
+                pattern: CandlePattern::BullishEngulfing,
+                confidence: (curr_body / prev_body / 2.0).min(1.0),
+                index: 0,
+                is_bullish: true,
+            });
+        }
+    }
+
+    // Bearish engulfing: prev bullish, curr bearish, curr engulfs prev
+    if prev.is_bullish() && curr.is_bearish() {
+        if curr_body > prev_body && curr.open > prev.close && curr.close < prev.open {
+            return Some(PatternResult {
+                pattern: CandlePattern::BearishEngulfing,
+                confidence: (curr_body / prev_body / 2.0).min(1.0),
+                index: 0,
+                is_bullish: false,
+            });
+        }
+    }
+
+    None
+}
+
+/// Detect Morning Star pattern (bullish reversal)
+fn detect_morning_star(
+    first: &OHLCV,
+    second: &OHLCV,
+    third: &OHLCV,
+    _config: &PatternConfig,
+) -> Option<PatternResult> {
+    // First: large bearish
+    // Second: small body (gap down preferred)
+    // Third: large bullish closing above midpoint of first
+
+    if !first.is_bearish() || !third.is_bullish() {
+        return None;
+    }
+
+    let first_body = first.body_size();
+    let second_body = second.body_size();
+    let third_body = third.body_size();
+
+    // Second should be small
+    if second_body > first_body * 0.3 {
+        return None;
+    }
+
+    // Third should close above midpoint of first
+    let first_mid = (first.open + first.close) / 2.0;
+    if third.close < first_mid {
+        return None;
+    }
+
+    // Third should be large
+    if third_body < first_body * 0.6 {
+        return None;
+    }
+
+    Some(PatternResult {
+        pattern: CandlePattern::MorningStar,
+        confidence: (third_body / first_body).min(1.0),
+        index: 0,
+        is_bullish: true,
+    })
+}
+
+/// Detect Evening Star pattern (bearish reversal)
+fn detect_evening_star(
+    first: &OHLCV,
+    second: &OHLCV,
+    third: &OHLCV,
+    _config: &PatternConfig,
+) -> Option<PatternResult> {
+    // First: large bullish
+    // Second: small body (gap up preferred)
+    // Third: large bearish closing below midpoint of first
+
+    if !first.is_bullish() || !third.is_bearish() {
+        return None;
+    }
+
+    let first_body = first.body_size();
+    let second_body = second.body_size();
+    let third_body = third.body_size();
+
+    // Second should be small
+    if second_body > first_body * 0.3 {
+        return None;
+    }
+
+    // Third should close below midpoint of first
+    let first_mid = (first.open + first.close) / 2.0;
+    if third.close > first_mid {
+        return None;
+    }
+
+    // Third should be large
+    if third_body < first_body * 0.6 {
+        return None;
+    }
+
+    Some(PatternResult {
+        pattern: CandlePattern::EveningStar,
+        confidence: (third_body / first_body).min(1.0),
+        index: 0,
+        is_bullish: false,
+    })
+}
+
+/// Detect Three White Soldiers pattern
+fn detect_three_soldiers(
+    first: &OHLCV,
+    second: &OHLCV,
+    third: &OHLCV,
+    _config: &PatternConfig,
+) -> Option<PatternResult> {
+    // Three consecutive bullish candles
+    // Each opens within previous body
+    // Each closes higher
+
+    if !first.is_bullish() || !second.is_bullish() || !third.is_bullish() {
+        return None;
+    }
+
+    // Check progression
+    if second.close <= first.close || third.close <= second.close {
+        return None;
+    }
+
+    // Check opens are within previous bodies
+    if second.open < first.close.min(first.open)
+        || second.open > first.close.max(first.open)
+        || third.open < second.close.min(second.open)
+        || third.open > second.close.max(second.open)
+    {
+        return None;
+    }
+
+    Some(PatternResult {
+        pattern: CandlePattern::ThreeWhiteSoldiers,
+        confidence: 0.9,
+        index: 0,
+        is_bullish: true,
+    })
+}
+
+/// Detect Three Black Crows pattern
+fn detect_three_crows(
+    first: &OHLCV,
+    second: &OHLCV,
+    third: &OHLCV,
+    _config: &PatternConfig,
+) -> Option<PatternResult> {
+    // Three consecutive bearish candles
+    // Each opens within previous body
+    // Each closes lower
+
+    if !first.is_bearish() || !second.is_bearish() || !third.is_bearish() {
+        return None;
+    }
+
+    // Check progression
+    if second.close >= first.close || third.close >= second.close {
+        return None;
+    }
+
+    // Check opens are within previous bodies
+    if second.open < first.close.min(first.open)
+        || second.open > first.close.max(first.open)
+        || third.open < second.close.min(second.open)
+        || third.open > second.close.max(second.open)
+    {
+        return None;
+    }
+
+    Some(PatternResult {
+        pattern: CandlePattern::ThreeBlackCrows,
+        confidence: 0.9,
+        index: 0,
+        is_bullish: false,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_doji_detection() {
+        let candle = OHLCV::new(0, 100.0, 105.0, 95.0, 100.5, 1000.0);
+        let config = PatternConfig::default();
+        let result = detect_doji(&candle, &config);
+        assert!(result.is_some());
+        assert_eq!(result.unwrap().pattern, CandlePattern::Doji);
+    }
+
+    #[test]
+    fn test_bullish_engulfing() {
+        let prev = OHLCV::new(0, 102.0, 103.0, 98.0, 99.0, 1000.0);
+        let curr = OHLCV::new(0, 98.5, 105.0, 98.0, 104.0, 1000.0);
+        let config = PatternConfig::default();
+        let result = detect_engulfing(&prev, &curr, &config);
+        assert!(result.is_some());
+        assert_eq!(result.unwrap().pattern, CandlePattern::BullishEngulfing);
+    }
+
+    #[test]
+    fn test_module_reexports() {
+        // Test that all types are properly re-exported
+        use super::*;
+
+        // Support/Resistance types
+        let _level_type = LevelType::Support;
+
+        // Chart pattern types
+        let _pattern_type = PatternType::DoubleTop;
+        let _direction = PatternDirection::Bullish;
+
+        // Breakout types
+        let _breakout_dir = BreakoutDirection::Up;
+
+        // This test just verifies the types compile correctly
+    }
+}