private void SetChainPositions(VertexListMatrix chains, VertexIntDictionary chain_number, VertexIntDictionary pos_in_chain) // Record chain number and position in chain of each vertex in chains { if (chain_number == null) { throw new ArgumentNullException("chain_number"); } if (pos_in_chain == null) { throw new ArgumentNullException("pos_in_chain"); } for (int i = 0; i < chains.RowCount; i++) { for (int j = 0; j < chains[i].Count; j++) { IVertex v = (IVertex)chains[i][j]; if (!chain_number.ContainsKey(v)) { chain_number.Add(v, i); } if (!pos_in_chain.ContainsKey(v)) { pos_in_chain.Add(v, j); } } } }
/// <summary> /// Create a collection of odd vertices /// </summary> /// <param name="g">graph to visit</param> /// <returns>colleciton of odd vertices</returns> /// <exception cref="ArgumentNullException">g is a null reference</exception> public static VertexCollection OddVertices(IVertexAndEdgeListGraph g) { if (g == null) { throw new ArgumentNullException("g"); } VertexIntDictionary counts = new VertexIntDictionary(); foreach (IVertex v in g.Vertices) { counts[v] = 0; } foreach (IEdge e in g.Edges) { ++counts[e.Source]; --counts[e.Target]; } VertexCollection odds = new VertexCollection(); foreach (DictionaryEntry de in counts) { if ((int)de.Value % 2 != 0) { odds.Add((IVertex)de.Key); } } return(odds); }
protected void Initialize() { this.costs = new VertexDoubleDictionary(); this.priorityQueue = new PriorithizedVertexBuffer(costs); this.unvisitedSuccessorCounts = new VertexIntDictionary(); this.states.Clear(); foreach (IVertex v in this.goals) { this.costs.Add(v, 0); this.priorityQueue.Push(v); } foreach (IVertex v in this.NotGoals) { this.costs.Add(v, double.PositiveInfinity); } foreach (IVertex v in this.TestGraph.ChoicePoints) { this.unvisitedSuccessorCounts.Add(v, this.testGraph.Graph.OutDegree(v)); } foreach (IVertex v in this.TestGraph.Graph.Vertices) { this.states.Add(v, null); } }
public void Init() { m_Parents = new VertexVertexDictionary(); m_DiscoverTimes = new VertexIntDictionary(); m_FinishTimes = new VertexIntDictionary(); m_Time = 0; }
/// <summary> /// Clear the extracted strongly connected components /// </summary> public void ClearComponents() { this.components = null; if (sccVertexMap != null) { sccVertexMap.Clear(); } }
/// <summary> /// /// </summary> /// <param name="g"></param> public ConnectedComponentsAlgorithm(IVertexListGraph g) { if (g == null) { throw new ArgumentNullException("g"); } m_VisitedGraph = g; m_Components = new VertexIntDictionary(); }
/// <summary> /// Computes the strong components. /// </summary> /// <remarks> /// <para> /// Thread safe. /// </para> /// </remarks> /// <param name="g">graph to explore</param> /// <param name="components">component map where results are recorded</param> /// <returns>number of strong components</returns> public static int StrongComponents( IVertexListGraph g, VertexIntDictionary components) { StrongComponentsAlgorithm strong = new StrongComponentsAlgorithm(g, components); return(strong.Compute()); }
/// <summary> /// Computes the connected components. /// </summary> /// <param name="g">graph to explore</param> /// <param name="components">component map where results are recorded</param> /// <returns>number of components</returns> public static int ConnectedComponents( IVertexListGraph g, VertexIntDictionary components) { ConnectedComponentsAlgorithm conn = new ConnectedComponentsAlgorithm(g, components); return(conn.Compute()); }
/// <summary> /// Condensation Graph constructor /// </summary> /// <param name="g">Input graph from /// which condensation graph is created</param> public CondensationGraphAlgorithm(IVertexListGraph g) { if (g == null) { throw new ArgumentNullException("g"); } this.visitedGraph = g; this.components = null; }
/// <summary> /// Uses the dictionary to record the distance /// </summary> /// <param name="distances">Distance dictionary</param> /// <exception cref="ArgumentNullException">distances is null</exception> public DistanceRecorderVisitor(VertexIntDictionary distances) { if (distances == null) { throw new ArgumentNullException("distances"); } m_Distances = distances; }
/// <summary> /// /// </summary> /// <param name="g"></param> /// <param name="capacities"></param> /// <param name="reversedEdges"></param> public PushRelabelMaximumFlowAlgorithm( IIndexedVertexListGraph g, EdgeDoubleDictionary capacities, EdgeEdgeDictionary reversedEdges ) : base(g, capacities, reversedEdges) { this.visitedGraph = g; this.excessFlow = new VertexDoubleDictionary(); this.current = new VertexIntDictionary(); this.distances = new VertexIntDictionary(); }
/// <summary> /// /// </summary> /// <param name="g"></param> public StrongComponentsAlgorithm(IVertexListGraph g) { if (g == null) { throw new ArgumentNullException("g"); } m_VisitedGraph = g; m_Components = new VertexIntDictionary(); m_Roots = new VertexVertexDictionary(); m_DiscoverTimes = new VertexIntDictionary(); m_Stack = new Stack(); m_Count = 0; m_DfsTime = 0; }
/// <summary> /// Constructs a connected component algorithm, using a component map /// </summary> /// <param name="g">graph</param> /// <param name="components">map where the components are recorded</param> /// <exception cref="ArgumentNullException">g or components are null</exception> public ConnectedComponentsAlgorithm(IVertexListGraph g, VertexIntDictionary components) { if (g == null) { throw new ArgumentNullException("g"); } if (components == null) { throw new ArgumentNullException("components"); } this.visitedGraph = g; this.components = components; }
internal void ComputeComponents() { if (components == null) { components = new VertexIntDictionary(); } // components is a MAP containing vertex number as key & component_id as value. It maps every vertex in input graph to SCC vertex ID which contains it StrongComponentsAlgorithm algo = new StrongComponentsAlgorithm( VisitedGraph, this.components ); algo.Compute(); }
/// <summary> /// Construct a strong component algorithm /// </summary> /// <param name="g">graph to apply algorithm on</param> /// <exception cref="ArgumentNullException">graph is null</exception> public StrongComponentsAlgorithm(IVertexListGraph g) { if (g == null) { throw new ArgumentNullException("g"); } this.visitedGraph = g; this.components = new VertexIntDictionary(); this.roots = new VertexVertexDictionary(); this.discoverTimes = new VertexIntDictionary(); this.stack = new Stack(); this.count = 0; this.dfsTime = 0; }
private bool IsOptimal(MaximumFlowAlgorithm maxFlow) { // check if mincut is saturated... FilteredVertexListGraph residualGraph = new FilteredVertexListGraph( maxFlow.VisitedGraph, new ReversedResidualEdgePredicate(maxFlow.ResidualCapacities, maxFlow.ReversedEdges) ); BreadthFirstSearchAlgorithm bfs = new BreadthFirstSearchAlgorithm(residualGraph); VertexIntDictionary distances = new VertexIntDictionary(); DistanceRecorderVisitor vis = new DistanceRecorderVisitor(distances); bfs.RegisterDistanceRecorderHandlers(vis); bfs.Compute(sink); return distances[source] >= maxFlow.VisitedGraph.VerticesCount; }
public void Init() { parents = new VertexVertexDictionary(); discoverTimes = new VertexIntDictionary(); finishTimes = new VertexIntDictionary(); time = 0; g = new BidirectionalGraph(true); dfs = new UndirectedDepthFirstSearchAlgorithm(g); dfs.StartVertex += new VertexEventHandler(this.StartVertex); dfs.DiscoverVertex += new VertexEventHandler(this.DiscoverVertex); dfs.ExamineEdge += new EdgeEventHandler(this.ExamineEdge); dfs.TreeEdge += new EdgeEventHandler(this.TreeEdge); dfs.BackEdge += new EdgeEventHandler(this.BackEdge); dfs.FinishVertex += new VertexEventHandler(this.FinishVertex); }
private void menuItem8_Click(object sender, System.EventArgs e) { if (this.netronPanel.Graph == null) { throw new Exception("Generate a graph first"); } if (this.netronPanel.Populator == null) { throw new Exception("Populator should not be null."); } ResetVertexAndEdgeColors(); // create algorithm this.vertexCounts = new VertexIntDictionary(); this.edgeCounts = new EdgeIntDictionary(); foreach (IVertex vertex in this.netronPanel.Graph.Vertices) { this.vertexCounts[vertex] = 0; } foreach (IEdge edge in this.netronPanel.Graph.Edges) { this.edgeCounts[edge] = 0; } this.edgeWeights = new EdgeDoubleDictionary(); foreach (IEdge edge in this.netronPanel.Graph.Edges) { edgeWeights[edge] = 1; } WeightedMarkovEdgeChain chain = new WeightedMarkovEdgeChain(edgeWeights); RandomWalkAlgorithm walker = new RandomWalkAlgorithm( this.netronPanel.Graph ); walker.TreeEdge += new EdgeEventHandler(walker_WeightedTreeEdge); LayoutAlgorithmTraverVisitor tracer = new LayoutAlgorithmTraverVisitor(this.netronPanel.Populator); walker.TreeEdge += new EdgeEventHandler(tracer.TreeEdge); Thread thread = new Thread(new ThreadStart(walker.Generate)); thread.Start(); }
public void Init() { parents = new VertexVertexDictionary(); discoverTimes = new VertexIntDictionary(); finishTimes = new VertexIntDictionary(); time = 0; g = new AdjacencyGraph(true); dfs = new DepthFirstSearchAlgorithm(g); dfs.StartVertex += new VertexEventHandler(this.StartVertex); dfs.DiscoverVertex += new VertexEventHandler(this.DiscoverVertex); dfs.ExamineEdge += new EdgeEventHandler(this.ExamineEdge); dfs.TreeEdge += new EdgeEventHandler(this.TreeEdge); dfs.BackEdge += new EdgeEventHandler(this.BackEdge); dfs.ForwardOrCrossEdge += new EdgeEventHandler(this.FowardOrCrossEdge); dfs.FinishVertex += new VertexEventHandler(this.FinishVertex); }
private IVertex FirstNotInChain(ArrayList adj_topo_vertices, VertexIntDictionary vertices_in_a_chain) // Return the first adjacent vertex which is not already present in any of the chains { if (adj_topo_vertices == null) { throw new ArgumentNullException("Argument <adj_topo_vertices> in function FirstNotInChain cannot be null"); } if (adj_topo_vertices.Count == 0) { return(null); } foreach (IVertex v in adj_topo_vertices) { if (vertices_in_a_chain[v] == 0) { return(v); } } return(null); }
private ArrayList TopoSortAdjVertices(IVertex v, IIncidenceGraph g, VertexIntDictionary topo_ordering) // return adjacent vertices to "v" sorted in topological order { IEdgeEnumerator it = g.OutEdges(v).GetEnumerator(); bool valid = false; ArrayList adj = new ArrayList(); while (it.MoveNext()) { valid = true; adj.Add(it.Current.Target); } if (!valid) // no outgoing edges { return(adj); } CompareTopo ctopo = new CompareTopo(topo_ordering); SwapTopo stopo = new SwapTopo(); QuickSorter qs = new QuickSorter(ctopo, stopo); qs.Sort(adj); return(adj); }
private SortedList BuildSCCVertexMap(VertexIntDictionary vSccMap) { // Construct a map of SCC ID as key & IVertexCollection of vertices contained within the SCC as value SortedList h = new SortedList(); VertexCollection vertices = null; foreach (DictionaryEntry de in vSccMap) { IVertex v = (IVertex)de.Key; int scc_id = (int)de.Value; if (h.ContainsKey(scc_id)) { ((VertexCollection)h[scc_id]).Add(v); } else { vertices = new VertexCollection(); vertices.Add(v); h.Add(scc_id, vertices); } } return(h); }
public CompareTopo(VertexIntDictionary topological_ordering) { m_vid = topological_ordering; }
/// <summary> /// Compute the transitive closure and store it in the supplied graph 'tc' /// </summary> /// <param name="tc"> /// Mutable Graph instance to store the transitive closure /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="tc"/> is a <null/>. /// </exception> public void Create(IMutableVertexAndEdgeListGraph tc) { if (tc == null) { throw new ArgumentNullException("tc"); } CondensationGraphAlgorithm cgalgo = new CondensationGraphAlgorithm(VisitedGraph); cgalgo.Create(cg); ArrayList topo_order = new ArrayList(cg.VerticesCount); TopologicalSortAlgorithm topo = new TopologicalSortAlgorithm(cg, topo_order); topo.Compute(); VertexIntDictionary in_a_chain = new VertexIntDictionary(); VertexIntDictionary topo_number = new VertexIntDictionary(); for (int order = 0; order < topo_order.Count; order++) { IVertex v = (IVertex)topo_order[order]; topo_number.Add(v, order); if (!in_a_chain.Contains(v)) // Initially no vertex is present in a chain { in_a_chain.Add(v, 0); } } VertexListMatrix chains = new VertexListMatrix(); int position = -1; foreach (IVertex v in topo_order) { if (in_a_chain[v] == 0) { // Start a new chain position = chains.AddRow(); IVertex next = v; for (;;) { chains[position].Add(next); in_a_chain[next] = 1; // Get adjacent vertices ordered by topological number // Extend the chain by choosing the adj vertex with lowest topo# ArrayList adj = TopoSortAdjVertices(next, cg, topo_number); if ((next = FirstNotInChain(adj, in_a_chain)) == null) { break; } } } } VertexIntDictionary chain_number = new VertexIntDictionary(); VertexIntDictionary pos_in_chain = new VertexIntDictionary(); // Record chain positions of vertices SetChainPositions(chains, chain_number, pos_in_chain); VertexListMatrix successors = new VertexListMatrix(); successors.CreateObjectMatrix(cg.VerticesCount, chains.RowCount, int.MaxValue); if (topo_order.Count > 0) { for (int rtopo = topo_order.Count - 1; rtopo > -1; rtopo--) { IVertex u = (IVertex)topo_order[rtopo]; foreach (IVertex v in TopoSortAdjVertices(u, cg, topo_number)) { if (topo_number[v] < (int)successors[u.ID][chain_number[v]]) { // {succ(u)} = {succ(u)} U {succ(v)} LeftUnion(successors[u.ID], successors[v.ID]); // {succ(u)} = {succ(u)} U {v} successors[u.ID][chain_number[v]] = topo_number[v]; } } } } // Create transitive closure of condensation graph // Remove existing edges in CG & rebuild edges for TC from // successor set (to avoid duplicating parallel edges) ArrayList edges = new ArrayList(); foreach (IEdge e in cg.Edges) { edges.Add(e); } foreach (IEdge e in edges) { cg.RemoveEdge(e); } foreach (IVertex u in cg.Vertices) { int i = u.ID; for (int j = 0; j < chains.RowCount; j++) { int tnumber = (int)successors[i][j]; if (tnumber < int.MaxValue) { IVertex v = (IVertex)topo_order[tnumber]; for (int k = pos_in_chain[v]; k < chains[j].Count; k++) { cg.AddEdge(u, (IVertex)chains[j][k]); } } } } // Maps a vertex in input graph to it's transitive closure graph graphTransitiveClosures = new VertexVertexDictionary(); // Add vertices to transitive closure graph foreach (IVertex v in visitedGraph.Vertices) { if (!graphTransitiveClosures.Contains(v)) { IVertex vTransform = tc.AddVertex(); OnInitTransitiveClosureVertex( new TransitiveClosureVertexEventArgs( v, vTransform) ); // Fire the TC Vertex Event graphTransitiveClosures.Add(v, vTransform); } } //Add edges connecting vertices within SCC & adjacent // SCC (strongly connected component) IVertexCollection scc_vertices = null; foreach (IVertex s_tccg in cg.Vertices) { scc_vertices = (IVertexCollection)cgalgo.SCCVerticesMap[s_tccg.ID]; if (scc_vertices.Count > 1) { foreach (IVertex u in scc_vertices) { foreach (IVertex v in scc_vertices) { OnExamineEdge(tc.AddEdge(graphTransitiveClosures[u], graphTransitiveClosures[v])); } } } foreach (IEdge adj_edge in cg.OutEdges(s_tccg)) { IVertex t_tccg = adj_edge.Target; foreach (IVertex s in (IVertexCollection)cgalgo.SCCVerticesMap[s_tccg.ID]) { foreach (IVertex t in (IVertexCollection)cgalgo.SCCVerticesMap[t_tccg.ID]) { OnExamineEdge(tc.AddEdge(graphTransitiveClosures[s], graphTransitiveClosures[t])); } } } } }
public void Init() { m_Parents = new VertexVertexDictionary(); m_Distances = new VertexIntDictionary(); }
/// <summary> /// Default constructor /// </summary> public TimeStamperVisitor() { m_DiscoverTimes = new VertexIntDictionary(); m_FinishTimes = new VertexIntDictionary(); m_Time = 0; }
/// <summary> /// Default constructor /// </summary> public DistanceRecorderVisitor() { m_Distances = new VertexIntDictionary(); }