@pawells/math-extended 1.0.1

package/build/matrices/arithmetic.d.ts

@@ -0,0 +1,411 @@
+import { IMatrix, IMatrix1, IMatrix2, IMatrix3, IMatrix4, TMatrixResult } from './types.js';
+import { TVector, TVector2, TVector3, TVector4 } from '../vectors/types.js';
+/**
+ * Performs element-wise addition of two matrices.
+ *
+ * This function implements matrix addition using the standard mathematical definition:
+ * `C[i,j] = A[i,j] + B[i,j]` for all valid indices i,j
+ *
+ * The operation requires both matrices to have identical dimensions and produces
+ * a new matrix without modifying the input matrices. Matrix addition is both
+ * commutative (A + B = B + A) and associative ((A + B) + C = A + (B + C)).
+ *
+ * **Properties:**
+ * - Commutative: A + B = B + A
+ * - Associative: (A + B) + C = A + (B + C)
+ * - Identity element: A + 0 = A (where 0 is the zero matrix)
+ * - Inverse element: A + (-A) = 0
+ *
+ * **Time Complexity:** O(m×n) where m and n are the matrix dimensions
+ * **Space Complexity:** O(m×n) for the result matrix
+ *
+ * @template T - The matrix type extending IMatrix interface
+ * @param a - First matrix (addend) - must have same dimensions as b
+ * @param b - Second matrix (addend) - must have same dimensions as a
+ * @returns {TMatrixResult<T>} A new matrix where each element is the sum of corresponding elements
+ * @throws {Error} If matrices have different dimensions or contain invalid values
+ *
+ * @example
+ * ```typescript
+ * // Adding 2×2 matrices
+ * MatrixAdd([[1, 2], [3, 4]], [[5, 6], [7, 8]]) // Returns [[6, 8], [10, 12]]
+ *
+ * // Adding 1×3 row vectors
+ * MatrixAdd([[1, 2, 3]], [[4, 5, 6]]) // Returns [[5, 7, 9]]
+ *
+ * // Type-safe matrix addition with specific matrix types
+ * const matrixA: IMatrix2 = [[1, 2], [3, 4]];
+ * const matrixB: IMatrix2 = [[5, 6], [7, 8]];
+ * const result: IMatrix2 = MatrixAdd(matrixA, matrixB);
+ * ```
+ */
+export declare function MatrixAdd<T extends IMatrix>(a: T, b: T): TMatrixResult<T>;
+/**
+ * Performs element-wise subtraction of two matrices (a - b).
+ *
+ * This function implements matrix subtraction using the standard mathematical definition:
+ * `C[i,j] = A[i,j] - B[i,j]` for all valid indices i,j
+ *
+ * The operation requires both matrices to have identical dimensions and produces
+ * a new matrix without modifying the input matrices. Note that matrix subtraction
+ * is **not commutative**: A - B ≠ B - A in general.
+ *
+ * **Properties:**
+ * - Non-commutative: A - B ≠ B - A (in general)
+ * - Non-associative: (A - B) - C ≠ A - (B - C) (in general)
+ * - Relationship to addition: A - B = A + (-B)
+ * - Self-subtraction: A - A = 0 (zero matrix)
+ *
+ * **Time Complexity:** O(m×n) where m and n are the matrix dimensions
+ * **Space Complexity:** O(m×n) for the result matrix
+ *
+ * @template T - The matrix type extending IMatrix interface
+ * @param a - First matrix (minuend) - the matrix being subtracted from
+ * @param b - Second matrix (subtrahend) - the matrix being subtracted
+ * @returns {TMatrixResult<T>} A new matrix where each element is the difference of corresponding elements
+ * @throws {Error} If matrices have different dimensions or contain invalid values
+ *
+ * @example
+ * ```typescript
+ * // Subtracting 2×2 matrices
+ * MatrixSubtract([[10, 8], [6, 4]], [[3, 2], [1, 1]]) // Returns [[7, 6], [5, 3]]
+ *
+ * // Order matters: A - B ≠ B - A
+ * MatrixSubtract([[1, 2]], [[3, 4]]) // Returns [[-2, -2]]
+ * MatrixSubtract([[3, 4]], [[1, 2]]) // Returns [[2, 2]]
+ *
+ * // Self-subtraction produces zero matrix
+ * MatrixSubtract([[5, 6]], [[5, 6]]) // Returns [[0, 0]]
+ * ```
+ */
+export declare function MatrixSubtract<T extends IMatrix>(a: T, b: T): TMatrixResult<T>;
+/**
+ * Performs matrix multiplication with comprehensive type-safe overloads for matrices, vectors, and scalars.
+ *
+ * This function serves as a smart dispatcher that automatically routes to the most
+ * appropriate multiplication algorithm based on the type and characteristics of the
+ * second operand. The function provides extensive overloaded signatures for complete
+ * type safety and optimal performance across different operation types and matrix sizes.
+ *
+ * **Type-Safe Overloads:**
+ * - **Scalar Multiplication:**
+ *   - `IMatrix1 × number → IMatrix1` (1×1 matrix scalar multiplication)
+ *   - `IMatrix2 × number → IMatrix2` (2×2 matrix scalar multiplication)
+ *   - `IMatrix3 × number → IMatrix3` (3×3 matrix scalar multiplication)
+ *   - `IMatrix4 × number → IMatrix4` (4×4 matrix scalar multiplication)
+ *   - `IMatrix × number → IMatrix` (general matrix scalar multiplication)
+ *
+ * - **Vector Multiplication:**
+ *   - `IMatrix2 × TVector2 → TVector2` (2×2 matrix × 2D vector)
+ *   - `IMatrix3 × TVector3 → TVector3` (3×3 matrix × 3D vector)
+ *   - `IMatrix4 × TVector4 → TVector4` (4×4 matrix × 4D vector)
+ *   - `IMatrix × TVector → TVector` (general matrix × vector)
+ *
+ * - **Matrix Multiplication:**
+ *   - `IMatrix1 × IMatrix1 → IMatrix1` (1×1 matrix multiplication)
+ *   - `IMatrix2 × IMatrix2 → IMatrix2` (2×2 matrix multiplication)
+ *   - `IMatrix3 × IMatrix3 → IMatrix3` (3×3 matrix multiplication)
+ *   - `IMatrix4 × IMatrix4 → IMatrix4` (4×4 matrix multiplication)
+ *   - `IMatrix × IMatrix → IMatrix` (general matrix multiplication)
+ *
+ * **Operation Types:**
+ * - **Matrix × Scalar:** Element-wise multiplication by scalar value
+ * - **Matrix × Vector:** Matrix-vector multiplication producing a column vector
+ * - **Matrix × Matrix:** Full matrix multiplication with algorithm optimization
+ *
+ * **Algorithm Selection (for matrix-matrix multiplication):**
+ * - 1×1 to 4×4 square matrices: Hardcoded optimized formulas
+ * - Large square matrices (≥32×32): Strassen's algorithm O(n^2.807)
+ * - All other cases: Standard algorithm O(n³)
+ *
+ * **Mathematical Properties:**
+ * - Matrix multiplication is associative: (AB)C = A(BC)
+ * - Matrix multiplication is generally not commutative: AB ≠ BA
+ * - Scalar multiplication is commutative: kA = Ak
+ * - Distributive over addition: A(B + C) = AB + AC
+ *
+ * @param a - First matrix (left operand) with dimensions m×n
+ * @param b - Second operand: matrix (n×p), vector (n elements), or scalar number
+ * @returns {IMatrix | TVector} The product result:
+ *   - For scalar: m×n matrix with each element multiplied by scalar
+ *   - For vector: m×1 column vector matrix
+ *   - For matrix: m×p product matrix
+ * @throws {Error} If matrix dimensions are incompatible for multiplication
+ *
+ * @example
+ * ```typescript
+ * // Type-safe scalar multiplication with specific matrix types
+ * const matrix2: IMatrix2 = [[1, 2], [3, 4]];
+ * const scalar2Result: IMatrix2 = MatrixMultiply(matrix2, 2); // [[2, 4], [6, 8]]
+ *
+ * const matrix3: IMatrix3 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
+ * const scalar3Result: IMatrix3 = MatrixMultiply(matrix3, 5); // Identity × 5
+ *
+ * // Type-safe vector multiplication with specific matrix/vector types
+ * const matrix2x2: IMatrix2 = [[1, 2], [3, 4]];
+ * const vector2: TVector2 = [5, 6];
+ * const vectorResult: TVector2 = MatrixMultiply(matrix2x2, vector2); // [17, 39]
+ *
+ * const matrix4x4: IMatrix4 = [[1,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]];
+ * const vector4: TVector4 = [1, 2, 3, 4];
+ * const vector4Result: TVector4 = MatrixMultiply(matrix4x4, vector4); // [1, 2, 3, 4]
+ *
+ * // Type-safe matrix multiplication with specific matrix types
+ * const matrixA: IMatrix2 = [[1, 2], [3, 4]];
+ * const matrixB: IMatrix2 = [[5, 6], [7, 8]];
+ * const matrixResult: IMatrix2 = MatrixMultiply(matrixA, matrixB); // [[19, 22], [43, 50]]
+ *
+ * // General matrix operations (fallback to generic types)
+ * MatrixMultiply([[1, 2]], [[3], [4]]) // Returns [[11]]
+ * MatrixMultiply([[1], [2]], [[3, 4]]) // Returns [[3, 4], [6, 8]]
+ *
+ * // Type detection is automatic - no need to specify operation type
+ * const scalarResult = MatrixMultiply(matrixA, 5);        // Scalar multiplication
+ * const vectorResult2 = MatrixMultiply(matrixA, vector2);  // Vector multiplication
+ * const matrixResult2 = MatrixMultiply(matrixA, matrixB); // Matrix multiplication
+ * ```
+ */
+export declare function MatrixMultiply(a: IMatrix1, b: number): IMatrix1;
+export declare function MatrixMultiply(a: IMatrix2, b: number): IMatrix2;
+export declare function MatrixMultiply(a: IMatrix3, b: number): IMatrix3;
+export declare function MatrixMultiply(a: IMatrix4, b: number): IMatrix4;
+export declare function MatrixMultiply(a: IMatrix2, b: TVector2): TVector2;
+export declare function MatrixMultiply(a: IMatrix3, b: TVector3): TVector3;
+export declare function MatrixMultiply(a: IMatrix4, b: TVector4): TVector4;
+export declare function MatrixMultiply(a: IMatrix1, b: IMatrix1): IMatrix1;
+export declare function MatrixMultiply(a: IMatrix2, b: IMatrix2): IMatrix2;
+export declare function MatrixMultiply(a: IMatrix3, b: IMatrix3): IMatrix3;
+export declare function MatrixMultiply(a: IMatrix4, b: IMatrix4): IMatrix4;
+export declare function MatrixMultiply(a: IMatrix, b: TVector): TVector;
+export declare function MatrixMultiply(a: IMatrix, b: IMatrix): IMatrix;
+export declare function MatrixMultiply(a: IMatrix, b: number): IMatrix;
+/**
+ * Extracts a rectangular submatrix from a larger matrix.
+ *
+ * This function creates a new matrix containing a specified rectangular region from
+ * the source matrix. It performs a deep copy of the selected elements, ensuring the
+ * original matrix remains unmodified. This operation is fundamental for matrix
+ * partitioning algorithms, block operations, and data analysis workflows.
+ *
+ * Coordinate System:
+ * - startRow, startCol: Top-left corner of the extraction region (0-based, inclusive)
+ * - width, height: Dimensions of the region to extract
+ * - Extraction bounds: [startRow, startRow+height) × [startCol, startCol+width)
+ *
+ * NOTE: parameter order is (startCol, startRow) — reversed from typical convention
+ *
+ * Applications:
+ * - Block matrix algorithms (Strassen, block LU decomposition)
+ * - Image processing (extracting regions of interest)
+ * - Data analysis (extracting subsets of datasets)
+ * - Sparse matrix operations (extracting dense blocks)
+ * - Machine learning (feature selection, data windowing)
+ *
+ * Bounds Checking:
+ * - Validates that extraction region fits within source matrix
+ * - Ensures all parameters are non-negative integers
+ * - Checks for valid matrix structure and element values
+ *
+ * Memory Efficiency:
+ * - Creates new matrix with minimal required size
+ * - Performs element-by-element copying with validation
+ * - No unnecessary memory allocation or copying
+ *
+ * Time Complexity: O(width × height) - linear in extracted region size
+ * Space Complexity: O(width × height) - size of extracted submatrix
+ *
+ * @param matrix - Source matrix to extract from
+ * @param startCol - Starting column index (0-based, inclusive) — note reversed order
+ * @param startRow - Starting row index (0-based, inclusive) — note reversed order
+ * @param width - Number of columns to extract (must be positive)
+ * @param height - Number of rows to extract (must be positive)
+ * @returns {IMatrix} The extracted submatrix with dimensions height×width
+ * @throws {Error} If extraction bounds exceed matrix dimensions or contain invalid values
+ * @example
+ * ```typescript
+ * const matrix = [
+ *   [1,  2,  3,  4],
+ *   [5,  6,  7,  8],
+ *   [9, 10, 11, 12]
+ * ]; // 3×4 matrix
+ *
+ * // Extract 2×2 submatrix from top-left corner
+ * MatrixSubmatrix(matrix, 0, 0, 2, 2) // Returns [[1, 2], [5, 6]]
+ *
+ * // Extract 2×2 submatrix from center-right region
+ * MatrixSubmatrix(matrix, 2, 1, 2, 2) // Returns [[7, 8], [11, 12]]
+ *
+ * // Extract single column (column vector)
+ * MatrixSubmatrix(matrix, 1, 0, 1, 3) // Returns [[2], [6], [10]]
+ *
+ * // Extract single row (row vector)
+ * MatrixSubmatrix(matrix, 0, 1, 4, 1) // Returns [[5, 6, 7, 8]]
+ *
+ * // Block matrix partitioning for algorithms
+ * const large = MatrixCreate(8, 8); // 8×8 matrix
+ * const topLeft = MatrixSubmatrix(large, 0, 0, 4, 4);     // Top-left 4×4 block
+ * const topRight = MatrixSubmatrix(large, 4, 0, 4, 4);    // Top-right 4×4 block
+ * const bottomLeft = MatrixSubmatrix(large, 0, 4, 4, 4);  // Bottom-left 4×4 block
+ * const bottomRight = MatrixSubmatrix(large, 4, 4, 4, 4); // Bottom-right 4×4 block
+ * ```
+ */
+export declare function MatrixSubmatrix(matrix: IMatrix, startCol: number, startRow: number, width: number, height: number): IMatrix;
+/**
+ * Pads a matrix with zeros to reach the specified dimensions.
+ *
+ * This function extends a matrix by adding rows and/or columns filled with zeros,
+ * preserving the original matrix content in the top-left corner. This operation
+ * is essential for algorithms that require matrices of specific sizes or when
+ * preparing matrices for operations that need dimension alignment.
+ *
+ * Padding Strategy:
+ * - Original content remains in top-left corner at [0,0]
+ * - Additional rows/columns are filled with zeros
+ * - New dimensions must be greater than or equal to current dimensions
+ * - Supports both symmetric and asymmetric padding
+ *
+ * Common Use Cases:
+ * - Algorithm requirements (power-of-2 sizes for FFT-based algorithms)
+ * - Block matrix operations (ensuring uniform block sizes)
+ * - Strassen algorithm (handling odd-sized matrices)
+ * - Image processing (border padding for convolution operations)
+ * - Signal processing (zero-padding for frequency domain analysis)
+ * - Machine learning (batch size alignment, tensor operations)
+ *
+ * Padding Preservation Property:
+ * If A is the original matrix and A' is the padded matrix, then:
+ * A'[i,j] = A[i,j] for all valid i,j in A
+ * A'[i,j] = 0 for all other positions
+ *
+ * Memory Efficiency:
+ * - Creates new matrix only of the target size
+ * - Copies only existing elements (no redundant operations)
+ * - Zero-fills remaining positions efficiently
+ *
+ * Time Complexity: O(newRows × newCols) - must initialize entire new matrix
+ * Space Complexity: O(newRows × newCols) - size of padded result
+ *
+ * @param matrix - Source matrix to pad
+ * @param newRows - Target number of rows (must be ≥ current rows)
+ * @param newCols - Target number of columns (must be ≥ current columns)
+ * @returns {IMatrix} The padded matrix with dimensions newRows×newCols
+ * @throws {Error} If new dimensions are smaller than current dimensions
+ * @example
+ * ```typescript
+ * const matrix = [[1, 2], [3, 4]]; // 2×2 matrix
+ *
+ * // Pad to 4×4 matrix (symmetric padding)
+ * MatrixPad(matrix, 4, 4)
+ * // Returns:
+ * // [[1, 2, 0, 0],
+ * //  [3, 4, 0, 0],
+ * //  [0, 0, 0, 0],
+ * //  [0, 0, 0, 0]]
+ *
+ * // Pad to 3×4 matrix (asymmetric padding)
+ * MatrixPad(matrix, 3, 4)
+ * // Returns:
+ * // [[1, 2, 0, 0],
+ * //  [3, 4, 0, 0],
+ * //  [0, 0, 0, 0]]
+ *
+ * // Prepare for power-of-2 algorithm (e.g., FFT-based convolution)
+ * const data = [[1, 2, 3], [4, 5, 6]]; // 2×3 matrix
+ * const powerOf2 = MatrixPad(data, 4, 4); // Pad to 4×4 for FFT
+ *
+ * // Batch size alignment in machine learning
+ * const features = MatrixCreate(7, 10); // 7 samples, 10 features
+ * const aligned = MatrixPad(features, 8, 10); // Align to batch size 8
+ *
+ * // Image border padding for convolution
+ * const image = MatrixCreate(28, 28); // 28×28 image
+ * const padded = MatrixPad(image, 32, 32); // Add border for valid convolution
+ * ```
+ */
+export declare function MatrixPad(matrix: IMatrix, newRows: number, newCols: number): IMatrix;
+/**
+ * Combines four square submatrices into a single matrix (2×2 block structure).
+ *
+ * This function reconstructs a larger matrix from four quadrant submatrices using
+ * a 2×2 block structure. It serves as the inverse operation of matrix partitioning
+ * and is essential for divide-and-conquer algorithms like Strassen multiplication,
+ * block matrix operations, and hierarchical matrix constructions.
+ *
+ * **Block Matrix Structure:**
+ * ```
+ * Result = [C11  C12]  where each Cij is an n×n submatrix
+ *          [C21  C22]
+ * ```
+ *
+ * The resulting matrix has dimensions 2n×2n when each input quadrant is n×n.
+ *
+ * **Quadrant Placement:**
+ * - c11 (top-left): positioned at [0:n, 0:n]
+ * - c12 (top-right): positioned at [0:n, n:2n]
+ * - c21 (bottom-left): positioned at [n:2n, 0:n]
+ * - c22 (bottom-right): positioned at [n:2n, n:2n]
+ *
+ * **Applications:**
+ * - Strassen algorithm result reconstruction
+ * - Block matrix operations and algebra
+ * - Hierarchical matrix assembly (multigrid methods)
+ * - Sparse matrix construction from dense blocks
+ * - Parallel matrix computation result merging
+ * - Image processing (combining processed image quadrants)
+ * - Scientific computing (domain decomposition methods)
+ *
+ * **Validation Requirements:**
+ * - All four input matrices must be square
+ * - All four input matrices must have identical dimensions
+ * - All elements must be valid numbers
+ * - No null or undefined matrices allowed
+ *
+ * **Memory Layout:**
+ * The function performs efficient copying by iterating through each quadrant
+ * sequentially, minimizing cache misses and ensuring optimal memory access patterns.
+ *
+ * **Time Complexity:** O(n²) where n is the dimension of each input quadrant
+ * **Space Complexity:** O(4n²) for the combined result matrix
+ *
+ * @param c11 - Top-left quadrant (upper-left block)
+ * @param c12 - Top-right quadrant (upper-right block)
+ * @param c21 - Bottom-left quadrant (lower-left block)
+ * @param c22 - Bottom-right quadrant (lower-right block)
+ * @returns {IMatrix} The combined matrix with dimensions 2n×2n (where each input is n×n)
+ * @throws {Error} If quadrants have mismatched dimensions or invalid values
+ *
+ * @example
+ * ```typescript
+ * // Basic 2×2 quadrant combination
+ * const topLeft = [[1, 2], [3, 4]];
+ * const topRight = [[5, 6], [7, 8]];
+ * const bottomLeft = [[9, 10], [11, 12]];
+ * const bottomRight = [[13, 14], [15, 16]];
+ *
+ * MatrixCombine(topLeft, topRight, bottomLeft, bottomRight)
+ * // Returns:
+ * // [[1,  2,  5,  6],
+ * //  [3,  4,  7,  8],
+ * //  [9, 10, 13, 14],
+ * //  [11,12, 15, 16]]
+ *
+ * // Strassen algorithm result reconstruction
+ * const m1 = computeStrassenProduct1(); // Computed Strassen intermediate results
+ * const m2 = computeStrassenProduct2();
+ * const m3 = computeStrassenProduct3();
+ * const m4 = computeStrassenProduct4();
+ * const finalResult = MatrixCombine(m1, m2, m3, m4); // Assemble final result
+ *
+ * // Image processing: combining processed quadrants
+ * const processedTopLeft = processImageQuadrant(imageTopLeft);
+ * const processedTopRight = processImageQuadrant(imageTopRight);
+ * const processedBottomLeft = processImageQuadrant(imageBottomLeft);
+ * const processedBottomRight = processImageQuadrant(imageBottomRight);
+ * const reconstructedImage = MatrixCombine(
+ *   processedTopLeft, processedTopRight,
+ *   processedBottomLeft, processedBottomRight
+ * );
+ * ```
+ */
+export declare function MatrixCombine(c11: IMatrix, c12: IMatrix, c21: IMatrix, c22: IMatrix): IMatrix;
+//# sourceMappingURL=arithmetic.d.ts.map

package/build/matrices/arithmetic.d.ts.map

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