/// <summary> /// Returns with the adjacent vertices of the <code>vertex</code>. /// </summary> /// <param name="g">The graph.</param> /// <param name="vertex">The vertex which neighbours' we want to get.</param> /// <returns>List of the adjacent vertices of the <code>vertex</code>.</returns> public static IEnumerable <TVertex> GetNeighbours <TVertex, TEdge>(this IBidirectionalGraph <TVertex, TEdge> g, TVertex vertex) where TEdge : IEdge <TVertex> { return(((from e in g.InEdges(vertex) select e.Source) .Concat( (from e in g.OutEdges(vertex) select e.Target))).Distinct()); }
private static void CollectAdjacentVerticesRecursive <TVertex, TEdge>(IBidirectionalGraph <TVertex, TEdge> graph, TVertex vertex, EdgeDirection direction, ICollection <TVertex> collectedVertices, EdgePredicate <TVertex, TEdge> edgePredicate = null, bool recursive = false) where TEdge : IEdge <TVertex> { var adjacentEdges = direction == EdgeDirection.In ? graph.InEdges(vertex) : graph.OutEdges(vertex); var adjacentVertices = adjacentEdges .Where(edge => edgePredicate == null || edgePredicate(edge)) .Select(edge => edge.GetOtherEnd(vertex)) .Distinct(); foreach (var adjacentVertex in adjacentVertices) { // Loop detection if (collectedVertices.Contains(adjacentVertex)) { continue; } collectedVertices.Add(adjacentVertex); if (recursive) { CollectAdjacentVerticesRecursive(graph, adjacentVertex, direction, collectedVertices, edgePredicate, recursive: true); } } }
protected static IMutableBidirectionalGraph <T, IEdge <T> > GetSubGraphTo(IBidirectionalGraph <T, IEdge <T> > graph, T target) { var result = new BidirectionalGraph <T, IEdge <T> >(); var visited = new HashSet <T>(new IdentityComparer <T>()); var toVisit = new Queue <T>(); toVisit.Enqueue(target); while (toVisit.Count > 0) { var node = toVisit.Dequeue(); var inEdges = graph.InEdges(node); visited.Add(node); result.AddVertex(node); foreach (var inEdge in inEdges) { if (!visited.Contains(inEdge.Source)) { toVisit.Enqueue(inEdge.Source); } result.AddVerticesAndEdge(inEdge); } } return(result); }
public IEnumerable <IAction> GetPrevActions(IAction action) { if (action == null) { throw new ArgumentNullException("action"); } return(_graph.InEdges(action).Select(x => x.Source)); }
public static IEnumerable <TEdge> GetEdges <TVertex, TEdge>( this IBidirectionalGraph <TVertex, TEdge> graph, TVertex vertex, EdgeDirection edgeDirection) where TEdge : IEdge <TVertex> { return(edgeDirection == EdgeDirection.In ? graph.InEdges(vertex) : graph.OutEdges(vertex)); }
private IEnumerable <IVertex3D> getConnectedVertices(IVertex3D vertex3D) { return(graph.OutEdges((TVertex)vertex3D).Select(e => e.Target).Cast <IVertex3D>() .Union( graph.InEdges((TVertex)vertex3D).Select(e => e.Source).Cast <IVertex3D>() ) ); }
public static IEnumerable <TVertex> GetNeighbors <TVertex, TEdge>( [NotNull] this IBidirectionalGraph <TVertex, TEdge> graph, [NotNull] TVertex vertex) where TEdge : IEdge <TVertex> { return(graph.InEdges(vertex).Select(e => e.Source) .Concat(graph.OutEdges(vertex).Select(e => e.Target)) .Distinct()); }
/// <summary> /// Constructs a new ArrayBidirectionalGraph instance from a /// IBidirectionalGraph instance /// </summary> /// <param name="visitedGraph"></param> public ArrayBidirectionalGraph( IBidirectionalGraph <TVertex, TEdge> visitedGraph ) { Contract.Requires(visitedGraph != null); this.vertexEdges = new Dictionary <TVertex, InOutEdges>(visitedGraph.VertexCount); this.edgeCount = visitedGraph.EdgeCount; foreach (var vertex in visitedGraph.Vertices) { var outEdges = Enumerable.ToArray(visitedGraph.OutEdges(vertex)); var inEdges = Enumerable.ToArray(visitedGraph.InEdges(vertex)); this.vertexEdges.Add(vertex, new InOutEdges(outEdges, inEdges)); } }
/// <summary> /// Initializes a new instance of the <see cref="ArrayBidirectionalGraph{TVertex,TEdge}"/> class. /// </summary> /// <param name="baseGraph">Wrapped graph.</param> /// <exception cref="T:System.ArgumentNullException"><paramref name="baseGraph"/> is <see langword="null"/>.</exception> public ArrayBidirectionalGraph([NotNull] IBidirectionalGraph<TVertex, TEdge> baseGraph) { if (baseGraph is null) throw new ArgumentNullException(nameof(baseGraph)); AllowParallelEdges = baseGraph.AllowParallelEdges; _vertexEdges = new Dictionary<TVertex, InOutEdges>(baseGraph.VertexCount); EdgeCount = baseGraph.EdgeCount; foreach (TVertex vertex in baseGraph.Vertices) { TEdge[] outEdges = baseGraph.OutEdges(vertex).ToArray(); TEdge[] inEdges = baseGraph.InEdges(vertex).ToArray(); _vertexEdges.Add(vertex, new InOutEdges(outEdges, inEdges)); } }
/// <summary> /// Initializes a new instance of the <see cref="ArrayBidirectionalGraph{TVertex,TEdge}"/> class. /// </summary> /// <param name="visitedGraph">Graph to visit.</param> public ArrayBidirectionalGraph([NotNull] IBidirectionalGraph <TVertex, TEdge> visitedGraph) { if (visitedGraph is null) { throw new ArgumentNullException(nameof(visitedGraph)); } _vertexEdges = new Dictionary <TVertex, InOutEdges>(visitedGraph.VertexCount); EdgeCount = visitedGraph.EdgeCount; foreach (var vertex in visitedGraph.Vertices) { var outEdges = visitedGraph.OutEdges(vertex).ToArray(); var inEdges = visitedGraph.InEdges(vertex).ToArray(); _vertexEdges.Add(vertex, new InOutEdges(outEdges, inEdges)); } }
/// <summary> /// /// </summary> /// <param name="g"></param> /// <param name="assg"></param> public void Transform(IBidirectionalGraph g, IMutableVertexAndEdgeListGraph assg) { VertexCollection avs = new VertexCollection(); // adding vertices foreach (IEdge e in g.Edges) { // xi_-(L) = g(xi_-(0), xi_+(L)) CharacteristicVertex avm = (CharacteristicVertex)assg.AddVertex(); avm.IncomingEdge = e; avm.Vertex = e.Target; avs.Add(avm); // xi_+(0) = g(xi_-(0), xi_+(L)) CharacteristicVertex avp = (CharacteristicVertex)assg.AddVertex(); avp.IncomingEdge = e; avp.Vertex = e.Source; avs.Add(avp); } // adding out edges foreach (CharacteristicVertex av in avs) { foreach (IEdge e in g.OutEdges(av.Vertex)) { // find target vertex: CharacteristicVertex avtarget = FindTargetVertex(e); // add xi_- CharacteristicEdge aem = (CharacteristicEdge)assg.AddEdge(av, avtarget); aem.Positive = false; aem.Edge = e; } foreach (IEdge e in g.InEdges(av.Vertex)) { // find target vertex: CharacteristicVertex avtarget = FindTargetVertex(e); // add xi_- CharacteristicEdge aem = (CharacteristicEdge)assg.AddEdge(av, avtarget); aem.Positive = true; aem.Edge = e; } } }
public static void BidirectionalContainsEdgeAssertions( [NotNull] IBidirectionalGraph <int, IEdge <int> > graph, [NotNull] IEdge <int> e12, [NotNull] IEdge <int> f12, [CanBeNull] IEdge <int> e21, [CanBeNull] IEdge <int> f21) { Assert.AreEqual(0, graph.InDegree(1)); Assert.AreEqual(1, graph.OutDegree(1)); Assert.AreEqual(1, graph.InDegree(2)); Assert.AreEqual(0, graph.OutDegree(2)); Assert.AreEqual(1, graph.OutEdges(1).Count()); Assert.AreEqual(1, graph.InEdges(2).Count()); // e12 must be present in u, because we added it. Assert.IsTrue(graph.ContainsEdge(e12)); // f12 is also in u, because e12 == f12. Assert.IsTrue(graph.ContainsEdge(f12)); // e21 and f21 are not in u, because it's a directed graph. if (e21 != null) { Assert.IsFalse(graph.ContainsEdge(e21)); } if (f21 != null) { Assert.IsFalse(graph.ContainsEdge(f21)); } // There must be an edge between vertices 1, 2. Assert.IsTrue(graph.ContainsEdge(1, 2)); // No edge between vertices 2, 1, because the graph is directed. Assert.IsFalse(graph.ContainsEdge(2, 1)); // ContainsEdge(1, 3) raises contracts violation in IncidenceGraphContract, because 3 is not in the graph. // obviously no edge between vertices 1, 3, as vertex 3 is not even present in the graph. // Assert.IsFalse(g.ContainsEdge(1, 3)); }
private CFGTaintInfo AnalyzeNode2(CFGBlock block, IBidirectionalGraph <CFGBlock, TaggedEdge <CFGBlock, EdgeTag> > graph) { var oldTaint = Taints[block]; var predecessorsOut = graph.InEdges(block); var outTaints = predecessorsOut.Select(p => new { EdgeType = p.Tag, Source = p.Source }) .Where(s => Taints[s.Source].Out != null && Taints[s.Source].Out.Any()) .Select(s => Taints[s.Source].Out[s.EdgeType.EdgeType]) .Where(o => o != null); ImmutableVariableStorage newInTaint; if (outTaints.Any()) { newInTaint = oldTaint.In.Merge(outTaints.Aggregate((current, next) => current.Merge(next))); } else { newInTaint = oldTaint.In; } ImmutableDictionary <EdgeType, ImmutableVariableStorage> newOutTaint; if (block.AstEntryNode == null) { newOutTaint = ImmutableDictionary <EdgeType, ImmutableVariableStorage> .Empty.Add(EdgeType.Normal, newInTaint); } else { var newOut = _blockAnalyzer.Analyze(block.AstEntryNode, newInTaint); var newOutWithCondSani = _conditionTaintAnalyser.AnalyzeCond(block.AstEntryNode, newOut); newOutTaint = newOutWithCondSani.ToImmutableDictionary(); } return(new CFGTaintInfo(newInTaint, newOutTaint)); }
public static void ContainsEdgeAssertions(IBidirectionalGraph<int, IEdge<int>> g, IEdge<int> e12, IEdge<int> f12, IEdge<int> e21, IEdge<int> f21) { Assert.AreEqual(0, g.InDegree(1)); Assert.AreEqual(1, g.OutDegree(1)); Assert.AreEqual(1, g.InDegree(2)); Assert.AreEqual(0, g.OutDegree(2)); Assert.AreEqual(1, g.OutEdges(1).Count()); Assert.AreEqual(1, g.InEdges(2).Count()); // e12 must be present in u, because we added it. Assert.IsTrue(g.ContainsEdge(e12)); // f12 is also in u, because e12 == f12. Assert.IsTrue(g.ContainsEdge(f12)); // e21 and f21 are not in u, because it's a directed graph. if (e21 != null) Assert.IsFalse(g.ContainsEdge(e21)); if (f21 != null) Assert.IsFalse(g.ContainsEdge(f21)); // there must be an edge between vertices 1, 2. Assert.IsTrue(g.ContainsEdge(1, 2)); // no edge between vertices 2, 1, because the graph is directed. Assert.IsFalse(g.ContainsEdge(2, 1)); // ContainsEdge(1, 3) raises contracts violation in IIncidenceGraphContract, because 3 is not in the graph. // obviously no edge between vertices 1, 3, as vertex 3 is not even present in the graph. // Assert.IsFalse(g.ContainsEdge(1, 3)); }
/// <summary> /// /// </summary> /// <param name="g"></param> /// <param name="assg"></param> public void Transform(IBidirectionalGraph g, IMutableVertexAndEdgeListGraph assg) { VertexCollection avs = new VertexCollection(); // adding vertices foreach(IEdge e in g.Edges) { // xi_-(L) = g(xi_-(0), xi_+(L)) CharacteristicVertex avm = (CharacteristicVertex)assg.AddVertex(); avm.IncomingEdge = e; avm.Vertex = e.Target; avs.Add(avm); // xi_+(0) = g(xi_-(0), xi_+(L)) CharacteristicVertex avp = (CharacteristicVertex)assg.AddVertex(); avp.IncomingEdge = e; avp.Vertex = e.Source; avs.Add(avp); } // adding out edges foreach(CharacteristicVertex av in avs) { foreach(IEdge e in g.OutEdges(av.Vertex)) { // find target vertex: CharacteristicVertex avtarget = FindTargetVertex(e); // add xi_- CharacteristicEdge aem = (CharacteristicEdge)assg.AddEdge(av,avtarget); aem.Positive = false; aem.Edge = e; } foreach(IEdge e in g.InEdges(av.Vertex)) { // find target vertex: CharacteristicVertex avtarget = FindTargetVertex(e); // add xi_- CharacteristicEdge aem = (CharacteristicEdge)assg.AddEdge(av,avtarget); aem.Positive = true; aem.Edge = e; } } }
public IEnumerable <TaggedEdge <CFGBlock, EdgeTag> > NextEdges(IBidirectionalGraph <CFGBlock, TaggedEdge <CFGBlock, EdgeTag> > graph, CFGBlock block) { return(graph.InEdges(block)); }
public static IEnumerable <TVertex> GetInNeighbours <TVertex, TEdge>( this IBidirectionalGraph <TVertex, TEdge> graph, TVertex vertex) where TEdge : IEdge <TVertex> { return(graph.InEdges(vertex).Select(e => e.Source).Distinct()); }
private CFGTaintInfo AnalyzeNode2(CFGBlock block, IBidirectionalGraph<CFGBlock, TaggedEdge<CFGBlock, EdgeTag>> graph) { var oldTaint = Taints[block]; var predecessorsOut = graph.InEdges(block); var outTaints = predecessorsOut.Select(p => new { EdgeType = p.Tag, Source = p.Source }) .Where(s => Taints[s.Source].Out != null && Taints[s.Source].Out.Any()) .Select(s => Taints[s.Source].Out[s.EdgeType.EdgeType]) .Where(o => o != null); ImmutableVariableStorage newInTaint; if (outTaints.Any()) { newInTaint = oldTaint.In.Merge(outTaints.Aggregate((current, next) => current.Merge(next))); } else { newInTaint = oldTaint.In; } ImmutableDictionary<EdgeType, ImmutableVariableStorage> newOutTaint; if (block.AstEntryNode == null) { newOutTaint = ImmutableDictionary<EdgeType, ImmutableVariableStorage>.Empty.Add(EdgeType.Normal, newInTaint); } else { var newOut = _blockAnalyzer.Analyze(block.AstEntryNode, newInTaint); var newOutWithCondSani = _conditionTaintAnalyser.AnalyzeCond(block.AstEntryNode, newOut); newOutTaint = newOutWithCondSani.ToImmutableDictionary(); } return new CFGTaintInfo(newInTaint, newOutTaint); }
public static IEnumerable <TEdge> GetAllEdges <TVertex, TEdge>(this IBidirectionalGraph <TVertex, TEdge> graph, TVertex vertex) where TEdge : IEdge <TVertex> { return(graph.InEdges(vertex).Union(graph.OutEdges(vertex))); }
public IEnumerable<TaggedEdge<CFGBlock, EdgeTag>> NextEdges(IBidirectionalGraph<CFGBlock, TaggedEdge<CFGBlock, EdgeTag>> graph, CFGBlock block) { return graph.InEdges(block); }