@blackglory/structures 0.14.15 → 0.15.1

package/src/resizable-typed-array.ts

@@ -0,0 +1,214 @@
+import { TypedArrayConstructor, TypedArrayOfConstructor } from 'justypes'
+import { assert } from '@blackglory/errors'
+import { computeNewCapacity } from '@utils/compute-new-capacity.js'
+
+interface IResizableTypedArrayOptions {
+  maxCapacity: number
+
+  initialCapacity?: number
+  growthFactor?: number
+
+  fillValue?: number
+}
+
+export class ResizableTypedArray<
+  T extends TypedArrayConstructor
+> implements Iterable<number> {
+  private array: TypedArrayOfConstructor<T, ArrayBuffer>
+
+  readonly maxCapacity: number
+  readonly growthFactor: number
+  readonly BYTES_PER_ELEMENT: number
+  readonly internalTypedArray: TypedArrayOfConstructor<T>
+  readonly fillValue: number
+
+  #length: number = 0
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  /**
+   * 数组当前的容量.
+   */
+  get capacity(): number {
+    return this.array.length
+  }
+
+  /**
+   * 数组逻辑上的长度, 总是小于或等于capacity.
+   */
+  get length(): number {
+    return this.#length
+  }
+
+  constructor(
+    typedArrayConstructor: T
+  , {
+      maxCapacity
+    , initialCapacity = 0
+    , growthFactor = 1.5
+    , fillValue = 0
+    }: IResizableTypedArrayOptions
+  ) {
+    assert(growthFactor >= 1, 'growthFactory must be greater than or equal to 1')
+    assert(initialCapacity >= 0, 'initialCapacity must be greater than or equal to 0')
+    assert(Number.isInteger(initialCapacity), 'capacity must be an integer')
+    assert(initialCapacity >= 0, 'capacity must be greater than or equal to 0')
+    assert(Number.isInteger(maxCapacity), 'maxCapacity must be an integer')
+    assert(maxCapacity >= initialCapacity, 'maxCapacity must be greater than or equal to capacity')
+
+    this.growthFactor = growthFactor
+    this.maxCapacity = maxCapacity
+    this.fillValue = fillValue
+
+    const buffer = new ArrayBuffer(
+      initialCapacity * typedArrayConstructor.BYTES_PER_ELEMENT
+    , { maxByteLength: maxCapacity * typedArrayConstructor.BYTES_PER_ELEMENT }
+    )
+    const array = new typedArrayConstructor(buffer)
+    if (fillValue !== 0) array.fill(fillValue)
+    this.array = array as TypedArrayOfConstructor<T, ArrayBuffer>
+
+    this.internalTypedArray = array as TypedArrayOfConstructor<T, ArrayBuffer>
+    this.BYTES_PER_ELEMENT = typedArrayConstructor.BYTES_PER_ELEMENT
+  }
+
+  [Symbol.iterator](): IterableIterator<number> {
+    return this.values()
+  }
+
+  * values(): IterableIterator<number> {
+    for (let i = 0; i < this.#length; i++) {
+      yield this.array[i]
+    }
+  }
+
+  set(index: number, value: number): void {
+    if (index >= this.capacity) {
+      assert(index < this.maxCapacity, 'index must be less than maxCapacity')
+
+      const newCapacity = Math.min(
+        computeNewCapacity(
+          this.capacity
+        , index + 1
+        , this.growthFactor
+        )
+      , this.maxCapacity
+      )
+
+      this.resize(newCapacity)
+    }
+
+    if (index >= this.#length) {
+      this.#length = index + 1
+    }
+
+    this.array[index] = value
+  }
+
+  setValues(index: number, values: ArrayLike<number>): void {
+    const endIndex = index + values.length
+    if (endIndex > this.capacity) {
+      assert(
+        endIndex <= this.maxCapacity
+      , 'endIndex must be less than or equal tomaxCapacity'
+      )
+
+      const newCapacity = Math.min(
+        computeNewCapacity(
+          this.capacity
+        , index + values.length
+        , this.growthFactor
+        )
+      , this.maxCapacity
+      )
+
+      this.resize(newCapacity)
+    }
+
+    if (endIndex > this.#length) {
+      this.#length = endIndex
+    }
+
+    this.array.set(values, index)
+  }
+
+  get(index: number): number | undefined {
+    return index < this.#length
+         ? this.array[index]
+         : undefined
+  }
+
+  push(...values: number[]): void {
+    const newLength = this.#length + values.length
+    if (newLength > this.capacity) {
+      assert(
+        newLength <= this.maxCapacity
+      , 'newLength must be less than or equal to maxCapacity'
+      )
+
+      const newCapacity = Math.min(
+        computeNewCapacity(
+          this.capacity
+        , newLength
+        , this.growthFactor
+        )
+      , this.maxCapacity
+      )
+
+      this.resize(newCapacity)
+    }
+
+    for (const value of values) {
+      this.array[this.#length++] = value
+    }
+  }
+
+  pop(): number | undefined {
+    if (this.#length > 0) {
+      const value = this.array[this.#length - 1]
+      this.#length--
+
+      return value
+    } else {
+      return undefined
+    }
+  }
+
+  clear(): void {
+    this.#length = 0
+  }
+
+  shrink(): void {
+    const newCapacity = computeNewCapacity(
+      this.capacity
+    , this.length
+    , this.growthFactor
+    )
+    this.resize(newCapacity)
+  }
+
+  sort(compare?: (a: number, b: number) => number): void {
+    const capacity = this.capacity
+    this.resize(this.length)
+    this.array.sort(compare)
+    this.resize(capacity)
+  }
+
+  private resize(newCapacity: number): void {
+    if (this.array.length === newCapacity) {
+      return
+    } else if (this.array.length < newCapacity) {
+      if (this.fillValue === 0) {
+        this.array.buffer.resize(newCapacity * this.BYTES_PER_ELEMENT)
+      } else {
+        const startIndex = this.array.length
+        this.array.buffer.resize(newCapacity * this.BYTES_PER_ELEMENT)
+        this.array.fill(this.fillValue, startIndex)
+      }
+    } else /* if (this.array.length > newCapacity) */ {
+      this.array.buffer.resize(newCapacity * this.BYTES_PER_ELEMENT)
+    }
+  }
+}

package/src/sparse-map/clean-sparse-map.ts

@@ -0,0 +1,84 @@
+export class CleanSparseMap<T> {
+  private denseKeys: number[] = []
+  private denseValues: T[] = []
+  private sparse: Array<number | undefined> = []
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.denseKeys.length
+  }
+
+  readonly internalKeyArray: readonly number[] = this.denseKeys
+  readonly internalValueArray: T[] = this.denseValues
+
+  ;* entries(): IterableIterator<[key: number, value: T]> {
+    for (let i = 0; i < this.denseKeys.length; i++) {
+      yield [this.denseKeys[i], this.denseValues[i]]
+    }
+  }
+
+  keys(): IterableIterator<number> {
+    return this.denseKeys.values()
+  }
+
+  values(): IterableIterator<T> {
+    return this.denseValues.values()
+  }
+
+  getInternalIndexOfKey(key: number): number | undefined {
+    return this.sparse[key]
+  }
+
+  has(key: number): boolean {
+    return this.sparse[key] !== undefined
+  }
+
+  get(key: number): T | undefined {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      return this.denseValues[index]
+    } else {
+      return undefined
+    }
+  }
+
+  set(key: number, value: T): void {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      this.denseValues[index] = value
+    } else {
+      const index = this.denseKeys.length
+      this.denseKeys.push(key)
+      this.denseValues.push(value)
+      this.sparse[key] = index
+    }
+  }
+
+  delete(key: number): boolean {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      this.sparse[key] = undefined
+
+      const lastKey = this.denseKeys.pop()!
+      const lastValue = this.denseValues.pop()!
+      if (key !== lastKey) {
+        this.denseKeys[index] = lastKey
+        this.denseValues[index] = lastValue
+        this.sparse[lastKey] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.denseKeys.length = 0
+    this.denseValues.length = 0
+    this.sparse.length = 0
+  }
+}

