fibonacci-harmonic-wave

Fibonacci, Harmonic Patterns & Elliott Wave Engine

Section 1: Fibonacci Analysis

Core Fibonacci Levels Reference

RETRACEMENT LEVELS:
  23.6% → Minor support/resistance (weak)
  38.2% → Moderate pullback level
  50.0% → Psychological midpoint (widely watched, not true Fibonacci)
  61.8% → "Golden Ratio" — MOST IMPORTANT level
  78.6% → Deep retracement (= √0.618)
  88.6% → Very deep (= √0.786); used in harmonic patterns

EXTENSION LEVELS (profit targets):
  127.2% = 1st extension (= √1.272)
  138.2%
  161.8% = Most common major target
  200.0% = Double the prior move
  261.8% = Strong extension target

Entry Strategy:
  Conservative: Wait for price to react at level + candle confirmation
  Aggressive: Enter directly at level with tight stop

Stop Loss: Just beyond next Fibonacci level (e.g., short at 61.8%, stop above 78.6%)

Extensions — How to Draw:
  Uptrend: From swing low (A) to swing high (B) to retracement low (C)
  Target = C + (A to B distance × extension %)

Fibonacci Time Zones

After swing high or low, count forward:
Bars 1, 2, 3, 5, 8, 13, 21, 34, 55, 89...
→ Significant reactions likely at these time intervals

Fibonacci Strategy Engine (Code)

import pandas as pd, numpy as np
from scipy.signal import argrelextrema

FIB_LEVELS = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1.0]
FIB_EXTENSIONS = [1.0, 1.272, 1.414, 1.618, 2.0, 2.618]

class FibonacciEngine:

    @staticmethod
    def retracement(swing_high: float, swing_low: float, direction: str = "up") -> dict:
        diff = swing_high - swing_low
        levels = {}
        for fib in FIB_LEVELS:
            if direction == "up":
                levels[f"{fib:.3f}"] = round(swing_high - fib * diff, 5)
            else:
                levels[f"{fib:.3f}"] = round(swing_low + fib * diff, 5)
        return {
            "direction": direction, "swing_high": swing_high, "swing_low": swing_low,
            "levels": levels,
            "golden_zone": f"{levels['0.618']} — {levels['0.786']}",
            "strategy": "Buy at 0.618-0.786 in uptrend, sell at 0.618-0.786 in downtrend",
        }

    @staticmethod
    def extension(point_a: float, point_b: float, point_c: float) -> dict:
        diff = abs(point_b - point_a)
        direction = 1 if point_b > point_a else -1
        levels = {}
        for ext in FIB_EXTENSIONS:
            levels[f"{ext:.3f}"] = round(point_c + direction * diff * ext, 5)
        return {"extensions": levels, "primary_target": levels["1.618"]}

    @staticmethod
    def auto_fib(df: pd.DataFrame, order: int = 10) -> dict:
        """Automatically detect last major swing and compute fibs."""
        highs = argrelextrema(df["high"].values, np.greater, order=order)[0]
        lows = argrelextrema(df["low"].values, np.less, order=order)[0]
        if len(highs) == 0 or len(lows) == 0:
            return {"error": "No swings found"}
        last_high = df["high"].iloc[highs[-1]]
        last_low = df["low"].iloc[lows[-1]]
        direction = "up" if lows[-1] < highs[-1] else "down"
        return FibonacciEngine.retracement(last_high, last_low, direction)

    @staticmethod
    def cluster_zones(fibs_list: list, tolerance: float = 0.0005) -> list:
        """Find confluence zones where multiple fib levels cluster together."""
        all_levels = []
        for fib_set in fibs_list:
            for level_name, price in fib_set.get("levels", {}).items():
                all_levels.append(price)
        all_levels.sort()
        clusters = []
        i = 0
        while i < len(all_levels):
            cluster = [all_levels[i]]
            while i + 1 < len(all_levels) and all_levels[i + 1] - all_levels[i] < tolerance:
                i += 1
                cluster.append(all_levels[i])
            if len(cluster) >= 2:
                clusters.append({
                    "zone_center": round(np.mean(cluster), 5),
                    "zone_width": round(max(cluster) - min(cluster), 5),
                    "n_fibs_confluent": len(cluster),
                    "strength": "STRONG" if len(cluster) >= 3 else "MODERATE",
                })
            i += 1
        return sorted(clusters, key=lambda c: c["n_fibs_confluent"], reverse=True)