Release v6.3.0

MeridianAlgo

The Institutional-Grade Quantitative Finance Platform for Professional Developers

MeridianAlgo is a comprehensive, production-ready quantitative finance ecosystem for Python. Designed for hedge funds, proprietary trading desks, and independent researchers, it provides a unified interface for the entire quantitative lifecycle—from data acquisition and signal generation to optimal execution and performance attribution.

---

Institutional Modules

MeridianAlgo is built on a modular "Enterprise Foundation" where every component is optimized for performance and reliability.

Core Financial Primitives

The bedrock of the platform, providing high-performance implementations of essential financial calculations.

• Statistical Arbitrage Engine: Cointegration analysis, Hurst exponent calculation, and Half-life estimation.
• Advanced Technical Indicators: Vectorized RSI, MACD, Bollinger Bands, and 50+ other institutional indicators.
• Robust Market Data: Unified API for multi-vendor data acquisition with built-in cleaning and alignment.

Portfolio Management & Optimization

Beyond standard Mean-Variance optimization, we implement robust allocation strategies.

• Modern Portfolio Theory+: MVO, Black-Litterman, and Risk Parity (ERC).
• Hierarchical Risk Parity (HRP): Machine-learning based diversification that handles high correlations.
• Nested Clustered Optimization (NCO): Addressing the instability of quadratic programming in financial datasets.
• Transaction Cost Optimization: Incorporating market impact and slippage directly into the allocation process.

Risk Management & Analytics

Comprehensive risk assessment and performance monitoring.

• Multi-Method VaR: Parametric (Delta-Normal), Historical Simulation, and Monte Carlo models.
• Conditional VaR (CVaR): Expected Shortfall with tail risk decomposition.
• Cornish-Fisher Adjustments: Accounting for non-normality in returns (skewness/kurtosis).
• Stress Testing Engine: Scenario analysis for historical crashes (2008, 2020) and custom macroeconomic shocks.

Financial Machine Learning

Productionizing ML for time-series without the common pitfalls of overfitting.

• Deep Learning Architectures: High-fidelity LSTM, GRU, and Transformer models for financial time-series.
• Purged Cross-Validation: Preventing information leakage across overlapping time intervals.
• Feature Engineering Pipeline: 500+ alpha factors with built-in feature selection (Mutual Information, RF importance).
• Walk-Forward Validation: Simulating realistic model retraining and deployment cycles.

Optimal Execution

Production-grade algorithms to minimize market impact.

• Standard Algos: VWAP, TWAP, and Percentage of Volume (POV) with adaptive participation.
• Implementation Shortfall: Almgren-Chriss optimal trajectory for risk-averse liquidation.
• Market Microstructure: VPIN (Volume-Synchronized Probability of Informed Trading) and LOB dynamics.

---

Quick Start

1. Unified API Access

MeridianAlgo provides a clean "one-stop" API for baseline quantitative tasks.

import meridianalgo as ma

# Fetch data and perform quick analysis
prices = ma.get_market_data(['AAPL', 'MSFT', 'GOOGL'])
returns = prices.pct_change().dropna()

# Get institutional performance metrics
metrics = ma.calculate_metrics(returns['AAPL'])
print(f"Sharpe Ratio: {metrics['sharpe_ratio']:.2f}")

# Generate signals
rsi = ma.calculate_rsi(prices['AAPL'], window=14)

2. Advanced Portfolio Optimization

from meridianalgo.portfolio import PortfolioOptimizer

# Initialize and optimize using HRP
opt = PortfolioOptimizer(returns)
weights = opt.optimize(method='hrp')

print("Institutional Allocations:")
print(weights.sort_values(ascending=False).head())

3. Pricing & Greeks (Derivatives)

from meridianalgo.derivatives import BlackScholes, GreeksCalculator

# Calculate BS Price and Delta
price = BlackScholes.call_price(S=100, K=105, T=0.5, r=0.05, sigma=0.2)
delta = GreeksCalculator.delta('call', S=100, K=105, T=0.5, r=0.05, sigma=0.2)

---

Performance Benchmarks

