data-structure-typed 1.40.0-rc → 1.40.0

package/test/unit/data-structures/matrix/matrix2d.test.ts

@@ -1,5 +1,7 @@
 import {Matrix2D, Vector2D} from '../../../../src';
+import {isDebugTest} from '../../../config';
 
+const isDebug = isDebugTest;
 describe('Matrix2D', () => {
   it('should initialize with default identity matrix', () => {
     const matrix = new Matrix2D();
@@ -136,3 +138,208 @@ describe('Matrix2D', () => {
     expect(result.m).toEqual(expectedMatrix);
   });
 });
+
+describe('Vector2D', () => {
+  it('should create a vector with default values', () => {
+    const vector = new Vector2D();
+    expect(vector.x).toBe(0);
+    expect(vector.y).toBe(0);
+    expect(vector.w).toBe(1);
+  });
+
+  it('should correctly calculate vector length', () => {
+    const vector = new Vector2D(3, 4);
+    expect(vector.length).toBe(5);
+  });
+
+  it('should correctly add two vectors', () => {
+    const vector1 = new Vector2D(2, 3);
+    const vector2 = new Vector2D(1, 2);
+    const result = Vector2D.add(vector1, vector2);
+    expect(result.x).toBe(3);
+    expect(result.y).toBe(5);
+  });
+
+  // Add more test cases for Vector2D methods
+});
+
+describe('Matrix2D', () => {
+  it('should create an identity matrix by default', () => {
+    const matrix = new Matrix2D();
+    expect(matrix.m).toEqual(Matrix2D.identity);
+  });
+
+  it('should correctly add two matrices', () => {
+    const matrix1 = new Matrix2D([
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9]
+    ]);
+    const matrix2 = new Matrix2D([
+      [9, 8, 7],
+      [6, 5, 4],
+      [3, 2, 1]
+    ]);
+    const result = Matrix2D.add(matrix1, matrix2);
+    expect(result.m).toEqual([
+      [10, 10, 10],
+      [10, 10, 10],
+      [10, 10, 10]
+    ]);
+  });
+
+  // Add more test cases for Matrix2D methods
+});
+
+describe('Matrix2D', () => {
+  it('should create a matrix with default identity values', () => {
+    const matrix = new Matrix2D();
+    expect(matrix.m).toEqual(Matrix2D.identity);
+  });
+
+  it('should create a matrix from a Vector2D', () => {
+    const vector = new Vector2D(2, 3);
+    const matrix = new Matrix2D(vector);
+    expect(matrix.m).toEqual([
+      [2, 0, 0],
+      [3, 1, 0],
+      [1, 0, 1]
+    ]);
+  });
+
+  it('should correctly add two matrices', () => {
+    const matrix1 = new Matrix2D([
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9]
+    ]);
+    const matrix2 = new Matrix2D([
+      [9, 8, 7],
+      [6, 5, 4],
+      [3, 2, 1]
+    ]);
+    const result = Matrix2D.add(matrix1, matrix2);
+    expect(result.m).toEqual([
+      [10, 10, 10],
+      [10, 10, 10],
+      [10, 10, 10]
+    ]);
+  });
+
+  it('should correctly subtract two matrices', () => {
+    const matrix1 = new Matrix2D([
+      [5, 4, 3],
+      [2, 1, 0],
+      [0, 1, 2]
+    ]);
+    const matrix2 = new Matrix2D([
+      [4, 3, 2],
+      [1, 0, 1],
+      [2, 1, 0]
+    ]);
+    const result = Matrix2D.subtract(matrix1, matrix2);
+    expect(result.m).toEqual([
+      [1, 1, 1],
+      [1, 1, -1],
+      [-2, 0, 2]
+    ]);
+  });
+
+  it('should correctly multiply two matrices', () => {
+    const matrix1 = new Matrix2D([
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9]
+    ]);
+    const matrix2 = new Matrix2D([
+      [9, 8, 7],
+      [6, 5, 4],
+      [3, 2, 1]
+    ]);
+    const result = Matrix2D.multiply(matrix1, matrix2);
+    expect(result.m).toEqual([
+      [30, 24, 18],
+      [84, 69, 54],
+      [138, 114, 90]
+    ]);
+  });
+
+  it('should correctly multiply a matrix by a value', () => {
+    const matrix = new Matrix2D([
+      [2, 3, 4],
+      [5, 6, 7],
+      [8, 9, 10]
+    ]);
+    const value = 2;
+    const result = Matrix2D.multiplyByValue(matrix, value);
+    expect(result.m).toEqual([
+      [4, 6, 8],
+      [10, 12, 14],
+      [16, 18, 20]
+    ]);
+  });
+
+  it('should correctly multiply a matrix by a vector', () => {
+    const matrix = new Matrix2D([
+      [2, 3, 4],
+      [5, 6, 7],
+      [8, 9, 10]
+    ]);
+    const vector = new Vector2D(2, 3);
+    const result = Matrix2D.multiplyByVector(matrix, vector);
+    isDebug && console.log(JSON.stringify(result));
+    expect(result).toEqual({x: 17, y: 35, w: 1});
+  });
+
+  it('should correctly create a view matrix', () => {
+    const width = 800;
+    const height = 600;
+    const viewMatrix = Matrix2D.view(width, height);
+    expect(viewMatrix.m).toEqual([
+      [1, 0, 400],
+      [0, -1, 300],
+      [0, 0, 1]
+    ]);
+  });
+
+  it('should correctly scale a matrix', () => {
+    const factor = 3;
+    const scaledMatrix = Matrix2D.scale(factor);
+    expect(scaledMatrix.m).toEqual([
+      [3, 0, 0],
+      [0, 3, 0],
+      [0, 0, 3]
+    ]);
+  });
+
+  it('should correctly rotate a matrix', () => {
+    const radians = Math.PI / 4; // 45 degrees
+    const rotationMatrix = Matrix2D.rotate(radians);
+    console.log(JSON.stringify(rotationMatrix.m));
+    expect(rotationMatrix.m).toEqual([
+      [0.7071067811865476, -0.7071067811865475, 0],
+      [0.7071067811865475, 0.7071067811865476, 0],
+      [0, 0, 1]
+    ]);
+  });
+
+  it('should correctly translate a matrix', () => {
+    const translationVector = new Vector2D(2, 3);
+    const translationMatrix = Matrix2D.translate(translationVector);
+    expect(translationMatrix.m).toEqual([
+      [1, 0, 2],
+      [0, 1, 3],
+      [0, 0, 1]
+    ]);
+  });
+
+  it('should correctly convert a matrix to a vector', () => {
+    const matrix = new Matrix2D([
+      [2, 3, 4],
+      [5, 6, 7],
+      [8, 9, 10]
+    ]);
+    const vector = matrix.toVector();
+    expect(vector).toEqual(new Vector2D(2, 5));
+  });
+});

