@blackglory/structures 0.14.14 → 0.15.0

package/src/sparse-set/resizable-typed-clean-sparse-set.ts

@@ -0,0 +1,108 @@
+import { UnsignedTypedArrayConstructor } from 'justypes'
+import { ResizableTypedArray } from '@src/resizable-typed-array.js'
+import { assert } from '@blackglory/errors'
+import { go } from '@blackglory/go'
+import { getMaxValueOfUnsignedTypedArray, getMaxValueOfUnsignedTypedArrayConstructor } from '@utils/get-max-value-of-unsigned-typed-array.js'
+
+export class ResizableTypedCleanSparseSet implements Iterable<number> {
+  private dense: ResizableTypedArray<UnsignedTypedArrayConstructor>
+  private sparse: ResizableTypedArray<UnsignedTypedArrayConstructor>
+  private readonly NULL: number
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.dense.length
+  }
+
+  constructor(array: ResizableTypedArray<UnsignedTypedArrayConstructor>) {
+    assert(array.length === 0, 'The array must be empty')
+
+    this.dense = array
+
+    const NULL = Math.min(
+      array.maxCapacity
+    , getMaxValueOfUnsignedTypedArray(array.internalTypedArray) + 1
+    )
+    this.NULL = NULL
+
+    const sparseInternalArrayConstructor = go(() => {
+      if (
+        NULL <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint8Array)
+      ) {
+        return Uint8Array
+      } else if (
+        NULL <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint16Array)
+      ) {
+        return Uint16Array
+      } else if (
+        NULL <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint32Array)
+      ) {
+        return Uint32Array
+      } else {
+        throw new Error('The array is too large')
+      }
+    })
+    const sparse = new ResizableTypedArray(
+      sparseInternalArrayConstructor
+    , {
+        maxCapacity: getMaxValueOfUnsignedTypedArray(array.internalTypedArray)
+                   + 1
+      , fillValue: NULL
+      }
+    )
+    this.sparse = sparse
+  }
+
+  [Symbol.iterator](): IterableIterator<number> {
+    return this.values()
+  }
+
+  values(): IterableIterator<number> {
+    return this.dense.values()
+  }
+
+  has(value: number): boolean {
+    const index = this.sparse.get(value)
+    return index !== undefined
+        && index !== this.NULL
+  }
+
+  add(value: number): void {
+    if (!this.has(value)) {
+      const index = this.dense.length
+      this.dense.push(value)
+      this.sparse.set(value, index)
+    }
+  }
+
+  delete(value: number): boolean {
+    const index = this.sparse.get(value)
+    if (
+      index !== undefined &&
+      index !== this.NULL
+    ) {
+      this.sparse.internalTypedArray[value] = this.NULL
+
+      const lastValue = this.dense.pop()!
+      if (value !== lastValue) {
+        this.dense.internalTypedArray[index] = lastValue
+        this.sparse.internalTypedArray[lastValue] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.dense.clear()
+    this.sparse.clear()
+  }
+}

package/src/sparse-set/resizable-typed-sparse-set-lite.ts

@@ -0,0 +1,67 @@
+import { UnsignedTypedArrayConstructor } from 'justypes'
+import { ResizableTypedArray } from '@src/resizable-typed-array.js'
+import { assert } from '@blackglory/errors'
+
+export class ResizableTypedSparseSetLite implements Iterable<number> {
+  private dense: ResizableTypedArray<UnsignedTypedArrayConstructor>
+  private sparse: Array<number | undefined> = []
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.dense.length
+  }
+
+  constructor(array: ResizableTypedArray<UnsignedTypedArrayConstructor>) {
+    assert(array.length === 0, 'The array must be empty')
+
+    this.dense = array
+  }
+
+  [Symbol.iterator](): IterableIterator<number> {
+    return this.values()
+  }
+
+  values(): IterableIterator<number> {
+    return this.dense.values()
+  }
+
+  has(value: number): boolean {
+    const index = this.sparse[value]
+    return index !== undefined
+        && this.dense.get(index) === value
+  }
+
+  add(value: number): void {
+    if (!this.has(value)) {
+      const index = this.dense.length
+      this.dense.push(value)
+      this.sparse[value] = index
+    }
+  }
+
+  delete(value: number): boolean {
+    const index = this.sparse[value]
+    if (
+      index !== undefined &&
+      this.dense.get(index) === value
+    ) {
+      const lastValue = this.dense.pop()!
+      if (value !== lastValue) {
+        this.dense.internalTypedArray[index] = lastValue
+        this.sparse[lastValue] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.dense.clear()
+    // 无需清空sparse数组.
+  }
+}

package/src/sparse-set/resizable-typed-sparse-set.ts

@@ -0,0 +1,97 @@
+import { UnsignedTypedArrayConstructor } from 'justypes'
+import { ResizableTypedArray } from '@src/resizable-typed-array.js'
+import { getMaxValueOfUnsignedTypedArray, getMaxValueOfUnsignedTypedArrayConstructor } from '@utils/get-max-value-of-unsigned-typed-array.js'
+import { go } from '@blackglory/go'
+import { assert } from '@blackglory/errors'
+
+export class ResizableTypedSparseSet implements Iterable<number> {
+  private dense: ResizableTypedArray<UnsignedTypedArrayConstructor>
+  private sparse: ResizableTypedArray<UnsignedTypedArrayConstructor>
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.dense.length
+  }
+
+  constructor(array: ResizableTypedArray<UnsignedTypedArrayConstructor>) {
+    assert(array.length === 0, 'The array must be empty')
+
+    this.dense = array
+
+    const sparseInternalArrayConstructor = go(() => {
+      const maxIndex = Math.min(
+        array.maxCapacity - 1
+      , getMaxValueOfUnsignedTypedArray(array.internalTypedArray) + 1
+      )
+      if (
+        maxIndex <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint8Array)
+      ) {
+        return Uint8Array
+      } else if (
+        maxIndex <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint16Array)
+      ) {
+        return Uint16Array
+      } else if (
+        maxIndex <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint32Array)
+      ) {
+        return Uint32Array
+      } else {
+        throw new Error('The array is too large')
+      }
+    })
+    this.sparse = new ResizableTypedArray(sparseInternalArrayConstructor, {
+      maxCapacity: getMaxValueOfUnsignedTypedArray(array.internalTypedArray) + 1
+    })
+  }
+
+  [Symbol.iterator](): IterableIterator<number> {
+    return this.values()
+  }
+
+  values(): IterableIterator<number> {
+    return this.dense.values()
+  }
+
+  has(value: number): boolean {
+    const index = this.sparse.get(value)
+    return index !== undefined
+        && this.dense.get(index) === value
+  }
+
+  add(value: number): void {
+    if (!this.has(value)) {
+      const index = this.dense.length
+      this.dense.push(value)
+      this.sparse.set(value, index)
+    }
+  }
+
+  delete(value: number): boolean {
+    const index = this.sparse.get(value)
+    if (
+      index !== undefined &&
+      this.dense.get(index) === value
+    ) {
+      const lastValue = this.dense.pop()!
+      if (value !== lastValue) {
+        this.dense.internalTypedArray[index] = lastValue
+        this.sparse.set(lastValue, index)
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.dense.clear()
+    // 无需清空sparse数组.
+  }
+}

package/src/sparse-set/sparse-set.ts

@@ -0,0 +1,79 @@
+/**
+ * 稀疏集的标准实现.
+ */
+export class SparseSet implements Iterable<number> {
+  private dense: number[] = []
+  private sparse: Array<number | undefined> = []
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.dense.length
+  }
+
+  [Symbol.iterator](): IterableIterator<number> {
+    return this.values()
+  }
+
+  values(): IterableIterator<number> {
+    return this.dense.values()
+  }
+
+  has(value: number): boolean {
+    const index = this.sparse[value]
+    return index !== undefined
+        && index < this.dense.length // 用于改善JIT优化.
+        && this.dense[index] === value
+  }
+
+  add(value: number): void {
+    if (!this.has(value)) {
+      const index = this.dense.length
+      this.dense.push(value)
+      this.sparse[value] = index
+    }
+  }
+
+  delete(value: number): boolean {
+    const index = this.sparse[value]
+    if (
+      index !== undefined &&
+      index < this.dense.length && // 用于改善JIT优化.
+      this.dense[index] === value
+    ) {
+      const lastValue = this.dense.pop()!
+      if (value !== lastValue) {
+        this.dense[index] = lastValue
+        this.sparse[lastValue] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.dense.length = 0
+    // 无需清空sparse数组.
+  }
+
+  clone(): SparseSet {
+    const clone = new SparseSet()
+
+    const dense = [...this.dense]
+
+    // 由于`sparse`是稀疏的, 不应用`[...sparse]`复制.
+    const sparse: Array<number | undefined> = []
+    for (const [index, value] of dense.entries()) {
+      sparse[value] = index
+    }
+
+    clone.dense = dense
+    clone.sparse = sparse
+
+    return clone
+  }
+}

package/src/sparse-set/typed-clean-sparse-set-lite.ts

@@ -0,0 +1,67 @@
+import { assert } from '@blackglory/errors'
+import { UnsignedTypedArray } from 'justypes'
+
+export class TypedCleanSparseSetLite implements Iterable<number> {
+  private dense: UnsignedTypedArray
+  private sparse: Array<number | undefined> = []
+  #length = 0
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.#length
+  }
+
+  constructor(array: UnsignedTypedArray<ArrayBuffer>) {
+    assert(!array.buffer.resizable, 'The array buffer must not be resizable')
+
+    this.dense = array
+  }
+
+  [Symbol.iterator](): IterableIterator<number> {
+    return this.values()
+  }
+
+  * values(): IterableIterator<number> {
+    for (let i = 0; i < this.#length; i++) {
+      yield this.dense[i]
+    }
+  }
+
+  has(value: number): boolean {
+    return this.sparse[value] !== undefined
+  }
+
+  add(value: number): void {
+    if (!this.has(value)) {
+      const index = this.#length++
+      this.dense[index] = value
+      this.sparse[value] = index
+    }
+  }
+
+  delete(value: number): boolean {
+    const index = this.sparse[value]
+    if (index !== undefined) {
+      this.sparse[value] = undefined
+
+      const lastIndex = --this.#length
+      const lastValue = this.dense[lastIndex]
+      if (value !== lastValue) {
+        this.dense[index] = lastValue
+        this.sparse[lastValue] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.#length = 0
+    this.sparse.length = 0
+  }
+}

package/src/sparse-set/typed-clean-sparse-set.ts

@@ -0,0 +1,100 @@
+import { assert } from '@blackglory/errors'
+import { go } from '@blackglory/go'
+import { getMaxValueOfUnsignedTypedArray, getMaxValueOfUnsignedTypedArrayConstructor } from '@utils/get-max-value-of-unsigned-typed-array.js'
+import { UnsignedTypedArray } from 'justypes'
+
+export class TypedCleanSparseSet implements Iterable<number> {
+  private dense: UnsignedTypedArray
+  private sparse: UnsignedTypedArray
+  private readonly NULL: number
+  #length = 0
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.#length
+  }
+
+  constructor(array: UnsignedTypedArray<ArrayBuffer>) {
+    assert(!array.buffer.resizable, 'The array buffer must not be resizable')
+
+    this.dense = array
+
+    const NULL = Math.min(
+      array.length
+    , getMaxValueOfUnsignedTypedArray(array) + 1
+    )
+    this.NULL = NULL
+
+    const sparseConstructor = go(() => {
+      if (
+        NULL <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint8Array)
+      ) {
+        return Uint8Array
+      } else if (
+        NULL <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint16Array)
+      ) {
+        return Uint16Array
+      } else if (
+        NULL <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint32Array)
+      ) {
+        return Uint32Array
+      } else {
+        throw new Error('The array is too large')
+      }
+    })
+    const sparse = new sparseConstructor(getMaxValueOfUnsignedTypedArray(array) + 1)
+    sparse.fill(NULL)
+    this.sparse = sparse
+  }
+
+  [Symbol.iterator](): IterableIterator<number> {
+    return this.values()
+  }
+
+  * values(): IterableIterator<number> {
+    for (let i = 0; i < this.#length; i++) {
+      yield this.dense[i]
+    }
+  }
+
+  has(value: number): boolean {
+    return this.sparse[value] !== this.NULL
+  }
+
+  add(value: number): void {
+    if (!this.has(value)) {
+      const index = this.#length++
+      this.dense[index] = value
+      this.sparse[value] = index
+    }
+  }
+
+  delete(value: number): boolean {
+    const index = this.sparse[value]
+    if (index !== this.NULL) {
+      this.sparse[value] = this.NULL
+
+      const lastIndex = --this.#length
+      const lastValue = this.dense[lastIndex]
+      if (value !== lastValue) {
+        this.dense[index] = lastValue
+        this.sparse[lastValue] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.#length = 0
+    this.sparse.fill(this.NULL)
+  }
+}

package/src/sparse-set/typed-sparse-set-lite.ts

@@ -0,0 +1,74 @@
+import { assert } from '@blackglory/errors'
+import { UnsignedTypedArray } from 'justypes'
+
+export class TypedSparseSetLite implements Iterable<number> {
+  private dense: UnsignedTypedArray
+  private sparse: Array<number | undefined> = []
+  #length = 0
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.#length
+  }
+
+  constructor(array: UnsignedTypedArray<ArrayBuffer>) {
+    assert(!array.buffer.resizable, 'The array buffer must not be resizable')
+
+    this.dense = array
+  }
+
+  [Symbol.iterator](): IterableIterator<number> {
+    return this.values()
+  }
+
+  * values(): IterableIterator<number> {
+    for (let i = 0; i < this.#length; i++) {
+      yield this.dense[i]
+    }
+  }
+
+  has(value: number): boolean {
+    const index = this.sparse[value]
+    return index !== undefined
+        && index < this.#length
+        && index < this.dense.length // 用于改善JIT优化.
+        && this.dense[index] === value
+  }
+
+  add(value: number): void {
+    if (!this.has(value)) {
+      const index = this.#length++
+      this.dense[index] = value
+      this.sparse[value] = index
+    }
+  }
+
+  delete(value: number): boolean {
+    const index = this.sparse[value]
+    if (
+      index !== undefined &&
+      index < this.#length &&
+      index < this.dense.length && // 用于改善JIT优化.
+      this.dense[index] === value
+    ) {
+      const lastIndex = --this.#length
+      const lastValue = this.dense[lastIndex]
+      if (value !== lastValue) {
+        this.dense[index] = lastValue
+        this.sparse[lastValue] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.#length = 0
+    // 无需清空dense和sparse数组.
+  }
+}

package/src/sparse-set/typed-sparse-set.ts

@@ -0,0 +1,102 @@
+import { assert } from '@blackglory/errors'
+import { go } from '@blackglory/go'
+import { getMaxValueOfUnsignedTypedArray, getMaxValueOfUnsignedTypedArrayConstructor } from '@utils/get-max-value-of-unsigned-typed-array.js'
+import { UnsignedTypedArray } from 'justypes'
+
+export class TypedSparseSet implements Iterable<number> {
+  private dense: UnsignedTypedArray
+  private sparse: UnsignedTypedArray
+  #length = 0
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.#length
+  }
+
+  constructor(array: UnsignedTypedArray<ArrayBuffer>) {
+    assert(!array.buffer.resizable, 'The array buffer must not be resizable')
+
+    this.dense = array
+
+    const sparseConstructor = go(() => {
+      const maxIndex = Math.min(
+        array.length - 1
+      , getMaxValueOfUnsignedTypedArray(array) + 1
+      )
+      if (
+        maxIndex <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint8Array)
+      ) {
+        return Uint8Array
+      } else if (
+        maxIndex <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint16Array)
+      ) {
+        return Uint16Array
+      } else if (
+        maxIndex <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint32Array)
+      ) {
+        return Uint32Array
+      } else {
+        throw new Error('The array is too large')
+      }
+    })
+    this.sparse = new sparseConstructor(getMaxValueOfUnsignedTypedArray(array) + 1)
+  }
+
+  [Symbol.iterator](): IterableIterator<number> {
+    return this.values()
+  }
+
+  * values(): IterableIterator<number> {
+    for (let i = 0; i < this.#length; i++) {
+      yield this.dense[i]
+    }
+  }
+
+  has(value: number): boolean {
+    const index = this.sparse[value]
+    return index !== undefined
+        && index < this.#length
+        && index < this.dense.length // 用于改善JIT优化.
+        && this.dense[index] === value
+  }
+
+  add(value: number): void {
+    if (!this.has(value)) {
+      const index = this.#length++
+      this.dense[index] = value
+      this.sparse[value] = index
+    }
+  }
+
+  delete(value: number): boolean {
+    const index = this.sparse[value]
+    if (
+      index !== undefined &&
+      index < this.#length &&
+      index < this.dense.length && // 用于改善JIT优化.
+      this.dense[index] === value
+    ) {
+      const lastIndex = --this.#length
+      const lastValue = this.dense[lastIndex]
+      if (value !== lastValue) {
+        this.dense[index] = lastValue
+        this.sparse[lastValue] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.#length = 0
+    // 无需清空dense和sparse数组.
+  }
+}