Tested on Intel i9-12900K, 64GB RAM, Ubuntu 22.04

Operation	Scale	Latency	Efficiency
Portfolio VaR	5,000 assets	< 120ms	Optimized Cython/NumPy
GARCH(1,1) Fit	10 years daily	< 250ms	Parallelized Scipy
Backtest Engine	10M events	< 3.2s	Event-driven C-Speed
Option Greeks	500k contracts	< 400ms	Vectorized Broadcasters

---

Enterprise Configuration

Logging & Auditing

Standardized logging for production environments to ensure every trade decision is auditable.

from meridianalgo.utils.logging import setup_logger
logger = setup_logger("prod_trading", log_file="audit.log")

Data Integrity

Automated data validation for high-stakes trading systems.

from meridianalgo.utils.validation import DataValidator
DataValidator.validate_timeseries(raw_data) # Validates index, continuity, and NaNs

---

Documentation

Visit docs.meridianalgo.com for full API documentation, mathematical derivations, and research notebooks.

---

Legal Disclaimer

MeridianAlgo is a research and development platform. Trading financial instruments involves significant risk. The authors provide no warranties and are not responsible for financial losses incurred through the use of this software.

---

Built with Love by the Meridian Algorithmic Research Team.

Release v6.2.4

MeridianAlgo

A Powerful Python Library for Quantitative Finance

MeridianAlgo is a comprehensive Python library for quantitative finance, algorithmic trading, and financial machine learning. Whether you're a retail trader, quant researcher, or financial analyst, this library provides the tools you need to analyze markets, build strategies, and manage risk.

---

Installation

pip install meridianalgo

For full functionality with all optional dependencies:

pip install meridianalgo[all]

---

Quick Examples

🚀 Market Data & Basic Analysis

import meridianalgo as ma
import pandas as pd

# Get stock data
prices = ma.get_market_data(['AAPL', 'MSFT', 'GOOGL'], start='2020-01-01')
returns = prices.pct_change().dropna()

# Calculate technical indicators
rsi = ma.calculate_rsi(prices['AAPL'], window=14)
macd = ma.calculate_macd(prices['MSFT'])
bollinger = ma.calculate_bollinger_bands(prices['GOOGL'])

# Basic statistics
print(f"AAPL Sharpe Ratio: {ma.calculate_sharpe_ratio(returns['AAPL']):.2f}")
print(f"MSFT Max Drawdown: {ma.calculate_max_drawdown(returns['MSFT']):.2%}")

📊 Portfolio Optimization

from meridianalgo.portfolio import PortfolioOptimizer

# Create portfolio optimizer
opt = PortfolioOptimizer(returns)

# Different optimization methods
hrp_weights = opt.optimize(method='hrp')  # Hierarchical Risk Parity
min_var_weights = opt.optimize(method='min_variance')  # Minimum Variance
risk_parity_weights = opt.optimize(method='risk_parity')  # Risk Parity

print("Hierarchical Risk Parity Weights:")
print(hrp_weights.sort_values(ascending=False).head())

# Portfolio metrics
portfolio_return = (returns * hrp_weights).sum(axis=1)
portfolio_vol = portfolio_return.std() * (252 ** 0.5)
sharpe_ratio = portfolio_return.mean() / portfolio_return.std() * (252 ** 0.5)

print(f"Portfolio Annual Return: {portfolio_return.mean() * 252:.2%}")
print(f"Portfolio Annual Volatility: {portfolio_vol:.2%}")
print(f"Portfolio Sharpe Ratio: {sharpe_ratio:.2f}")

⚡ Risk Management

from meridianalgo.risk import RiskMetrics

# Calculate various risk metrics
risk = RiskMetrics(returns)

# Value at Risk (VaR)
var_95 = risk.calculate_var(level=0.95, method='historical')
var_99 = risk.calculate_var(level=0.99, method='gaussian')

# Conditional VaR (Expected Shortfall)
cvar_95 = risk.calculate_cvar(level=0.95)

# Cornish-Fisher adjusted VaR (accounts for skewness/kurtosis)
cf_var = risk.calculate_cornish_fisher_var(level=0.95)

