data-structure-typed 1.41.4 → 1.41.5

package/test/performance/data-structures/binary-tree/binary-tree.test.ts

@@ -1,25 +1,45 @@
 import {BinaryTree} from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {magnitude, randomInt, randomIntArray} from '../../../utils';
+import {getRandomIntArray, magnitude} from '../../../utils';
 
 const suite = new Benchmark.Suite();
 const biTree = new BinaryTree<number>();
 const {N_LOG_N} = magnitude;
+const arr = getRandomIntArray(N_LOG_N, 0, N_LOG_N, true);
 
 suite
-  .add(`add ${N_LOG_N}`, () => {
-    for (let i = 0; i < N_LOG_N; i++) biTree.add(randomInt(-N_LOG_N, N_LOG_N));
+  .add(`${N_LOG_N} add randomly`, () => {
+    biTree.clear();
+    for (let i = 0; i < arr.length; i++) {
+      biTree.add(arr[i]);
+    }
   })
-  .add(`delete ${N_LOG_N}`, () => {
-    for (let i = 0; i < N_LOG_N; i++) biTree.delete(randomInt(-N_LOG_N, N_LOG_N));
+  .add(`${N_LOG_N} add & delete randomly`, () => {
+    biTree.clear();
+    for (let i = 0; i < arr.length; i++) {
+      biTree.add(arr[i]);
+    }
+    for (let i = 0; i < arr.length; i++) {
+      biTree.delete(arr[i]);
+    }
   })
-  .add(`addMany ${N_LOG_N}`, () => {
+  .add(`${N_LOG_N} addMany`, () => {
     biTree.clear();
-    const arr = randomIntArray(N_LOG_N);
     biTree.addMany(arr);
   })
-  .add(`get ${N_LOG_N}`, () => {
-    for (let i = 0; i < N_LOG_N; i++) biTree.get(randomInt(-N_LOG_N, N_LOG_N));
+  .add(`${N_LOG_N} get`, () => {
+    for (let i = 0; i < arr.length; i++) {
+      biTree.get(arr[i]);
+    }
+  })
+  .add(`${N_LOG_N} dfs`, () => {
+    for (let i = 0; i < N_LOG_N; i++) biTree.dfs();
+  })
+  .add(`${N_LOG_N} bfs`, () => {
+    for (let i = 0; i < N_LOG_N; i++) biTree.bfs();
+  })
+  .add(`${N_LOG_N} morris`, () => {
+    for (let i = 0; i < N_LOG_N; i++) biTree.morris(n => n, 'pre');
   });
 
 export {suite};

package/test/performance/data-structures/binary-tree/bst.test.ts

@@ -1,24 +1,36 @@
 import {BST} from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {magnitude, randomInt, randomIntArray} from '../../../utils';
+import {getRandomIntArray, magnitude} from '../../../utils';
 
 const suite = new Benchmark.Suite();
 const bst = new BST<number>();
 const {N_LOG_N} = magnitude;
+const arr = getRandomIntArray(N_LOG_N, 0, N_LOG_N, true);
 
 suite
-  .add(`add ${N_LOG_N} randomly`, () => {
-    for (let i = 0; i < N_LOG_N; i++) bst.add(randomInt(0, N_LOG_N));
+  .add(`${N_LOG_N} add randomly`, () => {
+    bst.clear();
+    for (let i = 0; i < arr.length; i++) {
+      bst.add(arr[i]);
+    }
   })
-  .add(`delete ${N_LOG_N} randomly`, () => {
-    for (let i = 0; i < N_LOG_N; i++) bst.delete(randomInt(0, N_LOG_N));
+  .add(`${N_LOG_N} add & delete randomly`, () => {
+    bst.clear();
+    for (let i = 0; i < arr.length; i++) {
+      bst.add(arr[i]);
+    }
+    for (let i = 0; i < arr.length; i++) {
+      bst.delete(arr[i]);
+    }
   })
-  .add(`addMany ${N_LOG_N} balanced`, () => {
-    const arr = randomIntArray(N_LOG_N);
+  .add(`${N_LOG_N} addMany`, () => {
+    bst.clear();
     bst.addMany(arr);
   })
-  .add(`get ${N_LOG_N}`, () => {
-    for (let i = 0; i < N_LOG_N; i++) bst.get(randomInt(-N_LOG_N, N_LOG_N));
+  .add(`${N_LOG_N} get`, () => {
+    for (let i = 0; i < arr.length; i++) {
+      bst.get(arr[i]);
+    }
   });
 
 export {suite};

package/test/performance/data-structures/graph/directed-graph.test.ts

@@ -0,0 +1,49 @@
+import {DirectedGraph} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {getRandomIndex, getRandomWords, magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {THOUSAND} = magnitude;
+const graph = new DirectedGraph<number, number>();
+const vertexes = getRandomWords(THOUSAND);
+
+suite
+  .add(`${THOUSAND} addVertex`, () => {
+    for (const v of vertexes) {
+      graph.addVertex(v);
+    }
+  })
+  .add(`${THOUSAND} addEdge`, () => {
+    for (let i = 0; i < THOUSAND; i++) {
+      const v1 = vertexes[getRandomIndex(vertexes)];
+      const v2 = vertexes[getRandomIndex(vertexes)];
+      graph.addEdge(v1, v2);
+    }
+  })
+  .add(`${THOUSAND} getVertex`, () => {
+    for (let i = 0; i < THOUSAND; i++) {
+      graph.getVertex(vertexes[getRandomIndex(vertexes)]);
+    }
+  })
+  .add(`${THOUSAND} getEdge`, () => {
+    for (let i = 0; i < THOUSAND; i++) {
+      graph.getEdge(vertexes[getRandomIndex(vertexes)], vertexes[getRandomIndex(vertexes)]);
+    }
+  })
+  .add(`tarjan`, () => {
+    // for (let i = 0; i < THOUSAND; i++) {
+    graph.tarjan(true);
+    // }
+  })
+  .add(`tarjan all`, () => {
+    // for (let i = 0; i < THOUSAND; i++) {
+    graph.tarjan(true, true, true, true);
+    // }
+  })
+  .add(`topologicalSort`, () => {
+    // for (let i = 0; i < THOUSAND; i++) {
+    graph.topologicalSort('key');
+    // }
+  });
+
+export {suite};

package/test/performance/data-structures/heap/heap.test.ts

@@ -6,7 +6,7 @@ const suite = new Benchmark.Suite();
 const {N_LOG_N} = magnitude;
 
 suite
-  .add(`add & ${N_LOG_N}`, () => {
+  .add(`${N_LOG_N} add & pop`, () => {
     const heap = new Heap<number>({comparator: (a, b) => b - a});
 
     for (let i = 0; i < N_LOG_N; i++) {
@@ -17,7 +17,7 @@ suite
       heap.pop();
     }
   })
-  .add(`fib add & pop ${N_LOG_N}`, () => {
+  .add(`${N_LOG_N} fib add & pop`, () => {
     const fbHeap = new FibonacciHeap<number>();
     for (let i = 1; i <= N_LOG_N; i++) {
       fbHeap.push(i);

package/test/performance/data-structures/linked-list/doubly-linked-list.test.ts

@@ -6,14 +6,14 @@ const suite = new Benchmark.Suite();
 const {LINEAR, N_LOG_N} = magnitude;
 
 suite
-  .add(`unshift ${LINEAR}`, () => {
+  .add(`${LINEAR} unshift`, () => {
     const list = new DoublyLinkedList<number>();
 
     for (let i = 0; i < LINEAR; i++) {
       list.unshift(i);
     }
   })
-  .add(`unshift & shift ${LINEAR}`, () => {
+  .add(`${LINEAR} unshift & shift`, () => {
     const list = new DoublyLinkedList<number>();
 
     for (let i = 0; i < LINEAR; i++) {
@@ -23,7 +23,7 @@ suite
       list.shift();
     }
   })
-  .add(`insertBefore ${N_LOG_N}`, () => {
+  .add(`${N_LOG_N} insertBefore`, () => {
     const doublyList = new DoublyLinkedList<number>();
     let midNode: DoublyLinkedListNode | null = null;
     const midIndex = Math.floor(N_LOG_N / 2);

package/test/performance/data-structures/linked-list/singly-linked-list.test.ts

@@ -6,7 +6,7 @@ const suite = new Benchmark.Suite();
 const {N_LOG_N} = magnitude;
 
 suite
-  .add(`push & pop ${N_LOG_N}`, () => {
+  .add(`${N_LOG_N} push & pop`, () => {
     const list = new SinglyLinkedList<number>();
 
     for (let i = 0; i < N_LOG_N; i++) {
@@ -17,7 +17,7 @@ suite
       list.pop();
     }
   })
-  .add(`insertBefore ${N_LOG_N}`, () => {
+  .add(`${N_LOG_N} insertBefore`, () => {
     const singlyList = new SinglyLinkedList<number>();
     let midSinglyNode: SinglyLinkedListNode | null = null;
     const midIndex = Math.floor(N_LOG_N / 2);

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

@@ -3,11 +3,11 @@ import * as Benchmark from 'benchmark';
 import {magnitude} from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const {LINEAR} = magnitude;
+const {TEN_THOUSAND} = magnitude;
 
-suite.add(`refill & poll ${LINEAR}`, () => {
+suite.add(`${TEN_THOUSAND} refill & poll`, () => {
   const nodes = Array.from(
-    new Set<number>(Array.from(new Array(LINEAR), () => Math.floor(Math.random() * LINEAR * 100)))
+    new Set<number>(Array.from(new Array(TEN_THOUSAND), () => Math.floor(Math.random() * TEN_THOUSAND * 100)))
   );
   const maxPQ = new MaxPriorityQueue<number>();
   maxPQ.refill(nodes);

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

@@ -6,13 +6,13 @@ export const suite = new Benchmark.Suite();
 const {LINEAR} = magnitude;
 
 suite
-  .add(`push ${LINEAR}`, () => {
+  .add(`${LINEAR} push`, () => {
     const deque = new Deque<number>();
     for (let i = 0; i < LINEAR; i++) {
       deque.push(i);
     }
   })
-  .add(`shift ${LINEAR}`, () => {
+  .add(`${LINEAR} shift`, () => {
     const deque = new Deque<number>();
     for (let i = 0; i < LINEAR; i++) {
       deque.push(i);

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

@@ -6,14 +6,14 @@ const suite = new Benchmark.Suite();
 const {LINEAR} = magnitude;
 
 suite
-  .add(`push ${LINEAR}`, () => {
+  .add(`${LINEAR} push`, () => {
     const queue = new Queue<number>();
 
     for (let i = 0; i < LINEAR; i++) {
       queue.push(i);
     }
   })
-  .add(`push & shift ${LINEAR}`, () => {
+  .add(`${LINEAR} push & shift`, () => {
     const queue = new Queue<number>();
 
     for (let i = 0; i < LINEAR; i++) {

package/test/performance/data-structures/trie/trie.test.ts

@@ -0,0 +1,22 @@
+import {Trie} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {getRandomWords, magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {HUNDRED_THOUSAND} = magnitude;
+const trie = new Trie();
+const randomWords = getRandomWords(HUNDRED_THOUSAND, false);
+
+suite
+  .add(`${HUNDRED_THOUSAND} push`, () => {
+    for (let i = 0; i < randomWords.length; i++) {
+      trie.add(randomWords[i]);
+    }
+  })
+  .add(`${HUNDRED_THOUSAND} getWords`, () => {
+    for (let i = 0; i < randomWords.length; i++) {
+      trie.getWords(randomWords[i]);
+    }
+  });
+
+export {suite};

package/test/performance/reportor.ts

@@ -11,14 +11,12 @@ const testFiles = fastGlob.sync(path.join(testDir, '**', '*.test.ts'));
 
 const report: {[key: string]: any} = {};
 
-let testFileCount = 0,
-  completedCount = 0;
+let completedCount = 0;
 
 const performanceTests: PerformanceTest[] = [];
-const {GREEN, BOLD, RED, END, YELLOW, CYAN, BG_YELLOW} = Color;
+const {GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW} = Color;
 
 testFiles.forEach((file: string) => {
-  testFileCount++;
   const testName = path.basename(file, '.test.ts');
   const testFunction = require(file);
   const {suite} = testFunction;
@@ -133,7 +131,7 @@ function writeIntoMarkdown(html: string) {
       if (err) {
         console.error('Unable to write to README.md file：', err);
       } else {
-        console.log('The text has been successfully inserted into the README.md file!');
+        console.log('The tables have been successfully inserted into the README.md file!');
       }
     });
   });
@@ -141,29 +139,40 @@ function writeIntoMarkdown(html: string) {
 
 performanceTests.forEach(item => {
   const {suite, testName, file} = item;
-  console.log(`${BG_YELLOW}Running in${END}: ${CYAN}${file}${END}`);
+  const relativeFilePath = path.relative(__dirname, file);
+  const directory = path.dirname(relativeFilePath);
+  const fileName = path.basename(relativeFilePath);
+  console.log(`${BG_YELLOW}Running in${END}: ${GRAY}${directory}/${END}${CYAN}${fileName}${END}`);
 
   if (suite) {
+    let runTime = 0;
     suite
       .on('complete', function (this: Benchmark.Suite) {
         completedCount++;
         report[testName] = {};
-        report[testName].benchmarks = this.map((benchmark: Benchmark) => ({
-          'test name': benchmark.name,
-          'time taken (ms)': numberFix(benchmark.times.period * 1000, 2),
-          'executions per sec': numberFix(benchmark.hz, 2),
-          'executed times': numberFix(benchmark.count, 0),
-          'sample mean (secs)': numberFix(benchmark.stats.mean, 2),
-          'sample deviation': numberFix(benchmark.stats.deviation, 2)
-        }));
+        report[testName].benchmarks = this.map((benchmark: Benchmark) => {
+          runTime += benchmark.times.elapsed;
+          return {
+            'test name': benchmark.name,
+            'time taken (ms)': numberFix(benchmark.times.period * 1000, 2),
+            'executions per sec': numberFix(benchmark.hz, 2),
+            'executed times': numberFix(benchmark.count, 0),
+            'sample mean (secs)': numberFix(benchmark.stats.mean, 2),
+            'sample deviation': numberFix(benchmark.stats.deviation, 2)
+          };
+        });
+
         report[testName].testName = testName;
         const isDone = completedCount === performanceTests.length;
+        runTime = Number(runTime.toFixed(2));
+        const isTimeWarn = runTime > 120;
         console.log(
-          `Files: ${GREEN}${testFileCount}${END} `,
-          `Suites: ${GREEN}${performanceTests.length}${END} `,
-          `Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : RED}${
+          // `Files: ${GREEN}${testFileCount}${END} `,
+          // `Suites: ${GREEN}${performanceTests.length}${END} `,
+          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${
             performanceTests.length
-          }${END}`
+          }${END}`,
+          `Time: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
         );
         if (isDone) {
           composeReport();

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

@@ -1,5 +1,5 @@
 import {NIL, RBTNColor, RBTreeNode, RedBlackTree} from '../../../../src';
-import {randomInt} from '../../../utils';
+import {getRandomInt} from '../../../utils';
 import {isDebugTest} from '../../../config';
 
 const isDebug = isDebugTest;
@@ -428,8 +428,8 @@ describe('RedBlackTree', () => {
 
   it('should fix the tree after insertion and deletion', () => {
     for (let i = 0; i < 100; i++) {
-      tree.insert(randomInt(-100, 1000));
-      tree.delete(randomInt(-100, 1000));
+      tree.insert(getRandomInt(-100, 1000));
+      tree.delete(getRandomInt(-100, 1000));
     }
   });
 });

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

@@ -235,10 +235,11 @@ describe('FibonacciHeap Stress Test', () => {
     //   10, 100, 1000, 5000, 10000, 20000, 50000, 75000, 100000,
     //   150000, 200000, 250000, 300000, 400000, 500000, 600000, 700000, 800000, 900000, 1000000
     // ].forEach(m => logBigOMetricsWrap<typeof testByMagnitude>(testByMagnitude, [m]));
-    [
-      10, 100, 1000, 5000, 10000, 20000, 50000, 75000, 100000, 150000, 200000, 250000, 300000, 400000, 500000, 600000,
-      700000, 800000, 900000, 1000000
-    ].forEach(m =>
+    // [
+    //   10, 100, 1000, 5000, 10000, 20000, 50000, 75000, 100000, 150000, 200000, 250000, 300000, 400000, 500000, 600000,
+    //   700000, 800000, 900000, 1000000
+    // ]
+    [10, 100, 1000, 5000].forEach(m =>
       logBigOMetricsWrap(
         (c: number) => {
           const result: number[] = [];

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

@@ -1,5 +1,5 @@
 import {PriorityQueue} from '../../../../src';
-import {randomInt} from '../../../utils';
+import {getRandomInt} from '../../../utils';
 
 describe('PriorityQueue Operation Test', () => {
   it('should PriorityQueue poll, pee, heapify, toArray work well', function () {
@@ -44,7 +44,7 @@ describe('PriorityQueue Operation Test', () => {
 
 describe('Priority Queue Performance Test', () => {
   it('should numeric heap work well', function () {
-    const values = Array.from(new Array(10000), () => randomInt(1, 10000000));
+    const values = Array.from(new Array(10000), () => getRandomInt(1, 10000000));
     const minPriorityQueue = new PriorityQueue<number>({comparator: (a, b) => a - b});
     minPriorityQueue.refill(values);
     const sorted = minPriorityQueue.sort();