private void ExpandClusterOrder(List <ClusterOrderEntry <T> > clusterOrder, HashSet <T> processed, T dataObject) { var priorityQueue = new PriorityQueue <double, T>(); priorityQueue.Enqueue(double.PositiveInfinity, dataObject); while (!priorityQueue.IsEmpty) { PriorityQueueNode <double, T> node = priorityQueue.Dequeue(); double reachability = node.Priority; T current = node.Item; processed.Add(current); List <Tuple <T, double> > neighbors = _getNeighbors(current).OrderBy(n => n.Item2).ToList(); double coreDistance = double.PositiveInfinity; if (neighbors.Count >= _minPoints) { coreDistance = neighbors[_minPoints - 1].Item2; foreach (Tuple <T, double> neighbor in neighbors) { if (!processed.Contains(neighbor.Item1)) { priorityQueue.Enqueue(Math.Max(neighbor.Item2, coreDistance), neighbor.Item1); } } } clusterOrder.Add(new ClusterOrderEntry <T>(current, reachability, coreDistance)); } }
// Swaps the nodes at the given indexes. private void Swap(int index1, int index2) { PriorityQueueNode temp = m_heap[index1]; m_heap[index1] = m_heap[index2]; m_heap[index2] = temp; }
private void Swap(int i, int j) { PriorityQueueNode temp = _heap[i]; _heap[i] = _heap[j]; _heap[j] = temp; }
/// <summary> /// Enqueue work item. /// </summary> /// <remarks> /// Enqueuing is O(n), but since we re-enqueue the oldest originating time many times as it is processed by the pipeline, /// the dominant operation is to enqueue at the beginning of the queue /// </remarks> /// <param name="workitem">Work item to enqueue.</param> public void Enqueue(T workitem) { // reset the empty signal as needed if (this.count == 0) { this.empty.Reset(); } // take the head of the empty list int retries = this.emptyHead.Lock(); var newNode = this.emptyHead.Next; if (newNode != null) { this.emptyHead.Next = newNode.Next; } else { newNode = new PriorityQueueNode(Interlocked.Increment(ref this.nextId)); } this.emptyHead.Release(); newNode.Workitem = workitem; // insert it in the right place retries += this.Enqueue(newNode); this.counters?.Increment(PriorityQueueCounters.EnqueueingCount); this.counters?.Increment(PriorityQueueCounters.WorkitemCount); this.counters?.IncrementBy(PriorityQueueCounters.EnqueueingRetries, retries); }
private int Enqueue(PriorityQueueNode node) { // we'll insert the node between "previous" and "next" var previous = this.head; int retries = previous.Lock(); var next = this.head.Next; while (next != null && this.comparer(node.Workitem, next.Workitem) > 0) { retries += next.Lock(); previous.Release(); previous = next; next = previous.Next; } node.Next = previous.Next; previous.Next = node; // increment the count and signal the empty queue if needed, before releasing the previous node // If we didn't and this was a 0-1 transition of this.count, another thread could dequeue and go to -1, // we would still bring it back to 0, but we would miss signaling the empty queue. if (Interlocked.Increment(ref this.count) == 1) { this.empty.Reset(); } previous.Release(); return(retries); }
public void TestContains() { PriorityQueueNode node1 = new PriorityQueueNode(); PriorityQueueNode node2 = new PriorityQueueNode(); PriorityQueueNode node3 = new PriorityQueueNode(); int priority1 = this.RandomValue(); int priority2 = this.RandomValue(); // A newly created priority queue contains no elements. Assert.IsFalse(this.PriorityQueue.Contains(node1, priority1)); // Once a node is added to the priority queue with a certain priority, it's contained in it // but only for the specified priority. this.PriorityQueue.Enqueue(node1, priority1); Assert.IsTrue(this.PriorityQueue.Contains(node1, priority1)); Assert.IsFalse(this.PriorityQueue.Contains(node1, priority2)); this.PriorityQueue.Enqueue(node2, priority2); Assert.IsTrue(this.PriorityQueue.Contains(node1, priority1)); Assert.IsFalse(this.PriorityQueue.Contains(node1, priority2)); Assert.IsTrue(this.PriorityQueue.Contains(node2, priority2)); Assert.IsFalse(this.PriorityQueue.Contains(node2, priority1)); this.PriorityQueue.Enqueue(node3, priority1); Assert.IsTrue(this.PriorityQueue.Contains(node1, priority1)); Assert.IsFalse(this.PriorityQueue.Contains(node1, priority2)); Assert.IsTrue(this.PriorityQueue.Contains(node2, priority2)); Assert.IsFalse(this.PriorityQueue.Contains(node2, priority1)); Assert.IsTrue(this.PriorityQueue.Contains(node3, priority1)); Assert.IsFalse(this.PriorityQueue.Contains(node3, priority2)); }
internal void InsertFront(T new_data, U new_comparable)//if data needs to be put at front { PriorityQueueNode <T, U> new_node = new PriorityQueueNode <T, U>(new_data, new_comparable); new_node.next = this.head; this.head = new_node; }
public void PriorityQueueFillAndEmpty() { List <PriorityQueueNode> nodesToEnqueue = new List <PriorityQueueNode>() { new Node(new NodeData(uniqueKey: 0.ToString(), name: "A"), priority: 3), new Node(new NodeData(uniqueKey: 1.ToString(), name: "B"), priority: 2), new Node(new NodeData(uniqueKey: 2.ToString(), name: "C"), priority: 1), }; PriorityQueue pq = PriorityQueueFactory.CreatePriorityQueue(); foreach (Node node in nodesToEnqueue) { pq.Enqueue(node); } int expectedCount = pq.Count(); Assert.AreEqual(expectedCount, nodesToEnqueue.Count); int expectedPriority = 1; while (pq.Count() > 0) { PriorityQueueNode peek = pq.Peek(); PriorityQueueNode n = pq.Dequeue(); Assert.AreEqual(peek.Data.UniqueKey, n.Data.UniqueKey); Assert.AreEqual(n.Priority, expectedPriority); expectedPriority++; expectedCount--; Assert.AreEqual(pq.Count(), expectedCount); } }
public void RemoveBuildUnit(PriorityQueueNode <AssetBuildUnit> node) { lock (queueLock) { queue.Remove(node); } }
public void Enqueue(PriorityQueueNode node) { int lastIndex = Count(); PriorityQueueNodeWrapper wrapper = new PriorityQueueNodeWrapper(node); AttachNodeAtIndex(wrapper, lastIndex); SiftUp(lastIndex); }
private void SwapAndUpdateMap(int index1, int index2) { PriorityQueueNode node1 = this.minHeap[index1]; PriorityQueueNode node2 = this.minHeap[index2]; MapSwap(node1, node2); ArrayUtility.Swap(this.minHeap, index1, index2); }
// TODO: We will need a better API than exposing PriorityQueueNode<SchedulerEntry> before we can make this public. internal void Add(Action simpleAction, int priority = 0, object token = null) { var schedulerEntryNode = new PriorityQueueNode <SchedulerEntry>(new SchedulerEntry(simpleAction, priority) { Token = token }); Schedule(schedulerEntryNode, ScheduleMode.Last); }
private void MapSwap(PriorityQueueNode node1, PriorityQueueNode node2) { int tmp = this.nodeUniqueKeyToHeapIndexMap[node1.Data.UniqueKey]; this.nodeUniqueKeyToHeapIndexMap[node1.Data.UniqueKey] = this.nodeUniqueKeyToHeapIndexMap[node2.Data.UniqueKey]; this.nodeUniqueKeyToHeapIndexMap[node2.Data.UniqueKey] = tmp; }
public void Enqueue(T item, int priority) { EnsureCapacity(); int index = _count; _count++; _heap[index] = new PriorityQueueNode(item, priority); HeapifyUp(index); }
public MicroThread(Scheduler scheduler, MicroThreadFlags flags = MicroThreadFlags.None) { Id = Interlocked.Increment(ref globalCounterId); Scheduler = scheduler; ScheduledLinkedListNode = new PriorityQueueNode <MicroThread>(this); AllLinkedListNode = new LinkedListNode <MicroThread>(this); ScheduleMode = ScheduleMode.Last; Flags = flags; Tags = new PropertyContainer(this); }
internal void Unschedule(PriorityQueueNode <SchedulerEntry> schedulerEntry) { lock (ScheduledEntries) { if (schedulerEntry.Index != -1) { ScheduledEntries.Remove(schedulerEntry); } } }
private PriorityQueueNode <Chunk> GetNode(Chunk chunk) { PriorityQueueNode <Chunk> node; if (!c_nodes.TryGetValue(chunk.hashcode, out node)) { node = new PriorityQueueNode <Chunk>(chunk); } return(node); }
// TODO: We will need a better API than exposing PriorityQueueNode<SchedulerEntry> before we can make this public. internal PriorityQueueNode <SchedulerEntry> Add(Action simpleAction, int priority = 0, object token = null, ProfilingKey profilingKey = null) { var schedulerEntryNode = new PriorityQueueNode <SchedulerEntry>(new SchedulerEntry(simpleAction, priority) { Token = token, ProfilingKey = profilingKey }); Schedule(schedulerEntryNode, ScheduleMode.Last); return(schedulerEntryNode); }
public Graph GetTree() { // initialize the graph that will hold the MST Graph mst = new KevinGraph(); // initialize the priority queue that will hold the vertices outside the MST PriorityQueue remainingVertices = new KevinPriorityQueue(); foreach (GraphVertex v in weightedGraph.GetAllVertices()) { remainingVertices.Enqueue(new MSTPriorityQueueNode(data: v, priority: int.MaxValue)); } Dictionary <string, GraphEdge> lowestCostEdgeForVertex = new Dictionary <string, GraphEdge>(); while (remainingVertices.Count() > 0) { // Get the vertex with the lowest code to add to the MST // The first vertex is chosen arbitrarily because all vertices start with max cost. PriorityQueueNode currentNode = remainingVertices.Dequeue(); GraphVertex currentVertex = currentNode.Data as GraphVertex; // Add the vertex and its lowest cost edge (if any) to the MST mst.AddVertex(currentVertex.UniqueKey); if (lowestCostEdgeForVertex.ContainsKey(currentVertex.UniqueKey)) { GraphEdge lowestCostEdge = lowestCostEdgeForVertex[currentVertex.UniqueKey]; // TO-DO: why? mst.AddEdge(lowestCostEdge.SourceVertexUniqueKey, lowestCostEdge.TargetVertexUniqueKey, lowestCostEdge.Weight); mst.AddEdge(lowestCostEdge.TargetVertexUniqueKey, lowestCostEdge.SourceVertexUniqueKey, lowestCostEdge.Weight); } // update the minimum cost for each adjacent vertex, and the associated edge foreach (GraphEdge edge in currentVertex.GetIncidentEdges()) { GraphVertex edgeTarget = weightedGraph.GetVertexByUniqueKey(edge.TargetVertexUniqueKey); if (!remainingVertices.Contains(edgeTarget.UniqueKey)) { continue; } int newCost = edge.Weight; PriorityQueueNode targetNode = remainingVertices.Peek(edgeTarget.UniqueKey); if (newCost < targetNode.Priority) { remainingVertices.ChangePriority(targetNode.Data.UniqueKey, newCost); lowestCostEdgeForVertex[edgeTarget.UniqueKey] = edge; } } } return(mst); }
public MicroThread(Scheduler scheduler, MicroThreadFlags flags = MicroThreadFlags.None) { Id = Interlocked.Increment(ref globalCounterId); Scheduler = scheduler; ScheduledLinkedListNode = new PriorityQueueNode <SchedulerEntry>(new SchedulerEntry(this)); AllLinkedListNode = new LinkedListNode <MicroThread>(this); ScheduleMode = ScheduleMode.Last; Flags = flags; Tags = new PropertyContainer(this); cancellationTokenSource = new CancellationTokenSource(); }
/// <summary> /// The build (third) pass of the chunk manager. /// The Priority Queue for generation is rebuilt here. /// </summary> private void BuildPass(int offset_x, int offset_z) { this.chunkQueue.Clear(); foreach (Chunk chunk in this.c_generate.Values) { PriorityQueueNode <Chunk> node = GetNode(chunk); this.chunkQueue.Enqueue(node, (int)Distance(new Tuple <int, int>(offset_x, offset_z), new Tuple <int, int>(chunk.coordinates.GetX(CoordinateSpace.Chunk), chunk.coordinates.GetZ(CoordinateSpace.Chunk)))); } }
public List <GraphVertex> FindShortestPath( string startVertexUniqueKey, string targetVertexUniqueKey) { GraphVertex startVertex = weightedGraph.GetVertexByUniqueKey(startVertexUniqueKey); GraphVertex targetVertex = weightedGraph.GetVertexByUniqueKey(targetVertexUniqueKey); // initialize the 'prev' data structure that will hold the path Dictionary <string, GraphVertex> prev = new Dictionary <string, GraphVertex>(); // initialize the priority queue PriorityQueue remainingVertices = new KevinPriorityQueue(); foreach (GraphVertex v in weightedGraph.GetAllVertices()) { int totalPathWeightThroughCurrentVertex = v.UniqueKey == startVertex.UniqueKey ? 0 : int.MaxValue; remainingVertices.Enqueue( new ShortestPathPriorityQueueNode(data: v, priority: totalPathWeightThroughCurrentVertex)); } while (remainingVertices.Count() > 0) { PriorityQueueNode currentNode = remainingVertices.Dequeue(); GraphVertex currentVertex = currentNode.Data as GraphVertex; foreach (GraphEdge edge in currentVertex.GetIncidentEdges()) { GraphVertex edgeTarget = weightedGraph.GetVertexByUniqueKey(edge.TargetVertexUniqueKey); if (!remainingVertices.Contains(edgeTarget.UniqueKey)) { continue; } int newDist = currentNode.Priority + edge.Weight; PriorityQueueNode targetNode = remainingVertices.Peek(edgeTarget.UniqueKey); if (newDist < targetNode.Priority) { remainingVertices.ChangePriority(targetNode.Data.UniqueKey, newDist); prev[edgeTarget.UniqueKey] = currentVertex; } } if (currentVertex.UniqueKey == targetVertex.UniqueKey) { break; } } return(BuildPath(prev, startVertexUniqueKey, targetVertexUniqueKey)); }
internal void Schedule(PriorityQueueNode <SchedulerEntry> schedulerEntry, ScheduleMode scheduleMode) { var nextCounter = SchedulerCounter++; if (scheduleMode == ScheduleMode.First) { nextCounter = -nextCounter; } schedulerEntry.Value.SchedulerCounter = nextCounter; scheduledEntries.Enqueue(schedulerEntry); }
public void TestDequeue() { PriorityQueueNode node1 = new PriorityQueueNode(); PriorityQueueNode node2 = new PriorityQueueNode(); PriorityQueueNode node3 = new PriorityQueueNode(); int priority = this.RandomValue(); this.PriorityQueue.Enqueue(node1, priority); this.PriorityQueue.Enqueue(node2, priority + 1); Assert.AreEqual(node1, this.PriorityQueue.Dequeue()); this.PriorityQueue.Enqueue(node3, priority + 1); Assert.AreEqual(node2, this.PriorityQueue.Dequeue()); }
private void EnsureCapacity() { int capacity = _heap.Length; if (_count < capacity) { return; } var resized = new PriorityQueueNode[capacity * 2]; Array.Copy(_heap, 0, resized, 0, _count); _heap = resized; }
public void Update(Grid grid) { if (_startRow >= grid.RowCount || _startColumn >= grid.ColumnCount) { throw new ArgumentException("The grid is too small to hold source cell index", nameof(grid)); } GridCell sourceCell = grid[_startRow, _startColumn]; sourceCell.Tags.Add(PriorityNodeKey, CreatePriorityNode(sourceCell, 0)); foreach (GridCell cell in grid.GetCells().Where(cell => !sourceCell.Equals(cell))) { PriorityQueueNode <int, CellNodeValue> priorityQueueNode = CreatePriorityNode(cell, int.MaxValue); cell.Tags.Add(PriorityNodeKey, priorityQueueNode); } var priorityQueue = new PriorityQueue <CellNodeValue, int>(grid.Size); foreach (GridCell cell in grid.GetCells()) { PriorityQueueNode <int, CellNodeValue> cellTag = GetPriorityNodeOnCell(cell); priorityQueue.Enqueue(cellTag, cellTag.Priority); } while (priorityQueue.Count > 0) { PriorityQueueNode <int, CellNodeValue> minDistanceNode = priorityQueue.Dequeue(); GridCell minDistanceCell = minDistanceNode.Value.Current; foreach (GridCell neighbor in minDistanceCell.Links) { int altDistance = minDistanceNode.Priority + 1; PriorityQueueNode <int, CellNodeValue> neighborNode = GetPriorityNodeOnCell(neighbor); if (altDistance < neighborNode.Priority) { neighborNode.Value.Previous = minDistanceCell; priorityQueue.UpdatePriority(neighborNode, altDistance); } } } foreach (GridCell cell in grid.GetCells()) { PriorityQueueNode <int, CellNodeValue> node = GetPriorityNodeOnCell(cell); cell.Tags.Remove(PriorityNodeKey); cell.Tags[ResolvingDistance] = node.Priority; } }
public void TestEnumeration() { const int NodeCount = 18; var q = new AlternativePriorityQueue <double, object>(NodeCount); var random = new Random(); var nodes = new PriorityQueueNode <double, object> [NodeCount]; for (int i = 0; i < NodeCount; i++) { nodes[i] = new PriorityQueueNode <double, object>((object)null); q.Enqueue(nodes[i], random.NextDouble()); } CollectionAssert.AreEquivalent(nodes, q); }
public void ChangePriority(string nodeUniqueKey, int priority) { int heapIndex = GetPriorityQueueNodeIndex(nodeUniqueKey); PriorityQueueNode node = minHeap[heapIndex]; if (priority < node.Priority) { node.Priority = priority; SiftUp(heapIndex); } else if (priority > node.Priority) { node.Priority = priority; SiftDown(heapIndex); } }
public void Add(T new_data, U new_compareable) //sorted add { if (next == null) //is this the end of the list { next = new PriorityQueueNode <T, U>(new_data, new_compareable); //append data } else if (next.compareable.CompareTo(new_compareable) < 0) //is the new data larger than next? { next.Add(new_data, new_compareable); //pass it to the next node to check } else//current value is smaller than next so needs to be linked in here { PriorityQueueNode <T, U> temp = new PriorityQueueNode <T, U>(new_data, new_compareable); temp.next = next; next = temp; } }
public void TestContainsConsistency() { var q = new AlternativePriorityQueue <int, int>(); addRandomItems(q, 150); var missingNode = new PriorityQueueNode <int, int>(14); var presentNode = new PriorityQueueNode <int, int>(14); q.Enqueue(presentNode, 75); Assert.True(q.Contains(presentNode)); Assert.False(q.Contains(missingNode)); q.Remove(presentNode); Assert.False(q.Contains(presentNode)); CheckOrder(q); }