public List<Edge<int>> mfas(BidirectionalGraph<int, Edge<int>> G) { List<Edge<int>> F = new List<Edge<int>>(); IDictionary<int, int> P = new Dictionary<int, int>(); int sccCount = G.StronglyConnectedComponents(out P); if (sccCount == 0) { return F; } if (sccCount == 1) { Tuple<List<int>, List<int>> T = bisect(G); F = mfas(subGraph(T.Item1, G)); F.AddRange(mfas(subGraph(T.Item2, G))); F.AddRange(fromV2toV1(T, G)); } else { var scc = new HashSet<int>(P.Values); foreach (int k in scc) { List<int> S = P.Select(x => x).Where(x => x.Value == k).Select(x => x.Key).ToList<int>(); F.AddRange(mfas(subGraph(S, G))); } } return F; }
public void Repro13160() { // create a new graph var graph = new BidirectionalGraph<int, SEquatableEdge<int>>(false); // adding vertices for (int i = 0; i < 3; ++i) for(int j = 0;j<3;++j) graph.AddVertex(i * 3 + j); // adding Width edges for (int i = 0; i < 3; ++i) for(int j = 0; j < 2;++j) graph.AddEdge(new SEquatableEdge<int>(i * 3 +j, i * 3 + j + 1)); // adding Length edges for (int i = 0; i < 2; ++i) for(int j = 0; j < 3;++j) graph.AddEdge(new SEquatableEdge<int>(i * 3 + j, (i+1) * 3 + j)); // create cross edges foreach (var e in graph.Edges) graph.AddEdge(new SEquatableEdge<int>(e.Target, e.Source)); // breaking graph apart for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) if (i == 1) graph.RemoveVertex(i * 3 + j); var target = new CyclePoppingRandomTreeAlgorithm<int, SEquatableEdge<int>>(graph); target.Compute(2); foreach(var kv in target.Successors) Console.WriteLine("{0}: {1}", kv.Key, kv.Value); }
/// <summary> /// Constructor. /// </summary> /// <param name="configuration">Configuration</param> public RaceDetectionEngine(Configuration configuration) { this.Configuration = configuration; this.AllThreadTraces = new List<ThreadTrace>(); this.CGraph = new BidirectionalGraph<Node, Edge>(); }
public void NonAcyclic() { var g = new BidirectionalGraph<string, Edge<string>>( ); var vs = new string[ 4 ]; for ( int i = 1; i < 5; i++ ) { vs[ i - 1 ] = i.ToString( ); g.AddVertex( i.ToString( ) ); } g.AddEdge( new Edge<string>( vs[ 0 ], vs[ 1 ] ) ); g.AddEdge( new Edge<string>( vs[ 1 ], vs[ 2 ] ) ); g.AddEdge( new Edge<string>( vs[ 2 ], vs[ 0 ] ) ); g.AddEdge( new Edge<string>( vs[ 3 ], vs[ 0 ] ) ); try { var lts = new LayeredTopologicalSortAlgorithm<string, Edge<string>>( g ); lts.Compute( ); Assert.Fail( "It does not throw exception for non acyclic graphs." ); } catch ( NonAcyclicGraphException ex ) { Debug.WriteLine( ex.Message ); } }
public void CloneTest() { var g = new BidirectionalGraph<int, Edge<int>>(); g.AddVertexRange(new int[3] {1, 2, 3}); g.AddEdge(new Edge<int>(1, 2)); g.AddEdge(new Edge<int>(2, 3)); g.AddEdge(new Edge<int>(3, 1)); Assert.AreEqual(3, g.VertexCount); Assert.AreEqual(3, g.EdgeCount); var h = g.Clone(); Assert.AreEqual(3, h.VertexCount); Assert.AreEqual(3, h.EdgeCount); h.AddVertexRange(new int[4] { 10, 11, 12, 13 }); h.AddEdge(new Edge<int>(10, 11)); Assert.AreEqual(7, h.VertexCount); Assert.AreEqual(4, h.EdgeCount); var i = 0; foreach (var e in h.Edges) i++; Assert.AreEqual(4, i); Assert.AreEqual(3, g.VertexCount); Assert.AreEqual(3, g.EdgeCount); }
public BidirectionalGraph<object, IEdge<object>> BuildDependencyGraph() { var g = new BidirectionalGraph<object, IEdge<object>>(); foreach (var method in Methods) { g.AddVertex(method.Name); } foreach (var field in Fields) { g.AddVertex(field.Name); } foreach (var method in Methods) { foreach (var methodUse in method.MethodUses) { g.AddEdge(new Edge<object>(method.Name, methodUse.Name)); } foreach (var fieldUse in method.FieldUses) { g.AddEdge(new Edge<object>(method.Name, fieldUse.Name)); } } return g; }
Tuple<List<int>, List<int>> bisect(BidirectionalGraph<int, Edge<int>> G) { List<int> vl = G.Vertices.ToList<int>(); int vlc = vl.Count(); Tuple<List<int>, List<int>> V = new Tuple<List<int>, List<int>>(vl.GetRange(0, vlc / 2), vl.GetRange(vlc / 2, vlc - vlc / 2)); Tuple<List<int>, List<int>> B = new Tuple<List<int>, List<int>>(new List<int>(V.Item1), new List<int>(V.Item2)); int p = -1;//p0 == -1 int R = 1; int d = 2; int counter = 0; int Cpre, Cpost; int BC; Cpre = fromV2toV1(V, G).Count(); BC = Cpre; do { perturb(V, p, G); Cpost = fromV2toV1(V, G).Count(); if (Cpost < Cpre && BC > Cpost) { B = new Tuple<List<int>, List<int>> (new List<int>(V.Item1), new List<int>(V.Item2)); BC = Cpost; counter -= R; } else { counter++; } if (Cpost == Cpre) { p = p - d; } else { p = -1; //p0 == -1; } Cpre = Cpost; } while(!(counter > R)); return B; }
internal GcTypeHeap(BidirectionalGraph<GcType, GcTypeEdge> graph) { if (graph == null) throw new ArgumentNullException("graph"); this.graph = graph; }
public static IBidirectionalGraph<object, IEdge<object>> AdjacentyMatrixToGraph(MatrixWithHeaders matrixWithHeaders) { var graph = new BidirectionalGraph<object, IEdge<object>>(); var headers = matrixWithHeaders.Headers; var matrix = matrixWithHeaders.Matrix; foreach (var item in headers) { graph.AddVertex(item.Value); } if (headers.Count > 1) { for (int y = 0; y < matrix.GetLength(1); y++) { for (int x = 0; x < matrix.GetLength(0); x++) { if (matrix[x, y] == 1) { graph.AddEdge(new Edge<object>(headers[x], headers[y])); } } } } else { graph.AddEdge(new Edge<object>(headers[0], headers[0])); } return graph; }
public void SmallTest() { var g1 = new BidirectionalGraph<int, Edge<int>>(); var g2 = new BidirectionalGraph<int, Edge<int>>(); g1.AddVerticesAndEdgeRange(new[] {new Edge<int>(1, 2), new Edge<int>(1, 3), new Edge<int>(2, 4)}); g2.AddVerticesAndEdgeRange(new[] {new Edge<int>(1, 2), new Edge<int>(1, 3), new Edge<int>(2, 4)}); var dictionary = new Dictionary<Tuple<int, int>, double>(); foreach (var i in g1.Vertices) { foreach (var j in g2.Vertices) { if (i == j) dictionary[Tuple.Create(i, j)] = 1.0; else dictionary[Tuple.Create(i, j)] = 0.0; } } var algo = new MaxCardinality<int, Edge<int>>(g1, g2, dictionary, 0.5, (u, v) => new Edge<int>(u, v)); var res = algo.compMaxCardinality(); var e = Enumerable.Range(1, 4).Select(x => Tuple.Create(x, x)); var correctResult = SetModule.OfSeq(e); Assert.AreEqual(res, correctResult); }
public MainWindow() { InitializeLinkedList(); _graphToVisualize = new BidirectionalGraph<object, IEdge<object>>(); RefreshGraph(); InitializeComponent(); PopulateMethodList(); }
public void Test() { var graph = new BidirectionalGraph<int, Edge<int>>(); graph.AddVerticesAndEdgeRange(new[] { new Edge<int>(1, 2) , new Edge<int>(2, 3), new Edge<int>(3, 4), new Edge<int>(3, 5) }); var result = graph.ComputeTransitiveClosure((u, v) => new Edge<int>(u, v)); Assert.AreEqual(9, result.EdgeCount); }
public static void ImportEs(BidirectionalGraph<int, Edge<int>> WorkingGraph, int numObjects, string Filename = "C:\\Users\\perdo\\Desktop\\Test.es") { string s = ""; string[] Entries; Edge<int> Newedge; StreamReader reader = null; try { reader = new StreamReader(Filename); } catch { throw new Exception("Could not open File" + Filename); } reader.ReadLine(); reader.ReadLine(); //skipping first two useless lines if (!isUndirected) { while ((s = reader.ReadLine()) != null) { Entries = s.Split(' '); Newedge = new Edge<int>(int.Parse(Entries[0]), int.Parse(Entries[1])); if (Newedge.Source == Newedge.Target) continue; // removing self-edges WorkingGraph.AddVertex(int.Parse(Entries[0])); WorkingGraph.AddVertex(int.Parse(Entries[1])); WorkingGraph.AddEdge(Newedge); } } else // Would have to change the underlying graph structure to properly support undirected edges. Easier just to mirror each edge { while ((s = reader.ReadLine()) != null) { Entries = s.Split(' '); Newedge = new Edge<int>(int.Parse(Entries[0]), int.Parse(Entries[1])); if (Newedge.Source == Newedge.Target) continue; // removing self-edges WorkingGraph.AddVertex(int.Parse(Entries[0])); WorkingGraph.AddVertex(int.Parse(Entries[1])); WorkingGraph.AddEdge(Newedge); Newedge = new Edge<int>(int.Parse(Entries[1]), int.Parse(Entries[0])); WorkingGraph.AddEdge(Newedge); } } //Following code looks for vertices that have no incoming or outgoing edges //I debated not including it but figured i'd make this code robust var Verts = WorkingGraph.Vertices; var MissingItems = Enumerable.Range(0, numObjects); foreach (int item in MissingItems) { WorkingGraph.AddVertex(item); } reader.Close(); }
public void Repro12901() { var graph = new BidirectionalGraph<int, Edge<int>>(); int vertex = 1; graph.AddVerticesAndEdge(new Edge<int>(vertex, vertex)); var pathFinder = AlgorithmExtensions.ShortestPathsBellmanFord<int, Edge<int>>(graph, edge => -1.0, vertex); IEnumerable<Edge<int>> path; pathFinder(vertex, out path); }
public void BindGraph(BidirectionalGraph<object, IEdge<object>> graph) { Graph = graph; var bindingExpression = _graphLayout.GetBindingExpression(GraphLayout.GraphProperty); if (bindingExpression != null) { bindingExpression.UpdateTarget(); } }
public void Prune(BidirectionalGraph<CFGBlock, TaggedEdge<CFGBlock, EdgeTag>> graph) { Preconditions.NotNull(graph, "graph"); this.graph = graph; RemoveUnreachableBlocks(); RemoveEmptyBlocks(); this.graph = null; }
//Preparation for CTL requires all nodes without an outgoing edge to have a loop to self public void AddSelfLoops(BidirectionalGraph<CFGBlock, TaggedEdge<CFGBlock, EdgeTag>> graph) { foreach (var vertex in graph.Vertices) { if (!graph.OutEdges(vertex).Any()) { graph.AddEdge (new TaggedEdge<CFGBlock, EdgeTag> (vertex, vertex, new EdgeTag (EdgeType.Normal))); } } }
public ActivityArrowGraph GenerateGraph() { InitializeInternalStructures(); var nodeGraph = CreateActivityNodeGraphFromProject(); var nodeGraphReduction = nodeGraph.ComputeTransitiveReduction(); arrowGraph = ExplodeActivityNodeGraphToArrowGraph(nodeGraphReduction); RedirectArrowGraph(); DropRedundantArrows(); return CreateResultActivityArrowGraph(); }
public BlockModularity(int numClust,int numIts, double eps, BidirectionalGraph<int, Edge<int>> g) { numClusters = numClust; graph = g; numObjects = g.VertexCount; numEdges = g.EdgeCount; epsilon = eps; numIterations = numIts; rnd = new Random(); workingClustering= new int[numObjects]; }
public static void AddEdge(BidirectionalGraph<DataVertex, DataEdge> graph, DataVertex source, DataVertex target, int? sourcePoint = null, int? targetPoint = null, int weight = 0) { var edge = new DataEdge(source, target, weight) { Text = string.Empty, SourceConnectionPointId = sourcePoint, TargetConnectionPointId = targetPoint, ToolTipText = "Label "+ source.ID }; graph.AddEdge(edge); }
/// <summary> /// Get similarities by checking node actual values. Take threshold to limit results. /// </summary> /// <param name="gSource"></param> /// <param name="gTarget"></param> /// <param name="threshold"></param> /// <returns></returns> public double[,] getSimilarity(BidirectionalGraph<AbstractTreeLatticeNode, Edge<AbstractTreeLatticeNode>> gSource, BidirectionalGraph<AbstractTreeLatticeNode, Edge<AbstractTreeLatticeNode>> gTarget, double threshold) { double[,] simM = new double[gSource.VertexCount, gTarget.VertexCount]; for (int i = 0; i < gSource.VertexCount; i++) for (int j = 0; j < gTarget.VertexCount; j++) { simM[i, j] = checkNames(gSource.Vertices.ElementAt(i) as AbstractTreeLatticeNode, gTarget.Vertices.ElementAt(j) as AbstractTreeLatticeNode); } return normaliseResults(simM); }
public void ReadGraph(TextReader reader) { var g = new BidirectionalGraph<MyType, IEdge<MyType>>(); try { var csv = new CsvHelper.CsvReader(reader); while (csv.Read()) { if (!csv.CurrentRecord.Any()) { continue; } var node = csv.CurrentRecord.First(); var edges = csv.CurrentRecord.Skip(1) .Where(x => !string.IsNullOrEmpty(x)) .Select(x => x.Trim()) .Where(x => !string.IsNullOrEmpty(x)); foreach (var edge in edges) { g.AddVerticesAndEdge(new Edge<MyType>(node, edge)); } } var dict = new Dictionary<int, HashSet<MyType>>(); HashSet<MyType> set; foreach (var v in g.Vertices) { var edgeCount = g.InEdges(v).Count(); if (!dict.TryGetValue(edgeCount, out set)) { set = new HashSet<MyType>(); dict.Add(edgeCount, set); } set.Add(v); } Graph = g; Summary = string.Join(Environment.NewLine, dict .OrderBy(kvp => kvp.Key) .Select(kvp => kvp.Key + ": " + string.Join(", ", kvp.Value))) + Environment.NewLine + Environment.NewLine + string.Join(Environment.NewLine, g.Vertices .Where(v => g.OutEdges(v).Count() != 3) .Select(v => v + ": " + g.OutEdges(v).Count())); //Summary = string.Join( // Environment.NewLine, // graph.Vertices // .OrderBy(x => graph.InEdges(x).Count()) // .Select(v => v + ": " + graph.InEdges(v).Count())); } catch (Exception e) { Summary = "Failed to read:" + Environment.NewLine + e; } }
public void makeModel(BidirectionalGraph<CFGBlock, TaggedEdge<CFGBlock, EdgeTag>> graph, IncludeResolver resolver, string path) { this.graph = graph; this.resolver = resolver; var root = graph.Roots ().Single (v => v.IsSpecialBlock); BFS (root, this.graph); Console.WriteLine("Finished BFS Traversal, generating if sentences..."); GenerateIf (); Console.WriteLine("Writing to file..."); WriteToFile (path); }
public static BidirectionalGraph<string, Edge<string>> LoadBidirectionalGraph(string graphmlFile) { TestConsole.WriteLine(graphmlFile); var g = new BidirectionalGraph<string, Edge<string>>(); using (var reader = new StreamReader(graphmlFile)) { g.DeserializeFromGraphML( reader, id => id, (source, target, id) => new Edge<string>(source, target) ); } return g; }
public void SmallTest() { var graph = new BidirectionalGraph<int, Edge<int>>(); graph.AddVerticesAndEdgeRange(new[] { new Edge<int>(1, 2), new Edge<int>(1, 3), new Edge<int>(1, 4), new Edge<int>(1, 5), new Edge<int>(2, 4), new Edge<int>(3, 4), new Edge<int>(3, 5), new Edge<int>(4, 5) }); var result = graph.ComputeTransitiveReduction(); Assert.AreEqual(5, result.EdgeCount); }
private void AssembleGraph(BidirectionalGraph<ParseTree, Edge<ParseTree>> graph, ParseTree parent) { if (parent.Children == null) { return; } foreach (var child in parent.Children) { graph.AddVertex(child); graph.AddEdge(new Edge<ParseTree>(parent, child)); AssembleGraph(graph, child); } }
private void BuildPropertyAccessTreeGraph(BidirectionalGraph<object, IEdge<object>> g, string root, IEnumerable<Node> nodes) { foreach (var node in nodes) { var property_node = node as PropertyNode; if (property_node == null) continue; var property_node_name = string.Format("{0} - {1}", property_node.Type.UnderlyingSystemType.Name, property_node.PropertyName); g.AddVertex(property_node_name); g.AddEdge(new Edge<object>(root, property_node_name)); if (property_node.Children.Count > 0) BuildPropertyAccessTreeGraph(g, property_node_name, property_node.Children); } }
public void ContainsEdgeTest1() { var bd = new BidirectionalGraph<int, IEdge<int>>(); var e12 = new SEquatableUndirectedEdge<int>(1, 2); var f12 = new SEquatableUndirectedEdge<int>(1, 2); bd.AddVerticesAndEdge(e12); ContainsEdgeAssertions(bd, e12, f12, null, null); var u = new UndirectedBidirectionalGraph<int, IEdge<int>>(bd); UndirectedGraphTest.ContainsEdgeAssertions(u, e12, f12, null, null); }
public static BidirectionalGraph<object, IEdge<object>> testGraph() { var bidirectionalGraph = new BidirectionalGraph<object, IEdge<object>>(); var vertices = new object[] { "A", "B", "C", "D", "E", "F" }; var edges = new IEdge<object>[] { new Edge<object>(vertices[0], vertices[1]), new Edge<object>(vertices[1], vertices[2]), new Edge<object>(vertices[1], vertices[3]), new Edge<object>(vertices[3], vertices[4]), new Edge<object>(vertices[0], vertices[4]), new Edge<object>(vertices[4], vertices[5]) }; bidirectionalGraph.AddVerticesAndEdgeRange(edges); return bidirectionalGraph; }
public void CycleWithNoEdgesFromStart() { var knownSchedules = new Mock<IStoreSchedules>(); var verifier = new ScheduleVerifier(knownSchedules.Object); var graph = new BidirectionalGraph<IScheduleVertex, ScheduleEdge>(); var start = new StartVertex(1); graph.AddVertex(start); var end = new EndVertex(2); graph.AddVertex(end); var vertex1 = new InsertVertex(3); graph.AddVertex(vertex1); var vertex2 = new InsertVertex(4); graph.AddVertex(vertex2); var vertex3 = new InsertVertex(5); graph.AddVertex(vertex3); graph.AddEdge(new ScheduleEdge(start, end)); graph.AddEdge(new ScheduleEdge(vertex1, end)); graph.AddEdge(new ScheduleEdge(vertex1, vertex2)); graph.AddEdge(new ScheduleEdge(vertex2, vertex3)); graph.AddEdge(new ScheduleEdge(vertex3, vertex1)); var schedule = new Schedule(graph, start, end); var id = new ScheduleId(); var failures = new List<Tuple<ScheduleIntegrityFailureType, IScheduleVertex>>(); var result = verifier.IsValid( id, schedule, (f, v) => failures.Add(new Tuple<ScheduleIntegrityFailureType, IScheduleVertex>(f, v))); Assert.IsFalse(result); Assert.AreEqual(3, failures.Count); Assert.AreEqual(ScheduleIntegrityFailureType.ScheduleVertexIsNotReachableFromStart, failures[0].Item1); Assert.AreSame(vertex1, failures[0].Item2); Assert.AreEqual(ScheduleIntegrityFailureType.ScheduleVertexIsNotReachableFromStart, failures[1].Item1); Assert.AreSame(vertex2, failures[1].Item2); Assert.AreEqual(ScheduleIntegrityFailureType.ScheduleVertexIsNotReachableFromStart, failures[2].Item1); Assert.AreSame(vertex3, failures[2].Item2); }
public void OutDegreeSumEqualsEdgeCountAll(BidirectionalGraph <string, Edge <string> > g) { this.OutDegreeSumEqualsEdgeCount(g); }
public void AddEdgeRange() { var graph = new BidirectionalGraph <int, Edge <int> >(false); AddEdgeRange_Test(graph); }
public ConcurrentBidirectionalGraph(bool allowParallelEdges = true) { Graph = new BidirectionalGraph <TVertex, TEdge>(allowParallelEdges); SyncRoot = new object(); }
public void AddVerticesAndEdge() { var graph = new BidirectionalGraph <int, Edge <int> >(); AddVerticesAndEdge_Test(graph); }
public void ContainsEdge_EquatableEdge() { var graph = new BidirectionalGraph <int, EquatableEdge <int> >(); ContainsEdge_EquatableEdge_Test(graph); }
private static List <LocalVariableAnalysis> AnalyzeLocalVariables(List <ILInstruction> ilInstructions, MethodBody methodBody, BidirectionalGraph <ILInstruction, Edge <ILInstruction> > flowGraph, HashSet <ILInstruction> methodCalls) { if ((methodBody?.LocalVariables?.Count ?? 0) == 0) { return(new List <LocalVariableAnalysis>()); } var localVariableAnalyses = methodBody.LocalVariables.Select(localVariable => new LocalVariableAnalysis()).ToList(); foreach (var ilInstruction in ilInstructions) { var opCode = ilInstruction.Code; var opCodeValue = opCode.Value; if (IsLoadLocal(opCodeValue)) { localVariableAnalyses[GetLoadLocalIndex(ilInstruction)].Sinks.Add(ilInstruction); } else if (IsStoreLocal(opCodeValue)) { localVariableAnalyses[GetStoreLocalIndex(ilInstruction)].Sources.Add(ilInstruction); } else if (opCodeValue == OpCodes.Ldloca.Value || opCodeValue == OpCodes.Ldloca_S.Value) { var operand = Convert.ToInt32(ilInstruction.Operand); localVariableAnalyses[operand].AddressSources.Add(ilInstruction); } } foreach (var localVariableAnalysis in localVariableAnalyses) { var sinkScope = localVariableAnalysis.Sinks.SelectMany(sink => ComputeSinkScope(sink, localVariableAnalysis.Sources, flowGraph)).Distinct(); var addressSourceScope = localVariableAnalysis.AddressSources.SelectMany(source => ComputeSourceScope(source, flowGraph)).Distinct(); localVariableAnalysis.Scope = sinkScope.Union(addressSourceScope).ToHashSet(); localVariableAnalysis.SpannedMethodCalls = localVariableAnalysis.Scope.Intersect(methodCalls).ToHashSet(); } return(localVariableAnalyses); }
public static IEnumerable <string> Get_First_Mutual_Branch_Point_Backwards(string vertex, BidirectionalGraph <string, TaggedEdge <string, Tag> > graph) { if (!graph.ContainsVertex(vertex)) { yield break; } int inDegree = graph.InDegree(vertex); if (inDegree < 2) { yield break; // the provided vertex is not a mergePoint } if (inDegree == 2) { string s1 = graph.InEdge(vertex, 0).Source; string s2 = graph.InEdge(vertex, 1).Source; if (s1 != s2) { HashSet <string> branchPoints1 = new HashSet <string>(); HashSet <string> branchPoints2 = new HashSet <string>(); foreach (string v in Get_First_Branch_Point_Backwards(s1, graph)) { branchPoints1.Add(v); } foreach (string v in Get_First_Branch_Point_Backwards(s2, graph)) { branchPoints2.Add(v); } foreach (string mutual in branchPoints1.Intersect(branchPoints2)) { yield return(mutual); } } } else { Console.WriteLine("WARNING: Get_First_Mutual_Branch_Point_Backwards: multiple merge points at this the provided vertex " + vertex); } }
public void MergeIf_Test( [NotNull] IEnumerable <int> setupVertices, [NotNull, ItemNotNull] IEnumerable <EquatableEdge <int> > setupEdges, [NotNull, InstantHandle] VertexPredicate <int> vertexPredicate, int expectedVerticesRemoved, int expectedEdgesAdded, int expectedEdgesRemoved, [NotNull] IEnumerable <int> expectedVertices, [NotNull, ItemNotNull] IEnumerable <EquatableEdge <int> > expectedEdges) { int verticesAdded = 0; int edgesAdded = 0; int verticesRemoved = 0; int edgesRemoved = 0; var graph = new BidirectionalGraph <int, EquatableEdge <int> >(); graph.AddVertexRange(setupVertices); graph.AddEdgeRange(setupEdges); graph.VertexAdded += v => { Assert.IsNotNull(v); ++verticesAdded; }; graph.VertexRemoved += v => { Assert.IsNotNull(v); // ReSharper disable once AccessToModifiedClosure ++verticesRemoved; }; graph.EdgeAdded += e => { Assert.IsNotNull(e); // ReSharper disable once AccessToModifiedClosure ++edgesAdded; }; graph.EdgeRemoved += e => { Assert.IsNotNull(e); // ReSharper disable once AccessToModifiedClosure ++edgesRemoved; }; graph.MergeVerticesIf(vertexPredicate, (source, target) => new EquatableEdge <int>(source, target)); CheckCounters(); AssertHasVertices(graph, expectedVertices); EquatableEdge <int>[] edges = expectedEdges.ToArray(); if (!edges.Any()) { AssertNoEdge(graph); } else { AssertHasEdges(graph, edges); } #region Local function void CheckCounters() { Assert.AreEqual(0, verticesAdded); Assert.AreEqual(expectedVerticesRemoved, verticesRemoved); Assert.AreEqual(expectedEdgesAdded, edgesAdded); Assert.AreEqual(expectedEdgesRemoved, edgesRemoved); verticesRemoved = 0; edgesAdded = 0; edgesRemoved = 0; } #endregion }
public void AddVertex_Throws() { var graph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >(); AddVertex_Throws_Test(graph); }
public void TryGetInEdges_Throws() { var graph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >(); TryGetInEdges_Throws_Test(graph); }
public void Merge_Test( [NotNull] IEnumerable <int> setupVertices, [NotNull, ItemNotNull] IEnumerable <EquatableEdge <int> > setupEdges, int vertexToMerge, int expectedEdgesAdded, int expectedEdgesRemoved, [NotNull, ItemNotNull] IEnumerable <EquatableEdge <int> > expectedEdges) { int verticesAdded = 0; int edgesAdded = 0; int verticesRemoved = 0; int edgesRemoved = 0; var graph = new BidirectionalGraph <int, EquatableEdge <int> >(); int[] verticesArray = setupVertices.ToArray(); graph.AddVertexRange(verticesArray); graph.AddEdgeRange(setupEdges); graph.VertexAdded += v => { Assert.IsNotNull(v); ++verticesAdded; }; graph.VertexRemoved += v => { Assert.IsNotNull(v); // ReSharper disable once AccessToModifiedClosure ++verticesRemoved; }; graph.EdgeAdded += e => { Assert.IsNotNull(e); // ReSharper disable once AccessToModifiedClosure ++edgesAdded; }; graph.EdgeRemoved += e => { Assert.IsNotNull(e); // ReSharper disable once AccessToModifiedClosure ++edgesRemoved; }; graph.MergeVertex(vertexToMerge, (source, target) => new EquatableEdge <int>(source, target)); CheckCounters(); AssertHasVertices(graph, verticesArray.Except(new[] { vertexToMerge })); AssertHasEdges(graph, expectedEdges); #region Local function void CheckCounters() { Assert.AreEqual(0, verticesAdded); Assert.AreEqual(1, verticesRemoved); Assert.AreEqual(expectedEdgesAdded, edgesAdded); Assert.AreEqual(expectedEdgesRemoved, edgesRemoved); verticesRemoved = 0; edgesAdded = 0; edgesRemoved = 0; } #endregion }
public void TryGetInEdges() { var graph = new BidirectionalGraph <int, Edge <int> >(); TryGetInEdges_Test(graph); }
public void Degree_Throws() { var graph = new BidirectionalGraph <EquatableTestVertex, Edge <EquatableTestVertex> >(); Degree_Throws_Test(graph); }
public void Degree() { var graph = new BidirectionalGraph <int, Edge <int> >(); Degree_Test(graph); }
public void DegreeSumEqualsTwiceEdgeCountAll(BidirectionalGraph <string, Edge <string> > g) { this.DegreeSumEqualsTwiceEdgeCount(g); }
public void AddEdge_NoParallelEdges_EquatableEdge() { var graph = new BidirectionalGraph <int, EquatableEdge <int> >(false); AddEdge_NoParallelEdges_EquatableEdge_Test(graph); }
private static HashSet <ILInstruction> ComputeSinkScope(ILInstruction sink, HashSet <ILInstruction> sources, BidirectionalGraph <ILInstruction, Edge <ILInstruction> > flowGraph) { var scope = new HashSet <ILInstruction>(); var vertexStack = new Stack <ILInstruction>(); vertexStack.Push(sink); while (vertexStack.TryPop(out var vertex)) { if (!scope.Contains(vertex) && !sources.Contains(vertex)) { scope.Add(vertex); foreach (var edge in flowGraph.InEdges(vertex)) { vertexStack.Push(edge.Source); } } } return(scope); }
public void Transform(BidirectionalGraph <Resource, AssociationViewEdge> resourceGraph) { ApplyStudentTransformation(resourceGraph); ApplyStaffTransformation(resourceGraph); ApplyParentTransformation(resourceGraph); }
/// <summary>traverse the provided vertex backwards and return the first</summary> public static IEnumerable <string> Get_First_Branch_Point_Backwards(string vertex, BidirectionalGraph <string, TaggedEdge <string, Tag> > graph) { HashSet <string> visited = new HashSet <string>(); return(Get_Branch_Point_Backwards_LOCAL(vertex)); #region Local Method IEnumerable <string> Get_Branch_Point_Backwards_LOCAL(string v1) { if (visited.Contains(v1)) { yield break; } if (!graph.ContainsVertex(v1)) { yield break; } if (graph.OutDegree(v1) > 1) { visited.Add(v1); yield return(v1); } else { foreach (TaggedEdge <string, Tag> edge in graph.InEdges(v1)) { foreach (string v in Get_Branch_Point_Backwards_LOCAL(edge.Source)) { yield return(v); } } } } #endregion }
public void ContainsEdge_SourceTarget() { var graph = new BidirectionalGraph <int, Edge <int> >(); ContainsEdge_SourceTarget_Test(graph); }
public void Clone() { var graph = new BidirectionalGraph <int, Edge <int> >(); AssertEmptyGraph(graph); var clonedGraph = graph.Clone(); Assert.IsNotNull(clonedGraph); AssertEmptyGraph(clonedGraph); clonedGraph = new BidirectionalGraph <int, Edge <int> >(graph); Assert.IsNotNull(clonedGraph); AssertEmptyGraph(clonedGraph); clonedGraph = (BidirectionalGraph <int, Edge <int> >)((ICloneable)graph).Clone(); Assert.IsNotNull(clonedGraph); AssertEmptyGraph(clonedGraph); graph.AddVertexRange(new[] { 1, 2, 3 }); AssertHasVertices(graph, new[] { 1, 2, 3 }); AssertNoEdge(graph); clonedGraph = graph.Clone(); Assert.IsNotNull(clonedGraph); AssertHasVertices(clonedGraph, new[] { 1, 2, 3 }); AssertNoEdge(clonedGraph); clonedGraph = (BidirectionalGraph <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); graph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3 }); 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 = new BidirectionalGraph <int, Edge <int> >(graph); Assert.IsNotNull(clonedGraph); AssertHasVertices(clonedGraph, new[] { 1, 2, 3 }); AssertHasEdges(clonedGraph, new[] { edge1, edge2, edge3 }); clonedGraph = (BidirectionalGraph <int, Edge <int> >)((ICloneable)graph).Clone(); Assert.IsNotNull(clonedGraph); AssertHasVertices(clonedGraph, new[] { 1, 2, 3 }); AssertHasEdges(clonedGraph, new[] { edge1, edge2, edge3 }); graph.AddVertex(4); 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 = (BidirectionalGraph <int, Edge <int> >)((ICloneable)graph).Clone(); Assert.IsNotNull(clonedGraph); AssertHasVertices(clonedGraph, new[] { 1, 2, 3, 4 }); AssertHasEdges(clonedGraph, new[] { edge1, edge2, edge3 }); }
public void AddVerticesAndEdgeRange_Throws() { var graph = new BidirectionalGraph <int, Edge <int> >(false); AddVerticesAndEdgeRange_Throws_Test(graph); }
public void NotEnoughPaths() { int ii = 0; var graph = new BidirectionalGraph <int, TaggedEdge <int, int> >(); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(493, 495, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(495, 493, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(497, 499, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(499, 497, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(499, 501, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(501, 499, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(501, 503, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(503, 501, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(503, 505, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(505, 503, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(505, 507, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(507, 505, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(507, 509, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(509, 507, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(509, 511, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(511, 509, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2747, 2749, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2749, 2747, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2749, 2751, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2751, 2749, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2751, 2753, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2753, 2751, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2753, 2755, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2755, 2753, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2755, 2757, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2757, 2755, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2757, 2759, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2759, 2757, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2761, 2763, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2763, 2761, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2765, 2767, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2767, 2765, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2763, 2765, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2765, 2763, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(654, 978, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(978, 654, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(978, 1302, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1302, 978, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1302, 1626, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1626, 1302, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1626, 1950, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1950, 1626, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1950, 2274, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2274, 1950, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2274, 2598, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2598, 2274, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(513, 676, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(676, 513, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2767, 2608, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2608, 2767, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2287, 2608, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2608, 2287, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(676, 999, ii++));; graph.AddVerticesAndEdge(new TaggedEdge <int, int>(999, 676, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1321, 1643, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1643, 1321, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1643, 1965, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1965, 1643, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1965, 2287, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2287, 1965, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(999, 1321, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1321, 999, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2745, 2747, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2747, 2745, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(650, 491, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(491, 650, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(650, 970, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(970, 650, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2258, 2582, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2582, 2258, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(970, 1291, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1291, 970, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1935, 2258, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2258, 1935, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1291, 1613, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1613, 1291, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1613, 1935, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(1935, 1613, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2582, 2745, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2745, 2582, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(495, 497, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(497, 495, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(511, 513, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(513, 511, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(491, 493, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(493, 491, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(491, 654, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(654, 491, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2761, 2598, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2598, 2761, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2761, 2759, ii++)); graph.AddVerticesAndEdge(new TaggedEdge <int, int>(2759, 2761, ii++)); var test1 = new HoffmanPavleyRankedShortestPathAlgorithm <int, TaggedEdge <int, int> >(graph, e => 1.0); test1.ShortestPathCount = 5; test1.Compute(1626, 1965); Assert.AreEqual(4, test1.ComputedShortestPathCount); TestConsole.WriteLine("path: {0}", test1.ComputedShortestPathCount); foreach (var path in test1.ComputedShortestPaths) { foreach (var edge in path) { Console.Write(edge + ":"); } TestConsole.WriteLine(); } }
public void AddEdgeRange_Throws() { var graph = new BidirectionalGraph <int, Edge <int> >(); AddEdgeRange_Throws_Test(graph); }
public void RemoveInEdgeIf_Throws() { var graph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >(); RemoveInEdgeIf_Throws_Test(graph); }
public void AddEdge_ParallelEdges() { var graph = new BidirectionalGraph <int, Edge <int> >(); AddEdge_ParallelEdges_Test(graph); }
public void ClearEdges() { int edgesRemoved = 0; var graph = new BidirectionalGraph <int, Edge <int> >(); graph.EdgeRemoved += e => { Assert.IsNotNull(e); // ReSharper disable once AccessToModifiedClosure ++edgesRemoved; }; AssertEmptyGraph(graph); // Clear 1 => not in graph graph.ClearEdges(1); AssertEmptyGraph(graph); CheckCounter(0); // Clear 1 => In graph but not in/out edges graph.AddVertex(1); graph.ClearEdges(1); AssertHasVertices(graph, new[] { 1 }); AssertNoEdge(graph); CheckCounter(0); var edge12 = new Edge <int>(1, 2); var edge23 = new Edge <int>(2, 3); graph.AddVerticesAndEdgeRange(new[] { edge12, edge23 }); // Clear 2 graph.ClearEdges(2); AssertNoEdge(graph); CheckCounter(2); var edge13 = new Edge <int>(1, 3); var edge31 = new Edge <int>(3, 1); var edge32 = new Edge <int>(3, 2); graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge31, edge32 }); // Clear 3 graph.ClearEdges(3); AssertHasEdges(graph, new[] { edge12 }); CheckCounter(3); // Clear 1 = clear graph.ClearEdges(1); AssertNoEdge(graph); CheckCounter(1); #region Local function void CheckCounter(int expectedRemovedEdges) { Assert.AreEqual(expectedRemovedEdges, edgesRemoved); edgesRemoved = 0; } #endregion }
public void ContainsVertex_EquatableVertex() { var graph = new BidirectionalGraph <EquatableTestVertex, Edge <EquatableTestVertex> >(); ContainsVertex_EquatableVertex_Test(graph); }
public void OutEdges() { var graph = new BidirectionalGraph <int, Edge <int> >(); OutEdges_Test(graph); }
public void InEdge() { var graph = new BidirectionalGraph <int, Edge <int> >(); InEdge_Test(graph); }