@danielsimonjr/mathts-matrix 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,2837 @@
+import * as _danielsimonjr_mathts_parallel from '@danielsimonjr/mathts-parallel';
+import { ComputePool, ComputePoolConfig } from '@danielsimonjr/mathts-parallel';
+import * as typed_function from 'typed-function';
+
+/**
+ * Matrix Base Class
+ *
+ * Abstract base class defining the common interface for all matrix types.
+ * Provides a unified API for DenseMatrix, SparseMatrix, and future implementations.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Matrix dimension type
+ */
+interface MatrixDimensions {
+    rows: number;
+    cols: number;
+}
+/**
+ * Matrix index for element access
+ */
+interface MatrixIndex {
+    row: number;
+    col: number;
+}
+/**
+ * Slice specification for submatrix extraction
+ */
+interface SliceSpec {
+    rowStart?: number;
+    rowEnd?: number;
+    colStart?: number;
+    colEnd?: number;
+}
+/**
+ * Matrix iterator result
+ */
+interface MatrixEntry<T = number> {
+    row: number;
+    col: number;
+    value: T;
+}
+/**
+ * Matrix storage format identifier
+ */
+type MatrixType = 'DenseMatrix' | 'SparseMatrix' | 'DiagonalMatrix' | 'BandMatrix';
+/**
+ * Abstract base class for all matrix types
+ *
+ * @typeParam T - The element type (default: number)
+ */
+declare abstract class Matrix<T = number> {
+    /**
+     * The matrix storage format type
+     */
+    abstract readonly type: MatrixType;
+    /**
+     * Number of rows
+     */
+    abstract readonly rows: number;
+    /**
+     * Number of columns
+     */
+    abstract readonly cols: number;
+    /**
+     * Get the dimensions of the matrix
+     */
+    get size(): MatrixDimensions;
+    /**
+     * Check if the matrix is square
+     */
+    get isSquare(): boolean;
+    /**
+     * Check if the matrix is a vector (single row or column)
+     */
+    get isVector(): boolean;
+    /**
+     * Check if the matrix is a row vector
+     */
+    get isRowVector(): boolean;
+    /**
+     * Check if the matrix is a column vector
+     */
+    get isColumnVector(): boolean;
+    /**
+     * Total number of elements
+     */
+    get length(): number;
+    /**
+     * Get element at position (row, col)
+     * @param row - Row index (0-based)
+     * @param col - Column index (0-based)
+     */
+    abstract get(row: number, col: number): T;
+    /**
+     * Set element at position (row, col)
+     * @param row - Row index (0-based)
+     * @param col - Column index (0-based)
+     * @param value - Value to set
+     * @returns A new matrix with the updated value (immutable)
+     */
+    abstract set(row: number, col: number, value: T): Matrix<T>;
+    /**
+     * Get a row as a new matrix (1×n)
+     * @param index - Row index
+     */
+    abstract row(index: number): Matrix<T>;
+    /**
+     * Get a column as a new matrix (m×1)
+     * @param index - Column index
+     */
+    abstract column(index: number): Matrix<T>;
+    /**
+     * Get a submatrix (view or copy depending on implementation)
+     * @param spec - Slice specification
+     */
+    abstract slice(spec: SliceSpec): Matrix<T>;
+    /**
+     * Get the diagonal elements as a vector
+     * @param k - Diagonal offset (0 = main diagonal, positive = above, negative = below)
+     */
+    abstract diagonal(k?: number): Matrix<T>;
+    /**
+     * Matrix addition
+     */
+    abstract add(other: Matrix<T>): Matrix<T>;
+    /**
+     * Matrix subtraction
+     */
+    abstract subtract(other: Matrix<T>): Matrix<T>;
+    /**
+     * Element-wise multiplication (Hadamard product)
+     */
+    abstract multiplyElementwise(other: Matrix<T>): Matrix<T>;
+    /**
+     * Matrix multiplication
+     */
+    abstract multiply(other: Matrix<T>): Matrix<T>;
+    /**
+     * Scalar multiplication
+     */
+    abstract scale(scalar: T): Matrix<T>;
+    /**
+     * Matrix transpose
+     */
+    abstract transpose(): Matrix<T>;
+    /**
+     * Convert to nested array representation
+     */
+    abstract toArray(): T[][];
+    /**
+     * Convert to flat array (row-major order)
+     */
+    abstract toFlatArray(): T[];
+    /**
+     * Create a deep copy of the matrix
+     */
+    abstract clone(): Matrix<T>;
+    /**
+     * Iterate over all elements with their indices
+     */
+    abstract entries(): IterableIterator<MatrixEntry<T>>;
+    /**
+     * Iterate over all values (row-major order)
+     */
+    abstract values(): IterableIterator<T>;
+    /**
+     * Check if indices are within bounds
+     */
+    protected checkBounds(row: number, col: number): void;
+    /**
+     * Check if dimensions match for element-wise operations
+     */
+    protected checkDimensionsMatch(other: Matrix<T>): void;
+    /**
+     * Check if matrices can be multiplied
+     */
+    protected checkMultiplyDimensions(other: Matrix<T>): void;
+    /**
+     * Format matrix for display
+     */
+    toString(): string;
+    /**
+     * Check equality with another matrix
+     */
+    equals(other: Matrix<T>, tolerance?: number): boolean;
+}
+/**
+ * Type guard to check if a value is a Matrix
+ */
+declare function isMatrix<T = number>(value: unknown): value is Matrix<T>;
+
+/**
+ * Sparse Matrix Implementation (CSR Format)
+ *
+ * Compressed Sparse Row (CSR) format sparse matrix for efficient storage
+ * and operations on matrices with many zero elements.
+ *
+ * CSR stores:
+ * - values: Non-zero values in row-major order
+ * - colIndices: Column index for each non-zero value
+ * - rowPointers: Index into values/colIndices where each row starts
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Sparse matrix using Compressed Sparse Row (CSR) format
+ *
+ * Efficient for:
+ * - Row slicing and iteration
+ * - Sparse matrix-vector multiplication
+ * - Matrices with many zeros (typically < 10% non-zero)
+ */
+declare class SparseMatrix extends Matrix<number> {
+    readonly type: "SparseMatrix";
+    readonly rows: number;
+    readonly cols: number;
+    /**
+     * Non-zero values in row-major order
+     */
+    private readonly _data;
+    /**
+     * Column indices for each non-zero value
+     */
+    private readonly _colIndices;
+    /**
+     * Row pointers: rowPointers[i] = index of first non-zero in row i
+     * rowPointers[rows] = total number of non-zeros (nnz)
+     */
+    private readonly _rowPointers;
+    /**
+     * Create a sparse matrix from CSR components
+     *
+     * @param rows - Number of rows
+     * @param cols - Number of columns
+     * @param values - Non-zero values
+     * @param colIndices - Column index for each value
+     * @param rowPointers - Row start indices
+     */
+    constructor(rows: number, cols: number, values: Float64Array | number[], colIndices: Int32Array | number[], rowPointers: Int32Array | number[]);
+    /**
+     * Create a sparse matrix from a dense matrix
+     *
+     * @param dense - Dense matrix to convert
+     * @param dropTolerance - Values below this threshold are treated as zero
+     */
+    static fromDense(dense: DenseMatrix, dropTolerance?: number): SparseMatrix;
+    /**
+     * Create a sparse matrix from coordinate (COO) format
+     *
+     * @param rows - Number of rows
+     * @param cols - Number of columns
+     * @param entries - Array of {row, col, value} entries
+     */
+    static fromCOO(rows: number, cols: number, entries: Array<{
+        row: number;
+        col: number;
+        value: number;
+    }>): SparseMatrix;
+    /**
+     * Create a zero sparse matrix
+     */
+    static zeros(rows: number, cols: number): SparseMatrix;
+    /**
+     * Create a sparse identity matrix
+     */
+    static identity(n: number): SparseMatrix;
+    /**
+     * Create a sparse diagonal matrix
+     */
+    static diag(values: number[]): SparseMatrix;
+    /**
+     * Number of non-zero elements
+     */
+    get nnz(): number;
+    /**
+     * Sparsity: fraction of zero elements
+     */
+    get sparsity(): number;
+    /**
+     * Density: fraction of non-zero elements
+     */
+    get density(): number;
+    /**
+     * Get element at (row, col) - O(log(nnz_in_row)) for sorted columns
+     */
+    get(row: number, col: number): number;
+    /**
+     * Set element at (row, col) - returns new matrix (immutable)
+     */
+    set(row: number, col: number, value: number): SparseMatrix;
+    /**
+     * Get a row as a sparse 1×n matrix
+     */
+    row(index: number): SparseMatrix;
+    /**
+     * Get a column as a sparse m×1 matrix
+     */
+    column(index: number): SparseMatrix;
+    /**
+     * Get a submatrix
+     */
+    slice(spec: SliceSpec): SparseMatrix;
+    /**
+     * Get the diagonal elements
+     */
+    diagonal(k?: number): SparseMatrix;
+    /**
+     * Sparse matrix addition
+     */
+    add(other: Matrix<number>): SparseMatrix;
+    private addSparse;
+    /**
+     * Sparse matrix subtraction
+     */
+    subtract(other: Matrix<number>): SparseMatrix;
+    /**
+     * Element-wise multiplication (Hadamard product)
+     */
+    multiplyElementwise(other: Matrix<number>): SparseMatrix;
+    /**
+     * Sparse matrix multiplication
+     */
+    multiply(other: Matrix<number>): SparseMatrix;
+    private multiplySparse;
+    /**
+     * Scalar multiplication
+     */
+    scale(scalar: number): SparseMatrix;
+    /**
+     * Sparse matrix transpose
+     */
+    transpose(): SparseMatrix;
+    /**
+     * Negate all elements
+     */
+    negate(): SparseMatrix;
+    /**
+     * Sum of all elements
+     */
+    sum(): number;
+    /**
+     * Frobenius norm
+     */
+    norm(): number;
+    /**
+     * Trace (sum of diagonal elements)
+     */
+    trace(): number;
+    /**
+     * Convert to dense matrix
+     */
+    toDense(): DenseMatrix;
+    /**
+     * Convert to nested array
+     */
+    toArray(): number[][];
+    /**
+     * Convert to flat array (row-major)
+     */
+    toFlatArray(): number[];
+    /**
+     * Clone the matrix
+     */
+    clone(): SparseMatrix;
+    /**
+     * Get the CSR components
+     */
+    getCSR(): {
+        values: Float64Array;
+        colIndices: Int32Array;
+        rowPointers: Int32Array;
+    };
+    /**
+     * Iterate over non-zero entries
+     */
+    entries(): IterableIterator<MatrixEntry<number>>;
+    /**
+     * Iterate over non-zero values
+     */
+    values(): IterableIterator<number>;
+    /**
+     * Iterate over all values (including zeros, row-major)
+     */
+    allValues(): IterableIterator<number>;
+    /**
+     * Support for...of iteration (iterates over non-zero values)
+     */
+    [Symbol.iterator](): IterableIterator<number>;
+    /**
+     * Apply a function to each non-zero element
+     */
+    mapNonZeros(fn: (value: number, row: number, col: number) => number): SparseMatrix;
+    /**
+     * Apply a function to each element (including zeros)
+     * Warning: This may create a dense result
+     */
+    map(fn: (value: number, row: number, col: number) => number): SparseMatrix;
+}
+/**
+ * Type guard for SparseMatrix
+ */
+declare function isSparseMatrix(value: unknown): value is SparseMatrix;
+
+/**
+ * Dense Matrix Implementation
+ *
+ * Row-major dense matrix backed by Float64Array for efficient storage
+ * and operations. Supports views (slices without copying) where possible.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Dense matrix implementation using Float64Array
+ *
+ * Data is stored in row-major order for cache-friendly row access.
+ * All operations return new matrices (immutable API).
+ */
+declare class DenseMatrix extends Matrix<number> {
+    readonly type: "DenseMatrix";
+    readonly rows: number;
+    readonly cols: number;
+    /**
+     * Internal data storage (row-major Float64Array)
+     */
+    private readonly data;
+    /**
+     * Whether this matrix is a view into another matrix's data
+     */
+    private readonly isView;
+    /**
+     * Offset into data array (for views)
+     */
+    private readonly offset;
+    /**
+     * Stride between rows (for views)
+     */
+    private readonly rowStride;
+    /**
+     * Create a new DenseMatrix
+     *
+     * @param rows - Number of rows
+     * @param cols - Number of columns
+     * @param data - Optional initial data (row-major order)
+     */
+    constructor(rows: number, cols: number, data?: Float64Array | number[] | number[][], viewConfig?: {
+        isView: boolean;
+        offset: number;
+        rowStride: number;
+    });
+    /**
+     * Create a matrix from a nested array
+     */
+    static fromArray(arr: number[][]): DenseMatrix;
+    /**
+     * Create a matrix from a flat array with specified dimensions
+     */
+    static fromFlat(rows: number, cols: number, data: number[]): DenseMatrix;
+    /**
+     * Create a zero matrix
+     */
+    static zeros(rows: number, cols: number): DenseMatrix;
+    /**
+     * Create a matrix filled with ones
+     */
+    static ones(rows: number, cols: number): DenseMatrix;
+    /**
+     * Create an identity matrix
+     */
+    static identity(n: number): DenseMatrix;
+    /**
+     * Create a diagonal matrix from values
+     */
+    static diag(values: number[]): DenseMatrix;
+    /**
+     * Create a matrix filled with a constant value
+     */
+    static fill(rows: number, cols: number, value: number): DenseMatrix;
+    /**
+     * Create a matrix with random values in [0, 1)
+     */
+    static random(rows: number, cols: number): DenseMatrix;
+    /**
+     * Get element at (row, col)
+     * O(1) access time
+     */
+    get(row: number, col: number): number;
+    /**
+     * Set element at (row, col) - returns new matrix
+     */
+    set(row: number, col: number, value: number): DenseMatrix;
+    /**
+     * Get the raw Float64Array data (copy if view, reference otherwise)
+     */
+    private toFlatFloat64Array;
+    /**
+     * Get a row as a 1×n matrix (view, no copy)
+     */
+    row(index: number): DenseMatrix;
+    /**
+     * Get a column as an m×1 matrix (copy, since data is row-major)
+     */
+    column(index: number): DenseMatrix;
+    /**
+     * Get a submatrix
+     */
+    slice(spec: SliceSpec): DenseMatrix;
+    /**
+     * Get the diagonal elements
+     */
+    diagonal(k?: number): DenseMatrix;
+    /**
+     * Matrix addition
+     */
+    add(other: Matrix<number>): DenseMatrix;
+    /**
+     * Matrix subtraction
+     */
+    subtract(other: Matrix<number>): DenseMatrix;
+    /**
+     * Element-wise multiplication (Hadamard product)
+     */
+    multiplyElementwise(other: Matrix<number>): DenseMatrix;
+    /**
+     * Matrix multiplication
+     */
+    multiply(other: Matrix<number>): DenseMatrix;
+    /**
+     * Scalar multiplication
+     */
+    scale(scalar: number): DenseMatrix;
+    /**
+     * Matrix transpose
+     */
+    transpose(): DenseMatrix;
+    /**
+     * Negate all elements
+     */
+    negate(): DenseMatrix;
+    /**
+     * Sum of all elements
+     */
+    sum(): number;
+    /**
+     * Mean of all elements
+     */
+    mean(): number;
+    /**
+     * Minimum element
+     */
+    min(): number;
+    /**
+     * Maximum element
+     */
+    max(): number;
+    /**
+     * Frobenius norm (sqrt of sum of squared elements)
+     */
+    norm(): number;
+    /**
+     * Trace (sum of diagonal elements)
+     */
+    trace(): number;
+    /**
+     * Convert to nested array
+     */
+    toArray(): number[][];
+    /**
+     * Convert to flat array (row-major)
+     */
+    toFlatArray(): number[];
+    /**
+     * Get the underlying Float64Array (copy)
+     */
+    toFloat64Array(): Float64Array;
+    /**
+     * Clone the matrix
+     */
+    clone(): DenseMatrix;
+    /**
+     * Convert to sparse matrix (CSR format)
+     *
+     * This is a synchronous conversion that creates a SparseMatrix
+     * containing only the non-zero elements of this matrix.
+     *
+     * @param dropTolerance - Values below this threshold are treated as zero
+     * @returns SparseMatrix representation
+     */
+    toSparse(dropTolerance?: number): SparseMatrix;
+    /**
+     * Iterate over entries with indices
+     */
+    entries(): IterableIterator<MatrixEntry<number>>;
+    /**
+     * Iterate over values (row-major)
+     */
+    values(): IterableIterator<number>;
+    /**
+     * Support for...of iteration (iterates over values)
+     */
+    [Symbol.iterator](): IterableIterator<number>;
+    /**
+     * Apply a function to each element
+     */
+    map(fn: (value: number, row: number, col: number) => number): DenseMatrix;
+    /**
+     * Apply a function to each element (no return, for side effects)
+     */
+    forEach(fn: (value: number, row: number, col: number) => void): void;
+}
+/**
+ * Type guard for DenseMatrix
+ */
+declare function isDenseMatrix(value: unknown): value is DenseMatrix;
+
+/**
+ * Matrix Backend Interface
+ *
+ * Defines the contract for matrix operation backends.
+ * Implementations include JSBackend (pure TypeScript),
+ * WASMBackend (AssemblyScript), and GPUBackend (WebGPU).
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Backend type identifier
+ */
+type BackendType = 'js' | 'wasm' | 'gpu' | 'parallel';
+/**
+ * Backend selection hints
+ */
+interface BackendHints {
+    /** Minimum size to use WASM backend */
+    wasmThreshold?: number;
+    /** Minimum size to use GPU backend */
+    gpuThreshold?: number;
+    /** Force a specific backend */
+    preferredBackend?: BackendType;
+}
+/**
+ * Default backend hints
+ */
+declare const DEFAULT_BACKEND_HINTS: Required<BackendHints>;
+/**
+ * Abstract backend interface for matrix operations
+ *
+ * Each backend implements the same operations but may use different
+ * underlying implementations (pure JS, WASM SIMD, WebGPU compute shaders).
+ */
+interface MatrixBackend {
+    /**
+     * Backend identifier
+     */
+    readonly type: BackendType;
+    /**
+     * Whether the backend is available in the current environment
+     */
+    isAvailable(): boolean;
+    /**
+     * Initialize the backend (may be async for WASM/GPU)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Matrix addition: C = A + B
+     */
+    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Matrix subtraction: C = A - B
+     */
+    subtract(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Element-wise multiplication: C = A .* B
+     */
+    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Element-wise division: C = A ./ B
+     */
+    divideElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Scalar multiplication: C = A * s
+     */
+    scale(a: DenseMatrix, scalar: number): DenseMatrix;
+    /**
+     * Element-wise absolute value
+     */
+    abs(a: DenseMatrix): DenseMatrix;
+    /**
+     * Element-wise negation
+     */
+    negate(a: DenseMatrix): DenseMatrix;
+    /**
+     * Matrix multiplication: C = A * B
+     */
+    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Matrix transpose
+     */
+    transpose(a: DenseMatrix): DenseMatrix;
+    /**
+     * Sum of all elements (may be async for parallel backends)
+     */
+    sum(a: DenseMatrix): number | Promise<number>;
+    /**
+     * Sum along an axis (0 = columns, 1 = rows)
+     */
+    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
+    /**
+     * Frobenius norm
+     */
+    norm(a: DenseMatrix): number;
+    /**
+     * Dot product of two vectors (may be async for parallel backends)
+     */
+    dot(a: DenseMatrix, b: DenseMatrix): number | Promise<number>;
+}
+/**
+ * Registry of available backends
+ */
+declare class BackendRegistry {
+    private backends;
+    private initialized;
+    private hints;
+    /**
+     * Register a backend
+     */
+    register(backend: MatrixBackend): void;
+    /**
+     * Get a backend by type
+     */
+    get(type: BackendType): MatrixBackend | undefined;
+    /**
+     * Check if a backend is registered and available
+     */
+    has(type: BackendType): boolean;
+    /**
+     * Initialize a backend
+     */
+    initialize(type: BackendType): Promise<void>;
+    /**
+     * Get all available backends
+     */
+    available(): BackendType[];
+    /**
+     * Update selection hints
+     */
+    setHints(hints: BackendHints): void;
+    /**
+     * Get current hints
+     */
+    getHints(): Required<BackendHints>;
+    /**
+     * Select the best backend for a given operation size
+     */
+    selectBackend(elementCount: number): MatrixBackend;
+}
+/**
+ * Global backend registry
+ */
+declare const backendRegistry: BackendRegistry;
+
+/**
+ * Pure TypeScript Matrix Backend
+ *
+ * Reference implementation of matrix operations using plain JavaScript.
+ * Serves as baseline for correctness and fallback when WASM/GPU unavailable.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Pure JavaScript matrix backend
+ *
+ * All operations are implemented in TypeScript without external dependencies.
+ * Performance is optimized where possible but prioritizes correctness.
+ */
+declare class JSBackend implements MatrixBackend {
+    readonly type: BackendType;
+    /**
+     * JS backend is always available
+     */
+    isAvailable(): boolean;
+    /**
+     * No initialization needed for JS backend
+     */
+    initialize(): Promise<void>;
+    /**
+     * Matrix addition
+     */
+    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Matrix subtraction
+     */
+    subtract(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Element-wise multiplication
+     */
+    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Element-wise division
+     */
+    divideElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Scalar multiplication
+     */
+    scale(a: DenseMatrix, scalar: number): DenseMatrix;
+    /**
+     * Element-wise absolute value
+     */
+    abs(a: DenseMatrix): DenseMatrix;
+    /**
+     * Element-wise negation
+     */
+    negate(a: DenseMatrix): DenseMatrix;
+    /**
+     * Matrix multiplication using the naive O(n³) algorithm
+     *
+     * For larger matrices, consider using blocked/tiled multiplication
+     * or Strassen's algorithm (implemented in WASM backend).
+     */
+    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Matrix transpose
+     */
+    transpose(a: DenseMatrix): DenseMatrix;
+    /**
+     * Sum of all elements
+     */
+    sum(a: DenseMatrix): number;
+    /**
+     * Sum along an axis
+     * axis=0: sum columns (result is 1×n row vector)
+     * axis=1: sum rows (result is m×1 column vector)
+     */
+    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
+    /**
+     * Frobenius norm: sqrt(sum of squared elements)
+     */
+    norm(a: DenseMatrix): number;
+    /**
+     * Dot product of two vectors
+     *
+     * Works with row vectors (1×n) or column vectors (m×1).
+     */
+    dot(a: DenseMatrix, b: DenseMatrix): number;
+    private checkDimensionsMatch;
+    private checkMultiplyDimensions;
+}
+/**
+ * Default JS backend instance
+ */
+declare const jsBackend: JSBackend;
+
+/**
+ * Configuration for ParallelBackend
+ */
+interface ParallelBackendConfig {
+    /** Custom ComputePool instance (optional) */
+    pool?: ComputePool;
+    /** Pool configuration (if creating new pool) */
+    poolConfig?: Partial<ComputePoolConfig>;
+    /** Threshold for parallel execution (elements) */
+    parallelThreshold?: number;
+}
+/**
+ * Parallel matrix backend using worker pool
+ *
+ * Provides parallel implementations of matrix operations for large matrices.
+ * Uses automatic chunking and result aggregation for efficient parallel execution.
+ *
+ * @example
+ * ```typescript
+ * const backend = new ParallelBackend();
+ * await backend.initialize();
+ *
+ * const result = await backend.multiply(largeMatrixA, largeMatrixB);
+ * ```
+ */
+declare class ParallelBackend {
+    readonly type: BackendType;
+    private pool;
+    private initialized;
+    private parallelThreshold;
+    constructor(config?: ParallelBackendConfig);
+    /**
+     * Check if parallel backend is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Initialize the worker pool
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if initialized
+     */
+    isReady(): boolean;
+    /**
+     * Determine if operation should be parallelized
+     */
+    private shouldParallelize;
+    /**
+     * Parallel matrix addition
+     */
+    add(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
+    /**
+     * Parallel matrix subtraction
+     */
+    subtract(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
+    /**
+     * Parallel element-wise multiplication
+     */
+    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
+    /**
+     * Parallel element-wise division
+     */
+    divideElementwise(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
+    /**
+     * Parallel scalar multiplication
+     */
+    scale(a: DenseMatrix, scalar: number): Promise<DenseMatrix>;
+    /**
+     * Element-wise absolute value (sequential, as it's simple)
+     */
+    abs(a: DenseMatrix): DenseMatrix;
+    /**
+     * Element-wise negation
+     */
+    negate(a: DenseMatrix): DenseMatrix;
+    /**
+     * Parallel matrix multiplication
+     */
+    multiply(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
+    /**
+     * Parallel matrix transpose
+     */
+    transpose(a: DenseMatrix): Promise<DenseMatrix>;
+    /**
+     * Parallel sum of all elements
+     */
+    sum(a: DenseMatrix): Promise<number>;
+    /**
+     * Sum along an axis (sequential)
+     */
+    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
+    /**
+     * Frobenius norm (sequential)
+     */
+    norm(a: DenseMatrix): number;
+    /**
+     * Parallel dot product
+     */
+    dot(a: DenseMatrix, b: DenseMatrix): Promise<number>;
+    /**
+     * Terminate the worker pool
+     */
+    terminate(): Promise<void>;
+    /**
+     * Get pool statistics
+     */
+    getStats(): _danielsimonjr_mathts_parallel.PoolStats;
+    private checkDimensionsMatch;
+    private checkMultiplyDimensions;
+}
+/**
+ * Default parallel backend instance using global compute pool
+ */
+declare const parallelBackend: ParallelBackend;
+/**
+ * Create a new parallel backend with custom configuration
+ */
+declare function createParallelBackend(config?: ParallelBackendConfig): ParallelBackend;
+
+/**
+ * WASM Feature Detection
+ *
+ * Detects available WebAssembly features in the current environment.
+ * Used to enable/disable SIMD, threads, and other optimizations.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Available WASM features
+ */
+interface WasmFeatures {
+    /** Basic WebAssembly support */
+    webAssembly: boolean;
+    /** WASM SIMD (v128) support */
+    simd: boolean;
+    /** SharedArrayBuffer available */
+    sharedMemory: boolean;
+    /** Atomics API available */
+    atomics: boolean;
+    /** WASM threads (requires SharedArrayBuffer) */
+    threads: boolean;
+    /** Bulk memory operations */
+    bulkMemory: boolean;
+    /** Reference types */
+    referenceTypes: boolean;
+    /** WASM exception handling */
+    exceptions: boolean;
+    /** Tail call optimization */
+    tailCall: boolean;
+}
+/**
+ * Detect all WASM features
+ *
+ * @returns Promise resolving to detected features
+ */
+declare function detectWasmFeatures(): Promise<WasmFeatures>;
+/**
+ * Synchronously check if WASM is available (basic check only)
+ */
+declare function isWasmAvailable(): boolean;
+/**
+ * Synchronously check if SharedArrayBuffer is available
+ */
+declare function isSharedMemoryAvailable(): boolean;
+/**
+ * Synchronously check if Atomics are available
+ */
+declare function isAtomicsAvailable(): boolean;
+/**
+ * Clear the feature detection cache (useful for testing)
+ */
+declare function clearFeatureCache(): void;
+/**
+ * Get cached features if available
+ */
+declare function getCachedFeatures(): WasmFeatures | null;
+
+/**
+ * WASM Matrix Backend
+ *
+ * Implements MatrixBackend using WebAssembly for accelerated operations.
+ * Falls back to JSBackend when WASM is unavailable or for small matrices.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * WASM Backend configuration
+ */
+interface WASMBackendConfig {
+    /** Minimum elements to use WASM (default: 100) */
+    minElements?: number;
+    /** Path to WASM file */
+    wasmPath?: string;
+    /** Enable SIMD optimizations when available */
+    useSIMD?: boolean;
+}
+/**
+ * WASM Backend for matrix operations
+ *
+ * Uses WebAssembly for accelerated matrix operations with SIMD support.
+ * Automatically falls back to JavaScript for small matrices or when WASM unavailable.
+ */
+declare class WASMBackend implements MatrixBackend {
+    readonly type: BackendType;
+    private config;
+    private wasmModule;
+    private features;
+    private initPromise;
+    constructor(config?: WASMBackendConfig);
+    /**
+     * Check if WASM is available in the current environment
+     */
+    isAvailable(): boolean;
+    /**
+     * Initialize the WASM backend
+     */
+    initialize(): Promise<void>;
+    private doInitialize;
+    /**
+     * Check if operation should use WASM
+     */
+    private shouldUseWasm;
+    /**
+     * Get detected WASM features
+     */
+    getFeatures(): WasmFeatures | null;
+    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    subtract(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    divideElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    scale(a: DenseMatrix, scalar: number): DenseMatrix;
+    abs(a: DenseMatrix): DenseMatrix;
+    negate(a: DenseMatrix): DenseMatrix;
+    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    transpose(a: DenseMatrix): DenseMatrix;
+    sum(a: DenseMatrix): number;
+    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
+    norm(a: DenseMatrix): number;
+    dot(a: DenseMatrix, b: DenseMatrix): number;
+    /**
+     * LU Decomposition using WASM
+     */
+    luDecomposition(a: DenseMatrix): Promise<{
+        lu: DenseMatrix;
+        perm: Int32Array;
+        singular: boolean;
+    }>;
+    private luDecompositionJS;
+    /**
+     * QR Decomposition using WASM
+     */
+    qrDecomposition(a: DenseMatrix): Promise<{
+        q: DenseMatrix;
+        r: DenseMatrix;
+    }>;
+    private qrDecompositionJS;
+    /**
+     * Matrix inversion using LU decomposition
+     */
+    inverse(a: DenseMatrix): Promise<{
+        inverse: DenseMatrix;
+        singular: boolean;
+    }>;
+    private inverseJS;
+    /**
+     * Compute matrix determinant using LU decomposition
+     */
+    determinantWasm(a: DenseMatrix): Promise<number>;
+    private determinantJS;
+    /**
+     * Cholesky Decomposition using WASM
+     * For symmetric positive-definite matrices: A = L * L^T
+     */
+    choleskyDecomposition(a: DenseMatrix): Promise<{
+        l: DenseMatrix;
+        positiveDefinite: boolean;
+    }>;
+    private choleskyDecompositionJS;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<WASMBackendConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Required<WASMBackendConfig>;
+}
+/**
+ * Global WASM backend instance
+ */
+declare const wasmBackend: WASMBackend;
+/**
+ * Create a WASM backend with custom configuration
+ */
+declare function createWASMBackend(config?: WASMBackendConfig): WASMBackend;
+
+/**
+ * WebGPU Detection and Capability Checking
+ *
+ * Provides runtime detection of WebGPU support and adapter capabilities.
+ */
+/**
+ * WebGPU adapter information
+ */
+interface GPUAdapterInfo {
+    /** Adapter vendor */
+    vendor: string;
+    /** Adapter architecture */
+    architecture: string;
+    /** Device description */
+    device: string;
+    /** Driver description */
+    description: string;
+}
+/**
+ * WebGPU capability information
+ */
+interface GPUCapabilities {
+    /** Whether WebGPU is supported */
+    supported: boolean;
+    /** Adapter information if available */
+    adapterInfo: GPUAdapterInfo | null;
+    /** Maximum buffer size in bytes */
+    maxBufferSize: number;
+    /** Maximum compute workgroup size */
+    maxWorkgroupSize: [number, number, number];
+    /** Maximum storage buffer binding size */
+    maxStorageBufferBindingSize: number;
+    /** Maximum compute invocations per workgroup */
+    maxComputeInvocationsPerWorkgroup: number;
+    /** Maximum workgroups per dimension */
+    maxComputeWorkgroupsPerDimension: number;
+    /** Whether the adapter is a fallback/software adapter */
+    isFallbackAdapter: boolean;
+    /** Supported features */
+    features: string[];
+}
+/**
+ * Check if WebGPU is available in the current environment
+ */
+declare function hasWebGPU(): boolean;
+/**
+ * Detect WebGPU capabilities
+ * @param preferHighPerformance - Whether to prefer high-performance GPU
+ */
+declare function detectGPUCapabilities(preferHighPerformance?: boolean): Promise<GPUCapabilities>;
+/**
+ * Recommended workgroup size based on GPU capabilities
+ */
+declare function getRecommendedWorkgroupSize(capabilities: GPUCapabilities): [number, number, number];
+
+/**
+ * WebGPU Context Management
+ *
+ * Manages WebGPU device, queue, and command encoding.
+ */
+
+/**
+ * Options for GPUContext initialization
+ */
+interface GPUContextOptions {
+    /** Prefer high-performance GPU */
+    preferHighPerformance?: boolean;
+    /** Required features for the device */
+    requiredFeatures?: GPUFeatureName[];
+    /** Required limits for the device */
+    requiredLimits?: Record<string, number>;
+    /** Label for debugging */
+    label?: string;
+}
+/**
+ * Status of the GPU context
+ */
+type GPUContextStatus = 'uninitialized' | 'initializing' | 'ready' | 'error' | 'lost';
+/**
+ * Event emitted when device is lost
+ */
+interface DeviceLostEvent {
+    reason: GPUDeviceLostReason;
+    message: string;
+}
+/**
+ * GPU Context manages the lifecycle of WebGPU resources
+ */
+declare class GPUContext {
+    private adapter;
+    private device;
+    private _status;
+    private _capabilities;
+    private _lastError;
+    private deviceLostCallbacks;
+    private label;
+    constructor(options?: GPUContextOptions);
+    /**
+     * Get the current status
+     */
+    get status(): GPUContextStatus;
+    /**
+     * Check if context is ready
+     */
+    get isReady(): boolean;
+    /**
+     * Get the GPU device (throws if not initialized)
+     */
+    getDevice(): GPUDevice;
+    /**
+     * Get the GPU queue
+     */
+    getQueue(): GPUQueue;
+    /**
+     * Get capabilities
+     */
+    get capabilities(): GPUCapabilities | null;
+    /**
+     * Get last error
+     */
+    get lastError(): Error | null;
+    /**
+     * Initialize the GPU context
+     */
+    initialize(options?: GPUContextOptions): Promise<boolean>;
+    /**
+     * Register callback for device lost event
+     */
+    onDeviceLost(callback: (event: DeviceLostEvent) => void): void;
+    /**
+     * Create a command encoder
+     */
+    createCommandEncoder(label?: string): GPUCommandEncoder;
+    /**
+     * Create a buffer
+     */
+    createBuffer(size: number, usage: GPUBufferUsageFlags, label?: string, mappedAtCreation?: boolean): GPUBuffer;
+    /**
+     * Create a storage buffer for compute operations
+     */
+    createStorageBuffer(size: number, label?: string, readable?: boolean, writable?: boolean): GPUBuffer;
+    /**
+     * Create a staging buffer for reading back data
+     */
+    createStagingBuffer(size: number, label?: string): GPUBuffer;
+    /**
+     * Create a compute pipeline
+     */
+    createComputePipeline(shaderModule: GPUShaderModule, entryPoint: string, layout?: GPUPipelineLayout | 'auto', label?: string): GPUComputePipeline;
+    /**
+     * Create a shader module from WGSL source
+     */
+    createShaderModule(code: string, label?: string): GPUShaderModule;
+    /**
+     * Create a bind group
+     */
+    createBindGroup(layout: GPUBindGroupLayout, entries: GPUBindGroupEntry[], label?: string): GPUBindGroup;
+    /**
+     * Submit commands to the GPU queue
+     */
+    submitCommands(commandBuffers: GPUCommandBuffer[]): void;
+    /**
+     * Write data to a buffer
+     */
+    writeBuffer(buffer: GPUBuffer, data: ArrayBufferView | ArrayBuffer | SharedArrayBuffer, bufferOffset?: number, dataOffset?: number, size?: number): void;
+    /**
+     * Read data from a buffer (async)
+     */
+    readBuffer(buffer: GPUBuffer, offset?: number, size?: number): Promise<ArrayBuffer>;
+    /**
+     * Dispatch a compute shader
+     */
+    dispatchCompute(pipeline: GPUComputePipeline, bindGroups: GPUBindGroup[], workgroupCounts: [number, number, number]): void;
+    /**
+     * Wait for all GPU operations to complete
+     */
+    waitForCompletion(): Promise<void>;
+    /**
+     * Destroy the context and release resources
+     */
+    destroy(): void;
+}
+/**
+ * Get the global GPU context
+ */
+declare function getGlobalGPUContext(): GPUContext;
+/**
+ * Destroy the global GPU context
+ */
+declare function destroyGlobalGPU(): void;
+
+/**
+ * GPU Buffer Pool
+ *
+ * Manages GPU buffer allocation, deallocation, and reuse.
+ * Reduces allocation overhead by recycling buffers.
+ */
+
+/**
+ * Options for buffer pool
+ */
+interface BufferPoolOptions {
+    /** Maximum total memory to cache (bytes) */
+    maxCacheSize?: number;
+    /** Time after which unused buffers are evicted (ms) */
+    evictionTimeout?: number;
+    /** Whether to enable automatic eviction */
+    autoEvict?: boolean;
+    /** Interval for automatic eviction (ms) */
+    evictionInterval?: number;
+}
+/**
+ * GPU Buffer Pool for efficient buffer management
+ */
+declare class BufferPool {
+    private context;
+    private buffers;
+    private maxCacheSize;
+    private evictionTimeout;
+    private evictionTimer;
+    private currentCacheSize;
+    constructor(context: GPUContext, options?: BufferPoolOptions);
+    /**
+     * Generate a key for buffer categorization
+     */
+    private getBufferKey;
+    /**
+     * Round up to nearest power of 2
+     */
+    private roundUpToPowerOf2;
+    /**
+     * Acquire a buffer from the pool or create a new one
+     */
+    acquire(size: number, usage: GPUBufferUsageFlags, label?: string): GPUBuffer;
+    /**
+     * Release a buffer back to the pool
+     */
+    release(buffer: GPUBuffer): void;
+    /**
+     * Create a storage buffer from the pool
+     */
+    acquireStorageBuffer(size: number, label?: string, readable?: boolean, writable?: boolean): GPUBuffer;
+    /**
+     * Create a staging buffer from the pool
+     */
+    acquireStagingBuffer(size: number, label?: string): GPUBuffer;
+    /**
+     * Create a uniform buffer from the pool
+     */
+    acquireUniformBuffer(size: number, label?: string): GPUBuffer;
+    /**
+     * Evict old unused buffers
+     */
+    evictOldBuffers(): void;
+    /**
+     * Force eviction to reduce cache to target size
+     */
+    evictToSize(targetSize: number): void;
+    /**
+     * Start automatic eviction timer
+     */
+    startAutoEviction(interval: number): void;
+    /**
+     * Stop automatic eviction timer
+     */
+    stopAutoEviction(): void;
+    /**
+     * Get pool statistics
+     */
+    getStats(): {
+        totalBuffers: number;
+        inUseBuffers: number;
+        cachedBuffers: number;
+        currentCacheSize: number;
+        maxCacheSize: number;
+    };
+    /**
+     * Clear all buffers and reset pool
+     */
+    clear(): void;
+    /**
+     * Destroy the pool
+     */
+    destroy(): void;
+}
+
+/**
+ * GPU Shader Manager
+ *
+ * Manages WGSL shader loading, compilation, and caching.
+ */
+
+/**
+ * Built-in shader library
+ */
+declare const BUILTIN_SHADERS: {
+    /** Matrix addition shader */
+    matrixAdd: string;
+    /** Matrix subtraction shader */
+    matrixSub: string;
+    /** Element-wise multiplication shader */
+    matrixMul: string;
+    /** Scalar multiplication shader */
+    scalarMul: string;
+    /** Matrix multiplication (naive) shader */
+    matmul: string;
+    /** Matrix transpose shader */
+    transpose: string;
+    /** Sum reduction shader (first pass) */
+    sumReduce: string;
+};
+/**
+ * Shader Manager for compiling and caching GPU shaders
+ */
+declare class ShaderManager {
+    private context;
+    private cache;
+    constructor(context: GPUContext);
+    /**
+     * Get or compile a shader module
+     */
+    getShaderModule(name: string, code: string): GPUShaderModule;
+    /**
+     * Get a builtin shader module
+     */
+    getBuiltinShader(name: keyof typeof BUILTIN_SHADERS): GPUShaderModule;
+    /**
+     * Get or create a compute pipeline
+     */
+    getPipeline(shaderName: string, entryPoint: string, code?: string, layout?: GPUPipelineLayout | 'auto'): GPUComputePipeline;
+    /**
+     * Get a builtin compute pipeline
+     */
+    getBuiltinPipeline(name: keyof typeof BUILTIN_SHADERS, entryPoint?: string): GPUComputePipeline;
+    /**
+     * Precompile all builtin shaders
+     */
+    precompileBuiltins(): void;
+    /**
+     * Clear shader cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        cachedShaders: number;
+        cachedPipelines: number;
+    };
+}
+
+/**
+ * GPU Batch Executor
+ *
+ * Manages batched GPU command submission for reduced overhead.
+ * Queues multiple operations and executes them together for efficiency.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Result of batch execution
+ */
+interface BatchResult {
+    /** Success status */
+    success: boolean;
+    /** Number of operations executed */
+    operationCount: number;
+    /** Execution time in milliseconds */
+    duration: number;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Options for batch execution
+ */
+interface BatchOptions {
+    /** Maximum operations per batch before auto-flush */
+    maxBatchSize?: number;
+    /** Auto-flush when batch is full */
+    autoFlush?: boolean;
+    /** Wait for GPU completion before returning */
+    waitForCompletion?: boolean;
+}
+/**
+ * GPU Batch Executor
+ *
+ * Accumulates GPU operations and executes them in batches to reduce
+ * command submission overhead. Uses command buffers efficiently.
+ *
+ * @example
+ * ```typescript
+ * const executor = new BatchExecutor(context, shaders, bufferPool);
+ *
+ * executor.add(a, b, output, { rows: 100, cols: 100 });
+ * executor.matmul(a, b, output, { rows: 100, cols: 100, k: 100 });
+ *
+ * await executor.flush();
+ * ```
+ */
+declare class BatchExecutor {
+    private context;
+    private shaders;
+    private bufferPool;
+    private operations;
+    private options;
+    /**
+     * Create a new batch executor
+     */
+    constructor(context: GPUContext, shaders: ShaderManager, bufferPool: BufferPool, options?: BatchOptions);
+    /**
+     * Get current batch size
+     */
+    get size(): number;
+    /**
+     * Check if batch is empty
+     */
+    get isEmpty(): boolean;
+    /**
+     * Check if batch is full
+     */
+    get isFull(): boolean;
+    /**
+     * Queue an add operation
+     */
+    add(inputA: GPUBuffer, inputB: GPUBuffer, output: GPUBuffer, dimensions: {
+        rows: number;
+        cols: number;
+    }): void;
+    /**
+     * Queue a subtract operation
+     */
+    subtract(inputA: GPUBuffer, inputB: GPUBuffer, output: GPUBuffer, dimensions: {
+        rows: number;
+        cols: number;
+    }): void;
+    /**
+     * Queue an element-wise multiply operation
+     */
+    multiply(inputA: GPUBuffer, inputB: GPUBuffer, output: GPUBuffer, dimensions: {
+        rows: number;
+        cols: number;
+    }): void;
+    /**
+     * Queue a scale operation
+     */
+    scale(input: GPUBuffer, output: GPUBuffer, scalar: number, dimensions: {
+        rows: number;
+        cols: number;
+    }): void;
+    /**
+     * Queue a matrix multiplication operation
+     */
+    matmul(inputA: GPUBuffer, inputB: GPUBuffer, output: GPUBuffer, dimensions: {
+        rows: number;
+        cols: number;
+        k: number;
+    }): void;
+    /**
+     * Queue a transpose operation
+     */
+    transpose(input: GPUBuffer, output: GPUBuffer, dimensions: {
+        rows: number;
+        cols: number;
+    }): void;
+    /**
+     * Queue a sum reduction operation
+     */
+    reduceSum(input: GPUBuffer, output: GPUBuffer, dimensions: {
+        rows: number;
+        cols: number;
+    }): void;
+    /**
+     * Queue operation (internal)
+     */
+    private queueOperation;
+    /**
+     * Flush all queued operations (async)
+     */
+    flush(): Promise<BatchResult>;
+    /**
+     * Flush synchronously (fire and forget)
+     */
+    flushSync(): void;
+    /**
+     * Encode a single operation into the command encoder
+     */
+    private encodeOperation;
+    /**
+     * Get pipeline name for operation type
+     */
+    private getPipelineName;
+    /**
+     * Create params buffer for operation
+     */
+    private createParamsBuffer;
+    /**
+     * Calculate workgroup dispatch counts
+     */
+    private calculateWorkgroups;
+    /**
+     * Clear all queued operations without executing
+     */
+    clear(): void;
+    /**
+     * Get statistics about the batch executor
+     */
+    getStats(): {
+        queuedOperations: number;
+        maxBatchSize: number;
+        autoFlush: boolean;
+    };
+}
+
+/**
+ * GPU-CPU Synchronization Strategy
+ *
+ * Implements efficient patterns for synchronizing data between
+ * CPU and GPU memory. Minimizes transfer latency and enables
+ * overlapping of CPU and GPU work.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Synchronization strategy type
+ */
+type SyncStrategy = 'immediate' | 'lazy' | 'double-buffer' | 'streaming';
+/**
+ * Transfer direction
+ */
+type TransferDirection = 'cpu-to-gpu' | 'gpu-to-cpu';
+/**
+ * Transfer result
+ */
+interface TransferResult {
+    /** Request ID */
+    id: number;
+    /** Success status */
+    success: boolean;
+    /** Transfer time in milliseconds */
+    duration: number;
+    /** Bytes transferred */
+    bytesTransferred: number;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Sync configuration
+ */
+interface SyncConfig {
+    /** Default strategy */
+    strategy: SyncStrategy;
+    /** Chunk size for streaming (bytes) */
+    chunkSize?: number;
+    /** Maximum pending transfers */
+    maxPendingTransfers?: number;
+    /** Auto-coalesce nearby transfers */
+    coalesceTransfers?: boolean;
+}
+/**
+ * GPU-CPU Synchronization Manager
+ *
+ * Manages data transfer between CPU and GPU with various strategies
+ * optimized for different use cases.
+ *
+ * @example
+ * ```typescript
+ * const sync = new SyncManager(context, bufferPool, {
+ *   strategy: 'double-buffer',
+ * });
+ *
+ * // Upload data to GPU
+ * await sync.upload(cpuData, gpuBuffer);
+ *
+ * // Download results from GPU
+ * const result = await sync.download(gpuBuffer);
+ * ```
+ */
+declare class SyncManager {
+    private context;
+    private config;
+    private pendingTransfers;
+    private nextRequestId;
+    private stagingBuffers;
+    private totalUploads;
+    private totalDownloads;
+    private totalBytesUploaded;
+    private totalBytesDownloaded;
+    constructor(context: GPUContext, _bufferPool: BufferPool, // Reserved for future pool integration
+    config?: Partial<SyncConfig>);
+    /**
+     * Upload data from CPU to GPU
+     */
+    upload(cpuData: Float32Array | Float64Array | Uint32Array | Int32Array, gpuBuffer: GPUBuffer, options?: {
+        offset?: number;
+        size?: number;
+    }): Promise<TransferResult>;
+    /**
+     * Download data from GPU to CPU
+     */
+    download(gpuBuffer: GPUBuffer, options?: {
+        offset?: number;
+        size?: number;
+    }): Promise<Float32Array>;
+    /**
+     * Download data using double-buffering for overlap
+     */
+    downloadDoubleBuffered(gpuBuffer: GPUBuffer, size: number): Promise<Float32Array>;
+    /**
+     * Stream large data in chunks
+     */
+    uploadStreaming(cpuData: Float32Array, gpuBuffer: GPUBuffer, onProgress?: (progress: number) => void): Promise<TransferResult>;
+    /**
+     * Download large data in chunks
+     */
+    downloadStreaming(gpuBuffer: GPUBuffer, totalSize: number, onProgress?: (progress: number) => void): Promise<Float32Array>;
+    /**
+     * Batch multiple transfers
+     */
+    batchTransfer(requests: Array<{
+        data: Float32Array;
+        buffer: GPUBuffer;
+        direction: TransferDirection;
+    }>): Promise<TransferResult[]>;
+    /**
+     * Create or reuse a staging buffer
+     */
+    private getOrCreateStagingBuffer;
+    /**
+     * Round up to next power of 2
+     */
+    private roundToPowerOf2;
+    /**
+     * Wait for all pending transfers to complete
+     */
+    flush(): Promise<void>;
+    /**
+     * Get synchronization statistics
+     */
+    getStats(): {
+        totalUploads: number;
+        totalDownloads: number;
+        totalBytesUploaded: number;
+        totalBytesDownloaded: number;
+        pendingTransfers: number;
+        stagingBuffersCount: number;
+        strategy: SyncStrategy;
+    };
+    /**
+     * Destroy sync manager and release resources
+     */
+    destroy(): void;
+}
+/**
+ * Create a sync manager with the recommended configuration
+ */
+declare function createSyncManager(context: GPUContext, bufferPool: BufferPool, strategy?: SyncStrategy): SyncManager;
+
+/**
+ * GPU Backend for Matrix Operations
+ *
+ * WebGPU-accelerated matrix operations for large matrices.
+ */
+
+/**
+ * GPU Backend status
+ */
+type GPUBackendStatus = 'uninitialized' | 'initializing' | 'ready' | 'error' | 'unsupported';
+/**
+ * Options for GPU backend
+ */
+interface GPUBackendOptions extends GPUContextOptions {
+    /** Use global GPU context instead of creating a new one */
+    useGlobalContext?: boolean;
+    /** Buffer pool options */
+    bufferPoolOptions?: {
+        maxCacheSize?: number;
+        evictionTimeout?: number;
+    };
+    /** Threshold for using GPU (matrix size) */
+    threshold?: number;
+}
+/**
+ * GPU Backend for accelerated matrix operations
+ */
+declare class GPUBackend {
+    private context;
+    private bufferPool;
+    private shaderManager;
+    private _status;
+    private _capabilities;
+    private _lastError;
+    private threshold;
+    private workgroupSize;
+    private useGlobalContext;
+    constructor(options?: GPUBackendOptions);
+    /**
+     * Get the current status
+     */
+    get status(): GPUBackendStatus;
+    /**
+     * Check if backend is ready
+     */
+    get isReady(): boolean;
+    /**
+     * Get capabilities
+     */
+    get capabilities(): GPUCapabilities | null;
+    /**
+     * Get last error
+     */
+    get lastError(): Error | null;
+    /**
+     * Initialize the GPU backend
+     */
+    initialize(options?: GPUBackendOptions): Promise<boolean>;
+    /**
+     * Check if GPU should be used for the given matrix size
+     */
+    shouldUseGPU(rows: number, cols: number): boolean;
+    /**
+     * Calculate workgroup counts for a matrix
+     */
+    calculateWorkgroups(rows: number, cols: number): [number, number, number];
+    /**
+     * Get the GPU context
+     */
+    getContext(): GPUContext;
+    /**
+     * Get the buffer pool
+     */
+    getBufferPool(): BufferPool;
+    /**
+     * Get the shader manager
+     */
+    getShaderManager(): ShaderManager;
+    /**
+     * Add two matrices element-wise
+     */
+    add(a: Float32Array, b: Float32Array, rows: number, cols: number): Promise<Float32Array>;
+    /**
+     * Multiply two matrices
+     */
+    matmul(a: Float32Array, b: Float32Array, M: number, K: number, N: number): Promise<Float32Array>;
+    /**
+     * Transpose a matrix
+     */
+    transpose(a: Float32Array, rows: number, cols: number): Promise<Float32Array>;
+    /**
+     * Scale a matrix by a scalar
+     */
+    scale(a: Float32Array, scalar: number): Promise<Float32Array>;
+    /**
+     * Get backend statistics
+     */
+    getStats(): {
+        status: GPUBackendStatus;
+        capabilities: GPUCapabilities | null;
+        bufferPool: {
+            totalBuffers: number;
+            inUseBuffers: number;
+            cachedBuffers: number;
+        } | null;
+        shaders: {
+            cachedShaders: number;
+            cachedPipelines: number;
+        } | null;
+    };
+    /**
+     * Destroy the backend
+     */
+    destroy(): void;
+}
+/**
+ * Get the global GPU backend
+ */
+declare function getGlobalGPUBackend(): GPUBackend;
+/**
+ * Initialize the global GPU backend
+ */
+declare function initializeGlobalGPUBackend(options?: GPUBackendOptions): Promise<boolean>;
+/**
+ * Destroy the global GPU backend
+ */
+declare function destroyGlobalGPUBackend(): void;
+
+/**
+ * GPU Matrix Backend Adapter
+ *
+ * Adapts GPUBackend to implement the MatrixBackend interface,
+ * enabling seamless integration with the backend selection system.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Configuration for GPU Matrix Backend
+ */
+interface GPUMatrixBackendConfig {
+    /** Minimum elements to use GPU (default: 65536 = 256x256) */
+    minElements?: number;
+    /** Use global GPU backend instance */
+    useGlobalBackend?: boolean;
+    /** GPU backend options */
+    gpuOptions?: GPUBackendOptions;
+    /** Fall back to JS on GPU errors */
+    fallbackOnError?: boolean;
+}
+/**
+ * GPU Matrix Backend
+ *
+ * Implements MatrixBackend interface using WebGPU compute shaders.
+ * Provides significant acceleration for large matrices.
+ *
+ * @example
+ * ```typescript
+ * const gpu = new GPUMatrixBackend();
+ * await gpu.initialize();
+ *
+ * const result = gpu.multiply(matrixA, matrixB);
+ * ```
+ */
+declare class GPUMatrixBackend implements MatrixBackend {
+    readonly type: BackendType;
+    private config;
+    private backend;
+    private capabilities;
+    private initPromise;
+    private _available;
+    constructor(config?: GPUMatrixBackendConfig);
+    /**
+     * Check if GPU is available in the current environment
+     */
+    isAvailable(): boolean;
+    /**
+     * Initialize the GPU backend
+     */
+    initialize(): Promise<void>;
+    private doInitialize;
+    /**
+     * Check if operation should use GPU
+     */
+    private shouldUseGPU;
+    /**
+     * Execute GPU operation with fallback
+     */
+    private executeWithFallback;
+    /**
+     * Get GPU capabilities
+     */
+    getCapabilities(): GPUCapabilities | null;
+    /**
+     * Get backend statistics
+     */
+    getStats(): ReturnType<GPUBackend['getStats']> | null;
+    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Async add operation using GPU
+     */
+    addAsync(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
+    subtract(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    divideElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    scale(a: DenseMatrix, scalar: number): DenseMatrix;
+    /**
+     * Async scale operation using GPU
+     */
+    scaleAsync(a: DenseMatrix, scalar: number): Promise<DenseMatrix>;
+    abs(a: DenseMatrix): DenseMatrix;
+    negate(a: DenseMatrix): DenseMatrix;
+    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Async matrix multiplication using GPU
+     */
+    multiplyAsync(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
+    transpose(a: DenseMatrix): DenseMatrix;
+    /**
+     * Async transpose using GPU
+     */
+    transposeAsync(a: DenseMatrix): Promise<DenseMatrix>;
+    sum(a: DenseMatrix): number;
+    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
+    norm(a: DenseMatrix): number;
+    dot(a: DenseMatrix, b: DenseMatrix): number;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<GPUMatrixBackendConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Required<GPUMatrixBackendConfig>;
+    /**
+     * Destroy the backend
+     */
+    destroy(): void;
+}
+/**
+ * Global GPU matrix backend instance
+ */
+declare const gpuMatrixBackend: GPUMatrixBackend;
+/**
+ * Create a GPU matrix backend with custom configuration
+ */
+declare function createGPUMatrixBackend(config?: GPUMatrixBackendConfig): GPUMatrixBackend;
+
+/**
+ * Backend Manager
+ *
+ * Centralized management for matrix operation backends with automatic
+ * selection based on matrix size, operation type, and availability.
+ * Includes adaptive threshold tuning based on runtime profiling.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Operation type hints for backend selection
+ */
+type OperationType = 'add' | 'subtract' | 'multiply' | 'multiplyElementwise' | 'transpose' | 'scale' | 'decomposition' | 'solve';
+/**
+ * Extended backend hints with operation-specific thresholds
+ */
+interface ExtendedBackendHints extends BackendHints {
+    /** Specific thresholds by operation type */
+    operationThresholds?: Partial<Record<OperationType, {
+        wasm?: number;
+        gpu?: number;
+    }>>;
+    /** Enable automatic SIMD detection for WASM */
+    autoSIMD?: boolean;
+    /** Fallback to JS on backend failure */
+    fallbackOnError?: boolean;
+}
+/**
+ * Default extended hints
+ */
+declare const DEFAULT_EXTENDED_HINTS: Required<ExtendedBackendHints>;
+/**
+ * Centralized Backend Manager
+ *
+ * Provides a unified interface for executing matrix operations with
+ * automatic backend selection based on matrix size and operation type.
+ * Features adaptive threshold tuning based on runtime profiling.
+ */
+declare class BackendManager {
+    private hints;
+    private initialized;
+    private initializationPromise;
+    private adaptiveState;
+    private configUnsubscribe;
+    constructor(hints?: ExtendedBackendHints);
+    /**
+     * Sync manager state with global config
+     */
+    private syncWithConfig;
+    /**
+     * Initialize all available backends
+     */
+    initialize(): Promise<void>;
+    private doInitialize;
+    /**
+     * Update backend hints
+     */
+    setHints(hints: ExtendedBackendHints): void;
+    /**
+     * Get current hints
+     */
+    getHints(): Required<ExtendedBackendHints>;
+    /**
+     * Get the best backend for a given operation and matrix size
+     */
+    selectBackend(elementCount: number, operation?: OperationType): MatrixBackend;
+    /**
+     * Execute an operation with automatic backend selection
+     */
+    private executeWithFallback;
+    /**
+     * Matrix addition with auto backend selection
+     */
+    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Matrix subtraction with auto backend selection
+     */
+    subtract(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Element-wise multiplication with auto backend selection
+     */
+    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Element-wise division with auto backend selection
+     */
+    divideElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Scalar multiplication with auto backend selection
+     */
+    scale(a: DenseMatrix, scalar: number): DenseMatrix;
+    /**
+     * Element-wise absolute value with auto backend selection
+     */
+    abs(a: DenseMatrix): DenseMatrix;
+    /**
+     * Element-wise negation with auto backend selection
+     */
+    negate(a: DenseMatrix): DenseMatrix;
+    /**
+     * Matrix multiplication with auto backend selection
+     */
+    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
+    /**
+     * Matrix transpose with auto backend selection
+     */
+    transpose(a: DenseMatrix): DenseMatrix;
+    /**
+     * Sum of all elements with auto backend selection
+     */
+    sum(a: DenseMatrix): Promise<number>;
+    /**
+     * Sum along axis with auto backend selection
+     */
+    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
+    /**
+     * Frobenius norm with auto backend selection
+     */
+    norm(a: DenseMatrix): number;
+    /**
+     * Dot product with auto backend selection
+     */
+    dot(a: DenseMatrix, b: DenseMatrix): Promise<number>;
+    /**
+     * Get list of available backends
+     */
+    getAvailableBackends(): BackendType[];
+    /**
+     * Check if a specific backend is available
+     */
+    hasBackend(type: BackendType): boolean;
+    /**
+     * Get current active backend for a given operation size
+     */
+    getActiveBackend(elementCount: number, operation?: OperationType): BackendType;
+    /**
+     * Force a specific backend for all operations
+     */
+    forceBackend(type: BackendType | null): void;
+    /**
+     * Record a performance sample for adaptive tuning
+     */
+    recordSample(operation: OperationType, elementCount: number, backend: BackendType, durationMs: number): void;
+    /**
+     * Adjust thresholds based on collected samples
+     */
+    private maybeAdjustThresholds;
+    /**
+     * Get current adaptive thresholds
+     */
+    getAdaptiveThresholds(): Map<OperationType, {
+        wasm: number;
+        gpu: number;
+    }>;
+    /**
+     * Reset adaptive tuning state
+     */
+    resetAdaptiveState(): void;
+    /**
+     * Get performance statistics
+     */
+    getPerformanceStats(): {
+        sampleCount: number;
+        operationStats: Map<OperationType, {
+            avgDuration: number;
+            samples: number;
+            backendUsage: Record<BackendType, number>;
+        }>;
+    };
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}
+/**
+ * Default backend manager instance
+ */
+declare const backendManager: BackendManager;
+/**
+ * Create a new backend manager with custom hints
+ */
+declare function createBackendManager(hints?: ExtendedBackendHints): BackendManager;
+
+/**
+ * Eigenvalue and Eigenvector Decomposition
+ *
+ * Implements eigenvalue computation using QR algorithm and
+ * eigenvector extraction using inverse iteration.
+ */
+/**
+ * Result of eigenvalue decomposition
+ */
+interface EigResult {
+    /** Eigenvalues (may be complex for non-symmetric matrices) */
+    values: Array<{
+        re: number;
+        im: number;
+    }>;
+    /** Eigenvectors as columns (each column is an eigenvector) */
+    vectors: number[][];
+    /** Whether the matrix was symmetric */
+    isSymmetric: boolean;
+}
+/**
+ * Options for eigenvalue computation
+ */
+interface EigOptions {
+    /** Maximum number of QR iterations */
+    maxIterations?: number;
+    /** Convergence tolerance */
+    tolerance?: number;
+    /** Whether to compute eigenvectors */
+    computeVectors?: boolean;
+}
+/**
+ * Compute eigenvalues and eigenvectors of a square matrix
+ * Uses QR algorithm with implicit shifts
+ *
+ * @param matrix - Square matrix (n x n)
+ * @param options - Computation options
+ * @returns Eigenvalues and eigenvectors
+ */
+declare function eig(matrix: number[][] | Float64Array, options?: EigOptions): EigResult;
+/**
+ * Compute only eigenvalues (faster, no eigenvector computation)
+ */
+declare function eigvals(matrix: number[][] | Float64Array, options?: Omit<EigOptions, 'computeVectors'>): Array<{
+    re: number;
+    im: number;
+}>;
+/**
+ * Power iteration for dominant eigenvalue
+ * Faster than full eigendecomposition when only largest eigenvalue needed
+ */
+declare function powerIteration(matrix: number[][], options?: {
+    maxIterations?: number;
+    tolerance?: number;
+}): {
+    value: number;
+    vector: number[];
+};
+
+/**
+ * Singular Value Decomposition (SVD)
+ *
+ * Implements SVD using Golub-Reinsch bidiagonalization and implicit QR.
+ * A = U * S * V^T where:
+ *   - U: m x m orthogonal matrix (left singular vectors)
+ *   - S: m x n diagonal matrix (singular values)
+ *   - V: n x n orthogonal matrix (right singular vectors)
+ */
+/**
+ * Result of SVD decomposition
+ */
+interface SVDResult {
+    /** Left singular vectors (m x m) */
+    U: number[][];
+    /** Singular values (min(m,n) values) */
+    S: number[];
+    /** Right singular vectors (n x n) */
+    V: number[][];
+    /** Rank estimate */
+    rank: number;
+}
+/**
+ * Options for SVD computation
+ */
+interface SVDOptions {
+    /** Maximum number of iterations */
+    maxIterations?: number;
+    /** Convergence tolerance */
+    tolerance?: number;
+    /** Whether to compute full U and V matrices */
+    fullMatrices?: boolean;
+    /** Threshold for rank determination */
+    rankTolerance?: number;
+}
+/**
+ * Compute SVD of a matrix
+ *
+ * @param matrix - Input matrix (m x n)
+ * @param options - Computation options
+ * @returns SVD decomposition
+ */
+declare function svd(matrix: number[][] | Float64Array, options?: SVDOptions): SVDResult;
+/**
+ * Compute only singular values (faster than full SVD)
+ */
+declare function singularValues(matrix: number[][] | Float64Array, options?: Omit<SVDOptions, 'fullMatrices'>): number[];
+/**
+ * Compute the pseudoinverse (Moore-Penrose inverse) using SVD
+ */
+declare function pinv(matrix: number[][], options?: SVDOptions): number[][];
+/**
+ * Low-rank approximation using SVD
+ * Keeps only the top r singular values
+ */
+declare function lowRankApprox(matrix: number[][], r: number, options?: SVDOptions): number[][];
+/**
+ * Compute condition number using SVD
+ */
+declare function cond(matrix: number[][], options?: SVDOptions): number;
+/**
+ * Compute matrix norm using SVD
+ * Returns the spectral norm (largest singular value)
+ */
+declare function norm2(matrix: number[][], options?: SVDOptions): number;
+/**
+ * Compute Frobenius norm using SVD
+ * Equals sqrt(sum of squared singular values)
+ */
+declare function normFro(matrix: number[][]): number;
+
+/**
+ * WASM-accelerated Eigendecomposition
+ *
+ * Provides eigenvalue/eigenvector computation with optional WASM acceleration
+ * via the Rust-compiled Jacobi eigenvalue algorithm. Falls back to the pure
+ * JavaScript QR-based implementation when WASM is unavailable.
+ *
+ * WASM acceleration path:
+ *   - Symmetric matrices: Jacobi eigenvalue algorithm (Rust WASM)
+ *   - Non-symmetric matrices: falls back to JS QR algorithm
+ *
+ * JS fallback path:
+ *   - Full QR algorithm with implicit shifts (eig.ts)
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * WASM-accelerated eigendecomposition for symmetric matrices.
+ *
+ * Uses the Rust Jacobi eigenvalue algorithm when WASM is loaded,
+ * otherwise falls back to the JavaScript QR algorithm.
+ *
+ * @param matrix - Square matrix as 2D array
+ * @param options - Computation options
+ * @returns Eigenvalues and eigenvectors
+ */
+declare function eigWasm(matrix: number[][], options?: EigOptions): Promise<EigResult>;
+/**
+ * WASM-accelerated eigenvalues only (no eigenvectors).
+ * Faster than full eigWasm when only eigenvalues are needed.
+ *
+ * @param matrix - Square matrix as 2D array
+ * @param options - Computation options (computeVectors is ignored)
+ * @returns Array of eigenvalues
+ */
+declare function eigvalsWasm(matrix: number[][], options?: Omit<EigOptions, 'computeVectors'>): Promise<Array<{
+    re: number;
+    im: number;
+}>>;
+/**
+ * WASM-accelerated spectral radius.
+ * Uses Rust power iteration when WASM is available.
+ *
+ * @param matrix - Square matrix as 2D array
+ * @param options - Iteration options
+ * @returns Spectral radius (absolute value of largest eigenvalue)
+ */
+declare function spectralRadiusWasm(matrix: number[][], options?: {
+    maxIterations?: number;
+    tolerance?: number;
+}): Promise<number>;
+
+/**
+ * WASM-accelerated Singular Value Decomposition
+ *
+ * Provides SVD computation with optional WASM acceleration.
+ * The Rust WASM crate currently exposes eigenvalue operations but not
+ * a direct SVD implementation. For symmetric matrices, SVD can be
+ * derived from eigendecomposition (singular values = |eigenvalues|).
+ *
+ * Strategy:
+ *   - Symmetric matrices: WASM eig -> derive SVD
+ *   - General matrices: JS Golub-Reinsch bidiagonalization (svd.ts)
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * WASM-accelerated SVD.
+ *
+ * For symmetric matrices, uses WASM eigendecomposition to derive SVD.
+ * For general matrices, falls back to the JavaScript Golub-Reinsch algorithm.
+ *
+ * @param matrix - Input matrix (m x n) as 2D array
+ * @param options - SVD computation options
+ * @returns SVD decomposition { U, S, V, rank }
+ */
+declare function svdWasm(matrix: number[][], options?: SVDOptions): Promise<SVDResult>;
+
+/**
+ * Typed Matrix Operations
+ *
+ * Polymorphic matrix operations using typed-function for runtime dispatch.
+ * Supports operations on DenseMatrix with automatic type coercion.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Create a matrix from various input types
+ */
+declare const matrix: typed_function.TypedFunction;
+/**
+ * Create an identity matrix
+ */
+declare const identity: typed_function.TypedFunction;
+/**
+ * Create a matrix of zeros
+ */
+declare const zeros: typed_function.TypedFunction;
+/**
+ * Create a matrix of ones
+ */
+declare const ones: typed_function.TypedFunction;
+/**
+ * Create a diagonal matrix
+ */
+declare const diag: typed_function.TypedFunction;
+/**
+ * Create a random matrix
+ */
+declare const random: typed_function.TypedFunction;
+/**
+ * Matrix addition - polymorphic add function
+ */
+declare const add: typed_function.TypedFunction;
+/**
+ * Matrix subtraction
+ */
+declare const subtract: typed_function.TypedFunction;
+/**
+ * Matrix multiplication (matmul)
+ */
+declare const multiply: typed_function.TypedFunction;
+/**
+ * Element-wise multiplication (Hadamard product)
+ */
+declare const dotMultiply: typed_function.TypedFunction;
+/**
+ * Matrix division (A / B where B is scalar or element-wise)
+ */
+declare const divide: typed_function.TypedFunction;
+/**
+ * Matrix negation
+ */
+declare const unaryMinus: typed_function.TypedFunction;
+/**
+ * Matrix transpose
+ */
+declare const transpose: typed_function.TypedFunction;
+/**
+ * Sum of all elements
+ */
+declare const sum: typed_function.TypedFunction;
+/**
+ * Mean of all elements
+ */
+declare const mean: typed_function.TypedFunction;
+/**
+ * Minimum element
+ */
+declare const min: typed_function.TypedFunction;
+/**
+ * Maximum element
+ */
+declare const max: typed_function.TypedFunction;
+/**
+ * Frobenius norm
+ */
+declare const norm: typed_function.TypedFunction;
+/**
+ * Matrix trace (sum of diagonal elements)
+ */
+declare const trace: typed_function.TypedFunction;
+/**
+ * Element-wise absolute value
+ */
+declare const abs: typed_function.TypedFunction;
+/**
+ * Element-wise square root
+ */
+declare const sqrt: typed_function.TypedFunction;
+/**
+ * Element-wise square
+ */
+declare const square: typed_function.TypedFunction;
+/**
+ * Element-wise exponential
+ */
+declare const exp: typed_function.TypedFunction;
+/**
+ * Element-wise natural logarithm
+ */
+declare const log: typed_function.TypedFunction;
+/**
+ * Element-wise power
+ */
+declare const pow: typed_function.TypedFunction;
+/**
+ * Get matrix dimensions
+ */
+declare const size: typed_function.TypedFunction;
+/**
+ * Get element at position
+ */
+declare const subset: typed_function.TypedFunction;
+/**
+ * Get row from matrix
+ */
+declare const row: typed_function.TypedFunction;
+/**
+ * Get column from matrix
+ */
+declare const column: typed_function.TypedFunction;
+/**
+ * Get diagonal from matrix
+ */
+declare const diagonal: typed_function.TypedFunction;
+declare const typedMatrixOperations: {
+    matrix: typed_function.TypedFunction;
+    identity: typed_function.TypedFunction;
+    zeros: typed_function.TypedFunction;
+    ones: typed_function.TypedFunction;
+    diag: typed_function.TypedFunction;
+    random: typed_function.TypedFunction;
+    add: typed_function.TypedFunction;
+    subtract: typed_function.TypedFunction;
+    multiply: typed_function.TypedFunction;
+    dotMultiply: typed_function.TypedFunction;
+    divide: typed_function.TypedFunction;
+    unaryMinus: typed_function.TypedFunction;
+    transpose: typed_function.TypedFunction;
+    sum: typed_function.TypedFunction;
+    mean: typed_function.TypedFunction;
+    min: typed_function.TypedFunction;
+    max: typed_function.TypedFunction;
+    norm: typed_function.TypedFunction;
+    trace: typed_function.TypedFunction;
+    abs: typed_function.TypedFunction;
+    sqrt: typed_function.TypedFunction;
+    square: typed_function.TypedFunction;
+    exp: typed_function.TypedFunction;
+    log: typed_function.TypedFunction;
+    pow: typed_function.TypedFunction;
+    size: typed_function.TypedFunction;
+    subset: typed_function.TypedFunction;
+    row: typed_function.TypedFunction;
+    column: typed_function.TypedFunction;
+    diagonal: typed_function.TypedFunction;
+};
+
+/**
+ * Parallel-First Matrix Operations
+ *
+ * AssemblyScript-friendly TypeScript implementations with typed-function
+ * integration and workerpool parallel execution via @danielsimonjr/mathts-parallel.
+ *
+ * These operations use Float64Array flat row-major format for efficient
+ * parallel processing through the ComputePool worker infrastructure.
+ *
+ * Following the parallel-first philosophy per CLAUDE.md:
+ * - Use workers for ALL matrix operations (matmul, transpose, etc.)
+ * - Use workers for ALL element-wise operations on matrices
+ * - Only fall back to sequential for trivial scalar operations
+ *
+ * @packageDocumentation
+ */
+/**
+ * Create a matrix from various input types - parallel-first
+ */
+declare const parallelMatrix: typed_function.TypedFunction;
+/**
+ * Create an identity matrix
+ */
+declare const parallelIdentity: typed_function.TypedFunction;
+/**
+ * Create a matrix of zeros
+ */
+declare const parallelZeros: typed_function.TypedFunction;
+/**
+ * Create a matrix of ones
+ */
+declare const parallelOnes: typed_function.TypedFunction;
+/**
+ * Create a diagonal matrix
+ */
+declare const parallelDiag: typed_function.TypedFunction;
+/**
+ * Create a random matrix
+ */
+declare const parallelRandom: typed_function.TypedFunction;
+/**
+ * Parallel matrix addition with typed-function dispatch
+ */
+declare const parallelMatrixAdd: typed_function.TypedFunction;
+/**
+ * Parallel matrix subtraction with typed-function dispatch
+ */
+declare const parallelMatrixSubtract: typed_function.TypedFunction;
+/**
+ * Parallel matrix multiplication (matmul) with typed-function dispatch
+ */
+declare const parallelMatrixMultiply: typed_function.TypedFunction;
+/**
+ * Element-wise multiplication (Hadamard product) - parallel execution
+ */
+declare const parallelDotMultiply: typed_function.TypedFunction;
+/**
+ * Parallel matrix division
+ */
+declare const parallelMatrixDivide: typed_function.TypedFunction;
+/**
+ * Matrix negation - parallel execution
+ */
+declare const parallelUnaryMinus: typed_function.TypedFunction;
+/**
+ * Matrix transpose - parallel execution
+ */
+declare const parallelMatrixTranspose: typed_function.TypedFunction;
+/**
+ * Parallel sum of all elements
+ */
+declare const parallelMatrixSum: typed_function.TypedFunction;
+/**
+ * Parallel mean of all elements
+ */
+declare const parallelMatrixMean: typed_function.TypedFunction;
+/**
+ * Parallel minimum element
+ */
+declare const parallelMatrixMin: typed_function.TypedFunction;
+/**
+ * Parallel maximum element
+ */
+declare const parallelMatrixMax: typed_function.TypedFunction;
+/**
+ * Parallel variance computation
+ */
+declare const parallelMatrixVariance: typed_function.TypedFunction;
+/**
+ * Parallel standard deviation
+ */
+declare const parallelMatrixStd: typed_function.TypedFunction;
+/**
+ * Parallel Frobenius norm
+ */
+declare const parallelMatrixNorm: typed_function.TypedFunction;
+/**
+ * Parallel dot product
+ */
+declare const parallelMatrixDot: typed_function.TypedFunction;
+/**
+ * Matrix trace (sum of diagonal elements)
+ */
+declare const parallelMatrixTrace: typed_function.TypedFunction;
+/**
+ * Parallel Euclidean distance
+ */
+declare const parallelMatrixDistance: typed_function.TypedFunction;
+/**
+ * Parallel element-wise absolute value
+ */
+declare const parallelMatrixAbs: typed_function.TypedFunction;
+/**
+ * Parallel element-wise square root
+ */
+declare const parallelMatrixSqrt: typed_function.TypedFunction;
+/**
+ * Parallel element-wise square
+ */
+declare const parallelMatrixSquare: typed_function.TypedFunction;
+/**
+ * Parallel element-wise exponential
+ */
+declare const parallelMatrixExp: typed_function.TypedFunction;
+/**
+ * Parallel element-wise natural logarithm
+ */
+declare const parallelMatrixLog: typed_function.TypedFunction;
+/**
+ * Parallel element-wise sine
+ */
+declare const parallelMatrixSin: typed_function.TypedFunction;
+/**
+ * Parallel element-wise cosine
+ */
+declare const parallelMatrixCos: typed_function.TypedFunction;
+/**
+ * Parallel element-wise tangent
+ */
+declare const parallelMatrixTan: typed_function.TypedFunction;
+/**
+ * Get matrix dimensions
+ */
+declare const parallelMatrixSize: typed_function.TypedFunction;
+/**
+ * Get element at position
+ */
+declare const parallelMatrixSubset: typed_function.TypedFunction;
+/**
+ * Get row from matrix
+ */
+declare const parallelMatrixRow: typed_function.TypedFunction;
+/**
+ * Get column from matrix
+ */
+declare const parallelMatrixColumn: typed_function.TypedFunction;
+/**
+ * Get diagonal from matrix
+ */
+declare const parallelMatrixDiagonal: typed_function.TypedFunction;
+/**
+ * Parallel matrix-vector multiplication
+ */
+declare const parallelMatrixMatvec: typed_function.TypedFunction;
+/**
+ * Parallel outer product
+ */
+declare const parallelMatrixOuter: typed_function.TypedFunction;
+/**
+ * Parallel histogram computation
+ */
+declare const parallelMatrixHistogram: typed_function.TypedFunction;
+declare const parallelMatrixOperations: {
+    matrix: typed_function.TypedFunction;
+    identity: typed_function.TypedFunction;
+    zeros: typed_function.TypedFunction;
+    ones: typed_function.TypedFunction;
+    diag: typed_function.TypedFunction;
+    random: typed_function.TypedFunction;
+    add: typed_function.TypedFunction;
+    subtract: typed_function.TypedFunction;
+    multiply: typed_function.TypedFunction;
+    dotMultiply: typed_function.TypedFunction;
+    divide: typed_function.TypedFunction;
+    unaryMinus: typed_function.TypedFunction;
+    transpose: typed_function.TypedFunction;
+    sum: typed_function.TypedFunction;
+    mean: typed_function.TypedFunction;
+    min: typed_function.TypedFunction;
+    max: typed_function.TypedFunction;
+    variance: typed_function.TypedFunction;
+    std: typed_function.TypedFunction;
+    norm: typed_function.TypedFunction;
+    dot: typed_function.TypedFunction;
+    trace: typed_function.TypedFunction;
+    distance: typed_function.TypedFunction;
+    abs: typed_function.TypedFunction;
+    sqrt: typed_function.TypedFunction;
+    square: typed_function.TypedFunction;
+    exp: typed_function.TypedFunction;
+    log: typed_function.TypedFunction;
+    sin: typed_function.TypedFunction;
+    cos: typed_function.TypedFunction;
+    tan: typed_function.TypedFunction;
+    size: typed_function.TypedFunction;
+    subset: typed_function.TypedFunction;
+    row: typed_function.TypedFunction;
+    column: typed_function.TypedFunction;
+    diagonal: typed_function.TypedFunction;
+    matvec: typed_function.TypedFunction;
+    outer: typed_function.TypedFunction;
+    histogram: typed_function.TypedFunction;
+};
+/**
+ * Initialize parallel matrix operations
+ */
+declare function initializeParallelMatrix(): Promise<void>;
+/**
+ * Terminate parallel matrix operations pool
+ */
+declare function terminateParallelMatrix(): Promise<void>;
+
+export { BUILTIN_SHADERS, type BackendHints, BackendManager, BackendRegistry, type BackendType, BatchExecutor, BufferPool, DEFAULT_BACKEND_HINTS, DEFAULT_EXTENDED_HINTS, DenseMatrix, type EigOptions, type EigResult, type ExtendedBackendHints, GPUBackend, type GPUBackendOptions, type GPUBackendStatus, type GPUCapabilities, GPUContext, type GPUContextOptions, GPUMatrixBackend, type GPUMatrixBackendConfig, JSBackend, Matrix, type MatrixBackend, type MatrixDimensions, type MatrixEntry, type MatrixIndex, type MatrixType, type OperationType, ParallelBackend, type ParallelBackendConfig, type SVDOptions, type SVDResult, ShaderManager, type SliceSpec, SparseMatrix, type SyncConfig, SyncManager, type SyncStrategy, WASMBackend, type WASMBackendConfig, type WasmFeatures, abs, add, backendManager, backendRegistry, clearFeatureCache, column, cond, createBackendManager, createGPUMatrixBackend, createParallelBackend, createSyncManager, createWASMBackend, destroyGlobalGPU, destroyGlobalGPUBackend, detectGPUCapabilities, detectWasmFeatures, diag, diagonal, divide, dotMultiply, eig, eigWasm, eigvals, eigvalsWasm, exp, getCachedFeatures, getGlobalGPUBackend, getGlobalGPUContext, getRecommendedWorkgroupSize, gpuMatrixBackend, hasWebGPU, identity, initializeGlobalGPUBackend, initializeParallelMatrix, isAtomicsAvailable, isDenseMatrix, isMatrix, isSharedMemoryAvailable, isSparseMatrix, isWasmAvailable, jsBackend, log, lowRankApprox, matrix, max, mean, min, multiply, norm, norm2, normFro, ones, parallelBackend, parallelDiag, parallelDotMultiply, parallelIdentity, parallelMatrix, parallelMatrixAbs, parallelMatrixAdd, parallelMatrixColumn, parallelMatrixCos, parallelMatrixDiagonal, parallelMatrixDistance, parallelMatrixDivide, parallelMatrixDot, parallelMatrixExp, parallelMatrixHistogram, parallelMatrixLog, parallelMatrixMatvec, parallelMatrixMax, parallelMatrixMean, parallelMatrixMin, parallelMatrixMultiply, parallelMatrixNorm, parallelMatrixOperations, parallelMatrixOuter, parallelMatrixRow, parallelMatrixSin, parallelMatrixSize, parallelMatrixSqrt, parallelMatrixSquare, parallelMatrixStd, parallelMatrixSubset, parallelMatrixSubtract, parallelMatrixSum, parallelMatrixTan, parallelMatrixTrace, parallelMatrixTranspose, parallelMatrixVariance, parallelOnes, parallelRandom, parallelUnaryMinus, parallelZeros, pinv, pow, powerIteration, random, row, singularValues, size, spectralRadiusWasm, sqrt, square, subset, subtract, sum, svd, svdWasm, terminateParallelMatrix, trace, transpose, typedMatrixOperations, unaryMinus, wasmBackend, zeros };