@pawells/math-extended 1.1.1 → 3.0.0

package/build/matrices/arithmetic.js

@@ -1,8 +1,7 @@
 import { AssertNumber } from '@pawells/typescript-common';
-import { AssertMatrices, AssertMatrix, AssertMatrix1, AssertMatrix2, AssertMatrix3, AssertMatrix4, AssertMatrixRow, AssertMatrixValue } from './asserts.js';
-import { MatrixCreate, MatrixIsSquare, MatrixSize } from './core.js';
-import { VectorIsValid } from '../vectors/core.js';
-import { AssertVector } from '../vectors/asserts.js';
+import { AssertMatricesCompatible, AssertMatrix, AssertMatrix1, AssertMatrix2, AssertMatrix3, AssertMatrix4, AssertMatrixSquare, MatrixError } from './asserts.js';
+import { MatrixCreate, MatrixSize } from './core.js';
+import { ValidateVector, AssertVector } from '../vectors/asserts.js';
 /**
  * Performs element-wise addition of two matrices.
  *
@@ -22,7 +21,7 @@ import { AssertVector } from '../vectors/asserts.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
@@ -30,41 +29,39 @@ import { AssertVector } from '../vectors/asserts.js';
  *
  * @example
  * ```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: IMatrix2 = [[1, 2], [3, 4]];
- * const matrixB: IMatrix2 = [[5, 6], [7, 8]];
- * const result: IMatrix2 = MatrixAdd(matrixA, matrixB);
+ * const matrixA: TMatrix2 = [[1, 2], [3, 4]];
+ * const matrixB: TMatrix2 = [[5, 6], [7, 8]];
+ * const result: TMatrix2 = MatrixAdd(matrixA, matrixB);
+ * ```
  * ```
  */
 export function MatrixAdd(a, b) {
     // Validate matrices have compatible dimensions for addition
-    AssertMatrices(a, b);
-    // Initialize result matrix with same dimensions as inputs
+    AssertMatrix(a);
+    AssertMatrix(b);
+    AssertMatricesCompatible(a, b);
+    // Ensure matrices have the same dimensions
     const [arows, acols] = MatrixSize(a);
+    // Initialize result matrix with same dimensions as inputs
     const result = MatrixCreate(arows, acols);
     // Perform element-wise addition: C[i,j] = A[i,j] + B[i,j]
     for (let row = 0; row < arows; row++) {
         // Get row references for both input matrices
         const aRow = a[row];
-        AssertMatrixRow(aRow);
         const bRow = b[row];
-        AssertMatrixRow(bRow);
         // Get reference to result row for efficient access
         const resultRow = result[row];
-        AssertMatrixRow(resultRow);
         // Add corresponding elements column by column
         for (let col = 0; col < acols; col++) {
             // Validate and extract values from both matrices
             const aVal = aRow[col];
-            AssertMatrixValue(aVal, { rowIndex: row, columnIndex: col });
             const bVal = bRow[col];
-            AssertMatrixValue(bVal, { rowIndex: row, columnIndex: col });
             // Store sum in result matrix
             resultRow[col] = aVal + bVal;
         }
@@ -90,7 +87,7 @@ export function MatrixAdd(a, b) {
  * **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
@@ -98,20 +95,22 @@ export function MatrixAdd(a, b) {
  *
  * @example
  * ```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 function MatrixSubtract(a, b) {
     // Validate matrices have compatible dimensions for subtraction
-    AssertMatrices(a, b);
+    AssertMatrix(a);
+    AssertMatrix(b);
+    AssertMatricesCompatible(a, b);
     // Initialize result matrix with same dimensions as inputs
     const [arows, acols] = MatrixSize(a);
     const result = MatrixCreate(arows, acols);
@@ -119,18 +118,13 @@ export function MatrixSubtract(a, b) {
     for (let row = 0; row < arows; row++) {
         // Get row references for both input matrices
         const aRow = a[row];
-        AssertMatrixRow(aRow);
         const bRow = b[row];
-        AssertMatrixRow(bRow);
         // Get reference to result row for efficient access
         const resultRow = result[row];
-        AssertMatrixRow(resultRow);
         // Subtract corresponding elements column by column
         for (let col = 0; col < acols; col++) {
             const aVal = aRow[col];
-            AssertMatrixValue(aVal, { rowIndex: row, columnIndex: col });
             const bVal = bRow[col];
-            AssertMatrixValue(bVal, { rowIndex: row, columnIndex: col });
             // Store difference in result matrix
             resultRow[col] = aVal - bVal;
         }
@@ -142,7 +136,7 @@ export function MatrixMultiply(a, b) {
     // Route to appropriate multiplication algorithm based on operand type
     if (typeof b === 'number')
         return matrixMultiplyScalar(a, b);
-    if (VectorIsValid(b))
+    if (ValidateVector(b))
         return matrixMultiplyVector(a, b);
     return matrixMultiplyMatrix(a, b);
 }
@@ -154,13 +148,10 @@ function matrixMultiplyScalar(matrix, scalar) {
     // Apply scalar multiplication to each matrix element
     for (let row = 0; row < rows; row++) {
         const matrixRow = matrix[row];
-        AssertMatrixRow(matrixRow);
         const resultRow = result[row];
-        AssertMatrixRow(resultRow);
         // Multiply each element in the row by the scalar
         for (let col = 0; col < cols; col++) {
             const val = matrixRow[col];
-            AssertMatrixValue(val, { rowIndex: row, columnIndex: col });
             resultRow[col] = val * scalar;
         }
     }
@@ -173,25 +164,21 @@ function matrixMultiplyVector(matrix, vector) {
     // Get matrix dimensions
     const [matrixRows, matrixCols] = MatrixSize(matrix);
     // Verify dimensional compatibility: matrix columns must equal vector length
-    if (matrixCols !== vector.length) {
+    if (matrixCols !== vector.length)
         throw new Error(`Matrix-vector multiplication requires matrix columns (${matrixCols}) to equal vector length (${vector.length})`);
-    }
     // Initialize result vector with same length as matrix rows
     const result = new Array(matrixRows);
     // Compute each element of the result vector
     for (let row = 0; row < matrixRows; row++) {
         // Get matrix row reference
         const matrixRow = matrix[row];
-        AssertMatrixRow(matrixRow);
         // Compute dot product of matrix row with vector
         let dotProduct = 0;
         for (let col = 0; col < matrixCols; col++) {
             // Validate matrix element
             const matrixElement = matrixRow[col];
-            AssertMatrixValue(matrixElement, { rowIndex: row, columnIndex: col });
             // Validate vector element
             const vectorElement = vector[col];
-            AssertNumber(vectorElement);
             // Add to dot product
             dotProduct += matrixElement * vectorElement;
         }
@@ -202,13 +189,15 @@ function matrixMultiplyVector(matrix, vector) {
 }
 function matrixMultiplyMatrix(a, b) {
     // Validate matrices are compatible for multiplication (a.columns === b.rows)
-    AssertMatrices(a, b, { transposition: true });
+    AssertMatrix(a);
+    AssertMatrix(b);
     const [arows, acols] = MatrixSize(a);
-    const aSquare = MatrixIsSquare(a);
     const [brows, bcols] = MatrixSize(b);
-    const bSquare = MatrixIsSquare(b);
+    if (acols !== brows) {
+        throw new MatrixError(`Cannot multiply matrices: [${arows}×${acols}] × [${brows}×${bcols}] - columns of first matrix must equal rows of second matrix`);
+    }
     // Use optimized algorithms for specific square matrix sizes
-    if (aSquare && bSquare && arows === brows && acols === bcols) {
+    if (arows === acols && brows === bcols && arows === brows && acols === bcols) {
         const aSizeSquare = arows;
         if (aSizeSquare === 1) {
             AssertMatrix1(a);
@@ -241,19 +230,14 @@ function matrixMultiplyMatrix(a, b) {
     // Iterate through each position in the result matrix
     for (let row = 0; row < arows; row++) {
         const aRow = a[row];
-        AssertMatrixRow(aRow);
         const resultRow = result[row];
-        AssertMatrixRow(resultRow);
         for (let col = 0; col < bcols; col++) {
             let sum = 0;
             // Compute dot product of matrix A row with matrix B column
             for (let k = 0; k < acols; k++) {
                 const aVal = aRow[k];
-                AssertMatrixValue(aVal, { rowIndex: row, columnIndex: k });
                 const bRow = b[k];
-                AssertMatrixRow(bRow);
                 const bVal = bRow[col];
-                AssertMatrixValue(bVal, { rowIndex: k, columnIndex: col });
                 // Skip multiplication if either operand is zero (performance optimization)
                 if (aVal === 0 || bVal === 0)
                     continue;
@@ -283,21 +267,20 @@ function matrixMultiplyMatrix(a, b) {
  *
  * @param a - First 1×1 matrix [[a]]
  * @param b - Second 1×1 matrix [[b]]
- * @returns {IMatrix1} The product as a 1×1 matrix [[a×b]]
+ * @returns {TMatrix1} The product as a 1×1 matrix [[a×b]]
  *
  * @example
  * ```typescript
- * // Simple scalar values in matrix form
- * matrixMultiplyMatrix1([[5]], [[3]]) // Returns [[15]]
- *
- * // Decimal multiplication
- * matrixMultiplyMatrix1([[2.5]], [[4]]) // Returns [[10]]
- *
- * // Negative values
- * matrixMultiplyMatrix1([[-3]], [[7]]) // Returns [[-21]]
- *
- * // Zero multiplication
- * matrixMultiplyMatrix1([[0]], [[999]]) // Returns [[0]]
+ * ```typescript
+     * // Simple scalar values in matrix form
+     * matrixMultiplyMatrix1([[5]], [[3]]) // Returns [[15]]
+     * // Decimal multiplication
+     * matrixMultiplyMatrix1([[2.5]], [[4]]) // Returns [[10]]
+     * // Negative values
+     * matrixMultiplyMatrix1([[-3]], [[7]]) // Returns [[-21]]
+     * // Zero multiplication
+     * matrixMultiplyMatrix1([[0]], [[999]]) // Returns [[0]]
+ * ```
  * ```
  */
 function matrixMultiplyMatrix1(a, b) {
@@ -328,24 +311,24 @@ function matrixMultiplyMatrix1(a, b) {
  *
  * @param a - First 2×2 matrix
  * @param b - Second 2×2 matrix
- * @returns {IMatrix2} The product as a 2×2 matrix
+ * @returns {TMatrix2} The product as a 2×2 matrix
  * @example
  * ```typescript
+ * ```typescript
  * // Standard 2x2 multiplication
  * matrixMultiplyMatrix2([[1, 2], [3, 4]], [[5, 6], [7, 8]])
  * // Returns [[19, 22], [43, 50]]
  * // Calculation:
  * // [1*5+2*7, 1*6+2*8] = [19, 22]
  * // [3*5+4*7, 3*6+4*8] = [43, 50]
- *
  * // 2D rotation by 90 degrees (rotation matrix)
  * matrixMultiplyMatrix2([[0, -1], [1, 0]], [[1, 0], [0, 1]])
  * // Returns [[0, -1], [1, 0]]
- *
  * // Scaling transformation
  * matrixMultiplyMatrix2([[2, 0], [0, 3]], [[1, 2], [3, 4]])
  * // Returns [[2, 4], [9, 12]]
  * ```
+ * ```
  */
 function matrixMultiplyMatrix2(a, b) {
     return [
@@ -387,22 +370,22 @@ function matrixMultiplyMatrix2(a, b) {
  *
  * @param a - First 3×3 matrix
  * @param b - Second 3×3 matrix
- * @returns {IMatrix3} The product as a 3×3 matrix
+ * @returns {TMatrix3} The product as a 3×3 matrix
  * @example
  * ```typescript
+ * ```typescript
  * // 3D rotation matrix multiplication (combining rotations)
  * const rotX = [[1, 0, 0], [0, 0.707, -0.707], [0, 0.707, 0.707]]; // X rotation
  * const rotY = [[0.707, 0, 0.707], [0, 1, 0], [-0.707, 0, 0.707]]; // Y rotation
  * matrixMultiplyMatrix3(rotX, rotY) // Combined X-Y rotation
- *
  * // Identity matrix test
  * matrixMultiplyMatrix3([[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
  * // Returns [[1, 2, 3], [4, 5, 6], [7, 8, 9]] (unchanged)
- *
  * // Scaling transformation
  * matrixMultiplyMatrix3([[2, 0, 0], [0, 3, 0], [0, 0, 4]], [[1, 1, 1], [1, 1, 1], [1, 1, 1]])
  * // Returns [[2, 2, 2], [3, 3, 3], [4, 4, 4]]
  * ```
+ * ```
  */
 function matrixMultiplyMatrix3(a, b) {
     return [
@@ -459,24 +442,24 @@ function matrixMultiplyMatrix3(a, b) {
  *
  * @param a - First 4×4 matrix (typically a transformation matrix)
  * @param b - Second 4×4 matrix (typically another transformation matrix)
- * @returns {IMatrix4} The product as a 4×4 matrix (combined transformation)
+ * @returns {TMatrix4} The product as a 4×4 matrix (combined transformation)
  * @example
  * ```typescript
+ * ```typescript
  * // Combine translation and rotation matrices (common in 3D graphics)
  * const translation = [[1,0,0,5], [0,1,0,3], [0,0,1,0], [0,0,0,1]]; // Translate by (5,3,0)
  * const rotation = [[0,-1,0,0], [1,0,0,0], [0,0,1,0], [0,0,0,1]];    // 90° Z rotation
  * matrixMultiplyMatrix4(translation, rotation); // Combined transform
- *
  * // Identity matrix test (should return unchanged matrix)
  * const testMatrix = [[1,2,3,4], [5,6,7,8], [9,10,11,12], [13,14,15,16]];
  * const identity = [[1,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]];
  * matrixMultiplyMatrix4(testMatrix, identity) // Returns testMatrix unchanged
- *
  * // Perspective projection matrix combination
  * const projection = [[2,0,0,0], [0,2,0,0], [0,0,-1,-1], [0,0,-2,0]];
  * const view = [[1,0,0,0], [0,1,0,0], [0,0,1,-10], [0,0,0,1]];
  * matrixMultiplyMatrix4(projection, view); // Combined projection-view matrix
  * ```
+ * ```
  */
 function matrixMultiplyMatrix4(a, b) {
     return [
@@ -556,39 +539,39 @@ function matrixMultiplyMatrix4(a, b) {
  *
  * @param a - First square matrix (must be same size as b)
  * @param b - Second square matrix (must be same size as a)
- * @returns {IMatrix} The product matrix with same dimensions as inputs
+ * @returns {TMatrix} The product matrix with same dimensions as inputs
  * @throws {Error} If matrices are not square or have incompatible dimensions
  *
  * @example
  * ```typescript
+ * ```typescript
  * // Large matrix multiplication (automatically used for 32×32 and larger)
  * const size = 256;
  * const largeA = MatrixCreate(size, size); // Create 256×256 matrix
  * const largeB = MatrixCreate(size, size); // Create 256×256 matrix
  * // ... fill matrices with data ...
  * const result = matrixMultiplyStrassen(largeA, largeB); // Uses Strassen algorithm
- *
  * // Performance comparison for large matrices:
  * // Standard O(n³): ~16.8M operations for 256×256
  * // Strassen O(n^2.807): ~11.2M operations for 256×256 (33% reduction)
- *
  * // Odd-sized matrices are automatically handled with padding
  * const oddMatrix = MatrixCreate(127, 127); // Will be padded to 128×128 internally
  * const result2 = matrixMultiplyStrassen(oddMatrix, oddMatrix);
- *
  * // Base case automatically falls back to standard algorithm
  * const small = MatrixCreate(16, 16); // Uses standard algorithm (< 32×32)
  * const result3 = matrixMultiplyStrassen(small, small);
  * ```
+ * ```
  */
 function matrixMultiplyStrassen(a, b) {
-    AssertMatrix(a, { square: true });
-    AssertMatrix(b, { square: true });
+    AssertMatrix(a);
+    AssertMatrixSquare(a);
+    AssertMatrix(b);
+    AssertMatrixSquare(b);
     const [arows, _acols] = MatrixSize(a);
     const [brows, _bcols] = MatrixSize(b);
-    if (arows !== brows) {
+    if (arows !== brows)
         throw new Error(`Matrix dimensions incompatible for multiplication: ${arows}×${arows} and ${brows}×${brows}`);
-    }
     const n = arows;
     // Base case: use standard multiplication for small matrices to avoid overhead
     if (n < 32) {
@@ -671,28 +654,24 @@ function matrixMultiplyStrassen(a, b) {
  * @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
+ * ```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
@@ -700,6 +679,7 @@ function matrixMultiplyStrassen(a, b) {
  * 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 function MatrixSubmatrix(matrix, startCol, startRow, width, height) {
     AssertMatrix(matrix);
@@ -707,12 +687,9 @@ export function MatrixSubmatrix(matrix, startCol, startRow, width, height) {
     // Copy elements from specified source region to result matrix
     for (let row = 0; row < height; row++) {
         const sourceRow = matrix[startRow + row];
-        AssertMatrixRow(sourceRow);
         const resultRow = result[row];
-        AssertMatrixRow(resultRow);
         for (let col = 0; col < width; col++) {
             const val = sourceRow[startCol + col];
-            AssertMatrixValue(val, { rowIndex: startRow + row, columnIndex: startCol + col });
             resultRow[col] = val;
         }
     }
@@ -756,12 +733,12 @@ export function MatrixSubmatrix(matrix, startCol, startRow, width, height) {
  * @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
+ * ```typescript
  * const matrix = [[1, 2], [3, 4]]; // 2×2 matrix
- *
  * // Pad to 4×4 matrix (symmetric padding)
  * MatrixPad(matrix, 4, 4)
  * // Returns:
@@ -769,26 +746,23 @@ export function MatrixSubmatrix(matrix, startCol, startRow, width, height) {
  * //  [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 function MatrixPad(matrix, newRows, newCols) {
     AssertMatrix(matrix);
@@ -797,12 +771,9 @@ export function MatrixPad(matrix, newRows, newCols) {
     // Copy existing values to top-left corner, zero-fill remaining positions
     for (let row = 0; row < Math.min(currentRows, newRows); row++) {
         const sourceRow = matrix[row];
-        AssertMatrixRow(sourceRow);
         const resultRow = result[row];
-        AssertMatrixRow(resultRow);
         for (let col = 0; col < Math.min(currentCols, newCols); col++) {
             const val = sourceRow[col];
-            AssertMatrixValue(val, { rowIndex: row, columnIndex: col });
             resultRow[col] = val;
         }
     }
@@ -856,31 +827,29 @@ export function MatrixPad(matrix, newRows, newCols) {
  * @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
+ * ```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);
@@ -891,6 +860,7 @@ export function MatrixPad(matrix, newRows, newCols) {
  *   processedBottomLeft, processedBottomRight
  * );
  * ```
+ * ```
  */
 export function MatrixCombine(c11, c12, c21, c22) {
     AssertMatrix(c11);
@@ -904,48 +874,36 @@ export function MatrixCombine(c11, c12, c21, c22) {
     // Copy c11 to top-left quadrant [0:n, 0:n]
     for (let row = 0; row < halfSize; row++) {
         const sourceRow = c11[row];
-        AssertMatrixRow(sourceRow);
         const resultRow = result[row];
-        AssertMatrixRow(resultRow);
         for (let col = 0; col < halfSize; col++) {
             const val = sourceRow[col];
-            AssertMatrixValue(val, { rowIndex: row, columnIndex: col });
             resultRow[col] = val;
         }
     }
     // Copy c12 to top-right quadrant [0:n, n:2n]
     for (let row = 0; row < halfSize; row++) {
         const sourceRow = c12[row];
-        AssertMatrixRow(sourceRow);
         const resultRow = result[row];
-        AssertMatrixRow(resultRow);
         for (let col = 0; col < halfSize; col++) {
             const val = sourceRow[col];
-            AssertMatrixValue(val, { rowIndex: row, columnIndex: col });
             resultRow[col + halfSize] = val;
         }
     }
     // Copy c21 to bottom-left quadrant [n:2n, 0:n]
     for (let row = 0; row < halfSize; row++) {
         const sourceRow = c21[row];
-        AssertMatrixRow(sourceRow);
         const resultRow = result[row + halfSize];
-        AssertMatrixRow(resultRow);
         for (let col = 0; col < halfSize; col++) {
             const val = sourceRow[col];
-            AssertMatrixValue(val, { rowIndex: row, columnIndex: col });
             resultRow[col] = val;
         }
     }
     // Copy c22 to bottom-right quadrant [n:2n, n:2n]
     for (let row = 0; row < halfSize; row++) {
         const sourceRow = c22[row];
-        AssertMatrixRow(sourceRow);
         const resultRow = result[row + halfSize];
-        AssertMatrixRow(resultRow);
         for (let col = 0; col < halfSize; col++) {
             const val = sourceRow[col];
-            AssertMatrixValue(val, { rowIndex: row, columnIndex: col });
             resultRow[col + halfSize] = val;
         }
     }