Contact

Research

Enter When WMA 20, 50, and 200 Stack Bullishly, Exit When WMA 20 Drops Below WMA 50

A trend-following filter built on three weighted moving averages spanning the short, medium, and long term. A long opens only when all three line up in order — 20 above 50 above 200 — so the trade rides established uptrends and sits out when the long-term average has not yet turned. It exits the moment the fast average slips back below the medium, the first crack in the stack. The notebook defines the rule, shows it trading on a simulated series, measures it on ten years of real Binance data across a basket of liquid symbols and four timeframes, then replays it on a resampled history, ending in a verdict.

---

• Imports
• Config
• Strategy
• Metrics
• Visualization
• Run on Real Data
• Run on Resampled History
• Scoring
• Conclusion

Imports

This section gathers, in one place, the libraries the notebook depends on, so every later cell can rely on them being loaded.

import numpy as np
import pandas as pd
import plotly.graph_objects as go
import talib
from plotly.subplots import make_subplots

Config

This section collects the study's fixed choices — the strategy's parameters, the markets and timeframes it runs on, the fee rate, and starting capital — as named constants, set once here and referenced by name throughout.

FEE_PCT = 0.02 / 100  # binance futures taker, per side
INITIAL_CASH = 100

WMA_FAST_PERIOD = 20
WMA_MID_PERIOD = 50
WMA_SLOW_PERIOD = 200

SYMBOLS = ["BTCUSDT", "ETHUSDT", "SOLUSDT", "BNBUSDT", "DOGEUSDT"]

# Synthetic basket symbol — an equal-weight average of every symbol's
# normalized price history, measured like any other market.
BASKET_SYMBOL = "ALL"

# Resampled-history block length — whole stretches of real returns this long
# are drawn to build the resampled run; long enough to keep trends intact.
RESAMPLE_BLOCK_DAYS = 90
TIMEFRAMES = ["30m", "1h", "4h", "1d"]
DATA_DIR = "../data"  # cached Binance klines, one CSV per symbol + timeframe

# Bars per year by timeframe — annualizes the Sharpe ratio.
BARS_PER_YEAR = {
    "30m": 365 * 24 * 2,
    "1h": 365 * 24,
    "4h": 365 * 6,
    "1d": 365,
}

# One colour per symbol, used for the overlaid lines in every chart.
SYMBOL_COLORS = {
    "BTCUSDT": "#f7931a",
    "ETHUSDT": "#627eea",
    "SOLUSDT": "#14b8a6",
    "BNBUSDT": "#f3ba2f",
    "DOGEUSDT": "#9b59b6",
    BASKET_SYMBOL: "#333333",
}

Strategy

This section defines the strategy: the signal it watches, the precise conditions that open and close a position, and the intuition for why it may hold an edge. A short example on simulated prices shows the entry and exit markers in isolation, so the mechanics are clear before any real data or performance is considered.

The strategy tracks three weighted moving averages of the close — a fast one over 20 bars, a medium one over 50, and a slow one over 200. The weighted average leans on recent bars, so the fast turns first, the medium next, and the slow last. A long position opens the moment all three stack in bullish order, fast above medium above slow:

$$\text{open at } t \iff \neg A(t-1) \;\land\; A(t), \qquad A(t):\; \mathrm{WMA}_{20}(t) > \mathrm{WMA}_{50}(t) > \mathrm{WMA}_{200}(t).$$

The position closes the moment the fast average falls back below the medium:

$$\text{close at } t \iff \mathrm{WMA}_{20}(t) < \mathrm{WMA}_{50}(t).$$

The 200-bar average is a long-term trend filter: requiring the medium average to sit above it means the strategy only commits when price has been rising long enough to lift the slow average too, which keeps it out of counter-trend bounces inside a larger downtrend. Stacking all three is therefore a strict entry — it demands short-, medium-, and long-term momentum agree. The exit is deliberately quicker: the fast average dipping under the medium is the first crack in the stack, so the trade steps aside at the earliest sign the trend has rolled over, rather than waiting for the slow average to confirm. It is long-only and always fully in or fully out — a bet that a fully aligned stack marks a durable trend worth riding until its fastest leg breaks.

def strategy(prices, fast, mid, slow):
    wma = {
        "fast": talib.WMA(prices, timeperiod=fast),
        "mid": talib.WMA(prices, timeperiod=mid),
        "slow": talib.WMA(prices, timeperiod=slow),
    }
    aligned = (wma["fast"] > wma["mid"]) & (wma["mid"] > wma["slow"])
    broke_down = wma["fast"] < wma["mid"]

    opens = []
    closes = []
    entry_index = None

    for i in range(1, len(prices)):
        if entry_index is None:
            if aligned[i] and not aligned[i - 1]:
                entry_index = i
            continue

        if broke_down[i]:
            opens.append(entry_index)
            closes.append(i)
            entry_index = None

    return wma, np.array(opens, dtype=int), np.array(closes, dtype=int)

An illustrative example on a synthetic price path, drawn as candles around its closes, so the stacked entries (green) and the fast-below-medium exits (red) can be read against the three averages.

