data-structure-typed 1.37.3 → 1.37.5

package/src/types/data-structures/queue/queue.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/stack/index.ts

@@ -0,0 +1 @@
+export * from './stack';

package/src/types/data-structures/stack/stack.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/tree/index.ts

@@ -0,0 +1 @@
+export * from './tree';

package/src/types/data-structures/tree/tree.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/trie/index.ts

@@ -0,0 +1 @@
+export * from './trie';

package/src/types/data-structures/trie/trie.ts

@@ -0,0 +1 @@
+export {};

package/src/types/helpers.ts

@@ -1,4 +1,7 @@
 export type Comparator<T> = (a: T, b: T) => number;
 
-// export enum DFSOrderPattern {'pre' = 'pre', 'in' = 'in', 'post' = 'post'}
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
+
+export type MapCallback<N> = (node: N) => any;
+
+export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;

package/src/utils/utils.ts

@@ -77,3 +77,10 @@ export const trampolineAsync = (fn: TrlAsyncFn) => {
     {cont}
   );
 };
+
+export const getMSB = (value: number): number => {
+  if (value <= 0) {
+    return 0;
+  }
+  return 1 << (31 - Math.clz32(value));
+};

package/test/config.js

@@ -0,0 +1,4 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.isDebugTest = void 0;
+exports.isDebugTest = false;

package/test/types/index.js

@@ -0,0 +1,29 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            }
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  };
+Object.defineProperty(exports, '__esModule', {value: true});
+__exportStar(require('./utils'), exports);

package/test/types/utils/big-o.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', {value: true});

package/test/types/utils/index.js

@@ -0,0 +1,29 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            }
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  };
+Object.defineProperty(exports, '__esModule', {value: true});
+__exportStar(require('./big-o'), exports);

package/test/unit/data-structures/binary-tree/binary-index-tree.test.ts

