data-structure-typed 1.39.5 → 1.39.6

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

@@ -93,9 +93,9 @@ describe('DirectedGraph Operation Test', () => {
 });
 
 class MyVertex<V = any> extends DirectedVertex<V> {
-  constructor(key: VertexKey, val?: V) {
-    super(key, val);
-    this._data = val;
+  constructor(key: VertexKey, value?: V) {
+    super(key, value);
+    this._data = value;
   }
 
   private _data: V | undefined;
@@ -110,9 +110,9 @@ class MyVertex<V = any> extends DirectedVertex<V> {
 }
 
 class MyEdge<E = any> extends DirectedEdge<E> {
-  constructor(v1: VertexKey, v2: VertexKey, weight?: number, val?: E) {
-    super(v1, v2, weight, val);
-    this._data = val;
+  constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E) {
+    super(v1, v2, weight, value);
+    this._data = value;
   }
 
   private _data: E | undefined;
@@ -132,12 +132,20 @@ class MyDirectedGraph<
   VO extends MyVertex<V> = MyVertex<V>,
   EO extends MyEdge<E> = MyEdge<E>
 > extends DirectedGraph<V, E, VO, EO> {
-  createVertex(key: VertexKey, val: V): VO {
-    return new MyVertex(key, val) as VO;
+  createVertex(key: VertexKey, value: V): VO {
+    return new MyVertex(key, value) as VO;
+  }
+
+  createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO {
+    return new MyEdge(src, dest, weight ?? 1, value) as EO;
+  }
+
+  setInEdgeMap(value: Map<VO, EO[]>) {
+    super._setInEdgeMap(value);
   }
 
-  createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E): EO {
-    return new MyEdge(src, dest, weight ?? 1, val) as EO;
+  setOutEdgeMap(value: Map<VO, EO[]>) {
+    super._setOutEdgeMap(value);
   }
 }
 
@@ -164,6 +172,8 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     myGraph.addVertex(2, 'data2');
     myGraph.addEdge(1, 2, 10, 'edge-data1-2');
     myGraph.addEdge(new MyEdge(2, 1, 20, 'edge-data2-1'));
+    myGraph.setInEdgeMap(myGraph.inEdgeMap);
+    myGraph.setOutEdgeMap(myGraph.outEdgeMap);
 
     expect(myGraph.edgeSet().length).toBe(2);
     // TODO
@@ -182,7 +192,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     expect(edge1).toBeInstanceOf(MyEdge);
     if (edge1) {
       expect(edge1.data).toBe('val1');
-      expect(edge1?.val).toBe('val1');
+      expect(edge1?.value).toBe('val1');
       expect(edge1).toBeInstanceOf(MyEdge);
       expect(edge1.src).toBe(1);
       expect(edge1).toEqual(edge2);
@@ -204,7 +214,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
 
     expect(removedEdge).toBeInstanceOf(MyEdge);
     if (removedEdge) {
-      removedEdge && expect(removedEdge.val).toBe('edge-data1-2');
+      removedEdge && expect(removedEdge.value).toBe('edge-data1-2');
       removedEdge && expect(removedEdge.src).toBe(1);
     }
     expect(edgeAfterRemoval).toBeNull();

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

@@ -7,6 +7,14 @@ describe('UndirectedGraph Operation Test', () => {
     graph = new UndirectedGraph();
   });
 
+  it('should edge cases', () => {
+    expect(graph.deleteEdge(new UndirectedEdge('c', 'd'))).toBe(null);
+    expect(graph.deleteEdgeBetween('c', 'd')).toBe(null);
+    expect(graph.degreeOf('c')).toBe(0);
+    expect(graph.edgesOf('c').length).toBe(0);
+    expect(graph.getEndsOfEdge(new UndirectedEdge('c', 'd'))).toBe(null);
+  });
+
   it('should add vertices', () => {
     const vertex1 = new UndirectedVertex('A');
     const vertex2 = new UndirectedVertex('B');

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

@@ -7,7 +7,7 @@ describe('HashNode', () => {
     const hashNode = new HashTableNode(key, value);
 
     expect(hashNode.key).toBe(key);
-    expect(hashNode.val).toBe(value);
+    expect(hashNode.value).toBe(value);
     expect(hashNode.next).toBe(null);
   });
 });

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

@@ -4,9 +4,9 @@ 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);
+    expect(node1.value).toBe(2);
+    node1.value = 1;
+    expect(node1.value).toBe(1);
   });
 });
 
