data-structure-typed 1.49.3 → 1.49.5

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

@@ -1,54 +1,347 @@
-import { MatrixNTI2D } from '../../../../src';
-
-describe('MatrixNTI2D', () => {
-  it('should initialize a matrix with rows and columns', () => {
-    const numRows = 3;
-    const numCols = 4;
-    const matrix = new MatrixNTI2D({ row: numRows, col: numCols });
-
-    expect(matrix.toArray().length).toBe(numRows);
-    expect(matrix.toArray()[0].length).toBe(numCols);
-  });
-
-  it('should initialize all elements with the provided initial value', () => {
-    const numRows = 3;
-    const numCols = 4;
-    const initialValue = 42;
-    const matrix = new MatrixNTI2D({ row: numRows, col: numCols, initialVal: initialValue });
-
-    const matrixArray = matrix.toArray();
-    for (let i = 0; i < numRows; i++) {
-      for (let j = 0; j < numCols; j++) {
-        expect(matrixArray[i][j]).toBe(initialValue);
-      }
-    }
-  });
-
-  it('should initialize all elements with 0 if no initial value is provided', () => {
-    const numRows = 3;
-    const numCols = 4;
-    const matrix = new MatrixNTI2D({ row: numRows, col: numCols });
-
-    const matrixArray = matrix.toArray();
-    for (let i = 0; i < numRows; i++) {
-      for (let j = 0; j < numCols; j++) {
-        expect(matrixArray[i][j]).toBe(0);
-      }
-    }
-  });
-
-  it('should convert the matrix to a two-dimensional array', () => {
-    const numRows = 2;
-    const numCols = 3;
-    const matrix = new MatrixNTI2D({ row: numRows, col: numCols, initialVal: 1 });
-
-    const matrixArray = matrix.toArray();
-    expect(matrixArray.length).toBe(numRows);
-    for (let i = 0; i < numRows; i++) {
-      expect(matrixArray[i].length).toBe(numCols);
-      for (let j = 0; j < numCols; j++) {
-        expect(matrixArray[i][j]).toBe(1);
-      }
-    }
+import { Matrix } from '../../../../src';
+
+describe('Matrix', () => {
+  let matrix: Matrix;
+
+  beforeEach(() => {
+    // Initialize a 3x3 matrix with zeros
+    matrix = new Matrix([
+      [0, 0, 0],
+      [0, 0, 0],
+      [0, 0, 0]
+    ]);
+  });
+
+  it('should create a matrix with the correct dimensions and initial values', () => {
+    expect(matrix.rows).toBe(3);
+    expect(matrix.cols).toBe(3);
+    expect(matrix.data).toEqual([
+      [0, 0, 0],
+      [0, 0, 0],
+      [0, 0, 0]
+    ]);
+  });
+
+  it('should get a value at a specific position', () => {
+    expect(matrix.get(1, 1)).toBe(0);
+    expect(matrix.get(2, 2)).toBe(0);
+  });
+
+  it('should set a value at a specific position', () => {
+    matrix.set(1, 1, 42);
+    expect(matrix.get(1, 1)).toBe(42);
+  });
+
+  it('should not allow getting or setting values at invalid positions', () => {
+    expect(matrix.get(-1, 0)).toBeUndefined();
+    expect(matrix.get(0, 10)).toBeUndefined();
+
+    const originalValue = matrix.get(1, 1);
+    matrix.set(-1, 1, 42);
+    matrix.set(1, 10, 42);
+    expect(matrix.get(1, 1)).toBe(originalValue);
+  });
+
+  describe('add', () => {
+    it('should add two matrices correctly', () => {
+      const matrixA = new Matrix([
+        [1, 2],
+        [3, 4]
+      ]);
+      const matrixB = new Matrix([
+        [5, 6],
+        [7, 8]
+      ]);
+      const expectedResult = new Matrix([
+        [6, 8],
+        [10, 12]
+      ]);
+
+      const result = matrixA.add(matrixB);
+
+      expect(result?.data).toEqual(expectedResult.data);
+    });
+
+    it('should throw an error for matrices with mismatched dimensions', () => {
+      const matrixA = new Matrix([
+        [1, 2],
+        [3, 4]
+      ]);
+      const matrixB = new Matrix([
+        [5, 6, 7],
+        [8, 9, 10]
+      ]);
+
+      expect(() => matrixA.add(matrixB)).toThrowError('Matrix dimensions must match for addition.');
+    });
+
+    it('should throw an error for matrices with mismatched dimensions', () => {
+      const matrixA = new Matrix([
+        [1, 2],
+        [3, 4]
+      ]);
+      const matrixB = new Matrix([
+        [5, 6, 7],
+        [8, 9, 10]
+      ]);
+
+      expect(() => matrixA.add(matrixB)).toThrowError('Matrix dimensions must match for addition.');
+    });
+  });
+
+  describe('subtract', () => {
+    it('should subtract two matrices with numbers correctly', () => {
+      const matrixA = new Matrix([
+        [5, 6],
+        [7, 8]
+      ]);
+      const matrixB = new Matrix([
+        [1, 2],
+        [3, 4]
+      ]);
+      const expectedResult = new Matrix([
+        [4, 4],
+        [4, 4]
+      ]);
+
+      const result = matrixA.subtract(matrixB);
+
+      expect(result?.data).toEqual(expectedResult.data);
+    });
+
+    it('should subtract two matrices with custom subtract function correctly', () => {
+      const customSubtractFn = (a: number, b: number) => a * 10 - b; // Custom subtraction for arrays
+      const matrixA = new Matrix(
+        [
+          [5, 6],
+          [7, 8]
+        ],
+        { subtractFn: customSubtractFn }
+      );
+      const matrixB = new Matrix(
+        [
+          [1, 2],
+          [3, 4]
+        ],
+        { subtractFn: customSubtractFn }
+      );
+      const expectedResult = new Matrix(
+        [
+          [49, 58],
+          [67, 76]
+        ],
+        { subtractFn: customSubtractFn }
+      );
+
+      const result = matrixA.subtract(matrixB);
+
+      expect(result?.data).toEqual(expectedResult.data);
+    });
+
+    it('should throw an error for matrices with mismatched dimensions', () => {
+      const matrixA = new Matrix([
+        [1, 2],
+        [3, 4]
+      ]);
+      const matrixB = new Matrix([
+        [5, 6, 7],
+        [8, 9, 10]
+      ]);
+
+      expect(() => matrixA.subtract(matrixB)).toThrowError('Matrix dimensions must match for subtraction.');
+    });
+  });
+
+  describe('multiply', () => {
+    it('should multiply two matrices with numbers correctly', () => {
+      const matrixA = new Matrix([
+        [1, 2],
+        [3, 4]
+      ]);
+      const matrixB = new Matrix([
+        [5, 6],
+        [7, 8]
+      ]);
+      const expectedResult = new Matrix([
+        [19, 22],
+        [43, 50]
+      ]);
+
+      const result = matrixA.multiply(matrixB);
+
+      expect(result?.data).toEqual(expectedResult.data);
+    });
+
+    it('should multiply two matrices with custom multiply function correctly', () => {
+      const customMultiplyFn = (a: number, b: number) => a * 10 * b; // Custom multiplication for arrays
+      const matrixA = new Matrix(
+        [
+          [1, 2],
+          [3, 4]
+        ],
+        { multiplyFn: customMultiplyFn }
+      );
+      const matrixB = new Matrix(
+        [
+          [5, 6],
+          [7, 8]
+        ],
+        { multiplyFn: customMultiplyFn }
+      );
+      const result = matrixA.multiply(matrixB);
+
+      expect(result?.data).toEqual([
+        [190, 220],
+        [430, 500]
+      ]);
+    });
+
+    it('should throw an error for matrices with mismatched dimensions', () => {
+      const matrixA = new Matrix([
+        [1, 2, 3],
+        [3, 4, 5]
+      ]);
+      const matrixB = new Matrix([
+        [5, 6, 7],
+        [8, 9, 1]
+      ]);
+
+      expect(() => matrixA.multiply(matrixB)).toThrowError(
+        'Matrix dimensions must be compatible for multiplication (A.cols = B.rows).'
+      );
+    });
+  });
+
+  describe('transpose', () => {
+    test('should transpose a matrix with numeric values correctly', () => {
+      const originalMatrix = new Matrix([
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9]
+      ]);
+
+      const transposedMatrix = originalMatrix.transpose();
+
+      expect(transposedMatrix.rows).toBe(originalMatrix.cols);
+      expect(transposedMatrix.cols).toBe(originalMatrix.rows);
+      expect(transposedMatrix.data).toEqual([
+        [1, 4, 7],
+        [2, 5, 8],
+        [3, 6, 9]
+      ]);
+    });
+
+    test('should transpose an empty matrix correctly', () => {
+      const originalMatrix = new Matrix([]);
+
+      const transposedMatrix = originalMatrix.transpose();
+
+      expect(transposedMatrix.rows).toBe(0);
+      expect(transposedMatrix.cols).toBe(0);
+      expect(transposedMatrix.data).toEqual([]);
+    });
+
+    test('should throw an error when transposing a non-rectangular matrix', () => {
+      const originalMatrix = new Matrix([
+        [1, 2, 3],
+        [4, 5]
+      ]);
+
+      // Using a lambda to call transpose because Jest expects the error to be thrown within a function
+      expect(() => originalMatrix.transpose()).toThrowError('Matrix must be rectangular for transposition.');
+    });
+  });
+
+  describe('inverse', () => {
+    it('should calculate the inverse of a 2x2 matrix', () => {
+      const data: number[][] = [
+        [1, 2],
+        [3, 4]
+      ];
+
+      const matrix = new Matrix(data);
+      const inverseMatrix = matrix.inverse();
+
+      const expectedInverse: number[][] = [
+        [-2, 1],
+        [1.5, -0.5]
+      ];
+
+      expect(inverseMatrix?.data).toEqual(expectedInverse);
+    });
+
+    it('should calculate the inverse of a 3x3 matrix', () => {
+      const data: number[][] = [
+        [4, 7, 2],
+        [2, 6, 3],
+        [1, 2, 5]
+      ];
+
+      const matrix = new Matrix(data);
+      const inverseMatrix = matrix.inverse();
+
+      // const expectedInverse: number[][] = [
+      //   [24 / 43, -31 / 43, 9 / 43],
+      //   [-7 / 43, 18 / 43, -8 / 43],
+      //   [-2 / 43, -1 / 43, 10 / 43],
+      // ];
+
+      expect(inverseMatrix?.data).toEqual([
+        [0.558139534883721, -0.7209302325581396, 0.2093023255813954],
+        [-0.16279069767441862, 0.4186046511627907, -0.18604651162790697],
+        [-0.046511627906976744, -0.023255813953488372, 0.23255813953488372]
+      ]);
+    });
+  });
+
+  describe('dot', () => {
+    test('should calculate the dot product of two matrices', () => {
+      const matrix1 = new Matrix([
+        [1, 2],
+        [3, 4]
+      ]);
+      const matrix2 = new Matrix([
+        [5, 6],
+        [7, 8]
+      ]);
+
+      const resultMatrix = matrix1.dot(matrix2);
+
+      expect(resultMatrix?.data).toEqual([
+        [19, 22],
+        [43, 50]
+      ]);
+    });
+
+    test('should throw an error for incompatible matrices', () => {
+      const matrix1 = new Matrix([
+        [1, 2],
+        [3, 4]
+      ]);
+      const matrix2 = new Matrix([
+        [5, 6, 7],
+        [8, 9, 10],
+        [18, 19, 110]
+      ]);
+      expect(() => matrix1.dot(matrix2)).toThrowError(
+        'Number of columns in the first matrix must be equal to the number of rows in the second matrix for dot product.'
+      );
+    });
+
+    it('should throw an error for incompatible matrices', () => {
+      const matrixA = new Matrix([
+        [1, 2],
+        [3, 4]
+      ]);
+      const matrixB = new Matrix([
+        [5, 6],
+        [7, 8],
+        [9, 10]
+      ]);
+
+      expect(() => matrixA.dot(matrixB)).toThrowError(
+        'Number of columns in the first matrix must be equal to the number of rows in the second matrix for dot product.'
+      );
+    });
   });
 });

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

@@ -63,7 +63,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an object array', () => {
     const elements = [{ keyA: 5 }, { keyA: 3 }, { keyA: 7 }, { keyA: 1 }];
-    debugger
+    debugger;
     const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>(elements, { comparator: (a, b) => b.keyA - a.keyA });
 
     expect(maxPQ.poll()?.keyA).toBe(7);

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

@@ -31,7 +31,6 @@ describe('PriorityQueue Operation Test', () => {
     expect(maxPriorityQueue.peek()).toBe(3);
     expect(
       PriorityQueue.heapify([3, 2, 1, 5, 6, 7, 8, 9, 10], {
-
         comparator: (a, b) => a - b
       }).toArray()
     ).toEqual([1, 3, 2, 5, 6, 7, 8, 9, 10]);

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

@@ -170,7 +170,6 @@ describe('Deque - Utility Operations', () => {
     deque.print();
     expect(consoleSpy).toHaveBeenCalledWith([1, 2]);
   });
-
 });
 describe('Deque - Additional Operations', () => {
   let deque: Deque<number>;
@@ -229,7 +228,6 @@ describe('Deque - Additional Operations', () => {
     expect(iterator.next().value).toBe(2);
     expect(iterator.next().value).toBe(1);
   });
-
 });
 describe('Deque - push Method', () => {
   let deque: Deque<number>;
@@ -264,7 +262,6 @@ describe('Deque - push Method', () => {
   });
 
   test('push should add an element and reallocate when last bucket and lastInBucket are at max', () => {
-
     for (let i = 0; i < 100; i++) {
       deque.push(i);
     }
@@ -303,8 +300,6 @@ describe('Deque - pop Method', () => {
       const lastElement = deque.last;
       expect(deque.pop()).toBe(lastElement);
     }
-
-
   });
 });
 describe('Deque - unshift Method', () => {
@@ -368,6 +363,5 @@ describe('Deque - shift Method', () => {
       const firstElement = deque.first;
       expect(deque.shift()).toBe(firstElement);
     }
-
   });
 });

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

@@ -241,4 +241,4 @@ describe('LinkedListQueue', () => {
     queue.enqueue('B');
     expect(queue.peek()).toBe('A');
   });
-});
+});

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

