deque-typed 2.1.0 → 2.1.2

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

@@ -1,448 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Matrix = void 0;
-/**
- *
- */
-class Matrix {
-    /**
-     * 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(data, options) {
-        var _a, _b, _c;
-        this._rows = 0;
-        this._cols = 0;
-        if (options) {
-            const { rows, cols, addFn, subtractFn, multiplyFn } = options;
-            if (typeof rows === 'number' && rows > 0)
-                this._rows = rows;
-            else
-                this._rows = data.length;
-            if (typeof cols === 'number' && cols > 0)
-                this._cols = cols;
-            else
-                this._cols = ((_a = data[0]) === null || _a === void 0 ? void 0 : _a.length) || 0;
-            if (addFn)
-                this._addFn = addFn;
-            if (subtractFn)
-                this._subtractFn = subtractFn;
-            if (multiplyFn)
-                this._multiplyFn = multiplyFn;
-        }
-        else {
-            this._rows = data.length;
-            this._cols = (_c = (_b = data[0]) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
-        }
-        if (data.length > 0) {
-            this._data = data;
-        }
-        else {
-            this._data = [];
-            for (let i = 0; i < this.rows; i++) {
-                this._data[i] = new Array(this.cols).fill(0);
-            }
-        }
-    }
-    /**
-     * The function returns the number of rows.
-     * @returns The number of rows.
-     */
-    get rows() {
-        return this._rows;
-    }
-    /**
-     * The function returns the value of the protected variable _cols.
-     * @returns The number of columns.
-     */
-    get cols() {
-        return this._cols;
-    }
-    /**
-     * The function returns a two-dimensional array of numbers.
-     * @returns The data property, which is a two-dimensional array of numbers.
-     */
-    get data() {
-        return this._data;
-    }
-    /**
-     * The above function returns the value of the _addFn property.
-     * @returns The value of the property `_addFn` is being returned.
-     */
-    get addFn() {
-        return this._addFn;
-    }
-    /**
-     * The function returns the value of the _subtractFn property.
-     * @returns The `_subtractFn` property is being returned.
-     */
-    get subtractFn() {
-        return this._subtractFn;
-    }
-    /**
-     * The function returns the value of the _multiplyFn property.
-     * @returns The `_multiplyFn` property is being returned.
-     */
-    get multiplyFn() {
-        return this._multiplyFn;
-    }
-    /**
-     * 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, col) {
-        if (this.isValidIndex(row, col)) {
-            return this.data[row][col];
-        }
-    }
-    /**
-     * 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, col, value) {
-        if (this.isValidIndex(row, col)) {
-            this.data[row][col] = value;
-            return true;
-        }
-        return false;
-    }
-    /**
-     * 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) {
-        return this.rows === matrix.rows && this.cols === matrix.cols;
-    }
-    /**
-     * 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) {
-        if (!this.isMatchForCalculate(matrix)) {
-            throw new Error('Matrix dimensions must match for addition.');
-        }
-        const resultData = [];
-        for (let i = 0; i < this.rows; i++) {
-            resultData[i] = [];
-            for (let j = 0; j < this.cols; j++) {
-                const a = this.get(i, j), b = matrix.get(i, j);
-                if (a !== undefined && b !== undefined) {
-                    const added = this._addFn(a, b);
-                    if (added) {
-                        resultData[i][j] = added;
-                    }
-                }
-            }
-        }
-        return new Matrix(resultData, {
-            rows: this.rows,
-            cols: this.cols,
-            addFn: this.addFn,
-            subtractFn: this.subtractFn,
-            multiplyFn: this.multiplyFn
-        });
-    }
-    /**
-     * 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) {
-        if (!this.isMatchForCalculate(matrix)) {
-            throw new Error('Matrix dimensions must match for subtraction.');
-        }
-        const resultData = [];
-        for (let i = 0; i < this.rows; i++) {
-            resultData[i] = [];
-            for (let j = 0; j < this.cols; j++) {
-                const a = this.get(i, j), b = matrix.get(i, j);
-                if (a !== undefined && b !== undefined) {
-                    const subtracted = this._subtractFn(a, b);
-                    if (subtracted) {
-                        resultData[i][j] = subtracted;
-                    }
-                }
-            }
-        }
-        return new Matrix(resultData, {
-            rows: this.rows,
-            cols: this.cols,
-            addFn: this.addFn,
-            subtractFn: this.subtractFn,
-            multiplyFn: this.multiplyFn
-        });
-    }
-    /**
-     * 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) {
-        if (this.cols !== matrix.rows) {
-            throw new Error('Matrix dimensions must be compatible for multiplication (A.cols = B.rows).');
-        }
-        const resultData = [];
-        for (let i = 0; i < this.rows; i++) {
-            resultData[i] = [];
-            for (let j = 0; j < matrix.cols; j++) {
-                let sum;
-                for (let k = 0; k < this.cols; k++) {
-                    const a = this.get(i, k), b = matrix.get(k, j);
-                    if (a !== undefined && b !== undefined) {
-                        const multiplied = this.multiplyFn(a, b);
-                        if (multiplied !== undefined) {
-                            sum = this.addFn(sum, multiplied);
-                        }
-                    }
-                }
-                if (sum !== undefined)
-                    resultData[i][j] = sum;
-            }
-        }
-        return new Matrix(resultData, {
-            rows: this.rows,
-            cols: matrix.cols,
-            addFn: this.addFn,
-            subtractFn: this.subtractFn,
-            multiplyFn: this.multiplyFn
-        });
-    }
-    /**
-     * 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() {
-        if (this.data.some(row => row.length !== this.rows)) {
-            throw new Error('Matrix must be rectangular for transposition.');
-        }
-        const resultData = [];
-        for (let j = 0; j < this.cols; j++) {
-            resultData[j] = [];
-            for (let i = 0; i < this.rows; i++) {
-                const trans = this.get(i, j);
-                if (trans !== undefined)
-                    resultData[j][i] = trans;
-            }
-        }
-        return new Matrix(resultData, {
-            rows: this.cols,
-            cols: this.rows,
-            addFn: this.addFn,
-            subtractFn: this.subtractFn,
-            multiplyFn: this.multiplyFn
-        });
-    }
-    /**
-     * 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() {
-        var _a;
-        // Check if the matrix is square
-        if (this.rows !== this.cols) {
-            throw new Error('Matrix must be square for inversion.');
-        }
-        // Create an augmented matrix [this | I]
-        const augmentedMatrixData = [];
-        for (let i = 0; i < this.rows; i++) {
-            augmentedMatrixData[i] = this.data[i].slice(); // Copy the original matrix
-            for (let j = 0; j < this.cols; j++) {
-                augmentedMatrixData[i][this.cols + j] = i === j ? 1 : 0; // Append the identity matrix
-            }
-        }
-        const augmentedMatrix = new Matrix(augmentedMatrixData, {
-            rows: this.rows,
-            cols: this.cols * 2,
-            addFn: this.addFn,
-            subtractFn: this.subtractFn,
-            multiplyFn: this.multiplyFn
-        });
-        // Apply Gaussian elimination to transform the left half into the identity matrix
-        for (let i = 0; i < this.rows; i++) {
-            // Find pivot
-            let pivotRow = i;
-            while (pivotRow < this.rows && augmentedMatrix.get(pivotRow, i) === 0) {
-                pivotRow++;
-            }
-            if (pivotRow === this.rows) {
-                // Matrix is singular, and its inverse does not exist
-                throw new Error('Matrix is singular, and its inverse does not exist.');
-            }
-            // Swap rows to make the pivot the current row
-            augmentedMatrix._swapRows(i, pivotRow);
-            // Scale the pivot row to make the pivot element 1
-            const pivotElement = (_a = augmentedMatrix.get(i, i)) !== null && _a !== void 0 ? _a : 1;
-            if (pivotElement === 0) {
-                // Handle division by zero
-                throw new Error('Matrix is singular, and its inverse does not exist (division by zero).');
-            }
-            augmentedMatrix._scaleRow(i, 1 / pivotElement);
-            // Eliminate other rows to make elements in the current column zero
-            for (let j = 0; j < this.rows; j++) {
-                if (j !== i) {
-                    let factor = augmentedMatrix.get(j, i);
-                    if (factor === undefined)
-                        factor = 0;
-                    augmentedMatrix._addScaledRow(j, i, -factor);
-                }
-            }
-        }
-        // Extract the right half of the augmented matrix as the inverse
-        const inverseData = [];
-        for (let i = 0; i < this.rows; i++) {
-            inverseData[i] = augmentedMatrix.data[i].slice(this.cols);
-        }
-        return new Matrix(inverseData, {
-            rows: this.rows,
-            cols: this.cols,
-            addFn: this.addFn,
-            subtractFn: this.subtractFn,
-            multiplyFn: this.multiplyFn
-        });
-    }
-    /**
-     * 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) {
-        if (this.cols !== matrix.rows) {
-            throw new Error('Number of columns in the first matrix must be equal to the number of rows in the second matrix for dot product.');
-        }
-        const resultData = [];
-        for (let i = 0; i < this.rows; i++) {
-            resultData[i] = [];
-            for (let j = 0; j < matrix.cols; j++) {
-                let sum;
-                for (let k = 0; k < this.cols; k++) {
-                    const a = this.get(i, k), b = matrix.get(k, j);
-                    if (a !== undefined && b !== undefined) {
-                        const multiplied = this.multiplyFn(a, b);
-                        if (multiplied !== undefined) {
-                            sum = this.addFn(sum, multiplied);
-                        }
-                    }
-                }
-                if (sum !== undefined)
-                    resultData[i][j] = sum;
-            }
-        }
-        return new Matrix(resultData, {
-            rows: this.rows,
-            cols: matrix.cols,
-            addFn: this.addFn,
-            subtractFn: this.subtractFn,
-            multiplyFn: this.multiplyFn
-        });
-    }
-    /**
-     * 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.
-     */
-    isValidIndex(row, col) {
-        return row >= 0 && row < this.rows && col >= 0 && col < this.cols;
-    }
-    /**
-     * The `clone` function returns a new instance of the Matrix class with the same data and properties
-     * as the original instance.
-     * @returns The `clone()` method is returning a new instance of the `Matrix` class with the same data
-     * and properties as the current instance.
-     */
-    clone() {
-        return new Matrix(this.data, {
-            rows: this.rows,
-            cols: this.cols,
-            addFn: this.addFn,
-            subtractFn: this.subtractFn,
-            multiplyFn: this.multiplyFn
-        });
-    }
-    _addFn(a, b) {
-        if (a === undefined)
-            return b;
-        return a + b;
-    }
-    _subtractFn(a, b) {
-        return a - b;
-    }
-    _multiplyFn(a, b) {
-        return a * b;
-    }
-    /**
-     * 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.
-     */
-    _swapRows(row1, row2) {
-        const temp = this.data[row1];
-        this.data[row1] = this.data[row2];
-        this.data[row2] = temp;
-    }
-    /**
-     * 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.
-     */
-    _scaleRow(row, scalar) {
-        for (let j = 0; j < this.cols; j++) {
-            let multiplied = this.multiplyFn(this.data[row][j], scalar);
-            if (multiplied === undefined)
-                multiplied = 0;
-            this.data[row][j] = multiplied;
-        }
-    }
-    /**
-     * 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.
-     */
-    _addScaledRow(targetRow, sourceRow, scalar) {
-        for (let j = 0; j < this.cols; j++) {
-            let multiplied = this.multiplyFn(this.data[sourceRow][j], scalar);
-            if (multiplied === undefined)
-                multiplied = 0;
-            const scaledValue = multiplied;
-            let added = this.addFn(this.data[targetRow][j], scaledValue);
-            if (added === undefined)
-                added = 0;
-            this.data[targetRow][j] = added;
-        }
-    }
-}
-exports.Matrix = Matrix;

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

