doc/attr.xml

Author: baydrea

bellman_ford.g

@@ -0,0 +1,45 @@
+LoadPackage("Digraphs");
+bellmanford := function(digraph, source)
+local distance, n, predecessor, i, inf, u, v, edge, w;
+n := DigraphNrVertices(digraph);
+#wouldn't  work for weighted digraphs
+inf := n+1;
+distance := List([1..n],x->0);
+predecessor := List([1..n],x->0);
+for i in DigraphVertices(digraph) do
+  distance[i] := inf;
+  predecessor[i] := 0;
+od;
+distance[source] := 0;
+for i in [1..n-1] do
+  for edge in DigraphEdges(digraph) do
+    u := edge[1];
+    v := edge[2];
+    #only works for unweighted graphs, w needs to be changed into a variable
+    w := 1;
+    if distance[u] + w < distance[v] then
+      distance[v] := distance[u] + w;
+      predecessor[v] := u;
+    fi;
+  od;
+od;
+for edge in DigraphEdges(digraph) do
+  u := edge[1];
+  v := edge[2];
+  #only works for unweighted graphs, w needs to be changed into a variable
+  w := 1;
+  if distance[u] + w < distance[v] then
+    Print("Graph contains a negative-weight cycle"); 
+  fi;
+od;
+for i in DigraphVertices(digraph) do
+  if distance[i] >= inf then
+    distance[i] := fail;
+  fi;
+  if predecessor[i] = 0 then
+    predecessor[i] := fail;
+  fi;
+od; 
+return [distance, predecessor];
+end;
+

doc/attr.xml

@@ -902,6 +902,36 @@ gap> DigraphShortestDistances(D);
 </ManSection>
 <#/GAPDoc>
 
+<#GAPDoc Label="UnweightedBellmanFord">
+<ManSection>
+  <Attr Name="UnweightedBellmanFord" Arg="digraph","source"/>
+  <Returns>A list of integers or <K>fail</K>.</Returns>
+  <Description>
+    If <A>digraph</A> is a digraph with <M>n</M> vertices, then this
+    function returns a list with two sublists of <M>n</M> entries, where each entry is
+    either a non-negative integer, or <K>fail</K>.  <P/>
+
+    If there is a directed path from <A>source</A> to vertex <C>i</C>, then
+    the value of the entry i in the first sublist is the length of the shortest such directed
+    path and the entry i in the second sublist is the vertex preceding the vertex of that entry. If no such directed path exists,     then the value of i is <C>fail</C>.  We use the convention that the distance from every vertex to
+    itself is <C>0</C> for all vertices <C>i</C>.
+    <P/>
+
+    <Example><![CDATA[
+gap> D := Digraph([[1, 2], [3], [1, 2], [4]]);
+<immutable digraph with 4 vertices, 6 edges>
+gap> UnweightedBellmanFord(D,2)
+[ [ 2, 0, 1, fail ], [ 3, fail, 2, fail ] ]
+gap> D := CycleDigraph(IsMutableDigraph, 3);
+<mutable digraph with 3 vertices, 3 edges>
+gap> UnweightedBellmanFord(D,3);
+[ [ 1, 2, 0 ], [ 3, 1, fail ] ]
+]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+
 <#GAPDoc Label="DigraphDiameter">
 <ManSection>
   <Attr Name="DigraphDiameter" Arg="digraph"/>

gap/attr.gd

@@ -45,6 +45,7 @@ DeclareAttribute("DigraphDegeneracy", IsDigraph);
 DeclareAttribute("DigraphDegeneracyOrdering", IsDigraph);
 DeclareAttribute("DIGRAPHS_Degeneracy", IsDigraph);
 DeclareAttribute("DigraphShortestDistances", IsDigraph);
+DeclareOperation("UnweightedBellmanFord", [IsDigraph, IsPosInt]);
 DeclareAttribute("DigraphDiameter", IsDigraph);
 DeclareAttribute("DigraphGirth", IsDigraph);
 DeclareAttribute("DigraphOddGirth", IsDigraph);

gap/attr.gi

@@ -700,6 +700,54 @@ end);
 # returns the vertices (i.e. numbers) of <D> ordered so that there are no
 # edges from <out[j]> to <out[i]> for all <i> greater than <j>.
 
+InstallMethod(UnweightedBellmanFord, "for a digraph by out-neighbours",
+[IsDigraph,IsPosInt],
+function(digraph, source)
+  local distance, n, predecessor, i, inf, u, v, edge, w;
+  n := DigraphNrVertices(digraph);
+  #wouldn't  work for weighted digraphs
+  inf := n+1;
+  distance := List([1..n],x->0);
+  predecessor := List([1..n],x->0);
+  for i in DigraphVertices(digraph) do
+    distance[i] := inf;
+    predecessor[i] := 0;
+  od;
+  distance[source] := 0;
+  for i in [1..n-1] do
+    for edge in DigraphEdges(digraph) do
+      u := edge[1];
+      v := edge[2];
+      #only works for unweighted graphs, w needs to be changed into a variable
+      w := 1;
+      if distance[u] + w < distance[v] then
+        distance[v] := distance[u] + w;
+        predecessor[v] := u;
+      fi;
+    od;
+  od;
+  for edge in DigraphEdges(digraph) do
+    u := edge[1];
+    v := edge[2];
+    #only works for unweighted graphs, w needs to be changed into a variable
+    w := 1;
+    if distance[u] + w < distance[v] then
+      Print("Graph contains a negative-weight cycle");
+    fi;
+  od;
+  for i in DigraphVertices(digraph) do
+    if distance[i] >= inf then
+      distance[i] := fail;
+    fi;
+    if predecessor[i] = 0 then
+      predecessor[i] := fail;
+    fi;
+  od;
+  return [distance, predecessor];
+end);
+
+
+
 InstallMethod(DigraphTopologicalSort, "for a digraph by out-neighbours",
 [IsDigraphByOutNeighboursRep],
 D -> DIGRAPH_TOPO_SORT(OutNeighbours(D)));

tst/standard/attr.tst

@@ -486,6 +486,24 @@ gap> DIGRAPH_ConnectivityDataForVertex(gr, 2);;
 gap> DigraphShortestDistances(gr);
 [ [ 0, 1, 1 ], [ 1, 0, 1 ], [ 1, 1, 0 ] ]
 
+#  UnweightedBellmanFord
+gap> gr := Digraph([[1, 2], [3], [1, 2], [4]]);
+<immutable digraph with 4 vertices, 6 edges>
+gap> UnweightedBellmanFord(gr,2);
+[ [ 2, 0, 1, fail ], [ 3, fail, 2, fail ] ]
+gap> gr := CycleDigraph(IsMutableDigraph, 3);
+<mutable digraph with 3 vertices, 3 edges>
+gap> UnweightedBellmanFord(gr,3);
+[ [ 1, 2, 0 ], [ 3, 1, fail ] ]
+gap> gr := Digraph([[],[]]);
+<immutable empty digraph with 2 vertices>
+gap> UnweightedBellmanFord(gr,2);
+[ [ fail, 0 ], [ fail, fail ] ]
+gap> gr := Digraph([[1],[2],[3],[4]]);
+<immutable digraph with 4 vertices, 4 edges>
+gap> UnweightedBellmanFord(gr,2);
+[ [ fail, 0, fail, fail ], [ fail, fail, fail, fail ] ]
+
 #  OutNeighbours and InNeighbours
 gap> gr := Digraph(rec(DigraphNrVertices := 10,
 >                      DigraphSource := [1, 1, 5, 5, 7, 10],