atomic-fns 0.3.0 → 0.3.2

package/tests/SortedTree.spec.ts

@@ -0,0 +1,164 @@
+import assert from 'assert'
+import { SortedTree } from '../core/collections/SortedTree.js'
+
+describe('SortedTree', () => {
+  it('empty', () => {
+    let tree = new SortedTree()
+    assert(tree.empty())
+    assert(tree.size === 0)
+  })
+
+  it('initialized', () => {
+    let entries: Array<[number, number]> = [
+      [5, 5],
+      [4, 4],
+      [3, 3],
+      [1, 1],
+      [2, 2]
+    ]
+    let tree = new SortedTree(entries)
+    assert(!tree.empty())
+    assert(tree.size === 5)
+    entries.sort((x, y) => x[0] - y[0])
+    assert.deepEqual(
+      [...tree.keys()],
+      entries.map((x) => x[0])
+    )
+  })
+
+  it('add', () => {
+    let tree = new SortedTree()
+    for (let i = 10; i > 0; i--) {
+      tree.add(i)
+      assert(tree.get(i) === null)
+      assert(tree.contains(i))
+    }
+    assert(tree.size === 10)
+  })
+
+  it('get', () => {
+    let tree = new SortedTree()
+    for (let i = 10; i > 0; i--) {
+      tree.set(i, i)
+      assert(tree.get(i) === i)
+      assert(tree.contains(i))
+    }
+    assert(tree.size === 10)
+  })
+
+  it('set', () => {
+    let tree = new SortedTree()
+    for (let i = 10; i > 0; i--) {
+      tree.set(i, i)
+      assert(tree.get(i) === i)
+      assert(tree.contains(i))
+    }
+    // update a key
+    tree.set(1, 42)
+    assert(tree.get(1) === 42)
+    // adds if not exists
+    tree.set(0, 42)
+    assert(tree.size === 11)
+  })
+
+  it('has', () => {
+    let tree = new SortedTree()
+    for (let i = 100; i > 0; i--) {
+      tree.add(i)
+      assert(tree.has(i))
+    }
+    assert(tree.size === 100)
+  })
+
+  it('min', () => {
+    let tree = new SortedTree()
+    for (let i = 10; i > 0; i--) {
+      tree.add(i)
+    }
+    assert(tree.min() === 1)
+  })
+
+  it('max', () => {
+    let tree = new SortedTree()
+    for (let i = 10; i > 0; i--) {
+      tree.add(i)
+    }
+    assert(tree.max() === 10)
+  })
+
+  it('delete', () => {
+    let tree = new SortedTree()
+    tree.add(42)
+    assert(tree.contains(42))
+    assert(tree.delete(42) === true)
+    assert(!tree.contains(42))
+    assert(tree.delete(42) === false)
+  })
+
+  it('clear', () => {
+    let tree = new SortedTree()
+    for (let i = 1; i <= 5; i++) {
+      tree.add(i)
+      assert(tree.contains(i))
+    }
+    tree.clear()
+    assert(tree.empty())
+    assert(tree.size === 0)
+    for (let i = 1; i <= 5; i++) {
+      assert(!tree.contains(i))
+    }
+  })
+
+  it('freeze', () => {
+    let tree = new SortedTree()
+    for (let i = 10; i > 0; i--) {
+      tree.set(i, i)
+    }
+    tree.freeze()
+    assert.throws(tree.clear)
+    assert.throws(() => tree.add(11))
+  })
+
+  it('reversed', () => {
+    let tree = new SortedTree()
+    let entries: any[] = []
+    for (let i = 100; i > 0; i--) {
+      tree.set(i, i)
+      entries.push([i, i])
+    }
+    assert.deepEqual([...tree.reversed()], entries)
+  })
+
+  it('keys', () => {
+    let tree = new SortedTree()
+    for (let i = 1; i <= 5; i++) {
+      tree.set(i, i * 2)
+    }
+    assert.deepEqual([...tree.keys()], [1, 2, 3, 4, 5])
+  })
+
+  it('values', () => {
+    let tree = new SortedTree()
+    for (let i = 1; i <= 5; i++) {
+      tree.set(i, i * 2)
+    }
+    assert.deepEqual([...tree.values()], [2, 4, 6, 8, 10])
+  })
+
+  it('entries', () => {
+    let tree = new SortedTree()
+    for (let i = 1; i <= 5; i++) {
+      tree.set(i, i * 2)
+    }
+    assert.deepEqual(
+      [...tree.entries()],
+      [
+        [1, 2],
+        [2, 4],
+        [3, 6],
+        [4, 8],
+        [5, 10]
+      ]
+    )
+  })
+})

package/tests/SplayTree.spec.ts