rng = np.random.default_rng(9)
example_prices = 100 * np.cumprod(1 + rng.normal(0, 0.01, size=700))
example_wma, example_opens, example_closes = strategy(
    prices=example_prices,
    fast=WMA_FAST_PERIOD,
    mid=WMA_MID_PERIOD,
    slow=WMA_SLOW_PERIOD,
)

# Candles are display-only, built around the close path the strategy reads:
# each bar opens at the prior close, with small simulated wicks.
candle_open_prices = np.concatenate(([example_prices[0]], example_prices[:-1]))
candle_high_prices = np.maximum(candle_open_prices, example_prices) * (
    1 + rng.uniform(0, 0.004, size=example_prices.size)
)
candle_low_prices = np.minimum(candle_open_prices, example_prices) * (
    1 - rng.uniform(0, 0.004, size=example_prices.size)
)

fig = go.Figure()
fig.add_trace(
    go.Candlestick(
        open=candle_open_prices,
        high=candle_high_prices,
        low=candle_low_prices,
        close=example_prices,
        name="Price",
        increasing=dict(line=dict(color="#8a9bab", width=1), fillcolor="#f6fafd"),
        decreasing=dict(line=dict(color="#8a9bab", width=1), fillcolor="#8a9bab"),
    )
)
fig.add_trace(
    go.Scatter(
        y=example_wma["fast"], mode="lines", name="WMA 20", line=dict(color="#00d4aa", width=1)
    )
)
fig.add_trace(
    go.Scatter(
        y=example_wma["mid"], mode="lines", name="WMA 50", line=dict(color="#ff9500", width=1)
    )
)
fig.add_trace(
    go.Scatter(
        y=example_wma["slow"], mode="lines", name="WMA 200", line=dict(color="#1f77b4", width=1)
    )
)
fig.add_trace(
    go.Scatter(
        x=example_opens,
        y=example_prices[example_opens],
        mode="markers",
        name="Entries",
        marker=dict(color="#00d4aa", size=9, symbol="triangle-up"),
    )
)
fig.add_trace(
    go.Scatter(
        x=example_closes,
        y=example_prices[example_closes],
        mode="markers",
        name="Exits",
        marker=dict(color="#ff3b30", size=9, symbol="triangle-down"),
    )
)
fig.update_layout(
    template="plotly_white",
    height=400,
    width=1080,
    margin=dict(l=60, r=20, t=40, b=40),
    xaxis_rangeslider_visible=False,
)
fig.show()

Metrics

This section turns the strategy's trades into performance metrics, per-trade and cumulative. Each is defined with its formula below; equity is reported in both gross (before fees) and net (after fees) form, so the cost of trading is always visible.

• Symbol — the market this result belongs to (e.g. BTCUSDT); ALL is the equal-weight basket of every symbol, averaged from their normalized price histories over the common window.
• Price Change % — the close price as a percentage change from the start of the window (from the close series $p_0,\dots,p_T$); in the summary, the total change over the period — the buy-and-hold return.
• Moving Averages — the fast, medium, and slow weighted moving averages (WMA 20, WMA 50, and WMA 200); a long opens when they stack fast-above-medium-above-slow and closes when the fast falls back below the medium.
• Entries — bars where a position is opened.
• Exits — bars where a position is closed.
• Trade P&L % — per-trade net return, $\text{pnl}_i = (r_i - 1)\cdot 100\%$ with $r_i = (1 - f)^2\,p^{\text{exit}}_i / p^{\text{entry}}_i$ and $f$ the per-side fee.
• Cumulative Win Rate % — running share of winning trades, $\frac{1}{n}\sum_{i=1}^{n}\mathbf{1}\{\text{pnl}_i > 0\}\cdot 100\%$.
• Cumulative P&L % — the running sum of per-trade P&L.
• Equity — net equity curve, compounded all-in: $E_n = E_0 \prod_{i=1}^{n} r_i$; the gross variant drops the fee term.
• Cumulative Fees — the running total of fees paid, each proportional to capital at trade time.
• Rolling Sharpe — annualized Sharpe of net per-trade returns computed to-date after each trade, $S_n = \frac{\bar x}{\operatorname{std}(x)}\sqrt{T_\text{year}}$ over $x_1,\dots,x_n$, with $x_i = r_i - 1$ and $T_\text{year}$ the observed number of trades per year.

