data-structure-typed 1.33.7 → 1.33.9

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

@@ -1,79 +0,0 @@
-import {Character, NavigatorParams, Turning, Navigator} from '../../../../src';
-
-const exampleMatrix: number[][] = [
-  [0, 0, 0, 0],
-  [0, 1, 1, 0],
-  [0, 0, 0, 0]
-];
-
-// Create a sample redirect object
-const exampleTurning: Turning = {
-  up: 'right',
-  right: 'down',
-  down: 'left',
-  left: 'up'
-};
-
-// Create a sample move callback function
-const exampleOnMove = () => {
-  expect(true).toBeTruthy();
-  // console.log(`Moved to position (${cur[0]}, ${cur[1]})`);
-};
-
-// Create an initial parameter object for the example
-const exampleInit: NavigatorParams<number>['init'] = {
-  cur: [0, 0],
-  charDir: 'right',
-  VISITED: -1
-};
-
-// Create a Navigator Params object
-const exampleNavigatorParams: NavigatorParams<number> = {
-  matrix: exampleMatrix,
-  turning: exampleTurning,
-  onMove: exampleOnMove,
-  init: exampleInit
-};
-
-describe('Character class', () => {
-  it('should create a character with the correct direction', () => {
-    const character = new Character('up', exampleTurning);
-    expect(character.direction).toBe('up');
-  });
-
-  it('should turn the character in the correct direction', () => {
-    const character = new Character('up', exampleTurning);
-    const turnedCharacter = character.turn();
-    expect(turnedCharacter.direction).toBe('right');
-  });
-});
-
-describe('Navigator class', () => {
-  let navigator: Navigator<number>;
-
-  beforeEach(() => {
-    navigator = new Navigator(exampleNavigatorParams);
-  });
-
-  it('should initialize with the correct matrix and current position', () => {
-    expect(navigator['_matrix']).toEqual(exampleMatrix);
-    expect(navigator['_cur']).toEqual(exampleInit.cur);
-  });
-
-  it('should move the character correctly', () => {
-    navigator.move('right');
-    expect(navigator['_cur']).toEqual([0, 1]);
-    expect(navigator['_matrix'][0][1]).toBe(exampleInit.VISITED);
-  });
-
-  it('should turn the character correctly', () => {
-    expect(navigator['_character'].direction).toBe('right');
-  });
-
-  it('should check for valid moves correctly', () => {
-    expect(navigator.check('up')).toBe(false); // Blocked by wall
-    expect(navigator.check('right')).toBe(true); // Open path
-    expect(navigator.check('down')).toBe(true); // Blocked by wall
-    expect(navigator.check('left')).toBe(false); // Open path
-  });
-});

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

