@raikuxq/alg-ds 1.1.5 → 1.2.0

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/{data-structures → app/data-structures}/Graph/DirectedGraph.js

@@ -15,6 +15,7 @@ var __extends = (this && this.__extends) || (function () {
 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
@@ -33,7 +34,7 @@ var DirectedGraph = /** @class */ (function (_super) {
     DirectedGraph.prototype.getEdgeByValue = function (from, to) {
         var edge = this._edges.find(function (edge) { return edge.fromVertex === from && edge.toVertex === to; });
         if (!edge) {
-            throw new Error("Edge not found");
+            throw new IsNotFoundException_1.default("Edge not found");
         }
         return edge;
     };
@@ -57,7 +58,7 @@ var DirectedGraph = /** @class */ (function (_super) {
             }
         }
         catch (_b) {
-            throw new Error("Edge cannot be added because one of vertices was not found");
+            throw new IsNotFoundException_1.default("Edge cannot be added because one of vertices was not found");
         }
         return this;
     };
@@ -75,11 +76,11 @@ var DirectedGraph = /** @class */ (function (_super) {
             this._edges = this._edges.filter(function (edge) { return edge !== edgeToRemove_1; });
         }
         catch (_a) {
-            throw new Error("Edge cannot be removed because one of vertices was not found");
+            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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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{data-structures → app/data-structures}/Graph/GraphEdge.js

@@ -40,4 +40,4 @@ var GraphEdge = /** @class */ (function () {
     return GraphEdge;
 }());
 exports.default = GraphEdge;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFZGdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2RhdGEtc3RydWN0dXJlcy9HcmFwaC9HcmFwaEVkZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQTs7R0FFRztBQUNIO0lBS0U7O09BRUc7SUFDSCxtQkFBbUIsVUFBYSxFQUFFLFFBQVcsRUFBRSxNQUFVO1FBQVYsdUJBQUEsRUFBQSxVQUFVO1FBQ3ZELElBQUksQ0FBQyxXQUFXLEdBQUcsVUFBVSxDQUFDO1FBQzlCLElBQUksQ0FBQyxTQUFTLEdBQUcsUUFBUSxDQUFDO1FBQzFCLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDO0lBQ3hCLENBQUM7SUFFRCxzQkFBSSxpQ0FBVTthQUFkO1lBQ0UsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDO1FBQzFCLENBQUM7OztPQUFBO0lBRUQsc0JBQUksK0JBQVE7YUFBWjtZQUNFLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQztRQUN4QixDQUFDOzs7T0FBQTtJQUVELHNCQUFJLDZCQUFNO2FBQVY7WUFDRSxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7UUFDdEIsQ0FBQzthQUVELFVBQVcsS0FBYTtZQUN0QixJQUFJLENBQUMsT0FBTyxHQUFHLEtBQUssQ0FBQztRQUN2QixDQUFDOzs7T0FKQTtJQUtILGdCQUFDO0FBQUQsQ0FBQyxBQTdCRCxJQTZCQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFZGdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FwcC9kYXRhLXN0cnVjdHVyZXMvR3JhcGgvR3JhcGhFZGdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUE7O0dBRUc7QUFDSDtJQUtFOztPQUVHO0lBQ0gsbUJBQW1CLFVBQWEsRUFBRSxRQUFXLEVBQUUsTUFBVTtRQUFWLHVCQUFBLEVBQUEsVUFBVTtRQUN2RCxJQUFJLENBQUMsV0FBVyxHQUFHLFVBQVUsQ0FBQztRQUM5QixJQUFJLENBQUMsU0FBUyxHQUFHLFFBQVEsQ0FBQztRQUMxQixJQUFJLENBQUMsT0FBTyxHQUFHLE1BQU0sQ0FBQztJQUN4QixDQUFDO0lBRUQsc0JBQUksaUNBQVU7YUFBZDtZQUNFLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQztRQUMxQixDQUFDOzs7T0FBQTtJQUVELHNCQUFJLCtCQUFRO2FBQVo7WUFDRSxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUM7UUFDeEIsQ0FBQzs7O09BQUE7SUFFRCxzQkFBSSw2QkFBTTthQUFWO1lBQ0UsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO1FBQ3RCLENBQUM7YUFFRCxVQUFXLEtBQWE7WUFDdEIsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUM7UUFDdkIsQ0FBQzs7O09BSkE7SUFLSCxnQkFBQztBQUFELENBQUMsQUE3QkQsSUE2QkMifQ==

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.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomGraph = void 0;
+var EnumGraphType_1 = require("../../../types/EnumGraphType");
+var createGraph_1 = require("./createGraph");
+var utils_1 = require("../../../utils");
+var EnumRandomGenerationFormat_1 = require("../../../types/EnumRandomGenerationFormat");
+var ValueOutOfRangeException_1 = require("../../../exceptions/ValueOutOfRangeException");
+var getRandomVertex = function () {
+    return "_" + Math.random().toString(36).substr(2, 9);
+};
+var getPossibleEdgesCount = function (type, verticesCount) {
+    var possibleEdgesCount = verticesCount * (verticesCount - 1);
+    switch (type) {
+        case EnumGraphType_1.EnumGraphType.Directed: {
+            break;
+        }
+        case EnumGraphType_1.EnumGraphType.Undirected: {
+            possibleEdgesCount = Math.floor(possibleEdgesCount / 2);
+            break;
+        }
+    }
+    return possibleEdgesCount;
+};
+var fillGraphRandomly = function (graph, format, verticesCount) {
+    switch (format) {
+        case EnumRandomGenerationFormat_1.EnumRandomGenerationFormat.Hash: {
+            for (var i = 0; i < verticesCount; i++) {
+                graph.addVertex(getRandomVertex());
+            }
+            break;
+        }
+        case EnumRandomGenerationFormat_1.EnumRandomGenerationFormat.Numbers: {
+            for (var i = 0; i < verticesCount; i++) {
+                graph.addVertex((i + 1).toString());
+            }
+            break;
+        }
+    }
+};
+exports.generateRandomGraph = function (verticesCount, edgesCount, type, format) {
+    if (type === void 0) { type = EnumGraphType_1.EnumGraphType.Undirected; }
+    if (format === void 0) { format = EnumRandomGenerationFormat_1.EnumRandomGenerationFormat.Numbers; }
+    var graph = createGraph_1.createGraph(type);
+    var possibleEdgesCount = getPossibleEdgesCount(type, verticesCount);
+    if (edgesCount <= 0 || edgesCount > possibleEdgesCount) {
+        throw new ValueOutOfRangeException_1.default("Edges count must be in range between 0 and " + possibleEdgesCount);
+    }
+    fillGraphRandomly(graph, format, verticesCount);
+    var addedVertices = graph.vertices();
+    var addedEdgesCount = 0;
+    while (addedEdgesCount < edgesCount) {
+        var randomizeIndex = function () {
+            return utils_1.randomizeNumberInRange(0, addedVertices.length);
+        };
+        var randomVertexFrom = addedVertices[randomizeIndex()];
+        var randomVertexTo = addedVertices[randomizeIndex()];
+        var isEdgeAlreadyExists = graph.hasEdge(randomVertexFrom, randomVertexTo);
+        var isTheSameVertex = randomVertexFrom === randomVertexTo;
+        if (!isTheSameVertex && !isEdgeAlreadyExists) {
+            graph.addEdge(randomVertexFrom, randomVertexTo);
+            addedEdgesCount++;
+        }
+    }
+    return graph;
+};
+//# sourceMappingURL=data:application/json;base64,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