@@ -0,0 +1,284 @@
+import {BinaryIndexedTree} from '../../../../src';
+import {isDebugTest} from '../../../config';
+
+const isDebug = isDebugTest;
+
+describe('BinaryIndexedTree simple', () => {
+  let bit: BinaryIndexedTree;
+
+  beforeEach(() => {
+    //Create a new BinaryIndexedTree instance before each test case
+    bit = new BinaryIndexedTree({frequency: 0, max: 10}); // Modify the value of max as needed
+  });
+
+  it('should initialize correctly', () => {
+    expect(bit.freq).toBe(0);
+    expect(bit.max).toBe(10);
+    expect(bit.freqMap).toEqual({0: 0}); // Modify the initialized record value according to the actual situation
+    // More initialization checks can be added
+  });
+
+  it('should read a single value correctly', () => {
+    // Test the function of reading a single value
+    bit.writeSingle(5, 5); //Write test data
+    expect(bit.readSingle(5)).toBe(5); // Read and verify
+  });
+
+  it('should update a value correctly', () => {
+    // Test the ability to update a single value
+    bit.writeSingle(5, 5); //Write test data
+    bit.update(5, 2); // update value
+    expect(bit.readSingle(5)).toBe(7); // Verify the updated value
+  });
+
+  it('should find lower bound correctly', () => {
+    //Test the function of finding the lower bound
+    bit.writeSingle(2, 10);
+    bit.writeSingle(5, 20);
+    bit.writeSingle(8, 30);
+    expect(bit.lowerBound(15)).toBe(5); // Find and verify the lower bound
+  });
+
+  it('should find upper bound correctly', () => {
+    //Test the function of finding the upper bound
+    bit.writeSingle(2, 10);
+    bit.writeSingle(5, 20);
+    bit.writeSingle(8, 30);
+    expect(bit.upperBound(25)).toBe(5); // Find and verify the upper bound
+  });
+});
+
+describe('BinaryIndexedTree', () => {
+  const frequency = 999;
+  const max = 10;
+  let bit: BinaryIndexedTree;
+
+  beforeEach(function () {
+    bit = new BinaryIndexedTree({frequency, max});
+  });
+  it('should validate the index', function () {
+    expect(() => bit.readSingle(-1)).toThrow('Index out of range');
+    expect(() => bit.readSingle(10)).toThrow('Index out of range');
+  });
+
+  it('should read a single frequency correctly', function () {
+    for (let i = 0; i < max; i++) {
+      expect(bit.readSingle(i)).toBe(frequency);
+    }
+  });
+  it('should validate the index', function () {
+    expect(() => bit.update(-1, 100)).toThrow('Index out of range');
+    expect(() => bit.update(10, 100)).toThrow('Index out of range');
+  });
+  it('should frequency and max', function () {
+    const frequency = 200;
+    const max = 1000;
+    const bit = new BinaryIndexedTree({frequency, max});
+
+    expect(bit.freq).toBe(frequency);
+    expect(bit.max).toBe(max);
+  });
+
+  it('should update the frequency with the given delta', function () {
+    for (let i = 0; i < max; i++) {
+      bit.update(i, i * 2);
+    }
+    for (let i = 0; i < max; i++) {
+      expect(bit.readSingle(i)).toBe(i * 2 + frequency);
+    }
+  });
+  it('should validate the index', function () {
+    expect(() => bit.writeSingle(-1, 100)).toThrow('Index out of range');
+    expect(() => bit.writeSingle(10, 100)).toThrow('Index out of range');
+  });
+
+  it('should writeSingle to be correctly invoked', function () {
+    for (let i = 0; i < max; i++) {
+      bit.writeSingle(i, i * 2);
+    }
+    for (let i = 0; i < max; i++) {
+      expect(bit.readSingle(i)).toBe(i * 2);
+    }
+  });
+
+  it('should read the frequency', function () {
+    for (let c = 0; c <= max; c++) {
+      expect(bit.read(c)).toBe(c * frequency);
+    }
+  });
+
+  const values = [-5, 0, 5, 10, 95, 100, 1000];
+  it('should find the upper-bound index', function () {
+    loopUpperBoundTests(bit, values);
+  });
+
+  it('should find the lower-bound index', function () {
+    loopLowerBoundTests(bit, values);
+  });
+});
+
+describe('designated values', function () {
+  const array = [1, 8, 6, 10, 7, 9, 0, 2, 6, 3];
+  const sumArray = (sum => array.map(value => (sum += value)))(0);
+  let bit: BinaryIndexedTree;
+
+  beforeEach(function () {
+    bit = new BinaryIndexedTree({max: array.length});
+    array.forEach((value, i) => bit.writeSingle(i, value));
+  });
+
+  describe('readSingle', function () {
+    it('should read a single frequency correctly', function () {
+      array.forEach((value, i) => {
+        expect(bit.readSingle(i)).toBe(array[i]);
+      });
+    });
+  });
+
+  describe('update', function () {
+    it('should update the frequency with the given delta', function () {
+      array.forEach((value, i) => bit.update(i, value + i));
+      array.forEach((value, i) => {
+        expect(bit.readSingle(i)).toBe(array[i] * 2 + i);
+      });
+    });
+  });
+
+  describe('writeSingle', function () {
+    it('should write a single frequency correctly', function () {
+      array.forEach((value, i) => bit.writeSingle(i, value + i));
+      array.forEach((value, i) => {
+        expect(bit.readSingle(i)).toBe(array[i] + i);
+      });
+    });
+  });
+
+  describe('read', function () {
+    it('should read the cumulative frequency correctly', function () {
+      expect(bit.read(0)).toBe(0);
+      sumArray.forEach((sum, i) => {
+        expect(bit.read(i + 1)).toBe(sum);
+      });
+    });
+  });
+
+  const values = [-5, 0, 15, 25, 43, 53, 100];
+
+  describe('upperBound', function () {
+    it('should find the upper-bound index', function () {
+      loopUpperBoundTests(bit, values);
+    });
+  });
+
+  describe('lowerBound', function () {
+    it('should find the lower-bound index', function () {
+      loopLowerBoundTests(bit, values);
+    });
+  });
+});
+
+describe('descending sequence', function () {
+  const array = [1, 8, -6, 10, 7, 9, 0, -2, 6, 3];
+  let bit: BinaryIndexedTree;
+
+  beforeEach(function () {
+    bit = new BinaryIndexedTree({max: array.length});
+    array.forEach((value, i) => bit.writeSingle(i, value));
+  });
+
+  it('should have a correct negativeCount property', function () {
+    expect(bit.negativeCount).toBe(2);
+    bit.update(2, 6);
+    expect(bit.negativeCount).toBe(1);
+    bit.update(7, 3);
+    expect(bit.negativeCount).toBe(0);
+    bit.update(8, -7);
+    expect(bit.negativeCount).toBe(1);
+  });
+
+  const values = [-5, 0, 15, 25, 43, 53, 100];
+
+  describe('upperBound', function () {
+    it('should validate the non-descending', function () {
+      expect(() => bit.upperBound(20)).toThrow('Must not be descending');
+      bit.update(2, 12);
+      bit.update(7, 4);
+      loopUpperBoundTests(bit, values);
+    });
+  });
+
+  describe('BinaryIndexedTree lowerBound', function () {
+    it('should validate the non-descending', function () {
+      expect(() => bit.lowerBound(20)).toThrow('Sequence is not non-descending');
+      bit.update(2, 12);
+      bit.update(7, 4);
+      loopLowerBoundTests(bit, values);
+    });
+  });
+});
+
+describe('BinaryIndexedTree additional tests', () => {
+  it('should handle read method correctly', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    bit.writeSingle(2, 10);
+    bit.writeSingle(5, 20);
+    bit.writeSingle(8, 30);
+    expect(bit.read(5)).toBe(10); // Ensure read method accumulates correctly
+  });
+
+  it('should handle consecutive operations', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    bit.writeSingle(2, 10);
+    bit.update(2, 5);
+    expect(bit.readSingle(2)).toBe(15);
+    bit.writeSingle(5, 20);
+    expect(bit.readSingle(5)).toBe(20);
+    expect(bit.lowerBound(15)).toBe(2);
+  });
+
+  it('should handle frequent increment updates', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    for (let i = 0; i < 10; i++) {
+      bit.update(2, 5);
+    }
+    expect(bit.readSingle(2)).toBe(50);
+  });
+
+  it('should handle edge cases', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    bit.writeSingle(9, 100);
+    expect(bit.readSingle(9)).toBe(100);
+    expect(bit.lowerBound(200)).toBe(10);
+  });
+});
+function loopUpperBoundTests(bit: BinaryIndexedTree, values: number[]) {
+  for (const value of values) {
+    const index = bit.upperBound(value);
+    if (index > 0) {
+      expect(bit.read(index)).toBeLessThanOrEqual(value);
+    } else {
+      expect(index).toBe(0);
+    }
+    if (index < bit.max) {
+      expect(bit.read(index + 1)).toBeGreaterThan(value);
+    } else {
+      expect(index).toBe(bit.max);
+    }
+  }
+}
+
+function loopLowerBoundTests(bit: BinaryIndexedTree, values: number[]) {
+  for (const value of values) {
+    const index = bit.lowerBound(value);
+    if (index > 0) {
+      expect(bit.read(index)).toBeLessThan(value);
+    } else {
+      expect(index).toBe(0);
+    }
+    if (index < bit.max) {
+      expect(bit.read(index + 1)).toBeGreaterThanOrEqual(value);
+    } else {
+      expect(index).toBe(bit.max);
+    }
+  }
+}

