data-structure-typed 1.38.9 → 1.39.1

package/test/unit/data-structures/graph/overall.test.ts

@@ -20,7 +20,7 @@ describe('Overall Graph Operation Test', () => {
     expect(graph.hasEdge('A', 'B')).toBe(true); // true
     expect(graph.hasEdge('B', 'A')).toBe(false); // false
 
-    graph.removeEdgeSrcToDest('A', 'B');
+    graph.deleteEdgeSrcToDest('A', 'B');
     graph.hasEdge('A', 'B'); // false
     expect(graph.hasEdge('A', 'B')).toBe(false); // false
 
@@ -38,7 +38,7 @@ describe('Overall Graph Operation Test', () => {
     graph.addVertex('B');
     graph.addVertex('C');
     graph.addVertex('D');
-    graph.removeVertex('C');
+    graph.deleteVertex('C');
     graph.addEdge('A', 'B');
     graph.addEdge('B', 'D');
 

package/test/unit/data-structures/graph/undirected-graph.test.ts

@@ -40,7 +40,7 @@ describe('UndirectedGraph Operation Test', () => {
     graph.addVertex(vertex2);
     graph.addEdge(edge);
 
-    expect(graph.removeEdge(edge)).toBe(edge);
+    expect(graph.deleteEdge(edge)).toBe(edge);
     expect(graph.hasEdge('A', 'B')).toBe(false);
   });
 
@@ -49,7 +49,7 @@ describe('UndirectedGraph Operation Test', () => {
     graph.addVertex('B');
     graph.addVertex('C');
     graph.addVertex('D');
-    graph.removeVertex('C');
+    graph.deleteVertex('C');
     graph.addEdge('A', 'B');
     graph.addEdge('B', 'D');
 
@@ -57,3 +57,85 @@ describe('UndirectedGraph Operation Test', () => {
     expect(Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key)).toEqual(['A', 'B', 'D']);
   });
 });
+
+describe('UndirectedGraph', () => {
+  let undirectedGraph: UndirectedGraph<UndirectedVertex<string>, UndirectedEdge<string>>;
+
+  beforeEach(() => {
+    // Create a new UndirectedGraph instance before each test
+    undirectedGraph = new UndirectedGraph<UndirectedVertex<string>, UndirectedEdge<string>>();
+  });
+
+  // Test adding vertices to the graph
+  it('should add vertices to the graph', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+
+    expect(undirectedGraph.hasVertex('A')).toBe(true);
+    expect(undirectedGraph.hasVertex('B')).toBe(true);
+  });
+
+  // Test adding edges to the graph
+  it('should add edges to the graph', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+    const edgeAB = new UndirectedEdge('A', 'B', 1, 'Edge between A and B');
+
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+    undirectedGraph.addEdge(edgeAB);
+
+    expect(undirectedGraph.hasEdge('A', 'B')).toBe(true);
+  });
+
+  // Test getting neighbors of a vertex
+  it('should return the neighbors of a vertex', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+    const vertexC = new UndirectedVertex('C', 'Location C');
+    const edgeAB = new UndirectedEdge('A', 'B', 1, 'Edge between A and B');
+    const edgeBC = new UndirectedEdge('B', 'C', 2, 'Edge between B and C');
+
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+    undirectedGraph.addVertex(vertexC);
+    undirectedGraph.addEdge(edgeAB);
+    undirectedGraph.addEdge(edgeBC);
+
+    const neighborsOfA = undirectedGraph.getNeighbors('A');
+    const neighborsOfB = undirectedGraph.getNeighbors('B');
+
+    expect(neighborsOfA).toEqual([vertexB]);
+    expect(neighborsOfB).toEqual([vertexA, vertexC]);
+  });
+
+  // Test degree of a vertex
+  it('should return the degree of a vertex', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+    const vertexC = new UndirectedVertex('C', 'Location C');
+    const edgeAB = new UndirectedEdge('A', 'B', 3, 'Edge between A and B');
+    const edgeBC = new UndirectedEdge('B', 'C', 4, 'Edge between B and C');
+
+    edgeAB.vertices = edgeAB.vertices;
+    expect(undirectedGraph.edges.size).toBe(0);
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+    undirectedGraph.addVertex(vertexC);
+    undirectedGraph.addEdge(edgeAB);
+    undirectedGraph.addEdge(edgeBC);
+
+    const degreeOfA = undirectedGraph.degreeOf('A');
+    const degreeOfB = undirectedGraph.degreeOf('B');
+    const degreeOfC = undirectedGraph.degreeOf('C');
+    expect(undirectedGraph.edgeSet().length).toBe(2);
+    expect(undirectedGraph.getEndsOfEdge(edgeBC)?.length).toBe(2);
+
+    expect(degreeOfA).toBe(1);
+    expect(degreeOfB).toBe(2);
+    expect(degreeOfC).toBe(1);
+  });
+});

package/test/unit/data-structures/heap/heap.test.ts

@@ -22,7 +22,7 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap work well', function () {
-    const minHeap = new MinHeap<{a: string; key: number}>((a, b) => a.key - b.key);
+    const minHeap = new MinHeap<{a: string; key: number}>({comparator: (a, b) => a.key - b.key});
     minHeap.add({key: 1, a: 'a1'});
     minHeap.add({key: 6, a: 'a6'});
     minHeap.add({key: 2, a: 'a2'});
@@ -37,7 +37,7 @@ describe('Heap Operation Test', () => {
       i++;
     }
 
-    const maxHeap = new MaxHeap<{key: number; a: string}>((a, b) => b.key - a.key);
+    const maxHeap = new MaxHeap<{key: number; a: string}>({comparator: (a, b) => b.key - a.key});
     maxHeap.add({key: 1, a: 'a1'});
     maxHeap.add({key: 6, a: 'a6'});
     maxHeap.add({key: 5, a: 'a5'});

package/test/unit/data-structures/heap/max-heap.test.ts

@@ -5,7 +5,7 @@ describe('MaxHeap', () => {
   let maxHeap: MaxHeap<number>;
 
   beforeEach(() => {
-    maxHeap = new MaxHeap(numberComparator);
+    maxHeap = new MaxHeap({comparator: numberComparator});
   });
 
   test('add and poll elements in descending order', () => {

package/test/unit/data-structures/heap/min-heap.test.ts

@@ -5,7 +5,7 @@ describe('MinHeap', () => {
   let minHeap: MinHeap<number>;
 
   beforeEach(() => {
-    minHeap = new MinHeap(numberComparator);
+    minHeap = new MinHeap({comparator: numberComparator});
   });
 
   test('add and poll elements in ascending order', () => {

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -393,7 +393,7 @@ describe('SinglyLinkedList Performance Test', () => {
     }
 
     // expect(performance.now() - startPopTime).toBeLessThan(bigO.LINEAR);
-    expect(performance.now() - startPopTime).toBeLessThan(bigO.LINEAR * 300);
+    expect(performance.now() - startPopTime).toBeLessThan(bigO.LINEAR * 400);
   });
 });
 describe('SinglyLinkedList', () => {

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, 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]
+    ]);
+  });
+});