feat: add 4 new modules (Risk Parity, PCA, Bootstrap, Information Ratio) for v2.6.0

- Portfolio Management - Risk Parity: inverse-vol, ERC, custom risk budgeting
- Quantitative Methods - Principal Component Analysis: PCA from scratch, yield-curve decomposition
- Quantitative Methods - Bootstrap: i.i.d./block/stationary resampling, confidence intervals
- Finance - Information Ratio: active return, tracking error, IR, appraisal ratio
- Each module fully commented with the why behind every formula + per-module README
- Add 21 unit tests (all passing); fix test import paths to current folder names
- Update docs_builder to categorize Information Ratio; regenerate z_docs/mkdocs (105 modules)
- Refresh README to v2.6.0 with new directory entries and stats

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: MeridianAlgo-Developer

Finance - Information Ratio/README.md

@@ -0,0 +1,39 @@
+# Information Ratio & Active Management Metrics
+
+When a portfolio is judged **against a benchmark**, what matters is how much it beat the benchmark by — and how *reliably*. These are the core metrics of active management: active return, tracking error, Information Ratio, and the appraisal ratio.
+
+## Functions
+
+| Function | Description |
+|---|---|
+| `active_returns(portfolio, benchmark)` | Period-by-period excess over benchmark |
+| `tracking_error(portfolio, benchmark, periods)` | Annualised volatility of active returns |
+| `information_ratio(portfolio, benchmark, periods)` | Active return per unit of tracking error |
+| `appraisal_ratio(portfolio, benchmark, periods)` | Jensen's alpha ÷ residual vol, via CAPM regression |
+
+## Key Concepts
+
+- **Active return**: `r_portfolio − r_benchmark`. The value the manager added (or lost) versus simply holding the benchmark.
+- **Tracking error**: the standard deviation of active returns, annualised. It is the *risk* of deviating from the benchmark.
+- **Information Ratio (IR)**: `annualised active return / tracking error`. The benchmark-relative cousin of the Sharpe ratio. IR > 0.5 is good; > 1.0 is excellent and rare over long horizons.
+- **Appraisal ratio**: from `r_p = α + β·r_b + ε`, it is annualised `α / σ(ε)` — skill (alpha) per unit of idiosyncratic risk, isolating stock-picking from market exposure.
+
+## Example
+
+```python
+import numpy as np
+from information_ratio import information_ratio, tracking_error, appraisal_ratio
+
+bench = np.random.default_rng(0).normal(0.0004, 0.011, 504)
+port = 0.0002 + 1.05 * bench + np.random.default_rng(1).normal(0, 0.004, 504)
+
+print(tracking_error(port, bench))     # annualised TE
+print(information_ratio(port, bench))  # IR
+print(appraisal_ratio(port, bench))    # alpha, beta, residual vol, appraisal ratio
+```
+
+## Practical Notes
+
+- Annualisation uses `mean × periods` for return and `std × √periods` for volatility, so the IR scales by `√periods`.
+- Use `periods=252` for daily data, `52` for weekly, `12` for monthly.
+- A high IR from a tiny tracking error can be statistically fragile — pair it with the [[bootstrap]] module to put a confidence interval around it.

Finance - Information Ratio/information_ratio.py