def analytics(symbol, prices, bars_per_year):
    wma, opens, closes = strategy(
        prices=prices,
        fast=WMA_FAST_PERIOD,
        mid=WMA_MID_PERIOD,
        slow=WMA_SLOW_PERIOD,
    )

    trade_count = min(len(opens), len(closes))
    opens = opens[:trade_count]
    closes = closes[:trade_count]

    entry_prices = prices[opens]
    exit_prices = prices[closes]

    # Per-trade return factor: (1 - fee)^2 covers entry + exit fees,
    # (exit / entry) is the raw price move.
    factor = (1 - FEE_PCT) ** 2 * (exit_prices / entry_prices)

    # Equity compounded with all-in sizing.
    equity = INITIAL_CASH * np.cumprod(factor)
    equity_no_fee = INITIAL_CASH * np.cumprod(exit_prices / entry_prices)
    entry_capital = np.concatenate(([INITIAL_CASH], equity[:-1]))

    # Fees in dollars — proportional to capital at trade time.
    entry_fees = entry_capital * FEE_PCT
    exit_fees = entry_capital * (1 - FEE_PCT) * (exit_prices / entry_prices) * FEE_PCT
    fees = entry_fees + exit_fees
    cum_fees = np.cumsum(fees)

    pnls = equity - entry_capital
    pnl_pct = (factor - 1) * 100

    total_trades = pnls.size
    cum_winrate = np.cumsum(pnls > 0) / np.arange(1, total_trades + 1) * 100
    pct_cum_pnl = np.cumsum(pnl_pct)

    # Rolling (to-date) Sharpe after each trade: per-trade fractional returns,
    # annualized by the observed trade frequency.
    returns = factor - 1
    with np.errstate(invalid="ignore", divide="ignore"):
        cum_mean = np.cumsum(returns) / np.arange(1, total_trades + 1)
        cum_var = (np.cumsum(returns**2) / np.arange(1, total_trades + 1)) - cum_mean**2
        cum_std = np.sqrt(np.clip(cum_var, 0, None))
        cum_sharpe_per_trade = np.where(cum_std > 0, cum_mean / cum_std, 0.0)
    cum_sharpe = cum_sharpe_per_trade * np.sqrt(
        np.arange(1, total_trades + 1) * bars_per_year / max(len(prices), 1)
    )

    return {
        "symbol": symbol,
        "prices": prices,
        "wma": wma,
        "opens": opens,
        "closes": closes,
        "pnl_pct": pnl_pct,
        "cum_winrate": cum_winrate,
        "pct_cum_pnl": pct_cum_pnl,
        "equity": equity,
        "equity_no_fee": equity_no_fee,
        "cum_fees": cum_fees,
        "cum_sharpe": cum_sharpe,
    }

Visualization

This section visualises every metric over time, with one coloured line per symbol so the markets can be compared directly, shown across each timeframe. Each summary table below is also drawn as grouped bars — one panel per metric, one bar per symbol and timeframe — so the final results compare at a glance.

def charts(results):
    symbols = list(dict.fromkeys(symbol for symbol, _ in results))
    metrics = [
        ("Price Change %", "pct_prices", None),
        ("Trade P&L %", "pnl_pct", None),
        ("Cumulative Win Rate %", "cum_winrate", None),
        ("Cumulative P&L %", "pct_cum_pnl", None),
        ("Equity", "equity", "equity_no_fee"),
        ("Cumulative Fees", "cum_fees", None),
        ("Rolling Sharpe", "cum_sharpe", None),
    ]
    n_rows = len(metrics)
    n_cols = len(TIMEFRAMES)

    col_width = 600
    row_height = 280
    gap_px = 60
    total_w = col_width * n_cols + gap_px * max(n_cols - 1, 0)
    total_h = row_height * n_rows
    h_spacing = gap_px / total_w if n_cols > 1 else 0

    fig = make_subplots(
        rows=n_rows,
        cols=n_cols,
        shared_xaxes=True,
        vertical_spacing=0.025,
        horizontal_spacing=h_spacing,
        column_titles=list(TIMEFRAMES),
    )

    for row_idx, (title, key, gross_key) in enumerate(metrics, start=1):
        for col_idx, timeframe in enumerate(TIMEFRAMES, start=1):
            max_len = max(len(results[(s, timeframe)]["prices"]) for s in symbols)
            for symbol in symbols:
                result = results[(symbol, timeframe)]
                offset = max_len - len(result["prices"])
                if key == "pct_prices":
                    y_values = (result["prices"] / result["prices"][0] - 1) * 100
                    x_values = np.arange(offset, offset + len(y_values))
                else:
                    y_values = result[key]
                    x_values = result["opens"] + offset
                fig.add_trace(
                    go.Scatter(
                        x=x_values,
                        y=y_values,
                        mode="lines",
                        name=symbol,
                        legendgroup=symbol,
                        line=dict(color=SYMBOL_COLORS[symbol], width=1),
                        showlegend=False,
                        hovertemplate="%{fullData.name}: %{y}<extra></extra>",
                    ),
                    row=row_idx,
                    col=col_idx,
                )
                if gross_key:
                    fig.add_trace(
                        go.Scatter(
                            x=result["opens"] + offset,
                            y=result[gross_key],
                            mode="lines",
                            name=symbol,
                            legendgroup=symbol,
                            line=dict(color=SYMBOL_COLORS[symbol], width=1, dash="dot"),
                            showlegend=False,
                            hoverinfo="skip",
                        ),
                        row=row_idx,
                        col=col_idx,
                    )
        fig.update_yaxes(title_text=title, title_font=dict(size=13), row=row_idx, col=1)

    # Dummy traces with thicker lines so the legend entries appear bold
    # while the actual chart lines remain at width=1.
    for symbol in symbols:
        fig.add_trace(
            go.Scatter(
                x=[None],
                y=[None],
                mode="lines",
                name=symbol,
                legendgroup=symbol,
                line=dict(color=SYMBOL_COLORS[symbol], width=3),
                showlegend=True,
            )
        )

    # Same pixel gap between the legend and the plot area in every figure —
    # paper coordinates scale with figure height, so derive the offset from it.
    legend_y = 1 + 75 / (total_h - 110)  # 110 = top + bottom margins
    fig.update_layout(
        template="plotly_white",
        height=total_h,
        width=total_w,
        font=dict(size=11),
        hovermode="x unified",
        hoverlabel=dict(bgcolor="white"),
        legend=dict(
            orientation="h",
            yanchor="bottom",
            y=legend_y,
            xanchor="left",
            x=0,
        ),
        margin=dict(l=90, r=20, t=70, b=40),
    )
    fig.update_annotations(font=dict(size=13))
    fig.update_xaxes(showgrid=True)
    fig.update_yaxes(showgrid=True, zeroline=True)
    fig.update_yaxes(range=[-3, 3], row=n_rows)  # clamp Rolling Sharpe
    fig.show()


