MeridianAlgo v7.2.0

Full Changelog: v7.1.0...v7.2.0

Release v7.1.0

MeridianAlgo

Institutional-grade Python library for quantitative finance and algorithmic trading. Covers the complete quant stack: portfolio optimization, risk management, derivatives pricing, backtesting, credit risk, volatility modeling, Monte Carlo simulation, portfolio insurance, machine learning signal generation, execution algorithms, fixed income analytics, and market microstructure analysis.

Installation

pip install meridianalgo

# Selective extras
pip install meridianalgo[ml]           # scikit-learn, torch, statsmodels, hmmlearn
pip install meridianalgo[optimization] # cvxpy, cvxopt for convex portfolio optimization
pip install meridianalgo[volatility]   # arch (GARCH family models)
pip install meridianalgo[data]         # lxml, beautifulsoup4, polygon-api-client
pip install meridianalgo[distributed]  # ray, dask for parallel computing
pip install meridianalgo[all]          # all optional dependencies

Requirements: Python >= 3.10

---

Module Overview

Module	Key Classes / Functions
portfolio	MeanVariance, HierarchicalRiskParity, RiskParity, BlackLitterman, KellyCriterion
portfolio.insurance	CPPI, TimeInvariantCPPI
risk	RiskAnalyzer, VaRCalculator, CVaRCalculator, StressTesting, RiskBudgeting
risk.scenario	ScenarioAnalyzer, CorrelationScenario
credit	MertonModel, CreditDefaultSwap, CreditRiskAnalyzer, ZSpreadCalculator
volatility	GARCHModel, RealizedVolatility, VolatilityForecaster, VolatilityTermStructure
monte_carlo	GeometricBrownianMotion, HestonModel, JumpDiffusionModel, CIRModel, MonteCarloEngine
derivatives	BlackScholes, GreeksCalculator, ImpliedVolatility, MonteCarloPricer, OptionChain
fixed_income	BondPricer, YieldCurve, CreditSpreadAnalyzer
backtesting	BacktestEngine, Strategy, Backtest
ml	LSTMPredictor, WalkForwardValidator, FeatureEngineer, ModelSelector
execution	VWAP, TWAP, POV, ImplementationShortfall
analytics	PerformanceAnalyzer, BenchmarkAnalytics, ActiveShare, BrinsonAttribution
quant	StatisticalArbitrage, RegimeDetector, MarketMicrostructure
signals	RSI, MACD, BollingerBands, 40+ indicators
liquidity	OrderBook, SpreadAnalyzer, MarketImpact
factors	FamaFrenchModel, FactorExposure

---

Examples

Portfolio Optimization

import meridianalgo as ma
from meridianalgo.portfolio import PortfolioOptimizer

prices = ma.get_market_data(["AAPL", "MSFT", "GOOGL", "JPM", "GLD"], start="2020-01-01")
returns = ma.calculate_returns(prices)

opt = PortfolioOptimizer(returns)

hrp = opt.optimize(method="hrp")
min_var = opt.optimize(method="min_variance")
max_sharpe = opt.optimize(method="max_sharpe")
risk_parity = opt.optimize(method="risk_parity")

print("HRP weights:")
print(hrp.sort_values(ascending=False))
print(f"\nMin Variance vol:  {min_var.volatility:.4f}")
print(f"Max Sharpe ratio:  {max_sharpe.sharpe_ratio:.4f}")

Kelly Criterion Position Sizing

from meridianalgo import KellyCriterion

kc = KellyCriterion(fraction=0.5)  # half-Kelly

# Single asset (discrete binary bet)
f = kc.single_asset(win_prob=0.55, win_loss_ratio=1.0)
print(f"Kelly fraction: {f:.2%}")

# Multi-asset continuous Kelly from return history
weights = kc.optimize(returns)
print("Kelly weights:")
print(weights.sort_values(ascending=False))

# From moments
f_moments = kc.from_moments(expected_return=0.12, volatility=0.18)
print(f"Kelly (moments): {f_moments:.2%}")

# Expected long-run growth rate
g = kc.growth_rate(expected_return=0.12, volatility=0.18)
print(f"Expected growth: {g:.2%}")

