Study 1: 12 famous strategies, one protocol

Study 1, wave 1: twelve famous strategies on QQQ, one fixed protocol

Frozen before any run, 2026-10-28. The strategy files are fixed by the SHA-256 hashes at the bottom of this page. Nothing below changes after the first run. A change would be a new study with a new protocol.

918eccd6851cf015b3c4592fae89380061eee29994046365f54a1cdbae1f37c0  strategies/01_rsi2.py
34ee64a8a3700054e0d0812d520edd8e5133de42f5bf489474c5114fa285ed80  strategies/02_rsi14.py
eba0bfaaaa764f332883c9b21e79a4f7563d50123b14bce9a2265a5c480d591a  strategies/03_macd.py
4a6f5086a9acd1a393e13b3ea5eb63b894712034936593f60a79849dea74dd34  strategies/04_golden_cross.py
3f894d90a4dd5dd6cb03bfa642d1b6e2ca6226f7f4121c420b111e28ad48ac05  strategies/05_ema_9_21.py
c4a0d4f804e3b33cc3fb51c7723790c0e722ac61e4f83d5bb7e9b268870b257f  strategies/06_bollinger.py
a6e8e7290be5f34b4c1ddc6af857603ae70739d77f32c9579c7084fb5172860b  strategies/07_donchian.py
b23f395d20bbe9d4fa9d25cdaf23af956998fc1ef5c6a543dc543a805566d3a9  strategies/08_supertrend.py
a7cdc5128deef3c54100b7e37cdf489af9189c1217763fc6d46a71b24685e1af  strategies/09_parabolic_sar.py
8146121862a610b083a6684e67c1caedf3aadef4a0cafbce6a1d3032ad31cb3e  strategies/10_stochastic.py
95b39462b2495e871631ec687de0c22ef5bac4a2d696db1ec783b8a2c71f3ef4  strategies/11_keltner.py
17f75e5c715906fecc370093c1648b2776f5577b62ddc353f183ea20e48e9c02  strategies/12_tsmom_12_1.py

SHA-256: 918eccd6851cf015b3c4592fae89380061eee29994046365f54a1cdbae1f37c0

"""RSI(2) 10/90, long only.

Long when RSI(2) closes below 10; exit when RSI(2) closes above 90.
RSI is Wilder's: the average gain and the average loss are smoothed with alpha = 1/n,
each seeded with the simple mean of the first n changes; RSI = 100 - 100 / (1 + gain / loss),
and 100 when the average loss is 0. Orders fill at the next bar's open.
"""
import numpy as np
from backtesting import Strategy


def smooth(values, n, alpha):
    """out[i] = alpha * x[i] + (1 - alpha) * out[i-1], seeded with the mean of the first n values (leading NaNs skipped)."""
    x = np.asarray(values, dtype=float)
    out = np.full(len(x), np.nan)
    first = int(np.argmax(~np.isnan(x)))
    seed = first + n - 1
    if seed >= len(x):
        return out
    out[seed] = x[first:seed + 1].mean()
    for i in range(seed + 1, len(x)):
        out[i] = alpha * x[i] + (1 - alpha) * out[i - 1]
    return out


def rsi(close, n):
    change = np.diff(np.asarray(close, dtype=float), prepend=np.nan)
    gain = smooth(np.clip(change, 0, None), n, 1.0 / n)
    loss = smooth(np.clip(-change, 0, None), n, 1.0 / n)
    return np.where(loss == 0, 100.0, 100.0 - 100.0 / (1.0 + gain / loss))


class Rsi2(Strategy):
    rsi_period = 2
    entry_below = 10
    exit_above = 90

    def init(self):
        self.rsi = self.I(rsi, self.data.Close, self.rsi_period, name='RSI')

    def next(self):
        if not self.position:
            if self.rsi[-1] < self.entry_below:
                self.buy()
        elif self.rsi[-1] > self.exit_above:
            self.position.close()

SHA-256: 34ee64a8a3700054e0d0812d520edd8e5133de42f5bf489474c5114fa285ed80

