import numpy as np
def fixed_fractional_sizing(account_balance, risk_per_trade=0.02, atr=None, entry_price=None):
    """
    Risk a fixed percentage of account per trade
    Most common professional method
    """
risk_amount = account_balance * risk_per_trade
if atr is not None and entry_price is not None:
        # Calculate position size based on ATR stop loss
        stop_distance = 2.0 * atr
        position_size = risk_amount / stop_distance
    else:
        # Use as notional amount to risk
        position_size = risk_amount
return position_size
Example: $100k account, 2% risk, ATR = $2
size = fixed_fractional_sizing(100000, risk_per_trade=0.02, atr=2, entry_price=50)
print(f"Position size: {size} shares")
Output: 1,000 shares (risking $2,000)

def kelly_criterion_sizing(win_rate, avg_win, avg_loss):
    """
    Mathematical optimal position sizing
    f = (p × w - (1-p) × l) / w
    Where: p = win rate, w = avg win %, l = avg loss %
    """
f = (win_rate  avg_win - (1 - win_rate)  avg_loss) / avg_win
# Practical adjustment: use 25-50% of Kelly (safer)
    safe_f = f * 0.25  # Conservative: 25% of Kelly
return safe_f
Example: 60% win rate, +2% avg win, -1% avg loss
kelly = kelly_criterion_sizing(win_rate=0.60, avg_win=0.02, avg_loss=0.01)
safe_kelly = kelly * 0.25
print(f"Kelly fraction: {kelly:.2%}")
print(f"Safe Kelly (25%): {safe_kelly:.2%}")
Output: Kelly = 40%, Safe = 10% per trade

def volatility_adjusted_sizing(account_balance, base_risk=0.02, current_volatility=None,
                              historical_volatility=None):
    """
    Scale position size inversely to volatility
    High volatility = smaller positions, low volatility = larger positions
    """
if current_volatility is None or historical_volatility is None:
        # No adjustment
        return account_balance * base_risk
# Calculate volatility ratio
    vol_ratio = current_volatility / historical_volatility
# Scale risk inversely
    if vol_ratio > 2.0:  # 2x normal volatility
        adjusted_risk = base_risk * 0.25  # 75% reduction
    elif vol_ratio > 1.5:
        adjusted_risk = base_risk * 0.50  # 50% reduction
    elif vol_ratio > 1.2:
        adjusted_risk = base_risk * 0.75  # 25% reduction
    else:
        adjusted_risk = base_risk  # Normal volatility
return account_balance * adjusted_risk
Example: High volatility environment
current_vol = 0.025
historical_vol = 0.012
risk = volatility_adjusted_sizing(100000, base_risk=0.02,
                                  current_volatility=current_vol,
                                  historical_volatility=historical_vol)
print(f"Adjusted risk amount: ${risk:,.0f}")
Output: $1,000 (50% reduction from $2,000 base)

class EqualRiskPositionSizer:
    """
    Position size each trade so they contribute equally to portfolio risk
    If one position is volatile, reduce its size so risk = other positions
    """
def __init__(self, account_balance, max_risk_per_position=0.02):
        self.balance = account_balance
        self.max_risk = max_risk_per_position
        self.open_positions = {}
def calculate_equal_risk_size(self, symbol, entry_price, stop_loss, atr=None):
        """
        Each position risks exactly 2% of account
        """
risk_amount = self.balance * self.max_risk
        stop_distance = abs(entry_price - stop_loss)
if stop_distance == 0:
            return 0
position_size = risk_amount / stop_distance
return position_size
def maintain_portfolio_risk_balance(self):
        """
        Adjust existing position sizes if new signal added to keep risk equal
        """
if not self.open_positions:
            return
total_positions = len(self.open_positions) + 1  # +1 for new trade
# Reduce all positions to accommodate new trade
        for symbol, position in self.open_positions.items():
            new_size = position['base_size'] / total_positions
            position['current_size'] = new_size
