refactor(algorithms): convert statistics functions to arrow functions

Convert all exported statistical functions from function declarations to
arrow functions for consistent code style:
- pairedTTest
- wilcoxonSignedRank
- bootstrapCI
- bootstrapDifferenceTest

Also convert internal helper functions to arrow functions.

Author: Mearman

packages/algorithms/src/evaluation/statistics/bootstrap.ts

@@ -23,12 +23,7 @@
  * console.log(ci.mean);  // e.g., 0.85
  * ```
  */
-export function bootstrapCI(
-  samples: number[],
-  confidence: number = 0.95,
-  nBootstrap: number = 10000,
-  seed?: number
-): { lower: number; upper: number; mean: number } {
+export const bootstrapCI = (samples: number[], confidence: number = 0.95, nBootstrap: number = 10000, seed?: number): { lower: number; upper: number; mean: number } => {
   if (samples.length < 2) {
     throw new Error('Bootstrap requires at least 2 samples');
   }
@@ -67,7 +62,7 @@ export function bootstrapCI(
   const upper = bootstrapMeans[upperIndex]!;
 
   return { lower, upper, mean: observedMean };
-}
+};
 
 /**
  * Bootstrap test for significant difference between methods.
@@ -93,18 +88,12 @@ export function bootstrapCI(
  * console.log(result.ci.upper);       // e.g., 0.22
  * ```
  */
-export function bootstrapDifferenceTest(
-  method1Samples: number[],
-  method2Samples: number[],
-  nBootstrap: number = 10000,
-  alpha: number = 0.05,
-  seed?: number
-): {
+export const bootstrapDifferenceTest = (method1Samples: number[], method2Samples: number[], nBootstrap: number = 10000, alpha: number = 0.05, seed?: number): {
   pValue: number;
   meanDifference: number;
   ci: { lower: number; upper: number };
   significant: boolean;
-} {
+} => {
   if (method1Samples.length < 2 || method2Samples.length < 2) {
     throw new Error('Both methods require at least 2 samples');
   }
@@ -171,7 +160,7 @@ export function bootstrapDifferenceTest(
     ci,
     significant,
   };
-}
+};
 
 /**
  * Seeded random number generator for reproducible bootstrapping.

packages/algorithms/src/evaluation/statistics/effect-size.ts

@@ -27,11 +27,11 @@
  * console.log(result.interpretation); // 'very-large'
  * ```
  */
-export function cohensD(group1: number[], group2: number[]): {
+export const cohensD = (group1: number[], group2: number[]): {
   effectSize: number;
   interpretation: 'negligible' | 'small' | 'medium' | 'large' | 'very-large';
   magnitude: number;
-} {
+} => {
   if (group1.length < 2 || group2.length < 2) {
     throw new Error('Cohen\'s d requires at least 2 samples per group');
   }
@@ -72,7 +72,7 @@ export function cohensD(group1: number[], group2: number[]): {
     interpretation,
     magnitude: absD,
   };
-}
+};
 
 /**
  * Cliff's delta (non-parametric effect size).
@@ -101,12 +101,12 @@ export function cohensD(group1: number[], group2: number[]): {
  * console.log(result.probability);  // e.g., 0.96 (96% chance treatment > control)
  * ```
  */
-export function cliffsDelta(group1: number[], group2: number[]): {
+export const cliffsDelta = (group1: number[], group2: number[]): {
   effectSize: number;
   interpretation: 'negligible' | 'small' | 'medium' | 'large';
   probability: number;
   magnitude: number;
-} {
+} => {
   if (group1.length === 0 || group2.length === 0) {
     throw new Error('Cliff\'s delta requires at least 1 sample per group');
   }
@@ -152,7 +152,7 @@ export function cliffsDelta(group1: number[], group2: number[]): {
     probability,
     magnitude: absDelta,
   };
-}
+};
 
 /**
  * Glass's delta (alternative to Cohen's d).
@@ -172,10 +172,10 @@ export function cliffsDelta(group1: number[], group2: number[]): {
  * console.log(result.effectSize); // e.g., 1.8
  * ```
  */
