data-structure-typed 1.33.9 → 1.33.10

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

@@ -0,0 +1,54 @@
+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);
+  });
+});

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

@@ -0,0 +1,41 @@
+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);
+  });
+});

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

@@ -0,0 +1,104 @@
+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.hashFn = () => 0; // Override hash function to return the same index
+    hashMap.set('key1', 1);
+    hashMap.set('key2', 2);
+
+    expect(hashMap.get('key1')).toBe(1);
+    expect(hashMap.get('key2')).toBe(2);
+  });
+
+  it('should remove values', () => {
+    hashMap.set('one', 1);
+    hashMap.set('two', 2);
+
+    hashMap.remove('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

@@ -0,0 +1,184 @@
+import {HashTableNode, HashTable} 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.val).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.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 remove key-value pair correctly', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'testKey';
+    const value = 'testValue';
+
+    hashTable.set(key, value);
+    hashTable.remove(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 remove values correctly', () => {
+    hashTable.set('one', 1);
+    hashTable.set('two', 2);
+    hashTable.remove('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.remove('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);
+    }
+  });
+});

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

@@ -0,0 +1,55 @@
+import {MaxHeap, MinHeap} from '../../../../src';
+
+describe('Heap Operation Test', () => {
+  it('should numeric heap work well', function () {
+    const minNumHeap = new MinHeap<number>();
+    minNumHeap.add(1).add(6).add(2).add(0).add(5).add(9);
+    expect(minNumHeap.has(1)).toBe(true);
+    expect(minNumHeap.has(2)).toBe(true);
+    expect(minNumHeap.poll()).toBe(0);
+    expect(minNumHeap.poll()).toBe(1);
+    expect(minNumHeap.peek()).toBe(2);
+    expect(!minNumHeap.has(1));
+    expect(minNumHeap.has(2));
+    const arrFromHeap = minNumHeap.toArray();
+    expect(arrFromHeap.length).toBe(4);
+    expect(arrFromHeap[0]).toBe(2);
+    expect(arrFromHeap[1]).toBe(5);
+    expect(arrFromHeap[2]).toBe(9);
+    expect(arrFromHeap[3]).toBe(6);
+    expect(minNumHeap.sort()).toEqual([2, 5, 6, 9]);
+  });
+
+  it('should object heap work well', function () {
+    const minHeap = new MinHeap<{a: string}>();
+    minHeap.add(1, {a: 'a1'});
+    minHeap.add(6, {a: 'a6'});
+    minHeap.add(2, {a: 'a2'});
+    minHeap.add(0, {a: 'a0'});
+
+    expect(minHeap.peek()).toEqual({a: 'a0'});
+    expect(minHeap.toArray()).toEqual([{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}]);
+    let i = 0;
+    const expectPolled = [{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}];
+    while (minHeap.size > 0) {
+      expect(minHeap.poll()).toEqual(expectPolled[i]);
+      i++;
+    }
+
+    const maxHeap = new MaxHeap<{a: string}>();
+    maxHeap.add(1, {a: 'a1'});
+    maxHeap.add(6, {a: 'a6'});
+    maxHeap.add(5, {a: 'a5'});
+    maxHeap.add(2, {a: 'a2'});
+    maxHeap.add(0, {a: 'a0'});
+    maxHeap.add(9, {a: 'a9'});
+    expect(maxHeap.peek()).toEqual({a: 'a9'});
+    expect(maxHeap.toArray()).toEqual([{a: 'a9'}, {a: 'a2'}, {a: 'a6'}, {a: 'a1'}, {a: 'a0'}, {a: 'a5'}]);
+    const maxExpectPolled = [{a: 'a9'}, {a: 'a6'}, {a: 'a5'}, {a: 'a2'}, {a: 'a1'}, {a: 'a0'}];
+    let maxI = 0;
+    while (maxHeap.size > 0) {
+      expect(maxHeap.poll()).toEqual(maxExpectPolled[maxI]);
+      maxI++;
+    }
+  });
+});

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