"""RSI(14) 30/70, long only.

Long when RSI(14) closes below 30; exit when RSI(14) closes above 70.
RSI is Wilder's: the average gain and the average loss are smoothed with alpha = 1/n,
each seeded with the simple mean of the first n changes; RSI = 100 - 100 / (1 + gain / loss),
and 100 when the average loss is 0. Orders fill at the next bar's open.
"""
import numpy as np
from backtesting import Strategy


def smooth(values, n, alpha):
    """out[i] = alpha * x[i] + (1 - alpha) * out[i-1], seeded with the mean of the first n values (leading NaNs skipped)."""
    x = np.asarray(values, dtype=float)
    out = np.full(len(x), np.nan)
    first = int(np.argmax(~np.isnan(x)))
    seed = first + n - 1
    if seed >= len(x):
        return out
    out[seed] = x[first:seed + 1].mean()
    for i in range(seed + 1, len(x)):
        out[i] = alpha * x[i] + (1 - alpha) * out[i - 1]
    return out


def rsi(close, n):
    change = np.diff(np.asarray(close, dtype=float), prepend=np.nan)
    gain = smooth(np.clip(change, 0, None), n, 1.0 / n)
    loss = smooth(np.clip(-change, 0, None), n, 1.0 / n)
    return np.where(loss == 0, 100.0, 100.0 - 100.0 / (1.0 + gain / loss))


class Rsi14(Strategy):
    rsi_period = 14
    entry_below = 30
    exit_above = 70

    def init(self):
        self.rsi = self.I(rsi, self.data.Close, self.rsi_period, name='RSI')

    def next(self):
        if not self.position:
            if self.rsi[-1] < self.entry_below:
                self.buy()
        elif self.rsi[-1] > self.exit_above:
            self.position.close()

SHA-256: eba0bfaaaa764f332883c9b21e79a4f7563d50123b14bce9a2265a5c480d591a

"""MACD(12, 26, 9) cross, long only.

Long when the MACD line crosses above the signal line; exit when it crosses below.
MACD line = EMA(12) - EMA(26) of the close; signal line = EMA(9) of the MACD line.
EMA: alpha = 2 / (n + 1), seeded with the simple mean of the first n values.
A crosses above B on a bar when A > B on that bar and A <= B on the bar before (below: the mirror).
Orders fill at the next bar's open.
"""
import numpy as np
from backtesting import Strategy


def smooth(values, n, alpha):
    """out[i] = alpha * x[i] + (1 - alpha) * out[i-1], seeded with the mean of the first n values (leading NaNs skipped)."""
    x = np.asarray(values, dtype=float)
    out = np.full(len(x), np.nan)
    first = int(np.argmax(~np.isnan(x)))
    seed = first + n - 1
    if seed >= len(x):
        return out
    out[seed] = x[first:seed + 1].mean()
    for i in range(seed + 1, len(x)):
        out[i] = alpha * x[i] + (1 - alpha) * out[i - 1]
    return out


def ema(values, n):
    return smooth(values, n, 2.0 / (n + 1))


class MacdCross(Strategy):
    fast_period = 12
    slow_period = 26
    signal_period = 9

    def init(self):
        self.macd = self.I(lambda c: ema(c, self.fast_period) - ema(c, self.slow_period), self.data.Close, name='MACD')
        self.signal = self.I(lambda m: ema(m, self.signal_period), self.macd, name='Signal')

    def next(self):
        m, s = self.macd, self.signal
        if not self.position:
            if m[-2] <= s[-2] and m[-1] > s[-1]:
                self.buy()
        elif m[-2] >= s[-2] and m[-1] < s[-1]:
            self.position.close()

SHA-256: 4a6f5086a9acd1a393e13b3ea5eb63b894712034936593f60a79849dea74dd34

"""Golden cross 50/200, long only.

Long when SMA(50) of the close crosses above SMA(200); exit when it crosses below.
A crosses above B on a bar when A > B on that bar and A <= B on the bar before (below: the mirror).
Orders fill at the next bar's open.
"""
import pandas as pd
from backtesting import Strategy


