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
// Regularized incomplete gamma function P(a,x) = γ(a,x)/Γ(a)
//
// Lower regularized gamma: P(a,x) = (1/Γ(a)) ∫₀ˣ t^(a-1) e^(-t) dt
// Q(a,x) = 1 - P(a,x) is the upper regularized gamma.
//
// Uses series expansion when x < a+1 (rapid convergence); Lentz continued fraction
// when x >= a+1 (avoids cancellation in the series).
//
// Input: pairs [a₀, x₀, a₁, x₁, ...] interleaved (as vec2<u32> for f64)
// Output: [P(a₀,x₀), P(a₁,x₁), ...] at binding(1), [Q(a₀,x₀), ...] at binding(3)
//
// Applications: Chi-squared distributions, Poisson CDF, gamma CDF, exponential
// integral, survival analysis, queuing theory.
// Reference: Abramowitz & Stegun §6.5; Press et al. "Numerical Recipes" Ch. 6
//
// Note: Requires GPU f64 support including log/exp operations.

@group(0) @binding(0) var<storage, read> input: array<vec2<u32>>;
@group(0) @binding(1) var<storage, read_write> output: array<vec2<u32>>;
@group(0) @binding(2) var<uniform> params: Params;
@group(0) @binding(3) var<storage, read_write> output_q: array<vec2<u32>>;

struct Params {
    size: u32,   // Number of output elements (pairs)
}

const MAX_ITER: u32 = 100u;
const EPS: f64 = 1e-14;
const FPMIN: f64 = 1e-30;

// Constants for f64
const PI_F64: f64 = 3.14159265358979323846264338327950288;
const SQRT_2PI_F64: f64 = 2.5066282746310005024157652848110452;

// Lanczos approximation for lgamma (g=7)
fn lgamma_lanczos_f64(x: f64) -> f64 {
    let g = f64(7.0);
    let x_shifted = x - f64(1.0);
    var sum: f64 = f64(0.99999999999980993);
    sum = sum + f64(676.5203681218851) / (x_shifted + f64(1.0));
    sum = sum + f64(-1259.1392167224028) / (x_shifted + f64(2.0));
    sum = sum + f64(771.32342877765313) / (x_shifted + f64(3.0));
    sum = sum + f64(-176.61502916214059) / (x_shifted + f64(4.0));
    sum = sum + f64(12.507343278686905) / (x_shifted + f64(5.0));
    sum = sum + f64(-0.13857109526572012) / (x_shifted + f64(6.0));
    sum = sum + f64(9.9843695780195716e-6) / (x_shifted + f64(7.0));
    sum = sum + f64(1.5056327351493116e-7) / (x_shifted + f64(8.0));
    let t = x_shifted + g + f64(0.5);
    return log(SQRT_2PI_F64) + log(sum) + (x_shifted + f64(0.5)) * log(t) - t;
}

fn lgamma_f64(x: f64) -> f64 {
    if (x <= f64(0.0)) {
        let z = x - x;
        return z / z;  // NaN
    }
    if (x < f64(0.5)) {
        return log(PI_F64 / sin(PI_F64 * x)) - lgamma_lanczos_f64(f64(1.0) - x);
    }
    return lgamma_lanczos_f64(x);
}

fn gamma_series_f64(a: f64, x: f64, gln: f64) -> f64 {
    var sum: f64 = f64(1.0) / a;
    var term: f64 = sum;
    for (var n: u32 = 1u; n < MAX_ITER; n = n + 1u) {
        term = term * x / (a + f64(n));
        sum = sum + term;
        if (abs(term) < abs(sum) * EPS) {
            break;
        }
    }
    return sum * exp(-x + a * log(x) - gln);
}

fn gamma_cf_f64(a: f64, x: f64, gln: f64) -> f64 {
    var b: f64 = x + f64(1.0) - a;
    var c: f64 = f64(1.0) / FPMIN;
    var d: f64 = f64(1.0) / b;
    var h: f64 = d;
    for (var n: u32 = 1u; n < MAX_ITER; n = n + 1u) {
        let an = -f64(n) * (f64(n) - a);
        b = b + f64(2.0);
        d = an * d + b;
        if (abs(d) < FPMIN) {
            d = FPMIN;
        }
        c = b + an / c;
        if (abs(c) < FPMIN) {
            c = FPMIN;
        }
        d = f64(1.0) / d;
        let delta = d * c;
        h = h * delta;
        if (abs(delta - f64(1.0)) < EPS) {
            break;
        }
    }
    return exp(-x + a * log(x) - gln) * h;
}

fn regularized_gamma_p_f64(a: f64, x: f64) -> f64 {
    if (a <= f64(0.0) || x < f64(0.0)) {
        let z = a - a;
        return z / z;  // NaN
    }
    if (x == f64(0.0)) {
        return f64(0.0);
    }
    let gln = lgamma_f64(a);
    if (x < a + f64(1.0)) {
        return gamma_series_f64(a, x, gln);
    }
    return gamma_cf_f64(a, x, gln);
}

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

    let a = bitcast<f64>(input[idx * 2u]);
    let x = bitcast<f64>(input[idx * 2u + 1u]);

    let p = regularized_gamma_p_f64(a, x);
    let q = f64(1.0) - p;

    output[idx] = bitcast<vec2<u32>>(p);
    output_q[idx] = bitcast<vec2<u32>>(q);
}