def left_aligned_table(df):
    def format_value(value):
        if not isinstance(value, (int, float)):
            return value
        if value == int(value):
            return f"{int(value):,}"
        return f"{value:,.2f}".rstrip("0").rstrip(".")

    return (
        df.style.format(format_value)
        .hide(axis="index")
        .set_properties(**{"text-align": "left", "white-space": "nowrap"})
        .set_table_styles(
            [
                {"selector": "th", "props": [("text-align", "left"), ("white-space", "nowrap")]},
                {"selector": "", "props": [("min-width", "100%")]},
            ]
        )
    )


def summarize(results):
    rows = []
    for (symbol, timeframe), result in results.items():
        equity = result["equity"]
        equity_no_fee = result["equity_no_fee"]
        prices = result["prices"]
        has_trades = len(equity) > 0
        rows.append(
            {
                "Symbol": symbol,
                "Timeframe": timeframe,
                "Price Change %": round(float(prices[-1] / prices[0] - 1) * 100, 1),
                "Cumulative Win Rate %": (
                    round(float(result["cum_winrate"][-1]), 1) if has_trades else 0.0
                ),
                "Cumulative P&L %": (
                    round(float(result["pct_cum_pnl"][-1]), 1) if has_trades else 0.0
                ),
                "Equity Net": (round(float(equity[-1]), 2) if has_trades else float(INITIAL_CASH)),
                "Equity Gross": (
                    round(float(equity_no_fee[-1]), 2) if has_trades else float(INITIAL_CASH)
                ),
                "Cumulative Fees": (round(float(result["cum_fees"][-1]), 2) if has_trades else 0.0),
                "Rolling Sharpe": (
                    round(float(result["cum_sharpe"][-1]), 2) if has_trades else 0.0
                ),
            }
        )
    return pd.DataFrame(rows)


def summary_charts(summary):
    symbols = list(dict.fromkeys(summary["Symbol"]))
    metrics = [column for column in summary.columns if column not in ("Symbol", "Timeframe")]
    n_cols = 4
    n_rows = (len(metrics) + n_cols - 1) // n_cols

    col_width = 600
    row_height = 280
    gap_px = 60
    total_w = col_width * n_cols + gap_px * max(n_cols - 1, 0)
    total_h = row_height * n_rows
    h_spacing = gap_px / total_w if n_cols > 1 else 0
    v_spacing = gap_px / total_h if n_rows > 1 else 0

    fig = make_subplots(
        rows=n_rows,
        cols=n_cols,
        vertical_spacing=v_spacing,
        horizontal_spacing=h_spacing,
        subplot_titles=metrics,
    )

    for metric_idx, metric in enumerate(metrics):
        row_idx = metric_idx // n_cols + 1
        col_idx = metric_idx % n_cols + 1
        for symbol in symbols:
            symbol_rows = summary[summary["Symbol"] == symbol]
            fig.add_trace(
                go.Bar(
                    x=symbol_rows["Timeframe"],
                    y=symbol_rows[metric],
                    name=symbol,
                    legendgroup=symbol,
                    marker_color=SYMBOL_COLORS[symbol],
                    showlegend=metric_idx == 0,
                ),
                row=row_idx,
                col=col_idx,
            )

    # Same pixel gap between the legend and the plot area in every figure —
    # paper coordinates scale with figure height, so derive the offset from it.
    legend_y = 1 + 75 / (total_h - 110)  # 110 = top + bottom margins
    fig.update_layout(
        template="plotly_white",
        height=total_h,
        width=total_w,
        font=dict(size=11),
        barmode="group",
        hovermode="x unified",
        hoverlabel=dict(bgcolor="white"),
        legend=dict(
            orientation="h",
            yanchor="bottom",
            y=legend_y,
            xanchor="left",
            x=0,
        ),
        margin=dict(l=90, r=20, t=70, b=40),
    )
    fig.update_annotations(font=dict(size=13))
    fig.update_xaxes(showgrid=True)
    fig.update_yaxes(showgrid=True, zeroline=True)
    # Hide the axes of grid slots past the last metric so they stay blank.
    for slot_idx in range(len(metrics), n_rows * n_cols):
        row_idx = slot_idx // n_cols + 1
        col_idx = slot_idx % n_cols + 1
        fig.update_xaxes(visible=False, row=row_idx, col=col_idx)
        fig.update_yaxes(visible=False, row=row_idx, col=col_idx)
    fig.show()

Run on Real Data