-export function glassDelta(treatment: number[], control: number[]): {
+export const glassDelta = (treatment: number[], control: number[]): {
   effectSize: number;
   interpretation: 'negligible' | 'small' | 'medium' | 'large' | 'very-large';
-} {
+} => {
   if (treatment.length < 2 || control.length < 2) {
     throw new Error('Glass\'s delta requires at least 2 samples per group');
   }
@@ -206,7 +206,7 @@ export function glassDelta(treatment: number[], control: number[]): {
   }
 
   return { effectSize, interpretation };
-}
+};
 
 /**
  * Rank-biserial correlation (non-parametric effect size).
@@ -229,11 +229,11 @@ export function glassDelta(treatment: number[], control: number[]): {
  * console.log(result.effectSize);  // e.g., 0.70 (large effect)
  * ```
  */
-export function rankBiserialCorrelation(group1: number[], group2: number[]): {
+export const rankBiserialCorrelation = (group1: number[], group2: number[]): {
   effectSize: number;
   correlation: number;
   interpretation: 'negligible' | 'small' | 'medium' | 'large';
-} {
+} => {
   if (group1.length === 0 || group2.length === 0) {
     throw new Error('Rank-biserial correlation requires at least 1 sample per group');
   }
@@ -310,4 +310,4 @@ export function rankBiserialCorrelation(group1: number[], group2: number[]): {
     correlation,
     interpretation,
   };
-}
+};

packages/algorithms/src/evaluation/statistics/multiple-comparison.ts

@@ -20,10 +20,7 @@
  * console.log(result.significant);     // [true, false, false, false, false]
  * ```
  */
-export function bonferroniCorrection(
-  pValues: number[],
-  alpha: number = 0.05
-): { correctedAlpha: number; significant: boolean[] } {
+export const bonferroniCorrection = (pValues: number[], alpha: number = 0.05): { correctedAlpha: number; significant: boolean[] } => {
   if (pValues.length === 0) {
     return { correctedAlpha: alpha, significant: [] };
   }
@@ -35,7 +32,7 @@ export function bonferroniCorrection(
   const significant = pValues.map(p => p < correctedAlpha);
 
   return { correctedAlpha, significant };
-}
+};
 
 /**
  * Benjamini-Hochberg FDR correction.
@@ -60,10 +57,7 @@ export function bonferroniCorrection(
  * console.log(result.significant);     // [true, true, false, false, false]
  * ```
  */
-export function benjaminiHochberg(
-  pValues: number[],
-  fdr: number = 0.05
-): { adjustedPValues: number[]; significant: boolean[] } {
+export const benjaminiHochberg = (pValues: number[], fdr: number = 0.05): { adjustedPValues: number[]; significant: boolean[] } => {
   if (pValues.length === 0) {
     return { adjustedPValues: [], significant: [] };
   }
@@ -100,7 +94,7 @@ export function benjaminiHochberg(
   }
 
   return { adjustedPValues, significant };
-}
+};
 
 /**
  * Holm-Bonferroni method (step-down procedure).
@@ -124,10 +118,7 @@ export function benjaminiHochberg(
  * console.log(result.significant); // [true, false, false, false, false]
  * ```
  */
-export function holmBonferroni(
-  pValues: number[],
-  alpha: number = 0.05
-): { adjustedPValues: number[]; significant: boolean[] } {
+export const holmBonferroni = (pValues: number[], alpha: number = 0.05): { adjustedPValues: number[]; significant: boolean[] } => {
   if (pValues.length === 0) {
     return { adjustedPValues: [], significant: [] };
   }
@@ -181,7 +172,7 @@ export function holmBonferroni(
   }
 
   return { adjustedPValues, significant };
-}
+};
 
 /**
  * Storey's q-value method (FDR-based with estimation of true nulls).
@@ -202,11 +193,7 @@ export function holmBonferroni(
  * console.log(result.significant); // Which tests are significant at FDR=0.05
  * ```
  */