package/src/sparse-map/dynamic-typed-clean-sparse-map-lite.ts

@@ -0,0 +1,109 @@
+import { assert } from '@blackglory/errors'
+import { TypedArrayConstructor, UnsignedTypedArrayConstructor, TypedArrayOfConstructor } from 'justypes'
+import { DynamicTypedArray } from '@src/dynamic-typed-array.js'
+
+export class DynamicTypedCleanSparseMapLite<
+  K extends UnsignedTypedArrayConstructor
+, V extends TypedArrayConstructor
+> {
+  private denseKeys: DynamicTypedArray<K>
+  private denseValues: DynamicTypedArray<V>
+  private sparse: Array<number | undefined> = []
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.denseKeys.length
+  }
+
+  get internalKeyArray(): TypedArrayOfConstructor<K> {
+    return this.denseKeys.internalTypedArray
+  }
+
+  get internalValueArray(): TypedArrayOfConstructor<V> {
+    return this.denseValues.internalTypedArray
+  }
+
+  constructor(
+    keys: DynamicTypedArray<K>
+  , values: DynamicTypedArray<V>
+  ) {
+    assert(keys.length === 0, 'keys must be empty')
+
+    this.denseKeys = keys
+    this.denseValues = values
+  }
+
+  * entries(): IterableIterator<[key: number, value: number]> {
+    for (let i = 0; i < this.denseKeys.length; i++) {
+      yield [
+        this.denseKeys.internalTypedArray[i]
+      , this.denseValues.internalTypedArray[i]
+      ]
+    }
+  }
+
+  keys(): IterableIterator<number> {
+    return this.denseKeys.values()
+  }
+
+  values(): IterableIterator<number> {
+    return this.denseValues.values()
+  }
+
+  getInternalIndexOfKey(key: number): number | undefined {
+    return this.sparse[key]
+  }
+
+  has(key: number): boolean {
+    return this.sparse[key] !== undefined
+  }
+
+  get(key: number): number | undefined {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      return this.denseValues.internalTypedArray[index]
+    } else {
+      return undefined
+    }
+  }
+
+  set(key: number, value: number): void {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      this.denseValues.internalTypedArray[index] = value
+    } else {
+      const index = this.denseKeys.length
+      this.denseKeys.push(key)
+      this.denseValues.push(value)
+      this.sparse[key] = index
+    }
+  }
+
+  delete(key: number): boolean {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      this.sparse[key] = undefined
+
+      const lastKey = this.denseKeys.pop()!
+      const lastValue = this.denseValues.pop()!
+      if (key !== lastKey) {
+        this.denseKeys.internalTypedArray[index] = lastKey
+        this.denseValues.internalTypedArray[index] = lastValue
+        this.sparse[lastKey] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.denseKeys.clear()
+    this.denseValues.clear()
+    this.sparse.length = 0
+  }
+}

