public void TestPriorityCalculation1NoWitnesses()
{
var graph = new DirectedGraph<CHEdgeData>();
var vertex1 = graph.AddVertex(1, 0);
var vertex2 = graph.AddVertex(2, 0);
var vertex3 = graph.AddVertex(3, 0);
graph.AddEdge(vertex1, vertex3, new CHEdgeData(1, true, true, true, 10));
graph.AddEdge(vertex3, vertex1, new CHEdgeData(1, false, true, true, 10));
graph.AddEdge(vertex2, vertex3, new CHEdgeData(1, true, true, true, 10));
graph.AddEdge(vertex3, vertex2, new CHEdgeData(1, false, true, true, 10));
var witnessCalculator = new DykstraWitnessCalculator(int.MaxValue);
var priorityCalculator = new EdgeDifferenceContractedSearchSpace(graph, witnessCalculator);
int newEdges, removedEdges, contracted, depth;
priorityCalculator.Calculate(vertex1, out newEdges, out removedEdges, out depth, out contracted);
Assert.AreEqual(0, newEdges);
Assert.AreEqual(1, removedEdges);
Assert.AreEqual(0, depth);
Assert.AreEqual(0, contracted);
priorityCalculator.Calculate(vertex2, out newEdges, out removedEdges, out depth, out contracted);
Assert.AreEqual(0, newEdges);
Assert.AreEqual(1, removedEdges);
Assert.AreEqual(0, depth);
Assert.AreEqual(0, contracted);
priorityCalculator.Calculate(vertex3, out newEdges, out removedEdges, out depth, out contracted);
Assert.AreEqual(2, newEdges);
Assert.AreEqual(2, removedEdges);
Assert.AreEqual(0, depth);
Assert.AreEqual(0, contracted);
}
public static bool IsSatisfiable(IReadOnlyCollection<Clause> clauses)
{
var graph = new DirectedGraph<int>();
foreach (var clause in clauses)
{
var literal1 = clause.Literal1;
var literal2 = clause.Literal2;
var from1 = GetNodeIndex(literal1.Negate());
var to1 = GetNodeIndex(literal2);
graph.AddEdge(from1, to1);
var from2 = GetNodeIndex(literal2.Negate());
var to2 = GetNodeIndex(literal1);
graph.AddEdge(from2, to2);
}
var calculator = new StronglyConnectedComponentsCalculator<int>(graph);
var components = calculator.GetStronglyConnectedComponents().ToArray();
foreach (var component in components)
{
var positiveLiteralNodes = component.Where(node => node >= 0).ToArray();
var negativeLiteralNodes = new HashSet<int>(component.Where(node => node < 0));
if (positiveLiteralNodes.Any(node => negativeLiteralNodes.Contains(GetNegativeLiteralNodeIndex(node))))
{
return false;
}
}
return true;
}
public void DirectedGraphAllowsDuplicateEdgesTest()
{
var graph = new DirectedGraph<int>(new[] { 1, 2 });
graph.AddEdge(1, 2);
graph.AddEdge(1, 2);
graph.FindCycle().Should().BeEmpty("Expected no cycle vertices to be found");
}
public void TestVerifiedContraction1NoWitnesses()
{
var graph = new DirectedGraph<CHEdgeData>();
var vertex1 = graph.AddVertex(1, 0);
var vertex2 = graph.AddVertex(2, 0);
var vertex3 = graph.AddVertex(3, 0);
graph.AddEdge(vertex1, vertex3, new CHEdgeData(1, true, true, true, 10));
graph.AddEdge(vertex3, vertex1, new CHEdgeData(1, false, true, true, 10));
graph.AddEdge(vertex2, vertex3, new CHEdgeData(1, true, true, true, 10));
graph.AddEdge(vertex3, vertex2, new CHEdgeData(1, false, true, true, 10));
var witnessCalculator = new DykstraWitnessCalculator();
var preProcessor = new CHPreprocessor(graph,
new EdgeDifferenceContractedSearchSpace(graph, witnessCalculator), witnessCalculator);
preProcessor.Contract(3);
// there should be no edge from 1->3 and from 2->3.
Assert.IsFalse(graph.ContainsEdges(1, 3));
Assert.IsFalse(graph.ContainsEdges(2, 3));
var router = new CHRouter();
// expected: (1)-10s-(3)-10s-(2) (20s in total).
var path = router.Calculate(graph, 1, 2);
Assert.IsNotNull(path);
Assert.AreEqual(20, path.Weight);
var pathArray = path.ToArrayWithWeight();
Assert.AreEqual(3, pathArray.Length);
float latitude, longitude;
Assert.AreEqual(0, pathArray[0].Item2);
Assert.IsTrue(graph.GetVertex((uint)pathArray[0].Item1, out latitude, out longitude));
Assert.AreEqual(1, latitude);
Assert.AreEqual(10, pathArray[1].Item2);
Assert.IsTrue(graph.GetVertex((uint)pathArray[1].Item1, out latitude, out longitude));
Assert.AreEqual(3, latitude);
Assert.AreEqual(20, pathArray[2].Item2);
Assert.IsTrue(graph.GetVertex((uint)pathArray[2].Item1, out latitude, out longitude));
Assert.AreEqual(2, latitude);
// expected: (2)-10s-(3)-10s-(1) (20s in total).
path = router.Calculate(graph, 2, 1);
Assert.IsNotNull(path);
Assert.AreEqual(20, path.Weight);
pathArray = path.ToArrayWithWeight();
Assert.AreEqual(3, pathArray.Length);
Assert.AreEqual(0, pathArray[0].Item2);
Assert.IsTrue(graph.GetVertex((uint)pathArray[0].Item1, out latitude, out longitude));
Assert.AreEqual(2, latitude);
Assert.AreEqual(10, pathArray[1].Item2);
Assert.IsTrue(graph.GetVertex((uint)pathArray[1].Item1, out latitude, out longitude));
Assert.AreEqual(3, latitude);
Assert.AreEqual(20, pathArray[2].Item2);
Assert.IsTrue(graph.GetVertex((uint)pathArray[2].Item1, out latitude, out longitude));
Assert.AreEqual(1, latitude);
}
public void InitGraph()
{
_graph = new DirectedGraph<char>();
_graph.AddVertex('A');
_graph.AddVertex('B');
_graph.AddVertex('D');
_graph.AddVertex('E');
_graph.AddEdge('A', 'B');
_graph.AddEdge('A', 'D');
_graph.AddEdge('D', 'B');
_graph.AddEdge('D', 'E');
_graph.AddEdge('E', 'B');
}
private static DirectedGraph<int> GetTestGraph()
{
var graph = new DirectedGraph<int>();
graph.AddEdge(0, 1);
graph.AddEdge(0, 3);
graph.AddEdge(1, 0);
graph.AddEdge(1, 2);
graph.AddEdge(1, 3);
graph.AddEdge(2, 1);
graph.AddEdge(2, 3);
graph.AddEdge(3, 0);
graph.AddEdge(3, 1);
graph.AddEdge(3, 2);
return graph;
}
public void DirectedGraphFindsCyclesTest()
{
var graph = new DirectedGraph<int>(new[] { 1, 2, 3, 4, 5 });
// Add cycle
graph.AddEdge(1, 2);
graph.AddEdge(2, 3);
graph.AddEdge(3, 1);
// Add extra edges
graph.AddEdge(3, 4);
graph.AddEdge(4, 5);
graph.FindCycle().ShouldBeEquivalentTo(new[] { 1, 2, 3 }, "Expected cycle vertices to be found");
}
public void GetStronglyConnectedComponentsTest2()
{
var graph = new DirectedGraph<int>();
graph.AddEdge(1, 3);
graph.AddEdge(3, 5);
graph.AddEdge(3, 9);
graph.AddEdge(5, 7);
graph.AddEdge(7, 1);
var calculator = new StronglyConnectedComponentsCalculator<int>(graph);
var components = calculator.GetStronglyConnectedComponents().ToArray();
components.Should().HaveCount(2);
components[0].Should().BeEquivalentTo(new[] { 9 });
components[1].Should().BeEquivalentTo(new[] { 1, 3, 5, 7 });
}
public void DirectedGraphSortsThrowsForCyclicVerticesTest()
{
var graph = new DirectedGraph<int>(new[] { 4, 2, 1, 5, 3 });
// Add cycle
graph.AddEdge(1, 2);
graph.AddEdge(2, 3);
graph.AddEdge(3, 1);
// Add extra edges
graph.AddEdge(3, 4);
graph.AddEdge(4, 5);
graph.Invoking(g => g.Sort()).ShouldThrow<InvalidOperationException>();
}
public void Run()
{
using (var reader = new StreamReader("kargerMinCut.txt"))
using (var writer = new StreamWriter("output.txt"))
{
var graph = new DirectedGraph<int>();
while (true)
{
string row = reader.ReadLine();
if (row == null)
{
break;
}
var parts = row.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
var numbers = parts.Select(x => int.Parse(x, CultureInfo.InvariantCulture) - 1).ToArray();
foreach (var number in numbers.Skip(1))
{
graph.AddEdge(numbers[0], number);
}
}
int result = Enumerable.Repeat(0, 250).Select(_ => MinCut.GetMinCut(graph)).Min();
writer.WriteLine(result);
}
}
public void Run()
{
using (var reader = new StreamReader("SCC.txt"))
using (var writer = new StreamWriter("output.txt"))
{
var graph = new DirectedGraph<int>();
while (true)
{
string row = reader.ReadLine();
if (row == null)
{
break;
}
var parts = row.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
var numbers = parts.Select(x => int.Parse(x, CultureInfo.InvariantCulture) - 1).ToArray();
var from = numbers[0];
var to = numbers[1];
if (from != to)
{
graph.AddEdge(from, to);
}
}
var calculator = new StronglyConnectedComponentsCalculator<int>(graph);
var components = calculator.GetStronglyConnectedComponents().ToArray();
var top5Components = components.OrderByDescending(x => x.Length).Take(5).ToArray();
var result = string.Join(",", top5Components.Select(x => x.Length));
writer.WriteLine(result);
}
}
public static DirectedGraph CreateDirectedGraph49_Modfied()
{
var g = new DirectedGraph(5);
g.AddEdge('A', 'B', 4);
g.AddEdge('A', 'C', 2);
g.AddEdge('B', 'C', 3);
g.AddEdge('B', 'D', 2);
g.AddEdge('B', 'E', 3);
//AddEdge('C', 'B', 1);//remove cycle
g.AddEdge('C', 'D', 4);
g.AddEdge('C', 'E', 5);
g.AddEdge('E', 'D', 1);
return g;
}
public void Initialize()
{
// add several nodes
graph = new DirectedGraph<string, int>();
graph.AddEdge("A", "B", 5);
graph.AddEdge("B", "C", 4);
graph.AddEdge("C", "D", 8);
graph.AddEdge("D", "C", 8);
graph.AddEdge("D", "E", 6);
graph.AddEdge("A", "D", 5);
graph.AddEdge("C", "E", 2);
graph.AddEdge("E", "B", 3);
graph.AddEdge("A", "E", 7);
}
public static DirectedGraph CreateDirectedGraph49()
{
var g = new DirectedGraph(5);
g.AddEdge('A', 'B', 4);
g.AddEdge('A', 'C', 2);
g.AddEdge('B', 'C', 3);
g.AddEdge('B', 'D', 2);
g.AddEdge('B', 'E', 3);
g.AddEdge('C', 'B', 1);
g.AddEdge('C', 'D', 4);
g.AddEdge('C', 'E', 5);
g.AddEdge('E', 'D', 1);
return g;
}
public DirectedGraph<Type> GetDependencyGraph()
{
DirectedGraph<Type> graph = new DirectedGraph<Type>();
foreach (Type x in assembly.GetTypes())
{
foreach (Type y in GetDependentClasses(x))
{
graph.AddEdge(y, x);
}
}
return graph;
}
public void DepthFirstSearchTest()
{
var graph1 = GetTestGraph();
var calculator1 = new StronglyConnectedComponentsCalculator<int>(graph1);
IEnumerable<int> vertices1 = calculator1.DepthFirstSearch(0, true);
vertices1.Should().HaveCount(9);
var calculator2 = new StronglyConnectedComponentsCalculator<int>(graph1);
IEnumerable<int> vertices2 = calculator2.DepthFirstSearch(1, true);
vertices2.Should().HaveCount(3);
var graph2 = new DirectedGraph<int>();
graph2.AddEdge(0, 1);
graph2.AddEdge(0, 2);
graph2.AddEdge(2, 1);
var calculator3 = new StronglyConnectedComponentsCalculator<int>(graph2);
IEnumerable<int> vertices3 = calculator3.DepthFirstSearch(0, false);
vertices3.Should().HaveCount(3);
}
public void DirectedGraphSortsAcyclicVerticesTest()
{
var graph = new DirectedGraph<int>(new[] { 4, 2, 1, 5, 3 });
// Add non-cyclic edges
graph.AddEdge(1, 2);
graph.AddEdge(1, 5);
graph.AddEdge(2, 3);
graph.AddEdge(2, 4);
graph.AddEdge(3, 4);
graph.AddEdge(3, 5);
graph.AddEdge(4, 5);
graph.Sort().Should().BeInAscendingOrder("Expected vertices to be sorted");
}
public void DirectedGraphFindsNoCyclesInAcyclicGraphTest()
{
var graph = new DirectedGraph<int>(new[] { 1, 2, 3, 4, 5 });
// Add non-cyclic edges
graph.AddEdge(1, 2);
graph.AddEdge(1, 5);
graph.AddEdge(2, 3);
graph.AddEdge(2, 4);
graph.AddEdge(3, 4);
graph.AddEdge(3, 5);
graph.AddEdge(1, 5);
graph.FindCycle().Should().BeEmpty("Expected no cycle vertices to be found");
}
public static DirectedGraph CreateDirectedGraph38()
{
var g = new DirectedGraph(6);
#region add path
g.AddEdge(0, 2);
g.AddEdge(1, 0);
g.AddEdge(1, 3);
g.AddEdge(2, 4);
g.AddEdge(2, 5);
g.AddEdge(3, 2);
#endregion
return g;
}
public void InitializeTwoArmedGraph()
{
_graph = new DirectedGraph<string, string>();
_vertex1 = _graph.CreateVertex("A");
_vertex2 = _graph.CreateVertex("B");
_vertex3 = _graph.CreateVertex("C");
_vertex4 = _graph.CreateVertex("D");
_vertex5 = _graph.CreateVertex("E");
_vertex6 = _graph.CreateVertex("F");
_edge1 = _graph.AddEdge(_vertex1, _vertex2);
_edge2 = _graph.AddEdge(_vertex1, _vertex3);
_edge3 = _graph.AddEdge(_vertex2, _vertex3);
_edge4 = _graph.AddEdge(_vertex3, _vertex4);
_edge5 = _graph.AddEdge(_vertex4, _vertex5);
_edge6 = _graph.AddEdge(_vertex4, _vertex6);
_edge7 = _graph.AddEdge(_vertex5, _vertex6);
}
public void InitializePathfindingGraph()
{
_graph = new DirectedGraph<string, string>();
_vertex1 = _graph.CreateVertex("A");
_vertex2 = _graph.CreateVertex("B");
_vertex3 = _graph.CreateVertex("C");
_vertex4 = _graph.CreateVertex("D");
_vertex5 = _graph.CreateVertex("E");
_vertex6 = _graph.CreateVertex("F");
_vertex7 = _graph.CreateVertex("G");
_vertex8 = _graph.CreateVertex("H");
_vertex9 = _graph.CreateVertex("K");
_edge1 = _graph.AddEdge(_vertex1, _vertex2, 10, "AB");
_edge2 = _graph.AddEdge(_vertex2, _vertex3, 10, "BC");
_edge3 = _graph.AddEdge(_vertex1, _vertex4, 10, "AD");
_edge4 = _graph.AddEdge(_vertex1, _vertex5, 15, "AE");
_edge5 = _graph.AddEdge(_vertex4, _vertex5, 10, "DE");
_edge6 = _graph.AddEdge(_vertex4, _vertex8, 15, "DH");
_edge7 = _graph.AddEdge(_vertex2, _vertex5, 10, "BE");
_edge8 = _graph.AddEdge(_vertex5, _vertex6, 10, "EF");
_edge9 = _graph.AddEdge(_vertex5, _vertex8, 10, "EH");
_edge10 = _graph.AddEdge(_vertex5, _vertex3, 15, "EC");
_edge11 = _graph.AddEdge(_vertex5, _vertex9, 15, "EK");
_edge12 = _graph.AddEdge(_vertex3, _vertex6, 10, "CF");
_edge13 = _graph.AddEdge(_vertex3, _vertex7, 50, "CG");
_edge14 = _graph.AddEdge(_vertex8, _vertex9, 10, "HK");
_edge15 = _graph.AddEdge(_vertex9, _vertex6, 10, "KF");
_edge16 = _graph.AddEdge(_vertex9, _vertex7, 20, "KG");
}
public void InitializeStarGraph()
{
_graph = new DirectedGraph<string, string>();
_vertex1 = _graph.CreateVertex("A");
_vertex2 = _graph.CreateVertex("B");
_vertex3 = _graph.CreateVertex("C");
_vertex4 = _graph.CreateVertex("D");
_vertex5 = _graph.CreateVertex("E");
_edge1 = _graph.AddEdge(_vertex1, _vertex2);
_edge2 = _graph.AddEdge(_vertex1, _vertex3);
_edge3 = _graph.AddEdge(_vertex1, _vertex4);
_edge4 = _graph.AddEdge(_vertex1, _vertex5);
}
public void TestGraphSerialize1()
{
var graph = new DirectedGraph<Edge>();
var vertex1 = graph.AddVertex(51, 1);
var vertex2 = graph.AddVertex(51, 2);
graph.AddEdge(vertex1, vertex2, new Edge()
{
Forward = true,
Tags = 1
}, null);
// serialize.
using (var stream = new MemoryStream())
{
graph.Serialize(stream, Edge.SizeUints, Edge.MapFromDelegate, Edge.MapToDelegate);
// deserialize.
stream.Seek(0, SeekOrigin.Begin);
var graphDeserialized = DirectedGraph<Edge>.Deserialize(stream, Edge.SizeUints, Edge.MapFromDelegate, Edge.MapToDelegate, false);
// compare.
Assert.AreEqual(graph.VertexCount, graphDeserialized.VertexCount);
for (uint vertex = 1; vertex <= graph.VertexCount; vertex++)
{
float latitude1, longitude1, latitude2, longitude2;
if (graph.GetVertex(vertex, out latitude1, out longitude1) &&
graphDeserialized.GetVertex(vertex, out latitude2, out longitude2))
{
Assert.AreEqual(latitude1, latitude2, 0.000001);
Assert.AreEqual(longitude1, longitude2, 0.000001);
}
}
var edges = graphDeserialized.GetEdges(vertex1, vertex2).ToKeyValuePairs();
Assert.AreEqual(1, edges.Length);
Assert.AreEqual(1, edges[0].Value.Tags);
}
}
static IReadOnlyDictionary<string, IReadOnlyList<Export<IStyleRule, StyleRuleMetadata>>> OrderAndMapRules(
IReadOnlyList<Export<IStyleRule, StyleRuleMetadata>> rules)
{
var languageRuleMap = new Dictionary<string, IReadOnlyList<Export<IStyleRule, StyleRuleMetadata>>>();
ILookup<string, Export<IStyleRule, StyleRuleMetadata>> languageRuleLookup =
rules.ToLookup(r => r.Metadata.LanguageName);
foreach (IGrouping<string, Export<IStyleRule, StyleRuleMetadata>> languageRules in languageRuleLookup)
{
var graph = new DirectedGraph<Export<IStyleRule, StyleRuleMetadata>>(languageRules);
Dictionary<string, Export<IStyleRule, StyleRuleMetadata>> nameRuleMap =
languageRules.ToDictionary(r => r.Metadata.Name);
foreach (Export<IStyleRule, StyleRuleMetadata> languageRule in languageRules)
{
foreach (string afterName in languageRule.Metadata.AfterNames)
{
Export<IStyleRule, StyleRuleMetadata> afterRule;
if (nameRuleMap.TryGetValue(afterName, out afterRule))
{
graph.AddEdge(afterRule, languageRule);
}
}
foreach (string beforeName in languageRule.Metadata.BeforeNames)
{
Export<IStyleRule, StyleRuleMetadata> beforeRule;
if (nameRuleMap.TryGetValue(beforeName, out beforeRule))
{
graph.AddEdge(languageRule, beforeRule);
}
}
}
IReadOnlyList<Export<IStyleRule, StyleRuleMetadata>> cycle = graph.FindCycle();
if (cycle.Count > 0)
{
var ruleNames = String.Join(", ", cycle.Select(r => r.Metadata.Name));
throw new InvalidOperationException($"Dependency cycle exists in rules {ruleNames}");
}
languageRuleMap.Add(languageRules.Key, graph.Sort());
}
return languageRuleMap;
}
public void TestVerifiedContraction4ReplacePrevious()
{
var graph = new DirectedGraph<CHEdgeData>();
var vertex1 = graph.AddVertex(1, 0);
var vertex2 = graph.AddVertex(2, 0);
var vertex3 = graph.AddVertex(3, 0);
var vertex4 = graph.AddVertex(4, 0);
graph.AddEdge(vertex1, vertex4, new CHEdgeData(1, true, true, true, 15));
graph.AddEdge(vertex4, vertex1, new CHEdgeData(1, false, true, true, 15));
graph.AddEdge(vertex2, vertex4, new CHEdgeData(1, true, true, true, 15));
graph.AddEdge(vertex4, vertex2, new CHEdgeData(1, false, true, true, 15));
var witnessCalculator = new DykstraWitnessCalculator();
var preProcessor = new CHPreprocessor(graph,
new EdgeDifferenceContractedSearchSpace(graph, witnessCalculator), witnessCalculator);
preProcessor.Contract(4);
Assert.IsTrue(graph.ContainsEdge(vertex1, vertex2, new CHEdgeData(4, true, true, 30)));
Assert.IsTrue(graph.ContainsEdge(vertex2, vertex1, new CHEdgeData(4, true, true, 30)));
// add edges later to prevent witnesses from being found!
graph.AddEdge(vertex1, vertex3, new CHEdgeData(1, true, true, true, 10));
graph.AddEdge(vertex3, vertex1, new CHEdgeData(1, false, true, true, 10));
graph.AddEdge(vertex2, vertex3, new CHEdgeData(1, true, true, true, 10));
graph.AddEdge(vertex3, vertex2, new CHEdgeData(1, false, true, true, 10));
preProcessor.Contract(3);
Assert.IsTrue(graph.ContainsEdge(vertex1, vertex2, new CHEdgeData(3, true, true, 20)));
Assert.IsTrue(graph.ContainsEdge(vertex2, vertex1, new CHEdgeData(3, true, true, 20)));
}
private static DirectedGraph<int> GetTestGraph()
{
var graph = new DirectedGraph<int>();
graph.AddEdge(0, 3);
graph.AddEdge(1, 7);
graph.AddEdge(2, 5);
graph.AddEdge(3, 6);
graph.AddEdge(4, 1);
graph.AddEdge(5, 8);
graph.AddEdge(6, 0);
graph.AddEdge(7, 4);
graph.AddEdge(7, 5);
graph.AddEdge(8, 2);
graph.AddEdge(8, 6);
return graph;
}
public void TestAddEdge()
{
// a new graph.
var graph = new DirectedGraph(2, 10);
graph.AddEdge(0, 1, 10, 100);
graph.AddEdge(1, 0, 10, 100);
graph.AddEdge(0, 2, 20, 200);
graph.AddEdge(2, 0, 20, 200);
var edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(2, edges.Count);
Assert.AreEqual(10, edges.First(x => x.Neighbour == 1).Data[0]);
Assert.AreEqual(100, edges.First(x => x.Neighbour == 1).Data[1]);
Assert.AreEqual(20, edges.First(x => x.Neighbour == 2).Data[0]);
Assert.AreEqual(200, edges.First(x => x.Neighbour == 2).Data[1]);
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(1, edges.Count);
Assert.AreEqual(10, edges.First(x => x.Neighbour == 0).Data[0]);
Assert.AreEqual(100, edges.First(x => x.Neighbour == 0).Data[1]);
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(1, edges.Count);
Assert.AreEqual(20, edges.First(x => x.Neighbour == 0).Data[0]);
Assert.AreEqual(200, edges.First(x => x.Neighbour == 0).Data[1]);
var meta = new int[200];
graph = new DirectedGraph(2, 10, (x, y) =>
{
meta[y * 2] = meta[x * 2];
meta[y * 2 + 1] = meta[x * 2 + 1];
});
// add edge.
var edge = graph.AddEdge(0, 1, 10, 100);
meta[edge * 2] = 10;
meta[edge * 2 + 1] = 100;
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(10, edges.First().Data[0]);
Assert.AreEqual(100, edges.First().Data[1]);
Assert.AreEqual(10, meta[edges.First().Id * 2]);
Assert.AreEqual(100, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(0, edges.Count());
// add another edge.
edge = graph.AddEdge(1, 2, 20, 200);
meta[edge * 2] = 20;
meta[edge * 2 + 1] = 200;
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(10, edges.First().Data[0]);
Assert.AreEqual(100, edges.First().Data[1]);
Assert.AreEqual(10, meta[edges.First().Id * 2]);
Assert.AreEqual(100, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(20, edges.First().Data[0]);
Assert.AreEqual(200, edges.First().Data[1]);
Assert.AreEqual(20, meta[edges.First().Id * 2]);
Assert.AreEqual(200, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(2, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(0, edges.Count());
// add another edge.
edge = graph.AddEdge(1, 3, 30, 300);
meta[edge * 2] = 30;
meta[edge * 2 + 1] = 300;
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(10, edges.First().Data[0]);
Assert.AreEqual(100, edges.First().Data[1]);
Assert.AreEqual(10, meta[edges.First().Id * 2]);
Assert.AreEqual(100, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(2, edges.Count());
Assert.IsTrue(edges.Any(x => x.Neighbour == 2));
Assert.AreEqual(20, edges.First(x => x.Neighbour == 2).Data[0]);
Assert.AreEqual(200, edges.First(x => x.Neighbour == 2).Data[1]);
Assert.AreEqual(20, meta[edges.First(x => x.Neighbour == 2).Id * 2]);
Assert.AreEqual(200, meta[edges.First(x => x.Neighbour == 2).Id * 2 + 1]);
Assert.IsTrue(edges.Any(x => x.Neighbour == 3));
Assert.AreEqual(30, edges.First(x => x.Neighbour == 3).Data[0]);
Assert.AreEqual(300, edges.First(x => x.Neighbour == 3).Data[1]);
Assert.AreEqual(30, meta[edges.First(x => x.Neighbour == 3).Id * 2]);
Assert.AreEqual(300, meta[edges.First(x => x.Neighbour == 3).Id * 2 + 1]);
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(3);
Assert.AreEqual(0, edges.Count());
// add another edge but in reverse.
edge = graph.AddEdge(3, 1, 30, 300);
meta[edge * 2] = 30;
meta[edge * 2 + 1] = 300;
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(10, edges.First().Data[0]);
Assert.AreEqual(100, edges.First().Data[1]);
Assert.AreEqual(10, meta[edges.First().Id * 2]);
Assert.AreEqual(100, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(2, edges.Count());
Assert.IsTrue(edges.Any(x => x.Neighbour == 2));
Assert.AreEqual(20, edges.First(x => x.Neighbour == 2).Data[0]);
Assert.AreEqual(200, edges.First(x => x.Neighbour == 2).Data[1]);
Assert.AreEqual(20, meta[edges.First(x => x.Neighbour == 2).Id * 2]);
Assert.AreEqual(200, meta[edges.First(x => x.Neighbour == 2).Id * 2 + 1]);
Assert.IsTrue(edges.Any(x => x.Neighbour == 3));
Assert.AreEqual(30, edges.First(x => x.Neighbour == 3).Data[0]);
Assert.AreEqual(300, edges.First(x => x.Neighbour == 3).Data[1]);
Assert.AreEqual(30, meta[edges.First(x => x.Neighbour == 3).Id * 2]);
Assert.AreEqual(300, meta[edges.First(x => x.Neighbour == 3).Id * 2 + 1]);
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(3);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(30, edges.First().Data[0]);
Assert.AreEqual(300, edges.First().Data[1]);
Assert.AreEqual(30, meta[edges.First().Id * 2]);
Assert.AreEqual(300, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
// add another edge and start a new island.
edge = graph.AddEdge(4, 5, 40, 400);
meta[edge * 2] = 40;
meta[edge * 2 + 1] = 400;
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(10, edges.First().Data[0]);
Assert.AreEqual(100, edges.First().Data[1]);
Assert.AreEqual(10, meta[edges.First().Id * 2]);
Assert.AreEqual(100, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(2, edges.Count());
Assert.IsTrue(edges.Any(x => x.Neighbour == 2));
Assert.AreEqual(20, edges.First(x => x.Neighbour == 2).Data[0]);
Assert.AreEqual(200, edges.First(x => x.Neighbour == 2).Data[1]);
Assert.AreEqual(20, meta[edges.First(x => x.Neighbour == 2).Id * 2]);
Assert.AreEqual(200, meta[edges.First(x => x.Neighbour == 2).Id * 2 + 1]);
Assert.IsTrue(edges.Any(x => x.Neighbour == 3));
Assert.AreEqual(30, edges.First(x => x.Neighbour == 3).Data[0]);
Assert.AreEqual(300, edges.First(x => x.Neighbour == 3).Data[1]);
Assert.AreEqual(30, meta[edges.First(x => x.Neighbour == 3).Id * 2]);
Assert.AreEqual(300, meta[edges.First(x => x.Neighbour == 3).Id * 2 + 1]);
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(3);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(30, edges.First().Data[0]);
Assert.AreEqual(300, edges.First().Data[1]);
Assert.AreEqual(30, meta[edges.First().Id * 2]);
Assert.AreEqual(300, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(4);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(40, edges.First().Data[0]);
Assert.AreEqual(400, edges.First().Data[1]);
Assert.AreEqual(40, meta[edges.First().Id * 2]);
Assert.AreEqual(400, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(5, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(5);
Assert.AreEqual(0, edges.Count());
// connect the islands.
edge = graph.AddEdge(5, 3, 50, 500);
meta[edge * 2] = 50;
meta[edge * 2 + 1] = 500;
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(10, edges.First().Data[0]);
Assert.AreEqual(100, edges.First().Data[1]);
Assert.AreEqual(10, meta[edges.First().Id * 2]);
Assert.AreEqual(100, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(2, edges.Count());
Assert.IsTrue(edges.Any(x => x.Neighbour == 2));
Assert.AreEqual(20, edges.First(x => x.Neighbour == 2).Data[0]);
Assert.AreEqual(200, edges.First(x => x.Neighbour == 2).Data[1]);
Assert.AreEqual(20, meta[edges.First(x => x.Neighbour == 2).Id * 2]);
Assert.AreEqual(200, meta[edges.First(x => x.Neighbour == 2).Id * 2 + 1]);
Assert.IsTrue(edges.Any(x => x.Neighbour == 3));
Assert.AreEqual(30, edges.First(x => x.Neighbour == 3).Data[0]);
Assert.AreEqual(300, edges.First(x => x.Neighbour == 3).Data[1]);
Assert.AreEqual(30, meta[edges.First(x => x.Neighbour == 3).Id * 2]);
Assert.AreEqual(300, meta[edges.First(x => x.Neighbour == 3).Id * 2 + 1]);
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(3);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(30, edges.First().Data[0]);
Assert.AreEqual(300, edges.First().Data[1]);
Assert.AreEqual(30, meta[edges.First().Id * 2]);
Assert.AreEqual(300, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(4);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(40, edges.First().Data[0]);
Assert.AreEqual(400, edges.First().Data[1]);
Assert.AreEqual(40, meta[edges.First().Id * 2]);
Assert.AreEqual(400, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(5, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(5);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(50, edges.First().Data[0]);
Assert.AreEqual(500, edges.First().Data[1]);
Assert.AreEqual(50, meta[edges.First().Id * 2]);
Assert.AreEqual(500, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(3, edges.First().Neighbour);
edge = graph.AddEdge(1, 6, 60, 600);
meta[edge * 2] = 60;
meta[edge * 2 + 1] = 600;
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(10, edges.First().Data[0]);
Assert.AreEqual(100, edges.First().Data[1]);
Assert.AreEqual(10, meta[edges.First().Id * 2]);
Assert.AreEqual(100, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(3, edges.Count());
Assert.IsTrue(edges.Any(x => x.Neighbour == 2));
Assert.AreEqual(20, edges.First(x => x.Neighbour == 2).Data[0]);
Assert.AreEqual(200, edges.First(x => x.Neighbour == 2).Data[1]);
Assert.AreEqual(20, meta[edges.First(x => x.Neighbour == 2).Id * 2]);
Assert.AreEqual(200, meta[edges.First(x => x.Neighbour == 2).Id * 2 + 1]);
Assert.IsTrue(edges.Any(x => x.Neighbour == 3));
Assert.AreEqual(30, edges.First(x => x.Neighbour == 3).Data[0]);
Assert.AreEqual(300, edges.First(x => x.Neighbour == 3).Data[1]);
Assert.AreEqual(30, meta[edges.First(x => x.Neighbour == 3).Id * 2]);
Assert.AreEqual(300, meta[edges.First(x => x.Neighbour == 3).Id * 2 + 1]);
Assert.IsTrue(edges.Any(x => x.Neighbour == 6));
Assert.AreEqual(60, edges.First(x => x.Neighbour == 6).Data[0]);
Assert.AreEqual(600, edges.First(x => x.Neighbour == 6).Data[1]);
Assert.AreEqual(60, meta[edges.First(x => x.Neighbour == 6).Id * 2]);
Assert.AreEqual(600, meta[edges.First(x => x.Neighbour == 6).Id * 2 + 1]);
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(3);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(30, edges.First().Data[0]);
Assert.AreEqual(300, edges.First().Data[1]);
Assert.AreEqual(30, meta[edges.First().Id * 2]);
Assert.AreEqual(300, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(4);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(40, edges.First().Data[0]);
Assert.AreEqual(400, edges.First().Data[1]);
Assert.AreEqual(40, meta[edges.First().Id * 2]);
Assert.AreEqual(400, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(5, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(5);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(50, edges.First().Data[0]);
Assert.AreEqual(50, meta[edges.First().Id * 2]);
Assert.AreEqual(500, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(3, edges.First().Neighbour);
edge = graph.AddEdge(1, 7, 70, 700);
meta[edge * 2] = 70;
meta[edge * 2 + 1] = 700;
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(10, edges.First().Data[0]);
Assert.AreEqual(100, edges.First().Data[1]);
Assert.AreEqual(10, meta[edges.First().Id * 2]);
Assert.AreEqual(100, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(4, edges.Count());
Assert.IsTrue(edges.Any(x => x.Neighbour == 2));
Assert.AreEqual(20, edges.First(x => x.Neighbour == 2).Data[0]);
Assert.AreEqual(200, edges.First(x => x.Neighbour == 2).Data[1]);
Assert.AreEqual(20, meta[edges.First(x => x.Neighbour == 2).Id * 2]);
Assert.AreEqual(200, meta[edges.First(x => x.Neighbour == 2).Id * 2 + 1]);
Assert.IsTrue(edges.Any(x => x.Neighbour == 3));
Assert.AreEqual(30, edges.First(x => x.Neighbour == 3).Data[0]);
Assert.AreEqual(300, edges.First(x => x.Neighbour == 3).Data[1]);
Assert.AreEqual(30, meta[edges.First(x => x.Neighbour == 3).Id * 2]);
Assert.AreEqual(300, meta[edges.First(x => x.Neighbour == 3).Id * 2 + 1]);
Assert.IsTrue(edges.Any(x => x.Neighbour == 6));
Assert.AreEqual(60, edges.First(x => x.Neighbour == 6).Data[0]);
Assert.AreEqual(600, edges.First(x => x.Neighbour == 6).Data[1]);
Assert.AreEqual(60, meta[edges.First(x => x.Neighbour == 6).Id * 2]);
Assert.AreEqual(600, meta[edges.First(x => x.Neighbour == 6).Id * 2 + 1]);
Assert.IsTrue(edges.Any(x => x.Neighbour == 7));
Assert.AreEqual(70, edges.First(x => x.Neighbour == 7).Data[0]);
Assert.AreEqual(700, edges.First(x => x.Neighbour == 7).Data[1]);
Assert.AreEqual(70, meta[edges.First(x => x.Neighbour == 7).Id * 2]);
Assert.AreEqual(700, meta[edges.First(x => x.Neighbour == 7).Id * 2 + 1]);
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(3);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(30, edges.First().Data[0]);
Assert.AreEqual(300, edges.First().Data[1]);
Assert.AreEqual(30, meta[edges.First().Id * 2]);
Assert.AreEqual(300, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(4);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(40, edges.First().Data[0]);
Assert.AreEqual(400, edges.First().Data[1]);
Assert.AreEqual(40, meta[edges.First().Id * 2]);
Assert.AreEqual(400, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(5, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(5);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(50, edges.First().Data[0]);
Assert.AreEqual(500, edges.First().Data[1]);
Assert.AreEqual(50, meta[edges.First().Id * 2]);
Assert.AreEqual(500, meta[edges.First().Id * 2 + 1]);
Assert.AreEqual(3, edges.First().Neighbour);
}
public void TestVerifiedContraction6DuplicateForward()
{
var graph = new DirectedGraph<CHEdgeData>();
var witnessCalculator = new DykstraWitnessCalculator();
var preProcessor = new CHPreprocessor(graph,
new EdgeDifferenceContractedSearchSpace(graph, witnessCalculator), witnessCalculator);
var vertex1 = graph.AddVertex(1, 0);
var vertex2 = graph.AddVertex(2, 0);
var vertex3 = graph.AddVertex(3, 0);
var vertex4 = graph.AddVertex(4, 0);
graph.AddEdge(vertex1, vertex3, new CHEdgeData(1, true, false, true, 10));
graph.AddEdge(vertex3, vertex1, new CHEdgeData(1, false, true, false, 10));
graph.AddEdge(vertex2, vertex3, new CHEdgeData(1, true, true, false, 10));
graph.AddEdge(vertex3, vertex2, new CHEdgeData(1, false, false, true, 10));
graph.AddEdge(vertex1, vertex4, new CHEdgeData(1, true, true, false, 15));
graph.AddEdge(vertex4, vertex1, new CHEdgeData(1, false, false, true, 15));
graph.AddEdge(vertex2, vertex4, new CHEdgeData(1, true, false, true, 15));
graph.AddEdge(vertex4, vertex2, new CHEdgeData(1, false, true, false, 15));
preProcessor.Contract(3);
Assert.IsTrue(graph.ContainsEdge(vertex1, vertex2, new CHEdgeData(3, false, true, 20)));
Assert.IsTrue(graph.ContainsEdge(vertex2, vertex1, new CHEdgeData(3, true, false, 20)));
preProcessor.Contract(4);
Assert.IsTrue(graph.ContainsEdge(vertex1, vertex2, new CHEdgeData(4, true, false, 30)));
Assert.IsTrue(graph.ContainsEdge(vertex2, vertex1, new CHEdgeData(4, false, true, 30)));
Assert.IsTrue(graph.ContainsEdge(vertex1, vertex2, new CHEdgeData(3, false, true, 20)));
Assert.IsTrue(graph.ContainsEdge(vertex2, vertex1, new CHEdgeData(3, true, false, 20)));
}
public void Bwslc_AcrossJump()
{
var r1 = Reg("r1");
var r2 = Reg("r2");
var b = Given_Block(0x100);
Given_Instrs(b, m => { m.Assign(r1, m.Shl(r2, 2)); });
Given_Instrs(b, m => { m.Goto(Address.Ptr32(0x200)); });
var b2 = Given_Block(0x200);
Given_Instrs(b2, m => { m.Goto(m.IAdd(r1, 0x00123400)); });
graph.Nodes.Add(b);
graph.Nodes.Add(b2);
graph.AddEdge(b, b2);
var bwslc = new BackwardSlicer(host, b2, processorState);
Assert.IsTrue(bwslc.Start(b2, -1, Target(b2))); // indirect jump
Assert.IsTrue(bwslc.Step()); // direct jump
Assert.IsTrue(bwslc.Step()); // shift left
Assert.AreEqual(1, bwslc.Live.Count);
Assert.AreEqual("r2", bwslc.Live.First().Key.ToString());
}
public void AddEdge(Region nodeFrom, Region nodeTo)
{
graph.AddEdge(nodeTo, nodeFrom);
}
/// <summary>
/// Identifies if-then or if-then-else schemas in the region graph
/// and reduces them out of the graph.
/// </summary>
/// <param name="n">The header of the possible if-region</param>
/// <param name="reduceTailregions">If true, will consider tail
/// regions as well as properly formed regions.</param>
/// <returns></returns>
private bool ReduceIfRegion(Region n, bool reduceTailregions)
{
var ss = regionGraph.Successors(n).ToArray();
var el = ss[0];
var th = ss[1];
var elS = SingleSuccessor(el);
var thS = SingleSuccessor(th);
if (elS == th || (reduceTailregions && el.Type == RegionType.Tail))
{
if (RefinePredecessor(n, el))
return false;
// Collapse (If else) into n.
n.Statements.Add(new AbsynIf(n.Expression.Invert(), el.Statements));
regionGraph.RemoveEdge(n, el);
if (elS != null)
regionGraph.RemoveEdge(el, elS);
RemoveRegion(el);
n.Type = RegionType.Linear;
n.Expression = null;
return true;
}
else if (thS == el || (reduceTailregions && th.Type == RegionType.Tail))
{
if (RefinePredecessor(n, th))
return false;
// Collapse (if-then) into n
n.Statements.Add(new AbsynIf(n.Expression, th.Statements));
regionGraph.RemoveEdge(n, th);
if (thS != null)
regionGraph.RemoveEdge(th, thS);
RemoveRegion(th);
n.Type = RegionType.Linear;
n.Expression = null;
return true;
}
else if (elS != null && elS == thS)
{
if (RefinePredecessor(n, th) |
RefinePredecessor(n, el))
return false;
// Collapse (If then else) into n.
n.Statements.Add(new AbsynIf(n.Expression.Invert(), el.Statements, th.Statements));
regionGraph.RemoveEdge(n, el);
regionGraph.RemoveEdge(n, th);
regionGraph.RemoveEdge(el, elS);
regionGraph.RemoveEdge(th, thS);
RemoveRegion(th);
RemoveRegion(el);
regionGraph.AddEdge(n, elS);
n.Type = RegionType.Linear;
n.Expression = null;
return true;
}
else
{
if (RefinePredecessor(n, th))
return false;
return false;
}
}
public void TestCompress()
{
var graph = new DirectedGraph(1, 10);
// add and compress.
graph.AddEdge(0, 1, 1);
graph.Compress();
// verify all edges.
var edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(1, edges.First().Data[0]);
Assert.AreEqual(1, edges.First().Neighbour);
graph = new DirectedGraph(1, 10);
// add and compress.
graph.AddEdge(0, 1, 10);
graph.AddEdge(1, 2, 20);
graph.AddEdge(2, 3, 30);
graph.AddEdge(3, 4, 40);
graph.RemoveEdge(1, 2);
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(10, edges.First().Data[0]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(30, edges.First().Data[0]);
Assert.AreEqual(3, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(3);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(40, edges.First().Data[0]);
Assert.AreEqual(4, edges.First().Neighbour);
// compress.
graph.Compress();
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(10, edges.First().Data[0]);
Assert.AreEqual(1, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(30, edges.First().Data[0]);
Assert.AreEqual(3, edges.First().Neighbour);
edges = graph.GetEdgeEnumerator(3);
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(40, edges.First().Data[0]);
Assert.AreEqual(4, edges.First().Neighbour);
}
private void UpdateGraphs()
{
Graph graph = new DirectedGraph();
this.TransitionChains = new Dictionary <MemoryAccessMethod, List <TransitionChain> >();
foreach (Transition transition in this.RootTransitions)
{
//
// Skip identity primitives for now.
//
if (transition.Primitive.IsIdentity)
{
continue;
}
//
// Use an open-ended violation of the method that the transition is from to ensure
// the constraints will match.
//
// TODO: also leverage expected parameter control?
//
Violation initialViolation = new Violation(
transition.Primitive.FromMethod.Value
);
GlobalSimulationContext globalContext = new GlobalSimulationContext(
new Target()
{
Violation = initialViolation
});
//
// Assume that content initialization is possible. Most transitions will require
// that content has been initialized, and it is expected that a content initialization
// primitive will have been used to accomplish this. However, for the purpose of classification,
// we do not want to select or imply any one initialization primitive.
//
globalContext.AssumeContentInitializationPossible = true;
SimulationContext initialContext = new SimulationContext(globalContext);
Simulator simulator = new Simulator(this, initialContext);
//
// Limit simulation to include only those primitives that are part of the same technique.
//
simulator.RestrictToTransitions(
this.Transitions.Where(x => x.Technique == transition.Technique)
);
//
// Add edges for contexts that reach a fixed point.
//
simulator.OnFixedPointReached += (context) =>
{
TransitionInformation contextRoot = context.VisitedTransitions.Where(x => x.Transition.Primitive.IsIdentity == false).FirstOrDefault();
if (contextRoot == null || contextRoot.Transition != transition)
{
return;
}
TransitionChain chain = new TransitionChain();
foreach (TransitionInformation ti in context.VisitedTransitions)
{
graph.AddEdge(
new DirectedEdge(
ti.PreViolation,
ti.PostViolation,
ti.Transition.Primitive
)
);
chain.Transitions.Add(ti);
}
if (!this.TransitionChains.ContainsKey(initialViolation.Method))
{
this.TransitionChains[initialViolation.Method] = new List <TransitionChain>();
}
this.TransitionChains[initialViolation.Method].Add(chain);
};
//
// Execute the simulation.
//
simulator.Run();
}
this.CompleteGraph = graph;
}
public void InitializeTwoGraphGraphNoCycle()
{
_graph = new DirectedGraph<string, string>();
_vertex1 = _graph.CreateVertex("A");
_vertex2 = _graph.CreateVertex("B");
_vertex3 = _graph.CreateVertex("C");
_vertex4 = _graph.CreateVertex("D");
_vertex5 = _graph.CreateVertex("E");
_edge1 = _graph.AddEdge(_vertex1, _vertex2);
_edge3 = _graph.AddEdge(_vertex3, _vertex4);
_edge4 = _graph.AddEdge(_vertex4, _vertex5);
_edge5 = _graph.AddEdge(_vertex3, _vertex5);
}
public void TestUpdateEdge()
{
// a new graph.
var graph = new DirectedGraph(2, 10);
graph.AddEdge(0, 1, 10, 100);
// update
Assert.IsTrue(graph.UpdateEdge(0, 1, (data) =>
{
return(data[0] == 10);
}, 10, 101) != Constants.NO_EDGE);
// check result.
var edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(1, edges.Count);
Assert.AreEqual(10, edges.First(x => x.Neighbour == 1).Data[0]);
Assert.AreEqual(101, edges.First(x => x.Neighbour == 1).Data[1]);
// a new graph.
graph = new DirectedGraph(2, 10);
graph.AddEdge(0, 1, 10, 100);
graph.AddEdge(0, 1, 20, 200);
graph.AddEdge(0, 1, 30, 300);
// update
Assert.IsTrue(graph.UpdateEdge(0, 1, (data) =>
{
return(data[0] == 30);
}, 30, 301) != Constants.NO_EDGE);
// check result.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(3, edges.Count);
Assert.AreEqual(301, edges.First(x => x.Neighbour == 1 && x.Data[0] == 30).Data[1]);
// a new graph.
graph = new DirectedGraph(2, 10);
graph.AddEdge(0, 1, 10, 100);
graph.AddEdge(0, 1, 20, 200);
graph.AddEdge(0, 1, 30, 300);
// update
Assert.IsTrue(graph.UpdateEdge(0, 1, (data) =>
{
return(data[0] == 20);
}, 20, 201) != Constants.NO_EDGE);
// check result.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(3, edges.Count);
Assert.AreEqual(201, edges.First(x => x.Neighbour == 1 && x.Data[0] == 20).Data[1]);
// do a failing update.
Assert.IsFalse(graph.UpdateEdge(0, 1, (data) =>
{
return(false);
}, 20, 201) != Constants.NO_EDGE);
// do another failing update.
Assert.IsFalse(graph.UpdateEdge(0, 2, (data) =>
{
return(true);
}, 20, 201) != Constants.NO_EDGE);
}
public void Initialize()
{
_graph = new DirectedGraph<string, string>();
_vertex1 = _graph.CreateVertex("Penis");
_vertex2 = _graph.CreateVertex("Tomato");
_vertex3 = _graph.CreateVertex("Isa");
_vertex4 = _graph.CreateVertex("Robin");
_vertex5 = _graph.CreateVertex("Außenseiter");
_edge1 = _graph.AddEdge(_vertex1, _vertex2);
_edge2 = _graph.AddEdge(_vertex2, _vertex3);
_edge3 = _graph.AddEdge(_vertex3, _vertex4);
_edge4 = _graph.AddEdge(_vertex1, _vertex4);
}
public void ShuffleTreasures(MT19337 rng)
{
DirectedGraph<byte> graph = new DirectedGraph<byte>();
var treasureBlob = Get(TreasureOffset, TreasureSize * TreasureCount);
var usedIndices = Enumerable.Range(0, TreasureCount).Except(TreasureConditions.NotUsed).ToList();
var usedTreasures = usedIndices.Select(i => treasureBlob[i]).ToList();
bool tofrQuestItem;
do
{
usedTreasures.Shuffle(rng);
for (int i = 0; i < usedIndices.Count; i++)
{
treasureBlob[usedIndices[i]] = usedTreasures[i];
}
// ToFR is only exitable using WARP or EXIT, so we don't want these items showing up there.
// Especially not the TAIL, as that would make class change impossible. And the CROWN being
// here could block a LOT of valuable loot if you don't have a WW or BW.
tofrQuestItem =
TreasureConditions.ToFR.Contains(treasureBlob.IndexOf((byte)QuestItems.Crown)) ||
TreasureConditions.ToFR.Contains(treasureBlob.IndexOf((byte)QuestItems.Tail)) ||
TreasureConditions.ToFR.Contains(treasureBlob.IndexOf((byte)QuestItems.Adamant));
if (tofrQuestItem)
{
continue;
}
var blockages = new List<Tuple<byte, int, List<int>>>
{
Tuple.Create((byte)QuestItems.Crown, treasureBlob.IndexOf((byte)QuestItems.Crown), TreasureConditions.CrownBlocked),
Tuple.Create((byte)QuestItems.Tnt, treasureBlob.IndexOf((byte)QuestItems.Tnt), TreasureConditions.TntBlocked),
Tuple.Create((byte)QuestItems.Ruby, treasureBlob.IndexOf((byte)QuestItems.Ruby), TreasureConditions.RubyBlocked),
Tuple.Create((byte)QuestItems.Floater, treasureBlob.IndexOf((byte)QuestItems.Floater), TreasureConditions.FloaterBlocked),
Tuple.Create((byte)QuestItems.Slab, treasureBlob.IndexOf((byte)QuestItems.Slab), TreasureConditions.SlabBlocked)
};
graph = new DirectedGraph<byte>();
foreach (var blockage in blockages)
{
graph.AddNode(blockage.Item1);
}
foreach (var blocker in blockages)
{
foreach (var blockee in blockages)
{
if (blocker.Item3.Contains(blockee.Item2))
{
graph.AddEdge(blockee.Item1, blocker.Item1);
}
}
}
} while (tofrQuestItem || graph.HasCycles());
Put(TreasureOffset, treasureBlob);
}
public void AddEdge(T n1, T n2)
{
g.AddEdge(n1, n2);
g.AddEdge(n2, n1);
}
public void Add(char from, char to)
{
graph.AddEdge(nodes[from], nodes[to], 0);
}
