public DirectedGraphNode Add(CpuZ80.CpuZ80 cpu) { if (!Visit(cpu)) { return(FindNode(cpu)); } DirectedGraphNode node = AddNode <CpuZ80.CpuZ80>(cpu.Name); SetNodeMap(cpu, node); if (!DisplayComponents) { node = null; } LinkContains(node, Add(cpu.Address, cpu.Name)); LinkContains(node, Add(cpu.Data, cpu.Name)); LinkContains(node, Add(cpu.BusAcknowledge, cpu.Name)); LinkContains(node, Add(cpu.BusRequest, cpu.Name)); LinkContains(node, Add(cpu.Clock, cpu.Name)); LinkContains(node, Add(cpu.Halt, cpu.Name)); LinkContains(node, Add(cpu.Interrupt, cpu.Name)); LinkContains(node, Add(cpu.IoRequest, cpu.Name)); LinkContains(node, Add(cpu.MachineCycle1, cpu.Name)); LinkContains(node, Add(cpu.MemoryRequest, cpu.Name)); LinkContains(node, Add(cpu.NonMaskableInterrupt, cpu.Name)); LinkContains(node, Add(cpu.Read, cpu.Name)); LinkContains(node, Add(cpu.Refresh, cpu.Name)); LinkContains(node, Add(cpu.Reset, cpu.Name)); LinkContains(node, Add(cpu.Wait, cpu.Name)); LinkContains(node, Add(cpu.Write, cpu.Name)); return(node); }
private void OnFormatNode([NotNull] TVertex vertex, [NotNull] DirectedGraphNode node) { Debug.Assert(vertex != null); Debug.Assert(node != null); FormatNode?.Invoke(vertex, node); }
private bool IsCyclicUtil(DirectedGraphNode node, Dictionary <DirectedGraphNode, bool> visited, Dictionary <DirectedGraphNode, bool> recStack)// i, bool[] visited, bool[] recStack) { // Mark the current node as visited and // part of recursion stack if (recStack[node]) { return(true); } if (visited[node]) { return(false); } visited[node] = true; recStack[node] = true; foreach (var sucessor in node.Successors) { if (IsCyclicUtil(sucessor, visited, recStack)) { return(true); } } recStack[node] = false; return(false); }
public void SetUp() { root = new DirectedGraphNode <int>(21); var n1 = new DirectedGraphNode <int>(14); var n2 = new DirectedGraphNode <int>(18); var n3 = new DirectedGraphNode <int>(39); var n4 = new DirectedGraphNode <int>(51); var n5 = new DirectedGraphNode <int>(63); var n6 = new DirectedGraphNode <int>(16); var n7 = new DirectedGraphNode <int>(27); var n8 = new DirectedGraphNode <int>(84); var n9 = new DirectedGraphNode <int>(30); var n10 = new DirectedGraphNode <int>(33); var n11 = new DirectedGraphNode <int>(36); var n12 = new DirectedGraphNode <int>(11); root.AddNeighbor(n1); root.AddNeighbor(n2); root.AddNeighbor(n3); n1.AddNeighbor(n4); n2.AddNeighbor(n1); n2.AddNeighbor(n5); n3.AddNeighbor(n6); n3.AddNeighbor(n7); n5.AddNeighbor(n8); n6.AddNeighbor(n8); n6.AddNeighbor(n12); n7.AddNeighbor(n9); n9.AddNeighbor(n10); n10.AddNeighbor(n11); }
public void AddNode(DirectedGraphNode <NodeData> n) { if (!nodes.Contains(n)) { nodes.Add(n); } }
private bool IsCyclic(DirectedGraphNode node, out DirectedGraphNode cyclicNode) { if (!node.Visited) { node.Visited = true; node.Recursion = true; foreach (var it in node.Dependents) { if (!it.Visited && IsCyclic(it, out cyclicNode)) { node.Recursion = false; return(true); } else if (it.Recursion) { cyclicNode = node; node.Recursion = false; return(true); } } } cyclicNode = default; node.Recursion = false; return(false); }
public DirectedGraphNode Add <AddressT, DataT>(MemoryRam <AddressT, DataT> ram) where AddressT : BusData, new() where DataT : BusData, new() { if (!Visit(ram)) { return(FindNode(ram)); } DirectedGraphNode node = AddNode <MemoryRam <AddressT, DataT> >(ram.Name); SetNodeMap(ram, node); if (!DisplayComponents) { node = null; } LinkContains(node, Add(ram.Address, ram.Name)); LinkContains(node, Add(ram.Data, ram.Name)); LinkContains(node, Add(ram.ChipEnable, ram.Name)); LinkContains(node, Add(ram.OutputEnable, ram.Name)); LinkContains(node, Add(ram.WriteEnable, ram.Name)); return(node); }
private void ConfigurePackageNode(DirectedGraphNode node, PackageIdentity package) { if (package.Version.IsPrerelease) { node.Background = _palette.PrereleaseColor; } }
private int CompareNodes(DirectedGraphNode left, DirectedGraphNode right) { var leftDistance = _distances[left.Name]; var rightDistance = _distances[right.Name]; return(leftDistance.CompareTo(rightDistance)); }
private void GetShortestGraph(DirectedGraphNode sourceNode, DirectedGraphNode targetNode, DirectedGraph graph) { if (sourceNode.Name == targetNode.Name) { return; } var predecessorNodes = this.GetShortestPathPredecessors(targetNode); foreach (var predecessor in predecessorNodes) { var node = new DistanceNode(predecessor.Name) { Tag = predecessor.Tag, }; if (!graph.TryAddNode(node)) { node = (DistanceNode)graph.GetNode(node.Name); } var distance = _distances[predecessor.Name]; node.Distance = distance; _graph.TryGetEdge(predecessor, targetNode, out var edge); if (graph.TryAddEdge(predecessor.Name, targetNode.Name, edge.Weight, false, out _)) { GetShortestGraph(sourceNode, predecessor, graph); } } }
/// <summary> /// Given 2 DirectedGraphNodes, uses BFS algorithm to determine if a route exists from source node to destination node /// O(n) time, O(n) space /// </summary> /// <param name="source">DirectedGraphNode</param> /// <param name="dest">DirectedGraphNode</param> /// <returns>bool</returns> public static bool RouteExists(DirectedGraphNode source, DirectedGraphNode dest) { if (source == null || dest == null) { return(false); } if (source == dest) { return(true); } Queue <DirectedGraphNode> nodeQueue = new Queue <DirectedGraphNode>(); HashSet <DirectedGraphNode> visitedNodes = new HashSet <DirectedGraphNode>(); nodeQueue.Enqueue(source); while (nodeQueue.Count > 0) { DirectedGraphNode currNode = nodeQueue.Dequeue(); if (currNode == dest) { return(true); } visitedNodes.Add(currNode); foreach (DirectedGraphNode node in currNode.Children) { if (!visitedNodes.Contains(node)) { nodeQueue.Enqueue(node); } } } return(false); }
private DirectedGraphNode FindNode <T>(T component) { DirectedGraphNode node = null; _visited.TryGetValue(component, out node); return(node); }
public void DirectedGraphNode_Equals_NoNeighbors_Equal() { var n1 = new DirectedGraphNode <int>(10); var n2 = new DirectedGraphNode <int>(10); Assert.IsTrue(n1.Equals(n2)); }
private void ConfigureDependencyNode(DirectedGraphNode node, PackageUpgrade upgrade) { if (upgrade.Package == null) { node.Stroke = _palette.MissingPackageColor; node.StrokeThickness = "2"; } }
public void AddNode(DirectedGraphNode node) { var nodes = new List <DirectedGraphNode>(DirectedGraph.Nodes); nodes.Add(node); DirectedGraph.Nodes = nodes.ToArray(); }
public override DirectedGraph GetShortestGraph(DirectedGraphNode sourceNode, DirectedGraphNode targetNode) { InitializeSearch(sourceNode); CalculateDistancesByBreadthFirst(); return(BuildShortestPathGraph(sourceNode, targetNode)); }
/// <summary> /// Determines the distances of all nodes starting from the 'sourceNode'. /// </summary> public override IDictionary <string, double> GetAllDistances(DirectedGraphNode sourceNode) { InitializeSearch(sourceNode); CalculateDistancesByBreadthFirst(); return(_distances); }
public DirectedGraphLink AddLink(DirectedGraphNode source, DirectedGraphNode target) { if (source == null || target == null) { return(null); } return(AddLink(source.Id, target.Id)); }
private void SetNodeMap(object component, DirectedGraphNode node) { if (!_visited.ContainsKey(component)) { throw new ArgumentException("Component was not visited.", nameof(component)); } _visited[component] = node; }
private void AddNode(DirectedGraphNode node) { var nodes = _directedGraph.Nodes; var nodeIndex = nodes.Length; Array.Resize(ref nodes, nodeIndex + 1); nodes[nodeIndex] = node; _directedGraph.Nodes = nodes; }
public DirectedGraphEdge <EdgeData> GetEdge(DirectedGraphNode <NodeData> from, DirectedGraphNode <NodeData> to) { if (edges.ContainsKey(from) && edges[from].ContainsKey(to)) { return(edges[from][to]); } throw new ArgumentException("Edge does not exist"); }
private double GetStartDistanceToMe(DirectedGraphNode predecessor, DirectedGraphNode successor) { var predecessorDistanceFromStart = _distances[predecessor.Name]; var predecessorDistanceToMe = _graph.GetEdge(predecessor, successor).Weight; var startDistanceToMe = predecessorDistanceFromStart + predecessorDistanceToMe; return(startDistanceToMe); }
private void OnFormatNode(TVertex vertex, DirectedGraphNode node) { Contract.Requires(node != null); var eh = this.FormatNode; if (eh != null) { eh(vertex, node); } }
public DirectedGraphNode AddNode(string id) { var node = new DirectedGraphNode() { Id = id }; AddNode(node); return(node); }
private DirectedGraphLink CreateLink(DirectedGraphNode source, DirectedGraphNode target) { var link = new DirectedGraphLink { Source = source.Id, Target = target.Id, }; AddLink(link); return(link); }
public List <DirectedGraphNode> TopSort(List <DirectedGraphNode> graph) { List <DirectedGraphNode> list = new List <DirectedGraphNode>(); if (graph == null) { return(list); } Dictionary <DirectedGraphNode, int> ingreeDic = new Dictionary <DirectedGraphNode, int>(); foreach (var n in graph) { ingreeDic.Add(n, 0); } Queue <DirectedGraphNode> queue = new Queue <DirectedGraphNode>(); foreach (var n in graph) { foreach (var nb in n.neighbors) { if (ingreeDic.ContainsKey(nb)) { int v = ingreeDic[nb]; ingreeDic[nb] = v + 1; } } } //要考虑 多个入度为0的节点 foreach (var n in ingreeDic) { if (n.Value == 0) { list.Add(n.Key); queue.Enqueue(n.Key); } } while (queue.Count != 0) { DirectedGraphNode node = queue.Dequeue(); foreach (var n in node.neighbors) { int val = ingreeDic[n]; val = val - 1; ingreeDic[n] = val; if (val == 0) { list.Add(n); queue.Enqueue(n); } } } return(list); }
protected void InitializeSearch(DirectedGraphNode sourceNode) { _distances = new Dictionary <string, double>(); foreach (DirectedGraphNode node in this._graph.Nodes) { _distances.Add(node.Name, double.PositiveInfinity); } _distances.Remove(sourceNode.Name); _distances.Add(sourceNode.Name, 0); }
public void AddNode(T node) { if (!_nodeLookup.TryGetValue(node, out var graphNode)) { graphNode = new DirectedGraphNode() { Node = node }; _nodeLookup.Add(node, graphNode); _nodes.Add(graphNode); } }
private DirectedGraphLink LinkContains(DirectedGraphNode container, DirectedGraphNode containee) { var link = _dgmlBuilder.AddLink(container, containee); if (link != null) { link.Label = "Contains"; link.Category1 = "Contains"; } return(link); }
public List <string> GetAllPaths(DirectedGraphNode startNode) { if (!_graph.IsDirected() || !_graph.IsAcyclic()) { throw new InvalidOperationException("To determine the pathset the graph has to be directed and asyclic."); } var paths = new List <string>(); BuildPath(startNode, startNode.Name, paths); return(paths); }