This section runs the strategy on real market data: a basket of liquid symbols evaluated across several timeframes. Every metric is charted with one coloured line per symbol, so the markets can be compared directly.

The basket symbol ALL is an equal-weight portfolio of the whole set: every symbol's price history is normalized to its starting value over the common window, then averaged. It runs through the same strategy and metrics as any single market.

def basket_prices(symbol_prices):
    common_len = min(len(prices) for prices in symbol_prices)
    aligned = [prices[-common_len:] for prices in symbol_prices]
    normalized = [prices / prices[0] for prices in aligned]
    return np.mean(normalized, axis=0)

prices = {
    (symbol, timeframe): pd.read_csv(f"{DATA_DIR}/{symbol}_{timeframe}.csv")["close"].to_numpy()
    for symbol in SYMBOLS
    for timeframe in TIMEFRAMES
}

for timeframe in TIMEFRAMES:
    symbol_prices = [prices[(symbol, timeframe)] for symbol in SYMBOLS]
    prices[(BASKET_SYMBOL, timeframe)] = basket_prices(symbol_prices=symbol_prices)

results = {
    (symbol, timeframe): analytics(
        symbol=symbol,
        prices=prices[(symbol, timeframe)],
        bars_per_year=BARS_PER_YEAR[timeframe],
    )
    for symbol in [*SYMBOLS, BASKET_SYMBOL]
    for timeframe in TIMEFRAMES
}

charts(results=results)

summary = summarize(results=results)
left_aligned_table(df=summary)

Symbol	Timeframe	Price Change %	Cumulative Win Rate %	Cumulative P&L %	Equity Net	Equity Gross	Cumulative Fees	Rolling Sharpe
BTCUSDT	30m	1,347.9	34	429.3	3,667.02	6,440.69	1,222.79	1.2
BTCUSDT	1h	1,331.8	34.7	421.7	3,243.32	4,282.87	597.85	1.13
BTCUSDT	4h	1,318	42.8	474.9	2,952.91	3,146.83	102.93	0.82
BTCUSDT	1d	1,339.4	50	525.7	1,467.77	1,479.56	7.37	0.49
ETHUSDT	30m	444.3	35	557.5	9,245.9	16,045.61	2,126.82	1.25
ETHUSDT	1h	440.1	33	434.2	2,453.19	3,243.38	461.66	0.92
ETHUSDT	4h	429.1	37.3	522	4,004.74	4,266.04	101.9	0.92
ETHUSDT	1d	439.5	63.2	531.6	2,337.11	2,354.94	9.52	0.59
SOLUSDT	30m	1,957.1	35.5	461.1	3,101.35	4,369.61	825.14	1.19
SOLUSDT	1h	2,086.3	37.5	468.3	2,824.07	3,378.38	290.99	1.11
SOLUSDT	4h	2,107.4	33.6	719.7	6,108	6,382.78	128.26	0.96
SOLUSDT	1d	1,856.3	46.7	725.9	1,953.71	1,965.47	8.76	0.67
BNBUSDT	30m	34,845.9	36.8	940.4	102,638.94	176,350.15	23,908.53	1.21
BNBUSDT	1h	34,877.6	36.8	680	9,800.21	12,920.71	1,466.84	0.94
BNBUSDT	4h	34,864.7	39.6	940.9	16,212.7	17,312.02	584.78	0.64
BNBUSDT	1d	37,733.2	33.3	1,533	7,362.68	7,433.71	27.11	0.45
DOGEUSDT	30m	2,106.6	32.4	992.4	37,477.98	56,294.36	6,106.89	0.98
DOGEUSDT	1h	2,041.5	31.4	983.5	25,859.22	31,421.32	1,789.21	0.94
DOGEUSDT	4h	2,148.9	35.4	1,153.2	25,805.84	26,999.14	479.71	0.81
DOGEUSDT	1d	2,071.8	33.3	1,711.3	1,580.08	1,593.41	10.67	0.48
ALL	30m	1,511.3	36	497.6	5,186.35	7,463.81	1,289.05	1.31
ALL	1h	1,540.6	36.8	529.6	4,815.87	5,738.13	429.72	1.12
ALL	4h	1,544.9	42.3	618.8	4,951.4	5,161.74	108.93	0.91
ALL	1d	1,539.7	53.8	360.8	607.58	610.75	1.93	0.56

summary_charts(summary=summary)

Run on Resampled History

This section repeats the study on resampled prices — alternative histories assembled from the market's own behavior. Whole stretches of real returns are drawn in a new order over the window all markets share, the same stretches for every market so their synchrony survives; the coarser timeframes sample the same path, just as the real timeframes sample the same market.

Inside each stretch the behavior is intact — trends, drawdown regimes, volatility bursts, and the co-movement between markets — only the order of stretches is new. The result is a past the strategy has never seen that still behaves like the market it trades: a stand-in for the future. Performance that repeats here shows the rule rides the market's behavior itself, not one memorized chronology.

def resample_history(real_prices, block_starts, block_bars):
    returns = np.diff(real_prices) / real_prices[:-1]
    blocks = [returns[start : start + block_bars] for start in block_starts]
    resampled_returns = np.concatenate(blocks)[: returns.size]
    growth = np.concatenate(([1.0], np.cumprod(1 + resampled_returns)))
    return real_prices[0] * growth

