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
// Incomplete gamma functions: lower γ(a,x) and upper Γ(a,x)
//
// Lower: γ(a,x) = ∫₀ˣ t^(a-1) e^(-t) dt = P(a,x) · Γ(a)
// Upper: Γ(a,x) = ∫ₓ^∞ t^(a-1) e^(-t) dt = Γ(a) - γ(a,x)
//
// Uses series expansion when x < a+1, Lentz continued fraction when x >= a+1,
// same as the regularized gamma P(a,x) = γ(a,x)/Γ(a).
//
// Input: pairs [a₀, x₀, a₁, x₁, ...] interleaved (as vec2<u32> for f64)
// Output: [γ(a₀,x₀), ...] at binding(1), [Γ(a₀,x₀), ...] at binding(3)
//
// Applications: Chi-squared PDF/CDF, exponential integrals, Poisson processes,
// gamma distribution, survival analysis, reliability engineering.
// Reference: Abramowitz & Stegun §6.5; DLMF 8.2
//
// 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>>;      // lower γ(a,x)
@group(0) @binding(2) var<uniform> params: Params;
@group(0) @binding(3) var<storage, read_write> output_upper: array<vec2<u32>>; // upper Γ(a,x)

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 gln = lgamma_f64(a);
    let gamma_a = exp(gln);
    let p = regularized_gamma_p_f64(a, x);

    let lower = p * gamma_a;   // γ(a,x)
    let upper = gamma_a - lower;  // Γ(a,x)

    output[idx] = bitcast<vec2<u32>>(lower);
    output_upper[idx] = bitcast<vec2<u32>>(upper);
}