data-structure-typed 1.41.5 → 1.41.6

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

@@ -1,49 +0,0 @@
-import {DirectedGraph, UndirectedGraph} from '../../../../src';
-
-describe('Overall Graph Operation Test', () => {
-  it('Overall DirectedGraph Operation Test', () => {
-    const graph = new DirectedGraph();
-
-    graph.addVertex('A');
-    graph.addVertex('B');
-
-    graph.hasVertex('A'); // true
-    graph.hasVertex('B'); // true
-    graph.hasVertex('C'); // false
-    expect(graph.hasVertex('A')).toBe(true); // true
-    expect(graph.hasVertex('B')).toBe(true); // true
-    expect(graph.hasVertex('C')).toBe(false); // false
-
-    graph.addEdge('A', 'B');
-    graph.hasEdge('A', 'B'); // true
-    graph.hasEdge('B', 'A'); // false
-    expect(graph.hasEdge('A', 'B')).toBe(true); // true
-    expect(graph.hasEdge('B', 'A')).toBe(false); // false
-
-    graph.deleteEdgeSrcToDest('A', 'B');
-    graph.hasEdge('A', 'B'); // false
-    expect(graph.hasEdge('A', 'B')).toBe(false); // false
-
-    graph.addVertex('C');
-
-    graph.addEdge('A', 'B');
-    graph.addEdge('B', 'C');
-
-    const topologicalOrderKeys = graph.topologicalSort();
-    expect(topologicalOrderKeys).toEqual(['A', 'B', 'C']);
-  });
-  it('Overall UndirectedGraph Operation Test', () => {
-    const graph = new UndirectedGraph();
-    graph.addVertex('A');
-    graph.addVertex('B');
-    graph.addVertex('C');
-    graph.addVertex('D');
-    graph.deleteVertex('C');
-    graph.addEdge('A', 'B');
-    graph.addEdge('B', 'D');
-
-    const dijkstraResult = graph.dijkstra('A');
-    Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key); // ['A', 'B', 'D']
-    expect(Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key)).toEqual(['A', 'B', 'D']);
-  });
-});

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