print(f"95% VaR (Historical): {var_95['AAPL']:.2%}")
print(f"99% VaR (Gaussian): {var_99['AAPL']:.2%}")
print(f"95% CVaR: {cvar_95['AAPL']:.2%}")
print(f"95% Cornish-Fisher VaR: {cf_var['AAPL']:.2%}")

🤖 Machine Learning for Finance

from meridianalgo.ml import FeatureEngineer, ModelValidator
from sklearn.ensemble import RandomForestClassifier

# Engineer features
fe = FeatureEngineer()
features = fe.create_features(prices, 
    features=['returns', 'rsi', 'macd', 'bollinger_position', 'volume_ratio'])

# Prepare labels (next day direction)
labels = (returns.shift(-1) > 0).astype(int)

# Walk-forward validation
validator = ModelValidator()
results = validator.walk_forward_validation(
    features, labels, 
    model=RandomForestClassifier(n_estimators=100),
    train_window=252,  # 1 year training
    test_window=21     # 1 month testing
)

print(f"Average Accuracy: {results['accuracy'].mean():.2%}")
print(f"Average Precision: {results['precision'].mean():.2%}")
print(f"Average F1 Score: {results['f1_score'].mean():.2%}")

📈 Statistical Arbitrage

from meridianalgo.quant import StatisticalArbitrage

# Find cointegrated pairs
pairs_trader = StatisticalArbitrage()
pairs = pairs_trader.find_cointegrated_pairs(prices, p_value=0.05)

print("Cointegrated Pairs:")
for pair, p_val in pairs.items():
    print(f"{pair}: p-value = {p_val:.4f}")

# Calculate half-life for mean reversion
if pairs:
    pair = list(pairs.keys())[0]
    spread = prices[pair[0]] - prices[pair[1]]
    half_life = pairs_trader.calculate_half_life(spread)
    print(f"{pair} Half-Life: {half_life:.1f} days")
    
    # Generate trading signals
    signals = pairs_trader.generate_pairs_signals(spread, z_entry=2.0, z_exit=0.5)
    print(f"Generated {len(signals)} trading signals")

💰 Options Pricing & Greeks

from meridianalgo.derivatives import BlackScholes, GreeksCalculator, ImpliedVolatility

# Option pricing
call_price = BlackScholes.call_price(S=100, K=105, T=0.25, r=0.05, sigma=0.2)
put_price = BlackScholes.put_price(S=100, K=105, T=0.25, r=0.05, sigma=0.2)

# Greeks
delta = GreeksCalculator.delta('call', S=100, K=105, T=0.25, r=0.05, sigma=0.2)
gamma = GreeksCalculator.gamma(S=100, K=105, T=0.25, r=0.05, sigma=0.2)
theta = GreeksCalculator.theta('call', S=100, K=105, T=0.25, r=0.05, sigma=0.2)
vega = GreeksCalculator.vega(S=100, K=105, T=0.25, r=0.05, sigma=0.2)

print(f"Call Price: ${call_price:.2f}")
print(f"Put Price: ${put_price:.2f}")
print(f"Delta: {delta:.3f}")
print(f"Gamma: {gamma:.3f}")
print(f"Theta: {theta:.3f}")
print(f"Vega: {vega:.3f}")

# Implied volatility
market_price = 5.50
implied_vol = ImpliedVolatility.calculate('call', S=100, K=105, T=0.25, r=0.05, market_price=market_price)
print(f"Implied Volatility: {implied_vol:.2%}")

⚡ Backtesting Engine

from meridianalgo.backtesting import Backtester, Strategy

# Simple moving average crossover strategy
class MACrossover(Strategy):
    def __init__(self, short_window=20, long_window=50):
        self.short_window = short_window
        self.long_window = long_window
    
    def generate_signals(self, data):
        signals = pd.DataFrame(index=data.index, columns=data.columns)
        
        for asset in data.columns:
            short_ma = data[asset].rolling(self.short_window).mean()
            long_ma = data[asset].rolling(self.long_window).mean()
            
            # Buy when short MA crosses above long MA
            signals[asset] = (short_ma > long_ma).astype(int)
            
        return signals

