atomic-fns 0.3.4 → 0.4.2

package/tests/Heap.spec.ts

@@ -1,66 +0,0 @@
-import assert from 'assert'
-import { Heap } from '../core/collections/Heap.js'
-import { sorted } from '../core/itertools/index.js'
-
-describe('Heap', () => {
-  it('empty', () => {
-    let h = new Heap()
-    assert(h.empty())
-  })
-
-  it('heapifies array', () => {
-    let arr = [7, 9, 3, 5, 8, 1, 2, 6, 4]
-    let h = new Heap(arr)
-    assert.deepEqual([...h.values()], arr)
-    for (const x of sorted(arr)) {
-      assert(h.contains(x))
-      assert(h.pop() === x)
-    }
-  })
-
-  it('max heapifies', () => {
-    let arr = [7, 9, 3, 5, 8, 1, 2, 6, 4]
-    let h = new Heap(arr, (x, y) => {
-      if (x > y) return -1
-      if (x < y) return 1
-      return 0
-    })
-    assert.deepEqual([...h.values()], arr)
-    for (const x of sorted(arr, true)) {
-      assert(h.contains(x))
-      assert(h.pop() === x)
-    }
-  })
-
-  it('add', () => {
-    let h = new Heap()
-    let arr = [7, 9, 3, 5, 8, 1, 2, 6, 4]
-    for (const value of arr) {
-      h.add(value)
-      assert(h.contains(value))
-    }
-    assert(h.size === arr.length)
-  })
-
-  it('pop', () => {
-    let h = new Heap()
-    let arr = [7, 9, 3, 5, 8, 1, 2, 6, 4]
-    for (const value of arr) {
-      h.add(value)
-    }
-    assert(h.pop() === 1)
-    assert(h.size === arr.length - 1)
-    assert(h.pop() === 2)
-  })
-
-  it('remove', () => {
-    let h = new Heap()
-    let arr = [7, 9, 3, 5, 8, 1, 2, 6, 4]
-    for (const value of arr) {
-      h.add(value)
-    }
-    assert(h.pop() === 1)
-    assert(h.size === arr.length - 1)
-    assert(h.pop() === 2)
-  })
-})

package/tests/SortedMap.spec.ts

@@ -1,144 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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]
-      ]
-    )
-  })
-})