public void Complex_maximum_priority_queue_test_with_multiple_operation()
{
IPriorityQueue <string, int> priorityQueue = CreateMaximumPriorityQueue <int>();
IPriorityQueueEntry <string> entry1 = priorityQueue.Enqueue("a", -1);
IPriorityQueueEntry <string> entry2 = priorityQueue.Enqueue("b", -2);
IPriorityQueueEntry <string> entry3 = priorityQueue.Enqueue("c", -3);
IPriorityQueueEntry <string> entry4 = priorityQueue.Enqueue("d", -4);
priorityQueue.UpdatePriority(entry1, -5);
priorityQueue.UpdatePriority(entry2, -5);
priorityQueue.UpdatePriority(entry1, -7);
priorityQueue.UpdatePriority(entry2, -1);
priorityQueue.UpdatePriority(entry4, -4);
priorityQueue.UpdatePriority(entry3, -6);
priorityQueue.UpdatePriority(entry1, -10);
Assert.AreEqual(-1, priorityQueue.PeekPriority);
Assert.AreEqual("b", priorityQueue.Dequeue());
Assert.AreEqual(-4, priorityQueue.PeekPriority);
Assert.AreEqual("d", priorityQueue.Dequeue());
Assert.AreEqual(-6, priorityQueue.PeekPriority);
Assert.AreEqual("c", priorityQueue.Dequeue());
Assert.AreEqual(-10, priorityQueue.PeekPriority);
Assert.AreEqual("a", priorityQueue.Dequeue());
Assert.AreEqual(0, priorityQueue.Count);
}
public void Clear_if_priority_queue_is_already_empty()
{
IPriorityQueue <string, int> priorityQueue = CreateMinimumPriorityQueue <int>();
priorityQueue.Clear();
Assert.AreEqual(0, priorityQueue.Count);
}
public void Complex_minimum_priority_queue_test_with_multiple_operation()
{
IPriorityQueue <string, int> priorityQueue = CreateMinimumPriorityQueue <int>();
IPriorityQueueEntry <string> entry1 = priorityQueue.Enqueue("a", 1);
IPriorityQueueEntry <string> entry2 = priorityQueue.Enqueue("b", 2);
IPriorityQueueEntry <string> entry3 = priorityQueue.Enqueue("c", 3);
IPriorityQueueEntry <string> entry4 = priorityQueue.Enqueue("d", 4);
priorityQueue.UpdatePriority(entry1, 5);
priorityQueue.UpdatePriority(entry2, 5);
priorityQueue.UpdatePriority(entry1, 7);
priorityQueue.UpdatePriority(entry2, 1);
priorityQueue.UpdatePriority(entry4, 4);
priorityQueue.UpdatePriority(entry3, 6);
priorityQueue.UpdatePriority(entry1, 10);
Assert.AreEqual(1, priorityQueue.PeekPriority);
Assert.AreEqual("b", priorityQueue.Dequeue());
Assert.AreEqual(4, priorityQueue.PeekPriority);
Assert.AreEqual("d", priorityQueue.Dequeue());
Assert.AreEqual(6, priorityQueue.PeekPriority);
Assert.AreEqual("c", priorityQueue.Dequeue());
Assert.AreEqual(10, priorityQueue.PeekPriority);
Assert.AreEqual("a", priorityQueue.Dequeue());
Assert.AreEqual(0, priorityQueue.Count);
}
public void Update_throws_exception_if_priority_is_null()
{
IPriorityQueue <string, string> priorityQueue = CreateMinimumPriorityQueue <string>();
IPriorityQueueEntry <string> entry = priorityQueue.Enqueue("Item", "1");
priorityQueue.UpdatePriority(entry, null);
}
public void Enqueue_two_item_with_non_comparable_priority()
{
IPriorityQueue <string, object> priorityQueue = CreateMinimumPriorityQueue <object>();
priorityQueue.Enqueue("Test1", new object());
priorityQueue.Enqueue("Test2", new object());
}
public void Enqueue_single_item_with_negative_priority()
{
IPriorityQueue <string, int> priorityQueue = CreateMinimumPriorityQueue <int>();
priorityQueue.Enqueue("Test", -1);
Assert.AreEqual(-1, priorityQueue.PeekPriority);
}
public void Update_throws_exception_if_entry_is_null()
{
IPriorityQueue <string, int> priorityQueue = CreateMinimumPriorityQueue <int>();
IPriorityQueueEntry <string> entry = priorityQueue.Enqueue("Item", 1);
priorityQueue.UpdatePriority(null, 0);
}
public void AddingExistingItemTest()
{
this._priorityQueue = new PriorityQueue <int, double>();
this._priorityQueue.Enqueue(1, 1);
Assert.ThrowsException <InvalidOperationException>(() => this._priorityQueue.Enqueue(1, 1));
}
public void UpdatePriorityBatchTest()
{
var testSize = 1000;
this._priorityQueue = new PriorityQueue <int, double>();
for (int i = 0; i < testSize; i++)
{
this._priorityQueue.Enqueue(i, i);
}
for (int i = 0; i < testSize; i++)
{
if (i % 2 == 0)
{
this._priorityQueue.UpdatePriority(i, double.MaxValue - i);
Debug.WriteLine(i);
}
}
for (int i = 0; i < testSize / 2; i++)
{
if (i % 2 != 0)
{
Assert.AreEqual(i, this._priorityQueue.Dequeue());
}
}
}
/// <summary>
/// Joins another heap to this heap.
/// </summary>
/// <param name="other">The other heap.</param>
public void Union(IPriorityQueue <TKey, TValue> other)
{
var casted = (BinaryHeap <TKey, TValue>)other;
list.AddRange(casted.list);
BuildHeap();
}
/// <summary>
/// Initializes a new instance of the AStar class.
/// </summary>
/// <param name="openSetCapacity">The max capacity of the open set.</param>
/// <param name="findDistance">A delegate to find the g distance.</param>
/// <param name="heuristic">A delegate to calculate the heuristic value.</param>
public AStar(int openSetCapacity, FindDistance findDistance, Heuristic heuristic)
{
this.closed = new List <Node>();
this.open = new BlueRajaWrapper <Node>(openSetCapacity);
this.findDistance = findDistance;
this.heuristic = heuristic;
}
public void PriorityQueue_08_BuildHeap(
[Values(
new int[] { 1 },
new int[] { 1, 2, 3, 4, 5, 6, 7, 8 },
new int[] { 8, 7, 6, 5, 4, 3, 2, 1 },
new int[] { 2, 1, 3, 8, 4, 7, 6, 5 },
new int[] { 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 }
)] int[] sequence,
[Values(
"1",
"1 2 3 4 5 6 7 8",
"1 4 2 5 8 3 6 7",
"1 2 3 5 4 7 6 8",
"1 2 6 3 10 8 7 4 12 11 19 9 15 18 14 5 13 17 20 16"
)] string expected)
{
// Arrange
IPriorityQueue <int> q = DSBuilder.CreatePriorityQueueEmpty();
foreach (int element in sequence)
{
q.AddFreely(element);
}
// Act
q.BuildHeap();
string actual = q.ToString();
// Assert
Assert.AreEqual(expected, actual);
}
public Solver(Graph g, IHeuristic heuristic, IPriorityQueue <PriorityQueueItem> queue)
{
_heuristic = heuristic;
graph = g;
queue.Clear();
priorityQueue = queue;
}
public PathFinder(byte[,] grid, PathFinderOptions pathFinderOptions = null)
{
if (grid == null)
{
throw new Exception("Grid cannot be null");
}
_grid = grid;
if (_mCalcGrid == null || _mCalcGrid.GetLength(0) != _grid.GetLength(0) || _mCalcGrid.GetLength(1) != _grid.GetLength(1))
{
_mCalcGrid = new PathFinderNodeFast[_gridX, _gridY];
}
_open = new PriorityQueueB <Point>(new ComparePfNodeMatrix(_mCalcGrid));
_options = pathFinderOptions ?? new PathFinderOptions();
_direction = _options.Diagonals
? new sbyte[, ] {
{ 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 }, { 1, -1 }, { 1, 1 }, { -1, 1 }, { -1, -1 }
}
: new sbyte[, ] {
{ 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 }
};
}
public LazyPrim(EdgeWeightedGraph graph) : base(graph)
{
marked = new bool[graph.VertexCount];
mst = new Queue <UndirectedEdge>();
priorityQueue = new HeapPriorityQueue <UndirectedEdge>(graph.EdgeCount);
Visit(0);
while (!priorityQueue.IsEmpty)
{
UndirectedEdge edge = priorityQueue.DeleteMax();
if (marked[edge.V] && marked[edge.W])
{
continue;
}
mst.Enqueue(edge);
if (!marked[edge.V])
{
Visit(edge.V);
}
if (!marked[edge.W])
{
Visit(edge.W);
}
}
foreach (var edge in mst)
{
weight += edge.Weight;
}
}
public void ReloadContent(ref Director dir)
{
mDirector = dir;
mAttackingUnits = new IntervalHeap <PrioritizableObject <EnemyUnit> >(new PrioritizableObjectAscendingComparer <EnemyUnit>());
mDefendingUnits = new IntervalHeap <PrioritizableObject <EnemyUnit> >(new PrioritizableObjectAscendingComparer <EnemyUnit>());
mScoutingUnits = new IntervalHeap <PrioritizableObject <EnemyUnit> >(new PrioritizableObjectAscendingComparer <EnemyUnit>());
mUnitToFlockingGroup = new Dictionary <EnemyUnit, FlockingGroup>();
foreach (var unit in mAllUnits)
{
var asFast = unit.GetObject() as EnemyFast;
var asHeavy = unit.GetObject() as EnemyHeavy;
if (asFast != null)
{
mScoutingUnits.Add(unit);
continue;
}
if (asHeavy != null)
{
mDefendingUnits.Add(unit);
continue;
}
mAttackingUnits.Add(unit);
}
}
/// <summary>
/// Initializes a new instance of the AStar class.
/// </summary>
/// <param name="openSetCapacity">The max capacity of the open set.</param>
/// <param name="findDistance">A delegate to find the g distance.</param>
/// <param name="heuristic">A delegate to calculate the heuristic value.</param>
public AStar(int openSetCapacity, FindDistance findDistance, Heuristic heuristic)
{
this.closed = new List<Node>();
this.open = new BlueRajaWrapper<Node>(openSetCapacity);
this.findDistance = findDistance;
this.heuristic = heuristic;
}
internal SchedulingService()
{
_timer = new Timer(TimerCallbackHandler);
_queue = new IntervalHeap <ScheduledJob>();
_namedEntries = new HashDictionary <string, JobExecutionWrapper>();
_logFactory = new DefaultLogFactory();
}
public void RandTest()
{
IPriorityQueue <int> priorityQueue = CreateInstance();
const int N = 100_000;
var values = new List <int>(N);
for (int i = 0; i < N; ++i)
{
values.Add(rand.Next());
priorityQueue.Insert(values[i]);
}
Assert.AreEqual(N, priorityQueue.Size, $"Size should be {N}");
values.Sort((a, b) => - 1 * a.CompareTo(b));
Assert.AreEqual(values[0], priorityQueue.Max(), $"Max should be {values[0]}");
int j = 0;
while (priorityQueue.Size > 0)
{
int val = priorityQueue.Max();
priorityQueue.DeleteMax();
Console.WriteLine($"{val} ");
Assert.AreEqual(values[j], val, 0, $"Current max should be {values[j]}");
j += 1;
}
Assert.AreEqual(j, N, $"Should have popped {j} values.");
}
public void PriorityQueue_07_AddFreely(
[Values(
new int[] { 1 },
new int[] { 1, 2, 3, 4, 5, 6, 7, 8 },
new int[] { 8, 7, 6, 5, 4, 3, 2, 1 },
new int[] { 2, 1, 3, 8, 4, 7, 6, 5 }
)] int[] sequence,
[Values(
"1",
"1 2 3 4 5 6 7 8",
"8 7 6 5 4 3 2 1",
"2 1 3 8 4 7 6 5"
)] string expected)
{
// Arrange
IPriorityQueue <int> q = DSBuilder.CreatePriorityQueueEmpty();
// Act
foreach (int element in sequence)
{
q.AddFreely(element);
}
string actual = q.ToString();
// Assert
Assert.AreEqual(expected, actual);
}
public void OrderTest()
{
IPriorityQueue <int> priorityQueue = CreateInstance();
int[] values = new int[] { 3, 2, 3, 1, 4, 5, 8, 1, -5, 0, -45, 1, 15 };
for (int i = 0; i < values.Length; ++i)
{
priorityQueue.Insert(values[i]);
}
Array.Sort(values);
Array.Reverse(values);
int j = 0;
while (priorityQueue.Size > 0)
{
int val = priorityQueue.Max();
priorityQueue.DeleteMax();
Console.WriteLine($"{val} ");
Assert.AreEqual(values[j], val, $"Current max should be {values[j]}");
j += 1;
}
Assert.AreEqual(j, values.Length, $"Should have popped {j} values.");
}
public static void Add <T>(this IPriorityQueue <T> queue, params T[] values)
{
foreach (var value in values)
{
queue.Add(value);
}
}
public GameController(Account account, TabPage tabPage)
{
tabPage.Text = account.AccountName + " - Speed: " + account.Speed.ToString();
PlayerAccount = account;
WebBrowser = (WebBrowser)tabPage.Controls.Find("webBrowser", true)[0];
WebBrowser.ScriptErrorsSuppressed = true;
StatusStrip ss = (StatusStrip)tabPage.Controls.Find("statusStrip1", true)[0];
ProgressBar = (ToolStripProgressBar)ss.Items.Find("tspbOpperationProgress", true)[0];
ProgressLabel = (ToolStripStatusLabel)ss.Items.Find("tsslOpperation", true)[0];
ProgressLabel.Text = "Starting up, starting login soon.";
Client = new CustomHttpClient(account);
HtmlReader = new HtmlReader();
WorkerPriorityQueue = new SimplePriorityQueue <IWorker, int>();
var loginWorker = new LoginWorker(PlayerAccount, Client, HtmlReader, WebBrowser, ProgressLabel, ProgressBar);
loginWorker.Worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
WorkerPriorityQueue.Enqueue(loginWorker, 0);
IWorker worker = WorkerPriorityQueue.Dequeue();
worker.StartWork();
}
public TW[] Dijkstra(TW maxWeight, int startIndex = 0)
{
Reset();
TW[] weights = new TW[N];
for (int i = 0; i < N; i++)
{
weights[i] = maxWeight;
}
weights[startIndex] = default(TW);
Status(startIndex, VStatus.Discovered);
IPriorityQueue <DijkstraNode> nodes = BuildDijkstraNodes(weights);
while (nodes.Count != 0)
{
DijkstraNode node = nodes.DelMax();
Status(node.Index, VStatus.Visited);
for (int u = FirstNbr(node.Index); -1 < u; u = NextNbr(node.Index, u))
{
if (Status(u) != VStatus.Visited)
{
Status(u, VStatus.Discovered);
if (Sum(weights[node.Index], Weight(node.Index, u)).CompareTo(weights[u]) < 0)
{
weights[u] = Sum(weights[node.Index], Weight(node.Index, u));
}
}
}
nodes = BuildDijkstraNodes(weights);
}
return(weights);
}
public WeightedFairQueueByteDistributor(IHttp2Connection connection, int maxStateOnlySize)
{
uint uMaxStateOnlySize = (uint)maxStateOnlySize;
if (uMaxStateOnlySize > SharedConstants.TooBigOrNegative)
{
ThrowHelper.ThrowArgumentException_PositiveOrZero(maxStateOnlySize, ExceptionArgument.maxStateOnlySize);
}
if (0u >= uMaxStateOnlySize)
{
_stateOnlyMap = EmptyDictionary <int, State> .Instance;
_stateOnlyRemovalQueue = EmptyPriorityQueue <State> .Instance;
}
else
{
_stateOnlyMap = new Dictionary <int, State>(maxStateOnlySize);
// +2 because we may exceed the limit by 2 if a new dependency has no associated IHttp2Stream object. We need
// to create the State objects to put them into the dependency tree, which then impacts priority.
_stateOnlyRemovalQueue = new PriorityQueue <State>(StateOnlyComparator.Instance, maxStateOnlySize + 2);
}
_maxStateOnlySize = maxStateOnlySize;
_connection = connection;
_stateKey = connection.NewKey();
IHttp2Stream connectionStream = connection.ConnectionStream;
_ = connectionStream.SetProperty(_stateKey, _connectionState = new State(this, connectionStream, 16));
// Register for notification of new streams.
connection.AddListener(this);
}
public SchedulingService()
{
_timer = new Timer(TimerCallbackHandler);
_queue = new IntervalHeap<ScheduledJob>();
_namedEntries = new HashDictionary<string, JobExecutionWrapper>();
_logFactory = new DefaultLogFactory();
}
private Node GoTo(Vector2 start, Vector2 target, BaseUnit unit)
{
if (DEBUG) Debug.Log(start + " " + target);
int h1 = GetManhattanDistance(start, target);
_priorityQueue = new BinaryHeap<Node>(25);
_priorityQueue.Enqueue(new Node(start, null, 0, h1));
Node bestGuess = null;
int heuristic = int.MaxValue;
while (heuristic > 0 && !_priorityQueue.IsEmpty())
{
bestGuess = _priorityQueue.Dequeue();
heuristic = bestGuess.Heuristic;
if (DEBUG) Debug.Log("Heruistic " + heuristic + " " + bestGuess.GetTotalCost());
if (heuristic == 0)
break;
Expand(bestGuess, ref target, unit);
if (DEBUG) Debug.Log("Size " + _priorityQueue.IsEmpty());
}
_closedSet.Clear();
_priorityQueue.Clear();
return bestGuess;
}
internal State(WeightedFairQueueByteDistributor distributor, int streamId, IHttp2Stream stream, int initialSize)
{
_distributor = distributor;
_stream = stream;
_streamId = streamId;
_pseudoTimeQueue = new PriorityQueue <State>(StatePseudoTimeComparator.Instance, initialSize);
}
protected BasePathSearch(IGraph <CellInfo> graph)
{
Graph = graph;
OpenQueue = new PriorityQueue <GraphConnection>(GraphConnection.ConnectionCostComparer);
StartPoints = new PriorityQueue <GraphConnection>(GraphConnection.ConnectionCostComparer);
MaxCost = 0;
}
public bool Merge(IPriorityQueue <J, T> q1, IPriorityQueue <J, T> q2)
{
bool executed = true;
while (!q1.IsEmpty())
{
T element = default(T);
J key = default(J);
if (q1.DeleteMin(out element, out key))
{
this.Insert(key, element);
}
}
while (!q2.IsEmpty())
{
T element = default(T);
J key = default(J);
if (q2.DeleteMin(out element, out key))
{
this.Insert(key, element);
}
}
return(executed);
}
public void InsertInRandomOrder_RemoveInOrder()
{
IPriorityQueue <int> priorityQueue = PriorityQueueFactory <int> .CreatePriorityQueue(HeapType.MIN, 4);
priorityQueue.Insert(3);
priorityQueue.Insert(2);
priorityQueue.Insert(1);
priorityQueue.Insert(5);
priorityQueue.Insert(4);
priorityQueue.Insert(10);
priorityQueue.Insert(8);
priorityQueue.Insert(7);
Queue <int> queue = new Queue <int>();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
queue.Enqueue(4);
queue.Enqueue(5);
queue.Enqueue(7);
queue.Enqueue(8);
queue.Enqueue(10);
while (!priorityQueue.IsEmpty())
{
var item = priorityQueue.Remove();
var itemExpected = queue.Dequeue();
Assert.AreEqual(item, itemExpected);
}
}
//初始化地图，在地图被更改之后调用
public void InitEngineForMap(IPositionSet_Connected map)
{
positionSet = map;
IPosition_Connected p;
//初始化
positionSet.InitToTraverseSet();
while (positionSet.NextPosition())
{
p = positionSet.GetPosition_Connected();
p.SetAttachment(new Tag());
}
int num = (int)(Math.Sqrt((double)positionSet.GetNum()));
path = new List <IPosition_Connected>(num * 2);
if (num > 0)
{
open = new PriorityQueue <IPosition_Connected>(num * 4, com);
}
else
{
open = new PriorityQueue <IPosition_Connected>(com);
}
}
public void PriorityQueue_05_Remove_01_OnEmptyQueue()
{
// Arrange
IPriorityQueue <int> q = DSBuilder.CreatePriorityQueueEmpty();
// Act & Assert
Assert.Throws(typeof(PriorityQueueEmptyException), () => q.Remove());
}
public bool FindPath(IMap map, int start, int target)
{
openList = new SimplePriorityQueue<int>();
openListLookup = new AStarNode?[map.NrNodes];
this.map = map;
this.isGoal = nodeId => nodeId == target;
this.getHeuristic = nodeId => map.GetHeuristic(nodeId, target);
Path = new List<int>();
FindPathAstar(start);
return true;
}
public DijkstraAnimation(Canvas c)
: base()
{
popped = new Nodes();
pushing = new Nodes();
incomingEdge = new Hashtable();
proposedWeight = new Hashtable();
pq = new BinaryPriorityQueue(Node.sortAscending());
graph = new Graph(); //empty graph until initialized.
this.c = c;
t = new Thread(new ThreadStart(Run));
}
public void SetUp()
{
this.priorityQueue = new PriorityQueue<string>();
this.itemA = "a";
this.itemB = "b";
this.keyA = 1.0;
this.keyB = 2.0;
}
public void Init()
{
this.PriorityQueue = this.CreateInstance();
}
private Node GoTo(Vector3 start, Vector3 target, BaseSoldier unit)
{
#if (FOUNDATION_DEBUG_PATHFINDER)
Log.Debug("PathFinder", "Go to (start={0}, target={1})", start, target);
#endif
int h1 = GetManhattanDistance(start, target);
_closedSet = new HashSet<int>();
_priorityQueue = new BinaryHeap<Node>(25);
_priorityQueue.Enqueue(new Node(start, null, 0, h1));
Node bestGuess = null;
int heuristic = int.MaxValue;
while (heuristic > 0 && !_priorityQueue.IsEmpty())
{
bestGuess = _priorityQueue.Dequeue();
heuristic = bestGuess.Heuristic;
#if (FOUNDATION_DEBUG_PATHFINDER)
Log.Debug("PathFinder", "heruistic={0}, best total cost={1}", heuristic, bestGuess.GetTotalCost());
#endif
if (heuristic == 0)
break;
Expand(bestGuess, ref target, unit);
#if (FOUNDATION_DEBUG_PATHFINDER)
Log.Debug("PathFinder", "queue empty={0}", _priorityQueue.IsEmpty());
#endif
}
_closedSet.Clear();
_priorityQueue.Clear();
return bestGuess;
}
public void Dispose()
{
queue = null; events = null;
}
protected BasePathSearch(IGraph<CellInfo> graph)
{
Graph = graph;
OpenQueue = new PriorityQueue<GraphConnection>(GraphConnection.ConnectionCostComparer);
StartPoints = new PriorityQueue<GraphConnection>(GraphConnection.ConnectionCostComparer);
Debug = false;
MaxCost = 0;
}
public void Init()
{
queue = new IntervalHeap<int>();
}
public void Dispose()
{
queue = null;
}
public void Init()
{
queue = new IntervalHeap<int>();
events = new ArrayList<KeyValuePair<Acts, int>>();
}
protected BasePathSearch(IGraph<CellInfo> graph)
{
Graph = graph;
OpenQueue = new PriorityQueue<CPos>(new PositionComparer(Graph));
startPoints = new PriorityQueue<CPos>(new PositionComparer(Graph));
Debug = false;
MaxCost = 0;
}
internal PriorityMessageQueue(IPriorityQueue<DateTime, IMessage> priorityQueue)
{
_messageQueue = priorityQueue;
}
