data-structure-typed 1.39.0 → 1.39.2

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

@@ -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/hash/coordinate-map.test.ts

@@ -52,3 +52,23 @@ describe('CoordinateMap', () => {
     expect(retrievedValue).toBe(value);
   });
 });
+
+describe('CoordinateMap', () => {
+  class MyCoordinateMap<V = any> extends CoordinateMap<V> {
+    constructor(joint?: string) {
+      super(joint);
+      this._setJoint(joint += '-')
+    }
+  }
+
+  const cMap = new MyCoordinateMap<number>('*');
+
+  beforeEach(() => {
+    cMap.set([0, 0], 0);
+    cMap.set([0, 1], 1);
+    cMap.set([1, 1], 11);
+  })
+  it('should joint to be *-', () => {
+    expect(cMap.joint).toBe('*-');
+  });
+});

package/test/unit/data-structures/hash/coordinate-set.test.ts

@@ -39,3 +39,28 @@ describe('CoordinateSet', () => {
     expect(hasValue).toBe(true);
   });
 });
+
+describe('MyCoordinateSet', () => {
+  class MyCoordinateSet extends CoordinateSet {
+    constructor(joint?: string) {
+      super(joint);
+      this._setJoint(joint += '-')
+    }
+  }
+
+  const mySet = new MyCoordinateSet('*');
+
+  beforeEach(() => {
+    mySet.add([0, 0]);
+    mySet.add([0, 1]);
+    mySet.add([1, 1]);
+  })
+  it('should joint to be *-', () => {
+    expect(mySet.joint).toBe('*-');
+  });
+
+  it('should has, delete', () => {
+    mySet.delete([0, 1]);
+    expect(mySet.has([0, 1])).toBe(false);
+  });
+});

package/test/unit/data-structures/hash/hash-table.test.ts