@@ -33,13 +33,13 @@ describe('DoublyLinkedList Operation Test', () => {
 
   it('should delete tail', () => {
     expect(list.delete(list.tail)).toBe(true);
-    expect(list.tail?.val).toBe(4);
+    expect(list.tail?.value).toBe(4);
     expect(list.delete(6)).toBe(false);
-    expect(list.tail?.val).toBe(4);
+    expect(list.tail?.value).toBe(4);
   });
 
   it('should find null', () => {
-    expect(list.find(val => val === 6)).toBe(null);
+    expect(list.find(value => value === 6)).toBe(null);
   });
 
   it('should indexOf -1', () => {
@@ -47,7 +47,7 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should findBackward null', () => {
-    expect(list.findBackward(val => val === 0)).toBe(null);
+    expect(list.findBackward(value => value === 0)).toBe(null);
   });
 
   it('should insertAfter tail', () => {
@@ -80,8 +80,8 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
     expect(list.length).toBe(3);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(3);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(3);
   });
 
   it('should pop elements from the end of the list', () => {
@@ -90,8 +90,8 @@ describe('DoublyLinkedList Operation Test', () => {
     const poppedValue = list.pop();
     expect(poppedValue).toBe(2);
     expect(list.length).toBe(1);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(1);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(1);
   });
   it('should insert elements at specific positions', () => {
     list.push(1);
@@ -114,7 +114,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.insertAt(5, 4);
     expect(list.length).toBe(6);
     expect(list.getAt(5)).toBe(4);
-    expect(list.tail!.val).toBe(4);
+    expect(list.tail!.value).toBe(4);
   });
 
   it('should delete elements at specific positions', () => {
@@ -126,12 +126,12 @@ describe('DoublyLinkedList Operation Test', () => {
     const deletedValue = list.deleteAt(0);
     expect(deletedValue).toBe(1);
     expect(list.length).toBe(2);
-    expect(list.head!.val).toBe(2);
+    expect(list.head!.value).toBe(2);
 
     // Deleting from the middle
     list.deleteAt(0); // Deleting the second element
     expect(list.length).toBe(1);
-    expect(list.head!.val).toBe(3);
+    expect(list.head!.value).toBe(3);
 
     // Deleting from the end
     list.deleteAt(0);
@@ -147,12 +147,12 @@ describe('DoublyLinkedList Operation Test', () => {
 
     list.delete(2);
     expect(list.length).toBe(2);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(3);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(3);
 
     list.delete(1);
     expect(list.length).toBe(1);
-    expect(list.head!.val).toBe(3);
+    expect(list.head!.value).toBe(3);
 
     list.delete(3);
     expect(list.length).toBe(0);
@@ -176,7 +176,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const mappedList = list.map(val => val * 2);
+    const mappedList = list.map(value => value * 2);
 
     expect(mappedList.toArray()).toEqual([2, 4, 6]);
   });
@@ -187,7 +187,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const filteredList = list.filter(val => val % 2 === 0);
+    const filteredList = list.filter(value => value % 2 === 0);
 
     expect(filteredList.toArray()).toEqual([2, 4]);
   });
@@ -198,7 +198,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const sum = list.reduce((acc, val) => acc + val, 0);
+    const sum = list.reduce((acc, value) => acc + value, 0);
 
     expect(sum).toBe(10);
   });
@@ -227,7 +227,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const found = list.find(val => val % 2 === 0);
+    const found = list.find(value => value % 2 === 0);
 
     expect(found).toBe(2);
   });
@@ -248,7 +248,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const lastEven = list.findBackward(val => val % 2 === 0);
+    const lastEven = list.findBackward(value => value % 2 === 0);
 
     expect(lastEven).toBe(4);
   });
@@ -283,8 +283,8 @@ describe('DoublyLinkedList Operation Test', () => {
     list.reverse();
 
     expect(list.toArray()).toEqual([3, 2, 1]);
-    expect(list.head?.val).toBe(3);
-    expect(list.tail?.val).toBe(1);
+    expect(list.head?.value).toBe(3);
+    expect(list.tail?.value).toBe(1);
   });
 
   it('should iterate over each element and apply a callback', () => {
@@ -293,8 +293,8 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
 
     const result: number[] = [];
-    list.forEach(val => {
-      result.push(val * 2);
+    list.forEach(value => {
+      result.push(value * 2);
     });
 
     expect(result).toEqual([2, 4, 6]);
@@ -305,7 +305,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const mappedList = list.map(val => val * 2);
+    const mappedList = list.map(value => value * 2);
 
     expect(mappedList.toArray()).toEqual([2, 4, 6]);
   });
@@ -316,7 +316,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const filteredList = list.filter(val => val % 2 === 0);
+    const filteredList = list.filter(value => value % 2 === 0);
 
     expect(filteredList.toArray()).toEqual([2, 4]);
   });
@@ -326,7 +326,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const sum = list.reduce((acc, val) => acc + val, 0);
+    const sum = list.reduce((acc, value) => acc + value, 0);
 
     expect(sum).toBe(6);
   });
@@ -387,7 +387,7 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(insertSuccess).toBe(true);
 
     const getNode = objectList.getNode(newObj); // Use newObj instead of obj2
