const COUNT_EPSILON: f64 = 1e-3;
type Pdf = Vec<(f64, f64)>;
fn regularize(counts: &[u64]) -> Vec<f64> {
counts
.iter()
.map(|&c| if c == 0 { COUNT_EPSILON } else { c as f64 })
.collect()
}
fn results_to_pdf(counts: &[u64]) -> (f64, Pdf) {
let regularized = regularize(counts);
let n: f64 = regularized.iter().sum();
let len = counts.len();
let pdf = regularized
.iter()
.enumerate()
.map(|(i, &r)| (i as f64 / (len - 1) as f64, r / n))
.collect();
(n, pdf)
}
fn secular(shifted: &[(f64, f64)]) -> f64 {
let values = shifted.iter().map(|&(a, _)| a);
let v = values.clone().fold(f64::INFINITY, f64::min);
let w = values.fold(f64::NEG_INFINITY, f64::max);
debug_assert!(
v < 0.0 && w > 0.0,
"secular equation requires shifted support straddling zero"
);
let f = |x: f64| -> f64 { shifted.iter().map(|&(a, p)| p * a / (1.0 + x * a)).sum() };
let epsilon = 1e-9;
let mut lo = -1.0 / w + epsilon;
let mut hi = -1.0 / v - epsilon;
for _ in 0..100 {
let mid = (lo + hi) / 2.0;
if f(mid) > 0.0 { lo = mid } else { hi = mid }
}
(lo + hi) / 2.0
}
fn mle_expected(pdf: &Pdf, s: f64) -> Pdf {
let shifted: Vec<(f64, f64)> = pdf.iter().map(|&(a, p)| (a - s, p)).collect();
let x = secular(&shifted);
pdf.iter()
.map(|&(a, p)| (a, p / (1.0 + x * (a - s))))
.collect()
}
fn llr_per_pair(pdf: &Pdf, s0: f64, s1: f64) -> f64 {
let pdf0 = mle_expected(pdf, s0);
let pdf1 = mle_expected(pdf, s1);
pdf.iter()
.zip(pdf0.iter())
.zip(pdf1.iter())
.map(|((&(_, p), &(_, p0)), &(_, p1))| p * (p1.ln() - p0.ln()))
.sum()
}
fn generalized_llr(counts: &[u64], elo0: f64, elo1: f64) -> f64 {
let (n, pdf) = results_to_pdf(counts);
let s0 = crate::stats::sprt::score_from_elo(elo0);
let s1 = crate::stats::sprt::score_from_elo(elo1);
n * llr_per_pair(&pdf, s0, s1)
}
pub(crate) fn pentanomial_llr(elo0: f64, elo1: f64, counts: &[u64; 5]) -> f64 {
generalized_llr(counts, elo0, elo1)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::stats::sprt::{llr_delta, score_from_elo};
fn assert_close(actual: f64, expected: f64, tol: f64) {
assert!(
(actual - expected).abs() < tol,
"expected {expected}, got {actual}"
);
}
#[test]
fn two_category_reduces_to_the_plain_wald_llr() {
let (elo0, elo1) = (0.0, 20.0);
let (loss, win) = (300u64, 700u64);
let computed = generalized_llr(&[loss, win], elo0, elo1);
let (p0, p1) = (score_from_elo(elo0), score_from_elo(elo1));
let wald_llr =
win as f64 * llr_delta(true, p0, p1) + loss as f64 * llr_delta(false, p0, p1);
assert_close(computed, wald_llr, 1e-6);
}
#[test]
fn two_category_reduction_holds_with_a_lopsided_empirical_split() {
let (elo0, elo1) = (-10.0, 15.0);
let (loss, win) = (950u64, 50u64);
let computed = generalized_llr(&[loss, win], elo0, elo1);
let (p0, p1) = (score_from_elo(elo0), score_from_elo(elo1));
let wald_llr =
win as f64 * llr_delta(true, p0, p1) + loss as f64 * llr_delta(false, p0, p1);
assert_close(computed, wald_llr, 1e-6);
}
#[test]
fn matches_fishtest_llr_logistic_reference_value() {
let counts = [5u64, 20, 50, 20, 5];
let llr = pentanomial_llr(0.0, 10.0, &counts);
assert_close(llr, -0.206_511_723, 1e-6);
}
#[test]
fn matches_fishtest_llr_logistic_reference_value_draw_heavy() {
let counts = [2u64, 10, 70, 10, 2];
let llr = pentanomial_llr(0.0, 20.0, &counts);
assert_close(llr, -1.523_230_410, 1e-6);
}
#[test]
fn all_mass_in_one_bucket_does_not_panic_or_produce_nan() {
for counts in [[100u64, 0, 0, 0, 0], [0, 0, 0, 0, 100], [0, 100, 0, 0, 0]] {
let llr = pentanomial_llr(0.0, 20.0, &counts);
assert!(llr.is_finite(), "counts {counts:?} produced non-finite LLR");
}
}
#[test]
fn single_pair_of_each_kind_does_not_panic() {
for i in 0..5 {
let mut counts = [0u64; 5];
counts[i] = 1;
let llr = pentanomial_llr(0.0, 20.0, &counts);
assert!(llr.is_finite(), "bucket {i} produced non-finite LLR");
}
}
#[test]
fn stronger_candidate_evidence_drives_llr_upward() {
let balanced = pentanomial_llr(0.0, 20.0, &[10, 20, 40, 20, 10]);
let candidate_favored = pentanomial_llr(0.0, 20.0, &[2, 8, 20, 30, 40]);
assert!(candidate_favored > balanced);
}
}