min-heap-typed 1.49.4 → 1.49.5

package/dist/data-structures/base/iterable-base.d.ts

@@ -1,4 +1,4 @@
-import { ElementCallback, EntryCallback, ReduceElementCallback, ReduceEntryCallback } from "../../types";
+import { ElementCallback, EntryCallback, ReduceElementCallback, ReduceEntryCallback } from '../../types';
 export declare abstract class IterableEntryBase<K = any, V = any> {
     /**
      * Time Complexity: O(n)

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -8,7 +8,7 @@
 import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNCallback, BTNEntry, BTNExemplar, BTNKeyOrNode, DFSOrderPattern, EntryCallback, NodeDisplayLayout } from '../../types';
 import { FamilyPosition, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
-import { IterableEntryBase } from "../base";
+import { IterableEntryBase } from '../base';
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
@@ -542,18 +542,6 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * @returns The method is returning the newNode.
      */
     protected _replaceNode(oldNode: N, newNode: N): N;
-    /**
-     * The function `_addTo` adds a new node to a binary tree if there is an available position.
-     * @param {N | null | undefined} newNode - The `newNode` parameter represents the node that you want to add to
-     * the binary tree. It can be either a node object or `null`.
-     * @param {N} parent - The `parent` parameter represents the parent node to which the new node will
-     * be added as a child.
-     * @returns either the left or right child node of the parent node, depending on which child is
-     * available for adding the new node. If a new node is added, the function also updates the size of
-     * the binary tree. If neither the left nor right child is available, the function returns undefined.
-     * If the parent node is null, the function also returns undefined.
-     */
-    protected _addTo(newNode: N | null | undefined, parent: BTNKeyOrNode<K, N>): N | null | undefined;
     /**
      * The function sets the root property of an object to a given value, and if the value is not null,
      * it also sets the parent property of the value to undefined.

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

@@ -80,7 +80,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         super();
         this.iterationType = types_1.IterationType.ITERATIVE;
         this._extractor = (key) => Number(key);
-        this._defaultOneParamCallback = (node) => node ? node.key : undefined;
+        this._defaultOneParamCallback = (node) => (node ? node.key : undefined);
         if (options) {
             const { iterationType, extractor } = options;
             if (iterationType) {
@@ -1594,21 +1594,30 @@ class BinaryTree extends base_1.IterableEntryBase {
         function _buildNodeDisplay(line, width, left, right) {
             const [leftLines, leftWidth, leftHeight, leftMiddle] = left;
             const [rightLines, rightWidth, rightHeight, rightMiddle] = right;
-            const firstLine = ' '.repeat(Math.max(0, leftMiddle + 1))
-                + '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1))
-                + line
-                + '_'.repeat(Math.max(0, rightMiddle))
-                + ' '.repeat(Math.max(0, rightWidth - rightMiddle));
-            const secondLine = (leftHeight > 0 ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1) : ' '.repeat(leftWidth))
-                + ' '.repeat(width)
-                + (rightHeight > 0 ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1) : ' '.repeat(rightWidth));
+            const firstLine = ' '.repeat(Math.max(0, leftMiddle + 1)) +
+                '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1)) +
+                line +
+                '_'.repeat(Math.max(0, rightMiddle)) +
+                ' '.repeat(Math.max(0, rightWidth - rightMiddle));
+            const secondLine = (leftHeight > 0
+                ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1)
+                : ' '.repeat(leftWidth)) +
+                ' '.repeat(width) +
+                (rightHeight > 0
+                    ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1)
+                    : ' '.repeat(rightWidth));
             const mergedLines = [firstLine, secondLine];
             for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
                 const leftLine = i < leftHeight ? leftLines[i] : ' '.repeat(leftWidth);
                 const rightLine = i < rightHeight ? rightLines[i] : ' '.repeat(rightWidth);
                 mergedLines.push(leftLine + ' '.repeat(width) + rightLine);
             }
-            return [mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
+            return [
+                mergedLines,
+                leftWidth + width + rightWidth,
+                Math.max(leftHeight, rightHeight) + 2,
+                leftWidth + Math.floor(width / 2)
+            ];
         }
     }
     /**
@@ -1658,45 +1667,6 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         return newNode;
     }
-    /**
-     * The function `_addTo` adds a new node to a binary tree if there is an available position.
-     * @param {N | null | undefined} newNode - The `newNode` parameter represents the node that you want to add to
-     * the binary tree. It can be either a node object or `null`.
-     * @param {N} parent - The `parent` parameter represents the parent node to which the new node will
-     * be added as a child.
-     * @returns either the left or right child node of the parent node, depending on which child is
-     * available for adding the new node. If a new node is added, the function also updates the size of
-     * the binary tree. If neither the left nor right child is available, the function returns undefined.
-     * If the parent node is null, the function also returns undefined.
-     */
-    _addTo(newNode, parent) {
-        if (this.isNotNodeInstance(parent))
-            parent = this.getNode(parent);
-        if (parent) {
-            // When all leaf nodes are null, it will no longer be possible to add new entity nodes to this binary tree.
-            // In this scenario, null nodes serve as "sentinel nodes," "virtual nodes," or "placeholder nodes."
-            if (parent.left === undefined) {
-                parent.left = newNode;
-                if (newNode) {
-                    this._size = this.size + 1;
-                }
-                return parent.left;
-            }
-            else if (parent.right === undefined) {
-                parent.right = newNode;
-                if (newNode) {
-                    this._size = this.size + 1;
-                }
-                return parent.right;
-            }
-            else {
-                return;
-            }
-        }
-        else {
-            return;
-        }
-    }
     /**
      * The function sets the root property of an object to a given value, and if the value is not null,
      * it also sets the parent property of the value to undefined.

package/dist/data-structures/binary-tree/tree-multimap.d.ts

@@ -163,22 +163,6 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
     clone(): TREE;
-    /**
-     * 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.
-     */
-    protected _addTo(newNode: N | undefined, parent: BSTNKeyOrNode<K, N>): N | undefined;
     /**
      * 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/data-structures/binary-tree/tree-multimap.js

@@ -33,7 +33,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     // 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;
     }
     /**
@@ -312,48 +312,6 @@ class TreeMultimap extends avl_tree_1.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/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/data-structures/graph/abstract-graph.js

@@ -95,7 +95,7 @@ class AbstractGraph extends base_1.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.
@@ -1015,7 +1015,8 @@ class AbstractGraph extends base_1.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/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/data-structures/hash/hash-map.js

@@ -219,11 +219,11 @@ class HashMap extends base_1.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/data-structures/heap/heap.js

@@ -401,11 +401,10 @@ class Heap extends base_1.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/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/data-structures/matrix/index.d.ts

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

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

@@ -15,6 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./matrix"), exports);
-__exportStar(require("./vector2d"), exports);
-__exportStar(require("./matrix2d"), exports);
 __exportStar(require("./navigator"), exports);

package/dist/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;
 }