data-structure-typed 2.4.0 → 2.4.2

package/test/unit/data-structures/linked-list/skip-linked-list.more-branches.coverage.test.ts

@@ -1,31 +0,0 @@
-import { SkipList } from '../../../../src';
-
-describe('SkipList additional branch coverage', () => {
-  it('constructor applies options branches (maxLevel/probability) and first() returns undefined when empty', () => {
-    const s = new SkipList<number, number>([], { maxLevel: 8, probability: 0.25 });
-    expect(s.maxLevel).toBe(8);
-    expect(s.probability).toBe(0.25);
-
-    // covers `firstNode ? ... : undefined` false arm
-    expect(s.first).toBeUndefined();
-  });
-
-  it('delete() covers the break branch when deleted node has smaller level than list level', () => {
-    const s = new SkipList<number, string>();
-
-    // Force deterministic node levels: first node makes list level high, second is low-level.
-    const origRandomLevel = (s as any)._randomLevel;
-    const levels = [4, 1];
-    (s as any)._randomLevel = () => levels.shift() ?? 1;
-    try {
-      s.add(1, 'hi'); // level 4, end -> raises list level
-      s.add(2, 'lo'); // level 1, end, list level stays 4
-
-      expect(s.level).toBeGreaterThan(1);
-      expect(s.delete(2)).toBe(true);
-      expect(s.get(2)).toBeUndefined();
-    } finally {
-      (s as any)._randomLevel = origRandomLevel;
-    }
-  });
-});

package/test/unit/data-structures/linked-list/skip-linked-list.test.ts

@@ -1,13 +0,0 @@
-// import {SkipLinkedList} from '../../../../src'
-
-describe('SkipLinkedList Operation Test', () => {
-  it('should xxx', function () {
-    expect(true).toBeTruthy();
-  });
-});
-
-describe('SkipLinkedList Performance Test', () => {
-  it('should xxx', function () {
-    expect(true).toBeTruthy();
-  });
-});

package/test/unit/data-structures/linked-list/skip-list.test.ts

@@ -1,86 +0,0 @@
-import { SkipList } from '../../../../src';
-
-describe('SkipList', () => {
-  let skipList: SkipList<number, string>;
-
-  beforeEach(() => {
-    skipList = new SkipList<number, string>();
-  });
-
-  it('should insert and retrieve elements correctly', () => {
-    skipList.add(1, 'One');
-    skipList.add(2, 'Two');
-    skipList.add(3, 'Three');
-
-    expect(skipList.get(1)).toBe('One');
-    expect(skipList.get(2)).toBe('Two');
-    expect(skipList.get(3)).toBe('Three');
-  });
-
-  it('should return undefined for non-existent keys', () => {
-    skipList.add(1, 'One');
-    skipList.add(2, 'Two');
-
-    expect(skipList.get(3)).toBeUndefined();
-    expect(skipList.get(0)).toBeUndefined();
-  });
-
-  it('should delete elements correctly', () => {
-    skipList.add(1, 'One');
-    skipList.add(2, 'Two');
-    skipList.add(3, 'Three');
-
-    skipList.delete(2);
-
-    expect(skipList.get(2)).toBeUndefined();
-  });
-
-  it('should handle random data correctly', () => {
-    const randomData: Array<[number, string]> = [
-      [5, 'Five'],
-      [1, 'One'],
-      [3, 'Three'],
-      [2, 'Two'],
-      [4, 'Four']
-    ];
-
-    for (const [key, value] of randomData) {
-      skipList.add(key, value);
-    }
-
-    expect(skipList.get(3)).toBe('Three');
-    expect(skipList.get(5)).toBe('Five');
-    expect(skipList.get(4)).toBe('Four');
-  });
-});
-
-describe('SkipList Test2', () => {
-  let skipList: SkipList<number, string>;
-
-  beforeEach(() => {
-    skipList = new SkipList();
-    skipList.add(1, 'One');
-    skipList.add(2, 'Two');
-    skipList.add(3, 'Three');
-    skipList.add(4, 'Four');
-  });
-
-  it('first() should return the first element', () => {
-    expect(skipList.first).toBe('One');
-  });
-
-  it('last() should return the last element', () => {
-    expect(skipList.last).toBe('Four');
-  });
-
-  it('higher(key) should return the first element greater than the given key', () => {
-    expect(skipList.higher(2)).toBe('Three');
-    expect(skipList.higher(3)).toBe('Four');
-    expect(skipList.higher(4)).toBeUndefined();
-  });
-
-  it('lower(key) should return the last element less than the given key', () => {
-    expect(skipList.lower(2)).toBe('One');
-    expect(skipList.lower(1)).toBe(undefined);
-  });
-});

package/test/unit/data-structures/matrix/matrix.more-branches.coverage.test.ts

