data-structure-typed 1.40.0-rc → 1.41.0

package/dist/cjs/data-structures/hash/coordinate-map.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoordinateMap = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+class CoordinateMap extends Map {
+    constructor(joint) {
+        super();
+        this._joint = '_';
+        if (joint !== undefined)
+            this._joint = joint;
+    }
+    get joint() {
+        return this._joint;
+    }
+    /**
+     * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
+     * key array with a specified delimiter.
+     * @param {number[]} key - The parameter "key" is an array of numbers.
+     * @returns The `has` method is being overridden to return the result of calling the `has` method of the superclass
+     * (`super.has`) with the `key` array joined together using the `_joint` property.
+     */
+    has(key) {
+        return super.has(key.join(this._joint));
+    }
+    /**
+     * The function overrides the set method of a Map object to convert the key from an array to a string using a specified
+     * delimiter before calling the original set method.
+     * @param {number[]} key - The key parameter is an array of numbers.
+     * @param {V} value - The value parameter is the value that you want to associate with the specified key.
+     * @returns The `set` method is returning the result of calling the `set` method of the superclass
+     * (`super.set(key.join(this._joint), value)`).
+     */
+    set(key, value) {
+        return super.set(key.join(this._joint), value);
+    }
+    /**
+     * The function overrides the get method to join the key array with a specified joint and then calls the super get
+     * method.
+     * @param {number[]} key - An array of numbers
+     * @returns The code is returning the value associated with the specified key in the map.
+     */
+    get(key) {
+        return super.get(key.join(this._joint));
+    }
+    /**
+     * The function overrides the delete method and joins the key array using a specified joint character before calling
+     * the super delete method.
+     * @param {number[]} key - An array of numbers that represents the key to be deleted.
+     * @returns The `delete` method is returning the result of calling the `delete` method on the superclass, with the
+     * `key` array joined together using the `_joint` property.
+     */
+    delete(key) {
+        return super.delete(key.join(this._joint));
+    }
+}
+exports.CoordinateMap = CoordinateMap;
+//# sourceMappingURL=coordinate-map.js.map

package/dist/cjs/data-structures/hash/coordinate-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinate-map.js","sourceRoot":"","sources":["../../../../src/data-structures/hash/coordinate-map.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACH,MAAa,aAAiB,SAAQ,GAAW;IAC/C,YAAY,KAAc;QACxB,KAAK,EAAE,CAAC;QAIA,WAAM,GAAG,GAAG,CAAC;QAHrB,IAAI,KAAK,KAAK,SAAS;YAAE,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IAC/C,CAAC;IAID,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;;;OAMG;IACM,GAAG,CAAC,GAAa;QACxB,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;OAOG;IACM,GAAG,CAAC,GAAa,EAAE,KAAQ;QAClC,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;IACjD,CAAC;IAED;;;;;OAKG;IACM,GAAG,CAAC,GAAa;QACxB,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;OAMG;IACM,MAAM,CAAC,GAAa;QAC3B,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC7C,CAAC;CACF;AAvDD,sCAuDC"}

package/dist/cjs/data-structures/hash/coordinate-set.d.ts

@@ -0,0 +1,36 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export declare class CoordinateSet extends Set<any> {
+    constructor(joint?: string);
+    protected _joint: string;
+    get joint(): string;
+    /**
+     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
+     * joining its elements with a specified separator.
+     * @param {number[]} value - The parameter "value" is an array of numbers.
+     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
+     * in the joined value as an argument.
+     */
+    has(value: number[]): boolean;
+    /**
+     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
+     * specified delimiter before calling the parent class's "add" function.
+     * @param {number[]} value - An array of numbers
+     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
+     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
+     */
+    add(value: number[]): this;
+    /**
+     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
+     * array with a specified joint and then calling the delete method of the parent class.
+     * @param {number[]} value - An array of numbers
+     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
+     * `value` array joined together using the `_joint` property.
+     */
+    delete(value: number[]): boolean;
+}