def sma(values, n):
    return pd.Series(values).rolling(n).mean().to_numpy()


class GoldenCross(Strategy):
    fast_period = 50
    slow_period = 200

    def init(self):
        self.fast = self.I(sma, self.data.Close, self.fast_period, name='SMA50')
        self.slow = self.I(sma, self.data.Close, self.slow_period, name='SMA200')

    def next(self):
        f, s = self.fast, self.slow
        if not self.position:
            if f[-2] <= s[-2] and f[-1] > s[-1]:
                self.buy()
        elif f[-2] >= s[-2] and f[-1] < s[-1]:
            self.position.close()

SHA-256: 3f894d90a4dd5dd6cb03bfa642d1b6e2ca6226f7f4121c420b111e28ad48ac05

"""EMA 9/21 cross, long only.

Long when EMA(9) of the close crosses above EMA(21); exit when it crosses below.
EMA: alpha = 2 / (n + 1), seeded with the simple mean of the first n values.
A crosses above B on a bar when A > B on that bar and A <= B on the bar before (below: the mirror).
Orders fill at the next bar's open.
"""
import numpy as np
from backtesting import Strategy


def smooth(values, n, alpha):
    """out[i] = alpha * x[i] + (1 - alpha) * out[i-1], seeded with the mean of the first n values (leading NaNs skipped)."""
    x = np.asarray(values, dtype=float)
    out = np.full(len(x), np.nan)
    first = int(np.argmax(~np.isnan(x)))
    seed = first + n - 1
    if seed >= len(x):
        return out
    out[seed] = x[first:seed + 1].mean()
    for i in range(seed + 1, len(x)):
        out[i] = alpha * x[i] + (1 - alpha) * out[i - 1]
    return out


def ema(values, n):
    return smooth(values, n, 2.0 / (n + 1))


class EmaCross(Strategy):
    fast_period = 9
    slow_period = 21

    def init(self):
        self.fast = self.I(ema, self.data.Close, self.fast_period, name='EMA9')
        self.slow = self.I(ema, self.data.Close, self.slow_period, name='EMA21')

    def next(self):
        f, s = self.fast, self.slow
        if not self.position:
            if f[-2] <= s[-2] and f[-1] > s[-1]:
                self.buy()
        elif f[-2] >= s[-2] and f[-1] < s[-1]:
            self.position.close()

SHA-256: c4a0d4f804e3b33cc3fb51c7723790c0e722ac61e4f83d5bb7e9b268870b257f

"""Bollinger(20, 2) mean reversion, long only.

Long when the close is below the lower band; exit when the close is above the middle band.
Middle band = SMA(20) of the close; lower band = middle - 2 x the population standard
deviation (divisor n) of the last 20 closes. Orders fill at the next bar's open.
"""
import pandas as pd
from backtesting import Strategy


class BollingerReversion(Strategy):
    period = 20
    width = 2

    def init(self):
        close = pd.Series(self.data.Close)
        mid = close.rolling(self.period).mean()
        lower = mid - self.width * close.rolling(self.period).std(ddof=0)
        self.mid = self.I(lambda: mid.to_numpy(), name='Middle')
        self.lower = self.I(lambda: lower.to_numpy(), name='Lower')

    def next(self):
        close = self.data.Close[-1]
        if not self.position:
            if close < self.lower[-1]:
                self.buy()
        elif close > self.mid[-1]:
            self.position.close()

SHA-256: a6e8e7290be5f34b4c1ddc6af857603ae70739d77f32c9579c7084fb5172860b

"""Donchian / Turtle System 1 breakout, long only (the stated close rule only).

Long when the close is above the highest high of the previous 20 bars; exit when the close
is below the lowest low of the previous 10 bars. "Previous" leaves the current bar out.
Orders fill at the next bar's open.
"""
import pandas as pd
from backtesting import Strategy