@@ -0,0 +1,44 @@
+import {HeapItem, MaxHeap} from '../../../../src';
+
+describe('MaxHeap Operation Test', () => {
+  it('should object Max Heap operations be proper', function () {
+    const maxHeap = new MaxHeap<{keyA: string}>();
+    const myObj1 = {keyA: 'a1'},
+      myObj6 = {keyA: 'a6'},
+      myObj5 = {keyA: 'a5'},
+      myObj2 = {keyA: 'a2'},
+      myObj0 = {keyA: 'a0'},
+      myObj9 = {keyA: 'a9'};
+    maxHeap.add(1, myObj1);
+    expect(maxHeap.has(myObj1)).toBe(true);
+    expect(maxHeap.has(myObj9)).toBe(false);
+    maxHeap.add(6, myObj6);
+    expect(maxHeap.has(myObj6)).toBe(true);
+    maxHeap.add(5, myObj5);
+    expect(maxHeap.has(myObj5)).toBe(true);
+    maxHeap.add(2, myObj2);
+    expect(maxHeap.has(myObj2)).toBe(true);
+    expect(maxHeap.has(myObj6)).toBe(true);
+    maxHeap.add(0, myObj0);
+    expect(maxHeap.has(myObj0)).toBe(true);
+    expect(maxHeap.has(myObj9)).toBe(false);
+    maxHeap.add(9, myObj9);
+    expect(maxHeap.has(myObj9)).toBe(true);
+
+    const peek9 = maxHeap.peek(true);
+    peek9 && peek9.val && expect(peek9.val.keyA).toBe('a9');
+
+    const heapToArr = maxHeap.toArray(true);
+    expect(heapToArr.map(item => item?.val?.keyA)).toEqual(['a9', 'a2', 'a6', 'a1', 'a0', 'a5']);
+
+    const values = ['a9', 'a6', 'a5', 'a2', 'a1', 'a0'];
+    let i = 0;
+    while (maxHeap.size > 0) {
+      const polled = maxHeap.poll(true);
+      expect(polled).toBeInstanceOf(HeapItem);
+      polled && expect(polled.val).toHaveProperty('keyA');
+      polled && polled.val && expect(polled.val.keyA).toBe(values[i]);
+      i++;
+    }
+  });
+});

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

@@ -0,0 +1,82 @@
+import {HeapItem, MinHeap} from '../../../../src';
+
+describe('MinHeap Operation Test', () => {
+  it('should numeric Min Heap operations be proper', function () {
+    const minNumHeap = new MinHeap<number>();
+    expect(minNumHeap).toBeInstanceOf(MinHeap);
+
+    minNumHeap.add(1);
+    expect(minNumHeap.has(1)).toBe(true);
+    minNumHeap.add(6);
+    expect(minNumHeap.has(2)).toBe(false);
+    expect(minNumHeap.has(6)).toBe(true);
+    minNumHeap.add(2);
+    expect(minNumHeap.has(2)).toBe(true);
+    minNumHeap.add(0);
+    expect(minNumHeap.has(0)).toBe(true);
+    minNumHeap.add(5);
+    expect(minNumHeap.has(5)).toBe(true);
+    minNumHeap.add(9);
+    expect(minNumHeap.has(9)).toBe(true);
+    expect(minNumHeap.size).toBe(6);
+
+    const poll1 = minNumHeap.poll(true);
+    expect(poll1).toBeInstanceOf(HeapItem);
+    poll1 instanceof HeapItem && expect(poll1.val).toBe(0);
+
+    const poll2 = minNumHeap.poll(true);
+    expect(poll2).toBeInstanceOf(HeapItem);
+    poll2 instanceof HeapItem && expect(poll2.val).toBe(1);
+
+    const peek1 = minNumHeap.peek(true);
+    expect(peek1).toBeInstanceOf(HeapItem);
+    peek1 instanceof HeapItem && expect(peek1.val).toBe(2);
+
+    const heapArray = minNumHeap.toArray(true);
+    expect(heapArray).toBeInstanceOf(Array);
+    expect(heapArray.map(item => item?.priority)).toEqual([2, 5, 9, 6]);
+    expect(minNumHeap.size).toBe(4);
+  });
+
+  it('should object Min Heap operations be proper', function () {
+    class MyObject {
+      keyA: string;
+
+      constructor(keyA: string) {
+        this.keyA = keyA;
+      }
+    }
+
+    const minObjHeap = new MinHeap<MyObject>();
+
+    const obj1 = new MyObject('a1'),
+      obj6 = new MyObject('a6'),
+      obj2 = new MyObject('a2'),
+      obj0 = new MyObject('a0');
+    minObjHeap.add(1, obj1);
+    expect(minObjHeap.has(obj1)).toBe(true);
+    expect(minObjHeap.has(obj6)).toBe(false);
+    minObjHeap.add(6, obj6);
+    expect(minObjHeap.has(obj6)).toBe(true);
+    minObjHeap.add(2, obj2);
+    expect(minObjHeap.has(obj2)).toBe(true);
+    minObjHeap.add(0, obj0);
+    expect(minObjHeap.has(obj0)).toBe(true);
+
+    const peek = minObjHeap.peek(true);
+    peek && peek.val && expect(peek.val.keyA).toBe('a0');
+
+    const heapToArr = minObjHeap.toArray(true);
+    expect(heapToArr.map(item => item?.val?.keyA)).toEqual(['a0', 'a1', 'a2', 'a6']);
+
+    const values = ['a0', 'a1', 'a2', 'a6'];
+    let i = 0;
+    while (minObjHeap.size > 0) {
+      const polled = minObjHeap.poll(true);
+      expect(polled).toBeInstanceOf(HeapItem);
+      polled && expect(polled.val).toBeInstanceOf(MyObject);
+      polled && polled.val && expect(polled.val.keyA).toBe(values[i]);
+      i++;
+    }
+  });
+});