public static void Clone <TVertex, TEdge>( IVertexAndEdgeListGraph <TVertex, TEdge> g, IMutableVertexAndEdgeListGraph <TVertex, TEdge> clone) where TVertex : ICloneable where TEdge : ICloneableEdge <TVertex> { GraphContracts.AssumeNotNull(g, "g"); GraphContracts.AssumeNotNull(clone, "clone"); var vertexClones = new Dictionary <TVertex, TVertex>(); foreach (var v in g.Vertices) { var vc = (TVertex)v.Clone(); clone.AddVertex(vc); vertexClones.Add(v, vc); } foreach (var edge in g.Edges) { var ec = (TEdge)edge.Clone( vertexClones[edge.Source], vertexClones[edge.Target]); clone.AddEdge(ec); } }
public static bool IsDirectedAcyclicGraph <TVertex, TEdge>(IVertexListGraph <TVertex, TEdge> g) where TEdge : IEdge <TVertex> { GraphContracts.AssumeNotNull(g, "g"); return(new DagTester().IsDag(g)); }
private bool Less(int i, int j) { GraphContracts.Assert(i >= 0 & i < this.count & j >= 0 & j < this.count & i != j, String.Format("i: {0}, j: {1}", i, j)); return(this.priorityComparison(this.items[i].Key, this.items[j].Key) <= 0); }
public void AddEdgeRange(IEnumerable <TEdge> edges)//yes { GraphContracts.AssumeNotNull(edges, "edges"); foreach (var edge in edges) { this.AddEdge(edge); } }
public void Compute(TVertex rootVertex) { GraphContracts.AssumeNotNull(rootVertex, "rootVertex"); // GraphContracts.AssumeInVertexSet(this.VisitedGraph, rootVertex, "rootVertex"); this.SetRootVertex(rootVertex); this.Compute(); }
public void Add(TPriority priority, TValue value) { GraphContracts.Assert(count <= this.items.Length); this.version++; this.ResizeArray(); this.items[this.count++] = new KeyValuePair <TPriority, TValue>(priority, value); this.MinHeapifyDown(this.count - 1); }
public void Serialize(TextWriter writer, IVertexAndEdgeSet <TVertex, TEdge> visitedGraph) { GraphContracts.AssumeNotNull(writer, "writer"); GraphContracts.AssumeNotNull(visitedGraph, "visitedGraph"); using (var xwriter = new XmlTextWriter(writer)) { xwriter.Formatting = Formatting.Indented; Serialize(xwriter, visitedGraph); } }
public static ICollection <TVertex> SourceFirstTopologicalSort <TVertex, TEdge>( IVertexAndEdgeListGraph <TVertex, TEdge> visitedGraph) where TEdge : IEdge <TVertex> { GraphContracts.AssumeNotNull(visitedGraph, "visitedGraph"); var vertices = new List <TVertex>(visitedGraph.VertexCount); SourceFirstTopologicalSort(visitedGraph, vertices); return(vertices); }
private void Swap(int i, int j) { GraphContracts.Assert(i >= 0 & i < this.count & j >= 0 & j < this.count & i != j); var kv = this.items[i]; this.items[i] = this.items[j]; this.items[j] = kv; }
public static void SourceFirstTopologicalSort <TVertex, TEdge>( IVertexAndEdgeListGraph <TVertex, TEdge> visitedGraph, IList <TVertex> vertices) where TEdge : IEdge <TVertex> { GraphContracts.AssumeNotNull(visitedGraph, "visitedGraph"); GraphContracts.AssumeNotNull(vertices, "vertices"); var topo = new SourceFirstTopologicalSortAlgorithm <TVertex, TEdge>(visitedGraph); topo.Compute(vertices); }
public bool ContainsEdge(TEdge edge) //yes { GraphContracts.AssumeInVertexSet(this, edge, "edge"); foreach (var e in this.Edges) { if (e.Equals(edge)) { return(true); } } return(false); }
public static int StronglyConnectedComponents <TVertex, TEdge>( IVertexListGraph <TVertex, TEdge> g, IDictionary <TVertex, int> components) where TEdge : IEdge <TVertex> { GraphContracts.AssumeNotNull(g, "g"); GraphContracts.AssumeNotNull(components, "components"); var conn = new StronglyConnectedComponentsAlgorithm <TVertex, TEdge>(g, components); conn.Compute(); return(conn.ComponentCount); }
public static IEnumerable <TVertex> Roots <TVertex, TEdge>( IBidirectionalGraph <TVertex, TEdge> visitedGraph) where TEdge : IEdge <TVertex> { GraphContracts.AssumeNotNull(visitedGraph, "visitedGraph"); foreach (var v in visitedGraph.Vertices) { if (visitedGraph.IsInEdgesEmpty(v)) { yield return(v); } } }
public void SetRootVertex(TVertex rootVertex) { GraphContracts.AssumeNotNull(rootVertex, "rootVertex"); // GraphContracts.AssumeInVertexSet(this.VisitedGraph, rootVertex, "rootVertex"); bool changed = !Comparison <TVertex> .Equals(this.rootVertex, rootVertex); this.rootVertex = rootVertex; if (changed) { this.OnRooVertexChanged(EventArgs.Empty); } this.hasRootVertex = true; }
public static IEnumerable <TVertex> IsolatedVertices <TVertex, TEdge>( IBidirectionalGraph <TVertex, TEdge> visitedGraph) where TEdge : IEdge <TVertex> { GraphContracts.AssumeNotNull(visitedGraph, "visitedGraph"); foreach (var v in visitedGraph.Vertices) { if (visitedGraph.Degree(v) == 0) { yield return(v); } } }
public void ObjectInvariant() { GraphContracts.Assert(this.items != null); GraphContracts.Assert( this.count > -1 & this.count <= this.items.Length); for (int index = 0; index < this.count; ++index) { var left = 2 * index + 1; GraphContracts.Assert(left >= count || this.Less(index, left)); var right = 2 * index + 2; GraphContracts.Assert(right >= count || this.Less(index, right)); } }
public static IDictionary <TEdge, double> ConstantCapacities <TVertex, TEdge>( IEdgeSet <TVertex, TEdge> g, double value) where TEdge : IEdge <TVertex> { GraphContracts.AssumeNotNull(g, "g"); var capacities = new Dictionary <TEdge, double>(g.EdgeCount); foreach (var e in g.Edges) { capacities.Add(e, value); } return(capacities); }
public static IEnumerable <TVertex> Sinks <TVertex, TEdge>( IVertexListGraph <TVertex, TEdge> visitedGraph) where TEdge : IEdge <TVertex> { GraphContracts.AssumeNotNull(visitedGraph, "visitedGraph"); foreach (var v in visitedGraph.Vertices) { if (visitedGraph.IsOutEdgesEmpty(v)) { yield return(v); } } }
public static int ConnectedComponents <TVertex, TEdge>( IUndirectedGraph <TVertex, TEdge> g, TVertex startVertex, IDictionary <TVertex, int> components) where TEdge : IEdge <TVertex> { GraphContracts.AssumeNotNull(g, "g"); GraphContracts.Assume(g.ContainsVertex(startVertex), "g.ContainsVertex(startVertex)"); GraphContracts.AssumeNotNull(components, "components"); var conn = new ConnectedComponentsAlgorithm <TVertex, TEdge>(g, components); conn.Compute(startVertex); return(conn.ComponentCount); }
public int RemoveEdges(IEnumerable <TEdge> edges) //yes { GraphContracts.AssumeNotNull(edges, "edges"); int count = 0; foreach (var edge in edges) { if (RemoveEdge(edge)) { count++; } } return(count); }
public int RemoveEdgeIf(EdgePredicate <TVertex, TEdge> predicate) { GraphContracts.AssumeNotNull(predicate, "predicate"); List <TEdge> edges = new List <TEdge>(); foreach (var edge in this.Edges) { if (predicate(edge)) { edges.Add(edge); } } return(this.RemoveEdges(edges)); }
/// <summary> /// Does a depth first search on the vertex u /// </summary> /// <param name="se">edge to explore</param> /// <param name="depth">current exploration depth</param> /// <exception cref="ArgumentNullException">se cannot be null</exception> private void Visit(TEdge se, int depth) { GraphContracts.AssumeNotNull(se, "se"); if (depth > this.maxDepth) { return; } // mark edge as gray this.EdgeColors[se] = GraphColor.Gray; // add edge to the search tree OnTreeEdge(se); var cancelManager = this.Services.CancelManager; // iterate over out-edges foreach (var e in this.VisitedGraph.OutEdges(se.Target)) { if (cancelManager.IsCancelling) { return; } // check edge is not explored yet, // if not, explore it. if (!this.EdgeColors.ContainsKey(e)) { OnDiscoverTreeEdge(se, e); Visit(e, depth + 1); } else { GraphColor c = this.EdgeColors[e]; if (EdgeColors[e] == GraphColor.Gray) { OnBackEdge(e); } else { OnForwardOrCrossEdge(e); } } } // all out-edges have been explored this.EdgeColors[se] = GraphColor.Black; OnFinishEdge(se); }
public bool RemoveEdge(TEdge edge)//yes { GraphContracts.AssumeInVertexSet(this, edge, "edge"); /* NotpAssume.IsTrue(this.adjacentEdges.ContainsKey(edge.Source)); */ this.adjacentEdges[edge.Source].Remove(edge); /* NotpAssume.IsTrue(this.adjacentEdges.ContainsKey(edge.Target)); */ if (this.adjacentEdges[edge.Target].Remove(edge)) { this.edgeCount--; System.Diagnostics.Debug.Assert(this.edgeCount >= 0); this.OnEdgeRemoved(new EdgeEventArgs <TVertex, TEdge>(edge)); return(true); } else { return(false); } }
public int RemoveVertexIf(VertexPredicate <TVertex> pred) { GraphContracts.AssumeNotNull(pred, "pred"); List <TVertex> vertices = new List <TVertex>(); foreach (var v in this.Vertices) { if (pred(v)) { vertices.Add(v); } } foreach (var v in vertices) { RemoveVertex(v); } return(vertices.Count); }
public bool AddEdge(TEdge edge)//yes { GraphContracts.AssumeInVertexSet(this, edge, "edge"); if (!this.AllowParallelEdges) { if (this.adjacentEdges[edge.Source].Contains(edge)) { return(false); } } this.adjacentEdges[edge.Source].Add(edge); this.adjacentEdges[edge.Target].Add(edge); this.edgeCount++; this.OnEdgeAdded(new EdgeEventArgs <TVertex, TEdge>(edge)); return(true); }
public int RemoveAdjacentEdgeIf(TVertex v, EdgePredicate <TVertex, TEdge> predicate) { GraphContracts.AssumeInVertexSet(this, v, "v"); GraphContracts.AssumeNotNull(predicate, "predicate"); IList <TEdge> outEdges = this.adjacentEdges[v]; List <TEdge> edges = new List <TEdge>(outEdges.Count); foreach (var edge in outEdges) { if (predicate(edge)) { edges.Add(edge); } } this.RemoveEdges(edges); return(edges.Count); }
public static IEnumerable <TVertex> Roots <TVertex, TEdge>( IVertexListGraph <TVertex, TEdge> visitedGraph) where TEdge : IEdge <TVertex> { GraphContracts.AssumeNotNull(visitedGraph, "visitedGraph"); var dfs = new DepthFirstSearchAlgorithm <TVertex, TEdge>(visitedGraph); var vis = new VertexPredecessorRecorderObserver <TVertex, TEdge>(); vis.Attach(dfs); foreach (var predecessor in vis.VertexPredecessors) { if (predecessor.Value.Equals(default(TEdge))) { yield return(predecessor.Key); } } }
public void ClearAdjacentEdges(TVertex v)//yes { GraphContracts.AssumeInVertexSet(this, v, "v"); List <TEdge> edges = this.adjacentEdges[v]; this.edgeCount -= edges.Count; foreach (var edge in edges) { if (edge.Source.Equals(v)) { this.adjacentEdges[edge.Target].Remove(edge); } else { this.adjacentEdges[edge.Source].Remove(edge); } } System.Diagnostics.Debug.Assert(this.edgeCount >= 0); }
public void Visit(TVertex u, int depth) { GraphContracts.AssumeNotNull(u, "u"); if (depth > this.maxDepth) { return; } VertexColors[u] = GraphColor.Gray; OnDiscoverVertex(u); var cancelManager = this.Services.CancelManager; TVertex v = default(TVertex); foreach (var e in VisitedGraph.OutEdges(u)) { if (cancelManager.IsCancelling) { return; } OnExamineEdge(e); v = e.Target; ProcessEdge(depth, v, e); } foreach (var e in VisitedGraph.InEdges(u)) { if (cancelManager.IsCancelling) { return; } OnExamineEdge(e); v = e.Source; ProcessEdge(depth, v, e); } VertexColors[u] = GraphColor.Black; OnFinishVertex(u); }
public static double ComputePredecessorCost <TVertex, TEdge>( IDictionary <TVertex, TEdge> predecessors, IDictionary <TEdge, double> edgeCosts, TVertex target ) where TEdge : IEdge <TVertex> { GraphContracts.AssumeNotNull(predecessors, "predecessors"); GraphContracts.AssumeNotNull(edgeCosts, "edgeCosts"); double cost = 0; TVertex current = target; TEdge edge; while (predecessors.TryGetValue(current, out edge)) { cost += edgeCosts[edge]; current = edge.Source; } return(cost); }