@@ -0,0 +1,121 @@
+import assert from 'assert'
+import { SplayTree } from '../core/collections/SplayTree.js'
+
+describe('SplayTree', () => {
+  it('empty', () => {
+    let tree = new SplayTree()
+    assert(tree.empty())
+    assert(tree.size === 0)
+    for (const value of tree.values()) {
+      assert(!value)
+    }
+  })
+
+  it('set', () => {
+    let tree = new SplayTree()
+    for (let i = 10; i > 0; i--) {
+      tree.set(i, i)
+      assert(tree.contains(i))
+    }
+    assert(tree.size === 10)
+  })
+
+  it('get', () => {
+    let tree = new SplayTree()
+    for (let i = 100; i > 0; i--) {
+      tree.set(i, i)
+      assert(tree.get(i) === i)
+    }
+    assert(tree.size === 100)
+  })
+
+  it('splay', () => {
+    let tree = new SplayTree()
+    for (let i = 100; i > 0; i--) {
+      tree.add(i)
+      assert(tree.contains(i))
+    }
+    tree.splay(42)
+    assert(tree.top() === 42)
+  })
+
+  it('lowerBound', () => {
+    let tree = new SplayTree()
+    for (let i = 20; i > 0; i -= 2) {
+      tree.set(i, i)
+    }
+    assert(tree.lowerBound(12) === 10)
+  })
+
+  it('min', () => {
+    let tree = new SplayTree()
+    for (let i = 10; i > 0; i--) {
+      tree.set(i, i)
+    }
+    assert(tree.min() === 1)
+  })
+
+  it('max', () => {
+    let tree = new SplayTree()
+    for (let i = 10; i > 0; i--) {
+      tree.set(i, i)
+    }
+    assert(tree.max() === 10)
+  })
+
+  it('remove', () => {
+    let tree = new SplayTree()
+    tree.set(42, 42)
+    assert(tree.contains(42))
+    assert(tree.remove(42) === 42)
+    assert(!tree.contains(42))
+    assert(tree.remove(42) === undefined)
+  })
+
+  it('clear', () => {
+    let tree = new SplayTree()
+    for (let i = 1; i <= 5; i++) {
+      tree.add(i)
+      assert(tree.contains(i))
+    }
+    tree.clear()
+    assert(tree.empty())
+    assert(tree.size === 0)
+    for (let i = 1; i <= 5; i++) {
+      assert(!tree.contains(i))
+    }
+  })
+
+  it('keys', () => {
+    let tree = new SplayTree()
+    for (let i = 1; i <= 5; i++) {
+      tree.set(i, i)
+    }
+    assert.deepEqual([...tree.keys()], [1, 2, 3, 4, 5])
+  })
+
+  it('values', () => {
+    let tree = new SplayTree()
+    for (let i = 1; i <= 5; i++) {
+      tree.set(i, i * 2)
+    }
+    assert.deepEqual([...tree.values()], [2, 4, 6, 8, 10])
+  })
+
+  it('entries', () => {
+    let tree = new SplayTree()
+    for (let i = 1; i <= 5; i++) {
+      tree.set(i, i * 2)
+    }
+    assert.deepEqual(
+      [...tree.entries()],
+      [
+        [1, 2],
+        [2, 4],
+        [3, 6],
+        [4, 8],
+        [5, 10]
+      ]
+    )
+  })
+})

package/tests/collections.spec.ts