@@ -1,106 +0,0 @@
-import {MaxPriorityQueue} from '../../../../src';
-import {bigO, magnitude} from '../../../utils';
-
-describe('MaxPriorityQueue Operation Test', () => {
-  it('should add elements and maintain heap property', () => {
-    const priorityQueue = new MaxPriorityQueue<number>();
-
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-    priorityQueue.add(1);
-
-    expect(priorityQueue.poll()).toBe(7);
-    expect(priorityQueue.poll()).toBe(5);
-    expect(priorityQueue.poll()).toBe(3);
-    expect(priorityQueue.poll()).toBe(1);
-  });
-
-  it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
-    const priorityQueue = new MaxPriorityQueue<{keyA: number}>({
-      nodes: [{keyA: 5}, {keyA: 3}, {keyA: 1}],
-      comparator: (a, b) => b.keyA - a.keyA
-    });
-
-    priorityQueue.add({keyA: 7});
-
-    expect(priorityQueue.poll()?.keyA).toBe(7);
-    expect(priorityQueue.poll()?.keyA).toBe(5);
-    expect(priorityQueue.poll()?.keyA).toBe(3);
-    expect(priorityQueue.poll()?.keyA).toBe(1);
-  });
-
-  it('should return and remove the smallest element', () => {
-    const priorityQueue = new MaxPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-
-    expect(priorityQueue.poll()).toBe(7);
-    expect(priorityQueue.poll()).toBe(5);
-    expect(priorityQueue.size).toBe(1);
-  });
-
-  it('should create a clone of the priority queue', () => {
-    const priorityQueue = new MaxPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-
-    const clone = priorityQueue.clone();
-    expect(clone.poll()).toBe(7);
-    expect(clone.poll()).toBe(5);
-    expect(clone.poll()).toBe(3);
-    expect(clone.isEmpty()).toBe(true);
-  });
-
-  it('should correctly heapify an array', () => {
-    const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>({nodes: array});
-
-    expect(heap.poll()).toBe(7);
-    expect(heap.poll()).toBe(5);
-    expect(heap.poll()).toBe(3);
-    expect(heap.poll()).toBe(1);
-  });
-
-  it('should correctly heapify an object array', () => {
-    const nodes = [{keyA: 5}, {keyA: 3}, {keyA: 7}, {keyA: 1}];
-    const maxPQ = MaxPriorityQueue.heapify<{keyA: number}>({nodes, comparator: (a, b) => b.keyA - a.keyA});
-
-    expect(maxPQ.poll()?.keyA).toBe(7);
-    expect(maxPQ.poll()?.keyA).toBe(5);
-    expect(maxPQ.poll()?.keyA).toBe(3);
-    expect(maxPQ.poll()?.keyA).toBe(1);
-  });
-});
-
-describe('MaxPriorityQueue Performance Test', () => {
-  it('should the poll method adheres to a time complexity of O(log n) and executed correctly under large scale distinct data', () => {
-    const nodes = Array.from(
-      new Set<number>(Array.from(new Array(magnitude.LINEAR), () => Math.floor(Math.random() * magnitude.LINEAR * 100)))
-    );
-    expect(nodes.length).toBeGreaterThan(magnitude.LINEAR / 2);
-    const maxPQ = new MaxPriorityQueue<number>({nodes});
-
-    let prev = Number.MAX_SAFE_INTEGER;
-    const startTime = performance.now();
-    while (maxPQ.size > 0) {
-      const polled = maxPQ.poll();
-      if (polled) {
-        prev = polled;
-      }
-    }
-    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 50);
-    expect(prev).toBeGreaterThan(0);
-  });
-
-  it('should sorted.length to be the same as original data', () => {
-    // const magnitude = 1000;
-    // const maxPriorityQueue = new MaxPriorityQueue<number>({nodes: Array.from(new Array<number>(magnitude), () => Math.floor(Math.random() * magnitude))});
-    // const nodeCount = maxPriorityQueue.getNodes().length;
-    // const sorted = maxPriorityQueue.sort();
-    //
-    // expect(sorted.length).toBe(nodeCount); // TODO Plan to support sorting of duplicate elements.
-  });
-});

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

@@ -1,105 +0,0 @@
-import {MinPriorityQueue, PriorityQueue} from '../../../../src';
-
-describe('MinPriorityQueue Operation Test', () => {
-  it('should check if a node exists in the queue', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-    priorityQueue.add(5);
-
-    expect(priorityQueue.has(5)).toBe(true);
-    expect(priorityQueue.has(3)).toBe(false);
-  });
-
-  it('should return the smallest element without removing it', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-
-    expect(priorityQueue.peek()).toBe(3);
-    expect(priorityQueue.size).toBe(3);
-  });
-
-  it('should return the last element', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-
-    expect(priorityQueue.leaf()).toBe(7);
-  });
-
-  it('should check if the queue is empty', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-
-    expect(priorityQueue.isEmpty()).toBe(true);
-
-    priorityQueue.add(5);
-
-    expect(priorityQueue.isEmpty()).toBe(false);
-  });
-
-  it('should clear the queue', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-
-    priorityQueue.clear();
-
-    expect(priorityQueue.size).toBe(0);
-    expect(priorityQueue.isEmpty()).toBe(true);
-  });
-
-  it('should sort the elements', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-    priorityQueue.add(1);
-
-    const sortedArray = priorityQueue.sort();
-    expect(sortedArray).toEqual([1, 3, 5, 7]);
-  });
-
-  it('should PriorityQueue poll, pee, heapify, toArray work well', function () {
-    const minPQ = new PriorityQueue<number>({nodes: [5, 2, 3, 4, 6, 1], comparator: (a, b) => a - b});
-    expect(minPQ.toArray()).toEqual([1, 2, 3, 4, 6, 5]);
-    minPQ.poll();
-    minPQ.poll();
-    minPQ.poll();
-    expect(minPQ.toArray()).toEqual([4, 5, 6]);
-    expect(minPQ.peek()).toBe(4);
-    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>({nodes: [5, 2, 3, 4, 6, 1], comparator: (a, b) => b - a});
-    expect(maxPriorityQueue.toArray()).toEqual([6, 5, 3, 4, 2, 1]);
-    maxPriorityQueue.poll();
-    maxPriorityQueue.poll();
-    maxPriorityQueue.poll();
-    expect(maxPriorityQueue.toArray()).toEqual([3, 2, 1]);
-    expect(maxPriorityQueue.peek()).toBe(3);
-    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>({nodes: [2, 5, 8, 3, 1, 6, 7, 4], comparator: (a, b) => a - b});
-    const clonedPriorityQueue = minPQ1.clone();
-    expect(clonedPriorityQueue.getNodes()).toEqual(minPQ1.getNodes());
-    expect(clonedPriorityQueue.sort()).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
-    expect(minPQ1.DFS('in')).toEqual([4, 3, 2, 5, 1, 8, 6, 7]);
-    expect(minPQ1.DFS('post')).toEqual([4, 3, 5, 2, 8, 7, 6, 1]);
-    expect(minPQ1.DFS('pre')).toEqual([1, 2, 3, 4, 5, 6, 8, 7]);
-  });
-});

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