package/dist/cjs/data-structures/hash/coordinate-set.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoordinateSet = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+class CoordinateSet extends Set {
+    constructor(joint) {
+        super();
+        this._joint = '_';
+        if (joint !== undefined)
+            this._joint = joint;
+    }
+    get joint() {
+        return this._joint;
+    }
+    /**
+     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
+     * joining its elements with a specified separator.
+     * @param {number[]} value - The parameter "value" is an array of numbers.
+     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
+     * in the joined value as an argument.
+     */
+    has(value) {
+        return super.has(value.join(this._joint));
+    }
+    /**
+     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
+     * specified delimiter before calling the parent class's "add" function.
+     * @param {number[]} value - An array of numbers
+     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
+     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
+     */
+    add(value) {
+        return super.add(value.join(this._joint));
+    }
+    /**
+     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
+     * array with a specified joint and then calling the delete method of the parent class.
+     * @param {number[]} value - An array of numbers
+     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
+     * `value` array joined together using the `_joint` property.
+     */
+    delete(value) {
+        return super.delete(value.join(this._joint));
+    }
+}
+exports.CoordinateSet = CoordinateSet;
+//# sourceMappingURL=coordinate-set.js.map

package/dist/cjs/data-structures/hash/coordinate-set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinate-set.js","sourceRoot":"","sources":["../../../../src/data-structures/hash/coordinate-set.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACH,MAAa,aAAc,SAAQ,GAAQ;IACzC,YAAY,KAAc;QACxB,KAAK,EAAE,CAAC;QAIA,WAAM,GAAG,GAAG,CAAC;QAHrB,IAAI,KAAK,KAAK,SAAS;YAAE,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IAC/C,CAAC;IAID,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;;;OAMG;IACM,GAAG,CAAC,KAAe;QAC1B,OAAO,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;OAMG;IACM,GAAG,CAAC,KAAe;QAC1B,OAAO,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;OAMG;IACM,MAAM,CAAC,KAAe;QAC7B,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/C,CAAC;CACF;AA5CD,sCA4CC"}

package/dist/cjs/data-structures/hash/hash-map.d.ts

@@ -0,0 +1,50 @@
+import { HashFunction } from '../../types';
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export declare class HashMap<K, V> {
+    /**
+     * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
+     * multiplier, size, table array, and hash function.
+     * @param [initialCapacity=16] - The initial capacity is the initial size of the hash table. It determines the number of
+     * buckets or slots available for storing key-value pairs. The default value is 16.
+     * @param [loadFactor=0.75] - The load factor is a measure of how full the hash table can be before it is resized. It is
+     * a value between 0 and 1, where 1 means the hash table is completely full and 0 means it is completely empty. When the
+     * load factor is reached, the hash table will
+     * @param [hashFn] - The `hashFn` parameter is an optional parameter that represents the hash function used to calculate
+     * the index of a key in the hash table. If a custom hash function is not provided, a default hash function is used. The
+     * default hash function converts the key to a string, calculates the sum of the
+     */
+    constructor(initialCapacity?: number, loadFactor?: number, hashFn?: HashFunction<K>);
+    protected _initialCapacity: number;
+    get initialCapacity(): number;
+    protected _loadFactor: number;
+    get loadFactor(): number;
+    protected _capacityMultiplier: number;
+    get capacityMultiplier(): number;
+    protected _size: number;
+    get size(): number;
+    protected _table: Array<Array<[K, V]>>;
+    get table(): Array<Array<[K, V]>>;
+    protected _hashFn: HashFunction<K>;
+    get hashFn(): HashFunction<K>;
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    delete(key: K): void;
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    clear(): void;
+    isEmpty(): boolean;
+    protected _hash(key: K): number;
+    /**
+     * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
+     * rehashing the key-value pairs from the old table into the new table.
+     * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
+     * the number of buckets that the new table should have.
+     */
+    protected resizeTable(newCapacity: number): void;
+}