@@ -0,0 +1,143 @@
+"""
+Information Ratio & Active Management Metrics
+----------------------------------------------
+When a portfolio is run *against a benchmark*, the questions that matter are not
+"how much did we return?" but "how much did we beat the benchmark by, and how
+reliably?". This module covers the core metrics of active management:
+
+- Active return     — portfolio return minus benchmark return.
+- Tracking error    — volatility of the active return (the risk taken to deviate
+                      from the benchmark).
+- Information Ratio — active return per unit of tracking error. The active-
+                      management analogue of the Sharpe ratio.
+- Appraisal ratio   — Jensen's alpha divided by the volatility of regression
+                      residuals (idiosyncratic risk), via a CAPM-style fit.
+
+These are the numbers used to judge a long-only active manager or a market-
+neutral overlay. A higher Information Ratio means more consistent outperformance
+per unit of benchmark-relative risk.
+"""
+
+import numpy as np
+
+# Trading days per year — used to annualise daily statistics.
+TRADING_DAYS = 252
+
+
+def active_returns(portfolio: np.ndarray, benchmark: np.ndarray) -> np.ndarray:
+    """
+    Active (excess-over-benchmark) returns, period by period.
+
+    Args:
+        portfolio: Array of portfolio returns.
+        benchmark: Array of benchmark returns (same length).
+
+    Returns:
+        np.ndarray: portfolio - benchmark, element-wise.
+    """
+    portfolio = np.asarray(portfolio, dtype=float)
+    benchmark = np.asarray(benchmark, dtype=float)
+    if portfolio.shape != benchmark.shape:
+        raise ValueError("portfolio and benchmark must be the same length")
+    return portfolio - benchmark
+
+
+def tracking_error(portfolio: np.ndarray, benchmark: np.ndarray, periods: int = TRADING_DAYS) -> float:
+    """
+    Annualised tracking error: the standard deviation of active returns.
+
+    Args:
+        portfolio: Portfolio returns.
+        benchmark: Benchmark returns.
+        periods: Periods per year for annualisation (252 daily, 12 monthly).
+
+    Returns:
+        float: Annualised tracking error.
+    """
+    active = active_returns(portfolio, benchmark)
+    # Volatility scales with the square root of time.
+    return float(active.std(ddof=1) * np.sqrt(periods))
+
+
+def information_ratio(portfolio: np.ndarray, benchmark: np.ndarray, periods: int = TRADING_DAYS) -> float:
+    """
+    Information Ratio = annualised active return / annualised tracking error.
+
+    Interpreted like a Sharpe ratio but relative to a benchmark. IR > 0.5 is
+    good, > 1.0 is excellent and rare over long horizons.
+
+    Args:
+        portfolio: Portfolio returns.
+        benchmark: Benchmark returns.
+        periods: Periods per year for annualisation.
+
+    Returns:
+        float: Information Ratio (0.0 if tracking error is zero).
+    """
+    active = active_returns(portfolio, benchmark)
+    te = active.std(ddof=1)
+    if te == 0:
+        return 0.0
+    # Annualise numerator (mean × periods) and denominator (std × sqrt(periods));
+    # the ratio simplifies to mean/std × sqrt(periods).
+    return float(active.mean() / te * np.sqrt(periods))
+
+
+def appraisal_ratio(portfolio: np.ndarray, benchmark: np.ndarray, periods: int = TRADING_DAYS) -> dict:
+    """
+    Appraisal ratio via a CAPM-style regression of portfolio on benchmark.
+
+    Fits  r_p = alpha + beta * r_b + epsilon  by ordinary least squares. The
+    appraisal ratio is alpha divided by the volatility of the residuals
+    (idiosyncratic risk) — it measures stock-picking skill net of market beta.
+
+    Args:
+        portfolio: Portfolio returns.
+        benchmark: Benchmark returns.
+        periods: Periods per year for annualisation.
+
+    Returns:
+        dict with annualised "alpha", "beta", "residual_vol", and
+        "appraisal_ratio".
+    """
+    r_p = np.asarray(portfolio, dtype=float)
+    r_b = np.asarray(benchmark, dtype=float)
+    # Design matrix [1, r_b] for the intercept (alpha) and slope (beta).
+    X = np.column_stack([np.ones_like(r_b), r_b])
+    coef, *_ = np.linalg.lstsq(X, r_p, rcond=None)
+    alpha, beta = coef
+    residuals = r_p - X @ coef
+    resid_vol = residuals.std(ddof=1)
+
+    ann_alpha = alpha * periods
+    ann_resid_vol = resid_vol * np.sqrt(periods)
+    ratio = ann_alpha / ann_resid_vol if ann_resid_vol > 0 else 0.0
+    return {
+        "alpha": float(ann_alpha),
+        "beta": float(beta),
+        "residual_vol": float(ann_resid_vol),
+        "appraisal_ratio": float(ratio),
+    }
+
+
+if __name__ == "__main__":
+    print("Information Ratio & Active Management Metrics")
+    print("=" * 46)
+
+    rng = np.random.default_rng(11)
+    # Benchmark: broad market. Portfolio: benchmark beta of ~1.05 plus a small
+    # consistent alpha and some idiosyncratic noise.
+    bench = rng.normal(0.0004, 0.011, TRADING_DAYS * 2)
+    port = 0.0002 + 1.05 * bench + rng.normal(0, 0.004, len(bench))
+
+    te = tracking_error(port, bench)
+    ir = information_ratio(port, bench)
+    print(f"\nAnnualised tracking error : {te:.2%}")
+    print(f"Information Ratio         : {ir:.3f}")
+
+    ap = appraisal_ratio(port, bench)
+    print("\nCAPM-style regression:")
+    print(f"  Annualised alpha   : {ap['alpha']:+.2%}")
+    print(f"  Beta               : {ap['beta']:.3f}")
+    print(f"  Residual vol       : {ap['residual_vol']:.2%}")
+    print(f"  Appraisal ratio    : {ap['appraisal_ratio']:.3f}")

