use rand::rngs::StdRng;
use rand::{RngExt, SeedableRng};
use statrs::distribution::{ContinuousCDF, Normal};
use crate::Outcome;
use crate::stats::wilson::inverse_normal_cdf;
pub const DEFAULT_SEED: u64 = 0x5EED;
fn bootstrap_means(diffs: &[f64], resamples: usize, seed: u64) -> Vec<f64> {
let n = diffs.len();
let mut rng = StdRng::seed_from_u64(seed);
let mut means: Vec<f64> = Vec::with_capacity(resamples);
for _ in 0..resamples {
let mut accumulator = MeanAccumulator::default();
for _ in 0..n {
let idx = rng.random_range(0..n);
accumulator.push(diffs[idx]);
}
means.push(accumulator.finish());
}
means.sort_by(f64::total_cmp);
means
}
pub(crate) fn lo_index(p: f64, resamples: usize) -> usize {
((p * resamples as f64).floor() as usize).min(resamples - 1)
}
pub(crate) fn hi_index(p: f64, resamples: usize) -> usize {
let idx_raw = (p * resamples as f64).ceil() as usize;
idx_raw.saturating_sub(1).min(resamples - 1)
}
pub(crate) fn resample_edge_multinomial(
lo_wins: u64,
hi_wins: u64,
draws: u64,
rng: &mut StdRng,
) -> (u64, u64, u64) {
let n = lo_wins + hi_wins + draws;
debug_assert!(
n > 0,
"resample_edge_multinomial called on an edge with zero games"
);
let n_f = n as f64;
let p_lo = lo_wins as f64 / n_f;
let p_lo_or_hi = p_lo + hi_wins as f64 / n_f;
let (mut new_lo, mut new_hi, mut new_draws) = (0u64, 0u64, 0u64);
for _ in 0..n {
let u: f64 = rng.random();
if u < p_lo {
new_lo += 1;
} else if u < p_lo_or_hi {
new_hi += 1;
} else {
new_draws += 1;
}
}
(new_lo, new_hi, new_draws)
}
const CLUSTER_RESAMPLE_RETRY_CAP: u32 = 1_000;
fn resample_outcome_pool(clusters: &[Vec<Outcome>], rng: &mut StdRng) -> (u64, u64, u64) {
let k = clusters.len();
let mut baseline_wins = 0u64;
let mut candidate_wins = 0u64;
let mut draws = 0u64;
for _ in 0..k {
let idx = rng.random_range(0..k);
for outcome in &clusters[idx] {
match outcome {
Outcome::BaselineWin => baseline_wins += 1,
Outcome::CandidateWin => candidate_wins += 1,
Outcome::Draw => draws += 1,
}
}
}
(baseline_wins, candidate_wins, draws)
}
pub(crate) fn cluster_bootstrap_outcome_draws(
clusters: &[Vec<Outcome>],
resamples: usize,
seed: u64,
statistic: fn(u64, u64, u64) -> f64,
) -> Vec<f64> {
let mut rng = StdRng::seed_from_u64(seed);
let mut draws_out = Vec::with_capacity(resamples);
for _ in 0..resamples {
let mut attempt = resample_outcome_pool(clusters, &mut rng);
let mut value = statistic(attempt.0, attempt.1, attempt.2);
let mut tries = 0;
while value.is_nan() && tries < CLUSTER_RESAMPLE_RETRY_CAP {
attempt = resample_outcome_pool(clusters, &mut rng);
value = statistic(attempt.0, attempt.1, attempt.2);
tries += 1;
}
draws_out.push(value);
}
draws_out.sort_by(f64::total_cmp);
draws_out
}
pub(crate) fn iid_bootstrap_outcome_draws(
clusters: &[Vec<Outcome>],
resamples: usize,
seed: u64,
statistic: fn(u64, u64, u64) -> f64,
) -> Vec<f64> {
let records: Vec<Outcome> = clusters.iter().flatten().copied().collect();
let singleton_clusters: Vec<Vec<Outcome>> = records.into_iter().map(|o| vec![o]).collect();
cluster_bootstrap_outcome_draws(&singleton_clusters, resamples, seed, statistic)
}
pub(crate) struct ClusterBootstrapResult {
pub ci_low: f64,
pub ci_high: f64,
pub design_effect: f64,
pub effective_sample_size: f64,
}
pub(crate) fn cluster_bootstrap_ci(
clusters: &[Vec<Outcome>],
n: u64,
confidence: f64,
resamples: usize,
seed: u64,
statistic: fn(u64, u64, u64) -> f64,
) -> ClusterBootstrapResult {
let cluster_draws = cluster_bootstrap_outcome_draws(clusters, resamples, seed, statistic);
let iid_draws = iid_bootstrap_outcome_draws(clusters, resamples, seed, statistic);
let alpha = 1.0 - confidence;
let ci_low = cluster_draws[lo_index(alpha / 2.0, resamples)];
let ci_high = cluster_draws[hi_index(1.0 - alpha / 2.0, resamples)];
let var_cluster = sample_variance(&cluster_draws);
let var_iid = sample_variance(&iid_draws);
let design_effect = if var_iid > 0.0 {
var_cluster / var_iid
} else {
1.0
};
let effective_sample_size = if design_effect > 0.0 {
n as f64 / design_effect
} else {
n as f64
};
ClusterBootstrapResult {
ci_low,
ci_high,
design_effect,
effective_sample_size,
}
}
pub fn bootstrap_mean_diff_ci(
diffs: &[f64],
confidence: f64,
resamples: usize,
seed: u64,
) -> (f64, f64) {
debug_assert!(!diffs.is_empty(), "bootstrap called with empty sample");
debug_assert!(resamples > 0, "bootstrap called with zero resamples");
let means = bootstrap_means(diffs, resamples, seed);
let alpha = 1.0 - confidence;
let lo_idx = lo_index(alpha / 2.0, resamples);
let hi_idx = hi_index(1.0 - alpha / 2.0, resamples).max(lo_idx);
(means[lo_idx], means[hi_idx])
}
pub fn bootstrap_mean_diff_ci_basic(
diffs: &[f64],
confidence: f64,
resamples: usize,
seed: u64,
) -> (f64, f64) {
debug_assert!(!diffs.is_empty(), "bootstrap called with empty sample");
debug_assert!(resamples > 0, "bootstrap called with zero resamples");
let effect = mean(diffs);
let (perc_lo, perc_hi) = bootstrap_mean_diff_ci(diffs, confidence, resamples, seed);
let doubled = 2.0 * effect;
if doubled.is_finite() {
(doubled - perc_hi, doubled - perc_lo)
} else {
(effect + (effect - perc_hi), effect + (effect - perc_lo))
}
}
pub(crate) fn bias_correction_z0(below_count: f64, resamples: usize) -> f64 {
let prop_less = (below_count / resamples as f64)
.clamp(0.5 / resamples as f64, 1.0 - 0.5 / resamples as f64);
inverse_normal_cdf(prop_less)
}
pub(crate) fn weighted_acceleration(replicates: &[(f64, f64)]) -> f64 {
let mut total_weight = 0.0;
let mut weighted_mean = 0.0;
let mut weighted_sum = 0.0;
for &(value, weight) in replicates {
if weight <= 0.0 {
continue;
}
weighted_sum += value * weight;
let next_weight = total_weight + weight;
weighted_mean =
weighted_mean * (total_weight / next_weight) + value * (weight / next_weight);
total_weight = next_weight;
}
if total_weight <= 0.0 {
return 0.0;
}
if weighted_sum.is_finite() {
weighted_mean = weighted_sum / total_weight;
}
let (mut raw_num, mut raw_den) = (0.0, 0.0);
for &(value, weight) in replicates {
if weight <= 0.0 {
continue;
}
let delta = weighted_mean - value;
raw_num += weight * delta.powi(3);
raw_den += weight * delta.powi(2);
}
if raw_num.is_finite() && raw_den.is_finite() {
if raw_den < 1e-12 {
return 0.0;
}
let raw_scale = 6.0 * raw_den.powf(1.5);
if raw_scale.is_finite() {
return raw_num / raw_scale;
}
}
let scale = replicates
.iter()
.filter(|&&(_, weight)| weight > 0.0)
.map(|&(value, _)| value.abs())
.fold(weighted_mean.abs(), f64::max);
if scale == 0.0 {
return 0.0;
}
let (mut num, mut den) = (0.0, 0.0);
for &(v, w) in replicates {
if w <= 0.0 {
continue;
}
let delta = weighted_mean / scale - v / scale;
num += w * delta.powi(3);
den += w * delta.powi(2);
}
if den < 1e-12 {
0.0
} else {
num / (6.0 * den.powf(1.5))
}
}
pub(crate) fn bca_adjusted_percentiles(z0: f64, a: f64, confidence: f64) -> (f64, f64) {
let alpha = 1.0 - confidence;
let z_lo = inverse_normal_cdf(alpha / 2.0);
let z_hi = inverse_normal_cdf(1.0 - alpha / 2.0);
let normal = Normal::new(0.0, 1.0).expect("standard normal distribution is always valid");
let adjust = |z: f64| -> f64 {
let denom = 1.0 - a * (z0 + z);
let adjusted = if denom.abs() < 1e-12 || !denom.is_finite() {
z0 + z
} else {
z0 + (z0 + z) / denom
};
normal.cdf(adjusted).clamp(0.0, 1.0)
};
(adjust(z_lo), adjust(z_hi))
}
pub fn bootstrap_mean_diff_ci_bca(
diffs: &[f64],
confidence: f64,
resamples: usize,
seed: u64,
) -> (f64, f64) {
debug_assert!(!diffs.is_empty(), "bootstrap called with empty sample");
debug_assert!(resamples > 0, "bootstrap called with zero resamples");
let n = diffs.len();
if n == 1 {
return (diffs[0], diffs[0]);
}
let original_mean = mean(diffs);
let means = bootstrap_means(diffs, resamples, seed);
let below = means.iter().filter(|&&m| m < original_mean).count() as f64;
let z0 = bias_correction_z0(below, resamples);
let mut total_accumulator = MeanAccumulator::default();
for &value in diffs {
total_accumulator.push(value);
}
let total = total_accumulator.sum_for_subtraction();
let direct_jack: Vec<(f64, f64)> = diffs
.iter()
.map(|d| ((total - d) / (n - 1) as f64, 1.0))
.collect();
let jack_replicates = if direct_jack.iter().all(|(value, _)| value.is_finite()) {
direct_jack
} else {
let mut prefix_means = vec![0.0; n + 1];
for (i, &value) in diffs.iter().enumerate() {
prefix_means[i + 1] = update_mean(prefix_means[i], value, i + 1);
}
let mut suffix_means = vec![0.0; n + 1];
for i in (0..n).rev() {
suffix_means[i] = update_mean(suffix_means[i + 1], diffs[i], n - i);
}
(0..n)
.map(|skip| {
let left_count = skip;
let right_count = n - skip - 1;
let leave_one_out = combine_means(
prefix_means[skip],
left_count,
suffix_means[skip + 1],
right_count,
);
(leave_one_out, 1.0)
})
.collect()
};
let a = weighted_acceleration(&jack_replicates);
let (p_lo, p_hi) = bca_adjusted_percentiles(z0, a, confidence);
let lo_idx = lo_index(p_lo, resamples);
let hi_idx = hi_index(p_hi, resamples).max(lo_idx);
(means[lo_idx], means[hi_idx])
}
fn update_mean(current: f64, value: f64, count: usize) -> f64 {
let count = count as f64;
current * ((count - 1.0) / count) + value / count
}
fn combine_means(left: f64, left_count: usize, right: f64, right_count: usize) -> f64 {
match (left_count, right_count) {
(0, _) => right,
(_, 0) => left,
_ => {
let total = (left_count + right_count) as f64;
left * (left_count as f64 / total) + right * (right_count as f64 / total)
}
}
}
#[derive(Default)]
struct MeanAccumulator {
sum: f64,
correction: f64,
overflow_mean: Option<f64>,
count: usize,
}
impl MeanAccumulator {
fn push(&mut self, value: f64) {
if let Some(mean) = self.overflow_mean {
self.count += 1;
self.overflow_mean = Some(update_mean(mean, value, self.count));
return;
}
let next = self.sum + value;
let delta = if self.sum.abs() >= value.abs() {
(self.sum - next) + value
} else {
(value - next) + self.sum
};
let correction = self.correction + delta;
if next.is_finite() && correction.is_finite() {
self.sum = next;
self.correction = correction;
self.count += 1;
return;
}
let previous_mean = (self.sum + self.correction) / self.count as f64;
self.count += 1;
self.overflow_mean = Some(update_mean(previous_mean, value, self.count));
}
fn corrected_sum(&self) -> Option<f64> {
let corrected = self.sum + self.correction;
corrected.is_finite().then_some(corrected)
}
fn sum_for_subtraction(&self) -> f64 {
self.overflow_mean
.map(|mean| mean * self.count as f64)
.or_else(|| self.corrected_sum())
.unwrap_or(self.sum)
}
fn finish(&self) -> f64 {
debug_assert!(self.count > 0, "mean accumulator is empty");
self.overflow_mean
.unwrap_or_else(|| self.corrected_sum().unwrap_or(self.sum) / self.count as f64)
}
}
pub fn mean(values: &[f64]) -> f64 {
debug_assert!(!values.is_empty(), "mean called on an empty sample");
let mut accumulator = MeanAccumulator::default();
for &value in values {
accumulator.push(value);
}
accumulator.finish()
}
pub fn sample_variance(values: &[f64]) -> f64 {
let m = mean(values);
let sum_sq_dev: f64 = values.iter().map(|v| (v - m).powi(2)).sum();
sum_sq_dev / (values.len() as f64 - 1.0)
}
pub fn sample_sd(values: &[f64]) -> f64 {
sample_variance(values).sqrt()
}
pub fn quantile(values: &[f64], q: f64) -> f64 {
debug_assert!(!values.is_empty(), "quantile called on an empty sample");
let mut sorted: Vec<f64> = values.to_vec();
sorted.sort_by(f64::total_cmp);
sorted_quantile(&sorted, q)
}
fn sorted_quantile(sorted: &[f64], q: f64) -> f64 {
let n = sorted.len();
if n == 1 {
return sorted[0];
}
let h = q * (n - 1) as f64;
let lo = h.floor() as usize;
let hi = h.ceil() as usize;
if lo == hi {
return sorted[lo];
}
let frac = h - lo as f64;
let delta = sorted[hi] - sorted[lo];
if delta.is_finite() {
sorted[lo] + frac * delta
} else {
sorted[lo] * (1.0 - frac) + sorted[hi] * frac
}
}
fn bootstrap_quantiles(diffs: &[f64], q: f64, resamples: usize, seed: u64) -> Vec<f64> {
let n = diffs.len();
let mut rng = StdRng::seed_from_u64(seed);
let mut quantiles: Vec<f64> = Vec::with_capacity(resamples);
for _ in 0..resamples {
let mut resample: Vec<f64> = Vec::with_capacity(n);
for _ in 0..n {
let idx = rng.random_range(0..n);
resample.push(diffs[idx]);
}
resample.sort_by(f64::total_cmp);
quantiles.push(sorted_quantile(&resample, q));
}
quantiles.sort_by(f64::total_cmp);
quantiles
}
pub fn bootstrap_quantile_diff_ci(
diffs: &[f64],
q: f64,
confidence: f64,
resamples: usize,
seed: u64,
) -> (f64, f64) {
debug_assert!(!diffs.is_empty(), "bootstrap called with empty sample");
debug_assert!(resamples > 0, "bootstrap called with zero resamples");
let quantiles = bootstrap_quantiles(diffs, q, resamples, seed);
let alpha = 1.0 - confidence;
let lo_idx = lo_index(alpha / 2.0, resamples);
let hi_idx = hi_index(1.0 - alpha / 2.0, resamples).max(lo_idx);
(quantiles[lo_idx], quantiles[hi_idx])
}
pub fn bootstrap_quantile_diff_ci_basic(
diffs: &[f64],
q: f64,
confidence: f64,
resamples: usize,
seed: u64,
) -> (f64, f64) {
debug_assert!(!diffs.is_empty(), "bootstrap called with empty sample");
debug_assert!(resamples > 0, "bootstrap called with zero resamples");
let effect = quantile(diffs, q);
let (perc_lo, perc_hi) = bootstrap_quantile_diff_ci(diffs, q, confidence, resamples, seed);
let doubled = 2.0 * effect;
if doubled.is_finite() {
(doubled - perc_hi, doubled - perc_lo)
} else {
(effect + (effect - perc_hi), effect + (effect - perc_lo))
}
}
pub fn bootstrap_quantile_diff_ci_bca(
diffs: &[f64],
q: f64,
confidence: f64,
resamples: usize,
seed: u64,
) -> (f64, f64) {
debug_assert!(!diffs.is_empty(), "bootstrap called with empty sample");
debug_assert!(resamples > 0, "bootstrap called with zero resamples");
let n = diffs.len();
if n == 1 {
return (diffs[0], diffs[0]);
}
let original_estimate = quantile(diffs, q);
let quantiles = bootstrap_quantiles(diffs, q, resamples, seed);
let below = quantiles.iter().filter(|&&v| v < original_estimate).count() as f64;
let z0 = bias_correction_z0(below, resamples);
let mut sorted: Vec<f64> = diffs.to_vec();
sorted.sort_by(f64::total_cmp);
let jack_replicates: Vec<(f64, f64)> = (0..n)
.map(|skip| {
let leave_one_out: Vec<f64> = sorted
.iter()
.enumerate()
.filter(|&(i, _)| i != skip)
.map(|(_, &v)| v)
.collect();
(sorted_quantile(&leave_one_out, q), 1.0)
})
.collect();
let a = weighted_acceleration(&jack_replicates);
let (p_lo, p_hi) = bca_adjusted_percentiles(z0, a, confidence);
let lo_idx = lo_index(p_lo, resamples);
let hi_idx = hi_index(p_hi, resamples).max(lo_idx);
(quantiles[lo_idx], quantiles[hi_idx])
}
#[cfg(test)]
mod tests {
use super::*;
fn assert_close(actual: f64, expected: f64, tol: f64) {
assert!(
(actual - expected).abs() < tol,
"expected {expected}, got {actual}"
);
}
#[test]
fn deterministic_across_calls() {
let diffs = vec![0.1, 0.2, -0.05, 0.3, 0.0, 0.15];
let (lo1, hi1) = bootstrap_mean_diff_ci(&diffs, 0.95, 2000, DEFAULT_SEED);
let (lo2, hi2) = bootstrap_mean_diff_ci(&diffs, 0.95, 2000, DEFAULT_SEED);
assert_eq!(lo1, lo2);
assert_eq!(hi1, hi2);
}
#[test]
fn different_seed_can_change_output() {
let diffs = vec![0.1, 0.2, -0.05, 0.3, 0.0, 0.15, 0.4, -0.2, 0.05, 0.25];
let a = bootstrap_mean_diff_ci(&diffs, 0.95, 2000, DEFAULT_SEED);
let b = bootstrap_mean_diff_ci(&diffs, 0.95, 2000, 42);
assert_ne!(a, b);
}
#[test]
fn brackets_true_mean() {
let diffs = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let (lo, hi) = bootstrap_mean_diff_ci(&diffs, 0.95, 5000, DEFAULT_SEED);
assert!(
lo <= 3.0 && 3.0 <= hi,
"expected [{lo}, {hi}] to bracket 3.0"
);
}
#[test]
fn single_sample_no_panic() {
let diffs = vec![2.5];
let (lo, hi) = bootstrap_mean_diff_ci(&diffs, 0.95, 1000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert_eq!(lo, 2.5);
assert_eq!(hi, 2.5);
}
#[test]
fn mean_of_known_values() {
assert!((mean(&[0.1, 0.2, -0.05]) - 0.08333333333333333).abs() < 1e-9);
}
#[test]
fn mean_of_extreme_values_stays_finite() {
assert_eq!(mean(&[f64::MAX, f64::MAX]), f64::MAX);
assert_eq!(mean(&[f64::MAX, -f64::MAX]), 0.0);
}
#[test]
fn mean_recovers_a_small_residual_after_severe_cancellation() {
assert_close(mean(&[1e16, 1.0, -1e16]), 1.0 / 3.0, 1e-15);
}
#[test]
fn mean_does_not_gate_compensation_on_a_magnitude_ratio() {
assert_close(mean(&[1e16, 100001.0, -1e16]), 100001.0 / 3.0, 1e-12);
}
#[test]
fn quantile_interpolation_of_opposite_extremes_stays_finite() {
assert_eq!(quantile(&[-f64::MAX, f64::MAX], 0.5), 0.0);
}
#[test]
fn bootstrap_mean_intervals_stay_finite_for_constant_extreme_values() {
let diffs = [f64::MAX, f64::MAX];
for interval in [
bootstrap_mean_diff_ci(&diffs, 0.95, 100, DEFAULT_SEED),
bootstrap_mean_diff_ci_basic(&diffs, 0.95, 100, DEFAULT_SEED),
bootstrap_mean_diff_ci_bca(&diffs, 0.95, 100, DEFAULT_SEED),
] {
assert_eq!(interval, (f64::MAX, f64::MAX));
}
}
#[test]
fn weighted_acceleration_stays_finite_for_extreme_replicates() {
let acceleration = weighted_acceleration(&[(f64::MAX, 1.0), (-f64::MAX, 1.0), (0.0, 1.0)]);
assert!(acceleration.is_finite());
assert_close(acceleration, 0.0, 1e-12);
}
#[test]
fn multinomial_resample_preserves_the_total() {
let mut rng = StdRng::seed_from_u64(DEFAULT_SEED);
for _ in 0..1000 {
let (lo, hi, draws) = resample_edge_multinomial(3, 5, 2, &mut rng);
assert_eq!(lo + hi + draws, 10);
}
}
#[test]
fn multinomial_resample_is_deterministic_for_a_given_rng_state() {
let mut rng_a = StdRng::seed_from_u64(DEFAULT_SEED);
let mut rng_b = StdRng::seed_from_u64(DEFAULT_SEED);
for _ in 0..50 {
assert_eq!(
resample_edge_multinomial(4, 1, 0, &mut rng_a),
resample_edge_multinomial(4, 1, 0, &mut rng_b)
);
}
}
#[test]
fn multinomial_resample_proportions_converge_to_the_input_proportions() {
let mut rng = StdRng::seed_from_u64(DEFAULT_SEED);
let (lo_wins, hi_wins, draws, n) = (20u64, 50u64, 30u64, 100u64);
let resamples = 20_000;
let (mut sum_lo, mut sum_hi, mut sum_draws) = (0u64, 0u64, 0u64);
for _ in 0..resamples {
let (lo, hi, d) = resample_edge_multinomial(lo_wins, hi_wins, draws, &mut rng);
assert_eq!(lo + hi + d, n);
sum_lo += lo;
sum_hi += hi;
sum_draws += d;
}
let mean_lo_frac = sum_lo as f64 / (resamples as f64 * n as f64);
let mean_hi_frac = sum_hi as f64 / (resamples as f64 * n as f64);
let mean_draws_frac = sum_draws as f64 / (resamples as f64 * n as f64);
assert_close(mean_lo_frac, lo_wins as f64 / n as f64, 0.01);
assert_close(mean_hi_frac, hi_wins as f64 / n as f64, 0.01);
assert_close(mean_draws_frac, draws as f64 / n as f64, 0.01);
}
const SKEWED: [f64; 20] = [
0.05, 0.08, 0.12, 0.02, 0.15, 0.01, 0.30, 0.04, 0.06, 0.50, 0.03, 0.09, 0.11, 0.07, 0.02,
0.60, 0.04, 0.08, 0.10, 0.05,
];
#[test]
fn bca_deterministic_across_calls() {
let (lo1, hi1) = bootstrap_mean_diff_ci_bca(&SKEWED, 0.95, 2000, DEFAULT_SEED);
let (lo2, hi2) = bootstrap_mean_diff_ci_bca(&SKEWED, 0.95, 2000, DEFAULT_SEED);
assert_eq!(lo1, lo2);
assert_eq!(hi1, hi2);
}
#[test]
fn bca_brackets_true_mean() {
let diffs = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let (lo, hi) = bootstrap_mean_diff_ci_bca(&diffs, 0.95, 5000, DEFAULT_SEED);
assert!(
lo <= 3.0 && 3.0 <= hi,
"expected [{lo}, {hi}] to bracket 3.0"
);
}
#[test]
fn bca_single_sample_no_panic() {
let diffs = vec![2.5];
let (lo, hi) = bootstrap_mean_diff_ci_bca(&diffs, 0.95, 1000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert_eq!(lo, 2.5);
assert_eq!(hi, 2.5);
}
#[test]
fn bca_constant_data_no_panic() {
let diffs = vec![2.5; 5];
let (lo, hi) = bootstrap_mean_diff_ci_bca(&diffs, 0.95, 1000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert_eq!(lo, 2.5);
assert_eq!(hi, 2.5);
}
#[test]
fn bca_matches_fixture_at_fixed_seed() {
let (lo, hi) = bootstrap_mean_diff_ci_bca(&SKEWED, 0.95, 2000, DEFAULT_SEED);
assert_close(lo, 0.07850, 1e-4);
assert_close(hi, 0.22400, 1e-4);
let (lo, hi) = bootstrap_mean_diff_ci_bca(&SKEWED, 0.95, 10_000, DEFAULT_SEED);
assert_close(lo, 0.07550, 1e-4);
assert_close(hi, 0.22250, 1e-4);
}
#[test]
fn bca_differs_from_percentile_on_skewed_data() {
let (bca_lo, bca_hi) = bootstrap_mean_diff_ci_bca(&SKEWED, 0.95, 10_000, DEFAULT_SEED);
let (pct_lo, pct_hi) = bootstrap_mean_diff_ci(&SKEWED, 0.95, 10_000, DEFAULT_SEED);
assert_ne!((bca_lo, bca_hi), (pct_lo, pct_hi));
}
#[test]
fn bca_ties_do_not_panic() {
let diffs = vec![1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0, 0.0, 0.0, 1.0];
let (lo, hi) = bootstrap_mean_diff_ci_bca(&diffs, 0.95, 2000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert!(lo <= hi);
}
#[test]
fn bca_close_to_percentile_bounds_on_roughly_symmetric_data() {
let diffs = vec![-2.0, -1.0, 0.0, 1.0, 2.0];
let (bca_lo, bca_hi) = bootstrap_mean_diff_ci_bca(&diffs, 0.95, 20_000, DEFAULT_SEED);
let (pct_lo, pct_hi) = bootstrap_mean_diff_ci(&diffs, 0.95, 20_000, DEFAULT_SEED);
assert_close(bca_lo, pct_lo, 0.3);
assert_close(bca_hi, pct_hi, 0.3);
}
#[test]
fn basic_deterministic_across_calls() {
let diffs = vec![0.1, 0.2, -0.05, 0.3, 0.0, 0.15];
let (lo1, hi1) = bootstrap_mean_diff_ci_basic(&diffs, 0.95, 2000, DEFAULT_SEED);
let (lo2, hi2) = bootstrap_mean_diff_ci_basic(&diffs, 0.95, 2000, DEFAULT_SEED);
assert_eq!(lo1, lo2);
assert_eq!(hi1, hi2);
}
#[test]
fn basic_brackets_true_mean() {
let diffs = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let (lo, hi) = bootstrap_mean_diff_ci_basic(&diffs, 0.95, 5000, DEFAULT_SEED);
assert!(
lo <= 3.0 && 3.0 <= hi,
"expected [{lo}, {hi}] to bracket 3.0"
);
}
#[test]
fn basic_single_sample_no_panic() {
let diffs = vec![2.5];
let (lo, hi) = bootstrap_mean_diff_ci_basic(&diffs, 0.95, 1000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert_eq!(lo, 2.5);
assert_eq!(hi, 2.5);
}
#[test]
fn basic_equals_percentile_exactly_on_single_sample() {
let diffs = vec![2.5];
let basic = bootstrap_mean_diff_ci_basic(&diffs, 0.95, 1000, DEFAULT_SEED);
let percentile = bootstrap_mean_diff_ci(&diffs, 0.95, 1000, DEFAULT_SEED);
assert_eq!(basic, percentile);
}
#[test]
fn basic_equals_percentile_exactly_on_constant_data() {
let diffs = vec![2.5; 5];
let basic = bootstrap_mean_diff_ci_basic(&diffs, 0.95, 1000, DEFAULT_SEED);
let percentile = bootstrap_mean_diff_ci(&diffs, 0.95, 1000, DEFAULT_SEED);
assert_eq!(basic, percentile);
}
#[test]
fn basic_close_to_percentile_on_roughly_symmetric_data() {
let diffs = vec![-2.0, -1.0, 0.0, 1.0, 2.0];
let (basic_lo, basic_hi) = bootstrap_mean_diff_ci_basic(&diffs, 0.95, 20_000, DEFAULT_SEED);
let (pct_lo, pct_hi) = bootstrap_mean_diff_ci(&diffs, 0.95, 20_000, DEFAULT_SEED);
assert_close(basic_lo, pct_lo, 0.3);
assert_close(basic_hi, pct_hi, 0.3);
}
#[test]
fn basic_differs_from_percentile_on_skewed_data() {
let (basic_lo, basic_hi) =
bootstrap_mean_diff_ci_basic(&SKEWED, 0.95, 10_000, DEFAULT_SEED);
let (pct_lo, pct_hi) = bootstrap_mean_diff_ci(&SKEWED, 0.95, 10_000, DEFAULT_SEED);
assert_ne!((basic_lo, basic_hi), (pct_lo, pct_hi));
}
#[test]
fn basic_ties_do_not_panic() {
let diffs = vec![1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0, 0.0, 0.0, 1.0];
let (lo, hi) = bootstrap_mean_diff_ci_basic(&diffs, 0.95, 2000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert!(lo <= hi);
}
#[test]
fn basic_reflects_percentile_exactly() {
let effect = mean(&SKEWED);
let (perc_lo, perc_hi) = bootstrap_mean_diff_ci(&SKEWED, 0.95, 10_000, DEFAULT_SEED);
let (basic_lo, basic_hi) =
bootstrap_mean_diff_ci_basic(&SKEWED, 0.95, 10_000, DEFAULT_SEED);
assert_eq!(basic_lo, 2.0 * effect - perc_hi);
assert_eq!(basic_hi, 2.0 * effect - perc_lo);
}
#[test]
fn sample_variance_matches_a_hand_computed_example() {
let values = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0];
assert_close(sample_variance(&values), 32.0 / 7.0, 1e-9);
assert_close(sample_sd(&values), (32.0f64 / 7.0).sqrt(), 1e-9);
}
#[test]
fn sample_variance_of_identical_values_is_zero() {
assert_eq!(sample_variance(&[3.0, 3.0, 3.0]), 0.0);
assert_eq!(sample_sd(&[3.0, 3.0, 3.0]), 0.0);
}
#[test]
fn quantile_matches_hand_computed_type7_examples() {
let values: Vec<f64> = (1..=10).map(|v| v as f64).collect();
assert_close(quantile(&values, 0.9), 9.1, 1e-9);
assert_close(quantile(&[1.0, 2.0, 3.0, 4.0, 5.0], 0.5), 3.0, 1e-9);
assert_close(quantile(&[1.0, 2.0, 3.0, 4.0], 0.5), 2.5, 1e-9);
}
#[test]
fn quantile_ignores_input_order() {
let sorted = [1.0, 2.0, 3.0, 4.0, 5.0];
let shuffled = [3.0, 1.0, 5.0, 2.0, 4.0];
assert_eq!(quantile(&sorted, 0.5), quantile(&shuffled, 0.5));
}
#[test]
fn quantile_single_value_is_that_value() {
assert_eq!(quantile(&[7.0], 0.1), 7.0);
assert_eq!(quantile(&[7.0], 0.9), 7.0);
}
#[test]
fn quantile_ci_deterministic_across_calls() {
let diffs = vec![0.1, 0.2, -0.05, 0.3, 0.0, 0.15];
let (lo1, hi1) = bootstrap_quantile_diff_ci(&diffs, 0.5, 0.95, 2000, DEFAULT_SEED);
let (lo2, hi2) = bootstrap_quantile_diff_ci(&diffs, 0.5, 0.95, 2000, DEFAULT_SEED);
assert_eq!(lo1, lo2);
assert_eq!(hi1, hi2);
}
#[test]
fn quantile_ci_brackets_true_median() {
let diffs = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let (lo, hi) = bootstrap_quantile_diff_ci(&diffs, 0.5, 0.95, 5000, DEFAULT_SEED);
assert!(
lo <= 3.0 && 3.0 <= hi,
"expected [{lo}, {hi}] to bracket the true median 3.0"
);
}
#[test]
fn quantile_ci_single_sample_no_panic() {
let diffs = vec![2.5];
let (lo, hi) = bootstrap_quantile_diff_ci(&diffs, 0.5, 0.95, 1000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert_eq!(lo, 2.5);
assert_eq!(hi, 2.5);
}
#[test]
fn quantile_ci_ties_do_not_panic() {
let diffs = vec![1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0, 0.0, 0.0, 1.0];
let (lo, hi) = bootstrap_quantile_diff_ci(&diffs, 0.9, 0.95, 2000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert!(lo <= hi);
}
#[test]
fn quantile_ci_basic_reflects_percentile_exactly() {
let effect = quantile(&SKEWED, 0.9);
let (perc_lo, perc_hi) =
bootstrap_quantile_diff_ci(&SKEWED, 0.9, 0.95, 10_000, DEFAULT_SEED);
let (basic_lo, basic_hi) =
bootstrap_quantile_diff_ci_basic(&SKEWED, 0.9, 0.95, 10_000, DEFAULT_SEED);
assert_eq!(basic_lo, 2.0 * effect - perc_hi);
assert_eq!(basic_hi, 2.0 * effect - perc_lo);
}
#[test]
fn quantile_ci_basic_single_sample_no_panic() {
let diffs = vec![2.5];
let (lo, hi) = bootstrap_quantile_diff_ci_basic(&diffs, 0.5, 0.95, 1000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert_eq!(lo, 2.5);
assert_eq!(hi, 2.5);
}
#[test]
fn quantile_ci_bca_deterministic_across_calls() {
let (lo1, hi1) = bootstrap_quantile_diff_ci_bca(&SKEWED, 0.9, 0.95, 2000, DEFAULT_SEED);
let (lo2, hi2) = bootstrap_quantile_diff_ci_bca(&SKEWED, 0.9, 0.95, 2000, DEFAULT_SEED);
assert_eq!(lo1, lo2);
assert_eq!(hi1, hi2);
}
#[test]
fn quantile_ci_bca_single_sample_no_panic() {
let diffs = vec![2.5];
let (lo, hi) = bootstrap_quantile_diff_ci_bca(&diffs, 0.5, 0.95, 1000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert_eq!(lo, 2.5);
assert_eq!(hi, 2.5);
}
#[test]
fn quantile_ci_bca_constant_data_no_panic() {
let diffs = vec![2.5; 5];
let (lo, hi) = bootstrap_quantile_diff_ci_bca(&diffs, 0.5, 0.95, 1000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert_eq!(lo, 2.5);
assert_eq!(hi, 2.5);
}
#[test]
fn quantile_ci_bca_ties_do_not_panic() {
let diffs = vec![1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0, 0.0, 0.0, 1.0];
let (lo, hi) = bootstrap_quantile_diff_ci_bca(&diffs, 0.9, 0.95, 2000, DEFAULT_SEED);
assert!(lo.is_finite() && hi.is_finite());
assert!(lo <= hi);
}
#[test]
fn quantile_ci_bca_differs_from_percentile_on_skewed_data() {
let (bca_lo, bca_hi) =
bootstrap_quantile_diff_ci_bca(&SKEWED, 0.9, 0.95, 10_000, DEFAULT_SEED);
let (pct_lo, pct_hi) = bootstrap_quantile_diff_ci(&SKEWED, 0.9, 0.95, 10_000, DEFAULT_SEED);
assert_ne!((bca_lo, bca_hi), (pct_lo, pct_hi));
}
}