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
// cooperation_ode_rk4_f64.wgsl — Batched RK4 for cooperative QS game theory
//
// LOCAL EVOLUTION — to be absorbed by ToadStool as BatchedOdeRK4Generic<4, 13>.
//
// ODE system (Bruger & Waters 2018):
//   dNc/dt = (mu_c - cost + benefit·hill(A) + disp·(1-B)) · crowding · Nc - death·Nc
//   dNd/dt = (mu_d + benefit·hill(A) + disp·(1-B)) · crowding · Nd - death·Nd
//   dA/dt  = k_ai·Nc - d_ai·A
//   dB/dt  = k_bio·hill(A, k_bio_ai)·(1-B) - d_bio·B
//
// State vector: [Nc, Nd, A, B]  (4 variables)
// Parameters (per batch, 13 values — matches CooperationParams::to_flat()):
//   [mu_coop, mu_cheat, k_cap, death_rate, k_ai_prod, d_ai,
//    benefit, k_benefit, cost, k_bio, k_bio_ai, dispersal_bonus, d_bio]

// f64 is enabled by compile_shader_f64() preamble injection

const N_VARS:   u32 = 4u;
const N_PARAMS: u32 = 13u;

struct OdeConfig {
    n_batches:      u32,
    n_steps:        u32,
    _pad0:          u32,
    _pad1:          u32,
    h:              f64,
    t0:             f64,
    clamp_max:      f64,
    clamp_min:      f64,
}

@group(0) @binding(0) var<uniform>             config:         OdeConfig;
@group(0) @binding(1) var<storage, read>       initial_states: array<f64>;
@group(0) @binding(2) var<storage, read>       batch_params:   array<f64>;
@group(0) @binding(3) var<storage, read_write> output_states:  array<f64>;

fn fmax(a: f64, b: f64) -> f64 {
    if (a >= b) { return a; }
    return b;
}
fn fclamp(x: f64, lo: f64, hi: f64) -> f64 {
    if (x < lo) { return lo; }
    if (x > hi) { return hi; }
    return x;
}

fn hill(x: f64, k: f64) -> f64 {
    let z = x - x;
    if (x <= z) { return z; }
    let x2 = x * x;
    return x2 / (k * k + x2);
}

fn coop_deriv(y0: f64, y1: f64, y2: f64, y3: f64,
              p_base: u32) -> array<f64, 4> {
    let mu_coop  = batch_params[p_base + 0u];
    let mu_cheat = batch_params[p_base + 1u];
    let k_cap    = batch_params[p_base + 2u];
    let death    = batch_params[p_base + 3u];
    let k_ai     = batch_params[p_base + 4u];
    let d_ai     = batch_params[p_base + 5u];
    let benefit  = batch_params[p_base + 6u];
    let k_ben    = batch_params[p_base + 7u];
    let cost     = batch_params[p_base + 8u];
    let k_bio    = batch_params[p_base + 9u];
    let k_bio_ai = batch_params[p_base + 10u];
    let disp     = batch_params[p_base + 11u];
    let d_bio    = batch_params[p_base + 12u];

    let z   = y0 - y0;
    let one = z + 1.0;

    let nc  = fmax(y0, z);
    let nd  = fmax(y1, z);
    let ai  = fmax(y2, z);
    let bio = fmax(y3, z);

    let n_total  = nc + nd;
    let crowding = fmax(one - n_total / (k_cap + 1e-30), z);

    let sig_benefit = benefit * hill(ai, k_ben);
    let dispersal   = disp * (one - bio);

    let fit_coop  = (mu_coop  - cost + sig_benefit + dispersal) * crowding;
    let fit_cheat = (mu_cheat + sig_benefit + dispersal) * crowding;

    var dy: array<f64, 4>;
    dy[0] = fit_coop  * nc - death * nc;
    dy[1] = fit_cheat * nd - death * nd;
    dy[2] = k_ai * nc - d_ai * ai;
    dy[3] = k_bio * hill(ai, k_bio_ai) * (one - bio) - d_bio * bio;
    return dy;
}

fn rk4_step(y0: f64, y1: f64, y2: f64, y3: f64,
            p_base: u32, h: f64) -> array<f64, 4> {
    let z    = h - h;
    let half = z + 0.5;
    let two  = z + 2.0;
    let h2   = h * half;

    let k1 = coop_deriv(y0, y1, y2, y3, p_base);
    let k2 = coop_deriv(
        y0 + h2 * k1[0], y1 + h2 * k1[1],
        y2 + h2 * k1[2], y3 + h2 * k1[3], p_base);
    let k3 = coop_deriv(
        y0 + h2 * k2[0], y1 + h2 * k2[1],
        y2 + h2 * k2[2], y3 + h2 * k2[3], p_base);
    let k4 = coop_deriv(
        y0 + h * k3[0], y1 + h * k3[1],
        y2 + h * k3[2], y3 + h * k3[3], p_base);

    var yn: array<f64, 4>;
    let sixth = (z + 1.0) / (z + 6.0);
    yn[0] = y0 + h * sixth * (k1[0] + two * k2[0] + two * k3[0] + k4[0]);
    yn[1] = y1 + h * sixth * (k1[1] + two * k2[1] + two * k3[1] + k4[1]);
    yn[2] = y2 + h * sixth * (k1[2] + two * k2[2] + two * k3[2] + k4[2]);
    yn[3] = y3 + h * sixth * (k1[3] + two * k2[3] + two * k3[3] + k4[3]);
    return yn;
}

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let b = global_id.x;
    if (b >= config.n_batches) { return; }

    let s_base = b * N_VARS;
    let p_base = b * N_PARAMS;

    var y0 = initial_states[s_base + 0u];
    var y1 = initial_states[s_base + 1u];
    var y2 = initial_states[s_base + 2u];
    var y3 = initial_states[s_base + 3u];

    let cmax = config.clamp_max;
    let cmin = config.clamp_min;
    let h    = config.h;

    for (var step = 0u; step < config.n_steps; step = step + 1u) {
        let yn = rk4_step(y0, y1, y2, y3, p_base, h);
        y0 = fclamp(yn[0], cmin, cmax);
        y1 = fclamp(yn[1], cmin, cmax);
        y2 = fclamp(yn[2], cmin, cmax);
        // biofilm clamped to [0, 1]
        y3 = fclamp(yn[3], cmin, cmin + 1.0);
    }

    output_states[s_base + 0u] = y0;
    output_states[s_base + 1u] = y1;
    output_states[s_base + 2u] = y2;
    output_states[s_base + 3u] = y3;
}