public void ClearRootVertex() { var graph = new BidirectionalGraph <int, Edge <int> >(); var algorithm = new BidirectionalDepthFirstSearchAlgorithm <int, Edge <int> >(graph); ClearRootVertex_Test(algorithm); }
public void EmptyGraph(IBidirectionalGraph<string, Edge<string>> g) { this.dfs = new BidirectionalDepthFirstSearchAlgorithm<string, Edge<string>>(g); this.dfs.Compute(); VerifyDfs(); }
public void SetRootVertex_Throws() { var graph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >(); var algorithm = new BidirectionalDepthFirstSearchAlgorithm <TestVertex, Edge <TestVertex> >(graph); SetRootVertex_Throws_Test(algorithm); }
public void testing4() { BidirectionalGraph <string, Edge <string> > graph = new BidirectionalGraph <string, Edge <string> >(true); graph.AddVertex("A"); graph.AddVertex("B"); graph.AddVertex("C"); graph.AddVertex("D"); graph.AddVertex("E"); graph.AddVertex("F"); graph.AddVertex("G"); graph.AddVertex("H"); graph.AddVertex("I"); graph.AddVertex("J"); graph.AddEdge(new Edge <string>("A", "B")); graph.AddEdge(new Edge <string>("B", "C")); graph.AddEdge(new Edge <string>("C", "D")); graph.AddEdge(new Edge <string>("C", "E")); graph.AddEdge(new Edge <string>("E", "F")); graph.AddEdge(new Edge <string>("G", "H")); graph.AddEdge(new Edge <string>("H", "I")); graph.AddEdge(new Edge <string>("H", "J")); WeaklyConnectedComponentsAlgorithm <string, Edge <string> > ConnectedComponent = new WeaklyConnectedComponentsAlgorithm <string, Edge <string> >(graph); ConnectedComponent.Compute(); // Debug.Log(ConnectedComponent.ComponentCount); // // Debug.Log(ConnectedComponent.Components); // foreach (string key in ConnectedComponent.Components.Keys) { // Debug.Log(key); // Debug.Log(ConnectedComponent.Components[key]); // } List <string> vertexfound = new List <string>(); List <string> startvertexfound = new List <string>(); // ReversedBidirectionalGraph<string, Edge<string>> Rgraph = new ReversedBidirectionalGraph<string, Edge<string>>(graph); BidirectionalDepthFirstSearchAlgorithm <string, Edge <string> > DFS = new BidirectionalDepthFirstSearchAlgorithm <string, Edge <string> >(graph); DFS.SetRootVertex("C"); // DFS.TreeEdge += vertexfound.Add; DFS.TreeEdge += e => isRoot(graph, e); // DFS.FinishVertex += startvertexfound.Add; DFS.Compute(); // Debug.Log("Found:"); foreach (string V in Roots) { Debug.Log(V); } // // Debug.Log("START VERTEX Found:"); // foreach(string V in vertexfound) { // Debug.Log(V); // } // Debug.Log(DFS.rootVertex); }
public void ComputeWithRoot() { var graph = new BidirectionalGraph <int, Edge <int> >(); graph.AddVertex(0); var algorithm = new BidirectionalDepthFirstSearchAlgorithm <int, Edge <int> >(graph); ComputeWithRoot_Test(algorithm); }
private static void Compute <TVertex, TEdge>([NotNull] IBidirectionalGraph <TVertex, TEdge> graph) where TEdge : IEdge <TVertex> { var dfs = new BidirectionalDepthFirstSearchAlgorithm <TVertex, TEdge>(graph); dfs.Compute(); foreach (TVertex vertex in graph.Vertices) { Assert.IsTrue(dfs.VerticesColors.ContainsKey(vertex)); Assert.AreEqual(dfs.VerticesColors[vertex], GraphColor.Black); } }
public List <string> FindRoots(string root) { List <string> Roots = new List <string>(); BidirectionalDepthFirstSearchAlgorithm <string, Edge <string> > DFS = new BidirectionalDepthFirstSearchAlgorithm <string, Edge <string> >(graph); DFS.SetRootVertex(root); DFS.DiscoverVertex += e => isRoot(e); // DFS.TreeEdge += e => isRoot(e); DFS.Compute(); return(Roots); }
public static BidirectionalDepthFirstSearchAlgorithm <int, Edge <int> > CreateAlgorithmAndMaybeDoComputation( [NotNull] ContractScenario scenario) { var graph = new BidirectionalGraph <int, Edge <int> >(); graph.AddVerticesAndEdgeRange(scenario.EdgesInGraph.Select(e => new Edge <int>(e.Source, e.Target))); graph.AddVertexRange(scenario.SingleVerticesInGraph); var algorithm = new BidirectionalDepthFirstSearchAlgorithm <int, Edge <int> >(graph); if (scenario.DoComputation) { algorithm.Compute(scenario.Root); } return(algorithm); }
public void GetVertexColor() { var graph = new BidirectionalGraph <int, Edge <int> >(); graph.AddVerticesAndEdge(new Edge <int>(1, 2)); var algorithm = new BidirectionalDepthFirstSearchAlgorithm <int, Edge <int> >(graph); // Algorithm not run // ReSharper disable once ReturnValueOfPureMethodIsNotUsed Assert.Throws <VertexNotFoundException>(() => algorithm.GetVertexColor(1)); algorithm.Compute(); Assert.AreEqual(GraphColor.Black, algorithm.GetVertexColor(1)); Assert.AreEqual(GraphColor.Black, algorithm.GetVertexColor(2)); }
public void Constructor() { var graph = new BidirectionalGraph <int, Edge <int> >(); var algorithm = new BidirectionalDepthFirstSearchAlgorithm <int, Edge <int> >(graph); AssertAlgorithmProperties(algorithm, graph); var verticesColors = new Dictionary <int, GraphColor>(); algorithm = new BidirectionalDepthFirstSearchAlgorithm <int, Edge <int> >(graph, verticesColors); AssertAlgorithmProperties(algorithm, graph, verticesColors); algorithm = new BidirectionalDepthFirstSearchAlgorithm <int, Edge <int> >(null, graph, verticesColors); AssertAlgorithmProperties(algorithm, graph, verticesColors); algorithm.MaxDepth = 12; AssertAlgorithmProperties(algorithm, graph, verticesColors, 12); algorithm.ProcessAllComponents = true; AssertAlgorithmProperties(algorithm, graph, verticesColors, 12, true); #region Local function void AssertAlgorithmProperties <TVertex, TEdge>( BidirectionalDepthFirstSearchAlgorithm <TVertex, TEdge> algo, IBidirectionalGraph <TVertex, TEdge> g, IDictionary <TVertex, GraphColor> vColors = null, int maxDepth = int.MaxValue, bool processAllComponents = false) where TEdge : IEdge <TVertex> { AssertAlgorithmState(algo, g); if (vColors is null) { CollectionAssert.IsEmpty(algo.VerticesColors); } else { Assert.AreSame(vColors, algo.VerticesColors); } Assert.AreEqual(maxDepth, algo.MaxDepth); Assert.AreEqual(processAllComponents, algo.ProcessAllComponents); } #endregion }
public void ProcessAllComponents(bool processAll) { var graph = new BidirectionalGraph <int, Edge <int> >(); graph.AddVerticesAndEdgeRange(new[] { new Edge <int>(1, 2), new Edge <int>(1, 3), new Edge <int>(2, 1), new Edge <int>(2, 4), new Edge <int>(2, 5), new Edge <int>(6, 7), new Edge <int>(6, 8), new Edge <int>(8, 6) }); var algorithm = new BidirectionalDepthFirstSearchAlgorithm <int, Edge <int> >(graph) { ProcessAllComponents = processAll }; algorithm.Compute(1); if (processAll) { QuikGraphAssert.TrueForAll(algorithm.VerticesColors, pair => pair.Value == GraphColor.Black); } else { QuikGraphAssert.TrueForAll( new[] { 1, 2, 3, 4, 5 }, vertex => algorithm.VerticesColors[vertex] == GraphColor.Black); QuikGraphAssert.TrueForAll( new[] { 6, 7, 8 }, vertex => algorithm.VerticesColors[vertex] == GraphColor.White); } }
private static void RunDFSAndCheck <TVertex, TEdge>( [NotNull] IBidirectionalGraph <TVertex, TEdge> graph, int maxDepth = int.MaxValue) where TEdge : IEdge <TVertex> { var discoverTimes = new Dictionary <TVertex, int>(); var finishTimes = new Dictionary <TVertex, int>(); int time = 0; var dfs = new BidirectionalDepthFirstSearchAlgorithm <TVertex, TEdge>(graph) { MaxDepth = maxDepth }; dfs.InitializeVertex += vertex => { Assert.AreEqual(GraphColor.White, dfs.VerticesColors[vertex]); }; dfs.StartVertex += vertex => { Assert.AreEqual(GraphColor.White, dfs.VerticesColors[vertex]); }; dfs.DiscoverVertex += vertex => { Assert.AreEqual(GraphColor.Gray, dfs.VerticesColors[vertex]); discoverTimes[vertex] = time++; }; dfs.ExamineEdge += edge => { // Depending if the edge was taken from in or out edges // Here we cannot determine in which case we are Assert.IsTrue( dfs.VerticesColors[edge.Source] == GraphColor.Gray || dfs.VerticesColors[edge.Target] == GraphColor.Gray); }; dfs.TreeEdge += edge => { // Depending if the edge was taken from in or out edges // Here we cannot determine in which case we are Assert.IsTrue( dfs.VerticesColors[edge.Source] == GraphColor.White || dfs.VerticesColors[edge.Target] == GraphColor.White); }; dfs.BackEdge += edge => { // Depending if the edge was taken from in or out edges // Here we cannot determine in which case we are Assert.IsTrue( dfs.VerticesColors[edge.Source] == GraphColor.Gray || dfs.VerticesColors[edge.Target] == GraphColor.Gray); }; dfs.ForwardOrCrossEdge += edge => { // Depending if the edge was taken from in or out edges // Here we cannot determine in which case we are Assert.IsTrue( dfs.VerticesColors[edge.Source] == GraphColor.Black || dfs.VerticesColors[edge.Target] == GraphColor.Black); }; dfs.FinishVertex += vertex => { Assert.AreEqual(GraphColor.Black, dfs.VerticesColors[vertex]); finishTimes[vertex] = time++; }; dfs.Compute(); // Check // All vertices should be black foreach (TVertex vertex in graph.Vertices) { Assert.IsTrue(dfs.VerticesColors.ContainsKey(vertex)); Assert.AreEqual(dfs.VerticesColors[vertex], GraphColor.Black); } foreach (TVertex u in graph.Vertices) { foreach (TVertex v in graph.Vertices) { if (!u.Equals(v)) { Assert.IsTrue( finishTimes[u] < discoverTimes[v] || finishTimes[v] < discoverTimes[u] || (discoverTimes[v] < discoverTimes[u] && finishTimes[u] < finishTimes[v]) || (discoverTimes[u] < discoverTimes[v] && finishTimes[v] < finishTimes[u])); } } } }