public void Clear()
{
var pq = new PriorityQueue<int>();
pq.Clear();
Assert.AreEqual(0, pq.Count);
pq.Enqueue(777);
pq.Enqueue(234);
pq.Enqueue(13);
pq.Clear();
Assert.AreEqual(0, pq.Count);
}
public void RestartSearch()
{
m_grid.CleanupGrid();
m_grid.ResetNeighbours();
m_frontierNodes.Clear();
m_frontierNodes = new PriorityQueue <Node>();
m_exploredNodes.Clear();
m_exploredNodes = new List <Node>();
m_pathNodes.Clear();
m_pathNodes = new List <Node>();
ShowColors();
}
/// <summary>
/// Atomically removes all of the elements from this queue.
/// The queue will be empty after this call returns.
/// </summary>
public override void Clear()
{
ReentrantLock rl = _lock;
rl.Lock();
try {
_innerQueue.Clear();
}
finally {
rl.Unlock();
}
}
///
///If the priority queue has entries in it when we modify any of the nodes'
///ranks, then we need to re-generate it to make sure it's up-to-date.
///
private void CheckRegen()
{
if (ToRegen)
{
ToRegen = false;
prioritizedQ.Clear();
foreach (Entry e in entries)
{
prioritizedQ.Enqueue(e, e);
}
}
}
public void PriorityQueueClearEmptiesTheQueue()
{
var q = new PriorityQueue <int>();
q.Enqueue(AnyInt);
q.Enqueue(AnyInt);
q.Clear();
Assert.Equal(0, q.Count);
Assert.Throws <InvalidOperationException>(() => q.Peek());
}
public void ClearResetsCountToZero()
{
var pq = new PriorityQueue <int>();
for (var i = 0; i < 10; ++i)
{
pq.Enqueue(i);
}
pq.Clear();
Assert.AreEqual(0, pq.Count);
}
public void TestDecreasePriorityClearedQueue()
{
var q = new PriorityQueue <double, string>();
q.Enqueue(2, "first item");
q.Enqueue(3, "second item");
q.Enqueue(1, "third item");
q.Clear();
Assert.Throws <KeyNotFoundException>(() => q.DecreasePriority("third item", 0));
}
public void PriorityQueue_CountLimit()
{
PriorityQueue <PlainItem> queue = new PriorityQueue <PlainItem>();
queue.CountLimit = 3;
queue.Enqueue(new PlainItem(0));
queue.Enqueue(new PlainItem(1));
queue.Enqueue(new PlainItem(2));
Assert.AreEqual(3, queue.Count);
Assert.AreEqual(0, queue.Dequeue().Value);
Assert.AreEqual(1, queue.Dequeue().Value);
Assert.AreEqual(2, queue.Dequeue().Value);
Assert.AreEqual(0, queue.Count);
queue.Enqueue(new PlainItem(0));
queue.Enqueue(new PlainItem(1));
queue.Enqueue(new PlainItem(2));
queue.Enqueue(new PlainItem(3));
Assert.AreEqual(3, queue.Count);
Assert.AreEqual(1, queue.Dequeue().Value);
Assert.AreEqual(2, queue.Dequeue().Value);
Assert.AreEqual(3, queue.Dequeue().Value);
Assert.AreEqual(0, queue.Count);
queue.Enqueue(new PlainItem(0));
queue.Enqueue(new PlainItem(1));
queue.Enqueue(new PlainItem(2));
queue.CountLimit = 2;
Assert.AreEqual(2, queue.Count);
Assert.AreEqual(1, queue.Dequeue().Value);
Assert.AreEqual(2, queue.Dequeue().Value);
// Make sure that priority items aren't impacted
queue.Clear();
queue.CountLimit = 3;
queue.Enqueue(new PlainItem(0));
queue.Enqueue(new PlainItem(1));
queue.Enqueue(new PlainItem(2));
queue.Enqueue(new PlainItem(3));
queue.EnqueuePriority(new PlainItem(4));
queue.EnqueuePriority(new PlainItem(5));
Assert.AreEqual(5, queue.Count);
Assert.AreEqual(2, queue.PriorityCount);
Assert.AreEqual(4, queue.Dequeue().Value);
Assert.AreEqual(5, queue.Dequeue().Value);
Assert.AreEqual(1, queue.Dequeue().Value);
Assert.AreEqual(2, queue.Dequeue().Value);
Assert.AreEqual(3, queue.Dequeue().Value);
}
void ScheduleNoteTriggers(int startBeat)
{
var b = startBeat;
notes.Clear();
for (var i = 0; i < sequence.Length; i++)
{
var n = sequence[i];
n.beat = b;
notes.Push(n);
b += n.duration;
}
}
public void Clear_ClearsElements()
{
// Arrange
var queue = new PriorityQueue <int> {
1
};
// Act
queue.Clear();
// Assert
Assert.Equal(queue.Count, 0);
}
protected override void StartRealization()
{
base.StartRealization();
// Update the rates once! This will initialize the current rates
_a0 = InitializeReactionRatesAndTaus(model.Reactions, _currentRates, _currentTaus);
_pq.Clear();
foreach (Reaction r in model.Reactions)
{
_pq.Add(_currentTaus[r], r);
}
}
public static void StopScheduledTasks()
{
if (!running)
{
throw new InvalidOperationException("SchedulerLogic is already Stopped in {0}".FormatWith(Environment.MachineName));
}
lock (priorityQueue)
{
if (!running)
{
return;
}
running = false;
timer.Change(Timeout.Infinite, Timeout.Infinite);
priorityQueue.Clear();
}
SystemEventLogLogic.Log("Stop ScheduledTasks");
}
public static void EmptyPrimitivesTest(PriorityQueue <int> q)
{
Assert.AreEqual(INT_DATA.Length, q.Count, "Count should equal length of source array");
q.Clear();
Assert.AreEqual(0, q.RemoveLowest(), "Should remove a zero from an empty queue");
Assert.AreEqual(0, q.LowestNode, "Lowest Node should be zero in an empty queue");
Assert.AreEqual(0, q.Count, "Count should be zero");
var en = ((System.Collections.IEnumerable)q).GetEnumerator();
Assert.IsNotNull(en, "Should get an enumerator");
}
public void TestAdd()
{
PriorityQueue <int> q = new PriorityQueue <int>(PriorityQueueType.MinPriorityQueue);
q.Add(4);
Assert.AreEqual(q.Count, 1);
Assert.AreEqual(q.Dequeue(), 4);
q.Add(5);
q.Add(6, 2);
Assert.AreEqual(q.Dequeue(), 5);
Assert.AreEqual(q.Dequeue(), 6);
q.Add(6, 2);
q.Add(5);
Assert.AreEqual(q.Dequeue(), 5);
Assert.AreEqual(q.Dequeue(), 6);
PriorityQueue <string> q2 = new PriorityQueue <string>(PriorityQueueType.MinPriorityQueue);
q2.Add("a", 1);
q2.Add("b", 2);
q2.Add("c", 3);
q2.Add("d", 4);
q2.Add("e", 5);
q2.Add("f", 6);
q2.Add("z", 6);
q2.Add("y", 5);
q2.Add("x", 4);
q2.Add("w", 3);
q2.Add("v", 2);
q2.Add("u", 1);
q2.Add("z", 1);
q2.Add("y", 2);
q2.Add("x", 3);
q2.Add("w", 4);
q2.Add("v", 5);
q2.Add("u", 6);
Assert.AreEqual(q2.Count, 18);
q2.Clear();
Assert.AreEqual(q2.Count, 0);
}
public void Simple()
{
var priorityQueue1 = new PriorityQueue <int, int>(PriorityQueueType.Minimum)
{
4
};
Assert.AreEqual(priorityQueue1.Count, 1);
Assert.AreEqual(priorityQueue1.Dequeue(), 4);
priorityQueue1.Add(5);
priorityQueue1.Add(6, 2);
Assert.AreEqual(priorityQueue1.Dequeue(), 5);
Assert.AreEqual(priorityQueue1.Dequeue(), 6);
priorityQueue1.Add(6, 2);
priorityQueue1.Add(5);
Assert.AreEqual(priorityQueue1.Dequeue(), 5);
Assert.AreEqual(priorityQueue1.Dequeue(), 6);
var priorityQueue2 = new PriorityQueue <string, int>(PriorityQueueType.Minimum)
{
{ "a", 1 },
{ "b", 2 },
{ "c", 3 },
{ "d", 4 },
{ "e", 5 },
{ "f", 6 },
{ "z", 6 },
{ "y", 5 },
{ "x", 4 },
{ "w", 3 },
{ "v", 2 },
{ "u", 1 },
{ "z", 1 },
{ "y", 2 },
{ "x", 3 },
{ "w", 4 },
{ "v", 5 },
{ "u", 6 }
};
Assert.AreEqual(priorityQueue2.Count, 18);
priorityQueue2.Clear();
Assert.AreEqual(priorityQueue2.Count, 0);
}
public void Enumerator()
{
var pq = new PriorityQueue <int>();
for (int i = 0; i < 10; i++)
{
pq.Enqueue(i);
}
var list = new List <int>();
foreach (var i in pq)
{
Assert.IsTrue(!list.Contains(i));
list.Add(i);
}
Assert.AreEqual(pq.Count, list.Count);
Assert.Throws(typeof(InvalidOperationException), () =>
{
foreach (var i in pq)
{
pq.Enqueue(1);
}
});
Assert.Throws(typeof(InvalidOperationException), () =>
{
foreach (var i in pq)
{
pq.Dequeue();
}
});
Assert.Throws(typeof(InvalidOperationException), () =>
{
foreach (var i in pq)
{
pq.Remove(1);
}
});
Assert.Throws(typeof(InvalidOperationException), () =>
{
foreach (var i in pq)
{
pq.Clear();
}
});
}
/// <summary>
/// Stops the listener
/// </summary>
private void StopEventListener()
{
try
{
if (eventListenerService != null)
{
RemotingServices.Unmarshal(eventListenerService);
}
if (eventInvocation != null)
{
RemotingServices.Disconnect(eventInvocation);
}
if (eventListenerChannel != null)
{
ChannelServices.UnregisterChannel(eventListenerChannel);
}
if (eventQueue != null)
{
eventQueue.Clear();
eventQueue = null;
}
if (eventTrigger != null)
{
eventTrigger.Close();
eventTrigger = null;
}
if (eventProcessor != null)
{
try
{
if (eventProcessor.IsAlive)
{
eventProcessor.Abort();
}
}
catch (Exception) { }
eventProcessor = null;
}
eventListenerService = null;
eventInvocation = null;
eventListenerChannel = null;
}
catch (Exception ex)
{
log.Error("Error stopping event listener: " + ex.Message, ex);
}
}
public void Simple()
{
var priorityQueue = new PriorityQueue<int, int>(PriorityQueueType.Minimum);
Assert.AreEqual(priorityQueue.Count, 0);
priorityQueue.Add(4);
Assert.AreEqual(priorityQueue.Count, 1);
priorityQueue.Add(99);
Assert.AreEqual(priorityQueue.Count, 2);
priorityQueue.Clear();
Assert.AreEqual(priorityQueue.Count, 0);
}
static void Main()
{
string decorationLine = new string('-', Console.WindowWidth);
Console.Write(decorationLine);
Console.WriteLine("Priority queue - Demo");
Console.Write(decorationLine);
PriorityQueue <int> numbers = new PriorityQueue <int>();
Console.WriteLine("--- Enqueue operation ---");
numbers.Enqueue(4);
numbers.Enqueue(-1);
numbers.Enqueue(3);
numbers.Enqueue(22);
numbers.Enqueue(16);
numbers.Enqueue(-9);
numbers.Enqueue(10);
numbers.Enqueue(14);
numbers.Enqueue(-48);
numbers.Enqueue(71);
Console.WriteLine("Count = " + numbers.Count);
Console.WriteLine();
Console.WriteLine("--- Iterator functionality ---");
PrintNumbersOnConsole(numbers);
Console.WriteLine();
Console.WriteLine("--- Peek operation ---");
int topNumber = numbers.Peek();
Console.WriteLine("Count = " + numbers.Count);
Console.WriteLine("The result from peek operation: " + topNumber);
Console.WriteLine("Queue after peek:");
PrintNumbersOnConsole(numbers);
Console.WriteLine();
Console.WriteLine("--- Dequeue operation ---");
int poppedNumber = numbers.Dequeue();
Console.WriteLine("The result from dequeue operation: " + poppedNumber);
Console.WriteLine("Count = " + numbers.Count);
Console.WriteLine("Queue after dequeue:");
PrintNumbersOnConsole(numbers);
Console.WriteLine();
Console.WriteLine("--- Clear operation ---");
numbers.Clear();
Console.WriteLine("Elements count after clearing: " + numbers.Count);
}
public void Stop()
{
scriptThreadpool.Restart();
scriptChangeThreadpool.Restart();
cmdThreadpool.Restart();
LUQueue.Clear();
QueueItemStruct itm;
while (ScriptEvents.TryDequeue(out itm))
{
}
lock (SleepingScriptEvents)
SleepingScriptEvents.Clear();
}
public void Simple()
{
var priorityQueue1 = new PriorityQueue <int, int>(PriorityQueueType.Minimum);
priorityQueue1.Enqueue(4);
Assert.AreEqual(priorityQueue1.Count, 1);
Assert.AreEqual(priorityQueue1.Dequeue(), 4);
priorityQueue1.Enqueue(5);
priorityQueue1.Enqueue(6, 2);
Assert.AreEqual(priorityQueue1.Dequeue(), 5);
Assert.AreEqual(priorityQueue1.Dequeue(), 6);
priorityQueue1.Enqueue(6, 2);
priorityQueue1.Enqueue(5);
Assert.AreEqual(priorityQueue1.Dequeue(), 5);
Assert.AreEqual(priorityQueue1.Dequeue(), 6);
var priorityQueue2 = new PriorityQueue <string, int>(PriorityQueueType.Minimum);
priorityQueue2.Enqueue("a", 1);
priorityQueue2.Enqueue("b", 2);
priorityQueue2.Enqueue("c", 3);
priorityQueue2.Enqueue("d", 4);
priorityQueue2.Enqueue("e", 5);
priorityQueue2.Enqueue("f", 6);
priorityQueue2.Enqueue("z", 6);
priorityQueue2.Enqueue("y", 5);
priorityQueue2.Enqueue("x", 4);
priorityQueue2.Enqueue("w", 3);
priorityQueue2.Enqueue("v", 2);
priorityQueue2.Enqueue("u", 1);
priorityQueue2.Enqueue("z", 1);
priorityQueue2.Enqueue("y", 2);
priorityQueue2.Enqueue("x", 3);
priorityQueue2.Enqueue("w", 4);
priorityQueue2.Enqueue("v", 5);
priorityQueue2.Enqueue("u", 6);
Assert.AreEqual(priorityQueue2.Count, 18);
priorityQueue2.Clear();
Assert.AreEqual(priorityQueue2.Count, 0);
}
public void Simple()
{
var priorityQueue = new PriorityQueue<int, int>(PriorityQueueType.Maximum);
Assert.IsFalse(priorityQueue.IsReadOnly);
priorityQueue.Add(4);
Assert.IsFalse(priorityQueue.IsReadOnly);
priorityQueue.Add(99);
Assert.IsFalse(priorityQueue.IsReadOnly);
priorityQueue.Clear();
Assert.IsFalse(priorityQueue.IsReadOnly);
}
public void Simple()
{
var priorityQueue1 = new PriorityQueue<int, int>(PriorityQueueType.Minimum);
priorityQueue1.Enqueue(4);
Assert.AreEqual(priorityQueue1.Count, 1);
Assert.AreEqual(priorityQueue1.Dequeue(), 4);
priorityQueue1.Enqueue(5);
priorityQueue1.Enqueue(6, 2);
Assert.AreEqual(priorityQueue1.Dequeue(), 5);
Assert.AreEqual(priorityQueue1.Dequeue(), 6);
priorityQueue1.Enqueue(6, 2);
priorityQueue1.Enqueue(5);
Assert.AreEqual(priorityQueue1.Dequeue(), 5);
Assert.AreEqual(priorityQueue1.Dequeue(), 6);
var priorityQueue2 = new PriorityQueue<string, int>(PriorityQueueType.Minimum);
priorityQueue2.Enqueue("a", 1);
priorityQueue2.Enqueue("b", 2);
priorityQueue2.Enqueue("c", 3);
priorityQueue2.Enqueue("d", 4);
priorityQueue2.Enqueue("e", 5);
priorityQueue2.Enqueue("f", 6);
priorityQueue2.Enqueue("z", 6);
priorityQueue2.Enqueue("y", 5);
priorityQueue2.Enqueue("x", 4);
priorityQueue2.Enqueue("w", 3);
priorityQueue2.Enqueue("v", 2);
priorityQueue2.Enqueue("u", 1);
priorityQueue2.Enqueue("z", 1);
priorityQueue2.Enqueue("y", 2);
priorityQueue2.Enqueue("x", 3);
priorityQueue2.Enqueue("w", 4);
priorityQueue2.Enqueue("v", 5);
priorityQueue2.Enqueue("u", 6);
Assert.AreEqual(priorityQueue2.Count, 18);
priorityQueue2.Clear();
Assert.AreEqual(priorityQueue2.Count, 0);
}
public void TestCount()
{
PriorityQueue <int> q = new PriorityQueue <int>(PriorityQueueType.MinPriorityQueue);
Assert.AreEqual(q.Count, 0);
q.Add(4);
Assert.AreEqual(q.Count, 1);
q.Add(99);
Assert.AreEqual(q.Count, 2);
q.Clear();
Assert.AreEqual(q.Count, 0);
}
public void PriorityQueueClear()
{
const int size = 2;
var pq = new PriorityQueue <int>(size);
pq.Add(1.0f, 0);
pq.Add(2.0f, 1);
Assert.AreEqual(1, pq.LastIndex);
pq.Clear();
Assert.AreEqual(-1, pq.LastIndex);
pq.Add(1.0f, 2);
pq.Add(2.0f, 3);
Assert.AreEqual(1, pq.LastIndex);
}
public void resetPath()
{
frontier.Clear();
cameFrom.Clear();
costSoFar.Clear();
if (previousPath.Count > 0)
{
foreach (Node node in previousPath)
{
node.GetComponent <MeshRenderer>().material.color = Color.white;
}
previousPath.Clear();
}
}
public void Simple()
{
var priorityQueue = new PriorityQueue <int, int>(PriorityQueueType.Minimum);
Assert.AreEqual(priorityQueue.Count, 0);
priorityQueue.Add(4);
Assert.AreEqual(priorityQueue.Count, 1);
priorityQueue.Add(99);
Assert.AreEqual(priorityQueue.Count, 2);
priorityQueue.Clear();
Assert.AreEqual(priorityQueue.Count, 0);
}
public void Simple()
{
var priorityQueue = new PriorityQueue <int, int>(PriorityQueueType.Minimum);
Assert.IsFalse(priorityQueue.IsReadOnly);
priorityQueue.Add(4);
Assert.IsFalse(priorityQueue.IsReadOnly);
priorityQueue.Add(99);
Assert.IsFalse(priorityQueue.IsReadOnly);
priorityQueue.Clear();
Assert.IsFalse(priorityQueue.IsReadOnly);
}
public void TestIsEmpty()
{
PriorityQueue <int> q = new PriorityQueue <int>(PriorityQueueType.MaxPriorityQueue);
Assert.AreEqual(q.IsEmpty, true);
q.Add(4);
Assert.AreEqual(q.IsEmpty, false);
q.Add(99);
Assert.AreEqual(q.IsEmpty, false);
q.Clear();
Assert.AreEqual(q.IsEmpty, true);
}
public void TestIsReadOnly()
{
PriorityQueue <int> q = new PriorityQueue <int>(PriorityQueueType.MinPriorityQueue);
Assert.AreEqual(q.IsReadOnly, false);
q.Add(4);
Assert.AreEqual(q.IsReadOnly, false);
q.Add(99);
Assert.AreEqual(q.IsReadOnly, false);
q.Clear();
Assert.AreEqual(q.IsReadOnly, false);
}
public void Can_clear_heap()
{
var heap = new PriorityQueue <int, int>(QueueType.Max, i => i);
heap.Push(1);
heap.Push(15);
heap.Push(8);
Assert.False(heap.IsEmpty);
Assert.Equal(3, heap.Count);
heap.Clear();
Assert.True(heap.IsEmpty);
Assert.Equal(0, heap.Count);
}
static void Main()
{
string decorationLine = new string('-', Console.WindowWidth);
Console.Write(decorationLine);
Console.WriteLine("***Presenting the functionality of the data structure 'Priority queue'***");
Console.Write(decorationLine);
PriorityQueue<int> numbers = new PriorityQueue<int>();
Console.WriteLine("---Enqueue operation---");
numbers.Enqueue(4);
numbers.Enqueue(-1);
numbers.Enqueue(3);
numbers.Enqueue(22);
numbers.Enqueue(16);
numbers.Enqueue(-9);
numbers.Enqueue(10);
numbers.Enqueue(14);
numbers.Enqueue(-48);
numbers.Enqueue(71);
Console.WriteLine("Count = " + numbers.Count);
Console.WriteLine();
Console.WriteLine("---Iterator functionality---");
PrintNumbersOnConsole(numbers);
Console.WriteLine();
Console.WriteLine("---Peek operation---");
int topNumber = numbers.Peek();
Console.WriteLine("Count = " + numbers.Count);
Console.WriteLine("The result from peek operation: " + topNumber);
Console.WriteLine("Queue after peek:");
PrintNumbersOnConsole(numbers);
Console.WriteLine();
Console.WriteLine("---Dequeue operation---");
int poppedNumber = numbers.Dequeue();
Console.WriteLine("The result from dequeue operation: " + poppedNumber);
Console.WriteLine("Count = " + numbers.Count);
Console.WriteLine("Queue after dequeue:");
PrintNumbersOnConsole(numbers);
Console.WriteLine();
Console.WriteLine("---Clear operation---");
numbers.Clear();
Console.WriteLine("Elements count after clearing: " + numbers.Count);
}
/// <summary>
/// スレッド内処理を実行します。
/// </summary>
void Run()
{
// スレッド ループ。
while (running)
{
// カメラの反映。
lock (cameraLock)
{
view = nextView;
projection = nextProjection;
eyePositionWorld = nextEyePositionWorld;
eyePositionPartition = nextEyePositionPartition;
}
// 比較オブジェクトの視錐台を更新。
Matrix viewProjection;
Matrix.Multiply(ref view, ref projection, out viewProjection);
comparer.Frustum.Matrix = viewProjection;
// 比較オブジェクトの視点位置を更新。
comparer.EyePositionWorld = eyePositionWorld;
// 候補を探索。
volume.ForEach(collectAction);
// 候補をマネージャへ通知。
while (0 < candidates.Count)
{
// 候補を取得。
var candidate = candidates.Dequeue();
// 非同期アクティブ化を実行。
// マネージャが実行許容量を超えた場合は通知を停止。
if (!manager.RequestActivatePartition(candidate.Position))
{
break;
}
}
// 候補キューをリセット。
candidates.Clear();
}
// 停止イベントをシグナル状態に。
stopEvent.Set();
}
public void SimpleTest()
{
var Test = new PriorityQueue <int>();
Test.Push(5);
Test.Push(12);
Test.Push(1);
Assert.IsTrue(Test[0] == 1, "Assert1 (should == 1) + " + Test[0]);
var i = Test.Pop();
Assert.IsTrue(i == 1, "i should equal 1" + i);
Assert.IsTrue(Test[0] == 5, "Assert2 (should == 5) + " + Test[0]);
i = Test.Pop();
Assert.IsTrue(i == 5, "i should equal 5" + i);
Assert.IsTrue(Test[0] == 12, "Assert3 (should == 12) + " + Test[0]);
i = Test.Pop();
Assert.IsTrue(i == 12, "i should = 12" + i);
Test.Push(11);
Test.Push(10);
Test.Push(9);
Test.Push(8);
Test.RemoveLocation(9);
Assert.IsTrue(Test[0] == 8, "Assert5 (Should equal 8) + " + Test[0]);
Test.Push(11);
Test.Push(10);
Test.Push(9);
Test.Push(8);
Assert.IsTrue(Test.Count == 7, "Assert6 (Should equal 7) + " + Test.Count);
Assert.IsTrue(Test.Peek() == 8, "Assert7 (Should equal 8) + " + Test.Peek());
Assert.IsTrue(Test.Pop() == 8, "Assert8 (Should equal 8)");
Assert.IsTrue(Test.Pop() == 8, "Assert8++ (should equal 8)");
Assert.IsTrue(Test.Peek() == 9, "Assert9 (Should equal 9) + " + Test.Peek());
Test.RemoveLocation(9);
Assert.IsTrue(Test.Peek() == 10);
Test.Clear();
Assert.IsTrue(Test.Count == 0, "Assert10 (Should equal 0) + " + Test.Count);
}
/// <summary>
/// Clears the DelegateScheduler of all tasks.
/// </summary>
public void Clear()
{
#region Require
if (disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
#endregion
lock (queue.SyncRoot)
{
queue.Clear();
tasks.Clear();
}
}
public void SimpleTest()
{
var Test = new PriorityQueue<int>();
Test.Push(5);
Test.Push(12);
Test.Push(1);
Assert.IsTrue(Test[0] == 1, "Assert1 (should == 1) + " + Test[0]);
var i = Test.Pop();
Assert.IsTrue(i == 1, "i should equal 1" + i);
Assert.IsTrue(Test[0] == 5, "Assert2 (should == 5) + " + Test[0]);
i = Test.Pop();
Assert.IsTrue(i == 5, "i should equal 5" + i);
Assert.IsTrue(Test[0] == 12, "Assert3 (should == 12) + " + Test[0]);
i = Test.Pop();
Assert.IsTrue(i == 12, "i should = 12" + i);
Test.Push(11);
Test.Push(10);
Test.Push(9);
Test.Push(8);
Test.RemoveLocation(9);
Assert.IsTrue(Test[0] == 8, "Assert5 (Should equal 8) + " + Test[0]);
Test.Push(11);
Test.Push(10);
Test.Push(9);
Test.Push(8);
Assert.IsTrue(Test.Count == 7, "Assert6 (Should equal 7) + " + Test.Count);
Assert.IsTrue(Test.Peek() == 8, "Assert7 (Should equal 8) + " + Test.Peek());
Assert.IsTrue(Test.Pop() == 8, "Assert8 (Should equal 8)");
Assert.IsTrue(Test.Pop() == 8, "Assert8++ (should equal 8)");
Assert.IsTrue(Test.Peek() == 9, "Assert9 (Should equal 9) + " + Test.Peek());
Test.RemoveLocation(9);
Assert.IsTrue(Test.Peek() == 10);
Test.Clear();
Assert.IsTrue(Test.Count == 0, "Assert10 (Should equal 0) + " + Test.Count);
}
static void Main()
{
var priQueue = new PriorityQueue<int>();
priQueue.Add(-5);
priQueue.Add(7);
priQueue.Add(9);
priQueue.Add(5);
priQueue.Add(1);
priQueue.Add(8);
priQueue.Remove();
foreach (var el in priQueue)
{
Console.WriteLine(el);
}
Console.WriteLine("Element count: {0}, Capacity: {1}", priQueue.Count, priQueue.Capacity);
priQueue.Clear();
Console.WriteLine("Element count: {0}, Capacity: {1}", priQueue.Count, priQueue.Capacity);
}
public void Count()
{
var pq = new PriorityQueue<int>();
Assert.AreEqual(0, pq.Count);
pq.Enqueue(123);
Assert.AreEqual(1, pq.Count);
pq.Enqueue(31);
pq.Enqueue(64);
Assert.AreEqual(3, pq.Count);
for (int i = 0; i < 30; i++)
pq.Enqueue(i);
pq.Peek();
pq.Dequeue();
pq.Dequeue();
Assert.AreEqual(31, pq.Count);
pq.Clear();
Assert.AreEqual(0, pq.Count);
}
public void Enumerator()
{
var pq = new PriorityQueue<int>();
for (int i = 0; i < 10; i++)
pq.Enqueue(i);
var list = new List<int>();
foreach (var i in pq)
{
Assert.IsTrue(!list.Contains(i));
list.Add(i);
}
Assert.AreEqual(pq.Count, list.Count);
Assert.Throws(typeof(InvalidOperationException), () =>
{
foreach (var i in pq)
{
pq.Enqueue(1);
}
});
Assert.Throws(typeof(InvalidOperationException), () =>
{
foreach (var i in pq)
{
pq.Dequeue();
}
});
Assert.Throws(typeof(InvalidOperationException), () =>
{
foreach (var i in pq)
{
pq.Remove(1);
}
});
Assert.Throws(typeof(InvalidOperationException), () =>
{
foreach (var i in pq)
{
pq.Clear();
}
});
}
public void Simple()
{
var priorityQueue1 = new PriorityQueue<int, int>(PriorityQueueType.Minimum) { 4 };
Assert.AreEqual(priorityQueue1.Count, 1);
Assert.AreEqual(priorityQueue1.Dequeue(), 4);
priorityQueue1.Add(5);
priorityQueue1.Add(6, 2);
Assert.AreEqual(priorityQueue1.Dequeue(), 5);
Assert.AreEqual(priorityQueue1.Dequeue(), 6);
priorityQueue1.Add(6, 2);
priorityQueue1.Add(5);
Assert.AreEqual(priorityQueue1.Dequeue(), 5);
Assert.AreEqual(priorityQueue1.Dequeue(), 6);
var priorityQueue2 = new PriorityQueue<string, int>(PriorityQueueType.Minimum)
{
{"a", 1},
{"b", 2},
{"c", 3},
{"d", 4},
{"e", 5},
{"f", 6},
{"z", 6},
{"y", 5},
{"x", 4},
{"w", 3},
{"v", 2},
{"u", 1},
{"z", 1},
{"y", 2},
{"x", 3},
{"w", 4},
{"v", 5},
{"u", 6}
};
Assert.AreEqual(priorityQueue2.Count, 18);
priorityQueue2.Clear();
Assert.AreEqual(priorityQueue2.Count, 0);
}
public void ClearExample()
{
var priorityQueue = new PriorityQueue<string, int>(PriorityQueueType.Minimum);
priorityQueue.Enqueue("cat");
priorityQueue.Enqueue("dog");
priorityQueue.Enqueue("canary");
// There should be 3 items in the priorityQueue.
Assert.AreEqual(3, priorityQueue.Count);
// Clear the priorityQueue
priorityQueue.Clear();
// The priorityQueue should be empty.
Assert.AreEqual(0, priorityQueue.Count);
// No cat here..
Assert.IsFalse(priorityQueue.Contains("cat"));
}
public bool Run(Board board, Position blank_pos, Board goal_board, ref List<Move> moves, int grid_size, ref int boards_searched, ref int open_list_size, ref long timer, ref long memory_used)
{
hf_ = new HelperFunctions();
if (hf_.CompareBoards(board, goal_board))
return true;
size_ = grid_size;
AStarNode root = new AStarNode(board, null, blank_pos, null);
AStarNode goal = new AStarNode(goal_board, null, null, null);
PriorityQueue open_q = new PriorityQueue();
HashSet<AStarNode> open_d = new HashSet<AStarNode>();
HashSet<AStarNode> closed_list = new HashSet<AStarNode>();
open_q.Add(root);
open_d.Add(root);
bool goal_found = false;
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
while(open_q.Size() > 0 && !goal_found) // && sw.ElapsedMilliseconds < 10000)
{
AStarNode next_node = open_q.GetNext();
open_d.Remove(next_node);
if (next_node.board_.Equals(goal.board_))
{
timer = sw.ElapsedMilliseconds;
sw.Stop();
goal_found = true;
goal = next_node;
continue;
}
List<AStarNode> successors = GetChildren(next_node);
foreach(AStarNode successor in successors)
{
if (hf_.CompareBoards(successor, closed_list))
continue;
successor.g = next_node.g + 1;
if (hf_.CompareBoards(successor, open_d))
continue;
successor.h = ManhattanDistance(successor.board_);
successor.f = successor.g + successor.h;
open_q.Add(successor);
open_d.Add(successor);
}
closed_list.Add(next_node);
}
memory_used = GC.GetTotalMemory(false);
open_list_size = open_q.Size();
boards_searched = closed_list.Count;
if(goal_found) TraverseTree(ref moves, goal);
closed_list.Clear();
open_d.Clear();
open_q.Clear();
GC.Collect();
return goal_found;
}