@@ -1,27 +0,0 @@
-import {PriorityQueue} from '../../../../src';
-import {getRandomInt} from '../../../utils';
-
-describe('PriorityQueue Operation Test', () => {
-  it('should validate a priority queue', () => {
-    const minPQ = new PriorityQueue<number>({nodes: [1, 5, 7, 9, 3, 6, 2], comparator: (a, b) => a - b});
-
-    expect(minPQ.isValid()).toBe(true);
-    expect(PriorityQueue.isPriorityQueueified({nodes: minPQ.nodes, comparator: (a, b) => a - b})).toBe(true);
-    expect(PriorityQueue.isPriorityQueueified({nodes: minPQ.nodes, comparator: (a, b) => b - a})).toBe(false);
-    expect(
-      PriorityQueue.isPriorityQueueified({
-        nodes: [1, 5, 7, 9, 3, 6, 2],
-        comparator: (a, b) => b - a
-      })
-    ).toBe(false);
-  });
-});
-
-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>({nodes: values, comparator: (a, b) => a - b});
-    const sorted = minPriorityQueue.sort();
-    expect(sorted).toEqual(values.sort((a, b) => a - b));
-  });
-});

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

@@ -1,130 +0,0 @@
-import {Deque, ArrayDeque, ObjectDeque} from '../../../../src';
-
-describe('Deque Tests', () => {
-  // Test cases for the Deque class (DoublyLinkedList-based)
-  describe('Deque (DoublyLinkedList-based)', () => {
-    let deque: Deque<number>;
-
-    beforeEach(() => {
-      deque = new Deque<number>();
-    });
-
-    it('should add elements at the beginning and end', () => {
-      deque.addFirst(1);
-      deque.addLast(2);
-      expect(deque.peekFirst()).toBe(1);
-      expect(deque.peekLast()).toBe(2);
-    });
-
-    it('should remove elements from the beginning and end', () => {
-      deque.addFirst(1);
-      deque.addLast(2);
-      deque.pollFirst();
-      deque.pollLast();
-      expect(deque.isEmpty()).toBe(true);
-    });
-
-    it('should handle edge case when removing from an empty deque', () => {
-      const result = deque.pollFirst();
-      expect(result).toBeUndefined();
-    });
-
-    it('should correctly report its size', () => {
-      deque.addFirst(1);
-      deque.addLast(2);
-      expect(deque.size).toBe(2);
-    });
-
-    it('should handle adding and removing elements alternately', () => {
-      deque.addFirst(1);
-      expect(deque.pollFirst()).toBe(1);
-      deque.addLast(2);
-      expect(deque.pollLast()).toBe(2);
-      expect(deque.isEmpty()).toBe(true);
-    });
-
-    it('should handle adding and removing elements in a cyclic manner', () => {
-      deque.addFirst(1);
-      deque.addLast(2);
-      expect(deque.pollFirst()).toBe(1);
-      deque.addFirst(3);
-      expect(deque.pollLast()).toBe(2);
-      expect(deque.size).toBe(1);
-    });
-    // Add more test cases as needed
-  });
-
-  // Test cases for the ObjectDeque class
-  describe('ObjectDeque', () => {
-    let objectDeque: ObjectDeque<string>;
-
-    beforeEach(() => {
-      objectDeque = new ObjectDeque<string>();
-    });
-
-    it('should add elements at the beginning and end', () => {
-      objectDeque.addFirst('one');
-      objectDeque.addLast('two');
-      expect(objectDeque.peekFirst()).toBe('one');
-      expect(objectDeque.peekLast()).toBe('two');
-    });
-
-    it('should remove elements from the beginning and end', () => {
-      objectDeque.addFirst('one');
-      objectDeque.addLast('two');
-      objectDeque.pollFirst();
-      objectDeque.pollLast();
-      expect(objectDeque.isEmpty()).toBe(true);
-    });
-
-    it('should handle edge case when removing from an empty deque', () => {
-      const result = objectDeque.pollFirst();
-      expect(result).toBeUndefined();
-    });
-
-    it('should correctly report its size', () => {
-      objectDeque.addFirst('one');
-      objectDeque.addLast('two');
-      expect(objectDeque.size).toBe(2);
-    });
-
-    // Add more test cases as needed
-  });
-
-  // Test cases for the ArrayDeque class
-  describe('ArrayDeque', () => {
-    let arrayDeque: ArrayDeque<number>;
-
-    beforeEach(() => {
-      arrayDeque = new ArrayDeque<number>();
-    });
-
-    it('should add elements at the beginning and end', () => {
-      arrayDeque.addFirst(1);
-      arrayDeque.addLast(2);
-      expect(arrayDeque.peekFirst()).toBe(1);
-      expect(arrayDeque.peekLast()).toBe(2);
-    });
-
-    it('should remove elements from the beginning and end', () => {
-      arrayDeque.addFirst(1);
-      arrayDeque.addLast(2);
-      arrayDeque.pollFirst();
-      arrayDeque.pollLast();
-      expect(arrayDeque.isEmpty()).toBe(true);
-    });
-
-    it('should handle edge case when removing from an empty deque', () => {
-      const result = arrayDeque.pollFirst();
-      expect(result).toBeNull();
-    });
-
-    it('should correctly report its size', () => {
-      arrayDeque.addFirst(1);
-      arrayDeque.addLast(2);
-      expect(arrayDeque.size).toBe(2);
-    });
-
-    // Add more test cases as needed
-  });
-});

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

