primal-barracuda 0.4.0

barraCuda — BARrier-free Rust Abstracted Cross-platform Unified Dimensional Algebra. Vendor-agnostic GPU compute via WGSL.
Documentation
// SPDX-License-Identifier: AGPL-3.0-or-later
//! Runge-Kutta 4th Order (RK4) Time Integration
//!
//! **Physics**: General ODE solver (accurate for smooth systems)
//! **Algorithm**: Fourth-order accurate (error ~ Δt⁵)
//! **Use Case**: Stiff ODEs, chemical kinetics, smooth dynamics
//!
//! **Advantages over RK2/Euler**:
//! - Quartic accuracy
//! - Widely tested classical method
//! - Self-starting (no history needed)
//!
//! **Algorithm** (for ODE: dy/dt = f(t,y)):
//! k₁ = f(t, y)
//! k₂ = f(t + Δt/2, y + k₁Δt/2)
//! k₃ = f(t + Δt/2, y + k₂Δt/2)
//! k₄ = f(t + Δt, y + k₃Δt)
//! y(t+Δt) = y(t) + Δt/6 · (k₁ + 2k₂ + 2k₃ + k₄)
//!
//! **For MD**: y = (x, v), f = (v, a)
//!
//! **Deep Debt Compliance**:
//! - ✅ Pure WGSL shader
//! - ✅ Zero unsafe code

@group(0) @binding(0) var<storage, read> positions: array<f32>;      // [N, 3]
@group(0) @binding(1) var<storage, read> velocities: array<f32>;     // [N, 3]
@group(0) @binding(2) var<storage, read> accelerations: array<f32>;  // [N, 3]
@group(0) @binding(3) var<storage, read_write> positions_new: array<f32>; // [N, 3]
@group(0) @binding(4) var<storage, read_write> velocities_new: array<f32>; // [N, 3]
@group(0) @binding(5) var<uniform> params: Params;

struct Params {
    n_particles: u32,
    dt: f32,
    pad1: f32,
    pad2: f32,
}

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let i = global_id.x;
    
    if (i >= params.n_particles) {
        return;
    }
    
    // Load current state
    let x = vec3<f32>(
        positions[i * 3u],
        positions[i * 3u + 1u],
        positions[i * 3u + 2u]
    );
    let v = vec3<f32>(
        velocities[i * 3u],
        velocities[i * 3u + 1u],
        velocities[i * 3u + 2u]
    );
    let a = vec3<f32>(
        accelerations[i * 3u],
        accelerations[i * 3u + 1u],
        accelerations[i * 3u + 2u]
    );
    
    // RK4 for coupled ODEs:
    // dx/dt = v, dv/dt = a
    //
    // Simplified version (assuming constant acceleration in interval):
    // k1_x = v, k1_v = a
    // k2_x = v + a*dt/2, k2_v = a
    // k3_x = v + a*dt/2, k3_v = a
    // k4_x = v + a*dt, k4_v = a
    //
    // For constant acceleration, this simplifies to:
    let k1_x = v;
    let k1_v = a;
    
    let k2_x = v + 0.5 * k1_v * params.dt;
    let k2_v = a; // Assume constant acceleration
    
    let k3_x = v + 0.5 * k2_v * params.dt;
    let k3_v = a;
    
    let k4_x = v + k3_v * params.dt;
    let k4_v = a;
    
    // Weighted average
    let x_new = x + (params.dt / 6.0) * (k1_x + 2.0*k2_x + 2.0*k3_x + k4_x);
    let v_new = v + (params.dt / 6.0) * (k1_v + 2.0*k2_v + 2.0*k3_v + k4_v);
    
    // Write new state
    positions_new[i * 3u] = x_new.x;
    positions_new[i * 3u + 1u] = x_new.y;
    positions_new[i * 3u + 2u] = x_new.z;
    
    velocities_new[i * 3u] = v_new.x;
    velocities_new[i * 3u + 1u] = v_new.y;
    velocities_new[i * 3u + 2u] = v_new.z;
}