class DonchianBreakout(Strategy):
    entry_period = 20
    exit_period = 10

    def init(self):
        self.prior_high = self.I(lambda h: pd.Series(h).rolling(self.entry_period).max().shift(1).to_numpy(), self.data.High, name='High20')
        self.prior_low = self.I(lambda low: pd.Series(low).rolling(self.exit_period).min().shift(1).to_numpy(), self.data.Low, name='Low10')

    def next(self):
        close = self.data.Close[-1]
        if not self.position:
            if close > self.prior_high[-1]:
                self.buy()
        elif close < self.prior_low[-1]:
            self.position.close()

SHA-256: b23f395d20bbe9d4fa9d25cdaf23af956998fc1ef5c6a543dc543a805566d3a9

"""Supertrend(10, 3), long only.

Long when Supertrend flips to up; exit when it flips to down.
True range = max(high - low, |high - previous close|, |low - previous close|), and high - low on
the first bar. ATR(10) is Wilder's: alpha = 1/10, seeded with the mean of the first 10 true ranges.
Basic bands: (high + low) / 2 +/- 3 x ATR. Final upper band: the basic upper band if it is below the
previous final upper band or the previous close was above it, else the previous final upper band;
final lower band: the mirror. The trend starts down on the first bar with an ATR. While down it turns
up when the close is above the final upper band; while up it turns down when the close is below the
final lower band. Orders fill at the next bar's open.
"""
import numpy as np
from backtesting import Strategy


def smooth(values, n, alpha):
    """out[i] = alpha * x[i] + (1 - alpha) * out[i-1], seeded with the mean of the first n values (leading NaNs skipped)."""
    x = np.asarray(values, dtype=float)
    out = np.full(len(x), np.nan)
    first = int(np.argmax(~np.isnan(x)))
    seed = first + n - 1
    if seed >= len(x):
        return out
    out[seed] = x[first:seed + 1].mean()
    for i in range(seed + 1, len(x)):
        out[i] = alpha * x[i] + (1 - alpha) * out[i - 1]
    return out


def supertrend_direction(high, low, close, n, mult):
    """+1 while the trend is up, -1 while it is down, NaN before the first ATR."""
    high = np.asarray(high, dtype=float)
    low = np.asarray(low, dtype=float)
    close = np.asarray(close, dtype=float)
    prev_close = np.concatenate(([np.nan], close[:-1]))
    true_range = np.fmax(high - low, np.fmax(np.abs(high - prev_close), np.abs(low - prev_close)))
    atr = smooth(true_range, n, 1.0 / n)
    upper = (high + low) / 2 + mult * atr
    lower = (high + low) / 2 - mult * atr
    direction = np.full(len(close), np.nan)
    start = int(np.argmax(~np.isnan(atr)))
    if np.isnan(atr[start]):
        return direction
    direction[start] = -1.0
    for i in range(start + 1, len(close)):
        if not (upper[i] < upper[i - 1] or close[i - 1] > upper[i - 1]):
            upper[i] = upper[i - 1]
        if not (lower[i] > lower[i - 1] or close[i - 1] < lower[i - 1]):
            lower[i] = lower[i - 1]
        if direction[i - 1] < 0:
            direction[i] = 1.0 if close[i] > upper[i] else -1.0
        else:
            direction[i] = -1.0 if close[i] < lower[i] else 1.0
    return direction


class Supertrend(Strategy):
    atr_period = 10
    multiplier = 3

    def init(self):
        self.direction = self.I(supertrend_direction, self.data.High, self.data.Low, self.data.Close,
                                self.atr_period, self.multiplier, name='Direction')

    def next(self):
        d = self.direction
        if not self.position:
            if d[-2] < 0 and d[-1] > 0:
                self.buy()
        elif d[-2] > 0 and d[-1] < 0:
            self.position.close()

SHA-256: a7cdc5128deef3c54100b7e37cdf489af9189c1217763fc6d46a71b24685e1af