package/test/unit/data-structures/matrix/navigator.test.ts

@@ -1,5 +1,7 @@
-import {Character, NavigatorParams, Turning, Navigator} from '../../../../src';
+import {Character, Navigator, NavigatorParams, Turning} from '../../../../src';
+import {isDebugTest} from '../../../config';
 
+const isDebug = isDebugTest;
 const exampleMatrix: number[][] = [
   [0, 0, 0, 0],
   [0, 1, 1, 0],
@@ -17,7 +19,7 @@ const exampleTurning: Turning = {
 // Create a sample move callback function
 const exampleOnMove = () => {
   expect(true).toBeTruthy();
-  // console.log(`Moved to position (${cur[0]}, ${cur[1]})`);
+  // isDebug && console.log(`Moved to position (${cur[0]}, ${cur[1]})`);
 };
 
 // Create an initial parameter object for the example
@@ -77,3 +79,166 @@ describe('Navigator class', () => {
     expect(navigator.check('left')).toBe(false); // Open path
   });
 });
+
+describe('Navigator', () => {
+  it('should correctly navigate the grid', () => {
+    // Define a sample grid and initial parameters
+    const matrix: number[][] = [
+      [0, 0, 1],
+      [0, 1, 0],
+      [0, 0, 0]
+    ];
+
+    const turning: Turning = {
+      up: 'right',
+      right: 'down',
+      down: 'left',
+      left: 'up'
+    };
+
+    const init: NavigatorParams<number>['init'] = {
+      cur: [0, 0], // Initial position
+      charDir: 'right', // Initial character direction
+      VISITED: 2 // Value to mark visited cells
+    };
+
+    // Initialize the navigator
+    const navigator = new Navigator({
+      matrix,
+      turning,
+      init,
+      onMove: cur => cur
+    });
+
+    // Define a function to track visited cells
+    const visitedCells: number[][] = [];
+    const onMove = (cur: number[]) => {
+      visitedCells.push([...cur]);
+    };
+
+    // Attach the onMove function
+    navigator.onMove = onMove;
+
+    // Start the navigation
+    navigator.start();
+
+    // The character should have navigated the grid correctly
+    expect(visitedCells).toEqual([
+      [0, 1],
+      [0, 2],
+      [1, 2],
+      [2, 2],
+      [2, 1],
+      [2, 0],
+      [1, 0],
+      [1, 1]
+    ]);
+  });
+
+  it('should not move if there are no valid moves', () => {
+    // Define a sample grid with no valid moves
+    const matrix: number[][] = [
+      [1, 1],
+      [1, 1]
+    ];
+
+    const turning: Turning = {
+      up: 'right',
+      right: 'down',
+      down: 'left',
+      left: 'up'
+    };
+
+    const init: NavigatorParams<number>['init'] = {
+      cur: [0, 0], // Initial position
+      charDir: 'right', // Initial character direction
+      VISITED: 2 // Value to mark visited cells
+    };
+
+    // Initialize the navigator
+    const navigator = new Navigator({
+      matrix,
+      turning,
+      init,
+      onMove: cur => cur
+    });
+
+    // Define a function to track visited cells
+    const visitedCells: number[][] = [];
+    const onMove = (cur: number[]) => {
+      visitedCells.push([...cur]);
+    };
+
+    // Attach the onMove function
+    navigator.onMove = onMove;
+
+    // Start the navigation
+    navigator.start();
+
+    // The character should not move
+    isDebug && console.log(visitedCells);
+    expect(visitedCells).toEqual([
+      [0, 1],
+      [1, 1],
+      [1, 0]
+    ]);
+  });
+
+  it('should handle edge cases and turns correctly', () => {
+    // Define a sample grid with turns and edge cases
+    const matrix: number[][] = [
+      [1, 0, 0, 0],
+      [1, 0, 1, 0],
+      [0, 0, 1, 1]
+    ];
+
+    const turning: Turning = {
+      up: 'right',
+      right: 'down',
+      down: 'left',
+      left: 'up'
+    };
+
+    const init: NavigatorParams<number>['init'] = {
+      cur: [0, 0], // Initial position
+      charDir: 'right', // Initial character direction
+      VISITED: 2 // Value to mark visited cells
+    };
+
+    // Initialize the navigator
+    const navigator = new Navigator({
+      matrix,
+      turning,
+      init,
+      onMove: cur => cur
+    });
+
+    // Define a function to track visited cells
+    const visitedCells: number[][] = [];
+    const onMove = (cur: number[]) => {
+      visitedCells.push([...cur]);
+    };
+
+    // Attach the onMove function
+    navigator.onMove = onMove;
+
+    // Start the navigation
+    navigator.start();
+
+    // The character should have navigated the grid, handled turns, and edge cases
+    isDebug && console.log(visitedCells);
+    expect(visitedCells).toEqual([
+      [0, 1],
+      [0, 2],
+      [0, 3],
+      [1, 3],
+      [2, 3],
+      [2, 2],
+      [2, 1],
+      [2, 0],
+      [1, 0],
+      [1, 1],
+      [1, 2]
+    ]);
+  });
+});