Performance and Risk Metrics

import meridianalgo as ma

# Top-level convenience functions
sharpe = ma.calculate_sharpe_ratio(returns["AAPL"])
sortino = ma.calculate_sortino_ratio(returns["AAPL"])
calmar = ma.calculate_calmar_ratio(returns["AAPL"])
max_dd = ma.calculate_max_drawdown(returns["AAPL"])
cvar_95 = ma.calculate_expected_shortfall(returns["AAPL"])

print(f"Sharpe:       {sharpe:.3f}")
print(f"Sortino:      {sortino:.3f}")
print(f"Calmar:       {calmar:.3f}")
print(f"Max Drawdown: {max_dd:.2%}")
print(f"95% CVaR:     {cvar_95:.2%}")

# One-call summary of ~28 metrics, plus a formatted text report
stats = ma.summary_stats(returns["AAPL"])
print(ma.tearsheet(returns["AAPL"]))

# Full performance report
from meridianalgo import PerformanceAnalyzer

analyzer = PerformanceAnalyzer(returns["AAPL"], benchmark=returns["SPY"], risk_free_rate=0.05)
metrics = analyzer.calculate_all_metrics()
print(metrics)

Benchmark-Relative Analytics

from meridianalgo import BenchmarkAnalytics, ActiveShare, BrinsonAttribution

# Manager analytics
analytics = BenchmarkAnalytics(
    portfolio_returns=portfolio_daily_returns,
    benchmark_returns=spy_daily_returns,
    risk_free_rate=0.05,
)
m = analytics.active_metrics()

print(f"Active Return:     {m.active_return:.2%}")
print(f"Tracking Error:    {m.tracking_error:.2%}")
print(f"Information Ratio: {m.information_ratio:.3f}")
print(f"Up Capture:        {m.up_capture:.2%}")
print(f"Down Capture:      {m.down_capture:.2%}")
print(f"Batting Average:   {m.batting_average:.2%}")
print(f"Beta:              {m.beta:.3f}")
print(f"Alpha (ann.):      {m.alpha_annualized:.2%}")

# Active share from holdings
active_share = ActiveShare.compute(portfolio_weights, benchmark_weights)
print(f"Active Share: {active_share:.2%}")
print(f"Category:     {ActiveShare.categorize(active_share)}")

# Brinson-Hood-Beebower attribution
attribution = BrinsonAttribution(
    portfolio_weights=sector_weights_portfolio,
    benchmark_weights=sector_weights_benchmark,
    portfolio_returns=sector_returns_portfolio,
    benchmark_returns=sector_returns_benchmark,
)
result = attribution.compute()
print("\nAllocation effect by sector:")
print(result.allocation_effect.sort_values())
print("\nSelection effect by sector:")
print(result.selection_effect.sort_values())
print(f"\nTotal active return: {result.total_active_return:.4f}")

Value at Risk and Stress Testing

from meridianalgo import RiskAnalyzer, VaRCalculator

# VaR/CVaR
risk = RiskAnalyzer(returns["portfolio"])
var_95 = risk.value_at_risk(confidence=0.95, method="historical")
var_99 = risk.value_at_risk(confidence=0.99, method="cornish_fisher")
cvar_95 = risk.conditional_var(confidence=0.95)

print(f"Historical VaR 95%:        {var_95:.2%}")
print(f"Cornish-Fisher VaR 99%:    {var_99:.2%}")
print(f"CVaR 95%:                  {cvar_95:.2%}")

# Scenario stress testing
from meridianalgo import ScenarioAnalyzer

analyzer = ScenarioAnalyzer(
    portfolio_weights=weights,
    factor_sensitivities=factor_betas,
    portfolio_value=10_000_000,
)

# Built-in historical scenarios
results = analyzer.run_all_historical()
summary = analyzer.summary_table(results)
print(summary[["scenario", "portfolio_return", "portfolio_pnl", "severity"]].head(10))

# Reverse stress test: what equity shock causes -10% loss?
shock = analyzer.reverse_stress_test(target_loss=-0.10, factor="equity")
print(f"Equity shock for -10% loss: {shock:.2%}")

