use crate::device::WgpuDevice;
use crate::device::capabilities::{DeviceCapabilities, Fp64Strategy};
use crate::device::pipeline_cache::{BindGroupLayoutSignature, create_f64_data_pipeline};
use crate::device::tensor_context::get_device_context;
use crate::error::Result;
use bytemuck::{Pod, Zeroable};
use std::sync::Arc;
const SHADER_FUSED: &str = include_str!("../shaders/stats/correlation_full_f64.wgsl");
const SHADER_FUSED_DF64: &str = include_str!("../shaders/stats/correlation_full_df64.wgsl");
const DF64_CORE: &str = include_str!("../shaders/math/df64_core.wgsl");
fn fused_shader_for_device(device: &WgpuDevice) -> &'static str {
let caps = DeviceCapabilities::from_device(device);
match caps.fp64_strategy() {
Fp64Strategy::Sovereign | Fp64Strategy::Native | Fp64Strategy::Concurrent => SHADER_FUSED,
Fp64Strategy::Hybrid => {
static DF64_COMBINED: std::sync::LazyLock<String> = std::sync::LazyLock::new(|| {
format!("enable f64;\n{DF64_CORE}\n{SHADER_FUSED_DF64}")
});
&DF64_COMBINED
}
}
}
#[repr(C)]
#[derive(Copy, Clone, Pod, Zeroable)]
struct Params {
n: u32,
_pad0: u32,
_pad1: u32,
_pad2: u32,
}
#[derive(Debug, Clone, Copy)]
pub struct CorrelationResult {
pub mean_x: f64,
pub mean_y: f64,
pub var_x: f64,
pub var_y: f64,
pub pearson_r: f64,
}
impl CorrelationResult {
#[must_use]
pub fn covariance(&self) -> f64 {
self.pearson_r * self.var_x.sqrt() * self.var_y.sqrt()
}
#[must_use]
pub fn r_squared(&self) -> f64 {
self.pearson_r * self.pearson_r
}
}
pub struct CorrelationF64 {
device: Arc<WgpuDevice>,
}
impl CorrelationF64 {
pub fn new(device: Arc<WgpuDevice>) -> Result<Self> {
Ok(Self { device })
}
pub fn correlation(&self, x: &[f64], y: &[f64]) -> Result<f64> {
Ok(self.correlation_full(x, y)?.pearson_r)
}
pub fn r_squared(&self, observed: &[f64], simulated: &[f64]) -> Result<f64> {
Ok(self.correlation_full(observed, simulated)?.r_squared())
}
pub fn covariance(&self, x: &[f64], y: &[f64]) -> Result<f64> {
Ok(self.correlation_full(x, y)?.covariance())
}
pub fn correlation_full(&self, x: &[f64], y: &[f64]) -> Result<CorrelationResult> {
if x.len() != y.len() || x.is_empty() {
return Ok(CorrelationResult {
mean_x: 0.0,
mean_y: 0.0,
var_x: 0.0,
var_y: 0.0,
pearson_r: 0.0,
});
}
let n = x.len();
let ctx = get_device_context(&self.device);
let x_buf = self
.device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("CorrFused X"),
contents: bytemuck::cast_slice(x),
usage: wgpu::BufferUsages::STORAGE,
});
let y_buf = self
.device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("CorrFused Y"),
contents: bytemuck::cast_slice(y),
usage: wgpu::BufferUsages::STORAGE,
});
let output_buf = ctx.acquire_pooled_output_f64(5);
let params = Params {
n: n as u32,
_pad0: 0,
_pad1: 0,
_pad2: 0,
};
let params_buf = self
.device
.create_uniform_buffer("CorrFused Params", ¶ms);
let layout_sig = BindGroupLayoutSignature {
read_only_buffers: 2,
read_write_buffers: 1,
uniform_buffers: 1,
};
let bind_group = ctx.get_or_create_bind_group(
layout_sig,
&[&x_buf, &y_buf, &output_buf, ¶ms_buf],
Some("CorrFused BG"),
);
let shader_src = fused_shader_for_device(&self.device);
let pipeline = create_f64_data_pipeline(
&self.device,
shader_src,
layout_sig,
"main",
Some("CorrFused Pipeline"),
);
ctx.record_operation(move |encoder| {
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("CorrFused Pass"),
timestamp_writes: None,
});
pass.set_pipeline(&pipeline);
pass.set_bind_group(0, Some(&*bind_group), &[]);
pass.dispatch_workgroups(1, 1, 1);
})?;
let result = self.device.read_buffer_f64(&output_buf, 5)?;
Ok(CorrelationResult {
mean_x: result[0],
mean_y: result[1],
var_x: result[2],
var_y: result[3],
pearson_r: result[4],
})
}
pub fn correlation_full_buffer(
&self,
x_buffer: &wgpu::Buffer,
y_buffer: &wgpu::Buffer,
n: usize,
) -> Result<CorrelationResult> {
if n == 0 {
return Ok(CorrelationResult {
mean_x: 0.0,
mean_y: 0.0,
var_x: 0.0,
var_y: 0.0,
pearson_r: 0.0,
});
}
let ctx = get_device_context(&self.device);
let output_buf = ctx.acquire_pooled_output_f64(5);
let params = Params {
n: n as u32,
_pad0: 0,
_pad1: 0,
_pad2: 0,
};
let params_buf = self
.device
.create_uniform_buffer("CorrFused:Buf Params", ¶ms);
let layout_sig = BindGroupLayoutSignature {
read_only_buffers: 2,
read_write_buffers: 1,
uniform_buffers: 1,
};
let bind_group = ctx.get_or_create_bind_group(
layout_sig,
&[x_buffer, y_buffer, &output_buf, ¶ms_buf],
Some("CorrFused:Buf BG"),
);
let shader_src = fused_shader_for_device(&self.device);
let pipeline = create_f64_data_pipeline(
&self.device,
shader_src,
layout_sig,
"main",
Some("CorrFused:Buf Pipeline"),
);
ctx.record_operation(move |encoder| {
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("CorrFused:Buf Pass"),
timestamp_writes: None,
});
pass.set_pipeline(&pipeline);
pass.set_bind_group(0, Some(&*bind_group), &[]);
pass.dispatch_workgroups(1, 1, 1);
})?;
let result = self.device.read_buffer_f64(&output_buf, 5)?;
Ok(CorrelationResult {
mean_x: result[0],
mean_y: result[1],
var_x: result[2],
var_y: result[3],
pearson_r: result[4],
})
}
pub fn correlation_buffer(
&self,
x_buffer: &wgpu::Buffer,
y_buffer: &wgpu::Buffer,
n: usize,
) -> Result<f64> {
Ok(self
.correlation_full_buffer(x_buffer, y_buffer, n)?
.pearson_r)
}
#[expect(
dead_code,
reason = "CPU reference implementation for GPU parity validation"
)]
fn correlation_cpu(x: &[f64], y: &[f64]) -> f64 {
let n = x.len();
if n == 0 {
return 0.0;
}
let mean_x: f64 = x.iter().sum::<f64>() / n as f64;
let mean_y: f64 = y.iter().sum::<f64>() / n as f64;
let mut cov = 0.0;
let mut var_x = 0.0;
let mut var_y = 0.0;
for (xi, yi) in x.iter().zip(y.iter()) {
let dx = xi - mean_x;
let dy = yi - mean_y;
cov = dx.mul_add(dy, cov);
var_x = dx.mul_add(dx, var_x);
var_y = dy.mul_add(dy, var_y);
}
let denom = (var_x * var_y).sqrt();
if denom < crate::tolerances::eps::SAFE_DIV {
return 0.0;
}
cov / denom
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::device::test_pool::get_test_device_if_f64_gpu_available;
#[tokio::test]
async fn test_correlation_perfect_positive() {
let Some(device) = get_test_device_if_f64_gpu_available().await else {
return;
};
let corr = CorrelationF64::new(device).unwrap();
let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let y = vec![2.0, 4.0, 6.0, 8.0, 10.0];
let result = corr.correlation(&x, &y).unwrap();
assert!(
(result - 1.0).abs() < 1e-10,
"Correlation should be 1.0, got {result}"
);
}
#[tokio::test]
async fn test_correlation_perfect_negative() {
let Some(device) = get_test_device_if_f64_gpu_available().await else {
return;
};
let corr = CorrelationF64::new(device).unwrap();
let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let y = vec![10.0, 8.0, 6.0, 4.0, 2.0];
let result = corr.correlation(&x, &y).unwrap();
assert!(
(result + 1.0).abs() < 1e-10,
"Correlation should be -1.0, got {result}"
);
}
#[tokio::test]
async fn test_correlation_self() {
let Some(device) = get_test_device_if_f64_gpu_available().await else {
return;
};
let corr = CorrelationF64::new(device).unwrap();
let x = vec![1.0, 3.0, 7.0, 2.5, 9.0];
let result = corr.correlation(&x, &x).unwrap();
assert!(
(result - 1.0).abs() < 1e-10,
"Self-correlation should be 1.0, got {result}"
);
}
#[tokio::test]
async fn test_correlation_uncorrelated() {
let Some(device) = get_test_device_if_f64_gpu_available().await else {
return;
};
let corr = CorrelationF64::new(device).unwrap();
let x = vec![1.0, 0.0, -1.0, 0.0];
let y = vec![0.0, 1.0, 0.0, -1.0];
let result = corr.correlation(&x, &y).unwrap();
assert!(
result.abs() < 1e-10,
"Orthogonal vectors should have correlation ~0, got {result}"
);
}
#[tokio::test]
async fn test_correlation_bounds() {
let Some(device) = get_test_device_if_f64_gpu_available().await else {
return;
};
let corr = CorrelationF64::new(device).unwrap();
let x = vec![2.3, 5.1, 1.2, 8.7, 3.3, 6.8, 4.2];
let y = vec![1.5, 4.2, 2.8, 7.1, 5.5, 3.9, 6.1];
let result = corr.correlation(&x, &y).unwrap();
assert!(
(-1.0..=1.0).contains(&result),
"Correlation must be in [-1, 1], got {result}"
);
}
#[tokio::test]
async fn test_correlation_full_returns_all_stats() {
let Some(device) = get_test_device_if_f64_gpu_available().await else {
return;
};
let corr = CorrelationF64::new(device).unwrap();
let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let y = vec![2.0, 4.0, 6.0, 8.0, 10.0];
let result = corr.correlation_full(&x, &y).unwrap();
assert!(
(result.mean_x - 3.0).abs() < 1e-10,
"mean_x = {}",
result.mean_x
);
assert!(
(result.mean_y - 6.0).abs() < 1e-10,
"mean_y = {}",
result.mean_y
);
assert!(
(result.var_x - 2.0).abs() < 1e-10,
"var_x = {}",
result.var_x
);
assert!(
(result.var_y - 8.0).abs() < 1e-10,
"var_y = {}",
result.var_y
);
assert!(
(result.pearson_r - 1.0).abs() < 1e-10,
"r = {}",
result.pearson_r
);
}
}