deepbox 0.1.0

package/dist/chunk-AU7XHGKJ.js

@@ -0,0 +1,2092 @@
+import { tensor, isContiguous, Tensor } from './chunk-BCR7G3A6.js';
+import { __export, ShapeError, DataValidationError, InvalidParameterError, ConvergenceError, DeepboxError, normalizeAxes, normalizeAxis, getConfig, IndexError, DTypeError } from './chunk-4S73VUBD.js';
+
+// src/linalg/index.ts
+var linalg_exports = {};
+__export(linalg_exports, {
+  cholesky: () => cholesky,
+  cond: () => cond,
+  det: () => det,
+  eig: () => eig,
+  eigh: () => eigh,
+  eigvals: () => eigvals,
+  eigvalsh: () => eigvalsh,
+  inv: () => inv,
+  lstsq: () => lstsq,
+  lu: () => lu,
+  matrixRank: () => matrixRank,
+  norm: () => norm,
+  pinv: () => pinv,
+  qr: () => qr,
+  slogdet: () => slogdet,
+  solve: () => solve,
+  solveTriangular: () => solveTriangular,
+  svd: () => svd,
+  trace: () => trace
+});
+
+// src/linalg/_internal.ts
+function asMatrix2D(t) {
+  if (t.dtype === "string") {
+    throw new DTypeError("String tensors are not supported");
+  }
+  if (t.ndim !== 2) {
+    throw new ShapeError("Expected a 2D tensor");
+  }
+  const rows = t.shape[0];
+  const cols = t.shape[1];
+  if (rows === void 0 || cols === void 0) {
+    throw new ShapeError("Tensor shape metadata is inconsistent");
+  }
+  const strideRow = t.strides[0];
+  const strideCol = t.strides[1];
+  if (strideRow === void 0 || strideCol === void 0) {
+    throw new ShapeError("Tensor stride metadata is inconsistent");
+  }
+  const isRowMajorContiguous = strideCol === 1 && strideRow === cols;
+  return {
+    tensor: t,
+    rows,
+    cols,
+    offset: t.offset,
+    strideRow,
+    strideCol,
+    isRowMajorContiguous
+  };
+}
+function toDenseMatrix2D(t) {
+  const m = asMatrix2D(t);
+  const { rows, cols } = m;
+  const out = new Float64Array(rows * cols);
+  if (m.isRowMajorContiguous) {
+    const start = m.offset;
+    const end = start + rows * cols;
+    for (let i = 0, j = start; j < end; i++, j++) {
+      const val = Number(m.tensor.data[j]);
+      if (!Number.isFinite(val)) {
+        throw new DataValidationError("Input contains non-finite values");
+      }
+      out[i] = val;
+    }
+    return { rows, cols, data: out };
+  }
+  for (let i = 0; i < rows; i++) {
+    const base = m.offset + i * m.strideRow;
+    for (let j = 0; j < cols; j++) {
+      const val = Number(m.tensor.data[base + j * m.strideCol]);
+      if (!Number.isFinite(val)) {
+        throw new DataValidationError("Input contains non-finite values");
+      }
+      out[i * cols + j] = val;
+    }
+  }
+  return { rows, cols, data: out };
+}
+function toDenseVector1D(t) {
+  if (t.dtype === "string") {
+    throw new DTypeError("String tensors are not supported");
+  }
+  if (t.ndim !== 1) {
+    throw new ShapeError("Expected a 1D tensor");
+  }
+  const n = t.shape[0];
+  if (n === void 0) {
+    throw new ShapeError("Tensor shape metadata is inconsistent");
+  }
+  const stride = t.strides[0];
+  if (stride === void 0) {
+    throw new ShapeError("Tensor stride metadata is inconsistent");
+  }
+  const out = new Float64Array(n);
+  const base = t.offset;
+  for (let i = 0; i < n; i++) {
+    const val = Number(t.data[base + i * stride]);
+    if (!Number.isFinite(val)) {
+      throw new DataValidationError("Input contains non-finite values");
+    }
+    out[i] = val;
+  }
+  return out;
+}
+function fromDenseMatrix2D(rows, cols, data) {
+  const config = getConfig();
+  return Tensor.fromTypedArray({
+    data,
+    shape: [rows, cols],
+    dtype: "float64",
+    device: config.defaultDevice
+  });
+}
+function fromDenseVector1D(data) {
+  const config = getConfig();
+  return Tensor.fromTypedArray({
+    data,
+    shape: [data.length],
+    dtype: "float64",
+    device: config.defaultDevice
+  });
+}
+function luFactorSquare(a, n) {
+  const lu2 = new Float64Array(a);
+  const piv = new Int32Array(n);
+  for (let i = 0; i < n; i++) piv[i] = i;
+  let pivSign = 1;
+  for (let k = 0; k < n; k++) {
+    let maxRow = k;
+    let maxVal = Math.abs(at(lu2, k * n + k));
+    for (let i = k + 1; i < n; i++) {
+      const v = Math.abs(at(lu2, i * n + k));
+      if (v > maxVal) {
+        maxVal = v;
+        maxRow = i;
+      }
+    }
+    if (!Number.isFinite(maxVal) || maxVal === 0) {
+      throw new DataValidationError("Matrix is singular");
+    }
+    if (maxRow !== k) {
+      for (let j = 0; j < n; j++) {
+        const tmp = at(lu2, k * n + j);
+        lu2[k * n + j] = at(lu2, maxRow * n + j);
+        lu2[maxRow * n + j] = tmp;
+      }
+      const tp = atInt(piv, k);
+      piv[k] = atInt(piv, maxRow);
+      piv[maxRow] = tp;
+      pivSign = -pivSign;
+    }
+    const pivot = at(lu2, k * n + k);
+    for (let i = k + 1; i < n; i++) {
+      lu2[i * n + k] = at(lu2, i * n + k) / pivot;
+      const lik = at(lu2, i * n + k);
+      for (let j = k + 1; j < n; j++) {
+        lu2[i * n + j] = at(lu2, i * n + j) - lik * at(lu2, k * n + j);
+      }
+    }
+  }
+  return { lu: lu2, piv, pivSign };
+}
+function luSolveInPlace(lu2, piv, n, b, nrhs) {
+  const b0 = new Float64Array(b);
+  for (let i = 0; i < n; i++) {
+    const pi = atInt(piv, i);
+    for (let j = 0; j < nrhs; j++) {
+      b[i * nrhs + j] = at(b0, pi * nrhs + j);
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < nrhs; j++) {
+      let sum = at(b, i * nrhs + j);
+      for (let k = 0; k < i; k++) {
+        sum -= at(lu2, i * n + k) * at(b, k * nrhs + j);
+      }
+      b[i * nrhs + j] = sum;
+    }
+  }
+  for (let i = n - 1; i >= 0; i--) {
+    const diag = at(lu2, i * n + i);
+    if (diag === 0) throw new DataValidationError("Matrix is singular");
+    for (let j = 0; j < nrhs; j++) {
+      let sum = at(b, i * nrhs + j);
+      for (let k = i + 1; k < n; k++) {
+        sum -= at(lu2, i * n + k) * at(b, k * nrhs + j);
+      }
+      b[i * nrhs + j] = sum / diag;
+    }
+  }
+}
+function at(arr, i) {
+  const value = arr[i];
+  if (value === void 0) {
+    throw new IndexError(`Index ${i} is out of bounds for Float64Array length ${arr.length}`, {
+      index: i,
+      validRange: [0, Math.max(0, arr.length - 1)]
+    });
+  }
+  return value;
+}
+function atArr(arr, i) {
+  const value = arr[i];
+  if (value === void 0) {
+    throw new IndexError(`Index ${i} is out of bounds for array length ${arr.length}`, {
+      index: i,
+      validRange: [0, Math.max(0, arr.length - 1)]
+    });
+  }
+  return value;
+}
+function atInt(arr, i) {
+  const value = arr[i];
+  if (value === void 0) {
+    throw new IndexError(`Index ${i} is out of bounds for Int32Array length ${arr.length}`, {
+      index: i,
+      validRange: [0, Math.max(0, arr.length - 1)]
+    });
+  }
+  return value;
+}
+function getDim(t, axis, context) {
+  const dim = t.shape[axis];
+  if (dim === void 0) {
+    throw new ShapeError(`${context}: missing dimension for axis ${axis}`);
+  }
+  return dim;
+}
+function getStride(t, axis, context) {
+  const stride = t.strides[axis];
+  if (stride === void 0) {
+    throw new ShapeError(`${context}: missing stride for axis ${axis}`);
+  }
+  return stride;
+}
+function assertFiniteTensor(t, context) {
+  if (t.dtype === "string") {
+    throw new DTypeError(`${context} does not support string dtype`);
+  }
+  if (t.size === 0) return;
+  const ndim = t.ndim;
+  if (ndim === 0) {
+    const val = Number(t.data[t.offset]);
+    if (!Number.isFinite(val)) {
+      throw new DataValidationError(`${context} contains non-finite values`);
+    }
+    return;
+  }
+  const shape = t.shape;
+  const strides = t.strides;
+  const data = t.data;
+  if (!Array.isArray(data) && !(data instanceof BigInt64Array) && t.offset === 0) {
+    let contiguous = true;
+    let expected = 1;
+    for (let i = ndim - 1; i >= 0; i--) {
+      if (strides[i] !== expected) {
+        contiguous = false;
+        break;
+      }
+      expected *= shape[i] ?? 1;
+    }
+    if (contiguous) {
+      for (let i = 0; i < t.size; i++) {
+        const val = data[i];
+        if (!Number.isFinite(val)) {
+          throw new DataValidationError(`${context} contains non-finite values`);
+        }
+      }
+      return;
+    }
+  }
+  const idx = new Array(ndim).fill(0);
+  let offset = t.offset;
+  for (let count = 0; count < t.size; count++) {
+    const val = Number(data[offset]);
+    if (!Number.isFinite(val)) {
+      throw new DataValidationError(`${context} contains non-finite values`);
+    }
+    for (let d = ndim - 1; d >= 0; d--) {
+      const dim = shape[d];
+      const stride = strides[d];
+      if (dim === void 0 || stride === void 0) {
+        throw new ShapeError(`${context}: tensor metadata is inconsistent`);
+      }
+      const idxVal = idx[d] ?? 0;
+      const nextIdx = idxVal + 1;
+      idx[d] = nextIdx;
+      offset += stride;
+      if (nextIdx < dim) {
+        break;
+      }
+      offset -= nextIdx * stride;
+      idx[d] = 0;
+    }
+  }
+}
+
+// src/linalg/decomposition/cholesky.ts
+function cholesky(a) {
+  if (a.ndim !== 2) {
+    throw new ShapeError("Input must be a 2D matrix");
+  }
+  const rows = getDim(a, 0, "cholesky()");
+  const cols = getDim(a, 1, "cholesky()");
+  if (rows !== cols) {
+    throw new ShapeError("cholesky requires a square matrix");
+  }
+  const n = rows;
+  if (n === 0) {
+    return fromDenseMatrix2D(0, 0, new Float64Array(0));
+  }
+  const { data: A } = toDenseMatrix2D(a);
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const aij = at(A, i * n + j);
+      const aji = at(A, j * n + i);
+      if (Math.abs(aij - aji) > 1e-10) {
+        throw new DataValidationError("Matrix must be symmetric");
+      }
+    }
+  }
+  const L = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j <= i; j++) {
+      let sum = 0;
+      if (j === i) {
+        for (let k = 0; k < j; k++) {
+          const Lik = at(L, i * n + k);
+          sum += Lik * Lik;
+        }
+        const val = at(A, i * n + i) - sum;
+        if (val <= 0) {
+          throw new DataValidationError("Matrix is not positive definite");
+        }
+        L[i * n + i] = Math.sqrt(val);
+      } else {
+        for (let k = 0; k < j; k++) {
+          sum += at(L, i * n + k) * at(L, j * n + k);
+        }
+        const Ljj = at(L, j * n + j);
+        L[i * n + j] = (at(A, i * n + j) - sum) / Ljj;
+      }
+    }
+  }
+  return fromDenseMatrix2D(n, n, L);
+}
+
+// src/linalg/decomposition/svd.ts
+function identityMatrix(n) {
+  const out = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) out[i * n + i] = 1;
+  return out;
+}
+function fillOrthonormalColumn(mat, rows, cols, col) {
+  for (let basis = 0; basis < rows; basis++) {
+    const vec = new Float64Array(rows);
+    vec[basis] = 1;
+    for (let j = 0; j < col; j++) {
+      let dot = 0;
+      for (let i = 0; i < rows; i++) {
+        dot += at(mat, i * cols + j) * at(vec, i);
+      }
+      for (let i = 0; i < rows; i++) {
+        vec[i] = at(vec, i) - dot * at(mat, i * cols + j);
+      }
+    }
+    let norm2 = 0;
+    for (let i = 0; i < rows; i++) {
+      const v = at(vec, i);
+      norm2 += v * v;
+    }
+    norm2 = Math.sqrt(norm2);
+    if (norm2 > 1e-12) {
+      const inv2 = 1 / norm2;
+      for (let i = 0; i < rows; i++) {
+        mat[i * cols + col] = at(vec, i) * inv2;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function completeOrthonormalColumns(mat, rows, cols, startCol) {
+  for (let col = startCol; col < cols; col++) {
+    fillOrthonormalColumn(mat, rows, cols, col);
+  }
+}
+function jacobiSVDCols(a, m, n, maxSweeps = 100, tol = 1e-12) {
+  const B = new Float64Array(a);
+  const V = identityMatrix(n);
+  if (m === 0 || n === 0) return { B, V };
+  for (let sweep = 0; sweep < maxSweeps; sweep++) {
+    let maxCorr = 0;
+    for (let p = 0; p < n - 1; p++) {
+      for (let q = p + 1; q < n; q++) {
+        let alpha = 0;
+        let beta = 0;
+        let gamma = 0;
+        for (let i = 0; i < m; i++) {
+          const ip = at(B, i * n + p);
+          const iq = at(B, i * n + q);
+          alpha += ip * ip;
+          beta += iq * iq;
+          gamma += ip * iq;
+        }
+        if (alpha === 0 || beta === 0) continue;
+        const denom = Math.sqrt(alpha * beta);
+        if (denom === 0) continue;
+        const corr = Math.abs(gamma) / denom;
+        if (corr > maxCorr) maxCorr = corr;
+        if (corr <= tol) continue;
+        const tau = (beta - alpha) / (2 * gamma);
+        const sign = tau >= 0 ? 1 : -1;
+        const t = sign / (Math.abs(tau) + Math.sqrt(1 + tau * tau));
+        const c = 1 / Math.sqrt(1 + t * t);
+        const s = c * t;
+        for (let i = 0; i < m; i++) {
+          const ip = at(B, i * n + p);
+          const iq = at(B, i * n + q);
+          B[i * n + p] = c * ip - s * iq;
+          B[i * n + q] = s * ip + c * iq;
+        }
+        for (let i = 0; i < n; i++) {
+          const vip = at(V, i * n + p);
+          const viq = at(V, i * n + q);
+          V[i * n + p] = c * vip - s * viq;
+          V[i * n + q] = s * vip + c * viq;
+        }
+      }
+    }
+    if (maxCorr <= tol) break;
+  }
+  return { B, V };
+}
+function emptySvd(m, n, fullMatrices) {
+  const k = Math.min(m, n);
+  const s = new Float64Array(0);
+  if (!fullMatrices) {
+    return [
+      fromDenseMatrix2D(m, k, new Float64Array(m * k)),
+      fromDenseVector1D(s),
+      fromDenseMatrix2D(k, n, new Float64Array(k * n))
+    ];
+  }
+  const Ufull = identityMatrix(m);
+  const VtFull = identityMatrix(n);
+  return [fromDenseMatrix2D(m, m, Ufull), fromDenseVector1D(s), fromDenseMatrix2D(n, n, VtFull)];
+}
+function buildSvdFromJacobi(B, V, m, n, fullMatrices) {
+  const k = Math.min(m, n);
+  const norms = new Float64Array(n);
+  let maxSigma = 0;
+  for (let j = 0; j < n; j++) {
+    let sum = 0;
+    for (let i = 0; i < m; i++) {
+      const v = at(B, i * n + j);
+      sum += v * v;
+    }
+    const sigma = Math.sqrt(sum);
+    norms[j] = sigma;
+    if (sigma > maxSigma) maxSigma = sigma;
+  }
+  const idx = new Array(n);
+  for (let i = 0; i < n; i++) idx[i] = i;
+  idx.sort((i, j) => at(norms, j) - at(norms, i));
+  const sigmaTol = Number.EPSILON * Math.max(m, n) * (maxSigma || 1);
+  const s = new Float64Array(k);
+  const U = new Float64Array(m * k);
+  const filled = new Array(k).fill(false);
+  for (let j = 0; j < k; j++) {
+    const col = idx[j] ?? 0;
+    const sigma = norms[col] ?? 0;
+    s[j] = sigma;
+    if (sigma > sigmaTol) {
+      const inv2 = 1 / sigma;
+      for (let i = 0; i < m; i++) {
+        U[i * k + j] = at(B, i * n + col) * inv2;
+      }
+      filled[j] = true;
+    }
+  }
+  for (let j = 0; j < k; j++) {
+    if (!filled[j]) {
+      fillOrthonormalColumn(U, m, k, j);
+    }
+  }
+  const Vsorted = new Float64Array(n * n);
+  for (let j = 0; j < n; j++) {
+    const col = idx[j] ?? 0;
+    for (let i = 0; i < n; i++) {
+      Vsorted[i * n + j] = at(V, i * n + col);
+    }
+  }
+  if (!fullMatrices) {
+    const Vt = new Float64Array(k * n);
+    for (let i = 0; i < k; i++) {
+      for (let j = 0; j < n; j++) {
+        Vt[i * n + j] = at(Vsorted, j * n + i);
+      }
+    }
+    return [fromDenseMatrix2D(m, k, U), fromDenseVector1D(s), fromDenseMatrix2D(k, n, Vt)];
+  }
+  let Ufull = U;
+  if (m !== k) {
+    Ufull = new Float64Array(m * m);
+    for (let j = 0; j < k; j++) {
+      for (let i = 0; i < m; i++) {
+        Ufull[i * m + j] = at(U, i * k + j);
+      }
+    }
+    completeOrthonormalColumns(Ufull, m, m, k);
+  }
+  const VtFull = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      VtFull[i * n + j] = at(Vsorted, j * n + i);
+    }
+  }
+  return [fromDenseMatrix2D(m, m, Ufull), fromDenseVector1D(s), fromDenseMatrix2D(n, n, VtFull)];
+}
+function buildSvdFromJacobiTransposed(B, V, m, n, fullMatrices) {
+  const k = Math.min(m, n);
+  const norms = new Float64Array(k);
+  let maxSigma = 0;
+  for (let j = 0; j < k; j++) {
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+      const v = at(B, i * k + j);
+      sum += v * v;
+    }
+    const sigma = Math.sqrt(sum);
+    norms[j] = sigma;
+    if (sigma > maxSigma) maxSigma = sigma;
+  }
+  const idx = new Array(k);
+  for (let i = 0; i < k; i++) idx[i] = i;
+  idx.sort((i, j) => at(norms, j) - at(norms, i));
+  const sigmaTol = Number.EPSILON * Math.max(m, n) * (maxSigma || 1);
+  const s = new Float64Array(k);
+  const U = new Float64Array(m * k);
+  const Vcols = new Float64Array(n * k);
+  const filledV = new Array(k).fill(false);
+  for (let j = 0; j < k; j++) {
+    const col = idx[j] ?? 0;
+    const sigma = norms[col] ?? 0;
+    s[j] = sigma;
+    for (let i = 0; i < m; i++) {
+      U[i * k + j] = at(V, i * k + col);
+    }
+    if (sigma > sigmaTol) {
+      const inv2 = 1 / sigma;
+      for (let i = 0; i < n; i++) {
+        Vcols[i * k + j] = at(B, i * k + col) * inv2;
+      }
+      filledV[j] = true;
+    }
+  }
+  for (let j = 0; j < k; j++) {
+    if (!filledV[j]) {
+      fillOrthonormalColumn(Vcols, n, k, j);
+    }
+  }
+  if (!fullMatrices) {
+    const Vt = new Float64Array(k * n);
+    for (let i = 0; i < k; i++) {
+      for (let j = 0; j < n; j++) {
+        Vt[i * n + j] = at(Vcols, j * k + i);
+      }
+    }
+    return [fromDenseMatrix2D(m, k, U), fromDenseVector1D(s), fromDenseMatrix2D(k, n, Vt)];
+  }
+  let Vfull = Vcols;
+  if (n !== k) {
+    Vfull = new Float64Array(n * n);
+    for (let j = 0; j < k; j++) {
+      for (let i = 0; i < n; i++) {
+        Vfull[i * n + j] = at(Vcols, i * k + j);
+      }
+    }
+    completeOrthonormalColumns(Vfull, n, n, k);
+  }
+  const VtFull = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      VtFull[i * n + j] = at(Vfull, j * n + i);
+    }
+  }
+  return [fromDenseMatrix2D(m, m, U), fromDenseVector1D(s), fromDenseMatrix2D(n, n, VtFull)];
+}
+function svd(a, fullMatrices = true) {
+  if (a.ndim !== 2) throw new ShapeError("Input must be 2D matrix");
+  const m = getDim(a, 0, "svd()");
+  const n = getDim(a, 1, "svd()");
+  if (m === 0 || n === 0) {
+    return emptySvd(m, n, fullMatrices);
+  }
+  const { data: A } = toDenseMatrix2D(a);
+  const maxSweeps = 100;
+  const tol = 1e-12;
+  if (m >= n) {
+    const { B: B2, V: V2 } = jacobiSVDCols(A, m, n, maxSweeps, tol);
+    return buildSvdFromJacobi(B2, V2, m, n, fullMatrices);
+  }
+  const At = new Float64Array(n * m);
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      At[j * m + i] = at(A, i * n + j);
+    }
+  }
+  const { B, V } = jacobiSVDCols(At, n, m, maxSweeps, tol);
+  return buildSvdFromJacobiTransposed(B, V, m, n, fullMatrices);
+}
+
+// src/linalg/decomposition/eig.ts
+function getSquareMatrixSize(a, context) {
+  if (a.ndim !== 2) {
+    throw new ShapeError(`${context}: input must be 2D matrix`);
+  }
+  const rows = a.shape[0];
+  const cols = a.shape[1];
+  if (rows === void 0 || cols === void 0 || rows !== cols) {
+    throw new ShapeError(`${context}: input must be square matrix`);
+  }
+  return rows;
+}
+function jacobiEigenSymmetric(a, n, maxSweeps = 100, tol = 1e-12) {
+  const A = new Float64Array(a);
+  const V = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) V[i * n + i] = 1;
+  for (let sweep = 0; sweep < maxSweeps; sweep++) {
+    let p = 0;
+    let q = 1;
+    let max = 0;
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        const v = Math.abs(at(A, i * n + j));
+        if (v > max) {
+          max = v;
+          p = i;
+          q = j;
+        }
+      }
+    }
+    if (max < tol) break;
+    const app = at(A, p * n + p);
+    const aqq = at(A, q * n + q);
+    const apq = at(A, p * n + q);
+    if (apq === 0) continue;
+    const tau = (aqq - app) / (2 * apq);
+    const sign = tau >= 0 ? 1 : -1;
+    const t = sign / (Math.abs(tau) + Math.sqrt(1 + tau * tau));
+    const c = 1 / Math.sqrt(1 + t * t);
+    const s = t * c;
+    for (let k = 0; k < n; k++) {
+      if (k === p || k === q) continue;
+      const aik = at(A, k * n + p);
+      const akq = at(A, k * n + q);
+      const newAik = c * aik - s * akq;
+      const newAkq = s * aik + c * akq;
+      A[k * n + p] = newAik;
+      A[p * n + k] = newAik;
+      A[k * n + q] = newAkq;
+      A[q * n + k] = newAkq;
+    }
+    const newApp = c * c * app - 2 * s * c * apq + s * s * aqq;
+    const newAqq = s * s * app + 2 * s * c * apq + c * c * aqq;
+    A[p * n + p] = newApp;
+    A[q * n + q] = newAqq;
+    A[p * n + q] = 0;
+    A[q * n + p] = 0;
+    for (let k = 0; k < n; k++) {
+      const vkp = at(V, k * n + p);
+      const vkq = at(V, k * n + q);
+      V[k * n + p] = c * vkp - s * vkq;
+      V[k * n + q] = s * vkp + c * vkq;
+    }
+  }
+  const values = new Float64Array(n);
+  for (let i = 0; i < n; i++) values[i] = at(A, i * n + i);
+  return { values, vectors: V };
+}
+function matmulSquare(a, b, n) {
+  const out = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      let sum = 0;
+      for (let k = 0; k < n; k++) {
+        sum += at(a, i * n + k) * at(b, k * n + j);
+      }
+      out[i * n + j] = sum;
+    }
+  }
+  return out;
+}
+function qrFactorSquare(a, n) {
+  const Q = new Float64Array(n * n);
+  const R = new Float64Array(n * n);
+  const v = new Float64Array(n * n);
+  v.set(a);
+  const fillOrthonormalColumn2 = (col) => {
+    for (let basis = 0; basis < n; basis++) {
+      const vec = new Float64Array(n);
+      vec[basis] = 1;
+      for (let j = 0; j < col; j++) {
+        let dot = 0;
+        for (let k = 0; k < n; k++) {
+          dot += at(Q, k * n + j) * at(vec, k);
+        }
+        for (let k = 0; k < n; k++) {
+          vec[k] = at(vec, k) - dot * at(Q, k * n + j);
+        }
+      }
+      let norm2 = 0;
+      for (let k = 0; k < n; k++) {
+        const val = at(vec, k);
+        norm2 += val * val;
+      }
+      norm2 = Math.sqrt(norm2);
+      if (norm2 > 1e-12) {
+        const inv2 = 1 / norm2;
+        for (let k = 0; k < n; k++) {
+          Q[k * n + col] = at(vec, k) * inv2;
+        }
+        return;
+      }
+    }
+  };
+  for (let j = 0; j < n; j++) {
+    for (let i = 0; i < j; i++) {
+      let dot = 0;
+      for (let k = 0; k < n; k++) {
+        dot += at(Q, k * n + i) * at(v, k * n + j);
+      }
+      R[i * n + j] = dot;
+      for (let k = 0; k < n; k++) {
+        v[k * n + j] = at(v, k * n + j) - dot * at(Q, k * n + i);
+      }
+    }
+    let norm2 = 0;
+    for (let k = 0; k < n; k++) {
+      const x = at(v, k * n + j);
+      norm2 += x * x;
+    }
+    norm2 = Math.sqrt(norm2);
+    R[j * n + j] = norm2;
+    if (norm2 > 1e-12) {
+      const inv2 = 1 / norm2;
+      for (let k = 0; k < n; k++) {
+        Q[k * n + j] = at(v, k * n + j) * inv2;
+      }
+    } else {
+      fillOrthonormalColumn2(j);
+    }
+  }
+  return { Q, R };
+}
+function hessenbergReduce(a, n) {
+  const H = new Float64Array(a);
+  const Q = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) Q[i * n + i] = 1;
+  const v = new Float64Array(n);
+  for (let col = 0; col < n - 2; col++) {
+    let norm2 = 0;
+    for (let i = col + 1; i < n; i++) {
+      const val = at(H, i * n + col);
+      v[i] = val;
+      norm2 += val * val;
+    }
+    norm2 = Math.sqrt(norm2);
+    if (norm2 < 1e-14) continue;
+    const vkp1 = at(v, col + 1);
+    const sign = vkp1 >= 0 ? 1 : -1;
+    v[col + 1] = vkp1 + sign * norm2;
+    let vnorm = 0;
+    for (let i = col + 1; i < n; i++) {
+      const val = at(v, i);
+      vnorm += val * val;
+    }
+    vnorm = Math.sqrt(vnorm);
+    if (vnorm < 1e-14) continue;
+    for (let i = col + 1; i < n; i++) {
+      v[i] = at(v, i) / vnorm;
+    }
+    for (let j = col; j < n; j++) {
+      let dot = 0;
+      for (let i = col + 1; i < n; i++) {
+        dot += at(v, i) * at(H, i * n + j);
+      }
+      dot *= 2;
+      for (let i = col + 1; i < n; i++) {
+        H[i * n + j] = at(H, i * n + j) - dot * at(v, i);
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      let dot = 0;
+      for (let j = col + 1; j < n; j++) {
+        dot += at(H, i * n + j) * at(v, j);
+      }
+      dot *= 2;
+      for (let j = col + 1; j < n; j++) {
+        H[i * n + j] = at(H, i * n + j) - dot * at(v, j);
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      let dot = 0;
+      for (let j = col + 1; j < n; j++) {
+        dot += at(Q, i * n + j) * at(v, j);
+      }
+      dot *= 2;
+      for (let j = col + 1; j < n; j++) {
+        Q[i * n + j] = at(Q, i * n + j) - dot * at(v, j);
+      }
+    }
+  }
+  return { H, Q };
+}
+function eig(a, options = {}) {
+  const n = getSquareMatrixSize(a, "eig");
+  if (n === 0) {
+    return [fromDenseVector1D(new Float64Array(0)), fromDenseMatrix2D(0, 0, new Float64Array(0))];
+  }
+  const { data: A0 } = toDenseMatrix2D(a);
+  let symmetric = true;
+  for (let i = 0; i < n && symmetric; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const aij = at(A0, i * n + j);
+      const aji = at(A0, j * n + i);
+      if (Math.abs(aij - aji) > 1e-10) {
+        symmetric = false;
+        break;
+      }
+    }
+  }
+  if (symmetric) {
+    return eigh(a);
+  }
+  const { H } = hessenbergReduce(A0, n);
+  const maxIter = options.maxIter ?? 300;
+  const convTol = options.tol ?? 1e-10;
+  let Ak = H;
+  let converged = false;
+  for (let iter = 0; iter < maxIter; iter++) {
+    let off = 0;
+    for (let i = 1; i < n; i++) {
+      const v = at(Ak, i * n + (i - 1));
+      off += v * v;
+    }
+    if (Math.sqrt(off) < convTol) {
+      converged = true;
+      break;
+    }
+    const mu = at(Ak, (n - 1) * n + (n - 1));
+    const shifted = new Float64Array(Ak);
+    for (let i = 0; i < n; i++) {
+      shifted[i * n + i] = at(shifted, i * n + i) - mu;
+    }
+    const { Q, R } = qrFactorSquare(shifted, n);
+    Ak = matmulSquare(R, Q, n);
+    for (let i = 0; i < n; i++) {
+      Ak[i * n + i] = at(Ak, i * n + i) + mu;
+    }
+  }
+  for (let i = 1; i < n; i++) {
+    const v = at(Ak, i * n + (i - 1));
+    if (Math.abs(v) < convTol) {
+      Ak[i * n + (i - 1)] = 0;
+    }
+  }
+  const complexTol = 1e-8;
+  let hasComplex = false;
+  for (let i = 0; i < n - 1; i++) {
+    const subdiag = Math.abs(at(Ak, (i + 1) * n + i));
+    if (subdiag > complexTol) {
+      const a11 = at(Ak, i * n + i);
+      const a12 = at(Ak, i * n + (i + 1));
+      const a21 = at(Ak, (i + 1) * n + i);
+      const a22 = at(Ak, (i + 1) * n + (i + 1));
+      const discriminant = (a11 - a22) * (a11 - a22) + 4 * a12 * a21;
+      if (discriminant < -complexTol) {
+        hasComplex = true;
+        break;
+      }
+    }
+  }
+  if (hasComplex) {
+    throw new InvalidParameterError(
+      "Matrix has complex eigenvalues, which are not supported. Only matrices with real eigenvalues can be decomposed. Symmetric matrices always have real eigenvalues.",
+      "a"
+    );
+  }
+  if (!converged) {
+    throw new ConvergenceError(`eig() failed to converge after ${maxIter} iterations`, {
+      iterations: maxIter,
+      tolerance: convTol
+    });
+  }
+  const evals = new Float64Array(n);
+  for (let i = 0; i < n; i++) evals[i] = at(Ak, i * n + i);
+  const vectors = new Float64Array(n * n);
+  const used = new Array(n).fill(false);
+  const clusterTol = 1e-8;
+  for (let i = 0; i < n; i++) {
+    if (used[i]) continue;
+    const lambda = at(evals, i);
+    const cluster = [i];
+    used[i] = true;
+    for (let j = i + 1; j < n; j++) {
+      if (used[j]) continue;
+      const diff = Math.abs(at(evals, j) - lambda);
+      const scale = Math.max(1, Math.abs(lambda));
+      if (diff <= clusterTol * scale) {
+        used[j] = true;
+        cluster.push(j);
+      }
+    }
+    const basis = (() => {
+      const M = new Float64Array(A0);
+      for (let d = 0; d < n; d++) {
+        M[d * n + d] = at(M, d * n + d) - lambda;
+      }
+      const [_, s, Vt] = svd(fromDenseMatrix2D(n, n, M), true);
+      const sDense = toDenseVector1D(s);
+      const { data: VtData } = toDenseMatrix2D(Vt);
+      const vData = new Float64Array(n * n);
+      for (let r = 0; r < n; r++) {
+        for (let c = 0; c < n; c++) {
+          vData[r * n + c] = at(VtData, c * n + r);
+        }
+      }
+      const sMax = sDense.length === 0 ? 0 : at(sDense, 0);
+      const tol = Number.EPSILON * n * sMax;
+      const basisVecs = [];
+      for (let r = sDense.length - 1; r >= 0; r--) {
+        if (at(sDense, r) <= tol) {
+          const vec = new Float64Array(n);
+          for (let c = 0; c < n; c++) {
+            vec[c] = at(vData, c * n + r);
+          }
+          basisVecs.push(vec);
+        }
+      }
+      if (basisVecs.length === 0 && sDense.length > 0) {
+        const r = sDense.length - 1;
+        const vec = new Float64Array(n);
+        for (let c = 0; c < n; c++) {
+          vec[c] = at(vData, c * n + r);
+        }
+        basisVecs.push(vec);
+      }
+      return basisVecs.length === 0 ? [new Float64Array(n)] : basisVecs;
+    })();
+    for (let b = 0; b < cluster.length; b++) {
+      const colIndex = cluster[b];
+      if (colIndex === void 0) {
+        throw new ShapeError("eig(): eigenvector index is missing");
+      }
+      const vec = basis[b % basis.length];
+      if (vec === void 0) {
+        throw new ShapeError("eig(): eigenvector basis is missing");
+      }
+      let norm2 = 0;
+      for (let r = 0; r < n; r++) {
+        const v = at(vec, r);
+        norm2 += v * v;
+      }
+      if (norm2 === 0) {
+        for (let r = 0; r < n; r++) {
+          vectors[r * n + colIndex] = r === colIndex ? 1 : 0;
+        }
+        continue;
+      }
+      const inv2 = 1 / Math.sqrt(norm2);
+      for (let r = 0; r < n; r++) {
+        vectors[r * n + colIndex] = at(vec, r) * inv2;
+      }
+    }
+  }
+  return [fromDenseVector1D(evals), fromDenseMatrix2D(n, n, vectors)];
+}
+function eigvals(a, options) {
+  const [eigenvalues] = eig(a, options);
+  return eigenvalues;
+}
+function eigvalsh(a) {
+  const n = getSquareMatrixSize(a, "eigvalsh");
+  const { data: A } = toDenseMatrix2D(a);
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const aij = at(A, i * n + j);
+      const aji = at(A, j * n + i);
+      if (Math.abs(aij - aji) > 1e-10) {
+        throw new DataValidationError("Input must be symmetric for eigvalsh");
+      }
+    }
+  }
+  const [eigenvalues] = eigh(a);
+  return eigenvalues;
+}
+function eigh(a) {
+  const n = getSquareMatrixSize(a, "eigh");
+  if (n === 0) {
+    return [fromDenseVector1D(new Float64Array(0)), fromDenseMatrix2D(0, 0, new Float64Array(0))];
+  }
+  const { data: A } = toDenseMatrix2D(a);
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const aij = at(A, i * n + j);
+      const aji = at(A, j * n + i);
+      if (Math.abs(aij - aji) > 1e-10) {
+        throw new DataValidationError("Input must be symmetric for eigh");
+      }
+    }
+  }
+  const { values, vectors } = jacobiEigenSymmetric(A, n);
+  const idx = new Array(n);
+  for (let i = 0; i < n; i++) idx[i] = i;
+  idx.sort((i, j) => at(values, i) - at(values, j));
+  const outVals = new Float64Array(n);
+  const outVecs = new Float64Array(n * n);
+  for (let col = 0; col < n; col++) {
+    const src = atArr(idx, col);
+    outVals[col] = at(values, src);
+    for (let row = 0; row < n; row++) {
+      outVecs[row * n + col] = at(vectors, row * n + src);
+    }
+  }
+  return [fromDenseVector1D(outVals), fromDenseMatrix2D(n, n, outVecs)];
+}
+
+// src/linalg/decomposition/lu.ts
+function lu(a) {
+  if (a.ndim !== 2) throw new ShapeError("Input must be 2D matrix");
+  const m = getDim(a, 0, "lu()");
+  const n = getDim(a, 1, "lu()");
+  const k = Math.min(m, n);
+  const { data: A0 } = toDenseMatrix2D(a);
+  const Ufull = new Float64Array(A0);
+  const Lfull = new Float64Array(m * k);
+  for (let i = 0; i < Math.min(m, k); i++) Lfull[i * k + i] = 1;
+  const piv = new Int32Array(m);
+  for (let i = 0; i < m; i++) piv[i] = i;
+  for (let col = 0; col < k; col++) {
+    let maxRow = col;
+    let maxVal = Math.abs(at(Ufull, col * n + col));
+    for (let i = col + 1; i < m; i++) {
+      const v = Math.abs(at(Ufull, i * n + col));
+      if (v > maxVal) {
+        maxVal = v;
+        maxRow = i;
+      }
+    }
+    if (maxRow !== col) {
+      for (let j = 0; j < n; j++) {
+        const tmp = at(Ufull, col * n + j);
+        Ufull[col * n + j] = at(Ufull, maxRow * n + j);
+        Ufull[maxRow * n + j] = tmp;
+      }
+      for (let j = 0; j < col; j++) {
+        const tmp = at(Lfull, col * k + j);
+        Lfull[col * k + j] = at(Lfull, maxRow * k + j);
+        Lfull[maxRow * k + j] = tmp;
+      }
+      const tp = atInt(piv, col);
+      piv[col] = atInt(piv, maxRow);
+      piv[maxRow] = tp;
+    }
+    const pivot = at(Ufull, col * n + col);
+    if (pivot === 0) continue;
+    for (let i = col + 1; i < m; i++) {
+      const factor = at(Ufull, i * n + col) / pivot;
+      Lfull[i * k + col] = factor;
+      Ufull[i * n + col] = factor;
+      for (let j = col + 1; j < n; j++) {
+        Ufull[i * n + j] = at(Ufull, i * n + j) - factor * at(Ufull, col * n + j);
+      }
+    }
+  }
+  const Pfull = new Float64Array(m * m);
+  for (let i = 0; i < m; i++) {
+    const pi = atInt(piv, i);
+    Pfull[i * m + pi] = 1;
+  }
+  const U = new Float64Array(k * n);
+  for (let i = 0; i < k; i++) {
+    for (let j = 0; j < n; j++) {
+      U[i * n + j] = i <= j ? at(Ufull, i * n + j) : 0;
+    }
+  }
+  return [
+    fromDenseMatrix2D(m, m, Pfull),
+    fromDenseMatrix2D(m, k, Lfull),
+    fromDenseMatrix2D(k, n, U)
+  ];
+}
+
+// src/linalg/decomposition/qr.ts
+function qr(a, mode = "reduced") {
+  if (a.ndim !== 2) throw new ShapeError("Input must be 2D matrix");
+  const m = getDim(a, 0, "qr()");
+  const n = getDim(a, 1, "qr()");
+  const minDim = Math.min(m, n);
+  const { data: A_data } = toDenseMatrix2D(a);
+  const R = new Float64Array(A_data);
+  const Q = new Float64Array(m * m);
+  for (let i = 0; i < m; i++) {
+    Q[i * m + i] = 1;
+  }
+  const v = new Float64Array(m);
+  const w = new Float64Array(m);
+  for (let k = 0; k < minDim; k++) {
+    let normXSq = 0;
+    for (let i = k; i < m; i++) {
+      const val = at(R, i * n + k);
+      normXSq += val * val;
+    }
+    if (normXSq < 1e-15) continue;
+    const normX = Math.sqrt(normXSq);
+    const x0 = at(R, k * n + k);
+    const sign = x0 >= 0 ? 1 : -1;
+    const alpha = -sign * normX;
+    v.fill(0);
+    v[k] = x0 - alpha;
+    for (let i = k + 1; i < m; i++) {
+      v[i] = at(R, i * n + k);
+    }
+    let normVSq = 0;
+    for (let i = k; i < m; i++) {
+      const vi = at(v, i);
+      normVSq += vi * vi;
+    }
+    const normV = Math.sqrt(normVSq);
+    if (normV < 1e-15) continue;
+    const invNormV = 1 / normV;
+    for (let i = k; i < m; i++) {
+      v[i] = at(v, i) * invNormV;
+    }
+    for (let j = k; j < n; j++) {
+      let dot = 0;
+      for (let i = k; i < m; i++) {
+        dot += at(v, i) * at(R, i * n + j);
+      }
+      for (let i = k; i < m; i++) {
+        R[i * n + j] = at(R, i * n + j) - 2 * dot * at(v, i);
+      }
+    }
+    R[k * n + k] = alpha;
+    for (let i = k + 1; i < m; i++) {
+      R[i * n + k] = 0;
+    }
+    w.fill(0);
+    for (let i = 0; i < m; i++) {
+      let dot = 0;
+      for (let j = k; j < m; j++) {
+        dot += at(Q, i * m + j) * at(v, j);
+      }
+      w[i] = dot;
+    }
+    for (let j = k; j < m; j++) {
+      const vj = at(v, j);
+      for (let i = 0; i < m; i++) {
+        Q[i * m + j] = at(Q, i * m + j) - 2 * at(w, i) * vj;
+      }
+    }
+  }
+  if (mode === "reduced") {
+    const k = minDim;
+    const Q_reduced = new Float64Array(m * k);
+    for (let i = 0; i < m; i++) {
+      for (let j = 0; j < k; j++) {
+        Q_reduced[i * k + j] = at(Q, i * m + j);
+      }
+    }
+    const R_reduced = new Float64Array(k * n);
+    for (let i = 0; i < k; i++) {
+      for (let j = 0; j < n; j++) {
+        R_reduced[i * n + j] = at(R, i * n + j);
+      }
+    }
+    return [fromDenseMatrix2D(m, k, Q_reduced), fromDenseMatrix2D(k, n, R_reduced)];
+  }
+  return [fromDenseMatrix2D(m, m, Q), fromDenseMatrix2D(m, n, R)];
+}
+
+// src/linalg/inverse.ts
+function inv(a) {
+  if (a.ndim !== 2) throw new ShapeError("Input must be 2D matrix");
+  const rows = getDim(a, 0, "inv()");
+  const cols = getDim(a, 1, "inv()");
+  if (rows !== cols) throw new ShapeError("inv requires a square matrix");
+  const n = rows;
+  if (n === 0) {
+    return fromDenseMatrix2D(0, 0, new Float64Array(0));
+  }
+  const { data: A } = toDenseMatrix2D(a);
+  const { lu: lu2, piv } = luFactorSquare(A, n);
+  const rhs = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) rhs[i * n + i] = 1;
+  luSolveInPlace(lu2, piv, n, rhs, n);
+  return fromDenseMatrix2D(n, n, rhs);
+}
+function pinv(a, rcond) {
+  if (a.ndim !== 2) throw new ShapeError("Input must be 2D matrix");
+  if (rcond !== void 0 && (!Number.isFinite(rcond) || rcond < 0)) {
+    throw new InvalidParameterError("rcond must be a non-negative finite number", "rcond", rcond);
+  }
+  const m = getDim(a, 0, "pinv()");
+  const n = getDim(a, 1, "pinv()");
+  const k = Math.min(m, n);
+  if (k === 0) {
+    return fromDenseMatrix2D(n, m, new Float64Array(n * m));
+  }
+  const [U_t, s_t, Vt_t] = svd(a, false);
+  const { data: U, cols: uCols, rows: uRows } = toDenseMatrix2D(U_t);
+  const s = toDenseVector1D(s_t);
+  const { data: Vt, cols: vtCols, rows: vtRows } = toDenseMatrix2D(Vt_t);
+  if (uRows !== m || uCols !== k) throw new DeepboxError("Internal error: unexpected U shape");
+  if (vtRows !== k || vtCols !== n) throw new DeepboxError("Internal error: unexpected Vt shape");
+  const s0 = at(s, 0);
+  const rcondVal = rcond ?? Number.EPSILON * Math.max(m, n);
+  const cutoff = rcondVal * s0;
+  const sInv = new Float64Array(k);
+  for (let i = 0; i < k; i++) {
+    const si = at(s, i);
+    sInv[i] = si > cutoff ? 1 / si : 0;
+  }
+  const out = new Float64Array(n * m);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      let sum = 0;
+      for (let r = 0; r < k; r++) {
+        const v_ir = at(Vt, r * n + i);
+        const u_jr = at(U, j * k + r);
+        sum += v_ir * at(sInv, r) * u_jr;
+      }
+      out[i * m + j] = sum;
+    }
+  }
+  return fromDenseMatrix2D(n, m, out);
+}
+
+// src/linalg/norms.ts
+function norm(x, ord, axis, keepdims = false) {
+  assertFiniteTensor(x, "norm()");
+  const axes = axis !== void 0 ? normalizeAxes(axis, x.ndim) : void 0;
+  let p;
+  if (ord === void 0) {
+    if (axes === void 0) {
+      p = x.ndim === 1 ? 2 : "fro";
+    } else if (axes.length === 2) {
+      p = "fro";
+    } else {
+      p = 2;
+    }
+  } else {
+    p = ord;
+  }
+  const normalizeVectorOrder = (order) => {
+    const ordValue = order === "fro" ? 2 : order;
+    if (Number.isNaN(ordValue)) {
+      throw new InvalidParameterError("ord must be a valid number", "ord", ordValue);
+    }
+    if (!Number.isFinite(ordValue)) {
+      if (ordValue === Number.POSITIVE_INFINITY || ordValue === Number.NEGATIVE_INFINITY) {
+        return ordValue;
+      }
+      throw new InvalidParameterError("ord must be finite or \xB1Infinity", "ord", ordValue);
+    }
+    if (ordValue < 0) {
+      throw new InvalidParameterError(
+        "Vector norm order must be non-negative or \xB1Infinity",
+        "ord",
+        ordValue
+      );
+    }
+    return ordValue;
+  };
+  const vectorNormValue = (values, order) => {
+    const n = values.length;
+    if (n === 0) return 0;
+    if (order === 0) {
+      let count = 0;
+      for (const v of values) if (v !== 0) count++;
+      return count;
+    }
+    if (order === 1) {
+      let sum2 = 0;
+      for (const v of values) sum2 += Math.abs(v);
+      return sum2;
+    }
+    if (order === 2) {
+      let sum2 = 0;
+      for (const v of values) sum2 += v * v;
+      return Math.sqrt(sum2);
+    }
+    if (order === Number.POSITIVE_INFINITY) {
+      let max = 0;
+      for (const v of values) max = Math.max(max, Math.abs(v));
+      return max;
+    }
+    if (order === Number.NEGATIVE_INFINITY) {
+      let min = Infinity;
+      for (const v of values) min = Math.min(min, Math.abs(v));
+      return min === Infinity ? 0 : min;
+    }
+    let sum = 0;
+    for (const v of values) sum += Math.abs(v) ** order;
+    return sum ** (1 / order);
+  };
+  const vectorNormAxis = (axisValue, order, keep) => {
+    const ax = normalizeAxis(axisValue, x.ndim);
+    const axisDim = getDim(x, ax, "norm()");
+    const outShape = [];
+    for (let i = 0; i < x.ndim; i++) {
+      if (i === ax) {
+        if (keep) outShape.push(1);
+      } else {
+        outShape.push(getDim(x, i, "norm()"));
+      }
+    }
+    const outSize = outShape.length === 0 ? 1 : outShape.reduce((a, b) => a * b, 1);
+    const out = new Float64Array(outSize);
+    const outStrides = new Array(outShape.length);
+    let stride = 1;
+    for (let i = outShape.length - 1; i >= 0; i--) {
+      outStrides[i] = stride;
+      stride *= outShape[i] ?? 0;
+    }
+    for (let outFlat = 0; outFlat < outSize; outFlat++) {
+      let rem = outFlat;
+      const outIdx = new Array(outShape.length);
+      let i = 0;
+      for (const s of outStrides) {
+        outIdx[i] = Math.floor(rem / s);
+        rem %= s;
+        i++;
+      }
+      const inIdx = new Array(x.ndim);
+      if (keep) {
+        for (let i2 = 0; i2 < x.ndim; i2++) {
+          inIdx[i2] = i2 === ax ? 0 : outIdx[i2] ?? 0;
+        }
+      } else {
+        let outAxis = 0;
+        for (let i2 = 0; i2 < x.ndim; i2++) {
+          if (i2 === ax) {
+            inIdx[i2] = 0;
+          } else {
+            inIdx[i2] = outIdx[outAxis] ?? 0;
+            outAxis++;
+          }
+        }
+      }
+      if (axisDim === 0) {
+        out[outFlat] = 0;
+        continue;
+      }
+      let baseOffset = x.offset;
+      for (let i2 = 0; i2 < x.ndim; i2++) {
+        baseOffset += (inIdx[i2] ?? 0) * getStride(x, i2, "norm()");
+      }
+      const axisStride = getStride(x, ax, "norm()");
+      if (order === 0) {
+        let count = 0;
+        for (let k = 0; k < axisDim; k++) {
+          if (Number(x.data[baseOffset + k * axisStride]) !== 0) count++;
+        }
+        out[outFlat] = count;
+      } else if (order === 1) {
+        let sum = 0;
+        for (let k = 0; k < axisDim; k++) {
+          sum += Math.abs(Number(x.data[baseOffset + k * axisStride]));
+        }
+        out[outFlat] = sum;
+      } else if (order === 2) {
+        let sum = 0;
+        for (let k = 0; k < axisDim; k++) {
+          const v = Number(x.data[baseOffset + k * axisStride]);
+          sum += v * v;
+        }
+        out[outFlat] = Math.sqrt(sum);
+      } else if (order === Number.POSITIVE_INFINITY) {
+        let max = 0;
+        for (let k = 0; k < axisDim; k++) {
+          max = Math.max(max, Math.abs(Number(x.data[baseOffset + k * axisStride])));
+        }
+        out[outFlat] = max;
+      } else if (order === Number.NEGATIVE_INFINITY) {
+        let min = Infinity;
+        for (let k = 0; k < axisDim; k++) {
+          min = Math.min(min, Math.abs(Number(x.data[baseOffset + k * axisStride])));
+        }
+        out[outFlat] = min === Infinity ? 0 : min;
+      } else {
+        let sum = 0;
+        for (let k = 0; k < axisDim; k++) {
+          sum += Math.abs(Number(x.data[baseOffset + k * axisStride])) ** order;
+        }
+        out[outFlat] = sum ** (1 / order);
+      }
+    }
+    if (outShape.length === 0 && !keep) return at(out, 0);
+    return tensor(out).view(outShape);
+  };
+  const collectValues = () => {
+    const values = new Array(x.size);
+    if (x.size === 0) return values;
+    if (x.ndim === 0) {
+      values[0] = Number(x.data[x.offset]);
+      return values;
+    }
+    const data = x.data;
+    if (!Array.isArray(data) && !(data instanceof BigInt64Array) && x.offset === 0 && isContiguous(x.shape, x.strides)) {
+      for (let i = 0; i < x.size; i++) {
+        values[i] = data[i];
+      }
+      return values;
+    }
+    const idx = new Array(x.ndim).fill(0);
+    let offset = x.offset;
+    for (let count = 0; count < x.size; count++) {
+      values[count] = Number(data[offset]);
+      for (let d = x.ndim - 1; d >= 0; d--) {
+        const dim = getDim(x, d, "norm()");
+        const stride = getStride(x, d, "norm()");
+        const idxVal = idx[d] ?? 0;
+        const nextIdx = idxVal + 1;
+        idx[d] = nextIdx;
+        offset += stride;
+        if (nextIdx < dim) break;
+        offset -= nextIdx * stride;
+        idx[d] = 0;
+      }
+    }
+    return values;
+  };
+  if (axis !== void 0) {
+    if (p === "nuc") {
+      throw new InvalidParameterError(
+        "axis is only supported for vector norms, not nuclear norm",
+        "axis",
+        axis
+      );
+    }
+    if (axes === void 0) {
+      throw new ShapeError("axis has invalid length for input");
+    }
+    if (axes.length === 0) {
+      const ordValue = normalizeVectorOrder(p === "fro" ? 2 : p);
+      const value = vectorNormValue(collectValues(), ordValue);
+      if (!keepdims) return value;
+      const kdShape = new Array(x.ndim).fill(1);
+      return tensor([value]).view(kdShape);
+    }
+    if (axes.length === 1) {
+      const ax = axes[0];
+      if (ax === void 0) throw new ShapeError("axis has invalid length for input");
+      const ordValue = normalizeVectorOrder(p === "fro" ? 2 : p);
+      return vectorNormAxis(ax, ordValue, keepdims);
+    }
+    if (axes.length === 2) {
+      if (x.ndim < 2) throw new ShapeError("axis has invalid length for input");
+      const ax0 = axes[0];
+      const ax1 = axes[1];
+      if (ax0 === void 0 || ax1 === void 0)
+        throw new ShapeError("axis has invalid length for input");
+      const dimRow = getDim(x, ax0, "norm()");
+      const dimCol = getDim(x, ax1, "norm()");
+      const strideRow = getStride(x, ax0, "norm()");
+      const strideCol = getStride(x, ax1, "norm()");
+      const outerShape = [];
+      const outerStrides = [];
+      for (let i = 0; i < x.ndim; i++) {
+        if (i !== ax0 && i !== ax1) {
+          outerShape.push(getDim(x, i, "norm()"));
+          outerStrides.push(getStride(x, i, "norm()"));
+        }
+      }
+      const outerSize = outerShape.length === 0 ? 1 : outerShape.reduce((a, b) => a * b, 1);
+      const matOrd = p === "fro" ? "fro" : p;
+      if (matOrd !== "fro" && matOrd !== 1 && matOrd !== -1 && matOrd !== 2 && matOrd !== -2 && matOrd !== Number.POSITIVE_INFINITY && matOrd !== Number.NEGATIVE_INFINITY) {
+        throw new InvalidParameterError(
+          `Invalid norm order '${String(matOrd)}' for matrix norm. Valid orders are: 1, -1, 2, -2, Infinity, -Infinity, 'fro'.`,
+          "ord",
+          matOrd
+        );
+      }
+      const results = new Float64Array(outerSize);
+      for (let outer = 0; outer < outerSize; outer++) {
+        let baseOffset = x.offset;
+        let rem = outer;
+        for (let d = outerShape.length - 1; d >= 0; d--) {
+          const dim = outerShape[d] ?? 0;
+          const idx = rem % dim;
+          rem = Math.floor(rem / dim);
+          baseOffset += idx * (outerStrides[d] ?? 0);
+        }
+        let val = 0;
+        if (matOrd === "fro") {
+          let sum = 0;
+          for (let i = 0; i < dimRow; i++) {
+            for (let j = 0; j < dimCol; j++) {
+              const v = Number(x.data[baseOffset + i * strideRow + j * strideCol]);
+              sum += v * v;
+            }
+          }
+          val = Math.sqrt(sum);
+        } else if (matOrd === 1) {
+          let maxSum = 0;
+          for (let j = 0; j < dimCol; j++) {
+            let colSum = 0;
+            for (let i = 0; i < dimRow; i++) {
+              colSum += Math.abs(Number(x.data[baseOffset + i * strideRow + j * strideCol]));
+            }
+            maxSum = Math.max(maxSum, colSum);
+          }
+          val = maxSum;
+        } else if (matOrd === -1) {
+          let minSum = Infinity;
+          for (let j = 0; j < dimCol; j++) {
+            let colSum = 0;
+            for (let i = 0; i < dimRow; i++) {
+              colSum += Math.abs(Number(x.data[baseOffset + i * strideRow + j * strideCol]));
+            }
+            minSum = Math.min(minSum, colSum);
+          }
+          val = minSum === Infinity ? 0 : minSum;
+        } else if (matOrd === Number.POSITIVE_INFINITY) {
+          let maxSum = 0;
+          for (let i = 0; i < dimRow; i++) {
+            let rowSum = 0;
+            for (let j = 0; j < dimCol; j++) {
+              rowSum += Math.abs(Number(x.data[baseOffset + i * strideRow + j * strideCol]));
+            }
+            maxSum = Math.max(maxSum, rowSum);
+          }
+          val = maxSum;
+        } else if (matOrd === Number.NEGATIVE_INFINITY) {
+          let minSum = Infinity;
+          for (let i = 0; i < dimRow; i++) {
+            let rowSum = 0;
+            for (let j = 0; j < dimCol; j++) {
+              rowSum += Math.abs(Number(x.data[baseOffset + i * strideRow + j * strideCol]));
+            }
+            minSum = Math.min(minSum, rowSum);
+          }
+          val = minSum === Infinity ? 0 : minSum;
+        } else if (matOrd === 2 || matOrd === -2) {
+          const sliceData = new Float64Array(dimRow * dimCol);
+          for (let i = 0; i < dimRow; i++) {
+            for (let j = 0; j < dimCol; j++) {
+              sliceData[i * dimCol + j] = Number(
+                x.data[baseOffset + i * strideRow + j * strideCol]
+              );
+            }
+          }
+          const sliceTensor = tensor(sliceData).view([dimRow, dimCol]);
+          const [_U, s, _Vt] = svd(sliceTensor);
+          const sDense = toDenseVector1D(s);
+          if (sDense.length === 0) {
+            val = 0;
+          } else {
+            val = matOrd === 2 ? at(sDense, 0) : Math.abs(at(sDense, sDense.length - 1));
+          }
+        }
+        results[outer] = val;
+      }
+      if (keepdims) {
+        const kdShape = [];
+        for (let i = 0; i < x.ndim; i++) {
+          kdShape.push(i === ax0 || i === ax1 ? 1 : getDim(x, i, "norm()"));
+        }
+        return tensor(results).view(kdShape);
+      }
+      if (outerSize === 1 && outerShape.length === 0) return at(results, 0);
+      return tensor(results).view(outerShape);
+    }
+    throw new ShapeError("axis has invalid length for input");
+  }
+  if (x.ndim === 0) {
+    if (p === "nuc") {
+      throw new InvalidParameterError("Invalid norm order 'nuc' for scalar norm.", "ord", p);
+    }
+    const ordInput = p === "fro" ? 2 : p;
+    if (typeof ordInput !== "number") {
+      throw new InvalidParameterError(
+        `Invalid norm order '${String(ordInput)}' for scalar norm.`,
+        "ord",
+        ordInput
+      );
+    }
+    const ordValue = normalizeVectorOrder(ordInput);
+    return vectorNormValue(collectValues(), ordValue);
+  }
+  if (x.ndim === 1) {
+    if (p === "nuc") {
+      throw new InvalidParameterError("Invalid norm order 'nuc' for vector norm.", "ord", p);
+    }
+    const ordInput = p === "fro" ? 2 : p;
+    if (typeof ordInput !== "number") {
+      throw new InvalidParameterError(
+        `Invalid norm order '${String(ordInput)}' for vector norm.`,
+        "ord",
+        ordInput
+      );
+    }
+    const ordValue = normalizeVectorOrder(ordInput);
+    return vectorNormValue(collectValues(), ordValue);
+  }
+  if (x.ndim !== 2) {
+    throw new ShapeError("norm requires 1D or 2D input when axis is omitted");
+  }
+  const s0 = getStride(x, 0, "norm()");
+  const s1 = getStride(x, 1, "norm()");
+  const rows = getDim(x, 0, "norm()");
+  const cols = getDim(x, 1, "norm()");
+  if (p === "fro") {
+    let sum = 0;
+    for (let i = 0; i < rows; i++) {
+      for (let j = 0; j < cols; j++) {
+        const val = Number(x.data[x.offset + i * s0 + j * s1]);
+        sum += val * val;
+      }
+    }
+    return Math.sqrt(sum);
+  }
+  if (p === "nuc") {
+    const [_U, s, _Vt] = svd(x);
+    const sDense = toDenseVector1D(s);
+    let sum = 0;
+    for (let i = 0; i < sDense.length; i++) sum += Math.abs(at(sDense, i));
+    return sum;
+  }
+  if (p === 1) {
+    let maxSum = 0;
+    for (let j = 0; j < cols; j++) {
+      let colSum = 0;
+      for (let i = 0; i < rows; i++) {
+        colSum += Math.abs(Number(x.data[x.offset + i * s0 + j * s1]));
+      }
+      maxSum = Math.max(maxSum, colSum);
+    }
+    return maxSum;
+  }
+  if (p === -1) {
+    let minSum = Infinity;
+    for (let j = 0; j < cols; j++) {
+      let colSum = 0;
+      for (let i = 0; i < rows; i++) {
+        colSum += Math.abs(Number(x.data[x.offset + i * s0 + j * s1]));
+      }
+      minSum = Math.min(minSum, colSum);
+    }
+    return minSum === Infinity ? 0 : minSum;
+  }
+  if (p === Number.POSITIVE_INFINITY) {
+    let maxSum = 0;
+    for (let i = 0; i < rows; i++) {
+      let rowSum = 0;
+      for (let j = 0; j < cols; j++) {
+        rowSum += Math.abs(Number(x.data[x.offset + i * s0 + j * s1]));
+      }
+      maxSum = Math.max(maxSum, rowSum);
+    }
+    return maxSum;
+  }
+  if (p === Number.NEGATIVE_INFINITY) {
+    let minSum = Infinity;
+    for (let i = 0; i < rows; i++) {
+      let rowSum = 0;
+      for (let j = 0; j < cols; j++) {
+        rowSum += Math.abs(Number(x.data[x.offset + i * s0 + j * s1]));
+      }
+      minSum = Math.min(minSum, rowSum);
+    }
+    return minSum === Infinity ? 0 : minSum;
+  }
+  if (p === 2 || p === -2) {
+    const [_U, s, _Vt] = svd(x);
+    const sDense = toDenseVector1D(s);
+    if (sDense.length === 0) return 0;
+    const sMax = at(sDense, 0);
+    const sMin = at(sDense, sDense.length - 1);
+    return p === 2 ? sMax : Math.abs(sMin);
+  }
+  throw new InvalidParameterError(
+    `Invalid norm order '${String(p)}' for matrix norm. Valid orders are: 1, -1, 2, -2, Infinity, -Infinity, 'fro', 'nuc'.`,
+    "ord",
+    p
+  );
+}
+function cond(a, _p) {
+  if (a.ndim !== 2) throw new ShapeError("Input must be 2D matrix");
+  assertFiniteTensor(a, "cond()");
+  if (_p !== void 0) {
+    if (_p === "fro") ; else if (typeof _p === "number") {
+      if (!Number.isFinite(_p) || Number.isNaN(_p) || _p !== 2) {
+        throw new InvalidParameterError(
+          "Only 2-norm and Frobenius norm are supported for condition number",
+          "p",
+          _p
+        );
+      }
+    } else {
+      throw new InvalidParameterError(
+        "Only 2-norm and Frobenius norm are supported for condition number",
+        "p",
+        _p
+      );
+    }
+  }
+  const m = getDim(a, 0, "cond()");
+  const n = getDim(a, 1, "cond()");
+  const k = Math.min(m, n);
+  if (k === 0) return Infinity;
+  const [_U, s, _Vt] = svd(a);
+  const sDense = toDenseVector1D(s);
+  if (_p === "fro") {
+    if (sDense.length === 0) return Infinity;
+    let sumSq = 0;
+    let sumInvSq = 0;
+    for (let i = 0; i < sDense.length; i++) {
+      const si = at(sDense, i);
+      sumSq += si * si;
+      if (si === 0) return Infinity;
+      sumInvSq += 1 / (si * si);
+    }
+    return Math.sqrt(sumSq) * Math.sqrt(sumInvSq);
+  }
+  const sMax = at(sDense, 0);
+  const sMin = at(sDense, k - 1);
+  if (sMin === 0) return Infinity;
+  return sMax / sMin;
+}
+
+// src/linalg/properties.ts
+function det(a) {
+  if (a.ndim !== 2) throw new ShapeError("det requires a 2-D matrix");
+  const rows = getDim(a, 0, "det()");
+  const cols = getDim(a, 1, "det()");
+  if (rows !== cols) throw new ShapeError("det requires a square matrix");
+  const n = rows;
+  if (n === 0) return 1;
+  const { data: A } = toDenseMatrix2D(a);
+  try {
+    const { lu: lu2, pivSign } = luFactorSquare(A, n);
+    let detVal = pivSign;
+    for (let i = 0; i < n; i++) detVal *= at(lu2, i * n + i);
+    return detVal;
+  } catch (err) {
+    if (err instanceof DataValidationError && err.message === "Matrix is singular") {
+      return 0;
+    }
+    throw err;
+  }
+}
+function slogdet(a) {
+  if (a.ndim !== 2) throw new ShapeError("slogdet requires a 2-D matrix");
+  const rows = getDim(a, 0, "slogdet()");
+  const cols = getDim(a, 1, "slogdet()");
+  if (rows !== cols) throw new ShapeError("slogdet requires a square matrix");
+  const n = rows;
+  if (n === 0) return [tensor([1]), tensor([0])];
+  const { data: A } = toDenseMatrix2D(a);
+  try {
+    const { lu: lu2, pivSign } = luFactorSquare(A, n);
+    let sign = pivSign;
+    let logAbsDet = 0;
+    for (let i = 0; i < n; i++) {
+      const d = at(lu2, i * n + i);
+      if (d === 0) {
+        return [tensor([0]), tensor([-Infinity])];
+      }
+      sign *= Math.sign(d);
+      logAbsDet += Math.log(Math.abs(d));
+    }
+    return [tensor([sign]), tensor([logAbsDet])];
+  } catch (err) {
+    if (err instanceof DataValidationError && err.message === "Matrix is singular") {
+      return [tensor([0]), tensor([-Infinity])];
+    }
+    throw err;
+  }
+}
+function trace(a, offset = 0, axis1 = 0, axis2 = 1) {
+  if (a.ndim < 2) {
+    throw new ShapeError("Input must be at least 2D");
+  }
+  if (!Number.isInteger(offset)) {
+    throw new InvalidParameterError("offset must be an integer", "offset", offset);
+  }
+  if (a.dtype === "string") {
+    throw new DataValidationError("trace() does not support string dtype");
+  }
+  const ndim = a.ndim;
+  const ax1 = normalizeAxis(axis1, ndim);
+  const ax2 = normalizeAxis(axis2, ndim);
+  if (ax1 === ax2) {
+    throw new InvalidParameterError("axis1 and axis2 must be different", "axis", [axis1, axis2]);
+  }
+  const dim1 = getDim(a, ax1, "trace()");
+  const dim2 = getDim(a, ax2, "trace()");
+  const stride1 = getStride(a, ax1, "trace()");
+  const stride2 = getStride(a, ax2, "trace()");
+  const outerShape = [];
+  const outerStrides = [];
+  for (let i = 0; i < ndim; i++) {
+    if (i !== ax1 && i !== ax2) {
+      outerShape.push(getDim(a, i, "trace()"));
+      outerStrides.push(getStride(a, i, "trace()"));
+    }
+  }
+  const outerSize = outerShape.length === 0 ? 1 : outerShape.reduce((acc, v) => acc * v, 1);
+  const out = new Float64Array(outerSize);
+  for (let outer = 0; outer < outerSize; outer++) {
+    let baseOffset = a.offset;
+    let rem = outer;
+    for (let d = outerShape.length - 1; d >= 0; d--) {
+      const dim = outerShape[d];
+      if (dim === void 0) throw new ShapeError("trace(): outer shape is out of bounds");
+      const idx = rem % dim;
+      rem = Math.floor(rem / dim);
+      const stride = outerStrides[d];
+      if (stride === void 0) throw new ShapeError("trace(): outer stride is out of bounds");
+      baseOffset += idx * stride;
+    }
+    let sum = 0;
+    if (offset >= 0) {
+      const n = Math.min(dim1, Math.max(0, dim2 - offset));
+      for (let i = 0; i < n; i++) {
+        sum += Number(a.data[baseOffset + i * stride1 + (i + offset) * stride2]);
+      }
+    } else {
+      const absOffset = -offset;
+      const n = Math.min(Math.max(0, dim1 - absOffset), dim2);
+      for (let i = 0; i < n; i++) {
+        sum += Number(a.data[baseOffset + (i + absOffset) * stride1 + i * stride2]);
+      }
+    }
+    out[outer] = sum;
+  }
+  if (outerShape.length === 0) {
+    return tensor([at(out, 0)]);
+  }
+  return tensor(out).view(outerShape);
+}
+function matrixRank(a, tol) {
+  if (a.ndim !== 2) throw new ShapeError("matrixRank requires a 2-D matrix");
+  if (tol !== void 0 && (!Number.isFinite(tol) || tol < 0)) {
+    throw new InvalidParameterError("tol must be a non-negative finite number", "tol", tol);
+  }
+  const rows = getDim(a, 0, "matrixRank()");
+  const cols = getDim(a, 1, "matrixRank()");
+  const k = Math.min(rows, cols);
+  if (k === 0) return 0;
+  const [_U, s, _Vt] = svd(a);
+  const sDense = toDenseVector1D(s);
+  const defaultTol = at(sDense, 0) * Number.EPSILON * Math.max(rows, cols);
+  const threshold = tol ?? defaultTol;
+  let rank = 0;
+  for (let i = 0; i < k; i++) {
+    if (at(sDense, i) > threshold) rank++;
+  }
+  return rank;
+}
+
+// src/linalg/solvers/lstsq.ts
+function lstsq(a, b, rcond) {
+  if (a.ndim !== 2) throw new ShapeError("A must be a 2D matrix");
+  if (b.ndim !== 1 && b.ndim !== 2) throw new ShapeError("b must be a 1D or 2D tensor");
+  if (rcond !== void 0 && (!Number.isFinite(rcond) || rcond < 0)) {
+    throw new InvalidParameterError("rcond must be a non-negative finite number", "rcond", rcond);
+  }
+  const m = getDim(a, 0, "lstsq()");
+  const n = getDim(a, 1, "lstsq()");
+  const bRows = getDim(b, 0, "lstsq()");
+  if (bRows !== m) throw new ShapeError("A and b dimensions do not match");
+  const k = Math.min(m, n);
+  if (k === 0) {
+    const zeroX = b.ndim === 1 ? fromDenseVector1D(new Float64Array(n)) : fromDenseMatrix2D(
+      n,
+      getDim(b, 1, "lstsq()"),
+      new Float64Array(n * getDim(b, 1, "lstsq()"))
+    );
+    const zeroResiduals = b.ndim === 1 ? tensor([0]) : fromDenseVector1D(new Float64Array(getDim(b, 1, "lstsq()")));
+    return {
+      x: zeroX,
+      residuals: zeroResiduals,
+      rank: 0,
+      s: fromDenseVector1D(new Float64Array(0))
+    };
+  }
+  const rcondVal = rcond ?? Number.EPSILON * Math.max(m, n);
+  const [U_t, s, Vt_t] = svd(a, false);
+  const { data: U, cols: uCols, rows: uRows } = toDenseMatrix2D(U_t);
+  const sDense = toDenseVector1D(s);
+  const { data: Vt, cols: vtCols, rows: vtRows } = toDenseMatrix2D(Vt_t);
+  if (uRows !== m || uCols !== k) {
+    throw new DeepboxError("Internal error: unexpected U shape");
+  }
+  if (vtRows !== k || vtCols !== n) {
+    throw new DeepboxError("Internal error: unexpected Vt shape");
+  }
+  const cutoff = at(sDense, 0) * rcondVal;
+  let rank = 0;
+  const sInv = new Float64Array(k);
+  for (let i = 0; i < k; i++) {
+    const si = at(sDense, i);
+    if (si > cutoff) {
+      rank++;
+      sInv[i] = 1 / si;
+    } else {
+      sInv[i] = 0;
+    }
+  }
+  const P = new Float64Array(n * m);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      let sum = 0;
+      for (let r = 0; r < k; r++) {
+        const v_ir = at(Vt, r * n + i);
+        const u_jr = at(U, j * k + r);
+        sum += v_ir * at(sInv, r) * u_jr;
+      }
+      P[i * m + j] = sum;
+    }
+  }
+  if (b.ndim === 1) {
+    const bv = toDenseVector1D(b);
+    const x = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      let sum = 0;
+      for (let j = 0; j < m; j++) {
+        sum += at(P, i * m + j) * at(bv, j);
+      }
+      x[i] = sum;
+    }
+    const { data: A2 } = toDenseMatrix2D(a);
+    let residual = 0;
+    for (let i = 0; i < m; i++) {
+      let pred = 0;
+      for (let j = 0; j < n; j++) {
+        pred += at(A2, i * n + j) * at(x, j);
+      }
+      const err = at(bv, i) - pred;
+      residual += err * err;
+    }
+    return {
+      x: fromDenseVector1D(x),
+      residuals: tensor([residual]),
+      rank,
+      s
+    };
+  }
+  const nrhs = getDim(b, 1, "lstsq()");
+  const { data: B, rows: bM, cols: bK } = toDenseMatrix2D(b);
+  if (bM !== m || bK !== nrhs) throw new DeepboxError("Internal error: unexpected b shape");
+  const X = new Float64Array(n * nrhs);
+  for (let i = 0; i < n; i++) {
+    for (let k2 = 0; k2 < nrhs; k2++) {
+      let sum = 0;
+      for (let j = 0; j < m; j++) {
+        sum += at(P, i * m + j) * at(B, j * nrhs + k2);
+      }
+      X[i * nrhs + k2] = sum;
+    }
+  }
+  const { data: A } = toDenseMatrix2D(a);
+  const residuals = new Float64Array(nrhs);
+  for (let k2 = 0; k2 < nrhs; k2++) {
+    let rsum = 0;
+    for (let i = 0; i < m; i++) {
+      let pred = 0;
+      for (let j = 0; j < n; j++) {
+        pred += at(A, i * n + j) * at(X, j * nrhs + k2);
+      }
+      const err = at(B, i * nrhs + k2) - pred;
+      rsum += err * err;
+    }
+    residuals[k2] = rsum;
+  }
+  return {
+    x: fromDenseMatrix2D(n, nrhs, X),
+    residuals: fromDenseVector1D(residuals),
+    rank,
+    s
+  };
+}
+
+// src/linalg/solvers/solve.ts
+function solve(a, b) {
+  if (a.ndim !== 2) throw new ShapeError("A must be a 2D matrix");
+  const n = getDim(a, 0, "solve()");
+  const n2 = getDim(a, 1, "solve()");
+  if (n !== n2) throw new ShapeError("A must be square");
+  if (b.ndim !== 1 && b.ndim !== 2) {
+    throw new ShapeError("b must be a 1D or 2D tensor");
+  }
+  const bRows = getDim(b, 0, "solve()");
+  if (bRows !== n) {
+    throw new ShapeError("A and b dimensions do not match");
+  }
+  const { data: A } = toDenseMatrix2D(a);
+  const { lu: lu2, piv } = luFactorSquare(A, n);
+  if (b.ndim === 1) {
+    const rhs = toDenseVector1D(b);
+    const rhsMat = new Float64Array(n * 1);
+    for (let i = 0; i < n; i++) rhsMat[i] = at(rhs, i);
+    luSolveInPlace(lu2, piv, n, rhsMat, 1);
+    return fromDenseVector1D(rhsMat);
+  }
+  const nrhs = getDim(b, 1, "solve()");
+  const { data: B } = toDenseMatrix2D(b);
+  luSolveInPlace(lu2, piv, n, B, nrhs);
+  return fromDenseMatrix2D(n, nrhs, B);
+}
+function solveTriangular(a, b, lower = true) {
+  if (a.ndim !== 2) throw new ShapeError("A must be a 2D matrix");
+  const n = getDim(a, 0, "solveTriangular()");
+  const n2 = getDim(a, 1, "solveTriangular()");
+  if (n !== n2) throw new ShapeError("A must be square");
+  if (b.ndim !== 1 && b.ndim !== 2) {
+    throw new ShapeError("b must be a 1D or 2D tensor");
+  }
+  const bN = getDim(b, 0, "solveTriangular()");
+  if (bN !== n) throw new ShapeError("A and b dimensions do not match");
+  const { data: A } = toDenseMatrix2D(a);
+  if (b.ndim === 1) {
+    const rhs = toDenseVector1D(b);
+    const x = new Float64Array(n);
+    if (lower) {
+      for (let i = 0; i < n; i++) {
+        let sum = at(rhs, i);
+        for (let j = 0; j < i; j++) {
+          sum -= at(A, i * n + j) * at(x, j);
+        }
+        const diag = at(A, i * n + i);
+        if (diag === 0) throw new DataValidationError("Matrix is singular");
+        x[i] = sum / diag;
+      }
+    } else {
+      for (let i = n - 1; i >= 0; i--) {
+        let sum = at(rhs, i);
+        for (let j = i + 1; j < n; j++) {
+          sum -= at(A, i * n + j) * at(x, j);
+        }
+        const diag = at(A, i * n + i);
+        if (diag === 0) throw new DataValidationError("Matrix is singular");
+        x[i] = sum / diag;
+      }
+    }
+    return fromDenseVector1D(x);
+  }
+  const nrhs = getDim(b, 1, "solveTriangular()");
+  const { data: B } = toDenseMatrix2D(b);
+  const X = new Float64Array(n * nrhs);
+  if (lower) {
+    for (let k = 0; k < nrhs; k++) {
+      for (let i = 0; i < n; i++) {
+        let sum = at(B, i * nrhs + k);
+        for (let j = 0; j < i; j++) {
+          sum -= at(A, i * n + j) * at(X, j * nrhs + k);
+        }
+        const diag = at(A, i * n + i);
+        if (diag === 0) throw new DataValidationError("Matrix is singular");
+        X[i * nrhs + k] = sum / diag;
+      }
+    }
+  } else {
+    for (let k = 0; k < nrhs; k++) {
+      for (let i = n - 1; i >= 0; i--) {
+        let sum = at(B, i * nrhs + k);
+        for (let j = i + 1; j < n; j++) {
+          sum -= at(A, i * n + j) * at(X, j * nrhs + k);
+        }
+        const diag = at(A, i * n + i);
+        if (diag === 0) throw new DataValidationError("Matrix is singular");
+        X[i * nrhs + k] = sum / diag;
+      }
+    }
+  }
+  return fromDenseMatrix2D(n, nrhs, X);
+}
+
+export { cholesky, cond, det, eig, eigh, eigvals, eigvalsh, inv, linalg_exports, lstsq, lu, matrixRank, norm, pinv, qr, slogdet, solve, solveTriangular, svd, trace };
+//# sourceMappingURL=chunk-AU7XHGKJ.js.map
+//# sourceMappingURL=chunk-AU7XHGKJ.js.map