print(f"Rebalanced {len(self.open_positions)} positions for equal risk")
This method ensures portfolio stays balanced regardless of individual volatility

class DrawdownAdjustedSizer:
    """
    Reduce position size if account has experienced recent losses
    Return to normal sizing when equity reaches new highs
    """
def __init__(self, account_balance, base_risk=0.02):
        self.initial_balance = account_balance
        self.current_balance = account_balance
        self.base_risk = base_risk
        self.peak_balance = account_balance
def calculate_drawdown(self):
        """Calculate current drawdown from peak"""
        return (self.peak_balance - self.current_balance) / self.peak_balance
def calculate_adjusted_risk(self):
        """Scale position size based on drawdown"""
drawdown = self.calculate_drawdown()
if drawdown < 0.05:  # Less than 5% drawdown
            multiplier = 1.0
        elif drawdown < 0.10:  # 5-10% drawdown
            multiplier = 0.75
        elif drawdown < 0.15:  # 10-15% drawdown
            multiplier = 0.50
        elif drawdown < 0.20:  # 15-20% drawdown
            multiplier = 0.25
        else:  # >20% drawdown
            multiplier = 0.0  # Stop trading entirely
return self.base_risk * multiplier
def update_balance(self, new_balance):
        """Update balance and track peak"""
        self.current_balance = new_balance
        if new_balance > self.peak_balance:
            self.peak_balance = new_balance
Usage: If account drops 15%, reduce position sizes to 50%

class ProfessionalPositionSizer:
    """
    Complete production position sizing system
    """
def __init__(self, account_balance=100000, max_risk_per_trade=0.02,
                 max_portfolio_leverage=2.0):
        self.balance = account_balance
        self.max_risk = max_risk_per_trade
        self.max_leverage = max_portfolio_leverage
        self.open_positions = []
def calculate_position_size(self, symbol, entry_price, stop_loss, atr,
                               signal_strength=1.0, volatility_regime='NORMAL'):
        """
        Complete position sizing considering all factors
        """
# Base risk amount
        risk_amount = self.balance * self.max_risk
# Volatility adjustment
        if volatility_regime == 'HIGH':
            risk_amount *= 0.50
        elif volatility_regime == 'EXTREME':
            return 0  # Don't trade
# Signal strength adjustment (0.5 to 1.5)
        risk_amount *= signal_strength
# Stop loss distance
        stop_distance = abs(entry_price - stop_loss)
        if stop_distance == 0:
            return 0
# Base position size
        position_size = risk_amount / stop_distance
# Portfolio leverage constraint
        portfolio_notional = sum([p['size'] * p['entry_price'] for p in self.open_positions])
        current_leverage = portfolio_notional / self.balance
if current_leverage + (position_size * entry_price / self.balance) > self.max_leverage:
            # Scale down to leverage limit
            available_leverage = self.max_leverage - current_leverage
            position_size = (available_leverage * self.balance) / entry_price
return max(0, position_size)
def add_position(self, symbol, entry_price, stop_loss, size):
        """Track new position"""
        self.open_positions.append({
            'symbol': symbol,
            'entry_price': entry_price,
            'stop_loss': stop_loss,
            'size': size,
            'notional': size * entry_price,
            'risk': abs(entry_price - stop_loss) * size
        })
def validate_position(self, entry_price, stop_loss, size):
        """Pre-trade validation"""
# Check max single position risk (never >5% account)
        position_risk = abs(entry_price - stop_loss) * size
        if position_risk > self.balance * 0.05:
            return False, "Position risk exceeds 5% of account"
# Check total portfolio risk
        total_risk = sum([p['risk'] for p in self.open_positions]) + position_risk
        if total_risk > self.balance * 0.10:  # Max 10% total portfolio risk
            return False, "Total portfolio risk exceeds 10%"
return True, "Valid"