@pawells/math-extended 2.0.0 → 3.0.0

package/build/matrices/arithmetic.d.ts

@@ -1,5 +1,5 @@
-import { TMatrix, TMatrix1, TMatrix2, TMatrix3, TMatrix4, TMatrixResult } from './types.js';
-import { TVector, TVector2, TVector3, TVector4 } from '../vectors/types.js';
+import type { TMatrix, TMatrix1, TMatrix2, TMatrix3, TMatrix4, TMatrixResult } from './types.js';
+import type { TVector, TVector2, TVector3, TVector4 } from '../vectors/types.js';
 /**
  * Performs element-wise addition of two matrices.
  *
@@ -26,18 +26,18 @@ import { TVector, TVector2, TVector3, TVector4 } from '../vectors/types.js';
  * @throws {Error} If matrices have different dimensions or contain invalid values
  *
  * @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: TMatrix2 = [[1, 2], [3, 4]];
-     * const matrixB: TMatrix2 = [[5, 6], [7, 8]];
-     * const result: TMatrix2 = 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 TMatrix>(a: T, b: T): TMatrixResult<T>;
 /**
@@ -66,17 +66,17 @@ export declare function MatrixAdd<T extends TMatrix>(a: T, b: T): TMatrixResult<
  * @throws {Error} If matrices have different dimensions or contain invalid values
  *
  * @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]]
-     * ```
-     * ```
+ * ```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 TMatrix>(a: T, b: T): TMatrixResult<T>;
 /**
@@ -133,33 +133,33 @@ export declare function MatrixSubtract<T extends TMatrix>(a: T, b: T): TMatrixRe
  * @throws {Error} If matrix dimensions are incompatible for multiplication
  *
  * @example
-     * ```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
-     * ```
-     * ```
+ * ```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: TMatrix1, b: number): TMatrix1;
 export declare function MatrixMultiply(a: TMatrix2, b: number): TMatrix2;
@@ -218,29 +218,29 @@ export declare function MatrixMultiply(a: TMatrix, b: number): TMatrix;
  * @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
-     * 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: TMatrix, startCol: number, startRow: number, width: number, height: number): TMatrix;
 /**
@@ -284,33 +284,33 @@ export declare function MatrixSubmatrix(matrix: TMatrix, startCol: number, start
  * @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:
-     * // [[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: TMatrix, newRows: number, newCols: number): TMatrix;
 /**
@@ -365,36 +365,36 @@ export declare function MatrixPad(matrix: TMatrix, newRows: number, newCols: num
  * @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);
-     * 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: 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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"}