public void TestDecPriority()
{
PairingHeap <Plane, int> queue = new PairingHeap <Plane, int>();
int idCounter = 0;
Plane plane1 = new Plane();
plane1.SetInternationalID("id" + idCounter);
idCounter++;
plane1.SetPriority(4);
queue.Add(plane1);
Plane plane2 = new Plane();
plane2.SetInternationalID("id" + idCounter);
idCounter++;
plane2.SetPriority(5);
queue.Add(plane2);
Plane plane3 = new Plane();
plane3.SetInternationalID("id" + idCounter);
idCounter++;
plane3.SetPriority(7);
queue.Add(plane3);
queue.ChangePriority(plane2, 89);
File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\testDecPriority.txt",
queue.TraverseLevelOrder());
}
void Merge(PairingHeap <T> other)
{
if (Empty && !other.Empty)
{
root = other.root;
children = other.children;
}
else if (!Empty && !other.Empty)
{
int ourPrio = root.priority;
int otherPrio = other.root.priority;
if (ourPrio < otherPrio)
{
children.Add(other);
}
else
{
PairingHeap <T> us = new PairingHeap <T>(root.item, root.priority);
us.children = new List <PairingHeap <T> >(children);
root.item = other.root.item;
root.priority = other.root.priority;
children = other.children;
children.Add(us);
}
}
}
/// <summary>
/// Gets the minimum-weight path to a goal using the A* algorithm.
/// </summary>
/// <remarks>Because the heuristic is not known to be consistent, we cannot use the closed set optimization.</remarks>
/// <typeparam name="TNode">The type of a node.</typeparam>
/// <typeparam name="TKey">The type of a node key.</typeparam>
/// <param name="sources">The set of nodes from which to start the search, weighted by their initial cost.</param>
/// <param name="key">The function which maps a node to its key.</param>
/// <param name="next">The function which maps a node to its adjacent nodes.</param>
/// <param name="goal">The goal predicate.</param>
/// <param name="heuristic">The possibly-inconsistent heuristic function.</param>
/// <returns>The minimum-weight path, or null if none exists.</returns>
private static IWeighted <IEnumerable <TNode> > AStarInconsistent <TNode, TKey>(
IEnumerable <IWeighted <TNode> > sources,
Func <TNode, TKey> key,
Func <TNode, IEnumerable <IWeighted <TNode> > > next,
Func <TNode, bool> goal,
Func <TNode, double> heuristic)
{
var came_from = new Dictionary <TKey, TNode>();
IPriorityQueue <double, AStarOpen <TNode> > open_queue = new PairingHeap <double, AStarOpen <TNode> >();
var open_lookup = new Dictionary <TKey, IPriorityQueueHandle <double, AStarOpen <TNode> > >();
foreach (var source in sources)
{
var u = source.Value;
var key_u = key(u);
var g_u = source.Weight;
var f_u = g_u + heuristic(u);
var open_u = new AStarOpen <TNode>(u, g_u);
open_u.Handle = open_queue.Add(f_u, open_u);
open_lookup.Add(key_u, open_u.Handle);
}
while (open_queue.Count > 0)
{
var handle_u = open_queue.Min;
var u = handle_u.Value.Node;
var key_u = key(u);
if (goal(u))
{
var path = ReconstructPath(key, came_from, u);
return(new Weighted <IEnumerable <TNode> >(path, handle_u.Value.G));
}
open_queue.Remove(handle_u);
open_lookup.Remove(key_u);
foreach (var uv in next(u))
{
var v = uv.Value;
var key_v = key(v);
var g_v = handle_u.Value.G + uv.Weight;
var f_v = g_v + heuristic(v);
IPriorityQueueHandle <double, AStarOpen <TNode> > handle_v;
if (open_lookup.TryGetValue(key_v, out handle_v))
{
if (f_v < handle_v.Key)
{
open_queue.UpdateKey(handle_v, f_v);
handle_v.Value.G = g_v;
came_from[key_v] = u;
}
}
else
{
var open_v = new AStarOpen <TNode>(v, g_v);
open_v.Handle = open_queue.Add(f_v, open_v);
open_lookup.Add(key_v, open_v.Handle);
came_from[key_v] = u;
}
}
}
return(null);
}
public TrackType(double length)
{
Length = length;
Tracks = new List <Track>();
WaitingPlanes = new PairingHeap <Plane, double>();
WaitingPlanesForSearch = new SplayTree <Plane>();
}
public void Enqueue(T item)
{
var heap = new PairingHeap <T>(item);
top = PairingHeap <T> .Merge(top, heap, compare);
size++;
}
public static void Print <TNode, TKey, TValue>([NotNull] this PairingHeap <TNode, TKey, TValue> thisValue)
where TNode : PairingNode <TNode, TKey, TValue>
{
Console.WriteLine();
Console.WriteLine("Count: " + thisValue.Count);
Console.WriteLine();
thisValue.WriteTo(Console.Out);
}
/// <summary>
/// Gets the minimum-weight path to a goal using uniform cost search.
/// </summary>
/// <typeparam name="TNode">The type of a node.</typeparam>
/// <typeparam name="TKey">The type of a node key.</typeparam>
/// <param name="sources">The set of nodes from which to start the search, weighted by their initial cost.</param>
/// <param name="key">The function which maps a node to its key.</param>
/// <param name="next">The function which maps a node to its adjacent nodes.</param>
/// <param name="goal">The goal predicate.</param>
/// <returns>The minimum-weight path, or null if none exists.</returns>
public static IWeighted <IEnumerable <TNode> > UniformCostSearch <TNode, TKey>(
this IEnumerable <IWeighted <TNode> > sources,
Func <TNode, TKey> key,
Func <TNode, IEnumerable <IWeighted <TNode> > > next,
Func <TNode, bool> goal)
{
var came_from = new Dictionary <TKey, TNode>();
var open_lookup = new Dictionary <TKey, IPriorityQueueHandle <double, TNode> >();
IPriorityQueue <double, TNode> open_queue = new PairingHeap <double, TNode>();
var closed = new HashSet <TKey>();
foreach (var source in sources)
{
var u = source.Value;
var g_u = source.Weight;
open_lookup.Add(key(u), open_queue.Add(g_u, u));
}
while (open_queue.Count > 0)
{
var handle_u = open_queue.Min;
var u = handle_u.Value;
var key_u = key(u);
var g_u = handle_u.Key;
if (goal(u))
{
var path = ReconstructPath(key, came_from, u);
return(new Weighted <IEnumerable <TNode> >(path, g_u));
}
open_lookup.Remove(key_u);
open_queue.Remove(handle_u);
closed.Add(key_u);
foreach (var uv in next(u))
{
var v = uv.Value;
var key_v = key(v);
if (closed.Contains(key_v))
{
continue;
}
IPriorityQueueHandle <double, TNode> v_handle;
var g_uv = g_u + uv.Weight;
if (open_lookup.TryGetValue(key_v, out v_handle))
{
if (g_uv < v_handle.Key)
{
open_queue.UpdateKey(v_handle, g_uv);
came_from[key_v] = u;
}
}
else
{
open_lookup.Add(key_v, open_queue.Add(g_uv, v));
came_from[key_v] = u;
}
}
}
return(null);
}
public void OneValueTest()
{
PairingHeap <int> pairingHeap = new PairingHeap <int>((x, y) => x > y);
pairingHeap.Insert(10);
var value = pairingHeap.ExtractMinimum();
Assert.Equal(10, value.value);
}
public T Dequeue()
{
var ret = top.Key;
size--;
top = PairingHeap <T> .Pop(top, compare);
return(ret);
}
public void BuildMinHeap_CheckEnumerator_NotThrowOnEnumerate()
{
var minHeap = new PairingHeap <int>();
minHeap.Insert(1);
var items = minHeap.ToList();
items.Should().HaveCount(1);
}
public void BuildMinHeap_UpdateBadNode_ThrowException()
{
var minHeap = new PairingHeap <int>();
minHeap.Insert(10);
Action act = () => minHeap.UpdateKey(10, 11);
act.Should().Throw <ArgumentException>();
}
public void BuildMinHeap_CheckEnumerable_NotThrowOnEnumerate()
{
var minHeap = new PairingHeap <int>();
minHeap.Insert(1);
foreach (var node in (IEnumerable)minHeap)
{
node.Should().NotBe(null);
}
}
public void Max_PairingHeap_Test()
{
int nodeCount = 1000 * 10;
var maxHeap = new PairingHeap <int>(SortDirection.Descending);
for (int i = 0; i <= nodeCount; i++)
{
maxHeap.Insert(i);
}
for (int i = 0; i <= nodeCount; i++)
{
maxHeap.UpdateKey(i, i + 1);
}
//IEnumerable tests.
Assert.AreEqual(maxHeap.Count, maxHeap.Count());
int max = 0;
for (int i = nodeCount; i >= 0; i--)
{
max = maxHeap.Extract();
Assert.AreEqual(max, i + 1);
}
var rnd = new Random();
var testSeries = Enumerable.Range(0, nodeCount - 1).OrderBy(x => rnd.Next()).ToList();
foreach (var item in testSeries)
{
maxHeap.Insert(item);
}
for (int i = 0; i < testSeries.Count; i++)
{
var incremented = testSeries[i] + rnd.Next(0, 1000);
maxHeap.UpdateKey(testSeries[i], incremented);
testSeries[i] = incremented;
}
testSeries = testSeries.OrderByDescending(x => x).ToList();
for (int i = 0; i < nodeCount - 2; i++)
{
max = maxHeap.Extract();
Assert.AreEqual(testSeries[i], max);
}
//IEnumerable tests.
Assert.AreEqual(maxHeap.Count, maxHeap.Count());
}
public void Min_PairingHeap_Test()
{
int nodeCount = 1000 * 10;
var minHeap = new PairingHeap <int>();
for (int i = 0; i <= nodeCount; i++)
{
minHeap.Insert(i);
}
for (int i = 0; i <= nodeCount; i++)
{
minHeap.UpdateKey(i, i - 1);
}
int min = 0;
for (int i = 0; i <= nodeCount; i++)
{
min = minHeap.Extract();
Assert.AreEqual(min, i - 1);
}
//IEnumerable tests.
Assert.AreEqual(minHeap.Count, minHeap.Count());
var rnd = new Random();
var testSeries = Enumerable.Range(0, nodeCount - 1).OrderBy(x => rnd.Next()).ToList();
foreach (var item in testSeries)
{
minHeap.Insert(item);
}
for (int i = 0; i < testSeries.Count; i++)
{
var decremented = testSeries[i] - rnd.Next(0, 1000);
minHeap.UpdateKey(testSeries[i], decremented);
testSeries[i] = decremented;
}
testSeries.Sort();
for (int i = 0; i < nodeCount - 2; i++)
{
min = minHeap.Extract();
Assert.AreEqual(testSeries[i], min);
}
//IEnumerable tests.
Assert.AreEqual(minHeap.Count, minHeap.Count());
}
static public PairingHeap <T> Merge(PairingHeap <T> l, PairingHeap <T> r, Comparison <T> compare)
{
if (l == null || r == null)
{
return(l == null ? r : l);
}
if (compare(l.key, r.key) > 0)
{
Swap(ref l, ref r);
}
r.next = l.head;
l.head = r;
return(l);
}
public void Initialize()
{
var random = new Random(42);
_priorities = new int[Size];
for (int i = 0; i < Size; i++)
{
_priorities[i] = random.Next();
}
_prioritySet = new PrioritySet <int, int>(initialCapacity: Size);
_pairingHeap = new PairingHeap <int, int>(Comparer <int> .Default);
_pairingHeapNodes = new Dictionary <int, PairingHeapNode <int, int> >(Size);
}
/// <summary>
/// Computes the minimum spanning tree for the connected component containing a specified vertex.
/// </summary>
/// <param name="startVertex">The vertex where the algorithm should start.</param>
/// <returns>The set of edges that define the minimum spanning tree.</returns>
public ReadOnlySpan <TEdgeId> ComputeMinimumSpanningTree(TVertexId startVertex)
{
var heapNodes = new Dictionary <TVertexId, PairingHeap <VertexWithDistanceAndEdge> .ElementPointer>(this._graph.Comparer)
{
{ startVertex, PairingHeap <VertexWithDistanceAndEdge> .ElementPointer.Undefined }
};
var todo = new PairingHeap <VertexWithDistanceAndEdge>(new DistanceComparer(this._comparer));
var result = new DynamicArray <TEdgeId>(true);
ProcessEdges(startVertex);
while (todo.TryExtractMinimum(out var next))
{
heapNodes[next.Vertex] = PairingHeap <VertexWithDistanceAndEdge> .ElementPointer.Undefined;
result.AddLast(next.Edge);
ProcessEdges(next.Vertex);
}
return(result.AsSpan());
void ProcessEdges(TVertexId vertex)
{
foreach (var outEdgeIdx in this._graph.GetOutEdges(vertex))
{
var target = this._graph.GetTarget(outEdgeIdx);
if (heapNodes.TryGetValue(target, out var vertexState))
{
if (vertexState.IsUndefined)
{
continue;
}
var currentBestDistanceToTarget = todo[vertexState].Distance;
var distance = this._graph.GetEdgeTag(outEdgeIdx);
if (this._comparer.Compare(distance, currentBestDistanceToTarget) >= 0)
{
continue;
}
todo.Decrease(vertexState, new(target, distance, outEdgeIdx));
}
else
{
var distance = this._graph.GetEdgeTag(outEdgeIdx);
var node = todo.Insert(new(target, distance, outEdgeIdx));
heapNodes.Add(target, node);
}
}
}
}
public void BuildMaxHeap_CreateHeap_HeapIsCheked()
{
var nodeCount = 1000 * 10;
var maxHeap = new PairingHeap <int>(Sorting.Descending);
for (var i = 0; i <= nodeCount; i++)
{
maxHeap.Insert(i);
}
for (var i = 0; i <= nodeCount; i++)
{
maxHeap.UpdateKey(i, i + 1);
}
Assert.AreEqual(maxHeap.Count, maxHeap.Count);
var max = 0;
for (var i = nodeCount; i >= 0; i--)
{
max = maxHeap.Extract();
Assert.AreEqual(max, i + 1);
}
var rnd = new Random();
var testSeries = Enumerable.Range(0, nodeCount - 1).OrderBy(_ => rnd.Next()).ToList();
foreach (var item in testSeries)
{
maxHeap.Insert(item);
}
for (var i = 0; i < testSeries.Count; i++)
{
var incremented = testSeries[i] + rnd.Next(0, 1000);
maxHeap.UpdateKey(testSeries[i], incremented);
testSeries[i] = incremented;
}
testSeries = testSeries.OrderByDescending(x => x).ToList();
for (var i = 0; i < nodeCount - 2; i++)
{
max = maxHeap.Extract();
Assert.AreEqual(testSeries[i], max);
}
Assert.AreEqual(maxHeap.Count, maxHeap.Count);
}
public void Initialize()
{
var random = new Random(42);
_priorities = new int[2 * Size];
for (int i = 0; i < 2 * Size; i++)
{
_priorities[i] = random.Next();
}
_priorityQueue2 = new PriorityQueue <int>(initialCapacity: Size);
_priorityQueue = new PriorityQueue <int, int>(initialCapacity: Size);
_prioritySet = new PrioritySet <int, int>(initialCapacity: Size);
_pairingHeap = new PairingHeap <int, int>(Comparer <int> .Default);
}
public static (bool connected, Graph tree) Prim(this Graph g, int startingVertex = 0)
{
if (g.Directed)
{
throw new WrongGraphException("Graph must be an undirected graph");
}
if (startingVertex < 0 || startingVertex >= g.VerticesCount)
{
throw new ArgumentOutOfRangeException("startingVertex");
}
Graph tree = g.IsolatedGraph(g.Directed);
PairingHeap <Edge> queue = new PairingHeap <Edge>((x, y) => x.Weight > y.Weight);
UnionFind unionFind = new UnionFind(g.VerticesCount);
foreach (var e in g.GetEdgesFrom(startingVertex))
{
queue.Insert(e);
}
int c = 0;
while (true)
{
if (queue.IsEmpty() || c == g.VerticesCount - 1)
{
return(c == g.VerticesCount - 1 ? true : false, tree);
}
var e = queue.ExtractMinimum();
if (unionFind.FindParent(e.value.From) != unionFind.FindParent(e.value.To))
{
tree.AddEdge(e.value);
unionFind.Union(e.value.From, e.value.To);
foreach (var f in g.GetEdgesFrom(e.value.To))
{
queue.Insert(f);
}
c++;
}
}
}
protected bool Find(T item, out PairingHeap <T> heap, out LinkedListNode <PairingHeap <T> > node)
{
heap = null; node = null;
if (this.root.CompareTo(item) == 0)
{
heap = this;
return(true);
}
if (this.children.Count == 0)
{
return(false);
}
Stack <LinkedListNode <PairingHeap <T> > > stack = new Stack <LinkedListNode <PairingHeap <T> > >();
LinkedListNode <PairingHeap <T> > current = this.children.First;
stack.Push(new LinkedListNode <PairingHeap <T> >(this));
while (stack.Count > 0)
{
if (current.Value.root.CompareTo(item) == 0)
{
heap = current.Value;
node = current;
return(true);
}
if (current.Value.children.Count > 0)
{
if (current.Next != null)
{
stack.Push(current.Next);
}
current = current.Value.children.First;
}
else if (current.Next != null)
{
current = current.Next;
}
else
{
current = stack.Pop();
}
}
return(false);
}
// Test program
public static void Main(string[] args)
{
PairingHeap <int> h = new PairingHeap <int>( );
int numItems = 10000;
int i = 37;
int j;
Console.WriteLine("Checking; no bad output is good");
for (i = 37; i != 0; i = (i + 37) % numItems)
{
h.Insert(i);
}
for (i = 1; i < numItems; i++)
{
if (h.DeleteMin( ) != i)
{
Console.WriteLine("Oops! " + i);
}
}
List <IPriorityQueuePosition <int> > p = new List <IPriorityQueuePosition <int> >( );
for (i = 0; i < numItems; i++)
{
p.Add(null);
}
for (i = 0, j = numItems / 2; i < numItems; i++, j = (j + 71) % numItems)
{
p[j] = h.Insert(j + numItems);
}
for (i = 0, j = numItems / 2; i < numItems; i++, j = (j + 53) % numItems)
{
h.DecreaseKey(p[j], p[j].GetValue( ) - numItems);
}
i = -1;
while (!h.IsEmpty( ))
{
if (h.DeleteMin( ) != ++i)
{
Console.WriteLine("Oops! " + i + " ");
}
}
Console.WriteLine("Check completed");
}
// Single-source weighted shortest-path algorithm using pairing heaps.
public void Dijkstra2(string startName)
{
IPriorityQueue <Path> pq = new PairingHeap <Path>();
Vertex start = vertexMap[startName]; // throws an exception if not found
ClearAll();
start.pos = pq.Insert(new Path(start, 0));
start.dist = 0;
while (!pq.IsEmpty())
{
Path vrec = pq.DeleteMin();
Vertex v = vrec.dest;
foreach (Edge e in v.adj)
{
Vertex w = e.dest;
double cvw = e.cost;
if (cvw < 0)
{
throw new GraphException("Graph has negative edges");
}
if (w.dist > v.dist + cvw)
{
w.dist = v.dist + cvw;
w.prev = v;
Path newVal = new Path(w, w.dist);
if (w.pos == null)
{
w.pos = pq.Insert(newVal);
}
else
{
pq.DecreaseKey(w.pos, newVal);
}
}
}
}
}
/// <summary>
/// Removes the first occurrence of a specific object from the PairingHeap<T>.
/// </summary>
/// <param name="item">The object to be removed.</param>
/// <returns><code>true</code> if item was successfully removed from the PairingHeap<T>; otherwise, <code>false</code>.</returns>
public bool Remove(T item)
{
PairingHeap <T> heap, parent;
LinkedListNode <PairingHeap <T> > node;
if (this.Find(item, out heap, out node))
{
parent = heap;
while (parent != null)
{
parent.Count--;
parent = parent.parent;
}
heap.MergePairs();
return(true);
}
return(false);
}
public static (bool connected, Graph tree) Kruskal(this Graph g)
{
if (g.Directed)
{
throw new WrongGraphException("Graph must be an undirected graph");
}
Graph tree = g.IsolatedGraph(g.Directed);
PairingHeap <Edge> queue = new PairingHeap <Edge>((x, y) => x.Weight > y.Weight);
UnionFind unionFind = new UnionFind(g.VerticesCount);
for (int i = 0; i < g.VerticesCount; i++)
{
foreach (var e in g.GetEdgesFrom(i))
{
queue.Insert(e);
}
}
int c = 0;
while (true)
{
if (queue.IsEmpty() || c == g.VerticesCount - 1)
{
return(c == g.VerticesCount - 1 ? true : false, tree);
}
var e = queue.ExtractMinimum();
if (unionFind.FindParent(e.value.From) != unionFind.FindParent(e.value.To))
{
tree.AddEdge(e.value);
unionFind.Union(e.value.From, e.value.To);
c++;
}
}
}
void MergePairs(List <PairingHeap <T> > l)
{
if (l.Count == 0)
{
return;
}
else if (l.Count == 1)
{
if (root == null)
{
root = l[0].root;
}
else
{
root.item = l[0].root.item;
root.priority = l[0].root.priority;
}
children = l[0].children;
}
else
{
PairingHeap <T> aux = new PairingHeap <T>();
aux.Merge(l[0]);
aux.Merge(l[1]);
PairingHeap <T> aux2 = new PairingHeap <T>();
aux2.MergePairs(l.GetRange(2, l.Count - 2));
aux.Merge(aux2);
if (root == null)
{
root = aux.root;
}
else
{
root.item = aux.root.item;
root.priority = aux.root.priority;
}
children = aux.children;
}
}
public void NValueTest(int n)
{
PairingHeap <int> pairingHeap = new PairingHeap <int>((x, y) => x > y);
List <int> lista = new List <int>();
Random random = new Random();
for (int i = 0; i < n; i++)
{
int value = random.Next() % n * (0 == random.Next() % 2 ? -1 : 1);
lista.Add(value);
pairingHeap.Insert(value);
}
lista.Sort();
for (int i = 0; i < n; i++)
{
var value = pairingHeap.ExtractMinimum();
Assert.Equal(lista[i], value.value);
}
}
/// <summary>
/// Merges a heap into this one.
/// </summary>
/// <param name="other">The heap to merge into this one.</param>
public override void Merge(PairingHeap <T> other)
{
PairingMaxHeap <T> heap = other as PairingMaxHeap <T>;
if (heap == null)
{
this.AddRange(other);
return;
}
if (heap.Count == 0)
{
return;
}
if (this.Count == 0)
{
this.root = heap.root;
this.children = heap.children;
this.Count = heap.Count;
return;
}
this.Count += heap.Count;
if (this.root.CompareTo(heap.root) >= 0)
{
this.children.AddFirst(heap);
heap.parent = this;
}
else
{
PairingMaxHeap <T> newHeap = new PairingMaxHeap <T>(this.root, this.children, this.Count);
this.root = heap.root;
this.children = heap.children;
this.children.AddFirst(newHeap);
newHeap.parent = this;
}
}
static public PairingHeap <T> MergeLst(PairingHeap <T> s, Comparison <T> compare)
{
var n = new PairingHeap <T>(default(T));
while (s != null)
{
PairingHeap <T> a = s, b = null;
s = s.next; a.next = null;
if (s != null)
{
b = s; s = s.next; b.next = null;
}
a = Merge(a, b, compare); a.next = n.next;
n.next = a;
}
while (n.next != null)
{
var j = n.next;
n.next = n.next.next;
s = Merge(j, s, compare);
}
return(s);
}
private void FindPaths()
{
var frontier = new PairingHeap <double, Location>(new DoubleComparer())
{
{ 0, HeroLocation }
};
CategorizeObject(ObjectMap[HeroLocation]);
while (frontier.Count != 0)
{
var current = frontier.Pop().Value;
for (var d = Direction.Up; d <= Direction.RightDown; d++)
{
var next = current.NeighborAt(d);
if (IsEnemySpawn(next) ||
!ObjectMap.ContainsKey(next))
{
continue;
}
var mapObject = ObjectMap[next];
CategorizeObject(mapObject);
var nextTime = TravelTimes[current] + 0.5 * movementCost[mapObject.Terrain];
if (TravelTimes.ContainsKey(next) && !(nextTime < TravelTimes[next]))
{
continue;
}
TravelTimes[next] = nextTime;
if (IsPassable(mapObject))
{
frontier.Add(nextTime, next);
}
previousLocation[next] = current;
}
}
}
public IEnumerable<Tuple<Word, int>> Derive()
{
var derivedWords = new HashSet<string>();
var pq = new PairingHeap<Word, int>();
pq.Add(new Word(Grammar.StartSymbol), 0);
var rules = Grammar.Rules.OrderBy(r => r.WordToInsert.Length - r.WordToReplace.Length).ToArray();
while (pq.Count > 0)
{
var elementToDerive = pq.Min;
pq.Remove(elementToDerive);
var wordToDerive = elementToDerive.Key;
foreach (var nw in rules.SelectMany(rule => wordToDerive.ReplaceAll(rule.WordToReplace, rule.WordToInsert))
.Where(nw => !derivedWords.Contains(nw.ToString())))
{
derivedWords.Add(nw.ToString());
pq.Add(nw, nw.Length);
yield return Tuple.Create(nw, wordToDerive.Length);
}
}
}
public OutstandingMessageCache()
{
_outstandingRequests = new Dictionary<Guid, OutstandingMessage>();
_byTime = new PairingHeap<RetryableMessage>((x,y) => x.DueTime < y.DueTime);
_bySequences = new SortedList<int, int>();
}
public void TearDown()
{
_heap = null;
}
public void SetUp()
{
_heap = new PairingHeap<int>();
}