@ebowwa/quant-rust 0.1.0

package/src/patterns/chart.rs

@@ -0,0 +1,772 @@
+//! Chart Pattern Detection
+//!
+//! Functions for detecting chart patterns like double tops/bottoms,
+//! head and shoulders, triangles, gaps, and channels.
+
+use serde::{Deserialize, Serialize};
+
+use crate::utils::{max, min};
+
+/// Type of chart pattern
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum PatternType {
+    DoubleTop,
+    DoubleBottom,
+    HeadAndShoulders,
+    InverseHeadAndShoulders,
+    TriangleAscending,
+    TriangleDescending,
+    TriangleSymmetrical,
+    FlagBullish,
+    FlagBearish,
+    WedgeRising,
+    WedgeFalling,
+    ChannelUp,
+    ChannelDown,
+    CupAndHandle,
+    RoundingBottom,
+    GapUp,
+    GapDown,
+}
+
+impl PatternType {
+    /// Check if this is a bullish pattern
+    pub fn is_bullish(&self) -> bool {
+        matches!(
+            self,
+            PatternType::DoubleBottom
+                | PatternType::InverseHeadAndShoulders
+                | PatternType::TriangleAscending
+                | PatternType::FlagBullish
+                | PatternType::ChannelUp
+                | PatternType::CupAndHandle
+                | PatternType::RoundingBottom
+                | PatternType::GapUp
+        )
+    }
+
+    /// Check if this is a bearish pattern
+    pub fn is_bearish(&self) -> bool {
+        matches!(
+            self,
+            PatternType::DoubleTop
+                | PatternType::HeadAndShoulders
+                | PatternType::TriangleDescending
+                | PatternType::FlagBearish
+                | PatternType::WedgeRising
+                | PatternType::ChannelDown
+                | PatternType::GapDown
+        )
+    }
+}
+
+/// Pattern direction (bullish/bearish/neutral)
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum PatternDirection {
+    Bullish,
+    Bearish,
+    Neutral,
+}
+
+impl PatternDirection {
+    /// Get direction from pattern type
+    pub fn from_pattern(pattern_type: &PatternType) -> Self {
+        if pattern_type.is_bullish() {
+            PatternDirection::Bullish
+        } else if pattern_type.is_bearish() {
+            PatternDirection::Bearish
+        } else {
+            PatternDirection::Neutral
+        }
+    }
+}
+
+/// A detected chart pattern
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PatternMatch {
+    /// Type of pattern
+    pub pattern_type: PatternType,
+    /// Direction (bullish/bearish/neutral)
+    pub direction: PatternDirection,
+    /// Index where pattern starts
+    pub start_index: usize,
+    /// Index where pattern ends
+    pub end_index: usize,
+    /// Confidence level (0-1)
+    pub confidence: f64,
+    /// Target price (optional)
+    pub target_price: Option<f64>,
+    /// Stop loss price (optional)
+    pub stop_loss: Option<f64>,
+    /// Key price points in the pattern
+    pub points: Vec<f64>,
+}
+
+impl PatternMatch {
+    /// Create a new pattern match
+    pub fn new(
+        pattern_type: PatternType,
+        start_index: usize,
+        end_index: usize,
+        confidence: f64,
+    ) -> Self {
+        let direction = PatternDirection::from_pattern(&pattern_type);
+        Self {
+            pattern_type,
+            direction,
+            start_index,
+            end_index,
+            confidence: confidence.clamp(0.0, 1.0),
+            target_price: None,
+            stop_loss: None,
+            points: Vec::new(),
+        }
+    }
+
+    /// Add target and stop loss
+    pub fn with_targets(mut self, target: f64, stop: f64) -> Self {
+        self.target_price = Some(target);
+        self.stop_loss = Some(stop);
+        self
+    }
+
+    /// Add key points
+    pub fn with_points(mut self, points: Vec<f64>) -> Self {
+        self.points = points;
+        self
+    }
+}
+
+/// A swing point (peak or trough)
+#[derive(Debug, Clone, Copy)]
+struct SwingPoint {
+    index: usize,
+    value: f64,
+}
+
+/// Detect double top pattern
+///
+/// A double top is a bearish reversal pattern with two peaks
+/// at approximately the same price level.
+pub fn detect_double_top(high: &[f64], low: &[f64], tolerance: f64) -> Vec<PatternMatch> {
+    let mut patterns = Vec::new();
+    let peaks = find_swing_points_high(high, 3);
+
+    for i in 0..peaks.len().saturating_sub(1) {
+        let p1 = &peaks[i];
+        let p2 = &peaks[i + 1];
+
+        // Peaks should be at similar height
+        let peak_diff = (p1.value - p2.value).abs() / p1.value;
+        if peak_diff < tolerance {
+            // Find neckline (lowest point between peaks)
+            let neckline_start = p1.index;
+            let neckline_end = p2.index;
+
+            if neckline_end > neckline_start {
+                let neckline_slice = &low[neckline_start..neckline_end];
+                let neckline_idx = neckline_start + find_min_index(neckline_slice);
+                let neckline = low[neckline_idx];
+
+                let confidence = 1.0 - peak_diff;
+                let target = neckline - (p1.value.max(p2.value) - neckline);
+                let stop = p1.value.max(p2.value) * 1.01;
+
+                patterns.push(
+                    PatternMatch::new(PatternType::DoubleTop, p1.index, p2.index, confidence)
+                        .with_targets(target, stop)
+                        .with_points(vec![p1.value, p2.value, neckline]),
+                );
+            }
+        }
+    }
+
+    patterns
+}
+
+/// Detect double bottom pattern
+///
+/// A double bottom is a bullish reversal pattern with two troughs
+/// at approximately the same price level.
+pub fn detect_double_bottom(high: &[f64], low: &[f64], tolerance: f64) -> Vec<PatternMatch> {
+    let mut patterns = Vec::new();
+    let troughs = find_swing_points_low(low, 3);
+
+    for i in 0..troughs.len().saturating_sub(1) {
+        let t1 = &troughs[i];
+        let t2 = &troughs[i + 1];
+
+        // Troughs should be at similar level
+        let trough_diff = (t1.value - t2.value).abs() / t1.value;
+        if trough_diff < tolerance {
+            // Find neckline (highest point between troughs)
+            let neckline_start = t1.index;
+            let neckline_end = t2.index;
+
+            if neckline_end > neckline_start {
+                let neckline_slice = &high[neckline_start..neckline_end];
+                let neckline_idx = neckline_start + find_max_index(neckline_slice);
+                let neckline = high[neckline_idx];
+
+                let confidence = 1.0 - trough_diff;
+                let target = neckline + (neckline - t1.value.min(t2.value));
+                let stop = t1.value.min(t2.value) * 0.99;
+
+                patterns.push(
+                    PatternMatch::new(PatternType::DoubleBottom, t1.index, t2.index, confidence)
+                        .with_targets(target, stop)
+                        .with_points(vec![t1.value, t2.value, neckline]),
+                );
+            }
+        }
+    }
+
+    patterns
+}
+
+/// Detect head and shoulders pattern
+///
+/// A bearish reversal pattern with three peaks, where the middle peak (head)
+/// is higher than the two shoulders.
+pub fn detect_head_and_shoulders(high: &[f64], low: &[f64], tolerance: f64) -> Vec<PatternMatch> {
+    let mut patterns = Vec::new();
+    let peaks = find_swing_points_high(high, 4);
+
+    for i in 0..peaks.len().saturating_sub(2) {
+        let left_shoulder = &peaks[i];
+        let head = &peaks[i + 1];
+        let right_shoulder = &peaks[i + 2];
+
+        // Head should be higher than shoulders
+        if head.value > left_shoulder.value && head.value > right_shoulder.value {
+            // Shoulders should be at similar height
+            let shoulder_diff =
+                (left_shoulder.value - right_shoulder.value).abs() / left_shoulder.value;
+
+            if shoulder_diff < tolerance {
+                // Find neckline points
+                let neckline1_start = left_shoulder.index;
+                let neckline1_end = head.index;
+                let neckline2_start = head.index;
+                let neckline2_end = right_shoulder.index;
+
+                if neckline1_end > neckline1_start && neckline2_end > neckline2_start {
+                    let nl1_slice = &low[neckline1_start..neckline1_end];
+                    let nl1_idx = neckline1_start + find_min_index(nl1_slice);
+                    let nl1 = low[nl1_idx];
+
+                    let nl2_slice = &low[neckline2_start..neckline2_end];
+                    let nl2_idx = neckline2_start + find_min_index(nl2_slice);
+                    let nl2 = low[nl2_idx];
+
+                    let neckline = (nl1 + nl2) / 2.0;
+                    let confidence = (1.0 - shoulder_diff) * (head.value / left_shoulder.value - 1.0);
+                    let target = neckline - (head.value - neckline);
+                    let stop = head.value * 1.02;
+
+                    patterns.push(
+                        PatternMatch::new(
+                            PatternType::HeadAndShoulders,
+                            left_shoulder.index,
+                            right_shoulder.index,
+                            confidence,
+                        )
+                        .with_targets(target, stop)
+                        .with_points(vec![left_shoulder.value, head.value, right_shoulder.value, neckline]),
+                    );
+                }
+            }
+        }
+    }
+
+    patterns
+}
+
+/// Detect inverse head and shoulders pattern
+///
+/// A bullish reversal pattern with three troughs, where the middle trough (head)
+/// is lower than the two shoulders.
+pub fn detect_inverse_head_and_shoulders(
+    high: &[f64],
+    low: &[f64],
+    tolerance: f64,
+) -> Vec<PatternMatch> {
+    let mut patterns = Vec::new();
+    let troughs = find_swing_points_low(low, 4);
+
+    for i in 0..troughs.len().saturating_sub(2) {
+        let left_shoulder = &troughs[i];
+        let head = &troughs[i + 1];
+        let right_shoulder = &troughs[i + 2];
+
+        // Head should be lower than shoulders
+        if head.value < left_shoulder.value && head.value < right_shoulder.value {
+            let shoulder_diff =
+                (left_shoulder.value - right_shoulder.value).abs() / left_shoulder.value;
+
+            if shoulder_diff < tolerance {
+                // Find neckline points
+                let neckline1_start = left_shoulder.index;
+                let neckline1_end = head.index;
+                let neckline2_start = head.index;
+                let neckline2_end = right_shoulder.index;
+
+                if neckline1_end > neckline1_start && neckline2_end > neckline2_start {
+                    let nl1_slice = &high[neckline1_start..neckline1_end];
+                    let nl1_idx = neckline1_start + find_max_index(nl1_slice);
+                    let nl1 = high[nl1_idx];
+
+                    let nl2_slice = &high[neckline2_start..neckline2_end];
+                    let nl2_idx = neckline2_start + find_max_index(nl2_slice);
+                    let nl2 = high[nl2_idx];
+
+                    let neckline = (nl1 + nl2) / 2.0;
+                    let confidence =
+                        (1.0 - shoulder_diff) * (1.0 - head.value / left_shoulder.value);
+                    let target = neckline + (neckline - head.value);
+                    let stop = head.value * 0.98;
+
+                    patterns.push(
+                        PatternMatch::new(
+                            PatternType::InverseHeadAndShoulders,
+                            left_shoulder.index,
+                            right_shoulder.index,
+                            confidence,
+                        )
+                        .with_targets(target, stop)
+                        .with_points(vec![left_shoulder.value, head.value, right_shoulder.value, neckline]),
+                    );
+                }
+            }
+        }
+    }
+
+    patterns
+}
+
+/// Detect triangle patterns (ascending, descending, symmetrical)
+///
+/// Triangles are continuation patterns formed by converging trendlines.
+pub fn detect_triangles(high: &[f64], low: &[f64], min_periods: usize) -> Vec<PatternMatch> {
+    let mut patterns = Vec::new();
+
+    if high.len() < min_periods {
+        return patterns;
+    }
+
+    for i in min_periods..high.len() {
+        let window_high = &high[(i - min_periods)..i];
+        let window_low = &low[(i - min_periods)..i];
+
+        let high_peaks = find_swing_points_high(window_high, 2);
+        let low_troughs = find_swing_points_low(window_low, 2);
+
+        if high_peaks.len() >= 2 && low_troughs.len() >= 2 {
+            let high_line = fit_line(&high_peaks);
+            let low_line = fit_line(&low_troughs);
+
+            let window_high_max = max(window_high);
+            let window_low_min = min(window_low);
+
+            // Ascending triangle: flat top, rising bottom
+            if high_line.slope.abs() < 0.001 && low_line.slope > 0.001 {
+                let confidence = (low_line.slope.abs() * 100.0).min(1.0);
+
+                patterns.push(
+                    PatternMatch::new(PatternType::TriangleAscending, i - min_periods, i, confidence)
+                        .with_points(vec![window_high_max, window_low_min]),
+                );
+            }
+
+            // Descending triangle: falling top, flat bottom
+            if high_line.slope < -0.001 && low_line.slope.abs() < 0.001 {
+                let confidence = (high_line.slope.abs() * 100.0).min(1.0);
+
+                patterns.push(
+                    PatternMatch::new(PatternType::TriangleDescending, i - min_periods, i, confidence)
+                        .with_points(vec![window_high_max, window_low_min]),
+                );
+            }
+
+            // Symmetrical triangle: converging lines
+            if high_line.slope < -0.001 && low_line.slope > 0.001 {
+                let confidence =
+                    ((high_line.slope.abs() + low_line.slope.abs()) * 50.0).min(1.0);
+
+                let direction = PatternDirection::Neutral;
+
+                let mut pattern = PatternMatch::new(
+                    PatternType::TriangleSymmetrical,
+                    i - min_periods,
+                    i,
+                    confidence,
+                );
+                pattern.direction = direction;
+                pattern.points = vec![window_high_max, window_low_min];
+
+                patterns.push(pattern);
+            }
+        }
+    }
+
+    patterns
+}
+
+/// Detect price gaps
+///
+/// A gap occurs when the opening price is significantly different
+/// from the previous closing range.
+pub fn detect_gaps(open: &[f64], high: &[f64], low: &[f64], threshold: f64) -> Vec<PatternMatch> {
+    let mut patterns = Vec::new();
+
+    if open.len() < 2 {
+        return patterns;
+    }
+
+    for i in 1..open.len() {
+        let prev_high = high[i - 1];
+        let prev_low = low[i - 1];
+        let curr_open = open[i];
+
+        // Gap up
+        if curr_open > prev_high * (1.0 + threshold) {
+            let gap_size = (curr_open - prev_high) / prev_high;
+            let confidence = (gap_size / threshold).min(1.0);
+
+            patterns.push(
+                PatternMatch::new(PatternType::GapUp, i - 1, i, confidence)
+                    .with_points(vec![prev_high, curr_open]),
+            );
+        }
+
+        // Gap down
+        if curr_open < prev_low * (1.0 - threshold) {
+            let gap_size = (prev_low - curr_open) / prev_low;
+            let confidence = (gap_size / threshold).min(1.0);
+
+            patterns.push(
+                PatternMatch::new(PatternType::GapDown, i - 1, i, confidence)
+                    .with_points(vec![prev_low, curr_open]),
+            );
+        }
+    }
+
+    patterns
+}
+
+/// Detect price channels
+///
+/// A channel is formed when price moves between two parallel trend lines.
+pub fn detect_channels(
+    high: &[f64],
+    low: &[f64],
+    _close: &[f64],
+    min_periods: usize,
+) -> Vec<PatternMatch> {
+    let mut patterns = Vec::new();
+
+    if high.len() < min_periods {
+        return patterns;
+    }
+
+    let mut i = min_periods;
+    while i <= high.len() {
+        let window_high = &high[(i - min_periods)..i];
+        let window_low = &low[(i - min_periods)..i];
+
+        // Create points for fitting (index, value)
+        let high_points: Vec<(usize, f64)> = window_high
+            .iter()
+            .enumerate()
+            .map(|(idx, &v)| (idx, v))
+            .collect();
+        let low_points: Vec<(usize, f64)> = window_low
+            .iter()
+            .enumerate()
+            .map(|(idx, &v)| (idx, v))
+            .collect();
+
+        let high_line = fit_line_from_tuples(&high_points);
+        let low_line = fit_line_from_tuples(&low_points);
+
+        // Channel should have parallel lines
+        let slope_diff = (high_line.slope - low_line.slope).abs();
+        let avg_slope = (high_line.slope + low_line.slope) / 2.0;
+
+        if slope_diff < 0.001 && high_line.r2 > 0.7 && low_line.r2 > 0.7 {
+            let pattern_type = if avg_slope > 0.0 {
+                PatternType::ChannelUp
+            } else {
+                PatternType::ChannelDown
+            };
+
+            let confidence = (high_line.r2 + low_line.r2) / 2.0;
+            let window_high_max = max(window_high);
+            let window_low_min = min(window_low);
+
+            patterns.push(
+                PatternMatch::new(pattern_type, i - min_periods, i, confidence)
+                    .with_points(vec![window_high_max, window_low_min]),
+            );
+        }
+
+        i += min_periods;
+    }
+
+    patterns
+}
+
+/// Detect all chart patterns
+///
+/// Runs all pattern detectors and returns combined results sorted by confidence.
+pub fn detect_all_patterns(high: &[f64], low: &[f64], _close: &[f64]) -> Vec<PatternMatch> {
+    let mut patterns = Vec::new();
+
+    patterns.extend(detect_double_top(high, low, 0.02));
+    patterns.extend(detect_double_bottom(high, low, 0.02));
+    patterns.extend(detect_head_and_shoulders(high, low, 0.03));
+    patterns.extend(detect_inverse_head_and_shoulders(high, low, 0.03));
+    patterns.extend(detect_triangles(high, low, 10));
+
+    // Sort by confidence (highest first)
+    patterns.sort_by(|a, b| {
+        b.confidence
+            .partial_cmp(&a.confidence)
+            .unwrap_or(std::cmp::Ordering::Equal)
+    });
+
+    patterns
+}
+
+// Helper functions
+
+fn find_swing_points_high(data: &[f64], lookback: usize) -> Vec<SwingPoint> {
+    let mut points = Vec::new();
+    let n = data.len();
+
+    for i in lookback..(n.saturating_sub(lookback)) {
+        let left = &data[(i - lookback)..i];
+        let right = &data[(i + 1)..=(i + lookback).min(n - 1)];
+
+        let left_max = max(left);
+        let right_max = max(right);
+
+        if data[i] >= left_max && data[i] >= right_max {
+            points.push(SwingPoint {
+                index: i,
+                value: data[i],
+            });
+        }
+    }
+
+    points
+}
+
+fn find_swing_points_low(data: &[f64], lookback: usize) -> Vec<SwingPoint> {
+    let mut points = Vec::new();
+    let n = data.len();
+
+    for i in lookback..(n.saturating_sub(lookback)) {
+        let left = &data[(i - lookback)..i];
+        let right = &data[(i + 1)..=(i + lookback).min(n - 1)];
+
+        let left_min = min(left);
+        let right_min = min(right);
+
+        if data[i] <= left_min && data[i] <= right_min {
+            points.push(SwingPoint {
+                index: i,
+                value: data[i],
+            });
+        }
+    }
+
+    points
+}
+
+fn find_min_index(data: &[f64]) -> usize {
+    data.iter()
+        .enumerate()
+        .min_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
+        .map(|(i, _)| i)
+        .unwrap_or(0)
+}
+
+fn find_max_index(data: &[f64]) -> usize {
+    data.iter()
+        .enumerate()
+        .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
+        .map(|(i, _)| i)
+        .unwrap_or(0)
+}
+
+/// Result of linear regression
+#[allow(dead_code)]
+struct LineFitResult {
+    slope: f64,
+    intercept: f64,
+    r2: f64,
+}
+
+fn fit_line(points: &[SwingPoint]) -> LineFitResult {
+    let n = points.len();
+    if n < 2 {
+        return LineFitResult {
+            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;
+
+    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;
+    }
+
+    let denom = n as f64 * sum_x2 - sum_x * sum_x;
+    if denom.abs() < 1e-10 {
+        return LineFitResult {
+            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
+    let y_mean = sum_y / n as f64;
+    let ss_tot: f64 = points.iter().map(|p| (p.value - y_mean).powi(2)).sum();
+    let ss_res: f64 = points
+        .iter()
+        .map(|p| {
+            let predicted = slope * p.index as f64 + intercept;
+            (p.value - predicted).powi(2)
+        })
+        .sum();
+
+    let r2 = if ss_tot > 1e-10 {
+        1.0 - ss_res / ss_tot
+    } else {
+        0.0
+    };
+
+    LineFitResult {
+        slope,
+        intercept,
+        r2: r2.max(0.0),
+    }
+}
+
+fn fit_line_from_tuples(points: &[(usize, f64)]) -> LineFitResult {
+    let n = points.len();
+    if n < 2 {
+        return LineFitResult {
+            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;
+
+    for (x, y) in points {
+        let x = *x as f64;
+        sum_x += x;
+        sum_y += y;
+        sum_xy += x * y;
+        sum_x2 += x * x;
+    }
+
+    let denom = n as f64 * sum_x2 - sum_x * sum_x;
+    if denom.abs() < 1e-10 {
+        return LineFitResult {
+            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
+    let y_mean = sum_y / n as f64;
+    let ss_tot: f64 = points.iter().map(|(_, y)| (y - y_mean).powi(2)).sum();
+    let ss_res: f64 = points
+        .iter()
+        .map(|(x, y)| {
+            let predicted = slope * *x as f64 + intercept;
+            (y - predicted).powi(2)
+        })
+        .sum();
+
+    let r2 = if ss_tot > 1e-10 {
+        1.0 - ss_res / ss_tot
+    } else {
+        0.0
+    };
+
+    LineFitResult {
+        slope,
+        intercept,
+        r2: r2.max(0.0),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_pattern_type_direction() {
+        assert!(PatternType::DoubleTop.is_bearish());
+        assert!(PatternType::DoubleBottom.is_bullish());
+        assert!(PatternType::TriangleSymmetrical.is_bullish() == false);
+        assert!(PatternType::TriangleSymmetrical.is_bearish() == false);
+    }
+
+    #[test]
+    fn test_detect_gaps() {
+        let open = vec![100.0, 105.0, 102.0, 95.0]; // Gap up at 1, gap down at 3
+        let high = vec![102.0, 107.0, 104.0, 97.0];
+        let low = vec![99.0, 104.0, 101.0, 94.0];
+
+        let gaps = detect_gaps(&open, &high, &low, 0.02);
+
+        assert!(gaps.len() >= 1); // Should detect at least one gap
+    }
+
+    #[test]
+    fn test_detect_double_top() {
+        // Create a double top pattern
+        let high = vec![
+            100.0, 105.0, 110.0, 105.0, 100.0, // Up to 110, down
+            95.0, 100.0, 105.0, 110.0, 105.0, // Up to 110 again, down
+            100.0,
+        ];
+        let low = vec![
+            98.0, 103.0, 108.0, 102.0, 95.0,
+            92.0, 97.0, 102.0, 108.0, 100.0,
+            95.0,
+        ];
+
+        let patterns = detect_double_top(&high, &low, 0.02);
+
+        // May or may not detect depending on swing points
+        // This is more of a smoke test
+    }
+}