pub fn mean_value(values: &[f64]) -> f64 {
if values.is_empty() {
return f64::NAN; }
values.iter().sum::<f64>() / values.len() as f64
}
pub fn mean_and_stdev(values: &[f64]) -> Option<(f64, f64)> {
if values.is_empty() {
return None;
}
let mean = mean_value(values);
let variance = values.iter().map(|v| (v - mean).powi(2)).sum::<f64>() / values.len() as f64;
Some((mean, variance.sqrt()))
}
pub fn median(values: &[f64]) -> Option<f64> {
if values.is_empty() {
return None;
}
let mut sorted = values.to_vec();
sorted.sort_by(|a, b| a.total_cmp(b));
let n = sorted.len();
Some(if n.is_multiple_of(2) {
0.5 * (sorted[n / 2 - 1] + sorted[n / 2])
} else {
sorted[n / 2]
})
}
pub fn has_nan(values: &[f64]) -> bool {
values.iter().any(|v| v.is_nan())
}
pub fn are_all_finite(values: &[f64]) -> bool {
values.iter().all(|v| v.is_finite())
}
pub fn are_in_ascending_order(values: &[f64]) -> bool {
values.windows(2).all(|w| w[0] <= w[1])
}
pub fn are_in_descending_order(values: &[f64]) -> bool {
values.windows(2).all(|w| w[0] >= w[1])
}
pub fn sort_with_nan(values: &mut [f64]) {
values.sort_by(|a, b| {
if a.is_nan() {
std::cmp::Ordering::Greater
} else if b.is_nan() {
std::cmp::Ordering::Less
} else {
a.partial_cmp(b).unwrap()
}
});
}
pub fn sort_nan_panics(values: &mut [f64]) {
values.sort_by(|a, b| a.partial_cmp(b).unwrap());
}
pub fn sort_and_dedup(values: &mut Vec<f64>, tol: Option<f64>) {
let tol = tol.unwrap_or(f64::EPSILON);
values.sort_by(|a, b| a.partial_cmp(b).unwrap());
values.dedup_by(|a, b| (*a - *b).abs() < tol);
}
#[cfg(test)]
mod tests {
use super::*;
use approx::assert_relative_eq;
#[test]
fn median_handles_both_parities() {
assert_eq!(median(&[3.0, 1.0, 2.0]), Some(2.0));
assert_eq!(median(&[4.0, 1.0, 3.0, 2.0]), Some(2.5));
assert_eq!(median(&[]), None);
}
#[test]
fn mean_value_empty_returns_nan() {
assert!(mean_value(&[]).is_nan());
}
#[test]
fn mean_value_single_element() {
assert_relative_eq!(mean_value(&[7.0]), 7.0, epsilon = 1e-12);
}
#[test]
fn mean_value_uniform_values() {
assert_relative_eq!(mean_value(&[3.0, 3.0, 3.0]), 3.0, epsilon = 1e-12);
}
#[test]
fn mean_value_typical() {
assert_relative_eq!(mean_value(&[1.0, 2.0, 3.0, 4.0]), 2.5, epsilon = 1e-12);
}
#[test]
fn mean_and_stdev_empty_returns_none() {
assert!(mean_and_stdev(&[]).is_none());
}
#[test]
fn mean_and_stdev_single_element_has_zero_stdev() {
let (mean, stdev) = mean_and_stdev(&[5.0]).unwrap();
assert_relative_eq!(mean, 5.0, epsilon = 1e-12);
assert_relative_eq!(stdev, 0.0, epsilon = 1e-12);
}
#[test]
fn mean_and_stdev_uniform_values_have_zero_stdev() {
let (mean, stdev) = mean_and_stdev(&[4.0, 4.0, 4.0]).unwrap();
assert_relative_eq!(mean, 4.0, epsilon = 1e-12);
assert_relative_eq!(stdev, 0.0, epsilon = 1e-12);
}
#[test]
fn mean_and_stdev_known_values() {
let (mean, stdev) = mean_and_stdev(&[2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]).unwrap();
assert_relative_eq!(mean, 5.0, epsilon = 1e-12);
assert_relative_eq!(stdev, 2.0, epsilon = 1e-12);
}
#[test]
fn has_nan_test() {
let values = vec![1.0, f64::NAN, 3.0];
assert!(has_nan(&values));
let values = vec![1.0, 2.0, 3.0];
assert!(!has_nan(&values));
}
#[test]
fn are_all_finite_test() {
let values = vec![1.0, 2.0, 3.0];
assert!(are_all_finite(&values));
let values = vec![1.0, f64::INFINITY, 3.0];
assert!(!are_all_finite(&values));
}
#[test]
fn are_in_ascending_order_test() {
let values = vec![1.0, 2.0, 3.0];
assert!(are_in_ascending_order(&values));
let values = vec![1.0, 3.0, 2.0];
assert!(!are_in_ascending_order(&values));
}
#[test]
fn are_in_descending_order_test() {
let values = vec![3.0, 2.0, 1.0];
assert!(are_in_descending_order(&values));
let values = vec![1.0, 3.0, 2.0];
assert!(!are_in_descending_order(&values));
}
#[test]
fn sort_with_nan_test() {
let mut values = vec![3.0, f64::NAN, 1.0];
sort_with_nan(&mut values);
assert_eq!(values[0], 1.0);
assert_eq!(values[1], 3.0);
assert!(values[2].is_nan());
}
#[test]
fn sort_nan_panics_test() {
let mut values = vec![3.0, 5.0, 1.0];
sort_nan_panics(&mut values);
assert_eq!(values, vec![1.0, 3.0, 5.0]);
}
#[test]
#[should_panic]
fn sort_nan_panics_with_nan_test() {
let mut values = vec![3.0, f64::NAN, 1.0];
sort_nan_panics(&mut values);
}
}