@@ -1,199 +0,0 @@
-import {Queue, LinkedListQueue} from '../../../../src';
-import {bigO, magnitude} from '../../../utils';
-
-describe('Queue Operation Test', () => {
-  it('should validate a queue', () => {
-    const queue = new Queue<number>();
-    for (let i = 0; i < 1000; i++) {
-      queue.enqueue(i);
-    }
-    let last: number | undefined = 0;
-    for (let i = 0; i < 1000; i++) {
-      last = queue.dequeue();
-    }
-    expect(last).toBe(999);
-  });
-});
-
-describe('Queue Performance Test', () => {
-  it('should numeric queue performance well', function () {
-    const queue = new Queue<number>();
-    for (let i = 0; i < magnitude.LINEAR; i++) {
-      queue.enqueue(i);
-    }
-    let last: number | undefined = 0;
-
-    const startTime = performance.now();
-    for (let i = 0; i < magnitude.LINEAR; i++) {
-      last = queue.dequeue();
-    }
-    expect(last).toBe(magnitude.LINEAR - 1);
-    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
-  });
-});
-
-describe('Queue', () => {
-  let queue: Queue<number>;
-
-  beforeEach(() => {
-    queue = new Queue<number>();
-  });
-
-  it('should initialize an empty queue', () => {
-    expect(queue.size).toBe(0);
-  });
-
-  it('should push elements to the end of the queue', () => {
-    queue.push(1);
-    queue.push(2);
-    expect(queue.peek()).toBe(1);
-    expect(queue.size).toBe(2);
-  });
-
-  // it('should shift elements from the front of the queue', () => {
-  //   queue.push(1);
-  //   queue.push(2);
-  //   const shifted = queue.shift();
-  //   expect(shifted).toBe(1);
-  //   expect(queue.peek()).toBe(2);
-  //   expect(queue.size).toBe(1);
-  // });
-  //
-  // it('should peek at the front of the queue', () => {
-  //   queue.push(1);
-  //   queue.push(2);
-  //   expect(queue.peek()).toBe(1);
-  // });
-
-  // Add more test cases for other methods of Queue.
-});
-describe('Queue', () => {
-  let queue: Queue<number>;
-
-  beforeEach(() => {
-    queue = new Queue<number>();
-  });
-
-  it('should initialize an empty queue', () => {
-    expect(queue.size).toBe(0);
-    expect(queue.isEmpty()).toBe(true);
-  });
-
-  it('should push elements to the end of the queue', () => {
-    queue.push(1);
-    queue.push(2);
-    expect(queue.size).toBe(2);
-    expect(queue.peek()).toBe(1);
-    expect(queue.peekLast()).toBe(2);
-  });
-
-  it('should shift elements from the front of the queue', () => {
-    queue.push(1);
-    queue.push(2);
-    const shifted = queue.shift();
-    expect(shifted).toBe(1);
-    expect(queue.size).toBe(1);
-    expect(queue.peek()).toBe(2);
-    expect(queue.peekLast()).toBe(2);
-  });
-
-  it('should handle shifting when queue reaches half size', () => {
-    for (let i = 1; i <= 5; i++) {
-      queue.push(i);
-    }
-    for (let i = 1; i <= 3; i++) {
-      queue.shift();
-    }
-    // Queue size should be 2, but internal array size is still 5.
-    // Test that shifting optimizes the internal array.
-    expect(queue.size).toBe(2);
-    expect(queue.nodes.length).toBe(2);
-    expect(queue.peek()).toBe(4);
-  });
-
-  it('should peek at the front and end of the queue', () => {
-    queue.push(1);
-    queue.push(2);
-    expect(queue.peek()).toBe(1);
-    expect(queue.peekLast()).toBe(2);
-  });
-
-  it('should handle shifting when the queue is empty', () => {
-    const shifted = queue.shift();
-    expect(shifted).toBeUndefined();
-    expect(queue.size).toBe(0);
-    expect(queue.peek()).toBeUndefined();
-  });
-
-  it('should handle peeking when the queue is empty', () => {
-    expect(queue.peek()).toBeUndefined();
-    expect(queue.peekLast()).toBeUndefined();
-  });
-
-  it('should handle clearing the queue', () => {
-    for (let i = 1; i <= 3; i++) {
-      queue.push(i);
-    }
-    queue.clear();
-    expect(queue.size).toBe(0);
-    expect(queue.peek()).toBeUndefined();
-    expect(queue.peekLast()).toBeUndefined();
-  });
-
-  it('should clone the queue', () => {
-    for (let i = 1; i <= 3; i++) {
-      queue.push(i);
-    }
-    const clonedQueue = queue.clone();
-    expect(clonedQueue.size).toBe(3);
-    expect(clonedQueue.peek()).toBe(1);
-    expect(clonedQueue.peekLast()).toBe(3);
-  });
-
-  it('should handle creating a queue from an array', () => {
-    const elements = [1, 2, 3, 4, 5];
-    const newQueue = Queue.fromArray(elements);
-    expect(newQueue.size).toBe(5);
-    expect(newQueue.peek()).toBe(1);
-    expect(newQueue.peekLast()).toBe(5);
-  });
-
-  it('should iterate through the queue', () => {
-    for (let i = 1; i <= 3; i++) {
-      queue.push(i);
-    }
-    const values = Array.from(queue);
-    expect(values).toEqual([1, 2, 3]);
-  });
-});
-describe('LinkedListQueue', () => {
-  let queue: LinkedListQueue<string>;
-
-  beforeEach(() => {
-    queue = new LinkedListQueue<string>();
-  });
-
-  it('should enqueue elements to the end of the queue', () => {
-    queue.enqueue('A');
-    queue.enqueue('B');
-    expect(queue.peek()).toBe('A');
-    expect(queue.length).toBe(2);
-  });
-
-  it('should dequeue elements from the front of the queue', () => {
-    queue.enqueue('A');
-    queue.enqueue('B');
-    const dequeued = queue.dequeue();
-    expect(dequeued).toBe('A');
-    expect(queue.peek()).toBe('B');
-    expect(queue.length).toBe(1);
-  });
-
-  it('should peek at the front of the queue', () => {
-    queue.enqueue('A');
-    queue.enqueue('B');
-    expect(queue.peek()).toBe('A');
-  });
-
-  // Add more test cases for other methods of LinkedListQueue.
-});