The Matrix: Mastering Position Sizing & Stop Losses in Algo Trading

import pandas as pd
import numpy as np

# -------------------------------------------------
# Sample data: OHLCV for a fictitious future contract
# -------------------------------------------------
df = pd.DataFrame({
    'open':  np.random.randn(100).cumsum() + 100,
    'high':  np.random.randn(100).cumsum() + 102,
    'low':   np.random.randn(100).cumsum() +  98,
    'close': np.random.randn(100).cumsum() + 100,
    'volume': np.random.randint(1000, 5000, size=100)
})
df['high'] = df[['open','close']].max(axis=1) + np.random.rand(100)*0.5
df['low']  = df[['open','close']].min(axis=1) - np.random.rand(100)*0.5

# -------------------------------------------------
# 1️⃣  THE STRUGGLE: Fixed‑fraction position sizing
# -------------------------------------------------
equity = 100_000                # starting capital
risk_per_trade = 0.01           # 1% of equity per trade (naïve)
fixed_frac = risk_per_trade     # we use the same fraction every time

# Simple entry signal: buy when close > 20‑period SMA, sell when < SMA
df['sma20'] = df['close'].rolling(20).mean()
df['signal'] = np.where(df['close'] > df['sma20'], 1, -1)   # 1 = long, -1 = short

# Fixed‑fraction shares (ignore volatility!)
df['shares_fixed'] = (equity * fixed_frac) / df['close']
df['shares_fixed'] = df['shares_fixed'].astype(int)        # whole contracts

# Static stop loss: 50 ticks away (no adaptation to volatility)
tick_size = 0.25   # example tick size
static_stop_ticks = 50
df['stop_price_fixed'] = np.where(df['signal'] == 1,
                                  df['close'] - static_stop_ticks * tick_size,
                                  df['close'] + static_stop_ticks * tick_size)

# -------------------------------------------------
# 2️⃣  THE TRAPS (common mistakes) – spot them!
# -------------------------------------------------
# Trap A: Using the *current* equity for sizing after each trade
#         (instead of the equity *at the time of the signal*). 
#         This can cause over‑sizing during a winning streak.
#
# Trap B: Placing the stop based on a fixed tick distance
#         regardless of how volatile the instrument is.
#         In low‑vol periods you get stopped out too often;
#         in high‑vol periods you give the market too much room.

# -------------------------------------------------
# 3️⃣  THE VICTORY: Volatility‑adjusted sizing + ATR stop
# -------------------------------------------------
# Calculate ATR (14‑period)
high_low   = df['high'] - df['low']
high_close = np.abs(df['high'] - df['close'].shift())
low_close  = np.abs(df['low']  - df['close'].shift())
tr = pd.concat([high_low, high_close, low_close], axis=1).max(axis=1)
df['atr14'] = tr.rolling(14).mean()

# Risk per trade in dollars (still 1% of equity)
risk_dollars = equity * risk_per_trade

# Volatility‑adjusted position size: risk_dollars / (ATR * multiplier)
# We'll use 1 × ATR as the stop distance for sizing.
atr_multiplier_for_size = 1.0
df['shares_vol'] = (risk_dollars / (df['atr14'] * atr_multiplier_for_size)).astype(int)

# Dynamic stop loss: place stop at ATR_multiplier_stop × ATR from entry
atr_multiplier_stop = 1.5
df['stop_price_vol'] = np.where(df['signal'] == 1,
                                df['close'] - atr_multiplier_stop * df['atr14'],
                                df['close'] + atr_multiplier_stop * df['atr14'])

# -------------------------------------------------
# 4️⃣  Quick equity curve comparison (optional)
# -------------------------------------------------
def compute_equity(df, shares_col, stop_col):
    equity_curve = [equity]
    position = 0
    entry_price = 0.0
    for i in range(len(df)):
        if position == 0 and df['signal'].iloc[i] != 0:
            # open new position
            position = df['signal'].iloc[i] * df[shares_col].iloc[i]
            entry_price = df['close'].iloc[i]
        elif position != 0:
            # check stop
            stop_price = df[stop_col].iloc[i]
            if (position > 0 and df['low'].iloc[i] <= stop_price) or \
               (position < 0 and df['high'].iloc[i] >= stop_price):
                # stop hit
                pnl = position * (stop_price - entry_price)
                equity_curve.append(equity_curve[-1] + pnl)
                position = 0
                entry_price = 0.0
                continue
            # optional: close on opposite signal
            if df['signal'].iloc[i] != position:
                pnl = position * (df['close'].iloc[i] - entry_price)
                equity_curve.append(equity_curve[-1] + pnl)
                position = 0
                entry_price = 0.0
                continue
        # hold
        equity_curve.append(equity_curve[-1])
    return pd.Series(equity_curve, name='equity')

eq_fixed = compute_equity(df, 'shares_fixed', 'stop_price_fixed')
eq_vol   = compute_equity(df, 'shares_vol',   'stop_price_vol')

# Plot (if you have matplotlib) – omitted for brevity
# eq_fixed.plot(label='Fixed‑frac')
# eq_vol.plot(label='Vol‑adjusted')
# plt.legend()
# plt.show()