@@ -18,7 +18,7 @@ import {
   sortedUniq,
   union,
   uniq
-} from '../src/collections/index.js'
+} from '../core/collections/index.js'
 
 describe('collections', () => {
   it('compact', () => {

package/tests/deque.spec.ts

@@ -0,0 +1,107 @@
+import assert from 'assert'
+import { Deque } from '../core/collections/deque.js'
+
+describe('deque', () => {
+  const print = (x) => console.log(x.toArray())
+
+  it('empty', () => {
+    let deque = new Deque()
+    assert(deque.size === 0)
+  })
+
+  it('iterable', () => {
+    let values = [1, 2, 3, 4]
+    let deque = new Deque(values)
+    let elements = [] as any[]
+    for (const value of deque.values()) {
+      elements.push(value)
+    }
+    assert.deepEqual(values, elements)
+  })
+
+  it('append', () => {
+    let values = [1, 2, 3, 4]
+    let deque = new Deque(values)
+    assert(deque.size === values.length)
+    assert.deepEqual(deque.toArray(), values)
+    deque.append(5)
+    assert(deque.size === 5)
+    assert.deepEqual(deque.toArray(), [1, 2, 3, 4, 5])
+  })
+
+  it('appendleft', () => {
+    let values = [1, 2, 3, 4]
+    let deque = new Deque(values)
+    deque.appendleft(0)
+    deque.appendleft(1)
+    deque.appendleft(1)
+    deque.appendleft(0)
+    assert.deepEqual(deque.toArray(), [0, 1, 1, 0, 1, 2, 3, 4])
+    assert(deque.size === 8)
+  })
+
+  it('pop', () => {
+    let values = [1, 2, 3, 4]
+    let deque = new Deque(values)
+    assert(deque.pop() === 4)
+    assert(deque.pop() === 3)
+    assert(deque.pop() === 2)
+    assert(deque.pop() === 1)
+    assert(deque.size === 0)
+    assert.deepEqual(deque.toArray(), [])
+    // assert.throws(() => deque.pop())
+  })
+
+  it('popleft', () => {
+    let values = [1, 2, 3, 4]
+    let deque = new Deque(values)
+    assert(deque.popleft() === 1)
+    assert(deque.popleft() === 2)
+    assert(deque.popleft() === 3)
+    assert(deque.popleft() === 4)
+    assert(deque.size === 0)
+    assert.deepEqual(deque.toArray(), [])
+    // assert.throws(() => deque.popleft())
+  })
+
+  it('contains', () => {
+    let values = [1, 2, 3, 4]
+    let deque = new Deque(values)
+    for (const val of values) {
+      assert(deque.contains(val))
+    }
+  })
+
+  it('get', () => {
+    let values = [1, 2, 3, 4]
+    let deque = new Deque(values)
+    for (let i = 0; i < values.length; i++) {
+      assert(deque.get(i) === values[i])
+    }
+    assert(deque.get(-1) === 4)
+    assert(deque.get(-2) === 3)
+  })
+
+  it('clear', () => {
+    let values = [1, 2, 3, 4]
+    let deque = new Deque(values)
+    deque.clear()
+    assert(deque.size === 0)
+    assert.deepEqual(deque.toArray(), [])
+  })
+
+  it('reversed', () => {
+    let values = [4, 3, 2, 0, 1]
+    let deque = new Deque(values)
+    values.reverse()
+    let arr = deque.reversed()
+    assert.deepEqual(arr, values)
+  })
+
+  it('toArray', () => {
+    let values = [1, 2, 3, 4]
+    let deque = new Deque(values)
+    assert(deque.size === values.length)
+    assert.deepEqual(deque.toArray(), values)
+  })
+})

package/tests/globals.spec.ts

@@ -35,8 +35,8 @@ import {
   uniqueId,
   values,
   _
-} from '../src/globals/index.js'
-import { enumerate } from '../src/itertools/index.js'
+} from '../core/globals/index.js'
+import { enumerate } from '../core/itertools/index.js'
 
 describe('globals', () => {
   it('CustomError', () => {

package/tests/itertools.spec.ts

@@ -25,8 +25,8 @@ import {
   takeWhile,
   times,
   zip
-} from '../src/itertools/index.js'
-import { max } from '../src/math/index.js'
+} from '../core/itertools/index.js'
+import { max } from '../core/math/index.js'
 
 const Falsy = (x) => !x
 

package/tests/math.spec.ts

@@ -1,5 +1,5 @@
 import assert from 'assert'
-import { max, min, round, sum } from '../src/math/index.js'
+import { max, min, round, sum } from '../core/math/index.js'
 
 describe('math', () => {
   it('min', () => {

package/tests/operators.spec.ts

@@ -1,5 +1,5 @@
 import assert from 'assert'
-import { bool, id, isinstance, not, comp, shallowEqual } from '../src/operators/index.js'
+import { bool, id, isinstance, not, compare, shallowEqual } from '../core/operators/index.js'
 
 describe('operators', () => {
   it('id', () => {
@@ -18,10 +18,10 @@ describe('operators', () => {
     assert(not(''))
   })
 
-  it('comp', () => {
-    assert(comp(1, 1) === 0)
-    assert(comp(2, 3) === -1)
-    assert(comp(4, 3) === 1)
+  it('compare', () => {
+    assert(compare(1, 1) === 0)
+    assert(compare(2, 3) === -1)
+    assert(compare(4, 3) === 1)
   })
 
   it('isinstance', () => {

package/tests/random.spec.ts

@@ -1,26 +1,26 @@
 import assert from 'assert'
-import { any, times } from '../src/itertools/index.js'
-import { choice, random, randomInt, sample, shuffle } from '../src/random/index.js'
+import { any, times } from '../core/itertools/index.js'
+import { choice, random, randomInt, sample, shuffle } from '../core/random/index.js'
 
-const randomArr = () => [...times(10, (i) => randomInt(i, 71))]
+const randomArr = () => [...times(100, (i) => randomInt(i, 100))]
 
 describe('random', () => {
   it('choice', () => {
     let arr = randomArr()
-    for (let i = 0; i < 10; i++) {
+    for (let i = 0; i < 100; i++) {
       assert(arr.includes(choice(arr)))
     }
   })
 
   it('random', () => {
-    for (let i = 1; i <= 10; i++) {
+    for (let i = 1; i <= 100; i++) {
       let r = random(0, i)
       assert(0 <= r && r < i)
     }
   })
 
   it('randomInt', () => {
-    for (let i = 1; i <= 10; i++) {
+    for (let i = 1; i <= 100; i++) {
       let r = randomInt(0, i)
       assert(0 <= r && r <= i)
     }
@@ -29,7 +29,7 @@ describe('random', () => {
   it('shuffle', () => {
     let arr = randomArr()
     let copy = arr.slice()
-    for (let i = 0; i < 10; i++) {
+    for (let i = 0; i < 100; i++) {
       assert(shuffle(copy) === copy)
       assert(copy.some((x, i) => x !== arr[i]))
     }
@@ -37,9 +37,9 @@ describe('random', () => {
 
   it('sample', () => {
     let arr = randomArr()
-    for (let i = 0; i < 10; i++) {
-      let s = sample(arr, 3)
-      assert(s.length === 3)
+    for (let i = 0; i < 100; i++) {
+      let s = sample(arr, 30)
+      assert(s.length === 30)
       assert(s.some((x, i) => x !== arr[i]))
     }
   })

package/tsconfig.json

@@ -27,7 +27,7 @@
     // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
     /* Modules */
     "module": "ESNext", /* Specify what module code is generated. */
-    "rootDir": "./src", /* Specify the root folder within your source files. */
+    "rootDir": "core", /* Specify the root folder within your source files. */
     "moduleResolution": "node", /* Specify how TypeScript looks up a file from a given module specifier. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
     // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
@@ -106,14 +106,14 @@
   ],
   "typedocOptions": {
     "entryPoints": [
-      "./src/globals/index.ts",
-      "./src/collections/index.ts",
-      "./src/datetime/index.ts",
-      "./src/functools/index.ts",
-      "./src/itertools/index.ts",
-      "./src/math/index.ts",
-      "./src/operators/index.ts",
-      "./src/random/index.ts",
+      "./core/globals/index.ts",
+      "./core/collections/index.ts",
+      "./core/datetime/index.ts",
+      "./core/functools/index.ts",
+      "./core/itertools/index.ts",
+      "./core/math/index.ts",
+      "./core/operators/index.ts",
+      "./core/random/index.ts",
     ],
     "out": "docs",
     "exclude": [
@@ -122,4 +122,4 @@
     "excludeExternals": true,
     "excludePrivate": true,
   }
-}
+}

package/tsconfig.node.json

@@ -1,6 +1,6 @@
 {
   "include": [
-    "src"
+    "core"
   ],
   "compilerOptions": {
     "composite": true,
@@ -15,4 +15,4 @@
   "exclude": [
     "build"
   ]
-}
+}

package/tsconfig.xo.json

@@ -1,9 +1,9 @@
 {
   "extends": "./tsconfig.json",
   "include": [
-    "src"
+    "core"
   ],
   "exclude": [
     "build"
   ]
-}
+}

package/src/operators/index.d.ts

@@ -1,31 +0,0 @@
-/**
- * Generic operations for both values and objects.
- *
- * @module Operators
- */
-export declare const id: (x: any) => any;
-export declare const bool: (x: any) => boolean;
-export declare const not: (x: any) => boolean;
-export declare const isinstance: (x: any, y: any) => boolean;
-export declare function comp(x: any, y: any): 0 | 1 | -1;
-export declare function eq(x: any, y: any): any;
-export declare function lt(x: any, y: any): any;
-export declare function lte(x: any, y: any): any;
-export declare function gt(x: any, y: any): any;
-export declare function gte(x: any, y: any): any;
-export declare function add(x: any, y: any): any;
-export declare function sub(x: any, y: any): any;
-export declare function mul(x: any, y: any): any;
-export declare function div(x: any, y: any): any;
-export declare function mod(x: any, y: any): any;
-/**
- * Calculates `x` to the power of `y`. If `x` implements a custom `pow` operator
- * it will return `x.pow(y)`.
- *
- * @param {*} x
- * @param {*} y
- * @return `x` raised to the power `y`
- */
-export declare function pow(x: any, y: any): any;
-export declare function shallowEqual(obj: any, other: any): boolean;
-export declare function deepEqual(obj: any, other: any, checker?: typeof eq): boolean;