public static IEnumerable <TaggedEdge <string, string> > GetEdges(UndirectedGraph <string, TaggedEdge <string, string> > g)
{
var algorithm = new PrimMinimumSpanningTreeAlgorithm <string, TaggedEdge <string, string> >(g, edgeWeights => double.Parse(edgeWeights.Tag));
var recorder = new EdgeRecorderObserver <string, TaggedEdge <string, string> >();
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges);
}
}
public static IEnumerable <Edge <int> > GetEdges(UndirectedGraph <int, Edge <int> > g)
{
var algorithm = new PrimMinimumSpanningTreeAlgorithm <int, Edge <int> >(g, edgeWeights => 1.0);
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges);
}
}
private void Generate <TVertex, TEdge>(IVertexListGraph <TVertex, TEdge> g)
where TEdge : IEdge <TVertex>
{
foreach (var v in g.Vertices)
{
var walker = new RandomWalkAlgorithm <TVertex, TEdge>(g);
var vis = new EdgeRecorderObserver <TVertex, TEdge>();
using (vis.Attach(walker))
walker.Generate(v);
}
}
private static void Generate <TVertex, TEdge>([NotNull] IVertexListGraph <TVertex, TEdge> graph)
where TEdge : IEdge <TVertex>
{
foreach (TVertex vertex in graph.Vertices)
{
var walker = new RandomWalkAlgorithm <TVertex, TEdge>(graph);
var vis = new EdgeRecorderObserver <TVertex, TEdge>();
using (vis.Attach(walker))
walker.Generate(vertex);
}
}
public static IEnumerable <Edge <int> > Get(AdjacencyGraph <int, Edge <int> > g)
{
var dfs = new DepthFirstSearchAlgorithm <int, Edge <int> >(g);
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
using (recorder.Attach(dfs))
{
dfs.Compute();
return(recorder.Edges);
}
}
private static void AssertMinimumSpanningTree<TVertex, TEdge>(
IUndirectedGraph<TVertex, TEdge> g,
IMinimumSpanningTreeAlgorithm<TVertex, TEdge> algorithm)
where TEdge : IEdge<TVertex>
{
var edgeRecorder = new EdgeRecorderObserver<TVertex, TEdge>();
using (edgeRecorder.Attach(algorithm))
algorithm.Compute();
TestConsole.WriteLine("tree cost: {0}", edgeRecorder.Edges.Count);
AssertSpanningTree<TVertex, TEdge>(g, edgeRecorder.Edges);
}
private static void AssertMinimumSpanningTree <TVertex, TEdge>(
[NotNull] IUndirectedGraph <TVertex, TEdge> graph,
[NotNull] IMinimumSpanningTreeAlgorithm <TVertex, TEdge> algorithm)
where TEdge : IEdge <TVertex>
{
var edgeRecorder = new EdgeRecorderObserver <TVertex, TEdge>();
using (edgeRecorder.Attach(algorithm))
algorithm.Compute();
AssertSpanningTree(graph, edgeRecorder.Edges);
}
public void GenerateWithVisitor(
[UsingFactories(typeof(EdgeChainFactory))]
KeyValuePair<IVertexAndEdgeListGraph<string,Edge<string>>,IEdgeChain<string,Edge<String>>> eg
)
{
RandomWalkAlgorithm<string, Edge<string>> walker =
new RandomWalkAlgorithm<string, Edge<string>>(eg.Key, eg.Value);
EdgeRecorderObserver<string, Edge<string>> vis = new EdgeRecorderObserver<string, Edge<string>>();
vis.Attach(walker);
walker.Generate(TraversalHelper.GetFirstVertex(eg.Key));
vis.Detach(walker);
}
public void GenerateWithVisitor(
[UsingFactories(typeof(EdgeChainFactory))]
KeyValuePair <IVertexAndEdgeListGraph <string, Edge <string> >, IEdgeChain <string, Edge <String> > > eg
)
{
RandomWalkAlgorithm <string, Edge <string> > walker =
new RandomWalkAlgorithm <string, Edge <string> >(eg.Key, eg.Value);
EdgeRecorderObserver <string, Edge <string> > vis = new EdgeRecorderObserver <string, Edge <string> >();
vis.Attach(walker);
walker.Generate(TraversalHelper.GetFirstVertex(eg.Key));
vis.Detach(walker);
}
/// <summary>
/// Collect edges
/// ToDo Change To Prim.Compute() or Kruskal.Compute() look at AssertMinimumSpanningTree<TVertex, TEdge>(g, prim, ref resultEdges);
/// </summary>
/// <typeparam name="TVertex"></typeparam>
/// <typeparam name="TEdge"></typeparam>
/// <param name="g"></param>
/// <param name="algorithm"></param>
/// <param name="resultEdges"></param>
private static void AssertMinimumSpanningTree <TVertex, TEdge>(IUndirectedGraph <TVertex, TEdge> g, IMinimumSpanningTreeAlgorithm <TVertex, TEdge> algorithm, ref int[][] resultEdges) where TEdge : IEdge <TVertex>
{
EdgeRecorderObserver <TVertex, TEdge> edgeRecorder = new EdgeRecorderObserver <TVertex, TEdge>();
using (edgeRecorder.Attach(algorithm))
algorithm.Compute();
resultEdges = new int[edgeRecorder.Edges.Count][];
for (int i = 0; i < edgeRecorder.Edges.Count; i++)
{
resultEdges[i] = new int[] { Convert.ToInt32(edgeRecorder.Edges[i].Source), Convert.ToInt32(edgeRecorder.Edges[i].Target) }
}
;
}
}
public void RoundRobinTestWithVisitor(IVertexListGraph<string, Edge<string>> g)
{
if (g.VertexCount == 0)
return;
RandomWalkAlgorithm<String, Edge<string>> walker =
new RandomWalkAlgorithm<String, Edge<string>>(g);
walker.EdgeChain = new NormalizedMarkovEdgeChain<string, Edge<string>>();
string root = TraversalHelper.GetFirstVertex(g);
EdgeRecorderObserver<string, Edge<string>> vis = new EdgeRecorderObserver<string, Edge<string>>();
vis.Attach(walker);
walker.Generate(root);
vis.Detach(walker);
}
public static double GetCost(UndirectedGraph <int, Edge <int> > g)
{
var algorithm = new PrimMinimumSpanningTreeAlgorithm <int, Edge <int> >(g, edgeWeights => 1.0);
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
var distances = new Dictionary <Edge <int>, double>();
foreach (var edge in g.Edges)
{
distances[edge] = 1.0;
}
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges.Sum(e => distances[e]));
}
}
public void Constructor()
{
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
CollectionAssert.IsEmpty(recorder.Edges);
var edge12 = new Edge <int>(1, 2);
var edge22 = new Edge <int>(2, 2);
var edge31 = new Edge <int>(3, 1);
recorder = new EdgeRecorderObserver <int, Edge <int> >(new[]
{
edge12, edge22, edge31
});
CollectionAssert.AreEqual(
new[] { edge12, edge22, edge31 },
recorder.Edges);
}
public static double GetCost(UndirectedGraph <string, TaggedEdge <string, string> > g)
{
var algorithm = new PrimMinimumSpanningTreeAlgorithm <string, TaggedEdge <string, string> >(g, edgeWeights => double.Parse(edgeWeights.Tag));
var recorder = new EdgeRecorderObserver <string, TaggedEdge <string, string> >();
var distances = new Dictionary <TaggedEdge <string, string>, double>();
foreach (var e in g.Edges)
{
distances[e] = double.Parse(e.Tag);
}
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges.Sum(e => distances[e]));
}
}
public void RoundRobinTestWithVisitor <TVertex, TEdge>(IVertexListGraph <TVertex, TEdge> g)
where TEdge : IEdge <TVertex>
{
if (g.VertexCount == 0)
{
return;
}
foreach (var root in g.Vertices)
{
var walker =
new RandomWalkAlgorithm <TVertex, TEdge>(g);
walker.EdgeChain = new NormalizedMarkovEdgeChain <TVertex, TEdge>();
var vis = new EdgeRecorderObserver <TVertex, TEdge>();
using (vis.Attach(walker))
walker.Generate(root);
}
}
private static void NormalizedEdgeChainTestWithVisitor <TVertex, TEdge>([NotNull] IVertexListGraph <TVertex, TEdge> graph)
where TEdge : IEdge <TVertex>
{
if (graph.VertexCount == 0)
{
return;
}
foreach (TVertex root in graph.Vertices)
{
var walker = new RandomWalkAlgorithm <TVertex, TEdge>(graph)
{
EdgeChain = new NormalizedMarkovEdgeChain <TVertex, TEdge>()
};
var vis = new EdgeRecorderObserver <TVertex, TEdge>();
using (vis.Attach(walker))
walker.Generate(root);
}
}
/// <summary>
/// Computes the minimum spanning tree using Kruskal's algorithm.
/// </summary>
/// <typeparam name="TVertex">type of the vertices</typeparam>
/// <typeparam name="TEdge">type of the edges</typeparam>
/// <param name="visitedGraph"></param>
/// <param name="weights"></param>
/// <returns></returns>
public static IEnumerable <TEdge> MinimumSpanningTreeKruskal <TVertex, TEdge>
(this IUndirectedGraph <TVertex, TEdge> visitedGraph, Func <TEdge, double> weights)
where TEdge : IEdge <TVertex>
{
Contract.Requires(visitedGraph != null);
Contract.Requires(weights != null);
if (visitedGraph.VertexCount == 0)
{
return(new TEdge[0]);
}
var kruskal = new KruskalMinimumSpanningTreeAlgorithm <TVertex, TEdge>(visitedGraph, weights);
var edgeRecorder = new EdgeRecorderObserver <TVertex, TEdge>();
using (edgeRecorder.Attach(kruskal))
kruskal.Compute();
return(edgeRecorder.Edges);
}
public void RoundRobinTestWithVisitor(IVertexListGraph <string, Edge <string> > g)
{
if (g.VertexCount == 0)
{
return;
}
RandomWalkAlgorithm <String, Edge <string> > walker =
new RandomWalkAlgorithm <String, Edge <string> >(g);
walker.EdgeChain = new NormalizedMarkovEdgeChain <string, Edge <string> >();
string root = TraversalHelper.GetFirstVertex(g);
EdgeRecorderObserver <string, Edge <string> > vis = new EdgeRecorderObserver <string, Edge <string> >();
vis.Attach(walker);
walker.Generate(root);
vis.Detach(walker);
}
public void Attach()
{
// DFS is used for tests but result may change if using another search algorithm
// or another starting point
{
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
var graph = new AdjacencyGraph <int, Edge <int> >();
var dfs = new DepthFirstSearchAlgorithm <int, Edge <int> >(graph);
using (recorder.Attach(dfs))
{
dfs.Compute();
CollectionAssert.IsEmpty(recorder.Edges);
}
}
{
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVertexRange(new[] { 1, 2 });
var dfs = new DepthFirstSearchAlgorithm <int, Edge <int> >(graph);
using (recorder.Attach(dfs))
{
dfs.Compute();
CollectionAssert.IsEmpty(recorder.Edges);
}
}
{
var edge12 = new Edge <int>(1, 2);
var recorder = new EdgeRecorderObserver <int, Edge <int> >(new[] { edge12 });
var edge23 = new Edge <int>(2, 3);
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVerticesAndEdgeRange(new[] { edge12, edge23 });
var dfs = new DepthFirstSearchAlgorithm <int, Edge <int> >(graph);
using (recorder.Attach(dfs))
{
dfs.Compute();
CollectionAssert.AreEqual(
new[] { edge12, edge12, edge23 }, // Add without checking if edge already exists
recorder.Edges);
}
}
{
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
var edge12 = new Edge <int>(1, 2);
var edge32 = new Edge <int>(3, 2); // Is not reachable
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVerticesAndEdgeRange(new[] { edge12, edge32 });
var dfs = new DepthFirstSearchAlgorithm <int, Edge <int> >(graph);
using (recorder.Attach(dfs))
{
dfs.Compute();
CollectionAssert.AreEqual(
new[] { edge12 }, // 3 -> 2 is not reachable (wrong orientation)
recorder.Edges);
}
}
{
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
var edge12 = new Edge <int>(1, 2);
var edge22 = new Edge <int>(2, 2);
var edge23 = new Edge <int>(2, 3);
var edge34 = new Edge <int>(3, 4);
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVerticesAndEdgeRange(new[]
{
edge12, edge22, edge23, edge34
});
var dfs = new DepthFirstSearchAlgorithm <int, Edge <int> >(graph);
using (recorder.Attach(dfs))
{
dfs.Compute();
CollectionAssert.AreEqual(
new[] { edge12, edge23, edge34 }, // Self edge skipped
recorder.Edges);
}
}
}
private static void RunRandomWalkAndCheck <TVertex, TEdge>(
[NotNull] IVertexListGraph <TVertex, TEdge> graph)
where TEdge : IEdge <TVertex>
{
if (graph.VertexCount == 0)
{
return;
}
foreach (TVertex root in graph.Vertices)
{
RandomWalkAlgorithm <TVertex, TEdge> walker1 = CreateAlgorithm();
bool calledStart1 = false;
bool calledEnd1 = false;
var encounteredEdges1 = new List <TEdge>();
walker1.StartVertex += vertex =>
{
Assert.IsFalse(calledStart1);
calledStart1 = true;
Assert.AreEqual(root, vertex);
};
walker1.TreeEdge += edge =>
{
Assert.IsNotNull(edge);
encounteredEdges1.Add(edge);
};
walker1.EndVertex += vertex =>
{
Assert.IsFalse(calledEnd1);
calledEnd1 = true;
Assert.IsNotNull(vertex);
};
RandomWalkAlgorithm <TVertex, TEdge> walker2 = CreateAlgorithm();
bool calledStart2 = false;
bool calledEnd2 = false;
var encounteredEdges2 = new List <TEdge>();
walker2.StartVertex += vertex =>
{
Assert.IsFalse(calledStart2);
calledStart2 = true;
Assert.AreEqual(root, vertex);
};
walker2.TreeEdge += edge =>
{
Assert.IsNotNull(edge);
encounteredEdges2.Add(edge);
};
walker2.EndVertex += vertex =>
{
Assert.IsFalse(calledEnd2);
calledEnd2 = true;
Assert.IsNotNull(vertex);
};
RandomWalkAlgorithm <TVertex, TEdge> walker3 = CreateAlgorithm();
bool calledStart3 = false;
bool calledEnd3 = false;
var encounteredEdges3 = new List <TEdge>();
walker3.StartVertex += vertex =>
{
Assert.IsFalse(calledStart3);
calledStart3 = true;
Assert.AreEqual(root, vertex);
};
walker3.TreeEdge += edge =>
{
Assert.IsNotNull(edge);
encounteredEdges3.Add(edge);
};
walker3.EndVertex += vertex =>
{
Assert.IsFalse(calledEnd3);
calledEnd3 = true;
Assert.IsNotNull(vertex);
};
var vis1 = new EdgeRecorderObserver <TVertex, TEdge>();
using (vis1.Attach(walker1))
walker1.Generate(root);
Assert.IsTrue(calledStart1);
Assert.IsTrue(calledEnd1);
walker2.SetRootVertex(root);
var vis2 = new EdgeRecorderObserver <TVertex, TEdge>();
using (vis2.Attach(walker2))
walker2.Compute();
Assert.IsTrue(calledStart2);
Assert.IsTrue(calledEnd2);
var vis3 = new EdgeRecorderObserver <TVertex, TEdge>();
using (vis3.Attach(walker3))
walker3.Generate(root, 100);
Assert.IsTrue(calledStart3);
Assert.IsTrue(calledEnd3);
CollectionAssert.AreEqual(vis1.Edges, encounteredEdges1);
CollectionAssert.AreEqual(vis1.Edges, encounteredEdges2);
CollectionAssert.AreEqual(vis1.Edges, encounteredEdges3);
CollectionAssert.AreEqual(vis1.Edges, vis2.Edges);
CollectionAssert.AreEqual(vis1.Edges, vis3.Edges);
}
#region Local function
RandomWalkAlgorithm <TVertex, TEdge> CreateAlgorithm()
{
var walker = new RandomWalkAlgorithm <TVertex, TEdge>(graph)
{
EdgeChain = new NormalizedMarkovEdgeChain <TVertex, TEdge>
{
Rand = new Random(123456)
}
};
return(walker);
}
#endregion
}