package/test/utils/big-o.js

@@ -0,0 +1,212 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.logBigOMetrics = exports.logBigOMetricsWrap = exports.bigO = exports.magnitude = void 0;
+var config_1 = require('../config');
+
+var isDebug = config_1.isDebugTest;
+var orderReducedBy = 2; // reduction of bigO's order compared to the baseline bigO
+exports.magnitude = {
+  CONSTANT: Math.floor(Number.MAX_SAFE_INTEGER / Math.pow(10, orderReducedBy)),
+  LOG_N: Math.pow(10, 9 - orderReducedBy),
+  LINEAR: Math.pow(10, 6 - orderReducedBy),
+  N_LOG_N: Math.pow(10, 5 - orderReducedBy),
+  SQUARED: Math.pow(10, 4 - orderReducedBy),
+  CUBED: Math.pow(10, 3 - orderReducedBy),
+  FACTORIAL: 20 - orderReducedBy
+};
+exports.bigO = {
+  CONSTANT: exports.magnitude.CONSTANT / 100000,
+  LOG_N: Math.log2(exports.magnitude.LOG_N) / 1000,
+  LINEAR: exports.magnitude.LINEAR / 1000,
+  N_LOG_N: (exports.magnitude.N_LOG_N * Math.log2(exports.magnitude.LOG_N)) / 1000,
+  SQUARED: Math.pow(exports.magnitude.SQUARED, 2) / 1000,
+  CUBED: Math.pow(exports.magnitude.SQUARED, 3) / 1000,
+  FACTORIAL: 10000
+};
+function findPotentialN(input) {
+  var longestArray = [];
+  var mostProperties = {};
+  function recurse(obj) {
+    if (Array.isArray(obj)) {
+      if (obj.length > longestArray.length) {
+        longestArray = obj;
+      }
+    } else if (typeof obj === 'object' && obj !== null) {
+      var keys = Object.keys(obj);
+      if (keys.length > Object.keys(mostProperties).length) {
+        mostProperties = obj;
+      }
+      keys.forEach(function (key) {
+        recurse(obj[key]);
+      });
+    }
+  }
+  if (Array.isArray(input)) {
+    input.forEach(function (item) {
+      recurse(item);
+    });
+  } else {
+    recurse(input);
+  }
+  // return [longestArray, mostProperties] : [any[], { [key: string]: any }];
+  return Math.max(longestArray.length, Object.keys(mostProperties).length);
+}
+function linearRegression(x, y) {
+  var n = x.length;
+  var sumX = x.reduce(function (acc, val) {
+    return acc + val;
+  }, 0);
+  var sumY = y.reduce(function (acc, val) {
+    return acc + val;
+  }, 0);
+  var sumXSquared = x.reduce(function (acc, val) {
+    return acc + Math.pow(val, 2);
+  }, 0);
+  var sumXY = x.reduce(function (acc, val, i) {
+    return acc + val * y[i];
+  }, 0);
+  var slope = (n * sumXY - sumX * sumY) / (n * sumXSquared - Math.pow(sumX, 2));
+  var intercept = (sumY - slope * sumX) / n;
+  var yHat = x.map(function (val) {
+    return slope * val + intercept;
+  });
+  var totalVariation = y
+    .map(function (val, i) {
+      return Math.pow(val - yHat[i], 2);
+    })
+    .reduce(function (acc, val) {
+      return acc + val;
+    }, 0);
+  var explainedVariation = y
+    .map(function (val) {
+      return Math.pow(val - sumY / n, 2);
+    })
+    .reduce(function (acc, val) {
+      return acc + val;
+    }, 0);
+  var rSquared = 1 - totalVariation / explainedVariation;
+  return {slope: slope, intercept: intercept, rSquared: rSquared};
+}
+function estimateBigO(runtimes, dataSizes) {
+  // Make sure the input runtimes and data sizes have the same length
+  if (runtimes.length !== dataSizes.length) {
+    return 'Lengths of input arrays do not match';
+  }
+  // Create an array to store the computational complexity of each data point
+  var complexities = [];
+  // Traverse different possible complexities
+  var complexitiesToCheck = [
+    'O(1)',
+    'O(log n)',
+    'O(n)',
+    'O(n log n)',
+    'O(n^2)' // squared time complexity
+  ];
+  var _loop_1 = function (complexity) {
+    // Calculate data points for fitting
+    var fittedData = dataSizes.map(function (size) {
+      if (complexity === 'O(1)') {
+        return 1; // constant time complexity
+      } else if (complexity === 'O(log n)') {
+        return Math.log(size);
+      } else if (complexity === 'O(n)') {
+        return size;
+      } else if (complexity === 'O(n log n)') {
+        return size * Math.log(size);
+      } else if (complexity === 'O(n^2)') {
+        return Math.pow(size, 2);
+      } else {
+        return Math.pow(size, 10);
+      }
+    });
+    // Fit the data points using linear regression analysis
+    var regressionResult = linearRegression(fittedData, runtimes);
+    // Check the R-squared value of the fit. It is usually considered a valid fit if it is greater than 0.9.
+    if (regressionResult.rSquared >= 0.9) {
+      complexities.push(complexity);
+    }
+  };
+  for (var _i = 0, complexitiesToCheck_1 = complexitiesToCheck; _i < complexitiesToCheck_1.length; _i++) {
+    var complexity = complexitiesToCheck_1[_i];
+    _loop_1(complexity);
+  }
+  // If there is no valid fitting result, return "cannot estimate", otherwise return the estimated time complexity
+  if (complexities.length === 0) {
+    return 'Unable to estimate';
+  } else {
+    return complexities.join(' or ');
+  }
+}
+var methodLogs = new Map();
+function logBigOMetricsWrap(fn, args, fnName) {
+  var startTime = performance.now();
+  var result = fn(args);
+  var endTime = performance.now();
+  var runTime = endTime - startTime;
+  var methodName = ''.concat(fnName);
+  if (!methodLogs.has(methodName)) {
+    methodLogs.set(methodName, []);
+  }
+  var methodLog = methodLogs.get(methodName);
+  var maxDataSize = args.length === 1 && typeof args[0] === 'number' ? args[0] : findPotentialN(args);
+  if (methodLog) {
+    methodLog.push([runTime, maxDataSize]);
+    if (methodLog.length >= 20) {
+      isDebug && console.log('triggered', methodName, methodLog);
+      var bigO_1 = estimateBigO(
+        methodLog.map(function (_a) {
+          var runTime = _a[0];
+          return runTime;
+        }),
+        methodLog.map(function (_a) {
+          var runTime = _a[0];
+          return runTime;
+        })
+      );
+      isDebug && console.log('Estimated Big O: '.concat(bigO_1));
+      methodLogs.delete(methodName);
+    }
+  }
+  return result;
+}
+exports.logBigOMetricsWrap = logBigOMetricsWrap;
+function logBigOMetrics(target, propertyKey, descriptor) {
+  var originalMethod = descriptor.value;
+  descriptor.value = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    var startTime = performance.now();
+    var result = originalMethod.apply(this, args);
+    var endTime = performance.now();
+    var runTime = endTime - startTime;
+    var methodName = ''.concat(target.constructor.name, '.').concat(propertyKey);
+    if (!methodLogs.has(methodName)) {
+      methodLogs.set(methodName, []);
+    }
+    var methodLog = methodLogs.get(methodName);
+    var maxDataSize = args.length === 1 && typeof args[0] === 'number' ? args[0] : findPotentialN(args);
+    if (methodLog) {
+      methodLog.push([runTime, maxDataSize]);
+      if (methodLog.length >= 20) {
+        isDebug && console.log('triggered', methodName, methodLog);
+        var bigO_2 = estimateBigO(
+          methodLog.map(function (_a) {
+            var runTime = _a[0];
+            return runTime;
+          }),
+          methodLog.map(function (_a) {
+            var runTime = _a[0];
+            return runTime;
+          })
+        );
+        isDebug && console.log('Estimated Big O: '.concat(bigO_2));
+        methodLogs.delete(methodName);
+      }
+    }
+    return result;
+  };
+  return descriptor;
+}
+exports.logBigOMetrics = logBigOMetrics;

package/test/utils/index.js

@@ -0,0 +1,30 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            }
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  };
+Object.defineProperty(exports, '__esModule', {value: true});
+__exportStar(require('./number'), exports);
+__exportStar(require('./big-o'), exports);

package/test/utils/number.js

@@ -0,0 +1,14 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.getMSB = exports.getRandomInt = void 0;
+function getRandomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+exports.getRandomInt = getRandomInt;
+var getMSB = function (value) {
+  if (value <= 0) {
+    return 0;
+  }
+  return 1 << (31 - Math.clz32(value));
+};
+exports.getMSB = getMSB;