@raikuxq/alg-ds 1.1.6 → 1.2.1

package/lib/app/data-structures/BinaryTree/_helpers/createBinaryTree.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBinaryTree = void 0;
+var EnumBinarySearchTreeType_1 = require("../../../types/EnumBinarySearchTreeType");
+var BinarySearchTree_1 = require("../BinarySearchTree/BinarySearchTree");
+var RandBinarySearchTree_1 = require("../RandBinarySearchTree/RandBinarySearchTree");
+/**
+ * Returns binary tree by type
+ */
+exports.createBinaryTree = function (type) {
+    var binaryTree;
+    switch (type) {
+        case EnumBinarySearchTreeType_1.EnumBinarySearchTreeType.BST:
+            binaryTree = new BinarySearchTree_1.default();
+            break;
+        case EnumBinarySearchTreeType_1.EnumBinarySearchTreeType.RANDOMIZED_BST:
+            binaryTree = new RandBinarySearchTree_1.default();
+            break;
+    }
+    return binaryTree;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlQmluYXJ5VHJlZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvZGF0YS1zdHJ1Y3R1cmVzL0JpbmFyeVRyZWUvX2hlbHBlcnMvY3JlYXRlQmluYXJ5VHJlZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxvRkFBbUY7QUFDbkYseUVBQW9FO0FBQ3BFLHFGQUFnRjtBQUdoRjs7R0FFRztBQUNVLFFBQUEsZ0JBQWdCLEdBQUcsVUFDOUIsSUFBOEI7SUFFOUIsSUFBSSxVQUEwQixDQUFDO0lBRS9CLFFBQVEsSUFBSSxFQUFFO1FBQ1osS0FBSyxtREFBd0IsQ0FBQyxHQUFHO1lBQy9CLFVBQVUsR0FBRyxJQUFJLDBCQUFnQixFQUFFLENBQUM7WUFDcEMsTUFBTTtRQUNSLEtBQUssbURBQXdCLENBQUMsY0FBYztZQUMxQyxVQUFVLEdBQUcsSUFBSSw4QkFBb0IsRUFBRSxDQUFDO1lBQ3hDLE1BQU07S0FDVDtJQUVELE9BQU8sVUFBVSxDQUFDO0FBQ3BCLENBQUMsQ0FBQyJ9

package/lib/app/data-structures/Graph/AbstractGraph.d.ts

@@ -0,0 +1,84 @@
+import GraphEdge from "./GraphEdge";
+export default abstract class AbstractGraph<T> {
+    protected _vertices: Map<T, Array<T>>;
+    protected _edges: Array<GraphEdge<T>>;
+    /**
+     * Created empty instance
+     */
+    protected constructor();
+    /**
+     * Find edge by its from and to vertices
+     */
+    protected abstract getEdgeByValue(from: T, to: T): GraphEdge<T>;
+    /**
+     * Get vertices list in array format
+     */
+    protected getVerticesArrayFormat(): Array<T>;
+    /**
+     * Find vertex in vertices list by its data
+     * @throws when vertex was not found
+     */
+    protected tryFindVertex(data: T): T;
+    /**
+     * Update edge weight between from and to vertices
+     */
+    protected updateEdgeWeight(from: T, to: T, weight: number): void;
+    /**
+     * Will remove all vertex relations with others vertices
+     */
+    protected cascadeRemoveVertexRelations(vertexToRemove: T): void;
+    /**
+     * Will remove all vertices edges with vertex to remove
+     */
+    protected cascadeRemoveVertexEdges(vertexToRemove: T): void;
+    /**
+     * Get sum of all graph edges
+     */
+    weight(): number;
+    /**
+     * Get array of vertices
+     */
+    vertices(): Array<T>;
+    /**
+     * Get vertices count
+     */
+    verticesCount(): number;
+    /**
+     * Get edges count
+     */
+    edgesCount(): number;
+    /**
+     * Add vertex
+     * @throws when vertex is already exists
+     */
+    addVertex(data: T): this;
+    /**
+     * Remove vertex
+     * @throws when vertex is already does not exist
+     */
+    removeVertex(data: T): this;
+    /**
+     * Add edge between two vertices
+     */
+    abstract addEdge(from: T, to: T, weight?: number): this;
+    /**
+     * Remove edge between two vertices
+     */
+    abstract removeEdge(from: T, to: T): this;
+    /**
+     * Get vertex neighbors by its data
+     */
+    getVertexNeighbors(data: T): Array<T>;
+    /**
+     * Check if graph has vertex
+     */
+    hasVertex(data: T): boolean;
+    /**
+     * Check if graph has edge between from and to vertices
+     */
+    hasEdge(from: T, to: T): boolean;
+    /**
+     * Get edge weight between from and to vertices
+     */
+    getEdgeWeight(from: T, to: T): number;
+}

package/lib/app/data-structures/Graph/AbstractGraph.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var IsNotFoundException_1 = require("../../exceptions/IsNotFoundException");
+var IsAlreadyExistsException_1 = require("../../exceptions/IsAlreadyExistsException");
+var AbstractGraph = /** @class */ (function () {
+    /**
+     * Created empty instance
+     */
+    function AbstractGraph() {
+        this._vertices = new Map();
+        this._edges = new Array();
+    }
+    /**
+     * Get vertices list in array format
+     */
+    AbstractGraph.prototype.getVerticesArrayFormat = function () {
+        return Array.from(this._vertices.keys());
+    };
+    /**
+     * Find vertex in vertices list by its data
+     * @throws when vertex was not found
+     */
+    AbstractGraph.prototype.tryFindVertex = function (data) {
+        var isExists = this._vertices.has(data);
+        if (!isExists) {
+            throw new IsNotFoundException_1.default("Vertex not found");
+        }
+        return data;
+    };
+    /**
+     * Update edge weight between from and to vertices
+     */
+    AbstractGraph.prototype.updateEdgeWeight = function (from, to, weight) {
+        var edge = this.getEdgeByValue(from, to);
+        edge.weight = weight;
+    };
+    /**
+     * Will remove all vertex relations with others vertices
+     */
+    AbstractGraph.prototype.cascadeRemoveVertexRelations = function (vertexToRemove) {
+        var _this = this;
+        this.getVerticesArrayFormat().forEach(function (neighbor) {
+            var neighborVertexNeighbors = _this._vertices.get(neighbor);
+            if (neighborVertexNeighbors) {
+                var neighborVertexFilteredNeighbors = neighborVertexNeighbors.filter(function (newNeighbor) { return newNeighbor !== vertexToRemove; });
+                _this._vertices.set(neighbor, neighborVertexFilteredNeighbors);
+            }
+        });
+    };
+    /**
+     * Will remove all vertices edges with vertex to remove
+     */
+    AbstractGraph.prototype.cascadeRemoveVertexEdges = function (vertexToRemove) {
+        this._edges = this._edges.filter(function (edge) {
+            var shouldBeDeleted = edge.toVertex === vertexToRemove || edge.fromVertex === vertexToRemove;
+            return !shouldBeDeleted;
+        });
+    };
+    /**
+     * Get sum of all graph edges
+     */
+    AbstractGraph.prototype.weight = function () {
+        return this._edges.reduce(function (acc, edge) { return acc + edge.weight; }, 0);
+    };
+    /**
+     * Get array of vertices
+     */
+    AbstractGraph.prototype.vertices = function () {
+        return this.getVerticesArrayFormat().map(function (vertex) { return vertex; });
+    };
+    /**
+     * Get vertices count
+     */
+    AbstractGraph.prototype.verticesCount = function () {
+        return this.vertices().length;
+    };
+    /**
+     * Get edges count
+     */
+    AbstractGraph.prototype.edgesCount = function () {
+        return this._edges.length;
+    };
+    /**
+     * Add vertex
+     * @throws when vertex is already exists
+     */
+    AbstractGraph.prototype.addVertex = function (data) {
+        if (this.hasVertex(data)) {
+            throw new IsAlreadyExistsException_1.default("Vertex is already exist");
+        }
+        this._vertices.set(data, new Array());
+        return this;
+    };
+    /**
+     * Remove vertex
+     * @throws when vertex is already does not exist
+     */
+    AbstractGraph.prototype.removeVertex = function (data) {
+        try {
+            var vertexToRemove = this.tryFindVertex(data);
+            this.cascadeRemoveVertexEdges(vertexToRemove);
+            this.cascadeRemoveVertexRelations(vertexToRemove);
+            this._vertices.delete(vertexToRemove);
+        }
+        catch (e) {
+            throw new IsNotFoundException_1.default("Vertex does not exist already");
+        }
+        return this;
+    };
+    /**
+     * Get vertex neighbors by its data
+     */
+    AbstractGraph.prototype.getVertexNeighbors = function (data) {
+        var vertex = this.tryFindVertex(data);
+        return this._vertices.get(vertex) || [];
+    };
+    /**
+     * Check if graph has vertex
+     */
+    AbstractGraph.prototype.hasVertex = function (data) {
+        return this._vertices.has(data);
+    };
+    /**
+     * Check if graph has edge between from and to vertices
+     */
+    AbstractGraph.prototype.hasEdge = function (from, to) {
+        return Boolean(this._edges.find(function (edge) {
+            return edge.fromVertex === from && edge.toVertex === to;
+        }));
+    };
+    /**
+     * Get edge weight between from and to vertices
+     */
+    AbstractGraph.prototype.getEdgeWeight = function (from, to) {
+        var fromVertex = this.tryFindVertex(from);
+        var toVertex = this.tryFindVertex(to);
+        var edge = this.getEdgeByValue(fromVertex, toVertex);
+        return edge.weight;
+    };
+    return AbstractGraph;
+}());
+exports.default = AbstractGraph;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/app/data-structures/Graph/DirectedGraph.d.ts

@@ -0,0 +1,24 @@
+import AbstractGraph from "./AbstractGraph";
+import GraphEdge from "./GraphEdge";
+/**
+ * Directed graph - data structure where edges with same pair of vertices are not equal
+ * @example A-B is not the same as B-A
+ */
+export default class DirectedGraph<T> extends AbstractGraph<T> {
+    /**
+     * @inheritDoc
+     */
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected getEdgeByValue(from: T, to: T): GraphEdge<T>;
+    /**
+     * @inheritDoc
+     */
+    addEdge(from: T, to: T, weight?: number): this;
+    /**
+     * @inheritDoc
+     */
+    removeEdge(from: T, to: T): this;
+}

package/lib/app/data-structures/Graph/DirectedGraph.js

@@ -0,0 +1,86 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractGraph_1 = require("./AbstractGraph");
+var GraphEdge_1 = require("./GraphEdge");
+var IsNotFoundException_1 = require("../../exceptions/IsNotFoundException");
+/**
+ * Directed graph - data structure where edges with same pair of vertices are not equal
+ * @example A-B is not the same as B-A
+ */
+var DirectedGraph = /** @class */ (function (_super) {
+    __extends(DirectedGraph, _super);
+    /**
+     * @inheritDoc
+     */
+    function DirectedGraph() {
+        return _super.call(this) || this;
+    }
+    /**
+     * @inheritDoc
+     */
+    DirectedGraph.prototype.getEdgeByValue = function (from, to) {
+        var edge = this._edges.find(function (edge) { return edge.fromVertex === from && edge.toVertex === to; });
+        if (!edge) {
+            throw new IsNotFoundException_1.default("Edge not found");
+        }
+        return edge;
+    };
+    /**
+     * @inheritDoc
+     */
+    DirectedGraph.prototype.addEdge = function (from, to, weight) {
+        var _a;
+        try {
+            var fromVertex = this.tryFindVertex(from);
+            var toVertex = this.tryFindVertex(to);
+            if (this.hasEdge(fromVertex, toVertex)) {
+                if (typeof weight === "number") {
+                    this.updateEdgeWeight(fromVertex, toVertex, weight);
+                }
+            }
+            else {
+                var edge = new GraphEdge_1.default(fromVertex, toVertex, weight);
+                this._edges.push(edge);
+                (_a = this._vertices.get(fromVertex)) === null || _a === void 0 ? void 0 : _a.push(toVertex);
+            }
+        }
+        catch (_b) {
+            throw new IsNotFoundException_1.default("Edge cannot be added because one of vertices was not found");
+        }
+        return this;
+    };
+    /**
+     * @inheritDoc
+     */
+    DirectedGraph.prototype.removeEdge = function (from, to) {
+        try {
+            var fromVertex = this.tryFindVertex(from);
+            var toVertex_1 = this.tryFindVertex(to);
+            var edgeToRemove_1 = this.getEdgeByValue(fromVertex, toVertex_1);
+            var fromVertexNeighbors = this._vertices.get(fromVertex) || [];
+            var fromNewNeighbors = fromVertexNeighbors.filter(function (vertex) { return toVertex_1 !== vertex; });
+            this._vertices.set(fromVertex, fromNewNeighbors);
+            this._edges = this._edges.filter(function (edge) { return edge !== edgeToRemove_1; });
+        }
+        catch (_a) {
+            throw new IsNotFoundException_1.default("Edge cannot be removed because one of vertices was not found");
+        }
+        return this;
+    };
+    return DirectedGraph;
+}(AbstractGraph_1.default));
+exports.default = DirectedGraph;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/app/data-structures/Graph/GraphEdge.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Graph edge between two vertices
+ */
+export default class GraphEdge<T> {
+    private readonly _fromVertex;
+    private readonly _toVertex;
+    private _weight;
+    /**
+     * Create instance with linked "from" and "to" vertices
+     */
+    constructor(fromVertex: T, toVertex: T, weight?: number);
+    get fromVertex(): T;
+    get toVertex(): T;
+    get weight(): number;
+    set weight(value: number);
+}

package/lib/app/data-structures/Graph/GraphEdge.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Graph edge between two vertices
+ */
+var GraphEdge = /** @class */ (function () {
+    /**
+     * Create instance with linked "from" and "to" vertices
+     */
+    function GraphEdge(fromVertex, toVertex, weight) {
+        if (weight === void 0) { weight = 0; }
+        this._fromVertex = fromVertex;
+        this._toVertex = toVertex;
+        this._weight = weight;
+    }
+    Object.defineProperty(GraphEdge.prototype, "fromVertex", {
+        get: function () {
+            return this._fromVertex;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GraphEdge.prototype, "toVertex", {
+        get: function () {
+            return this._toVertex;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GraphEdge.prototype, "weight", {
+        get: function () {
+            return this._weight;
+        },
+        set: function (value) {
+            this._weight = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return GraphEdge;
+}());
+exports.default = GraphEdge;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFZGdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FwcC9kYXRhLXN0cnVjdHVyZXMvR3JhcGgvR3JhcGhFZGdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUE7O0dBRUc7QUFDSDtJQUtFOztPQUVHO0lBQ0gsbUJBQW1CLFVBQWEsRUFBRSxRQUFXLEVBQUUsTUFBVTtRQUFWLHVCQUFBLEVBQUEsVUFBVTtRQUN2RCxJQUFJLENBQUMsV0FBVyxHQUFHLFVBQVUsQ0FBQztRQUM5QixJQUFJLENBQUMsU0FBUyxHQUFHLFFBQVEsQ0FBQztRQUMxQixJQUFJLENBQUMsT0FBTyxHQUFHLE1BQU0sQ0FBQztJQUN4QixDQUFDO0lBRUQsc0JBQUksaUNBQVU7YUFBZDtZQUNFLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQztRQUMxQixDQUFDOzs7T0FBQTtJQUVELHNCQUFJLCtCQUFRO2FBQVo7WUFDRSxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUM7UUFDeEIsQ0FBQzs7O09BQUE7SUFFRCxzQkFBSSw2QkFBTTthQUFWO1lBQ0UsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO1FBQ3RCLENBQUM7YUFFRCxVQUFXLEtBQWE7WUFDdEIsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUM7UUFDdkIsQ0FBQzs7O09BSkE7SUFLSCxnQkFBQztBQUFELENBQUMsQUE3QkQsSUE2QkMifQ==

package/lib/app/data-structures/Graph/UndirectedGraph.d.ts

@@ -0,0 +1,28 @@
+import AbstractGraph from "./AbstractGraph";
+import GraphEdge from "./GraphEdge";
+/**
+ * Undirected graph - data structure where edges with same pair of vertices are equal
+ * @example A-B is same as B-A
+ */
+export default class UndirectedGraph<T> extends AbstractGraph<T> {
+    /**
+     * @inheritDoc
+     */
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected getEdgeByValue(from: T, to: T): GraphEdge<T>;
+    /**
+     * @inheritDoc
+     */
+    hasEdge(from: T, to: T): boolean;
+    /**
+     * @inheritDoc
+     */
+    addEdge(from: T, to: T, weight?: number): this;
+    /**
+     * @inheritDoc
+     */
+    removeEdge(from: T, to: T): this;
+}

package/lib/app/data-structures/Graph/UndirectedGraph.js

@@ -0,0 +1,103 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractGraph_1 = require("./AbstractGraph");
+var GraphEdge_1 = require("./GraphEdge");
+var IsNotFoundException_1 = require("../../exceptions/IsNotFoundException");
+/**
+ * Undirected graph - data structure where edges with same pair of vertices are equal
+ * @example A-B is same as B-A
+ */
+var UndirectedGraph = /** @class */ (function (_super) {
+    __extends(UndirectedGraph, _super);
+    /**
+     * @inheritDoc
+     */
+    function UndirectedGraph() {
+        return _super.call(this) || this;
+    }
+    /**
+     * @inheritDoc
+     */
+    UndirectedGraph.prototype.getEdgeByValue = function (from, to) {
+        var edge = this._edges.find(function (edge) {
+            return (edge.fromVertex === from && edge.toVertex === to) ||
+                (edge.fromVertex === to && edge.toVertex === from);
+        });
+        if (!edge) {
+            throw new IsNotFoundException_1.default("Edge not found");
+        }
+        return edge;
+    };
+    /**
+     * @inheritDoc
+     */
+    UndirectedGraph.prototype.hasEdge = function (from, to) {
+        return Boolean(this._edges.find(function (edge) {
+            return ((edge.fromVertex === from && edge.toVertex === to) ||
+                (edge.fromVertex === to && edge.toVertex === from));
+        }));
+    };
+    /**
+     * @inheritDoc
+     */
+    UndirectedGraph.prototype.addEdge = function (from, to, weight) {
+        var _a, _b;
+        try {
+            var fromVertex = this.tryFindVertex(from);
+            var toVertex = this.tryFindVertex(to);
+            /** When edge is already exist, we should only update its weight */
+            if (this.hasEdge(fromVertex, toVertex)) {
+                if (typeof weight === "number") {
+                    this.updateEdgeWeight(fromVertex, toVertex, weight);
+                }
+            }
+            else {
+                var edge = new GraphEdge_1.default(fromVertex, toVertex, weight);
+                this._edges.push(edge);
+                (_a = this._vertices.get(fromVertex)) === null || _a === void 0 ? void 0 : _a.push(toVertex);
+                (_b = this._vertices.get(toVertex)) === null || _b === void 0 ? void 0 : _b.push(fromVertex);
+            }
+        }
+        catch (_c) {
+            throw new IsNotFoundException_1.default("Edge cannot be added because one of vertices was not found");
+        }
+        return this;
+    };
+    /**
+     * @inheritDoc
+     */
+    UndirectedGraph.prototype.removeEdge = function (from, to) {
+        try {
+            var fromVertex_1 = this.tryFindVertex(from);
+            var toVertex_1 = this.tryFindVertex(to);
+            var edgeToRemove_1 = this.getEdgeByValue(fromVertex_1, toVertex_1);
+            var fromVertexNeighbors = this._vertices.get(fromVertex_1) || [];
+            var toVertexNeighbors = this._vertices.get(toVertex_1) || [];
+            var fromNewNeighbors = fromVertexNeighbors.filter(function (vertex) { return toVertex_1 !== vertex; });
+            var toNewNeighbors = toVertexNeighbors.filter(function (vertex) { return fromVertex_1 !== vertex; });
+            this._vertices.set(fromVertex_1, fromNewNeighbors);
+            this._vertices.set(toVertex_1, toNewNeighbors);
+            this._edges = this._edges.filter(function (edge) { return edge !== edgeToRemove_1; });
+        }
+        catch (_a) {
+            throw new IsNotFoundException_1.default("Edge cannot be removed because one of vertices was not found");
+        }
+        return this;
+    };
+    return UndirectedGraph;
+}(AbstractGraph_1.default));
+exports.default = UndirectedGraph;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/app/data-structures/Graph/_helpers/createGraph.d.ts

@@ -0,0 +1,6 @@
+import IGraph from "../../../types/IGraph";
+import { EnumGraphType } from "../../../types/EnumGraphType";
+/**
+ * Returns graph by type
+ */
+export declare const createGraph: <T>(type: EnumGraphType) => IGraph<T>;

package/lib/app/data-structures/Graph/_helpers/createGraph.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraph = void 0;
+var DirectedGraph_1 = require("../DirectedGraph");
+var UndirectedGraph_1 = require("../UndirectedGraph");
+var EnumGraphType_1 = require("../../../types/EnumGraphType");
+/**
+ * Returns graph by type
+ */
+exports.createGraph = function (type) {
+    var graph;
+    switch (type) {
+        case EnumGraphType_1.EnumGraphType.Directed:
+            graph = new DirectedGraph_1.default();
+            break;
+        case EnumGraphType_1.EnumGraphType.Undirected:
+            graph = new UndirectedGraph_1.default();
+            break;
+    }
+    return graph;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlR3JhcGguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2RhdGEtc3RydWN0dXJlcy9HcmFwaC9faGVscGVycy9jcmVhdGVHcmFwaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSxrREFBNkM7QUFDN0Msc0RBQWlEO0FBQ2pELDhEQUE2RDtBQUU3RDs7R0FFRztBQUNVLFFBQUEsV0FBVyxHQUFHLFVBQUksSUFBbUI7SUFDaEQsSUFBSSxLQUFnQixDQUFDO0lBRXJCLFFBQVEsSUFBSSxFQUFFO1FBQ1osS0FBSyw2QkFBYSxDQUFDLFFBQVE7WUFDekIsS0FBSyxHQUFHLElBQUksdUJBQWEsRUFBRSxDQUFDO1lBQzVCLE1BQU07UUFDUixLQUFLLDZCQUFhLENBQUMsVUFBVTtZQUMzQixLQUFLLEdBQUcsSUFBSSx5QkFBZSxFQUFFLENBQUM7WUFDOUIsTUFBTTtLQUNUO0lBRUQsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDLENBQUMifQ==

package/lib/app/data-structures/Graph/_helpers/createGraphFromMatrix.d.ts

@@ -0,0 +1,7 @@
+import IGraph from "../../../types/IGraph";
+import { EnumGraphType } from "../../../types/EnumGraphType";
+import { TypeArrayMatrix } from "../../../types/TypeArrayMatrix";
+/**
+ * Creates a graph from N*N matrix that contains 1 in case of edge exists or 0 in case it does not
+ */
+export declare const createGraphFromMatrix: <T>(matrix: TypeArrayMatrix, fieldsList: T[], type: EnumGraphType) => IGraph<T>;

package/lib/app/data-structures/Graph/_helpers/createGraphFromMatrix.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphFromMatrix = void 0;
+var EnumGraphType_1 = require("../../../types/EnumGraphType");
+var createGraph_1 = require("./createGraph");
+var constants_1 = require("../../../constants");
+var IllegalArgumentException_1 = require("../../../exceptions/base/IllegalArgumentException");
+var utils_1 = require("../../../utils");
+/**
+ * Creates a graph from N*N matrix that contains 1 in case of edge exists or 0 in case it does not
+ */
+exports.createGraphFromMatrix = function (matrix, fieldsList, type) {
+    if (!utils_1.checkIsArrayMatrix(matrix)) {
+        throw new IllegalArgumentException_1.default("Given array is not a matrix");
+    }
+    var graph = createGraph_1.createGraph(type);
+    fieldsList.forEach(function (fieldName) {
+        graph.addVertex(fieldName);
+    });
+    matrix.forEach(function (row, rowIndex) {
+        row.forEach(function (col, colIndex) {
+            var rowColState = matrix[rowIndex][colIndex];
+            var colRowState = matrix[colIndex][rowIndex];
+            if (type === EnumGraphType_1.EnumGraphType.Undirected) {
+                if (rowColState === constants_1.EDGE_EXISTS_STATE &&
+                    colRowState === constants_1.EDGE_EXISTS_STATE) {
+                    graph.addEdge(fieldsList[rowIndex], fieldsList[colIndex]);
+                }
+            }
+            if (type === EnumGraphType_1.EnumGraphType.Directed) {
+                if (rowColState === constants_1.EDGE_EXISTS_STATE) {
+                    graph.addEdge(fieldsList[rowIndex], fieldsList[colIndex]);
+                }
+                if (colRowState === constants_1.EDGE_EXISTS_STATE) {
+                    graph.addEdge(fieldsList[colIndex], fieldsList[rowIndex]);
+                }
+            }
+        });
+    });
+    return graph;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlR3JhcGhGcm9tTWF0cml4LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9kYXRhLXN0cnVjdHVyZXMvR3JhcGgvX2hlbHBlcnMvY3JlYXRlR3JhcGhGcm9tTWF0cml4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLDhEQUE2RDtBQUU3RCw2Q0FBNEM7QUFDNUMsZ0RBQXVEO0FBQ3ZELDhGQUF5RjtBQUN6Rix3Q0FBb0Q7QUFFcEQ7O0dBRUc7QUFDVSxRQUFBLHFCQUFxQixHQUFHLFVBQ25DLE1BQXVCLEVBQ3ZCLFVBQW9CLEVBQ3BCLElBQW1CO0lBRW5CLElBQUksQ0FBQywwQkFBa0IsQ0FBQyxNQUFNLENBQUMsRUFBRTtRQUMvQixNQUFNLElBQUksa0NBQXdCLENBQUMsNkJBQTZCLENBQUMsQ0FBQztLQUNuRTtJQUVELElBQU0sS0FBSyxHQUFjLHlCQUFXLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDM0MsVUFBVSxDQUFDLE9BQU8sQ0FBQyxVQUFDLFNBQVM7UUFDM0IsS0FBSyxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUM3QixDQUFDLENBQUMsQ0FBQztJQUVILE1BQU0sQ0FBQyxPQUFPLENBQUMsVUFBQyxHQUFrQixFQUFFLFFBQWdCO1FBQ2xELEdBQUcsQ0FBQyxPQUFPLENBQUMsVUFBQyxHQUFXLEVBQUUsUUFBZ0I7WUFDeEMsSUFBTSxXQUFXLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQy9DLElBQU0sV0FBVyxHQUFHLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUUvQyxJQUFJLElBQUksS0FBSyw2QkFBYSxDQUFDLFVBQVUsRUFBRTtnQkFDckMsSUFDRSxXQUFXLEtBQUssNkJBQWlCO29CQUNqQyxXQUFXLEtBQUssNkJBQWlCLEVBQ2pDO29CQUNBLEtBQUssQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxFQUFFLFVBQVUsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO2lCQUMzRDthQUNGO1lBRUQsSUFBSSxJQUFJLEtBQUssNkJBQWEsQ0FBQyxRQUFRLEVBQUU7Z0JBQ25DLElBQUksV0FBVyxLQUFLLDZCQUFpQixFQUFFO29CQUNyQyxLQUFLLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsRUFBRSxVQUFVLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQztpQkFDM0Q7Z0JBQ0QsSUFBSSxXQUFXLEtBQUssNkJBQWlCLEVBQUU7b0JBQ3JDLEtBQUssQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxFQUFFLFVBQVUsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO2lCQUMzRDthQUNGO1FBQ0gsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDLENBQUMsQ0FBQztJQUVILE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQyxDQUFDIn0=

package/lib/app/data-structures/Graph/_helpers/generateRandomGraph.d.ts

@@ -0,0 +1,4 @@
+import IGraph from "../../../types/IGraph";
+import { EnumGraphType } from "../../../types/EnumGraphType";
+import { EnumRandomGenerationFormat } from "../../../types/EnumRandomGenerationFormat";
+export declare const generateRandomGraph: (verticesCount: number, edgesCount: number, type?: EnumGraphType, format?: EnumRandomGenerationFormat) => IGraph<string>;