@pawells/math-extended 2.0.0 → 3.0.0

package/build/matrices/asserts.js

@@ -1,43 +1,5 @@
-import { AssertArray2D, AssertNumber, SetExceptionClass, SetExceptionMessage, ThrowException } from '@pawells/typescript-common';
-import { MatrixSize } from './core.js';
-/**
- * Custom error class for matrix-related validation failures.
- *
- * This error class provides a specific error type for matrix validation
- * failures, making it easier to catch and handle matrix-specific errors
- * separately from other types of errors in your application.
- *
- * @class MatrixError
- * @extends Error
- * @example
-     * ```typescript
-     * ```typescript
-     * try {
-     *   AssertMatrix(invalidMatrix);
-     * } catch (error) {
-     *   if (error instanceof MatrixError) {
-     *     console.log('Matrix validation failed:', error.message);
-     *   }
-     * }
-     * ```
-     * ```
- */
-export class MatrixError extends Error {
-    code = 'MATRIX_ERROR';
-    /**
-     * Creates a new MatrixError instance.
-     *
-     * @param message - Error message describing the validation failure
-     * @param options - Optional error context
-     * @param options.cause - Original error that caused this error
-     */
-    constructor(message, options) {
-        super(message, options);
-        this.name = 'MatrixError';
-        // Maintains proper prototype chain for instanceof checks
-        Object.setPrototypeOf(this, new.target.prototype);
-    }
-}
+import { MatrixSize } from '../index.js';
+import { MATRIX1_SCHEMA, MATRIX2_SCHEMA, MATRIX3_SCHEMA, MATRIX4_SCHEMA, MATRIX_SCHEMA, MATRIX_SQUARE_SCHEMA } from './types.js';
 /**
  * Validates that an unknown value is a valid matrix conforming to the TMatrix interface.
  *
@@ -50,544 +12,138 @@ export class MatrixError extends Error {
  * @param matrix - The value to validate as a matrix
  * @param args - Validation configuration options
  * @param exception - Custom exception details if validation fails
- * @throws {IAssertException} When the matrix doesn't meet the specified criteria
- *
- * @example
-     * ```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 function AssertMatrix(matrix, args = {}, exception = {}) {
-    // Initialize the exception with the default MatrixError class if not provided
-    SetExceptionClass(exception, MatrixError);
-    // First validation: ensure the input is a valid 2D array structure
-    AssertArray2D(matrix, {}, exception);
-    // Second validation: verify all elements are numeric values
-    // Note: We check both type and NaN since NaN has type 'number' but isn't a valid matrix element
-    for (let i = 0; i < matrix.length; i++) {
-        const row = matrix[i];
-        if (row) {
-            for (let j = 0; j < row.length; j++) {
-                if (typeof row[j] !== 'number' || Number.isNaN(row[j])) {
-                    SetExceptionMessage(exception, `Matrix[${i}][${j}] Not a Number`);
-                    ThrowException(exception);
-                }
-            }
-        }
-    }
-    // Extract matrix dimensions for constraint validation
-    const [rows, columns] = MatrixSize(matrix);
-    // Reject empty matrices (zero rows or zero columns)
-    if (rows === 0 || columns === 0) {
-        SetExceptionMessage(exception, 'Matrix must have at least one row and one column');
-        ThrowException(exception);
-    }
-    // Validate exact size constraint when specified as [rows, columns] tuple
-    if (Array.isArray(args.size)) {
-        const [expectedRows, expectedColumns] = args.size;
-        if (rows !== expectedRows) {
-            SetExceptionMessage(exception, `Matrix has ${rows} rows, expected exactly ${expectedRows}`);
-            ThrowException(exception);
-        }
-        if (columns !== expectedColumns) {
-            SetExceptionMessage(exception, `Matrix has ${columns} columns, expected exactly ${expectedColumns}`);
-            ThrowException(exception);
-        }
-    }
-    else if (typeof args.size === 'number') {
-        // Validate exact size constraint when specified as single number (assumes square matrix)
-        if (rows !== args.size) {
-            SetExceptionMessage(exception, `Square matrix has ${rows} rows, expected exactly ${args.size}`);
-            ThrowException(exception);
-        }
-        if (columns !== args.size) {
-            SetExceptionMessage(exception, `Square matrix has ${columns} columns, expected exactly ${args.size}`);
-            ThrowException(exception);
-        }
-    }
-    // Validate exact row count constraint when explicitly specified
-    if (args.rows !== undefined && rows !== args.rows) {
-        SetExceptionMessage(exception, `Matrix has ${rows} rows, expected exactly ${args.rows}`);
-        ThrowException(exception);
-    }
-    // Validate exact column count constraint when explicitly specified
-    if (args.columns !== undefined && columns !== args.columns) {
-        SetExceptionMessage(exception, `Matrix has ${columns} columns, expected exactly ${args.columns}`);
-        ThrowException(exception);
-    }
-    // Validate minimum row count constraint (useful for operations requiring minimum dimensions)
-    if (args.minRows !== undefined && rows < args.minRows) {
-        SetExceptionMessage(exception, `Matrix has ${rows} rows, minimum required is ${args.minRows}`);
-        ThrowException(exception);
-    }
-    // Validate maximum row count constraint (useful for memory or performance limits)
-    if (args.maxRows !== undefined && rows > args.maxRows) {
-        SetExceptionMessage(exception, `Matrix has ${rows} rows, maximum allowed is ${args.maxRows}`);
-        ThrowException(exception);
-    }
-    // Validate minimum column count constraint (useful for operations requiring minimum dimensions)
-    if (args.minColumns !== undefined && columns < args.minColumns) {
-        SetExceptionMessage(exception, `Matrix has ${columns} columns, minimum required is ${args.minColumns}`);
-        ThrowException(exception);
-    }
-    // Validate maximum column count constraint (useful for memory or performance limits)
-    if (args.maxColumns !== undefined && columns > args.maxColumns) {
-        SetExceptionMessage(exception, `Matrix has ${columns} columns, maximum allowed is ${args.maxColumns}`);
-        ThrowException(exception);
-    }
-    // Validate square matrix constraint (required for operations like determinant, inverse, etc.)
-    if (args.square === true && rows !== columns) {
-        SetExceptionMessage(exception, `Matrix must be square but has ${rows} rows and ${columns} columns`);
-        ThrowException(exception);
-    }
-}
-/**
- * Validates that an unknown value is a valid matrix row (array of numbers).
- *
- * This function ensures that the provided value is a proper matrix row,
- * which should be an array containing only numeric values.
- *
- * @param row - The value to validate as a matrix row
- * @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
-     * ```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 function AssertMatrixRow(row, exception = {}) {
-    // Initialize the exception with the default MatrixError class if not provided
-    SetExceptionClass(exception, MatrixError);
-    // First validation: ensure the input is an array
-    if (!Array.isArray(row)) {
-        const rowInfo = exception.rowIndex !== undefined ? ` at row ${exception.rowIndex}` : '';
-        SetExceptionMessage(exception, `Matrix row${rowInfo} must be an array`);
-        ThrowException(exception);
-    }
-    // Safe cast to array since we've verified it's an array
-    const rowArray = row;
-    // Second validation: ensure all elements are finite numbers
-    // This excludes NaN, Infinity, and -Infinity which are technically numbers but invalid for matrices
-    for (let i = 0; i < rowArray.length; i++) {
-        if (typeof rowArray[i] !== 'number' || !isFinite(rowArray[i])) {
-            const rowInfo = exception.rowIndex !== undefined ? ` at row ${exception.rowIndex}` : '';
-            SetExceptionMessage(exception, `Matrix row${rowInfo} element at index ${i} is not a finite number`);
-            ThrowException(exception);
-        }
-    }
-}
-/**
- * Validates that an unknown value is a valid matrix element (finite number).
- *
- * This function ensures that the provided value is a proper matrix element,
- * 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 (optionally includes `rowIndex` and `columnIndex` for richer messages)
- * @throws {MatrixError} When the value is not a finite number
- *
- * @example
-     * ```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 function AssertMatrixValue(value, exception = {}) {
-    // Initialize the exception with the default MatrixError class if not provided
-    SetExceptionClass(exception, MatrixError);
-    // Build position information for error messages when row and column indices are available
-    // This provides more context about where the validation failure occurred
-    const position = exception.rowIndex !== undefined && exception.columnIndex !== undefined ? ` at row ${exception.rowIndex}, column ${exception.columnIndex}` : '';
-    SetExceptionMessage(exception, `Matrix value${position} must be a finite number`);
-    // Delegate to the general number assertion which handles finite number validation
-    // Wrap any thrown error as MatrixError to maintain consistent error handling
-    try {
-        AssertNumber(value, { finite: true }, exception);
-    }
-    catch {
-        // Re-throw as MatrixError to maintain API contract
-        throw new MatrixError(exception.message ?? 'Matrix value must be a finite number');
-    }
-}
-/**
- * Validates compatibility between two matrices for mathematical operations.
- *
- * This function checks that two matrices are compatible for operations like
- * multiplication, addition, or other matrix operations that require specific
- * dimensional relationships.
- *
- * @param a - The first matrix to validate
- * @param b - The second matrix to validate
- * @param args - Validation configuration options
- * @param exception - Custom exception details if validation fails
- * @throws {IAssertException} When the matrices are not compatible
- *
- * @example
-     * ```typescript
-     * ```typescript
-     * // Validate matrices for multiplication (A columns must equal B rows)
-     * AssertMatrices(matrixA, matrixB);
-     * // Allow transposed compatibility
-     * AssertMatrices(matrixA, matrixB, { transposition: true });
-     * ```
-     * ```
- */
-export function AssertMatrices(a, b, args = {}, exception = {}) {
-    // Initialize the exception with the default MatrixError class if not provided
-    SetExceptionClass(exception, MatrixError);
-    // First validation: ensure both inputs are valid matrices
-    AssertMatrix(a, {}, exception);
-    AssertMatrix(b, {}, exception);
-    // Safe cast to TMatrix since we've validated both inputs
-    const matrixA = a;
-    const matrixB = b;
-    // Extract dimensions from both matrices for compatibility checking
-    const rowsA = matrixA.length;
-    const columnsA = rowsA > 0 && matrixA[0] ? matrixA[0].length : 0;
-    const rowsB = matrixB.length;
-    const columnsB = rowsB > 0 && matrixB[0] ? matrixB[0].length : 0;
-    // Check compatibility based on whether transposition is allowed
-    if (args.transposition === true) {
-        // With transposition allowed, check all possible multiplication combinations:
-        // - A × B (standard): columns of A must equal rows of B
-        // - A × B^T (B transposed): columns of A must equal columns of B
-        // - A^T × B (A transposed): rows of A must equal rows of B
-        // - A^T × B^T (both transposed): rows of A must equal columns of B
-        const canMultiplyAB = columnsA === rowsB;
-        const canMultiplyABT = columnsA === columnsB;
-        const canMultiplyATB = rowsA === rowsB;
-        const canMultiplyATBT = rowsA === columnsB;
-        if (!canMultiplyAB && !canMultiplyABT && !canMultiplyATB && !canMultiplyATBT) {
-            SetExceptionMessage(exception, `Matrices are not compatible for multiplication even with transposition. Matrix A is ${rowsA}×${columnsA}, Matrix B is ${rowsB}×${columnsB}`);
-            ThrowException(exception);
-        }
-    }
-    else {
-        // Without transposition: matrices must have identical dimensions
-        // This is required for element-wise operations like addition and subtraction
-        if (rowsA !== rowsB || columnsA !== columnsB) {
-            SetExceptionMessage(exception, `Matrices must have identical dimensions for addition/subtraction. Matrix A is ${rowsA}×${columnsA}, Matrix B is ${rowsB}×${columnsB}`);
-            ThrowException(exception);
-        }
-    }
-}
-/**
- * Validates that an unknown value is a valid 1x1 matrix.
- *
- * This function ensures that the provided value is a proper 1x1 matrix,
- * which should be a 2D array with exactly 1 row and 1 column containing a number.
- *
- * @param matrix - The value to validate as a 1x1 matrix
- * @param exception - Custom exception details if validation fails
- * @throws {IAssertException} When the matrix is not a valid 1x1 matrix
- *
- * @example
-     * ```typescript
-     * ```typescript
-     * // Validate a 1x1 matrix
-     * AssertMatrix1([[5]]);
-     * // This would throw an exception
-     * AssertMatrix1([[1, 2]]); // Too many columns
-     * ```
-     * ```
- */
-export function AssertMatrix1(matrix, exception = {}) {
-    // Initialize the exception with the default MatrixError class if not provided
-    SetExceptionClass(exception, MatrixError);
-    // Delegate to the general matrix assertion with 1x1 square matrix constraints
-    // This ensures the matrix is exactly 1 row by 1 column
-    AssertMatrix(matrix, { square: true, size: 1 }, exception);
-}
-/**
- * Validates that an unknown value is a valid 2x2 matrix.
- *
- * This function ensures that the provided value is a proper 2x2 matrix,
- * which should be a 2D array with exactly 2 rows and 2 columns containing numbers.
- *
- * @param matrix - The value to validate as a 2x2 matrix
- * @param exception - Custom exception details if validation fails
- * @throws {IAssertException} When the matrix is not a valid 2x2 matrix
- *
- * @example
-     * ```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 function AssertMatrix2(matrix, exception = {}) {
-    // Initialize the exception with the default MatrixError class if not provided
-    SetExceptionClass(exception, MatrixError);
-    // Delegate to the general matrix assertion with 2x2 square matrix constraints
-    // This ensures the matrix is exactly 2 rows by 2 columns
-    AssertMatrix(matrix, { square: true, size: 2 }, exception);
-}
-/**
- * Validates that an unknown value is a valid 3x3 matrix.
- *
- * This function ensures that the provided value is a proper 3x3 matrix,
- * which should be a 2D array with exactly 3 rows and 3 columns containing numbers.
- *
- * @param matrix - The value to validate as a 3x3 matrix
- * @param exception - Custom exception details if validation fails
- * @throws {IAssertException} When the matrix is not a valid 3x3 matrix
- *
- * @example
-     * ```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 function AssertMatrix3(matrix, exception = {}) {
-    // Initialize the exception with the default MatrixError class if not provided
-    SetExceptionClass(exception, MatrixError);
-    // Delegate to the general matrix assertion with 3x3 square matrix constraints
-    // This ensures the matrix is exactly 3 rows by 3 columns
-    AssertMatrix(matrix, { square: true, size: 3 }, exception);
-}
-/**
- * Validates that an unknown value is a valid 4x4 matrix.
- *
- * This function ensures that the provided value is a proper 4x4 matrix,
- * which should be a 2D array with exactly 4 rows and 4 columns containing numbers.
- *
- * @param matrix - The value to validate as a 4x4 matrix
- * @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 function AssertMatrix4(matrix, exception = {}) {
-    // Initialize the exception with the default MatrixError class if not provided
-    SetExceptionClass(exception, MatrixError);
-    // Delegate to the general matrix assertion with 4x4 square matrix constraints
-    // This ensures the matrix is exactly 4 rows by 4 columns
-    AssertMatrix(matrix, { square: true, size: 4 }, exception);
-}
-/**
- * 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
+ * @throws {MatrixError} When the matrix doesn't meet the specified criteria
  *
  * @example
  * ```typescript
- * if (ValidateMatrix(someValue, { square: true })) {
- *   // Process the valid square matrix
- * }
+ * ```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 function ValidateMatrix(matrix, args = {}) {
-    try {
-        AssertMatrix(matrix, args);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 /**
- * 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
+ * Matrix error class for validation failures and matrix operations.
+ * Extends Error to provide detailed error information with optional cause chain.
  *
  * @example
  * ```typescript
- * if (ValidateMatrix1(someValue)) {
- *   // Process the valid 1×1 matrix
- * }
+ * throw new MatrixError('Invalid matrix dimensions', { cause: originalError });
  * ```
  */
