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
//
// linear_regression_f64.wgsl — Batched OLS: beta = (X'X)^-1 X'y
//
// For B independent regressions: X[B*N*K], y[B*N], out_beta[B*K]
// For small K (1-4): explicit inverse formula. For K>4: Cholesky on X'X.
//
// Bindings: @0 x[B*N*K], @1 y[B*N], @2 out_beta[B*K], @3 uniform{b, n, k}
//
// Provenance: neuralSpring → ToadStool absorption

struct OLSParams {
    b: u32,
    n: u32,
    k: u32,
    _pad: u32,
}

@group(0) @binding(0) var<storage, read>       x:        array<f64>;  // [B*N*K]
@group(0) @binding(1) var<storage, read>       y:        array<f64>;  // [B*N]
@group(0) @binding(2) var<storage, read_write> out_beta: array<f64>;  // [B*K]
@group(0) @binding(3) var<uniform>             params:   OLSParams;

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

    let N = params.n;
    let K = params.k;
    let x_base = batch * N * K;
    let y_base = batch * N;
    let out_base = batch * K;

    var xtx: array<f64, 16>;  // K*K max for K<=4
    var xty: array<f64, 4>;   // K max

    for (var i: u32 = 0u; i < K * K; i = i + 1u) {
        xtx[i] = 0.0;
    }
    for (var i: u32 = 0u; i < K; i = i + 1u) {
        xty[i] = 0.0;
    }

    for (var r: u32 = 0u; r < N; r = r + 1u) {
        let yr = y[y_base + r];
        for (var i: u32 = 0u; i < K; i = i + 1u) {
            let xi = x[x_base + r * K + i];
            xty[i] += xi * yr;
            for (var j: u32 = 0u; j <= i; j = j + 1u) {
                let xj = x[x_base + r * K + j];
                xtx[i * K + j] += xi * xj;
                if i != j {
                    xtx[j * K + i] += xi * xj;
                }
            }
        }
    }

    if K == 1u {
        let denom = xtx[0u];
        out_beta[out_base] = select(f64(0.0), xty[0u] / denom, abs(denom) > 1.0e-15);
        return;
    }

    if K == 2u {
        let a = xtx[0u];
        let b = xtx[1u];
        let c = xtx[2u];
        let d = xtx[3u];
        let det = a * d - b * c;
        if abs(det) < 1.0e-15 {
            out_beta[out_base] = 0.0;
            out_beta[out_base + 1u] = 0.0;
            return;
        }
        let inv_det = 1.0 / det;
        out_beta[out_base] = (d * xty[0u] - b * xty[1u]) * inv_det;
        out_beta[out_base + 1u] = (-c * xty[0u] + a * xty[1u]) * inv_det;
        return;
    }

    if K == 3u {
        let a00 = xtx[0u]; let a01 = xtx[1u]; let a02 = xtx[2u];
        let a10 = xtx[3u]; let a11 = xtx[4u]; let a12 = xtx[5u];
        let a20 = xtx[6u]; let a21 = xtx[7u]; let a22 = xtx[8u];
        let det = a00*(a11*a22 - a12*a21) - a01*(a10*a22 - a12*a20) + a02*(a10*a21 - a11*a20);
        if abs(det) < 1.0e-15 {
            for (var i: u32 = 0u; i < 3u; i = i + 1u) { out_beta[out_base + i] = 0.0; }
            return;
        }
        let inv_det = 1.0 / det;
        out_beta[out_base] = ((a11*a22 - a12*a21)*xty[0u] - (a01*a22 - a02*a21)*xty[1u] + (a01*a12 - a02*a11)*xty[2u]) * inv_det;
        out_beta[out_base + 1u] = (-(a10*a22 - a12*a20)*xty[0u] + (a00*a22 - a02*a20)*xty[1u] - (a00*a12 - a02*a10)*xty[2u]) * inv_det;
        out_beta[out_base + 2u] = ((a10*a21 - a11*a20)*xty[0u] - (a00*a21 - a01*a20)*xty[1u] + (a00*a11 - a01*a10)*xty[2u]) * inv_det;
        return;
    }

    if K == 4u {
        let m = array<f64, 16>(xtx[0u], xtx[1u], xtx[2u], xtx[3u], xtx[4u], xtx[5u], xtx[6u], xtx[7u], xtx[8u], xtx[9u], xtx[10u], xtx[11u], xtx[12u], xtx[13u], xtx[14u], xtx[15u]);
        let s0 = m[0]*m[5] - m[1]*m[4];
        let s1 = m[0]*m[6] - m[2]*m[4];
        let s2 = m[0]*m[7] - m[3]*m[4];
        let s3 = m[1]*m[6] - m[2]*m[5];
        let s4 = m[1]*m[7] - m[3]*m[5];
        let s5 = m[2]*m[7] - m[3]*m[6];
        let c5 = s0*m[10] - s1*m[9] + s3*m[8];
        let c4 = s0*m[11] - s2*m[9] + s4*m[8];
        let c3 = s1*m[11] - s2*m[10] + s5*m[8];
        let c2 = s3*m[11] - s4*m[10] + s5*m[9];
        let det = c5*m[15] - c4*m[14] + c3*m[13] - c2*m[12];
        if abs(det) < 1.0e-15 {
            for (var i: u32 = 0u; i < 4u; i = i + 1u) { out_beta[out_base + i] = 0.0; }
            return;
        }
        let inv_det = 1.0 / det;
        let rhs = array<f64, 4>(xty[0u], xty[1u], xty[2u], xty[3u]);
        for (var col: u32 = 0u; col < 4u; col = col + 1u) {
            var cof: f64 = 0.0;
            for (var row: u32 = 0u; row < 4u; row = row + 1u) {
                let sign = select(-1.0, 1.0, (row + col) % 2u == 0u);
                var minor: array<f64, 9>;
                var mi: u32 = 0u;
                for (var i: u32 = 0u; i < 4u; i = i + 1u) {
                    for (var j: u32 = 0u; j < 4u; j = j + 1u) {
                        if i != row && j != col {
                            minor[mi] = m[i*4u+j];
                            mi = mi + 1u;
                        }
                    }
                }
                let d = minor[0]*(minor[4]*minor[8]-minor[5]*minor[7]) - minor[1]*(minor[3]*minor[8]-minor[5]*minor[6]) + minor[2]*(minor[3]*minor[7]-minor[4]*minor[6]);
                cof += sign * d * rhs[row];
            }
            out_beta[out_base + col] = cof * inv_det;
        }
        return;
    }

    for (var i: u32 = 0u; i < K; i = i + 1u) {
        out_beta[out_base + i] = 0.0;
    }
}