data-structure-typed 1.41.6 → 1.41.7

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

@@ -0,0 +1,45 @@
+import {BinaryTree} from '../../../../src';
+import * as Benchmark from 'benchmark';
+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(`${N_LOG_N} add randomly`, () => {
+    biTree.clear();
+    for (let i = 0; i < arr.length; i++) {
+      biTree.add(arr[i]);
+    }
+  })
+  .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(`${N_LOG_N} addMany`, () => {
+    biTree.clear();
+    biTree.addMany(arr);
+  })
+  .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

@@ -0,0 +1,36 @@
+import {BST} from '../../../../src';
+import * as Benchmark from 'benchmark';
+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(`${N_LOG_N} add randomly`, () => {
+    bst.clear();
+    for (let i = 0; i < arr.length; i++) {
+      bst.add(arr[i]);
+    }
+  })
+  .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(`${N_LOG_N} addMany`, () => {
+    bst.clear();
+    bst.addMany(arr);
+  })
+  .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

@@ -0,0 +1,30 @@
+import {FibonacciHeap, Heap} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {N_LOG_N} = magnitude;
+
+suite
+  .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++) {
+      heap.add(i);
+    }
+
+    for (let i = 0; i < N_LOG_N; i++) {
+      heap.pop();
+    }
+  })
+  .add(`${N_LOG_N} fib add & pop`, () => {
+    const fbHeap = new FibonacciHeap<number>();
+    for (let i = 1; i <= N_LOG_N; i++) {
+      fbHeap.push(i);
+    }
+    for (let i = 1; i <= N_LOG_N; i++) {
+      fbHeap.pop();
+    }
+  });
+
+export {suite};

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

@@ -0,0 +1,40 @@
+import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {LINEAR, N_LOG_N} = magnitude;
+
+suite
+  .add(`${LINEAR} unshift`, () => {
+    const list = new DoublyLinkedList<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      list.unshift(i);
+    }
+  })
+  .add(`${LINEAR} unshift & shift`, () => {
+    const list = new DoublyLinkedList<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      list.unshift(i);
+    }
+    for (let i = 0; i < LINEAR; i++) {
+      list.shift();
+    }
+  })
+  .add(`${N_LOG_N} insertBefore`, () => {
+    const doublyList = new DoublyLinkedList<number>();
+    let midNode: DoublyLinkedListNode | null = null;
+    const midIndex = Math.floor(N_LOG_N / 2);
+    for (let i = 0; i < N_LOG_N; i++) {
+      doublyList.push(i);
+      if (i === midIndex) {
+        midNode = doublyList.getNode(i);
+      } else if (i > midIndex && midNode) {
+        doublyList.insertBefore(midNode, i);
+      }
+    }
+  });
+
+export {suite};

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

@@ -0,0 +1,34 @@
+import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {N_LOG_N} = magnitude;
+
+suite
+  .add(`${N_LOG_N} push & pop`, () => {
+    const list = new SinglyLinkedList<number>();
+
+    for (let i = 0; i < N_LOG_N; i++) {
+      list.push(i);
+    }
+
+    for (let i = 0; i < N_LOG_N; i++) {
+      list.pop();
+    }
+  })
+  .add(`${N_LOG_N} insertBefore`, () => {
+    const singlyList = new SinglyLinkedList<number>();
+    let midSinglyNode: SinglyLinkedListNode | null = null;
+    const midIndex = Math.floor(N_LOG_N / 2);
+    for (let i = 0; i < N_LOG_N; i++) {
+      singlyList.push(i);
+      if (i === midIndex) {
+        midSinglyNode = singlyList.getNode(i);
+      } else if (i > midIndex && midSinglyNode) {
+        singlyList.insertBefore(midSinglyNode.value, i);
+      }
+    }
+  });
+
+export {suite};

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

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

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

@@ -0,0 +1,21 @@
+import {Deque} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+export const suite = new Benchmark.Suite();
+const {LINEAR} = magnitude;
+
+suite
+  .add(`${LINEAR} push`, () => {
+    const deque = new Deque<number>();
+    for (let i = 0; i < LINEAR; i++) {
+      deque.push(i);
+    }
+  })
+  .add(`${LINEAR} shift`, () => {
+    const deque = new Deque<number>();
+    for (let i = 0; i < LINEAR; i++) {
+      deque.push(i);
+      deque.shift();
+    }
+  });

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

@@ -0,0 +1,25 @@
+import {Queue} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {LINEAR} = magnitude;
+
+suite
+  .add(`${LINEAR} push`, () => {
+    const queue = new Queue<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      queue.push(i);
+    }
+  })
+  .add(`${LINEAR} push & shift`, () => {
+    const queue = new Queue<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      queue.push(i);
+      queue.shift();
+    }
+  });
+
+export {suite};

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