"""Parabolic SAR(0.02 step, 0.2 max), long only.

Long when price flips above the SAR; exit when it flips below.
Wilder's Parabolic SAR as TA-Lib computes it (TA_SAR): the acceleration factor starts at 0.02,
rises 0.02 with each new extreme point, and is capped at 0.2. The first trend (bar 1) is short when
bar 1's down move (previous low - low) is positive and larger than its up move (high - previous high),
else long. A long flips short when the low touches or crosses the SAR (low <= SAR); a short flips long
when the high touches or crosses it (high >= SAR). On a flip the SAR restarts at the prior extreme point.
Each next SAR = SAR + AF x (EP - SAR), kept beyond the current and previous bar's range (below their
lows while long, above their highs while short). Orders fill at the next bar's open.
"""
import numpy as np
from backtesting import Strategy


def sar_trend(high, low, step, max_step):
    """+1 while the SAR trend is long, -1 while short, after each bar's flip check; NaN on bar 0."""
    high = np.asarray(high, dtype=float)
    low = np.asarray(low, dtype=float)
    trend = np.full(len(high), np.nan)
    if len(high) < 2:
        return trend
    down_move = low[0] - low[1]
    up_move = high[1] - high[0]
    is_long = not (down_move > 0 and down_move > up_move)
    if is_long:
        ep, sar = high[1], low[0]
    else:
        ep, sar = low[1], high[0]
    af = step
    new_high, new_low = high[1], low[1]
    for i in range(1, len(high)):
        prev_high, prev_low = new_high, new_low
        new_high, new_low = high[i], low[i]
        if is_long:
            if new_low <= sar:
                is_long = False
                sar = max(ep, prev_high, new_high)
                af = step
                ep = new_low
                sar = max(sar + af * (ep - sar), prev_high, new_high)
            else:
                if new_high > ep:
                    ep = new_high
                    af = min(af + step, max_step)
                sar = min(sar + af * (ep - sar), prev_low, new_low)
        else:
            if new_high >= sar:
                is_long = True
                sar = min(ep, prev_low, new_low)
                af = step
                ep = new_high
                sar = min(sar + af * (ep - sar), prev_low, new_low)
            else:
                if new_low < ep:
                    ep = new_low
                    af = min(af + step, max_step)
                sar = max(sar + af * (ep - sar), prev_high, new_high)
        trend[i] = 1.0 if is_long else -1.0
    return trend


class ParabolicSar(Strategy):
    step = 0.02
    max_step = 0.2

    def init(self):
        self.trend = self.I(sar_trend, self.data.High, self.data.Low, self.step, self.max_step, name='SAR trend')

    def next(self):
        t = self.trend
        if not self.position:
            if t[-2] < 0 and t[-1] > 0:
                self.buy()
        elif t[-2] > 0 and t[-1] < 0:
            self.position.close()

SHA-256: 8146121862a610b083a6684e67c1caedf3aadef4a0cafbce6a1d3032ad31cb3e

"""Stochastic(14, 3, 3) 20/80, long only.

Long when the slow %K crosses above 20 from below; exit when it crosses below 80 from above.
Fast %K = 100 x (close - lowest low of 14 bars) / (highest high of 14 bars - lowest low of 14 bars),
the current bar included; slow %K = SMA(3) of fast %K. (The second 3, the slow %D, is not used by the rule.)
Crosses above 20: slow %K > 20 on the bar and <= 20 on the bar before; crosses below 80: slow %K < 80
on the bar and >= 80 on the bar before. Orders fill at the next bar's open.
"""
import pandas as pd
from backtesting import Strategy


def slow_k(high, low, close, n, smoothing):
    highest = pd.Series(high).rolling(n).max()
    lowest = pd.Series(low).rolling(n).min()
    fast = 100 * (pd.Series(close) - lowest) / (highest - lowest)
    return fast.rolling(smoothing).mean().to_numpy()


class Stochastic(Strategy):
    k_period = 14
    k_smoothing = 3
    entry_level = 20
    exit_level = 80

    def init(self):
        self.k = self.I(slow_k, self.data.High, self.data.Low, self.data.Close, self.k_period, self.k_smoothing, name='Slow %K')

    def next(self):
        k = self.k
        if not self.position:
            if k[-2] <= self.entry_level and k[-1] > self.entry_level:
                self.buy()
        elif k[-2] >= self.exit_level and k[-1] < self.exit_level:
            self.position.close()

