occam-directed-graphs 3.0.37 → 3.0.41

package/src/directedGraph.js

@@ -4,307 +4,386 @@ import { arrayUtilities } from "necessary";
 
 import Edge from "./edge";
 import Cycle from "./cycle";
-import PartialCycle from "./partialCycle";
-import DirectedAcyclicGraph from "./directedAcyclicGraph";
+import Vertex from "./vertex";
 
-import { forwardsDepthFirstSearch } from "./utilities/vertex";
-import { checkEdgesIncludesEdge, removeEdgeFromEdges, edgesBySourceVertexName, edgesByTargetVertexName } from "./utilities/edge";
+import { orderIndexes, indexesFromVertexes } from "./utilities/index";
+import { orderVertexes, vertexNamesFromVertexes } from "./utilities/vertex";
 
-const { first, filter } = arrayUtilities;
+const { first } = arrayUtilities;
 
 export default class DirectedGraph {
-  constructor(cyclicEdges, directedAcyclicGraph) {
-    this.cyclicEdges = cyclicEdges;
-
-    this.directedAcyclicGraph = directedAcyclicGraph;
+  constructor(vertexMap) {
+    this.vertexMap = vertexMap;
   }
 
-  getCyclicEdges() {
-    return this.cyclicEdges;
+  getVertexNap() {
+    return this.vertexMap;
   }
 
-  getDirectedAcyclicGraph() {
-    return this.directedAcyclicGraph;
+  getVertexes() {
+    const vertexMapValues = Object.values(this.vertexMap),
+          vertexes = vertexMapValues; ///
+
+    return vertexes;
   }
 
-  getVertexNames() { return this.directedAcyclicGraph.getVertexNames(); }
+  getVertexNames() {
+    const vertexMapKeys = Object.keys(this.vertexMap),
+          vertexNames = vertexMapKeys;  ///
 
-  getOrderedVertexNames() { return this.directedAcyclicGraph.getOrderedVertexNames(); }
+    return vertexNames;
+  }
 
-  addVertexByVertexName(vertexName) { this.directedAcyclicGraph.addVertexByVertexName(vertexName); }
+  getOrderedVertexNames() {
+    const vertexes = this.getVertexes();
 
-  isEdgePresentByVertexNames(sourceVertexName, targetVertexName) { return this.directedAcyclicGraph.isEdgePresentByVertexNames(sourceVertexName, targetVertexName); }
+    orderVertexes(vertexes);
 
-  isVertexPresentByVertexName(vertexName) { return this.directedAcyclicGraph.isVertexPresentByVertexName(vertexName); }
+    const orderedVertexes = vertexes, ///
+          orderedVertexNames = vertexNamesFromVertexes(orderedVertexes);
 
-  getSuccessorVertexNamesByVertexName(vertexName) { return this.directedAcyclicGraph.getSuccessorVertexNamesByVertexName(vertexName); }
+    return orderedVertexNames;
+  }
 
-  getPredecessorVertexNamesByVertexName(vertexName) { return this.directedAcyclicGraph.getPredecessorVertexNamesByVertexName(vertexName); }
+  getVertexByVertexName(vertexName) {
+    const vertexPresent = this.isVertexPresentByVertexName(vertexName),
+          vertex = vertexPresent ?
+                     this.vertexMap[vertexName] :
+                       null;
 
-  getImmediatePredecessorVertexNamesByVertexName(vertexName, includeCyclicEdges = false) {
-    const immediatePredecessorVertexNames = this.directedAcyclicGraph.getImmediatePredecessorVertexNamesByVertexName(vertexName);
+    return vertex;
+  }
 
-    if (includeCyclicEdges) {
-      this.cyclicEdges.forEach((cyclicEdge) => {
-        const cyclicEdgeTargetVertexName = cyclicEdge.getTargetVertexName();
+  getEdgesBySourceVertexName(sourceVertexName) {
+    const edges = [],
+          sourceVertex = this.getVertexByVertexName(sourceVertexName);
 
-        if (cyclicEdgeTargetVertexName === vertexName) {
-          const cyclicEdgeSourceVertexName = cyclicEdge.getSourceVertexName(),
-                immediatePredecessorVertexName = cyclicEdgeSourceVertexName;  ///
+    if (sourceVertex !== null) {
+      const immediateSuccessorVertexes = sourceVertex.getImmediateSuccessorVertexes(),
+            immediateSuccessorVertexNames = vertexNamesFromVertexes(immediateSuccessorVertexes),
+            targetVertexNames = immediateSuccessorVertexNames;  ///
 
-          immediatePredecessorVertexNames.push(immediatePredecessorVertexName);
-        }
+      targetVertexNames.forEach((targetVertexName) => {
+        const edge = Edge.fromSourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
+
+        edges.push(edge);
       });
     }
 
-    return immediatePredecessorVertexNames;
+    return edges;
   }
 
-  getImmediateSuccessorVertexNamesByVertexName(vertexName, includeCyclicEdges = false) {
-    const immediateSuccessorVertexNames = this.directedAcyclicGraph.getImmediateSuccessorVertexNamesByVertexName(vertexName);
+  getEdgesByTargetVertexName(targetVertexName) {
+    const edges = [],
+          targetVertex = this.getVertexByVertexName(targetVertexName);
 
-    if (includeCyclicEdges) {
-      this.cyclicEdges.forEach((cyclicEdge) => {
-        const cyclicEdgeSourceVertexName = cyclicEdge.getSourceVertexName();
+    if (targetVertex !== null) {
+      const immediatePredecessorVertexes = targetVertex.getImmediatePredecessorVertexes(),
+            immediatePredecessorVertexNames = vertexNamesFromVertexes(immediatePredecessorVertexes),
+            sourceVertexNames = immediatePredecessorVertexNames;  ///
 
-        if (cyclicEdgeSourceVertexName === vertexName) {
-          const cyclicEdgeTargetVertexName = cyclicEdge.getTargetVertexName(),
-                immediateSuccessorVertexName = cyclicEdgeTargetVertexName;  ///
+      sourceVertexNames.forEach((sourceVertexName) => {
+        const edge = Edge.fromSourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
 
-          immediateSuccessorVertexNames.push(immediateSuccessorVertexName);
-        }
+        edges.push(edge);
       });
     }
 
-    return immediateSuccessorVertexNames;
+    return edges;
   }
 
-  areCyclesPresentByVertexName(vertexName) {
-    let cyclesPresent = false;
+  getFirstCycle() {
+    let firstCycle = null;
+
+    const cyclesPresent = this.areCyclesPresent();
+
+    if (cyclesPresent) {
+      const cyclicEdges = this.getCyclicEdges(),
+            firstCyclicEdge = first(cyclicEdges),
+            sourceVertexName = firstCyclicEdge.getSourceVertexName(), ///
+            targetVertexName = firstCyclicEdge.getTargetVertexName(), ///
+            sourceVertex = this.getVertexByVertexName(sourceVertexName),
+            targetVertex = this.getVertexByVertexName(targetVertexName);
 
-    const vertexPresent = this.directedAcyclicGraph.isVertexPresentByVertexName(vertexName);
+      targetVertex.forwardsDepthFirstSearch((vertex, predecessorVertexes) => {
+        let terminate = false;
 
-    if (vertexPresent) {
-      const firstCycle = this.getFirstCycleByVertexName(vertexName);
+        if (vertex === sourceVertex) {
+          terminate = true;
 
-      cyclesPresent = (firstCycle !== null);
+          const cycle = Cycle.fromSourceVertexAndPredecessorVertexes(sourceVertex, predecessorVertexes);  ///
+
+          firstCycle = cycle; ///
+        }
+
+        return terminate;
+      });
     }
 
-    return cyclesPresent;
+    return firstCycle;
   }
 
-  getFirstCycleByVertexName(vertexName) {
-    let firstCycle = null;
-    
-    const vertex = this.directedAcyclicGraph.getVertexByVertexName(vertexName),
-          cyclicEdges = this.cyclicEdges.slice(), ///
-          partialCycles = [],
-          cycles = [];
-
-    forwardsDepthFirstSearch(vertex, (visitedVertex, getPredecessorVertices) => {
-      const visitedVertexName = visitedVertex.getName(),
-            sourceVertexName = visitedVertexName; ///
-
-      filter(cyclicEdges, (cyclicEdge) => {
-        const matches = cyclicEdge.matchSourceVertexName(sourceVertexName);
-
-        if (matches) {
-          const predecessorVertices = getPredecessorVertices(),
-                partialCycle =  PartialCycle.fromCyclicEdgeAndPredecessorVertices(cyclicEdge, predecessorVertices);
-          
-          partialCycles.push(partialCycle);
-        } else {
-          return true;
+  getCyclicEdges() {
+    const cyclicEdges = [],
+          vertexes = this.getVertexes();
+
+    vertexes.forEach((vertex) => {
+      const sourceVertex = vertex,  ///
+            sourceVertexIndex = sourceVertex.getIndex();
+
+      vertex.forEachImmediateSuccessorVertex((immediateSuccessorVertex) => {
+        const targetVertex = immediateSuccessorVertex,  ///
+              targetVertexIndex = targetVertex.getIndex();
+
+        if (targetVertexIndex < sourceVertexIndex) {
+          const sourceVertexName = sourceVertex.getName(),
+                targetVertexName = targetVertex.getName(),
+                edge = Edge.fromSourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName),
+                cyclicEdge = edge;  ///
+
+          cyclicEdges.push(cyclicEdge);
         }
       });
 
-      const cyclicEdgesLength = cyclicEdges.length,
-            terminate = (cyclicEdgesLength === 0);
-
-      return terminate;
+      sourceVertex
     });
 
-    partialCycles.some((partialCycle) => {
-      const targetVertexName = partialCycle.getTargetVertexName(),
-            targetVertex = this.directedAcyclicGraph.getVertexByVertexName(targetVertexName);
+    return cyclicEdges;
+  }
 
-      forwardsDepthFirstSearch(targetVertex, (visitedVertex, getPredecessorVertices) => {
-        const visitedVertexName = visitedVertex.getName();
+  areCyclesPresent() {
+    const vertexes = this.getVertexes(),
+          cyclesPresent = vertexes.some((vertex) => {
+            const sourceVertex = vertex,  ///
+                  sourceVertexIndex = sourceVertex.getIndex(),
+                  cyclicEdgePresent = vertex.someImmediateSuccessorVertex((immediateSuccessorVertex) => {
+                    const targetVertex = immediateSuccessorVertex,  ///
+                          targetVertexIndex = targetVertex.getIndex();
+
+                    if (targetVertexIndex < sourceVertexIndex) {
+                      return true;
+                    }
+                  });
+
+            if (cyclicEdgePresent) {
+              return true;
+            }
+          });
 
-        if (visitedVertexName === vertexName) {
-          const predecessorVertices = getPredecessorVertices(),
-                successorVertices = predecessorVertices,  ///
-                cycle = Cycle.fromVertexNamePartialCycleAndSuccessorVertices(vertexName, partialCycle, successorVertices);
+    return cyclesPresent;
+  }
 
-          cycles.push(cycle);
-        }
+  isEdgePresent(edge) {
+    let edgePresent = false;
 
-        const cyclesLength = cycles.length,
-              terminate = (cyclesLength > 0);
+    const sourceVertexName = edge.getSourceVertexName(),
+          sourceVertex = this.getVertexByVertexName(sourceVertexName);
 
-        return terminate;
-      });
-    });
+    if (sourceVertex !== null) {
+      const targetVertexName = edge.getTargetVertexName(),
+            targetVertex = this.getVertexByVertexName(targetVertexName);
 
-    const cyclesLength = cycles.length;
-    
-    if (cyclesLength > 0) {
-      firstCycle = first(cycles);
+      if (targetVertex !== null) {
+        edgePresent = sourceVertex.isEdgePresentByTargetVertex(targetVertex);
+      }
     }
 
-    return firstCycle;
+    return edgePresent;
   }
 
-  getFirstCycle() {
-    const firstCyclicEdge = first(this.cyclicEdges),
-          cyclicEdge = firstCyclicEdge, ///
-          sourceVertexName = cyclicEdge.getSourceVertexName(),
-          vertexName = sourceVertexName,  ///
-          firstCycle = this.getFirstCycleByVertexName(vertexName);
+  isVertexPresentByVertexName(vertexName) {
+    const vertexNames = this.getVertexNames(),
+          vertexNamesIncludesVertexName = vertexNames.includes(vertexName),
+          vertexPresent = vertexNamesIncludesVertexName;  ///
 
-    return firstCycle;
+    return vertexPresent;
   }
 
-  areCyclesPresent() {
-    const cyclicEdgesLength = this.cyclicEdges.length,
-          cyclesPresent = (cyclicEdgesLength > 0);
+  addVertexByVertexName(vertexName) {
+    const vertexPresent = this.isVertexPresentByVertexName(vertexName);
 
-    return cyclesPresent;
-  }
+    if (!vertexPresent) {
+      const vertexNames = this.getVertexNames(),
+            vertexNamesLength = vertexNames.length,
+            name = vertexName,  ///
+            index = vertexNamesLength, ///
+            vertex = Vertex.fromNameAndIndex(name, index);
 
-  addVerticesByVertexNames(vertexNames) {
-    vertexNames.forEach((vertexName) => this.addVertexByVertexName(vertexName));
+      this.setVertexByVertexName(vertexName, vertex);
+    }
+
+    const vertex = this.getVertexByVertexName(vertexName);
+
+    return vertex;
   }
 
   removeVertexByVertexName(vertexName) {
-    this.directedAcyclicGraph.removeVertexByVertexName(vertexName);
+    const vertexPresent = this.isVertexPresentByVertexName(vertexName);
 
-    this.filterCyclicEdges();
-  }
+    if (!vertexPresent) {
+      return;
+    }
 
-  removeVerticesByVertexNames(vertexNames) {
-    vertexNames.forEach((vertexName) => this.removeVertexByVertexName(vertexName));
+    const vertex = this.getVertexByVertexName(vertexName);
+
+    vertex.forEachImmediateSuccessorVertex((immediateSuccessVertex) => {
+      const immediatePredecessorVertex = vertex;  ///
+
+      immediateSuccessVertex.removeImmediatePredecessorVertex(immediatePredecessorVertex);
+    });
+
+    vertex.forEachImmediatePredecessorVertex((immediatePredecessorVertex) => {
+      const immediateSuccessVertex = vertex;  ///
+
+      immediatePredecessorVertex.removeImmediateSuccessorVertex(immediateSuccessVertex);
+    });
+
+    this.deleteVertexByVertexName(vertexName);
+
+    const vertexes = this.getVertexes(),
+          deletedVertex = vertex, ///
+          deletedVertexIndex = deletedVertex.getIndex();
+
+    vertexes.forEach((vertex) => {
+      const vertexIndex = vertex.getIndex();
+
+      if (vertexIndex > deletedVertexIndex) {
+        vertex.decrementIndex();
+      }
+    });
+
+    this.filterCyclicEdges();
   }
 
   addEdge(edge) {
-    const success = this.directedAcyclicGraph.addEdge(edge);
-    
-    if (!success) {
-      const cyclicEdgesIncludesEdge = checkEdgesIncludesEdge(edge, this.cyclicEdges);
+    const sourceVertexName = edge.getSourceVertexName(),
+          targetVertexName = edge.getTargetVertexName();
 
-      if (!cyclicEdgesIncludesEdge) {
-        const cyclicEdge = edge;  ///
+    if (sourceVertexName === targetVertexName) {
+      return;
+    }
 
-        this.cyclicEdges.push(cyclicEdge);
-      }
+    const sourceVertex = this.addVertexByVertexName(sourceVertexName),
+          targetVertex = this.addVertexByVertexName(targetVertexName),
+          edgePresent = sourceVertex.isEdgePresentByTargetVertex(targetVertex);
+
+    if (edgePresent) {
+      return;
     }
+
+    const sourceVertexIndex = sourceVertex.getIndex(),
+          targetVertexIndex = targetVertex.getIndex();
+
+    if (sourceVertexIndex > targetVertexIndex) {
+      this.reorderVertexesBySourceVertexAndTargetVertex(sourceVertex, targetVertex);
+    }
+
+    const immediatePredecessorVertex = sourceVertex, ///
+          immediateSuccessorVertex = targetVertex; ///
+
+    immediatePredecessorVertex.addImmediateSuccessorVertex(immediateSuccessorVertex);
+
+    immediateSuccessorVertex.addImmediatePredecessorVertex(immediatePredecessorVertex);
   }
-  
+
   addEdges(edges) {
-    edges.forEach((edge) => this.addEdge(edge));
+    edges.forEach((edge) => {
+      this.addEdge(edge);
+    });
   }
 
-  removeEdge(edge, removeStrandedVertices = false) {
-    const cyclicEdgesIncludesEdge = checkEdgesIncludesEdge(edge, this.cyclicEdges),
-          edgePresent = this.directedAcyclicGraph.isEdgePresent(edge),
-          edgeCyclic = cyclicEdgesIncludesEdge; ///
-
-    if (false) {
-      ///
-    } else if (edgeCyclic) {
-      const cyclicEdge = edge;  ///
-
-      removeEdgeFromEdges(cyclicEdge, this.cyclicEdges);
-    } else if (edgePresent) {
-      this.directedAcyclicGraph.removeEdge(edge);
-
-      if (removeStrandedVertices) {
-        const sourceVertexName = edge.getSourceVertexName(),
-              targetVertexName = edge.getTargetVertexName(),
-              sourceVertex = this.directedAcyclicGraph.getVertexByVertexName(sourceVertexName),
-              targetVertex = this.directedAcyclicGraph.getVertexByVertexName(targetVertexName),
-              sourceVertexStranded = sourceVertex.isStranded(),
-              targetVertexStranded = targetVertex.isStranded();
-
-        if (sourceVertexStranded) {
-          this.directedAcyclicGraph.removeVertexByVertexName(sourceVertexName);
-        }
+  removeEdge(edge, removeStrandedVertexes) {
+    const sourceVertexName = edge.getSourceVertexName(),
+          targetVertexName = edge.getTargetVertexName(),
+          sourceVertex = this.addVertexByVertexName(sourceVertexName),
+          targetVertex = this.addVertexByVertexName(targetVertexName),
+          edgePresent = sourceVertex.isEdgePresentByTargetVertex(targetVertex);
 
-        if (targetVertexStranded) {
-          this.directedAcyclicGraph.removeVertexByVertexName(targetVertexName);
-        }
+    if (!edgePresent) {
+      return;
+    }
+
+    sourceVertex.removeImmediateSuccessorVertex(targetVertex);
+
+    targetVertex.removeImmediatePredecessorVertex(sourceVertex);
+
+    if (removeStrandedVertexes) {
+      const sourceVertexStranded = sourceVertex.isStranded(),
+            targetVertexStranded = targetVertex.isStranded();
+
+      if (sourceVertexStranded) {
+        this.removeVertexByVertexName(sourceVertexName);
+      }
+
+      if (targetVertexStranded) {
+        this.removeVertexByVertexName(targetVertexName);
       }
     }
 
     this.filterCyclicEdges();
   }
 
-  removeEdges(edges, removeStrandedVertices = false) {
-    edges.forEach((edge) => this.removeEdge(edge, removeStrandedVertices));
+  removeEdges(edges, removeStrandedVertexes = false) {
+    edges.forEach((edge) => {
+      this.removeEdge(edge, removeStrandedVertexes);
+    });
   }
 
-  addEdgeByVertexNames(sourceVertexName, targetVertexName) {
-    const edge = Edge.fromSourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
-
-    this.addEdge(edge);
+  removeAllEdgesAndVertexes() {
+    this.vertexMap = {};
   }
 
-  removeEdgeByVertexNames(sourceVertexName, targetVertexName, removeStrandedVertices = false) {
-    const edge = Edge.fromSourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
+  reorderVertexesBySourceVertexAndTargetVertex(sourceVertex, targetVertex) {
+    const sourceVertexReachable = targetVertex.isVertexReachable(sourceVertex);
 
-    this.removeEdge(edge, removeStrandedVertices);
-  }
+    if (sourceVertexReachable) {
+      return;
+    }
 
-  removeEdgesByTargetVertexName(targetVertexName, removeStrandedVertices = false) {
-    const cyclicEdges = edgesByTargetVertexName(targetVertexName, this.cyclicEdges),
-          edges = this.directedAcyclicGraph.getEdgesByTargetVertexName(targetVertexName);
+    const forwardsVisitedVertexes = targetVertex.retrieveForwardsVisitedVertexes(),
+          backwardsVisitedVertexes = sourceVertex.retrieveBackwardsVisitedVertexes();
 
-    this.removeEdges(cyclicEdges, removeStrandedVertices);
+    orderVertexes(backwardsVisitedVertexes);
 
-    this.removeEdges(edges, removeStrandedVertices);
-  }
+    orderVertexes(forwardsVisitedVertexes);
 
-  removeEdgesBySourceVertexName(sourceVertexName, removeStrandedVertices = false) {
-    const cyclicEdges = edgesBySourceVertexName(sourceVertexName, this.cyclicEdges),
-          edges = this.directedAcyclicGraph.getEdgesBySourceVertexName(sourceVertexName);
+    const visitedVertexes = [
+            ...backwardsVisitedVertexes,
+            ...forwardsVisitedVertexes
+          ],
+          visitedIndexes = indexesFromVertexes(visitedVertexes);
 
-    this.removeEdges(cyclicEdges, removeStrandedVertices);
+    orderIndexes(visitedIndexes);
 
-    this.removeEdges(edges, removeStrandedVertices);
-  }
+    visitedVertexes.forEach((visitedVertex, index) => {
+      const visitedIndex = visitedIndexes[index];
 
-  removeAllEdgesAndVertices() {
-    this.directedAcyclicGraph = DirectedAcyclicGraph.fromNothing();
+      index = visitedIndex; ///
 
-    this.cyclicEdges = [];
+      visitedVertex.setIndex(index);
+    });
   }
 
   filterCyclicEdges() {
-    filter(this.cyclicEdges, (cyclicEdge) => {
-      const sourceVertexName = cyclicEdge.getSourceVertexName(),
-            targetVertexName = cyclicEdge.getTargetVertexName(),
-            sourceVertexPresent = this.isVertexPresentByVertexName(sourceVertexName),
-            targetVertexPresent = this.isVertexPresentByVertexName(targetVertexName);
-
-      if (sourceVertexPresent && targetVertexPresent) {
-        return true;
-      }
-    });
+    const cyclicEdges = this.getCyclicEdges(),
+          edges = cyclicEdges;  ///
 
-    filter(this.cyclicEdges, (cyclicEdge) => {
-      const edge = cyclicEdge,  ///
-            success = this.directedAcyclicGraph.addEdge(edge);
+    this.removeEdges(edges);
 
-      if (!success) {
-        return true;
-      }
-    });
+    this.addEdges(edges);
+  }
+
+  setVertexByVertexName(vertexName, vertex) {
+    this.vertexMap[vertexName] = vertex;
+  }
+
+  deleteVertexByVertexName(vertexName) {
+    delete this.vertexMap[vertexName];
   }
 
   static fromNothing() {
-    const cyclicEdges = [],
-          directedAcyclicGraph = DirectedAcyclicGraph.fromNothing(),
-          directedGraph = new DirectedGraph(cyclicEdges, directedAcyclicGraph);
+    const vertexMap = {},
+          directedGraph = new DirectedGraph(vertexMap);
     
     return directedGraph;    
   }

package/src/index.js

@@ -1,4 +1,6 @@
 "use strict";
 
 export { default as Edge } from "./edge";
+export { default as Cycle } from "./cycle";
+export { default as Vertex } from "./vertex";
 export { default as DirectedGraph } from "./directedGraph";

package/src/utilities/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+export function orderIndexes(indexes) {  ///
+  indexes.sort((firstIndex, secondIndex) => {
+    if (false) {
+      ///
+    } else if (firstIndex < secondIndex) {
+      return -1;
+    } else  if (firstIndex > secondIndex) {
+      return +1;
+    } else {
+      return 0;
+    }
+  });
+}
+
+export function indexesFromVertexes(vertexes) {
+  const indexes = vertexes.map((vertex) => {
+    const index = vertex.getIndex();
+
+    return index;
+  });
+
+  return indexes;
+}