phacker 0.1.0__cp313-cp313-win_amd64.whl

phacker/__init__.py

@@ -0,0 +1,19 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_13_2():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'phacker.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_13_2()
+del _delvewheel_patch_1_13_2
+# end delvewheel patch
+
+try:
+    from . import _core
+except ImportError:  # sdist built without a compiler
+    _core = None
+
+
+def backend():
+    return "numpy" if _core is None else "cpp"

phacker/cscv.py

@@ -0,0 +1,51 @@
+from itertools import combinations
+import numpy as np
+
+try:
+    from ._core import cscv as _cscv_cpp
+except ImportError:
+    _cscv_cpp = None
+
+
+def sharpe(x):
+    # an all-zero column (a config that never trades in this window) scores 0, not NaN
+    flat = ~x.any(axis=0)
+    m, v = x.mean(axis=0), x.var(axis=0, ddof=1)
+    return np.where(flat, 0.0, m / np.sqrt(np.where(flat, 1.0, v)))
+
+
+def cscv(M, S=16, metric=sharpe):
+    """Probability of Backtest Overfitting via CSCV (Bailey et al., Algorithm 2.3).
+
+    M: T x N array, column n = P&L series of trial n.
+    Returns (pbo, logits). Runs the C++ kernel when it is built and metric is sharpe.
+    """
+    if metric is sharpe and _cscv_cpp is not None:
+        return _cscv_cpp(np.asarray(M, dtype=float), S)
+    return cscv_reference(M, S, metric)
+
+
+def cscv_reference(M, S=16, metric=sharpe):
+    """NumPy implementation of cscv, for any metric. The C++ kernel is tested against it."""
+    M = np.asarray(M, dtype=float)
+    T, N = M.shape
+    if S % 2 != 0:
+        raise ValueError("S must be even")
+
+    blocks = np.array_split(np.arange(T - T % S), S)
+
+    logits = []
+    for c in combinations(range(S), S // 2):
+        is_rows = np.concatenate([blocks[i] for i in c])
+        oos_rows = np.concatenate([blocks[i] for i in range(S) if i not in c])
+
+        R = metric(M[is_rows])
+        R_bar = metric(M[oos_rows])
+
+        n_star = np.argmax(R)
+        rank = 1 + np.sum(R_bar < R_bar[n_star])  # 1..N, higher = better; ties rank low
+        w = rank / (N + 1)
+        logits.append(np.log(w / (1 - w)))
+
+    logits = np.array(logits)
+    return (logits <= 0).mean(), logits

phacker/grid.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from dataclasses import dataclass, field
+from itertools import product
+from typing import Literal, NamedTuple
+
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+
+Side = Literal["long", "short", "both"]
+FloatArray = npt.NDArray[np.float64]
+
+_SIDES: dict[str, tuple[int, ...]] = {"long": (1,), "short": (-1,), "both": (1, -1)}
+
+
+def linspace(start, stop, num):
+    # rounded so grid points like 0.25 print and compare cleanly
+    return np.round(np.linspace(start, stop, num), 12)
+
+
+class Config(NamedTuple):
+    indicator: str
+    entry: float
+    band: float
+    hold: int
+    side: int
+
+    @property
+    def name(self) -> str:
+        side = "long" if self.side > 0 else "short"
+        return f"{self.indicator}:entry={self.entry:g}:band={self.band:g}:hold={self.hold}:{side}"
+
+
+@dataclass(frozen=True)
+class Grid:
+    indicators: Sequence[str]
+    entry: Sequence[float] | FloatArray
+    band: Sequence[float] | FloatArray
+    hold: Sequence[int]
+    side: Side = "both"
+    cost_bps: float = 0.0
+
+    def __post_init__(self):
+        object.__setattr__(self, "indicators", tuple(str(i) for i in self.indicators))
+        object.__setattr__(self, "entry", tuple(float(e) for e in self.entry))
+        object.__setattr__(self, "band", tuple(float(b) for b in self.band))
+        object.__setattr__(self, "hold", tuple(int(h) for h in self.hold))
+        if not (self.indicators and self.entry and self.band and self.hold):
+            raise ValueError("every grid axis needs at least one value")
+        if len(set(self.indicators)) != len(self.indicators):
+            raise ValueError("indicators must be unique")
+        if any(b <= 0 for b in self.band):
+            raise ValueError("band widths must be positive")
+        if any(h < 1 for h in self.hold):
+            raise ValueError("hold periods must be at least 1 bar")
+        if self.side not in _SIDES:
+            raise ValueError(f"side must be one of {sorted(_SIDES)}, got {self.side!r}")
+        if self.cost_bps < 0:
+            raise ValueError("cost_bps must be non-negative")
+
+    @property
+    def sides(self):
+        return _SIDES[self.side]
+
+    @property
+    def shape(self):
+        return (len(self.indicators), len(self.entry), len(self.band), len(self.hold), len(self.sides))
+
+    def __len__(self):
+        return int(np.prod(self.shape))
+
+    def __iter__(self):
+        # order matches the column order produced by backtest
+        for ind, e, b, h, s in product(self.indicators, self.entry, self.band, self.hold, self.sides):
+            yield Config(ind, e, b, h, s)
+
+    def configs(self):
+        return list(self)
+
+
+@dataclass
+class TrialMatrix:
+    pnl: FloatArray
+    names: list[str] = field(default_factory=list)
+    index: pd.Index | None = None
+
+    def __post_init__(self):
+        self.pnl = np.ascontiguousarray(self.pnl, dtype=np.float64)
+        if self.pnl.ndim != 2:
+            raise ValueError(f"pnl must be 2-D (T x N), got shape {self.pnl.shape}")
+        if not self.names:
+            self.names = [f"trial_{n}" for n in range(self.pnl.shape[1])]
+        if len(self.names) != self.pnl.shape[1]:
+            raise ValueError(f"got {len(self.names)} names for {self.pnl.shape[1]} columns")
+        if self.index is not None and len(self.index) != self.pnl.shape[0]:
+            raise ValueError(f"index length {len(self.index)} does not match T={self.pnl.shape[0]}")
+        if not np.all(np.isfinite(self.pnl)):
+            raise ValueError("pnl contains NaN or inf")
+
+    @property
+    def T(self):
+        return int(self.pnl.shape[0])
+
+    @property
+    def N(self):
+        return int(self.pnl.shape[1])
+
+    @property
+    def shape(self):
+        return (self.T, self.N)
+
+    def __array__(self, dtype: npt.DTypeLike = None, copy: bool | None = None):
+        return self.pnl if dtype is None else self.pnl.astype(dtype)
+
+    def to_frame(self):
+        return pd.DataFrame(self.pnl, index=self.index, columns=self.names)
+
+
+def expanding_zscore(x, min_periods):
+    # stats at t use only rows 0..t, so there is no lookahead
+    if min_periods < 2:
+        raise ValueError("min_periods must be at least 2")
+    ex = x.astype(np.float64).expanding(min_periods=min_periods)
+    sd = ex.std(ddof=1)
+    return (x - ex.mean()) / sd.where(sd > 0)
+
+
+def _held(signal, hold):
+    # position is on if any trigger fired in the last `hold` bars, via a windowed cumsum
+    T = signal.shape[0]
+    cs = np.zeros((T + hold,) + signal.shape[1:], dtype=np.int32)
+    np.cumsum(signal, axis=0, out=cs[hold:])
+    return (cs[hold:] - cs[:T]) > 0
+
+
+def backtest(prices, grid, price_col, min_periods):
+
+    missing = [c for c in (price_col, *grid.indicators) if c not in prices.columns]
+    if missing:
+        raise KeyError(f"prices is missing columns: {missing}")
+
+    px = prices[price_col].to_numpy(dtype=np.float64)
+    if px.shape[0] < 3:
+        raise ValueError("need at least 3 price rows")
+    if not np.all(np.isfinite(px)) or np.any(px <= 0):
+        raise ValueError(f"{price_col} must be finite and positive")
+
+    T = px.shape[0] - 1
+    r = np.diff(np.log(px))
+    cost = grid.cost_bps * 1e-4
+    entry = np.asarray(grid.entry)
+    band = np.asarray(grid.band)
+    I, K, B, H, S = grid.shape
+
+    out = np.empty((T, I, K, B, H, S), dtype=np.float64)
+
+    for i, ind in enumerate(grid.indicators):
+        z = expanding_zscore(prices[ind], min_periods).to_numpy(dtype=np.float64)
+        # NaN z (warmup or zero spread) compares False, so those rows stay flat
+        with np.errstate(invalid="ignore"):
+            signal = np.abs(z[:, None, None] - entry[None, :, None]) <= band[None, None, :]
+
+        for j, h in enumerate(grid.hold):
+            pos = _held(signal, h).astype(np.float64)
+            # pnl_t = pos_{t-1} * r_t, trading cost charged on the bar the position changes
+            gross = pos[:-1] * r[:, None, None]
+            turn = cost * np.abs(np.diff(pos, axis=0))
+            for k, s in enumerate(grid.sides):
+                out[:, i, :, :, j, k] = s * gross - turn
+
+    index = prices.index[1:] if not isinstance(prices.index, pd.RangeIndex) else None
+    return TrialMatrix(out.reshape(T, -1), names=[c.name for c in grid], index=index)

phacker/indicators.py

@@ -0,0 +1,107 @@
+import numpy as np
+import pandas as pd
+
+# adapted from an older project with Johan Naresh
+# https://github.com/johannaresh/CSC-project/blob/main/tickerdataframe.py
+
+CLOSE = "Adj_Close"
+
+
+def _safe_div(num, den):
+    # zero denominators give NaN instead of inf so the expanding z-score in grid.py stays finite
+    return num / den.where(den != 0)
+
+
+def _true_range(df, close):
+    prev = df[close].shift()
+    tr1 = df["High"] - df["Low"]
+    tr2 = (df["High"] - prev).abs()
+    tr3 = (df["Low"] - prev).abs()
+    return pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
+
+
+def sma(df, n, close=CLOSE):  # Simple Moving Average
+    return df[close].rolling(window=n).mean()
+
+
+def ema(df, n, close=CLOSE):  # Exponential Moving Average seeded with the first value
+    return df[close].ewm(alpha=2 / (n + 1), adjust=False).mean()
+
+
+def rsi(df, n=14, close=CLOSE):  # Relative Strength Index
+    delta = df[close].diff()
+    avg_gain = delta.clip(lower=0).rolling(window=n).mean()
+    avg_loss = (-delta.clip(upper=0)).rolling(window=n).mean()
+    return 100 - 100 / (1 + avg_gain / avg_loss)
+
+
+def atr(df, n=14, close=CLOSE):  # Average True Range
+    return _true_range(df, close).rolling(window=n).mean()
+
+
+# OBV increases when price rises on high volume, decreases when it falls on high volume
+def obv(df, close=CLOSE, volume="Volume"):
+    direction = np.sign(df[close].diff()).fillna(0)
+    return (direction * df[volume]).cumsum()
+
+
+# shows where the current price sits within its volatility range (0 = lower band, 1 = upper band)
+def bollinger_b(df, n=20, k=2, close=CLOSE):
+    mid = df[close].rolling(window=n).mean()
+    std = df[close].rolling(window=n).std()
+    lower = mid - k * std
+    return _safe_div(df[close] - lower, 2 * k * std)
+
+
+def adx(df, n=14, close=CLOSE):  # Average Directional Index
+    up = df["High"].diff()
+    down = -df["Low"].diff()
+
+    plus_dm = up.where((up > down) & (up > 0), 0.0)
+    minus_dm = down.where((down > up) & (down > 0), 0.0)
+
+    tr = _true_range(df, close).rolling(window=n).mean()
+    plus_di = 100 * _safe_div(plus_dm.rolling(window=n).mean(), tr)
+    minus_di = 100 * _safe_div(minus_dm.rolling(window=n).mean(), tr)
+
+    dx = 100 * _safe_div((plus_di - minus_di).abs(), plus_di + minus_di)
+    return dx.rolling(window=n).mean()
+
+
+def rolling_vol(df, n=20, close=CLOSE):  # Rolling Volatility (Std Dev of returns)
+    return df[close].pct_change().rolling(window=n).std()
+
+
+def zscore(df, n=20, close=CLOSE):  # Z-Score vs SMA(n)
+    mid = df[close].rolling(window=n).mean()
+    std = df[close].rolling(window=n).std()
+    return _safe_div(df[close] - mid, std)
+
+
+# names used by Grid and the query layer, mapped to their builders
+INDICATORS = {
+    "SMA5": lambda df, close: sma(df, 5, close),
+    "SMA20": lambda df, close: sma(df, 20, close),
+    "EMA5": lambda df, close: ema(df, 5, close),
+    "EMA20": lambda df, close: ema(df, 20, close),
+    "RSI14": lambda df, close: rsi(df, 14, close),
+    "ATR14": lambda df, close: atr(df, 14, close),
+    "OBV": lambda df, close: obv(df, close),
+    "BOLL_B20": lambda df, close: bollinger_b(df, 20, 2, close),
+    "ADX14": lambda df, close: adx(df, 14, close),
+    "VOL20": lambda df, close: rolling_vol(df, 20, close),
+    "Z20": lambda df, close: zscore(df, 20, close),
+}
+
+
+def indicators(df, names=None, close=CLOSE):
+    # warmup rows are left as NaN rather than dropped so T matches the price series
+    names = list(INDICATORS) if names is None else list(names)
+    unknown = [n for n in names if n not in INDICATORS]
+    if unknown:
+        raise KeyError(f"unknown indicators: {unknown}, available: {list(INDICATORS)}")
+
+    df = df.copy()
+    for name in names:
+        df[name] = INDICATORS[name](df, close)
+    return df

phacker/stats.py

@@ -0,0 +1,44 @@
+import numpy as np
+
+
+def sharpe_se(x):
+    """Delta-method standard error of the Sharpe ratio, per column.
+
+    var(SR) = (1 - g3*SR + (g4 - 1)/4 * SR^2) / (T - 1), g4 = non-excess kurtosis.
+    """
+    x = np.asarray(x, dtype=float)
+    T = x.shape[0]
+    d = x - x.mean(axis=0)
+    s = d.std(axis=0)
+    sr = x.mean(axis=0) / x.std(axis=0, ddof=1)
+    g3 = (d**3).mean(axis=0) / s**3
+    g4 = (d**4).mean(axis=0) / s**4
+    return np.sqrt((1 - g3 * sr + (g4 - 1) / 4 * sr**2) / (T - 1))
+
+
+def logistic_cdf(x):
+    """Exact null CDF of the CSCV logit: omega ~ U(0,1) => logit(omega) ~ Logistic(0,1)."""
+    return 1 / (1 + np.exp(-np.asarray(x, dtype=float)))
+
+
+def logistic_pdf(x):
+    p = logistic_cdf(x)
+    return p * (1 - p)
+
+
+def logit_fit(logits):
+    """KS distance from the logistic null and mean logit. Descriptive only:
+    the CSCV logits are dependent, so no p-value is reported."""
+    lam = np.sort(np.asarray(logits, dtype=float))
+    n = len(lam)
+    F = logistic_cdf(lam)
+    i = np.arange(1, n + 1)
+    ks = max((i / n - F).max(), (F - (i - 1) / n).max())
+    return ks, lam.mean()
+
+
+def n_eff(M):
+    """Effective number of trials: participation ratio of the centred SVD spectrum."""
+    M = np.asarray(M, dtype=float)
+    s2 = np.linalg.svd(M - M.mean(axis=0), compute_uv=False) ** 2
+    return s2.sum() ** 2 / (s2**2).sum()

phacker-0.1.0.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.13.2
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-hbtco9i5\\cp313-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-hbtco9i5\\cp313-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-hbtco9i5\\cp313-win_amd64\\built_wheel\\phacker-0.1.0-cp313-cp313-win_amd64.whl']

phacker-0.1.0.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.4
+Name: phacker
+Version: 0.1.0
+Summary: Probability of backtest overfitting via CSCV (Bailey et al. 2016), with a C++ kernel
+License-Expression: MIT
+License-File: LICENSE
+Project-URL: Source, https://github.com/ryousuf569/phacker
+Project-URL: Paper, https://doi.org/10.21314/JCF.2016.322
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Description-Content-Type: text/markdown
+
+# phacker
+
+Measure how likely it is that your best backtest is overfit.
+
+If you try many strategy configurations and keep the one with the best in-sample
+Sharpe ratio, part of that Sharpe is selection luck. `phacker` estimates the
+**Probability of Backtest Overfitting (PBO)**: the probability that the configuration
+you picked as best in-sample ranks below the median out-of-sample. It implements
+combinatorially symmetric cross-validation (CSCV) from
+
+> Bailey, D., Borwein, J., López de Prado, M., & Zhu, Q. J. (2016).
+> *The Probability of Backtest Overfitting.* Journal of Computational Finance, 20(4), 39–69.
+> [doi:10.21314/JCF.2016.322](https://doi.org/10.21314/JCF.2016.322)
+
+CSCV is deterministic: there is no Monte Carlo, and the same input always gives the same
+answer. The core is a C++ kernel (OpenMP, SIMD) with a pure-NumPy fallback.
+
+## Install
+
+```bash
+pip install phacker
+```
+
+Wheels are built for CPython 3.11–3.13 on Linux (x86_64, aarch64), macOS (Intel,
+Apple Silicon) and Windows (x64). On other platforms pip builds from source, and
+if no C++ compiler is available you get the NumPy implementation alone. Both give
+the same results; only the speed differs.
+
+```python
+import phacker
+phacker.backend()   # "cpp" if the compiled kernel is available, else "numpy"
+```
+
+## Quick start
+
+You need a T × N matrix of P&L: one column per configuration you tried, one row per
+period, with all columns on the same time index.
+
+```python
+import numpy as np
+from phacker.cscv import cscv
+
+pnl = np.random.default_rng(0).standard_normal((2000, 500))   # 500 pure-noise strategies
+pbo, logits = cscv(pnl, S=16)
+
+pbo            # 0.317; noise averages 0.5, but one family can land well away from it
+logits.shape   # (12870,) = C(16, 8)
+```
+
+**Include every configuration you tried**, including the ones that did badly.
+Leaving out failed trials biases PBO downward.
+
+### Reading the result
+
+- **PBO = 0.5** means selection carried no information. The in-sample winner is
+  equally likely to land above or below the out-of-sample median. This is what pure
+  noise gives, not 0.
+- **PBO near 0** means the in-sample winner reliably stays above the median
+  out-of-sample.
+- **PBO above 0.5** means the selection is worse than random. The in-sample winners
+  tend to underperform out-of-sample (mean reversion between halves, for example).
+
+`logits` holds one value per train/test split, λ = ln(ω / (1 − ω)), where ω is the
+in-sample winner's relative out-of-sample rank. PBO is the fraction with λ ≤ 0.
+With no skill, ω is uniform and λ follows the standard logistic distribution exactly.
+
+## Building a trial matrix from prices
+
+`phacker` includes a grid backtester for threshold rules on technical indicators.
+
+```python
+import pandas as pd
+from phacker.indicators import indicators
+from phacker.grid import Grid, backtest, linspace
+from phacker.cscv import cscv
+
+# a DataFrame with Adj_Close, High, Low, Volume columns on a DatetimeIndex
+prices = pd.read_csv("NQ.csv", index_col=0, parse_dates=True)
+prices = indicators(prices, ["RSI14", "Z20", "BOLL_B20"])
+
+grid = Grid(
+    indicators=["RSI14", "Z20", "BOLL_B20"],
+    entry=linspace(-2, 2, 17),     # z-score levels
+    band=[0.25, 0.5, 1.0, 2.0],    # half-width around each level
+    hold=[1, 5, 10, 20],           # bars to hold after a trigger
+    side="both",                   # "long", "short" or "both"
+    cost_bps=0.5,                  # per unit of position change
+)
+M = backtest(prices, grid, price_col="Adj_Close", min_periods=60)   # TrialMatrix, 1,632 columns
+
+pbo, logits = cscv(M, S=16)
+M.names[0]     # 'RSI14:entry=-2:band=0.25:hold=1:long'
+```
+
+For each configuration (indicator, entry, band, hold, side) the rule goes long or short
+whenever the indicator's z-score is within `band` of `entry`, and holds for `hold` bars.
+Positions are lagged one bar, so there is no lookahead. Indicators are standardized
+with an **expanding-window** z-score, so θ means the same thing for every indicator
+and no future data leaks into the past. `min_periods` is the warm-up before the
+z-score is defined.
+
+Available indicators: `SMA5`, `SMA20`, `EMA5`, `EMA20`, `RSI14`, `ATR14`, `OBV`,
+`BOLL_B20`, `ADX14`, `VOL20`, `Z20`.
+
+To bring your own P&L with labels, wrap it in `TrialMatrix(pnl, names=[...])`.
+
+## Diagnostics
+
+```python
+from phacker.stats import n_eff, logit_fit, sharpe_se
+
+n_eff(M)            # effective number of independent trials
+logit_fit(logits)   # (KS distance from the logistic null, mean logit)
+sharpe_se(returns)  # delta-method standard error of each column's Sharpe ratio
+```
+
+- **`n_eff`**: the participation ratio of the centred trial matrix's singular values.
+  A grid of 1,632 configurations that mostly trade the same signal can have an
+  `n_eff` near 1. High PBO on a family with a small `n_eff` may say more about
+  redundancy than about overfitting.
+- **`logit_fit`** compares the logits to the exact logistic null. It's descriptive
+  only: the C(S, S/2) splits share blocks, so the logits are dependent and a
+  classical KS p-value would be wrong. None is reported.
+- **`sharpe_se`** is √((1 − γ₃·SR + (γ₄ − 1)/4·SR²) / (T − 1)), with skewness γ₃
+  and non-excess kurtosis γ₄. Use it to check that Sharpe estimates on
+  T/2 rows are reliable enough for your choice of S.
+
+## Choosing S
+
+`S` is the number of blocks the rows are split into. It must be even and at most 32.
+CSCV evaluates C(S, S/2) splits, each with T/2 rows on each side:
+
+| S | splits |
+|---|---|
+| 8 | 70 |
+| 12 | 924 |
+| 16 | 12,870 |
+| 20 | 184,756 |
+
+The paper uses S = 16. A larger S gives more splits but shorter blocks. If T isn't a
+multiple of S, the last `T % S` rows are dropped.
+
+## Custom metrics
+
+`cscv` accepts any performance function that maps a `(rows, N)` array to N scores.
+Rows arrive in their original time order, so path-dependent metrics such as drawdown
+work too:
+
+```python
+pbo, logits = cscv(M, S=16, metric=lambda x: x.mean(axis=0))
+```
+
+The C++ kernel computes the Sharpe ratio only. Any other metric runs the NumPy
+implementation (also available directly as `phacker.cscv.cscv_reference`), which is
+much slower at large N.
+
+## Performance
+
+With the Sharpe metric, the kernel sums each block once and then reuses those sums.
+Neighbouring splits are visited in revolving-door (Gray code) order, so each split
+needs one block added and one removed, and the out-of-sample sums are the totals minus
+the in-sample ones. Splits are processed in parallel with OpenMP.
+
+N = 1,000 strategies, T = 2,000 rows, S = 16, Intel i7-1365U (10 cores), Windows:
+
+| backend | time |
+|---|---|
+| NumPy reference | ~250 s |
+| C++ kernel, 1 thread | ~0.3 s |
+| C++ kernel, OpenMP | ~0.05–0.07 s |
+
+macOS wheels are built without OpenMP and run single-threaded.
+
+## Behaviour details
+
+- **Flat columns.** A configuration with no nonzero returns in a half (it never traded
+  there) gets a Sharpe of 0 in that half rather than NaN.
+- **Ties.** The out-of-sample rank is 1 + the number of strategies strictly worse,
+  so ties rank low.
+- **First winner.** If several strategies share the best in-sample score, the first
+  column wins.
+- Both backends follow these rules and agree to within 1e-12 on the logits.
+
+## Limitations
+
+1. **PBO measures the selection process, not a strategy.** A family where every
+   configuration is genuinely good and roughly equal also gives a high PBO (paper
+   §5.2). `n_eff` helps tell these cases apart but doesn't settle it.
+2. **The answer is only as honest as the trial list.** Omitting configurations you
+   tried biases PBO down, and so does padding the family with configurations
+   designed to fail.
+3. **Never optimize for low PBO.** Using CSCV as an objective function overfits PBO
+   itself.
+4. **The splits are dependent**, so there's no calibrated goodness-of-fit p-value on
+   the logits.
+5. **Regimes outside the sample are invisible.** PBO can't account for structural
+   breaks it never saw.
+6. **Order-dependent metrics** (max drawdown, Calmar) have no additive block
+   statistics, so they run on the slow NumPy path only.
+
+## Development
+
+```bash
+git clone https://github.com/ryousuf569/phacker.git
+cd phacker
+pip install -e ".[test]"   # builds the C++ kernel; needs a C++20 compiler
+pytest
+```
+
+`pytest` without installing runs against the source tree on the NumPy backend, and
+the C++ parity tests are skipped. On Windows with MinGW on `PATH`, set
+`CMAKE_GENERATOR="Visual Studio 17 2022"` so the build uses MSVC.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

phacker-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+phacker/cscv.py,sha256=UUSNy3gab1YwRqpU-J8HY8PXwFqedmElm7PUbgUASIk,1692
+phacker/grid.py,sha256=qZx5eYxF-5jGDTDt_FA0kAxmEaN-_RVPrbF4zIMy8OQ,6450
+phacker/indicators.py,sha256=EFBLo7j9-AeB6K8HrLbyLkpmjUOVPPZA5MDOdRcTNJk,3837
+phacker/stats.py,sha256=gcqXF2hUUWJlt7k7FGIYcVIMYtvYsLLN_B6oUHCoc1M,1391
+phacker/_core.cp313-win_amd64.pyd,sha256=4-HbXslGHddwZpM_Vrvig6zIncNF2DpAcDE5HNA_qAQ,161792
+phacker/__init__.py,sha256=HI-CW2E2ePnTdUzOB9jbYShmnO2HroA0XWgRIQcbqYI,501
+phacker-0.1.0.dist-info/DELVEWHEEL,sha256=s-jG6QA6tKMb3JGUWcxR4ECvB4eKIJA4c_E7w9ftMjc,400
+phacker-0.1.0.dist-info/METADATA,sha256=of7Dx8v8THDxxMroQs3mbSXcP0dGkGqc44uwXcnkiB8,9015
+phacker-0.1.0.dist-info/RECORD,,
+phacker-0.1.0.dist-info/WHEEL,sha256=sq6LgldFBnjvRzPumpzyb8wN76iXDClJOEXkoK-XWzE,105
+phacker-0.1.0.dist-info/licenses/LICENSE,sha256=4kaKcfEDxi1E-OFjGpmaaKNMf8C0KzyV_nqYDUXBXqI,1088
+phacker.libs/msvcp140-a4c2229bdc2a2a630acdc095b4d86008.dll,sha256=pMIim9wqKmMKzcCVtNhgCOXD47x3cxdDVPPaT1vrnN4,575056
+phacker.libs/vcomp140-f96f3a14d88d8846f31f3ab38a490304.dll,sha256=-W86FNiNiEbzHzqzikkDBM59bk9w-uQwTGPlnHrqLTA,213072

phacker-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 1.1.1
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

phacker-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ryousuf569
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.