# Run backtest
strategy = MACrossover(short_window=20, long_window=50)
backtest = Backtester(strategy, prices, returns)
results = backtest.run()

print(f"Total Return: {results['total_return']:.2%}")
print(f"Annual Return: {results['annual_return']:.2%}")
print(f"Sharpe Ratio: {results['sharpe_ratio']:.2f}")
print(f"Max Drawdown: {results['max_drawdown']:.2%}")
print(f"Win Rate: {results['win_rate']:.2%}")

📊 Advanced Technical Analysis

# Advanced indicators
from meridianalgo.signals import TechnicalIndicators

ti = TechnicalIndicators()

# Multiple timeframes
data_1h = ma.get_market_data(['BTC-USD'], interval='1h', start='2024-01-01')
data_1d = ma.get_market_data(['BTC-USD'], interval='1d', start='2024-01-01')

# Calculate indicators
indicators = {
    'RSI': ti.rsi(data_1h['BTC-USD'], window=14),
    'MACD': ti.macd(data_1h['BTC-USD']),
    'ATR': ti.atr(data_1h['BTC-USD'], window=14),
    'Stochastic': ti.stochastic(data_1h['BTC-USD'], k_window=14, d_window=3),
    'Williams %R': ti.williams_r(data_1h['BTC-USD'], window=14),
    'CCI': ti.cci(data_1h['BTC-USD'], window=20),
    'MFI': ti.mfi(data_1h['BTC-USD'], window=14),
    'OBV': ti.obv(data_1h['BTC-USD'])
}

# Generate composite signal
def generate_composite_signal(indicators):
    signals = pd.Series(0, index=indicators['RSI'].index)
    
    # RSI oversold/overbought
    signals[indicators['RSI'] < 30] += 1  # Buy signal
    signals[indicators['RSI'] > 70] -= 1  # Sell signal
    
    # MACD crossover
    macd_signal = indicators['MACD']['MACD'] > indicators['MACD']['Signal']
    signals[macd_signal] += 1
    signals[~macd_signal] -= 1
    
    return signals

composite_signal = generate_composite_signal(indicators)
print(f"Generated {len(composite_signal)} composite signals")

---

Performance Benchmarks

Tested on Intel i7-10700K, 32GB RAM, Python 3.11

Operation	Dataset Size	Time	Memory Usage
Portfolio Optimization (HRP)	100 assets, 5 years	45ms	12MB
VaR Calculation (Historical)	500 assets, 10 years	120ms	8MB
Backtest (Simple Strategy)	50 assets, 5 years	200ms	15MB
Options Greeks (1000 contracts)	1000 contracts	35ms	5MB
Feature Engineering	10 assets, 3 years	180ms	20MB

---

Data Sources

MeridianAlgo supports multiple data providers:

# Free data sources
yf_data = ma.get_yahoo_data(['AAPL', 'MSFT'])  # Yahoo Finance
fred_data = ma.get_fred_data(['GDP', 'CPI'])   # FRED

# Premium data (API keys required)
polygon_data = ma.get_polygon_data(['SPY'], api_key='your_key')
alpha_vantage = ma.get_alpha_vantage_data(['TSLA'], api_key='your_key')

# Crypto data
crypto_data = ma.get_crypto_data(['BTC-USD', 'ETH-USD'])

---

Configuration & Utilities

# Setup logging
from meridianalgo.utils import setup_logger
logger = setup_logger('trading_bot', level='INFO')

# Data validation
from meridianalgo.utils import DataValidator
validator = DataValidator()
validator.check_missing_values(prices)
validator.check_outliers(returns, threshold=3)

# Performance monitoring
from meridianalgo.utils import PerformanceTimer
with PerformanceTimer('portfolio_optimization'):
    weights = opt.optimize(method='hrp')

---

Optional Depend...

v6.1.2 - Public

MeridianAlgo

The Complete Quantitative Finance Platform

MeridianAlgo is a comprehensive, institutional-grade Python platform for quantitative finance. It provides a complete suite of tools for algorithmic trading, portfolio optimization, risk management, derivatives pricing, and market microstructure analysis. Built for professional quants, researchers, and trading firms.