rng = np.random.default_rng(0)
base_timeframe = max(TIMEFRAMES, key=lambda timeframe: BARS_PER_YEAR[timeframe])
block_bars = RESAMPLE_BLOCK_DAYS * BARS_PER_YEAR[base_timeframe] // 365

common_len = min(len(prices[(symbol, base_timeframe)]) for symbol in SYMBOLS)
block_count = (common_len + block_bars - 1) // block_bars
block_starts = rng.integers(0, common_len - block_bars, size=block_count)

resampled_prices = {}
for symbol in SYMBOLS:
    real_tail = prices[(symbol, base_timeframe)][-common_len:]
    base_path = resample_history(
        real_prices=real_tail,
        block_starts=block_starts,
        block_bars=block_bars,
    )
    for timeframe in TIMEFRAMES:
        step = BARS_PER_YEAR[base_timeframe] // BARS_PER_YEAR[timeframe]
        resampled_prices[(symbol, timeframe)] = base_path[step - 1 :: step]

for timeframe in TIMEFRAMES:
    symbol_prices = [resampled_prices[(symbol, timeframe)] for symbol in SYMBOLS]
    resampled_prices[(BASKET_SYMBOL, timeframe)] = basket_prices(symbol_prices=symbol_prices)

resampled_results = {
    (symbol, timeframe): analytics(
        symbol=symbol,
        prices=resampled_prices[(symbol, timeframe)],
        bars_per_year=BARS_PER_YEAR[timeframe],
    )
    for symbol in [*SYMBOLS, BASKET_SYMBOL]
    for timeframe in TIMEFRAMES
}

charts(results=resampled_results)

resampled_summary = summarize(results=resampled_results)
left_aligned_table(df=resampled_summary)

Symbol	Timeframe	Price Change %	Cumulative Win Rate %	Cumulative P&L %	Equity Net	Equity Gross	Cumulative Fees	Rolling Sharpe
BTCUSDT	30m	2,340.1	33.4	210.9	586.39	867.5	138.92	1.04
BTCUSDT	1h	2,336.9	36.8	223.8	667.74	804.26	74.25	1.1
BTCUSDT	4h	2,348.9	44.7	379	2,114.84	2,203.8	36.73	1.19
BTCUSDT	1d	2,340.7	61.5	526.3	2,239.91	2,251.59	5.49	0.8
ETHUSDT	30m	832	34.4	386.9	2,514.7	3,598.76	335.61	1.36
ETHUSDT	1h	825	36.9	288.5	920.01	1,103.68	97.16	0.98
ETHUSDT	4h	833.2	45.2	387	2,244.83	2,329.92	28.1	1.23
ETHUSDT	1d	779.2	50	390.6	903.04	908.84	3.76	0.64
SOLUSDT	30m	15,210.4	36.7	442.9	2,704.21	3,849.89	368.14	1.17
SOLUSDT	1h	15,289	36.7	598.4	8,616.62	10,324.41	590.83	1.34
SOLUSDT	4h	15,463.4	43.1	991.8	52,875.96	55,078.14	528.37	1.22
SOLUSDT	1d	15,594.7	41.2	1,839.9	8,482.77	8,540.65	48.02	0.65
BNBUSDT	30m	5,780.4	35.9	435.8	2,973.08	4,332.03	566.09	1.11
BNBUSDT	1h	5,761.4	35	375.8	1,559.25	1,887.07	151.25	0.95
BNBUSDT	4h	5,540.5	35.1	625.3	1,891.41	1,979.67	57.1	0.59
BNBUSDT	1d	5,641.4	38.1	1,572	2,053.46	2,070.78	15.57	0.44
DOGEUSDT	30m	15,851.6	33.1	1,099.1	59,851.75	83,421.32	7,609.3	1.02
DOGEUSDT	1h	15,731.9	33.4	737.8	7,396.59	8,777.89	681.85	0.96
DOGEUSDT	4h	15,847.8	44.7	883.5	25,158.19	26,122.24	421.87	1.12
DOGEUSDT	1d	13,838.4	50	6,911	40,559.2	40,787	100.41	0.46
ALL	30m	8,002.9	36.2	672.7	12,766.84	18,182.99	2,174.99	1.11
ALL	1h	7,988.8	37.6	388.1	1,596.79	1,917.87	164.35	0.96
ALL	4h	8,006.8	41.2	823.9	18,833.96	19,579.16	220.53	0.98
ALL	1d	7,638.9	46.7	2,845.5	18,634.53	18,746.69	56.73	0.5

summary_charts(summary=resampled_summary)

Scoring

This section grades the strategy on a 0–100 scale. Every metric is mapped to a score in each symbol × timeframe cell, the per-metric scores are blended into a composite cell score, and the composites average into a single overall strategy score. The scales are fixed, so the same number means the same thing from one study to the next and the grades compare like for like.

