algo_trading_book/converted_code/README.md

MATLAB to Python Trading Algorithm Conversions

This directory contains Python implementations of various algorithmic trading strategies and utility functions originally written in MATLAB.

Overview

The converted files include:

Utility Functions

• backshift.py - Shift data backward in time
• fwdshift.py - Shift data forward in time
• movingAvg.py - Calculate moving averages
• movingStd.py - Calculate moving standard deviations
• smartmean.py - Mean calculation ignoring NaN/Inf values
• smartstd.py - Standard deviation ignoring NaN/Inf values
• smartsum.py - Sum calculation ignoring NaN/Inf values
• smartMovingStd.py - Moving standard deviation ignoring NaN/Inf values
• calculateReturns.py - Calculate returns from price series
• calculateMaxDD.py - Calculate maximum drawdown and duration

Data Loading

• data_loader.py - Load converted CSV/JSON data files
• convert_mat_files.py - Convert .mat files to CSV/JSON format

Trading Strategies

• TU_mom.py - Treasury futures momentum strategy
• TU_mom_hypothesisTest.py - Hypothesis testing for TU momentum strategy
• kentdaniel.py - Long-short equity momentum strategy
• gapFutures_FSTX.py - Gap trading strategy for futures
• pead.py - Post-earnings announcement drift strategy

Installation

1. Install required dependencies:

pip install -r requirements.txt

2. Add the parent directory to your Python path or install as a package:

import sys
sys.path.append('/path/to/algo_trading_book')

Usage

Using Utility Functions

import numpy as np
from converted_code import backshift, smartmean, calculateReturns

# Example: Calculate returns
prices = np.array([100, 102, 101, 103, 105])
returns = calculateReturns(prices, 1)
print(returns)

# Example: Backshift data
shifted_prices = backshift(1, prices)
print(shifted_prices)

# Example: Smart mean (ignoring NaN)
data_with_nan = np.array([1, 2, np.nan, 4, 5])
mean_val = smartmean(data_with_nan)
print(mean_val)

Loading Real Market Data

from converted_code.data_loader import load_futures_data, load_stock_data, load_earnings_data

# Load Treasury futures data
tu_data = load_futures_data('TU', '20120813')
print(f"Loaded {len(tu_data['tday'])} days of TU data")

# Load stock data
stock_data = load_stock_data('20120424')
print(f"Stock data shape: {stock_data['cl'].shape}")

# Load earnings announcements
earnings = load_earnings_data()
print(f"Earnings data shape: {earnings['earnann'].shape}")

Running Trading Strategies

# Run TU momentum strategy
from converted_code.TU_mom import main as tu_mom_main
tu_mom_main()

# Run Kent Daniel momentum strategy  
from converted_code.kentdaniel import main as kent_daniel_main
kent_daniel_main()

# Run PEAD strategy
from converted_code.pead import main as pead_main
pead_main()

Important Notes

Data Requirements

The implementations now support both real market data (from converted .mat files) and synthetic data for demonstration.

Real Data (Converted from .mat files)

• Located in converted_code/data/ directory
• Includes futures, stocks, ETFs, and earnings data
• Automatically loaded by trading strategies
• CSV format for time series, JSON for metadata

Data Format

• Prices: 2D numpy arrays (time x assets)
• Returns: Same format as prices
• Dates: 1D array of date integers (YYYYMMDD format)
• OHLC Data: Separate arrays for Open, High, Low, Close

Available Datasets

• Futures: TU (Treasury), CL (Crude Oil), VX (VIX), HG (Copper), etc.
• Stocks: OHLC data for 500+ stocks
• ETFs: Exchange-traded fund data
• Earnings: Earnings announcement calendar
• Interest Rates: AUD and CAD interest rate data

Converting Additional .mat Files

# Run the conversion script to convert new .mat files
python convert_mat_files.py

Performance Considerations

1. Vectorization: The code uses numpy vectorization for efficiency
2. Memory Usage: Large datasets may require chunked processing
3. NaN Handling: Smart functions handle NaN/Inf values gracefully

Differences from MATLAB

1. Indexing: Python uses 0-based indexing vs MATLAB's 1-based
2. Array Operations: Uses numpy instead of MATLAB's matrix operations
3. Function Names: Some functions renamed for Python conventions
4. Error Handling: Added proper error handling and type checking

Testing

Each strategy file can be run independently:

python converted_code/TU_mom.py
python converted_code/kentdaniel.py
python converted_code/pead.py

Contributing

When adding new conversions:

1. Follow the existing code structure
2. Add proper docstrings
3. Include error handling
4. Use synthetic data for examples
5. Update this README

License

This code is converted from the original MATLAB implementations for educational and research purposes.