Portfolio Management - Risk Parity/README.md

@@ -0,0 +1,40 @@
+# Risk Parity Portfolio Construction
+
+Risk parity builds a portfolio where **every asset contributes the same amount of risk** to the total — not the same amount of capital. A naive 60/40 stock/bond portfolio is ~90% *equity risk* despite being only 60% equity *capital*; risk parity fixes that imbalance.
+
+## Functions
+
+| Function | Description |
+|---|---|
+| `portfolio_volatility(weights, cov)` | Portfolio standard deviation `sqrt(wᵀΣw)` |
+| `risk_contributions(weights, cov)` | Component risk contribution per asset (sums to total vol) |
+| `inverse_volatility_weights(cov)` | Naive risk parity — closed-form, ignores correlations |
+| `risk_parity_weights(cov, budget=None)` | Equal Risk Contribution (ERC) or custom risk budget, solved numerically |
+
+## Key Concepts
+
+- **Marginal risk contribution**: `MRC = (Σw) / σ_p` — how much portfolio volatility changes per unit of weight.
+- **Component risk contribution**: `w ⊙ MRC`. By Euler's theorem these sum *exactly* to the portfolio volatility.
+- **Equal Risk Contribution (ERC)**: choose weights so every component contribution is equal. No closed form in general → solved by minimising the squared deviation of fractional contributions from the target budget.
+- **Risk budgeting**: ERC generalised — set an arbitrary target risk share per asset (e.g. 50% equity / 30% bond / 20% cash).
+
+## Example
+
+```python
+import numpy as np
+from risk_parity import risk_parity_weights, risk_contributions
+
+vols = np.array([0.20, 0.10, 0.04])
+corr = np.array([[1.0, 0.3, 0.05], [0.3, 1.0, 0.15], [0.05, 0.15, 1.0]])
+cov = np.outer(vols, vols) * corr
+
+w = risk_parity_weights(cov)              # ERC weights
+rc = risk_contributions(w, cov)
+print(rc / rc.sum())                      # ≈ equal risk shares
+```
+
+## Practical Notes
+
+- Inverse-volatility weighting is a fast, robust approximation and is exact only when assets are uncorrelated.
+- Risk parity portfolios are often **levered up** to reach a target volatility, since they tend to be bond-heavy and low-vol.
+- The optimiser starts from inverse-vol weights, which are close to the ERC solution, so SLSQP converges quickly and reliably.