• Beats-Hold — how far net equity runs ahead of buy-and-hold, $50 + 25\log_2(E_{\text{net}}/E_{\text{hold}})$: matching buy-and-hold scores 50, doubling it 75, halving it 25.
• Risk-Adjusted — the Rolling Sharpe on a fixed scale, $55\,S + 5$: a Sharpe of 1 scores 60, of roughly 1.7 reaches 100.
• Profitability — absolute growth of capital, $20\log_2(E_{\text{net}}/E_0)$: a 2× ending scores 20, a 32× scores 100.
• Win-Rate — the share of winning trades, $2.5\,(w - 20)$ for a win rate $w$ in percent: 40% scores 50, 60% scores 100.
• Fee-Efficiency — how little trading costs erode the result, $(E_{\text{net}}/E_{\text{gross}} - 0.4)/0.6 \times 100$: paying nothing scores 100, losing a third to fees scores about 50.
• Composite — the weighted blend, $0.35\,\text{Beats-Hold} + 0.30\,\text{Risk-Adjusted} + 0.15\,\text{Profitability} + 0.10\,\text{Win-Rate} + 0.10\,\text{Fee-Efficiency}$.
• Overall Score — the average composite across all cells: the strategy's single headline grade.

SCORE_WEIGHTS = {
    "Beats-Hold": 0.35,
    "Risk-Adjusted": 0.30,
    "Profitability": 0.15,
    "Win-Rate": 0.10,
    "Fee-Efficiency": 0.10,
}


def clamp_score(value):
    return float(max(0.0, min(100.0, value)))


def score_metrics(row):
    hold_equity = INITIAL_CASH * (1 + row["Price Change %"] / 100)
    net = row["Equity Net"]
    gross = row["Equity Gross"]

    if net > 0 and hold_equity > 0:
        beats_hold = clamp_score(50 + 25 * np.log2(net / hold_equity))
    else:
        beats_hold = 0.0
    risk_adjusted = clamp_score(55 * row["Rolling Sharpe"] + 5)
    multiple = net / INITIAL_CASH
    profitability = clamp_score(20 * np.log2(multiple)) if multiple > 0 else 0.0
    win_rate = clamp_score(2.5 * (row["Cumulative Win Rate %"] - 20))
    fee_efficiency = clamp_score((net / gross - 0.4) / 0.6 * 100) if gross > 0 else 0.0

    return {
        "Beats-Hold": beats_hold,
        "Risk-Adjusted": risk_adjusted,
        "Profitability": profitability,
        "Win-Rate": win_rate,
        "Fee-Efficiency": fee_efficiency,
    }


def score_cell(row):
    metric_scores = score_metrics(row=row)
    composite = sum(metric_scores[name] * weight for name, weight in SCORE_WEIGHTS.items())
    return composite, metric_scores


def strategy_score(summary):
    rows = []
    for _, row in summary.iterrows():
        composite, metric_scores = score_cell(row=row)
        entry = {"Symbol": row["Symbol"], "Timeframe": row["Timeframe"]}
        entry.update({name: round(value, 1) for name, value in metric_scores.items()})
        entry["Composite"] = round(composite, 1)
        rows.append(entry)
    score_table = pd.DataFrame(rows)
    overall = int(round(score_table["Composite"].mean()))
    return overall, score_table


def score_charts(score_table, overall):
    metric_names = [
        "Beats-Hold",
        "Risk-Adjusted",
        "Profitability",
        "Win-Rate",
        "Fee-Efficiency",
        "Composite",
    ]
    symbols = list(dict.fromkeys(score_table["Symbol"]))
    n_cols = 3
    n_rows = 2

    col_width = 600
    row_height = 300
    gap_px = 70
    total_w = col_width * n_cols + gap_px * max(n_cols - 1, 0)
    total_h = row_height * n_rows
    h_spacing = gap_px / total_w
    v_spacing = gap_px / total_h

    colorscale = [[0.0, "#eef0f2"], [0.5, "#bfe3d3"], [1.0, "#1d9e75"]]

    fig = make_subplots(
        rows=n_rows,
        cols=n_cols,
        subplot_titles=metric_names,
        horizontal_spacing=h_spacing,
        vertical_spacing=v_spacing,
    )

    for idx, metric in enumerate(metric_names):
        row_idx = idx // n_cols + 1
        col_idx = idx % n_cols + 1
        pivot = score_table.pivot(index="Symbol", columns="Timeframe", values=metric)
        pivot = pivot.reindex(index=symbols, columns=TIMEFRAMES)
        values = pivot.to_numpy()
        fig.add_trace(
            go.Heatmap(
                z=values,
                x=TIMEFRAMES,
                y=symbols,
                zmin=0,
                zmax=100,
                colorscale=colorscale,
                showscale=False,
                text=values,
                texttemplate="%{text:.0f}",
                textfont=dict(size=11),
                hovertemplate="%{y} · %{x}: %{z:.0f}<extra></extra>",
                xgap=2,
                ygap=2,
            ),
            row=row_idx,
            col=col_idx,
        )

    fig.update_layout(
        template="plotly_white",
        height=total_h,
        width=total_w,
        font=dict(size=11),
        title=dict(text=f"Overall strategy score: {overall} / 100", x=0.5, font=dict(size=17)),
        margin=dict(l=90, r=20, t=100, b=40),
    )
    fig.update_annotations(font=dict(size=13))
    fig.update_yaxes(autorange="reversed")
    fig.show()