SHA-256: 95b39462b2495e871631ec687de0c22ef5bac4a2d696db1ec783b8a2c71f3ef4

"""Keltner breakout, long only.

Middle line EMA(20) of the close; upper band = middle + 2 x ATR(10).
Long when the close is above the upper band; exit when the close is below the middle line.
EMA: alpha = 2 / (n + 1), seeded with the simple mean of the first n values.
True range = max(high - low, |high - previous close|, |low - previous close|), and high - low on
the first bar; ATR(10) is Wilder's: alpha = 1/10, seeded with the mean of the first 10 true ranges.
Orders fill at the next bar's open.
"""
import numpy as np
from backtesting import Strategy


def smooth(values, n, alpha):
    """out[i] = alpha * x[i] + (1 - alpha) * out[i-1], seeded with the mean of the first n values (leading NaNs skipped)."""
    x = np.asarray(values, dtype=float)
    out = np.full(len(x), np.nan)
    first = int(np.argmax(~np.isnan(x)))
    seed = first + n - 1
    if seed >= len(x):
        return out
    out[seed] = x[first:seed + 1].mean()
    for i in range(seed + 1, len(x)):
        out[i] = alpha * x[i] + (1 - alpha) * out[i - 1]
    return out


def atr(high, low, close, n):
    high = np.asarray(high, dtype=float)
    low = np.asarray(low, dtype=float)
    close = np.asarray(close, dtype=float)
    prev_close = np.concatenate(([np.nan], close[:-1]))
    true_range = np.fmax(high - low, np.fmax(np.abs(high - prev_close), np.abs(low - prev_close)))
    return smooth(true_range, n, 1.0 / n)


class KeltnerBreakout(Strategy):
    ema_period = 20
    atr_period = 10
    atr_multiple = 2

    def init(self):
        d = self.data
        mid = smooth(d.Close, self.ema_period, 2.0 / (self.ema_period + 1))
        upper = mid + self.atr_multiple * atr(d.High, d.Low, d.Close, self.atr_period)
        self.mid = self.I(lambda: mid, name='Middle')
        self.upper = self.I(lambda: upper, name='Upper')

    def next(self):
        close = self.data.Close[-1]
        if not self.position:
            if close > self.upper[-1]:
                self.buy()
        elif close < self.mid[-1]:
            self.position.close()

SHA-256: 17f75e5c715906fecc370093c1648b2776f5577b62ddc353f183ea20e48e9c02

"""Time-series momentum 12-1, long only.

At each month's last trading day, be long for the next month if the return from 252 trading days ago
to 21 trading days ago (close[t-21] / close[t-252] - 1) is positive, else flat. Orders fill at the next
bar's open, the first trading day of the next month.
The month's last trading day is found from each bar's own date: the bar is the last weekday (Mon-Fri)
of its month. When that weekday is an exchange holiday (Good Friday or Memorial Day at a month's end)
there is no such bar, and the decision is made on the first bar of the new month instead, one day late.
"""
import pandas as pd
from backtesting import Strategy


class TimeSeriesMomentum(Strategy):
    lookback = 252
    skip = 21

    def init(self):
        days = self.data.index
        month = (days.year * 12 + days.month).to_numpy(dtype=float)
        last_weekday = ((days + pd.offsets.BDay(1)).month != days.month).astype(float)
        close = pd.Series(self.data.Close)
        momentum = (close.shift(self.skip) / close.shift(self.lookback) - 1).to_numpy()
        self.month = self.I(lambda: month, name='Month')
        self.last_weekday = self.I(lambda: last_weekday, name='Last weekday')
        self.momentum = self.I(lambda: momentum, name='Momentum 12-1')
        self.decided_for = 0

    def next(self):
        month = self.month[-1]
        if self.last_weekday[-1] > 0:
            self.decide()
            self.decided_for = month + 1
        elif 0 < self.decided_for < month:
            self.decide()
            self.decided_for = month

    def decide(self):
        if self.momentum[-1] > 0:
            if not self.position:
                self.buy()
        elif self.position:
            self.position.close()