data-structure-typed 0.8.6

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

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Matrix2D = void 0;
+const vector2d_1 = __importDefault(require("./vector2d"));
+class Matrix2D {
+    constructor(value) {
+        if (typeof value === 'undefined') {
+            this._matrix = Matrix2D.identity;
+        }
+        else if (value instanceof vector2d_1.default) {
+            this._matrix = Matrix2D.identity;
+            this._matrix[0][0] = value.x;
+            this._matrix[1][0] = value.y;
+            this._matrix[2][0] = value.w;
+        }
+        else {
+            this._matrix = value;
+        }
+    }
+    /**
+     * Return the matrix values
+     */
+    get m() {
+        return this._matrix;
+    }
+    static get empty() {
+        return [[], [], []];
+    }
+    get toVector() {
+        return new vector2d_1.default(this._matrix[0][0], this._matrix[1][0]);
+    }
+    /**
+     * Initialize an identity matrix
+     */
+    static get identity() {
+        return [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]
+        ];
+    }
+    static add(matrix1, matrix2) {
+        const result = Matrix2D.empty;
+        for (let i = 0; i < 3; i++) {
+            for (let j = 0; j < 3; j++) {
+                result[i][j] = matrix1.m[i][j] + matrix2.m[i][j];
+            }
+        }
+        return new Matrix2D(result);
+    }
+    static subtract(matrix1, matrix2) {
+        const result = Matrix2D.empty;
+        for (let i = 0; i < 3; i++) {
+            for (let j = 0; j < 3; j++) {
+                result[i][j] = matrix1.m[i][j] - matrix2.m[i][j];
+            }
+        }
+        return new Matrix2D(result);
+    }
+    static multiply(matrix1, matrix2) {
+        const result = Matrix2D.empty;
+        for (let i = 0; i < 3; i++) {
+            for (let j = 0; j < 3; j++) {
+                result[i][j] = 0;
+                for (let k = 0; k < 3; k++) {
+                    result[i][j] += matrix1.m[i][k] * matrix2.m[k][j];
+                }
+            }
+        }
+        return new Matrix2D(result);
+    }
+    static multiplyByValue(matrix, value) {
+        const result = Matrix2D.empty;
+        for (let i = 0; i < 3; i++) {
+            for (let j = 0; j < 3; j++) {
+                result[i][j] = matrix.m[i][j] * value;
+            }
+        }
+        return new Matrix2D(result);
+    }
+    static multiplyByVector(matrix, vector) {
+        return Matrix2D.multiply(matrix, new Matrix2D(vector)).toVector;
+    }
+    static view(width, height) {
+        const scaleStep = 1; // Scale every vector * scaleStep
+        const centerX = width / 2;
+        const centerY = height / 2;
+        const flipX = Math.cos(Math.PI); // rotate 180deg / 3.14radian around X-axis
+        return new Matrix2D([
+            [scaleStep, 0, centerX],
+            [0, flipX * scaleStep, centerY],
+            [0, 0, 1]
+        ]);
+    }
+    static scale(factor) {
+        return Matrix2D.multiplyByValue(new Matrix2D(), factor);
+    }
+    static rotate(radians) {
+        const cos = Math.cos(radians);
+        const sin = Math.sin(radians);
+        return new Matrix2D([
+            [cos, -sin, 0],
+            [sin, cos, 0],
+            [0, 0, 1]
+        ]);
+    }
+    static translate(vector) {
+        return new Matrix2D([
+            [1, 0, vector.x],
+            [0, 1, vector.y],
+            [0, 0, vector.w]
+        ]);
+    }
+}
+exports.Matrix2D = Matrix2D;
+exports.default = Matrix2D;

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Navigator = exports.Character = void 0;
+class Character {
+    constructor(direction, turning) {
+        this.direction = direction;
+        this.turn = () => new Character(turning[direction], turning);
+    }
+}
+exports.Character = Character;
+class Navigator {
+    constructor({ matrix, turning, onMove, init: { cur, charDir, VISITED } }) {
+        this._matrix = matrix;
+        this._cur = cur;
+        this._character = new Character(charDir, turning);
+        this.onMove = onMove;
+        this.onMove && this.onMove(this._cur);
+        this._VISITED = VISITED;
+        this._matrix[this._cur[0]][this._cur[1]] = this._VISITED;
+    }
+    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();
+            }
+        }
+    }
+    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;
+    }
+    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;
+        this.onMove && this.onMove(this._cur);
+    }
+}
+exports.Navigator = Navigator;

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

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Vector2D {
+    static add(vector1, vector2) {
+        return new Vector2D(vector1.x + vector2.x, vector1.y + vector2.y);
+    }
+    static subtract(vector1, vector2) {
+        return new Vector2D(vector1.x - vector2.x, vector1.y - vector2.y);
+    }
+    static subtractValue(vector, value) {
+        return new Vector2D(vector.x - value, vector.y - value);
+    }
+    static multiply(vector, value) {
+        return new Vector2D(vector.x * value, vector.y * value);
+    }
+    static divide(vector, value) {
+        return new Vector2D(vector.x / value, vector.y / value);
+    }
+    static equals(vector1, vector2) {
+        return vector1.x === vector2.x && vector1.y === vector2.y;
+    }
+    static equalsRounded(vector1, vector2, roundingFactor = 12) {
+        const vector = Vector2D.abs(Vector2D.subtract(vector1, vector2));
+        if (vector.x < roundingFactor && vector.y < roundingFactor) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Normalizes the vector if it matches a certain condition
+     */
+    static normalize(vector) {
+        const length = vector.length;
+        if (length > 2.220446049250313e-16) { // Epsilon
+            return Vector2D.divide(vector, length);
+        }
+        return vector;
+    }
+    /**
+     * Adjusts x and y so that the length of the vector does not exceed max
+     */
+    static truncate(vector, max) {
+        if (vector.length > max) {
+            return Vector2D.multiply(Vector2D.normalize(vector), max);
+        }
+        return vector;
+    }
+    /**
+     * The vector that is perpendicular to this one
+     */
+    static perp(vector) {
+        return new Vector2D(-vector.y, vector.x);
+    }
+    /**
+     * returns the vector that is the reverse of this vector
+     */
+    static reverse(vector) {
+        return new Vector2D(-vector.x, -vector.y);
+    }
+    static abs(vector) {
+        return new Vector2D(Math.abs(vector.x), Math.abs(vector.y));
+    }
+    /**
+     * The dot product of v1 and v2
+     */
+    static dot(vector1, vector2) {
+        return (vector1.x * vector2.x) + (vector1.y * vector2.y);
+    }
+    /**
+     * The distance between this and the vector
+     */
+    static distance(vector1, vector2) {
+        const ySeparation = vector2.y - vector1.y;
+        const xSeparation = vector2.x - vector1.x;
+        return Math.sqrt((ySeparation * ySeparation) + (xSeparation * xSeparation));
+    }
+    /**
+     * The distance between this and the vector squared
+     */
+    static distanceSq(vector1, vector2) {
+        const ySeparation = vector2.y - vector1.y;
+        const xSeparation = vector2.x - vector1.x;
+        return (ySeparation * ySeparation) + (xSeparation * xSeparation);
+    }
+    /**
+     * Returns positive if v2 is clockwise of this vector, negative if counterclockwise
+     * (assuming the Y axis is pointing down, X axis to right like a Window app)
+     */
+    static sign(vector1, vector2) {
+        if (vector1.y * vector2.x > vector1.x * vector2.y) {
+            return -1;
+        }
+        return 1;
+    }
+    /**
+     * Returns the angle between origin and the given vector in radians
+     * @param vector
+     */
+    static angle(vector) {
+        const origin = new Vector2D(0, -1);
+        const radian = Math.acos(Vector2D.dot(vector, origin) / (vector.length * origin.length));
+        return Vector2D.sign(vector, origin) === 1 ? ((Math.PI * 2) - radian) : radian;
+    }
+    static random(maxX, maxY) {
+        const randX = Math.floor(Math.random() * maxX - (maxX / 2));
+        const randY = Math.floor(Math.random() * maxY - (maxY / 2));
+        return new Vector2D(randX, randY);
+    }
+    // /**
+    //  * Transform vectors based on the current tranformation matrices: translation, rotation and scale
+    //  * @param vectors The vectors to transform
+    //  */
+    // public static transform(vector: Vector2D, transformation: Matrix2D): Vector2D {
+    //     return Matrix2D.multiplyByVector(transformation, vector)
+    // }
+    // /**
+    //  * Transform vectors based on the current tranformation matrices: translation, rotation and scale
+    //  * @param vectors The vectors to transform
+    //  */
+    // public static transformList(vectors: Vector2D[], transformation: Matrix2D): Vector2D[] {
+    //     return vectors.map(vector => Matrix2D.multiplyByVector(transformation, vector))
+    // }
+    constructor(x = 0, y = 0, w = 1 // needed for matrix multiplication
+    ) {
+        this.x = x;
+        this.y = y;
+        this.w = w;
+    }
+    /**
+     * Check wether both x and y are zero
+     */
+    zero() {
+        this.x = 0;
+        this.y = 0;
+    }
+    /**
+     * Set x and y both to zero
+     */
+    get isZero() {
+        return this.x === 0 && this.y === 0;
+    }
+    /**
+     * The length / magnitude of the vector
+     */
+    get length() {
+        return Math.sqrt((this.x * this.x) + (this.y * this.y));
+    }
+    /**
+     * The squared length of the vector
+     */
+    get lengthSq() {
+        return (this.x * this.x) + (this.y * this.y);
+    }
+    /**
+     * Return the vector with rounded values
+     */
+    get rounded() {
+        return new Vector2D(Math.round(this.x), Math.round(this.y));
+    }
+}
+exports.default = Vector2D;

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

@@ -0,0 +1,19 @@
+"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.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxPriorityQueue = void 0;
+const priority_queue_1 = require("./priority-queue");
+class MaxPriorityQueue extends priority_queue_1.PriorityQueue {
+    constructor(options) {
+        super({
+            nodes: options.nodes, comparator: (a, b) => {
+                const aKey = a, bKey = b;
+                return bKey - aKey;
+            }
+        });
+    }
+}
+exports.MaxPriorityQueue = MaxPriorityQueue;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinPriorityQueue = void 0;
+const priority_queue_1 = require("./priority-queue");
+class MinPriorityQueue extends priority_queue_1.PriorityQueue {
+    constructor(options) {
+        super({
+            nodes: options.nodes, comparator: (a, b) => {
+                const aKey = a, bKey = b;
+                return aKey - bKey;
+            }
+        });
+    }
+}
+exports.MinPriorityQueue = MinPriorityQueue;

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

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityQueue = void 0;
+class PriorityQueue {
+    get size() {
+        return this.nodes.length;
+    }
+    constructor(options) {
+        this.nodes = [];
+        this._comparator = (a, b) => {
+            const aKey = a, bKey = b;
+            return aKey - bKey;
+        };
+        const { nodes, comparator, isFix = true } = options;
+        this._comparator = comparator;
+        if (nodes && nodes instanceof Array && nodes.length > 0) {
+            // TODO support distinct
+            this.nodes = Array.isArray(nodes) ? [...nodes] : [];
+            isFix && this._fix();
+        }
+    }
+    _compare(a, b) {
+        return this._comparator(this.nodes[a], this.nodes[b]) > 0;
+    }
+    _swap(a, b) {
+        const temp = this.nodes[a];
+        this.nodes[a] = this.nodes[b];
+        this.nodes[b] = temp;
+    }
+    _isValidIndex(index) {
+        return index > -1 && index < this.nodes.length;
+    }
+    _getParent(child) {
+        return Math.floor((child - 1) / 2);
+    }
+    _getLeft(parent) {
+        return (2 * parent) + 1;
+    }
+    _getRight(parent) {
+        return (2 * parent) + 2;
+    }
+    _getComparedChild(parent) {
+        let min = parent;
+        const left = this._getLeft(parent), right = this._getRight(parent);
+        if (left < this.size && this._compare(min, left)) {
+            min = left;
+        }
+        if (right < this.size && this._compare(min, right)) {
+            min = right;
+        }
+        return min;
+    }
+    _heapifyUp(start) {
+        while (start > 0 && this._compare(this._getParent(start), start)) {
+            const parent = this._getParent(start);
+            this._swap(start, parent);
+            start = parent;
+        }
+    }
+    _heapifyDown(start) {
+        let min = this._getComparedChild(start);
+        while (this._compare(start, min)) {
+            this._swap(min, start);
+            start = min;
+            min = this._getComparedChild(start);
+        }
+    }
+    _fix() {
+        for (let i = Math.floor(this.size / 2); i > -1; i--)
+            this._heapifyDown(i);
+    }
+    offer(node) {
+        this.nodes.push(node);
+        this._heapifyUp(this.size - 1);
+    }
+    peek() {
+        return this.size ? this.nodes[0] : null;
+    }
+    poll() {
+        var _a, _b;
+        let res = null;
+        if (this.size > 1) {
+            this._swap(0, this.nodes.length - 1);
+            res = (_a = this.nodes.pop()) !== null && _a !== void 0 ? _a : null;
+            this._heapifyDown(0);
+        }
+        else if (this.size === 1) {
+            res = (_b = this.nodes.pop()) !== null && _b !== void 0 ? _b : null;
+        }
+        return res;
+    }
+    leaf() {
+        var _a;
+        return (_a = this.nodes[this.size - 1]) !== null && _a !== void 0 ? _a : null;
+    }
+    isEmpty() {
+        return this.size === 0;
+    }
+    clear() {
+        this.nodes = [];
+    }
+    toArray() {
+        return [...this.nodes];
+    }
+    clone() {
+        return new PriorityQueue({ nodes: this.nodes, comparator: this._comparator });
+    }
+    // --- start additional methods ---
+    isValid() {
+        const isValidRecursive = (parentIndex) => {
+            let isValidLeft = true;
+            let isValidRight = true;
+            if (this._getLeft(parentIndex) !== -1) {
+                const leftChildIndex = (parentIndex * 2) + 1;
+                if (!this._compare(parentIndex, leftChildIndex))
+                    return false;
+                isValidLeft = isValidRecursive(leftChildIndex);
+            }
+            if (this._getRight(parentIndex) !== -1) {
+                const rightChildIndex = (parentIndex * 2) + 2;
+                if (!this._compare(parentIndex, rightChildIndex))
+                    return false;
+                isValidRight = isValidRecursive(rightChildIndex);
+            }
+            return isValidLeft && isValidRight;
+        };
+        return isValidRecursive(0);
+    }
+    sort() {
+        const visitedNode = [];
+        while (this.size !== 0) {
+            const top = this.poll();
+            if (top)
+                visitedNode.push(top);
+        }
+        return visitedNode;
+    }
+    DFS(dfsMode) {
+        const visitedNode = [];
+        const traverse = (cur) => {
+            var _a, _b, _c;
+            const leftChildIndex = this._getLeft(cur);
+            const rightChildIndex = this._getRight(cur);
+            switch (dfsMode) {
+                case 'in':
+                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    visitedNode.push((_a = this.nodes[cur]) !== null && _a !== void 0 ? _a : null);
+                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    break;
+                case 'pre':
+                    visitedNode.push((_b = this.nodes[cur]) !== null && _b !== void 0 ? _b : null);
+                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    break;
+                case 'post':
+                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    visitedNode.push((_c = this.nodes[cur]) !== null && _c !== void 0 ? _c : null);
+                    break;
+            }
+        };
+        this._isValidIndex(0) && traverse(0);
+        return visitedNode;
+    }
+    static heapify(options) {
+        const heap = new PriorityQueue(options);
+        heap._fix();
+        return heap;
+    }
+    static isPriorityQueueified(options) {
+        return new PriorityQueue(Object.assign(Object.assign({}, options), { isFix: true })).isValid();
+    }
+}
+exports.PriorityQueue = PriorityQueue;