data-structure-typed 1.38.9 → 1.39.1

package/test/unit/data-structures/matrix/vector2d.test.ts

@@ -0,0 +1,171 @@
+import {Vector2D} from '../../../../src';
+
+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 check if a vector is zero', () => {
+    const nonZeroVector = new Vector2D(3, 4);
+    const zeroVector = new Vector2D(0, 0);
+    expect(nonZeroVector.isZero).toBe(false);
+    expect(zeroVector.isZero).toBe(true);
+  });
+
+  it('should correctly calculate vector length', () => {
+    const vector = new Vector2D(3, 4);
+    expect(vector.length).toBe(5);
+  });
+
+  it('should correctly calculate squared vector length', () => {
+    const vector = new Vector2D(3, 4);
+    expect(vector.lengthSq).toBe(25);
+  });
+
+  it('should correctly round vector components', () => {
+    const vector = new Vector2D(3.6, 4.3);
+    const roundedVector = vector.rounded;
+    expect(roundedVector.x).toBe(4);
+    expect(roundedVector.y).toBe(4);
+  });
+
+  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);
+  });
+
+  it('should correctly subtract two vectors', () => {
+    const vector1 = new Vector2D(4, 5);
+    const vector2 = new Vector2D(1, 2);
+    const result = Vector2D.subtract(vector1, vector2);
+    expect(result.x).toBe(3);
+    expect(result.y).toBe(3);
+  });
+
+  it('should correctly subtract value from a vector', () => {
+    const vector = new Vector2D(5, 7);
+    const result = Vector2D.subtractValue(vector, 3);
+    expect(result.x).toBe(2);
+    expect(result.y).toBe(4);
+  });
+
+  it('should correctly multiply a vector by a value', () => {
+    const vector = new Vector2D(2, 3);
+    const result = Vector2D.multiply(vector, 4);
+    expect(result.x).toBe(8);
+    expect(result.y).toBe(12);
+  });
+
+  it('should correctly divide a vector by a value', () => {
+    const vector = new Vector2D(6, 8);
+    const result = Vector2D.divide(vector, 2);
+    expect(result.x).toBe(3);
+    expect(result.y).toBe(4);
+  });
+
+  it('should correctly check if two vectors are equal', () => {
+    const vector1 = new Vector2D(3, 4);
+    const vector2 = new Vector2D(3, 4);
+    const vector3 = new Vector2D(4, 5);
+    expect(Vector2D.equals(vector1, vector2)).toBe(true);
+    expect(Vector2D.equals(vector1, vector3)).toBe(false);
+  });
+
+  it('should correctly check if two vectors are equal within a rounding factor', () => {
+    const vector1 = new Vector2D(3, 4);
+    const vector2 = new Vector2D(2.9, 3.9);
+    const vector3 = new Vector2D(4, 5);
+    expect(Vector2D.equalsRounded(vector1, vector2, 0.2)).toBe(true);
+    expect(Vector2D.equalsRounded(vector1, vector3, 0.2)).toBe(false);
+  });
+
+  it('should correctly normalize a vector', () => {
+    const vector = new Vector2D(3, 4);
+    const normalized = Vector2D.normalize(vector);
+    expect(normalized.x).toBeCloseTo(0.6);
+    expect(normalized.y).toBeCloseTo(0.8);
+  });
+
+  it('should correctly truncate a vector', () => {
+    const vector = new Vector2D(3, 4);
+    const truncated = Vector2D.truncate(vector, 4);
+    expect(truncated.length).toBeLessThanOrEqual(4);
+  });
+
+  it('should correctly get the perpendicular vector', () => {
+    const vector = new Vector2D(3, 4);
+    const perpendicular = Vector2D.perp(vector);
+    expect(Vector2D.dot(vector, perpendicular)).toBe(0);
+  });
+
+  it('should correctly reverse the vector', () => {
+    const vector = new Vector2D(3, 4);
+    const reversed = Vector2D.reverse(vector);
+    expect(reversed.x).toBe(-3);
+    expect(reversed.y).toBe(-4);
+  });
+
+  it('should correctly get the absolute vector', () => {
+    const vector = new Vector2D(-3, 4);
+    const absVector = Vector2D.abs(vector);
+    expect(absVector.x).toBe(3);
+    expect(absVector.y).toBe(4);
+  });
+
+  it('should correctly calculate the dot product of two vectors', () => {
+    const vector1 = new Vector2D(2, 3);
+    const vector2 = new Vector2D(4, 5);
+    const dotProduct = Vector2D.dot(vector1, vector2);
+    expect(dotProduct).toBe(23);
+  });
+
+  it('should correctly calculate the distance between two vectors', () => {
+    const vector1 = new Vector2D(1, 1);
+    const vector2 = new Vector2D(4, 5);
+    const distance = Vector2D.distance(vector1, vector2);
+    expect(distance).toBeCloseTo(5);
+  });
+
+  it('should correctly calculate the squared distance between two vectors', () => {
+    const vector1 = new Vector2D(1, 1);
+    const vector2 = new Vector2D(4, 5);
+    const distanceSq = Vector2D.distanceSq(vector1, vector2);
+    expect(distanceSq).toBe(25);
+  });
+
+  it('should correctly determine the sign of the cross product of two vectors', () => {
+    const vector1 = new Vector2D(2, 3);
+    const vector2 = new Vector2D(4, 5);
+    const sign = Vector2D.sign(vector1, vector2);
+    expect(sign).toBe(-1); // Assuming specific vector values, the result may vary
+  });
+
+  it('should correctly calculate the angle between a vector and the negative y-axis', () => {
+    const vector = new Vector2D(3, 4);
+    const angle = Vector2D.angle(vector);
+    expect(angle).toBeCloseTo(2.498091544796509, 3);
+  });
+
+  it('should create a random vector within the specified range', () => {
+    const maxX = 10;
+    const maxY = 10;
+    const randomVector = Vector2D.random(maxX, maxY);
+    expect(randomVector.x).toBeGreaterThanOrEqual(-maxX / 2);
+    expect(randomVector.x).toBeLessThanOrEqual(maxX / 2);
+    expect(randomVector.y).toBeGreaterThanOrEqual(-maxY / 2);
+    expect(randomVector.y).toBeLessThanOrEqual(maxY / 2);
+  });
+
+  it('should zero the vector components', () => {
+    const vector = new Vector2D(3, 4);
+    vector.zero();
+    expect(vector.x).toBe(0);
+    expect(vector.y).toBe(0);
+  });
+});

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -17,7 +17,7 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
-    const priorityQueue = new MaxPriorityQueue<{keyA: number}>((a, b) => b.keyA - a.keyA);
+    const priorityQueue = new MaxPriorityQueue<{keyA: number}>({comparator: (a, b) => b.keyA - a.keyA});
     priorityQueue.refill([{keyA: 5}, {keyA: 3}, {keyA: 1}]);
     priorityQueue.add({keyA: 7});
 
