12.1 Introduction to Algorithmic Trading: Foundations, Microstructure, and Execution

1import time
2import random
3import logging
4
5# Configure structured logging for our algorithm
6logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
7logger = logging.getLogger('AlgorithmicEngine')
8
9class MarketDataSimulator:
10    """Simulates a live Level 1 WebSocket feed of bid/ask prices."""
11    def __init__(self, symbol, initial_price):
12        self.symbol = symbol
13        self.price = initial_price
14
15    def get_next_tick(self):
16        # Simulate a random walk with a small drift
17        self.price += random.normalvariate(0.0, 0.15)
18        spread = round(random.uniform(0.02, 0.05), 2)
19        bid = round(self.price - (spread / 2), 2)
20        ask = round(self.price + (spread / 2), 2)
21        bid_qty = random.randint(100, 5000)
22        ask_qty = random.randint(100, 5000)
23        return {
24            'symbol': self.symbol,
25            'timestamp': time.time(),
26            'bid': bid,
27            'ask': ask,
28            'bid_qty': bid_qty,
29            'ask_qty': ask_qty
30        }
31
32class RiskManager:
33    """Pre-trade risk engine ensuring absolute compliance limits."""
34    def __init__(self, max_position, max_drawdown):
35        self.max_position = max_position
36        self.max_drawdown = max_drawdown
37        self.current_position = 0
38        self.cumulative_pnl = 0.0
39
40    def approve_order(self, size, direction):
41        # Check if the order violates maximum position limits
42        proposed_position = self.current_position + (size if direction == 'BUY' else -size)
43        if abs(proposed_position) > self.max_position:
44            logger.warning(f"[RISK REJECTED] Proposed position {proposed_position} exceeds limit {self.max_position}")
45            return False
46        if self.cumulative_pnl < -self.max_drawdown:
47            logger.error(f"[RISK REJECTED] Maximum drawdown exceeded. Trading halted.")
48            return False
49        return True
50
51    def update_position(self, size, direction, execution_price):
52        trade_multiplier = 1 if direction == 'BUY' else -1
53        self.current_position += size * trade_multiplier
54        logger.info(f"[RISK UPDATE] Position updated to {self.current_position} units.")
55
56class ExecutionEngine:
57    """Simulates order transmission to broker API and fill reconciliation."""
58    def __init__(self, risk_manager):
59        self.risk_manager = risk_manager
60
61    def send_order(self, symbol, size, direction, price):
62        if not self.risk_manager.approve_order(size, direction):
63            return None
64        
65        # Simulate network latency of order transmission (e.g., 20ms)
66        time.sleep(0.02)
67        
68        # In a real environment, this would format a FIX protocol message or REST payload
69        logger.info(f"[ORDER SENT] {direction} {size} {symbol} @ {price}")
70        
71        # Simulate successful execution fill
72        fill_price = price # Assuming no slippage for simplicity
73        logger.info(f"[ORDER FILLED] {direction} {size} {symbol} @ {fill_price}")
74        
75        self.risk_manager.update_position(size, direction, fill_price)
76        return {
77            'status': 'FILLED',
78            'fill_price': fill_price,
79            'size': size,
80            'direction': direction
81        }
82
83class MeanReversionStrategy:
84    """A simple statistical strategy utilizing rolling micro-price imbalance."""
85    def __init__(self, window_size=10):
86        self.window_size = window_size
87        self.micro_prices = []
88
89    def calculate_micro_price(self, tick):
90        # Micro-price accounts for order book volume imbalances
91        total_qty = tick['bid_qty'] + tick['ask_qty']
92        if total_qty == 0:
93            return (tick['bid'] + tick['ask']) / 2
94        return (tick['bid_qty'] * tick['ask'] + tick['ask_qty'] * tick['bid']) / total_qty
95
96    def generate_signal(self, tick):
97        micro_price = self.calculate_micro_price(tick)
98        self.micro_prices.append(micro_price)
99        
100        if len(self.micro_prices) < self.window_size:
101            return None # Insufficient data to calculate rolling metrics
102            
103        if len(self.micro_prices) > self.window_size:
104            self.micro_prices.pop(0)
105            
106        rolling_mean = sum(self.micro_prices) / self.window_size
107        deviation = micro_price - rolling_mean
108        
109        # Signal threshold (e.g., standard deviation threshold or fixed nominal value)
110        if deviation < -0.15:
111            return 'BUY'
112        elif deviation > 0.15:
113            return 'SELL'
114        return 'HOLD'
115
116# Instantiate and run the algorithmic loop
117if __name__ == '__main__':
118    simulator = MarketDataSimulator('EURUSD', 1.1000)
119    risk = RiskManager(max_position=5000, max_drawdown=1000.0)
120    execution = ExecutionEngine(risk)
121    strategy = MeanReversionStrategy(window_size=5)
122
123    logger.info("Starting systematic trading engine...")
124    for step in range(15):
125        tick = simulator.get_next_tick()
126        logger.info(f"Tick {step+1}: Bid={tick['bid']} ({tick['bid_qty']}) | Ask={tick['ask']} ({tick['ask_qty']})")
127        
128        signal = strategy.generate_signal(tick)
129        logger.info(f"Strategy Signal: {signal}")
130        
131        if signal in ['BUY', 'SELL']:
132            order_price = tick['ask'] if signal == 'BUY' else tick['bid']
133            execution.send_order(tick['symbol'], 1000, signal, order_price)
134            
135        time.sleep(0.1) # Simulate real-time gap between incoming ticks