use std::sync::Arc;
use crate::device::WgpuDevice;
use crate::device::capabilities::WORKGROUP_SIZE_1D;
use crate::device::compute_pipeline::ComputeDispatch;
use crate::error::{BarracudaError, Result};
use crate::special::chi_squared_sf;
use bytemuck::{Pod, Zeroable};
pub const WGSL_FUSED_CHI_SQUARED_F64: &str =
include_str!("../shaders/special/fused_chi_squared_f64.wgsl");
#[derive(Debug, Clone)]
pub struct ChiSquaredTestResult {
pub statistic: f64,
pub p_value: f64,
pub degrees_of_freedom: usize,
}
#[repr(C)]
#[derive(Copy, Clone, Pod, Zeroable)]
struct GpuParams {
n: u32,
_pad1: u32,
_pad2: u32,
_pad3: u32,
}
pub struct FusedChiSquaredGpu;
impl FusedChiSquaredGpu {
pub fn execute(
device: Arc<WgpuDevice>,
observed: &[f64],
expected: &[f64],
) -> Result<ChiSquaredTestResult> {
if observed.len() != expected.len() {
return Err(BarracudaError::InvalidInput {
message: format!(
"observed and expected must have same length: {} vs {}",
observed.len(),
expected.len()
),
});
}
let n = observed.len();
if n == 0 {
return Err(BarracudaError::InvalidInput {
message: "observed and expected cannot be empty".to_string(),
});
}
for (i, &e) in expected.iter().enumerate() {
if e <= 0.0 {
return Err(BarracudaError::InvalidInput {
message: format!("expected[{i}] must be positive, got {e}"),
});
}
}
let n_workgroups = n.div_ceil(WORKGROUP_SIZE_1D as usize) as u32;
let observed_buf = device.create_buffer_f64_init("fused_chi2:observed", observed);
let expected_buf = device.create_buffer_f64_init("fused_chi2:expected", expected);
let partial_buf = device.create_buffer_f64(n_workgroups as usize)?;
let params = GpuParams {
n: n as u32,
_pad1: 0,
_pad2: 0,
_pad3: 0,
};
let params_buf = device.create_uniform_buffer("fused_chi2:params", ¶ms);
ComputeDispatch::new(&device, "fused_chi_squared_f64")
.shader(WGSL_FUSED_CHI_SQUARED_F64, "main")
.f64()
.storage_read(0, &observed_buf)
.storage_read(1, &expected_buf)
.storage_rw(2, &partial_buf)
.uniform(3, ¶ms_buf)
.dispatch(n_workgroups, 1, 1)
.submit()?;
let partials = device.read_f64_buffer(&partial_buf, n_workgroups as usize)?;
let statistic = partials.iter().sum::<f64>();
let df = n - 1;
let p_value = chi_squared_sf(statistic, df as f64)?;
Ok(ChiSquaredTestResult {
statistic,
p_value,
degrees_of_freedom: df,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::device::test_pool::get_test_device_if_f64_gpu_available;
#[tokio::test]
async fn test_fused_chi_squared_construction() {
let Some(device) = get_test_device_if_f64_gpu_available().await else {
return;
};
let observed = vec![10.0, 10.0, 10.0, 10.0, 10.0, 10.0];
let expected = vec![10.0; 6];
let result = FusedChiSquaredGpu::execute(device, &observed, &expected).unwrap();
assert_eq!(result.degrees_of_freedom, 5);
assert!((result.statistic - 0.0).abs() < 1e-10);
assert!(result.p_value > 0.99);
}
#[tokio::test]
async fn test_fused_chi_squared_dimension_check() {
let Some(device) = get_test_device_if_f64_gpu_available().await else {
return;
};
let observed = vec![10.0, 10.0];
let expected = vec![10.0, 10.0, 10.0];
let result = FusedChiSquaredGpu::execute(device, &observed, &expected);
assert!(result.is_err());
}
}