data-structure-typed 1.49.2 → 1.49.4

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

@@ -16,7 +16,7 @@ import { getRandomIntArray, magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { TEN_THOUSAND, HUNDRED_THOUSAND, LINEAR } = magnitude;
+const { TEN_THOUSAND, HUNDRED_THOUSAND, MILLION } = magnitude;
 const cOrderedMap = new OrderedMap<number, number>();
 const arrHundredThousand = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
 
@@ -96,10 +96,10 @@ if (isCompetitor) {
         hm.getElementByKey(i);
       }
     })
-    .add(`CPT LL ${LINEAR.toLocaleString()} unshift`, () => {
+    .add(`CPT LL ${MILLION.toLocaleString()} unshift`, () => {
       const list = new CLinkedList<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         list.pushFront(i);
       }
     })
@@ -114,33 +114,33 @@ if (isCompetitor) {
         pq.pop();
       }
     })
-    .add(`CPT DQ ${LINEAR.toLocaleString()} push`, () => {
+    .add(`CPT DQ ${MILLION.toLocaleString()} push`, () => {
       const deque = new CDeque<number>();
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         deque.pushBack(i);
       }
     })
-    .add(`CPT Q ${LINEAR.toLocaleString()} push`, () => {
+    .add(`CPT Q ${MILLION.toLocaleString()} push`, () => {
       const queue = new CQueue<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.push(i);
       }
     })
-    .add(`CPT ST ${LINEAR.toLocaleString()} push`, () => {
+    .add(`CPT ST ${MILLION.toLocaleString()} push`, () => {
       const queue = new CStack<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.push(i);
       }
     })
-    .add(`CPT ST ${LINEAR.toLocaleString()} push & pop`, () => {
+    .add(`CPT ST ${MILLION.toLocaleString()} push & pop`, () => {
       const queue = new CStack<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.push(i);
       }
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.pop();
       }
     });

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

@@ -5,61 +5,50 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { LINEAR } = magnitude;
+const { MILLION } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const list = new DoublyLinkedList<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
-    list.push(i);
-  }
+  for (let i = 0; i < MILLION; i++) list.push(i);
 });
 
 
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const list = new CLinkedList<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
-      list.pushBack(i);
-    }
+    for (let i = 0; i < MILLION; i++) list.pushBack(i);
   });
 }
 
-suite.add(`${LINEAR.toLocaleString()} unshift`, () => {
+suite.add(`${MILLION.toLocaleString()} unshift`, () => {
   const list = new DoublyLinkedList<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
-    list.unshift(i);
-  }
+  for (let i = 0; i < MILLION; i++) list.unshift(i);
 });
 
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} unshift`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} unshift`, () => {
     const list = new CLinkedList<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
-      list.pushFront(i);
-    }
+    for (let i = 0; i < MILLION; i++) list.pushFront(i);
   });
 }
 
 suite
