@danielsimonjr/mathts-tensor 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -1,3 +1,81 @@
+import { DenseMatrix } from '@danielsimonjr/mathts-matrix';
+
+/**
+ * Index — an immutable value type carrying a unique identity, a dimension,
+ * optional tags, and a prime level. Two indices *match* (and will be
+ * contracted by `Tensor.contract`) iff their `id` and `primeLevel` agree.
+ * Dimension agreement is validated at contraction time, not at matching time.
+ *
+ * Inspired by ITensors.jl's `Index` primitive.
+ */
+interface IndexOpts {
+    /** Human-readable name; not used for matching but useful in errors / debug. */
+    name?: string;
+    /**
+     * Free-form tag list. Two indices with the SAME id but DIFFERENT tags still
+     * match by id.
+     */
+    tags?: ReadonlyArray<string>;
+    /**
+     * Prime level (ITensor's "prime"). Two indices with the same id but different
+     * prime levels do NOT match.
+     */
+    primeLevel?: number;
+}
+/**
+ * A first-class index value. Each `new Index(...)` call mints a fresh `id`
+ * (Symbol) that can never collide with another. Methods that would mutate
+ * state instead return a new `Index` sharing the same `id`.
+ */
+declare class Index {
+    readonly id: symbol;
+    readonly dim: number;
+    readonly name?: string;
+    readonly tags: ReadonlyArray<string>;
+    readonly primeLevel: number;
+    constructor(dim: number, opts?: IndexOpts);
+    /**
+     * Internal constructor used by mutating-style methods that need to share the
+     * same `id` with a different primeLevel / tags. Not exposed publicly.
+     */
+    private static _from;
+    /**
+     * Return a new Index with `primeLevel` incremented by `by` (default 1).
+     */
+    prime(by?: number): Index;
+    /**
+     * Return a new Index with `primeLevel` reset to 0.
+     */
+    noprime(): Index;
+    /**
+     * Return a new Index with `tag` added to its tag list (no-op if already present).
+     */
+    addTag(tag: string): Index;
+    /**
+     * Return a new Index with `tag` removed from its tag list (no-op if absent).
+     */
+    removeTag(tag: string): Index;
+    /**
+     * True if `tag` is in this index's tag list.
+     */
+    hasTag(tag: string): boolean;
+    /**
+     * 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: Index): boolean;
+    toString(): string;
+}
+/**
+ * Convenience factory: `const i = idx(3, 'i')`.
+ *
+ * ```ts
+ * const i = idx(3, 'i');            // dim=3, name='i', primeLevel=0
+ * const j = idx(4, 'j', { tags: ['site'] });
+ * ```
+ */
+declare function idx(dim: number, name?: string, opts?: Omit<IndexOpts, 'name'>): Index;
+
 /**
  * Tensor — rank-N, Float64Array-backed, row-major dense tensor. The
  * compute primitive behind @danielsimonjr/mathts-tensor. Construction +
@@ -9,6 +87,7 @@
  * arbitrary rank, filling the `Matrix<T>` base class's documented
  * "generic template for future rank-N support".
  */
+
 type NestedArray = number | NestedArray[];
 interface EinsumSpec {
     readonly contractions: ReadonlyArray<{
@@ -22,25 +101,1022 @@ interface EinsumSpec {
 declare class Tensor {
     readonly shape: ReadonlyArray<number>;
     readonly data: Float64Array;
-    constructor(shape: ReadonlyArray<number>, data: Float64Array);
+    /** Optional per-axis Index labels. When set, enables `contract`, `replaceIndex`, `axisOf`. */
+    readonly axisLabels?: ReadonlyArray<Index>;
+    constructor(shape: ReadonlyArray<number>, data: Float64Array, axisLabels?: ReadonlyArray<Index>);
     static sizeOf(shape: ReadonlyArray<number>): number;
     static rowMajorStrides(shape: ReadonlyArray<number>): number[];
     static fromNested(data: NestedArray, shape: ReadonlyArray<number>): Tensor;
     static identity(n: number): Tensor;
     toNested(): NestedArray;
+    /**
+     * 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: DenseMatrix): Tensor;
+    /**
+     * Convert a rank-2 Tensor to a native DenseMatrix. Throws for any other rank.
+     */
+    toDenseMatrix(): DenseMatrix;
     private sameShape;
     private elementwise;
-    add(other: Tensor): Tensor;
-    sub(other: Tensor): Tensor;
-    mul(other: Tensor): Tensor;
+    add(other: Tensor | number): Tensor;
+    sub(other: Tensor | number): Tensor;
+    mul(other: Tensor | number): Tensor;
     scale(k: number): Tensor;
     normInf(): number;
+    /**
+     * 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: ReadonlyArray<number>, b: ReadonlyArray<number>): number[];
+    /**
+     * 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.
+     */
+    private static broadcastOp;
+    /**
+     * 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.
+     */
+    private reduceAxes;
+    /**
+     * Sum elements along the given axis/axes (or all axes if omitted).
+     * `keepDims: true` preserves reduced axes as length-1.
+     */
+    sum(axis?: number | ReadonlyArray<number>, opts?: {
+        keepDims?: boolean;
+    }): Tensor;
+    /**
+     * Arithmetic mean along the given axis/axes (or all axes if omitted).
+     */
+    mean(axis?: number | ReadonlyArray<number>, opts?: {
+        keepDims?: boolean;
+    }): Tensor;
+    /**
+     * Element-wise maximum along the given axis/axes (or all axes if omitted).
+     * NaN propagates (matches NumPy default behaviour).
+     */
+    max(axis?: number | ReadonlyArray<number>, opts?: {
+        keepDims?: boolean;
+    }): Tensor;
+    /**
+     * Element-wise minimum along the given axis/axes (or all axes if omitted).
+     * NaN propagates (matches NumPy default behaviour).
+     */
+    min(axis?: number | ReadonlyArray<number>, opts?: {
+        keepDims?: boolean;
+    }): Tensor;
+    /**
+     * Product of elements along the given axis/axes (or all axes if omitted).
+     */
+    prod(axis?: number | ReadonlyArray<number>, opts?: {
+        keepDims?: boolean;
+    }): Tensor;
+    /**
+     * 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?: {
+        p?: number | 'inf' | '-inf' | 'fro';
+        axis?: number;
+        keepDims?: boolean;
+    }): Tensor;
+    /**
+     * 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: Tensor, axes: ReadonlyArray<readonly [number, number]>): Tensor;
+    /**
+     * Normalise an `axis` argument into a sorted list of axis indices.
+     * `undefined` ⇒ all axes (reduce everything to a rank-0 scalar).
+     */
+    private resolveAxes;
     private static forEachIndex;
     private static flatIndex;
     reshape(shape: ReadonlyArray<number>): Tensor;
     transpose(perm?: ReadonlyArray<number>): Tensor;
     matMul(other: Tensor): Tensor;
     static einsum(spec: EinsumSpec, ...operands: Tensor[]): Tensor;
+    /**
+     * Return the axis position (0-based) of a labelled index.
+     * Throws if the index is not found in `axisLabels`.
+     */
+    axisOf(index: Index): number;
+    /**
+     * 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: Index, newIndex: Index): Tensor;
+    /**
+     * 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: Tensor): Tensor;
+}
+
+/**
+ * tensorSvd — truncated SVD for rank-N tensors.
+ *
+ * Partitions the axes of `t` into "row" axes (joining with U) and "col" axes
+ * (the remaining axes, joining with V), permutes + reshapes `t` into a 2-D
+ * matrix, calls the existing DenseMatrix SVD primitive, optionally truncates
+ * the singular-value spectrum, and reshapes U / S / V back into Tensors.
+ *
+ * Phase-2 note: `rowAxes` is positional-integer-only. The named-Index overload
+ * (accepting `ReadonlyArray<Index>`) is reserved for the Phase-1-enabled
+ * follow-up once `Index` is part of the Tensor surface.
+ *
+ * The `joiningIndexName` option is accepted for forward-compatibility with the
+ * labelled-tensor extension but is unused in Phase 2 — the output Tensors carry
+ * no `axisLabels`.
+ */
+
+interface TensorSvdOpts {
+    /** If set, keep at most `maxdim` singular values. */
+    maxdim?: number;
+    /**
+     * If set, drop singular values whose absolute value is strictly less than
+     * `cutoff`. Default is 0 (no cutoff). The test is `s >= cutoff`.
+     */
+    cutoff?: number;
+    /**
+     * Accepted for forward-compatibility with the labelled-tensor extension
+     * (Phase-2-extension follow-up). Currently unused — output Tensors carry
+     * no `axisLabels` in Phase 2.
+     */
+    joiningIndexName?: string;
+}
+interface TensorSvdResult {
+    /** U factor reshaped to [...rowDims, k]. */
+    U: Tensor;
+    /** Singular values as a rank-1 Tensor of shape [k]. */
+    S: Tensor;
+    /** V factor reshaped to [k, ...colDims]. */
+    V: Tensor;
+    /** Number of singular values retained after truncation. */
+    truncatedDim: number;
+    /** Sum of squares of the dropped singular values (Frobenius-norm squared of the discarded part). */
+    truncationError: number;
+}
+/**
+ * Compute the (optionally truncated) SVD of tensor `t` by partitioning its
+ * axes into "row" and "col" groups.
+ *
+ * @param t        - Input tensor of any rank ≥ 1.
+ * @param rowAxes  - Axis indices (integers) whose dimensions form the row
+ *                   dimension of the effective 2-D matrix. The remaining axes
+ *                   form the column dimension. The order of `rowAxes` controls
+ *                   the layout of the U output tensor.
+ * @param opts     - Optional truncation / naming settings.
+ */
+declare function tensorSvd(t: Tensor, rowAxes: ReadonlyArray<number>, opts?: TensorSvdOpts): TensorSvdResult;
+
+/**
+ * randomTensor — construct a Tensor filled with pseudo-random values.
+ *
+ * Supported distributions:
+ *   'uniform'    — U(0, 1) via the seeded PRNG or Math.random().
+ *   'normal'     — N(0, 1) via Box–Muller transform on the underlying PRNG.
+ *   'orthogonal' — Uniform on the orthogonal group O(n) via QR decomposition
+ *                  of a normal random matrix. Rank-2 shapes only.
+ *
+ * Seeded RNG: Mulberry32 — a small, fast, high-quality 32-bit PRNG.
+ * Reference: Tommy Ettinger, https://gist.github.com/tommyettinger/46a874533244883189143505d203312c
+ *
+ * WARNING: The seeded path is NOT cryptographically secure. Do not use for
+ * security-sensitive purposes (key generation, nonces, etc.).
+ */
+
+interface RandomTensorOpts {
+    /**
+     * Distribution to sample from.
+     *
+     * - `'uniform'`     — U(0, 1).
+     * - `'normal'`      — N(0, 1) via Box–Muller transform.
+     * - `'orthogonal'`  — uniform on the orthogonal group; rank-2 shape only.
+     *
+     * @default 'uniform'
+     */
+    distribution?: 'uniform' | 'normal' | 'orthogonal';
+    /**
+     * Integer seed for the Mulberry32 PRNG. When omitted, Math.random() is
+     * used (non-reproducible). NOT cryptographically secure.
+     */
+    seed?: number;
+    /**
+     * Optional axis labels forwarded into the new Tensor's constructor.
+     * Requires Phase-1 `axisLabels` support in the Tensor constructor
+     * (constructor signature: `Tensor(shape, data, axisLabels?)`).
+     */
+    axisLabels?: ReadonlyArray<Index>;
+}
+/**
+ * Construct a Tensor of the given `shape` filled with pseudo-random values.
+ *
+ * @param shape  - Array of positive integers defining the tensor dimensions.
+ * @param opts   - Optional configuration (distribution, seed, axisLabels).
+ * @returns A new Tensor.
+ *
+ * @example
+ * ```ts
+ * // 3x4 uniform random tensor
+ * const t = randomTensor([3, 4]);
+ *
+ * // Seeded normal random vector (reproducible)
+ * const v = randomTensor([100], { distribution: 'normal', seed: 42 });
+ *
+ * // 8x8 random orthogonal matrix
+ * const O = randomTensor([8, 8], { distribution: 'orthogonal', seed: 7 });
+ * ```
+ */
+declare function randomTensor(shape: ReadonlyArray<number>, opts?: RandomTensorOpts): Tensor;
+
+/**
+ * contractNetwork — given an ordered list of Tensors (each carrying
+ * `axisLabels`), find the pairwise-contraction order minimising the total
+ * FLOP count and execute it. ITensor's `optimal_contraction_sequence`
+ * equivalent.
+ *
+ * Two algorithms are provided:
+ *
+ *   - 'exact' — bitmask dynamic programming. For every non-empty subset
+ *     S ⊂ {0..N-1} of input tensors, we compute `bestCost[S]` and the
+ *     partition (S₁, S₂) achieving it (S = S₁ ⊔ S₂, both non-empty).
+ *     Transition:
+ *
+ *         bestCost[S] = min over all proper subset pairs (S₁, S₂) of
+ *                       bestCost[S₁] + bestCost[S₂] + pairwiseCost(net(S₁), net(S₂))
+ *
+ *     Base: bestCost[{i}] = 0. Subset enumeration via the standard
+ *     submask trick `for (sub = (mask-1) & mask; sub > 0; sub = (sub-1) & mask)`
+ *     visits every non-empty proper subset in O(3^N) total.
+ *
+ *     Determinism: ties broken by preferring the lexicographically smaller
+ *     (subsetMask₁, subsetMask₂) where subsetMask₁ ≤ subsetMask₂.
+ *
+ *     Bitmask encoding: bit `i` of a 32-bit integer is set iff input tensor
+ *     index `i` is part of the subset. So `0b1011 = {0, 1, 3}`. We use
+ *     ordinary JavaScript numbers (safe up to 2^32 for bitwise ops; capped
+ *     at N ≤ 30 for headroom).
+ *
+ *   - 'greedy' — Hendrickson–Sundaram. Maintain a working list of
+ *     intermediate tensor shapes. At each step, choose the pair (i, j) with
+ *     the cheapest pairwise contraction cost and replace them with their
+ *     contraction. Repeat until one remains. O(N³) per step × O(N) steps.
+ *
+ * Cost model: for a pairwise contraction of two intermediate tensors with
+ * shared-axis dimension product `D_shared` and free-axis dimension products
+ * `D_free_left`, `D_free_right`, the contraction FLOP cost is
+ *
+ *     cost = D_shared * D_free_left * D_free_right
+ *
+ * which is the volume of the OUTPUT tensor times the contraction depth. If
+ * `D_shared = 1` (no shared axes — outer product) we use `D_free_left *
+ * D_free_right`; mathematically that is the same formula. We follow this
+ * convention but it never fires in practice because we drive the cost
+ * through pairs with at least one shared index when possible.
+ *
+ * Output-tensor size for `intermediateSizes`: `D_free_left * D_free_right`
+ * (the contracted-axis dimensions are summed away, not multiplied into the
+ * result).
+ *
+ * `contractionOrder` indexing convention: each pair `[i, j]` is in
+ * "virtual-index" space. Input tensors occupy slots 0..N-1; the first
+ * pairwise contraction produces virtual slot N, the second slot N+1, and
+ * so on. So a length-N input network has a length-(N-1) order array.
+ */
+
+interface ContractNetworkOpts {
+    /** Cap intermediate-tensor element count to avoid blowups. Default: 2^31. */
+    maxIntermediateSize?: number;
+    /**
+     * 'exact'  = DP optimal (≤ ~16 tensors, slow beyond that).
+     * 'greedy' = Hendrickson–Sundaram heuristic (any N).
+     * 'auto'   = 'exact' when N ≤ 16, otherwise 'greedy'.
+     * Default: 'auto'.
+     */
+    algorithm?: 'exact' | 'greedy' | 'auto';
+}
+interface ContractNetworkResult {
+    result: Tensor;
+    /** Pairwise contractions in (virtual) input-index space; see file header. */
+    contractionOrder: ReadonlyArray<readonly [number, number]>;
+    /** Sum of pairwise FLOP costs along the chosen order. */
+    totalFlops: number;
+    /** Element count of each intermediate, in creation order. */
+    intermediateSizes: ReadonlyArray<number>;
+}
+/**
+ * Contract a network of named-index tensors in the optimal pairwise order.
+ *
+ * Returns:
+ *   - `result` — the fully contracted final Tensor.
+ *   - `contractionOrder` — the chosen sequence of pairwise contractions in
+ *     virtual-slot space (slots 0..N-1 = inputs; each produced intermediate
+ *     takes the next free slot).
+ *   - `totalFlops` — sum of per-step FLOP costs along the chosen order.
+ *   - `intermediateSizes` — element count of each produced intermediate.
+ *
+ * Throws:
+ *   - on empty input.
+ *   - if any input lacks `axisLabels`.
+ *   - if `maxIntermediateSize` is so tight no valid order exists.
+ */
+declare function contractNetwork(tensors: ReadonlyArray<Tensor>, opts?: ContractNetworkOpts): ContractNetworkResult;
+
+/**
+ * tensorQr — QR decomposition for rank-N tensors.
+ *
+ * Mirrors the `tensorSvd` pattern: partitions the axes of `t` into "row" axes
+ * (joining with Q) and "col" axes (joining with R), permutes + reshapes `t`
+ * into a 2-D matrix, calls the DenseMatrix `qr` primitive, then reshapes Q
+ * and R back into Tensors.
+ *
+ * In 'reduced' mode (default, thin QR):
+ *   Q has shape [...rowDims, k]   where k = min(numRows, numCols)
+ *   R has shape [k, ...colDims]
+ *
+ * In 'full' mode:
+ *   Q has shape [...rowDims, numRows]   (square in the row direction)
+ *   R has shape [numRows, ...colDims]
+ *
+ * `axisLabels` propagation: when the input carries labels, the row-axis
+ * labels are forwarded to Q's leading dims and the col-axis labels to R's
+ * trailing dims. A fresh "joining" Index of dimension `k` (or `numRows` in
+ * full mode) is inserted between them.
+ */
+
+interface TensorQrOpts {
+    /** 'reduced' (default, thin QR) or 'full'. */
+    mode?: 'reduced' | 'full';
+    /**
+     * Optional name for the joining index between Q and R. Used only when
+     * input axisLabels are present to label the new joining axis. Defaults
+     * to "qr".
+     */
+    joiningIndexName?: string;
+}
+interface TensorQrResult {
+    /** Q factor with orthonormal columns reshaped to [...rowDims, k]. */
+    Q: Tensor;
+    /** R factor (upper-triangular) reshaped to [k, ...colDims]. */
+    R: Tensor;
+}
+/**
+ * Compute the QR decomposition of tensor `t` by partitioning its axes into
+ * "row" and "col" groups.
+ *
+ * @param t        - Input tensor of any rank ≥ 1.
+ * @param rowAxes  - Axis indices forming the row dimension of the effective
+ *                   2-D matrix. The remaining axes form the column dimension.
+ * @param opts     - Optional mode + naming settings.
+ */
+declare function tensorQr(t: Tensor, rowAxes: ReadonlyArray<number>, opts?: TensorQrOpts): TensorQrResult;
+
+/**
+ * tensorLU — LU decomposition with partial pivoting for rank-N tensors.
+ *
+ * Mirrors the `tensorSvd` pattern: partitions the axes of `t` into "row"
+ * axes and "col" axes, reshapes `t` into a 2-D matrix, performs LU with
+ * partial pivoting (Doolittle's algorithm via the matrix primitive), and
+ * returns the factors as Tensors.
+ *
+ * The 2-D-reshaped input must be square; otherwise an error is thrown.
+ *
+ * Decomposition: P · A = L · U, where L is unit lower-triangular and U is
+ * upper-triangular. P is returned as the row-permutation array (P[i] is
+ * the row index of the original A that was moved to position i).
+ *
+ * `axisLabels` propagation: L receives the rowAxes labels on its leading
+ * dims and a fresh joining Index on its trailing axis; U receives the
+ * joining Index on its leading axis and the colAxes labels on its trailing
+ * dims.
+ */
+
+interface TensorLUResult {
+    /** Unit lower-triangular L. Shape [...rowDims, n]. */
+    L: Tensor;
+    /** Upper-triangular U. Shape [n, ...colDims]. */
+    U: Tensor;
+    /** Row permutation array of length n. P[i] is the original-row index now at position i. */
+    P: Int32Array;
+    /** Sign of the permutation (+1 for even, -1 for odd) — useful for det(). */
+    parity: 1 | -1;
+}
+interface TensorLUOpts {
+    /** Optional name for the joining index between L and U. Defaults to "lu". */
+    joiningIndexName?: string;
+}
+/**
+ * Compute the LU decomposition of tensor `t` by partitioning its axes into
+ * "row" and "col" groups. The reshaped 2-D matrix must be square.
+ *
+ * Delegates the core Doolittle algorithm to `@danielsimonjr/mathts-matrix`'s
+ * `lu` primitive.
+ *
+ * @param t        - Input tensor of any rank ≥ 1.
+ * @param rowAxes  - Axis indices forming the row dimension of the effective
+ *                   2-D matrix. The remaining axes form the column dimension.
+ * @param opts     - Optional joining-index name.
+ */
+declare function tensorLU(t: Tensor, rowAxes: ReadonlyArray<number>, opts?: TensorLUOpts): TensorLUResult;
+
+/**
+ * tensorCholesky — Cholesky decomposition for symmetric positive-definite
+ * rank-N tensors.
+ *
+ * Mirrors the `tensorSvd` pattern: partitions the axes of `t` into "row"
+ * axes and "col" axes, reshapes `t` into a 2-D matrix, performs the
+ * Cholesky decomposition via the matrix primitive (right-looking algorithm),
+ * and returns the factor as a Tensor.
+ *
+ * The 2-D reshaped input must be square and symmetric positive-definite;
+ * otherwise an error is thrown.
+ *
+ * Decomposition modes:
+ *   - default (`lower: true`):  returns L such that A = L · Lᵀ.
+ *   - `lower: false`:           returns U such that A = Uᵀ · U.
+ *
+ * `axisLabels` propagation: the returned factor receives the rowAxes labels
+ * on its leading dims and a fresh joining Index on its trailing axis
+ * (for L), or the joining Index on the leading axis and colAxes labels on
+ * the trailing dims (for U).
+ */
+
+interface TensorCholeskyOpts {
+    /** When true (default), return L such that A = L·Lᵀ. When false, return U such that A = Uᵀ·U. */
+    lower?: boolean;
+    /** Optional name for the joining index on the returned factor. Defaults to "cholesky". */
+    joiningIndexName?: string;
+}
+interface TensorCholeskyResult {
+    /** Cholesky factor (lower or upper depending on `opts.lower`). */
+    L: Tensor;
+}
+/**
+ * Compute the Cholesky decomposition of tensor `t` by partitioning its
+ * axes into "row" and "col" groups. The reshaped 2-D matrix must be
+ * square and symmetric positive-definite.
+ *
+ * Delegates the core right-looking Cholesky algorithm to
+ * `@danielsimonjr/mathts-matrix`'s `cholesky` primitive.
+ *
+ * @param t        - Input tensor of any rank ≥ 1.
+ * @param rowAxes  - Axis indices forming the row dimension of the effective
+ *                   2-D matrix. The remaining axes form the column dimension.
+ * @param opts     - Optional triangle selector + naming.
+ */
+declare function tensorCholesky(t: Tensor, rowAxes: ReadonlyArray<number>, opts?: TensorCholeskyOpts): TensorCholeskyResult;
+
+/**
+ * tensorEig — eigenvalue / eigenvector decomposition for rank-N tensors.
+ *
+ * Mirrors the `tensorSvd` pattern: partitions the axes of `t` into "row"
+ * axes and "col" axes, reshapes `t` into a 2-D matrix, and delegates to
+ * the DenseMatrix `eig` primitive.
+ *
+ * The 2-D reshaped input must be square.
+ *
+ * Routing:
+ *   - `symmetric: true`     — eigenvalues are real and eigenvectors are
+ *                             orthogonal (matrix routes the symmetric path
+ *                             internally).
+ *   - `symmetric: false` (default) — general eigensolver. If any eigenvalue
+ *                             has a non-zero imaginary part, the result
+ *                             includes an `eigenvaluesImaginary` Tensor;
+ *                             otherwise the field is undefined.
+ *   - `computeVectors: false` — only eigenvalues are returned (faster).
+ */
+
+interface TensorEigOpts {
+    /** Hint that the input is symmetric; routes through a stable real-eigenvalue path. */
+    symmetric?: boolean;
+    /** When false, only eigenvalues are computed. Default true. */
+    computeVectors?: boolean;
+}
+interface TensorEigResult {
+    /** Real parts of the eigenvalues. 1-D Tensor of length n. */
+    eigenvalues: Tensor;
+    /** Eigenvectors as columns; shape [n, n]. Present only when computeVectors !== false. */
+    eigenvectors?: Tensor;
+    /**
+     * Imaginary parts of the eigenvalues. 1-D Tensor of length n.
+     * Only present when any eigenvalue has nonzero imaginary part (general
+     * non-symmetric case). Undefined when all eigenvalues are real.
+     */
+    eigenvaluesImaginary?: Tensor;
+}
+/**
+ * Compute the eigendecomposition of tensor `t` by partitioning its axes
+ * into "row" and "col" groups. The reshaped 2-D matrix must be square.
+ *
+ * @param t        - Input tensor of any rank ≥ 1.
+ * @param rowAxes  - Axis indices forming the row dimension of the effective
+ *                   2-D matrix. The remaining axes form the column dimension.
+ * @param opts     - Optional symmetric hint + computeVectors flag.
+ */
+declare function tensorEig(t: Tensor, rowAxes: ReadonlyArray<number>, opts?: TensorEigOpts): TensorEigResult;
+
+/**
+ * tensorPinv — Moore-Penrose pseudoinverse for rank-N tensors.
+ *
+ * Partitions the axes of `t` into "row" axes (the axes that form the
+ * numerically "tall" side of the matrix) and the remaining "col" axes.
+ * Then:
+ *   1. Permutes + reshapes `t` to a 2-D matrix M (numRows × numCols).
+ *   2. Computes the full SVD:  M = U · diag(S) · V^T.
+ *   3. Thresholds small singular values using `rcond`: keep s_i if
+ *      s_i > rcond · max(S), else treat as zero.
+ *   4. Computes pinv(M) = V · diag(S^+) · U^T   (shape: numCols × numRows).
+ *   5. Reshapes the result back into a Tensor with swapped row/col dims.
+ *
+ * Axis labels: if the input carries `axisLabels`, the output tensor's
+ * leading axes get the original col-axis labels and the trailing axes get
+ * the original row-axis labels (because the pseudoinverse swaps rows ↔ cols).
+ */
+
+interface TensorPinvOpts {
+    /**
+     * Relative condition threshold for singular-value truncation.
+     * A singular value s_i is treated as zero when s_i ≤ rcond · max(S).
+     * Default: 1e-10.
+     */
+    rcond?: number;
+}
+/**
+ * Compute the Moore-Penrose pseudoinverse of tensor `t` by partitioning its
+ * axes into "row" and "col" groups.
+ *
+ * @param t        - Input tensor of any rank ≥ 1.
+ * @param rowAxes  - Axis indices (integers) or Index objects whose dimensions
+ *                   form the row dimension of the effective 2-D matrix. The
+ *                   remaining axes form the column dimension.
+ * @param opts     - Optional rcond threshold.
+ */
+declare function tensorPinv(t: Tensor, rowAxes: ReadonlyArray<number | Index>, opts?: TensorPinvOpts): Tensor;
+
+/**
+ * tensorSolve — named-index linear solver for rank-N tensors.
+ *
+ * Reshapes tensor A into a square matrix and tensor b into a column vector (or
+ * multi-column RHS matrix), solves A·x = b via LU decomposition with partial
+ * pivoting, and reshapes the solution back.
+ *
+ * Axis matching:
+ *   - When A has `axisLabels` and `b` has `axisLabels`, the "row" axes of A
+ *     are matched to axes of `b` by Index identity (ignoring prime level).
+ *   - Otherwise `rowAxesA` / `rowAxesB` (integer indices) must be provided,
+ *     or the first axes of each tensor are used by default.
+ *
+ * Constraints:
+ *   - The reshaped A must be square (numRows_A × numRows_A).
+ *   - A must be non-singular (LU decomposition throws if pivot is zero).
+ *   - For multi-RHS, the RHS col dimension must match A's row dimension.
+ *
+ * Result shape:
+ *   - `x` has shape [...colDimsA, ...colDimsB] where colDimsA are the axes
+ *     of A not used as row axes and colDimsB are the axes of b not used as
+ *     row (contracting) axes.
+ *   - When A is square as a whole tensor (rank 2), the result has the same
+ *     shape as b.
+ *
+ * Axis labels: propagated from A's col axes and b's col axes.
+ */
+
+interface TensorSolveOpts {
+    /**
+     * Axis indices (integers) or Index objects of A that form the "contracting"
+     * (row) side of the square matrix. Default: first `ceil(rank/2)` axes.
+     */
+    rowAxesA?: ReadonlyArray<number | Index>;
+    /**
+     * Axis indices (integers) or Index objects of b that form the "contracting"
+     * (row) side matched to A's row dimension. Default: first axis of b.
+     */
+    rowAxesB?: ReadonlyArray<number | Index>;
+}
+interface TensorSolveResult {
+    /** Solution tensor x satisfying A·x ≈ b. */
+    x: Tensor;
+}
+/**
+ * Solve A·x = b for x using LU decomposition.
+ *
+ * @param A    - Coefficient tensor (rank ≥ 2 when reshaped to square).
+ * @param b    - Right-hand side tensor.
+ * @param opts - Optional axis-selection overrides.
+ */
+declare function tensorSolve(A: Tensor, b: Tensor, opts?: TensorSolveOpts): TensorSolveResult;
+
+/**
+ * tensorKron — Kronecker product for rank-N tensors.
+ *
+ * Computes the Kronecker product of tensors `a` and `b`. For rank-2 matrices
+ * this is the classical Kronecker product:
+ *
+ *   kron(A, B)[i0, j0] = A[i0 / B.rows, j0 / B.cols] * B[i0 % B.rows, j0 % B.cols]
+ *
+ * For higher-rank tensors, the same rule is applied axis-by-axis:
+ *
+ *   result.shape[k] = a.shape[k] * b.shape[k]
+ *   result[...i] = a[i[0]/b.shape[0], ..., i[r-1]/b.shape[r-1]]
+ *                * b[i[0]%b.shape[0], ..., i[r-1]%b.shape[r-1]]
+ *
+ * Rank alignment: if the tensors have different ranks, the smaller one is
+ * broadcast-aligned to the right by prepending size-1 dimensions (numpy-style).
+ *
+ * Axis labels: when both tensors carry `axisLabels`, the output axis labels
+ * are formed by concatenating each pair as `"<aName>_X_<bName>"` to avoid
+ * collisions. When only one tensor has labels, the output carries no labels.
+ */
+
+interface TensorKronOpts {
+    /**
+     * Separator string inserted between a's and b's axis-label names when
+     * building the output axisLabels. Default: "_X_".
+     */
+    separator?: string;
+}
+/**
+ * Compute the Kronecker product of tensors `a` and `b`.
+ *
+ * @param a    - Left operand tensor.
+ * @param b    - Right operand tensor.
+ * @param opts - Optional separator for axis-label naming.
+ */
+declare function tensorKron(a: Tensor, b: Tensor, opts?: TensorKronOpts): Tensor;
+
+/**
+ * slice — extract a sub-tensor by per-axis [start, stop, step] ranges.
+ *
+ * Mirrors NumPy / JAX basic slicing semantics:
+ *   - Negative indices wrap around: -1 refers to the last element.
+ *   - `null` range for an axis means "take the entire axis".
+ *   - `step` must be >= 1 (reverse-step slicing is deferred).
+ *   - Output shape for axis i: Math.ceil((stop - start) / step).
+ *
+ * Axis-label semantics: labels from the input axes are preserved in the
+ * output. A slice is still the same logical axis — just smaller — so the
+ * label name and tags are carried forward (dimension is updated to match the
+ * new axis size; the id is re-minted since the Index type is immutable and
+ * dimension is part of the index identity).
+ */
+
+interface SliceRange {
+    /** Default 0. Supports negative indexing: -1 means shape[axis]-1. */
+    start?: number;
+    /** Default = shape[axis]. Supports negative indexing. */
+    stop?: number;
+    /** Default 1. Must be >= 1 (no reverse step). */
+    step?: number;
 }
+/**
+ * Extract a sub-tensor by per-axis `SliceRange` triples.
+ *
+ * @param t      - Input tensor of any rank.
+ * @param ranges - Array of length `t.shape.length`. Each element is either a
+ *                 `SliceRange` or `null` (which means "take the entire axis").
+ *                 Must have the same length as `t.shape`.
+ * @returns A new `Tensor` whose shape[i] = ceil((stop_i - start_i) / step_i),
+ *          carrying preserved axis labels (same name/tags, updated dim).
+ *
+ * @throws {RangeError} If `step` is not a positive integer.
+ * @throws {Error}      If `ranges.length !== t.shape.length`.
+ *
+ * @example
+ * // Extract rows 1–3 (exclusive), all columns from a 5×4 tensor:
+ * const sub = slice(t, [{ start: 1, stop: 3 }, null]);
+ */
+declare function slice(t: Tensor, ranges: (SliceRange | null)[]): Tensor;
+
+/**
+ * gather — pull elements along one axis (NumPy `take` / JAX `gather`).
+ *
+ * For each index in `indices`, the output contains the corresponding "slice"
+ * of the input tensor along `axis`. The output has the same rank as the input;
+ * only `shape[axis]` changes to `indices.length`.
+ *
+ * Axis-label semantics: the gathered axis's label is **primed** (primeLevel
+ * incremented by 1 via `Index.prime()`) so it does not auto-match the original
+ * axis in `contract`. All other axis labels are preserved unchanged.
+ *
+ * The priming approach mirrors ITensors.jl's convention: after gathering, the
+ * index is the "selected" variant of the original, not the original itself.
+ */
+
+/**
+ * Gather elements along `axis` using `indices`.
+ *
+ * @param t       - Input tensor of any rank.
+ * @param axis    - The axis along which to gather. Supports negative indexing.
+ * @param indices - The indices to gather. Duplicates are allowed.
+ * @returns A new `Tensor` with `shape[axis] === indices.length` and all other
+ *          dimensions unchanged. The gathered-axis label is primed.
+ *
+ * @throws {RangeError} If any index in `indices` is outside [0, shape[axis]).
+ * @throws {Error}      If `axis` is out of range.
+ *
+ * @example
+ * // Select rows 0 and 2 from a 3×4 matrix:
+ * const rows = gather(matrix, 0, [0, 2]);   // shape [2, 4]
+ */
+declare function gather(t: Tensor, axis: number, indices: readonly number[]): Tensor;
+
+/**
+ * stack — stack same-shape tensors along a new axis (NumPy `stack`).
+ *
+ * All input tensors must have identical shapes. A new axis is inserted at
+ * position `axis` in the output, making the output rank = input rank + 1.
+ * `stack([a, b], 0)` is equivalent to NumPy's `np.stack([a, b], axis=0)`.
+ *
+ * Axis-label semantics:
+ *   - The new axis gets `undefined` label by default (it has no correspondence
+ *     to any input axis).
+ *   - Pass `opts.newAxisLabel` (an `Index`) to label the new axis explicitly.
+ *   - The remaining axes inherit labels from `tensors[0]`. If labels disagree
+ *     across inputs for a given axis, `tensors[0]`'s label is used silently
+ *     (no error, no warning — document this choice here).
+ *   - If `tensors[0]` has no `axisLabels`, the output also carries none.
+ */
+
+interface StackOpts {
+    /**
+     * Optional label for the newly created axis. If omitted, the new axis
+     * carries no label (`axisLabels[axis] === undefined` in the output, or more
+     * precisely: the output `axisLabels` array contains `undefined` at that
+     * position — encoded as `null` in the array but TypeScript sees it as the
+     * slot being absent when axisLabels is stripped to only defined entries).
+     *
+     * In practice: if `tensors[0].axisLabels` is defined, an `Index` for the
+     * new axis is created either from this option or as a placeholder.
+     */
+    newAxisLabel?: Index;
+}
+/**
+ * Stack same-shape tensors along a new axis.
+ *
+ * @param tensors - Array of tensors, all with the same shape. Must be non-empty.
+ * @param axis    - Position of the new axis in the output. Supports negative
+ *                  indexing relative to the output rank. E.g. `axis=0` inserts
+ *                  a new leading axis; `axis=-1` appends a new trailing axis.
+ * @param opts    - Optional `newAxisLabel` for the inserted axis.
+ * @returns A tensor of rank `inputRank + 1` with `shape[axis] === tensors.length`.
+ *
+ * @throws {Error} If `tensors` is empty, or if any tensor's shape differs from
+ *                 `tensors[0]`.
+ *
+ * @example
+ * // Stack two row-vectors [a, b, c] and [d, e, f] → 2×3 matrix:
+ * const matrix = stack([v1, v2], 0);
+ */
+declare function stack(tensors: Tensor[], axis: number, opts?: StackOpts): Tensor;
+
+/**
+ * concatenate — join tensors along an existing axis (NumPy `concatenate`).
+ *
+ * All tensors must agree on every axis except the join axis. The output rank
+ * equals the input rank; only `shape[axis]` grows (sum of all input shapes
+ * along that axis).
+ *
+ * Axis-label semantics:
+ *   - All axis labels are taken from `tensors[0]`.
+ *   - If any `tensors[i].axisLabels[axis]` disagrees with `tensors[0]`'s label
+ *     on the join axis, `tensors[0]`'s label is used silently (matching the
+ *     principle that the first tensor is authoritative for label semantics).
+ *   - If `tensors[0]` carries no `axisLabels`, the output also carries none.
+ */
+
+/**
+ * Concatenate tensors along an existing `axis`.
+ *
+ * @param tensors - Array of tensors. Must be non-empty. All must agree on every
+ *                  axis except `axis`.
+ * @param axis    - The axis along which to concatenate. Supports negative indexing.
+ * @returns A tensor with the same rank and with `shape[axis]` equal to the sum
+ *          of `tensors[i].shape[axis]`.
+ *
+ * @throws {Error} If `tensors` is empty, if any tensor has a different rank, or
+ *                 if shapes disagree on any non-join axis.
+ *
+ * @example
+ * // Vertically stack two 2×3 matrices → 4×3 matrix:
+ * const tall = concatenate([a, b], 0);
+ * // Horizontally stack two 2×3 matrices → 2×6 matrix:
+ * const wide = concatenate([a, b], 1);
+ */
+declare function concatenate(tensors: Tensor[], axis: number): Tensor;
+
+/**
+ * scatter — inverse of gather. Writes `updates` into a copy of `t` at the
+ * given `indices` along `axis` (NumPy `np.put_along_axis` / JAX `scatter`).
+ *
+ * For each position `i` in `indices`, the corresponding "slice" of `updates`
+ * along `axis` is written into the matching "slice" of the output at position
+ * `indices[i]`. All positions of `t` not referenced by `indices` are copied
+ * unchanged.
+ *
+ * Duplicate-index semantics: **last-wins** — when the same index appears more
+ * than once in `indices`, the last occurrence overwrites earlier ones. This
+ * mirrors NumPy's default scatter behaviour. Document-level note: if
+ * deterministic accumulation (e.g. `add`) is needed, use `ScatterOpts.reduce`.
+ *
+ * Axis-label semantics: the output has exactly the same shape as `t`
+ * (scatter never changes the size of any axis), so all axis labels from `t`
+ * are preserved unchanged.
+ */
+
+interface ScatterOpts {
+    /**
+     * How to combine `updates` with existing values at the target positions.
+     * - `'overwrite'` (default) — last-wins; target is replaced.
+     * - `'add'`                 — target is incremented by the update value.
+     */
+    reduce?: 'overwrite' | 'add';
+}
+/**
+ * Scatter `updates` into a copy of `t` at `indices` along `axis`.
+ *
+ * @param t       - Destination tensor (not mutated). Any rank.
+ * @param axis    - The axis along which to scatter. Supports negative indexing.
+ * @param indices - Target positions along `axis`. Must all be in
+ *                  `[0, t.shape[axis])`. Duplicates are allowed (last-wins
+ *                  by default, or add-accumulate when `opts.reduce === 'add'`).
+ * @param updates - Source tensor. Must have the same rank as `t` with
+ *                  `updates.shape[axis] === indices.length` and all other
+ *                  dimensions equal to `t.shape`.
+ * @param opts    - Optional scatter options.
+ * @returns A new `Tensor` with the same shape as `t`, with axis labels
+ *          preserved from `t`.
+ *
+ * @throws {Error}      If `axis` is out of range, `updates` rank mismatches,
+ *                      or `updates` shape is incompatible.
+ * @throws {RangeError} If any index in `indices` is outside `[0, shape[axis])`.
+ *
+ * @example
+ * // Round-trip with gather: scatter zeros back to a masked copy
+ * const zeros = new Tensor([3, 4], new Float64Array(12));
+ * const result = scatter(zeros, 0, [0, 2], gather(t, 0, [0, 2]));
+ * // result[0, :] === t[0, :], result[1, :] === 0, result[2, :] === t[2, :]
+ */
+declare function scatter(t: Tensor, axis: number, indices: readonly number[], updates: Tensor, opts?: ScatterOpts): Tensor;
+
+/**
+ * pad — pad each axis by [before, after] amounts.
+ *
+ * Three modes are supported, mirroring NumPy's `np.pad`:
+ *
+ * - `'constant'` (default): Fill padded cells with `constantValue` (default 0).
+ * - `'edge'`:    Repeat the boundary element along each padded slice.
+ * - `'reflect'`: Mirror the data across the boundary, excluding the boundary
+ *                element itself. Requires that each padding amount is strictly
+ *                less than the corresponding axis size.
+ *
+ * Axis-label semantics: output rank equals input rank and axis identities do
+ * not change (padding is just extension, not transformation). All axis labels
+ * from the input are preserved unchanged in the output.
+ */
+
+interface PadOptions {
+    /**
+     * Padding mode.
+     * - `'constant'` (default): fill with `constantValue`.
+     * - `'edge'`:    repeat boundary element.
+     * - `'reflect'`: mirror across boundary, excluding boundary itself.
+     */
+    mode?: 'constant' | 'edge' | 'reflect';
+    /** Value used when `mode === 'constant'`. Default `0`. */
+    constantValue?: number;
+}
+/**
+ * Pad a tensor along each axis by specified widths.
+ *
+ * @param t         - Input tensor of any rank.
+ * @param padWidths - Array of `[before, after]` pairs, one per axis. Length
+ *                    must equal `t.shape.length`. Each value must be >= 0.
+ * @param opts      - Optional padding options (mode and constantValue).
+ * @returns A new `Tensor` with `shape[k] = t.shape[k] + before_k + after_k`
+ *          and axis labels preserved from `t`.
+ *
+ * @throws {Error}      If `padWidths.length !== t.shape.length`, any pad
+ *                      value is negative, or `mode === 'reflect'` is used
+ *                      with a pad amount >= the corresponding axis size.
+ *
+ * @example
+ * // Constant-pad a 3×4 tensor with 1 cell of zeros on each side:
+ * const padded = pad(t, [[1, 1], [1, 1]]);  // shape [5, 6]
+ *
+ * // Edge-pad with asymmetric widths:
+ * const ep = pad(t, [[2, 0], [0, 1]], { mode: 'edge' });
+ */
+declare function pad(t: Tensor, padWidths: readonly (readonly [number, number])[], opts?: PadOptions): Tensor;
+
+/**
+ * roll — cyclic shift along given axes.
+ *
+ * Each element is moved `shifts[k]` positions forward along `axes[k]`
+ * (wrapping around at the axis boundaries). Negative shifts move backward.
+ *
+ * When `axes` is omitted, `shifts` must be a single number and the tensor is
+ * treated as a flattened 1-D array that is shifted by that amount, then
+ * reshaped back to the original shape — exactly matching NumPy `np.roll(t, n)`.
+ *
+ * Implementation: for each output flat index, the corresponding input flat
+ * index is computed by decoding the multi-index, un-shifting each specified
+ * axis (with modulo wrap), then re-encoding to a flat input index.
+ *
+ * Axis-label semantics: cyclic shifting does not change the semantic identity
+ * of any axis (it is the same axis with reordered elements), so all axis
+ * labels from the input are preserved unchanged in the output.
+ */
+
+/**
+ * Cyclically shift a tensor along given axes.
+ *
+ * @param t      - Input tensor of any rank.
+ * @param shifts - Number of positions to shift. A single number when `axes` is
+ *                 omitted (flat shift); an array of the same length as `axes`
+ *                 when `axes` is provided.
+ * @param axes   - Axes to shift along. Supports negative indexing. When
+ *                 omitted, the tensor is treated as flattened and `shifts` must
+ *                 be a single number.
+ * @returns A new `Tensor` with the same shape as `t`, with axis labels
+ *          preserved from `t`.
+ *
+ * @throws {Error} If `axes` is provided and `shifts` array length !== `axes`
+ *                 length, or if any axis value is out of range.
+ *
+ * @example
+ * // Shift a rank-1 tensor [1,2,3,4,5] by 2: → [4,5,1,2,3]
+ * const r = roll(t, 2, [0]);
+ *
+ * // Flat shift (no axes):
+ * const flat = roll(matrix, 3);
+ */
+declare function roll(t: Tensor, shifts: number | readonly number[], axes?: readonly number[]): Tensor;
+
+/**
+ * flip — reverse element order along given axes.
+ *
+ * For each axis in `axes`, the index along that axis is reversed:
+ *
+ *   out[..., i, ...] = in[..., dim - 1 - i, ...]
+ *
+ * Multiple axes can be flipped in a single pass. An empty `axes` array is
+ * a no-op (returns a copy of the input).
+ *
+ * Axis-label semantics: reversing the iteration order of an axis does not
+ * change its semantic identity — it is still the same logical axis. All axis
+ * labels from the input are therefore preserved unchanged in the output.
+ */
+
+/**
+ * Reverse element order along the specified axes.
+ *
+ * @param t    - Input tensor of any rank.
+ * @param axes - The axes to flip. Supports negative indexing. Duplicates are
+ *               ignored. An empty array returns a copy of `t`.
+ * @returns A new `Tensor` with the same shape as `t`, with axis labels
+ *          preserved from `t`.
+ *
+ * @throws {Error} If any axis value is out of range.
+ *
+ * @example
+ * // Flip rows (axis 0) of a 3×4 matrix:
+ * const flipped = flip(matrix, [0]);
+ *
+ * // Flip both axes simultaneously:
+ * const rotated180 = flip(matrix, [0, 1]);
+ */
+declare function flip(t: Tensor, axes: readonly number[]): Tensor;
 
-export { type EinsumSpec, type NestedArray, Tensor };
+export { type ContractNetworkOpts, type ContractNetworkResult, type EinsumSpec, Index, type IndexOpts, type NestedArray, type PadOptions, type RandomTensorOpts, type ScatterOpts, type SliceRange, type StackOpts, Tensor, type TensorCholeskyOpts, type TensorCholeskyResult, type TensorEigOpts, type TensorEigResult, type TensorKronOpts, type TensorLUOpts, type TensorLUResult, type TensorPinvOpts, type TensorQrOpts, type TensorQrResult, type TensorSolveOpts, type TensorSolveResult, type TensorSvdOpts, type TensorSvdResult, concatenate, contractNetwork, flip, gather, idx, pad, randomTensor, roll, scatter, slice, stack, tensorCholesky, tensorEig, tensorKron, tensorLU, tensorPinv, tensorQr, tensorSolve, tensorSvd };