@pawells/math-extended 1.0.5 → 2.0.0

package/build/matrices/asserts.d.ts

@@ -1,5 +1,5 @@
 import { IAssertException } from '@pawells/typescript-common';
-import { IMatrix, IMatrix1, IMatrix2, IMatrix3, IMatrix4 } from './types.js';
+import { TMatrix, TMatrix1, TMatrix2, TMatrix3, TMatrix4 } from './types.js';
 /**
  * Configuration options for matrix validation constraints.
  *
@@ -9,19 +9,18 @@ import { IMatrix, IMatrix1, IMatrix2, IMatrix3, IMatrix4 } from './types.js';
  *
  * @interface IAssertMatrixArgs
  * @example
- * ```typescript
- * // Validate a square matrix of any size
- * const squareArgs: IAssertMatrixArgs = { square: true };
- *
- * // Validate minimum dimensions
- * const minSizeArgs: IAssertMatrixArgs = { minRows: 2, minColumns: 3 };
- *
- * // Validate exact size using tuple
- * const exactSizeArgs: IAssertMatrixArgs = { size: [4, 5] };
- *
- * // Validate square matrix with exact size
- * const squareExactArgs: IAssertMatrixArgs = { square: true, size: 3 };
- * ```
+     * ```typescript
+     * ```typescript
+     * // Validate a square matrix of any size
+     * const squareArgs: IAssertMatrixArgs = { square: true };
+     * // Validate minimum dimensions
+     * const minSizeArgs: IAssertMatrixArgs = { minRows: 2, minColumns: 3 };
+     * // Validate exact size using tuple
+     * const exactSizeArgs: IAssertMatrixArgs = { size: [4, 5] };
+     * // Validate square matrix with exact size
+     * const squareExactArgs: IAssertMatrixArgs = { square: true, size: 3 };
+     * ```
+     * ```
  */
 interface IAssertMatrixArgs {
     /** Minimum number of rows required in the matrix */
@@ -55,15 +54,16 @@ interface IAssertMatrixArgs {
  *
  * @interface IAssertMatricesArgs
  * @example
- * ```typescript
- * // Standard compatibility (same dimensions for addition/subtraction)
- * const standardArgs: IAssertMatricesArgs = {};
- *
- * // Allow transposed compatibility for multiplication
- * const transposedArgs: IAssertMatricesArgs = { transposition: true };
- * ```
+     * ```typescript
+     * ```typescript
+     * // Standard compatibility (same dimensions for addition/subtraction)
+     * const standardArgs: IAssertMatricesArgs = {};
+     * // Allow transposed compatibility for multiplication
+     * const transposedArgs: IAssertMatricesArgs = { transposition: true };
+     * ```
+     * ```
  */
-interface IAssertMatricesArgs {
+export interface IAssertMatricesArgs {
     /**
      * Whether to allow transposed dimensions between matrices.
      * When true, matrices A (m×n) and B (n×m) are considered compatible.
@@ -98,26 +98,33 @@ interface IAssertMatrixException extends IAssertException {
  * @class MatrixError
  * @extends Error
  * @example
- * ```typescript
- * try {
- *   AssertMatrix(invalidMatrix);
- * } catch (error) {
- *   if (error instanceof MatrixError) {
- *     console.log('Matrix validation failed:', error.message);
- *   }
- * }
- * ```
+     * ```typescript
+     * ```typescript
+     * try {
+     *   AssertMatrix(invalidMatrix);
+     * } catch (error) {
+     *   if (error instanceof MatrixError) {
+     *     console.log('Matrix validation failed:', error.message);
+     *   }
+     * }
+     * ```
+     * ```
  */
 export declare class MatrixError extends Error {
+    readonly code: string;
     /**
      * Creates a new MatrixError instance.
      *
-     * @param message - Optional error message describing the validation failure
+     * @param message - Error message describing the validation failure
+     * @param options - Optional error context
+     * @param options.cause - Original error that caused this error
      */
-    constructor(message?: string);
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
 }
 /**
- * Validates that an unknown value is a valid matrix conforming to the IMatrix interface.
+ * Validates that an unknown value is a valid matrix conforming to the TMatrix interface.
  *
  * This function performs comprehensive validation of matrix structure including:
  * - Type checking to ensure the value is a proper matrix
@@ -131,18 +138,18 @@ export declare class MatrixError extends Error {
  * @throws {IAssertException} When the matrix doesn't meet the specified criteria
  *
  * @example
- * ```typescript
- * // Validate a 3x3 square matrix
- * AssertMatrix(someValue, { square: true, size: 3 });
- *
- * // Validate minimum dimensions
- * AssertMatrix(someValue, { minRows: 2, minColumns: 3 });
- *
- * // Validate exact dimensions
- * AssertMatrix(someValue, { rows: 4, columns: 5 });
- * ```
+     * ```typescript
+     * ```typescript
+     * // Validate a 3x3 square matrix
+     * AssertMatrix(someValue, { square: true, size: 3 });
+     * // Validate minimum dimensions
+     * AssertMatrix(someValue, { minRows: 2, minColumns: 3 });
+     * // Validate exact dimensions
+     * AssertMatrix(someValue, { rows: 4, columns: 5 });
+     * ```
+     * ```
  */
-export declare function AssertMatrix(matrix: unknown, args?: IAssertMatrixArgs, exception?: IAssertMatrixException): asserts matrix is IMatrix;
+export declare function AssertMatrix(matrix: unknown, args?: IAssertMatrixArgs, exception?: IAssertMatrixException): asserts matrix is TMatrix;
 /**
  * Validates that an unknown value is a valid matrix row (array of numbers).
  *
@@ -150,21 +157,20 @@ export declare function AssertMatrix(matrix: unknown, args?: IAssertMatrixArgs,
  * which should be an array containing only numeric values.
  *
  * @param row - The value to validate as a matrix row
- * @param exception - Custom exception details if validation fails
- * @param rowIndex - Optional row index for more descriptive error messages
- * @throws {IAssertException} When the row is not a valid array of numbers
+ * @param exception - Custom exception details (optionally includes `rowIndex` for richer messages)
+ * @throws {MatrixError} When the row is not a valid array of finite numbers
  *
  * @example
- * ```typescript
- * // Validate a matrix row
- * AssertMatrixRow([1, 2, 3, 4]);
- *
- * // Validate with row index for better error messages
- * AssertMatrixRow([1, 2, 3, 4], {}, 0);
- *
- * // This would throw an exception
- * AssertMatrixRow([1, "2", 3]); // Contains non-numeric value
- * ```
+     * ```typescript
+     * ```typescript
+     * // Validate a matrix row
+     * AssertMatrixRow([1, 2, 3, 4]);
+     * // Validate with row index in exception for better error messages
+     * AssertMatrixRow([1, 2, 3, 4], { rowIndex: 0 });
+     * // This would throw MatrixError
+     * AssertMatrixRow([1, '2', 3]); // Contains non-numeric value
+     * ```
+     * ```
  */
 export declare function AssertMatrixRow(row: unknown, exception?: IAssertMatrixException): asserts row is number[];
 /**
@@ -174,24 +180,22 @@ export declare function AssertMatrixRow(row: unknown, exception?: IAssertMatrixE
  * which should be a finite number (not NaN, Infinity, or -Infinity).
  *
  * @param value - The value to validate as a matrix element
- * @param exception - Custom exception details if validation fails
- * @param rowIndex - Optional row index for more descriptive error messages
- * @param columnIndex - Optional column index for more descriptive error messages
- * @throws {IAssertException} When the value is not a finite number
+ * @param exception - Custom exception details (optionally includes `rowIndex` and `columnIndex` for richer messages)
+ * @throws {MatrixError} When the value is not a finite number
  *
  * @example
- * ```typescript
- * // Validate a matrix element
- * AssertMatrixValue(42);
- *
- * // Validate with position information for better error messages
- * AssertMatrixValue(3.14, {}, 0, 1);
- *
- * // This would throw an exception
- * AssertMatrixValue(NaN); // Not a finite number
- * AssertMatrixValue(Infinity); // Not a finite number
- * AssertMatrixValue("5"); // Not a number
- * ```
+     * ```typescript
+     * ```typescript
+     * // Validate a matrix element
+     * AssertMatrixValue(42);
+     * // Validate with position information for better error messages
+     * AssertMatrixValue(3.14, { rowIndex: 0, columnIndex: 1 });
+     * // These would throw MatrixError
+     * AssertMatrixValue(NaN);      // Not a number
+     * AssertMatrixValue(Infinity); // Not a finite number
+     * AssertMatrixValue('5');      // Not a number type
+     * ```
+     * ```
  */
 export declare function AssertMatrixValue(value: unknown, exception?: IAssertMatrixException): asserts value is number;
 /**
@@ -208,13 +212,14 @@ export declare function AssertMatrixValue(value: unknown, exception?: IAssertMat
  * @throws {IAssertException} When the matrices are not compatible
  *
  * @example
- * ```typescript
- * // Validate matrices for multiplication (A columns must equal B rows)
- * AssertMatrices(matrixA, matrixB);
- *
- * // Allow transposed compatibility
- * AssertMatrices(matrixA, matrixB, { transposition: true });
- * ```
+     * ```typescript
+     * ```typescript
+     * // Validate matrices for multiplication (A columns must equal B rows)
+     * AssertMatrices(matrixA, matrixB);
+     * // Allow transposed compatibility
+     * AssertMatrices(matrixA, matrixB, { transposition: true });
+     * ```
+     * ```
  */
 export declare function AssertMatrices(a: unknown, b: unknown, args?: IAssertMatricesArgs, exception?: IAssertMatrixException): void;
 /**
@@ -228,15 +233,16 @@ export declare function AssertMatrices(a: unknown, b: unknown, args?: IAssertMat
  * @throws {IAssertException} When the matrix is not a valid 1x1 matrix
  *
  * @example
- * ```typescript
- * // Validate a 1x1 matrix
- * AssertMatrix1([[5]]);
- *
- * // This would throw an exception
- * AssertMatrix1([[1, 2]]); // Too many columns
- * ```
+     * ```typescript
+     * ```typescript
+     * // Validate a 1x1 matrix
+     * AssertMatrix1([[5]]);
+     * // This would throw an exception
+     * AssertMatrix1([[1, 2]]); // Too many columns
+     * ```
+     * ```
  */
-export declare function AssertMatrix1(matrix: unknown, exception?: IAssertMatrixException): asserts matrix is IMatrix1;
+export declare function AssertMatrix1(matrix: unknown, exception?: IAssertMatrixException): asserts matrix is TMatrix1;
 /**
  * Validates that an unknown value is a valid 2x2 matrix.
  *
@@ -248,15 +254,16 @@ export declare function AssertMatrix1(matrix: unknown, exception?: IAssertMatrix
  * @throws {IAssertException} When the matrix is not a valid 2x2 matrix
  *
  * @example
- * ```typescript
- * // Validate a 2x2 matrix
- * AssertMatrix2([[1, 2], [3, 4]]);
- *
- * // This would throw an exception
- * AssertMatrix2([[1, 2, 3], [4, 5, 6]]); // Too many columns
- * ```
+     * ```typescript
+     * ```typescript
+     * // Validate a 2x2 matrix
+     * AssertMatrix2([[1, 2], [3, 4]]);
+     * // This would throw an exception
+     * AssertMatrix2([[1, 2, 3], [4, 5, 6]]); // Too many columns
+     * ```
+     * ```
  */
-export declare function AssertMatrix2(matrix: unknown, exception?: IAssertMatrixException): asserts matrix is IMatrix2;
+export declare function AssertMatrix2(matrix: unknown, exception?: IAssertMatrixException): asserts matrix is TMatrix2;
 /**
  * Validates that an unknown value is a valid 3x3 matrix.
  *
@@ -268,15 +275,16 @@ export declare function AssertMatrix2(matrix: unknown, exception?: IAssertMatrix
  * @throws {IAssertException} When the matrix is not a valid 3x3 matrix
  *
  * @example
- * ```typescript
- * // Validate a 3x3 matrix
- * AssertMatrix3([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
- *
- * // This would throw an exception
- * AssertMatrix3([[1, 2], [3, 4]]); // Too few rows and columns
- * ```
+     * ```typescript
+     * ```typescript
+     * // Validate a 3x3 matrix
+     * AssertMatrix3([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
+     * // This would throw an exception
+     * AssertMatrix3([[1, 2], [3, 4]]); // Too few rows and columns
+     * ```
+     * ```
  */
-export declare function AssertMatrix3(matrix: unknown, exception?: IAssertMatrixException): asserts matrix is IMatrix3;
+export declare function AssertMatrix3(matrix: unknown, exception?: IAssertMatrixException): asserts matrix is TMatrix3;
 /**
  * Validates that an unknown value is a valid 4x4 matrix.
  *
@@ -287,20 +295,140 @@ export declare function AssertMatrix3(matrix: unknown, exception?: IAssertMatrix
  * @param exception - Custom exception details if validation fails
  * @throws {IAssertException} When the matrix is not a valid 4x4 matrix
  *
+ * @example
+     * ```typescript
+     * ```typescript
+     * // Validate a 4x4 matrix
+     * AssertMatrix4([
+     *   [1, 2, 3, 4],
+     *   [5, 6, 7, 8],
+     *   [9, 10, 11, 12],
+     *   [13, 14, 15, 16]
+     * ]);
+     * // This would throw an exception
+     * AssertMatrix4([[1, 2], [3, 4]]); // Too few rows and columns
+     * ```
+     * ```
+ */
+export declare function AssertMatrix4(matrix: unknown, exception?: IAssertMatrixException): asserts matrix is TMatrix4;
+/**
+ * Validates that an unknown value is a valid matrix without throwing an error.
+ *
+ * This function performs the same validation as AssertMatrix but returns
+ * a boolean instead of throwing an exception, making it suitable for
+ * conditional logic where exceptions are not desired.
+ *
+ * @param matrix - The value to validate as a matrix
+ * @param args - Validation configuration options
+ * @returns true if the matrix is valid, false otherwise
+ *
  * @example
  * ```typescript
- * // Validate a 4x4 matrix
- * AssertMatrix4([
- *   [1, 2, 3, 4],
- *   [5, 6, 7, 8],
- *   [9, 10, 11, 12],
- *   [13, 14, 15, 16]
- * ]);
- *
- * // This would throw an exception
- * AssertMatrix4([[1, 2], [3, 4]]); // Too few rows and columns
+ * if (ValidateMatrix(someValue, { square: true })) {
+ *   // Process the valid square matrix
+ * }
+ * ```
+ */
+export declare function ValidateMatrix(matrix: unknown, args?: IAssertMatrixArgs): matrix is TMatrix;
+/**
+ * Validates that an unknown value is a valid 1×1 matrix without throwing an error.
+ *
+ * @param matrix - The value to validate as a 1×1 matrix
+ * @returns true if the matrix is valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (ValidateMatrix1(someValue)) {
+ *   // Process the valid 1×1 matrix
+ * }
+ * ```
+ */
+export declare function ValidateMatrix1(matrix: unknown): matrix is TMatrix1;
+/**
+ * Validates that an unknown value is a valid 2×2 matrix without throwing an error.
+ *
+ * @param matrix - The value to validate as a 2×2 matrix
+ * @returns true if the matrix is valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (ValidateMatrix2(someValue)) {
+ *   // Process the valid 2×2 matrix
+ * }
+ * ```
+ */
+export declare function ValidateMatrix2(matrix: unknown): matrix is TMatrix2;
+/**
+ * Validates that an unknown value is a valid 3×3 matrix without throwing an error.
+ *
+ * @param matrix - The value to validate as a 3×3 matrix
+ * @returns true if the matrix is valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (ValidateMatrix3(someValue)) {
+ *   // Process the valid 3×3 matrix
+ * }
+ * ```
+ */
+export declare function ValidateMatrix3(matrix: unknown): matrix is TMatrix3;
+/**
+ * Validates that an unknown value is a valid 4×4 matrix without throwing an error.
+ *
+ * @param matrix - The value to validate as a 4×4 matrix
+ * @returns true if the matrix is valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (ValidateMatrix4(someValue)) {
+ *   // Process the valid 4×4 matrix
+ * }
+ * ```
+ */
+export declare function ValidateMatrix4(matrix: unknown): matrix is TMatrix4;
+/**
+ * Validates that an unknown value is a valid matrix row without throwing an error.
+ *
+ * @param row - The value to validate as a matrix row
+ * @returns true if the row is valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (ValidateMatrixRow([1, 2, 3])) {
+ *   // Process the valid row
+ * }
+ * ```
+ */
+export declare function ValidateMatrixRow(row: unknown): row is number[];
+/**
+ * Validates that an unknown value is a valid matrix value (finite number) without throwing an error.
+ *
+ * @param value - The value to validate as a matrix element
+ * @returns true if the value is valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (ValidateMatrixValue(someValue)) {
+ *   // Process the valid numeric value
+ * }
+ * ```
+ */
+export declare function ValidateMatrixValue(value: unknown): value is number;
+/**
+ * Validates that two unknown values are compatible matrices without throwing an error.
+ *
+ * @param a - The first matrix to validate
+ * @param b - The second matrix to validate
+ * @param args - Validation configuration options
+ * @returns true if both matrices are valid and compatible, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (ValidateMatrices(matrixA, matrixB, { transposition: true })) {
+ *   // Process the valid and compatible matrices
+ * }
  * ```
  */
-export declare function AssertMatrix4(matrix: unknown, exception?: IAssertMatrixException): asserts matrix is IMatrix4;
+export declare function ValidateMatrices(a: unknown, b: unknown, args?: IAssertMatricesArgs): boolean;
 export {};
 //# sourceMappingURL=asserts.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"asserts.d.ts","sourceRoot":"","sources":["../../src/matrices/asserts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,gBAAgB,EAAwE,MAAM,4BAA4B,CAAC;AACnJ,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG7E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,UAAU,iBAAiB;IAC1B,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC;CACjC;AACD;;;;;;;;;;;;;;;;GAgBG;AACH,UAAU,mBAAmB;IAC5B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACxB;AACD;;;;;;;;;GASG;AACH,UAAU,sBAAuB,SAAQ,gBAAgB;IACxD,qGAAqG;IACrG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2GAA2G;IAC3G,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACrC;;;;OAIG;gBACS,OAAO,CAAC,EAAE,MAAM;CAM5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,GAAE,iBAAsB,EAAE,SAAS,GAAE,sBAA2B,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CA8F7I;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,GAAE,sBAA2B,GAAG,OAAO,CAAC,GAAG,IAAI,MAAM,EAAE,CAuB7G;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,GAAE,sBAA2B,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAWjH;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,GAAE,mBAAwB,EAAE,SAAS,GAAE,sBAA2B,GAAG,IAAI,CAgDnI;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,GAAE,sBAA2B,GAAG,OAAO,CAAC,MAAM,IAAI,QAAQ,CAOjH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,GAAE,sBAA2B,GAAG,OAAO,CAAC,MAAM,IAAI,QAAQ,CAOjH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,GAAE,sBAA2B,GAAG,OAAO,CAAC,MAAM,IAAI,QAAQ,CAOjH;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,GAAE,sBAA2B,GAAG,OAAO,CAAC,MAAM,IAAI,QAAQ,CAOjH"}
+{"version":3,"file":"asserts.d.ts","sourceRoot":"","sources":["../../src/matrices/asserts.ts"],"names":[],"mappings":"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"}