occam-directed-graphs 3.0.37 → 3.0.42

package/src/utilities/search.js

@@ -0,0 +1,69 @@
+"use strict";
+
+export function forwardsDepthFirstSearch(vertex, callback, visitedVertexes, predecessorVertexes = []) {
+  let terminate = true;
+
+  const visitedVertexesIncludesVertex = visitedVertexes.includes(vertex);
+
+  if (!visitedVertexesIncludesVertex) {
+    const visitedVertex = vertex; ///
+
+    visitedVertexes.push(visitedVertex);
+
+    terminate = callback(vertex, predecessorVertexes);
+
+    if (!terminate) {
+      const predecessorVertex = vertex;  ///
+
+      predecessorVertexes = [ ///
+        ...predecessorVertexes,
+        predecessorVertex
+      ];
+
+      terminate = vertex.someImmediateSuccessorVertex((immediateSuccessorVertex) => {
+        const vertex = immediateSuccessorVertex,  ///
+              terminate = forwardsDepthFirstSearch(vertex, callback, visitedVertexes, predecessorVertexes);
+
+        if (terminate) {
+          return true;
+        }
+      });
+    }
+  }
+
+  return terminate;
+}
+
+export function backwardsDepthFirstSearch(vertex, callback, visitedVertexes, successorVertexes = []) {
+  let terminate = true;
+
+  const visitedVertexesIncludesVertex = visitedVertexes.includes(vertex);
+
+  if (!visitedVertexesIncludesVertex) {
+    const visitedVertex = vertex; ///
+
+    visitedVertexes.push(visitedVertex);
+
+    terminate = callback(vertex, successorVertexes);
+
+    if (!terminate) {
+      const successorVertex = vertex;  ///
+
+      successorVertexes = [ ///
+        ...successorVertexes,
+        successorVertex
+      ];
+
+      terminate = vertex.someImmediatePredecessorVertex((immediatePredecessorVertex) => {
+        const vertex = immediatePredecessorVertex,  ///
+              terminate = backwardsDepthFirstSearch(vertex, callback, visitedVertexes, successorVertexes);
+
+        if (terminate) {
+          return true;
+        }
+      });
+    }
+  }
+
+  return terminate;
+}

package/src/utilities/vertex.js

@@ -1,7 +1,7 @@
 "use strict";
 
