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