-export function ValidateMatrix1(matrix) {
-    try {
-        AssertMatrix1(matrix);
-        return true;
-    }
-    catch {
-        return false;
+export class MatrixError extends Error {
+    code = 'MATRIX_ERROR';
+    constructor(message, options) {
+        super(message);
+        this.name = 'MatrixError';
+        if (options?.cause) {
+            this.cause = options.cause;
+        }
     }
 }
 /**
- * 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
- * }
- * ```
+ * Factory function to create a Validate* type guard from an Assert* function.
+ * @param assert - The assertion function to wrap
+ * @returns A type guard function that returns true if valid, false otherwise
  */
-export function ValidateMatrix2(matrix) {
+function makeValidate(assert) {
+    return (value) => {
+        try {
+            assert(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+}
+export function AssertMatrix(matrix) {
     try {
-        AssertMatrix2(matrix);
-        return true;
+        MATRIX_SCHEMA.parse(matrix);
     }
-    catch {
-        return false;
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new MatrixError(`Invalid matrix: ${message}`, {
+            cause: error instanceof Error ? error : undefined,
+        });
     }
 }
-/**
- * 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 function ValidateMatrix3(matrix) {
+export const ValidateMatrix = makeValidate(AssertMatrix);
+export function AssertMatrix1(matrix) {
     try {
-        AssertMatrix3(matrix);
-        return true;
+        MATRIX1_SCHEMA.parse(matrix);
     }
-    catch {
-        return false;
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new MatrixError(`Invalid 1x1 matrix: ${message}`, {
+            cause: error instanceof Error ? error : undefined,
+        });
     }
 }
-/**
- * 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 function ValidateMatrix4(matrix) {
+export const ValidateMatrix1 = makeValidate(AssertMatrix1);
+export function AssertMatrix2(matrix) {
     try {
-        AssertMatrix4(matrix);
-        return true;
+        MATRIX2_SCHEMA.parse(matrix);
     }
-    catch {
-        return false;
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new MatrixError(`Invalid 2x2 matrix: ${message}`, {
+            cause: error instanceof Error ? error : undefined,
+        });
     }
 }
-/**
- * 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 function ValidateMatrixRow(row) {
+export const ValidateMatrix2 = makeValidate(AssertMatrix2);
+export function AssertMatrix3(matrix) {
     try {
-        AssertMatrixRow(row);
-        return true;
+        MATRIX3_SCHEMA.parse(matrix);
     }
-    catch {
-        return false;
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new MatrixError(`Invalid 3x3 matrix: ${message}`, {
+            cause: error instanceof Error ? error : undefined,
+        });
     }
 }
-/**
- * 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 function ValidateMatrixValue(value) {
+export const ValidateMatrix3 = makeValidate(AssertMatrix3);
+export function AssertMatrix4(matrix) {
     try {
-        AssertMatrixValue(value);
-        return true;
+        MATRIX4_SCHEMA.parse(matrix);
     }
-    catch {
-        return false;
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new MatrixError(`Invalid 4x4 matrix: ${message}`, {
+            cause: error instanceof Error ? error : undefined,
+        });
     }
 }
-/**
- * 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 function ValidateMatrices(a, b, args = {}) {
+export const ValidateMatrix4 = makeValidate(AssertMatrix4);
+export function AssertMatrixSquare(matrix) {
     try {
-        AssertMatrices(a, b, args);
-        return true;
-    }
-    catch {
-        return false;
+        MATRIX_SQUARE_SCHEMA.parse(matrix);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new MatrixError(`Invalid square matrix: ${message}`, {
+            cause: error instanceof Error ? error : undefined,
+        });
+    }
+}
+export const ValidateMatrixSquare = makeValidate(AssertMatrixSquare);
+export function AssertMatricesCompatible(...matrices) {
+    for (const matrix of matrices) {
+        AssertMatrix(matrix);
+    }
+    // Validate that all matrices have the same dimensions
+    const [firstRows, firstCols] = MatrixSize(matrices[0]);
+    for (let i = 1; i < matrices.length; i++) {
+        const [rows, cols] = MatrixSize(matrices[i]);
+        if (rows !== firstRows || cols !== firstCols) {
+            throw new MatrixError(`All matrices must have the same dimensions. Expected [${firstRows}, ${firstCols}], but got [${rows}, ${cols}] at index ${i}`);
+        }
     }
 }
 //# sourceMappingURL=asserts.js.map