use crate::error::{BarracudaError, Result};
use crate::special::gamma::{ln_gamma, regularized_gamma_p, regularized_gamma_q};
pub const WGSL_CHI_SQUARED_F64: &str = include_str!("../shaders/special/chi_squared_f64.wgsl");
pub const WGSL_CHI2_DECOMPOSED_F64: &str =
include_str!("../shaders/special/chi2_decomposed_f64.wgsl");
pub fn chi_squared_pdf(x: f64, k: f64) -> Result<f64> {
if k <= 0.0 {
return Err(BarracudaError::InvalidInput {
message: format!("chi_squared_pdf requires k > 0, got {k}"),
});
}
if x < 0.0 {
return Err(BarracudaError::InvalidInput {
message: format!("chi_squared_pdf requires x >= 0, got {x}"),
});
}
if x == 0.0 {
if k < 2.0 {
return Ok(f64::INFINITY);
} else if (k - 2.0).abs() < 1e-10 {
return Ok(0.5);
}
return Ok(0.0);
}
let half_k = k / 2.0;
let ln_pdf =
(half_k - 1.0).mul_add(x.ln(), -(x / 2.0)) - half_k * 2.0_f64.ln() - ln_gamma(half_k)?;
Ok(ln_pdf.exp())
}
pub fn chi_squared_cdf(x: f64, k: f64) -> Result<f64> {
if k <= 0.0 {
return Err(BarracudaError::InvalidInput {
message: format!("chi_squared_cdf requires k > 0, got {k}"),
});
}
if x < 0.0 {
return Ok(0.0);
}
regularized_gamma_p(k / 2.0, x / 2.0)
}
pub fn chi_squared_sf(x: f64, k: f64) -> Result<f64> {
if k <= 0.0 {
return Err(BarracudaError::InvalidInput {
message: format!("chi_squared_sf requires k > 0, got {k}"),
});
}
if x < 0.0 {
return Ok(1.0);
}
regularized_gamma_q(k / 2.0, x / 2.0)
}
pub fn chi_squared_quantile(p: f64, k: f64) -> Result<f64> {
if k <= 0.0 {
return Err(BarracudaError::InvalidInput {
message: format!("chi_squared_quantile requires k > 0, got {k}"),
});
}
if p <= 0.0 || p >= 1.0 {
return Err(BarracudaError::InvalidInput {
message: format!("chi_squared_quantile requires 0 < p < 1, got {p}"),
});
}
const BISECTION_LOWER_BRACKET: f64 = 0.001;
let mut a = BISECTION_LOWER_BRACKET;
let mut b = k.max(1.0);
for _ in 0..50 {
let cdf_b = chi_squared_cdf(b, k)?;
if cdf_b > p {
break;
}
b *= 2.0;
}
const MAX_ITER: usize = 100;
const TOL: f64 = 1e-10;
for _ in 0..MAX_ITER {
let mid = 0.5 * (a + b);
if (b - a) < TOL * mid {
return Ok(mid);
}
let cdf_mid = chi_squared_cdf(mid, k)?;
if cdf_mid < p {
a = mid;
} else {
b = mid;
}
}
Ok(0.5 * (a + b))
}
#[must_use]
pub fn chi_squared_mean(k: f64) -> f64 {
k
}
#[must_use]
pub fn chi_squared_variance(k: f64) -> f64 {
2.0 * k
}
#[must_use]
pub fn chi_squared_mode(k: f64) -> f64 {
(k - 2.0).max(0.0)
}
pub fn chi_squared_f64(observed: &[f64], expected: &[f64]) -> Result<f64> {
chi_squared_statistic(observed, expected)
}
pub fn chi_squared_statistic(observed: &[f64], expected: &[f64]) -> Result<f64> {
if observed.len() != expected.len() {
return Err(BarracudaError::InvalidInput {
message: format!(
"observed and expected must have same length: {} vs {}",
observed.len(),
expected.len()
),
});
}
let mut chi2 = 0.0;
for (o, e) in observed.iter().zip(expected.iter()) {
if *e <= 0.0 {
return Err(BarracudaError::InvalidInput {
message: "expected frequencies must be positive".to_string(),
});
}
chi2 += (o - e).powi(2) / e;
}
Ok(chi2)
}
pub fn chi_squared_test(observed: &[f64], expected: &[f64]) -> Result<(f64, f64, usize)> {
let chi2 = chi_squared_statistic(observed, expected)?;
let df = observed.len() - 1;
let p_value = chi_squared_sf(chi2, df as f64)?;
Ok((chi2, p_value, df))
}
#[cfg(feature = "gpu")]
pub struct ChiSquaredBatchGpu {
device: std::sync::Arc<crate::device::WgpuDevice>,
}
#[derive(Debug, Clone)]
pub struct ChiSquaredBatchResult {
pub pdf: Vec<f64>,
pub cdf: Vec<f64>,
}
#[cfg(feature = "gpu")]
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct Chi2GpuParams {
size: u32,
df: u32,
}
#[cfg(feature = "gpu")]
impl ChiSquaredBatchGpu {
pub fn new(device: std::sync::Arc<crate::device::WgpuDevice>) -> Result<Self> {
Ok(Self { device })
}
pub fn dispatch(&self, x_values: &[f64], df: u32) -> Result<ChiSquaredBatchResult> {
use crate::device::capabilities::WORKGROUP_SIZE_1D;
use crate::device::compute_pipeline::ComputeDispatch;
let n = x_values.len();
let input_buf = self.device.create_buffer_f64_init("chi2:input", x_values);
let pdf_buf = self.device.create_buffer_f64(n)?;
let cdf_buf = self.device.create_buffer_f64(n)?;
let params = Chi2GpuParams { size: n as u32, df };
let params_buf = self.device.create_uniform_buffer("chi2:params", ¶ms);
let wg = (n as u32).div_ceil(WORKGROUP_SIZE_1D);
ComputeDispatch::new(&self.device, "chi_squared_f64")
.shader(WGSL_CHI_SQUARED_F64, "main")
.f64()
.storage_read(0, &input_buf)
.storage_rw(1, &pdf_buf)
.uniform(2, ¶ms_buf)
.storage_rw(3, &cdf_buf)
.dispatch(wg, 1, 1)
.submit()?;
let pdf = self.device.read_f64_buffer(&pdf_buf, n)?;
let cdf = self.device.read_f64_buffer(&cdf_buf, n)?;
Ok(ChiSquaredBatchResult { pdf, cdf })
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_chi_squared_pdf_k1() {
let pdf = chi_squared_pdf(1.0, 1.0).unwrap();
assert!((pdf - 0.2420).abs() < 0.01);
}
#[test]
fn test_chi_squared_pdf_k2() {
let pdf = chi_squared_pdf(2.0, 2.0).unwrap();
let expected = (-1.0_f64).exp() / 2.0;
assert!((pdf - expected).abs() < 1e-10);
}
#[test]
fn test_chi_squared_cdf_k2() {
let cdf = chi_squared_cdf(2.0, 2.0).unwrap();
let expected = 1.0 - (-1.0_f64).exp();
assert!((cdf - expected).abs() < 1e-10);
}
#[test]
fn test_chi_squared_cdf_critical_values() {
let cdf = chi_squared_cdf(3.841, 1.0).unwrap();
assert!((cdf - 0.95).abs() < 0.01);
let cdf = chi_squared_cdf(5.991, 2.0).unwrap();
assert!((cdf - 0.95).abs() < 0.01);
let cdf = chi_squared_cdf(18.31, 10.0).unwrap();
assert!((cdf - 0.95).abs() < 0.01);
}
#[test]
fn test_chi_squared_sf_complement() {
let x = 5.0;
let k = 3.0;
let cdf = chi_squared_cdf(x, k).unwrap();
let sf = chi_squared_sf(x, k).unwrap();
assert!((cdf + sf - 1.0).abs() < 1e-10);
}
#[test]
fn test_chi_squared_quantile_inverse_cdf() {
for k in [2.0, 5.0, 10.0] {
for p in [0.5, 0.9, 0.95] {
let x = chi_squared_quantile(p, k).unwrap();
let p_check = chi_squared_cdf(x, k).unwrap();
assert!(
(p - p_check).abs() < 1e-4,
"Failed for k={k}, p={p}: got p_check={p_check}"
);
}
}
}
#[test]
fn test_chi_squared_quantile_known_values() {
let x = chi_squared_quantile(0.95, 1.0).unwrap();
assert!((x - 3.841).abs() < 0.01);
let x = chi_squared_quantile(0.95, 2.0).unwrap();
assert!((x - 5.991).abs() < 0.01);
}
#[test]
fn test_chi_squared_moments() {
let k = 5.0;
assert_eq!(chi_squared_mean(k), 5.0);
assert_eq!(chi_squared_variance(k), 10.0);
assert_eq!(chi_squared_mode(k), 3.0);
}
#[test]
fn test_chi_squared_f64_alias() {
let observed = vec![16.0, 18.0, 16.0, 14.0, 12.0, 12.0];
let expected = vec![14.67, 14.67, 14.67, 14.67, 14.67, 14.67];
let via_f64 = chi_squared_f64(&observed, &expected).unwrap();
let via_stat = chi_squared_statistic(&observed, &expected).unwrap();
assert!((via_f64 - via_stat).abs() < 1e-14);
let fair = chi_squared_f64(&[10.0; 6], &[10.0; 6]).unwrap();
assert!((fair - 0.0).abs() < 1e-14);
}
#[test]
fn test_chi_squared_statistic() {
let observed = vec![10.0, 10.0, 10.0, 10.0, 10.0, 10.0];
let expected = vec![10.0; 6];
let chi2 = chi_squared_statistic(&observed, &expected).unwrap();
assert!((chi2 - 0.0).abs() < 1e-10);
}
#[test]
fn test_chi_squared_test_fair_die() {
let observed = vec![10.0, 9.0, 11.0, 10.0, 10.0, 10.0];
let expected = vec![10.0; 6];
let (chi2, p_value, df) = chi_squared_test(&observed, &expected).unwrap();
assert_eq!(df, 5);
assert!(chi2 < 1.0); assert!(p_value > 0.9); }
#[test]
fn test_chi_squared_test_unfair_die() {
let observed = vec![5.0, 5.0, 5.0, 5.0, 5.0, 35.0];
let expected = vec![10.0; 6];
let (chi2, p_value, df) = chi_squared_test(&observed, &expected).unwrap();
assert_eq!(df, 5);
assert!(chi2 > 50.0); assert!(p_value < 0.01); }
#[test]
fn test_chi_squared_invalid_inputs() {
assert!(chi_squared_pdf(-1.0, 2.0).is_err());
assert!(chi_squared_cdf(1.0, 0.0).is_err());
assert!(chi_squared_quantile(0.0, 2.0).is_err());
assert!(chi_squared_quantile(1.0, 2.0).is_err());
}
}