package/dist/cjs/data-structures/hash/hash-map.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashMap = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+class HashMap {
+    /**
+     * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
+     * multiplier, size, table array, and hash function.
+     * @param [initialCapacity=16] - The initial capacity is the initial size of the hash table. It determines the number of
+     * buckets or slots available for storing key-value pairs. The default value is 16.
+     * @param [loadFactor=0.75] - The load factor is a measure of how full the hash table can be before it is resized. It is
+     * a value between 0 and 1, where 1 means the hash table is completely full and 0 means it is completely empty. When the
+     * load factor is reached, the hash table will
+     * @param [hashFn] - The `hashFn` parameter is an optional parameter that represents the hash function used to calculate
+     * the index of a key in the hash table. If a custom hash function is not provided, a default hash function is used. The
+     * default hash function converts the key to a string, calculates the sum of the
+     */
+    constructor(initialCapacity = 16, loadFactor = 0.75, hashFn) {
+        this._initialCapacity = initialCapacity;
+        this._loadFactor = loadFactor;
+        this._capacityMultiplier = 2;
+        this._size = 0;
+        this._table = new Array(initialCapacity);
+        this._hashFn =
+            hashFn ||
+                ((key) => {
+                    const strKey = String(key);
+                    let hash = 0;
+                    for (let i = 0; i < strKey.length; i++) {
+                        hash += strKey.charCodeAt(i);
+                    }
+                    return hash % this.table.length;
+                });
+    }
+    get initialCapacity() {
+        return this._initialCapacity;
+    }
+    get loadFactor() {
+        return this._loadFactor;
+    }
+    get capacityMultiplier() {
+        return this._capacityMultiplier;
+    }
+    get size() {
+        return this._size;
+    }
+    get table() {
+        return this._table;
+    }
+    get hashFn() {
+        return this._hashFn;
+    }
+    set(key, value) {
+        const loadFactor = this.size / this.table.length;
+        if (loadFactor >= this.loadFactor) {
+            this.resizeTable(this.table.length * this.capacityMultiplier);
+        }
+        const index = this._hash(key);
+        if (!this.table[index]) {
+            this.table[index] = [];
+        }
+        // Check if the key already exists in the bucket
+        for (let i = 0; i < this.table[index].length; i++) {
+            if (this.table[index][i][0] === key) {
+                this.table[index][i][1] = value;
+                return;
+            }
+        }
+        this.table[index].push([key, value]);
+        this._size++;
+    }
+    get(key) {
+        const index = this._hash(key);
+        if (!this.table[index]) {
+            return undefined;
+        }
+        for (const [k, v] of this.table[index]) {
+            if (k === key) {
+                return v;
+            }
+        }
+        return undefined;
+    }
+    delete(key) {
+        const index = this._hash(key);
+        if (!this.table[index]) {
+            return;
+        }
+        for (let i = 0; i < this.table[index].length; i++) {
+            if (this.table[index][i][0] === key) {
+                this.table[index].splice(i, 1);
+                this._size--;
+                // Check if the table needs to be resized down
+                const loadFactor = this.size / this.table.length;
+                if (loadFactor < this.loadFactor / this.capacityMultiplier) {
+                    this.resizeTable(this.table.length / this.capacityMultiplier);
+                }
+                return;
+            }
+        }
+    }
+    *entries() {
+        for (const bucket of this.table) {
+            if (bucket) {
+                for (const [key, value] of bucket) {
+                    yield [key, value];
+                }
+            }
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    clear() {
+        this._size = 0;
+        this._table = new Array(this.initialCapacity);
+    }
+    isEmpty() {
+        return this.size === 0;
+    }
+    _hash(key) {
+        return this._hashFn(key);
+    }
+    /**
+     * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
+     * rehashing the key-value pairs from the old table into the new table.
+     * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
+     * the number of buckets that the new table should have.
+     */
+    resizeTable(newCapacity) {
+        const newTable = new Array(newCapacity);
+        for (const bucket of this._table) {
+            // Note that this is this._table
+            if (bucket) {
+                for (const [key, value] of bucket) {
+                    const newIndex = this._hash(key) % newCapacity;
+                    if (!newTable[newIndex]) {
+                        newTable[newIndex] = [];
+                    }
+                    newTable[newIndex].push([key, value]);
+                }
+            }
+        }
+        this._table = newTable; // Again, here is this._table
+    }
+}
+exports.HashMap = HashMap;
+//# sourceMappingURL=hash-map.js.map

package/dist/cjs/data-structures/hash/hash-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-map.js","sourceRoot":"","sources":["../../../../src/data-structures/hash/hash-map.ts"],"names":[],"mappings":"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"}

package/dist/cjs/data-structures/hash/hash-table.d.ts

@@ -0,0 +1,103 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export declare class HashTableNode<K, V> {
+    key: K;
+    value: V;
+    next: HashTableNode<K, V> | null;
+    constructor(key: K, value: V);
+}
+import { HashFunction } from '../../types';
+export declare class HashTable<K, V> {
+    protected static readonly DEFAULT_CAPACITY = 16;
+    protected static readonly LOAD_FACTOR = 0.75;
+    constructor(capacity?: number, hashFn?: HashFunction<K>);
+    protected _capacity: number;
+    get capacity(): number;
+    protected _size: number;
+    get size(): number;
+    protected _buckets: Array<HashTableNode<K, V> | null>;
+    get buckets(): Array<HashTableNode<K, V> | null>;
+    protected _hashFn: HashFunction<K>;
+    get hashFn(): HashFunction<K>;
+    /**
+     * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
+     * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
+     * table. It is of type K, which is a generic type representing the key's data type.
+     * @param {V} value - The parameter `value` represents the value that you want to associate with the given key in the hash
+     * table.
+     * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
+     * value.
+     */
+    set(key: K, value: V): void;
+    /**
+     * The `get` function retrieves the value associated with a given key from a hash table.
+     * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data
+     * structure.
+     * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
+     * not found, it returns `undefined`.
+     */
+    get(key: K): V | undefined;
+    /**
+     * The delete function removes a key-value pair from a hash table.
+     * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
+     * table.
+     * @returns Nothing is being returned. The `delete` method has a return type of `void`, which means it does not return
+     * any value.
+     */
+    delete(key: K): void;
+    /**
+     * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
+     * capacity of the data structure.
+     * @param {K} key - The `key` parameter is the input value that needs to be hashed. It can be of any type, but in this
+     * code snippet, it is checked whether the key is a string or an object. If it is a string, the `_murmurStringHashFn`
+     * function is used to
+     * @returns the hash value of the key modulo the capacity of the data structure.
+     */
+    protected _defaultHashFn(key: K): number;
+    /**
+     * The `_multiplicativeStringHashFn` function calculates a hash value for a given string key using the multiplicative
+     * string hash function.
+     * @param {K} key - The `key` parameter is the input value for which we want to calculate the hash. It can be of any
+     * type, as it is generic (`K`). The function converts the `key` to a string using the `String()` function.
+     * @returns a number, which is the result of the multiplicative string hash function applied to the input key.
+     */
+    protected _multiplicativeStringHashFn<K>(key: K): number;
+    /**
+     * The function `_murmurStringHashFn` calculates a hash value for a given string key using the MurmurHash algorithm.
+     * @param {K} key - The `key` parameter is the input value for which you want to calculate the hash. It can be of any
+     * type, but it will be converted to a string using the `String()` function before calculating the hash.
+     * @returns a number, which is the hash value calculated for the given key.
+     */
+    protected _murmurStringHashFn<K>(key: K): number;
+    /**
+     * The _hash function takes a key and returns a number.
+     * @param {K} key - The parameter "key" is of type K, which represents the type of the key that will be hashed.
+     * @returns The hash function is returning a number.
+     */
+    protected _hash(key: K): number;
+    /**
+     * The function calculates a hash value for a given string using the djb2 algorithm.
+     * @param {string} key - The `key` parameter in the `stringHash` function is a string value that represents the input for
+     * which we want to calculate the hash value.
+     * @returns a number, which is the hash value of the input string.
+     */
+    protected _stringHash(key: string): number;
+    /**
+     * The function `_objectHash` takes a key and returns a hash value, using a custom hash function for objects.
+     * @param {K} key - The parameter "key" is of type "K", which means it can be any type. It could be a string, number,
+     * boolean, object, or any other type of value. The purpose of the objectHash function is to generate a hash value for
+     * the key, which can be used for
+     * @returns a number, which is the hash value of the key.
+     */
+    protected _objectHash(key: K): number;
+    /**
+     * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
+     * capacity and rehashing all the existing key-value pairs into the new buckets.
+     */
+    protected _expand(): void;
+}