@@ -1,149 +0,0 @@
-import {UndirectedEdge, UndirectedGraph, UndirectedVertex} from '../../../../src';
-
-describe('UndirectedGraph Operation Test', () => {
-  let graph: UndirectedGraph;
-
-  beforeEach(() => {
-    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');
-
-    graph.addVertex(vertex1);
-    graph.addVertex(vertex2);
-
-    expect(graph.hasVertex(vertex1)).toBe(true);
-    expect(graph.hasVertex(vertex2)).toBe(true);
-  });
-
-  it('should add edges', () => {
-    const vertex1 = new UndirectedVertex('A');
-    const vertex2 = new UndirectedVertex('B');
-    const edge = new UndirectedEdge('A', 'B');
-
-    graph.addVertex(vertex1);
-    graph.addVertex(vertex2);
-    graph.addEdge(edge);
-
-    expect(graph.hasEdge('A', 'B')).toBe(true);
-    expect(graph.hasEdge('B', 'A')).toBe(true);
-  });
-
-  it('should delete edges', () => {
-    const vertex1 = new UndirectedVertex('A');
-    const vertex2 = new UndirectedVertex('B');
-    const edge = new UndirectedEdge('A', 'B');
-
-    graph.addVertex(vertex1);
-    graph.addVertex(vertex2);
-    graph.addEdge(edge);
-
-    expect(graph.deleteEdge(edge)).toBe(edge);
-    expect(graph.hasEdge('A', 'B')).toBe(false);
-  });
-
-  it('should perform topological sort', () => {
-    graph.addVertex('A');
-    graph.addVertex('B');
-    graph.addVertex('C');
-    graph.addVertex('D');
-    graph.deleteVertex('C');
-    graph.addEdge('A', 'B');
-    graph.addEdge('B', 'D');
-
-    const dijkstraResult = graph.dijkstra('A');
-    expect(Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key)).toEqual(['A', 'B', 'D']);
-  });
-});
-
-describe('UndirectedGraph', () => {
-  let undirectedGraph: UndirectedGraph<string, string>;
-
-  beforeEach(() => {
-    // Create a new UndirectedGraph instance before each test
-    undirectedGraph = new UndirectedGraph<string, 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

@@ -1,74 +0,0 @@
-import {CoordinateMap} from '../../../../src';
-
-describe('CoordinateMap', () => {
-  it('should set and get values correctly', () => {
-    const coordinateMap = new CoordinateMap<string>();
-    const key = [1, 2, 3];
-    const value = 'TestValue';
-
-    coordinateMap.set(key, value);
-    const retrievedValue = coordinateMap.get(key);
-
-    expect(retrievedValue).toBe(value);
-  });
-
-  it('should return true when key exists', () => {
-    const coordinateMap = new CoordinateMap<string>();
-    const key = [1, 2, 3];
-    const value = 'TestValue';
-
-    coordinateMap.set(key, value);
-
-    expect(coordinateMap.has(key)).toBe(true);
-  });
-
-  it('should return false when key does not exist', () => {
-    const coordinateMap = new CoordinateMap<string>();
-    const key = [1, 2, 3];
-
-    expect(coordinateMap.has(key)).toBe(false);
-  });
-
-  it('should delete key-value pair correctly', () => {
-    const coordinateMap = new CoordinateMap<string>();
-    const key = [1, 2, 3];
-    const value = 'TestValue';
-
-    coordinateMap.set(key, value);
-    coordinateMap.delete(key);
-
-    expect(coordinateMap.has(key)).toBe(false);
-  });
-
-  it('should allow changing the joint character', () => {
-    const coordinateMap = new CoordinateMap<string>();
-    const key = [1, 2, 3];
-    const value = 'TestValue';
-
-    coordinateMap.set(key, value);
-    const newKey = [1, 2, 3];
-    const retrievedValue = coordinateMap.get(newKey);
-
-    expect(retrievedValue).toBe(value);
-  });
-});
-
-describe('CoordinateMap', () => {
-  class MyCoordinateMap<V = any> extends CoordinateMap<V> {
-    constructor(joint?: string) {
-      super(joint);
-      this._joint = 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

@@ -1,66 +0,0 @@
-import {CoordinateSet} from '../../../../src';
-
-describe('CoordinateSet', () => {
-  it('should add and check values correctly', () => {
-    const coordinateSet = new CoordinateSet();
-    const value = [1, 2, 3];
-
-    coordinateSet.add(value);
-    const hasValue = coordinateSet.has(value);
-
-    expect(hasValue).toBe(true);
-  });
-
-  it('should return false when value does not exist', () => {
-    const coordinateSet = new CoordinateSet();
-    const value = [1, 2, 3];
-
-    expect(coordinateSet.has(value)).toBe(false);
-  });
-
-  it('should delete value correctly', () => {
-    const coordinateSet = new CoordinateSet();
-    const value = [1, 2, 3];
-
-    coordinateSet.add(value);
-    coordinateSet.delete(value);
-
-    expect(coordinateSet.has(value)).toBe(false);
-  });
-
-  it('should allow changing the joint character', () => {
-    const coordinateSet = new CoordinateSet();
-    const value = [1, 2, 3];
-
-    coordinateSet.add(value);
-    const newValue = [1, 2, 3];
-    const hasValue = coordinateSet.has(newValue);
-
-    expect(hasValue).toBe(true);
-  });
-});
-
-describe('MyCoordinateSet', () => {
-  class MyCoordinateSet extends CoordinateSet {
-    constructor(joint?: string) {
-      super(joint);
-      this._joint = 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-map.test.ts

@@ -1,103 +0,0 @@
-import {HashMap} from '../../../../src';
-
-describe('HashMap', () => {
-  let hashMap: HashMap<string, number>;
-
-  beforeEach(() => {
-    hashMap = new HashMap<string, number>();
-  });
-
-  it('should initialize correctly', () => {
-    expect(hashMap.size).toBe(0);
-    expect(hashMap.table.length).toBe(16);
-    expect(hashMap.loadFactor).toBe(0.75);
-    expect(hashMap.capacityMultiplier).toBe(2);
-    expect(hashMap.initialCapacity).toBe(16);
-    expect(hashMap.isEmpty()).toBe(true);
-  });
-
-  it('should put and get values', () => {
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-    hashMap.set('three', 3);
-
-    expect(hashMap.get('one')).toBe(1);
-    expect(hashMap.get('two')).toBe(2);
-    expect(hashMap.get('three')).toBe(3);
-  });
-
-  it('should handle key collisions', () => {
-    // Force a collision by setting two different keys to the same bucket
-    hashMap.set('key1', 1);
-    hashMap.set('key2', 2);
-
-    expect(hashMap.get('key1')).toBe(1);
-    expect(hashMap.get('key2')).toBe(2);
-  });
-
-  it('should delete values', () => {
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-
-    hashMap.delete('one');
-    expect(hashMap.get('one')).toBeUndefined();
-    expect(hashMap.size).toBe(1);
-  });
-
-  it('should clear the HashMap', () => {
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-
-    hashMap.clear();
-    expect(hashMap.size).toBe(0);
-    expect(hashMap.isEmpty()).toBe(true);
-  });
-
-  it('should iterate over entries', () => {
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-    hashMap.set('three', 3);
-
-    const entries = Array.from(hashMap.entries());
-    expect(entries).toEqual(
-      expect.arrayContaining([
-        ['one', 1],
-        ['two', 2],
-        ['three', 3]
-      ])
-    );
-  });
-
-  it('should resize the table when load factor is exceeded', () => {
-    // Set a small initial capacity for testing resizing
-    hashMap = new HashMap<string, number>(4, 0.5);
-
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-    hashMap.set('three', 3);
-    hashMap.set('four', 4); // This should trigger a resize
-
-    expect(hashMap.table.length).toBe(8);
-    expect(hashMap.get('one')).toBe(1);
-    expect(hashMap.get('two')).toBe(2);
-    expect(hashMap.get('three')).toBe(3);
-    expect(hashMap.get('four')).toBe(4);
-  });
-
-  it('should allow using a custom hash function', () => {
-    const customHashFn = () => {
-      // A simple custom hash function that always returns 0
-      return 0;
-    };
-    hashMap = new HashMap<string, number>(16, 0.75, customHashFn);
-
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-
-    expect(hashMap.get('one')).toBe(1);
-    expect(hashMap.get('two')).toBe(2);
-    // Since the custom hash function always returns 0, these keys will collide.
-    // Make sure they are stored separately.
-    expect(hashMap.table[0].length).toBe(2);
-  });
-});

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

@@ -1,186 +0,0 @@
-import {HashTable, HashTableNode} from '../../../../src';
-
-describe('HashNode', () => {
-  it('should create a HashNode with key and value', () => {
-    const key = 'testKey';
-    const value = 'testValue';
-    const hashNode = new HashTableNode(key, value);
-
-    expect(hashNode.key).toBe(key);
-    expect(hashNode.value).toBe(value);
-    expect(hashNode.next).toBe(null);
-  });
-});
-
-describe('HashTable', () => {
-  it('should initialize with default capacity', () => {
-    const hashTable = new HashTable<string, string>();
-    expect(hashTable.capacity).toBe(16);
-    expect(hashTable.buckets).toEqual(new Array(16).fill(null));
-    expect(hashTable.hashFn('a')).toBe(6);
-    expect(hashTable.capacity).toBe(16);
-    expect(hashTable.size).toBe(0);
-    expect(hashTable.buckets.length).toBe(16);
-  });
-
-  it('should initialize with custom capacity', () => {
-    const customCapacity = 500;
-    const hashTable = new HashTable<string, string>(customCapacity);
-
-    expect(hashTable.capacity).toBe(customCapacity);
-    expect(hashTable.size).toBe(0);
-    expect(hashTable.buckets.length).toBe(customCapacity);
-  });
-
-  it('should put and get values correctly', () => {
-    const hashTable = new HashTable<string, string>();
-    const key = 'testKey';
-    const value = 'testValue';
-
-    hashTable.set(key, value);
-    const retrievedValue = hashTable.get(key);
-
-    expect(retrievedValue).toBe(value);
-  });
-
-  it('should handle collisions by chaining', () => {
-    const hashTable = new HashTable<string, string>();
-    const key1 = 'testKey1';
-    const value1 = 'testValue1';
-    const key2 = 'testKey2';
-    const value2 = 'testValue2';
-
-    hashTable.set(key1, value1);
-    hashTable.set(key2, value2);
-
-    const retrievedValue1 = hashTable.get(key1);
-    const retrievedValue2 = hashTable.get(key2);
-
-    expect(retrievedValue1).toBe(value1);
-    expect(retrievedValue2).toBe(value2);
-  });
-
-  it('should update value for an existing key', () => {
-    const hashTable = new HashTable<string, string>();
-    const key = 'testKey';
-    const initialValue = 'testValue1';
-    const updatedValue = 'testValue2';
-
-    hashTable.set(key, initialValue);
-    hashTable.set(key, updatedValue);
-
-    const retrievedValue = hashTable.get(key);
-
-    expect(retrievedValue).toBe(updatedValue);
-  });
-
-  it('should return undefined for non-existent key', () => {
-    const hashTable = new HashTable<string, string>();
-    const key = 'nonExistentKey';
-
-    const retrievedValue = hashTable.get(key);
-
-    expect(retrievedValue).toBeUndefined();
-  });
-
-  it('should delete key-value pair correctly', () => {
-    const hashTable = new HashTable<string, string>();
-    const key = 'testKey';
-    const value = 'testValue';
-
-    hashTable.set(key, value);
-    hashTable.delete(key);
-
-    const retrievedValue = hashTable.get(key);
-
-    expect(retrievedValue).toBeUndefined();
-    expect(hashTable.size).toBe(0);
-  });
-});
-
-describe('HashTable', () => {
-  let hashTable: HashTable<string, number>;
-
-  beforeEach(() => {
-    hashTable = new HashTable<string, number>();
-  });
-
-  it('should insert and retrieve values correctly', () => {
-    hashTable.set('one', 1);
-    hashTable.set('two', 2);
-
-    expect(hashTable.get('one')).toBe(1);
-    expect(hashTable.get('two')).toBe(2);
-  });
-
-  it('should update values correctly', () => {
-    hashTable.set('one', 1);
-    expect(hashTable.get('one')).toBe(1);
-
-    hashTable.set('one', 100); // Update the value
-    expect(hashTable.get('one')).toBe(100);
-  });
-
-  it('should handle collisions correctly', () => {
-    hashTable = new HashTable<string, number>(1); // Set a small capacity to force collisions
-    hashTable.set('one', 1);
-    hashTable.set('two', 2);
-
-    expect(hashTable.get('one')).toBe(1);
-    expect(hashTable.get('two')).toBe(2);
-  });
-
-  it('should delete values correctly', () => {
-    hashTable.set('one', 1);
-    hashTable.set('two', 2);
-    hashTable.delete('one');
-
-    expect(hashTable.get('one')).toBeUndefined();
-    expect(hashTable.get('two')).toBe(2);
-  });
-
-  it('should handle non-existent keys correctly', () => {
-    expect(hashTable.get('non-existent')).toBeUndefined();
-    hashTable.delete('non-existent'); // Removing a non-existent key should not cause errors
-  });
-
-  it('should handle custom hash function correctly', () => {
-    // const customHashFn = () => {
-    //   // Custom hash function that returns a fixed value for all keys
-    //   return 42;
-    // };
-
-    hashTable = new HashTable<string, number>(16);
-    hashTable.set('one', 1);
-    expect(hashTable.get('one')).toBe(1);
-    expect(hashTable.get('two')).toBeUndefined();
-  });
-
-  it('should expand when load factor exceeds threshold', () => {
-    hashTable = new HashTable<string, number>(2); // Set a small capacity to trigger expansion
-    hashTable.set('one', 1);
-    hashTable.set('two', 2);
-    hashTable.set('three', 3); // This should trigger an expansion
-
-    expect(hashTable.capacity).toBe(16);
-    expect(hashTable.get('one')).toBe(1);
-    expect(hashTable.get('two')).toBe(2);
-    expect(hashTable.get('three')).toBe(3);
-  });
-});
-
-describe('HashTable performance', function () {
-  it('Items set performance', function () {
-    const mag = 100000;
-    const ht = new HashTable();
-    // const s = performance.now();
-    for (let i = 0; i < mag; i++) {
-      ht.set(i, i);
-    }
-    // const s1 = performance.now();
-    const map = new Map();
-    for (let i = 0; i < mag; i++) {
-      map.set(i, i);
-    }
-  });
-});