Key Highlights:

• 50+ performance metrics and analytics
• Event-driven backtesting engine with realistic execution
• Optimal execution algorithms (VWAP, TWAP, POV, Implementation Shortfall)
• Market microstructure analysis (order book, VPIN, liquidity metrics)
• Statistical arbitrage and pairs trading
• Factor models (Fama-French, APT, custom)
• Options pricing and Greeks
• Machine learning integration
• GPU acceleration support
• Distributed computing ready

---

Installation

Standard Installation

pip install meridianalgo

With Optional Dependencies

# Machine learning support (scikit-learn, PyTorch, statsmodels)
pip install meridianalgo[ml]

# Optimization (CVXPY, CVXOPT)
pip install meridianalgo[optimization]

# Volatility modeling (ARCH)
pip install meridianalgo[volatility]

# Alternative data (web scraping, API clients)
pip install meridianalgo[data]

# Distributed computing (Ray, Dask)
pip install meridianalgo[distributed]

# Everything
pip install meridianalgo[all]

---

Quick Start

Portfolio Analytics

import meridianalgo as ma
import pandas as pd

# Load returns data
returns = pd.read_csv('returns.csv', index_col=0, parse_dates=True)

# Calculate comprehensive metrics
from meridianalgo.analytics import PerformanceAnalyzer

analyzer = PerformanceAnalyzer(returns)
metrics = analyzer.summary()

print(f"Sharpe Ratio: {metrics['sharpe_ratio']:.2f}")
print(f"Max Drawdown: {metrics['max_drawdown']:.1%}")
print(f"Calmar Ratio: {metrics['calmar_ratio']:.2f}")

Backtesting

from meridianalgo.backtesting import Backtest, SimpleMovingAverageStrategy
import yfinance as yf

# Get data
data = yf.download('AAPL', start='2020-01-01', end='2023-12-31')

# Create and run backtest
strategy = SimpleMovingAverageStrategy(short_window=20, long_window=50)
backtest = Backtest(data, strategy, initial_capital=100000)
results = backtest.run()

print(f"Total Return: {results['total_return']:.1%}")
print(f"Sharpe Ratio: {results['sharpe_ratio']:.2f}")

Execution Algorithms

from meridianalgo.quant.execution_algorithms import VWAP, TWAP, POV

# VWAP execution
vwap = VWAP(total_quantity=100000, start_time='09:30', end_time='16:00')
schedule = vwap.calculate_schedule(historical_volume)

# TWAP execution
twap = TWAP(total_quantity=100000, duration_minutes=480, slice_interval_minutes=5)
for i in range(twap.n_slices):
    execution = twap.execute_slice(market_price=150.0, available_liquidity=500000)
    print(f"Execute {execution['quantity']} shares at {execution['price']}")

# POV execution
pov = POV(total_quantity=100000, target_pov=0.10)
result = pov.execute(market_volume=1000000, market_price=150.0, time_remaining_pct=0.5)

Market Microstructure

from meridianalgo.liquidity import OrderBook, VPIN, MarketImpact

# Order book analysis
ob = OrderBook()
ob.add_bid(price=100.0, quantity=1000)
ob.add_ask(price=100.1, quantity=1000)

print(f"Spread: {ob.spread():.4f}")
print(f"Mid Price: {ob.mid_price():.2f}")
print(f"Depth: {ob.depth(levels=5)}")

# Volume-Synchronized PIN
vpin = VPIN(trades_data)
print(f"Current VPIN: {vpin.current_vpin():.3f}")
print(f"Toxicity Regime: {vpin.toxicity_regime()}")

# Market impact estimation
impact = MarketImpact()
cost = impact.estimate_total_cost(quantity=10000, volatility=0.02, volume=1000000)
print(f"Estimated Impact Cost: {cost:.4f}")

Statistical Arbitrage

from meridianalgo.quant.statistical_arbitrage import PairsTrading, CointegrationAnalyzer

# Pairs trading
pairs = PairsTrading(asset1_prices, asset2_prices)
signals = pairs.generate_signals(z_score_threshold=2.0)