package/src/sparse-map/dynamic-typed-sparse-map-lite.ts

@@ -0,0 +1,124 @@
+import { assert } from '@blackglory/errors'
+import { TypedArrayConstructor, UnsignedTypedArrayConstructor, TypedArrayOfConstructor } from 'justypes'
+import { DynamicTypedArray } from '@src/dynamic-typed-array.js'
+
+export class DynamicTypedSparseMapLite<
+  K extends UnsignedTypedArrayConstructor
+, V extends TypedArrayConstructor
+> {
+  private denseKeys: DynamicTypedArray<K>
+  private denseValues: DynamicTypedArray<V>
+  private sparse: Array<number | undefined> = []
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.denseKeys.length
+  }
+
+  get internalKeyArray(): TypedArrayOfConstructor<K> {
+    return this.denseKeys.internalTypedArray
+  }
+
+  get internalValueArray(): TypedArrayOfConstructor<V> {
+    return this.denseValues.internalTypedArray
+  }
+
+  constructor(
+    keys: DynamicTypedArray<K>
+  , values: DynamicTypedArray<V>
+  ) {
+    assert(keys.length === 0, 'keys must be empty')
+
+    this.denseKeys = keys
+    this.denseValues = values
+  }
+
+  * entries(): IterableIterator<[key: number, value: number]> {
+    for (let i = 0; i < this.denseKeys.length; i++) {
+      yield [
+        this.denseKeys.internalTypedArray[i]
+      , this.denseValues.internalTypedArray[i]
+      ]
+    }
+  }
+
+  keys(): IterableIterator<number> {
+    return this.denseKeys.values()
+  }
+
+  values(): IterableIterator<number> {
+    return this.denseValues.values()
+  }
+
+  getInternalIndexOfKey(key: number): number | undefined {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      this.denseKeys.get(index) === key
+    ) {
+      return index
+    }
+  }
+
+  has(key: number): boolean {
+    const index = this.sparse[key]
+    return index !== undefined
+        && this.denseKeys.get(index) === key
+  }
+
+  get(key: number): number | undefined {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      this.denseKeys.get(index) === key
+    ) {
+      return this.denseValues.internalTypedArray[index]
+    } else {
+      return undefined
+    }
+  }
+
+  set(key: number, value: number): void {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      this.denseKeys.get(index) === key
+    ) {
+      this.denseValues.internalTypedArray[index] = value
+    } else {
+      const index = this.denseKeys.length
+      this.denseKeys.push(key)
+      this.denseValues.push(value)
+      this.sparse[key] = index
+    }
+  }
+
+  delete(key: number): boolean {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      this.denseKeys.get(index) === key
+    ) {
+      const lastKey = this.denseKeys.pop()!
+      const lastValue = this.denseValues.pop()!
+      if (key !== lastKey) {
+        this.denseKeys.internalTypedArray[index] = lastKey
+        this.denseValues.internalTypedArray[index] = lastValue
+        this.sparse[lastKey] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.denseKeys.clear()
+    this.denseValues.clear()
+    // 无需清空sparse数组.
+  }
+}

