Implement the shortestPaths function that chooses whether to use Dijk…

…stra or Bellmanford.

lib/alg/bellman-ford.js

@@ -16,9 +16,9 @@ function bellmanFord(g, source, weightFn, edgeFn) {
 
 function runBellmanFord(g, source, weightFn, edgeFn) {
   var results = {},
-      didADistanceUpgrade = true,
-      iterations = 0,
-      nodes = g.nodes();
+    didADistanceUpgrade = true,
+    iterations = 0,
+    nodes = g.nodes();
 
   var relaxEdge = function(edge) {
     var edgeWeight = weightFn(edge);

lib/alg/index.js

@@ -9,6 +9,7 @@ module.exports = {
   postorder: require("./postorder"),
   preorder: require("./preorder"),
   prim: require("./prim"),
+  shortestPaths: require("./shortest-paths"),
   tarjan: require("./tarjan"),
   topsort: require("./topsort")
 };

lib/alg/shortest-paths.js

@@ -0,0 +1,42 @@
+var dijkstra = require("./dijkstra"),
+  bellmanFord = require("./bellman-ford");
+
+module.exports = shortestPaths;
+
+function shortestPaths(g, source, weightFn, edgeFn){
+  return runShortestPaths(
+    g,
+    source,
+    weightFn,
+    edgeFn || function(v) { return g.outEdges(v); }
+  );
+}
+
+function runShortestPaths(g, source, weightFn, edgeFn) {
+  if (weightFn === undefined) {
+    return dijkstra(g, source, weightFn, edgeFn);
+  }
+
+  var negativeEdgeExists = false;
+  var nodes = g.nodes();
+
+  for (var i = 0; i < nodes.length; i++) {
+    var adjList = edgeFn(nodes[i]);
+
+    for (var j = 0; j < adjList.length; j++) {
+      var edge = adjList[j];
+      var inVertex = edge.v === nodes[i] ? edge.v : edge.w;
+      var outVertex = inVertex === edge.v ? edge.w : edge.v;
+
+      if (weightFn({ v: inVertex, w: outVertex }) < 0) {
+        negativeEdgeExists = true;
+      }
+    }
+
+    if (negativeEdgeExists) {
+      return bellmanFord(g, source, weightFn, edgeFn);
+    }
+  }
+
+  return dijkstra(g, source, weightFn, edgeFn);
+}

test/alg/bellman-ford-tests.js

@@ -1,7 +1,7 @@
 var expect = require("../chai").expect,
-    Graph = require("../..").Graph,
-    bellmanFord = require("../..").alg.bellmanFord,
-    shortestPathsTests = require("./shortest-paths-tests.js");
+  Graph = require("../..").Graph,
+  bellmanFord = require("../..").alg.bellmanFord,
+  shortestPathsTests = require("./shortest-paths-tests.js");
 
 describe("alg.bellmanFord", function(){
   shortestPathsTests(bellmanFord);

test/alg/dijkstra-test.js

@@ -1,7 +1,7 @@
 var expect = require("../chai").expect,
-    Graph = require("../..").Graph,
-    dijkstra = require("../..").alg.dijkstra,
-    shortestPathsTests = require("./shortest-paths-tests.js");
+  Graph = require("../..").Graph,
+  dijkstra = require("../..").alg.dijkstra,
+  shortestPathsTests = require("./shortest-paths-tests.js");
 
 describe("alg.dijkstra", function() {
   shortestPathsTests(dijkstra);

test/alg/shortest-paths-tests.js

@@ -1,5 +1,6 @@
 var expect = require("../chai").expect,
-    Graph = require("../..").Graph;
+  Graph = require("../..").Graph,
+  alg = require("../..").alg;
 
 module.exports = tests;
 
@@ -75,6 +76,29 @@ function tests(algorithm) {
   });
 }
 
+// Test shortestPaths() function
+describe("alg.shortestPaths", function() {
+  tests(alg.shortestPaths);
+
+  it("uses dijkstra if no weightFn is provided", function() {
+    var g = new Graph();
+    g.setPath(["a", "b", "c"]);
+    g.setEdge("b", "d", -10);
+
+    expect(alg.shortestPaths(g, "a")).to.eql(alg.dijkstra(g, "a"));
+  });
+
+  it("uses bellman-ford if the graph contains a negative edge", function() {
+    var g = new Graph();
+    g.setEdge("a", "b", 10);
+    g.setEdge("b", "c", 8);
+    g.setEdge("a", "d", -3);
+    g.setEdge("d", "c", 2);
+
+    expect(alg.shortestPaths(g, "a", weightFn(g))).to.eql(alg.bellmanFord(g, "a", weightFn(g)));
+  });
+});
+
 function weightFn(g) {
   return function(e) {
     return g.edge(e);