Statistics: Sharpe, DSR, PBO, SPA, and Moment Functions

mean(a: number[]): number

variance(a: number[]): number

stdev(a: number[]): number

skewness(a: number[]): number

skewness = (1/n) · Σ ((xᵢ − mean) / stdev)³

kurtosis(a: number[]): number

sharpe(returns: number[]): number

normalCdf(z: number): number

normalInv(p: number): number

expectedMaxSharpe(varSR: number, nTrials: number): number

E[max SR] ≈ √varSR · [(1 − γ) · Φ⁻¹(1 − 1/N) + γ · Φ⁻¹(1 − 1/(N·e))]

deflatedSharpe(
  returns: number[],
  nTrials: number,
  varSRAcrossTrials: number,
): number

DSR = Φ( (SR − SR₀) · √(T − 1) / √(1 − skew · SR + (kurt − 1)/4 · SR²) )

minTrackRecordLength(returns: number[], alpha?: number): number

minTRL = 1 + [1 − skew · SR + (kurt − 1)/4 · SR²] · (Z_{1-α} / SR)²

probabilityOfBacktestOverfitting(perf: number[][]): number

realityCheckPValue(
  strategiesReturns: number[][],
  opts?: { bootstraps?: number; pBlock?: number; seed?: number },
): number

stationaryBootstrapResample(
  returns: number[],
  pBlock: number,
  rng: () => number,
): number[]

mulberry32(seed: number): () => number

import { mulberry32, stationaryBootstrapResample } from "pump-anomaly";

const rng = mulberry32(42);
const resampled = stationaryBootstrapResample(myReturns, 0.1, rng);

certifyStrategy(
  inp: CertificationInput,
  thresholds?: { dsr?: number; pbo?: number; spa?: number },
): Certification

interface CertificationInput {
  /** per-trade returns of the selected (best) strategy */
  selectedReturns: number[];
  /** number of configurations tried */
  nTrials: number;
  /** variance of Sharpe estimates across trials (for the DSR bar) */
  varSRAcrossTrials: number;
  /** perf[config][fold] for PBO (CSCV) */
  perfMatrix: number[][];
  /** return series for all candidate configurations, for SPA */
  candidateReturns: number[][];
  /** unbiased nested-CV OOS score (null if not computed) */
  nestedScore: number | null;
}

interface Certification {
  certified: boolean;
  dsr: number;              // ≥ 0.95 to pass
  pbo: number;              // ≤ 0.10 to pass
  spaPValue: number;        // ≤ 0.05 to pass
  minTRL: number;           // actualN must be ≥ minTRL
  actualN: number;          // returns.length
  nestedScore: number | null; // must be > 0 if non-null
  reasons: string[];        // human-readable failure reasons (empty when certified)
}

import { certifyStrategy } from "pump-anomaly";

const cert = certifyStrategy(
  {
    selectedReturns: myReturns,
    nTrials: 500,
    varSRAcrossTrials: 0.04,
    perfMatrix: foldPerf,
    candidateReturns: allReturns,
    nestedScore: 0.012,
  },
  { dsr: 0.95, pbo: 0.10, spa: 0.05 },
);

if (cert.certified) {
  console.log("Edge is real — safe to deploy.");
} else {
  console.log("Rejected:", cert.reasons);
}

shrinkageExpectancy(returns: number[], k?: number): number

score = mean(returns) · N / (N + k)

winrate(returns: number[]): number

percentile(xs: number[], p: number): number

riskRewardStats(
  trades: Array<{ pnl: number; hardStop: number }>,
): RiskRewardStats

interface RiskRewardStats {
  mean: number;   // mean RR across all trades
  p95:  number;   // 95th percentile RR (positive tail)
  p99:  number;   // 99th percentile RR
  n:    number;   // number of trades in the sample
}

pnlStats(pnls: number[]): PnlStats

interface PnlStats {
  mean:   number;   // arithmetic mean (sensitive to outliers — for comparison)
  median: number;   // 50th percentile (outlier-immune centre)
  p5:     number;   // 5th percentile (lower tail — how bad the worst 5% are)
  p95:    number;   // 95th percentile (upper tail)
  p99:    number;   // 99th percentile (extreme upper tail)
  n:      number;   // number of valid trades
}

standardError(foldScores: number[]): number

oneStandardErrorSelect<T>(
  entries: T[],
  scoreOf: (e: T) => number,
  foldsOf: (e: T) => number[],
  isSimpler: (a: T, b: T) => boolean,
  seMultiplier?: number,
): T | null