@pawells/math-extended 1.1.1 → 2.0.0

package/build/matrices/arithmetic.d.ts

@@ -1,4 +1,4 @@
-import { IMatrix, IMatrix1, IMatrix2, IMatrix3, IMatrix4, TMatrixResult } from './types.js';
+import { TMatrix, TMatrix1, TMatrix2, TMatrix3, TMatrix4, TMatrixResult } from './types.js';
 import { TVector, TVector2, TVector3, TVector4 } from '../vectors/types.js';
 /**
  * Performs element-wise addition of two matrices.
@@ -19,27 +19,27 @@ import { TVector, TVector2, TVector3, TVector4 } from '../vectors/types.js';
  * **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
+ * @template T - The matrix type extending TMatrix 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);
- * ```
+     * ```typescript
+     * ```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: TMatrix2 = [[1, 2], [3, 4]];
+     * const matrixB: TMatrix2 = [[5, 6], [7, 8]];
+     * const result: TMatrix2 = MatrixAdd(matrixA, matrixB);
+     * ```
+     * ```
  */
-export declare function MatrixAdd<T extends IMatrix>(a: T, b: T): TMatrixResult<T>;
+export declare function MatrixAdd<T extends TMatrix>(a: T, b: T): TMatrixResult<T>;
 /**
  * Performs element-wise subtraction of two matrices (a - b).
  *
@@ -59,26 +59,26 @@ export declare function MatrixAdd<T extends IMatrix>(a: T, b: T): TMatrixResult<
  * **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
+ * @template T - The matrix type extending TMatrix 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]]
- * ```
+     * ```typescript
+     * ```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>;
+export declare function MatrixSubtract<T extends TMatrix>(a: T, b: T): TMatrixResult<T>;
 /**
  * Performs matrix multiplication with comprehensive type-safe overloads for matrices, vectors, and scalars.
  *
@@ -89,24 +89,24 @@ export declare function MatrixSubtract<T extends IMatrix>(a: T, b: T): TMatrixRe
  *
  * **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)
+ *   - `TMatrix1 × number → TMatrix1` (1×1 matrix scalar multiplication)
+ *   - `TMatrix2 × number → TMatrix2` (2×2 matrix scalar multiplication)
+ *   - `TMatrix3 × number → TMatrix3` (3×3 matrix scalar multiplication)
+ *   - `TMatrix4 × number → TMatrix4` (4×4 matrix scalar multiplication)
+ *   - `TMatrix × number → TMatrix` (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)
+ *   - `TMatrix2 × TVector2 → TVector2` (2×2 matrix × 2D vector)
+ *   - `TMatrix3 × TVector3 → TVector3` (3×3 matrix × 3D vector)
+ *   - `TMatrix4 × TVector4 → TVector4` (4×4 matrix × 4D vector)
+ *   - `TMatrix × 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)
+ *   - `TMatrix1 × TMatrix1 → TMatrix1` (1×1 matrix multiplication)
+ *   - `TMatrix2 × TMatrix2 → TMatrix2` (2×2 matrix multiplication)
+ *   - `TMatrix3 × TMatrix3 → TMatrix3` (3×3 matrix multiplication)
+ *   - `TMatrix4 × TMatrix4 → TMatrix4` (4×4 matrix multiplication)
+ *   - `TMatrix × TMatrix → TMatrix` (general matrix multiplication)
  *
  * **Operation Types:**
  * - **Matrix × Scalar:** Element-wise multiplication by scalar value
@@ -126,59 +126,55 @@ export declare function MatrixSubtract<T extends IMatrix>(a: T, b: T): TMatrixRe
  *
  * @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:
+ * @returns {TMatrix | 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
- * ```
+     * ```typescript
+     * ```typescript
+     * // Type-safe scalar multiplication with specific matrix types
+     * const matrix2: TMatrix2 = [[1, 2], [3, 4]];
+     * const scalar2Result: TMatrix2 = MatrixMultiply(matrix2, 2); // [[2, 4], [6, 8]]
+     * const matrix3: TMatrix3 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
+     * const scalar3Result: TMatrix3 = MatrixMultiply(matrix3, 5); // Identity × 5
+     * // Type-safe vector multiplication with specific matrix/vector types
+     * const matrix2x2: TMatrix2 = [[1, 2], [3, 4]];
+     * const vector2: TVector2 = [5, 6];
+     * const vectorResult: TVector2 = MatrixMultiply(matrix2x2, vector2); // [17, 39]
+     * const matrix4x4: TMatrix4 = [[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: TMatrix2 = [[1, 2], [3, 4]];
+     * const matrixB: TMatrix2 = [[5, 6], [7, 8]];
+     * const matrixResult: TMatrix2 = 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;
+export declare function MatrixMultiply(a: TMatrix1, b: number): TMatrix1;
+export declare function MatrixMultiply(a: TMatrix2, b: number): TMatrix2;
+export declare function MatrixMultiply(a: TMatrix3, b: number): TMatrix3;
+export declare function MatrixMultiply(a: TMatrix4, b: number): TMatrix4;
+export declare function MatrixMultiply(a: TMatrix2, b: TVector2): TVector2;
+export declare function MatrixMultiply(a: TMatrix3, b: TVector3): TVector3;
+export declare function MatrixMultiply(a: TMatrix4, b: TVector4): TVector4;
+export declare function MatrixMultiply(a: TMatrix1, b: TMatrix1): TMatrix1;
+export declare function MatrixMultiply(a: TMatrix2, b: TMatrix2): TMatrix2;
+export declare function MatrixMultiply(a: TMatrix3, b: TMatrix3): TMatrix3;
+export declare function MatrixMultiply(a: TMatrix4, b: TMatrix4): TMatrix4;
+export declare function MatrixMultiply(a: TMatrix, b: TVector): TVector;
+export declare function MatrixMultiply(a: TMatrix, b: TMatrix): TMatrix;
+export declare function MatrixMultiply(a: TMatrix, b: number): TMatrix;
 /**
  * Extracts a rectangular submatrix from a larger matrix.
  *
@@ -219,37 +215,34 @@ export declare function MatrixMultiply(a: IMatrix, b: number): IMatrix;
  * @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
+ * @returns {TMatrix} 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
- * ```
+     * ```typescript
+     * ```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;
+export declare function MatrixSubmatrix(matrix: TMatrix, startCol: number, startRow: number, width: number, height: number): TMatrix;
 /**
  * Pads a matrix with zeros to reach the specified dimensions.
  *
@@ -288,41 +281,38 @@ export declare function MatrixSubmatrix(matrix: IMatrix, startCol: number, start
  * @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
+ * @returns {TMatrix} 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
- * ```
+     * ```typescript
+     * ```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;
+export declare function MatrixPad(matrix: TMatrix, newRows: number, newCols: number): TMatrix;
 /**
  * Combines four square submatrices into a single matrix (2×2 block structure).
  *
@@ -371,41 +361,40 @@ export declare function MatrixPad(matrix: IMatrix, newRows: number, newCols: num
  * @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)
+ * @returns {TMatrix} 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
- * );
- * ```
+     * ```typescript
+     * ```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;
+export declare function MatrixCombine(c11: TMatrix, c12: TMatrix, c21: TMatrix, c22: TMatrix): TMatrix;
 //# sourceMappingURL=arithmetic.d.ts.map

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

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