-    expect(getNode?.val).toEqual(newObj);
+    expect(getNode?.value).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

@@ -26,7 +26,7 @@ describe('LinkedList Performance Test', () => {
       if (i === midIndex) {
         midSinglyNode = singlyList.getNode(i);
       } else if (i > midIndex && midSinglyNode) {
-        singlyList.insertBefore(midSinglyNode.val, i);
+        singlyList.insertBefore(midSinglyNode.value, i);
       }
     }
 

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

@@ -4,9 +4,9 @@ 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);
+    expect(node1.value).toBe(2);
+    node1.value = 1;
+    expect(node1.value).toBe(1);
   });
 });
 
@@ -75,7 +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);
+      expect(list.getNodeAt(2)?.value).toBe(3);
     });
 
     it('should return undefined for an out-of-bounds index', () => {
@@ -382,7 +382,7 @@ describe('SinglyLinkedList Operation Test', () => {
     expect(insertSuccess).toBe(true);
 
     const getNode = objectList.getNode(newObj); // Use newObj instead of obj2
-    expect(getNode?.val).toEqual(newObj);
+    expect(getNode?.value).toEqual(newObj);
 
     const deleted = objectList.delete(newObj); // Use newObj instead of obj2
     expect(deleted).toBe(true);
@@ -431,8 +431,8 @@ describe('SinglyLinkedList', () => {
   it('should push elements to the end of the list', () => {
     list.push(1);
     list.push(2);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(2);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(2);
     expect(list.length).toBe(2);
   });
 
@@ -441,8 +441,8 @@ describe('SinglyLinkedList', () => {
     list.push(2);
     const popped = list.pop();
     expect(popped).toBe(2);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(1);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(1);
     expect(list.length).toBe(1);
   });
 
@@ -451,8 +451,8 @@ describe('SinglyLinkedList', () => {
     list.push(2);
     list.push(3);
     list.reverse();
-    expect(list.head!.val).toBe(3);
-    expect(list.tail!.val).toBe(1);
+    expect(list.head!.value).toBe(3);
+    expect(list.tail!.value).toBe(1);
     // Add more assertions for reversed order.
   });
 
@@ -470,14 +470,14 @@ describe('SinglyLinkedList', () => {
     list.push(1);
     list.push(2);
     list.push(3);
-    expect(list.filter(val => val !== 2).toArray()).toEqual([1, 3]);
+    expect(list.filter(value => value !== 2).toArray()).toEqual([1, 3]);
   });
 
   it('should forEach the list', () => {
     list.push(1);
     list.push(2);
     list.push(3);
-    list.forEach(val => val++);
+    list.forEach(value => value++);
     expect(list.toArray()).toEqual([1, 2, 3]);
   });
 
@@ -485,11 +485,11 @@ describe('SinglyLinkedList', () => {
     list.addLast(1);
     list.push(2);
     list.push(3);
-    expect(list.map(val => val * 2).toArray()).toEqual([2, 4, 6]);
+    expect(list.map(value => value * 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);
+    expect(list1.reduce((acc, value) => acc + value, 0)).toEqual(6);
   });
 });

package/test/utils/big-o.ts

@@ -59,19 +59,19 @@ function findPotentialN(input: any): number {
 function linearRegression(x: number[], y: number[]) {
   const n = x.length;
 
-  const sumX = x.reduce((acc, val) => acc + val, 0);
-  const sumY = y.reduce((acc, val) => acc + val, 0);
+  const sumX = x.reduce((acc, value) => acc + value, 0);
+  const sumY = y.reduce((acc, value) => acc + value, 0);
 
-  const sumXSquared = x.reduce((acc, val) => acc + val ** 2, 0);
-  const sumXY = x.reduce((acc, val, i) => acc + val * y[i], 0);
+  const sumXSquared = x.reduce((acc, value) => acc + value ** 2, 0);
+  const sumXY = x.reduce((acc, value, i) => acc + value * y[i], 0);
 
   const slope = (n * sumXY - sumX * sumY) / (n * sumXSquared - sumX ** 2);
   const intercept = (sumY - slope * sumX) / n;
 
-  const yHat = x.map(val => slope * val + intercept);
+  const yHat = x.map(value => slope * value + intercept);
 
-  const totalVariation = y.map((val, i) => (val - yHat[i]) ** 2).reduce((acc, val) => acc + val, 0);
-  const explainedVariation = y.map(val => (val - sumY / n) ** 2).reduce((acc, val) => acc + val, 0);
+  const totalVariation = y.map((value, i) => (value - yHat[i]) ** 2).reduce((acc, value) => acc + value, 0);
+  const explainedVariation = y.map(value => (value - sumY / n) ** 2).reduce((acc, value) => acc + value, 0);
 
   const rSquared = 1 - totalVariation / explainedVariation;