@@ -1,55 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Pablo Zeng
- * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import type { Direction, NavigatorParams, Turning } from '../../types';
-export declare class Character {
-    direction: Direction;
-    turn: () => Character;
-    /**
-     * The constructor function takes in a direction and turning object and sets the direction and turn properties of the
-     * Character class.
-     * @param {Direction} direction - The direction parameter is used to specify the current direction of the character. It
-     * can be any value that represents a direction, such as "north", "south", "east", or "west".
-     * @param {Turning} turning - The `turning` parameter is an object that maps each direction to the corresponding
-     * turning direction. It is used to determine the new direction when the character turns.
-     */
-    constructor(direction: Direction, turning: Turning);
-}
-/**
- *
- */
-export declare class Navigator<T = number> {
-    onMove: (cur: [number, number]) => void;
-    protected readonly _matrix: T[][];
-    protected readonly _cur: [number, number];
-    protected _character: Character;
-    protected readonly _VISITED: T;
-    /**
-     * The constructor initializes the Navigator object with the given parameters and sets the current position as visited
-     * in the matrix.
-     * @param  - - `matrix`: a 2D array representing the grid or map
-     */
-    constructor({ matrix, turning, onMove, init: { cur, charDir, VISITED } }: NavigatorParams<T>);
-    /**
-     * The "start" function moves the character in its current direction until it encounters an obstacle, then it turns the
-     * character and repeats the process.
-     */
-    start(): void;
-    /**
-     * The function checks if there is a valid move in the specified direction in a matrix.
-     * @param {Direction} direction - The direction parameter is a string that represents the direction in which to check.
-     * It can be one of the following values: 'up', 'right', 'down', or 'left'.
-     * @returns a boolean value.
-     */
-    check(direction: Direction): boolean;
-    /**
-     * The `move` function updates the current position based on the given direction and updates the matrix accordingly.
-     * @param {Direction} direction - The `direction` parameter is a string that represents the direction in which to move.
-     * It can have one of the following values: 'up', 'right', 'down', or 'left'.
-     */
-    move(direction: Direction): void;
-}

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

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Navigator = exports.Character = void 0;
-class Character {
-    /**
-     * The constructor function takes in a direction and turning object and sets the direction and turn properties of the
-     * Character class.
-     * @param {Direction} direction - The direction parameter is used to specify the current direction of the character. It
-     * can be any value that represents a direction, such as "north", "south", "east", or "west".
-     * @param {Turning} turning - The `turning` parameter is an object that maps each direction to the corresponding
-     * turning direction. It is used to determine the new direction when the character turns.
-     */
-    constructor(direction, turning) {
-        this.direction = direction;
-        this.turn = () => new Character(turning[direction], turning);
-    }
-}
-exports.Character = Character;
-/**
- *
- */
-class Navigator {
-    /**
-     * The constructor initializes the Navigator object with the given parameters and sets the current position as visited
-     * in the matrix.
-     * @param  - - `matrix`: a 2D array representing the grid or map
-     */
-    constructor({ matrix, turning, onMove, init: { cur, charDir, VISITED } }) {
-        this._matrix = matrix;
-        this._cur = cur;
-        this._character = new Character(charDir, turning);
-        this.onMove = onMove;
-        if (this.onMove)
-            this.onMove(this._cur);
-        this._VISITED = VISITED;
-        this._matrix[this._cur[0]][this._cur[1]] = this._VISITED;
-    }
-    /**
-     * The "start" function moves the character in its current direction until it encounters an obstacle, then it turns the
-     * character and repeats the process.
-     */
-    start() {
-        while (this.check(this._character.direction) || this.check(this._character.turn().direction)) {
-            const { direction } = this._character;
-            if (this.check(direction)) {
-                this.move(direction);
-            }
-            else if (this.check(this._character.turn().direction)) {
-                this._character = this._character.turn();
-            }
-        }
-    }
-    /**
-     * The function checks if there is a valid move in the specified direction in a matrix.
-     * @param {Direction} direction - The direction parameter is a string that represents the direction in which to check.
-     * It can be one of the following values: 'up', 'right', 'down', or 'left'.
-     * @returns a boolean value.
-     */
-    check(direction) {
-        let forward, row;
-        const matrix = this._matrix;
-        const [i, j] = this._cur;
-        switch (direction) {
-            case 'up':
-                row = matrix[i - 1];
-                if (!row)
-                    return false;
-                forward = row[j];
-                break;
-            case 'right':
-                forward = matrix[i][j + 1];
-                break;
-            case 'down':
-                row = matrix[i + 1];
-                if (!row)
-                    return false;
-                forward = row[j];
-                break;
-            case 'left':
-                forward = matrix[i][j - 1];
-                break;
-        }
-        return forward !== undefined && forward !== this._VISITED;
-    }
-    /**
-     * The `move` function updates the current position based on the given direction and updates the matrix accordingly.
-     * @param {Direction} direction - The `direction` parameter is a string that represents the direction in which to move.
-     * It can have one of the following values: 'up', 'right', 'down', or 'left'.
-     */
-    move(direction) {
-        switch (direction) {
-            case 'up':
-                this._cur[0]--;
-                break;
-            case 'right':
-                this._cur[1]++;
-                break;
-            case 'down':
-                this._cur[0]++;
-                break;
-            case 'left':
-                this._cur[1]--;
-                break;
-        }
-        const [i, j] = this._cur;
-        this._matrix[i][j] = this._VISITED;
-        if (this.onMove)
-            this.onMove(this._cur);
-    }
-}
-exports.Navigator = Navigator;

package/dist/data-structures/priority-queue/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./priority-queue"), exports);
-__exportStar(require("./min-priority-queue"), exports);
-__exportStar(require("./max-priority-queue"), exports);

package/dist/data-structures/priority-queue/max-priority-queue.d.ts

@@ -1,27 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
- */
-import type { PriorityQueueOptions } from '../../types';
-import { PriorityQueue } from './priority-queue';
-/**
- * Max-oriented priority queue (max-heap) built on {@link PriorityQueue}.
- * The default comparator orders primitive values in descending order. If you store objects,
- * you must provide a custom comparator via {@link PriorityQueueOptions}.
- * @template E Element type stored in the queue.
- * @template R Extra record/metadata associated with each element.
- * @example
- */
-export declare class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
-    /**
-     * Creates a max-priority queue.
-     * @param elements Optional initial elements to insert.
-     * @param options Optional configuration (e.g., `comparator`, `toElementFn`).
-     * @throws {TypeError} Thrown when using the default comparator with object elements (provide a custom comparator).
-     * @remarks Complexity — Time: O(n log n) when inserting n elements incrementally; Space: O(n).
-     */
-    constructor(elements?: Iterable<E> | Iterable<R>, options?: PriorityQueueOptions<E, R>);
-}