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
// Real spherical harmonics Y_l^m(theta, phi) — f64 precision
// Input: theta and phi interleaved [theta0, phi0, theta1, phi1, ...]
// Params: size, l (degree 0..6), m (order, can be negative)
//
// **f64 precision**: Required for high-order multipole expansion accuracy

@group(0) @binding(0) var<storage, read> theta_phi: array<f64>;
@group(0) @binding(1) var<storage, read_write> output: array<f64>;
@group(0) @binding(2) var<uniform> params: Params;

struct Params {
    size: u32,
    l: u32,
    abs_m: u32,       // |m|
    m_is_positive: u32, // 1 if m>0 (use cos), 0 if m<0 (use sin), ignored when m=0
}

const PI: f64 = 3.14159265358979323846;
const SQRT2: f64 = 1.4142135623730950488;  // sqrt(2) — avoids sqrt(f64) Naga overload issue

// Factorial for n=0..20 (extended for f64 precision needs)
fn factorial(n: u32) -> f64 {
    switch n {
        case 0u: { return f64(1.0); }
        case 1u: { return f64(1.0); }
        case 2u: { return f64(2.0); }
        case 3u: { return f64(6.0); }
        case 4u: { return f64(24.0); }
        case 5u: { return f64(120.0); }
        case 6u: { return f64(720.0); }
        case 7u: { return f64(5040.0); }
        case 8u: { return f64(40320.0); }
        case 9u: { return f64(362880.0); }
        case 10u: { return f64(3628800.0); }
        case 11u: { return f64(39916800.0); }
        case 12u: { return f64(479001600.0); }
        case 13u: { return f64(6227020800.0); }
        case 14u: { return f64(87178291200.0); }
        case 15u: { return f64(1307674368000.0); }
        case 16u: { return f64(20922789888000.0); }
        case 17u: { return f64(355687428096000.0); }
        case 18u: { return f64(6402373705728000.0); }
        case 19u: { return f64(121645100408832000.0); }
        case 20u: { return f64(2432902008176640000.0); }
        default: { return f64(1.0); }
    }
}

// Double factorial (2m-1)!! = 1*3*5*...*(2m-1)
fn double_factorial(m: u32) -> f64 {
    if (m == 0u) {
        return f64(1.0);
    }
    var r: f64 = f64(1.0);
    for (var k = 1u; k <= m; k = k + 1u) {
        let term = 2u * k - 1u;
        r = r * f64(term);
    }
    return r;
}

// Associated Legendre P_l^m(x) where x = cos(theta), iterative
fn assoc_legendre(l: u32, m: u32, x: f64) -> f64 {
    let abs_m = m;
    if (abs_m > l) {
        return f64(0.0);
    }
    let t = f64(1.0) - x * x;
    if (t <= f64(0.0)) {
        if (abs_m == 0u) {
            // P_l^0(1) = 1 for all l; P_l^0(-1) = (-1)^l
            if (x < f64(0.0) && l % 2u == 1u) {
                return f64(-1.0);
            }
            return f64(1.0);
        }
        return f64(0.0);
    }

    // P_m^m
    var pm = double_factorial(abs_m) * pow(sqrt(t), f64(abs_m));
    if (abs_m % 2u == 1u) {
        pm = -pm;
    }

    if (l == abs_m) {
        return pm;
    }

    // P_{m+1}^m
    let term_2m1 = 2u * abs_m + 1u;
    var pmp1 = f64(term_2m1) * x * pm;
    if (l == abs_m + 1u) {
        return pmp1;
    }

    // Recurrence for l >= m+2
    var pl_minus2 = pm;
    var pl_minus1 = pmp1;
    for (var ll = abs_m + 2u; ll <= l; ll = ll + 1u) {
        let term1 = 2u * ll - 1u;
        let term2 = ll + abs_m - 1u;
        let coef1 = f64(term1) * x * pl_minus1;
        let coef2 = f64(term2) * pl_minus2;
        let pl = (coef1 - coef2) / f64(ll - abs_m);
        pl_minus2 = pl_minus1;
        pl_minus1 = pl;
    }
    return pl_minus1;
}

// Normalization N_lm = sqrt((2l+1)/(4*pi) * (l-|m|)!/(l+|m|)!)
fn norm_lm(l: u32, abs_m: u32) -> f64 {
    let num = factorial(l - abs_m);
    let den = factorial(l + abs_m);
    let ratio = num / den;
    let term = 2u * l + 1u;
    let pre = f64(term) / (f64(4.0) * PI);
    return sqrt(pre * ratio);
}

@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 theta = theta_phi[idx * 2u];
    let phi = theta_phi[idx * 2u + 1u];

    let l = params.l;
    let abs_m = params.abs_m;
    let m_is_positive = params.m_is_positive;

    if (abs_m > l) {
        output[idx] = f64(0.0);
        return;
    }

    let x = cos(theta);
    let plm = assoc_legendre(l, abs_m, x);

    var angular: f64;
    if (abs_m == 0u) {
        angular = f64(1.0);
    } else if (m_is_positive == 1u) {
        angular = cos(f64(abs_m) * phi);
    } else {
        angular = sin(f64(abs_m) * phi);
    }

    let n_lm = norm_lm(l, abs_m);
    var y_lm = n_lm * plm * angular;

    if (abs_m != 0u) {
        y_lm = y_lm * SQRT2;  // Real form: sqrt(2) for m != 0
    }

    output[idx] = y_lm;
}