ADX Trend Strength Strategy

!pip install pandas numpy plotly

import warnings
warnings.filterwarnings("ignore")
import pandas as pd
import numpy as np
import plotly.graph_objects as go

def generate_data(periods: int) -> pd.DataFrame:
    start_date     = pd.to_datetime("2024-01-01 00:00:00+00:00")
    datetime_index = pd.date_range(start_date, periods=periods, freq="1min", tz="UTC")

    price_data = []; last_close = 42000
    volatility_scale = 0.005; wick_deviation_scale = 0.002

    for i in range(periods):
        open_price   = last_close + np.random.normal(0, last_close * volatility_scale * 0.1)
        price_change = np.random.normal(0, last_close * volatility_scale)
        close_price  = open_price + price_change

        body_high    = max(open_price, close_price)
        body_low     = min(open_price, close_price)

        high_price   = body_high + abs(np.random.normal(0, last_close * wick_deviation_scale))
        low_price    = body_low  - abs(np.random.normal(0, last_close * wick_deviation_scale))

        high_price   = max(high_price, open_price, close_price)
        low_price    = min(low_price,  open_price, close_price)

        if high_price < low_price:
            high_price, low_price = low_price, high_price

        price_data.append({
            "open":  max(1, int(open_price)),
            "high":  max(1, int(high_price)),
            "low":   max(1, int(low_price)),
            "close": max(1, int(close_price)),
        })
        last_close = close_price

    df = pd.DataFrame(price_data, index=datetime_index)
    df.index.name = "datetime"
    df["volume"] = np.random.uniform(100.0, 500.0, periods)
    df["datetime"] = df.index.to_series()
    return df.reset_index(drop=True)

df = generate_data(500)

print("--- Dataset Shape ---")
display(df.head())
df.info()

def adx_trend_strength_strategy(
    df:            pd.DataFrame,
    window:        int   = 14,
    adx_threshold: float = 25.0,
) -> pd.DataFrame:
    df = df.copy().sort_values("datetime", ignore_index=True)

    # --- True Range ---
    hl  = df["high"] - df["low"]
    hpc = (df["high"] - df["close"].shift(1)).abs()
    lpc = (df["low"]  - df["close"].shift(1)).abs()
    tr  = pd.concat([hl, hpc, lpc], axis=1).max(axis=1)

    # --- Directional Movement ---
    up_move   = df["high"] - df["high"].shift(1)
    down_move = df["low"].shift(1) - df["low"]

    plus_dm  = np.where((up_move > down_move) & (up_move > 0),   up_move,   0.0)
    minus_dm = np.where((down_move > up_move) & (down_move > 0), down_move, 0.0)

    atr_roll = tr.rolling(window).sum()
    plus_di  = 100 * pd.Series(plus_dm).rolling(window).sum()  / atr_roll
    minus_di = 100 * pd.Series(minus_dm).rolling(window).sum() / atr_roll
    dx       = 100 * (plus_di - minus_di).abs() / (plus_di + minus_di).replace(0, np.nan)
    adx      = dx.rolling(window).mean()

    df["+DI"]   = plus_di.values
    df["-DI"]   = minus_di.values
    df["adx"]   = adx.values

    # --- Signal ---
    df["signal"] = np.where(
        (df["adx"] > adx_threshold) & (df["+DI"] > df["-DI"]),   1,
        np.where(
        (df["adx"] > adx_threshold) & (df["-DI"] > df["+DI"]), -1, 0)
    )
    return df

df_signals = adx_trend_strength_strategy(df, window=14, adx_threshold=25.0)

print("--- Signal Distribution ---")
print(df_signals["signal"].value_counts())

print("\n--- ADX Statistics ---")
print(df_signals["adx"].describe().round(2))

display(df_signals[["datetime","close","+DI","-DI","adx","signal"]].dropna().head(20))

buy_signals  = df_signals[df_signals["signal"] ==  1]
sell_signals = df_signals[df_signals["signal"] == -1]

fig = go.FigureWidget(data=[go.Candlestick(
    x=df_signals["datetime"],
    open=df_signals["open"], high=df_signals["high"],
    low=df_signals["low"],   close=df_signals["close"],
    name="Price"
)])

fig.add_trace(go.Scatter(
    x=buy_signals["datetime"],
    y=buy_signals["low"] * 0.999,
    mode="markers",
    marker=dict(symbol="triangle-up",   size=10, color="green"),
    name="Buy Signal (+1)"
))

fig.add_trace(go.Scatter(
    x=sell_signals["datetime"],
    y=sell_signals["high"] * 1.001,
    mode="markers",
    marker=dict(symbol="triangle-down", size=10, color="red"),
    name="Sell Signal (−1)"
))

fig.add_trace(go.Scatter(
    x=df_signals["datetime"], y=df_signals["adx"],
    mode="lines", name="ADX",
    line=dict(color="purple", width=1), yaxis="y2"
))

fig.add_trace(go.Scatter(
    x=df_signals["datetime"], y=df_signals["+DI"],
    mode="lines", name="+DI",
    line=dict(color="green", width=1, dash="dot"), yaxis="y2"
))

fig.add_trace(go.Scatter(
    x=df_signals["datetime"], y=df_signals["-DI"],
    mode="lines", name="−DI",
    line=dict(color="red", width=1, dash="dot"), yaxis="y2"
))

fig.update_layout(
    title_text="ADX Trend Strength Strategy — Signals",
    xaxis_rangeslider_visible=False,
    xaxis_title="Datetime", yaxis_title="Price",
    yaxis2=dict(title="ADX / DI", overlaying="y", side="right", range=[0, 60]),
    height=600,
    yaxis=dict(autorange=True),
)
fig.show()