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);
}
}
}
}
