data-structure-typed 1.49.4 → 1.49.6

package/dist/mjs/data-structures/binary-tree/tree-multimap.js

@@ -21,16 +21,16 @@ export class TreeMultimapNode extends AVLTreeNode {
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export class TreeMultimap extends AVLTree {
-    constructor(elements, options) {
+    constructor(nodes, options) {
         super([], options);
-        if (elements)
-            this.addMany(elements);
+        if (nodes)
+            this.addMany(nodes);
     }
     _count = 0;
     // TODO the _count is not accurate after nodes count modified
     get count() {
         let sum = 0;
-        this.subTreeTraverse(node => sum += node.count);
+        this.subTreeTraverse(node => (sum += node.count));
         return sum;
     }
     /**
@@ -48,30 +48,13 @@ export class TreeMultimap extends AVLTree {
     createTree(options) {
         return new TreeMultimap([], {
             iterationType: this.iterationType,
-            variant: this.variant, ...options
+            variant: this.variant,
+            ...options
         });
     }
     /**
-     * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
-     * class.
-     */
-    isNode(exemplar) {
-        return exemplar instanceof TreeMultimapNode;
-    }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof TreeMultimapNode);
-    }
-    /**
-     * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
+     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -80,16 +63,16 @@ export class TreeMultimap extends AVLTree {
      * times the value should be added to the node. If not provided, it defaults to 1.
      * @returns a node of type `N` or `undefined`.
      */
-    exemplarToNode(exemplar, value, count = 1) {
+    exemplarToNode(keyOrNodeOrEntry, value, count = 1) {
         let node;
-        if (exemplar === undefined || exemplar === null) {
+        if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
             return;
         }
-        else if (this.isNode(exemplar)) {
-            node = exemplar;
+        else if (this.isNode(keyOrNodeOrEntry)) {
+            node = keyOrNodeOrEntry;
         }
-        else if (this.isEntry(exemplar)) {
-            const [key, value] = exemplar;
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            const [key, value] = keyOrNodeOrEntry;
             if (key === undefined || key === null) {
                 return;
             }
@@ -97,8 +80,8 @@ export class TreeMultimap extends AVLTree {
                 node = this.createNode(key, value, count);
             }
         }
-        else if (this.isNotNodeInstance(exemplar)) {
-            node = this.createNode(exemplar, value, count);
+        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+            node = this.createNode(keyOrNodeOrEntry, value, count);
         }
         else {
             return;
@@ -106,12 +89,31 @@ export class TreeMultimap extends AVLTree {
         return node;
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+     * class.
+     */
+    isNode(keyOrNodeOrEntry) {
+        return keyOrNodeOrEntry instanceof TreeMultimapNode;
+    }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof TreeMultimapNode);
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the add method of a binary tree node and adds a new node to the tree.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
@@ -128,21 +130,22 @@ export class TreeMultimap extends AVLTree {
     add(keyOrNodeOrEntry, value, count = 1) {
         const newNode = this.exemplarToNode(keyOrNodeOrEntry, value, count);
         if (newNode === undefined)
-            return;
+            return false;
         const orgNodeCount = newNode?.count || 0;
         const inserted = super.add(newNode);
         if (inserted) {
             this._count += orgNodeCount;
         }
-        return inserted;
+        return true;
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
      * structure.
@@ -154,12 +157,13 @@ export class TreeMultimap extends AVLTree {
         return super.addMany(keysOrNodesOrEntries);
     }
     /**
-     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node. linear space, as it creates an array to store the sorted nodes.
      */
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
      * tree using either a recursive or iterative approach.
@@ -205,12 +209,13 @@ export class TreeMultimap extends AVLTree {
         }
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
      * account the count of the node and balancing the tree if necessary.
@@ -285,10 +290,13 @@ export class TreeMultimap extends AVLTree {
         return deletedResult;
     }
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear() {
@@ -311,48 +319,6 @@ export class TreeMultimap extends AVLTree {
         this.bfs(node => cloned.add(node.key, node.value, node.count));
         return cloned;
     }
-    /**
-     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
-     *
-     * The function adds a new node to a binary tree, either as the left child or the right child of a
-     * given parent node.
-     * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
-     * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
-     * `undefined` if there is no node to add.
-     * @param {K | N | undefined} parent - The `parent` parameter represents the parent node to
-     * which the new node will be added as a child. It can be either a node object (`N`) or a key value
-     * (`K`).
-     * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
-     * added, or `undefined` if no node was added.
-     */
-    _addTo(newNode, parent) {
-        parent = this.ensureNode(parent);
-        if (parent) {
-            if (parent.left === undefined) {
-                parent.left = newNode;
-                if (newNode !== undefined) {
-                    this._size = this.size + 1;
-                    this._count += newNode.count;
-                }
-                return parent.left;
-            }
-            else if (parent.right === undefined) {
-                parent.right = newNode;
-                if (newNode !== undefined) {
-                    this._size = this.size + 1;
-                    this._count += newNode.count;
-                }
-                return parent.right;
-            }
-            else {
-                return;
-            }
-        }
-        else {
-            return;
-        }
-    }
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
      * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from

package/dist/mjs/data-structures/graph/abstract-graph.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { DijkstraResult, EntryCallback, VertexKey } from '../../types';
-import { IterableEntryBase } from "../base";
+import { IterableEntryBase } from '../base';
 import { IGraph } from '../../interfaces';
 export declare abstract class AbstractVertex<V = any> {
     key: VertexKey;

package/dist/mjs/data-structures/graph/abstract-graph.js

@@ -1,5 +1,5 @@
 import { uuidV4 } from '../../utils';
-import { IterableEntryBase } from "../base";
+import { IterableEntryBase } from '../base';
 import { Heap } from '../heap';
 import { Queue } from '../queue';
 export class AbstractVertex {
@@ -95,7 +95,7 @@ export class AbstractGraph extends IterableEntryBase {
     }
     isVertexKey(potentialKey) {
         const potentialKeyType = typeof potentialKey;
-        return potentialKeyType === "string" || potentialKeyType === "number";
+        return potentialKeyType === 'string' || potentialKeyType === 'number';
     }
     /**
      * Time Complexity: O(K), where K is the number of vertexMap to be removed.
@@ -1010,7 +1010,8 @@ export class AbstractGraph extends IterableEntryBase {
         const visited = new Set();
         const dfs = (vertex, currentPath, visited) => {
             if (visited.has(vertex)) {
-                if ((!isInclude2Cycle && currentPath.length > 2 || isInclude2Cycle && currentPath.length >= 2) && currentPath[0] === vertex.key) {
+                if (((!isInclude2Cycle && currentPath.length > 2) || (isInclude2Cycle && currentPath.length >= 2)) &&
+                    currentPath[0] === vertex.key) {
                     cycles.push([...currentPath]);
                 }
                 return;

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

@@ -121,7 +121,7 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
      */
     protected _getIterator(): IterableIterator<[K, V]>;
     protected _hashFn: (key: K) => string;
-    protected _isObjKey(key: any): key is (object | ((...args: any[]) => any));
+    protected _isObjKey(key: any): key is object | ((...args: any[]) => any);
     protected _getNoObjKey(key: K): string;
 }
 /**

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

@@ -215,11 +215,11 @@ export class HashMap extends IterableEntryBase {
     _getNoObjKey(key) {
         const keyType = typeof key;
         let strKey;
-        if (keyType !== "string" && keyType !== "number" && keyType !== "symbol") {
+        if (keyType !== 'string' && keyType !== 'number' && keyType !== 'symbol') {
             strKey = this._hashFn(key);
         }
         else {
-            if (keyType === "number") {
+            if (keyType === 'number') {
                 // TODO numeric key should has its own hash
                 strKey = key;
             }

package/dist/mjs/data-structures/heap/heap.js

@@ -398,11 +398,10 @@ export class Heap extends IterableElementBase {
     _sinkDown(index, halfLength) {
         const element = this.elements[index];
         while (index < halfLength) {
-            let left = index << 1 | 1;
+            let left = (index << 1) | 1;
             const right = left + 1;
             let minItem = this.elements[left];
-            if (right < this.elements.length &&
-                this.options.comparator(minItem, this.elements[right]) > 0) {
+            if (right < this.elements.length && this.options.comparator(minItem, this.elements[right]) > 0) {
                 left = right;
                 minItem = this.elements[right];
             }

package/dist/mjs/data-structures/linked-list/singly-linked-list.d.ts

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback } from "../../types";
-import { IterableElementBase } from "../base";
+import type { ElementCallback } from '../../types';
+import { IterableElementBase } from '../base';
 export declare class SinglyLinkedListNode<E = any> {
     value: E;
     next: SinglyLinkedListNode<E> | undefined;

package/dist/mjs/data-structures/linked-list/singly-linked-list.js

@@ -1,4 +1,4 @@
-import { IterableElementBase } from "../base";
+import { IterableElementBase } from '../base';
 export class SinglyLinkedListNode {
     value;
     next;

package/dist/mjs/data-structures/matrix/index.d.ts

@@ -1,4 +1,2 @@
 export * from './matrix';
-export * from './vector2d';
-export * from './matrix2d';
 export * from './navigator';

package/dist/mjs/data-structures/matrix/index.js

@@ -1,4 +1,2 @@
 export * from './matrix';
-export * from './vector2d';
-export * from './matrix2d';
 export * from './navigator';

package/dist/mjs/data-structures/matrix/matrix.d.ts

@@ -5,17 +5,135 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export declare class MatrixNTI2D<V = any> {
-    protected readonly _matrix: Array<Array<V>>;
+export declare class Matrix {
     /**
-     * The constructor creates a matrix with the specified number of rows and columns, and initializes all elements to a
-     * given initial value or 0 if not provided.
-     * @param options - An object containing the following properties:
+     * The constructor function initializes a matrix object with the provided data and options, or with
+     * default values if no options are provided.
+     * @param {number[][]} data - A 2D array of numbers representing the data for the matrix.
+     * @param [options] - The `options` parameter is an optional object that can contain the following
+     * properties:
      */
-    constructor(options: {
-        row: number;
-        col: number;
-        initialVal?: V;
+    constructor(data: number[][], options?: {
+        rows?: number;
+        cols?: number;
+        addFn?: (a: number, b: number) => any;
+        subtractFn?: (a: number, b: number) => any;
+        multiplyFn?: (a: number, b: number) => any;
     });
-    toArray(): Array<Array<V>>;
+    protected _rows: number;
+    get rows(): number;
+    protected _cols: number;
+    get cols(): number;
+    protected _data: number[][];
+    get data(): number[][];
+    get addFn(): (a: number | undefined, b: number) => number | undefined;
+    get subtractFn(): (a: number, b: number) => number;
+    get multiplyFn(): (a: number, b: number) => number;
+    /**
+     * The `get` function returns the value at the specified row and column index if it is a valid index.
+     * @param {number} row - The `row` parameter represents the row index of the element you want to
+     * retrieve from the data array.
+     * @param {number} col - The parameter "col" represents the column number of the element you want to
+     * retrieve from the data array.
+     * @returns The `get` function returns a number if the provided row and column indices are valid.
+     * Otherwise, it returns `undefined`.
+     */
+    get(row: number, col: number): number | undefined;
+    /**
+     * The set function updates the value at a specified row and column in a two-dimensional array.
+     * @param {number} row - The "row" parameter represents the row index of the element in a
+     * two-dimensional array or matrix. It specifies the row where the value will be set.
+     * @param {number} col - The "col" parameter represents the column index of the element in a
+     * two-dimensional array.
+     * @param {number} value - The value parameter represents the number that you want to set at the
+     * specified row and column in the data array.
+     * @returns a boolean value. It returns true if the index (row, col) is valid and the value is
+     * successfully set in the data array. It returns false if the index is invalid and the value is not
+     * set.
+     */
+    set(row: number, col: number, value: number): boolean;
+    /**
+     * The function checks if the dimensions of the given matrix match the dimensions of the current
+     * matrix.
+     * @param {Matrix} matrix - The parameter `matrix` is of type `Matrix`.
+     * @returns a boolean value.
+     */
+    isMatchForCalculate(matrix: Matrix): boolean;
+    /**
+     * The `add` function adds two matrices together, returning a new matrix with the result.
+     * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class.
+     * @returns The `add` method returns a new `Matrix` object that represents the result of adding the
+     * current matrix with the provided `matrix` parameter.
+     */
+    add(matrix: Matrix): Matrix | undefined;
+    /**
+     * The `subtract` function performs element-wise subtraction between two matrices and returns a new
+     * matrix with the result.
+     * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class. It
+     * represents the matrix that you want to subtract from the current matrix.
+     * @returns a new Matrix object with the result of the subtraction operation.
+     */
+    subtract(matrix: Matrix): Matrix | undefined;
+    /**
+     * The `multiply` function performs matrix multiplication between two matrices and returns the result
+     * as a new matrix.
+     * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class.
+     * @returns a new Matrix object.
+     */
+    multiply(matrix: Matrix): Matrix | undefined;
+    /**
+     * The transpose function takes a matrix and returns a new matrix that is the transpose of the
+     * original matrix.
+     * @returns The transpose() function returns a new Matrix object with the transposed data.
+     */
+    transpose(): Matrix;
+    /**
+     * The `inverse` function calculates the inverse of a square matrix using Gaussian elimination.
+     * @returns a Matrix object, which represents the inverse of the original matrix.
+     */
+    inverse(): Matrix | undefined;
+    /**
+     * The dot function calculates the dot product of two matrices and returns a new matrix.
+     * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class.
+     * @returns a new Matrix object.
+     */
+    dot(matrix: Matrix): Matrix | undefined;
+    protected _addFn(a: number | undefined, b: number): number | undefined;
+    protected _subtractFn(a: number, b: number): number;
+    protected _multiplyFn(a: number, b: number): number;
+    /**
+     * The function checks if a given row and column index is valid within a specified range.
+     * @param {number} row - The `row` parameter represents the row index of a two-dimensional array or
+     * matrix. It is a number that indicates the specific row in the matrix.
+     * @param {number} col - The "col" parameter represents the column index in a two-dimensional array
+     * or grid. It is used to check if the given column index is valid within the bounds of the grid.
+     * @returns A boolean value is being returned.
+     */
+    protected isValidIndex(row: number, col: number): boolean;
+    /**
+     * The function `_swapRows` swaps the positions of two rows in an array.
+     * @param {number} row1 - The `row1` parameter is the index of the first row that you want to swap.
+     * @param {number} row2 - The `row2` parameter is the index of the second row that you want to swap
+     * with the first row.
+     */
+    protected _swapRows(row1: number, row2: number): void;
+    /**
+     * The function scales a specific row in a matrix by a given scalar value.
+     * @param {number} row - The `row` parameter represents the index of the row in the matrix that you
+     * want to scale. It is a number that indicates the position of the row within the matrix.
+     * @param {number} scalar - The scalar parameter is a number that is used to multiply each element in
+     * a specific row of a matrix.
+     */
+    protected _scaleRow(row: number, scalar: number): void;
+    /**
+     * The function `_addScaledRow` multiplies a row in a matrix by a scalar value and adds it to another
+     * row.
+     * @param {number} targetRow - The targetRow parameter represents the index of the row in which the
+     * scaled values will be added.
+     * @param {number} sourceRow - The sourceRow parameter represents the index of the row from which the
+     * values will be scaled and added to the targetRow.
+     * @param {number} scalar - The scalar parameter is a number that is used to scale the values in the
+     * source row before adding them to the target row.
+     */
+    protected _addScaledRow(targetRow: number, sourceRow: number, scalar: number): void;
 }