-export function orderVertices(vertices) {  ///
-  vertices.sort((firstVertex, secondVertex) => {
+export function orderVertexes(vertexes) {  ///
+  vertexes.sort((firstVertex, secondVertex) => {
     const firstVertexIndex = firstVertex.getIndex(),
           secondVertexIndex = secondVertex.getIndex();
 
@@ -11,16 +11,14 @@ export function orderVertices(vertices) {  ///
       return -1;
     } else  if (firstVertexIndex > secondVertexIndex) {
       return +1;
+    } else {
+      return 0;
     }
   });
-
-  const orderedVertices = vertices;  ///
-
-  return orderedVertices;
 }
 
-export function vertexNamesFromVertices(vertices) {
-  const vertexNames = vertices.map((vertex) => {
+export function vertexNamesFromVertexes(vertexes) {
+  const vertexNames = vertexes.map((vertex) => {
     const vertexName = vertex.getName();
 
     return vertexName;
@@ -28,56 +26,3 @@ export function vertexNamesFromVertices(vertices) {
 
   return vertexNames;
 }
-
-export function forwardsDepthFirstSearch(vertex, callback) {
-  const visitedVertices = [];
-
-  retrieveForwardsVisitedVertices(vertex, (visitedVertex, getPredecessorVertices) => {
-    const terminate = callback(visitedVertex, getPredecessorVertices);  ///
-
-    visitedVertices.push(visitedVertex);
-
-    return terminate;
-  }, getPredecessorVertices);
-
-  visitedVertices.forEach((visitedVertex) => visitedVertex.resetVisited());
-
-  return visitedVertices;
-
-  function getPredecessorVertices() {
-    const predecessorVertices = [];
-    
-    return predecessorVertices;
-  }
-}
-
-function retrieveForwardsVisitedVertices(vertex, callback, getPredecessorVertices) {
-  let terminate = false;
-
-  if (vertex.visited === false) {
-    vertex.visited = true;
-
-    const visitedVertex = vertex;  ///
-
-    terminate = callback(visitedVertex, getPredecessorVertices);
-
-    if (terminate !== true) {
-      visitedVertex.someImmediateSuccessorVertex((immediateSuccessorVertex) => {
-        terminate = retrieveForwardsVisitedVertices(immediateSuccessorVertex, callback, () => {
-          let predecessorVertices = getPredecessorVertices();
-
-          const immediatePredecessorVertex = vertex,  ///
-                predecessorVertex = immediatePredecessorVertex; ///
-
-          predecessorVertices = predecessorVertices.concat(predecessorVertex);
-
-          return predecessorVertices;
-        });
-
-        return terminate;
-      });
-    }
-  }
-
-  return terminate;
-}

package/src/vertex.js

@@ -1,14 +1,18 @@
 "use strict";
 
-import { vertexNamesFromVertices, orderVertices } from "./utilities/vertex";
+import { arrayUtilities } from "necessary";
+
+import { vertexNamesFromVertexes } from "./utilities/vertex";
+import { forwardsDepthFirstSearch, backwardsDepthFirstSearch } from "./utilities/search";
+
+const { last, tail } = arrayUtilities;
 
 export default class Vertex {
-  constructor(name, index, visited, immediatePredecessorVertices, immediateSuccessorVertices) {
+  constructor(name, index, immediateSuccessorVertexes, immediatePredecessorVertexes) {
     this.name = name;
     this.index = index;
-    this.visited = visited;
-    this.immediatePredecessorVertices = immediatePredecessorVertices;
-    this.immediateSuccessorVertices = immediateSuccessorVertices;
+    this.immediateSuccessorVertexes = immediateSuccessorVertexes;
+    this.immediatePredecessorVertexes = immediatePredecessorVertexes;
   }
 
   getName() {
@@ -19,177 +23,114 @@ export default class Vertex {
     return this.index;
   }
 
-  isVisited() {
-    return this.visited;
+  getImmediateSuccessorVertexes() {
+    return this.immediateSuccessorVertexes;
   }
 
-  isStranded() {
-    const immediatePredecessorVerticesLength = this.immediatePredecessorVertices.length,
-          immediateSuccessorVerticesLength = this.immediateSuccessorVertices.length,
-          stranded = ((immediatePredecessorVerticesLength === 0) && (immediateSuccessorVerticesLength === 0));
-
-    return stranded;
+  getImmediatePredecessorVertexes() {
+    return this.immediatePredecessorVertexes;
   }
 
-  getImmediatePredecessorVertexNames() {
-    const immediatePredecessorVertexNames = this.immediatePredecessorVertices.map((immediatePredecessorVertex) => {
-      const immediatePredecessorVertexName = immediatePredecessorVertex.getName();
-
-      return immediatePredecessorVertexName;
-    });
+  isStranded() {
+    const immediateSuccessorVertexesLength = this.immediateSuccessorVertexes.length,
+          immediatePredecessorVertexesLength = this.immediatePredecessorVertexes.length,
+          stranded = ((immediateSuccessorVertexesLength === 0) && (immediatePredecessorVertexesLength === 0));
 
-    return immediatePredecessorVertexNames;
+    return stranded;
   }
 
-  getImmediateSuccessorVertexNames() {
-    const immediateSuccessorVertexNames = this.immediateSuccessorVertices.map((immediateSuccessorVertex) => {
-      const immediateSuccessorVertexName = immediateSuccessorVertex.getName();
+  isVertexReachable(vertex) {
+    const forwardsVisitedVertices = this.retrieveForwardsVisitedVertexes(vertex),
+          lastForwardsVisitedVertex = last(forwardsVisitedVertices),
+          vertexReachable = (vertex === lastForwardsVisitedVertex);
 
-      return immediateSuccessorVertexName;
-    });
-
-    return immediateSuccessorVertexNames;
+    return vertexReachable;
   }
 
-  getImmediatePredecessorVertices() {
-    return this.immediatePredecessorVertices;
-  }
+  isEdgePresentBySourceVertex(sourceVertex) {
+    const sourceVertexImmediatePredecessorVertex = this.isVertexImmediatePredecessorVertex(sourceVertex),
+          edgePresent = sourceVertexImmediatePredecessorVertex; ///
 
-  getImmediateSuccessorVertices() {
-    return this.immediateSuccessorVertices;
+    return edgePresent;
   }
 
-  getPredecessorVertexMap(predecessorVertexMap = {}) {
-    this.forEachImmediatePredecessorVertex((immediatePredecessorVertex) => {
-      const predecessorVertex = immediatePredecessorVertex, ///
-            predecessorVertexName = predecessorVertex.getName();
-
-      predecessorVertexMap[predecessorVertexName] = predecessorVertex;
-
-      predecessorVertex.getPredecessorVertexMap(predecessorVertexMap);
-    });
+  isEdgePresentByTargetVertex(targetVertex) {
+    const targetVertexImmediateSuccessorVertex = this.isVertexImmediateSuccessorVertex(targetVertex),
+          edgePresent = targetVertexImmediateSuccessorVertex; ///
 
-    return predecessorVertexMap;
+    return edgePresent;
   }
 
-  getSuccessorVertexMap(successorVertexMap = {}) {
-    this.forEachImmediateSuccessorVertex((immediateSuccessorVertex) => {
-      const successorVertex = immediateSuccessorVertex, ///
-            successorVertexName = successorVertex.getName();
+  retrieveSuccessorVertexNames() {
+    const forwardsVisitedVertexes = this.retrieveForwardsVisitedVertexes(),
+          forwardsVisitedVertexesTail = tail(forwardsVisitedVertexes),
+          successorVertexes = forwardsVisitedVertexesTail,
+          successorVertexNames = vertexNamesFromVertexes(successorVertexes);
 
-      successorVertexMap[successorVertexName] = successorVertex;
-
-      successorVertex.getSuccessorVertexMap(successorVertexMap);
-    });
-
-    return successorVertexMap;
+    return successorVertexNames;
   }
 
-  getPredecessorVertexNames() {
-    const predecessorVertices = this.getPredecessorVertices(),
-          predecessorVertexNames = predecessorVertices.map((predecessorVertex) => {
-            const predecessorVertexName = predecessorVertex.getName();
-
-            return predecessorVertexName;
-          });
+  retrievePredecessorVertexNames() {
+    const backwardsVisitedVertexes = this.retrieveBackwardsVisitedVertexes(),
+          backwardsVisitedVertexesTail = tail(backwardsVisitedVertexes),
+          predecessorVertexes = backwardsVisitedVertexesTail,
+          predecessorVertexNames = vertexNamesFromVertexes(predecessorVertexes);
 
     return predecessorVertexNames;
   }
 
-  getSuccessorVertexNames() {
-    const successorVertices = this.getSuccessorVertices(),
-          successorVertexNames = successorVertices.map((successorVertex) => {
-            const successorVertexName = successorVertex.getName();
+  retrieveForwardsVisitedVertexes(vertex = null) {
+    const vertexA = vertex, ///
+          visitedVertexes = this.forwardsDepthFirstSearch((vertex) => {
+            const vertexB = vertex, ///
+                  terminate = (vertexA === vertexB);
 
-            return successorVertexName;
-          });
+            if (terminate) {
+              return true;
+            }
+          }),
+          forwardsVisitedVertexes = visitedVertexes;  ///
 
-    return successorVertexNames;
+    return forwardsVisitedVertexes;
   }
 
-  getPredecessorVertices() {
-    const predecessorVertexMap = this.getPredecessorVertexMap(),
-          predecessorVertexNames = Object.keys(predecessorVertexMap),
-          predecessorVertices = predecessorVertexNames.map((predecessorVertexName) => {
-            const predecessorVertex = predecessorVertexMap[predecessorVertexName];
+  retrieveBackwardsVisitedVertexes(vertex = null) {
+    const vertexA = vertex, ///
+          visitedVertexes = this.backwardsDepthFirstSearch((vertex) => {
+            const vertexB = vertex, ///
+                  terminate = (vertexA === vertexB);
 
-            return predecessorVertex;
-          });
+            if (terminate) {
+              return true;
+            }
+          }),
+          backwardsVisitedVertexes = visitedVertexes;  ///
 
-    return predecessorVertices;
+    return backwardsVisitedVertexes;
   }
 
-  getSuccessorVertices() {
-    const successorVertexMap = this.getSuccessorVertexMap(),
-          successorVertexNames = Object.keys(successorVertexMap),
-          successorVertices = successorVertexNames.map((successorVertexName) => {
-            const successorVertex = successorVertexMap[successorVertexName];
-  
-            return successorVertex;
-          });
-
-    return successorVertices;
-  }
-
-  getOrderedPredecessorVertexNames() {
-    const predecessorVertices = this.getPredecessorVertices();
-
-    orderVertices(predecessorVertices);
-
-    const orderedPredecessorVertices = predecessorVertices,  ///
-          orderedPredecessorVertexNames = vertexNamesFromVertices(orderedPredecessorVertices);
+  isVertexImmediateSuccessorVertex(vertex) {
+    const vertexImmediateSuccessorVertex = this.immediateSuccessorVertexes.includes(vertex);
 
-    return orderedPredecessorVertexNames;
-  }
-  
-  retrieveForwardsAffectedVertices(sourceVertex) {
-    const forwardsAffectedVertices = this.forwardsDepthFirstSearch((visitedVertex) => {
-      const terminate = (visitedVertex === sourceVertex);
-      
-      if (terminate) {
-        return true;
-      }
-    });
-    
-    return forwardsAffectedVertices;
+    return vertexImmediateSuccessorVertex;
   }
 
-  retrieveBackwardsAffectedVertices() {
-    const backwardsAffectedVertices = this.backwardsDepthFirstSearch((visitedVertex) => {
-      const terminate = false;
-
-      if (terminate) {
-        return true;
-      }
-    });
-    
-    return backwardsAffectedVertices;
-  }
-  
   isVertexImmediatePredecessorVertex(vertex) {
-    const vertexImmediatePredecessorVertex = this.immediatePredecessorVertices.includes(vertex);
+    const vertexImmediatePredecessorVertex = this.immediatePredecessorVertexes.includes(vertex);
 
     return vertexImmediatePredecessorVertex;
   }
 
-  isVertexImmediateSuccessorVertex(vertex) {
-    const vertexImmediateSuccessorVertex = this.immediateSuccessorVertices.includes(vertex);
-
-    return vertexImmediateSuccessorVertex;
-  }
-
-  isEdgePresentBySourceVertex(sourceVertex) {
-    const sourceVertexImmediatePredecessorVertex = this.isVertexImmediatePredecessorVertex(sourceVertex),
-          edgePresent = sourceVertexImmediatePredecessorVertex; ///
+  getImmediateSuccessorVertexNames() {
+    const immediateSuccessorVertexNames = vertexNamesFromVertexes(this.immediateSuccessorVertexes);
 
-    return edgePresent;
+    return immediateSuccessorVertexNames;
   }
 
-  isEdgePresentByTargetVertex(targetVertex) {
-    const targetVertexImmediateSuccessorVertex = this.isVertexImmediateSuccessorVertex(targetVertex),
-          edgePresent = targetVertexImmediateSuccessorVertex; ///
+  getImmediatePredecessorVertexNames() {
+    const immediatePredecessorVertexNames = vertexNamesFromVertexes(this.immediatePredecessorVertexes);
 
-    return edgePresent;
+    return immediatePredecessorVertexNames;
   }
 
   setName(name) {
@@ -200,159 +141,80 @@ export default class Vertex {
     this.index = index;
   }
 
-  setVisited(visited) {
-    this.visited = visited;
+  setImmediateSuccessorVertexes(immediateSuccessorVertexes) {
+    this.immediateSuccessorVertexes = immediateSuccessorVertexes;
+  }
+
+  setImmediatePredecessorVertexes(immediatePredecessorVertexes) {
+    this.immediatePredecessorVertexes = immediatePredecessorVertexes;
   }
 
   decrementIndex() {
     this.index--;
   }
 
-  removeImmediatePredecessorVertex(immediatePredecessorVertex) {
-    const index = this.immediatePredecessorVertices.indexOf(immediatePredecessorVertex),
-          start = index,  ///
-          deleteCount = 1;
+  addImmediateSuccessorVertex(immediateSuccessorVertex) {
+    this.immediateSuccessorVertexes.push(immediateSuccessorVertex);
+  }
 
-    this.immediatePredecessorVertices.splice(start, deleteCount);
+  addImmediatePredecessorVertex(immediatePredecessorVertex) {
+    this.immediatePredecessorVertexes.push(immediatePredecessorVertex);
   }
 
   removeImmediateSuccessorVertex(immediateSuccessorVertex) {
-    const index = this.immediateSuccessorVertices.indexOf(immediateSuccessorVertex),
+    const index = this.immediateSuccessorVertexes.indexOf(immediateSuccessorVertex),
           start = index,  ///
           deleteCount = 1;
 
-    this.immediateSuccessorVertices.splice(start, deleteCount);
+    this.immediateSuccessorVertexes.splice(start, deleteCount);
   }
-  
-  removeIncomingEdges() {
-    const immediateSuccessorVertex = this; ///
-    
-    this.immediatePredecessorVertices.forEach((immediatePredecessorVertex) => immediatePredecessorVertex.removeImmediateSuccessorVertex(immediateSuccessorVertex));
-
-    this.immediatePredecessorVertices = [];
-  }
-
-  removeOutgoingEdges() {
-    const immediatePredecessorVertex = this; ///
 
-    this.immediateSuccessorVertices.forEach((immediateSuccessorVertex) => immediateSuccessorVertex.removeImmediateSuccessorVertex(immediatePredecessorVertex));
-
-    this.immediateSuccessorVertices = [];
-  }
-
-  addImmediatePredecessorVertex(immediatePredecessorVertex) {
-    this.immediatePredecessorVertices.push(immediatePredecessorVertex);
-  }
+  removeImmediatePredecessorVertex(immediatePredecessorVertex) {
+    const index = this.immediatePredecessorVertexes.indexOf(immediatePredecessorVertex),
+          start = index,  ///
+          deleteCount = 1;
 
-  addImmediateSuccessorVertex(immediateSuccessorVertex) {
-    this.immediateSuccessorVertices.push(immediateSuccessorVertex);
+    this.immediatePredecessorVertexes.splice(start, deleteCount);
   }
 
   forwardsDepthFirstSearch(callback) {
-    const visitedVertices = [];
-
-    this.retrieveForwardsVisitedVertices((visitedVertex) => {
-      const terminate = callback(visitedVertex);  ///
+    const vertex = this,  ///
+          visitedVertexes = [];
 
-      visitedVertices.push(visitedVertex);
+    forwardsDepthFirstSearch(vertex, callback, visitedVertexes);
 
-      return terminate;
-    });
-
-    visitedVertices.forEach((visitedVertex) => visitedVertex.resetVisited());
-
-    return visitedVertices;
+    return visitedVertexes;
   }
 
   backwardsDepthFirstSearch(callback) {
-    const visitedVertices = [];
-
-    this.retrieveBackwardsVisitedVertices((visitedVertex) => {
-      const terminate = callback(visitedVertex);  ///
+    const vertex = this,  ///
+          visitedVertexes = [];
 
-      visitedVertices.push(visitedVertex);
+    backwardsDepthFirstSearch(vertex, callback, visitedVertexes);
 
-      return terminate;
-    });
-
-    visitedVertices.forEach((visitedVertex) => visitedVertex.resetVisited());
-
-    return visitedVertices;
-  }
-
-  retrieveForwardsVisitedVertices(callback) {
-    let terminate = false;
-
-    if (this.visited === false) {
-      this.visited = true;
-
-      const visitedVertex = this;  ///
-
-      terminate = callback(visitedVertex);
-
-      if (terminate !== true) {
-        visitedVertex.someImmediateSuccessorVertex((immediateSuccessorVertex) => {
-          terminate = immediateSuccessorVertex.retrieveForwardsVisitedVertices(callback);
-
-          if (terminate) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return terminate;
-  }
-
-  retrieveBackwardsVisitedVertices(callback) {
-    let terminate = false;
-
-    if (this.visited === false) {
-      this.visited = true;
-
-      const visitedVertex = this;  ///
-
-      terminate = callback(visitedVertex);
-
-      if (terminate !== true) {
-        visitedVertex.someImmediatePredecessorVertex((immediatePredecessorVertex) => {
-          terminate = immediatePredecessorVertex.retrieveBackwardsVisitedVertices(callback);
-
-          if (terminate) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return terminate;
+    return visitedVertexes;
   }
 
-  forEachImmediatePredecessorVertex(callback) {
-    this.immediatePredecessorVertices.forEach(callback);
-  }
-
-  forEachImmediateSuccessorVertex(callback) {
-    this.immediateSuccessorVertices.forEach(callback);
+  someImmediateSuccessorVertex(callback) {
+    return this.immediateSuccessorVertexes.some(callback);
   }
 
   someImmediatePredecessorVertex(callback) {
-    this.immediatePredecessorVertices.some(callback);
+    return this.immediatePredecessorVertexes.some(callback);
   }
 
-  someImmediateSuccessorVertex(callback) {
-    this.immediateSuccessorVertices.some(callback);
+  forEachImmediateSuccessorVertex(callback) {
+    this.immediateSuccessorVertexes.forEach(callback);
   }
 
-  resetVisited() {
-    this.visited = false;
+  forEachImmediatePredecessorVertex(callback) {
+    this.immediatePredecessorVertexes.forEach(callback);
   }
 
   static fromNameAndIndex(name, index) {
-    const visited = false,  ///
-          immediatePredecessorVertices = [],
-          immediateSuccessorVertices = [],
-          dependencyVertex = new Vertex(name, index, visited, immediatePredecessorVertices, immediateSuccessorVertices);
+    const immediateSuccessorVertexes = [],
+          immediatePredecessorVertexes = [],
+          dependencyVertex = new Vertex(name, index, immediateSuccessorVertexes, immediatePredecessorVertexes);
 
     return dependencyVertex;
   }