mod wgsl_templates;
use std::marker::PhantomData;
use crate::error::{BarracudaError, Result};
use wgsl_templates::{wgsl_rk4_template, wgsl_rk4_template_universal};
pub trait OdeSystem {
const N_VARS: usize;
const N_PARAMS: usize;
fn system_name() -> &'static str;
fn wgsl_derivative() -> &'static str;
#[must_use]
fn wgsl_derivative_universal() -> Option<&'static str> {
None
}
fn cpu_derivative(_t: f64, state: &[f64], params: &[f64]) -> Vec<f64>;
}
#[derive(Debug, Clone)]
pub struct OdeTrajectory {
pub states: Vec<f64>,
pub times: Vec<f64>,
pub n_vars: usize,
pub batch_size: usize,
}
impl OdeTrajectory {
#[must_use]
pub fn time_series(&self, batch: usize, var: usize) -> (Vec<f64>, Vec<f64>) {
let n_snapshots = self.times.len();
let stride = self.batch_size * self.n_vars;
let mut values = Vec::with_capacity(n_snapshots);
for step in 0..n_snapshots {
values.push(self.states[step * stride + batch * self.n_vars + var]);
}
(self.times.clone(), values)
}
#[must_use]
pub fn state_at(&self, batch: usize, t: f64) -> Option<Vec<f64>> {
if self.times.is_empty() {
return None;
}
let t_start = self.times[0];
let t_end = *self.times.last()?;
if t < t_start || t > t_end {
return None;
}
let idx = self
.times
.partition_point(|&ti| ti < t)
.min(self.times.len() - 1);
if idx == 0 || (self.times[idx] - t).abs() < f64::EPSILON {
let stride = self.batch_size * self.n_vars;
let off = idx * stride + batch * self.n_vars;
return Some(self.states[off..off + self.n_vars].to_vec());
}
let t0 = self.times[idx - 1];
let t1 = self.times[idx];
let frac = (t - t0) / (t1 - t0);
let stride = self.batch_size * self.n_vars;
let off0 = (idx - 1) * stride + batch * self.n_vars;
let off1 = idx * stride + batch * self.n_vars;
let mut state = vec![0.0; self.n_vars];
for (i, s) in state.iter_mut().enumerate() {
*s = self.states[off0 + i].mul_add(1.0 - frac, self.states[off1 + i] * frac);
}
Some(state)
}
#[must_use]
pub fn n_snapshots(&self) -> usize {
self.times.len()
}
#[must_use]
pub fn final_state(&self, batch: usize) -> Option<Vec<f64>> {
if self.times.is_empty() {
return None;
}
let stride = self.batch_size * self.n_vars;
let last = (self.times.len() - 1) * stride + batch * self.n_vars;
Some(self.states[last..last + self.n_vars].to_vec())
}
}
#[must_use]
pub struct BatchedOdeRK4<S: OdeSystem> {
_marker: PhantomData<S>,
}
impl<S: OdeSystem> BatchedOdeRK4<S> {
#[must_use]
pub fn generate_shader() -> String {
wgsl_rk4_template(S::N_VARS, S::N_PARAMS, S::wgsl_derivative())
}
#[must_use]
pub fn generate_shader_universal() -> Option<String> {
S::wgsl_derivative_universal()
.map(|deriv| wgsl_rk4_template_universal(S::N_VARS, S::N_PARAMS, deriv))
}
pub fn integrate_cpu(
initial_states: &[f64],
params: &[f64],
dt: f64,
n_steps: usize,
batch_size: usize,
) -> Result<Vec<f64>> {
let n_vars = S::N_VARS;
let n_params = S::N_PARAMS;
if initial_states.len() != batch_size * n_vars {
return Err(BarracudaError::InvalidInput {
message: format!(
"initial_states: expected {} ([batch_size×{}]), got {}",
batch_size * n_vars,
n_vars,
initial_states.len()
),
});
}
if params.len() != batch_size * n_params {
return Err(BarracudaError::InvalidInput {
message: format!(
"params: expected {} ([batch_size×{}]), got {}",
batch_size * n_params,
n_params,
params.len()
),
});
}
let mut state: Vec<f64> = initial_states.to_vec();
let mut t = 0.0_f64;
let mut y_buf = vec![0.0_f64; n_vars];
let mut stage_buf = vec![0.0_f64; n_vars];
for _step in 0..n_steps {
for b in 0..batch_size {
let s_off = b * n_vars;
let p = ¶ms[b * n_params..b * n_params + n_params];
y_buf.copy_from_slice(&state[s_off..s_off + n_vars]);
let k1 = S::cpu_derivative(t, &y_buf, p);
for i in 0..n_vars {
stage_buf[i] = (0.5 * dt).mul_add(k1[i], y_buf[i]);
}
let k2 = S::cpu_derivative(0.5f64.mul_add(dt, t), &stage_buf, p);
for i in 0..n_vars {
stage_buf[i] = (0.5 * dt).mul_add(k2[i], y_buf[i]);
}
let k3 = S::cpu_derivative(0.5f64.mul_add(dt, t), &stage_buf, p);
for i in 0..n_vars {
stage_buf[i] = dt.mul_add(k3[i], y_buf[i]);
}
let k4 = S::cpu_derivative(t + dt, &stage_buf, p);
let sixth = 1.0 / 6.0;
for i in 0..n_vars {
state[s_off + i] = (dt * sixth).mul_add(
2.0f64.mul_add(k3[i], 2.0f64.mul_add(k2[i], k1[i])) + k4[i],
y_buf[i],
);
}
}
t += dt;
}
Ok(state)
}
pub fn integrate_cpu_trajectory(
initial_states: &[f64],
params: &[f64],
dt: f64,
n_steps: usize,
batch_size: usize,
) -> Result<OdeTrajectory> {
let n_vars = S::N_VARS;
let n_params = S::N_PARAMS;
if initial_states.len() != batch_size * n_vars {
return Err(BarracudaError::InvalidInput {
message: format!(
"initial_states: expected {} ([batch_size×{n_vars}]), got {}",
batch_size * n_vars,
initial_states.len()
),
});
}
if params.len() != batch_size * n_params {
return Err(BarracudaError::InvalidInput {
message: format!(
"params: expected {} ([batch_size×{n_params}]), got {}",
batch_size * n_params,
params.len()
),
});
}
let stride = batch_size * n_vars;
let n_snapshots = n_steps + 1;
let mut all_states = Vec::with_capacity(n_snapshots * stride);
let mut times = Vec::with_capacity(n_snapshots);
let mut state: Vec<f64> = initial_states.to_vec();
all_states.extend_from_slice(&state);
times.push(0.0);
let mut t = 0.0_f64;
let mut y_buf = vec![0.0_f64; n_vars];
let mut stage_buf = vec![0.0_f64; n_vars];
for _step in 0..n_steps {
for b in 0..batch_size {
let s_off = b * n_vars;
let p = ¶ms[b * n_params..b * n_params + n_params];
y_buf.copy_from_slice(&state[s_off..s_off + n_vars]);
let k1 = S::cpu_derivative(t, &y_buf, p);
for i in 0..n_vars {
stage_buf[i] = (0.5 * dt).mul_add(k1[i], y_buf[i]);
}
let k2 = S::cpu_derivative(0.5f64.mul_add(dt, t), &stage_buf, p);
for i in 0..n_vars {
stage_buf[i] = (0.5 * dt).mul_add(k2[i], y_buf[i]);
}
let k3 = S::cpu_derivative(0.5f64.mul_add(dt, t), &stage_buf, p);
for i in 0..n_vars {
stage_buf[i] = dt.mul_add(k3[i], y_buf[i]);
}
let k4 = S::cpu_derivative(t + dt, &stage_buf, p);
let sixth = 1.0 / 6.0;
for i in 0..n_vars {
state[s_off + i] = (dt * sixth).mul_add(
2.0f64.mul_add(k3[i], 2.0f64.mul_add(k2[i], k1[i])) + k4[i],
y_buf[i],
);
}
}
t += dt;
all_states.extend_from_slice(&state);
times.push(t);
}
Ok(OdeTrajectory {
states: all_states,
times,
n_vars,
batch_size,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
struct ExponentialDecay;
impl OdeSystem for ExponentialDecay {
const N_VARS: usize = 1;
const N_PARAMS: usize = 1;
fn system_name() -> &'static str {
"exponential_decay"
}
fn wgsl_derivative() -> &'static str {
r"
fn deriv(state: array<f64, 1>, params: array<f64, 1>, t: f64) -> array<f64, 1> {
let k = params[0];
var dy: array<f64, 1>;
dy[0] = -k * state[0];
return dy;
}
"
}
fn wgsl_derivative_universal() -> Option<&'static str> {
Some(
r"
fn deriv(state: array<Scalar, 1>, params: array<Scalar, 1>, t: Scalar) -> array<Scalar, 1> {
let k = params[0];
var dy: array<Scalar, 1>;
dy[0] = op_neg(op_mul(k, state[0]));
return dy;
}
",
)
}
fn cpu_derivative(_t: f64, state: &[f64], params: &[f64]) -> Vec<f64> {
let k = params[0];
vec![-k * state[0]]
}
}
#[test]
fn test_exponential_decay_cpu_matches_analytical() {
let k = 1.0_f64;
let t_final = 1.0_f64;
let dt = 0.001_f64;
let n_steps = (t_final / dt).round() as usize;
let initial = vec![1.0];
let params = vec![k];
let result =
BatchedOdeRK4::<ExponentialDecay>::integrate_cpu(&initial, ¶ms, dt, n_steps, 1)
.expect("integrate_cpu should succeed");
let expected = (-k * t_final).exp();
assert!(
(result[0] - expected).abs() < 1e-6,
"y(1) = {}, expected {}",
result[0],
expected
);
}
#[test]
fn test_exponential_decay_batched() {
let initial = vec![1.0, 2.0]; let params = vec![1.0, 0.5]; let dt = 0.01;
let n_steps = 100;
let result =
BatchedOdeRK4::<ExponentialDecay>::integrate_cpu(&initial, ¶ms, dt, n_steps, 2)
.expect("integrate_cpu should succeed");
let expected_0 = (-1.0_f64).exp();
let expected_1 = 2.0 * (-0.5_f64).exp();
assert!(
(result[0] - expected_0).abs() < 1e-4,
"batch 0: got {}, expected {}",
result[0],
expected_0
);
assert!(
(result[1] - expected_1).abs() < 1e-4,
"batch 1: got {}, expected {}",
result[1],
expected_1
);
}
#[test]
fn test_generated_wgsl_has_expected_structure() {
let shader = BatchedOdeRK4::<ExponentialDecay>::generate_shader();
assert!(shader.contains("fn main"));
assert!(shader.contains("fn deriv"));
assert!(shader.contains("fn rk4_step"));
assert!(shader.contains("@compute @workgroup_size(64)"));
assert!(shader.contains("const N_VARS: u32 = 1u"));
assert!(shader.contains("const N_PARAMS: u32 = 1u"));
}
#[test]
fn test_generated_universal_wgsl_has_expected_structure() {
let shader = BatchedOdeRK4::<ExponentialDecay>::generate_shader_universal()
.expect("ExponentialDecay should have a universal derivative");
assert!(shader.contains("fn main"));
assert!(shader.contains("fn deriv"));
assert!(shader.contains("fn rk4_step"));
assert!(shader.contains("Scalar"));
assert!(shader.contains("op_add"));
assert!(shader.contains("op_mul"));
assert!(shader.contains("op_from_f32"));
assert!(
!shader.contains("f64"),
"universal template must not contain raw f64"
);
}
#[test]
#[cfg(feature = "gpu")]
fn test_generated_wgsl_compiles() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available_sync()
else {
return;
};
let shader = BatchedOdeRK4::<ExponentialDecay>::generate_shader();
let _ = device.compile_shader_f64(&shader, Some("ode_generic_exponential_decay"));
}
#[test]
fn test_integrate_cpu_invalid_initial_states_len() {
let initial = vec![1.0, 2.0, 3.0]; let params = vec![1.0];
let result =
BatchedOdeRK4::<ExponentialDecay>::integrate_cpu(&initial, ¶ms, 0.01, 10, 1);
assert!(result.is_err());
}
#[test]
fn test_integrate_cpu_invalid_params_len() {
let initial = vec![1.0];
let params = vec![1.0, 2.0]; let result =
BatchedOdeRK4::<ExponentialDecay>::integrate_cpu(&initial, ¶ms, 0.01, 10, 1);
assert!(result.is_err());
}
#[test]
fn test_trajectory_time_series() {
let initial = vec![1.0];
let params = vec![1.0]; let traj = BatchedOdeRK4::<ExponentialDecay>::integrate_cpu_trajectory(
&initial, ¶ms, 0.01, 100, 1,
)
.unwrap();
assert_eq!(traj.n_snapshots(), 101);
let (times, values) = traj.time_series(0, 0);
assert_eq!(times.len(), 101);
assert!((times[0] - 0.0).abs() < 1e-14);
assert!((times[100] - 1.0).abs() < 1e-10);
let expected = (-1.0_f64).exp();
assert!(
(values[100] - expected).abs() < 1e-6,
"y(1) = {}, expected {}",
values[100],
expected
);
}
#[test]
fn test_trajectory_state_at_interpolation() {
let initial = vec![1.0];
let params = vec![1.0];
let traj = BatchedOdeRK4::<ExponentialDecay>::integrate_cpu_trajectory(
&initial, ¶ms, 0.1, 10, 1,
)
.unwrap();
let state = traj.state_at(0, 0.55).unwrap();
let expected = (-0.55_f64).exp();
assert!(
(state[0] - expected).abs() < 1e-3,
"y(0.55) = {}, expected {}",
state[0],
expected
);
assert!(traj.state_at(0, -0.1).is_none());
assert!(traj.state_at(0, 1.1).is_none());
}
#[test]
fn test_trajectory_final_state() {
let initial = vec![1.0, 2.0]; let params = vec![1.0, 0.5]; let traj = BatchedOdeRK4::<ExponentialDecay>::integrate_cpu_trajectory(
&initial, ¶ms, 0.01, 100, 2,
)
.unwrap();
let final_0 = traj.final_state(0).unwrap();
let final_1 = traj.final_state(1).unwrap();
let expected_0 = (-1.0_f64).exp();
let expected_1 = 2.0 * (-0.5_f64).exp();
assert!(
(final_0[0] - expected_0).abs() < 1e-6,
"batch 0: {} vs {}",
final_0[0],
expected_0
);
assert!(
(final_1[0] - expected_1).abs() < 1e-6,
"batch 1: {} vs {}",
final_1[0],
expected_1
);
}
}