private void RemoveUnreachableBlocks() { var root = graph.Roots().Single(v => v.IsSpecialBlock); var reachableBlocks = graph.ReachableBlocks(root); var unreachableBlocks = graph.Vertices.Except(reachableBlocks).ToList(); foreach (var unreachableBlock in unreachableBlocks) { graph.RemoveVertex(unreachableBlock); } }
/// <summary> /// /// </summary> /// <param name="node"></param> protected void RemoveNode(NodeVertex node) { if (graph.ContainsVertex(node)) { // TODO Need a better way to removing incoming edges var edgesToRemove = AssociatedObject.EdgesList.Values.Where(x => ((NodeEdge)x.Edge).Source == node || ((NodeEdge)x.Edge).Target == node).ToList(); foreach (var control in edgesToRemove) { var edge = (NodeEdge)control.Edge; graph.RemoveEdge(edge); AssociatedObject.RemoveEdge(edge); } // Disconnect control VertexControl vertexControl; if (AssociatedObject.VertexList.TryGetValue(node, out vertexControl)) { node.DisconnectControl(vertexControl); } // Then remove the vertex graph.RemoveVertex(node); AssociatedObject.RemoveVertex(node); } }
void UpdateVectorsT() { if (this.CGraph.VertexCount == 0) { return; } BidirectionalGraph <Node, Edge> topoGraph = this.CGraph.Clone(); while (topoGraph.VertexCount > 0) { Node current = topoGraph.Vertices.Where(item => topoGraph.InDegree(item) == 0).First(); IEnumerable <Edge> outEdges = topoGraph.Edges.Where(item => item.Source.Equals(current)); foreach (Edge outEdge in outEdges) { Node succ = outEdge.Target; Node successor = this.CGraph.Vertices.Where(v => v.Equals(succ)).Single(); for (int i = 0; i < this.VcCount; i++) { //succ.VectorClock[i] = Math.Max(succ.VectorClock[i], current.VectorClock[i]); successor.VectorClock[i] = Math.Max(successor.VectorClock[i], current.VectorClock[i]); } } topoGraph.RemoveVertex(current); } }
/// <summary> /// Removes the group that is related to the specified ID. /// </summary> /// <param name="group">The ID of the group that should be removed.</param> /// <returns>A task that indicates when the removal has taken place.</returns> public Task Remove(GroupCompositionId group) { { Debug.Assert(group != null, "The ID that should be removed should not be a null reference."); Debug.Assert(m_Groups.ContainsKey(group), "The ID should be known."); } m_Diagnostics.Log( LevelToLog.Trace, HostConstants.LogPrefix, string.Format( CultureInfo.InvariantCulture, Resources.ProxyCompositionLayer_LogMessage_RemovingGroup_WithId, group)); var remoteTask = m_Commands.Remove(group); return(remoteTask.ContinueWith( t => { lock (m_Lock) { if (m_GroupConnections.ContainsVertex(group)) { m_GroupConnections.RemoveVertex(group); } if (m_Groups.ContainsKey(group)) { m_Groups.Remove(group); } } })); }
public RemoveVertexResult <TVertex, TEdge> RemoveVertex(TVertex vertex) { bool vertexWasRemoved; TEdge[] edgesOfRemovedVertex; lock (SyncRoot) { edgesOfRemovedVertex = Graph.GetAllEdges(vertex).ToArray(); vertexWasRemoved = Graph.RemoveVertex(vertex); } if (!vertexWasRemoved) { return(RemoveVertexResult <TVertex, TEdge> .Empty); } foreach (var edge in edgesOfRemovedVertex) { EdgeRemoved?.Invoke(edge); } VertexRemoved?.Invoke(vertex); return(new RemoveVertexResult <TVertex, TEdge>(vertex, edgesOfRemovedVertex)); }
/// <summary> /// Retourne True si outil est supprimé du circuit /// </summary> /// <param name="outil"></param> /// <returns></returns> public bool DeleteComponent(Outils outil) { if (Circuit.ContainsVertex(outil))// Si outil figure dans le circuit { //Mettre à jour les entrées des outils auxquelles l'outil était connecté foreach (var sortie in outil.getListesorties()) { sortie.getSortie().ForEach((outstruct) => { outstruct.GetEntree().setRelated(false); }); } //Mettre à jour les sorties des outils auxquelles l'outil était connecté foreach (var edge in Circuit.InEdges(outil)) { foreach (var sortie in edge.Source.getListesorties()) { sortie.DeleteOustruct(outil); } } Circuit.ClearEdges(outil); Circuit.RemoveVertex(outil); return(true); } else { return(false); } }
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> /// Applies the changes in the current change to the given history object. /// </summary> /// <param name="historyObject">The object to which the changes should be applied.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="historyObject"/> is <see langword="null" />. /// </exception> public void ApplyTo(BidirectionalGraph <TVertex, TEdge> historyObject) { { Lokad.Enforce.Argument(() => historyObject); } historyObject.RemoveVertex(m_Vertex); }
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); } }
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 (SEquatableEdge <int> edge in graph.Edges) { graph.AddEdge(new SEquatableEdge <int>(edge.Target, edge.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); }
public void NextStep() { _steps.Push(_graph.Clone()); var v = _graph.Vertices.First(); _graph.RemoveVertex(v); ShowResults(); if (!_graph.Vertices.Any()) { _hasFinished = true; } }
public void RemoveNode(Node node) { Argument.NotNull(node, nameof(node)); lock (_graph) { if (_graph.RemoveVertex(node)) { _graph.RemoveEdgeIf(link => link.Source == node || link.Target == node); OnGraphChanged(); node.Parent = null; } } }
private void TriggersOnCollectionChanged(object sender, NotifyCollectionChangedEventArgs args) { if (!Dispatcher.CheckAccess()) { Dispatcher.Invoke(() => TriggersOnCollectionChanged(sender, args)); return; } if (args.NewItems != null) { foreach (var item in args.NewItems) { _graph.AddVertex(item); } } if (args.OldItems != null) { foreach (var item in args.OldItems) { _graph.RemoveVertex(item); } } CreateVertices(); }
private void OnRemoveVertexClick(object sender, RoutedEventArgs args) { if (_graph is null || _graph.VertexCount < 1) { return; } var random = new Random(DateTime.Now.Millisecond); for (int i = 0; i < 10 && _graph.VertexCount > 1; ++i) { int index = random.Next(_graph.VertexCount); _graph.RemoveVertex(_graph.Vertices.ElementAt(index)); } }
/// <summary> /// Removes all the plugins related to the given plugin files. /// </summary> /// <param name="deletedFiles">The collection of plugin file paths that were removed.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="deletedFiles"/> is <see langword="null" />. /// </exception> public void RemovePlugins(IEnumerable <string> deletedFiles) { { Lokad.Enforce.Argument(() => deletedFiles); } lock (m_Lock) { var filesToDelete = m_PluginFiles .Join( deletedFiles, pluginFile => pluginFile.Path, filePath => filePath, (pluginFile, filePath) => pluginFile) .ToList(); foreach (var file in filesToDelete) { m_PluginFiles.Remove(file); } var groupsToDelete = m_Groups .Join( filesToDelete, p => p.Value.Item2, file => file, (pair, file) => pair.Key) .ToList(); foreach (var group in groupsToDelete) { m_Groups.Remove(group); } var typesToDelete = m_Parts .Join( filesToDelete, p => p.Value.Item2, file => file, (pair, file) => pair.Key) .ToList(); foreach (var type in typesToDelete) { m_Parts.Remove(type); m_Types.Remove(type); m_TypeGraph.RemoveVertex(type); } } }
private void Reset_Click(object sender, RoutedEventArgs e) { for (int i = 1; i < this.nbVirtex; i++) { g.RemoveVertex(i.ToString()); } nbVirtex = 1; nbVirtexAdded = 1; //addedVir.Clear(); addedVir = new List <int>(); addedVir.Add(0); addV.IsEnabled = false; nbVir.IsEnabled = true; Rem.IsEnabled = false; add.IsEnabled = false; }
private void RemoveVertex_Click(object sender, RoutedEventArgs e) { if (graph == null) { return; } if (graph.VertexCount < 1) { return; } var rnd = new Random(DateTime.Now.Millisecond); for (int i = 0; i < 10 && graph.VertexCount > 1; i++) { graph.RemoveVertex(graph.Vertices.ElementAt(rnd.Next(graph.VertexCount))); } }
public void Repro13160() { // Create a new graph var graph = new BidirectionalGraph <int, Edge <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 Edge <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 Edge <int>(i * 3 + j, (i + 1) * 3 + j)); } } // Create cross edges foreach (Edge <int> edge in graph.Edges) { graph.AddEdge(new Edge <int>(edge.Target, edge.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 randomChain = new Random(123456); var chain = new NormalizedMarkovEdgeChain <int, Edge <int> > { Rand = randomChain }; var randomAlgorithm = new Random(123456); var algorithm = new CyclePoppingRandomTreeAlgorithm <int, Edge <int> >(graph, chain) { Rand = randomAlgorithm }; Assert.DoesNotThrow(() => algorithm.Compute(2)); // Successors is not a spanning tree... }
/// <summary> /// Inserts the given vertex in the position of the given insert vertex. The insert vertex will /// be removed if it has no more inserts left. /// </summary> /// <param name="insertVertex">The vertex which will be replaced.</param> /// <param name="vertexToInsert">The new vertex.</param> /// <returns>A tuple containing the insert vertices that were place before and after the newly inserted vertex.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="insertVertex"/> is <see langword="null" />. /// </exception> /// <exception cref="UnknownScheduleVertexException"> /// Thrown if <paramref name="insertVertex"/> does not exist in the current schedule. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="vertexToInsert"/> is <see langword="null" />. /// </exception> /// <exception cref="CannotInsertExistingVertexException"> /// Thrown if <paramref name="vertexToInsert"/> already exists in the schedule. /// </exception> /// <exception cref="NoInsertsLeftOnVertexException"> /// Thrown if <paramref name="insertVertex"/> has no more inserts left. /// </exception> public Tuple <InsertVertex, InsertVertex> InsertIn( InsertVertex insertVertex, IScheduleVertex vertexToInsert) { { Lokad.Enforce.Argument(() => insertVertex); Lokad.Enforce.With <UnknownScheduleVertexException>( m_Schedule.ContainsVertex(insertVertex), Resources.Exceptions_Messages_UnknownScheduleVertex); Lokad.Enforce.Argument(() => vertexToInsert); Lokad.Enforce.With <CannotInsertExistingVertexException>( !m_Schedule.ContainsVertex(vertexToInsert), Resources.Exceptions_Messages_CannotInsertExistingVertex); Lokad.Enforce.With <NoInsertsLeftOnVertexException>( (insertVertex.RemainingInserts == -1) || (insertVertex.RemainingInserts > 0), Resources.Exceptions_Messages_NoInsertsLeftOnVertex); } // Find the inbound and outbound edges var inbound = from edge in m_Schedule.InEdges(insertVertex) select edge; var outbound = from edge in m_Schedule.OutEdges(insertVertex) select edge; // Add the new node m_Schedule.AddVertex(vertexToInsert); // Create two new insert vertices to be placed on either side of the new vertex var count = (insertVertex.RemainingInserts != -1) ? insertVertex.RemainingInserts - 1 : -1; InsertVertex inboundInsert = null; InsertVertex outboundInsert = null; if ((count == -1) || (count > 0)) { inboundInsert = new InsertVertex(m_Schedule.VertexCount, count); m_Schedule.AddVertex(inboundInsert); m_Schedule.AddEdge(new ScheduleEdge(inboundInsert, vertexToInsert, null)); outboundInsert = new InsertVertex(m_Schedule.VertexCount, count); m_Schedule.AddVertex(outboundInsert); m_Schedule.AddEdge(new ScheduleEdge(vertexToInsert, outboundInsert, null)); } // Reconnect all the edges var inboundTarget = inboundInsert ?? vertexToInsert; var outboundSource = outboundInsert ?? vertexToInsert; foreach (var inboundEdge in inbound) { m_Schedule.AddEdge(new ScheduleEdge(inboundEdge.Source, inboundTarget, inboundEdge.TraversingCondition)); } foreach (var outboundEdge in outbound) { m_Schedule.AddEdge(new ScheduleEdge(outboundSource, outboundEdge.Target, outboundEdge.TraversingCondition)); } // Lastly remove the current insert node, which also destroys all the edges that are // connected to it. m_Schedule.RemoveVertex(insertVertex); return(new Tuple <InsertVertex, InsertVertex>(inboundInsert, outboundInsert)); }
private bool TryRemoveDummyEdge(InternalActivityEdge edge) { bool edgeRemoved = false; // If this is a single edge out or a single edge in - it adds no information to the graph and can be merged. var outDegree = arrowGraph.OutDegree(edge.Source); var inDegree = arrowGraph.InDegree(edge.Target); // Remove the vertex which has no other edges connected to it if (outDegree == 1) { IEnumerable <InternalActivityEdge> allIncoming; if (!arrowGraph.TryGetInEdges(edge.Source, out allIncoming)) { allIncoming = new List <InternalActivityEdge>(); } bool abortMerge = WillParallelEdgesBeCreated(allIncoming, null, edge.Target); if (!abortMerge) { // Add the edges with the new source vertex // And remove the old edges foreach (var incomingEdge in allIncoming.ToList()) { arrowGraph.AddEdge(new InternalActivityEdge(incomingEdge.Source, edge.Target, incomingEdge.IsCritical, incomingEdge.ActivityId)); arrowGraph.RemoveEdge(incomingEdge); } // Remove the edge which is no longer needed arrowGraph.RemoveEdge(edge); // Now remove the vertex which is no longer needed arrowGraph.RemoveVertex(edge.Source); edgeRemoved = true; } } else if (inDegree == 1) { IEnumerable <InternalActivityEdge> allOutgoing; if (!arrowGraph.TryGetOutEdges(edge.Target, out allOutgoing)) { allOutgoing = new List <InternalActivityEdge>(); } bool abortMerge = WillParallelEdgesBeCreated(allOutgoing, edge.Source, null); if (!abortMerge) { // Add the edges with the new source vertex // And remove the old edges foreach (var outgoingEdge in allOutgoing.ToList()) { arrowGraph.AddEdge(new InternalActivityEdge(edge.Source, outgoingEdge.Target, outgoingEdge.IsCritical, outgoingEdge.ActivityId)); arrowGraph.RemoveEdge(outgoingEdge); } // Remove the edge which is no longer needed arrowGraph.RemoveEdge(edge); // Now remove the vertex which is no longer needed arrowGraph.RemoveVertex(edge.Target); edgeRemoved = true; } } return(edgeRemoved); }
public IBidirectionalGraph <Cluster <T>, ClusterEdge <T> > GenerateClusters(IEnumerable <T> dataObjects) { var tree = new BidirectionalGraph <Cluster <T>, ClusterEdge <T> >(false); var clusters = new List <Cluster <T> >(); foreach (T dataObject in dataObjects) { var cluster = new Cluster <T>(dataObject) { Description = dataObject.ToString() }; clusters.Add(cluster); tree.AddVertex(cluster); } var distances = new Dictionary <UnorderedTuple <Cluster <T>, Cluster <T> >, double>(); var heights = new Dictionary <Cluster <T>, double>(); for (int i = 0; i < clusters.Count; i++) { for (int j = i + 1; j < clusters.Count; j++) { double distance = _getDistance(clusters[i].DataObjects.First(), clusters[j].DataObjects.First()); if (double.IsNaN(distance) || double.IsInfinity(distance) || distance < 0) { throw new ArgumentException("Invalid distance between data objects.", "dataObjects"); } distances[UnorderedTuple.Create(clusters[i], clusters[j])] = distance; } heights[clusters[i]] = 0; } while (clusters.Count >= 2) { int minI = 0, minJ = 0; double minDist = double.MaxValue; for (int i = 0; i < clusters.Count; i++) { for (int j = i + 1; j < clusters.Count; j++) { double dist = distances[UnorderedTuple.Create(clusters[i], clusters[j])]; if (dist < minDist) { minDist = dist; minI = i; minJ = j; } } } Cluster <T> iCluster = clusters[minI]; Cluster <T> jCluster = clusters[minJ]; distances.Remove(UnorderedTuple.Create(iCluster, jCluster)); var uCluster = new Cluster <T>(); tree.AddVertex(uCluster); double height = minDist / 2; heights[uCluster] = height; int iCount = tree.GetAllDataObjects(iCluster).Count(); double iLen = height - heights[iCluster]; if (iLen <= 0 && !tree.IsOutEdgesEmpty(iCluster)) { foreach (ClusterEdge <T> edge in tree.OutEdges(iCluster)) { tree.AddEdge(new ClusterEdge <T>(uCluster, edge.Target, edge.Length)); } tree.RemoveVertex(iCluster); } else { tree.RemoveInEdgeIf(iCluster, edge => true); tree.AddEdge(new ClusterEdge <T>(uCluster, iCluster, Math.Max(iLen, 0))); } int jCount = tree.GetAllDataObjects(jCluster).Count(); double jLen = height - heights[jCluster]; if (jLen <= 0 && !tree.IsOutEdgesEmpty(jCluster)) { foreach (ClusterEdge <T> edge in tree.OutEdges(jCluster)) { tree.AddEdge(new ClusterEdge <T>(uCluster, edge.Target, edge.Length)); } tree.RemoveVertex(jCluster); } else { tree.RemoveInEdgeIf(jCluster, edge => true); tree.AddEdge(new ClusterEdge <T>(uCluster, jCluster, Math.Max(jLen, 0))); } double iWeight = (double)iCount / (iCount + jCount); double jWeight = (double)jCount / (iCount + jCount); foreach (Cluster <T> kCluster in clusters.Where(c => c != iCluster && c != jCluster)) { UnorderedTuple <Cluster <T>, Cluster <T> > kiKey = UnorderedTuple.Create(kCluster, iCluster); UnorderedTuple <Cluster <T>, Cluster <T> > kjKey = UnorderedTuple.Create(kCluster, jCluster); distances[UnorderedTuple.Create(uCluster, kCluster)] = (iWeight * distances[kiKey]) + (jWeight * distances[kjKey]); distances.Remove(kiKey); distances.Remove(kjKey); } clusters.RemoveAt(minJ); clusters.RemoveAt(minI); clusters.Add(uCluster); } return(tree); }
public IUndirectedGraph <Cluster <T>, ClusterEdge <T> > GenerateClusters(IEnumerable <T> dataObjects) { var tree = new BidirectionalGraph <Cluster <T>, ClusterEdge <T> >(false); var clusters = new List <Cluster <T> >(); foreach (T dataObject in dataObjects) { var cluster = new Cluster <T>(dataObject) { Description = dataObject.ToString() }; clusters.Add(cluster); tree.AddVertex(cluster); } var distances = new Dictionary <UnorderedTuple <Cluster <T>, Cluster <T> >, double>(); for (int i = 0; i < clusters.Count; i++) { for (int j = i + 1; j < clusters.Count; j++) { double distance = _getDistance(clusters[i].DataObjects.First(), clusters[j].DataObjects.First()); if (double.IsNaN(distance) || double.IsInfinity(distance) || distance < 0) { throw new ArgumentException("Invalid distance between data objects.", "dataObjects"); } distances[UnorderedTuple.Create(clusters[i], clusters[j])] = distance; } } while (clusters.Count > 2) { Dictionary <Cluster <T>, double> r = clusters.ToDictionary(c => c, c => clusters.Where(oc => oc != c).Sum(oc => distances[UnorderedTuple.Create(c, oc)] / (clusters.Count - 2))); int minI = 0, minJ = 0; double minDist = 0, minQ = double.MaxValue; for (int i = 0; i < clusters.Count; i++) { for (int j = i + 1; j < clusters.Count; j++) { double dist = distances[UnorderedTuple.Create(clusters[i], clusters[j])]; double q = dist - r[clusters[i]] - r[clusters[j]]; if (q < minQ) { minQ = q; minDist = dist; minI = i; minJ = j; } } } Cluster <T> iCluster = clusters[minI]; Cluster <T> jCluster = clusters[minJ]; distances.Remove(UnorderedTuple.Create(iCluster, jCluster)); var uCluster = new Cluster <T>(); tree.AddVertex(uCluster); double iLen = (minDist / 2) + ((r[iCluster] - r[jCluster]) / 2); if (iLen <= 0 && !tree.IsOutEdgesEmpty(iCluster)) { foreach (ClusterEdge <T> edge in tree.OutEdges(iCluster)) { tree.AddEdge(new ClusterEdge <T>(uCluster, edge.Target, edge.Length)); } tree.RemoveVertex(iCluster); } else { tree.RemoveInEdgeIf(iCluster, edge => true); tree.AddEdge(new ClusterEdge <T>(uCluster, iCluster, Math.Max(iLen, 0))); } double jLen = minDist - iLen; if (jLen <= 0 && !tree.IsOutEdgesEmpty(jCluster)) { foreach (ClusterEdge <T> edge in tree.OutEdges(jCluster)) { tree.AddEdge(new ClusterEdge <T>(uCluster, edge.Target, edge.Length)); } tree.RemoveVertex(jCluster); } else { tree.RemoveInEdgeIf(jCluster, edge => true); tree.AddEdge(new ClusterEdge <T>(uCluster, jCluster, Math.Max(jLen, 0))); } foreach (Cluster <T> kCluster in clusters.Where(c => c != iCluster && c != jCluster)) { UnorderedTuple <Cluster <T>, Cluster <T> > kiKey = UnorderedTuple.Create(kCluster, iCluster); UnorderedTuple <Cluster <T>, Cluster <T> > kjKey = UnorderedTuple.Create(kCluster, jCluster); distances[UnorderedTuple.Create(kCluster, uCluster)] = (distances[kiKey] + distances[kjKey] - minDist) / 2; distances.Remove(kiKey); distances.Remove(kjKey); } clusters.RemoveAt(minJ); clusters.RemoveAt(minI); clusters.Add(uCluster); } if (clusters.Count == 2) { tree.AddEdge(new ClusterEdge <T>(clusters[1], clusters[0], distances[UnorderedTuple.Create(clusters[0], clusters[1])])); clusters.RemoveAt(0); } var unrootedTree = new UndirectedGraph <Cluster <T>, ClusterEdge <T> >(false); unrootedTree.AddVertexRange(tree.Vertices); unrootedTree.AddEdgeRange(tree.Edges); return(unrootedTree); }
private void ClearGraph() { _root?.PostOrderTreeTraversal((parent, child) => _graph.RemoveVertex(child.ToString())); }
public void RemoveNode(string nodeID) { graph.RemoveVertex(nodeID); }