@@ -66,7 +66,6 @@ describe('Stack', () => {
   });
 });
 
-
 describe('Stack iterative methods', () => {
   let stack: Stack<number>; // Declare a Stack instance
 
@@ -88,7 +87,7 @@ describe('Stack iterative methods', () => {
 
   test('should apply forEach to the stack', () => {
     const result: number[] = [];
-    stack.forEach((element) => {
+    stack.forEach(element => {
       result.push(element);
     });
 
@@ -96,14 +95,14 @@ describe('Stack iterative methods', () => {
   });
 
   test('should filter elements in the stack', () => {
-    const filteredStack = stack.filter((element) => element > 1);
+    const filteredStack = stack.filter(element => element > 1);
 
     expect(filteredStack.size).toBe(2);
     expect([...filteredStack]).toEqual([2, 3]);
   });
 
   test('should map elements in the stack', () => {
-    const mappedStack = stack.map((element) => element * 2);
+    const mappedStack = stack.map(element => element * 2);
 
     expect(mappedStack.size).toBe(3);
     expect([...mappedStack]).toEqual([2, 4, 6]);

package/test/unit/unrestricted-interconversion.test.ts

@@ -17,122 +17,132 @@ import {
   TreeMultimap,
   Trie
 } from '../../src';
-import { isDebugTest } from "../config";
+import { isDebugTest } from '../config';
 
 const isDebug = isDebugTest;
 const orgArr: number[] = [6, 1, 2, 7, 5, 3, 4, 9, 8];
 const orgStrArr: string[] = [
-  "trie",
-  "trial",
-  "trick",
-  "trip",
-  "tree",
-  "trend",
-  "triangle",
-  "track",
-  "trace",
-  "transmit"
+  'trie',
+  'trial',
+  'trick',
+  'trip',
+  'tree',
+  'trend',
+  'triangle',
+  'track',
+  'trace',
+  'transmit'
+];
+const entries: [number, number][] = [
+  [6, 6],
+  [1, 1],
+  [2, 2],
+  [7, 7],
+  [5, 5],
+  [3, 3],
+  [4, 4],
+  [9, 9],
+  [8, 8]
 ];
-const entries: [number, number][] = [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]];
 
 describe('conversions', () => {
   it('Array to Queue', () => {
     const q = new Queue<number>(orgArr);
     isDebug && q.print();
-  })
+  });
 
   it('Array to Deque', () => {
     const dq = new Deque<number>(orgArr);
     isDebug && dq.print();
-  })
+  });
 
   it('Array to SinglyLinkedList', () => {
     const sl = new SinglyLinkedList<number>(orgArr);
     isDebug && sl.print();
-  })
+  });
 
   it('Array to DoublyLinkedList', () => {
     const dl = new DoublyLinkedList<number>(orgArr);
     isDebug && dl.print();
-  })
+  });
 
   it('Array to Stack', () => {
     const stack = new Stack<number>(orgArr);
     isDebug && stack.print();
-  })
+  });
 
   it('Array to MinHeap', () => {
     const minHeap = new MinHeap<number>(orgArr);
     isDebug && minHeap.print();
-  })
+  });
 
   it('Array to MaxHeap', () => {
     const maxHeap = new MaxHeap<number>(orgArr);
     isDebug && maxHeap.print();
-  })
+  });
 
   it('Array to MinPriorityQueue', () => {
     const minPQ = new MinPriorityQueue<number>(orgArr);
     isDebug && minPQ.print();
-  })
+  });
 
   it('Array to MaxPriorityQueue', () => {
     const maxPQ = new MaxPriorityQueue<number>(orgArr);
     isDebug && maxPQ.print();
-  })
+  });
 
   it('Entry Array to BinaryTree', () => {
     const biTree = new BinaryTree<number>(entries);
     isDebug && biTree.print();
-  })
+  });
 
   it('Entry Array to BST', () => {
     const bst = new BST<number>(entries);
-    expect(bst.size).toBe(9)
+    expect(bst.size).toBe(9);
     isDebug && bst.print();
-  })
+  });
 
   it('Entry Array to RedBlackTree', () => {
     const rbTree = new RedBlackTree<number>(entries);
-    expect(rbTree.size).toBe(9)
+    expect(rbTree.size).toBe(9);
     isDebug && rbTree.print();
-  })
+  });
 
   it('Entry Array to AVLTree', () => {
     const avl = new AVLTree<number>(entries);
-    expect(avl.size).toBe(9)
+    expect(avl.size).toBe(9);
     isDebug && avl.print();
-  })
+  });
 
   it('Entry Array to TreeMultimap', () => {
     const treeMulti = new TreeMultimap<number>(entries);
-    expect(treeMulti.size).toBe(9)
+    expect(treeMulti.size).toBe(9);
     isDebug && treeMulti.print();
-  })
+  });
 
   it('HashMap to RedBlackTree', () => {
     const hm = new HashMap(entries);
-    isDebug && hm.print()
+    isDebug && hm.print();
     const rbTree = new RedBlackTree<number>(hm);
-    expect(rbTree.size).toBe(9)
+    expect(rbTree.size).toBe(9);
     isDebug && rbTree.print();
-  })
+  });
 
   it('PriorityQueue to BST', () => {
     const pq = new MinPriorityQueue(orgArr);
     isDebug && pq.print();
     const bst = new BST<number>(pq);
-    expect(bst.size).toBe(9)
+    expect(bst.size).toBe(9);
     isDebug && bst.print();
-  })
+  });
 
   it('Deque to RedBlackTree', () => {
     const dq = new Deque(orgArr);
     isDebug && dq.print();
     const rbTree = new RedBlackTree<number>(dq);
-    expect(rbTree.size).toBe(9)
+    expect(rbTree.size).toBe(9);
     isDebug && rbTree.print();
-  })
+  });
 
   it('Trie to Heap to Deque', () => {
     const trie = new Trie(orgStrArr);
@@ -146,11 +156,7 @@ describe('conversions', () => {
     isDebug && dq.print();
     const entries = dq.map((el, i) => <[number, string]>[i, el]);
     const avl = new AVLTree<number, string>(entries);
-    expect(avl.size).toBe(10)
+    expect(avl.size).toBe(10);
     isDebug && avl.print();
-  })
-
-})
-
-
-
+  });
+});