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
//
// cubic_spline_eval_f64.wgsl — Evaluate cubic spline at query points (native f64)
//
// Math: s(x) = a + b·dx + c·dx² + d·dx³ where dx = x - knots[segment]
// Algorithm: Binary search for segment, then Horner evaluation.
//
// Bindings:
//   0: query_x    array<f64> read — query x values [n_query]
//   1: knots      array<f64> read — knot x values [n_segments + 1]
//   2: coefs      array<f64> read — [a,b,c,d] per segment [4 * n_segments]
//   3: result     array<f64> read_write — interpolated y [n_query]
//   4: params     uniform

struct Params {
    n_query: u32,
    n_segments: u32,
}

@group(0) @binding(0) var<storage, read> query_x: array<f64>;
@group(0) @binding(1) var<storage, read> knots: array<f64>;
@group(0) @binding(2) var<storage, read> coefs: array<f64>;
@group(0) @binding(3) var<storage, read_write> result: array<f64>;
@group(0) @binding(4) var<uniform> params: Params;

fn find_segment(x: f64, n_segments: u32) -> u32 {
    if (n_segments == 0u) { return 0u; }
    var lo = 0u;
    var hi = n_segments;
    while (lo + 1u < hi) {
        let mid = (lo + hi) / 2u;
        if (x >= knots[mid]) {
            lo = mid;
        } else {
            hi = mid;
        }
    }
    if (x < knots[lo] && lo > 0u) {
        return lo - 1u;
    }
    return lo;
}

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

    let x = query_x[i];
    let seg = min(find_segment(x, params.n_segments), params.n_segments - 1u);
    let dx = x - knots[seg];

    let base = seg * 4u;
    let a = coefs[base];
    let b = coefs[base + 1u];
    let c = coefs[base + 2u];
    let d = coefs[base + 3u];

    // Horner: y = a + dx*(b + dx*(c + dx*d))
    result[i] = a + dx * (b + dx * (c + dx * d));
}