package/src/sparse-map/index.ts

@@ -0,0 +1,11 @@
+export * from './sparse-map.js'
+export * from './typed-sparse-map.js'
+export * from './typed-sparse-map-lite.js'
+export * from './dynamic-typed-sparse-map-lite.js'
+export * from './resizable-typed-sparse-map-lite.js'
+
+export * from './clean-sparse-map.js'
+export * from './typed-clean-sparse-map.js'
+export * from './typed-clean-sparse-map-lite.js'
+export * from './dynamic-typed-clean-sparse-map-lite.js'
+export * from './resizable-typed-clean-sparse-map-lite.js'

package/src/sparse-map/resizable-typed-clean-sparse-map-lite.ts

@@ -0,0 +1,107 @@
+import { assert } from '@blackglory/errors'
+import { TypedArrayConstructor, UnsignedTypedArrayConstructor, TypedArrayOfConstructor } from 'justypes'
+import { ResizableTypedArray } from '@src/resizable-typed-array.js'
+
+export class ResizableTypedCleanSparseMapLite<
+  K extends UnsignedTypedArrayConstructor
+, V extends TypedArrayConstructor
+> {
+  private denseKeys: ResizableTypedArray<K>
+  private denseValues: ResizableTypedArray<V>
+  private sparse: Array<number | undefined> = []
+
+  readonly internalKeyArray: TypedArrayOfConstructor<K>
+  readonly internalValueArray: TypedArrayOfConstructor<V>
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.denseKeys.length
+  }
+
+  constructor(
+    keys: ResizableTypedArray<K>
+  , values: ResizableTypedArray<V>
+  ) {
+    assert(keys.length === 0, 'keys must be empty')
+
+    this.denseKeys = keys
+    this.denseValues = values
+
+    this.internalKeyArray = keys.internalTypedArray
+    this.internalValueArray = values.internalTypedArray
+  }
+
+  * entries(): IterableIterator<[key: number, value: number]> {
+    for (let i = 0; i < this.denseKeys.length; i++) {
+      yield [
+        this.denseKeys.internalTypedArray[i]
+      , this.denseValues.internalTypedArray[i]
+      ]
+    }
+  }
+
+  keys(): IterableIterator<number> {
+    return this.denseKeys.values()
+  }
+
+  values(): IterableIterator<number> {
+    return this.denseValues.values()
+  }
+
+  getInternalIndexOfKey(key: number): number | undefined {
+    return this.sparse[key]
+  }
+
+  has(key: number): boolean {
+    return this.sparse[key] !== undefined
+  }
+
+  get(key: number): number | undefined {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      return this.denseValues.internalTypedArray[index]
+    } else {
+      return undefined
+    }
+  }
+
+  set(key: number, value: number): void {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      this.denseValues.internalTypedArray[index] = value
+    } else {
+      const index = this.denseKeys.length
+      this.denseKeys.push(key)
+      this.denseValues.push(value)
+      this.sparse[key] = index
+    }
+  }
+
+  delete(key: number): boolean {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      this.sparse[key] = undefined
+
+      const lastKey = this.denseKeys.pop()!
+      const lastValue = this.denseValues.pop()!
+      if (key !== lastKey) {
+        this.denseKeys.internalTypedArray[index] = lastKey
+        this.denseValues.internalTypedArray[index] = lastValue
+        this.sparse[lastKey] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.denseKeys.clear()
+    this.denseValues.clear()
+    this.sparse.length = 0
+  }
+}