@@ -53,7 +53,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an array', () => {
     const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>(array, (a, b) => b - a);
+    const heap = MaxPriorityQueue.heapify<number>({nodes: array, comparator: (a, b) => b - a});
     heap.refill(array);
 
     expect(heap.poll()).toBe(7);
@@ -64,7 +64,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an object array', () => {
     const nodes = [{keyA: 5}, {keyA: 3}, {keyA: 7}, {keyA: 1}];
-    const maxPQ = MaxPriorityQueue.heapify<{keyA: number}>(nodes, (a, b) => b.keyA - a.keyA);
+    const maxPQ = MaxPriorityQueue.heapify<{keyA: number}>({nodes: nodes, comparator: (a, b) => b.keyA - a.keyA});
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);

package/test/unit/data-structures/priority-queue/priority-queue.test.ts

@@ -3,7 +3,7 @@ import {getRandomInt} from '../../../utils';
 
 describe('PriorityQueue Operation Test', () => {
   it('should PriorityQueue poll, pee, heapify, toArray work well', function () {
-    const minPQ = new PriorityQueue<number>((a, b) => a - b);
+    const minPQ = new PriorityQueue<number>({comparator: (a, b) => a - b});
     minPQ.refill([5, 2, 3, 4, 6, 1]);
     expect(minPQ.toArray()).toEqual([1, 2, 3, 4, 6, 5]);
     minPQ.poll();
@@ -11,13 +11,13 @@ describe('PriorityQueue Operation Test', () => {
     minPQ.poll();
     expect(minPQ.toArray()).toEqual([4, 5, 6]);
     expect(minPQ.peek()).toBe(4);
-    expect(PriorityQueue.heapify([3, 2, 1, 5, 6, 7, 8, 9, 10], (a, b) => a - b).toArray()).toEqual([
-      1, 2, 3, 5, 6, 7, 8, 9, 10
-    ]);
+    expect(PriorityQueue.heapify({nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10], comparator: (a, b) => a - b}).toArray()).toEqual(
+      [1, 2, 3, 5, 6, 7, 8, 9, 10]
+    );
   });
 
   it('should Max PriorityQueue poll, peek, heapify, toArray work well', function () {
-    const maxPriorityQueue = new PriorityQueue<number>((a, b) => b - a);
+    const maxPriorityQueue = new PriorityQueue<number>({comparator: (a, b) => b - a});
     maxPriorityQueue.refill([5, 2, 3, 4, 6, 1]);
     expect(maxPriorityQueue.toArray()).toEqual([6, 5, 3, 4, 2, 1]);
     maxPriorityQueue.poll();
@@ -25,13 +25,13 @@ describe('PriorityQueue Operation Test', () => {
     maxPriorityQueue.poll();
     expect(maxPriorityQueue.toArray()).toEqual([3, 2, 1]);
     expect(maxPriorityQueue.peek()).toBe(3);
-    expect(PriorityQueue.heapify([3, 2, 1, 5, 6, 7, 8, 9, 10], (a, b) => a - b).toArray()).toEqual([
-      1, 2, 3, 5, 6, 7, 8, 9, 10
-    ]);
+    expect(PriorityQueue.heapify({nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10], comparator: (a, b) => a - b}).toArray()).toEqual(
+      [1, 2, 3, 5, 6, 7, 8, 9, 10]
+    );
   });
 
   it('should PriorityQueue clone, sort, getNodes, dfs work well', function () {
-    const minPQ1 = new PriorityQueue<number>((a, b) => a - b);
+    const minPQ1 = new PriorityQueue<number>({comparator: (a, b) => a - b});
     minPQ1.refill([2, 5, 8, 3, 1, 6, 7, 4]);
     const clonedPriorityQueue = minPQ1.clone();
     expect(clonedPriorityQueue.getNodes()).toEqual(minPQ1.getNodes());
@@ -45,7 +45,7 @@ describe('PriorityQueue Operation Test', () => {
 describe('Priority Queue Performance Test', () => {
   it('should numeric heap work well', function () {
     const values = Array.from(new Array(10000), () => getRandomInt(1, 10000000));
-    const minPriorityQueue = new PriorityQueue<number>((a, b) => a - b);
+    const minPriorityQueue = new PriorityQueue<number>({comparator: (a, b) => a - b});
     minPriorityQueue.refill(values);
     const sorted = minPriorityQueue.sort();
     expect(sorted).toEqual(values.sort((a, b) => a - b));

package/test/unit/data-structures/queue/deque.test.ts

@@ -1,6 +1,8 @@
 import {ArrayDeque, Deque, ObjectDeque} from '../../../../src';
 import {bigO} from '../../../utils';
+import {isDebugTest} from '../../../config';
 
+const isDebug = isDebugTest;
 describe('Deque Tests', () => {
   // Test cases for the Deque class (DoublyLinkedList-based)
   describe('Deque (DoublyLinkedList-based)', () => {
@@ -141,7 +143,268 @@ describe('Deque Performance Test', () => {
     for (let i = 0; i < dataSize; i++) {
       queue.pop();
     }
-    console.log(`Queue Deque Test: ${performance.now() - startTime} ms`);
+    isDebug && console.log(`Queue Deque Test: ${performance.now() - startTime} ms`);
     expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
   });
 });
+
+describe('Deque', () => {
+  let deque: Deque<number>;
+
+  beforeEach(() => {
+    deque = new Deque<number>();
+  });
+
+  test('should initialize an empty deque', () => {
+    expect(deque.size).toBe(0);
+    expect(deque.isEmpty()).toBe(true);
+  });
+
+  test('should add elements to the front and back', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+
+    expect(deque.size).toBe(2);
+    expect(deque.peekFirst()).toBe(1);
+    expect(deque.peekLast()).toBe(2);
+  });
+
+  test('should remove elements from the front and back', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+
+    const firstElement = deque.pollFirst();
+    const lastElement = deque.pollLast();
+
+    expect(deque.size).toBe(0);
+    expect(firstElement).toBe(1);
+    expect(lastElement).toBe(2);
+  });
+
+  test('should get elements by index', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    expect(deque.getAt(0)).toBe(1);
+    expect(deque.getAt(1)).toBe(2);
+    expect(deque.getAt(2)).toBe(3);
+  });
+
+  test('should return null for out-of-bounds index', () => {
+    expect(deque.getAt(0)).toBe(undefined);
+    expect(deque.getAt(1)).toBe(undefined);
+    expect(deque.getAt(-1)).toBe(undefined);
+  });
+
+  test('should check if the deque is empty', () => {
+    expect(deque.isEmpty()).toBe(true);
+
+    deque.addLast(1);
+    expect(deque.isEmpty()).toBe(false);
+
+    deque.pollFirst();
+    expect(deque.isEmpty()).toBe(true);
+  });
+});
+
+describe('ArrayDeque', () => {
+  let deque: ArrayDeque<number>;
+
+  beforeEach(() => {
+    deque = new ArrayDeque<number>();
+  });
+
+  test('should initialize an empty deque', () => {
+    expect(deque.size).toBe(0);
+    expect(deque.isEmpty()).toBe(true);
+  });
+
+  test('should add elements to the front and back', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+
+    expect(deque.size).toBe(2);
+    expect(deque.peekFirst()).toBe(1);
+    expect(deque.peekLast()).toBe(2);
+  });
+
+  test('should remove elements from the front and back', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+
+    const firstElement = deque.pollFirst();
+    const lastElement = deque.pollLast();
+
+    expect(deque.size).toBe(0);
+    expect(firstElement).toBe(1);
+    expect(lastElement).toBe(2);
+  });
+
+  test('should get elements by index', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    expect(deque.get(0)).toBe(1);
+    expect(deque.get(1)).toBe(2);
+    expect(deque.get(2)).toBe(3);
+  });
+
+  test('should return null for out-of-bounds index', () => {
+    expect(deque.get(0)).toBe(null);
+    expect(deque.get(1)).toBe(null);
+    expect(deque.get(-1)).toBe(null);
+  });
+
+  test('should check if the deque is empty', () => {
+    expect(deque.isEmpty()).toBe(true);
+
+    deque.addLast(1);
+    expect(deque.isEmpty()).toBe(false);
+
+    deque.pollFirst();
+    expect(deque.isEmpty()).toBe(true);
+  });
+
+  test('should set elements at a specific index', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    deque.set(1, 4);
+
+    expect(deque.get(0)).toBe(1);
+    expect(deque.get(1)).toBe(4);
+    expect(deque.get(2)).toBe(3);
+  });
+
+  test('should insert elements at a specific index', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    deque.insert(1, 4);
+
+    expect(deque.size).toBe(4);
+    expect(deque.get(0)).toBe(1);
+    expect(deque.get(1)).toBe(4);
+    expect(deque.get(2)).toBe(2);
+    expect(deque.get(3)).toBe(3);
+  });
+
+  test('should delete elements at a specific index', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    const deletedElement = deque.delete(1);
+
+    expect(deque.size).toBe(2);
+    expect(deletedElement[0]).toBe(2);
+    expect(deque.get(0)).toBe(1);
+    expect(deque.get(1)).toBe(3);
+  });
+});
+
+describe('ObjectDeque', () => {
+  let deque: ObjectDeque<number>;
+
+  beforeEach(() => {
+    deque = new ObjectDeque<number>();
+  });
+
+  test('should add elements to the front of the deque', () => {
+    deque.addFirst(1);
+    deque.addFirst(2);
+
+    expect(deque.size).toBe(2);
+    expect(deque.peekFirst()).toBe(2);
+    expect(deque.peekLast()).toBe(1);
+  });
+
+  test('should add elements to the end of the deque', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+
+    expect(deque.size).toBe(2);
+    expect(deque.peekFirst()).toBe(1);
+    expect(deque.peekLast()).toBe(2);
+  });
+
+  test('should remove elements from the front of the deque', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+
+    const removedElement = deque.pollFirst();
+
+    expect(deque.size).toBe(1);
+    expect(removedElement).toBe(1);
+    expect(deque.peekFirst()).toBe(2);
+  });
+
+  test('should remove elements from the end of the deque', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+
+    const removedElement = deque.pollFirst();
+
+    expect(deque.size).toBe(1);
+    expect(removedElement).toBe(1);
+    expect(deque.peekLast()).toBe(2);
+  });
+
+  test('should return the element at the front of the deque without removing it', () => {
+    deque.addFirst(1);
+    deque.addFirst(2);
+
+    expect(deque.peekFirst()).toBe(2);
+    expect(deque.size).toBe(2);
+  });
+
+  test('should return the element at the end of the deque without removing it', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+
+    expect(deque.peekLast()).toBe(2);
+    expect(deque.size).toBe(2);
+  });
+
+  test('should return the correct size of the deque', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    expect(deque.size).toBe(3);
+  });
+
+  test('should check if the deque is empty', () => {
+    expect(deque.isEmpty()).toBe(true);
+
+    deque.addFirst(1);
+
+    expect(deque.isEmpty()).toBe(false);
+  });
+
+  test('should set elements at a specific index', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    expect(deque.peekFirst()).toBe(1);
+    expect(deque.get(1)).toBe(2);
+    expect(deque.peekLast()).toBe(3);
+  });
+
+  test('should insert elements at a specific index', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    expect(deque.size).toBe(3);
+    expect(deque.peekFirst()).toBe(1);
+    expect(deque.get(1)).toBe(2);
+    expect(deque.get(2)).toBe(3);
+    expect(deque.peekLast()).toBe(3);
+  });
+});

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

@@ -1,6 +1,8 @@
 import {LinkedListQueue, Queue} from '../../../../src';
 import {bigO, magnitude} from '../../../utils';
+import {isDebugTest} from '../../../config';
 
+const isDebug = isDebugTest;
 describe('Queue Operation Test', () => {
   it('should validate a queue', () => {
     const queue = new Queue<number>();
@@ -209,7 +211,7 @@ describe('Queue Performance Test', () => {
     for (let i = 0; i < dataSize; i++) {
       queue.dequeue();
     }
-    console.log(`Queue Performance Test: ${performance.now() - startTime} ms`);
+    isDebug && console.log(`Queue Performance Test: ${performance.now() - startTime} ms`);
     expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
   });