package/test/unit/data-structures/matrix/vector2d.test.ts

@@ -0,0 +1,171 @@
+import {Vector2D} from '../../../../src';
+
+describe('Vector2D', () => {
+  it('should create a vector with default values', () => {
+    const vector = new Vector2D();
+    expect(vector.x).toBe(0);
+    expect(vector.y).toBe(0);
+    expect(vector.w).toBe(1);
+  });
+
+  it('should correctly check if a vector is zero', () => {
+    const nonZeroVector = new Vector2D(3, 4);
+    const zeroVector = new Vector2D(0, 0);
+    expect(nonZeroVector.isZero).toBe(false);
+    expect(zeroVector.isZero).toBe(true);
+  });
+
+  it('should correctly calculate vector length', () => {
+    const vector = new Vector2D(3, 4);
+    expect(vector.length).toBe(5);
+  });
+
+  it('should correctly calculate squared vector length', () => {
+    const vector = new Vector2D(3, 4);
+    expect(vector.lengthSq).toBe(25);
+  });
+
+  it('should correctly round vector components', () => {
+    const vector = new Vector2D(3.6, 4.3);
+    const roundedVector = vector.rounded;
+    expect(roundedVector.x).toBe(4);
+    expect(roundedVector.y).toBe(4);
+  });
+
+  it('should correctly add two vectors', () => {
+    const vector1 = new Vector2D(2, 3);
+    const vector2 = new Vector2D(1, 2);
+    const result = Vector2D.add(vector1, vector2);
+    expect(result.x).toBe(3);
+    expect(result.y).toBe(5);
+  });
+
+  it('should correctly subtract two vectors', () => {
+    const vector1 = new Vector2D(4, 5);
+    const vector2 = new Vector2D(1, 2);
+    const result = Vector2D.subtract(vector1, vector2);
+    expect(result.x).toBe(3);
+    expect(result.y).toBe(3);
+  });
+
+  it('should correctly subtract value from a vector', () => {
+    const vector = new Vector2D(5, 7);
+    const result = Vector2D.subtractValue(vector, 3);
+    expect(result.x).toBe(2);
+    expect(result.y).toBe(4);
+  });
+
+  it('should correctly multiply a vector by a value', () => {
+    const vector = new Vector2D(2, 3);
+    const result = Vector2D.multiply(vector, 4);
+    expect(result.x).toBe(8);
+    expect(result.y).toBe(12);
+  });
+
+  it('should correctly divide a vector by a value', () => {
+    const vector = new Vector2D(6, 8);
+    const result = Vector2D.divide(vector, 2);
+    expect(result.x).toBe(3);
+    expect(result.y).toBe(4);
+  });
+
+  it('should correctly check if two vectors are equal', () => {
+    const vector1 = new Vector2D(3, 4);
+    const vector2 = new Vector2D(3, 4);
+    const vector3 = new Vector2D(4, 5);
+    expect(Vector2D.equals(vector1, vector2)).toBe(true);
+    expect(Vector2D.equals(vector1, vector3)).toBe(false);
+  });
+
+  it('should correctly check if two vectors are equal within a rounding factor', () => {
+    const vector1 = new Vector2D(3, 4);
+    const vector2 = new Vector2D(2.9, 3.9);
+    const vector3 = new Vector2D(4, 5);
+    expect(Vector2D.equalsRounded(vector1, vector2, 0.2)).toBe(true);
+    expect(Vector2D.equalsRounded(vector1, vector3, 0.2)).toBe(false);
+  });
+
+  it('should correctly normalize a vector', () => {
+    const vector = new Vector2D(3, 4);
+    const normalized = Vector2D.normalize(vector);
+    expect(normalized.x).toBeCloseTo(0.6);
+    expect(normalized.y).toBeCloseTo(0.8);
+  });
+
+  it('should correctly truncate a vector', () => {
+    const vector = new Vector2D(3, 4);
+    const truncated = Vector2D.truncate(vector, 4);
+    expect(truncated.length).toBeLessThanOrEqual(4);
+  });
+
+  it('should correctly get the perpendicular vector', () => {
+    const vector = new Vector2D(3, 4);
+    const perpendicular = Vector2D.perp(vector);
+    expect(Vector2D.dot(vector, perpendicular)).toBe(0);
+  });
+
+  it('should correctly reverse the vector', () => {
+    const vector = new Vector2D(3, 4);
+    const reversed = Vector2D.reverse(vector);
+    expect(reversed.x).toBe(-3);
+    expect(reversed.y).toBe(-4);
+  });
+
+  it('should correctly get the absolute vector', () => {
+    const vector = new Vector2D(-3, 4);
+    const absVector = Vector2D.abs(vector);
+    expect(absVector.x).toBe(3);
+    expect(absVector.y).toBe(4);
+  });
+
+  it('should correctly calculate the dot product of two vectors', () => {
+    const vector1 = new Vector2D(2, 3);
+    const vector2 = new Vector2D(4, 5);
+    const dotProduct = Vector2D.dot(vector1, vector2);
+    expect(dotProduct).toBe(23);
+  });
+
+  it('should correctly calculate the distance between two vectors', () => {
+    const vector1 = new Vector2D(1, 1);
+    const vector2 = new Vector2D(4, 5);
+    const distance = Vector2D.distance(vector1, vector2);
+    expect(distance).toBeCloseTo(5);
+  });
+
+  it('should correctly calculate the squared distance between two vectors', () => {
+    const vector1 = new Vector2D(1, 1);
+    const vector2 = new Vector2D(4, 5);
+    const distanceSq = Vector2D.distanceSq(vector1, vector2);
+    expect(distanceSq).toBe(25);
+  });
+
+  it('should correctly determine the sign of the cross product of two vectors', () => {
+    const vector1 = new Vector2D(2, 3);
+    const vector2 = new Vector2D(4, 5);
+    const sign = Vector2D.sign(vector1, vector2);
+    expect(sign).toBe(-1); // Assuming specific vector values, the result may vary
+  });
+
+  it('should correctly calculate the angle between a vector and the negative y-axis', () => {
+    const vector = new Vector2D(3, 4);
+    const angle = Vector2D.angle(vector);
+    expect(angle).toBeCloseTo(2.498091544796509, 3);
+  });
+
+  it('should create a random vector within the specified range', () => {
+    const maxX = 10;
+    const maxY = 10;
+    const randomVector = Vector2D.random(maxX, maxY);
+    expect(randomVector.x).toBeGreaterThanOrEqual(-maxX / 2);
+    expect(randomVector.x).toBeLessThanOrEqual(maxX / 2);
+    expect(randomVector.y).toBeGreaterThanOrEqual(-maxY / 2);
+    expect(randomVector.y).toBeLessThanOrEqual(maxY / 2);
+  });
+
+  it('should zero the vector components', () => {
+    const vector = new Vector2D(3, 4);
+    vector.zero();
+    expect(vector.x).toBe(0);
+    expect(vector.y).toBe(0);
+  });
+});

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -17,11 +17,8 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
-    const priorityQueue = new MaxPriorityQueue<{keyA: number}>({
-      nodes: [{keyA: 5}, {keyA: 3}, {keyA: 1}],
-      comparator: (a, b) => b.keyA - a.keyA
-    });
-
+    const priorityQueue = new MaxPriorityQueue<{keyA: number}>({comparator: (a, b) => b.keyA - a.keyA});
+    priorityQueue.refill([{keyA: 5}, {keyA: 3}, {keyA: 1}]);
     priorityQueue.add({keyA: 7});
 
     expect(priorityQueue.poll()?.keyA).toBe(7);
