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
// cosine_similarity_f64.wgsl - Cosine Similarity at f64 precision
//
// Computes cosine similarity between pairs of vectors using f64 arithmetic
// Similarity = (a · b) / (||a|| * ||b||)
//
// REQUIRES: SHADER_F64 feature (wgpu::Features::SHADER_F64)
//
// Use cases (wetSpring Priority 2):
// - MS2 spectral matching in analytical chemistry
// - High-precision similarity search
// - Biological sequence comparison
//
// Date: February 16, 2026
// License: AGPL-3.0-or-later

// Import sqrt_f64 from math_f64.wgsl (include via ShaderTemplate or inline)
// For standalone use, inline the sqrt function:

fn sqrt_f64_inline(x: f64) -> f64 {
    let zero = x - x;
    if (x <= zero) {
        return zero;
    }
    
    var y = x;
    var scale = zero + 1.0;
    let large = zero + 1e32;
    let small = zero + 1e-32;
    
    if (x > large) {
        y = x / large;
        scale = zero + 1e16;
    } else if (x < small) {
        y = x * large;
        scale = zero + 1e-16;
    }
    
    var r = (y + (zero + 1.0)) / (zero + 2.0);
    let half = zero + 0.5;
    r = half * (r + y / r);
    r = half * (r + y / r);
    r = half * (r + y / r);
    r = half * (r + y / r);
    r = half * (r + y / r);
    
    return r * scale;
}

struct Params {
    num_vectors_a: u32,
    num_vectors_b: u32,
    vector_dim: u32,
    _padding: u32,
}

@group(0) @binding(0) var<storage, read> vectors_a: array<f64>;     // [num_vectors_a, dim]
@group(0) @binding(1) var<storage, read> vectors_b: array<f64>;     // [num_vectors_b, dim]
@group(0) @binding(2) var<storage, read_write> output: array<f64>;  // [num_vectors_a, num_vectors_b]
@group(0) @binding(3) var<uniform> params: Params;

@compute @workgroup_size(16, 16)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let i = global_id.x;
    let j = global_id.y;
    
    if (i >= params.num_vectors_a || j >= params.num_vectors_b) {
        return;
    }
    
    // Use (zero + literal) pattern for f64 constants
    let first_a = vectors_a[i * params.vector_dim];
    let zero = first_a - first_a;
    
    var dot_product = zero;
    var norm_a = zero;
    var norm_b = zero;
    
    for (var d: u32 = 0u; d < params.vector_dim; d = d + 1u) {
        let a_val = vectors_a[i * params.vector_dim + d];
        let b_val = vectors_b[j * params.vector_dim + d];
        
        dot_product = dot_product + a_val * b_val;
        norm_a = norm_a + a_val * a_val;
        norm_b = norm_b + b_val * b_val;
    }
    
    // Cosine similarity with f64 precision epsilon
    let epsilon = zero + 1e-15;
    let denom = sqrt_f64_inline(norm_a) * sqrt_f64_inline(norm_b) + epsilon;
    let similarity = dot_product / denom;
    
    output[i * params.num_vectors_b + j] = similarity;
}

// ============================================================================
// Variant: Single vector pair (more efficient for small comparisons)
// ============================================================================

struct SinglePairParams {
    vector_dim: u32,
    _pad1: u32,
    _pad2: u32,
    _pad3: u32,
}

@group(0) @binding(0) var<storage, read> vector_a_single: array<f64>;      // [dim]
@group(0) @binding(1) var<storage, read> vector_b_single: array<f64>;      // [dim]
@group(0) @binding(2) var<storage, read_write> result_single: array<f64>;  // [1]
@group(0) @binding(3) var<uniform> single_params: SinglePairParams;

// Workgroup shared memory for parallel reduction
var<workgroup> shared_dot: array<f64, 256>;
var<workgroup> shared_norm_a: array<f64, 256>;
var<workgroup> shared_norm_b: array<f64, 256>;

@compute @workgroup_size(256)
fn cosine_single_pair(
    @builtin(local_invocation_id) local_id: vec3<u32>,
    @builtin(workgroup_id) workgroup_id: vec3<u32>
) {
    let tid = local_id.x;
    let dim = single_params.vector_dim;
    
    // Each thread handles multiple elements
    let first = vector_a_single[0];
    let zero = first - first;
    
    var local_dot = zero;
    var local_norm_a = zero;
    var local_norm_b = zero;
    
    var idx = tid;
    while (idx < dim) {
        let a_val = vector_a_single[idx];
        let b_val = vector_b_single[idx];
        
        local_dot = local_dot + a_val * b_val;
        local_norm_a = local_norm_a + a_val * a_val;
        local_norm_b = local_norm_b + b_val * b_val;
        
        idx = idx + 256u;
    }
    
    // Store to shared memory
    shared_dot[tid] = local_dot;
    shared_norm_a[tid] = local_norm_a;
    shared_norm_b[tid] = local_norm_b;
    workgroupBarrier();
    
    // Parallel reduction
    var stride = 128u;
    while (stride > 0u) {
        if (tid < stride) {
            shared_dot[tid] = shared_dot[tid] + shared_dot[tid + stride];
            shared_norm_a[tid] = shared_norm_a[tid] + shared_norm_a[tid + stride];
            shared_norm_b[tid] = shared_norm_b[tid] + shared_norm_b[tid + stride];
        }
        workgroupBarrier();
        stride = stride / 2u;
    }
    
    // Thread 0 writes result
    if (tid == 0u) {
        let epsilon = zero + 1e-15;
        let denom = sqrt_f64_inline(shared_norm_a[0]) * sqrt_f64_inline(shared_norm_b[0]) + epsilon;
        result_single[0] = shared_dot[0] / denom;
    }
}