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 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); } }
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); }
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 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 }