@@ -1,81 +0,0 @@
-import { Matrix } from '../../../../src';
-
-describe('Matrix additional branch coverage', () => {
-  it('inverse throws when matrix is singular (pivotRow reaches rows)', () => {
-    const m = new Matrix([[0]], { rows: 1, cols: 1 });
-    expect(() => m.inverse()).toThrow(/singular/i);
-  });
-
-  it('inverse hits division-by-zero guard (pivotElement===0) via get() monkeypatch', () => {
-    const m = new Matrix(
-      [
-        [1, 0],
-        [0, 1]
-      ],
-      { rows: 2, cols: 2 }
-    );
-
-    const origGet = (Matrix as any).prototype.get;
-    try {
-      (Matrix as any).prototype.get = function (row: number, col: number) {
-        // Make pivot search succeed (non-zero) but pivot element read as 0.
-        if (row === col) return 0;
-        return 1;
-      };
-      expect(() => m.inverse()).toThrow(/division by zero/i);
-    } finally {
-      (Matrix as any).prototype.get = origGet;
-    }
-  });
-
-  it('inverse treats undefined elimination factor as 0 (factor===undefined branch)', () => {
-    const m = new Matrix(
-      [
-        [1, 0],
-        [0, 1]
-      ],
-      { rows: 2, cols: 2 }
-    );
-
-    const origGet = (Matrix as any).prototype.get;
-    try {
-      (Matrix as any).prototype.get = function (row: number, col: number) {
-        // Provide real diagonal for pivoting
-        if (row === col) return 1;
-        // For elimination factor reads (j,i) when j!=i, return undefined
-        return undefined;
-      };
-
-      // Should still return something (we only care about branch execution)
-      const inv = m.inverse();
-      expect(inv?.rows).toBe(2);
-      expect(inv?.cols).toBe(2);
-    } finally {
-      (Matrix as any).prototype.get = origGet;
-    }
-  });
-
-  it('_scaleRow and _addScaledRow coerce undefined multiply/add results to 0', () => {
-    const m = new Matrix(
-      [
-        [1, 2],
-        [3, 4]
-      ],
-      {
-        rows: 2,
-        cols: 2,
-        multiplyFn: () => undefined as any,
-        addFn: () => undefined as any
-      }
-    );
-
-    // call protected helpers via any
-    (m as any)._scaleRow(0, 2);
-    expect(m.data[0][0]).toBe(0);
-    expect(m.data[0][1]).toBe(0);
-
-    (m as any)._addScaledRow(1, 0, 3);
-    expect(m.data[1][0]).toBe(0);
-    expect(m.data[1][1]).toBe(0);
-  });
-});

package/test/unit/data-structures/matrix/matrix.pivotElement-nullish.coverage.test.ts

@@ -1,28 +0,0 @@
-import { Matrix } from '../../../../src';
-
-describe('Matrix inverse pivotElement ?? 1 remaining branch coverage', () => {
-  it('inverse() uses pivotElement fallback 1 when get(i,i) is nullish', () => {
-    const origGet = Matrix.prototype.get;
-    try {
-      Matrix.prototype.get = function (row: number, col: number): any {
-        if (row === 0 && col === 0) return undefined;
-        return origGet.call(this, row, col);
-      };
-
-      const m = new Matrix([
-        [1, 0],
-        [0, 1]
-      ]);
-
-      const inv = m.inverse();
-
-      // Restore before asserting so inv.get is not affected.
-      Matrix.prototype.get = origGet;
-
-      expect(inv?.get(0, 0)).toBe(1);
-      expect(inv?.get(1, 1)).toBe(1);
-    } finally {
-      Matrix.prototype.get = origGet;
-    }
-  });
-});

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

@@ -1,377 +0,0 @@
-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 initiate with empty', () => {
-    matrix = new Matrix([], { rows: 2, cols: 2 });
-    expect(matrix.data).toEqual([
-      [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', () => {
-    it('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]
-      ]);
-    });
-
-    it('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([]);
-    });
-
-    it('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]
-      ]);
-    });
-
-    it('should throw error when cols does not equal to rows', () => {
-      const data: number[][] = [
-        [4, 7, 2],
-        [2, 6, 3]
-      ];
-
-      const matrix = new Matrix(data);
-      expect(() => matrix.inverse()).toThrow('Matrix must be square for inversion.');
-    });
-
-    it('should clone', () => {
-      const data: number[][] = [
-        [4, 7, 2],
-        [2, 6, 3]
-      ];
-
-      const matrix = new Matrix(data);
-      const cloned = matrix.clone();
-      expect(cloned instanceof Matrix).toBe(true);
-      expect(cloned.data).toEqual(data);
-    });
-  });
-
-  describe('dot', () => {
-    it('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]
-      ]);
-    });
-
-    it('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.'
-      );
-    });
-  });
-});