atomic-fns 0.3.1 → 0.3.3

package/tests/SortedMap.spec.ts

@@ -0,0 +1,144 @@
+import assert from 'assert'
+import { SortedMap } from '../core/collections/SortedMap.js'
+
+describe('SortedMap', () => {
+  it('empty', () => {
+    let tree = new SortedMap()
+    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 SortedMap(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 SortedMap()
+    for (let i = 10; i > 0; i--) {
+      tree.add(i)
+      assert(tree.get(i) === null)
+      assert(tree.contains(i))
+    }
+    assert(tree.size === 10)
+  })
+
+  it('set', () => {
+    let tree = new SortedMap()
+    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('get', () => {
+    let tree = new SortedMap()
+    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('has', () => {
+    let tree = new SortedMap()
+    for (let i = 100; i > 0; i--) {
+      tree.add(i)
+      assert(tree.has(i))
+    }
+    assert(tree.size === 100)
+  })
+
+  it('min', () => {
+    let tree = new SortedMap()
+    for (let i = 10; i > 0; i--) {
+      tree.add(i)
+    }
+    assert(tree.min() === 1)
+  })
+
+  it('max', () => {
+    let tree = new SortedMap()
+    for (let i = 10; i > 0; i--) {
+      tree.add(i)
+    }
+    assert(tree.max() === 10)
+  })
+
+  it('delete', () => {
+    let tree = new SortedMap()
+    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 SortedMap()
+    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 SortedMap()
+    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 SortedMap()
+    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 SortedMap()
+    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/SortedSet.spec.ts

@@ -0,0 +1,84 @@
+import assert from 'assert'
+import { SortedSet } from '../core/collections/SortedSet.js'
+
+describe('SortedSet', () => {
+  it('empty', () => {
+    let tree = new SortedSet()
+    assert(tree.empty())
+    assert(tree.size === 0)
+  })
+
+  it('initialized', () => {
+    let entries: number[] = [5, 4, 3, 1, 2]
+    let tree = new SortedSet(entries)
+    assert(!tree.empty())
+    assert(tree.size === 5)
+    entries.sort()
+    assert.deepEqual([...tree.values()], entries)
+  })
+
+  it('add', () => {
+    let tree = new SortedSet()
+    for (let i = 10; i > 0; i--) {
+      tree.add(i)
+      assert(tree.contains(i))
+    }
+    assert(tree.size === 10)
+  })
+
+  it('has', () => {
+    let tree = new SortedSet()
+    for (let i = 100; i > 0; i--) {
+      tree.add(i)
+      assert(tree.has(i))
+    }
+    assert(tree.size === 100)
+  })
+
+  it('min', () => {
+    let tree = new SortedSet()
+    for (let i = 10; i > 0; i--) {
+      tree.add(i)
+    }
+    assert(tree.min() === 1)
+  })
+
+  it('max', () => {
+    let tree = new SortedSet()
+    for (let i = 10; i > 0; i--) {
+      tree.add(i)
+    }
+    assert(tree.max() === 10)
+  })
+
+  it('delete', () => {
+    let tree = new SortedSet()
+    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 SortedSet()
+    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('values', () => {
+    let tree = new SortedSet()
+    for (let i = 1; i <= 5; i++) {
+      tree.add(i * 2)
+    }
+    assert.deepEqual([...tree.values()], [2, 4, 6, 8, 10])
+  })
+})

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', () => {