@danielsimonjr/mathts-matrix 0.7.1 → 0.7.2

package/dist/typed-operations.d.ts

@@ -0,0 +1,161 @@
+/**
+ * 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
+ */
+export declare const matrix: import("typed-function").TypedFunction;
+/**
+ * Create an identity matrix
+ */
+export declare const identity: import("typed-function").TypedFunction;
+/**
+ * Create a matrix of zeros
+ */
+export declare const zeros: import("typed-function").TypedFunction;
+/**
+ * Create a matrix of ones
+ */
+export declare const ones: import("typed-function").TypedFunction;
+/**
+ * Create a diagonal matrix
+ */
+export declare const diag: import("typed-function").TypedFunction;
+/**
+ * Create a random matrix
+ */
+export declare const random: import("typed-function").TypedFunction;
+/**
+ * Matrix addition - polymorphic add function
+ */
+export declare const add: import("typed-function").TypedFunction;
+/**
+ * Matrix subtraction
+ */
+export declare const subtract: import("typed-function").TypedFunction;
+/**
+ * Matrix multiplication (matmul)
+ */
+export declare const multiply: import("typed-function").TypedFunction;
+/**
+ * Element-wise multiplication (Hadamard product)
+ */
+export declare const dotMultiply: import("typed-function").TypedFunction;
+/**
+ * Matrix division (A / B where B is scalar or element-wise)
+ */
+export declare const divide: import("typed-function").TypedFunction;
+/**
+ * Matrix negation
+ */
+export declare const unaryMinus: import("typed-function").TypedFunction;
+/**
+ * Matrix transpose
+ */
+export declare const transpose: import("typed-function").TypedFunction;
+/**
+ * Sum of all elements
+ */
+export declare const sum: import("typed-function").TypedFunction;
+/**
+ * Mean of all elements
+ */
+export declare const mean: import("typed-function").TypedFunction;
+/**
+ * Minimum element
+ */
+export declare const min: import("typed-function").TypedFunction;
+/**
+ * Maximum element
+ */
+export declare const max: import("typed-function").TypedFunction;
+/**
+ * Frobenius norm
+ */
+export declare const norm: import("typed-function").TypedFunction;
+/**
+ * Matrix trace (sum of diagonal elements)
+ */
+export declare const trace: import("typed-function").TypedFunction;
+/**
+ * Element-wise absolute value
+ */
+export declare const abs: import("typed-function").TypedFunction;
+/**
+ * Element-wise square root
+ */
+export declare const sqrt: import("typed-function").TypedFunction;
+/**
+ * Element-wise square
+ */
+export declare const square: import("typed-function").TypedFunction;
+/**
+ * Element-wise exponential
+ */
+export declare const exp: import("typed-function").TypedFunction;
+/**
+ * Element-wise natural logarithm
+ */
+export declare const log: import("typed-function").TypedFunction;
+/**
+ * Element-wise power
+ */
+export declare const pow: import("typed-function").TypedFunction;
+/**
+ * Get matrix dimensions
+ */
+export declare const size: import("typed-function").TypedFunction;
+/**
+ * Get element at position
+ */
+export declare const subset: import("typed-function").TypedFunction;
+/**
+ * Get row from matrix
+ */
+export declare const row: import("typed-function").TypedFunction;
+/**
+ * Get column from matrix
+ */
+export declare const column: import("typed-function").TypedFunction;
+/**
+ * Get diagonal from matrix
+ */
+export declare const diagonal: import("typed-function").TypedFunction;
+export declare const typedMatrixOperations: {
+    matrix: import("typed-function").TypedFunction;
+    identity: import("typed-function").TypedFunction;
+    zeros: import("typed-function").TypedFunction;
+    ones: import("typed-function").TypedFunction;
+    diag: import("typed-function").TypedFunction;
+    random: import("typed-function").TypedFunction;
+    add: import("typed-function").TypedFunction;
+    subtract: import("typed-function").TypedFunction;
+    multiply: import("typed-function").TypedFunction;
+    dotMultiply: import("typed-function").TypedFunction;
+    divide: import("typed-function").TypedFunction;
+    unaryMinus: import("typed-function").TypedFunction;
+    transpose: import("typed-function").TypedFunction;
+    sum: import("typed-function").TypedFunction;
+    mean: import("typed-function").TypedFunction;
+    min: import("typed-function").TypedFunction;
+    max: import("typed-function").TypedFunction;
+    norm: import("typed-function").TypedFunction;
+    trace: import("typed-function").TypedFunction;
+    abs: import("typed-function").TypedFunction;
+    sqrt: import("typed-function").TypedFunction;
+    square: import("typed-function").TypedFunction;
+    exp: import("typed-function").TypedFunction;
+    log: import("typed-function").TypedFunction;
+    pow: import("typed-function").TypedFunction;
+    size: import("typed-function").TypedFunction;
+    subset: import("typed-function").TypedFunction;
+    row: import("typed-function").TypedFunction;
+    column: import("typed-function").TypedFunction;
+    diagonal: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=typed-operations.d.ts.map

package/dist/typed-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-operations.d.ts","sourceRoot":"","sources":["../src/typed-operations.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH;;GAEG;AACH,eAAO,MAAM,MAAM,wCAUH,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,QAAQ,wCAEL,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,KAAK,wCAEF,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,IAAI,wCAED,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,IAAI,wCAED,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,MAAM,wCAEH,CAAC;AAMjB;;GAEG;AACH,eAAO,MAAM,GAAG,wCAYA,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,QAAQ,wCAYL,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,QAAQ,wCAYL,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,WAAW,wCAIR,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,MAAM,wCASH,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,UAAU,wCAGP,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,SAAS,wCAEN,CAAC;AAMjB;;GAEG;AACH,eAAO,MAAM,GAAG,wCAGA,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGD,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,GAAG,wCAIA,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,GAAG,wCAIA,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGD,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,KAAK,wCAEF,CAAC;AAMjB;;GAEG;AACH,eAAO,MAAM,GAAG,wCAGA,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGD,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,MAAM,wCAGH,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,GAAG,wCAGA,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,GAAG,wCAGA,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,GAAG,wCAGA,CAAC;AAMjB;;GAEG;AACH,eAAO,MAAM,IAAI,wCAQD,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,MAAM,wCAEH,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,GAAG,wCAEA,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,MAAM,wCAEH,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,QAAQ,wCAGL,CAAC;AAMjB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCjC,CAAC"}

package/dist/types/DenseMatrix.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Dense Matrix Implementation
+ *
+ * Row-major dense matrix backed by Float64Array for efficient storage
+ * and operations. Supports views (slices without copying) where possible.
+ *
+ * @packageDocumentation
+ */
+import { Matrix, MatrixEntry, SliceSpec } from './Matrix.js';
+/**
+ * Dense matrix implementation using Float64Array
+ *
+ * Data is stored in row-major order for cache-friendly row access.
+ * All operations return new matrices (immutable API).
+ */
+export 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 (typed as the `Matrix` base — the
+     *   `SparseMatrix` subtype is loaded lazily to avoid an import cycle)
+     */
+    toSparse(dropTolerance?: number): Matrix;
+    /**
+     * 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
+ */
+export declare function isDenseMatrix(value: unknown): value is DenseMatrix;
+//# sourceMappingURL=DenseMatrix.d.ts.map

package/dist/types/DenseMatrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DenseMatrix.d.ts","sourceRoot":"","sources":["../../src/types/DenseMatrix.ts"],"names":[],"mappings":"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"}

package/dist/types/Matrix.d.ts

@@ -0,0 +1,188 @@
+/**
+ * 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, consolidated from `@danielsimonjr/mathts-core`'s
+ * byte-identical copy (see docs/Architecture/duplicate-symbols.json).
+ */
+import type { MatrixDimensions } from '@danielsimonjr/mathts-core';
+export type { MatrixDimensions };
+/**
+ * Matrix index for element access
+ */
+export interface MatrixIndex {
+    row: number;
+    col: number;
+}
+/**
+ * Slice specification for submatrix extraction
+ */
+export interface SliceSpec {
+    rowStart?: number;
+    rowEnd?: number;
+    colStart?: number;
+    colEnd?: number;
+}
+/**
+ * Matrix iterator result
+ */
+export interface MatrixEntry<T = number> {
+    row: number;
+    col: number;
+    value: T;
+}
+/**
+ * Matrix storage format identifier
+ */
+export type MatrixType = 'DenseMatrix' | 'SparseMatrix' | 'DiagonalMatrix' | 'BandMatrix';
+/**
+ * Abstract base class for all matrix types
+ *
+ * @typeParam T - The element type (default: number)
+ */
+export 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
+ */
+export declare function isMatrix<T = number>(value: unknown): value is Matrix<T>;
+//# sourceMappingURL=Matrix.d.ts.map

package/dist/types/Matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Matrix.d.ts","sourceRoot":"","sources":["../../src/types/Matrix.ts"],"names":[],"mappings":"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"}