public List <ShortestResponse> GetAllPaths(SearchReq request)
{
MethodBase currentMethod = MethodBase.GetCurrentMethod();
try
{
DepthFirstTraversal graph = new DepthFirstTraversal(9);
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(1, 2);
graph.addEdge(1, 4);
graph.addEdge(2, 1);
graph.addEdge(2, 6);
graph.addEdge(3, 8);
graph.addEdge(4, 0);
graph.addEdge(4, 2);
graph.addEdge(5, 0);
graph.addEdge(5, 6);
graph.addEdge(6, 5);
graph.addEdge(6, 7);
graph.addEdge(7, 8);
graph.addEdge(8, 2);
graph.addEdge(8, 3);
var source = graph.datacode.FirstOrDefault(x => x.Key == request.source).Value;
var destination = graph.datacode.FirstOrDefault(x => x.Key == request.destination).Value;
graph.printAllPaths(source, destination);
return(graph.ShortestResponses);
}
catch (Exception ex)
{
AirlineLogManager.Error(null, CurrentClass, currentMethod, ex);
}
return(null);
}
public void PostOrderTest()
{
var graph = new Graph();
graph.Nodes.Add("0");
graph.Nodes.Add("1");
graph.Nodes.Add("2");
graph.Nodes.Add("3");
graph.Nodes.Add("4");
graph.Edges.Add("0", "2");
graph.Edges.Add("2", "1");
graph.Edges.Add("1", "0");
graph.Edges.Add("0", "3");
graph.Edges.Add("3", "4");
var traversal = new DepthFirstTraversal();
var recorder = new PostOrderRecorder(traversal);
traversal.Run(graph.Nodes["0"]);
var order = recorder.GetOrder();
Assert.Equal(order.Count, graph.Nodes.Count);
Assert.All(graph.Nodes, n => Assert.True(order.IndexOf(graph.Nodes["0"]) >= order.IndexOf(n)));
Assert.True(order.IndexOf(graph.Nodes["1"]) < order.IndexOf(graph.Nodes["2"]));
Assert.True(order.IndexOf(graph.Nodes["4"]) < order.IndexOf(graph.Nodes["3"]));
}
/// <summary>
/// Replace one node with another.
/// </summary>
/// <param name="rootNode">The root node.</param>
/// <param name="replaceThisNode">The node to replace.</param>
/// <param name="replaceWith">What to replace with.</param>
public static void Process(ITreeNode rootNode, ITreeNode replaceThisNode, ITreeNode replaceWith)
{
bool done = false;
DepthFirstTraversal trav = new DepthFirstTraversal();
trav.Traverse(rootNode, (n) =>
{
if (done)
{
return false;
}
for (int i = 0; i < n.ChildNodes.Count; i++)
{
ITreeNode childNode = n.ChildNodes[i];
if (childNode == replaceThisNode)
{
n.ChildNodes[i] = replaceWith;
done = true;
return false;
}
}
return true;
});
}
/// <summary>
/// Replace one node with another.
/// </summary>
/// <param name="rootNode">The root node.</param>
/// <param name="replaceThisNode">The node to replace.</param>
/// <param name="replaceWith">What to replace with.</param>
public static void Process(ITreeNode rootNode, ITreeNode replaceThisNode, ITreeNode replaceWith)
{
bool done = false;
DepthFirstTraversal trav = new DepthFirstTraversal();
trav.Traverse(rootNode, (n) =>
{
if (done)
{
return(false);
}
for (int i = 0; i < n.ChildNodes.Count; i++)
{
ITreeNode childNode = n.ChildNodes[i];
if (childNode == replaceThisNode)
{
n.ChildNodes[i] = replaceWith;
done = true;
return(false);
}
}
return(true);
});
}
public void TestDFSUnDirectedGraph()
{
IGraph graph = new Graph();
graph.AddNode(new Node("s"));
graph.AddNode(new Node("a"));
graph.AddNode(new Node("b"));
graph.AddNode(new Node("c"));
graph.AddNode(new Node("d"));
graph.AddNode(new Node("e"));
graph.BuildEdge("s", "a", 0);
graph.BuildEdge("s", "b", 0);
graph.BuildEdge("a", "c", 0);
graph.BuildEdge("a", "b", 0);
graph.BuildEdge("b", "d", 0);
graph.BuildEdge("c", "e", 0);
graph.BuildEdge("c", "d", 0);
graph.BuildEdge("d", "e", 0);
DepthFirstTraversal dfs = new DepthFirstTraversal(graph, graph.GetNodeByID("s"));
TraversalResult tr = dfs.Run();
Assert.Equal("s,a,c,e,d,b", string.Join(",", tr.Nodes.Select(node => node.ID)));
}
/// <summary>
/// Checks whether there is a definition from the beginning to the use node
/// </summary>
/// <param name="fdef"></param>
/// <param name="otherDefinedOffsets"></param>
/// <returns></returns>
private bool HasDefinitionFromRootToUseNode(DUCoverStore dcs, FieldDefUseStore fuse, HashSet <int> otherDefinedOffsets)
{
DEFUSE_FEASIBILITY_TYPE feasibilityVal;
if (this.feasibilityDicCache.TryGetValue(fuse, out feasibilityVal))
{
if (feasibilityVal == DEFUSE_FEASIBILITY_TYPE.USE_FEASIBLE)
{
return(false);
}
else
{
return(true);
}
}
InstructionGraph ig = dcs.GetInstructionGraph(fuse.Method);
DepthFirstTraversal dft = new DepthFirstTraversal(ig);
InstructionVertex iv = ig.GetVertex(fuse.Offset);
var result = dft.HasDefClearPathFromBeginning(iv, otherDefinedOffsets);
if (result)
{
this.feasibilityDicCache[fuse] = DEFUSE_FEASIBILITY_TYPE.USE_FEASIBLE;
}
else
{
this.feasibilityDicCache[fuse] = DEFUSE_FEASIBILITY_TYPE.USE_INFEASIBLE;
}
return(!result);
}
public void TestDFSDirectedGraph()
{
INode node1 = new Node("1");
INode node2 = new Node("2");
INode node3 = new Node("3");
INode node4 = new Node("4");
INode node5 = new Node("5");
IGraph graph = new Graph(true);
graph.AddNode(node1);
graph.AddNode(node2);
graph.AddNode(node3);
graph.AddNode(node4);
graph.AddNode(node5);
graph.BuildEdge(node1, node2, 0);
graph.BuildEdge(node1, node3, 0);
graph.BuildEdge(node2, node4, 0);
graph.BuildEdge(node2, node5, 0);
DepthFirstTraversal dfs = new DepthFirstTraversal(graph, node1);
TraversalResult traversalResult = dfs.Run();
string result = string.Join(",", traversalResult.Nodes.Select(node => node.ID));
Assert.Equal("1,2,4,5,3", result);
}
public void If()
{
// Artificially construct an if construct.
var graph = TestGraphs.CreateIfElse();
var n1 = graph.GetNodeById(1);
var n2 = graph.GetNodeById(2);
var n3 = graph.GetNodeById(3);
var n4 = graph.GetNodeById(4);
// Record a depth first traversal.
var traversal = new DepthFirstTraversal();
var recorder = new TraversalOrderRecorder(traversal);
traversal.Run(n1);
// Check if n1 is before any node in the traversal.
Assert.All(graph.GetNodes(),
n => Assert.True(n1 == n || recorder.GetIndex(n1) < recorder.GetIndex(n)));
// DFS should either pick n2 or n3. If n2, then n4 is before n3, otherwise before n2.
if (recorder.GetIndex(n2) < recorder.GetIndex(n3))
{
Assert.True(recorder.GetIndex(n4) < recorder.GetIndex(n3));
}
else
{
Assert.True(recorder.GetIndex(n4) < recorder.GetIndex(n2));
}
}
public void DepthFirstDepthShouldBeTwoWhenEndNodeIsFoundTest()
{
// Arrange
var start = Tree.Nodes["1"];
var stop = Tree.Nodes["5"];
var traversal = new DepthFirstTraversal();
Node result = null;
int depth = 0;
traversal.NodeDiscovered += (sender, args) =>
{
if (args.NewNode == stop)
{
args.ContinueExploring = false;
args.Abort = true;
result = args.NewNode;
depth = args.Depth;
}
};
// Act
traversal.Run(start);
// Assert
Assert.Equal(stop, result);
Assert.Equal(2, depth);
}
/// <summary>
/// Count the nodes from this tree node.
/// </summary>
/// <param name="node">The tree node.</param>
/// <returns>The node count.</returns>
public static int Process(ITreeNode node)
{
int result = 0;
DepthFirstTraversal trav = new DepthFirstTraversal();
trav.Traverse( node, (n) =>
{
result++;
return true;
});
return result;
}
public void SingleNode()
{
var graph = TestGraphs.CreateSingularGraph();
var startNode = graph.GetNodeById(1);
// Record a depth first traversal.
var traversal = new DepthFirstTraversal();
var recorder = new TraversalOrderRecorder(traversal);
traversal.Run(startNode);
Assert.Single(recorder.GetTraversal());
Assert.Equal(0, recorder.GetIndex(startNode));
}
/// <summary>
/// Count the nodes from this tree node.
/// </summary>
/// <param name="node">The tree node.</param>
/// <returns>The node count.</returns>
public static int Process(ITreeNode node)
{
int result = 0;
DepthFirstTraversal trav = new DepthFirstTraversal();
trav.Traverse(node, (n) =>
{
result++;
return(true);
});
return(result);
}
public void CollectionOfAllNodes()
{
var vertices = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var edges = new[] { Tuple.Create(1, 2), Tuple.Create(1, 3),
Tuple.Create(2, 4), Tuple.Create(3, 5), Tuple.Create(3, 6),
Tuple.Create(4, 7), Tuple.Create(5, 7), Tuple.Create(5, 8),
Tuple.Create(5, 6), Tuple.Create(8, 9), Tuple.Create(9, 10) };
Graph <int> graph = new Graph <int>(vertices, edges);
var algorithms = new DepthFirstTraversal();
var dft = algorithms.DFS(graph, 1);
Assert.Equal(dft.Count, graph.AdjacencyList.Count);
}
public void DepthFirstOrderTest()
{
var traversal = new DepthFirstTraversal();
var recorder = new TraversalOrderRecorder(traversal);
traversal.Run(Tree.Nodes["1"]);
if (recorder.GetIndex(Tree.Nodes["2"]) < recorder.GetIndex(Tree.Nodes["3A"]))
{
Assert.True(recorder.GetIndex(Tree.Nodes["4A"]) < recorder.GetIndex(Tree.Nodes["3A"]));
}
else
{
Assert.True(recorder.GetIndex(Tree.Nodes["5"]) < recorder.GetIndex(Tree.Nodes["4A"]));
}
}
private static void Main()
{
IGraph <char> graph = new Graph <char>();
var a = graph.AddVertex('A');
var b = graph.AddVertex('B');
var c = graph.AddVertex('C');
var d = graph.AddVertex('D');
var e = graph.AddVertex('E');
graph.AddEdge(a, b, 6);
graph.AddEdge(b, a, 6);
graph.AddEdge(a, d, 1);
graph.AddEdge(d, a, 1);
graph.AddEdge(d, e, 1);
graph.AddEdge(e, d, 1);
graph.AddEdge(d, b, 2);
graph.AddEdge(b, d, 2);
graph.AddEdge(e, b, 2);
graph.AddEdge(b, e, 2);
graph.AddEdge(e, c, 5);
graph.AddEdge(c, e, 5);
graph.AddEdge(c, b, 5);
graph.AddEdge(b, c, 5);
Console.WriteLine("Depth-First recursive traversal: ");
DepthFirstTraversal <char> .DepthFirstSearchIterative(graph, a);
graph.Reset();
Console.WriteLine("Depth-First iterative path between two vertices: ");
var depthFirstIterative = DepthFirstTraversal <char>
.DepthFirstIterative(graph, a, e);
foreach (var vertex in depthFirstIterative)
{
Console.WriteLine(vertex);
}
}
public void DepthFirstDepthShouldBeZeroOnFirstNodeTest()
{
// Arrange
var start = new Node("7");
Tree.Nodes.Add(start);
var traversal = new DepthFirstTraversal();
traversal.NodeDiscovered += (sender, args) =>
{
Assert.Equal(0, args.Depth);
};
// Act
traversal.Run(start);
// Assert done in NodeDiscoverd event handler.
}
public void PathReversed()
{
// Artificially construct a path of four nodes in sequential order.
var graph = TestGraphs.CreatePath();
// Record a depth first traversal.
var traversal = new DepthFirstTraversal(true);
var recorder = new TraversalOrderRecorder(traversal);
traversal.Run(graph.GetNodeById(4));
// Traversal should exactly be the path.
Assert.Equal(new INode[]
{
graph.GetNodeById(4),
graph.GetNodeById(3),
graph.GetNodeById(2),
graph.GetNodeById(1),
}, recorder.GetTraversal());
}
/// <summary>
/// Checks whether a definition and use are in different methods
/// </summary>
/// <param name="dcse"></param>
/// <returns></returns>
private bool IsFeasibleDUCoverEntry(DUCoverStore dcs, FieldDefUseStore fdef, FieldDefUseStore fuse)
{
//if (fdef.Method.FullName.Contains("AddVertex") && fuse.Method.FullName.Contains("AddVertex") && fdef.Field.FullName.Contains("m_VertexOutEdges")
// && fdef.Offset == 13 && fuse.Offset == 2)
//{
// int i = 0;
//}
//check whether the def and use are in the same method
if (fdef.Method.Equals(fuse.Method))
{
var otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fdef.Method, fdef);
InstructionGraph ig = dcs.GetInstructionGraph(fdef.Method);
DepthFirstTraversal dft = new DepthFirstTraversal(ig);
var source = ig.GetVertex(fdef.Offset);
var target = ig.GetVertex(fuse.Offset);
return(dft.HasDefClearPathBetweenNodes(source, target, otherFDefOffsets));
}
else
{
var otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fdef.Method, fdef);
if (otherFDefOffsets.Count > 0)
{
if (this.HasRedefinition(dcs, fdef, otherFDefOffsets))
{
return(false);
}
}
otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fuse.Method, fdef);
if (otherFDefOffsets.Count > 0)
{
if (this.HasDefinitionFromRootToUseNode(dcs, fuse, otherFDefOffsets))
{
return(false);
}
}
return(true);
}
}
public void LoopReversed()
{
// Artificially construct a looping construct.
var graph = TestGraphs.CreateLoop();
var n1 = graph.GetNodeById(1);
var n2 = graph.GetNodeById(2);
var n3 = graph.GetNodeById(3);
var n4 = graph.GetNodeById(4);
// Record a depth first traversal.
var traversal = new DepthFirstTraversal(true);
var recorder = new TraversalOrderRecorder(traversal);
traversal.Run(n4);
// Check if n1 is before any node in the traversal.
Assert.All(graph.GetNodes(),
n => Assert.True(n4 == n || recorder.GetIndex(n4) < recorder.GetIndex(n)));
Assert.True(recorder.GetIndex(n1) > recorder.GetIndex(n3));
}
/// <summary>
/// Obtain the specified tree node for the specified index.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="node">The tree node to search from.</param>
/// <returns>The tree node for the specified index.</returns>
public static ITreeNode process(int index, ITreeNode node)
{
ITreeNode result = null;
int nodeCount = 0;
DepthFirstTraversal trav = new DepthFirstTraversal();
trav.Traverse(node, (n) =>
{
if ( nodeCount >= index)
{
if (result == null)
{
result = n;
}
return false;
}
nodeCount++;
return true;
});
return result;
}
/// <summary>
/// Determines whether a graph contains at least one cycle.
/// </summary>
/// <param name="graph">The graph to test.</param>
/// <returns>True if the graph is cyclic, false otherwise.</returns>
public static bool IsCyclic(this Graph graph)
{
var visited = new HashSet <Node>();
foreach (var node in graph.Nodes)
{
if (!visited.Add(node))
{
return(false);
}
bool cycleDetected = false;
var reachableNodes = new HashSet <Node>();
var visitedEdges = new HashSet <Edge>();
var traversal = new DepthFirstTraversal();
traversal.NodeDiscovered += (sender, args) =>
{
if (visitedEdges.Add(args.Origin) && !reachableNodes.Add(args.NewNode))
{
args.ContinueExploring = false;
cycleDetected = true;
}
};
traversal.Run(node);
if (cycleDetected)
{
return(true);
}
visited.UnionWith(reachableNodes);
}
return(false);
}
/// <summary>
/// Obtain the specified tree node for the specified index.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="node">The tree node to search from.</param>
/// <returns>The tree node for the specified index.</returns>
public static ITreeNode process(int index, ITreeNode node)
{
ITreeNode result = null;
int nodeCount = 0;
DepthFirstTraversal trav = new DepthFirstTraversal();
trav.Traverse(node, (n) =>
{
if (nodeCount >= index)
{
if (result == null)
{
result = n;
}
return(false);
}
nodeCount++;
return(true);
});
return(result);
}
public static ICollection <ISet <Node> > FindStronglyConnectedComponents(this Node entrypoint)
{
var graph = entrypoint.ParentGraph;
var traversal = new DepthFirstTraversal();
var recorder = new PostOrderRecorder(traversal);
traversal.Run(entrypoint);
var transpose = graph.Transpose();
var visited = new HashSet <Node>();
var result = new List <ISet <Node> >();
foreach (var node in recorder.GetOrder().Reverse())
{
if (!visited.Contains(node))
{
var subTraversal = new DepthFirstTraversal();
var component = new HashSet <Node>();
subTraversal.NodeDiscovered += (sender, args) =>
{
if (visited.Add(graph.Nodes[args.NewNode.Name]))
{
args.ContinueExploring = true;
component.Add(graph.Nodes[args.NewNode.Name]);
}
};
subTraversal.Run(transpose.Nodes[node.Name]);
result.Add(component);
}
}
return(result);
}
/// <summary>
/// Computes the dominator tree of a control flow graph, defined by its entrypoint.
/// </summary>
/// <param name="entrypoint">The entrypoint of the control flow graph.</param>
/// <returns>A dictionary mapping all the nodes to their immediate dominator.</returns>
/// <remarks>
/// The algorithm used is based on the one engineered by Lengauer and Tarjan.
/// https://www.cs.princeton.edu/courses/archive/fall03/cs528/handouts/a%20fast%20algorithm%20for%20finding.pdf
/// https://www.cl.cam.ac.uk/~mr10/lengtarj.pdf
/// </remarks>
private static IDictionary <IIdentifiedNode, IIdentifiedNode> GetImmediateDominators(IIdentifiedNode entrypoint)
{
var idom = new Dictionary <IIdentifiedNode, IIdentifiedNode>();
var semi = new Dictionary <IIdentifiedNode, IIdentifiedNode>();
var ancestor = new Dictionary <IIdentifiedNode, IIdentifiedNode>();
var bucket = new Dictionary <IIdentifiedNode, ISet <IIdentifiedNode> >();
var traversal = new DepthFirstTraversal();
var order = new TraversalOrderRecorder(traversal);
var parents = new ParentRecorder(traversal);
traversal.Run(entrypoint);
var orderedNodes = order.GetTraversal();
foreach (var node in orderedNodes.Cast <IIdentifiedNode>())
{
idom[node] = null;
semi[node] = node;
ancestor[node] = null;
bucket[node] = new HashSet <IIdentifiedNode>();
}
for (int i = orderedNodes.Count - 1; i >= 1; i--)
{
var current = (IIdentifiedNode)orderedNodes[i];
var parent = (IIdentifiedNode)parents.GetParent(current);
// step 2
foreach (var predecessor in current.GetPredecessors().Cast <IIdentifiedNode>())
{
var u = Eval(predecessor, ancestor, semi, order);
if (order.GetIndex(semi[current]) > order.GetIndex(semi[u]))
{
semi[current] = semi[u];
}
}
bucket[semi[current]].Add(current);
Link(parent, current, ancestor);
// step 3
foreach (var bucketNode in bucket[parent])
{
var u = Eval(bucketNode, ancestor, semi, order);
if (order.GetIndex(semi[u]) < order.GetIndex(semi[bucketNode]))
{
idom[bucketNode] = u;
}
else
{
idom[bucketNode] = parent;
}
}
bucket[parent].Clear();
}
// step 4
for (int i = 1; i < orderedNodes.Count; i++)
{
var w = (IIdentifiedNode)orderedNodes[i];
if (idom[w] != semi[w])
{
idom[w] = idom[idom[w]];
}
}
idom[entrypoint] = entrypoint;
return(idom);
}
public DepthFirstTraversalTest()
{
depthFirstTraversal = new DepthFirstTraversal <string>();
}
