Merge branch 'pr/31'

* pr/31:
  Fix bug in Graph.Reducers.Bfs inbound edge detection
  Use ID as vertex label when generating DOT output
  Add Bellman ford alogorythm

Author: bitwalker

lib/graph.ex

@@ -45,6 +45,7 @@ defmodule Graph do
   @type edge_key :: {vertex_id, vertex_id}
   @type edge_value :: %{label => edge_weight}
   @type graph_type :: :directed | :undirected
+  @type vertices :: %{vertex_id => vertex}
   @type t :: %__MODULE__{
           in_edges: %{vertex_id => MapSet.t()},
           out_edges: %{vertex_id => MapSet.t()},
@@ -320,6 +321,24 @@ defmodule Graph do
   @spec dijkstra(t, vertex, vertex) :: [vertex]
   defdelegate dijkstra(g, a, b), to: Graph.Pathfinding
 
+  @doc """
+  ## Example
+
+      iex> g = Graph.new |> Graph.add_edges([
+      ...>   {:b, :c, weight: -2}, {:a, :b, weight: 1},
+      ...>   {:c, :d, weight: 3}, {:b, :d, weight: 4}])
+      ...> Graph.bellman_ford(g, :a)
+      %{97 => 0, 98 => 1, 99 => -1, 100 => 2}
+
+      iex> g = Graph.new |> Graph.add_edges([
+      ...>   {:b, :c, weight: -2}, {:a, :b, weight: -1},
+      ...>   {:c, :d, weight: -3}, {:d, :a, weight: -5}])
+      ...> Graph.bellman_ford(g, :a)
+      nil
+  """
+  @spec bellman_ford(t, vertex) :: [vertex]
+  defdelegate bellman_ford(g, a), to: Graph.Pathfinding
+
   @doc """
   Gets the shortest path between `a` and `b`.
 

lib/graph/pathfinding.ex

@@ -6,6 +6,9 @@ defmodule Graph.Pathfinding do
 
   @type heuristic_fun :: (Graph.vertex() -> integer)
 
+  @spec bellman_ford(Graph.t, Graph.vertex) :: [Graph.vertex]
+  def bellman_ford(g, a), do: Pathfindings.BellmanFord.call(g, a)
+
   @doc """
   Finds the shortest path between `a` and `b` as a list of vertices.
   Returns `nil` if no path can be found.

lib/graph/pathfindings/bellman_ford.ex

@@ -0,0 +1,62 @@
+defmodule Pathfindings.BellmanFord do
+  @moduledoc """
+  The Bellman–Ford algorithm is an algorithm that computes shortest paths from a single
+  source vertex to all of the other vertices in a weighted digraph.
+  It is capable of handling graphs in which some of the edge weights are negative numbers
+
+  Time complexity: O(VLogV)
+  """
+  import Graph.Utils, only: [vertex_id: 1]
+
+  @type distance :: %{Graph.vertex_id => integer}
+
+  @doc """
+  Returns nil when graph has negative cycle.
+  """
+  @spec call(Graph.t, Graph.vertex) :: [Graph.vertex] | nil
+  def call(%Graph{vertices: vs, edges: meta}, a) do
+    distances = a |> vertex_id |> init_distances(vs)
+
+    distances = vs |> Enum.reduce(distances, fn (_vertex, distances) ->
+      meta |> Enum.reduce(distances, &update_distance(&1, &2))
+    end)
+
+    if has_negative_cycle?(distances, meta) do
+      nil
+    else
+      distances
+    end
+  end
+
+  @spec init_distances(Graph.vertex, Graph.vertices) :: distance
+  defp init_distances(vertex_id, vertices) do
+    Enum.reduce(vertices, Map.new, fn {id, _vertex}, dist ->
+      Map.put(dist, id, init_distance_value(id, vertex_id))
+    end)
+  end
+
+  defp init_distance_value(vertex_id, id) when vertex_id == id, do: 0
+  defp init_distance_value(_, _), do: :infinity
+
+  @spec update_distance(term, distance) :: distance
+  defp update_distance({{u, v}, _} = edge, distances) do
+    weight = edge_weight(edge)
+
+    if distances[u] != :infinity and distances[u] + weight < distances[v] do
+      Map.replace!(distances, v, distances[u] + weight)
+    else
+      distances
+    end
+  end
+
+  @spec edge_weight(term) :: float
+  defp edge_weight({_, edge_value}), do: edge_value |> Map.values |> List.first
+
+  defp has_negative_cycle?(distances, meta) do
+    meta |> Enum.reduce(false, fn({{u, v}, _} = edge, has_cycle) ->
+      weight = edge_weight(edge)
+
+      has_cycle or distances[u] != :infinity and distances[u] + weight < distances[v]
+    end)
+  end
+end

lib/graph/reducers/bfs.ex

@@ -50,18 +50,25 @@ defmodule Graph.Reducers.Bfs do
       ...> #{__MODULE__}.reduce(g, [], fn 4, acc -> {:halt, acc}; v, acc -> {:next, [v|acc]} end)
       [3, 1]
   """
-  def reduce(%Graph{vertices: vs, in_edges: ie} = g, acc, fun) when is_function(fun, 2) do
+  def reduce(%Graph{vertices: vs} = g, acc, fun) when is_function(fun, 2) do
     vs
     # Start with a cost of zero
     |> Stream.map(fn {id, _} -> {id, 0} end)
     # Only populate the initial queue with those vertices which have no inbound edges
-    |> Stream.filter(fn {id, _cost} -> is_nil(Map.get(ie, id)) end)
+    |> Stream.reject(fn {id, _cost} -> inbound_edges?(g, id) end)
     |> Enum.reduce(PriorityQueue.new(), fn {id, cost}, q ->
       PriorityQueue.push(q, id, cost)
     end)
     |> traverse(g, MapSet.new(), fun, acc)
   end
 
+  defp inbound_edges?(%Graph{in_edges: ie}, v_id) do
+    case Map.get(ie, v_id) do
+      nil -> false
+      edges -> MapSet.size(edges) > 0
+    end
+  end
+
   defp traverse(q, %Graph{out_edges: oe, vertices: vertices} = g, visited, fun, acc) do
     case PriorityQueue.pop(q) do
       {{:value, v_id}, q1} ->

lib/graph/serializers/dot.ex

@@ -14,27 +14,23 @@ defmodule Graph.Serializers.DOT do
 
   defp serialize_nodes(%Graph{vertices: vertices} = g) do
     Enum.reduce(vertices, "", fn {id, v}, acc ->
-      acc <> Serializer.indent(1) <> Serializer.get_vertex_label(g, id, v) <> "\n"
+      acc <> Serializer.indent(1) <> "#{id}" <> "[label=" <> Serializer.get_vertex_label(g, id, v) <> "]\n"
     end)
   end
 
-  defp serialize_edges(%Graph{type: type, vertices: vertices, out_edges: oe, edges: em} = g) do
+  defp serialize_edges(%Graph{type: type, vertices: vertices, out_edges: oe, edges: em} = _g) do
     edges =
-      Enum.reduce(vertices, [], fn {id, v}, acc ->
-        v_label = Serializer.get_vertex_label(g, id, v)
-
+      Enum.reduce(vertices, [], fn {id, _v}, acc ->
         edges =
           oe
           |> Map.get(id, MapSet.new())
           |> Enum.flat_map(fn id2 ->
-            v2_label = Serializer.get_vertex_label(g, id2, Map.get(vertices, id2))
-
             Enum.map(Map.fetch!(em, {id, id2}), fn
               {nil, weight} ->
-                {v_label, v2_label, weight}
+                {id, id2, weight}
 
               {label, weight} ->
-                {v_label, v2_label, weight, Serializer.encode_label(label)}
+                {id, id2, weight, Serializer.encode_label(label)}
             end)
           end)
 
@@ -47,16 +43,16 @@ defmodule Graph.Serializers.DOT do
     arrow = if type == :directed, do: "->", else: "--"
 
     Enum.reduce(edges, "", fn
-      {v_label, v2_label, weight, edge_label}, acc ->
+      {v_id, v2_id, weight, edge_label}, acc ->
         acc <>
           Serializer.indent(1) <>
-          v_label <>
-          " #{arrow} " <> v2_label <> " [" <> "label=#{edge_label}; weight=#{weight}" <> "]\n"
+          "#{v_id}" <>
+          " #{arrow} " <> "#{v2_id}" <> " [" <> "label=#{edge_label}; weight=#{weight}" <> "]\n"
 
-      {v_label, v2_label, weight}, acc ->
+      {v_id, v2_id, weight}, acc ->
         acc <>
           Serializer.indent(1) <>
-          v_label <> " #{arrow} " <> v2_label <> " [" <> "weight=#{weight}" <> "]\n"
+          "#{v_id}" <> " #{arrow} " <> "#{v2_id}" <> " [" <> "weight=#{weight}" <> "]\n"
     end)
   end
 end

test/graph_test.exs

@@ -289,6 +289,12 @@ defmodule GraphTest do
              ["start", "start_0", 95, 94, 93, 39, 38, 21, 69, 68, "end_0", "end"]
   end
 
+  test "shortest paths for complex graph using signed weights (negative and positive)" do
+    g = build_complex_signed_graph()
+    shortest_paths = Graph.bellman_ford(g, :a)
+    assert shortest_paths == %{97 => 0, 98 => -1, 99 => 2, 100 => -2, 101 => 1}
+  end
+
   test "edge undirected graph v1 > v2" do
     g = build_basic_undirected_graph()
     e1 = Graph.edge(g, :a, :b)
@@ -629,6 +635,18 @@ defmodule GraphTest do
     |> Graph.add_edge(:c, :b)
   end
 
+  defp build_complex_signed_graph do
+    Graph.new
+    |> Graph.add_edge(:a, :b, weight: -1)
+    |> Graph.add_edge(:b, :e, weight: 2)
+    |> Graph.add_edge(:e, :d, weight: -3)
+    |> Graph.add_edge(:d, :c, weight: 5)
+    |> Graph.add_edge(:a, :c, weight: 4)
+    |> Graph.add_edge(:b, :c, weight: 3)
+    |> Graph.add_edge(:b, :d, weight: 2)
+    |> Graph.add_edge(:d, :b, weight: 1)
+  end
+
   defp build_complex_graph(type \\ :directed) do
     Graph.new(type: type)
     |> Graph.add_edge(42, 25, weight: 2525)

test/reducer_test.exs

@@ -33,4 +33,21 @@ defmodule Graph.Reducer.Test do
     expected = [:a, :b, :d, :c, :f, :e, :g]
     assert ^expected = Graph.Reducers.Bfs.map(g, fn v -> v end)
   end
+
+  test "can walk a graph breadth-first, when the starting points had their in-edges deleted" do
+    g = Graph.new
+    |> Graph.add_vertices([:a, :b, :c, :d, :e, :f, :g])
+    |> Graph.add_edge(:a, :b)
+    |> Graph.add_edge(:a, :d)
+    |> Graph.add_edge(:b, :c)
+    |> Graph.add_edge(:b, :d)
+    |> Graph.add_edge(:c, :e)
+    |> Graph.add_edge(:d, :f)
+    |> Graph.add_edge(:f, :g)
+    |> Graph.add_edge(:b, :a) # Add this edge and then remove it
+    |> Graph.delete_edge(:b, :a)
+
+    expected = [:a, :b, :d, :c, :f, :e, :g]
+    assert ^expected = Graph.Reducers.Bfs.map(g, fn v -> v end)
+  end
 end