#[must_use]
pub fn cumulative_pass(probs_in_rung_order: &[f64]) -> Option<Vec<f64>> {
if probs_in_rung_order.is_empty() {
return None;
}
if probs_in_rung_order
.iter()
.any(|p| !p.is_finite() || *p < 0.0)
{
return None;
}
let sum: f64 = probs_in_rung_order.iter().sum();
if sum <= 0.0 {
return None;
}
let mut running = 0.0;
let mut out: Vec<f64> = probs_in_rung_order
.iter()
.map(|p| {
running += p / sum;
running.clamp(0.0, 1.0)
})
.collect();
if let Some(last) = out.last_mut() {
*last = 1.0;
}
Some(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_empty() {
assert_eq!(cumulative_pass(&[]), None);
}
#[test]
fn rejects_negative() {
assert_eq!(cumulative_pass(&[0.5, -0.1, 0.6]), None);
}
#[test]
fn rejects_non_finite() {
assert_eq!(cumulative_pass(&[0.5, f64::NAN, 0.5]), None);
assert_eq!(cumulative_pass(&[0.5, f64::INFINITY]), None);
}
#[test]
fn rejects_all_zero() {
assert_eq!(cumulative_pass(&[0.0, 0.0, 0.0]), None);
}
#[test]
fn normalizes_and_cumsums() {
let out = cumulative_pass(&[0.2, 0.3, 0.5]).unwrap();
assert_eq!(out.len(), 3);
assert!((out[0] - 0.2).abs() < 1e-12);
assert!((out[1] - 0.5).abs() < 1e-12);
assert_eq!(out[2], 1.0);
}
#[test]
fn normalizes_unnormalized_input() {
let out = cumulative_pass(&[1.0, 1.0, 2.0]).unwrap();
assert!((out[0] - 0.25).abs() < 1e-12);
assert!((out[1] - 0.5).abs() < 1e-12);
assert_eq!(out[2], 1.0);
}
#[test]
fn is_monotone_non_decreasing() {
let out = cumulative_pass(&[0.05, 0.15, 0.3, 0.5]).unwrap();
assert!(out.windows(2).all(|w| w[1] >= w[0]));
}
#[test]
fn single_rung_is_certain() {
let out = cumulative_pass(&[0.37]).unwrap();
assert_eq!(out, vec![1.0]);
}
#[test]
fn last_is_exactly_one() {
let out = cumulative_pass(&[1e-10, 1e-10, 1e-10]).unwrap();
assert_eq!(*out.last().unwrap(), 1.0);
}
}