/// <summary>Constructs a maximum flow algorithm.</summary>
/// <param name="g">Graph to compute maximum flow on.</param>
/// <param name="capacities">edge capacities</param>
/// <param name="reversedEdges">reversed edge map</param>
/// <exception cref="ArgumentNullException"><paramref name="g"/> or
/// <paramref name="capacities"/> or <paramref name="reversedEdges"/> is a null
/// reference.
/// </exception>
public MaximumFlowAlgorithm(
IVertexListGraph g,
EdgeDoubleDictionary capacities,
EdgeEdgeDictionary reversedEdges
)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
if (capacities == null)
{
throw new ArgumentNullException("capacities");
}
if (reversedEdges == null)
{
throw new ArgumentNullException("reversedEdges");
}
this.visitedGraph = g;
this.capacities = capacities;
this.reversedEdges = reversedEdges;
this.predecessors = new VertexEdgeDictionary();
this.residualCapacities = new EdgeDoubleDictionary();
this.colors = new VertexColorDictionary();
}
/// <summary>
/// Generates the dot code to be rendered with GraphViz
/// </summary>
/// <param name="outputFileName">output file name</param>
/// <returns>corrected output file name</returns>
/// <remarks>
/// The output filename extension is automatically matched with the
/// output file type.
/// </remarks>
public string Write(string outputFileName)
{
if (outputFileName == null)
{
throw new ArgumentNullException("outputFileName");
}
ClusterCount = 0;
m_StringWriter = new StringWriter();
Output.WriteLine("digraph G {");
String gf = GraphFormat.ToDot();
if (gf.Length > 0)
{
Output.WriteLine(gf);
}
String vf = CommonVertexFormat.ToDot();
if (vf.Length > 0)
{
Output.WriteLine("node [{0}];", vf);
}
String ef = CommonEdgeFormat.ToDot();
if (ef.Length > 0)
{
Output.WriteLine("edge [{0}];", ef);
}
OnWriteGraph();
// initialize vertex map
VertexColorDictionary colors = new VertexColorDictionary();
foreach (IVertex v in VisitedGraph.Vertices)
{
colors[v] = GraphColor.White;
}
EdgeColorDictionary edgeColors = new EdgeColorDictionary();
foreach (IEdge e in VisitedGraph.Edges)
{
edgeColors[e] = GraphColor.White;
}
// write
if (VisitedGraph is IClusteredGraph)
{
WriteClusters(colors, edgeColors, VisitedGraph as IClusteredGraph);
}
WriteVertices(colors, VisitedGraph.Vertices);
WriteEdges(edgeColors, VisitedGraph.Edges);
Output.WriteLine("}");
return(m_Dot.Run(ImageType, Output.ToString(), outputFileName));
}
public static FilteredVertexAndEdgeListGraph FilteredFsm()
{
AdjacencyGraph g = Fsm();
// putting all black besides S4
// therefore all the edges touching s4 will be filtered out.
VertexColorDictionary vertexColors = new VertexColorDictionary();
IVertexPredicate pred = new NameEqualPredicate("S4");
foreach (IVertex v in g.Vertices)
{
if (pred.Test(v))
{
vertexColors[v] = GraphColor.Black;
}
else
{
vertexColors[v] = GraphColor.White;
}
}
IVertexPredicate vp = new NoBlackVertexPredicate(vertexColors);
IEdgePredicate ep = new EdgePredicate(
new KeepAllEdgesPredicate(),
vp
);
return(new FilteredVertexAndEdgeListGraph(g,
ep,
vp
));
}
private void edgeDepthFirstSearchItem_Click(object sender, System.EventArgs e)
{
if (this.netronPanel.Graph == null)
{
throw new Exception("Generate a graph first");
}
if (this.netronPanel.Populator == null)
{
throw new Exception("Populator should not be null.");
}
ResetVertexAndEdgeColors();
// create algorithm
this.vertexColors = null;
this.edgeColors = new EdgeColorDictionary();
EdgeDepthFirstSearchAlgorithm edfs =
new EdgeDepthFirstSearchAlgorithm(this.netronPanel.Graph, this.edgeColors);
// create tracer
LayoutAlgorithmTraverVisitor tracer = new LayoutAlgorithmTraverVisitor(this.netronPanel.Populator);
// link to algo
edfs.RegisterTreeEdgeBuilderHandlers(tracer);
edfs.RegisterEdgeColorizerHandlers(tracer);
// add handler to tracers
tracer.UpdateVertex += new ShapeVertexEventHandler(tracer_UpdateVertex);
tracer.UpdateEdge += new ConnectionEdgeEventHandler(tracer_UpdateEdge);
// running algorithm
Thread thread = new Thread(new ThreadStart(edfs.Compute));
thread.Start();
}
/// <summary>
/// Construct the edge predicate with the edge color map
/// </summary>
/// <param name="edgeColors">edge color map</param>
/// <remarks>
/// The vertex color map must be initialize for the graph edges.
/// </remarks>
public NoBlackVertexPredicate(VertexColorDictionary vertexColors)
{
if (vertexColors == null)
{
throw new ArgumentNullException("vertexColors");
}
m_VertexColors = vertexColors;
}
/// <summary>
/// A depth first search algorithm on a directed graph
/// </summary>
/// <param name="g">The graph to traverse</param>
/// <exception cref="ArgumentNullException">g is null</exception>
public DepthFirstSearchAlgorithm(IVertexListGraph g)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
m_VisitedGraph = g;
m_Colors = new VertexColorDictionary();
}
/// <summary>
/// A height first search algorithm on a directed graph
/// </summary>
/// <param name="g">The graph to traverse</param>
/// <exception cref="ArgumentNullException">g is null</exception>
public HeightFirstSearchAlgorithm(IBidirectionalVertexListGraph g)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
this.visitedGraph = g;
this.colors = new VertexColorDictionary();
}
/// <summary>
/// Create a undirected dfs algorithm
/// </summary>
/// <param name="g">Graph to search on.</param>
public UndirectedDepthFirstSearchAlgorithm(IBidirectionalVertexAndEdgeListGraph g)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
visitedGraph = g;
edgeColors = new EdgeColorDictionary();
colors = new VertexColorDictionary();
}
internal void WriteVertices(VertexColorDictionary colors,
IVertexEnumerable vertices)
{
foreach (IVertex v in vertices)
{
if (colors[v] == GraphColor.White)
{
OnWriteVertex(v);
OnFormatVertex(v);
colors[v] = GraphColor.Black;
}
}
}
private void breadthFirstSearchItem_Click(object sender, System.EventArgs e)
{
if (this.netronPanel.Graph == null)
{
throw new Exception("Generate a graph first");
}
if (this.netronPanel.Populator == null)
{
throw new Exception("Populator should not be null.");
}
ResetVertexAndEdgeColors();
// create algorithm
this.edgeColors = new EdgeColorDictionary();
foreach (IEdge edge in this.netronPanel.Graph.Edges)
{
this.edgeColors[edge] = GraphColor.White;
}
this.vertexColors = new VertexColorDictionary();
BreadthFirstSearchAlgorithm bfs = new BreadthFirstSearchAlgorithm(
this.netronPanel.Graph,
new VertexBuffer(),
this.vertexColors);
// create tracer
LayoutAlgorithmTraverVisitor tracer = new LayoutAlgorithmTraverVisitor(this.netronPanel.Populator);
// link to algo
bfs.RegisterTreeEdgeBuilderHandlers(tracer);
bfs.RegisterVertexColorizerHandlers(tracer);
bfs.TreeEdge += new EdgeEventHandler(dfs_TreeEdge);
bfs.NonTreeEdge += new EdgeEventHandler(dfs_BackEdge);
bfs.BlackTarget += new EdgeEventHandler(dfs_ForwardOrCrossEdge);
// add handler to tracers
tracer.UpdateVertex += new ShapeVertexEventHandler(tracer_UpdateVertex);
tracer.UpdateEdge += new ConnectionEdgeEventHandler(tracer_UpdateEdge);
// running algorithm
VertexMethodCaller vm =
new VertexMethodCaller(
new ComputeVertexDelegate(bfs.Compute),
Traversal.FirstVertex(this.netronPanel.Graph)
);
Thread thread = new Thread(new ThreadStart(vm.Run));
thread.Start();
}
/// <summary>
/// Builds a new Bellman Ford searcher.
/// </summary>
/// <param name="g">The graph</param>
/// <param name="weights">Edge weights</param>
/// <exception cref="ArgumentNullException">Any argument is null</exception>
/// <remarks>This algorithm uses the <seealso cref="BreadthFirstSearchAlgorithm"/>.</remarks>
public BellmanFordShortestPathAlgorithm(
IVertexAndEdgeListGraph g,
EdgeDoubleDictionary weights
)
{
if (weights == null)
{
throw new ArgumentNullException("Weights");
}
m_VisitedGraph = g;
m_Colors = new VertexColorDictionary();
m_Weights = weights;
m_Distances = new VertexDoubleDictionary();
m_Predecessors = new VertexVertexDictionary();
}
/// <summary>
/// A depth first search algorithm on a directed graph
/// </summary>
/// <param name="g">The graph to traverse</param>
/// <param name="colors">vertex color map</param>
/// <exception cref="ArgumentNullException">g or colors are null</exception>
public NeighborDepthFirstSearchAlgorithm(
IBidirectionalVertexListGraph g,
VertexColorDictionary colors
)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
if (colors == null)
{
throw new ArgumentNullException("Colors");
}
this.visitedGraph = g;
this.colors = colors;
}
internal void WriteClusters(
VertexColorDictionary colors,
EdgeColorDictionary edgeColors,
IClusteredGraph parent
)
{
++ClusterCount;
foreach (IVertexAndEdgeListGraph g in parent.Clusters)
{
Output.Write("subgraph cluster{0}", ClusterCount.ToString());
Output.WriteLine(" {");
OnFormatCluster(g);
if (g is IClusteredGraph)
{
WriteClusters(colors, edgeColors, g as IClusteredGraph);
}
if (parent.Colapsed)
{
// draw cluster
// put vertices as black
foreach (IVertex v in g.Vertices)
{
colors[v] = GraphColor.Black;
}
foreach (IEdge e in g.Edges)
{
edgeColors[e] = GraphColor.Black;
}
// add fake vertex
}
else
{
WriteVertices(colors, g.Vertices);
WriteEdges(edgeColors, g.Edges);
}
Output.WriteLine("}");
}
}
private void depthFirstSearchAlgorithmItem_Click(object sender, System.EventArgs e)
{
if (this.netronPanel.Graph == null)
{
throw new Exception("Generate a graph first");
}
// clear colors
ResetVertexAndEdgeColors();
// create algorithm
this.edgeColors = new EdgeColorDictionary();
foreach (IEdge edge in this.netronPanel.Graph.Edges)
{
this.edgeColors[edge] = GraphColor.White;
}
this.vertexColors = new VertexColorDictionary();
DepthFirstSearchAlgorithm dfs = new DepthFirstSearchAlgorithm(
this.netronPanel.Graph,
this.vertexColors);
// create tracer
LayoutAlgorithmTraverVisitor tracer = new LayoutAlgorithmTraverVisitor(this.netronPanel.Populator);
// link to algo
dfs.RegisterTreeEdgeBuilderHandlers(tracer);
dfs.RegisterVertexColorizerHandlers(tracer);
dfs.TreeEdge += new EdgeEventHandler(dfs_TreeEdge);
dfs.BackEdge += new EdgeEventHandler(dfs_BackEdge);
dfs.ForwardOrCrossEdge += new EdgeEventHandler(dfs_ForwardOrCrossEdge);
// add handler to tracers
tracer.UpdateVertex += new ShapeVertexEventHandler(tracer_UpdateVertex);
tracer.UpdateEdge += new ConnectionEdgeEventHandler(tracer_UpdateEdge);
// running algorithm
Thread thread = new Thread(new ThreadStart(dfs.Compute));
thread.Start();
}
/// <summary>
/// Builds a new Dijsktra searcher.
/// </summary>
/// <param name="g">The graph</param>
/// <param name="weights">Edge weights</param>
/// <exception cref="ArgumentNullException">Any argument is null</exception>
/// <remarks>This algorithm uses the <seealso cref="BreadthFirstSearchAlgorithm"/>.</remarks>
public DijkstraShortestPathAlgorithm(
IVertexListGraph g,
EdgeDoubleDictionary weights
)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
if (weights == null)
{
throw new ArgumentNullException("Weights");
}
this.visitedGraph = g;
this.colors = new VertexColorDictionary();
this.distances = new VertexDoubleDictionary();
this.weights = weights;
this.vertexQueue = null;
}
/// <summary>
/// Builds a new Dijsktra searcher.
/// </summary>
/// <param name="g">The graph</param>
/// <param name="weights">Edge weights</param>
/// <exception cref="ArgumentNullException">Any argument is null</exception>
/// <remarks>This algorithm uses the <seealso cref="BreadthFirstSearchAlgorithm"/>.</remarks>
public DijkstraShortestPathAlgorithm(
IVertexListGraph g,
EdgeDoubleDictionary weights
)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
if (weights == null)
{
throw new ArgumentNullException("Weights");
}
m_VisitedGraph = g;
m_Colors = new VertexColorDictionary();
m_Distances = new VertexDoubleDictionary();
m_Predecessors = new VertexVertexDictionary();
m_Weights = weights;
m_VertexQueue = null;
}
/// <summary>
/// BreadthFirstSearch searcher contructor
/// </summary>
/// <param name="g">Graph to visit</param>
/// <param name="q">Vertex buffer</param>
/// <param name="colors">Vertex color map</param>
public BreadthFirstSearchAlgorithm(
IVertexListGraph g,
VertexBuffer q,
VertexColorDictionary colors
)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
if (q == null)
{
throw new ArgumentNullException("Stack Q is null");
}
if (colors == null)
{
throw new ArgumentNullException("Colors");
}
m_VisitedGraph = g;
m_Colors = colors;
m_Q = q;
}
private void FilterFsm()
{
AdjacencyGraph graph = GraphProvider.Fsm();
// drawing the fsm
DrawGraph(graph, "fsm");
// filtering
// putting all black besides S4
// therefore all the edges touching s4 will be filtered out.
VertexColorDictionary vertexColors = new VertexColorDictionary();
IVertexPredicate pred = new NameEqualPredicate("S4");
foreach (IVertex v in graph.Vertices)
{
if (pred.Test(v))
{
vertexColors[v] = GraphColor.Black;
}
else
{
vertexColors[v] = GraphColor.White;
}
}
IVertexPredicate vp = new NoBlackVertexPredicate(vertexColors);
IEdgePredicate ep = new EdgePredicate(
Preds.KeepAllEdges(),
vp
);
IVertexAndEdgeListGraph filteredGraph = new FilteredVertexAndEdgeListGraph(graph,
ep,
vp
);
DrawGraph(filteredGraph, "fsmfiltered");
}
public ReportResult RunTests()
{
ReportResult result = new ReportResult();
if (graph.VerticesCount == 0)
{
this.OnLog("No assembly to execute");
result.UpdateCounts();
return(result);
}
this.OnLog("Sorting assemblies by dependencies");
// create topological sort
ArrayList sortedVertices = new ArrayList();
TopologicalSortAlgorithm topo = new TopologicalSortAlgorithm(graph);
topo.Compute(sortedVertices);
if (sortedVertices.Count == 0)
{
throw new InvalidOperationException("Cannot be zero");
}
// set vertices colors
this.OnLog("Setting up fixture colors");
VertexColorDictionary colors = new VertexColorDictionary();
foreach (TestDomainVertex v in graph.Vertices)
{
colors.Add(v, GraphColor.White);
}
// execute each domain
foreach (TestDomainVertex v in sortedVertices)
{
// if vertex color is not white, skip it
GraphColor color = colors[v];
if (color != GraphColor.White)
{
this.OnLog("Skipping assembly {0} because dependent assembly failed", v.Domain.TestEngine.Explorer.AssemblyName);
// mark children
foreach (TestDomainVertex child in graph.AdjacentVertices(v))
{
colors[child] = GraphColor.Black;
}
continue;
}
this.OnLog("Loading {0}", v.Domain.TestEngine.Explorer.AssemblyName);
ReportCounter counter = v.Domain.TestEngine.GetTestCount();
this.OnLog("Found {0} tests", counter.RunCount);
this.OnLog("Running fixtures.");
v.Domain.TestEngine.RunPipes();
counter = v.Domain.TestEngine.GetTestCount();
this.OnLog("Tests finished: {0} tests, {1} success, {2} failures, {3} ignored"
, counter.RunCount
, counter.SuccessCount
, counter.FailureCount
, counter.IgnoreCount
);
result.Merge(v.Domain.TestEngine.Report.Result);
if (counter.FailureCount != 0)
{
// mark children as failed
colors[v] = GraphColor.Black;
foreach (TestDomainVertex child in graph.AdjacentVertices(v))
{
colors[child] = GraphColor.Black;
}
}
else
{
// mark vertex as succesfull
colors[v] = GraphColor.Gray;
}
}
result.UpdateCounts();
MbUnit.Framework.Assert.IsNotNull(result);
MbUnit.Framework.Assert.IsNotNull(result.Counter);
this.OnLog("All Tests finished: {0} tests, {1} success, {2} failures, {3} ignored in {4} seconds"
, result.Counter.RunCount
, result.Counter.SuccessCount
, result.Counter.FailureCount
, result.Counter.IgnoreCount
, result.Counter.Duration
);
return(result);
}