# Cointegration analysis
analyzer = CointegrationAnalyzer(asset1_prices, asset2_prices)
result = analyzer.test_cointegration()
print(f"Cointegration p-value: {result['p_value']:.4f}")
print(f"Is cointegrated: {result['is_cointegrated']}")

Factor Models

from meridianalgo.quant.factor_models import FamaFrenchModel, FactorRiskDecomposition

# Fama-French 3-factor model
ff = FamaFrenchModel(returns, market_excess_returns, smb, hml)
alpha, beta_market, beta_smb, beta_hml = ff.fit()

# Factor risk decomposition
decomp = FactorRiskDecomposition(returns, factors)
risk_contrib = decomp.factor_contribution_to_risk()
print(f"Factor Risk Contributions: {risk_contrib}")

Technical Analysis

from meridianalgo.signals import RSI, MACD, BollingerBands, TechnicalAnalyzer

# Individual indicators
rsi = RSI(prices, period=14)
macd = MACD(prices, fast=12, slow=26, signal=9)
bb = BollingerBands(prices, period=20, std_dev=2)

# Comprehensive technical analysis
analyzer = TechnicalAnalyzer(prices)
signals = analyzer.calculate_all()
summary = analyzer.summary()

---

Core Modules

Analytics (meridianalgo.analytics)

• PerformanceAnalyzer: 50+ metrics (Sharpe, Sortino, Calmar, Information Ratio, etc.)
• RiskAnalyzer: VaR, CVaR, stress testing, scenario analysis
• DrawdownAnalyzer: Drawdown analysis, underwater plots, recovery metrics
• TearSheet: Pyfolio-style comprehensive performance reports

Backtesting (meridianalgo.backtesting)

• Event-driven engine: Realistic market simulation with bid-ask spreads
• Order management: Market, limit, stop, bracket orders
• Execution simulation: Market impact, slippage, commission modeling
• Pre-built strategies: SMA crossover, momentum, mean reversion

Liquidity (meridianalgo.liquidity)

• OrderBook: Depth analysis, microprice, spread metrics
• VPIN: Volume-Synchronized Probability of Informed Trading
• MarketImpact: Linear, square-root, power-law impact models
• Microstructure: Tick data analysis, volume profiles

Quant (meridianalgo.quant)

• Execution: VWAP, TWAP, POV, Implementation Shortfall (Almgren-Chriss)
• Statistical Arbitrage: Pairs trading, cointegration, mean reversion
• Factor Models: Fama-French, APT, custom factor models
• High-Frequency: Market making, latency arbitrage, order book dynamics
• Regime Detection: Hidden Markov Models, structural breaks, volatility regimes

Signals (meridianalgo.signals)

• Technical Indicators: SMA, EMA, RSI, MACD, Bollinger Bands, ATR, Stochastic, ADX, OBV
• Signal Generation: Multi-indicator signal generation and evaluation
• Pattern Recognition: Chart patterns, support/resistance levels

Portfolio (meridianalgo.portfolio)

• Optimization: Mean-variance, risk parity, Black-Litterman
• Rebalancing: Calendar, threshold, and drift-based rebalancing
• Performance Attribution: Brinson-Fachler attribution analysis
• Risk Management: Position sizing, concentration limits, Greeks hedging

Derivatives (meridianalgo.derivatives)

• Options Pricing: Black-Scholes, binomial, Monte Carlo
• Greeks: Delta, gamma, vega, theta, rho calculations
• Volatility Surfaces: Smile, skew, term structure modeling
• Exotic Options: Barrier, Asian, lookback options

Data (meridianalgo.data)

• Providers: Yahoo Finance, Polygon, custom data sources
• Processing: OHLCV normalization, corporate actions adjustment
• Storage: Efficient time-series storage and retrieval
• Streaming: Real-time data feed integration

---

Performance

MeridianAlgo is optimized for performance:

• Vectorized operations: NumPy/Pandas for fast computation
• GPU acceleration: CUDA support for matrix operations
• Distributed computing: Ray/Dask integration for parallel processing
• Efficient memory: Optimized data structures for large datasets

