public void DoCallback() { using (Socket s_d = this.s) using (Socket s_tar_d = this.s_tar) using (var bqSS = new BinaryQueue(true)) using (var bqS = new BinaryQueue(true)) { try { new Thread(() => { rcvLoop(s_d, bqS, ref DoExit); }).Start(); new Thread(() => { rcvLoop(s_tar_d, bqSS, ref DoExit); }).Start(); new Thread(() => { sndLoop(s_tar_d, bqS, ref DoExit); }).Start(); new Thread(() => { sndLoop(s_d, bqSS, ref DoExit); }).Start(); while (!DoExit) { Thread.Sleep(250); } } catch { DoExit = true; } } }
/// <inheritdoc /> protected override void InternalCompute() { var sets = new ForestDisjointSet <TVertex>(VisitedGraph.VertexCount); foreach (TVertex vertex in VisitedGraph.Vertices) { sets.MakeSet(vertex); } ThrowIfCancellationRequested(); var queue = new BinaryQueue <TEdge, double>(_edgeWeights); foreach (TEdge edge in VisitedGraph.Edges) { queue.Enqueue(edge); } ThrowIfCancellationRequested(); while (queue.Count > 0) { TEdge edge = queue.Dequeue(); OnExamineEdge(edge); if (!sets.AreInSameSet(edge.Source, edge.Target)) { OnTreeEdge(edge); sets.Union(edge.Source, edge.Target); } } }
void sndLoop(Socket socO, BinaryQueue bq, ref bool DoExit) { try { using (var stream = new NetworkStream(socO)) using (var bstream = new BufferedStream(stream)) while (true) { var b = bq.GetBlock(); if (b.Length <= 0) { Thread.Sleep(1); continue; } bstream.Write(b, 0, b.Length); bstream.Flush(); } } catch (Exception e) { //Console.WriteLine("Disconnected"); // throw; } finally { DoExit = true; } }
public UndirectedFirstTopologicalSortAlgorithm( IUndirectedGraph <TVertex, TEdge> visitedGraph ) : base(visitedGraph) { this.heap = new BinaryQueue <TVertex, int>(e => this.degrees[e]); }
protected override void InternalCompute() { var cancelManager = this.Services.CancelManager; var ds = new ForestDisjointSet<TVertex>(this.VisitedGraph.VertexCount); foreach (var v in this.VisitedGraph.Vertices) ds.MakeSet(v); if (cancelManager.IsCancelling) return; var queue = new BinaryQueue<TEdge, double>(this.edgeWeights); foreach (var e in this.VisitedGraph.Edges) queue.Enqueue(e); if (cancelManager.IsCancelling) return; while (queue.Count > 0) { var e = queue.Dequeue(); this.OnExamineEdge(e); if (!ds.AreInSameSet(e.Source, e.Target)) { this.OnTreeEdge(e); ds.Union(e.Source, e.Target); } } }
public SourceFirstTopologicalSortAlgorithm( IVertexAndEdgeListGraph <TVertex, TEdge> visitedGraph ) : base(visitedGraph) { this.heap = new BinaryQueue <TVertex, int>(e => this.inDegrees[e]); }
/// <summary> /// Initializes a new instance of the <see cref="SourceFirstBidirectionalTopologicalSortAlgorithm{TVertex,TEdge}"/> class. /// </summary> /// <param name="visitedGraph">Graph to visit.</param> /// <param name="direction">Sort direction.</param> public SourceFirstBidirectionalTopologicalSortAlgorithm( [NotNull] IBidirectionalGraph <TVertex, TEdge> visitedGraph, TopologicalSortDirection direction) : base(visitedGraph) { _direction = direction; _heap = new BinaryQueue <TVertex, int>(vertex => InDegrees[vertex]); }
/// <summary> /// Initializes a new instance of the <see cref="SourceFirstTopologicalSortAlgorithm{TVertex,TEdge}"/> class. /// </summary> /// <param name="visitedGraph">Graph to visit.</param> /// <param name="capacity">Sorted vertices capacity.</param> public SourceFirstTopologicalSortAlgorithm( [NotNull] IVertexAndEdgeListGraph <TVertex, TEdge> visitedGraph, int capacity = -1) : base(visitedGraph) { _heap = new BinaryQueue <TVertex, int>(vertex => InDegrees[vertex]); _sortedVertices = capacity > 0 ? new List <TVertex>(capacity) : new List <TVertex>(); }
/// <summary> /// Initializes a new instance of the <see cref="UndirectedFirstTopologicalSortAlgorithm{TVertex,TEdge}"/> class. /// </summary> /// <param name="visitedGraph">Graph to visit.</param> /// <param name="capacity">Sorted vertices capacity.</param> public UndirectedFirstTopologicalSortAlgorithm( IUndirectedGraph <TVertex, TEdge> visitedGraph, int capacity = -1) : base(visitedGraph) { _heap = new BinaryQueue <TVertex, int>(vertex => Degrees[vertex]); _sortedVertices = capacity > 0 ? new List <TVertex>(capacity) : new List <TVertex>(); }
public SourceFirstBidirectionalTopologicalSortAlgorithm( IBidirectionalGraph <TVertex, TEdge> visitedGraph, TopologicalSortDirection direction ) : base(visitedGraph) { this.direction = direction; this.heap = new BinaryQueue <TVertex, int>(e => this.predCounts[e]); }
/// <summary> /// /// </summary> protected AbstractRcpConnection() { MessageBuilder = new TMessageBuilder(); m_messageId = -1; m_messageLength = -1; m_messageData = new BinaryQueue(); OnMessageEvent += OnMessage; }
/// <summary> /// Initializes a new instance of the <see cref="SourceFirstBidirectionalTopologicalSortAlgorithm{TVertex,TEdge}"/> class. /// </summary> /// <param name="visitedGraph">Graph to visit.</param> /// <param name="direction">Sort direction.</param> /// <param name="capacity">Sorted vertices capacity.</param> public SourceFirstBidirectionalTopologicalSortAlgorithm( [NotNull] IBidirectionalGraph <TVertex, TEdge> visitedGraph, TopologicalSortDirection direction, int capacity = -1) : base(visitedGraph) { _direction = direction; _heap = new BinaryQueue <TVertex, int>(vertex => InDegrees[vertex]); _sortedVertices = capacity > 0 ? new List <TVertex>(capacity) : new List <TVertex>(); }
public void ToString2() { ToStringTest(1, 2, 3, 4); ToStringTest( new TestVertex("1"), new TestVertex("2"), new TestVertex("3"), new TestVertex("4")); ToStringTest( new EquatableTestVertex("1"), new EquatableTestVertex("2"), new EquatableTestVertex("3"), new EquatableTestVertex("4")); #region Local function void ToStringTest <TVertex>( TVertex vertex1, TVertex vertex2, TVertex vertex3, TVertex vertex4) { var queue = new BinaryQueue <TVertex, double>(_ => 1.0); // Empty heap => consistent StringAssert.StartsWith(Consistent, queue.ToString2()); queue.Enqueue(vertex1); queue.Enqueue(vertex2); queue.Enqueue(vertex2); queue.Enqueue(vertex3); queue.Enqueue(vertex1); StringAssert.StartsWith(Consistent, queue.ToString2()); queue.Dequeue(); queue.Dequeue(); StringAssert.StartsWith(Consistent, queue.ToString2()); queue.Dequeue(); queue.Dequeue(); queue.Dequeue(); StringAssert.StartsWith(Consistent, queue.ToString2()); queue.Enqueue(vertex4); StringAssert.StartsWith(Consistent, queue.ToString2()); } #endregion }
private void InitializeQueue() { _edges = new HashSet <TEdge>(); _queue = new BinaryQueue <TEdge, double>(_edgeWeights); TVertex lastVertex = _visitedVertices.First(); foreach (TEdge edge in _verticesEdges[lastVertex]) { if (!_edges.Contains(edge)) { _edges.Add(edge); _queue.Enqueue(edge); } } }
void rcvLoop(Socket socI, BinaryQueue bq, ref bool DoExit) { try { using (var stream = new NetworkStream(socI)) using (var bstream = new BufferedStream(stream)) bstream.CopyTo(bq); } catch (Exception e) { //Console.WriteLine("Disconnected"); // throw; } finally { DoExit = true; } }
public void Constructor_Throws() { // ReSharper disable ObjectCreationAsStatement // ReSharper disable AssignNullToNotNullAttribute var graph = new UndirectedGraph <int, Edge <int> >(); var verticesColors = new Dictionary <int, GraphColor>(); var queue = new BinaryQueue <int, double>(vertex => 1.0); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, queue, verticesColors)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(graph, null, verticesColors)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(graph, queue, null)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, verticesColors)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, queue, null)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(graph, null, null)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, null)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, queue, verticesColors)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, null, verticesColors)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, queue, null)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, null, verticesColors)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, queue, null)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, null, null)); Assert.Throws <ArgumentNullException>( () => new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, null, null)); // ReSharper restore AssignNullToNotNullAttribute // ReSharper restore ObjectCreationAsStatement }
public void Constructor() { var graph = new AdjacencyGraph <int, Edge <int> >(); var algorithm = new BreadthFirstSearchAlgorithm <int, Edge <int> >(graph); AssertAlgorithmProperties(algorithm, graph); var verticesColors = new Dictionary <int, GraphColor>(); var queue = new BinaryQueue <int, double>(_ => 1.0); algorithm = new BreadthFirstSearchAlgorithm <int, Edge <int> >(graph, queue, verticesColors); AssertAlgorithmProperties(algorithm, graph, verticesColors); algorithm = new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, queue, verticesColors); AssertAlgorithmProperties(algorithm, graph, verticesColors); algorithm = new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, queue, verticesColors, edges => edges.Where(e => e != null)); AssertAlgorithmProperties(algorithm, graph, verticesColors); #region Local function void AssertAlgorithmProperties <TVertex, TEdge>( BreadthFirstSearchAlgorithm <TVertex, TEdge> algo, IVertexListGraph <TVertex, TEdge> g, IDictionary <TVertex, GraphColor> vColors = null) where TEdge : IEdge <TVertex> { AssertAlgorithmState(algo, g); if (vColors is null) { CollectionAssert.IsEmpty(algo.VerticesColors); } else { Assert.AreSame(vColors, algo.VerticesColors); } Assert.IsNotNull(algo.OutEdgesFilter); } #endregion }
/// <inheritdoc /> protected override void InternalCompute() { ICancelManager cancelManager = Services.CancelManager; var sets = new ForestDisjointSet <TVertex>(VisitedGraph.VertexCount); foreach (TVertex vertex in VisitedGraph.Vertices) { sets.MakeSet(vertex); } if (cancelManager.IsCancelling) { return; } var queue = new BinaryQueue <TEdge, double>(_edgeWeights); foreach (TEdge edge in VisitedGraph.Edges) { queue.Enqueue(edge); } if (cancelManager.IsCancelling) { return; } while (queue.Count > 0) { TEdge edge = queue.Dequeue(); OnExamineEdge(edge); if (!sets.AreInSameSet(edge.Source, edge.Target)) { OnTreeEdge(edge); sets.Union(edge.Source, edge.Target); } } }
/// <summary> /// Runs the algorithm. /// </summary> /// <returns>Found paths.</returns> public IEnumerable <SortedPath> Execute() { SortedPath initialPath = GetInitialShortestPath(); var shortestPaths = new List <SortedPath> { initialPath }; // Initialize the set to store the potential k-th shortest path var shortestPathCandidates = new BinaryQueue <SortedPath, double>(GetPathDistance); for (int k = 1; k < _k; ++k) { SortedPath previousPath = shortestPaths[k - 1]; if (!SearchAndAddKthShortestPath(previousPath, shortestPaths, shortestPathCandidates)) { break; } } return(_filter(shortestPaths)); }
public void Constructor() { var graph = new UndirectedGraph <int, Edge <int> >(); var algorithm = new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(graph); AssertAlgorithmProperties(algorithm, graph); var verticesColors = new Dictionary <int, GraphColor>(); var queue = new BinaryQueue <int, double>(vertex => 1.0); algorithm = new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(graph, queue, verticesColors); AssertAlgorithmProperties(algorithm, graph, verticesColors); algorithm = new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, queue, verticesColors); AssertAlgorithmProperties(algorithm, graph, verticesColors); #region Local function void AssertAlgorithmProperties <TVertex, TEdge>( UndirectedBreadthFirstSearchAlgorithm <TVertex, TEdge> algo, IUndirectedGraph <TVertex, TEdge> g, IDictionary <TVertex, GraphColor> vColors = null) where TEdge : IEdge <TVertex> { AssertAlgorithmState(algo, g); if (vColors is null) { CollectionAssert.IsEmpty(algo.VerticesColors); } else { Assert.AreSame(vColors, algo.VerticesColors); } } #endregion }
public void Update() { UpdateInternalTest( 1, 2, 3); UpdateInternalTest( new TestVertex("1"), new TestVertex("2"), new TestVertex("3")); UpdateInternalTest( new EquatableTestVertex("1"), new EquatableTestVertex("2"), new EquatableTestVertex("3")); #region Local function void UpdateInternalTest <TVertex>( TVertex vertex1, TVertex vertex2, TVertex vertex3) { BinaryQueue <TVertex, double> queue = null; Update_Test( distFunc => queue = new BinaryQueue <TVertex, double>(distFunc), vertex1, vertex2); queue.Update(vertex3); // Added with distance 0.5 Assert.AreEqual(3, queue.Count); AssertEqual(vertex3, queue.Peek()); } #endregion }
/// <summary> /// /// </summary> protected AbstractRpcClient() { m_messageId = -1; m_messageLength = -1; m_messageData = new BinaryQueue(); }
/// <summary> /// /// </summary> public AbstractDofusClient() { m_messageQueue = new BinaryQueue(); FrameManager = new FrameManager <T, string>((T)this); }
/// <summary> /// Initializes a new instance of the <see cref="SourceFirstTopologicalSortAlgorithm{TVertex,TEdge}"/> class. /// </summary> /// <param name="visitedGraph">Graph to visit.</param> public SourceFirstTopologicalSortAlgorithm( [NotNull] IVertexAndEdgeListGraph <TVertex, TEdge> visitedGraph) : base(visitedGraph) { _heap = new BinaryQueue <TVertex, int>(vertex => InDegrees[vertex]); }
public void ToPairsArray() { ToPairsArrayTest(1, 2, 3, 4); ToPairsArrayTest( new TestVertex("1"), new TestVertex("2"), new TestVertex("3"), new TestVertex("4")); ToPairsArrayTest( new EquatableTestVertex("1"), new EquatableTestVertex("2"), new EquatableTestVertex("3"), new EquatableTestVertex("4")); #region Local function void ToPairsArrayTest <TVertex>( TVertex vertex1, TVertex vertex2, TVertex vertex3, TVertex vertex4) { var distances = new Stack <double>(new[] { 123.0, 3.0, 2.0, 4.0, 5.0, 1.0 }); var queue = new BinaryQueue <TVertex, double>(_ => distances.Pop()); // Empty heap CollectionAssert.IsEmpty(queue.ToPairsArray()); queue.Enqueue(vertex1); queue.Enqueue(vertex2); queue.Enqueue(vertex2); queue.Enqueue(vertex3); queue.Enqueue(vertex1); // Array not sorted with distance CollectionAssert.AreEquivalent( new[] { new KeyValuePair <double, TVertex>(1.0, vertex1), new KeyValuePair <double, TVertex>(5.0, vertex2), new KeyValuePair <double, TVertex>(4.0, vertex2), new KeyValuePair <double, TVertex>(2.0, vertex3), new KeyValuePair <double, TVertex>(3.0, vertex1) }, queue.ToPairsArray()); queue.Dequeue(); queue.Dequeue(); // Array not sorted with distance CollectionAssert.AreEquivalent( new[] { new KeyValuePair <double, TVertex>(3.0, vertex1), new KeyValuePair <double, TVertex>(5.0, vertex2), new KeyValuePair <double, TVertex>(4.0, vertex2) }, queue.ToPairsArray()); queue.Dequeue(); queue.Dequeue(); queue.Dequeue(); CollectionAssert.IsEmpty(queue.ToPairsArray()); queue.Enqueue(vertex4); CollectionAssert.AreEqual( new[] { new KeyValuePair <double, TVertex>(123.0, vertex4) }, queue.ToPairsArray()); } #endregion }
public void Constructor_Throws() { // ReSharper disable ObjectCreationAsStatement // ReSharper disable AssignNullToNotNullAttribute var graph = new AdjacencyGraph <int, Edge <int> >(); var verticesColors = new Dictionary <int, GraphColor>(); var queue = new BinaryQueue <int, double>(_ => 1.0); IEnumerable <Edge <int> > Filter(IEnumerable <Edge <int> > edges) => edges.Where(e => e != null); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, queue, verticesColors)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(graph, null, verticesColors)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(graph, queue, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, verticesColors)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, queue, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(graph, null, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, queue, verticesColors)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, null, verticesColors)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, queue, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, null, verticesColors)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, queue, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, null, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, null, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, queue, verticesColors, Filter)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, null, verticesColors, Filter)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, queue, null, Filter)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, queue, verticesColors, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, null, verticesColors, Filter)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, queue, null, Filter)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, queue, verticesColors, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, null, null, Filter)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, null, verticesColors, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, queue, null, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, graph, null, null, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, queue, null, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, null, verticesColors, null)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, null, null, Filter)); Assert.Throws <ArgumentNullException>( () => new BreadthFirstSearchAlgorithm <int, Edge <int> >(null, null, null, null, null)); // ReSharper restore AssignNullToNotNullAttribute // ReSharper restore ObjectCreationAsStatement }
/// <summary> /// Initializes a new instance of the <see cref="UndirectedFirstTopologicalSortAlgorithm{TVertex,TEdge}"/> class. /// </summary> /// <param name="visitedGraph">Graph to visit.</param> public UndirectedFirstTopologicalSortAlgorithm([NotNull] IUndirectedGraph <TVertex, TEdge> visitedGraph) : base(visitedGraph) { _heap = new BinaryQueue <TVertex, int>(vertex => Degrees[vertex]); }
protected override void InternalCompute() { var dic = new Dictionary <TVertex, HashSet <TEdge> >(); var cancelManager = this.Services.CancelManager; var visetedVert = new HashSet <TVertex>(); var edges = new HashSet <TEdge>(); var queue = new BinaryQueue <TEdge, double>(this.edgeWeights); var ds = new ForestDisjointSet <TVertex>(this.VisitedGraph.VertexCount); foreach (var v in this.VisitedGraph.Vertices) { if (visetedVert.Count == 0) { visetedVert.Add(v); } ds.MakeSet(v); dic.Add(v, new HashSet <TEdge>()); } foreach (var e in this.VisitedGraph.Edges) { dic[e.Source].Add(e); dic[e.Target].Add(e); } if (cancelManager.IsCancelling) { return; } var enumerator = visetedVert.GetEnumerator(); enumerator.MoveNext(); var lastVert = enumerator.Current; foreach (var edge in dic[lastVert]) { if (!edges.Contains(edge)) { edges.Add(edge); queue.Enqueue(edge); } } if (cancelManager.IsCancelling) { return; } while (edges.Count > 0 && visetedVert.Count < VisitedGraph.VertexCount) { var mined = queue.Dequeue(); this.OnExamineEdge(mined); if (!ds.AreInSameSet(mined.Source, mined.Target)) { this.OnTreeEdge(mined); ds.Union(mined.Source, mined.Target); if (visetedVert.Contains(mined.Source)) { lastVert = mined.Target; visetedVert.Add(mined.Target); } else { lastVert = mined.Source; visetedVert.Add(mined.Source); } foreach (var edge in dic[lastVert]) { if (!edges.Contains(edge)) { edges.Add(edge); queue.Enqueue(edge); } } } } }
protected override void InternalCompute() { var cancelManager = this.Services.CancelManager; var visetedVert = new List <TVertex>(); var visetedEdges = new List <TEdge>(); var ds = new ForestDisjointSet <TVertex>(this.VisitedGraph.VertexCount); foreach (var v in this.VisitedGraph.Vertices) { if (visetedVert.Count == 0) { visetedVert.Add(v); } ds.MakeSet(v); } if (cancelManager.IsCancelling) { return; } var queue = new BinaryQueue <TEdge, double>(this.edgeWeights); foreach (var edge in this.VisitedGraph.Edges) { if (!visetedEdges.Contains(edge) && (visetedVert.Contains(edge.Source) || visetedVert.Contains(edge.Target))) { queue.Enqueue(edge); visetedEdges.Add(edge); } } if (cancelManager.IsCancelling) { return; } while (queue.Count > 0) { foreach (var edge in this.VisitedGraph.Edges) { if (!visetedEdges.Contains(edge) && (visetedVert.Contains(edge.Source) || visetedVert.Contains(edge.Target))) { queue.Enqueue(edge); visetedEdges.Add(edge); } } var e = queue.Dequeue(); this.OnExamineEdge(e); if (!ds.AreInSameSet(e.Source, e.Target)) { this.OnTreeEdge(e); ds.Union(e.Source, e.Target); if (visetedVert.Contains(e.Source)) { visetedVert.Add(e.Target); } else { visetedVert.Add(e.Source); } } } }