@vorionsys/atsf-core 0.4.1 → 0.4.3

package/dist/paramesphere/gpu-svd.js

@@ -0,0 +1,668 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2024-2026 Vorion LLC
+/**
+ * GPU-Offloaded SVD Computation for ParameSphere
+ *
+ * Provides optional GPU-accelerated singular value decomposition for
+ * T5-T7 scale models where CPU power iteration becomes expensive on
+ * large weight matrices.
+ *
+ * Three provider implementations:
+ * - **WebGpuSvdProvider** — Uses WebGPU compute shaders for browser/Deno
+ *   environments that expose `navigator.gpu`.
+ * - **OnnxSvdProvider** — Uses ONNX Runtime with CUDA execution provider
+ *   for Node.js server environments.
+ * - **CpuFallbackProvider** — Wraps the existing CPU power-iteration
+ *   implementation for environments where no GPU is available.
+ *
+ * All providers satisfy the same `GpuSvdProvider` interface and produce
+ * results within 1e-6 tolerance of the CPU baseline.
+ *
+ * @packageDocumentation
+ */
+import { topKSingularValues } from './paramesphere-engine.js';
+// ---------------------------------------------------------------------------
+// CPU Fallback Provider
+// ---------------------------------------------------------------------------
+/**
+ * CPU fallback provider that delegates to the existing power-iteration
+ * implementation. This is the baseline — all other providers must match
+ * its output within 1e-6 tolerance.
+ */
+export class CpuFallbackProvider {
+    async available() {
+        return true; // CPU is always available
+    }
+    async topKSingularValues(data, rows, cols, k) {
+        return topKSingularValues(data, rows, cols, k);
+    }
+}
+// ---------------------------------------------------------------------------
+// WebGPU SVD Provider
+// ---------------------------------------------------------------------------
+/**
+ * WGSL compute shader for matrix-vector product A^T * A * v.
+ *
+ * This fuses the two matrix-vector multiplications (u = A*v, then
+ * v_new = A^T*u) into a single dispatch, halving the number of GPU
+ * round-trips per power iteration step.
+ *
+ * Bindings:
+ *   @group(0) @binding(0) — matrix A (row-major, f32 for GPU efficiency)
+ *   @group(0) @binding(1) — input vector v (f32)
+ *   @group(0) @binding(2) — output vector result (f32)
+ *   @group(0) @binding(3) — dimensions uniform (rows, cols as u32)
+ */
+const WGSL_ATA_SHADER = /* wgsl */ `
+struct Dims {
+  rows: u32,
+  cols: u32,
+};
+
+@group(0) @binding(0) var<storage, read> matrix_a: array<f32>;
+@group(0) @binding(1) var<storage, read> vec_in: array<f32>;
+@group(0) @binding(2) var<storage, read_write> vec_out: array<f32>;
+@group(0) @binding(3) var<uniform> dims: Dims;
+
+// Stage 1: Compute u = A * v (result has 'rows' elements)
+// Stage 2: Compute result = A^T * u (result has 'cols' elements)
+// We do both in one shader by using a workgroup-shared intermediate.
+
+// For simplicity and correctness, this shader computes one element of
+// the output (A^T * A * v) per invocation. Each invocation j computes:
+//   result[j] = sum_i( A[i][j] * sum_k( A[i][k] * v[k] ) )
+// which is the j-th element of A^T * (A * v).
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let j = gid.x;
+  let rows = dims.rows;
+  let cols = dims.cols;
+
+  if (j >= cols) {
+    return;
+  }
+
+  var acc: f32 = 0.0;
+
+  // For each row i, compute dot(A[i,:], v) then accumulate A[i][j] * dot
+  for (var i: u32 = 0u; i < rows; i = i + 1u) {
+    var row_dot: f32 = 0.0;
+    let row_off = i * cols;
+    for (var k: u32 = 0u; k < cols; k = k + 1u) {
+      row_dot = row_dot + matrix_a[row_off + k] * vec_in[k];
+    }
+    acc = acc + matrix_a[row_off + j] * row_dot;
+  }
+
+  vec_out[j] = acc;
+}
+`;
+/**
+ * WebGPU-based SVD provider.
+ *
+ * Uses a compute shader for the expensive A^T*A*v products in the power
+ * iteration loop. Falls back to CPU if WebGPU is unavailable.
+ *
+ * Note: This provider is primarily useful in browser or Deno environments
+ * that expose the WebGPU API. In Node.js, prefer `OnnxSvdProvider`.
+ */
+export class WebGpuSvdProvider {
+    device = null;
+    pipeline = null;
+    fallback = new CpuFallbackProvider();
+    initPromise = null;
+    /** Power iteration parameters matching the CPU implementation. */
+    static POWER_ITER_MAX = 300;
+    static POWER_ITER_TOL = 1e-10;
+    async available() {
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = this.initGpu();
+        return this.initPromise;
+    }
+    async topKSingularValues(data, rows, cols, k) {
+        const gpuReady = await this.available();
+        if (!gpuReady || !this.device || !this.pipeline) {
+            return this.fallback.topKSingularValues(data, rows, cols, k);
+        }
+        try {
+            return await this.computeOnGpu(data, rows, cols, k);
+        }
+        catch {
+            // Any GPU error falls back to CPU gracefully
+            return this.fallback.topKSingularValues(data, rows, cols, k);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // GPU Initialization
+    // -------------------------------------------------------------------------
+    async initGpu() {
+        try {
+            // Check for WebGPU availability (globalThis for cross-env compat)
+            const nav = globalThis.navigator;
+            if (!nav?.gpu)
+                return false;
+            const adapter = await nav.gpu.requestAdapter();
+            if (!adapter)
+                return false;
+            this.device = await adapter.requestDevice();
+            // Compile the compute shader
+            const shaderModule = this.device.createShaderModule({
+                code: WGSL_ATA_SHADER,
+            });
+            this.pipeline = this.device.createComputePipeline({
+                layout: 'auto',
+                compute: {
+                    module: shaderModule,
+                    entryPoint: 'main',
+                },
+            });
+            return true;
+        }
+        catch {
+            this.device = null;
+            this.pipeline = null;
+            return false;
+        }
+    }
+    // -------------------------------------------------------------------------
+    // GPU Computation
+    // -------------------------------------------------------------------------
+    async computeOnGpu(data, rows, cols, k) {
+        const device = this.device;
+        const pipeline = this.pipeline;
+        const rank = Math.min(rows, cols, k);
+        const sigmas = new Float64Array(rank);
+        // Work on a copy for deflation (same as CPU path)
+        const A = new Float64Array(data);
+        for (let s = 0; s < rank; s++) {
+            // Convert current matrix to Float32 for GPU
+            const matF32 = new Float32Array(A.length);
+            for (let i = 0; i < A.length; i++)
+                matF32[i] = A[i];
+            // Initialize v with deterministic pseudo-random vector (matching CPU)
+            const v = new Float64Array(cols);
+            for (let j = 0; j < cols; j++) {
+                v[j] = Math.sin((s + 1) * (j + 1) * 0.7071);
+            }
+            normalizeVecLocal(v);
+            let sigma = 0;
+            // Create GPU buffers
+            const matBuffer = device.createBuffer({
+                size: matF32.byteLength,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+            });
+            const vecInBuffer = device.createBuffer({
+                size: cols * 4, // f32
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+            });
+            const vecOutBuffer = device.createBuffer({
+                size: cols * 4, // f32
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            });
+            const dimsBuffer = device.createBuffer({
+                size: 8, // 2x u32
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            });
+            const readbackBuffer = device.createBuffer({
+                size: cols * 4,
+                usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+            });
+            // Upload matrix and dimensions (only once per singular value)
+            device.queue.writeBuffer(matBuffer, 0, matF32);
+            device.queue.writeBuffer(dimsBuffer, 0, new Uint32Array([rows, cols]));
+            const bindGroup = device.createBindGroup({
+                layout: pipeline.getBindGroupLayout(0),
+                entries: [
+                    { binding: 0, resource: { buffer: matBuffer } },
+                    { binding: 1, resource: { buffer: vecInBuffer } },
+                    { binding: 2, resource: { buffer: vecOutBuffer } },
+                    { binding: 3, resource: { buffer: dimsBuffer } },
+                ],
+            });
+            // Power iteration loop
+            for (let iter = 0; iter < WebGpuSvdProvider.POWER_ITER_MAX; iter++) {
+                // Upload current v as f32
+                const vF32 = new Float32Array(cols);
+                for (let j = 0; j < cols; j++)
+                    vF32[j] = v[j];
+                device.queue.writeBuffer(vecInBuffer, 0, vF32);
+                // Dispatch compute shader: A^T * A * v
+                const commandEncoder = device.createCommandEncoder();
+                const pass = commandEncoder.beginComputePass();
+                pass.setPipeline(pipeline);
+                pass.setBindGroup(0, bindGroup);
+                pass.dispatchWorkgroups(Math.ceil(cols / 64));
+                pass.end();
+                // Copy result to readback buffer
+                commandEncoder.copyBufferToBuffer(vecOutBuffer, 0, readbackBuffer, 0, cols * 4);
+                device.queue.submit([commandEncoder.finish()]);
+                // Read back result
+                await readbackBuffer.mapAsync(GPUMapMode.READ);
+                const resultF32 = new Float32Array(readbackBuffer.getMappedRange().slice(0));
+                readbackBuffer.unmap();
+                // Convert back to Float64 and extract sigma
+                const vNew = new Float64Array(cols);
+                for (let j = 0; j < cols; j++)
+                    vNew[j] = resultF32[j];
+                const sigmaNew = vecNormLocal(vNew);
+                if (sigmaNew < 1e-15)
+                    break;
+                scaleVecLocal(vNew, 1 / sigmaNew);
+                // sigma for A^T*A*v is sigma^2 of A, so take sqrt
+                const sigmaEst = Math.sqrt(sigmaNew);
+                const diff = Math.abs(sigma - sigmaEst);
+                for (let j = 0; j < cols; j++)
+                    v[j] = vNew[j];
+                sigma = sigmaEst;
+                if (diff < WebGpuSvdProvider.POWER_ITER_TOL * sigma && iter > 0)
+                    break;
+            }
+            sigmas[s] = sigma;
+            // Deflate: A <- A - sigma * u * v^T (on CPU — deflation is cheap)
+            const u = matVecMulLocal(A, rows, cols, v);
+            const uNorm = vecNormLocal(u);
+            if (uNorm > 1e-15) {
+                scaleVecLocal(u, 1 / uNorm);
+                for (let i = 0; i < rows; i++) {
+                    for (let j = 0; j < cols; j++) {
+                        A[i * cols + j] -= sigma * u[i] * v[j];
+                    }
+                }
+            }
+            // Cleanup GPU buffers for this singular value
+            matBuffer.destroy();
+            vecInBuffer.destroy();
+            vecOutBuffer.destroy();
+            dimsBuffer.destroy();
+            readbackBuffer.destroy();
+        }
+        return sigmas;
+    }
+}
+// ---------------------------------------------------------------------------
+// ONNX Runtime SVD Provider
+// ---------------------------------------------------------------------------
+/**
+ * ONNX Runtime-based SVD provider for Node.js server environments.
+ *
+ * Uses ONNX Runtime's CUDA execution provider when available, falling
+ * back to the CPU execution provider. This is the recommended GPU path
+ * for Node.js where WebGPU is not yet available.
+ *
+ * Implementation strategy: Since ONNX doesn't have a direct SVD op,
+ * we implement the same power-iteration algorithm but offload the
+ * matrix-vector multiplications (the expensive inner loop) to ONNX
+ * Runtime which can run them on GPU via CUDA/cuDNN.
+ */
+export class OnnxSvdProvider {
+    session = null;
+    onnxAvailable = false;
+    executionProvider = 'cpu';
+    fallback = new CpuFallbackProvider();
+    initPromise = null;
+    /** Power iteration parameters matching the CPU implementation. */
+    static POWER_ITER_MAX = 300;
+    static POWER_ITER_TOL = 1e-10;
+    async available() {
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = this.initOnnx();
+        return this.initPromise;
+    }
+    async topKSingularValues(data, rows, cols, k) {
+        const onnxReady = await this.available();
+        if (!onnxReady || !this.session) {
+            return this.fallback.topKSingularValues(data, rows, cols, k);
+        }
+        try {
+            return await this.computeWithOnnx(data, rows, cols, k);
+        }
+        catch {
+            // Any ONNX error falls back to CPU gracefully
+            return this.fallback.topKSingularValues(data, rows, cols, k);
+        }
+    }
+    /** Returns the active execution provider name ('cuda' or 'cpu'). */
+    getExecutionProvider() {
+        return this.executionProvider;
+    }
+    // -------------------------------------------------------------------------
+    // ONNX Initialization
+    // -------------------------------------------------------------------------
+    async initOnnx() {
+        try {
+            // Dynamic import to avoid hard dependency on onnxruntime-node
+            const ort = await importOnnxRuntime();
+            if (!ort)
+                return false;
+            // Try CUDA first, then fall back to CPU
+            const providers = [];
+            try {
+                // Probe for CUDA availability
+                providers.push('CUDAExecutionProvider');
+            }
+            catch {
+                // CUDA not available
+            }
+            providers.push('CPUExecutionProvider');
+            // Create a minimal MatMul model in-memory for GPU-accelerated mat-vec
+            const modelBytes = buildMatMulOnnxModel();
+            this.session = await ort.InferenceSession.create(modelBytes.buffer, { executionProviders: providers });
+            // Detect which provider was actually selected
+            this.executionProvider = providers.includes('CUDAExecutionProvider')
+                ? 'cuda'
+                : 'cpu';
+            this.onnxAvailable = true;
+            return true;
+        }
+        catch {
+            this.onnxAvailable = false;
+            return false;
+        }
+    }
+    // -------------------------------------------------------------------------
+    // ONNX Computation
+    // -------------------------------------------------------------------------
+    async computeWithOnnx(data, rows, cols, k) {
+        const rank = Math.min(rows, cols, k);
+        const sigmas = new Float64Array(rank);
+        const A = new Float64Array(data);
+        for (let s = 0; s < rank; s++) {
+            let v = new Float64Array(cols);
+            for (let j = 0; j < cols; j++) {
+                v[j] = Math.sin((s + 1) * (j + 1) * 0.7071);
+            }
+            normalizeVecLocal(v);
+            let sigma = 0;
+            for (let iter = 0; iter < OnnxSvdProvider.POWER_ITER_MAX; iter++) {
+                // u = A * v  (via ONNX MatMul or CPU)
+                const u = await this.onnxMatVecMul(A, rows, cols, v);
+                sigma = vecNormLocal(u);
+                if (sigma < 1e-15)
+                    break;
+                scaleVecLocal(u, 1 / sigma);
+                // v_new = A^T * u (via ONNX MatMul or CPU)
+                const vNew = await this.onnxMatTransVecMul(A, rows, cols, u);
+                const sigmaNew = vecNormLocal(vNew);
+                if (sigmaNew < 1e-15)
+                    break;
+                scaleVecLocal(vNew, 1 / sigmaNew);
+                const diff = Math.abs(sigma - sigmaNew);
+                v = vNew;
+                sigma = sigmaNew;
+                if (diff < OnnxSvdProvider.POWER_ITER_TOL * sigma)
+                    break;
+            }
+            sigmas[s] = sigma;
+            // Deflate
+            const u = matVecMulLocal(A, rows, cols, v);
+            const uNorm = vecNormLocal(u);
+            if (uNorm > 1e-15) {
+                scaleVecLocal(u, 1 / uNorm);
+                for (let i = 0; i < rows; i++) {
+                    for (let j = 0; j < cols; j++) {
+                        A[i * cols + j] -= sigma * u[i] * v[j];
+                    }
+                }
+            }
+        }
+        return sigmas;
+    }
+    /**
+     * GPU-accelerated matrix-vector multiply via ONNX Runtime.
+     * Falls back to CPU implementation if ONNX session is unavailable.
+     */
+    async onnxMatVecMul(A, rows, cols, v) {
+        if (!this.session) {
+            return matVecMulLocal(A, rows, cols, v);
+        }
+        try {
+            const ort = await importOnnxRuntime();
+            if (!ort)
+                return matVecMulLocal(A, rows, cols, v);
+            // Reshape: A is [rows, cols], v is [cols, 1] → result is [rows, 1]
+            const matData = new Float32Array(A.length);
+            for (let i = 0; i < A.length; i++)
+                matData[i] = A[i];
+            const vecData = new Float32Array(cols);
+            for (let i = 0; i < cols; i++)
+                vecData[i] = v[i];
+            const matTensor = new ort.Tensor('float32', matData, [rows, cols]);
+            const vecTensor = new ort.Tensor('float32', vecData, [cols, 1]);
+            const results = await this.session.run({ A: matTensor, B: vecTensor });
+            const outputData = results['Y'].data;
+            const result = new Float64Array(rows);
+            for (let i = 0; i < rows; i++)
+                result[i] = outputData[i];
+            return result;
+        }
+        catch {
+            return matVecMulLocal(A, rows, cols, v);
+        }
+    }
+    /**
+     * GPU-accelerated A^T * u via ONNX Runtime.
+     */
+    async onnxMatTransVecMul(A, rows, cols, u) {
+        if (!this.session) {
+            return matTransVecMulLocal(A, rows, cols, u);
+        }
+        try {
+            const ort = await importOnnxRuntime();
+            if (!ort)
+                return matTransVecMulLocal(A, rows, cols, u);
+            // A^T is [cols, rows], u is [rows, 1] → result is [cols, 1]
+            // Instead of transposing, pass u^T * A which gives same result
+            const matData = new Float32Array(A.length);
+            for (let i = 0; i < A.length; i++)
+                matData[i] = A[i];
+            const vecData = new Float32Array(rows);
+            for (let i = 0; i < rows; i++)
+                vecData[i] = u[i];
+            // Reshape as [1, rows] x [rows, cols] = [1, cols]
+            const vecTensor = new ort.Tensor('float32', vecData, [1, rows]);
+            const matTensor = new ort.Tensor('float32', matData, [rows, cols]);
+            const results = await this.session.run({ A: vecTensor, B: matTensor });
+            const outputData = results['Y'].data;
+            const result = new Float64Array(cols);
+            for (let i = 0; i < cols; i++)
+                result[i] = outputData[i];
+            return result;
+        }
+        catch {
+            return matTransVecMulLocal(A, rows, cols, u);
+        }
+    }
+}
+/**
+ * Dynamically import onnxruntime-node. Returns null if not installed.
+ */
+async function importOnnxRuntime() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const ort = await import('onnxruntime-node');
+        return ort;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build a minimal ONNX protobuf for a MatMul node (A × B = Y).
+ *
+ * This constructs the raw protobuf bytes for the simplest possible
+ * ONNX model: a single MatMul node with two dynamic-shaped inputs
+ * and one output. The model is opset 13 compatible.
+ *
+ * We build the protobuf manually to avoid depending on onnx-proto
+ * or protobufjs at runtime.
+ */
+function buildMatMulOnnxModel() {
+    // ONNX uses protobuf encoding. We construct a minimal valid model
+    // with a single MatMul node. This is a well-known minimal structure.
+    //
+    // The model graph:
+    //   inputs:  A (float, dynamic shape), B (float, dynamic shape)
+    //   node:    MatMul(A, B) -> Y
+    //   outputs: Y (float, dynamic shape)
+    // Helper to encode a protobuf varint
+    function encodeVarint(value) {
+        const bytes = [];
+        let v = value >>> 0; // ensure unsigned
+        while (v > 0x7f) {
+            bytes.push((v & 0x7f) | 0x80);
+            v >>>= 7;
+        }
+        bytes.push(v);
+        return bytes;
+    }
+    // Helper to encode a length-delimited protobuf field
+    function field(fieldNum, data) {
+        const tag = (fieldNum << 3) | 2; // wire type 2 = length-delimited
+        const dataArr = data instanceof Uint8Array ? Array.from(data) : data;
+        return [...encodeVarint(tag), ...encodeVarint(dataArr.length), ...dataArr];
+    }
+    // Helper to encode a varint field
+    function varintField(fieldNum, value) {
+        const tag = (fieldNum << 3) | 0; // wire type 0 = varint
+        return [...encodeVarint(tag), ...encodeVarint(value)];
+    }
+    // Helper to encode a string
+    function encodeString(s) {
+        return Array.from(new TextEncoder().encode(s));
+    }
+    // TensorTypeProto for float with unknown shape
+    // elem_type = 1 (FLOAT)
+    const tensorTypeFloat = [...varintField(1, 1)]; // elem_type = FLOAT
+    // TypeProto with tensor_type
+    const typeProtoFloat = field(1, tensorTypeFloat); // field 1 = tensor_type
+    // ValueInfoProto for input A
+    const valueInfoA = [
+        ...field(1, encodeString('A')), // name
+        ...field(2, typeProtoFloat), // type
+    ];
+    // ValueInfoProto for input B
+    const valueInfoB = [
+        ...field(1, encodeString('B')),
+        ...field(2, typeProtoFloat),
+    ];
+    // ValueInfoProto for output Y
+    const valueInfoY = [
+        ...field(1, encodeString('Y')),
+        ...field(2, typeProtoFloat),
+    ];
+    // NodeProto: MatMul(A, B) -> Y
+    const matMulNode = [
+        ...field(1, encodeString('A')), // input
+        ...field(1, encodeString('B')), // input
+        ...field(2, encodeString('Y')), // output
+        ...field(4, encodeString('MatMul')), // op_type
+    ];
+    // GraphProto
+    const graphProto = [
+        ...field(1, matMulNode), // node (repeated, field 1)
+        ...field(5, encodeString('svd_matmul')), // name
+        ...field(11, valueInfoA), // input
+        ...field(11, valueInfoB), // input
+        ...field(12, valueInfoY), // output
+    ];
+    // OperatorSetIdProto for opset 13
+    const opsetImport = [...varintField(2, 13)]; // version = 13
+    // ModelProto
+    const modelProto = [
+        ...varintField(1, 7), // ir_version = 7
+        ...field(8, opsetImport), // opset_import
+        ...field(2, encodeString('vorion-svd-matmul')), // producer_name
+        ...field(7, graphProto), // graph
+    ];
+    return new Uint8Array(modelProto);
+}
+// ---------------------------------------------------------------------------
+// Factory Function
+// ---------------------------------------------------------------------------
+/**
+ * Create the best available SVD provider.
+ *
+ * Auto-detection order:
+ * 1. WebGPU (if `preference` is 'gpu' or unset and WebGPU is available)
+ * 2. ONNX Runtime with CUDA (if `preference` is 'onnx' or unset and onnxruntime-node is installed)
+ * 3. CPU fallback (always available)
+ *
+ * @param preference - Force a specific provider. Omit to auto-detect.
+ * @returns The best available provider.
+ */
+export async function createSvdProvider(preference) {
+    if (preference === 'cpu') {
+        return new CpuFallbackProvider();
+    }
+    if (preference === 'gpu') {
+        const provider = new WebGpuSvdProvider();
+        if (await provider.available())
+            return provider;
+        // Explicit GPU request but unavailable — fall through to ONNX then CPU
+    }
+    if (preference === 'onnx') {
+        const provider = new OnnxSvdProvider();
+        if (await provider.available())
+            return provider;
+        // Explicit ONNX request but unavailable — fall through to CPU
+        return new CpuFallbackProvider();
+    }
+    // Auto-detect: try WebGPU first, then ONNX, then CPU
+    const webgpu = new WebGpuSvdProvider();
+    if (await webgpu.available())
+        return webgpu;
+    const onnx = new OnnxSvdProvider();
+    if (await onnx.available())
+        return onnx;
+    return new CpuFallbackProvider();
+}
+// ---------------------------------------------------------------------------
+// Local Linear Algebra Helpers (duplicated to avoid circular deps)
+// ---------------------------------------------------------------------------
+/** Matrix-vector multiply A * v. */
+function matVecMulLocal(A, m, n, v) {
+    const result = new Float64Array(m);
+    for (let i = 0; i < m; i++) {
+        let sum = 0;
+        const rowOff = i * n;
+        for (let j = 0; j < n; j++) {
+            sum += A[rowOff + j] * v[j];
+        }
+        result[i] = sum;
+    }
+    return result;
+}
+/** Matrix-transpose-vector multiply A^T * u. */
+function matTransVecMulLocal(A, m, n, u) {
+    const result = new Float64Array(n);
+    for (let j = 0; j < n; j++) {
+        let sum = 0;
+        for (let i = 0; i < m; i++) {
+            sum += A[i * n + j] * u[i];
+        }
+        result[j] = sum;
+    }
+    return result;
+}
+/** Euclidean norm of a vector. */
+function vecNormLocal(v) {
+    let sum = 0;
+    for (let i = 0; i < v.length; i++)
+        sum += v[i] * v[i];
+    return Math.sqrt(sum);
+}
+/** In-place normalisation. */
+function normalizeVecLocal(v) {
+    const n = vecNormLocal(v);
+    if (n > 1e-15)
+        scaleVecLocal(v, 1 / n);
+}
+/** In-place scalar multiply. */
+function scaleVecLocal(v, s) {
+    for (let i = 0; i < v.length; i++)
+        v[i] *= s;
+}
+//# sourceMappingURL=gpu-svd.js.map