Benchmark results on typical workloads:

• Portfolio analytics: 10,000+ assets in <1 second
• Backtesting: 10 years of daily data in <5 seconds
• Factor model fitting: 1,000+ factors in <10 seconds

---

Documentation

Full documentation available at: https://meridianalgo.readthedocs.io

• API Reference
• User Guide
• Examples
• Benchmarks

---

Citation

If you use MeridianAlgo in your research, please cite:

@software{meridianalgo2026,
  title = {MeridianAlgo: The Complete Quantitative Finance Platform},
  author = {Meridian Algorithmic Research Team},
  year = {2026},
  version = {6.2.1},
  url = {https://github.com/MeridianAlgo/Python-Packages}
}

---

Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

---

License

MeridianAlgo is licensed under the MIT License. See LICENSE for details.

---

Support

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Email: support@meridianalgo.com

---

Disclaimer

MeridianAlgo is provided for educational and research purposes. Past p...

v4.1.0

🚀 MeridianAlgo v4.1.0 - Quantum Edition

The Ultimate Quantitative Development Platform

We're excited to announce the release of MeridianAlgo v4.1.0 - Quantum Edition, a major milestone that transforms quantitative finance development in Python. This release delivers institutional-grade capabilities with unprecedented performance and comprehensive functionality.

🎉 What's New in v4.1.0

🌟 Complete Platform Overhaul

• All 7 Core Modules fully functional and tested
• Unified API for seamless integration across all features
• 200+ Technical Indicators including native implementations + TA library integration
• Production-Ready Codebase with comprehensive error handling

📚 Comprehensive Documentation

• Massive README Update with 50+ detailed examples
• Real-World Use Cases from basic analysis to advanced strategies
• Complete API Coverage with working code examples
• Professional Documentation suitable for institutional use

🏗️ Core Architecture

• Modular Design with optional dependencies
• Graceful Degradation when optional packages unavailable
• Performance Optimized with intelligent caching
• Memory Efficient processing for large datasets

🚀 Key Features

📊 Technical Analysis (200+ Indicators)

• 50+ Native Indicators: RSI, MACD, Bollinger Bands, Stochastic, Williams %R, ADX, Aroon, Parabolic SAR, Ichimoku Cloud
• 150+ TA Library Integration: Complete integration with the TA library
• Advanced Pattern Recognition: Candlestick patterns, chart patterns, support/resistance
• Custom Indicator Framework: Build your own indicators with JIT compilation

🏦 Portfolio Management

• Modern Portfolio Theory: Efficient frontier, mean-variance optimization
• Advanced Models: Black-Litterman, Risk Parity, Hierarchical Risk Parity
• Performance Attribution: Factor analysis, benchmark comparison, tracking error
• Transaction Cost Analysis: Market impact models, optimal execution algorithms

⚠️ Risk Management

• Value at Risk (VaR): Historical, Parametric, Monte Carlo methods
• Expected Shortfall (CVaR): Tail risk analysis with confidence intervals
• Stress Testing: Historical scenarios, Monte Carlo simulation
• Real-time Monitoring: Customizable alerts and dashboards

🤖 Machine Learning

• Feature Engineering: 500+ financial features
• Advanced Models: LSTM, Transformers, Ensemble methods
• Time Series Validation: Walk-forward analysis, purged cross-validation
• Model Deployment: Versioning, A/B testing, performance monitoring

🔄 Backtesting Engine

• Event-Driven Architecture: Realistic market simulation
• Order Management: All order types, partial fills, slippage modeling
• Performance Analytics: 50+ metrics, drawdown analysis
• Parallel Processing: GPU acceleration support

💰 Fixed Income & Derivatives

• Bond Pricing: Yield curve construction, duration, convexity
• Options Pricing: Black-Scholes, binomial trees, Monte Carlo
• Interest Rate Models: Vasicek, CIR, Hull-White
• Exotic Derivatives: Barrier options, Asian options, structured products

📦 Installation

# Standard installation
pip install meridianalgo==4.1.0

# With machine learning support
pip install meridianalgo[ml]

# With all optional dependencies
pip install meridianalgo[all]