-  .add(`${LINEAR.toLocaleString()} unshift & shift`, () => {
+  .add(`${MILLION.toLocaleString()} 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();
-    }
+    for (let i = 0; i < MILLION; i++) list.unshift(i);
+
+    for (let i = 0; i < MILLION; i++) list.shift();
   })
-  .add(`${LINEAR.toLocaleString()} addBefore`, () => {
+  .add(`${MILLION.toLocaleString()} addBefore`, () => {
     const doublyList = new DoublyLinkedList<number>();
     let midNode: DoublyLinkedListNode | undefined;
-    const midIndex = Math.floor(LINEAR / 2);
-    for (let i = 0; i < LINEAR; i++) {
+    const midIndex = Math.floor(MILLION / 2);
+    for (let i = 0; i < MILLION; i++) {
       doublyList.push(i);
       if (i === midIndex) {
         midNode = doublyList.getNode(i);

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

@@ -9,24 +9,16 @@ suite
   .add(`${MILLION.toLocaleString()} push & shift`, () => {
     const list = new SinglyLinkedList<number>();
 
-    for (let i = 0; i < MILLION; i++) {
-      list.push(i);
-    }
+    for (let i = 0; i < MILLION; i++) list.push(i);
 
-    for (let i = 0; i < MILLION; i++) {
-      list.shift();
-    }
+    for (let i = 0; i < MILLION; i++) list.shift();
   })
   .add(`${TEN_THOUSAND.toLocaleString()} push & pop`, () => {
     const list = new SinglyLinkedList<number>();
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
-      list.push(i);
-    }
+    for (let i = 0; i < TEN_THOUSAND; i++) list.push(i);
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
-      list.pop();
-    }
+    for (let i = 0; i < TEN_THOUSAND; i++) list.pop();
   })
   .add(`${TEN_THOUSAND.toLocaleString()} addBefore`, () => {
     const singlyList = new SinglyLinkedList<number>();

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

@@ -5,26 +5,26 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 export const suite = new Benchmark.Suite();
-const { LINEAR, HUNDRED_THOUSAND } = magnitude;
+const { MILLION, HUNDRED_THOUSAND } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const deque = new Deque<number>();
-  for (let i = 0; i < LINEAR; i++) deque.push(i);
+  for (let i = 0; i < MILLION; i++) deque.push(i);
 });
 
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const _deque = new CDeque<number>();
-    for (let i = 0; i < LINEAR; i++) _deque.pushBack(i);
+    for (let i = 0; i < MILLION; i++) _deque.pushBack(i);
   });
 }
 
 
-suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
+suite.add(`${MILLION.toLocaleString()} push & pop`, () => {
   const _deque = new Deque<number>();
 
-  for (let i = 0; i < LINEAR; i++) _deque.push(i);
-  for (let i = 0; i < LINEAR; i++) _deque.pop();
+  for (let i = 0; i < MILLION; i++) _deque.push(i);
+  for (let i = 0; i < MILLION; i++) _deque.pop();
 
 })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {

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

@@ -5,20 +5,20 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { LINEAR, HUNDRED_THOUSAND } = magnitude;
+const { MILLION, HUNDRED_THOUSAND } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const queue = new Queue<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     queue.push(i);
   }
 });
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const queue = new CQueue<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.push(i);
     }
   });

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

@@ -5,42 +5,42 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { LINEAR } = magnitude;
+const { MILLION } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const stack = new Stack<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     stack.push(i);
   }
 });
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const queue = new CStack<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.push(i);
     }
   });
 }
-suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
+suite.add(`${MILLION.toLocaleString()} push & pop`, () => {
   const queue = new Stack<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     queue.push(i);
   }
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     queue.pop();
   }
 });
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push & pop`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push & pop`, () => {
     const queue = new CStack<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.push(i);
     }
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.pop();
     }
   });

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

@@ -639,4 +639,19 @@ describe('BinaryTree iterative methods test', () => {
     const values = binaryTree.values();
     expect([...values]).toEqual(['b', 'a', 'c']);
   });
+
+  test('should iterative method return undefined when the node is null', () => {
+    const tree = new BinaryTree()
+    tree.addMany([-10, -10, -10, 9, 9, 20, null, null, 15, 7, 8, null, 2, null, 6, null, null, 8, 8, 8]);
+    const bfsResult = tree.bfs(undefined, undefined, undefined, true);
+    expect(bfsResult).toEqual([
+      -10, 9,
+      20, undefined,
+      undefined, 15,
+      7, 8,
+      undefined, 2,
+      undefined, 6,
+      undefined, undefined
+    ]);
+  })
 });

package/test/unit/data-structures/graph/abstract-graph.test.ts

@@ -66,7 +66,18 @@ class MyGraph<
     return edge ? undefined : undefined;
   }
 
-  protected _addEdgeOnly(edge: EO): boolean {
+  deleteVertex(vertexOrKey: VertexKey | VO): boolean {
+    let vertexKey: VertexKey;
+    if (this.isVertexKey(vertexOrKey)) {
+      vertexKey = vertexOrKey;
+    } else {
+      vertexKey = vertexOrKey.key;
+    }
+    this._vertexMap.delete(vertexKey);
+    return true;
+  }
+
+  protected _addEdge(edge: EO): boolean {
     return edge ? true : true;
   }
 }

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

@@ -588,7 +588,7 @@ describe('cycles, strongly connected components, bridges, articular points in Di
   const cutVertexes = graph.getCutVertexes();
   const dfnMap = graph.getDFNMap();
   const lowMap = graph.getLowMap();
-  expect(cycles.size).toBe(2);
+  expect(cycles.length).toBe(2);
   expect(scCs.size).toBe(5);
   expect(bridges.length).toBe(4);
   expect(cutVertexes.length).toBe(4);
@@ -635,7 +635,7 @@ describe('DirectedGraph iterative Methods', () => {
     expect(concatenated).toBe(vertexMap.join(''));
   });
 
-  test('Removing an edge of a DirectedGraph should not delete additional edges', () => {
+  test('Removing an edge of a DirectedGraph should delete additional edges', () => {
     const dg = new DirectedGraph();
     dg.addVertex('hello')
     dg.addVertex('hi')
@@ -649,9 +649,22 @@ describe('DirectedGraph iterative Methods', () => {
     dg.deleteEdge('hello', 'hi')
     expect(dg.getEdge('hello', 'hi')).toBe(undefined)
     expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(DirectedEdge)
+    expect(dg.incomingEdgesOf("Hi")).toEqual([])
   });
 
-  test('Removing a vertex from a UndirectedGraph should remove its edges', () => {
+  test('Removing a vertex of a DirectedGraph should delete additional edges', () => {
+    const graph = new DirectedGraph();
+
+    graph.addVertex("Hello");
+    graph.addVertex("Hi");
+
+    graph.addEdge("Hello", "Hi");
+    graph.deleteVertex("Hello");
+
+    expect(graph.incomingEdgesOf("Hi")).toEqual([]);
+  })
+
+  test('Removing a vertex from a DirectedGraph should remove its edges', () => {
     const dg = new DirectedGraph();
     dg.addVertex('hello')
     dg.addVertex('world')
@@ -688,8 +701,53 @@ describe('DirectedGraph getCycles', () => {
     graph.addEdge('D', 'E');
     graph.addEdge('E', 'B');
     const cycles = graph.getCycles();
-    expect(cycles.size).toBe(1);
-    expect(cycles.get(2)).toEqual( [{ "key": "B", "value": undefined }, { "key": "D", "value": undefined }, { "key": "E", "value": undefined }]);
+    expect(cycles.length).toBe(1);
+    expect(cycles[0]).toEqual(["B", "D", "E"]);
   })
+
+  test('should simple cycles graph getCycles return correct result', () => {
+    const graph = new DirectedGraph();
+
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    graph.addEdge('C', 'A');
+    graph.addEdge('A', 'D');
+    graph.addEdge('D', 'C');
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(2)
+    expect(cycles).toEqual([["A", "B", "C"], ["A", "D", "C"]])
+  });
+
+  test('should 3 cycles graph getCycles return correct result', () => {
+    const graph = new DirectedGraph();
+
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.addVertex('E');
+    graph.addVertex('F');
+    graph.addVertex('G');
+
+    graph.addEdge('A', 'B');
+    graph.addEdge('A', 'C');
+    graph.addEdge('B', 'D');
+    graph.addEdge('C', 'D');
+    graph.addEdge('D', 'E');
+    graph.addEdge('E', 'B');
+    graph.addEdge('B', 'F');
+    graph.addEdge('F', 'E');
+    graph.addEdge('C', 'G');
+    graph.addEdge('G', 'A');
+
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(3)
+    expect(cycles).toEqual([["A", "C", "G"], ["B", "D", "E"], ["B", "F", "E"]]);
+  });
 })
 

package/test/unit/data-structures/graph/undirected-graph.test.ts

@@ -190,6 +190,19 @@ describe('UndirectedGraph', () => {
     expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(UndirectedEdge)
   });
 
+
+  test('Removing a vertex of a DirectedGraph should delete additional edges', () => {
+    const graph = new UndirectedGraph();
+
+    graph.addVertex("Hello");
+    graph.addVertex("Hi");
+
+    graph.addEdge("Hello", "Hi");
+    graph.deleteVertex("Hello");
+
+    expect(graph.edgesOf("Hi")).toEqual([]);
+  })
+
   test('Removing a vertex from a UndirectedGraph should remove its edges', () => {
     const dg = new UndirectedGraph();
     dg.addVertex('hello')
@@ -237,7 +250,7 @@ describe('cycles, strongly connected components, bridges, articular points in Un
   const cutVertexes = graph.getCutVertexes();
   const dfnMap = graph.getDFNMap();
   const lowMap = graph.getLowMap();
-  expect(cycles.size).toBe(2);
+  expect(cycles.length).toBe(3);
   expect(scCs.size).toBe(5);
   expect(bridges.length).toBe(4);
   expect(cutVertexes.length).toBe(4);
@@ -277,8 +290,52 @@ describe('UndirectedGraph getCycles', () => {
     graph.addEdge('D', 'E');
     graph.addEdge('E', 'B');
     const cycles = graph.getCycles();
-    expect(cycles.size).toBe(2);
-    expect(cycles.get(1)).toEqual([{ "key": "A", "value": "A" }, { "key": "B", "value": "B" }, { "key": "D", "value": "D" }, { "key": "C", "value": "C" }]);
-    expect(cycles.get(2)).toEqual([{ "key": "B", "value": "B" }, { "key": "D", "value": "D" }, { "key": "E", "value": "E" }]);
+    expect(cycles.length).toBe(3);
+    expect(cycles).toEqual([["A", "B", "D", "C"], ["A", "B", "E", "D", "C"], ["B", "D", "E"]]);
   })
+
+  test('should simple cycles graph getCycles return correct result', () => {
+    const graph = new UndirectedGraph();
+
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    graph.addEdge('C', 'A');
+    graph.addEdge('A', 'D');
+    graph.addEdge('D', 'C');
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(3)
+    expect(cycles).toEqual([["A", "B", "C"], ["A", "B", "C", "D"], ["A", "C", "D"]])
+  });
+
+  test('should 3 cycles graph getCycles return correct result', () => {
+    const graph = new UndirectedGraph();
+
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.addVertex('E');
+    graph.addVertex('F');
+    graph.addVertex('G');
+
+    graph.addEdge('A', 'B');
+    graph.addEdge('A', 'C');
+    graph.addEdge('B', 'D');
+    graph.addEdge('C', 'D');
+    graph.addEdge('D', 'E');
+    graph.addEdge('E', 'B');
+    graph.addEdge('B', 'F');
+    graph.addEdge('F', 'E');
+    graph.addEdge('C', 'G');
+    graph.addEdge('G', 'A');
+
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(10)
+    expect(cycles).toEqual([["A", "B", "D", "C"], ["A", "B", "D", "C", "G"], ["A", "B", "E", "D", "C"], ["A", "B", "E", "D", "C", "G"], ["A", "B", "F", "E", "D", "C"], ["A", "B", "F", "E", "D", "C", "G"], ["A", "C", "G"], ["B", "D", "E"], ["B", "D", "E", "F"], ["B", "E", "F"]]);
+  });
 })

package/test/unit/data-structures/hash/hash-map.test.ts

@@ -554,4 +554,25 @@ describe('LinkedHashMap setMany, keys, values', () => {
   test('values', () => {
     expect([...hm.values()]).toEqual([2, 3, 4, 5, 6])
   });
+
+  test('entries', () => {
+    expect([...hm.entries()]).toEqual([[2, 2], [3, 3], [4, 4], [5, 5], [6, 6]])
+  });
+
+  test('every', () => {
+    expect(hm.every(value => value > 4)).toBe(false)
+  });
+
+  test('some', () => {
+    expect(hm.some(value => value > 6)).toBe(false)
+  });
+
+  test('hasValue', () => {
+    expect(hm.hasValue(3)).toBe(true)
+    expect(hm.hasValue(7)).toBe(false)
+  });
+
+  test('print', () => {
+    hm.print();
+  });
 });

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

@@ -5,7 +5,12 @@ import { logBigOMetricsWrap } from '../../../utils';
 describe('Heap Operation Test', () => {
   it('should numeric heap work well', function () {
     const minNumHeap = new MinHeap<number>();
-    minNumHeap.add(1);minNumHeap.add(6);minNumHeap.add(2);minNumHeap.add(0);minNumHeap.add(5);minNumHeap.add(9);
+    minNumHeap.add(1);
+    minNumHeap.add(6);
+    minNumHeap.add(2);
+    minNumHeap.add(0);
+    minNumHeap.add(5);
+    minNumHeap.add(9);
     expect(minNumHeap.has(1)).toBe(true);
     expect(minNumHeap.has(2)).toBe(true);
     expect(minNumHeap.poll()).toBe(0);

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

@@ -424,4 +424,31 @@ describe('iterable methods', () => {
     expect([...dl.map(element => element * 2)]).toEqual([2, 4, 6]);
     expect(dl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
   });
+
+  test('values', () => {
+    const dl = new DoublyLinkedList<number>()
+    dl.push(1);
+    dl.push(2);
+    dl.push(3);
+    dl.delete(2);
+    dl.unshift(0);
+    dl.shift();
+    dl.pop();
+    dl.unshift(3);
+    expect([...dl.values()]).toEqual([3, 1])
+  })
+
+  test('some', () => {
+    const dl = new DoublyLinkedList<number>()
+    dl.push(1);
+    dl.push(2);
+    dl.push(3);
+    dl.delete(2);
+    dl.unshift(0);
+    dl.shift();
+    dl.pop();
+    dl.unshift(3);
+    expect(dl.some(value => value > 1)).toBe(true)
+    expect(dl.some(value => value > 100)).toBe(false)
+  })
 });

package/test/utils/big-o.ts

@@ -2,16 +2,16 @@ import { AnyFunction } from '../types';
 import { isDebugTest } from '../config';
 
 const isDebug = isDebugTest;
-const orderReducedBy = 1; // reduction of bigO's order compared to the baseline bigO
+// const orderReducedBy = 1; // reduction of bigO's order compared to the baseline bigO
 
 export const magnitude = {
-  CONSTANT: Math.pow(10, 9),
-  LOG_N: Math.pow(10, 8 - orderReducedBy),
-  LINEAR: Math.pow(10, 7 - orderReducedBy),
-  N_LOG_N: Math.pow(10, 4 - orderReducedBy),
-  SQUARED: Math.pow(10, 3 - orderReducedBy),
-  CUBED: Math.pow(10, 2 - orderReducedBy),
-  FACTORIAL: 20 - orderReducedBy,
+  // CONSTANT: Math.pow(10, 9),
+  // LOG_N: Math.pow(10, 8 - orderReducedBy),
+  // LINEAR: Math.pow(10, 7 - orderReducedBy),
+  // N_LOG_N: Math.pow(10, 4 - orderReducedBy),
+  // SQUARED: Math.pow(10, 3 - orderReducedBy),
+  // CUBED: Math.pow(10, 2 - orderReducedBy),
+  // FACTORIAL: 20 - orderReducedBy,
   THOUSAND: 1000,
   TEN_THOUSAND: 10000,
   HUNDRED_THOUSAND: 100000,
@@ -21,12 +21,12 @@ export const magnitude = {
 };
 
 export const bigO = {
-  CONSTANT: magnitude.CONSTANT / 100000,
-  LOG_N: Math.log2(magnitude.LOG_N) / 1000,
-  LINEAR: magnitude.LINEAR / 1000,
-  N_LOG_N: (magnitude.N_LOG_N * Math.log2(magnitude.LOG_N)) / 1000,
-  SQUARED: Math.pow(magnitude.SQUARED, 2) / 1000,
-  CUBED: Math.pow(magnitude.SQUARED, 3) / 1000,
+  // CONSTANT: magnitude.CONSTANT / 100000,
+  // LOG_N: Math.log2(magnitude.LOG_N) / 1000,
+  // LINEAR: magnitude.LINEAR / 1000,
+  // N_LOG_N: (magnitude.N_LOG_N * Math.log2(magnitude.LOG_N)) / 1000,
+  // SQUARED: Math.pow(magnitude.SQUARED, 2) / 1000,
+  // CUBED: Math.pow(magnitude.SQUARED, 3) / 1000,
   FACTORIAL: 10000
 };