atomic-fns 0.3.1 → 0.3.2

package/tests/BTree.spec.ts

@@ -0,0 +1,143 @@
+import assert from 'assert'
+import { BTree } from '../core/collections/BTree.js'
+import { times } from '../core/itertools/index.js'
+
+describe('BTree', () => {
+  it('get', () => {
+    let tree = new BTree()
+
+    for (let i = 100; i > 0; i--) {
+      tree.set(i, i * 2)
+      assert(tree.get(i) == i * 2)
+    }
+  })
+
+  it('add', () => {
+    let tree = new BTree()
+
+    for (let i = 100; i > 0; i--) {
+      tree.add(i)
+      assert(tree.contains(i))
+      assert(tree.get(i) === null)
+    }
+  })
+
+  it('set', () => {
+    let tree = new BTree()
+
+    for (let i = 100; i > 0; i--) {
+      tree.set(i, i)
+      assert(tree.contains(i))
+    }
+
+    assert(tree.size === 100)
+  })
+
+  it('remove', () => {
+    let tree = new BTree()
+    for (let i = 100; i > 0; i--) {
+      tree.set(i, i)
+    }
+    assert(tree.contains(100))
+    tree.remove(100)
+    assert(tree.contains(100) === false)
+  })
+
+  it('clear', () => {
+    let tree = new BTree()
+    for (let i = 100; i > 0; i--) {
+      tree.set(i, i)
+    }
+    tree.clear()
+    assert(tree.size === 0)
+    assert(tree.contains(100) === false)
+  })
+
+  it('iterates in order', () => {
+    let tree = new BTree()
+    let entries: any[] = []
+    for (let i = 9; i >= 0; i--) {
+      tree.set(i, i * 2)
+      entries.push([i, i * 2])
+    }
+    entries.sort((x, y) => x[0] - y[0])
+    assert.deepEqual([...tree], entries)
+  })
+
+  it('minKey', () => {
+    let tree = new BTree()
+    let keys: number[] = []
+    for (let i = 10; i >= 0; i--) {
+      keys.push(i)
+      tree.set(i, i * 2)
+    }
+    keys.sort(tree._compare)
+    assert(tree.minKey() === keys[0])
+  })
+
+  it('maxKey', () => {
+    let tree = new BTree()
+    let keys: number[] = []
+    for (let i = 10; i >= 0; i--) {
+      keys.push(i)
+      tree.set(i, i * 2)
+    }
+    keys.sort(tree._compare)
+    assert(tree.maxKey() === keys[keys.length - 1])
+  })
+
+  it('clone', () => {
+    let tree = new BTree()
+    let entries: any[] = []
+    for (let i = 100; i > 0; i--) {
+      tree.set(i, i)
+      entries.push([i, i])
+    }
+    let t2 = tree.clone()
+    assert.deepEqual([...t2.reversed()], entries)
+  })
+
+  it('freeze', () => {
+    let tree = new BTree()
+    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 BTree()
+    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 BTree()
+    for (let i = 9; i >= 0; i--) {
+      tree.set(i, i)
+    }
+    assert.deepEqual([...tree.keys()], [...times(10, (i) => i)])
+  })
+
+  it('values', () => {
+    let tree = new BTree()
+    for (let i = 9; i >= 0; i--) {
+      tree.set(i, i * 2)
+    }
+    assert.deepEqual([...tree.values()], [...times(10, (i) => i * 2)])
+  })
+
+  it('entries', () => {
+    let tree = new BTree()
+    for (let i = 9; i >= 0; i--) {
+      tree.set(i, i * 2)
+    }
+    assert.deepEqual([...tree.entries()], [...times(10, (i) => [i, i * 2])])
+  })
+})

package/tests/Cache.spec.ts