@@ -15,7 +15,9 @@ describe('HashNode', () => {
 describe('HashTable', () => {
   it('should initialize with default capacity', () => {
     const hashTable = new HashTable<string, string>();
-
+    hashTable.capacity = hashTable.capacity;
+    hashTable.buckets = hashTable.buckets;
+    hashTable.hashFn = hashTable.hashFn;
     expect(hashTable.capacity).toBe(16);
     expect(hashTable.size).toBe(0);
     expect(hashTable.buckets.length).toBe(16);

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

@@ -1,6 +1,69 @@
-import {DoublyLinkedList} from '../../../../src';
+import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
 import {bigO, magnitude} from '../../../utils';
 
+describe('DoublyLinkedListNode', () => {
+  it('should DoublyLinkedListNode', () => {
+    const node1 = new DoublyLinkedListNode<number>(2);
+    expect(node1.val).toBe(2);
+    node1.val = 1;
+    expect(node1.val).toBe(1);
+  })
+});
+
+describe('DoublyLinkedList Operation Test', () => {
+  let list: DoublyLinkedList<number>;
+
+  beforeEach(() => {
+    list = DoublyLinkedList.fromArray([1, 2, 3, 4, 5]);
+  });
+
+  it('should out of bound index', () => {
+    expect(list.getNodeAt(-1)).toBe(null);
+    expect(list.getNodeAt(5)).toBe(null);
+    expect(list.insertAt(5, 6)).toBe(true);
+  });
+
+  it('should insertBefore', () => {
+    expect(list.insertBefore(1, 0)).toBe(true);
+  });
+
+  it('should deleteAt', () => {
+    expect(list.deleteAt(1)).toBeTruthy();
+  });
+
+  it('should delete tail', () => {
+    expect(list.delete(list.tail)).toBe(true);
+    expect(list.tail?.val).toBe(4);
+    expect(list.delete(6)).toBe(false);
+    expect(list.tail?.val).toBe(4);
+  });
+
+
+  it('should find null', () => {
+    expect(list.find(val => val === 6)).toBe(null);
+
+  });
+
+  it('should indexOf -1', () => {
+    expect(list.indexOf(6)).toBe(-1);
+  });
+
+  it('should findBackward null', () => {
+    expect(list.findBackward(val => val === 0)).toBe(null);
+  });
+
+  it('should insertAfter tail', () => {
+    expect(list.insertAfter(list.tail!, 6)).toBe(true);
+  });
+
+  it('should insertAfter tail', () => {
+    // @ts-ignore
+    expect([...list]).toEqual([1, 2, 3, 4, 5]);
+  });
+
+
+});
+
 describe('DoublyLinkedList Operation Test', () => {
   let list: DoublyLinkedList<number>;
   let objectList: DoublyLinkedList<{ keyA: number }>;
@@ -109,7 +172,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.reverse();
 
     expect(list.toArray()).toEqual([3, 2, 1]);
-    expect(list.toArrayReverse()).toEqual([1, 2, 3]);
+    expect(list.toArrayBackward()).toEqual([1, 2, 3]);
   });
 
   it('should map elements using a callback function', () => {
@@ -189,7 +252,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const lastEven = list.findLast(val => val % 2 === 0);
+    const lastEven = list.findBackward(val => val % 2 === 0);
 
     expect(lastEven).toBe(4);
   });
@@ -211,7 +274,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const reversedArray = list.toArrayReverse();
+    const reversedArray = list.toArrayBackward();
 
     expect(reversedArray).toEqual([3, 2, 1]);
   });
@@ -327,8 +390,8 @@ describe('DoublyLinkedList Operation Test', () => {
     const insertSuccess = objectList.insertBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 
-    const findNode = objectList.findNode(newObj); // Use newObj instead of obj2
-    expect(findNode?.val).toEqual(newObj);
+    const getNode = objectList.getNode(newObj); // Use newObj instead of obj2
+    expect(getNode?.val).toEqual(newObj);
 
     const deleted = objectList.delete(newObj); // Use newObj instead of obj2
     expect(deleted).toBe(true);

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

@@ -11,7 +11,7 @@ describe('LinkedList Performance Test', () => {
     for (let i = 0; i < magnitude.SQUARED; i++) {
       doublyList.push(i);
       if (i === midIndex) {
-        midNode = doublyList.findNode(i);
+        midNode = doublyList.getNode(i);
       } else if (i > midIndex && midNode) {
         doublyList.insertBefore(midNode, i);
       }
@@ -24,7 +24,7 @@ describe('LinkedList Performance Test', () => {
     for (let i = 0; i < magnitude.SQUARED; i++) {
       singlyList.push(i);
       if (i === midIndex) {
-        midSinglyNode = singlyList.findNode(i);
+        midSinglyNode = singlyList.getNode(i);
       } else if (i > midIndex && midSinglyNode) {
         singlyList.insertBefore(midSinglyNode.val, i);
       }

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

@@ -1,6 +1,15 @@
-import {SinglyLinkedList} from '../../../../src';
+import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
 import {bigO, magnitude} from '../../../utils';
 
+describe('SinglyLinkedListNode', () => {
+  it('should SinglyLinkedList', () => {
+    const node1 = new SinglyLinkedListNode<number>(2);
+    expect(node1.val).toBe(2);
+    node1.val = 1;
+    expect(node1.val).toBe(1);
+  })
+});
+
 describe('SinglyLinkedList Operation Test', () => {
   let list: SinglyLinkedList<number>;
   let objectList: SinglyLinkedList<{ keyA: number }>;
@@ -21,8 +30,10 @@ describe('SinglyLinkedList Operation Test', () => {
     it('should delete and return the last element of the list', () => {
       list.push(1);
       list.push(2);
+      list.push(3);
       const popped = list.pop();
-      expect(popped).toBe(2);
+      expect(popped).toBe(3);
+      expect(list.popLast()).toBe(2);
       expect(list.toArray()).toEqual([1]);
     });
 
@@ -36,9 +47,11 @@ describe('SinglyLinkedList Operation Test', () => {
     it('should delete and return the first element of the list', () => {
       list.push(1);
       list.push(2);
+      list.push(3);
       const shifted = list.shift();
       expect(shifted).toBe(1);
-      expect(list.toArray()).toEqual([2]);
+      expect(list.popFirst()).toBe(2);
+      expect(list.toArray()).toEqual([3]);
     });
 
     it('should return undefined if the list is empty', () => {
@@ -50,7 +63,7 @@ describe('SinglyLinkedList Operation Test', () => {
   describe('unshift', () => {
     it('should add elements to the beginning of the list', () => {
       list.unshift(1);
-      list.unshift(2);
+      list.addFirst(2);
       expect(list.toArray()).toEqual([2, 1]);
     });
   });
@@ -62,6 +75,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       const element = list.getAt(1);
       expect(element).toBe(2);
+      expect(list.getNodeAt(2)?.val).toBe(3);
     });
 
     it('should return undefined for an out-of-bounds index', () => {
@@ -113,9 +127,14 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(1);
       list.push(2);
       list.push(3);
-      const removed = list.delete(2);
-      expect(removed).toBe(true);
-      expect(list.toArray()).toEqual([1, 3]);
+      list.push(4);
+      list.push(5);
+      expect(list.delete(2)).toBe(true);
+      expect(list.toArray()).toEqual([1, 3, 4, 5]);
+      expect(list.delete(1)).toBe(true);
+      expect(list.toArray()).toEqual([3, 4, 5]);
+      expect(list.delete(5)).toBe(true);
+      expect(list.toArray()).toEqual([3, 4]);
     });
 
     it('should return false if the value is not found', () => {
@@ -362,8 +381,8 @@ describe('SinglyLinkedList Operation Test', () => {
     const insertSuccess = objectList.insertBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 
-    const findNode = objectList.findNode(newObj); // Use newObj instead of obj2
-    expect(findNode?.val).toEqual(newObj);
+    const getNode = objectList.getNode(newObj); // Use newObj instead of obj2
+    expect(getNode?.val).toEqual(newObj);
 
     const deleted = objectList.delete(newObj); // Use newObj instead of obj2
     expect(deleted).toBe(true);
@@ -393,7 +412,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', () => {
@@ -427,7 +446,6 @@ describe('SinglyLinkedList', () => {
     expect(list.length).toBe(1);
   });
 
-  // Add more test cases for other methods like shift, unshift, getAt, deleteAt, and more.
 
   it('should reverse the list', () => {
     list.push(1);
@@ -439,7 +457,6 @@ describe('SinglyLinkedList', () => {
     // Add more assertions for reversed order.
   });
 
-  // Add more test cases for other methods like find, indexOf, and more.
 
   it('should convert the list to an array', () => {
     list.push(1);
@@ -447,5 +464,35 @@ describe('SinglyLinkedList', () => {
     list.push(3);
     const array = list.toArray();
     expect(array).toEqual([1, 2, 3]);
+    // @ts-ignore
+    expect([...list]).toEqual([1, 2, 3]);
+  });
+
+  it('should filter the list', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+    expect(list.filter(val => val !== 2).toArray()).toEqual([1, 3]);
+  });
+
+
+  it('should forEach the list', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+    list.forEach(val => val++);
+    expect(list.toArray()).toEqual([1, 2, 3])
+  });
+
+  it('should map the list', () => {
+    list.addLast(1);
+    list.push(2);
+    list.push(3);
+    expect(list.map(val => val * 2).toArray()).toEqual([2, 4, 6]);
+  });
+
+  it('should reduce the list', () => {
+    const list1 = SinglyLinkedList.fromArray([1, 2, 3]);
+    expect(list1.reduce((acc, val) => acc + val, 0)).toEqual(6);
   });
 });

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