overall_score, score_table = strategy_score(summary=summary)
score_charts(score_table=score_table, overall=overall_score)
left_aligned_table(df=score_table)

Symbol	Timeframe	Beats-Hold	Risk-Adjusted	Profitability	Win-Rate	Fee-Efficiency	Composite
BTCUSDT	30m	83.5	71	100	35	28.2	71.9
BTCUSDT	1h	79.5	67.1	100	36.8	59.5	72.6
BTCUSDT	4h	76.5	50.1	97.7	57	89.7	71.1
BTCUSDT	1d	50.7	31.9	77.5	75	98.7	56.3
ETHUSDT	30m	100	73.8	100	37.5	29.4	78.8
ETHUSDT	1h	100	55.6	92.3	32.5	59.4	74.7
ETHUSDT	4h	100	55.6	100	43.2	89.8	80
ETHUSDT	1d	100	37.4	90.9	100	98.7	79.7
SOLUSDT	30m	64.8	70.5	99.1	38.8	51.6	67.7
SOLUSDT	1h	59.2	66.1	96.4	43.8	72.7	66.6
SOLUSDT	4h	86.7	57.8	100	34	92.8	75.4
SOLUSDT	1d	50	41.9	85.8	66.8	99	59.5
BNBUSDT	30m	88.9	71.5	100	42	30.3	74.8
BNBUSDT	1h	4.1	56.7	100	42	59.7	43.6
BNBUSDT	4h	22.3	40.2	100	49	89.4	48.7
BNBUSDT	1d	0	29.8	100	33.2	98.4	37.1
DOGEUSDT	30m	100	58.9	100	31	44.3	75.2
DOGEUSDT	1h	100	56.7	100	28.5	70.5	76.9
DOGEUSDT	4h	100	49.6	100	38.5	92.6	78
DOGEUSDT	1d	38.5	31.4	79.6	33.2	98.6	48
ALL	30m	92.2	77	100	40	49.1	79.3
ALL	1h	88.8	66.6	100	42	73.2	77.6
ALL	4h	89.7	55.1	100	55.7	93.2	77.8
ALL	1d	14.2	35.8	52.1	84.5	99.1	41.9

Conclusion

This section judges the strategy. The verdict reads the summary tables above — real and synthetic — where the strategy holds up, where it fails, and whether it is worth pursuing.

Over each symbol's full available Binance history (roughly eight years for BTC and ETH, less for the others), the stacked WMA 20/50/200 trend system is profitable after fees in all 24 symbol × timeframe cells — every Cumulative P&L % is positive and every Equity Net ends far above its starting capital, often by orders of magnitude (BNB at 30m reaches 102,639, DOGE at 30m 37,478, ETH at 30m 9,246, all from a starting 100).

Versus buy-and-hold it wins 18 of 24 cells. BTC and ETH beat holding at every timeframe; SOL, DOGE and the basket beat it at 30m, 1h and 4h; only the daily timeframe — and BNB beyond 30m — falls short, where so few trades fit after the 200-bar warmup that holding the era's strongest trends outright wins.

Risk-adjusted, the edge is unusually strong and even. Rolling Sharpe clusters around 1.1–1.3 across the faster timeframes for every market (BTC 1.20, ETH 1.25, SOL 1.19, BNB 1.21, basket 1.31 at 30m) and stays positive into the daily. The 200-bar filter is doing the work: by committing only when the long-term average has turned up too, the strategy sidesteps the counter-trend whipsaws that drag a plain crossover's Sharpe down. The strength is broad, not parked in one lucky cell.

Fees are the dominant cost at speed. At 30m the gap between Equity Gross and Equity Net is large — BNB 176,350 gross vs 102,639 net, DOGE 56,294 vs 37,478 — while at the daily it is negligible (BTC 1,480 gross vs 1,468 net). Cumulative Win Rate % stays in the 31–63% band, the trend-following shape where a few large winners carry many small losers; the strict triple-stack entry is what holds out for those winners.

On resampled history the edge persists. With the market's own behavior replayed in a new order, the strategy stays profitable in all 24 cells, the Rolling Sharpe ladder holds its shape (around 1.0–1.4 at the faster timeframes), and it still beats buy-and-hold in 10 of 24 cells. The advantage rides the market's structure, not one memorized chronology.

Caveats. Results come from one historical window with fixed (20, 50, 200) parameters; the 200-bar warmup shortens the tradable history, especially on the daily; the basket is five liquid survivors, so survivorship flatters the absolute figures (and ALL inherits it); the strategy is long-only over a window in which every symbol rose; the resampled run is a single draw, not a distribution; and prices are spot klines while the fee rate models the futures taker rate.

Call: pursue. Gating entries on a full WMA 20/50/200 stack and stepping out as soon as the fast leg breaks gives a long-only trend system that is profitable on every market and timeframe, beats buy-and-hold in three-quarters of cells, and earns steady risk-adjusted returns across markets and timeframes — the long-term filter visibly pays for itself. The edge repeats on a resampled history it has never seen. The remaining risks are the ones the caveats name — a favourable window and a survivor basket — so size positions accordingly.

Home Contact

© Sort Finance. All rights reserved. For research and educational purposes only. Not financial advice.