# Correlated scenario generation
from meridianalgo import CorrelationScenario

gen = CorrelationScenario(mean_returns, correlation_matrix, volatilities, weights)
scenarios = gen.generate(n_scenarios=100_000, stress_correlation=True, stress_factor=0.5)
print(f"Stressed 99% VaR:  {scenarios['var_99']:.2%}")
print(f"Stressed 99% CVaR: {scenarios['cvar_95']:.2%}")

Credit Risk

from meridianalgo import MertonModel, CreditDefaultSwap, CreditRiskAnalyzer, ZSpreadCalculator

# Merton structural model — equity as a call option on firm assets
model = MertonModel(
    equity_value=500e6,      # $500M market cap
    equity_volatility=0.35,  # 35% equity vol
    debt_face_value=800e6,   # $800M total debt
    time_to_maturity=1.0,
    risk_free_rate=0.05,
)
result = model.calibrate()
print(f"Asset Value:          ${result['asset_value']/1e6:.1f}M")
print(f"Distance to Default:  {result['distance_to_default']:.4f}")
print(f"Default Probability:  {result['default_probability']:.2%}")

# Default probability term structure
ts = model.default_probability_term_structure([0.5, 1.0, 2.0, 3.0, 5.0])
print("\nDefault Probability Term Structure:")
for t, pd in ts.items():
    print(f"  {t:4.1f}y: {pd:.2%}")

# CDS pricing
cds = CreditDefaultSwap(hazard_rate=0.02, recovery_rate=0.40, maturity=5.0)
r = cds.price()
print(f"\nCDS Fair Spread:  {r.fair_spread * 10000:.1f} bps")
print(f"Survival Prob:    {r.survival_probability:.4f}")

# Bootstrap CDS curve from market spreads
curve = CreditDefaultSwap.bootstrap_hazard_curve(
    maturities=[1, 3, 5, 7, 10],
    spreads=[0.0080, 0.0120, 0.0150, 0.0170, 0.0200],
)
print("\nHazard Rate Curve:")
print(curve)

# Portfolio expected loss
import pandas as pd
exposures = pd.DataFrame({
    "pd":  [0.010, 0.025, 0.050, 0.005],
    "lgd": [0.45,  0.40,  0.60,  0.35],
    "ead": [2e6,   1.5e6, 0.5e6, 3e6],
})
analyzer = CreditRiskAnalyzer()
el = analyzer.portfolio_expected_loss(exposures)
print(f"\nPortfolio Expected Loss: ${el['total_el']:,.0f}")
print(f"EL Rate:                 {el['el_rate']:.2%}")
print(f"Herfindahl Index:        {el['her...

v7.0.0 — Advanced Financial Modeling Suite

Major Release: v7.0.0

New Modules & Features

Credit Risk Module

• Merton structural model for default probability
• Credit Default Swap (CDS) pricing
• Credit Risk Analyzer for portfolio assessment
• Z-Spread calculator for bond valuation

Volatility Models

• GARCH(1,1) implementation with forecasting
• Realized Volatility with log-returns
• Heterogeneous Autoregressive RV (HAR-RV)
• Volatility Term Structure modeling
• Regime detection for market conditions

Monte Carlo Simulation

• Geometric Brownian Motion (GBM)
• Heston stochastic volatility model
• Jump-Diffusion processes
• Cox-Ingersoll-Ross (CIR) model
• Quasi-random sequence generation

Portfolio Insurance

• Constant Proportion Portfolio Insurance (CPPI)
• Time Invariant Portfolio Protection (TIPP)

Advanced Analytics

• Benchmark analytics with Brinson-Fachler attribution
• Active Share calculation
• Capture ratios (upside/downside)
• Scenario analysis with 10 historical scenarios
• Reverse stress testing
• Correlation stress testing

Documentation & Examples

• 13 comprehensive example files covering all modules
• 100+ new unit and integration tests
• Complete API documentation
• Real-world use cases and tutorials

Bug Fixes & Improvements

• Enhanced error handling across all modules
• Improved numerical stability
• Better performance for large portfolios
• Comprehensive test coverage (80%+)

---

Package: meridianalgo v7.0.0
Release Date: April 20, 2026