-export function storeyQValues(
-  pValues: number[],
-  fdr: number = 0.05,
-  lambda: number = 0.5
-): { qValues: number[]; significant: boolean[]; pi0: number } {
+export const storeyQValues = (pValues: number[], fdr: number = 0.05, lambda: number = 0.5): { qValues: number[]; significant: boolean[]; pi0: number } => {
   if (pValues.length === 0) {
     return { qValues: [], significant: [], pi0: 1 };
   }
@@ -243,4 +230,4 @@ export function storeyQValues(
   }
 
   return { qValues, significant, pi0 };
-}
+};

packages/algorithms/src/evaluation/statistics/paired-tests.ts

@@ -22,11 +22,7 @@
  * console.log(result.significant); // true
  * ```
  */
-export function pairedTTest(
-  method1Results: number[],
-  method2Results: number[],
-  alpha: number = 0.05
-): { pValue: number; tStatistic: number; significant: boolean } {
+export const pairedTTest = (method1Results: number[], method2Results: number[], alpha: number = 0.05): { pValue: number; tStatistic: number; significant: boolean } => {
   if (method1Results.length !== method2Results.length) {
     throw new Error('Paired samples must have equal length');
   }
@@ -63,7 +59,7 @@ export function pairedTTest(
     tStatistic,
     significant: pValue < alpha,
   };
-}
+};
 
 /**
  * Wilcoxon signed-rank test (non-parametric alternative to paired t-test).
@@ -84,11 +80,7 @@ export function pairedTTest(
  * console.log(result.pValue); // e.g., 0.031 (significant at α=0.05)
  * ```
  */
-export function wilcoxonSignedRank(
-  method1Results: number[],
-  method2Results: number[],
-  alpha: number = 0.05
-): { pValue: number; statistic: number; significant: boolean } {
+export const wilcoxonSignedRank = (method1Results: number[], method2Results: number[], alpha: number = 0.05): { pValue: number; statistic: number; significant: boolean } => {
   if (method1Results.length !== method2Results.length) {
     throw new Error('Paired samples must have equal length');
   }
@@ -170,15 +162,17 @@ export function wilcoxonSignedRank(
     statistic: w,
     significant: pValue < alpha,
   };
-}
+};
 
 /**
  * Calculate two-tailed p-value from t-statistic using t-distribution.
  *
  * Uses approximation of t-distribution CDF.
  * For large degrees of freedom, converges to normal distribution.
+ * @param t
+ * @param df
  */
-function twoTailedPValue(t: number, df: number): number {
+const twoTailedPValue = (t: number, df: number): number => {
   // Approximate t-distribution with normal for df > 30
   if (df > 30) {
     const z = standardScoreToZ(t, df);
@@ -189,22 +183,22 @@ function twoTailedPValue(t: number, df: number): number {
   // In production, use proper t-distribution tables or numerical integration
   const z = t; // Simplified - less accurate for small df
   return 2 * (1 - normalCDF(Math.abs(z)));
-}
+};
 
 /**
  * Convert t-score to approximate z-score (Welch-Satterthwaite approximation).
+ * @param t
+ * @param df
  */
-function standardScoreToZ(t: number, df: number): number {
-  // For large df, t approaches normal
-  return t;
-}
+const standardScoreToZ = (t: number, df: number): number => t;
 
 /**
  * Standard normal cumulative distribution function.
  *
  * Uses Abramowitz and Stegun approximation (error < 0.00005).
+ * @param x
  */
-function normalCDF(x: number): number {
+const normalCDF = (x: number): number => {
   const a1 = 0.254829592;
   const a2 = -0.284496736;
   const a3 = 1.421413741;
@@ -219,4 +213,4 @@ function normalCDF(x: number): number {
   const y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);
 
   return 0.5 * (1.0 + sign * y);
-}
+};