public void GenerateDotFile() { var graph = new AdjacencyGraph<string, TaggedEdge<string, string>>(); for (int i = 0; i < Math.Sqrt(Convert.ToDouble(m_Matrix.Length)); i++) { graph.AddVertex(String.Format("{0}", i)); } for (int i = 0; i < Math.Sqrt(Convert.ToDouble(m_Matrix.Length)); i++) { for (int j = 0; j < Math.Sqrt(Convert.ToDouble(m_Matrix.Length)); j++) { if ((m_Matrix[i, j] == true) & (i < j)) { graph.AddEdge(new TaggedEdge<string, string>(String.Format("{0}", i), String.Format("{0}", j), String.Format("{0}", i))); } } } var graphViz = new GraphvizAlgorithm<string, TaggedEdge<string, string>>(graph, @".\", QuickGraph.Graphviz.Dot.GraphvizImageType.Png); graphViz.FormatVertex += (sender, e) => { e.VertexFormatter.Shape = QuickGraph.Graphviz.Dot.GraphvizVertexShape.Circle; }; graphViz.FormatEdge += (sender, e) => { e.EdgeFormatter.Dir = QuickGraph.Graphviz.Dot.GraphvizEdgeDirection.None; }; graphViz.Generate(new FileDotEngine(), m_Name); }
public void Simple() { AdjacencyGraph<string, Edge<string>> g = new AdjacencyGraph<string, Edge<string>>(); GraphFactory.Simple(g); this.Compute(g); this.ComputeCriticalPath(g); }
//DC this version was using the old QuickGraph MarkedEdge public static void createGraphWizDotFile(AdjacencyGraph<String, TaggedEdge<String, String>> gGraphWizToPopulate, TreeNode tnTreeNode, bool bOrder, bool bFilterName, bool bFilterClass, int iFilterClassLevel) { if (bFilterClass) tnTreeNode.Text = FilteredSignature.filterName(tnTreeNode.Text, false, false, true, 0, true, true, iFilterClassLevel); TaggedEdge<String, string> meTemp; if (gGraphWizToPopulate.ContainsVertex(tnTreeNode.Text)) { } else gGraphWizToPopulate.AddVertex(tnTreeNode.Text); foreach (TreeNode tnChild in tnTreeNode.Nodes) { if (bFilterClass) tnChild.Text = FilteredSignature.filterName(tnChild.Text, false, false, true, 0, true, true, iFilterClassLevel); createGraphWizDotFile(gGraphWizToPopulate, tnChild, bOrder, bFilterName, bFilterClass, iFilterClassLevel); if (bOrder) { if (false == gGraphWizToPopulate.TryGetEdge(tnTreeNode.Text, tnChild.Text, out meTemp)) gGraphWizToPopulate.AddEdge(new TaggedEdge<String, string>(tnTreeNode.Text, tnChild.Text, "marker")); } else if (false == gGraphWizToPopulate.TryGetEdge(tnChild.Text, tnTreeNode.Text, out meTemp)) gGraphWizToPopulate.AddEdge(new TaggedEdge<String, string>(tnChild.Text, tnTreeNode.Text, "marker")); //gGraphToPopulate.AddEdge(tnTreeNode.Text, tnChild.Text); // gGraphToPopulate.AddEdge(Analysis_CallFlow.display.filterName(tnChild.Text, false, false, false), Analysis_CallFlow.display.filterName(tnTreeNode.Text, false, false, false)); //else } }
public void Removing_Explicit_Edges_2() { var graph = new AdjacencyGraph<int, Edge<int>>(); graph.AddVertex(1); graph.AddVertex(2); graph.AddVertex(3); graph.AddVertex(4); graph.AddVertex(5); graph.AddVertex(6); graph.AddVertex(7); graph.AddEdge(new Edge<int>(1, 3)); graph.AddEdge(new Edge<int>(1, 4)); graph.AddEdge(new Edge<int>(1, 6)); graph.AddEdge(new Edge<int>(3, 6)); graph.AddEdge(new Edge<int>(4, 6)); graph.AddEdge(new Edge<int>(2, 4)); graph.AddEdge(new Edge<int>(2, 5)); graph.AddEdge(new Edge<int>(2, 7)); graph.AddEdge(new Edge<int>(4, 7)); graph.AddEdge(new Edge<int>(5, 7)); GraphHelper.RemoveExplicitEdges(graph); Assert.AreEqual(8, graph.EdgeCount); Assert.IsTrue(graph.ContainsEdge(1, 3)); Assert.IsTrue(graph.ContainsEdge(1, 4)); Assert.IsTrue(graph.ContainsEdge(2, 4)); Assert.IsTrue(graph.ContainsEdge(2, 5)); Assert.IsTrue(graph.ContainsEdge(3, 6)); Assert.IsTrue(graph.ContainsEdge(4, 6)); Assert.IsTrue(graph.ContainsEdge(4, 7)); Assert.IsTrue(graph.ContainsEdge(5, 7)); }
public ParkingMap(string name, int width, int height) { Name = name; Width = width; Height = height; Graph = new AdjacencyGraph<Vertex, Edge<Vertex>>(); }
public static AdjacencyGraph<PropertyInfo, STaggedEdge<PropertyInfo, string>> BuildDependencyGraph(Type viewModelType) { var directDependencies = ViewModelConventions.GetViewModelProperties(viewModelType).ToDictionary(p => p, GetDirectDependentProperties); var graph = new AdjacencyGraph<PropertyInfo, STaggedEdge<PropertyInfo, string>>(); foreach (var directDependency in directDependencies) { var property = directDependency.Key; graph.AddVertex(property); foreach (var dependentProperty in directDependency.Value) { var sub = dependentProperty.SubPath; var propertyType = property.PropertyType; if (GetCollectionType(propertyType) != null) propertyType = GetCollectionType(propertyType); if (String.IsNullOrEmpty(sub) && ViewModelConventions.IsViewModel(propertyType)) sub = "*"; graph.AddEdge(new STaggedEdge<PropertyInfo, string>(property, dependentProperty.Property, sub)); } } return graph; }
private static IVertexAndEdgeListGraph<PipeGraphVertex, Edge<PipeGraphVertex>> CreateGraphOfPipeSystem(PipeGraphVertex firstVertex) { var graph = new AdjacencyGraph<PipeGraphVertex, Edge<PipeGraphVertex>>(false); var verticesSeen = new HashSet<PipeGraphVertex>(); var verticesToCheck = new Stack<PipeGraphVertex>(); verticesToCheck.Push(firstVertex); while (verticesToCheck.Any()) { var vertexToCheck = verticesToCheck.Pop(); if (verticesSeen.Contains(vertexToCheck)) continue; var sendsTo = GetVerticesYouSendMessagesTo(vertexToCheck); var receivesFrom = GetVerticesYouReceiveMessagesFrom(vertexToCheck); foreach (var vertex in sendsTo) verticesToCheck.Push(vertex); foreach (var vertex in receivesFrom) verticesToCheck.Push(vertex); graph.AddVertex(vertexToCheck); graph.AddVerticesAndEdgeRange(sendsTo.Select(v => new Edge<PipeGraphVertex>(vertexToCheck, v))); graph.AddVerticesAndEdgeRange(receivesFrom.Select(v => new Edge<PipeGraphVertex>(v, vertexToCheck))); verticesSeen.Add(vertexToCheck); } return graph; }
public override void Render(Context context, TextWriter result) { // init modules context ModulesContext modules = DotLiquidModules.ContextExtractor.GetOrAddModulesContext(context); // allow module name to be supplied as a variable, makes sense when you supply modules in the Model object evalName = context[_moduleName]; string modName = evalName != null ? Convert.ToString(evalName) : _moduleName; // remember modules that were already loaded Dictionary<string, bool> alreadyLoaded = new Dictionary<string, bool>(); foreach (string moduleName in modules.ModuleIndex.Keys) { alreadyLoaded[moduleName] = true; } // add module to context, get its dependencies in graph AdjacencyGraph<Module, Edge<Module>> dependencyGraph = new AdjacencyGraph<Module, Edge<Module>>(true); AddModuleToContextByName(modName, modules, context, dependencyGraph); // add dependency tree into context's dependency list foreach (Module module in dependencyGraph.TopologicalSort()) { if (!alreadyLoaded.ContainsKey(module.ModuleName)) { modules.DependencyOrder.Add(module); } } }
private static AdjacencyGraph<string, Edge<string>> BuildReferencesGraph(out Dictionary<string, string> servers) { servers = new Dictionary<string, string>(); var graph = new AdjacencyGraph<string, Edge<string>>(); foreach (var serverName in Args.ServerNames.Split('|')) { var projectsPath = Paths.ProjectsFolder(serverName); foreach (var projectFolder in Directory.GetDirectories(projectsPath)) { var projectName = Path.GetFileName(projectFolder); var referencesFolder = Path.Combine(projectFolder, Args.ReferencesFolder); servers.Add(projectName, serverName); if (!Directory.Exists(referencesFolder)) continue; var referenceFiles = Directory.GetFiles(referencesFolder).Select(Path.GetFileNameWithoutExtension); graph.AddVerticesAndEdgeRange(referenceFiles.Select(referenceName => new Edge<string>(referenceName, projectName))); } } return graph; }
public void CheckPredecessorDoubleLineGraph() { AdjacencyGraph<int, Edge<int>> g = new AdjacencyGraph<int, Edge<int>>(true); g.AddVertex(1); g.AddVertex(2); g.AddVertex(3); Edge<int> e12 = new Edge<int>(1, 2); g.AddEdge(e12); Edge<int> e23 = new Edge<int>(2, 3); g.AddEdge(e23); Edge<int> e13 = new Edge<int>(1, 3); g.AddEdge(e13); var dij = new DijkstraShortestPathAlgorithm<int, Edge<int>>(g, e => 1); var vis = new VertexPredecessorRecorderObserver<int, Edge<int>>(); using(vis.Attach(dij)) dij.Compute(1); IEnumerable<Edge<int>> path; Assert.IsTrue(vis.TryGetPath(2, out path)); var col = path.ToList(); Assert.AreEqual(1, col.Count); Assert.AreEqual(e12, col[0]); Assert.IsTrue(vis.TryGetPath(3, out path)); col = path.ToList(); Assert.AreEqual(1, col.Count); Assert.AreEqual(e13, col[0]); }
public void CheckPredecessorLineGraph() { AdjacencyGraph<int, Edge<int>> g = new AdjacencyGraph<int, Edge<int>>(true); g.AddVertex(1); g.AddVertex(2); g.AddVertex(3); Edge<int> e12 = new Edge<int>(1, 2); g.AddEdge(e12); Edge<int> e23 = new Edge<int>(2, 3); g.AddEdge(e23); Dictionary<Edge<int>, double> weights = DijkstraShortestPathAlgorithm<int, Edge<int>>.UnaryWeightsFromEdgeList(g); DijkstraShortestPathAlgorithm<int, Edge<int>> dij = new DijkstraShortestPathAlgorithm<int, Edge<int>>(g, weights); VertexPredecessorRecorderObserver<int, Edge<int>> vis = new VertexPredecessorRecorderObserver<int, Edge<int>>(); vis.Attach(dij); dij.Compute(1); IList<Edge<int>> col = vis.Path(2); Assert.AreEqual(1, col.Count); Assert.AreEqual(e12, col[0]); col = vis.Path(3); Assert.AreEqual(2, col.Count); Assert.AreEqual(e12, col[0]); Assert.AreEqual(e23, col[1]); }
public QGPathFinder(FloorPlan floorPlan) { this.messages += "- Checking Floor Plan...\n"; graph = new AdjacencyGraph<string, Edge<string>>(true); edgeCost = new Dictionary<Edge<string>, double>(graph.EdgeCount); this.fp = floorPlan; if (this.fp.getStartTile() != null) { this.messages += " Start Point is OK...\n"; startPoint = this.fp.getStartTile().Position.X + "_" + this.fp.getStartTile().Position.Y; } else { this.messages += " Start Point is not valid...\n"; startPoint = "4_4"; } if (this.fp.getTargetTile() != null) { this.messages += " Target Point is OK...\n"; targetPoint = this.fp.getTargetTile().Position.X + "_" + this.fp.getTargetTile().Position.Y; } else { this.messages += " Target Point is not valid...\n"; targetPoint = "4_6"; } buildGraph(); }
public RouteFinder(IGameDataProvider gameDataProvider) { provider = gameDataProvider; logger = LogManager.GetCurrentClassLogger(); graph = new AdjacencyGraph<StarSystem, Edge<StarSystem>>(); weights = new Dictionary<Edge<StarSystem>, double>(); }
public void FileDependency() { AdjacencyGraph<string, Edge<string>> g = new AdjacencyGraph<string, Edge<string>>(); GraphFactory.FileDependency(g); this.Compute(g); this.ComputeCriticalPath(g); }
public QGPathFinder(Status status, MainForm parent) { m_parent = parent; m_status = status; graph = new AdjacencyGraph<string, Edge<string>>(true); edgeCost = new Dictionary<Edge<string>, double>(graph.EdgeCount); this.fp = m_status.floorPlan; if (this.m_status.position != null) { startPoint = this.m_status.position.location.X + "_" + this.m_status.position.location.Y; m_parent.PostMessage("start: " + startPoint); } else { startPoint = "4_4"; } if (this.m_status.endPoint!= null) { targetPoint = this.m_status.endPoint.X + "_" + this.m_status.endPoint.Y; m_parent.PostMessage("end: " + targetPoint); } else { targetPoint = "4_6"; } buildGraph(); }
/// <summary> /// Przerabia graf na string z odnalezionymi paternami /// </summary> /// <param name="g"></param> /// <returns></returns> public string FindAllPatterns(AdjacencyGraph<Node, Edge<Node>> g) { bool nodesStillInGraph = true; while (nodesStillInGraph) { var decisionNodes = g.Vertices.Where(x => x.Type == NodeType.DecisionNode).ToList(); var forkNodes = g.Vertices.Where(x => x.Type == NodeType.ForkNode).ToList(); if (decisionNodes.Count == 0 && forkNodes.Count == 0) { nodesStillInGraph = false; continue; } g = FindLoopPattern(g); g = FindSeqPattern(g); g = FindDecisionPattern(g); g = FindSeqPattern(g); g = FindParPattern(g); g = FindSeqPattern(g); } if (g.Vertices.Count() == 3 && g.Edges.Count() == 2) { var start = g.Vertices.Where(x => x.Type == NodeType.InitalNode).ToList().FirstOrDefault(); var end = g.Vertices.Where(x => x.Type == NodeType.ActivityFinalNode).ToList().FirstOrDefault(); var body = g.Vertices.Where(x => x != start && x != end).ToList().FirstOrDefault(); return "seqseq(" + start.Name + "," + body.Name + "," + end.Name + ")"; } return "ERROR"; }
public void IsolatedVertex() { AdjacencyGraph<int, Edge<int>> g = new AdjacencyGraph<int, Edge<int>>(true); g.AddVertex(0); target = new CyclePoppingRandomTreeAlgorithm<int, Edge<int>>(g); target.RandomTree(); }
public void EmptyGraph() { IVertexListGraph<string, Edge<string>> g = new AdjacencyGraph<string, Edge<string>>(true); StronglyConnectedComponentsAlgorithm<string, Edge<String>> strong = new StronglyConnectedComponentsAlgorithm<string, Edge<String>>(g); strong.Compute(); Assert.AreEqual(0, strong.ComponentCount); checkStrong(strong); }
public void Init() { this.parents = new Dictionary<int, int>(); this.distances = new Dictionary<int, int>(); this.currentDistance = 0; this.algo = null; this.g = null; }
static AdjacencyGraph<Vertex, Edge<Vertex>> CreateAdjacencyGraph(StateMachineGraph data) { var graph = new AdjacencyGraph<Vertex, Edge<Vertex>>(); graph.AddVertexRange(data.Vertices); graph.AddEdgeRange(data.Edges.Select(x => new Edge<Vertex>(x.From, x.To))); return graph; }
/// <summary> /// Initializes a new instance of the <see cref="GraphBuilder2"/> class. /// </summary> /// <param name="bidirectional"> /// Specify if the graph must be build using both edges directions. /// </param> public PathFinder(bool bidirectional) { this.bidirectional = bidirectional; factory = null; strings = new List<ILineString>(); graph = new AdjacencyGraph<Coordinate, IEdge<Coordinate>>(true); }
public void IsolatedVerticesWithRoot() { var g = new AdjacencyGraph<int, Edge<int>>(true); g.AddVertex(0); g.AddVertex(1); var target = new CyclePoppingRandomTreeAlgorithm<int, Edge<int>>(g); target.RandomTreeWithRoot(0); }
public void OneTwo() { var graph = new AdjacencyGraph<int, Edge<int>>(); graph.AddVertex(1); graph.AddVertex(2); graph.AddEdge(new Edge<int>(1, 2)); var t = new TopologicalSortAlgorithm<int, Edge<int>>(graph); t.Compute(); }
public void OneVertex() { AdjacencyGraph<string, Edge<string>> g = new AdjacencyGraph<string, Edge<string>>(true); g.AddVertex("test"); StronglyConnectedComponentsAlgorithm<string, Edge<String>> strong = new StronglyConnectedComponentsAlgorithm<string, Edge<String>>(g); strong.Compute(); Assert.AreEqual(1, strong.ComponentCount); checkStrong(strong); }
//graph, tgraph, sourceNode, endNode, weight public static void AddEdgeToBoth(AdjacencyGraph<string, Edge<string>> graph, AdjacencyGraph<string, Edge<string>> tGraph, Dictionary<Edge<string>, double> edgeCost, Dictionary<Edge<string>, double> tEdgeCost, string sourceString, string endString, int weight) { Edge<string> curEdge = new Edge<string>(sourceString, endString); graph.AddEdge(curEdge); edgeCost.Add(curEdge, weight); Edge<string> transposeEdge = new Edge<string>(endString, sourceString); tGraph.AddEdge(transposeEdge); tEdgeCost.Add(transposeEdge, weight); }
public void RootIsNotAccessible() { AdjacencyGraph<int, Edge<int>> g = new AdjacencyGraph<int, Edge<int>>(true); g.AddVertex(0); g.AddVertex(1); g.AddEdge(new Edge<int>(0, 1)); target = new CyclePoppingRandomTreeAlgorithm<int, Edge<int>>(g); target.RandomTreeWithRoot(0); }
private static AdjacencyGraph<Node, Edge<Node>> ReadGraph(string filename) { var graph = new AdjacencyGraph<Node, Edge<Node>>(); using (var reader = XmlReader.Create(filename)) { graph.DeserializeFromGraphML(reader, id => new Node(), (source, target, id) => new Edge<Node>(source, target)); } return graph; }
public DoorAndClueManager(MapCycleReducer reducedMap, int startVertex) { this.mapNoCycles = reducedMap; this.startVertex = startVertex; lockDependencyGraph = new AdjacencyGraph<int, Edge<int>>(); doorMap = new Dictionary<int, Door>(); clueMap = new Dictionary<int, List<Clue>>(); objectiveMap = new Dictionary<int, Objective>(); objectiveRoomMap = new Dictionary<int, List<Objective>>(); }
public void TwoVertexOnEdge() { AdjacencyGraph<string, Edge<string>> g = new AdjacencyGraph<string, Edge<string>>(true); g.AddVertex("v1"); g.AddVertex("v2"); g.AddEdge(new Edge<string>("v1", "v2")); StronglyConnectedComponentsAlgorithm<string, Edge<String>> strong = new StronglyConnectedComponentsAlgorithm<string, Edge<String>>(g); strong.Compute(); Assert.AreEqual(2, strong.ComponentCount); checkStrong(strong); }
public IEnumerable<MapSolarSystemEdge> NearestRoute(long fromSolarSystemID, long toSolarSystemID, bool safeOnly = false) { eveGraph = new AdjacencyGraph<SolarSystem, Edge<SolarSystem>>(); // Eve universe getPathCache = new Dictionary<long, TryFunc<SolarSystem, IEnumerable<Edge<SolarSystem>>>>(); // function cache var dbResult = (from s in context.SolarSystems from e in s.ToSolarSystems where s.security >= (safeOnly ? 0.5 : -20) select new { From = s, To = e }).AsEnumerable(); var edges = dbResult.Select(a => new Edge<SolarSystem>(a.From, a.To)).OrderBy(e => e.Source.solarSystemID).ToList(); var vertices = context.SolarSystems; eveGraph.AddVertexRange(vertices); // Fill Graph eveGraph.AddEdgeRange(edges); // Fill Graph var allPathes = new List<IEnumerable<Edge<SolarSystem>>>(); var result = new List<MapSolarSystemEdge>(); var from = context.SolarSystems.Where(m => m.solarSystemID == fromSolarSystemID).SingleOrDefault(); var linkedSystems = from system in context.SolarSystems where system.solarSystemID == toSolarSystemID && system.security >= (safeOnly ? 0.5 : -20) select system; TryFunc<SolarSystem, IEnumerable<Edge<SolarSystem>>> tryGetPath; if (getPathCache.ContainsKey(from.solarSystemID)) { tryGetPath = getPathCache[from.solarSystemID]; } else { tryGetPath = eveGraph.ShortestPathsDijkstra(v => 1, from); getPathCache[from.solarSystemID] = tryGetPath; } foreach (var s in linkedSystems) { IEnumerable<Edge<SolarSystem>> path; if (tryGetPath(s, out path)) { allPathes.Add(path); } } var shortestPath = allPathes.OrderBy(p => p.Count()).FirstOrDefault(); if (shortestPath == null) return null; foreach (var item in shortestPath) { result.Add(new MapSolarSystemEdge() { From = item.Source.solarSystemID, To = item.Target.solarSystemID }); } return result; }
public void setGraph() { listEdgeNotInShortestGraph = new List <Edge <node> >(); myGraph = new AdjacencyGraph <node, Edge <node> >(); edgeCost = new Dictionary <Edge <node>, float>(myRoad.Count); foreach (node node in myNode) { myGraph.AddVertex(node); } foreach (Road road in myRoad) { node n1 = myNode[road.node1 - 1]; node n2 = myNode[road.node2 - 1]; Edge <node> edge = new Edge <node>(n1, n2); myGraph.AddEdge(edge); edgeCost.Add(edge, road.length); if (contains(listEdgeNotInShortestGraph, edge)[0] != 1) { listEdgeNotInShortestGraph.Add(edge); } } listEdgeShortestGraph = new List <Edge <node> >(); }
public void Construction() { var graph1 = new AdjacencyGraph <int, Edge <int> >(); var graph2 = new AdjacencyGraph <int, Edge <int> >(); // Value type CheckEdge( new CondensedEdge <int, Edge <int>, AdjacencyGraph <int, Edge <int> > >(graph1, graph2), graph1, graph2); CheckEdge( new CondensedEdge <int, Edge <int>, AdjacencyGraph <int, Edge <int> > >(graph2, graph1), graph2, graph1); CheckEdge( new CondensedEdge <int, Edge <int>, AdjacencyGraph <int, Edge <int> > >(graph1, graph1), graph1, graph1); // Reference type var graph3 = new AdjacencyGraph <TestVertex, Edge <TestVertex> >(); var graph4 = new AdjacencyGraph <TestVertex, Edge <TestVertex> >(); CheckEdge( new CondensedEdge <TestVertex, Edge <TestVertex>, AdjacencyGraph <TestVertex, Edge <TestVertex> > >(graph3, graph4), graph3, graph4); CheckEdge( new CondensedEdge <TestVertex, Edge <TestVertex>, AdjacencyGraph <TestVertex, Edge <TestVertex> > >(graph4, graph3), graph4, graph3); CheckEdge( new CondensedEdge <TestVertex, Edge <TestVertex>, AdjacencyGraph <TestVertex, Edge <TestVertex> > >(graph3, graph3), graph3, graph3); }
public void Constructor() { var graph = new AdjacencyGraph <int, Edge <int> >(); var algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(graph); AssertAlgorithmProperties(algorithm, graph); algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(null, graph); AssertAlgorithmProperties(algorithm, graph); #region Local function void AssertAlgorithmProperties <TVertex, TEdge>( EulerianTrailAlgorithm <TVertex, TEdge> algo, IMutableVertexAndEdgeListGraph <TVertex, TEdge> g) where TEdge : IEdge <TVertex> { AssertAlgorithmState(algo, g); CollectionAssert.IsEmpty(algo.Circuit); } #endregion }
public void OneWeaklyConnectedComponent() { var edge12 = new Edge<int>(1, 2); var edge13 = new Edge<int>(1, 3); var edge23 = new Edge<int>(2, 3); var edge42 = new Edge<int>(4, 2); var edge43 = new Edge<int>(4, 3); var edge45 = new Edge<int>(4, 5); var edge56 = new Edge<int>(5, 6); var edge57 = new Edge<int>(5, 7); var edge76 = new Edge<int>(7, 6); var edge71 = new Edge<int>(7, 1); var edge89 = new Edge<int>(8, 9); var edge82 = new Edge<int>(8, 2); var graph = new AdjacencyGraph<int, Edge<int>>(); graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge23, edge42, edge43, edge45, edge56, edge57, edge76, edge71, edge89, edge82 }); IMutableBidirectionalGraph<AdjacencyGraph<int, Edge<int>>, CondensedEdge<int, Edge<int>, AdjacencyGraph<int, Edge<int>>>> condensedGraph = graph.CondensateWeaklyConnected<int, Edge<int>, AdjacencyGraph<int, Edge<int>>>(); Assert.IsNotNull(condensedGraph); Assert.AreEqual(1, condensedGraph.VertexCount); Assert.AreEqual(0, condensedGraph.EdgeCount); CollectionAssert.AreEquivalent(graph.Vertices, condensedGraph.Vertices.ElementAt(0).Vertices); CollectionAssert.AreEquivalent(graph.Edges, condensedGraph.Vertices.ElementAt(0).Edges); }
public void TryGetPath() { { var recorder = new VertexPredecessorRecorderObserver <int, Edge <int> >(); var graph = new AdjacencyGraph <int, Edge <int> >(); var dfs = new DepthFirstSearchAlgorithm <int, Edge <int> >(graph); using (recorder.Attach(dfs)) { dfs.Compute(); // Vertex not in the graph Assert.IsFalse(recorder.TryGetPath(2, out _)); } } { var recorder = new VertexPredecessorRecorderObserver <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(); Assert.IsFalse(recorder.TryGetPath(2, out _)); } } { var recorder = new VertexPredecessorRecorderObserver <int, Edge <int> >(); // Graph without cycle var edge12 = new Edge <int>(1, 2); var edge13 = new Edge <int>(1, 3); var edge14 = new Edge <int>(1, 4); var edge24 = new Edge <int>(2, 4); var edge31 = new Edge <int>(3, 1); var edge33 = new Edge <int>(3, 3); var edge34 = new Edge <int>(3, 4); var graph = new AdjacencyGraph <int, Edge <int> >(); graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33, edge34 }); var dfs = new DepthFirstSearchAlgorithm <int, Edge <int> >(graph); using (recorder.Attach(dfs)) { dfs.Compute(); Assert.IsTrue(recorder.TryGetPath(4, out IEnumerable <Edge <int> > path)); CollectionAssert.AreEqual(new[] { edge12, edge24 }, path); } } { var recorder = new VertexPredecessorRecorderObserver <int, Edge <int> >(); // Graph with cycle var edge12 = new Edge <int>(1, 2); var edge13 = new Edge <int>(1, 3); var edge14 = new Edge <int>(1, 4); var edge24 = new Edge <int>(2, 4); var edge31 = new Edge <int>(3, 1); var edge33 = new Edge <int>(3, 3); var edge34 = new Edge <int>(3, 4); var edge41 = new Edge <int>(4, 1); var graph = new AdjacencyGraph <int, Edge <int> >(); graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33, edge34, edge41 }); var dfs = new DepthFirstSearchAlgorithm <int, Edge <int> >(graph); using (recorder.Attach(dfs)) { dfs.Compute(); Assert.IsTrue(recorder.TryGetPath(4, out IEnumerable <Edge <int> > path)); CollectionAssert.AreEqual(new[] { edge12, edge24 }, path); } } }
public void DeserializeFromGraphML_Throws() { // ReSharper disable AssignNullToNotNullAttribute // Filepath Assert.Throws <ArgumentNullException>( () => ((AdjacencyGraph <string, Edge <string> >)null).DeserializeFromGraphML( GetGraphFilePath(TestGraphFileName), id => id, (source, target, id) => new Edge <string>(source, target))); var graph = new AdjacencyGraph <string, Edge <string> >(); Assert.Throws <ArgumentException>( () => graph.DeserializeFromGraphML( (string)null, id => id, (source, target, id) => new Edge <string>(source, target))); Assert.Throws <ArgumentException>( () => graph.DeserializeFromGraphML( "", id => id, (source, target, id) => new Edge <string>(source, target))); Assert.Throws <ArgumentNullException>( () => graph.DeserializeFromGraphML <string, Edge <string>, AdjacencyGraph <string, Edge <string> > >( GetGraphFilePath(TestGraphFileName), null, (source, target, id) => new Edge <string>(source, target))); Assert.Throws <ArgumentNullException>( () => graph.DeserializeFromGraphML <string, Edge <string>, AdjacencyGraph <string, Edge <string> > >( GetGraphFilePath(TestGraphFileName), id => id, null)); // Text reader Assert.Throws <ArgumentNullException>( () => graph.DeserializeFromGraphML( (TextReader)null, id => id, (source, target, id) => new Edge <string>(source, target))); using (var reader = new StreamReader(GetGraphFilePath(TestGraphFileName))) { Assert.Throws <ArgumentNullException>( () => ((AdjacencyGraph <string, Edge <string> >)null).DeserializeFromGraphML( reader, id => id, (source, target, id) => new Edge <string>(source, target))); Assert.Throws <ArgumentNullException>( () => graph.DeserializeFromGraphML <string, Edge <string>, AdjacencyGraph <string, Edge <string> > >( reader, null, (source, target, id) => new Edge <string>(source, target))); Assert.Throws <ArgumentNullException>( () => graph.DeserializeFromGraphML <string, Edge <string>, AdjacencyGraph <string, Edge <string> > >( reader, id => id, null)); } // XML reader Assert.Throws <ArgumentNullException>( () => graph.DeserializeFromGraphML( (XmlReader)null, id => id, (source, target, id) => new Edge <string>(source, target))); using (XmlReader reader = XmlReader.Create(GetGraphFilePath(TestGraphFileName))) { Assert.Throws <ArgumentNullException>( () => ((AdjacencyGraph <string, Edge <string> >)null).DeserializeFromGraphML( reader, id => id, (source, target, id) => new Edge <string>(source, target))); Assert.Throws <ArgumentNullException>( () => graph.DeserializeFromGraphML <string, Edge <string>, AdjacencyGraph <string, Edge <string> > >( reader, null, (source, target, id) => new Edge <string>(source, target))); Assert.Throws <ArgumentNullException>( () => graph.DeserializeFromGraphML <string, Edge <string>, AdjacencyGraph <string, Edge <string> > >( reader, id => id, null)); } // ReSharper restore AssignNullToNotNullAttribute }
static void Main(string[] args) { var graph = new AdjacencyGraph <int, Edge <int> >(); graph.AddVertex(1); graph.AddVertex(2); graph.AddVertex(3); graph.AddVertex(4); //Console.WriteLine(graph.VertexCount); //var v = graph.Vertices.First(); //Console.WriteLine(v); var e12 = new Edge <int>(1, 2); var e23 = new Edge <int>(2, 3); var e34 = new Edge <int>(3, 4); var e14 = new Edge <int>(1, 4); var e24 = new Edge <int>(2, 4); //var graph = new AdjacencyGraph<int, Edge<int>>(); graph.AddEdge(e12); graph.AddEdge(e23); graph.AddEdge(e34); graph.AddEdge(e14); graph.AddEdge(e24); Console.WriteLine("Rzad grafu G wynosi: " + graph.VertexCount); Console.WriteLine("Rozmiar grafu G wynosi: " + graph.EdgeCount); for (int i = 0; i < graph.EdgeCount; i++) { Degree(graph.Edges.ToList()[i]); } for (int i = 1; i <= graphDegree.Count; i++) { Console.WriteLine("deg(" + i + "): " + graphDegree[i]); } Console.Write("Ciag stopni grafu G: "); foreach (int d in graphDegree.Select(x => x.Value).OrderBy(x => x)) { Console.Write(d + ", "); } //Dictionary<Edge<int>, double> edgeCost = new Dictionary<Edge<int>, double>(graph.EdgeCount); //DijkstraShortestPathAlgorithm<int, Edge<int>> dijkstra = new DijkstraShortestPathAlgorithm<int, Edge<int>>(graph, AlgorithmExtensions.GetIndexer<Edge<int>, double>(edgeCost)); //// Attach a Vertex Predecessor Recorder Observer to give us the paths //QuickGraph.Algorithms.Observers.VertexPredecessorRecorderObserver<int, Edge<int>> predecessorObserver = new QuickGraph.Algorithms.Observers.VertexPredecessorRecorderObserver<int, Edge<int>>(); //predecessorObserver.Attach(dijkstra); //// attach a distance observer to give us the shortest path distances //VertexDistanceRecorderObserver<int, Edge<int>> distObserver = new VertexDistanceRecorderObserver<int, Edge<int>>(AlgorithmExtensions.GetIndexer<Edge<int>, double>(edgeCost)); //distObserver.Attach(dijkstra); //// Run the algorithm with A set to be the source //dijkstra.Compute(1); //Console.WriteLine(graph.(3)); //foreach (var edges in graph.Edges) // Console.WriteLine(edges); //// graph.AddEdge(); //foreach (var vertex in graph.Vertices) // foreach (var edge in graph.OutEdges(vertex)) // Console.WriteLine(edge); Console.ReadKey(); }
public void BuildGraphAndSearchShortestPathUsingGeometryUnion() { IGeometry edges = a.Union(b).Union(c).Union(d).Union(e); Assert.IsNotNull(edges); Assert.IsTrue(edges.GetType() == typeof(MultiLineString)); Assert.Greater(edges.NumGeometries, 0); foreach (IGeometry edge in ((GeometryCollection)edges).Geometries) { Assert.IsNotNull(edge); Assert.IsTrue(edge.GetType() == typeof(LineString)); Debug.WriteLine(edge); } // Build graph IDictionary <IEdge <IGeometry>, double> consts = new Dictionary <IEdge <IGeometry>, double>(edges.NumGeometries); AdjacencyGraph <IGeometry, IEdge <IGeometry> > graph = new AdjacencyGraph <IGeometry, IEdge <IGeometry> >(true); foreach (ILineString str in ((GeometryCollection)edges).Geometries) { // Add vertex 1 IGeometry vertex1 = str.StartPoint; Assert.IsNotNull(vertex1); if (!graph.ContainsVertex(vertex1)) { Debug.WriteLine(String.Format("Adding vertex {0} to the list", vertex1)); graph.AddVertex(vertex1); } else { Debug.WriteLine(String.Format("Vertex {0} already present", vertex1)); } // Add vertex 2 IGeometry vertex2 = str.EndPoint; Assert.IsNotNull(vertex2); if (!graph.ContainsVertex(vertex2)) { Debug.WriteLine(String.Format("Adding vertex {0} to the list", vertex2)); graph.AddVertex(vertex2); } else { Debug.WriteLine(String.Format("Vertex {0} already present", vertex2)); } // Compute weight double weight = weightComputer(str); Assert.Greater(weight, 0.0); // Add edge for 1 => 2 IEdge <IGeometry> edge1 = new Edge <IGeometry>(vertex1, vertex2); Assert.IsNotNull(edge1); graph.AddEdge(edge1); consts.Add(edge1, weight); // Add edge for 2 => 1 IEdge <IGeometry> edge2 = new Edge <IGeometry>(vertex2, vertex1); Assert.IsNotNull(edge2); graph.AddEdge(edge2); consts.Add(edge2, weight); } // Perform DijkstraShortestPathAlgorithm DijkstraShortestPathAlgorithm <IGeometry, IEdge <IGeometry> > dijkstra = new DijkstraShortestPathAlgorithm <IGeometry, IEdge <IGeometry> >(graph, consts); // attach a distance observer to give us the shortest path distances VertexDistanceRecorderObserver <IGeometry, IEdge <IGeometry> > distObserver = new VertexDistanceRecorderObserver <IGeometry, IEdge <IGeometry> >(); distObserver.Attach(dijkstra); // Attach a Vertex Predecessor Recorder Observer to give us the paths VertexPredecessorRecorderObserver <IGeometry, IEdge <IGeometry> > predecessorObserver = new VertexPredecessorRecorderObserver <IGeometry, IEdge <IGeometry> >(); predecessorObserver.Attach(dijkstra); // Run the algorithm Debug.WriteLine(String.Format("Starting algorithm from root vertex {0}", start)); dijkstra.Compute(start); foreach (KeyValuePair <IGeometry, int> kvp in distObserver.Distances) { Debug.WriteLine(String.Format("Distance from root to node {0} is {1}", kvp.Key, kvp.Value)); } foreach (KeyValuePair <IGeometry, IEdge <IGeometry> > kvp in predecessorObserver.VertexPredecessors) { Debug.WriteLine(String.Format( "If you want to get to {0} you have to enter through the IN edge {1}", kvp.Key, kvp.Value)); } Check(graph, consts, predecessorObserver); // Detach the observers distObserver.Detach(dijkstra); predecessorObserver.Detach(dijkstra); }
public void FloydWarshall_Throws() { // Without negative cycle var edge12 = new Edge <int>(1, 2); var edge23 = new Edge <int>(2, 3); var edge34 = new Edge <int>(3, 4); var negativeWeightGraph = new AdjacencyGraph <int, Edge <int> >(); negativeWeightGraph.AddVerticesAndEdgeRange(new[] { edge12, edge23, edge34 }); var algorithm = new FloydWarshallAllShortestPathAlgorithm <int, Edge <int> >( negativeWeightGraph, e => { if (e == edge12) { return(12.0); } if (e == edge23) { return(-23.0); } if (e == edge34) { return(-34.0); } return(1.0); }); Assert.DoesNotThrow(() => algorithm.Compute()); // With negative cycle var edge41 = new Edge <int>(4, 1); var negativeCycleGraph = new AdjacencyGraph <int, Edge <int> >(); negativeCycleGraph.AddVerticesAndEdgeRange(new[] { edge12, edge23, edge34, edge41 }); algorithm = new FloydWarshallAllShortestPathAlgorithm <int, Edge <int> >( negativeCycleGraph, e => { if (e == edge12) { return(12.0); } if (e == edge23) { return(-23.0); } if (e == edge34) { return(-34.0); } if (e == edge41) { return(41.0); } return(1.0); }); Assert.Throws <NegativeCycleGraphException>(() => algorithm.Compute()); }
public void Clone() { var wrappedGraph = new AdjacencyGraph <int, Edge <int> >(); var graph = new ArrayAdjacencyGraph <int, Edge <int> >(wrappedGraph); AssertEmptyGraph(graph); var clonedGraph = graph.Clone(); Assert.IsNotNull(clonedGraph); AssertEmptyGraph(clonedGraph); clonedGraph = (ArrayAdjacencyGraph <int, Edge <int> >)((ICloneable)graph).Clone(); Assert.IsNotNull(clonedGraph); AssertEmptyGraph(clonedGraph); wrappedGraph.AddVertexRange(new[] { 1, 2, 3 }); graph = new ArrayAdjacencyGraph <int, Edge <int> >(wrappedGraph); AssertHasVertices(graph, new[] { 1, 2, 3 }); AssertNoEdge(graph); clonedGraph = graph.Clone(); Assert.IsNotNull(clonedGraph); AssertHasVertices(clonedGraph, new[] { 1, 2, 3 }); AssertNoEdge(clonedGraph); clonedGraph = (ArrayAdjacencyGraph <int, Edge <int> >)((ICloneable)graph).Clone(); Assert.IsNotNull(clonedGraph); AssertHasVertices(clonedGraph, new[] { 1, 2, 3 }); AssertNoEdge(clonedGraph); var edge1 = new Edge <int>(1, 2); var edge2 = new Edge <int>(1, 3); var edge3 = new Edge <int>(2, 3); wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3 }); graph = new ArrayAdjacencyGraph <int, Edge <int> >(wrappedGraph); AssertHasVertices(graph, new[] { 1, 2, 3 }); AssertHasEdges(graph, new[] { edge1, edge2, edge3 }); clonedGraph = graph.Clone(); Assert.IsNotNull(clonedGraph); AssertHasVertices(clonedGraph, new[] { 1, 2, 3 }); AssertHasEdges(clonedGraph, new[] { edge1, edge2, edge3 }); clonedGraph = (ArrayAdjacencyGraph <int, Edge <int> >)((ICloneable)graph).Clone(); Assert.IsNotNull(clonedGraph); AssertHasVertices(clonedGraph, new[] { 1, 2, 3 }); AssertHasEdges(clonedGraph, new[] { edge1, edge2, edge3 }); wrappedGraph.AddVertex(4); graph = new ArrayAdjacencyGraph <int, Edge <int> >(wrappedGraph); AssertHasVertices(graph, new[] { 1, 2, 3, 4 }); AssertHasEdges(graph, new[] { edge1, edge2, edge3 }); clonedGraph = graph.Clone(); Assert.IsNotNull(clonedGraph); AssertHasVertices(clonedGraph, new[] { 1, 2, 3, 4 }); AssertHasEdges(clonedGraph, new[] { edge1, edge2, edge3 }); clonedGraph = (ArrayAdjacencyGraph <int, Edge <int> >)((ICloneable)graph).Clone(); Assert.IsNotNull(clonedGraph); AssertHasVertices(clonedGraph, new[] { 1, 2, 3, 4 }); AssertHasEdges(clonedGraph, new[] { edge1, edge2, edge3 }); }
static IEnumerable <BagColor> ColorsFor(AdjacencyGraph <BagColor, BagEdge> graph, BagColor color) => graph .Edges .Where(e => e.Target == color) .Select(e => e.Source);
public void Create() { var graph = new AdjacencyGraph <int, EquatableEdge <int> >(); // With self edge int v = 0; RandomGraphFactory.Create( graph, () => ++ v, (source, target) => new EquatableEdge <int>(source, target), new Random(123456), 5, 10, true); AssertHasVertices(graph, new[] { 1, 2, 3, 4, 5 }); AssertHasEdges( graph, new[] { new EquatableEdge <int>(1, 2), new EquatableEdge <int>(1, 2), new EquatableEdge <int>(1, 2), new EquatableEdge <int>(2, 1), new EquatableEdge <int>(3, 5), new EquatableEdge <int>(3, 1), new EquatableEdge <int>(4, 5), new EquatableEdge <int>(4, 4), new EquatableEdge <int>(4, 1), new EquatableEdge <int>(5, 3) }); // Without self edge graph.Clear(); v = 0; RandomGraphFactory.Create( graph, () => ++ v, (source, target) => new EquatableEdge <int>(source, target), new Random(123456), 5, 10, false); AssertHasVertices(graph, new[] { 1, 2, 3, 4, 5 }); AssertHasEdges( graph, new[] { new EquatableEdge <int>(1, 2), new EquatableEdge <int>(1, 2), new EquatableEdge <int>(1, 2), new EquatableEdge <int>(2, 1), new EquatableEdge <int>(3, 5), new EquatableEdge <int>(3, 1), new EquatableEdge <int>(3, 1), new EquatableEdge <int>(4, 5), new EquatableEdge <int>(4, 1), new EquatableEdge <int>(5, 3) }); // Different seed change generated graph graph.Clear(); v = 0; RandomGraphFactory.Create( graph, () => ++ v, (source, target) => new EquatableEdge <int>(source, target), new Random(456789), 5, 10, true); AssertHasVertices(graph, new[] { 1, 2, 3, 4, 5 }); AssertHasEdges( graph, new[] { new EquatableEdge <int>(1, 2), new EquatableEdge <int>(2, 2), new EquatableEdge <int>(2, 5), new EquatableEdge <int>(3, 4), new EquatableEdge <int>(3, 2), new EquatableEdge <int>(4, 5), new EquatableEdge <int>(4, 2), new EquatableEdge <int>(4, 2), new EquatableEdge <int>(5, 2), new EquatableEdge <int>(5, 3) }); // On non empty graph, keep existing stuff graph.Clear(); graph.AddVerticesAndEdge(new EquatableEdge <int>(6, 7)); v = 0; RandomGraphFactory.Create( graph, () => ++ v, (source, target) => new EquatableEdge <int>(source, target), new Random(123456), 5, 10, true); AssertHasVertices(graph, new[] { 1, 2, 3, 4, 5, 6, 7 }); AssertHasEdges( graph, new[] { new EquatableEdge <int>(6, 7), new EquatableEdge <int>(1, 2), new EquatableEdge <int>(1, 2), new EquatableEdge <int>(1, 2), new EquatableEdge <int>(2, 1), new EquatableEdge <int>(3, 5), new EquatableEdge <int>(3, 1), new EquatableEdge <int>(4, 5), new EquatableEdge <int>(4, 4), new EquatableEdge <int>(4, 1), new EquatableEdge <int>(5, 3) }); }
public void Create_Throws() { var graph = new AdjacencyGraph <int, Edge <int> >(); var random = new Random(); // ReSharper disable AssignNullToNotNullAttribute Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( (IMutableVertexAndEdgeListGraph <int, Edge <int> >)null, () => 1, (source, target) => new Edge <int>(source, target), random, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( graph, null, (source, target) => new Edge <int>(source, target), random, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( graph, () => 1, null, random, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( graph, () => 1, (source, target) => new Edge <int>(source, target), null, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( (IMutableVertexAndEdgeListGraph <int, Edge <int> >)null, null, (source, target) => new Edge <int>(source, target), random, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( (IMutableVertexAndEdgeListGraph <int, Edge <int> >)null, () => 1, null, random, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( (IMutableVertexAndEdgeListGraph <int, Edge <int> >)null, () => 1, (source, target) => new Edge <int>(source, target), null, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( graph, null, null, random, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( graph, null, (source, target) => new Edge <int>(source, target), null, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( graph, () => 1, null, null, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( graph, null, null, null, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( (IMutableVertexAndEdgeListGraph <int, Edge <int> >)null, () => 1, null, null, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( (IMutableVertexAndEdgeListGraph <int, Edge <int> >)null, null, (source, target) => new Edge <int>(source, target), null, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( (IMutableVertexAndEdgeListGraph <int, Edge <int> >)null, null, null, random, 1, 1, false)); Assert.Throws <ArgumentNullException>( () => RandomGraphFactory.Create( (IMutableVertexAndEdgeListGraph <int, Edge <int> >)null, null, null, null, 1, 1, false)); // ReSharper restore AssignNullToNotNullAttribute Assert.Throws <ArgumentOutOfRangeException>( () => RandomGraphFactory.Create( graph, () => 1, (source, target) => new Edge <int>(source, target), random, -1, 1, false)); Assert.Throws <ArgumentOutOfRangeException>( () => RandomGraphFactory.Create( graph, () => 1, (source, target) => new Edge <int>(source, target), random, 0, 1, false)); Assert.Throws <ArgumentOutOfRangeException>( () => RandomGraphFactory.Create( graph, () => 1, (source, target) => new Edge <int>(source, target), random, 1, -1, false)); Assert.Throws <ArgumentOutOfRangeException>( () => RandomGraphFactory.Create( graph, () => 1, (source, target) => new Edge <int>(source, target), random, 1, 0, false)); Assert.Throws <ArgumentOutOfRangeException>( () => RandomGraphFactory.Create( graph, () => 1, (source, target) => new Edge <int>(source, target), random, 0, 0, false)); Assert.Throws <ArgumentOutOfRangeException>( () => RandomGraphFactory.Create( graph, () => 1, (source, target) => new Edge <int>(source, target), random, -1, -1, false)); }
public static (double, BidirectionalGraph <string, EquatableEdge <string> >) Get(AdjacencyGraph <int, Edge <int> > graph) { var tsp = new tsp(); foreach (var v in graph.Vertices) { tsp.AddVertex(v); } foreach (var e in graph.Edges) { tsp.AddDirectedEdge(e.Source, e.Target, 1.0); } var algorithm = new TSP <string, EquatableEdge <string>, BidirectionalGraph <string, EquatableEdge <string> > >(tsp.Graph, tsp.GetWeightsFunc()); algorithm.Compute(); return(algorithm.BestCost, algorithm.ResultPath); }
public static (double, BidirectionalGraph <string, TaggedEdge <string, string> >) Get(AdjacencyGraph <string, TaggedEdge <string, string> > graph) { var tsp = new tsp(); foreach (var v in graph.Vertices) { tsp.AddVertex(v); } foreach (var e in graph.Edges) { tsp.AddDirectedEdge(e.Source, e.Target, double.Parse(e.Tag)); } var weightFunc = tsp.GetWeightsFunc(); var algorithm = new TSP <string, EquatableEdge <string>, BidirectionalGraph <string, EquatableEdge <string> > >(tsp.Graph, weightFunc); algorithm.Compute(); var path = algorithm.ResultPath; if (path != null) { var results = new results(); foreach (var v in path.Vertices) { results.AddVertex(v); } foreach (var e in path.Edges) { results.AddDirectedEdge(e.Source, e.Target, weightFunc(e)); } return(algorithm.BestCost, results.Graph); } else { return(algorithm.BestCost, null); } }
public void Constructor_Throws() { // ReSharper disable ObjectCreationAsStatement // ReSharper disable AssignNullToNotNullAttribute var graph = new AdjacencyGraph <int, Edge <int> >(); Func <int, double> Heuristic = v => 1.0; Func <Edge <int>, double> Weights = e => 1.0; Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, Weights, Heuristic)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(graph, null, Heuristic)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(graph, Weights, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(graph, null, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, Heuristic)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, Weights, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, Heuristic)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, Weights, Heuristic, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(graph, null, Heuristic, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(graph, Weights, null, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(graph, Weights, Heuristic, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(graph, Weights, null, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(graph, null, Heuristic, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(graph, null, null, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, Weights, Heuristic, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, Weights, null, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, Heuristic, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, Weights, null, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, Heuristic, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, null, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, null, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, Weights, Heuristic, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, graph, null, Heuristic, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, graph, Weights, null, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, graph, Weights, Heuristic, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, graph, Weights, null, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, graph, null, Heuristic, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, graph, null, null, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, Weights, Heuristic, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, Weights, null, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, null, Heuristic, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, Weights, null, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, null, Heuristic, null)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, null, null, DistanceRelaxers.CriticalDistance)); Assert.Throws <ArgumentNullException>( () => new AStarShortestPathAlgorithm <int, Edge <int> >(null, null, null, null, null)); // ReSharper restore AssignNullToNotNullAttribute // ReSharper restore ObjectCreationAsStatement }
public void FacebookSeattleWordPuzzle() { /* A puzzle from Facebook Seattle opening party: * http://www.facebook.com/note.php?note_id=146727365346299 * You are given a list of relationships between the letters in a single word, all of which are in the form: * "The first occurrence of A comes before N occurrences of B." * You can safely assume that you have all such relationships except for any in which N would be 0. * Determine the original word, then go to http://www.facebook.com/seattle/[insert-word-here] to find the second part of the puzzle. * * The first occurrence of 'e' comes before 1 occurrence of 's'. * The first occurrence of 'i' comes before 1 occurrence of 'n'. * The first occurrence of 'i' comes before 1 occurrence of 'i'. * The first occurrence of 'n' comes before 2 occurrences of 'e'. * The first occurrence of 'e' comes before 1 occurrence of 'e'. * The first occurrence of 'i' comes before 1 occurrence of 'v'. * The first occurrence of 'n' comes before 1 occurrence of 'i'. * The first occurrence of 'n' comes before 1 occurrence of 'v'. * The first occurrence of 'i' comes before 1 occurrence of 's'. * The first occurrence of 't' comes before 1 occurrence of 's'. * The first occurrence of 'v' comes before 1 occurrence of 's'. * The first occurrence of 'v' comes before 2 occurrences of 'e'. * The first occurrence of 't' comes before 2 occurrences of 'e'. * The first occurrence of 'i' comes before 2 occurrences of 'e'. * The first occurrence of 'v' comes before 1 occurrence of 't'. * The first occurrence of 'n' comes before 1 occurrence of 't'. * The first occurrence of 'v' comes before 1 occurrence of 'i'. * The first occurrence of 'i' comes before 1 occurrence of 't'. * The first occurrence of 'n' comes before 1 occurrence of 's'. */ var graph = new AdjacencyGraph <Letter, Edge <Letter> >(); // A more generalized algorithm would handle duplicate letters automatically. // This is the quick and dirty solution. var i1 = new Letter('i'); var i2 = new Letter('i'); var e1 = new Letter('e'); var e2 = new Letter('e'); var s = new Letter('s'); var n = new Letter('n'); var t = new Letter('t'); var v = new Letter('v'); graph.AddVertexRange(new List <Letter> { e1, e2, s, i1, i2, n, t, v }); graph.AddEdge(new Edge <Letter>(e1, s)); graph.AddEdge(new Edge <Letter>(i1, n)); graph.AddEdge(new Edge <Letter>(i1, i2)); graph.AddEdge(new Edge <Letter>(n, e1)); graph.AddEdge(new Edge <Letter>(n, e2)); graph.AddEdge(new Edge <Letter>(e1, e2)); graph.AddEdge(new Edge <Letter>(i1, v)); graph.AddEdge(new Edge <Letter>(n, e1)); graph.AddEdge(new Edge <Letter>(n, v)); graph.AddEdge(new Edge <Letter>(i1, s)); graph.AddEdge(new Edge <Letter>(t, s)); graph.AddEdge(new Edge <Letter>(v, s)); graph.AddEdge(new Edge <Letter>(v, e1)); graph.AddEdge(new Edge <Letter>(v, e2)); graph.AddEdge(new Edge <Letter>(t, e1)); graph.AddEdge(new Edge <Letter>(t, e2)); graph.AddEdge(new Edge <Letter>(i1, e1)); graph.AddEdge(new Edge <Letter>(i1, e2)); graph.AddEdge(new Edge <Letter>(v, t)); graph.AddEdge(new Edge <Letter>(n, t)); graph.AddEdge(new Edge <Letter>(v, i2)); graph.AddEdge(new Edge <Letter>(i1, t)); graph.AddEdge(new Edge <Letter>(n, s)); var sort = new TopologicalSortAlgorithm <Letter, Edge <Letter> >(graph); sort.Compute(); var builder = new StringBuilder(); foreach (Letter item in sort.SortedVertices) { builder.Append(item); } string word = builder.ToString(); Assert.AreEqual("invitees", word); }
public void TopologicalSort_DCT8() { AdjacencyGraph <string, Edge <string> > graph = TestGraphFactory.LoadGraph(GetGraphFilePath("DCT8.graphml")); RunTopologicalSortAndCheck(graph); }
public void Attach() { // DFS is used for tests but result may change if using another search algorithm // or another starting point { var recorder = new VertexPredecessorRecorderObserver <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.VerticesPredecessors); } } { var recorder = new VertexPredecessorRecorderObserver <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.VerticesPredecessors); } } { var recorder = new VertexPredecessorRecorderObserver <int, Edge <int> >(); // Graph without cycle var edge12 = new Edge <int>(1, 2); var edge13 = new Edge <int>(1, 3); var edge14 = new Edge <int>(1, 4); var edge24 = new Edge <int>(2, 4); var edge31 = new Edge <int>(3, 1); var edge33 = new Edge <int>(3, 3); var edge34 = new Edge <int>(3, 4); var graph = new AdjacencyGraph <int, Edge <int> >(); graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33, edge34 }); var dfs = new DepthFirstSearchAlgorithm <int, Edge <int> >(graph); using (recorder.Attach(dfs)) { dfs.Compute(); CollectionAssert.AreEqual( new Dictionary <int, Edge <int> > { [2] = edge12, [3] = edge13, [4] = edge24 }, recorder.VerticesPredecessors); } } { var recorder = new VertexPredecessorRecorderObserver <int, Edge <int> >(); // Graph with cycle var edge12 = new Edge <int>(1, 2); var edge13 = new Edge <int>(1, 3); var edge14 = new Edge <int>(1, 4); var edge24 = new Edge <int>(2, 4); var edge31 = new Edge <int>(3, 1); var edge33 = new Edge <int>(3, 3); var edge34 = new Edge <int>(3, 4); var edge41 = new Edge <int>(4, 1); var graph = new AdjacencyGraph <int, Edge <int> >(); graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33, edge34, edge41 }); var dfs = new DepthFirstSearchAlgorithm <int, Edge <int> >(graph); using (recorder.Attach(dfs)) { dfs.Compute(); CollectionAssert.AreEqual( new Dictionary <int, Edge <int> > { [2] = edge12, [3] = edge13, [4] = edge24 }, recorder.VerticesPredecessors); } } }
public void SortAll(AdjacencyGraph <string, Edge <string> > g) { this.Sort(g); }
public void AugmentAll(AdjacencyGraph <string, Edge <string> > g) { this.Augment(g); }
public void IncrementalConnectedComponent() { var graph = new AdjacencyGraph <int, Edge <int> >(); graph.AddVertexRange(new[] { 0, 1, 2, 3 }); var algorithm = new IncrementalConnectedComponentsAlgorithm <int, Edge <int> >(graph); algorithm.Compute(); Assert.AreEqual(4, algorithm.ComponentCount); Assert.AreEqual(4, algorithm.GetComponents().Key); CollectionAssert.AreEquivalent( new Dictionary <int, int> { [0] = 0, [1] = 1, [2] = 2, [3] = 3 }, algorithm.GetComponents().Value); graph.AddEdge(new Edge <int>(0, 1)); Assert.AreEqual(3, algorithm.ComponentCount); Assert.AreEqual(3, algorithm.GetComponents().Key); CollectionAssert.AreEquivalent( new Dictionary <int, int> { [0] = 0, [1] = 0, [2] = 1, [3] = 2 }, algorithm.GetComponents().Value); graph.AddEdge(new Edge <int>(2, 3)); Assert.AreEqual(2, algorithm.ComponentCount); Assert.AreEqual(2, algorithm.GetComponents().Key); CollectionAssert.AreEquivalent( new Dictionary <int, int> { [0] = 0, [1] = 0, [2] = 1, [3] = 1 }, algorithm.GetComponents().Value); graph.AddEdge(new Edge <int>(1, 3)); Assert.AreEqual(1, algorithm.ComponentCount); Assert.AreEqual(1, algorithm.GetComponents().Key); CollectionAssert.AreEquivalent( new Dictionary <int, int> { [0] = 0, [1] = 0, [2] = 0, [3] = 0 }, algorithm.GetComponents().Value); graph.AddVerticesAndEdge(new Edge <int>(4, 5)); Assert.AreEqual(2, algorithm.ComponentCount); Assert.AreEqual(2, algorithm.GetComponents().Key); CollectionAssert.AreEquivalent( new Dictionary <int, int> { [0] = 0, [1] = 0, [2] = 0, [3] = 0, [4] = 1, [5] = 1 }, algorithm.GetComponents().Value); graph.AddVertex(6); Assert.AreEqual(3, algorithm.ComponentCount); Assert.AreEqual(3, algorithm.GetComponents().Key); CollectionAssert.AreEquivalent( new Dictionary <int, int> { [0] = 0, [1] = 0, [2] = 0, [3] = 0, [4] = 1, [5] = 1, [6] = 2 }, algorithm.GetComponents().Value); }
public void Scenario() { AdjacencyGraph <string, Edge <string> > graph = CreateGraph(out Dictionary <Edge <string>, double> edgeCosts); // Run Dijkstra on this graph var dijkstra = new DijkstraShortestPathAlgorithm <string, Edge <string> >(graph, e => edgeCosts[e]); // Attach a Vertex Predecessor Recorder Observer to give us the paths var predecessorObserver = new VertexPredecessorRecorderObserver <string, Edge <string> >(); using (predecessorObserver.Attach(dijkstra)) { // Run the algorithm with A as source dijkstra.Compute("A"); } foreach (KeyValuePair <string, Edge <string> > pair in predecessorObserver.VerticesPredecessors) { Console.WriteLine($"If you want to get to {pair.Key} you have to enter through the in edge {pair.Value}."); } foreach (string vertex in graph.Vertices) { double distance = AlgorithmExtensions.ComputePredecessorCost( predecessorObserver.VerticesPredecessors, edgeCosts, vertex); Console.WriteLine($"A -> {vertex}: {distance}"); } #region Local function AdjacencyGraph <string, Edge <string> > CreateGraph(out Dictionary <Edge <string>, double> costs) { var g = new AdjacencyGraph <string, Edge <string> >(true); // Add some vertices to the graph g.AddVertex("A"); g.AddVertex("B"); g.AddVertex("C"); g.AddVertex("D"); g.AddVertex("E"); g.AddVertex("F"); g.AddVertex("G"); g.AddVertex("H"); g.AddVertex("I"); g.AddVertex("J"); // Create the edges // ReSharper disable InconsistentNaming var a_b = new Edge <string>("A", "B"); var a_d = new Edge <string>("A", "D"); var b_a = new Edge <string>("B", "A"); var b_c = new Edge <string>("B", "C"); var b_e = new Edge <string>("B", "E"); var c_b = new Edge <string>("C", "B"); var c_f = new Edge <string>("C", "F"); var c_j = new Edge <string>("C", "J"); var d_e = new Edge <string>("D", "E"); var d_g = new Edge <string>("D", "G"); var e_d = new Edge <string>("E", "D"); var e_f = new Edge <string>("E", "F"); var e_h = new Edge <string>("E", "H"); var f_i = new Edge <string>("F", "I"); var f_j = new Edge <string>("F", "J"); var g_d = new Edge <string>("G", "D"); var g_h = new Edge <string>("G", "H"); var h_g = new Edge <string>("H", "G"); var h_i = new Edge <string>("H", "I"); var i_f = new Edge <string>("I", "F"); var i_j = new Edge <string>("I", "J"); var i_h = new Edge <string>("I", "H"); var j_f = new Edge <string>("J", "F"); // ReSharper restore InconsistentNaming // Add the edges g.AddEdge(a_b); g.AddEdge(a_d); g.AddEdge(b_a); g.AddEdge(b_c); g.AddEdge(b_e); g.AddEdge(c_b); g.AddEdge(c_f); g.AddEdge(c_j); g.AddEdge(d_e); g.AddEdge(d_g); g.AddEdge(e_d); g.AddEdge(e_f); g.AddEdge(e_h); g.AddEdge(f_i); g.AddEdge(f_j); g.AddEdge(g_d); g.AddEdge(g_h); g.AddEdge(h_g); g.AddEdge(h_i); g.AddEdge(i_f); g.AddEdge(i_h); g.AddEdge(i_j); g.AddEdge(j_f); // Define some weights to the edges costs = new Dictionary <Edge <string>, double>(g.EdgeCount) { [a_b] = 4, [a_d] = 1, [b_a] = 74, [b_c] = 2, [b_e] = 12, [c_b] = 12, [c_f] = 74, [c_j] = 12, [d_e] = 32, [d_g] = 22, [e_d] = 66, [e_f] = 76, [e_h] = 33, [f_i] = 11, [f_j] = 21, [g_d] = 12, [g_h] = 10, [h_g] = 2, [h_i] = 72, [i_f] = 31, [i_h] = 18, [i_j] = 7, [j_f] = 8 }; return(g); } #endregion }
public void Scenario() { AdjacencyGraph <string, Edge <string> > graph = new AdjacencyGraph <string, Edge <string> >(true); // Add some vertices to the graph 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"); // Create the edges Edge <string> a_b = new Edge <string>("A", "B"); Edge <string> a_d = new Edge <string>("A", "D"); Edge <string> b_a = new Edge <string>("B", "A"); Edge <string> b_c = new Edge <string>("B", "C"); Edge <string> b_e = new Edge <string>("B", "E"); Edge <string> c_b = new Edge <string>("C", "B"); Edge <string> c_f = new Edge <string>("C", "F"); Edge <string> c_j = new Edge <string>("C", "J"); Edge <string> d_e = new Edge <string>("D", "E"); Edge <string> d_g = new Edge <string>("D", "G"); Edge <string> e_d = new Edge <string>("E", "D"); Edge <string> e_f = new Edge <string>("E", "F"); Edge <string> e_h = new Edge <string>("E", "H"); Edge <string> f_i = new Edge <string>("F", "I"); Edge <string> f_j = new Edge <string>("F", "J"); Edge <string> g_d = new Edge <string>("G", "D"); Edge <string> g_h = new Edge <string>("G", "H"); Edge <string> h_g = new Edge <string>("H", "G"); Edge <string> h_i = new Edge <string>("H", "I"); Edge <string> i_f = new Edge <string>("I", "F"); Edge <string> i_j = new Edge <string>("I", "J"); Edge <string> i_h = new Edge <string>("I", "H"); Edge <string> j_f = new Edge <string>("J", "F"); // Add the edges graph.AddEdge(a_b); graph.AddEdge(a_d); graph.AddEdge(b_a); graph.AddEdge(b_c); graph.AddEdge(b_e); graph.AddEdge(c_b); graph.AddEdge(c_f); graph.AddEdge(c_j); graph.AddEdge(d_e); graph.AddEdge(d_g); graph.AddEdge(e_d); graph.AddEdge(e_f); graph.AddEdge(e_h); graph.AddEdge(f_i); graph.AddEdge(f_j); graph.AddEdge(g_d); graph.AddEdge(g_h); graph.AddEdge(h_g); graph.AddEdge(h_i); graph.AddEdge(i_f); graph.AddEdge(i_h); graph.AddEdge(i_j); graph.AddEdge(j_f); // Define some weights to the edges Dictionary <Edge <string>, double> edgeCost = new Dictionary <Edge <string>, double>(graph.EdgeCount); edgeCost.Add(a_b, 4); edgeCost.Add(a_d, 1); edgeCost.Add(b_a, 74); edgeCost.Add(b_c, 2); edgeCost.Add(b_e, 12); edgeCost.Add(c_b, 12); edgeCost.Add(c_f, 74); edgeCost.Add(c_j, 12); edgeCost.Add(d_e, 32); edgeCost.Add(d_g, 22); edgeCost.Add(e_d, 66); edgeCost.Add(e_f, 76); edgeCost.Add(e_h, 33); edgeCost.Add(f_i, 11); edgeCost.Add(f_j, 21); edgeCost.Add(g_d, 12); edgeCost.Add(g_h, 10); edgeCost.Add(h_g, 2); edgeCost.Add(h_i, 72); edgeCost.Add(i_f, 31); edgeCost.Add(i_h, 18); edgeCost.Add(i_j, 7); edgeCost.Add(j_f, 8); // We want to use Dijkstra on this graph var dijkstra = new DijkstraShortestPathAlgorithm <string, Edge <string> >(graph, e => edgeCost[e]); // Attach a Vertex Predecessor Recorder Observer to give us the paths var predecessorObserver = new VertexPredecessorRecorderObserver <string, Edge <string> >(); using (predecessorObserver.Attach(dijkstra)) { // Run the algorithm with A set to be the source dijkstra.Compute("A"); } foreach (KeyValuePair <string, Edge <string> > kvp in predecessorObserver.VertexPredecessors) { TestConsole.WriteLine("If you want to get to {0} you have to enter through the in edge {1}", kvp.Key, kvp.Value); } foreach (string v in graph.Vertices) { double distance = AlgorithmExtensions.ComputePredecessorCost( predecessorObserver.VertexPredecessors, edgeCost, v); TestConsole.WriteLine("A -> {0}: {1}", v, distance); } }
public void BuildGraphFromMinimalGraphShapefile() { string path = "minimalgraph.shp"; int count = 15; Assert.IsTrue(File.Exists(path)); ShapefileReader reader = new ShapefileReader(path); IGeometryCollection edges = reader.ReadAll(); Assert.IsNotNull(edges); Assert.IsInstanceOfType(typeof(GeometryCollection), edges); Assert.AreEqual(count, edges.NumGeometries); ILineString startls = null; // Build graph Dictionary <IEdge <IGeometry>, double> consts = new Dictionary <IEdge <IGeometry>, double>(edges.NumGeometries); AdjacencyGraph <IGeometry, IEdge <IGeometry> > graph = new AdjacencyGraph <IGeometry, IEdge <IGeometry> >(true); foreach (IMultiLineString mlstr in edges.Geometries) { Assert.AreEqual(1, mlstr.NumGeometries); ILineString str = (ILineString)mlstr.GetGeometryN(0); if (startls == null) { startls = str; } // Add vertex 1 IGeometry vertex1 = str.StartPoint; Assert.IsNotNull(vertex1); if (!graph.ContainsVertex(vertex1)) { Debug.WriteLine(String.Format("Adding vertex {0} to the list", vertex1)); graph.AddVertex(vertex1); } else { Debug.WriteLine(String.Format("Vertex {0} already present", vertex1)); } // Add vertex 2 IGeometry vertex2 = str.EndPoint; Assert.IsNotNull(vertex2); if (!graph.ContainsVertex(vertex2)) { Debug.WriteLine(String.Format("Adding vertex {0} to the list", vertex2)); graph.AddVertex(vertex2); } else { Debug.WriteLine(String.Format("Vertex {0} already present", vertex2)); } // Compute weight double weight = weightComputer(str); Assert.Greater(weight, 0.0); // Add edge 1 => 2 IEdge <IGeometry> edge1 = new Edge <IGeometry>(vertex1, vertex2); Assert.IsNotNull(edge1); graph.AddEdge(edge1); consts.Add(edge1, weight); // Add edge 2 => 1 IEdge <IGeometry> edge2 = new Edge <IGeometry>(vertex2, vertex1); Assert.IsNotNull(edge2); graph.AddEdge(edge2); consts.Add(edge2, weight); } // Perform DijkstraShortestPathAlgorithm DijkstraShortestPathAlgorithm <IGeometry, IEdge <IGeometry> > dijkstra = new DijkstraShortestPathAlgorithm <IGeometry, IEdge <IGeometry> >(graph, consts); // attach a distance observer to give us the shortest path distances VertexDistanceRecorderObserver <IGeometry, IEdge <IGeometry> > distObserver = new VertexDistanceRecorderObserver <IGeometry, IEdge <IGeometry> >(); distObserver.Attach(dijkstra); // Attach a Vertex Predecessor Recorder Observer to give us the paths VertexPredecessorRecorderObserver <IGeometry, IEdge <IGeometry> > predecessorObserver = new VertexPredecessorRecorderObserver <IGeometry, IEdge <IGeometry> >(); predecessorObserver.Attach(dijkstra); // Run the algorithm Assert.IsNotNull(startls); IGeometry startPoint = startls.StartPoint; Debug.WriteLine(String.Format("Starting algorithm from root vertex {0}", startPoint)); dijkstra.Compute(startPoint); foreach (KeyValuePair <IGeometry, int> kvp in distObserver.Distances) { Debug.WriteLine(String.Format("Distance from root to node {0} is {1}", kvp.Key, kvp.Value)); } foreach (KeyValuePair <IGeometry, IEdge <IGeometry> > kvp in predecessorObserver.VertexPredecessors) { Debug.WriteLine(String.Format( "If you want to get to {0} you have to enter through the IN edge {1}", kvp.Key, kvp.Value)); } Check(graph, consts, predecessorObserver); // Detach the observers distObserver.Detach(dijkstra); predecessorObserver.Detach(dijkstra); }
public void ToGraphvizWithInit() { var wrappedGraph = new AdjacencyGraph <int, Edge <int> >(); wrappedGraph.AddVerticesAndEdgeRange(new[] { new Edge <int>(1, 2), new Edge <int>(1, 3), new Edge <int>(2, 4) }); wrappedGraph.AddVertex(5); var clusteredGraph = new ClusteredAdjacencyGraph <int, Edge <int> >(wrappedGraph); ClusteredAdjacencyGraph <int, Edge <int> > subGraph1 = clusteredGraph.AddCluster(); subGraph1.AddVerticesAndEdgeRange(new[] { new Edge <int>(6, 7), new Edge <int>(7, 8) }); ClusteredAdjacencyGraph <int, Edge <int> > subGraph2 = clusteredGraph.AddCluster(); subGraph2.AddVerticesAndEdge(new Edge <int>(9, 10)); subGraph2.AddVertex(11); string expectedDot = "digraph G {" + Environment.NewLine + "node [shape=diamond];" + Environment.NewLine + "edge [tooltip=\"Test Edge\"];" + Environment.NewLine + "subgraph cluster1 {" + Environment.NewLine + "5 [label=\"Test Vertex 6\"];" + Environment.NewLine + "6 [label=\"Test Vertex 7\"];" + Environment.NewLine + "7 [label=\"Test Vertex 8\"];" + Environment.NewLine + "5 -> 6;" + Environment.NewLine + "6 -> 7;" + Environment.NewLine + "}" + Environment.NewLine + "subgraph cluster2 {" + Environment.NewLine + "8 [label=\"Test Vertex 9\"];" + Environment.NewLine + "9 [label=\"Test Vertex 10\"];" + Environment.NewLine + "10 [label=\"Test Vertex 11\"];" + Environment.NewLine + "8 -> 9;" + Environment.NewLine + "}" + Environment.NewLine + "0 [label=\"Test Vertex 1\"];" + Environment.NewLine + "1 [label=\"Test Vertex 2\"];" + Environment.NewLine + "2 [label=\"Test Vertex 3\"];" + Environment.NewLine + "3 [label=\"Test Vertex 4\"];" + Environment.NewLine + "4 [label=\"Test Vertex 5\"];" + Environment.NewLine + "0 -> 1;" + Environment.NewLine + "0 -> 2;" + Environment.NewLine + "1 -> 3;" + Environment.NewLine + "}"; string dotGraph = clusteredGraph.ToGraphviz(algorithm => { algorithm.CommonVertexFormat.Shape = GraphvizVertexShape.Diamond; algorithm.CommonEdgeFormat.ToolTip = "Test Edge"; algorithm.FormatVertex += (sender, args) => { args.VertexFormat.Label = $"Test Vertex {args.Vertex}"; }; }); Assert.AreEqual(expectedDot, dotGraph); }
public void AnalyzeDependencies(AdjacencyGraph<string, IEdge<string>> graph) { graph.AddVertex(RefId); P.AnalyzeDependencies(graph, RefId, Info.DataType); }
public void BellmanFord_NegativeCycle() { // Without negative cycle var edge12 = new Edge <int>(1, 2); var edge23 = new Edge <int>(2, 3); var edge34 = new Edge <int>(3, 4); var negativeWeightGraph = new AdjacencyGraph <int, Edge <int> >(); negativeWeightGraph.AddVerticesAndEdgeRange(new[] { edge12, edge23, edge34 }); var algorithm = new BellmanFordShortestPathAlgorithm <int, Edge <int> >( negativeWeightGraph, e => { if (e == edge12) { return(12.0); } if (e == edge23) { return(-23.0); } if (e == edge34) { return(-34.0); } return(1.0); }); Assert.DoesNotThrow(() => algorithm.Compute(1)); Assert.IsFalse(algorithm.FoundNegativeCycle); // With negative cycle var edge41 = new Edge <int>(4, 1); var negativeCycleGraph = new AdjacencyGraph <int, Edge <int> >(); negativeCycleGraph.AddVerticesAndEdgeRange(new[] { edge12, edge23, edge34, edge41 }); algorithm = new BellmanFordShortestPathAlgorithm <int, Edge <int> >( negativeCycleGraph, e => { if (e == edge12) { return(12.0); } if (e == edge23) { return(-23.0); } if (e == edge34) { return(-34.0); } if (e == edge41) { return(41.0); } return(1.0); }); Assert.DoesNotThrow(() => algorithm.Compute(1)); Assert.IsTrue(algorithm.FoundNegativeCycle); }
public void AnalyzeDependencies(AdjacencyGraph <string, IEdge <string> > graph) { P.AnalyzeDependencies(graph, Info); }
public void SerializeToGraphML_Throws() { // ReSharper disable AssignNullToNotNullAttribute // Filepath Assert.Throws <ArgumentNullException>( () => ((AdjacencyGraph <TestVertex, TestEdge>)null).SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >(WriteThrowsTestFilePath)); var graph = new AdjacencyGraph <TestVertex, TestEdge>(); Assert.Throws <ArgumentException>( () => graph.SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >((string)null)); Assert.Throws <ArgumentException>( () => graph.SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >("")); Assert.Throws <ArgumentNullException>( () => ((AdjacencyGraph <TestVertex, TestEdge>)null).SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >( WriteThrowsTestFilePath, vertex => vertex.ID, edge => edge.ID)); Assert.Throws <ArgumentException>( () => graph.SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >( (string)null, vertex => vertex.ID, edge => edge.ID)); Assert.Throws <ArgumentException>( () => graph.SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >( "", vertex => vertex.ID, edge => edge.ID)); Assert.Throws <ArgumentNullException>( () => graph.SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >( WriteThrowsTestFilePath, null, edge => edge.ID)); Assert.Throws <ArgumentNullException>( () => ((AdjacencyGraph <TestVertex, TestEdge>)null).SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >( WriteThrowsTestFilePath, vertex => vertex.ID, null)); // XML writer Assert.Throws <ArgumentNullException>( () => graph.SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >((XmlWriter)null)); Assert.Throws <ArgumentNullException>( () => graph.SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >( (XmlWriter)null, vertex => vertex.ID, edge => edge.ID)); using (XmlWriter writer = XmlWriter.Create(WriteThrowsTestFilePath)) { Assert.Throws <ArgumentNullException>( () => ((AdjacencyGraph <TestVertex, TestEdge>)null).SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >(writer)); Assert.Throws <ArgumentNullException>( () => ((AdjacencyGraph <TestVertex, TestEdge>)null).SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >( writer, vertex => vertex.ID, edge => edge.ID)); Assert.Throws <ArgumentNullException>( () => graph.SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >( writer, null, edge => edge.ID)); Assert.Throws <ArgumentNullException>( () => graph.SerializeToGraphML <TestVertex, TestEdge, AdjacencyGraph <TestVertex, TestEdge> >( writer, vertex => vertex.ID, null)); } // ReSharper restore AssignNullToNotNullAttribute }