@@ -30,7 +27,7 @@ describe('MaxPriorityQueue Operation Test', () => {
     expect(priorityQueue.poll()?.keyA).toBe(1);
   });
 
-  it('should return and remove the smallest element', () => {
+  it('should return and delete the smallest element', () => {
     const priorityQueue = new MaxPriorityQueue<number>();
     priorityQueue.add(5);
     priorityQueue.add(3);
@@ -56,7 +53,8 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an array', () => {
     const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>({nodes: array});
+    const heap = MaxPriorityQueue.heapify<number>({nodes: array, comparator: (a, b) => b - a});
+    heap.refill(array);
 
     expect(heap.poll()).toBe(7);
     expect(heap.poll()).toBe(5);
@@ -66,7 +64,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an object array', () => {
     const nodes = [{keyA: 5}, {keyA: 3}, {keyA: 7}, {keyA: 1}];
-    const maxPQ = MaxPriorityQueue.heapify<{keyA: number}>({nodes, comparator: (a, b) => b.keyA - a.keyA});
+    const maxPQ = MaxPriorityQueue.heapify<{keyA: number}>({nodes: nodes, comparator: (a, b) => b.keyA - a.keyA});
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);
@@ -81,8 +79,8 @@ describe('MaxPriorityQueue Performance Test', () => {
       new Set<number>(Array.from(new Array(magnitude.LINEAR), () => Math.floor(Math.random() * magnitude.LINEAR * 100)))
     );
     expect(nodes.length).toBeGreaterThan(magnitude.LINEAR / 2);
-    const maxPQ = new MaxPriorityQueue<number>({nodes});
-
+    const maxPQ = new MaxPriorityQueue<number>();
+    maxPQ.refill(nodes);
     let prev = Number.MAX_SAFE_INTEGER;
     const startTime = performance.now();
     while (maxPQ.size > 0) {
@@ -91,7 +89,8 @@ describe('MaxPriorityQueue Performance Test', () => {
         prev = polled;
       }
     }
-    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 50);
+    const cost = performance.now() - startTime;
+    expect(cost).toBeLessThan(bigO.LINEAR * 30);
     expect(prev).toBeGreaterThan(0);
   });
 

package/test/unit/data-structures/priority-queue/min-priority-queue.test.ts

@@ -25,7 +25,7 @@ describe('MinPriorityQueue Operation Test', () => {
     priorityQueue.add(3);
     priorityQueue.add(7);
 
-    expect(priorityQueue.leaf()).toBe(7);
+    expect(priorityQueue.leaf).toBe(7);
   });
 
   it('should check if the queue is empty', () => {