@@ -0,0 +1,186 @@
+import * as Benchmark from 'benchmark';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as fastGlob from 'fast-glob';
+import {Color, numberFix, render} from '../utils';
+import {PerformanceTest} from './types';
+
+const reportDistPath = 'benchmark';
+const testDir = path.join(__dirname, 'data-structures');
+const testFiles = fastGlob.sync(path.join(testDir, '**', '*.test.ts'));
+
+const report: {[key: string]: any} = {};
+
+let completedCount = 0;
+
+const performanceTests: PerformanceTest[] = [];
+const {GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW} = Color;
+
+testFiles.forEach((file: string) => {
+  const testName = path.basename(file, '.test.ts');
+  const testFunction = require(file);
+  const {suite} = testFunction;
+  if (suite) performanceTests.push({testName, suite, file});
+});
+
+const composeReport = () => {
+  if (!fs.existsSync(reportDistPath)) fs.mkdirSync(reportDistPath, {recursive: true});
+
+  const filePath = path.join(reportDistPath, 'report.json');
+  const htmlFilePath = path.join(reportDistPath, 'report.html');
+  fs.writeFileSync(filePath, JSON.stringify(report, null, 2));
+  let html = `<!DOCTYPE html>
+                        <html lang="en">
+                        <head>
+                          <meta charset="UTF-8">
+                          <title>performance of data-structure-typed</title>
+                          <style>
+                          *{
+                          box-sizing: border-box;
+                          }
+                                #json-to-html {
+                                padding: 0 10px 20px;
+                                }
+                                
+                                .json-to-html-label {
+                                    font-size: 2rem;
+                                    margin: 2rem 0 0 3px;
+                                }
+                               .content table {
+                                  width: 100%;
+                                  table-layout: fixed;
+                                  border-collapse: collapse;
+                                  margin-top: 10px;
+                                  font-size: 16px;
+                                }
+                            
+                                .content table th,
+                                .content table td {
+                                  padding: 8px 12px;
+                                  text-align: left;
+                                  border: 1px solid #ddd;
+                                }
+                            
+                                .content table th {
+                                  background-color: #f2f2f2;
+                                  font-weight: bold;
+                                }
+                            
+                                .content table tr:nth-child(odd) {
+                                  background-color: #ffffff;
+                                }
+                            </style>
+                        </head>
+                        <body>
+                        <div id="json-to-html">`;
+  let htmlTables = '';
+  for (const r in report) {
+    if (report.hasOwnProperty(r)) {
+      htmlTables += render(report[r].testName, report[r].benchmarks, {
+        plainHtml: true,
+        '<>': 'table',
+        html: [
+          {
+            '<>': 'tr',
+            html: [
+              {'<>': 'td', html: '${name}'},
+              {'<>': 'td', html: '${periodMS}'},
+              {'<>': 'td', html: '${mean}'}
+            ]
+          }
+        ]
+      });
+    }
+  }
+  htmlTables += `
+
+`;
+  html += htmlTables;
+  html += `</div>
+                    </body>
+                  </html>`;
+  replaceMarkdownContent(
+    '[//]: # (Start of Replace Section)', // Start tag
+    '[//]: # (End of Replace Section)', // end identifier
+    htmlTables // New content to be inserted
+  );
+  fs.writeFileSync(htmlFilePath, html);
+  console.log(`Performance ${BOLD}${GREEN}report${END} file generated`);
+};
+function replaceMarkdownContent(startMarker: string, endMarker: string, newText: string) {
+  const parentDirectory = path.resolve(__dirname, '../..'); // The path to the parent directory
+  const filePath = path.join(parentDirectory, 'README.md'); // Path to README.md file
+  fs.readFile(filePath, 'utf8', (err, data) => {
+    if (err) {
+      console.error(`Unable to read ${filePath}:`, err);
+      return;
+    }
+
+    // Find the start and end markers in the content
+    const startIndex = data.indexOf(startMarker);
+    const endIndex = data.indexOf(endMarker, startIndex + 1);
+
+    if (startIndex === -1 || endIndex === -1) {
+      console.error('Unable to find start or end marker');
+      return;
+    }
+
+    // Replace the old content with the new text
+    const updatedMarkdown =
+      data.slice(0, startIndex + startMarker.length) + '\n' + newText + data.slice(endIndex);
+
+    // Try writing the modified content back to the file
+    fs.writeFile(filePath, updatedMarkdown, 'utf8', (err) => {
+      if (err) {
+        console.error(`Unable to write to ${filePath}:`, err);
+      } else {
+        console.log(`The content has been successfully replaced in ${filePath}!`);
+      }
+    });
+  });
+}
+
+performanceTests.forEach(item => {
+  const {suite, testName, file} = item;
+  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) => {
+          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} `,
+          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${
+            performanceTests.length
+          }${END}`,
+          `Time: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
+        );
+        if (isDone) {
+          composeReport();
+        }
+      })
+      .run({async: false});
+  }
+});

package/test/performance/types/index.ts

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

package/test/performance/types/reportor.ts

@@ -0,0 +1,3 @@
+import * as Benchmark from 'benchmark';
+
+export type PerformanceTest = {testName: string; suite: Benchmark.Suite; file: string};

package/test/types/index.ts

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

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

@@ -0,0 +1 @@
+export type AnyFunction = (...args: any[]) => any;

package/test/types/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './big-o';
+export * from './json2html';

package/test/types/utils/json2html.ts

@@ -0,0 +1 @@
+export type Json2htmlOptions = {plainHtml?: boolean} & Partial<{[key: string]: any}>;