public double CompareRoot <TVertex, TEdge>(IUndirectedGraph <TVertex, TEdge> g)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (var e in g.Edges)
{
distances[e] = g.AdjacentDegree(e.Source) + 1;
}
var prim = new List <TEdge>(g.MinimumSpanningTreePrim(e => distances[e]));
var kruskal = new List <TEdge>(g.MinimumSpanningTreeKruskal(e => distances[e]));
var primCost = prim.Sum(e => distances[e]);
var kruskalCost = kruskal.Sum(e => distances[e]);
TestConsole.WriteLine("prim cost: {0}", primCost);
TestConsole.WriteLine("kruskal cost: {0}", kruskalCost);
if (primCost != kruskalCost)
{
GraphConsoleSerializer.DisplayGraph(g);
TestConsole.WriteLine("prim: {0}", String.Join(", ", Array.ConvertAll(prim.ToArray(), e => e.ToString() + ':' + distances[e])));
TestConsole.WriteLine("krus: {0}", String.Join(", ", Array.ConvertAll(kruskal.ToArray(), e => e.ToString() + ':' + distances[e])));
Assert.Fail("cost do not match");
}
return(kruskalCost);
}
public static void IsAdjacentEdgesEmpty([PexAssumeUnderTest] IUndirectedGraph <T, E> g)
{
foreach (T v in g.Vertices)
{
Assert.AreEqual(
g.IsAdjacentEdgesEmpty(v),
g.AdjacentDegree(v) == 0);
}
}
public void Kruskal<TVertex,TEdge>([PexAssumeNotNull]IUndirectedGraph<TVertex, TEdge> g)
where TEdge : IEdge<TVertex>
{
var distances = new Dictionary<TEdge, double>();
foreach(var e in g.Edges)
distances[e] = g.AdjacentDegree(e.Source) + 1;
var kruskal = new KruskalMinimumSpanningTreeAlgorithm<TVertex, TEdge>(g, e => distances[e]);
AssertMinimumSpanningTree<TVertex, TEdge>(g, kruskal);
}
public void Prim<TVertex, TEdge>([PexAssumeNotNull]IUndirectedGraph<TVertex, TEdge> g)
where TEdge : IEdge<TVertex>
{
var distances = new Dictionary<TEdge, double>();
foreach (var e in g.Edges)
distances[e] = g.AdjacentDegree(e.Source) + 1;
var edges = AlgorithmExtensions.MinimumSpanningTreePrim(g, e => distances[e]);
AssertSpanningTree(g, edges);
}
public static void IsAdjacentEdgesEmpty <T, E>(IUndirectedGraph <T, E> g)
where E : IEdge <T>
{
foreach (T v in g.Vertices)
{
Assert.Equal(
g.IsAdjacentEdgesEmpty(v),
g.AdjacentDegree(v) == 0);
}
}
private static void AssertAdjacentDegreeSumEqualsTwiceEdgeCount <TVertex, TEdge>(
[NotNull] IUndirectedGraph <TVertex, TEdge> graph)
where TEdge : IEdge <TVertex>
{
int totalAdjacentDegree = 0;
foreach (TVertex vertex in graph.Vertices)
{
totalAdjacentDegree += graph.AdjacentDegree(vertex);
}
Assert.AreEqual(graph.EdgeCount * 2, totalAdjacentDegree);
}
public static void ContainsEdgeAssertions(
[NotNull] IUndirectedGraph <int, IEdge <int> > graph,
[NotNull] IEdge <int> e12,
[NotNull] IEdge <int> f12,
[CanBeNull] IEdge <int> e21,
[CanBeNull] IEdge <int> f21)
{
Assert.AreEqual(1, graph.AdjacentDegree(1));
Assert.AreEqual(1, graph.AdjacentDegree(2));
Assert.AreEqual(1, graph.AdjacentEdges(1).Count());
Assert.AreEqual(1, graph.AdjacentEdges(2).Count());
// e12 must be present in u, because we added it.
Assert.IsTrue(graph.ContainsEdge(e12));
// f12 is also in u, because e12 == f12.
Assert.IsTrue(graph.ContainsEdge(f12));
// e21 and f21 are not in u, because ContainsEdge has semantics that
// if it returns true for an edge, that edge must be physically present in
// the collection of edges inside u.
if (e21 != null)
{
Assert.IsFalse(graph.ContainsEdge(e21));
}
if (f21 != null)
{
Assert.IsFalse(graph.ContainsEdge(f21));
}
// There must be an edge between vertices 1, 2.
Assert.IsTrue(graph.ContainsEdge(1, 2));
// There is also an edge between vertices 2, 1, because the graph is undirected.
Assert.IsTrue(graph.ContainsEdge(2, 1));
// Obviously no edge between vertices 1, 3, as vertex 3 is not even present in the graph.
Assert.IsFalse(graph.ContainsEdge(1, 3));
}
protected static void Kruskal <TVertex, TEdge>([NotNull] IUndirectedGraph <TVertex, TEdge> graph)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (TEdge edge in graph.Edges)
{
distances[edge] = graph.AdjacentDegree(edge.Source) + 1;
}
IEnumerable <TEdge> edges = graph.MinimumSpanningTreeKruskal(e => distances[e]);
AssertSpanningTree(graph, edges);
}
private static void Kruskal <TVertex, TEdge>([NotNull] IUndirectedGraph <TVertex, TEdge> graph)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (TEdge edge in graph.Edges)
{
distances[edge] = graph.AdjacentDegree(edge.Source) + 1;
}
var kruskal = new KruskalMinimumSpanningTreeAlgorithm <TVertex, TEdge>(graph, e => distances[e]);
AssertMinimumSpanningTree(graph, kruskal);
}
private static void RunUndirectedDijkstraAndCheck <TVertex, TEdge>([NotNull] IUndirectedGraph <TVertex, TEdge> graph, [NotNull] TVertex root)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (TEdge edge in graph.Edges)
{
distances[edge] = graph.AdjacentDegree(edge.Source) + 1;
}
var algorithm = new UndirectedDijkstraShortestPathAlgorithm <TVertex, TEdge>(graph, e => distances[e]);
var predecessors = new UndirectedVertexPredecessorRecorderObserver <TVertex, TEdge>();
using (predecessors.Attach(algorithm))
algorithm.Compute(root);
Verify(algorithm, predecessors);
}
private void UndirectedDijkstra <TVertex, TEdge>(IUndirectedGraph <TVertex, TEdge> g, TVertex root)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (var e in g.Edges)
{
distances[e] = g.AdjacentDegree(e.Source) + 1;
}
var algo = new UndirectedDijkstraShortestPathAlgorithm <TVertex, TEdge>(
g,
e => distances[e]
);
var predecessors = new UndirectedVertexPredecessorRecorderObserver <TVertex, TEdge>();
using (predecessors.Attach(algo))
algo.Compute(root);
Verify(algo, predecessors);
}
private static double CompareRoot <TVertex, TEdge>([NotNull] IUndirectedGraph <TVertex, TEdge> graph)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (TEdge edge in graph.Edges)
{
distances[edge] = graph.AdjacentDegree(edge.Source) + 1;
}
TEdge[] prim = graph.MinimumSpanningTreePrim(e => distances[e]).ToArray();
TEdge[] kruskal = graph.MinimumSpanningTreeKruskal(e => distances[e]).ToArray();
double primCost = prim.Sum(e => distances[e]);
double kruskalCost = kruskal.Sum(e => distances[e]);
if (Math.Abs(primCost - kruskalCost) > double.Epsilon)
{
Assert.Fail("Cost do not match.");
}
return(kruskalCost);
}
private static void RunUndirectedDijkstraAndCheck <TVertex, TEdge>([NotNull] IUndirectedGraph <TVertex, TEdge> graph, [NotNull] TVertex root)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (TEdge edge in graph.Edges)
{
distances[edge] = graph.AdjacentDegree(edge.Source) + 1;
}
var algorithm = new UndirectedDijkstraShortestPathAlgorithm <TVertex, TEdge>(graph, e => distances[e]);
var predecessors = new UndirectedVertexPredecessorRecorderObserver <TVertex, TEdge>();
using (predecessors.Attach(algorithm))
algorithm.Compute(root);
algorithm.InitializeVertex += vertex =>
{
Assert.AreEqual(GraphColor.White, algorithm.VerticesColors[vertex]);
};
algorithm.DiscoverVertex += vertex =>
{
Assert.AreEqual(GraphColor.Gray, algorithm.VerticesColors[vertex]);
};
algorithm.FinishVertex += vertex =>
{
Assert.AreEqual(GraphColor.Black, algorithm.VerticesColors[vertex]);
};
Assert.IsNotNull(algorithm.Distances);
Assert.AreEqual(graph.VertexCount, algorithm.Distances.Count);
Verify(algorithm, predecessors);
}
public static void ContainsEdgeAssertions(IUndirectedGraph<int, IEdge<int>> g,
IEdge<int> e12,
IEdge<int> f12,
IEdge<int> e21,
IEdge<int> f21)
{
Assert.AreEqual(1, g.AdjacentDegree(1));
Assert.AreEqual(1, g.AdjacentDegree(2));
Assert.AreEqual(1, g.AdjacentEdges(1).Count());
Assert.AreEqual(1, g.AdjacentEdges(2).Count());
// e12 must be present in u, because we added it.
Assert.IsTrue(g.ContainsEdge(e12));
// f12 is also in u, because e12 == f12.
Assert.IsTrue(g.ContainsEdge(f12));
// e21 and f21 are not in u, because ContainsEdge has semantics that
// if it returns true for an edge, that edge must be physically present in
// the collection of edges inside u.
if (e21 != null) Assert.IsFalse(g.ContainsEdge(e21));
if (f21 != null) Assert.IsFalse(g.ContainsEdge(f21));
// there must be an edge between vertices 1, 2.
Assert.IsTrue(g.ContainsEdge(1, 2));
// there is also an edge between vertices 2, 1, because the graph is undirected.
Assert.IsTrue(g.ContainsEdge(2, 1));
// obviously no edge between vertices 1, 3, as vertex 3 is not even present in the graph.
Assert.IsFalse(g.ContainsEdge(1, 3));
}
