@danielsimonjr/mathts-tensor 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,13 +1,26 @@
 // src/Tensor.ts
+import { DenseMatrix } from "@danielsimonjr/mathts-matrix";
 var Tensor = class _Tensor {
   shape;
   data;
-  constructor(shape, data) {
+  /** Optional per-axis Index labels. When set, enables `contract`, `replaceIndex`, `axisOf`. */
+  axisLabels;
+  constructor(shape, data, axisLabels) {
     if (data.length !== _Tensor.sizeOf(shape)) {
-      throw new Error(`Tensor: data length ${data.length} does not match shape [${shape}] (size ${_Tensor.sizeOf(shape)})`);
+      throw new Error(
+        `Tensor: data length ${data.length} does not match shape [${shape}] (size ${_Tensor.sizeOf(shape)})`
+      );
+    }
+    if (axisLabels !== void 0 && axisLabels.length !== shape.length) {
+      throw new Error(
+        `Tensor: axisLabels length ${axisLabels.length} does not match rank ${shape.length}`
+      );
     }
     this.shape = shape;
     this.data = data;
+    if (axisLabels !== void 0) {
+      this.axisLabels = [...axisLabels];
+    }
   }
   static sizeOf(shape) {
     return shape.reduce((a, b) => a * b, 1);
@@ -64,6 +77,27 @@ var Tensor = class _Tensor {
     };
     return build(0, 0);
   }
+  /**
+   * Build a rank-2 Tensor from a native DenseMatrix. Bridges the tensor and
+   * matrix packages so matrix data can flow into rank-N / autodiff code.
+   */
+  static fromDenseMatrix(m) {
+    const nested = m.toArray();
+    const rows = nested.length;
+    const cols = rows > 0 ? nested[0].length : 0;
+    return _Tensor.fromNested(nested, [rows, cols]);
+  }
+  /**
+   * Convert a rank-2 Tensor to a native DenseMatrix. Throws for any other rank.
+   */
+  toDenseMatrix() {
+    if (this.shape.length !== 2) {
+      throw new Error(
+        `Tensor.toDenseMatrix: expected a rank-2 tensor, got rank ${this.shape.length}`
+      );
+    }
+    return DenseMatrix.fromArray(this.toNested());
+  }
   sameShape(other) {
     return this.shape.length === other.shape.length && this.shape.every((v, i) => v === other.shape[i]);
   }
@@ -76,13 +110,35 @@ var Tensor = class _Tensor {
     return new _Tensor(this.shape, out);
   }
   add(other) {
-    return this.elementwise(other, "add", (x, y) => x + y);
+    if (typeof other === "number") {
+      const out = new Float64Array(this.data.length);
+      for (let i = 0; i < this.data.length; i++) out[i] = this.data[i] + other;
+      return new _Tensor(this.shape, out, this.axisLabels);
+    }
+    if (this.sameShape(other)) {
+      return this.elementwise(other, "add", (x, y) => x + y);
+    }
+    return _Tensor.broadcastOp(this, other, "add", (x, y) => x + y);
   }
   sub(other) {
-    return this.elementwise(other, "sub", (x, y) => x - y);
+    if (typeof other === "number") {
+      const out = new Float64Array(this.data.length);
+      for (let i = 0; i < this.data.length; i++) out[i] = this.data[i] - other;
+      return new _Tensor(this.shape, out, this.axisLabels);
+    }
+    if (this.sameShape(other)) {
+      return this.elementwise(other, "sub", (x, y) => x - y);
+    }
+    return _Tensor.broadcastOp(this, other, "sub", (x, y) => x - y);
   }
   mul(other) {
-    return this.elementwise(other, "mul", (x, y) => x * y);
+    if (typeof other === "number") {
+      return this.scale(other);
+    }
+    if (this.sameShape(other)) {
+      return this.elementwise(other, "mul", (x, y) => x * y);
+    }
+    return _Tensor.broadcastOp(this, other, "mul", (x, y) => x * y);
   }
   scale(k) {
     const out = new Float64Array(this.data.length);
@@ -97,24 +153,357 @@ var Tensor = class _Tensor {
     }
     return max;
   }
+  // -------------------------------------------------------------------------
+  // Broadcasting support
+  // -------------------------------------------------------------------------
+  /**
+   * Compute the broadcast output shape of two shapes following NumPy rules:
+   * right-align the two shapes; a dimension of 1 broadcasts against any size;
+   * missing leading axes are treated as length-1.
+   * Throws with message including both shape arrays on incompatibility.
+   */
+  static broadcastShape(a, b) {
+    const rank = Math.max(a.length, b.length);
+    const out = new Array(rank);
+    for (let i = 0; i < rank; i++) {
+      const ai = a.length - rank + i;
+      const bi = b.length - rank + i;
+      const da = ai >= 0 ? a[ai] : 1;
+      const db = bi >= 0 ? b[bi] : 1;
+      if (da === db) {
+        out[i] = da;
+      } else if (da === 1) {
+        out[i] = db;
+      } else if (db === 1) {
+        out[i] = da;
+      } else {
+        throw new Error(
+          `shapes [${a}] and [${b}] cannot be broadcast: dimension mismatch ${da} vs ${db} at axis ${i} of the aligned shape`
+        );
+      }
+    }
+    return out;
+  }
+  /**
+   * Apply a binary elementwise op with NumPy-style broadcasting.
+   * Both tensors are read via virtual broadcast indices — no data is copied
+   * until the output is written.
+   */
+  static broadcastOp(a, b, _opName, f) {
+    const outShape = _Tensor.broadcastShape(a.shape, b.shape);
+    const rank = outShape.length;
+    const outSize = _Tensor.sizeOf(outShape);
+    const aStrides = _Tensor.rowMajorStrides(a.shape);
+    const bStrides = _Tensor.rowMajorStrides(b.shape);
+    const aRankOffset = rank - a.shape.length;
+    const bRankOffset = rank - b.shape.length;
+    const aEffStrides = new Array(rank).fill(0);
+    const bEffStrides = new Array(rank).fill(0);
+    for (let i = 0; i < rank; i++) {
+      const ai = i - aRankOffset;
+      if (ai >= 0 && a.shape[ai] !== 1) {
+        aEffStrides[i] = aStrides[ai];
+      }
+      const bi = i - bRankOffset;
+      if (bi >= 0 && b.shape[bi] !== 1) {
+        bEffStrides[i] = bStrides[bi];
+      }
+    }
+    const out = new Float64Array(outSize);
+    const coords = new Array(rank).fill(0);
+    for (let n = 0; n < outSize; n++) {
+      let aFlat = 0;
+      let bFlat = 0;
+      for (let k = 0; k < rank; k++) {
+        aFlat += coords[k] * aEffStrides[k];
+        bFlat += coords[k] * bEffStrides[k];
+      }
+      out[n] = f(a.data[aFlat], b.data[bFlat]);
+      for (let k = rank - 1; k >= 0; k--) {
+        if (++coords[k] < outShape[k]) break;
+        coords[k] = 0;
+      }
+    }
+    return new _Tensor(outShape, out);
+  }
+  // -------------------------------------------------------------------------
+  // Reduction helpers
+  // -------------------------------------------------------------------------
+  /**
+   * Generic strided reduction over a set of axes.
+   *
+   * `init` is the neutral element; `combine` folds one new value into the
+   * accumulator; `finalise` (optional) post-processes the accumulator once
+   * all elements have been visited.
+   */
+  reduceAxes(axes, keepDims, init, combine, finalise) {
+    const rank = this.shape.length;
+    const axisSet = new Set(axes);
+    for (const ax of axes) {
+      if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
+        throw new Error(`Tensor.reduce: axis ${ax} out of range for rank-${rank} tensor`);
+      }
+    }
+    const outShape = [];
+    for (let k = 0; k < rank; k++) {
+      if (axisSet.has(k)) {
+        if (keepDims) outShape.push(1);
+      } else {
+        outShape.push(this.shape[k]);
+      }
+    }
+    const reduceCount = axes.reduce((prod, ax) => prod * this.shape[ax], 1);
+    const outSize = _Tensor.sizeOf(outShape);
+    const out = new Float64Array(outSize).fill(init);
+    const outStrides = _Tensor.rowMajorStrides(outShape.length > 0 ? outShape : [1]);
+    const inCoords = new Array(rank).fill(0);
+    const inSize = this.data.length;
+    for (let n = 0; n < inSize; n++) {
+      let outFlat = 0;
+      let outDim = 0;
+      for (let k = 0; k < rank; k++) {
+        if (axisSet.has(k)) {
+          if (keepDims) {
+            outDim++;
+          }
+        } else {
+          outFlat += inCoords[k] * outStrides[outDim];
+          outDim++;
+        }
+      }
+      out[outFlat] = combine(out[outFlat], this.data[n]);
+      for (let k = rank - 1; k >= 0; k--) {
+        if (++inCoords[k] < this.shape[k]) break;
+        inCoords[k] = 0;
+      }
+    }
+    if (finalise !== void 0) {
+      for (let i = 0; i < out.length; i++) {
+        out[i] = finalise(out[i], reduceCount);
+      }
+    }
+    let resultLabels;
+    if (!keepDims && this.axisLabels !== void 0) {
+      const surviving = [];
+      for (let k = 0; k < rank; k++) {
+        if (!axisSet.has(k)) {
+          surviving.push(this.axisLabels[k]);
+        }
+      }
+      if (surviving.length === outShape.length) {
+        resultLabels = surviving;
+      }
+    }
+    return new _Tensor(outShape, out, resultLabels);
+  }
+  // -------------------------------------------------------------------------
+  // Public reductions
+  // -------------------------------------------------------------------------
+  /**
+   * Sum elements along the given axis/axes (or all axes if omitted).
+   * `keepDims: true` preserves reduced axes as length-1.
+   */
+  sum(axis, opts) {
+    const axes = this.resolveAxes(axis);
+    const keepDims = opts?.keepDims ?? false;
+    return this.reduceAxes(axes, keepDims, 0, (acc, v) => acc + v);
+  }
+  /**
+   * Arithmetic mean along the given axis/axes (or all axes if omitted).
+   */
+  mean(axis, opts) {
+    const axes = this.resolveAxes(axis);
+    const keepDims = opts?.keepDims ?? false;
+    return this.reduceAxes(
+      axes,
+      keepDims,
+      0,
+      (acc, v) => acc + v,
+      (acc, count) => acc / count
+    );
+  }
+  /**
+   * Element-wise maximum along the given axis/axes (or all axes if omitted).
+   * NaN propagates (matches NumPy default behaviour).
+   */
+  max(axis, opts) {
+    const axes = this.resolveAxes(axis);
+    const keepDims = opts?.keepDims ?? false;
+    return this.reduceAxes(
+      axes,
+      keepDims,
+      -Infinity,
+      (acc, v) => isNaN(v) ? v : isNaN(acc) ? acc : Math.max(acc, v)
+    );
+  }
+  /**
+   * Element-wise minimum along the given axis/axes (or all axes if omitted).
+   * NaN propagates (matches NumPy default behaviour).
+   */
+  min(axis, opts) {
+    const axes = this.resolveAxes(axis);
+    const keepDims = opts?.keepDims ?? false;
+    return this.reduceAxes(
+      axes,
+      keepDims,
+      Infinity,
+      (acc, v) => isNaN(v) ? v : isNaN(acc) ? acc : Math.min(acc, v)
+    );
+  }
+  /**
+   * Product of elements along the given axis/axes (or all axes if omitted).
+   */
+  prod(axis, opts) {
+    const axes = this.resolveAxes(axis);
+    const keepDims = opts?.keepDims ?? false;
+    return this.reduceAxes(axes, keepDims, 1, (acc, v) => acc * v);
+  }
+  /**
+   * p-norm of the tensor.
+   *
+   * - `p = 2` (default): Euclidean / Frobenius norm — `sqrt(sum x_i^2)`.
+   * - `p = 'fro'`: alias for p=2 (Frobenius).
+   * - `p = 'inf'`: max of absolute values.
+   * - `p = '-inf'`: min of absolute values.
+   * - numeric p: `(sum |x_i|^p)^(1/p)`.
+   *
+   * When `axis` is given, the norm is computed along that single axis and the
+   * result has rank reduced by 1 (or stays the same with `keepDims`).
+   * When `axis` is omitted, the norm is computed over all elements.
+   */
+  norm(opts) {
+    const p = opts?.p ?? 2;
+    const keepDims = opts?.keepDims ?? false;
+    const axes = opts?.axis !== void 0 ? [opts.axis] : this.resolveAxes(void 0);
+    if (p === "fro" || p === 2) {
+      const sqSum = this.reduceAxes(axes, keepDims, 0, (acc, v) => acc + v * v);
+      const sqrtData = new Float64Array(sqSum.data.length);
+      for (let i = 0; i < sqSum.data.length; i++) sqrtData[i] = Math.sqrt(sqSum.data[i]);
+      return new _Tensor(sqSum.shape, sqrtData, sqSum.axisLabels);
+    }
+    if (p === "inf") {
+      return this.reduceAxes(axes, keepDims, 0, (acc, v) => Math.max(acc, Math.abs(v)));
+    }
+    if (p === "-inf") {
+      return this.reduceAxes(axes, keepDims, Infinity, (acc, v) => Math.min(acc, Math.abs(v)));
+    }
+    const pNum = p;
+    const powSum = this.reduceAxes(
+      axes,
+      keepDims,
+      0,
+      (acc, v) => acc + Math.pow(Math.abs(v), pNum)
+    );
+    const invP = 1 / pNum;
+    const result = new Float64Array(powSum.data.length);
+    for (let i = 0; i < powSum.data.length; i++) result[i] = Math.pow(powSum.data[i], invP);
+    return new _Tensor(powSum.shape, result, powSum.axisLabels);
+  }
+  /**
+   * Generalised dot product (NumPy `tensordot`) over explicitly specified axis pairs.
+   *
+   * `axes[i] = [a, b]` contracts axis `a` of `this` with axis `b` of `other`.
+   * The result shape is `this`'s non-contracted axes followed by `other`'s
+   * non-contracted axes (NumPy convention).
+   *
+   * Delegates to `Tensor.einsum` under the hood.
+   */
+  tensordot(other, axes) {
+    const selfRank = this.shape.length;
+    const otherRank = other.shape.length;
+    const selfContracted = /* @__PURE__ */ new Set();
+    const otherContracted = /* @__PURE__ */ new Set();
+    for (const [a, b] of axes) {
+      if (!Number.isInteger(a) || a < 0 || a >= selfRank) {
+        throw new Error(`Tensor.tensordot: axis ${a} of 'this' (rank ${selfRank}) is out of range`);
+      }
+      if (!Number.isInteger(b) || b < 0 || b >= otherRank) {
+        throw new Error(
+          `Tensor.tensordot: axis ${b} of 'other' (rank ${otherRank}) is out of range`
+        );
+      }
+      if (selfContracted.has(a)) {
+        throw new Error(`Tensor.tensordot: duplicate axis ${a} in self contraction list`);
+      }
+      if (otherContracted.has(b)) {
+        throw new Error(`Tensor.tensordot: duplicate axis ${b} in other contraction list`);
+      }
+      if (this.shape[a] !== other.shape[b]) {
+        throw new Error(
+          `Tensor.tensordot: dimension mismatch on contracted axes: this.shape[${a}]=${this.shape[a]} vs other.shape[${b}]=${other.shape[b]}`
+        );
+      }
+      selfContracted.add(a);
+      otherContracted.add(b);
+    }
+    const contractions = axes.map(([a, b]) => ({
+      pair: [
+        [0, a],
+        [1, b]
+      ]
+    }));
+    const free = [];
+    for (let si = 0; si < selfRank; si++) {
+      if (!selfContracted.has(si)) {
+        free.push({ operand: 0, axis: si });
+      }
+    }
+    for (let oi = 0; oi < otherRank; oi++) {
+      if (!otherContracted.has(oi)) {
+        free.push({ operand: 1, axis: oi });
+      }
+    }
+    const spec = { contractions, free };
+    const result = _Tensor.einsum(spec, this, other);
+    let resultLabels;
+    if (this.axisLabels !== void 0 || other.axisLabels !== void 0) {
+      if (this.axisLabels !== void 0 && other.axisLabels !== void 0) {
+        resultLabels = [];
+        for (let si = 0; si < selfRank; si++) {
+          if (!selfContracted.has(si)) {
+            resultLabels.push(this.axisLabels[si]);
+          }
+        }
+        for (let oi = 0; oi < otherRank; oi++) {
+          if (!otherContracted.has(oi)) {
+            resultLabels.push(other.axisLabels[oi]);
+          }
+        }
+      }
+    }
+    return new _Tensor([...result.shape], result.data, resultLabels);
+  }
+  /**
+   * Normalise an `axis` argument into a sorted list of axis indices.
+   * `undefined` ⇒ all axes (reduce everything to a rank-0 scalar).
+   */
+  resolveAxes(axis) {
+    if (axis === void 0) {
+      return Array.from({ length: this.shape.length }, (_, i) => i);
+    }
+    if (typeof axis === "number") {
+      return [axis];
+    }
+    return [...axis];
+  }
   static forEachIndex(shape, visit) {
     if (shape.length === 0) {
       visit([]);
       return;
     }
-    const idx = new Array(shape.length).fill(0);
+    const idx2 = new Array(shape.length).fill(0);
     const total = _Tensor.sizeOf(shape);
     for (let n = 0; n < total; n++) {
-      visit(idx);
+      visit(idx2);
       for (let k = shape.length - 1; k >= 0; k--) {
-        if (++idx[k] < shape[k]) break;
-        idx[k] = 0;
+        if (++idx2[k] < shape[k]) break;
+        idx2[k] = 0;
       }
     }
   }
-  static flatIndex(idx, strides) {
+  static flatIndex(idx2, strides) {
     let f = 0;
-    for (let k = 0; k < idx.length; k++) f += idx[k] * strides[k];
+    for (let k = 0; k < idx2.length; k++) f += idx2[k] * strides[k];
     return f;
   }
   reshape(shape) {
@@ -126,7 +515,8 @@ var Tensor = class _Tensor {
   transpose(perm) {
     const rank = this.shape.length;
     const p = perm ?? Array.from({ length: rank }, (_, i) => rank - 1 - i);
-    if (p.length !== rank) throw new Error(`Tensor.transpose: perm length ${p.length} != rank ${rank}`);
+    if (p.length !== rank)
+      throw new Error(`Tensor.transpose: perm length ${p.length} != rank ${rank}`);
     const outShape = p.map((axis) => this.shape[axis]);
     const inStrides = _Tensor.rowMajorStrides(this.shape);
     const outStrides = _Tensor.rowMajorStrides(outShape);
@@ -181,22 +571,20 @@ var Tensor = class _Tensor {
         if (ob === o) covered.add(axb);
       });
       if (covered.size !== operands[o].shape.length) {
-        throw new Error(
-          `Tensor.einsum: operand ${o} has axes not referenced by the spec`
-        );
+        throw new Error(`Tensor.einsum: operand ${o} has axes not referenced by the spec`);
       }
     }
     const operandFlatIndex = (opIndex, freeVals, contractVals) => {
-      const idx = new Array(operands[opIndex].shape.length).fill(0);
+      const idx2 = new Array(operands[opIndex].shape.length).fill(0);
       spec.free.forEach((fa, v) => {
-        if (fa.operand === opIndex) idx[fa.axis] = freeVals[v];
+        if (fa.operand === opIndex) idx2[fa.axis] = freeVals[v];
       });
       spec.contractions.forEach((c, v) => {
         const [[oa, axa], [ob, axb]] = c.pair;
-        if (oa === opIndex) idx[axa] = contractVals[v];
-        if (ob === opIndex) idx[axb] = contractVals[v];
+        if (oa === opIndex) idx2[axa] = contractVals[v];
+        if (ob === opIndex) idx2[axb] = contractVals[v];
       });
-      return _Tensor.flatIndex(idx, inStrides[opIndex]);
+      return _Tensor.flatIndex(idx2, inStrides[opIndex]);
     };
     _Tensor.forEachIndex(freeSizes, (freeVals) => {
       let acc = 0;
@@ -211,7 +599,1953 @@ var Tensor = class _Tensor {
     });
     return new _Tensor(freeSizes, out);
   }
+  // -------------------------------------------------------------------------
+  // Named-index API (opt-in via axisLabels)
+  // -------------------------------------------------------------------------
+  /**
+   * Return the axis position (0-based) of a labelled index.
+   * Throws if the index is not found in `axisLabels`.
+   */
+  axisOf(index) {
+    if (this.axisLabels === void 0) {
+      throw new Error("Tensor.axisOf: this tensor has no axisLabels");
+    }
+    const pos = this.axisLabels.findIndex((lbl) => lbl.matches(index));
+    if (pos === -1) {
+      throw new Error(`Tensor.axisOf: index ${index.toString()} not found in axisLabels`);
+    }
+    return pos;
+  }
+  /**
+   * Return a new Tensor with the same data and shape but with `oldIndex`
+   * swapped for `newIndex` in `axisLabels`.
+   * Throws if `oldIndex` is not found.
+   */
+  replaceIndex(oldIndex, newIndex) {
+    if (this.axisLabels === void 0) {
+      throw new Error("Tensor.replaceIndex: this tensor has no axisLabels");
+    }
+    const pos = this.axisLabels.findIndex((lbl) => lbl.matches(oldIndex));
+    if (pos === -1) {
+      throw new Error(`Tensor.replaceIndex: index ${oldIndex.toString()} not found in axisLabels`);
+    }
+    const newLabels = [...this.axisLabels];
+    newLabels[pos] = newIndex;
+    return new _Tensor([...this.shape], this.data.slice(), newLabels);
+  }
+  /**
+   * Contract this tensor with `other` over every shared index (matched by
+   * `Index.matches`). Both operands must carry `axisLabels`.
+   *
+   * The result tensor carries the non-shared axes from `this` followed by
+   * the non-shared axes from `other` as its `axisLabels`.
+   *
+   * Throws:
+   * - If either operand lacks `axisLabels`.
+   * - If there are no shared indices (use `einsum` or an explicit outer product).
+   * - If a shared index has mismatched dimensions on the two operands.
+   */
+  contract(other) {
+    if (this.axisLabels === void 0 || other.axisLabels === void 0) {
+      throw new Error("Tensor.contract requires axisLabels on both operands");
+    }
+    const sharedPairs = [];
+    for (let si = 0; si < this.axisLabels.length; si++) {
+      for (let oi = 0; oi < other.axisLabels.length; oi++) {
+        if (this.axisLabels[si].matches(other.axisLabels[oi])) {
+          sharedPairs.push({ selfAxis: si, otherAxis: oi });
+          break;
+        }
+      }
+    }
+    if (sharedPairs.length === 0) {
+      throw new Error(
+        "Tensor.contract: no shared indices to contract; use einsum or an explicit outer product"
+      );
+    }
+    for (const { selfAxis, otherAxis } of sharedPairs) {
+      const dSelf = this.shape[selfAxis];
+      const dOther = other.shape[otherAxis];
+      if (dSelf !== dOther) {
+        throw new Error(
+          `Tensor.contract: shared index ${this.axisLabels[selfAxis].toString()} has dimension ${dSelf} on 'this' but ${dOther} on 'other'`
+        );
+      }
+    }
+    const sharedSelfAxes = new Set(sharedPairs.map((p) => p.selfAxis));
+    const sharedOtherAxes = new Set(sharedPairs.map((p) => p.otherAxis));
+    let letterCount = 0;
+    const selfLetters = new Array(this.shape.length).fill(-1);
+    const otherLetters = new Array(other.shape.length).fill(-1);
+    for (const { selfAxis, otherAxis } of sharedPairs) {
+      const letter = letterCount++;
+      selfLetters[selfAxis] = letter;
+      otherLetters[otherAxis] = letter;
+    }
+    for (let si = 0; si < this.shape.length; si++) {
+      if (!sharedSelfAxes.has(si)) {
+        selfLetters[si] = letterCount++;
+      }
+    }
+    for (let oi = 0; oi < other.shape.length; oi++) {
+      if (!sharedOtherAxes.has(oi)) {
+        otherLetters[oi] = letterCount++;
+      }
+    }
+    const contractions = sharedPairs.map(
+      ({ selfAxis, otherAxis }) => ({
+        pair: [
+          [0, selfAxis],
+          [1, otherAxis]
+        ]
+      })
+    );
+    const free = [];
+    for (let si = 0; si < this.shape.length; si++) {
+      if (!sharedSelfAxes.has(si)) {
+        free.push({ operand: 0, axis: si });
+      }
+    }
+    for (let oi = 0; oi < other.shape.length; oi++) {
+      if (!sharedOtherAxes.has(oi)) {
+        free.push({ operand: 1, axis: oi });
+      }
+    }
+    const spec = { contractions, free };
+    const result = _Tensor.einsum(spec, this, other);
+    const resultLabels = [];
+    for (let si = 0; si < this.axisLabels.length; si++) {
+      if (!sharedSelfAxes.has(si)) {
+        resultLabels.push(this.axisLabels[si]);
+      }
+    }
+    for (let oi = 0; oi < other.axisLabels.length; oi++) {
+      if (!sharedOtherAxes.has(oi)) {
+        resultLabels.push(other.axisLabels[oi]);
+      }
+    }
+    return new _Tensor([...result.shape], result.data, resultLabels);
+  }
 };
+
+// src/named-index.ts
+var Index = class _Index {
+  id;
+  dim;
+  name;
+  tags;
+  primeLevel;
+  constructor(dim, opts) {
+    if (!Number.isInteger(dim) || dim < 1) {
+      throw new Error(`Index: dim must be a positive integer, got ${dim}`);
+    }
+    this.id = Symbol(opts?.name ?? "");
+    this.dim = dim;
+    this.name = opts?.name;
+    this.tags = opts?.tags ? [...opts.tags] : [];
+    this.primeLevel = opts?.primeLevel ?? 0;
+  }
+  /**
+   * Internal constructor used by mutating-style methods that need to share the
+   * same `id` with a different primeLevel / tags. Not exposed publicly.
+   */
+  static _from(id, dim, name, tags, primeLevel) {
+    const ix = Object.create(_Index.prototype);
+    ix.id = id;
+    ix.dim = dim;
+    ix.name = name;
+    ix.tags = [...tags];
+    ix.primeLevel = primeLevel;
+    return ix;
+  }
+  /**
+   * Return a new Index with `primeLevel` incremented by `by` (default 1).
+   */
+  prime(by = 1) {
+    if (!Number.isInteger(by) || by < 1) {
+      throw new Error(`Index.prime: 'by' must be a positive integer, got ${by}`);
+    }
+    return _Index._from(this.id, this.dim, this.name, this.tags, this.primeLevel + by);
+  }
+  /**
+   * Return a new Index with `primeLevel` reset to 0.
+   */
+  noprime() {
+    return _Index._from(this.id, this.dim, this.name, this.tags, 0);
+  }
+  /**
+   * Return a new Index with `tag` added to its tag list (no-op if already present).
+   */
+  addTag(tag) {
+    if (this.tags.includes(tag)) return this;
+    return _Index._from(this.id, this.dim, this.name, [...this.tags, tag], this.primeLevel);
+  }
+  /**
+   * Return a new Index with `tag` removed from its tag list (no-op if absent).
+   */
+  removeTag(tag) {
+    const next = this.tags.filter((t) => t !== tag);
+    if (next.length === this.tags.length) return this;
+    return _Index._from(this.id, this.dim, this.name, next, this.primeLevel);
+  }
+  /**
+   * True if `tag` is in this index's tag list.
+   */
+  hasTag(tag) {
+    return this.tags.includes(tag);
+  }
+  /**
+   * Two indices match iff they share the same `id` AND the same `primeLevel`.
+   * Dimension is NOT used for matching — it is validated at contraction time.
+   */
+  matches(other) {
+    return this.id === other.id && this.primeLevel === other.primeLevel;
+  }
+  toString() {
+    const primeStr = this.primeLevel > 0 ? `'`.repeat(this.primeLevel) : "";
+    const nameStr = this.name ?? this.id.toString();
+    const tagStr = this.tags.length > 0 ? ` [${this.tags.join(",")}]` : "";
+    return `Index(${nameStr}${primeStr}, dim=${this.dim}${tagStr})`;
+  }
+};
+function idx(dim, name, opts) {
+  return new Index(dim, { name, ...opts });
+}
+
+// src/operations/svd.ts
+import { svd } from "@danielsimonjr/mathts-matrix";
+function tensorSvd(t, rowAxes, opts) {
+  const rank = t.shape.length;
+  for (const ax of rowAxes) {
+    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
+      throw new RangeError(
+        `tensorSvd: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
+      );
+    }
+  }
+  const rowSet = new Set(rowAxes);
+  const colAxes = [];
+  for (let i = 0; i < rank; i++) {
+    if (!rowSet.has(i)) colAxes.push(i);
+  }
+  if (colAxes.length === 0) {
+    throw new Error("tensorSvd: rowAxes covers all axes \u2014 at least one axis must remain for V");
+  }
+  if (rowAxes.length === 0) {
+    throw new Error("tensorSvd: rowAxes is empty \u2014 at least one axis must be assigned to U");
+  }
+  const perm = [...rowAxes, ...colAxes];
+  const permuted = t.transpose(perm);
+  const rowDims = rowAxes.map((ax) => t.shape[ax]);
+  const colDims = colAxes.map((ax) => t.shape[ax]);
+  const numRows = rowDims.reduce((a, b) => a * b, 1);
+  const numCols = colDims.reduce((a, b) => a * b, 1);
+  const matrix = Array.from(
+    { length: numRows },
+    (_, i) => Array.from({ length: numCols }, (_2, j) => permuted.data[i * numCols + j])
+  );
+  const result = svd(matrix, { tolerance: 1e-12 });
+  const { U: fullU, S: allS, V: fullV } = result;
+  const cutoff = opts?.cutoff ?? 0;
+  const maxdim = opts?.maxdim;
+  let k = allS.filter((s) => s >= cutoff).length;
+  if (maxdim !== void 0) {
+    k = Math.min(k, maxdim);
+  }
+  k = Math.min(k, allS.length);
+  let truncationError = 0;
+  for (let i = k; i < allS.length; i++) {
+    truncationError += allS[i] * allS[i];
+  }
+  const truncatedDim = k;
+  const uData = new Float64Array(numRows * k);
+  for (let i = 0; i < numRows; i++) {
+    for (let j = 0; j < k; j++) {
+      uData[i * k + j] = fullU[i][j];
+    }
+  }
+  const uTensor = new Tensor([...rowDims, k], uData);
+  const vData = new Float64Array(k * numCols);
+  for (let j = 0; j < k; j++) {
+    for (let i = 0; i < numCols; i++) {
+      vData[j * numCols + i] = fullV[i][j];
+    }
+  }
+  const vTensor = new Tensor([k, ...colDims], vData);
+  const sData = new Float64Array(k);
+  for (let j = 0; j < k; j++) {
+    sData[j] = allS[j];
+  }
+  const sTensor = new Tensor([k], sData);
+  return {
+    U: uTensor,
+    S: sTensor,
+    V: vTensor,
+    truncatedDim,
+    truncationError
+  };
+}
+
+// src/operations/random.ts
+import { DenseMatrix as DenseMatrix2, qr as matrixQr } from "@danielsimonjr/mathts-matrix";
+function makeMulberry32(seed) {
+  let s = seed | 0;
+  return () => {
+    s = s + 1831565813 | 0;
+    let z = s;
+    z = Math.imul(z ^ z >>> 15, z | 1);
+    z ^= z + Math.imul(z ^ z >>> 7, z | 61);
+    z = (z ^ z >>> 14) >>> 0;
+    return z / 4294967296;
+  };
+}
+function boxMuller(u1, u2) {
+  const clamped = u1 === 0 ? Number.EPSILON : u1;
+  const r = Math.sqrt(-2 * Math.log(clamped));
+  const theta = 2 * Math.PI * u2;
+  return [r * Math.cos(theta), r * Math.sin(theta)];
+}
+function thinQViaMatrixQr(data, rows, cols) {
+  const matA = new DenseMatrix2(rows, cols, data);
+  const { Q: matQ } = matrixQr(matA, { mode: "reduced" });
+  return matQ.toFloat64Array();
+}
+function randomTensor(shape, opts) {
+  const distribution = opts?.distribution ?? "uniform";
+  const axisLabels = opts?.axisLabels;
+  const size = shape.reduce((acc, d) => acc * d, 1);
+  const rng = opts?.seed !== void 0 ? makeMulberry32(opts.seed) : () => Math.random();
+  if (distribution === "orthogonal") {
+    if (shape.length !== 2) {
+      throw new Error("randomTensor: 'orthogonal' distribution requires a rank-2 shape");
+    }
+    const [rows, cols] = shape;
+    const totalNormal = rows * cols;
+    const normalData = new Float64Array(totalNormal);
+    let idx2 = 0;
+    while (idx2 < totalNormal - 1) {
+      const [z0, z1] = boxMuller(rng(), rng());
+      normalData[idx2++] = z0;
+      normalData[idx2++] = z1;
+    }
+    if (idx2 < totalNormal) {
+      const [z0] = boxMuller(rng(), rng());
+      normalData[idx2] = z0;
+    }
+    const qCols = Math.min(rows, cols);
+    const qData = thinQViaMatrixQr(normalData, rows, qCols);
+    const outShape = [rows, qCols];
+    return new Tensor(outShape, qData, axisLabels);
+  }
+  const data = new Float64Array(size);
+  if (distribution === "uniform") {
+    for (let i = 0; i < size; i++) {
+      data[i] = rng();
+    }
+  } else if (distribution === "normal") {
+    let i = 0;
+    while (i < size - 1) {
+      const [z0, z1] = boxMuller(rng(), rng());
+      data[i++] = z0;
+      data[i++] = z1;
+    }
+    if (i < size) {
+      const [z0] = boxMuller(rng(), rng());
+      data[i] = z0;
+    }
+  } else {
+    const _exhaustive = distribution;
+    throw new Error(`randomTensor: unknown distribution '${String(_exhaustive)}'`);
+  }
+  return new Tensor([...shape], data, axisLabels);
+}
+
+// src/contraction-sequence.ts
+function pairwise(a, b) {
+  const aIsShared = new Array(a.indices.length).fill(false);
+  const bIsShared = new Array(b.indices.length).fill(false);
+  let dShared = 1;
+  for (let i = 0; i < a.indices.length; i++) {
+    for (let j = 0; j < b.indices.length; j++) {
+      if (bIsShared[j]) continue;
+      if (a.indices[i].matches(b.indices[j])) {
+        aIsShared[i] = true;
+        bIsShared[j] = true;
+        dShared *= a.indices[i].dim;
+        break;
+      }
+    }
+  }
+  let dFreeLeft = 1;
+  const free = [];
+  for (let i = 0; i < a.indices.length; i++) {
+    if (!aIsShared[i]) {
+      dFreeLeft *= a.indices[i].dim;
+      free.push(a.indices[i]);
+    }
+  }
+  let dFreeRight = 1;
+  for (let j = 0; j < b.indices.length; j++) {
+    if (!bIsShared[j]) {
+      dFreeRight *= b.indices[j].dim;
+      free.push(b.indices[j]);
+    }
+  }
+  const cost = dShared * dFreeLeft * dFreeRight;
+  const resultSize = dFreeLeft * dFreeRight;
+  return { cost, resultShape: { indices: free }, resultSize };
+}
+function netShape(shapes) {
+  const seen = [];
+  for (const sh of shapes) {
+    for (const ix of sh.indices) {
+      let found = false;
+      for (const entry of seen) {
+        if (entry.index.matches(ix)) {
+          entry.count++;
+          found = true;
+          break;
+        }
+      }
+      if (!found) seen.push({ index: ix, count: 1 });
+    }
+  }
+  return { indices: seen.filter((e) => e.count === 1).map((e) => e.index) };
+}
+function extractShapes(tensors) {
+  const shapes = [];
+  for (let i = 0; i < tensors.length; i++) {
+    const t = tensors[i];
+    if (t.axisLabels === void 0) {
+      throw new Error(`contractNetwork: tensor at index ${i} lacks axisLabels`);
+    }
+    shapes.push({ indices: t.axisLabels });
+  }
+  return shapes;
+}
+function buildCanonicalTable(shapes) {
+  const keyByIndex = [];
+  const dimsByKey = [];
+  const globalCount = [];
+  const perInputMaskLo = [];
+  const perInputMaskHi = [];
+  const lookupOrInsert = (ix) => {
+    for (const entry of keyByIndex) {
+      if (entry.index.matches(ix)) return entry.key;
+    }
+    const newKey = dimsByKey.length;
+    dimsByKey.push(ix.dim);
+    globalCount.push(0);
+    keyByIndex.push({ index: ix, key: newKey });
+    return newKey;
+  };
+  for (const sh of shapes) {
+    let maskLo = 0;
+    let maskHi = 0;
+    for (const ix of sh.indices) {
+      const key = lookupOrInsert(ix);
+      if (key < 30) {
+        maskLo |= 1 << key;
+      } else {
+        maskHi |= 1 << key - 30;
+      }
+      globalCount[key]++;
+    }
+    perInputMaskLo.push(maskLo);
+    perInputMaskHi.push(maskHi);
+  }
+  const xorSafe = globalCount.every((c) => c <= 2);
+  return {
+    dimsByKey,
+    perInputMaskLo,
+    perInputMaskHi,
+    xorSafe,
+    uniqueIndexCount: dimsByKey.length
+  };
+}
+function solveExact(shapes, maxIntermediateSize) {
+  const N = shapes.length;
+  if (N > 30) {
+    throw new Error(
+      `contractNetwork (exact): N=${N} exceeds bitmask cap of 30; use algorithm: 'greedy'`
+    );
+  }
+  const table = buildCanonicalTable(shapes);
+  if (!table.xorSafe || table.uniqueIndexCount > 60) {
+    return solveExactSlow(shapes, maxIntermediateSize);
+  }
+  const dims = table.dimsByKey;
+  const dp = new Array(1 << N);
+  const maskLoOf = new Int32Array(1 << N);
+  const maskHiOf = new Int32Array(1 << N);
+  for (let i = 0; i < N; i++) {
+    const single = 1 << i;
+    dp[single] = { cost: 0, split: null };
+    maskLoOf[single] = table.perInputMaskLo[i];
+    maskHiOf[single] = table.perInputMaskHi[i];
+  }
+  const full = (1 << N) - 1;
+  const masksByPopcount = [];
+  for (let k = 0; k <= N; k++) masksByPopcount.push([]);
+  for (let mask = 1; mask <= full; mask++) {
+    let pc = 0;
+    for (let m = mask; m > 0; m &= m - 1) pc++;
+    masksByPopcount[pc].push(mask);
+  }
+  for (let pc = 2; pc <= N; pc++) {
+    const buckets = masksByPopcount[pc];
+    for (let bi = 0; bi < buckets.length; bi++) {
+      const mask = buckets[bi];
+      let bestCost = Infinity;
+      let bestS1 = -1;
+      let bestS2 = -1;
+      let bestMaskLo = 0;
+      let bestMaskHi = 0;
+      for (let sub = mask - 1 & mask; sub > 0; sub = sub - 1 & mask) {
+        const comp = mask ^ sub;
+        if (sub > comp) continue;
+        const left = dp[sub];
+        const right = dp[comp];
+        if (!left || !right) continue;
+        const lLo = maskLoOf[sub];
+        const lHi = maskHiOf[sub];
+        const rLo = maskLoOf[comp];
+        const rHi = maskHiOf[comp];
+        const sharedLo = lLo & rLo;
+        const sharedHi = lHi & rHi;
+        const leftOnlyLo = lLo & ~rLo;
+        const leftOnlyHi = lHi & ~rHi;
+        const rightOnlyLo = rLo & ~lLo;
+        const rightOnlyHi = rHi & ~lHi;
+        let dShared = 1;
+        let m1 = sharedLo;
+        while (m1 !== 0) {
+          const lsb = m1 & -m1;
+          dShared *= dims[31 - Math.clz32(lsb)];
+          m1 ^= lsb;
+        }
+        let m2 = sharedHi;
+        while (m2 !== 0) {
+          const lsb = m2 & -m2;
+          dShared *= dims[30 + 31 - Math.clz32(lsb)];
+          m2 ^= lsb;
+        }
+        let dFreeLeft = 1;
+        m1 = leftOnlyLo;
+        while (m1 !== 0) {
+          const lsb = m1 & -m1;
+          dFreeLeft *= dims[31 - Math.clz32(lsb)];
+          m1 ^= lsb;
+        }
+        m2 = leftOnlyHi;
+        while (m2 !== 0) {
+          const lsb = m2 & -m2;
+          dFreeLeft *= dims[30 + 31 - Math.clz32(lsb)];
+          m2 ^= lsb;
+        }
+        let dFreeRight = 1;
+        m1 = rightOnlyLo;
+        while (m1 !== 0) {
+          const lsb = m1 & -m1;
+          dFreeRight *= dims[31 - Math.clz32(lsb)];
+          m1 ^= lsb;
+        }
+        m2 = rightOnlyHi;
+        while (m2 !== 0) {
+          const lsb = m2 & -m2;
+          dFreeRight *= dims[30 + 31 - Math.clz32(lsb)];
+          m2 ^= lsb;
+        }
+        const stepCost = dShared * dFreeLeft * dFreeRight;
+        const stepResultSize = dFreeLeft * dFreeRight;
+        if (stepResultSize > maxIntermediateSize) continue;
+        const total = left.cost + right.cost + stepCost;
+        const better = total < bestCost || total === bestCost && (sub < bestS1 || sub === bestS1 && comp < bestS2);
+        if (better) {
+          bestCost = total;
+          bestS1 = sub;
+          bestS2 = comp;
+          bestMaskLo = lLo ^ rLo;
+          bestMaskHi = lHi ^ rHi;
+        }
+      }
+      if (bestS1 !== -1) {
+        dp[mask] = { cost: bestCost, split: [bestS1, bestS2] };
+        maskLoOf[mask] = bestMaskLo;
+        maskHiOf[mask] = bestMaskHi;
+      }
+    }
+  }
+  const root = dp[full];
+  if (!root) return null;
+  const steps = [];
+  const slotFor = /* @__PURE__ */ new Map();
+  for (let i = 0; i < N; i++) slotFor.set(1 << i, i);
+  let nextSlot = N;
+  const stepFor = (s1, s2) => {
+    const lLo = maskLoOf[s1];
+    const lHi = maskHiOf[s1];
+    const rLo = maskLoOf[s2];
+    const rHi = maskHiOf[s2];
+    const sharedLo = lLo & rLo;
+    const sharedHi = lHi & rHi;
+    const leftOnlyLo = lLo & ~rLo;
+    const leftOnlyHi = lHi & ~rHi;
+    const rightOnlyLo = rLo & ~lLo;
+    const rightOnlyHi = rHi & ~lHi;
+    let dShared = 1;
+    for (let m = sharedLo; m !== 0; ) {
+      const lsb = m & -m;
+      dShared *= dims[31 - Math.clz32(lsb)];
+      m ^= lsb;
+    }
+    for (let m = sharedHi; m !== 0; ) {
+      const lsb = m & -m;
+      dShared *= dims[30 + 31 - Math.clz32(lsb)];
+      m ^= lsb;
+    }
+    let dFL = 1;
+    for (let m = leftOnlyLo; m !== 0; ) {
+      const lsb = m & -m;
+      dFL *= dims[31 - Math.clz32(lsb)];
+      m ^= lsb;
+    }
+    for (let m = leftOnlyHi; m !== 0; ) {
+      const lsb = m & -m;
+      dFL *= dims[30 + 31 - Math.clz32(lsb)];
+      m ^= lsb;
+    }
+    let dFR = 1;
+    for (let m = rightOnlyLo; m !== 0; ) {
+      const lsb = m & -m;
+      dFR *= dims[31 - Math.clz32(lsb)];
+      m ^= lsb;
+    }
+    for (let m = rightOnlyHi; m !== 0; ) {
+      const lsb = m & -m;
+      dFR *= dims[30 + 31 - Math.clz32(lsb)];
+      m ^= lsb;
+    }
+    return { cost: dShared * dFL * dFR, resultSize: dFL * dFR };
+  };
+  const stack2 = [{ mask: full, visited: false }];
+  while (stack2.length > 0) {
+    const frame = stack2[stack2.length - 1];
+    if (frame.visited) {
+      stack2.pop();
+      if (slotFor.has(frame.mask)) continue;
+      const entry2 = dp[frame.mask];
+      const [s12, s22] = entry2.split;
+      const step = stepFor(s12, s22);
+      const slot1 = slotFor.get(s12);
+      const slot2 = slotFor.get(s22);
+      const orderedPair = slot1 <= slot2 ? [slot1, slot2] : [slot2, slot1];
+      steps.push({ pair: orderedPair, cost: step.cost, resultSize: step.resultSize });
+      slotFor.set(frame.mask, nextSlot++);
+      continue;
+    }
+    frame.visited = true;
+    if (slotFor.has(frame.mask)) continue;
+    const entry = dp[frame.mask];
+    if (!entry.split) continue;
+    const [s1, s2] = entry.split;
+    stack2.push({ mask: s2, visited: false });
+    stack2.push({ mask: s1, visited: false });
+  }
+  return { steps };
+}
+function solveExactSlow(shapes, maxIntermediateSize) {
+  const N = shapes.length;
+  const dp = /* @__PURE__ */ new Map();
+  for (let i = 0; i < N; i++) {
+    dp.set(1 << i, { cost: 0, split: null, shape: shapes[i] });
+  }
+  const full = (1 << N) - 1;
+  const masksByPopcount = [];
+  for (let k = 0; k <= N; k++) masksByPopcount.push([]);
+  for (let mask = 1; mask <= full; mask++) {
+    let pc = 0;
+    for (let m = mask; m > 0; m &= m - 1) pc++;
+    masksByPopcount[pc].push(mask);
+  }
+  for (let pc = 2; pc <= N; pc++) {
+    for (const mask of masksByPopcount[pc]) {
+      let best = null;
+      for (let sub = mask - 1 & mask; sub > 0; sub = sub - 1 & mask) {
+        const comp = mask ^ sub;
+        if (sub > comp) continue;
+        const left = dp.get(sub);
+        const right = dp.get(comp);
+        if (!left || !right) continue;
+        const step = pairwise(left.shape, right.shape);
+        if (step.resultSize > maxIntermediateSize) continue;
+        const total = left.cost + right.cost + step.cost;
+        if (best === null || total < best.cost || total === best.cost && tieBreakBetter(sub, comp, best.split)) {
+          best = { cost: total, split: [sub, comp], shape: step.resultShape };
+        }
+      }
+      if (best !== null) {
+        dp.set(mask, { cost: best.cost, split: best.split, shape: best.shape });
+      }
+    }
+  }
+  const root = dp.get(full);
+  if (!root) return null;
+  const steps = [];
+  const slotFor = /* @__PURE__ */ new Map();
+  for (let i = 0; i < N; i++) slotFor.set(1 << i, i);
+  let nextSlot = N;
+  const stack2 = [{ mask: full, visited: false }];
+  while (stack2.length > 0) {
+    const frame = stack2[stack2.length - 1];
+    if (frame.visited) {
+      stack2.pop();
+      if (slotFor.has(frame.mask)) continue;
+      const entry2 = dp.get(frame.mask);
+      const [s12, s22] = entry2.split;
+      const left = dp.get(s12);
+      const right = dp.get(s22);
+      const step = pairwise(left.shape, right.shape);
+      const slot1 = slotFor.get(s12);
+      const slot2 = slotFor.get(s22);
+      const orderedPair = slot1 <= slot2 ? [slot1, slot2] : [slot2, slot1];
+      steps.push({ pair: orderedPair, cost: step.cost, resultSize: step.resultSize });
+      slotFor.set(frame.mask, nextSlot++);
+      continue;
+    }
+    frame.visited = true;
+    if (slotFor.has(frame.mask)) continue;
+    const entry = dp.get(frame.mask);
+    if (!entry.split) continue;
+    const [s1, s2] = entry.split;
+    stack2.push({ mask: s2, visited: false });
+    stack2.push({ mask: s1, visited: false });
+  }
+  return { steps };
+}
+function tieBreakBetter(a, b, prev) {
+  if (!prev) return true;
+  if (a < prev[0]) return true;
+  if (a > prev[0]) return false;
+  return b < prev[1];
+}
+function solveGreedy(shapes, maxIntermediateSize) {
+  const N = shapes.length;
+  const working = [];
+  for (let i = 0; i < N; i++) working.push({ slot: i, shape: shapes[i] });
+  let nextSlot = N;
+  const steps = [];
+  while (working.length > 1) {
+    let bestI = -1;
+    let bestJ = -1;
+    let bestCost = Infinity;
+    let bestStep = null;
+    let bestSharedCount = -1;
+    for (let i = 0; i < working.length; i++) {
+      for (let j = i + 1; j < working.length; j++) {
+        const step = pairwise(working[i].shape, working[j].shape);
+        if (step.resultSize > maxIntermediateSize) continue;
+        let shared = 0;
+        for (const ix of working[i].shape.indices) {
+          for (const jx of working[j].shape.indices) {
+            if (ix.matches(jx)) {
+              shared++;
+              break;
+            }
+          }
+        }
+        const isBetter = step.cost < bestCost || step.cost === bestCost && shared > bestSharedCount || step.cost === bestCost && shared === bestSharedCount && (i < bestI || i === bestI && j < bestJ);
+        if (isBetter) {
+          bestI = i;
+          bestJ = j;
+          bestCost = step.cost;
+          bestStep = step;
+          bestSharedCount = shared;
+        }
+      }
+    }
+    if (bestStep === null || bestI === -1) {
+      return null;
+    }
+    const slotI = working[bestI].slot;
+    const slotJ = working[bestJ].slot;
+    const orderedPair = slotI <= slotJ ? [slotI, slotJ] : [slotJ, slotI];
+    steps.push({ pair: orderedPair, cost: bestStep.cost, resultSize: bestStep.resultSize });
+    working.splice(bestJ, 1);
+    working.splice(bestI, 1);
+    working.push({ slot: nextSlot++, shape: bestStep.resultShape });
+  }
+  return { steps };
+}
+function executePlan(inputs, plan) {
+  const slots = /* @__PURE__ */ new Map();
+  for (let i = 0; i < inputs.length; i++) slots.set(i, inputs[i]);
+  let nextSlot = inputs.length;
+  const intermediateSizes = [];
+  for (const step of plan) {
+    const [i, j] = step.pair;
+    const a = slots.get(i);
+    const b = slots.get(j);
+    if (!a || !b) {
+      throw new Error(
+        `contractNetwork: plan references unknown virtual slot (${i}, ${j}); plan is corrupted`
+      );
+    }
+    const out = a.contract(b);
+    intermediateSizes.push(out.data.length);
+    slots.set(nextSlot++, out);
+  }
+  const finalSlot = nextSlot - 1;
+  const result = slots.get(finalSlot);
+  if (!result) throw new Error("contractNetwork: empty plan produced no result");
+  return { result, intermediateSizes };
+}
+function contractNetwork(tensors, opts) {
+  if (tensors.length === 0) {
+    throw new Error("contractNetwork: tensors array is empty");
+  }
+  if (tensors.length === 1) {
+    return {
+      result: tensors[0],
+      contractionOrder: [],
+      totalFlops: 0,
+      intermediateSizes: []
+    };
+  }
+  const shapes = extractShapes(tensors);
+  const maxIntermediateSize = opts?.maxIntermediateSize ?? 2 ** 31;
+  const algorithmRaw = opts?.algorithm ?? "auto";
+  const N = tensors.length;
+  const algorithm = algorithmRaw === "auto" ? N <= 16 ? "exact" : "greedy" : algorithmRaw;
+  const planResult = algorithm === "exact" ? solveExact(shapes, maxIntermediateSize) : solveGreedy(shapes, maxIntermediateSize);
+  if (planResult === null) {
+    throw new Error(
+      `contractNetwork: no valid contraction order found under maxIntermediateSize=${maxIntermediateSize}`
+    );
+  }
+  void netShape(shapes);
+  const { result, intermediateSizes } = executePlan(tensors, planResult.steps);
+  const contractionOrder = planResult.steps.map((s) => s.pair);
+  const totalFlops = planResult.steps.reduce((acc, s) => acc + s.cost, 0);
+  return {
+    result,
+    contractionOrder,
+    totalFlops,
+    intermediateSizes
+  };
+}
+
+// src/operations/qr.ts
+import { DenseMatrix as DenseMatrix3, qr as matrixQR } from "@danielsimonjr/mathts-matrix";
+function tensorQr(t, rowAxes, opts) {
+  const rank = t.shape.length;
+  const mode = opts?.mode ?? "reduced";
+  for (const ax of rowAxes) {
+    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
+      throw new RangeError(
+        `tensorQr: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
+      );
+    }
+  }
+  const rowSet = new Set(rowAxes);
+  if (rowSet.size !== rowAxes.length) {
+    throw new Error("tensorQr: rowAxes contains duplicate axes");
+  }
+  const colAxes = [];
+  for (let i = 0; i < rank; i++) {
+    if (!rowSet.has(i)) colAxes.push(i);
+  }
+  if (colAxes.length === 0) {
+    throw new Error("tensorQr: rowAxes covers all axes \u2014 at least one axis must remain for R");
+  }
+  if (rowAxes.length === 0) {
+    throw new Error("tensorQr: rowAxes is empty \u2014 at least one axis must be assigned to Q");
+  }
+  const perm = [...rowAxes, ...colAxes];
+  const permuted = t.transpose(perm);
+  const rowDims = rowAxes.map((ax) => t.shape[ax]);
+  const colDims = colAxes.map((ax) => t.shape[ax]);
+  const numRows = rowDims.reduce((a, b) => a * b, 1);
+  const numCols = colDims.reduce((a, b) => a * b, 1);
+  const mat = new DenseMatrix3(numRows, numCols, permuted.data.slice());
+  const { Q: qMat, R: rMat } = matrixQR(mat, { mode });
+  const qCols = qMat.cols;
+  const rRows = rMat.rows;
+  const qData = qMat.toFloat64Array();
+  const rData = rMat.toFloat64Array();
+  let qLabels;
+  let rLabels;
+  if (t.axisLabels !== void 0) {
+    const joiningDim = qCols;
+    const joiningIndex = new Index(joiningDim, {
+      name: opts?.joiningIndexName ?? "qr"
+    });
+    const rowLabels = rowAxes.map((ax) => t.axisLabels[ax]);
+    const colLabels = colAxes.map((ax) => t.axisLabels[ax]);
+    qLabels = [...rowLabels, joiningIndex];
+    rLabels = [joiningIndex, ...colLabels];
+  }
+  const qTensor = new Tensor([...rowDims, qCols], qData, qLabels);
+  const rTensor = new Tensor([rRows, ...colDims], rData, rLabels);
+  return { Q: qTensor, R: rTensor };
+}
+
+// src/operations/lu.ts
+import { DenseMatrix as DenseMatrix4 } from "@danielsimonjr/mathts-matrix";
+import { lu as matrixLU } from "@danielsimonjr/mathts-matrix";
+function tensorLU(t, rowAxes, opts) {
+  const rank = t.shape.length;
+  for (const ax of rowAxes) {
+    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
+      throw new RangeError(
+        `tensorLU: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
+      );
+    }
+  }
+  const rowSet = new Set(rowAxes);
+  if (rowSet.size !== rowAxes.length) {
+    throw new Error("tensorLU: rowAxes contains duplicate axes");
+  }
+  const colAxes = [];
+  for (let i = 0; i < rank; i++) {
+    if (!rowSet.has(i)) colAxes.push(i);
+  }
+  if (colAxes.length === 0) {
+    throw new Error("tensorLU: rowAxes covers all axes \u2014 at least one axis must remain for U");
+  }
+  if (rowAxes.length === 0) {
+    throw new Error("tensorLU: rowAxes is empty \u2014 at least one axis must be assigned to L");
+  }
+  const rowDims = rowAxes.map((ax) => t.shape[ax]);
+  const colDims = colAxes.map((ax) => t.shape[ax]);
+  const numRows = rowDims.reduce((a, b) => a * b, 1);
+  const numCols = colDims.reduce((a, b) => a * b, 1);
+  if (numRows !== numCols) {
+    throw new Error(
+      `tensorLU: reshaped matrix must be square (got ${numRows}\xD7${numCols}); LU decomposition requires equal row and column dimensions`
+    );
+  }
+  const perm = [...rowAxes, ...colAxes];
+  const permuted = t.transpose(perm);
+  const n = numRows;
+  const matA = new DenseMatrix4(n, n, new Float64Array(permuted.data));
+  const { L: matL, U: matU, P: matP } = matrixLU(matA);
+  const P = new Int32Array(matP);
+  let parity = 1;
+  const visited = new Uint8Array(n);
+  for (let i = 0; i < n; i++) {
+    if (visited[i] || P[i] === i) {
+      visited[i] = 1;
+      continue;
+    }
+    let cycleLen = 0;
+    let j = i;
+    while (!visited[j]) {
+      visited[j] = 1;
+      j = P[j];
+      cycleLen++;
+    }
+    if ((cycleLen - 1) % 2 !== 0) {
+      parity = parity === 1 ? -1 : 1;
+    }
+  }
+  const lData = matL.toFloat64Array();
+  const uData = matU.toFloat64Array();
+  let lLabels;
+  let uLabels;
+  if (t.axisLabels !== void 0) {
+    const joiningIndex = new Index(n, {
+      name: opts?.joiningIndexName ?? "lu"
+    });
+    const rowLabels = rowAxes.map((ax) => t.axisLabels[ax]);
+    const colLabels = colAxes.map((ax) => t.axisLabels[ax]);
+    lLabels = [...rowLabels, joiningIndex];
+    uLabels = [joiningIndex, ...colLabels];
+  }
+  const L = new Tensor([...rowDims, n], lData, lLabels);
+  const U = new Tensor([n, ...colDims], uData, uLabels);
+  return { L, U, P, parity };
+}
+
+// src/operations/cholesky.ts
+import { DenseMatrix as DenseMatrix5 } from "@danielsimonjr/mathts-matrix";
+import { cholesky as matrixCholesky } from "@danielsimonjr/mathts-matrix";
+function transposeSquare(data, n) {
+  const out = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      out[j * n + i] = data[i * n + j];
+    }
+  }
+  return out;
+}
+function tensorCholesky(t, rowAxes, opts) {
+  const rank = t.shape.length;
+  const lower = opts?.lower ?? true;
+  for (const ax of rowAxes) {
+    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
+      throw new RangeError(
+        `tensorCholesky: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
+      );
+    }
+  }
+  const rowSet = new Set(rowAxes);
+  if (rowSet.size !== rowAxes.length) {
+    throw new Error("tensorCholesky: rowAxes contains duplicate axes");
+  }
+  const colAxes = [];
+  for (let i = 0; i < rank; i++) {
+    if (!rowSet.has(i)) colAxes.push(i);
+  }
+  if (colAxes.length === 0) {
+    throw new Error(
+      "tensorCholesky: rowAxes covers all axes \u2014 at least one axis must remain for the column factor"
+    );
+  }
+  if (rowAxes.length === 0) {
+    throw new Error("tensorCholesky: rowAxes is empty \u2014 at least one axis must be assigned");
+  }
+  const rowDims = rowAxes.map((ax) => t.shape[ax]);
+  const colDims = colAxes.map((ax) => t.shape[ax]);
+  const numRows = rowDims.reduce((a, b) => a * b, 1);
+  const numCols = colDims.reduce((a, b) => a * b, 1);
+  if (numRows !== numCols) {
+    throw new Error(`tensorCholesky: reshaped matrix must be square (got ${numRows}\xD7${numCols})`);
+  }
+  const perm = [...rowAxes, ...colAxes];
+  const permuted = t.transpose(perm);
+  const n = numRows;
+  let lData;
+  try {
+    const matA = new DenseMatrix5(n, n, new Float64Array(permuted.data));
+    const { L: matL } = matrixCholesky(matA);
+    lData = matL.toFloat64Array();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(msg.replace(/^cholesky:/, "tensorCholesky:"));
+  }
+  const factorData = lower ? lData : transposeSquare(lData, n);
+  let factorLabels;
+  if (t.axisLabels !== void 0) {
+    const joiningIndex = new Index(n, {
+      name: opts?.joiningIndexName ?? "cholesky"
+    });
+    const rowLabels = rowAxes.map((ax) => t.axisLabels[ax]);
+    const colLabels = colAxes.map((ax) => t.axisLabels[ax]);
+    if (lower) {
+      factorLabels = [...rowLabels, joiningIndex];
+    } else {
+      factorLabels = [joiningIndex, ...colLabels];
+    }
+  }
+  const factorShape = lower ? [...rowDims, n] : [n, ...colDims];
+  const factor = new Tensor(factorShape, factorData, factorLabels);
+  return { L: factor };
+}
+
+// src/operations/eig.ts
+import { eig as matrixEig } from "@danielsimonjr/mathts-matrix";
+function tensorEig(t, rowAxes, opts) {
+  const rank = t.shape.length;
+  const computeVectors = opts?.computeVectors ?? true;
+  const symmetricHint = opts?.symmetric ?? false;
+  for (const ax of rowAxes) {
+    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
+      throw new RangeError(
+        `tensorEig: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
+      );
+    }
+  }
+  const rowSet = new Set(rowAxes);
+  if (rowSet.size !== rowAxes.length) {
+    throw new Error("tensorEig: rowAxes contains duplicate axes");
+  }
+  const colAxes = [];
+  for (let i = 0; i < rank; i++) {
+    if (!rowSet.has(i)) colAxes.push(i);
+  }
+  if (colAxes.length === 0) {
+    throw new Error("tensorEig: rowAxes covers all axes \u2014 at least one axis must remain");
+  }
+  if (rowAxes.length === 0) {
+    throw new Error("tensorEig: rowAxes is empty \u2014 at least one axis must be assigned");
+  }
+  const rowDims = rowAxes.map((ax) => t.shape[ax]);
+  const colDims = colAxes.map((ax) => t.shape[ax]);
+  const numRows = rowDims.reduce((a, b) => a * b, 1);
+  const numCols = colDims.reduce((a, b) => a * b, 1);
+  if (numRows !== numCols) {
+    throw new Error(`tensorEig: reshaped matrix must be square (got ${numRows}\xD7${numCols})`);
+  }
+  const perm = [...rowAxes, ...colAxes];
+  const permuted = t.transpose(perm);
+  const n = numRows;
+  const matrix2D = Array.from(
+    { length: n },
+    (_, i) => Array.from({ length: n }, (_2, j) => permuted.data[i * n + j])
+  );
+  if (symmetricHint) {
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        const avg = (matrix2D[i][j] + matrix2D[j][i]) / 2;
+        matrix2D[i][j] = avg;
+        matrix2D[j][i] = avg;
+      }
+    }
+  }
+  const { values, vectors } = matrixEig(matrix2D, { computeVectors });
+  const reData = new Float64Array(n);
+  const imData = new Float64Array(n);
+  let anyImaginary = false;
+  for (let i = 0; i < n; i++) {
+    reData[i] = values[i].re;
+    imData[i] = values[i].im;
+    if (values[i].im !== 0) anyImaginary = true;
+  }
+  const eigenvalues = new Tensor([n], reData);
+  const result = { eigenvalues };
+  if (anyImaginary && !symmetricHint) {
+    result.eigenvaluesImaginary = new Tensor([n], imData);
+  }
+  if (computeVectors) {
+    const vData = new Float64Array(n * n);
+    for (let i = 0; i < n; i++) {
+      const v = vectors[i];
+      for (let r = 0; r < n; r++) {
+        vData[r * n + i] = v[r];
+      }
+    }
+    result.eigenvectors = new Tensor([n, n], vData);
+  }
+  return result;
+}
+
+// src/operations/pinv.ts
+import { svd as svd2 } from "@danielsimonjr/mathts-matrix";
+function tensorPinv(t, rowAxes, opts) {
+  const rcond = opts?.rcond ?? 1e-10;
+  const rank = t.shape.length;
+  const resolvedRowAxes = rowAxes.map((ax) => {
+    if (typeof ax === "number") {
+      return ax;
+    }
+    if (t.axisLabels === void 0) {
+      throw new Error("tensorPinv: received Index in rowAxes but tensor has no axisLabels");
+    }
+    const pos = t.axisLabels.findIndex((lbl) => lbl.matches(ax));
+    if (pos === -1) {
+      throw new Error(
+        `tensorPinv: Index "${ax.name ?? ax.id.toString()}" not found in tensor axisLabels`
+      );
+    }
+    return pos;
+  });
+  for (const ax of resolvedRowAxes) {
+    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
+      throw new RangeError(
+        `tensorPinv: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
+      );
+    }
+  }
+  const rowSet = new Set(resolvedRowAxes);
+  if (rowSet.size !== resolvedRowAxes.length) {
+    throw new Error("tensorPinv: rowAxes contains duplicate axes");
+  }
+  const colAxes = [];
+  for (let i = 0; i < rank; i++) {
+    if (!rowSet.has(i)) colAxes.push(i);
+  }
+  if (colAxes.length === 0) {
+    throw new Error("tensorPinv: rowAxes covers all axes \u2014 at least one col axis is required");
+  }
+  if (resolvedRowAxes.length === 0) {
+    throw new Error("tensorPinv: rowAxes is empty \u2014 at least one row axis is required");
+  }
+  const perm = [...resolvedRowAxes, ...colAxes];
+  const permuted = t.transpose(perm);
+  const rowDims = resolvedRowAxes.map((ax) => t.shape[ax]);
+  const colDims = colAxes.map((ax) => t.shape[ax]);
+  const numRows = rowDims.reduce((a, b) => a * b, 1);
+  const numCols = colDims.reduce((a, b) => a * b, 1);
+  const matrix2D = Array.from(
+    { length: numRows },
+    (_, i) => Array.from({ length: numCols }, (_2, j) => permuted.data[i * numCols + j])
+  );
+  const { U, S, V } = svd2(matrix2D, { tolerance: 1e-12 });
+  const maxS = S.length > 0 ? S[0] : 0;
+  const Sinv = S.map((s) => s > rcond * maxS ? 1 / s : 0);
+  const k = S.length;
+  const pinvData = new Float64Array(numCols * numRows);
+  for (let i = 0; i < numCols; i++) {
+    for (let j = 0; j < numRows; j++) {
+      let sum = 0;
+      for (let l = 0; l < k; l++) {
+        sum += V[i][l] * Sinv[l] * U[j][l];
+      }
+      pinvData[i * numRows + j] = sum;
+    }
+  }
+  const outShape = [...colDims, ...rowDims];
+  let outLabels;
+  if (t.axisLabels !== void 0) {
+    const rowLabels = resolvedRowAxes.map((ax) => t.axisLabels[ax]);
+    const colLabels = colAxes.map((ax) => t.axisLabels[ax]);
+    outLabels = [...colLabels, ...rowLabels];
+  }
+  return new Tensor(outShape, pinvData, outLabels);
+}
+
+// src/operations/solve.ts
+import { DenseMatrix as DenseMatrix6 } from "@danielsimonjr/mathts-matrix";
+import { lu as matrixLU2 } from "@danielsimonjr/mathts-matrix";
+function resolveAxes(axes, t, label) {
+  return axes.map((ax) => {
+    if (typeof ax === "number") return ax;
+    if (t.axisLabels === void 0) {
+      throw new Error(`${label}: received Index in axes but tensor has no axisLabels`);
+    }
+    const pos = t.axisLabels.findIndex((lbl) => lbl.id === ax.id);
+    if (pos === -1) {
+      throw new Error(
+        `${label}: Index "${ax.name ?? ax.id.toString()}" not found in tensor axisLabels`
+      );
+    }
+    return pos;
+  });
+}
+function forwardSub(L, Pb, n, nRHS) {
+  const y = new Float64Array(n * nRHS);
+  for (let i = 0; i < n; i++) {
+    for (let r = 0; r < nRHS; r++) {
+      let sum = Pb[i * nRHS + r];
+      for (let j = 0; j < i; j++) {
+        sum -= L[i * n + j] * y[j * nRHS + r];
+      }
+      y[i * nRHS + r] = sum;
+    }
+  }
+  return y;
+}
+function backSub(U, y, n, nRHS) {
+  const x = new Float64Array(n * nRHS);
+  for (let i = n - 1; i >= 0; i--) {
+    for (let r = 0; r < nRHS; r++) {
+      let sum = y[i * nRHS + r];
+      for (let j = i + 1; j < n; j++) {
+        sum -= U[i * n + j] * x[j * nRHS + r];
+      }
+      x[i * nRHS + r] = sum / U[i * n + i];
+    }
+  }
+  return x;
+}
+function tensorSolve(A, b, opts) {
+  const rankA = A.shape.length;
+  const rankB = b.shape.length;
+  let rowAxesA;
+  if (opts?.rowAxesA !== void 0) {
+    rowAxesA = resolveAxes(opts.rowAxesA, A, "tensorSolve(A)");
+  } else if (A.axisLabels !== void 0 && b.axisLabels !== void 0) {
+    rowAxesA = [];
+    for (let i = 0; i < rankA; i++) {
+      const lbl = A.axisLabels[i];
+      if (b.axisLabels.some((blbl) => blbl.id === lbl.id)) {
+        rowAxesA.push(i);
+      }
+    }
+    if (rowAxesA.length === 0) {
+      const half = Math.ceil(rankA / 2);
+      rowAxesA = Array.from({ length: half }, (_, i) => i);
+    }
+  } else {
+    const half = Math.ceil(rankA / 2);
+    rowAxesA = Array.from({ length: half }, (_, i) => i);
+  }
+  let rowAxesB;
+  if (opts?.rowAxesB !== void 0) {
+    rowAxesB = resolveAxes(opts.rowAxesB, b, "tensorSolve(b)");
+  } else if (A.axisLabels !== void 0 && b.axisLabels !== void 0) {
+    const aRowIds = new Set(rowAxesA.map((ax) => A.axisLabels[ax].id));
+    rowAxesB = [];
+    for (let i = 0; i < rankB; i++) {
+      if (aRowIds.has(b.axisLabels[i].id)) {
+        rowAxesB.push(i);
+      }
+    }
+    if (rowAxesB.length === 0) {
+      rowAxesB = [0];
+    }
+  } else {
+    rowAxesB = [0];
+  }
+  for (const ax of rowAxesA) {
+    if (!Number.isInteger(ax) || ax < 0 || ax >= rankA) {
+      throw new RangeError(
+        `tensorSolve: rowAxesA contains invalid axis ${ax} for tensor A of rank ${rankA}`
+      );
+    }
+  }
+  const rowSetA = new Set(rowAxesA);
+  if (rowSetA.size !== rowAxesA.length) {
+    throw new Error("tensorSolve: rowAxesA contains duplicate axes");
+  }
+  for (const ax of rowAxesB) {
+    if (!Number.isInteger(ax) || ax < 0 || ax >= rankB) {
+      throw new RangeError(
+        `tensorSolve: rowAxesB contains invalid axis ${ax} for tensor b of rank ${rankB}`
+      );
+    }
+  }
+  const rowSetB = new Set(rowAxesB);
+  if (rowSetB.size !== rowAxesB.length) {
+    throw new Error("tensorSolve: rowAxesB contains duplicate axes");
+  }
+  const colAxesA = [];
+  for (let i = 0; i < rankA; i++) {
+    if (!rowSetA.has(i)) colAxesA.push(i);
+  }
+  const colAxesB = [];
+  for (let i = 0; i < rankB; i++) {
+    if (!rowSetB.has(i)) colAxesB.push(i);
+  }
+  const rowDimsA = rowAxesA.map((ax) => A.shape[ax]);
+  const colDimsA = colAxesA.map((ax) => A.shape[ax]);
+  const rowDimsB = rowAxesB.map((ax) => b.shape[ax]);
+  const colDimsB = colAxesB.map((ax) => b.shape[ax]);
+  const numRowsA = rowDimsA.reduce((a, v) => a * v, 1);
+  const numColsA = colDimsA.reduce((a, v) => a * v, 1);
+  const numRowsB = rowDimsB.reduce((a, v) => a * v, 1);
+  const numColsB = colDimsB.length > 0 ? colDimsB.reduce((a, v) => a * v, 1) : 1;
+  if (numRowsA !== numColsA) {
+    throw new Error(
+      `tensorSolve: reshaped A must be square (got ${numRowsA}\xD7${numColsA}); non-square systems are not supported \u2014 use tensorPinv for least-squares`
+    );
+  }
+  const n = numRowsA;
+  if (numRowsB !== n) {
+    throw new Error(
+      `tensorSolve: b's contracting dimension (${numRowsB}) does not match A's dimension (${n})`
+    );
+  }
+  const permA = [...rowAxesA, ...colAxesA];
+  const permutedA = A.transpose(permA);
+  const matA = new DenseMatrix6(n, n, new Float64Array(permutedA.data));
+  const { L, U, P } = matrixLU2(matA);
+  const lFlat = L.toFloat64Array();
+  const uFlat = U.toFloat64Array();
+  const permB = [...rowAxesB, ...colAxesB];
+  const permutedB = b.transpose(permB);
+  const bFlat = permutedB.data;
+  const Pb = new Float64Array(n * numColsB);
+  for (let i = 0; i < n; i++) {
+    for (let r = 0; r < numColsB; r++) {
+      Pb[i * numColsB + r] = bFlat[P[i] * numColsB + r];
+    }
+  }
+  const y = forwardSub(lFlat, Pb, n, numColsB);
+  const xFlat = backSub(uFlat, y, n, numColsB);
+  const outShape = [...colDimsA, ...colDimsB];
+  const finalShape = outShape.length > 0 ? outShape : [n];
+  let outLabels;
+  if (A.axisLabels !== void 0 || b.axisLabels !== void 0) {
+    const aColLabels = A.axisLabels ? colAxesA.map((ax) => A.axisLabels[ax]) : [];
+    const bColLabels = b.axisLabels ? colAxesB.map((ax) => b.axisLabels[ax]) : [];
+    if (aColLabels.length + bColLabels.length === finalShape.length) {
+      outLabels = [...aColLabels, ...bColLabels];
+    }
+  }
+  const xTensor = new Tensor(finalShape, xFlat, outLabels?.length ? outLabels : void 0);
+  return { x: xTensor };
+}
+
+// src/operations/kron.ts
+function tensorKron(a, b, opts) {
+  const separator = opts?.separator ?? "_X_";
+  let aShape = [...a.shape];
+  let bShape = [...b.shape];
+  let aLabels = a.axisLabels ? [...a.axisLabels] : void 0;
+  let bLabels = b.axisLabels ? [...b.axisLabels] : void 0;
+  const rankA = aShape.length;
+  const rankB = bShape.length;
+  const outRank = Math.max(rankA, rankB);
+  if (rankA < outRank) {
+    const pad2 = outRank - rankA;
+    aShape = [...new Array(pad2).fill(1), ...aShape];
+    if (aLabels !== void 0) {
+      const padLabels = Array.from(
+        { length: pad2 },
+        (_, i) => new Index(1, { name: `kron_pad_a_${i}` })
+      );
+      aLabels = [...padLabels, ...aLabels];
+    }
+  }
+  if (rankB < outRank) {
+    const pad2 = outRank - rankB;
+    bShape = [...new Array(pad2).fill(1), ...bShape];
+    if (bLabels !== void 0) {
+      const padLabels = Array.from(
+        { length: pad2 },
+        (_, i) => new Index(1, { name: `kron_pad_b_${i}` })
+      );
+      bLabels = [...padLabels, ...bLabels];
+    }
+  }
+  const outShape = aShape.map((d, k) => d * bShape[k]);
+  const outSize = outShape.reduce((acc, d) => acc * d, 1);
+  const outStrides = rowMajorStrides(outShape);
+  const aData = a.data;
+  const bData = b.data;
+  const aOrigStrides = rowMajorStrides(aShape.slice(outRank - rankA));
+  const bOrigStrides = rowMajorStrides(bShape.slice(outRank - rankB));
+  const result = new Float64Array(outSize);
+  const outIdx = new Array(outRank).fill(0);
+  for (let flatOut = 0; flatOut < outSize; flatOut++) {
+    {
+      let rem = flatOut;
+      for (let k = 0; k < outRank; k++) {
+        outIdx[k] = Math.floor(rem / outStrides[k]);
+        rem -= outIdx[k] * outStrides[k];
+      }
+    }
+    let flatA = 0;
+    let flatB = 0;
+    for (let k = 0; k < outRank; k++) {
+      const aIdx = Math.floor(outIdx[k] / bShape[k]);
+      const bIdx = outIdx[k] % bShape[k];
+      const aPadded = outRank - rankA;
+      const bPadded = outRank - rankB;
+      if (k >= aPadded) {
+        flatA += aIdx * aOrigStrides[k - aPadded];
+      }
+      if (k >= bPadded) {
+        flatB += bIdx * bOrigStrides[k - bPadded];
+      }
+    }
+    result[flatOut] = aData[flatA] * bData[flatB];
+  }
+  let outLabels;
+  if (aLabels !== void 0 && bLabels !== void 0) {
+    outLabels = aLabels.map((al, k) => {
+      const bl = bLabels[k];
+      const aName = al.name ?? `a${k}`;
+      const bName = bl.name ?? `b${k}`;
+      const outDim = outShape[k];
+      return new Index(outDim, { name: `${aName}${separator}${bName}` });
+    });
+  }
+  return new Tensor(outShape, result, outLabels);
+}
+function rowMajorStrides(shape) {
+  const rank = shape.length;
+  const strides = new Array(rank);
+  let acc = 1;
+  for (let k = rank - 1; k >= 0; k--) {
+    strides[k] = acc;
+    acc *= shape[k];
+  }
+  return strides;
+}
+
+// src/operations/slice.ts
+function slice(t, ranges) {
+  const rank = t.shape.length;
+  if (ranges.length !== rank) {
+    throw new Error(`slice: ranges length ${ranges.length} does not match tensor rank ${rank}`);
+  }
+  const resolved = ranges.map((r, axis) => {
+    const dim = t.shape[axis];
+    const step = r?.step ?? 1;
+    if (!Number.isInteger(step) || step < 1) {
+      throw new RangeError(`slice: step must be a positive integer (axis ${axis}), got ${step}`);
+    }
+    let start = r?.start ?? 0;
+    let stop = r?.stop ?? dim;
+    if (start < 0) start = dim + start;
+    if (stop < 0) stop = dim + stop;
+    if (start < 0 || start > dim) {
+      throw new RangeError(
+        `slice: start ${r?.start} is out of range for axis ${axis} with dim ${dim}`
+      );
+    }
+    stop = Math.max(0, Math.min(stop, dim));
+    return { start, stop, step };
+  });
+  const outShape = resolved.map(
+    ({ start, stop, step }) => start >= stop ? 0 : Math.ceil((stop - start) / step)
+  );
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const outData = new Float64Array(outSize);
+  if (outSize > 0) {
+    const inStrides = Tensor.rowMajorStrides(t.shape);
+    const outStrides = Tensor.rowMajorStrides(outShape);
+    const outIdx = new Array(rank).fill(0);
+    for (let flatOut = 0; flatOut < outSize; flatOut++) {
+      let rem = flatOut;
+      for (let k = 0; k < rank; k++) {
+        outIdx[k] = Math.floor(rem / outStrides[k]);
+        rem -= outIdx[k] * outStrides[k];
+      }
+      let flatIn = 0;
+      for (let k = 0; k < rank; k++) {
+        const inK = resolved[k].start + outIdx[k] * resolved[k].step;
+        flatIn += inK * inStrides[k];
+      }
+      outData[flatOut] = t.data[flatIn];
+    }
+  }
+  let outLabels;
+  if (t.axisLabels !== void 0) {
+    outLabels = t.axisLabels.map((lbl, k) => {
+      const newDim = outShape[k];
+      return new Index(Math.max(1, newDim), { name: lbl.name, tags: [...lbl.tags] });
+    });
+  }
+  return new Tensor(outShape, outData, outLabels);
+}
+
+// src/operations/gather.ts
+function gather(t, axis, indices) {
+  const rank = t.shape.length;
+  const ax = axis < 0 ? rank + axis : axis;
+  if (ax < 0 || ax >= rank) {
+    throw new Error(`gather: axis ${axis} is out of range for rank ${rank}`);
+  }
+  const dimAx = t.shape[ax];
+  for (let i = 0; i < indices.length; i++) {
+    if (!Number.isInteger(indices[i]) || indices[i] < 0 || indices[i] >= dimAx) {
+      throw new RangeError(
+        `gather: index ${indices[i]} at position ${i} is out of range [0, ${dimAx}) for axis ${ax}`
+      );
+    }
+  }
+  const outShape = [...t.shape];
+  outShape[ax] = indices.length;
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const outData = new Float64Array(outSize);
+  if (outSize > 0) {
+    const inStrides = Tensor.rowMajorStrides(t.shape);
+    const outStrides = Tensor.rowMajorStrides(outShape);
+    const outIdx = new Array(rank).fill(0);
+    for (let flatOut = 0; flatOut < outSize; flatOut++) {
+      let rem = flatOut;
+      for (let k = 0; k < rank; k++) {
+        outIdx[k] = Math.floor(rem / outStrides[k]);
+        rem -= outIdx[k] * outStrides[k];
+      }
+      let flatIn = 0;
+      for (let k = 0; k < rank; k++) {
+        const inK = k === ax ? indices[outIdx[k]] : outIdx[k];
+        flatIn += inK * inStrides[k];
+      }
+      outData[flatOut] = t.data[flatIn];
+    }
+  }
+  let outLabels;
+  if (t.axisLabels !== void 0) {
+    outLabels = t.axisLabels.map((lbl, k) => {
+      if (k === ax) {
+        return lbl.prime();
+      }
+      return lbl;
+    });
+  }
+  return new Tensor(outShape, outData, outLabels);
+}
+
+// src/operations/stack.ts
+function stack(tensors, axis, opts) {
+  if (tensors.length === 0) {
+    throw new Error("stack: tensors array must be non-empty");
+  }
+  const first = tensors[0];
+  const inRank = first.shape.length;
+  const outRank = inRank + 1;
+  const ax = axis < 0 ? outRank + axis : axis;
+  if (ax < 0 || ax > inRank) {
+    throw new Error(`stack: axis ${axis} is out of range for output rank ${outRank}`);
+  }
+  for (let t = 1; t < tensors.length; t++) {
+    const s = tensors[t].shape;
+    if (s.length !== inRank) {
+      throw new Error(
+        `stack: tensors[${t}] has rank ${s.length} but tensors[0] has rank ${inRank}`
+      );
+    }
+    for (let k = 0; k < inRank; k++) {
+      if (s[k] !== first.shape[k]) {
+        throw new Error(
+          `stack: shape mismatch at axis ${k}: tensors[${t}].shape[${k}]=${s[k]} vs tensors[0].shape[${k}]=${first.shape[k]}`
+        );
+      }
+    }
+  }
+  const outShape = [];
+  for (let k = 0; k < ax; k++) outShape.push(first.shape[k]);
+  outShape.push(tensors.length);
+  for (let k = ax; k < inRank; k++) outShape.push(first.shape[k]);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const outData = new Float64Array(outSize);
+  const outStrides = Tensor.rowMajorStrides(outShape);
+  const inStrides = Tensor.rowMajorStrides(first.shape);
+  for (let ti = 0; ti < tensors.length; ti++) {
+    const inData = tensors[ti].data;
+    const inSize = first.shape.reduce((a, b) => a * b, 1);
+    const inIdx = new Array(inRank).fill(0);
+    for (let flatIn = 0; flatIn < inSize; flatIn++) {
+      let rem = flatIn;
+      for (let k = 0; k < inRank; k++) {
+        inIdx[k] = Math.floor(rem / inStrides[k]);
+        rem -= inIdx[k] * inStrides[k];
+      }
+      let flatOut = 0;
+      for (let k = 0; k < ax; k++) flatOut += inIdx[k] * outStrides[k];
+      flatOut += ti * outStrides[ax];
+      for (let k = ax; k < inRank; k++) flatOut += inIdx[k] * outStrides[k + 1];
+      outData[flatOut] = inData[flatIn];
+    }
+  }
+  let outLabels;
+  if (first.axisLabels !== void 0) {
+    const newLabel = opts?.newAxisLabel ?? new Index(tensors.length, { name: void 0 });
+    const labels = [];
+    for (let k = 0; k < ax; k++) labels.push(first.axisLabels[k]);
+    labels.push(newLabel);
+    for (let k = ax; k < inRank; k++) labels.push(first.axisLabels[k]);
+    outLabels = labels;
+  } else if (opts?.newAxisLabel !== void 0) {
+  }
+  return new Tensor(outShape, outData, outLabels);
+}
+
+// src/operations/concatenate.ts
+function concatenate(tensors, axis) {
+  if (tensors.length === 0) {
+    throw new Error("concatenate: tensors array must be non-empty");
+  }
+  const first = tensors[0];
+  const rank = first.shape.length;
+  const ax = axis < 0 ? rank + axis : axis;
+  if (ax < 0 || ax >= rank) {
+    throw new Error(`concatenate: axis ${axis} is out of range for rank ${rank}`);
+  }
+  for (let t = 1; t < tensors.length; t++) {
+    const s = tensors[t].shape;
+    if (s.length !== rank) {
+      throw new Error(
+        `concatenate: tensors[${t}] has rank ${s.length} but tensors[0] has rank ${rank}`
+      );
+    }
+    for (let k = 0; k < rank; k++) {
+      if (k !== ax && s[k] !== first.shape[k]) {
+        throw new Error(
+          `concatenate: shape mismatch on non-join axis ${k}: tensors[${t}].shape[${k}]=${s[k]} vs tensors[0].shape[${k}]=${first.shape[k]}`
+        );
+      }
+    }
+  }
+  const joinDim = tensors.reduce((sum, t) => sum + t.shape[ax], 0);
+  const outShape = [...first.shape];
+  outShape[ax] = joinDim;
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const outData = new Float64Array(outSize);
+  const outStrides = Tensor.rowMajorStrides(outShape);
+  let joinOffset = 0;
+  for (let ti = 0; ti < tensors.length; ti++) {
+    const t = tensors[ti];
+    const inShape = t.shape;
+    const inSize = inShape.reduce((a, b) => a * b, 1);
+    const inStrides = Tensor.rowMajorStrides(inShape);
+    const inIdx = new Array(rank).fill(0);
+    for (let flatIn = 0; flatIn < inSize; flatIn++) {
+      let rem = flatIn;
+      for (let k = 0; k < rank; k++) {
+        inIdx[k] = Math.floor(rem / inStrides[k]);
+        rem -= inIdx[k] * inStrides[k];
+      }
+      let flatOut = 0;
+      for (let k = 0; k < rank; k++) {
+        const outK = k === ax ? inIdx[k] + joinOffset : inIdx[k];
+        flatOut += outK * outStrides[k];
+      }
+      outData[flatOut] = t.data[flatIn];
+    }
+    joinOffset += inShape[ax];
+  }
+  let outLabels;
+  if (first.axisLabels !== void 0) {
+    outLabels = first.axisLabels.map((lbl, k) => {
+      if (k === ax) {
+        return new Index(joinDim, { name: lbl.name, tags: [...lbl.tags] });
+      }
+      return lbl;
+    });
+  }
+  return new Tensor(outShape, outData, outLabels);
+}
+
+// src/operations/scatter.ts
+function scatter(t, axis, indices, updates, opts) {
+  const rank = t.shape.length;
+  const reduce = opts?.reduce ?? "overwrite";
+  const ax = axis < 0 ? rank + axis : axis;
+  if (ax < 0 || ax >= rank) {
+    throw new Error(`scatter: axis ${axis} is out of range for rank ${rank}`);
+  }
+  const dimAx = t.shape[ax];
+  for (let i = 0; i < indices.length; i++) {
+    if (!Number.isInteger(indices[i]) || indices[i] < 0 || indices[i] >= dimAx) {
+      throw new RangeError(
+        `scatter: index ${indices[i]} at position ${i} is out of range [0, ${dimAx}) for axis ${ax}`
+      );
+    }
+  }
+  if (updates.shape.length !== rank) {
+    throw new Error(
+      `scatter: updates rank ${updates.shape.length} does not match tensor rank ${rank}`
+    );
+  }
+  for (let k = 0; k < rank; k++) {
+    if (k === ax) {
+      if (updates.shape[k] !== indices.length) {
+        throw new Error(
+          `scatter: updates.shape[${k}] = ${updates.shape[k]} but indices.length = ${indices.length}`
+        );
+      }
+    } else {
+      if (updates.shape[k] !== t.shape[k]) {
+        throw new Error(
+          `scatter: updates.shape[${k}] = ${updates.shape[k]} does not match t.shape[${k}] = ${t.shape[k]}`
+        );
+      }
+    }
+  }
+  const outData = new Float64Array(t.data);
+  if (indices.length > 0) {
+    const inStrides = Tensor.rowMajorStrides(t.shape);
+    const updStrides = Tensor.rowMajorStrides(updates.shape);
+    const updSize = updates.shape.reduce((a, b) => a * b, 1);
+    const updIdx = new Array(rank).fill(0);
+    for (let flatUpd = 0; flatUpd < updSize; flatUpd++) {
+      let rem = flatUpd;
+      for (let k = 0; k < rank; k++) {
+        updIdx[k] = Math.floor(rem / updStrides[k]);
+        rem -= updIdx[k] * updStrides[k];
+      }
+      const targetAxIdx = indices[updIdx[ax]];
+      let flatOut = 0;
+      for (let k = 0; k < rank; k++) {
+        const idxK = k === ax ? targetAxIdx : updIdx[k];
+        flatOut += idxK * inStrides[k];
+      }
+      if (reduce === "add") {
+        outData[flatOut] += updates.data[flatUpd];
+      } else {
+        outData[flatOut] = updates.data[flatUpd];
+      }
+    }
+  }
+  let outLabels;
+  if (t.axisLabels !== void 0) {
+    outLabels = [...t.axisLabels];
+  }
+  return new Tensor([...t.shape], outData, outLabels);
+}
+
+// src/operations/pad.ts
+function pad(t, padWidths, opts) {
+  const rank = t.shape.length;
+  const mode = opts?.mode ?? "constant";
+  const fillValue = opts?.constantValue ?? 0;
+  if (padWidths.length !== rank) {
+    throw new Error(`pad: padWidths length ${padWidths.length} does not match tensor rank ${rank}`);
+  }
+  for (let k = 0; k < rank; k++) {
+    const [before, after] = padWidths[k];
+    if (!Number.isInteger(before) || before < 0) {
+      throw new Error(`pad: padWidths[${k}][0] must be a non-negative integer, got ${before}`);
+    }
+    if (!Number.isInteger(after) || after < 0) {
+      throw new Error(`pad: padWidths[${k}][1] must be a non-negative integer, got ${after}`);
+    }
+    if (mode === "reflect") {
+      const dim = t.shape[k];
+      if (before >= dim || after >= dim) {
+        throw new Error(
+          `pad: reflect mode requires pad amounts < axis size; axis ${k} has size ${dim} but pad is [${before}, ${after}]`
+        );
+      }
+    }
+  }
+  const outShape = t.shape.map((d, k) => d + padWidths[k][0] + padWidths[k][1]);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const outData = new Float64Array(outSize);
+  if (mode === "constant") {
+    if (fillValue !== 0) outData.fill(fillValue);
+  }
+  const inStrides = Tensor.rowMajorStrides(t.shape);
+  const outStrides = Tensor.rowMajorStrides(outShape);
+  const outIdx = new Array(rank).fill(0);
+  for (let flatOut = 0; flatOut < outSize; flatOut++) {
+    let rem = flatOut;
+    for (let k = 0; k < rank; k++) {
+      outIdx[k] = Math.floor(rem / outStrides[k]);
+      rem -= outIdx[k] * outStrides[k];
+    }
+    let inBounds = true;
+    let flatIn = 0;
+    for (let k = 0; k < rank; k++) {
+      const before = padWidths[k][0];
+      const dim = t.shape[k];
+      const oIdx = outIdx[k];
+      let iIdx;
+      if (oIdx < before) {
+        if (mode === "constant") {
+          inBounds = false;
+          break;
+        } else if (mode === "edge") {
+          iIdx = 0;
+        } else {
+          iIdx = before - oIdx;
+        }
+      } else if (oIdx >= before + dim) {
+        if (mode === "constant") {
+          inBounds = false;
+          break;
+        } else if (mode === "edge") {
+          iIdx = dim - 1;
+        } else {
+          const dist = oIdx - (before + dim - 1);
+          iIdx = dim - 1 - dist;
+        }
+      } else {
+        iIdx = oIdx - before;
+      }
+      flatIn += iIdx * inStrides[k];
+    }
+    if (inBounds) {
+      outData[flatOut] = t.data[flatIn];
+    }
+  }
+  let outLabels;
+  if (t.axisLabels !== void 0) {
+    outLabels = [...t.axisLabels];
+  }
+  return new Tensor(outShape, outData, outLabels);
+}
+
+// src/operations/roll.ts
+function roll(t, shifts, axes) {
+  const rank = t.shape.length;
+  const totalSize = t.shape.reduce((a, b) => a * b, 1);
+  if (axes === void 0) {
+    if (Array.isArray(shifts)) {
+      throw new Error("roll: when axes is omitted, shifts must be a single number");
+    }
+    const shift = shifts;
+    const outData2 = new Float64Array(totalSize);
+    const n = totalSize;
+    for (let i = 0; i < n; i++) {
+      const srcIdx = ((i - shift) % n + n) % n;
+      outData2[i] = t.data[srcIdx];
+    }
+    let outLabels2;
+    if (t.axisLabels !== void 0) outLabels2 = [...t.axisLabels];
+    return new Tensor([...t.shape], outData2, outLabels2);
+  }
+  const shiftArr = Array.isArray(shifts) ? [...shifts] : [shifts];
+  if (shiftArr.length !== axes.length) {
+    throw new Error(
+      `roll: shifts length ${shiftArr.length} does not match axes length ${axes.length}`
+    );
+  }
+  const normAxes = axes.map((ax) => {
+    const a = ax < 0 ? rank + ax : ax;
+    if (a < 0 || a >= rank) {
+      throw new Error(`roll: axis ${ax} is out of range for rank ${rank}`);
+    }
+    return a;
+  });
+  const axisShift = new Array(rank).fill(0);
+  for (let i = 0; i < normAxes.length; i++) {
+    axisShift[normAxes[i]] = shiftArr[i];
+  }
+  const outData = new Float64Array(totalSize);
+  const inStrides = Tensor.rowMajorStrides(t.shape);
+  const outStrides = Tensor.rowMajorStrides(t.shape);
+  const outIdx = new Array(rank).fill(0);
+  for (let flatOut = 0; flatOut < totalSize; flatOut++) {
+    let rem = flatOut;
+    for (let k = 0; k < rank; k++) {
+      outIdx[k] = Math.floor(rem / outStrides[k]);
+      rem -= outIdx[k] * outStrides[k];
+    }
+    let flatIn = 0;
+    for (let k = 0; k < rank; k++) {
+      const dim = t.shape[k];
+      const srcK = ((outIdx[k] - axisShift[k]) % dim + dim) % dim;
+      flatIn += srcK * inStrides[k];
+    }
+    outData[flatOut] = t.data[flatIn];
+  }
+  let outLabels;
+  if (t.axisLabels !== void 0) outLabels = [...t.axisLabels];
+  return new Tensor([...t.shape], outData, outLabels);
+}
+
+// src/operations/flip.ts
+function flip(t, axes) {
+  const rank = t.shape.length;
+  const totalSize = t.shape.reduce((a, b) => a * b, 1);
+  const normAxesSet = /* @__PURE__ */ new Set();
+  for (const ax of axes) {
+    const a = ax < 0 ? rank + ax : ax;
+    if (a < 0 || a >= rank) {
+      throw new Error(`flip: axis ${ax} is out of range for rank ${rank}`);
+    }
+    normAxesSet.add(a);
+  }
+  const flipSet = normAxesSet;
+  const outData = new Float64Array(totalSize);
+  const inStrides = Tensor.rowMajorStrides(t.shape);
+  const outStrides = Tensor.rowMajorStrides(t.shape);
+  const outIdx = new Array(rank).fill(0);
+  for (let flatOut = 0; flatOut < totalSize; flatOut++) {
+    let rem = flatOut;
+    for (let k = 0; k < rank; k++) {
+      outIdx[k] = Math.floor(rem / outStrides[k]);
+      rem -= outIdx[k] * outStrides[k];
+    }
+    let flatIn = 0;
+    for (let k = 0; k < rank; k++) {
+      const iIdx = flipSet.has(k) ? t.shape[k] - 1 - outIdx[k] : outIdx[k];
+      flatIn += iIdx * inStrides[k];
+    }
+    outData[flatOut] = t.data[flatIn];
+  }
+  let outLabels;
+  if (t.axisLabels !== void 0) outLabels = [...t.axisLabels];
+  return new Tensor([...t.shape], outData, outLabels);
+}
 export {
-  Tensor
+  Index,
+  Tensor,
+  concatenate,
+  contractNetwork,
+  flip,
+  gather,
+  idx,
+  pad,
+  randomTensor,
+  roll,
+  scatter,
+  slice,
+  stack,
+  tensorCholesky,
+  tensorEig,
+  tensorKron,
+  tensorLU,
+  tensorPinv,
+  tensorQr,
+  tensorSolve,
+  tensorSvd
 };