binary-tree-typed 2.5.0 → 2.5.2

package/src/data-structures/matrix/matrix.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { MatrixOptions } from '../../types';
-import { ERR } from '../../common';
+import { ERR, raise } from '../../common';
 
 /**
  *
@@ -200,6 +200,30 @@ export class Matrix {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get and set individual cells
  *  const m = new Matrix([
@@ -245,6 +269,30 @@ export class Matrix {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Modify individual cells
  *  const m = Matrix.zeros(2, 2);
@@ -287,6 +335,30 @@ export class Matrix {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Basic matrix arithmetic
  *  const a = new Matrix([
@@ -312,7 +384,7 @@ export class Matrix {
    */
   add(matrix: Matrix): Matrix | undefined {
     if (!this.isMatchForCalculate(matrix)) {
-      throw new Error(ERR.matrixDimensionMismatch('addition'));
+      raise(Error, ERR.matrixDimensionMismatch('addition'));
     }
 
     const resultData: number[][] = [];
@@ -353,6 +425,30 @@ export class Matrix {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Element-wise subtraction
  *  const a = Matrix.from([[5, 6], [7, 8]]);
@@ -362,7 +458,7 @@ export class Matrix {
    */
   subtract(matrix: Matrix): Matrix | undefined {
     if (!this.isMatchForCalculate(matrix)) {
-      throw new Error(ERR.matrixDimensionMismatch('subtraction'));
+      raise(Error, ERR.matrixDimensionMismatch('subtraction'));
     }
 
     const resultData: number[][] = [];
@@ -402,6 +498,30 @@ export class Matrix {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Matrix multiplication for transformations
  *  // 2x3 matrix * 3x2 matrix = 2x2 matrix
@@ -427,7 +547,7 @@ export class Matrix {
    */
   multiply(matrix: Matrix): Matrix | undefined {
     if (this.cols !== matrix.rows) {
-      throw new Error(ERR.matrixDimensionMismatch('multiplication (A.cols must equal B.rows)'));
+      raise(Error, ERR.matrixDimensionMismatch('multiplication (A.cols must equal B.rows)'));
     }
 
     const resultData: number[][] = [];
@@ -473,6 +593,30 @@ export class Matrix {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Matrix transpose (square matrix)
  *  const m = new Matrix([
@@ -495,7 +639,7 @@ export class Matrix {
    */
   transpose(): Matrix {
     if (this.data.some(row => row.length !== this.cols)) {
-      throw new Error(ERR.matrixNotRectangular());
+      raise(Error, ERR.matrixNotRectangular());
     }
 
     const resultData: number[][] = [];
@@ -531,6 +675,30 @@ export class Matrix {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Compute the inverse of a 2x2 matrix
  *  const m = Matrix.from([[4, 7], [2, 6]]);
@@ -546,7 +714,7 @@ export class Matrix {
   inverse(): Matrix | undefined {
     // Check if the matrix is square
     if (this.rows !== this.cols) {
-      throw new Error(ERR.matrixNotSquare());
+      raise(Error, ERR.matrixNotSquare());
     }
 
     // Create an augmented matrix [this | I]
@@ -576,7 +744,7 @@ export class Matrix {
 
       if (pivotRow === this.rows) {
         // Matrix is singular, and its inverse does not exist
-        throw new Error(ERR.matrixSingular());
+        raise(Error, ERR.matrixSingular());
       }
 
       // Swap rows to make the pivot the current row
@@ -587,7 +755,7 @@ export class Matrix {
 
       if (pivotElement === 0) {
         // Handle division by zero
-        throw new Error(ERR.matrixSingular());
+        raise(Error, ERR.matrixSingular());
       }
 
       augmentedMatrix._scaleRow(i, 1 / pivotElement);
@@ -633,6 +801,30 @@ export class Matrix {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Dot product of two matrices
  *  const a = Matrix.from([[1, 2], [3, 4]]);
@@ -642,7 +834,7 @@ export class Matrix {
    */
   dot(matrix: Matrix): Matrix | undefined {
     if (this.cols !== matrix.rows) {
-      throw new Error(ERR.matrixDimensionMismatch('dot product (A.cols must equal B.rows)'));
+      raise(Error, ERR.matrixDimensionMismatch('dot product (A.cols must equal B.rows)'));
     }
 
     const resultData: number[][] = [];
@@ -749,7 +941,7 @@ export class Matrix {
         if (i < data.length) {
           return { value: [...data[i++]], done: false };
         }
-        return { value: undefined as any, done: true };
+        return { value: undefined, done: true } as IteratorResult<number[]>;
       }
     };
   }

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -7,7 +7,7 @@
  */
 import type { PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
-import { ERR } from '../../common';
+import { ERR, raise } from '../../common';
 
 /**
  * Max-oriented priority queue (max-heap) built on {@link PriorityQueue}.
@@ -86,7 +86,7 @@ export class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
     super(elements, {
       comparator: (a: E, b: E): number => {
         if (typeof a === 'object' || typeof b === 'object') {
-          throw new TypeError(ERR.comparatorRequired('MaxPriorityQueue'));
+          raise(TypeError, ERR.comparatorRequired('MaxPriorityQueue'));
         }
         if (a < b) return 1;
         if (a > b) return -1;