public void SortCyclicPUT_NEW1(AdjacencyGraph g, bool rndConstructor, bool allowParallelEdges, int numberOfVertices, bool toNull)
{
g = AdjacencyGraphFactory.CreateAcyclicGraph1(allowParallelEdges, numberOfVertices, toNull);
TopologicalSortAlgorithm topo;
List<IVertex> list = null;
if (g != null && g.VerticesCount > 0)
{
list = new List<IVertex>();
foreach (IVertex v in g.Vertices)
{
IVertex a = g.AddVertex();
list.Add(v);
}
g = createCycle(g);
}
if (rndConstructor)
topo = new TopologicalSortAlgorithm(g, list);
else
topo = new TopologicalSortAlgorithm(g);
topo.Compute();
for (int j = 0; j < topo.SortedVertices.Count; ++j)
{
PexObserve.ValueForViewing<IVertex>("Sorted Vertex", (IVertex)topo.SortedVertices[j]);
}
}
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 MaximumFlowDemo()
{
graph = new AdjacencyGraph(
new NamedVertexProvider(),
new EdgeProvider(),
true);
s = (NamedVertex)graph.AddVertex(); s.Name = "s";
x = (NamedVertex)graph.AddVertex(); x.Name = "x";
v = (NamedVertex)graph.AddVertex(); v.Name = "v";
w = (NamedVertex)graph.AddVertex(); w.Name = "w";
t = (NamedVertex)graph.AddVertex(); t.Name = "t";
sx = graph.AddEdge(s, x); capacities[sx] = 5;
sv = graph.AddEdge(s, v); capacities[sv] = 7;
xv = graph.AddEdge(x, v); capacities[xv] = 3;
xw = graph.AddEdge(x, w); capacities[xw] = 7;
wv = graph.AddEdge(w, v); capacities[wv] = 5;
wt = graph.AddEdge(w, t); capacities[wt] = 4;
vt = graph.AddEdge(v, t); capacities[vt] = 6;
this.graphviz = new GraphvizAlgorithm(this.graph);
this.graphviz.ImageType = NGraphviz.Helpers.GraphvizImageType.Svg;
this.graphviz.GraphFormat.RankDirection = NGraphviz.Helpers.GraphvizRankDirection.LR;
this.graphviz.FormatVertex+=new FormatVertexEventHandler(graphviz_FormatVertex);
this.graphviz.FormatEdge+=new FormatEdgeEventHandler(graphviz_FormatEdge);
this.reversedEdgeAugmentor = new ReversedEdgeAugmentorAlgorithm(this.graph);
this.reversedEdgeAugmentor.ReversedEdgeAdded += new EdgeEventHandler(reversedEdgeAugmentor_ReversedEdgeAdded);
}
public void Sort()
{
AdjacencyGraph g = new AdjacencyGraph(true);
Hashtable iv = new Hashtable();
int i = 0;
IVertex a = g.AddVertex();
iv[i++]=a;
IVertex b = g.AddVertex();
iv[i++]=b;
IVertex c = g.AddVertex();
iv[i++]=c;
IVertex d = g.AddVertex();
iv[i++]=d;
IVertex e = g.AddVertex();
iv[i++]=e;
g.AddEdge(a,b);
g.AddEdge(a,c);
g.AddEdge(b,c);
g.AddEdge(c,d);
g.AddEdge(a,e);
TopologicalSortAlgorithm topo = new TopologicalSortAlgorithm(g);
topo.Compute();
}
public void SortCyclicPUT_NEW(AdjacencyGraph g, IVertex[] listOfVertices, bool rndConstructor)
{
TopologicalSortAlgorithm topo;// = new TopologicalSortAlgorithm(g);
List<IVertex> list = null;
if (listOfVertices != null && g!= null)
{
list = new List<IVertex>();
foreach (IVertex v in listOfVertices)
{
IVertex a = g.AddVertex();
list.Add(v);
}
g = createCycle(g);
}
if (rndConstructor)
topo = new TopologicalSortAlgorithm(g, list);
else
topo = new TopologicalSortAlgorithm(g);
topo.Compute();
for (int j = 0; j < topo.SortedVertices.Count; ++j)
{
PexObserve.ValueForViewing<IVertex>("Sorted Vertex", (IVertex)topo.SortedVertices[j]);
}
}
// [PexFactoryMethod(typeof(AdjacencyGraph))]
public static AdjacencyGraph CreateAcyclicGraph1(bool allowParallelEdges_b, int numberOfVertices, bool toNull)
{
AdjacencyGraph adjacencyGraph;
if (toNull)
{
adjacencyGraph = new AdjacencyGraph(null, allowParallelEdges_b);
return null;
}
PexAssume.IsTrue(numberOfVertices < 10);
adjacencyGraph = new AdjacencyGraph(new VertexAndEdgeProvider(), allowParallelEdges_b);
/* IVertex u = adjacencyGraph.AddVertex();
IVertex v = adjacencyGraph.AddVertex();
IVertex w = adjacencyGraph.AddVertex();
adjacencyGraph.AddEdge(u, v);
adjacencyGraph.AddEdge(v, w);
adjacencyGraph.AddEdge(w, u);*/
//Adding remaining number of vertices
for (int count = 0; count < numberOfVertices; count++)
{
adjacencyGraph.AddVertex();
}
return adjacencyGraph;
}
public static AdjacencyGraph CreateAcyclicGraph(
VertexAndEdgeProvider provider_iVertexAndEdgeProvider,
bool allowParallelEdges_b,
int numberOfVertices
)
{
PexAssume.IsTrue(numberOfVertices < 50);
AdjacencyGraph adjacencyGraph
= new AdjacencyGraph(provider_iVertexAndEdgeProvider, allowParallelEdges_b);
IVertex u = adjacencyGraph.AddVertex();
IVertex v = adjacencyGraph.AddVertex();
IVertex w = adjacencyGraph.AddVertex();
adjacencyGraph.AddEdge(u, v);
adjacencyGraph.AddEdge(v, w);
adjacencyGraph.AddEdge(u, w);
//Adding remaining number of vertices
for (int count = 3; count < numberOfVertices; count++)
{
adjacencyGraph.AddVertex();
}
return adjacencyGraph;
}
public void Sort()
{
AdjacencyGraph g = new AdjacencyGraph(new VertexAndEdgeProvider(), true);
Hashtable iv = new Hashtable();
int i = 0;
IVertex a = g.AddVertex();
iv[i++]=a;
IVertex b = g.AddVertex();
iv[i++]=b;
IVertex c = g.AddVertex();
iv[i++]=c;
IVertex d = g.AddVertex();
iv[i++]=d;
IVertex e = g.AddVertex();
iv[i++]=e;
g.AddEdge(a,b);
g.AddEdge(a,c);
g.AddEdge(b,c);
g.AddEdge(c,d);
g.AddEdge(a,e);
TopologicalSortAlgorithm topo = new TopologicalSortAlgorithm(g);
topo.Compute();
for(int j=0;j<topo.SortedVertices.Count;++j)
{
Assert.AreEqual( (IVertex)iv[j], topo.SortedVertices[j]);
}
}
public void Test()
{
// create a new adjacency graph
AdjacencyGraph g = new AdjacencyGraph(new VertexAndEdgeProvider(), false);
// adding files and storing names
IVertex zig_cpp = g.AddVertex(); Names[zig_cpp]="zip.cpp";
IVertex boz_h = g.AddVertex(); Names[boz_h]="boz.h";
IVertex zag_cpp = g.AddVertex(); Names[zag_cpp]="zag.cpp";
IVertex yow_h = g.AddVertex(); Names[yow_h]="yow.h";
IVertex dax_h = g.AddVertex(); Names[dax_h]="dax.h";
IVertex bar_cpp = g.AddVertex(); Names[bar_cpp]="bar.cpp";
IVertex zow_h = g.AddVertex(); Names[zow_h]="zow.h";
IVertex foo_cpp = g.AddVertex(); Names[foo_cpp]="foo.cpp";
IVertex zig_o = g.AddVertex(); Names[zig_o]="zig.o";
IVertex zag_o = g.AddVertex(); Names[zag_o]="zago";
IVertex bar_o = g.AddVertex(); Names[bar_o]="bar.o";
IVertex foo_o = g.AddVertex(); Names[foo_o]="foo.o";
IVertex libzigzag_a = g.AddVertex();Names[libzigzag_a]="libzigzig.a";
IVertex libfoobar_a = g.AddVertex();Names[libfoobar_a]="libfoobar.a";
IVertex killerapp = g.AddVertex(); Names[killerapp]="killerapp";
// adding dependencies
g.AddEdge(dax_h, foo_cpp);
g.AddEdge(dax_h, bar_cpp);
g.AddEdge(dax_h, yow_h);
g.AddEdge(yow_h, bar_cpp);
g.AddEdge(yow_h, zag_cpp);
g.AddEdge(boz_h, bar_cpp);
g.AddEdge(boz_h, zig_cpp);
g.AddEdge(boz_h, zag_cpp);
g.AddEdge(zow_h, foo_cpp);
g.AddEdge(foo_cpp, foo_o);
g.AddEdge(foo_o, libfoobar_a);
g.AddEdge(bar_cpp, bar_o);
g.AddEdge(bar_o, libfoobar_a);
g.AddEdge(libfoobar_a, libzigzag_a);
g.AddEdge(zig_cpp, zig_o);
g.AddEdge(zig_o, libzigzag_a);
g.AddEdge(zag_cpp, zag_o);
g.AddEdge(zag_o, libzigzag_a);
g.AddEdge(libzigzag_a, killerapp);
// outputing graph to png
GraphvizAlgorithm gw = new GraphvizAlgorithm(
g, // graph to draw
"filedependency", // output file prefix
".", // output file path
GraphvizImageType.Png // output file type
);
// outputing to graph.
gw.Write();
// attaching the file name outputer...
gw.WriteVertex += new VertexHandler(this.WriteVertex);
gw.Write();
}
public FixtureDependencyGraph()
{
this.graph = new AdjacencyGraph(
new FixtureVertex.Provider(),
new EdgeProvider(),
false
);
}
public void IsolatedVertex()
{
AdjacencyGraph g = new AdjacencyGraph();
g.AddVertex();
target = new CyclePoppingRandomTreeAlgorithm(g);
target.RandomTree();
}
public TestDomainDependencyGraph()
{
graph = new AdjacencyGraph(
new TestDomainVertex.Provider(),
new EdgeProvider(),
false
);
}
public void AttachDistanceRecorderVisitor()
{
AdjacencyGraph g = new AdjacencyGraph(true);
EdgeDoubleDictionary weights = DijkstraShortestPathAlgorithm.UnaryWeightsFromEdgeList(g);
DijkstraShortestPathAlgorithm dij = new DijkstraShortestPathAlgorithm(g,weights);
DistanceRecorderVisitor vis = new DistanceRecorderVisitor();
dij.RegisterDistanceRecorderHandlers(vis);
}
public void OneVertex()
{
AdjacencyGraph g =new AdjacencyGraph(true);
IVertex v1 = g.AddVertex();
StrongComponentsAlgorithm strong = new StrongComponentsAlgorithm(g);
Assert.AreEqual(1, strong.Compute());
checkStrong(strong);
}
/// <summary>
/// Constructs a <see cref="ClusteredAdjacencyGraph"/> on top of
/// the <see cref="AdjacencyGraph"/> object.
/// </summary>
/// <param name="wrapped">parent graph</param>
public ClusteredAdjacencyGraph(AdjacencyGraph wrapped)
{
if(wrapped==null)
throw new ArgumentNullException("parent");
this.parent = null;
this.wrapped = wrapped;
this.clusters = new ArrayList();
this.colapsed=false;
}
public ClusteredAdjacencyGraph(ClusteredAdjacencyGraph parent)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
this.parent = parent;
this.wrapped = new AdjacencyGraph(this.Parent.VertexProvider, this.Parent.EdgeProvider, this.Parent.AllowParallelEdges);
this.clusters = new ArrayList();
}
public void RootIsNotAccessible()
{
AdjacencyGraph g = new AdjacencyGraph();
IVertex root = g.AddVertex();
IVertex v = g.AddVertex();
g.AddEdge(root, v);
target = new CyclePoppingRandomTreeAlgorithm(g);
target.RandomTreeWithRoot(root);
}
public void Init()
{
this.capacities = new EdgeDoubleDictionary();
this.reversedEdges = new EdgeEdgeDictionary();
this.graph = new AdjacencyGraph();
this.source = graph.AddVertex();
this.sink = graph.AddVertex();
BuildSimpleGraph(source, sink);
}
/// <summary>
/// Star canal
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public static AdjacencyGraph CreateStar(int n)
{
AdjacencyGraph g = new AdjacencyGraph();
IVertex root = g.AddVertex();
for(int i = 0;i<n;++i)
{
IVertex v = g.AddVertex();
g.AddEdge(root, v);
}
return g;
}
/// <summary>
/// Reversed star canal
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public static AdjacencyGraph CreateReversedStart(int n)
{
AdjacencyGraph g = new AdjacencyGraph();
IVertex root = g.AddVertex();
for(int i = 0;i<n;++i)
{
IVertex v = g.AddVertex();
g.AddEdge(v,root);
}
return g;
}
public void TwoVertexOnEdge()
{
AdjacencyGraph g =new AdjacencyGraph(true);
IVertex v1 = g.AddVertex();
IVertex v2 = g.AddVertex();
IEdge e = g.AddEdge(v1,v2);
StrongComponentsAlgorithm strong = new StrongComponentsAlgorithm(g);
Assert.AreEqual(2, strong.Compute());
checkStrong(strong);
}
public RunTree(TestFixturePatternAttribute fixturePattern)
{
if (fixturePattern==null)
throw new ArgumentNullException("fixturePattern");
this.fixturePattern = fixturePattern;
this.graph = new AdjacencyGraph(
new RunVertex.Provider(),
new EdgeProvider(),
false);
this.root = (RunVertex)this.graph.AddVertex();
}
public static AdjacencyGraph FileDependency()
{
// create a new adjacency graph
AdjacencyGraph g = new AdjacencyGraph(
new NamedVertexProvider(),
new NamedEdgeProvider(),
true
);
// adding files and storing names
NamedVertex zig_cpp = (NamedVertex)g.AddVertex(); zig_cpp.Name="zip.cpp";
NamedVertex boz_h = (NamedVertex)g.AddVertex(); boz_h.Name="boz.h";
NamedVertex zag_cpp = (NamedVertex)g.AddVertex(); zag_cpp.Name="zag.cpp";
NamedVertex yow_h = (NamedVertex)g.AddVertex(); yow_h.Name="yow.h";
NamedVertex dax_h = (NamedVertex)g.AddVertex(); dax_h.Name="dax.h";
NamedVertex bar_cpp = (NamedVertex)g.AddVertex(); bar_cpp.Name="bar.cpp";
NamedVertex zow_h = (NamedVertex)g.AddVertex(); zow_h.Name="zow.h";
NamedVertex foo_cpp = (NamedVertex)g.AddVertex(); foo_cpp.Name="foo.cpp";
NamedVertex zig_o = (NamedVertex)g.AddVertex(); zig_o.Name="zi.o";
NamedVertex zag_o = (NamedVertex)g.AddVertex(); zag_o.Name="zag.o";
NamedVertex bar_o = (NamedVertex)g.AddVertex(); bar_o.Name="bar.o";
NamedVertex foo_o = (NamedVertex)g.AddVertex(); foo_o.Name="foo.o";
NamedVertex libzigzag_a = (NamedVertex)g.AddVertex(); libzigzag_a.Name="libzigzag.a";
NamedVertex libfoobar_a = (NamedVertex)g.AddVertex(); libfoobar_a.Name="libfoobar.a";
NamedVertex killerapp = (NamedVertex)g.AddVertex(); killerapp.Name="killerapp";
// adding dependencies
g.AddEdge(dax_h, foo_cpp);
g.AddEdge(dax_h, bar_cpp);
g.AddEdge(dax_h, yow_h);
g.AddEdge(yow_h, bar_cpp);
g.AddEdge(yow_h, zag_cpp);
g.AddEdge(boz_h, bar_cpp);
g.AddEdge(boz_h, zig_cpp);
g.AddEdge(boz_h, zag_cpp);
g.AddEdge(zow_h, foo_cpp);
g.AddEdge(foo_cpp, foo_o);
g.AddEdge(foo_o, libfoobar_a);
g.AddEdge(bar_cpp, bar_o);
g.AddEdge(bar_o, libfoobar_a);
g.AddEdge(libfoobar_a, libzigzag_a);
g.AddEdge(zig_cpp, zig_o);
g.AddEdge(zig_o, libzigzag_a);
g.AddEdge(zag_cpp, zag_o);
g.AddEdge(zag_o, libzigzag_a);
g.AddEdge(libzigzag_a, killerapp);
return g;
}
public AdjacencyGraph createCycle(AdjacencyGraph g)
{
foreach (IVertex v1 in g.Vertices)
{
foreach (IVertex v2 in g.Vertices)
{
if (v1 != v2 && g.ContainsEdge(v1, v2))
{
g.AddEdge(v1, v2);
}
}
}
return g;
}
/// <summary>
/// Cascade graph
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public static AdjacencyGraph CreateCascade(int n)
{
IVertex previous, next;
AdjacencyGraph g = new AdjacencyGraph();
next = g.AddVertex();
for(int i = 0;i<n;++i)
{
previous = next;
next = g.AddVertex();
g.AddEdge(previous,next);
}
return g;
}
public void AddAndRemoveOneEdge()
{
AdjacencyGraph g = new AdjacencyGraph();
IVertex v = g.AddVertex();
IVertex u = g.AddVertex();
IEdge edge = g.AddEdge(u, v);
this.target = new ReversedEdgeAugmentorAlgorithm(g);
target.AddReversedEdges();
target.RemoveReversedEdges();
Assert.AreEqual(2, this.target.VisitedGraph.VerticesCount);
Assert.AreEqual(1, this.target.VisitedGraph.EdgesCount);
CollectionAssert.AreCountEqual(0, this.target.AugmentedEdges);
Assert.AreEqual(0, this.target.ReversedEdges.Count);
}
public RunInvokerTree(Fixture fixture)
{
if (fixture==null)
throw new ArgumentNullException("fixture");
this.fixture = fixture;
this.graph = new AdjacencyGraph(
new RunInvokerVertexProvider(),
new EdgeProvider(),
false
);
CreateRoot();
Reflect();
}
public XmlSerializationTest()
{
m_Graph = new AdjacencyGraph(
new NamedVertexProvider(),
new NamedEdgeProvider(),
true
);
u = (NamedVertex)Graph.AddVertex(); u.Name = "u";
v = (NamedVertex)Graph.AddVertex(); v.Name = "v";
w = (NamedVertex)Graph.AddVertex(); w.Name = "w";
uv = (NamedEdge)Graph.AddEdge(u,v); uv.Name = "uv";
uw = (NamedEdge)Graph.AddEdge(u,w); uw.Name = "uw";
}
public void RunOnLineGraph()
{
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);
dij.Compute(v1);
Assert.AreEqual(0, dij.Distances[v1]);
Assert.AreEqual(1, dij.Distances[v2]);
Assert.AreEqual(2, dij.Distances[v3]);
}
public void AddOneEdge()
{
AdjacencyGraph g = new AdjacencyGraph();
IVertex v = g.AddVertex();
IVertex u = g.AddVertex();
IEdge edge = g.AddEdge(u, v);
this.target = new ReversedEdgeAugmentorAlgorithm(g);
target.AddReversedEdges();
Assert.AreEqual(2, this.target.VisitedGraph.VerticesCount);
Assert.AreEqual(2, this.target.VisitedGraph.EdgesCount);
CollectionAssert.AreCountEqual(1, this.target.AugmentedEdges);
VerifyReversedEdges();
IEdge reversedEdge = this.target.ReversedEdges[edge];
Assert.IsNotNull(reversedEdge);
Assert.IsTrue(this.target.AugmentedEdges.Contains(reversedEdge));
}
