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