@@ -0,0 +1,161 @@
+import assert from 'assert'
+import { Cache, LRUCache } from '../core/collections/LRUCache.js'
+
+describe('Cache', () => {
+  it('empty', () => {
+    let cache = new Cache()
+    assert(cache.size === 0)
+  })
+
+  it('contains', () => {
+    let cache = new Cache(2)
+    assert(cache.capacity === 2)
+    assert(!cache.contains(1))
+    cache.set(1, 'foo')
+    cache.set(2, 'bar')
+    assert(cache.contains(1))
+    assert(cache.contains(2))
+  })
+
+  it('evicts LRU keys', () => {
+    let cache = new Cache(2)
+    assert(cache.capacity === 2)
+    cache.set(1, 'foo')
+    cache.set(2, 'bar')
+    assert(cache.get(1) === 'foo')
+    cache.set(3, 'other')
+    assert(cache.get(2) === undefined)
+    assert.deepEqual([...cache.keys()], [3, 1])
+  })
+
+  it('keys', () => {
+    let cache = new Cache(5)
+    for (const value of [1, 2, 3, 4, 5]) {
+      cache.set(value, value)
+    }
+    assert.deepEqual([...cache.keys()], [5, 4, 3, 2, 1])
+  })
+
+  it('values', () => {
+    let cache = new Cache(5)
+    for (const value of [1, 2, 3, 4, 5]) {
+      cache.set(value, value)
+    }
+    assert.deepEqual([...cache.keys()], [5, 4, 3, 2, 1])
+  })
+
+  it('entries', () => {
+    let cache = new Cache(3)
+    for (const value of [1, 2, 3]) {
+      cache.set(value, 0)
+    }
+    assert.deepEqual(
+      [...cache.entries()],
+      [
+        [3, 0],
+        [2, 0],
+        [1, 0]
+      ]
+    )
+  })
+
+  it('iterator', () => {
+    let cache = new Cache(3)
+    for (const value of [1, 2, 3]) {
+      cache.set(value, 0)
+    }
+    let values = [...cache]
+    assert.deepEqual(values, [...cache.entries()])
+  })
+})
+
+describe('LRUCache', () => {
+  it('empty', () => {
+    let cache = new LRUCache()
+    assert(cache.size === 0)
+  })
+
+  it('contains', () => {
+    let cache = new LRUCache(2)
+    assert(cache.capacity === 2)
+    assert(!cache.contains(1))
+    cache.set(1, 'foo')
+    cache.set(2, 'bar')
+    assert(cache.contains(1))
+    assert(cache.contains(2))
+  })
+
+  it('evicts LRU keys', () => {
+    let cache = new LRUCache(2)
+    assert(cache.capacity === 2)
+    cache.set(1, 'foo')
+    cache.set(2, 'bar')
+    assert(cache.get(1) === 'foo')
+    cache.set(3, 'other')
+    assert(cache.get(2) === undefined)
+    assert.deepEqual([...cache.keys()], [3, 1])
+  })
+
+  it('keys', () => {
+    let cache = new LRUCache(5)
+    for (const value of [1, 2, 3, 4, 5]) {
+      cache.set(value, value)
+    }
+    assert.deepEqual([...cache.keys()], [5, 4, 3, 2, 1])
+  })
+
+  it('values', () => {
+    let cache = new LRUCache(5)
+    for (const value of [1, 2, 3, 4, 5]) {
+      cache.set(value, value)
+    }
+    assert.deepEqual([...cache.keys()], [5, 4, 3, 2, 1])
+  })
+
+  it('entries', () => {
+    let cache = new LRUCache(3)
+    for (const value of [1, 2, 3]) {
+      cache.set(value, 0)
+    }
+    assert.deepEqual(
+      [...cache.entries()],
+      [
+        [3, 0],
+        [2, 0],
+        [1, 0]
+      ]
+    )
+  })
+
+  it('iterator', () => {
+    let cache = new LRUCache(3)
+    for (const value of [1, 2, 3]) {
+      cache.set(value, 0)
+    }
+    let values = [...cache]
+    assert.deepEqual(values, [...cache.entries()])
+  })
+
+  it('delete', () => {
+    let cache = new LRUCache()
+    for (const value of [1, 2, 3]) {
+      cache.set(value, 0)
+    }
+    assert(cache.contains(1))
+    assert(cache.delete(1) === true)
+    assert(!cache.contains(1))
+    // try deleting again
+    assert(cache.delete(1) === false)
+  })
+
+  it('remove', () => {
+    let cache = new LRUCache()
+    for (const value of [1, 2, 3]) {
+      cache.set(value, 0)
+    }
+    assert(cache.contains(1))
+    assert(cache.remove(1) === 0)
+    assert(!cache.contains(1))
+    assert(cache.delete(2))
+  })
+})

package/tests/Heap.spec.ts

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

@@ -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])
+  })
+})