public void CheckPredecessorLineGraph()
{
AdjacencyGraph g = new AdjacencyGraph(true);
IVertex v1 = g.AddVertex();
IVertex v2 = g.AddVertex();
IVertex v3 = g.AddVertex();
IEdge e12 = g.AddEdge(v1,v2);
IEdge e23 = g.AddEdge(v2,v3);
EdgeDoubleDictionary weights = DijkstraShortestPathAlgorithm.UnaryWeightsFromEdgeList(g);
DijkstraShortestPathAlgorithm dij = new DijkstraShortestPathAlgorithm(g,weights);
PredecessorRecorderVisitor vis = new PredecessorRecorderVisitor();
dij.RegisterPredecessorRecorderHandlers(vis);
dij.Compute(v1);
EdgeCollection col = vis.Path(v2);
Assert.AreEqual(1,col.Count);
Assert.AreEqual(e12,col[0]);
col = vis.Path(v3);
Assert.AreEqual(2,col.Count);
Assert.AreEqual(e12,col[0]);
Assert.AreEqual(e23,col[1]);
}
public void AttachPredecessorRecorderVisitor()
{
AdjacencyGraph g = new AdjacencyGraph(true);
EdgeDoubleDictionary weights = DijkstraShortestPathAlgorithm.UnaryWeightsFromEdgeList(g);
DijkstraShortestPathAlgorithm dij = new DijkstraShortestPathAlgorithm(g,weights);
PredecessorRecorderVisitor vis = new PredecessorRecorderVisitor();
dij.RegisterPredecessorRecorderHandlers(vis);
}
public EdgeCollectionCollection GetAllEdgePaths()
{
if (this.graph.VerticesCount==0)
return new EdgeCollectionCollection();
DepthFirstSearchAlgorithm efs = new DepthFirstSearchAlgorithm(this.graph);
PredecessorRecorderVisitor vis =new PredecessorRecorderVisitor();
efs.RegisterPredecessorRecorderHandlers(vis);
// get root vertex
efs.Compute(this.Graph.Root);
return vis.AllPaths();
}
public override double Compute(IVertex src, IVertex sink)
{
if (src == null)
{
throw new ArgumentNullException("src");
}
if (sink == null)
{
throw new ArgumentNullException("sink");
}
IVertexEnumerator enumerator = base.VisitedGraph.get_Vertices().GetEnumerator();
while (enumerator.MoveNext())
{
IVertex vertex = enumerator.get_Current();
IEdgeEnumerator enumerator2 = base.VisitedGraph.OutEdges(vertex).GetEnumerator();
while (enumerator2.MoveNext())
{
IEdge edge = enumerator2.get_Current();
base.ResidualCapacities.set_Item(edge, base.Capacities.get_Item(edge));
}
}
base.Colors.set_Item(sink, 2);
while (base.Colors.get_Item(sink) != null)
{
PredecessorRecorderVisitor vis = new PredecessorRecorderVisitor(base.Predecessors);
VertexBuffer q = new VertexBuffer();
BreadthFirstSearchAlgorithm algorithm = new BreadthFirstSearchAlgorithm(this.ResidualGraph, q, base.Colors);
algorithm.RegisterPredecessorRecorderHandlers(vis);
algorithm.Compute(src);
if (base.Colors.get_Item(sink) != null)
{
this.Augment(src, sink);
}
}
double num = 0.0;
IEdgeEnumerator enumerator3 = base.VisitedGraph.OutEdges(src).GetEnumerator();
while (enumerator3.MoveNext())
{
IEdge edge2 = enumerator3.get_Current();
num += base.Capacities.get_Item(edge2) - base.ResidualCapacities.get_Item(edge2);
}
return num;
}
/// <summary>
/// Computes a set of eulerian trail, starting at <paramref name="s"/>
/// that spans the entire graph.
/// </summary>
/// <remarks>
/// <para>
/// This method computes a set of eulerian trail starting at <paramref name="s"/>
/// that spans the entire graph.The algorithm outline is as follows:
/// </para>
/// <para>
/// The algorithms iterates throught the Eulerian circuit of the augmented
/// graph (the augmented graph is the graph with additional edges to make
/// the number of odd vertices even).
/// </para>
/// <para>
/// If the current edge is not temporary, it is added to the current trail.
/// </para>
/// <para>
/// If the current edge is temporary, the current trail is finished and
/// added to the trail collection. The shortest path between the
/// start vertex <paramref name="s"/> and the target vertex of the
/// temporary edge is then used to start the new trail. This shortest
/// path is computed using the <see cref="BreadthFirstSearchAlgorithm"/>.
/// </para>
/// </remarks>
/// <param name="s">start vertex</param>
/// <returns>eulerian trail set, all starting at s</returns>
/// <exception cref="ArgumentNullException">s is a null reference.</exception>
/// <exception cref="Exception">Eulerian trail not computed yet.</exception>
public EdgeCollectionCollection Trails(IVertex s)
{
if (s==null)
throw new ArgumentNullException("s");
if (this.Circuit.Count==0)
throw new Exception("Circuit is empty");
// find the first edge in the circuit.
int i=0;
for(i=0;i<this.Circuit.Count;++i)
{
IEdge e = this.Circuit[i];
if (TemporaryEdges.Contains(e))
continue;
if (e.Source == s)
break;
}
if (i==this.Circuit.Count)
throw new Exception("Did not find vertex in eulerian trail?");
// create collections
EdgeCollectionCollection trails = new EdgeCollectionCollection();
EdgeCollection trail = new EdgeCollection();
BreadthFirstSearchAlgorithm bfs =
new BreadthFirstSearchAlgorithm(VisitedGraph);
PredecessorRecorderVisitor vis = new PredecessorRecorderVisitor();
bfs.RegisterPredecessorRecorderHandlers(vis);
bfs.Compute(s);
// go throught the edges and build the predecessor table.
int start = i;
for (;i<this.Circuit.Count;++i)
{
IEdge e = this.Circuit[i];
if (TemporaryEdges.Contains(e))
{
// store previous trail and start new one.
if(trail.Count != 0)
trails.Add(trail);
// start new trail
// take the shortest path from the start vertex to
// the target vertex
trail = vis.Path(e.Target);
}
else
trail.Add(e);
}
// starting again on the circuit
for (i=0;i<start;++i)
{
IEdge e = this.Circuit[i];
if (TemporaryEdges.Contains(e))
{
// store previous trail and start new one.
if(trail.Count != 0)
trails.Add(trail);
// start new trail
// take the shortest path from the start vertex to
// the target vertex
trail = vis.Path(e.Target);
}
else
trail.Add(e);
}
// adding the last element
if (trail.Count!=0)
trails.Add(trail);
return trails;
}
/// <summary>
/// Computes the maximum flow between <paramref name="src"/> and
/// <paramref name="sink"/>
/// </summary>
/// <param name="src"></param>
/// <param name="sink"></param>
/// <returns></returns>
public override double Compute(IVertex src, IVertex sink)
{
if (src==null)
throw new ArgumentNullException("src");
if (sink==null)
throw new ArgumentNullException("sink");
foreach(IVertex u in VisitedGraph.Vertices)
{
foreach(IEdge e in VisitedGraph.OutEdges(u))
{
ResidualCapacities[e] = Capacities[e];
}
}
Colors[sink] = GraphColor.Gray;
while (Colors[sink] != GraphColor.White)
{
PredecessorRecorderVisitor vis = new PredecessorRecorderVisitor(
Predecessors
);
VertexBuffer Q = new VertexBuffer();
BreadthFirstSearchAlgorithm bfs = new BreadthFirstSearchAlgorithm(
ResidualGraph,
Q,
Colors
);
bfs.RegisterPredecessorRecorderHandlers(vis);
bfs.Compute(src);
if (Colors[sink] != GraphColor.White)
Augment(src, sink);
} // while
double flow=0;
foreach(IEdge e in VisitedGraph.OutEdges(src))
flow += (Capacities[e] - ResidualCapacities[e]);
return flow;
}
public RunPipeCollection AllTestPipes()
{
if (this.graph.VerticesCount == 1)
{
// only the root vertex
return new RunPipeCollection();
}
DepthFirstSearchAlgorithm dfs = new DepthFirstSearchAlgorithm(
this.graph
);
// attach leaf recorder
PredecessorRecorderVisitor pred = new PredecessorRecorderVisitor();
dfs.RegisterPredecessorRecorderHandlers(pred);
dfs.Compute(this.Root);
// create pipies
RunPipeCollection pipes =
new RunPipeCollection();
foreach(EdgeCollection edges in pred.AllPaths())
{
RunPipe pipe = new RunPipe(this.Fixture);
foreach(IEdge e in edges)
{
pipe.Invokers.Add((RunInvokerVertex)e.Target);
}
pipes.Add(pipe);
}
return pipes;
}
public EdgeCollectionCollection Trails(IVertex s)
{
if (s == null)
{
throw new ArgumentNullException("s");
}
if (this.Circuit.Count == 0)
{
throw new Exception("Circuit is empty");
}
int num = 0;
num = 0;
while (num < this.Circuit.Count)
{
IEdge edge = this.Circuit.get_Item(num);
if (!this.TemporaryEdges.Contains(edge) && (edge.get_Source() == s))
{
break;
}
num++;
}
if (num == this.Circuit.Count)
{
throw new Exception("Did not find vertex in eulerian trail?");
}
EdgeCollectionCollection collections = new EdgeCollectionCollection();
EdgeCollection edges = new EdgeCollection();
BreadthFirstSearchAlgorithm algorithm = new BreadthFirstSearchAlgorithm(this.VisitedGraph);
PredecessorRecorderVisitor vis = new PredecessorRecorderVisitor();
algorithm.RegisterPredecessorRecorderHandlers(vis);
algorithm.Compute(s);
int num2 = num;
while (num < this.Circuit.Count)
{
IEdge edge2 = this.Circuit.get_Item(num);
if (this.TemporaryEdges.Contains(edge2))
{
if (edges.Count != 0)
{
collections.Add(edges);
}
edges = vis.Path(edge2.get_Target());
}
else
{
edges.Add(edge2);
}
num++;
}
for (num = 0; num < num2; num++)
{
IEdge edge3 = this.Circuit.get_Item(num);
if (this.TemporaryEdges.Contains(edge3))
{
if (edges.Count != 0)
{
collections.Add(edges);
}
edges = vis.Path(edge3.get_Target());
}
else
{
edges.Add(edge3);
}
}
if (edges.Count != 0)
{
collections.Add(edges);
}
return collections;
}
/// <summary>
/// Executes edge dfs
/// </summary>
/// <param name="g"></param>
public void TestAllActions(IVertexAndEdgeListGraph g, string path)
{
// Testing dfs all apth
DepthFirstSearchAlgorithm dfs = new DepthFirstSearchAlgorithm(g);
PredecessorRecorderVisitor visv = new PredecessorRecorderVisitor();
dfs.RegisterPredecessorRecorderHandlers(visv);
IVertex s0 = Traversal.FirstVertexIf(g.Vertices, new NameEqualPredicate("S0"));
dfs.Compute(s0);
Console.WriteLine("vertex paths");
foreach(EdgeCollection ec in visv.AllPaths())
{
foreach(IEdge edge in ec)
{
Console.WriteLine("{0}->{1}, {2}",
((NamedVertex)edge.Source).Name,
((NamedVertex)edge.Target).Name,
((NamedEdge)edge).Name
);
}
Console.WriteLine();
}
// end of dfs test
GraphvizAlgorithm gw = RenderActions(g,path);
// The all action algorithms
EdgeDepthFirstSearchAlgorithm edfs = CreateEdgeDfs(g);
// add tracer
AlgorithmTracerVisitor vis = AddTracer(edfs,path);
// add predecessor recorder
EdgePredecessorRecorderVisitor erec = AddPredecessorRecorder(edfs);
// computing all actions
edfs.Compute(s0);
// display end path edges
OutputEndPathEdges(erec);
// display all actions path
OutputAllActions(erec,gw,path);
}
