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) for multipole expansion
// Input: theta and phi interleaved [theta0, phi0, theta1, phi1, ...]
// Params: size, l (degree 0..6), m (order, can be negative)

@group(0) @binding(0) var<storage, read> theta_phi: array<f32>;
@group(0) @binding(1) var<storage, read_write> output: array<f32>;
@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: f32 = 3.14159265359;

// Factorial for n=0..12 (for l+|m| <= 6)
fn factorial(n: u32) -> f32 {
    switch n {
        case 0u: { return 1.0; }
        case 1u: { return 1.0; }
        case 2u: { return 2.0; }
        case 3u: { return 6.0; }
        case 4u: { return 24.0; }
        case 5u: { return 120.0; }
        case 6u: { return 720.0; }
        case 7u: { return 5040.0; }
        case 8u: { return 40320.0; }
        case 9u: { return 362880.0; }
        case 10u: { return 3628800.0; }
        case 11u: { return 39916800.0; }
        case 12u: { return 479001600.0; }
        default: { return 1.0; }
    }
}

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

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

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

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

    // P_{m+1}^m
    var pmp1 = f32(2u * abs_m + 1u) * 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 coef1 = f32(2u * ll - 1u) * x * pl_minus1;
        let coef2 = f32(ll + abs_m - 1u) * pl_minus2;
        let pl = (coef1 - coef2) / f32(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) -> f32 {
    let num = factorial(l - abs_m);
    let den = factorial(l + abs_m);
    let ratio = num / den;
    let pre = f32(2u * l + 1u) / (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] = 0.0;
        return;
    }

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

    var angular: f32;
    if (abs_m == 0u) {
        angular = 1.0;
    } else if (m_is_positive == 1u) {
        angular = cos(f32(abs_m) * phi);
    } else {
        angular = sin(f32(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 * sqrt(2.0); // Real form: sqrt(2) for m != 0
    }

    output[idx] = y_lm;
}