def test_length(self): q = PriorityQueue() assert q.length() == 0 q.enqueue('A', 5) assert q.length() == 1 q.enqueue('B', 1) assert q.length() == 2 q.dequeue() assert q.length() == 1 q.dequeue() assert q.length() == 0
def test_front(self): q = PriorityQueue() assert q.front() is None q.enqueue('A', 6) assert q.front() == 'A' q.enqueue('B', 10) assert q.front() == 'A' q.dequeue() assert q.front() == 'B' q.dequeue() assert q.front() is None
def test_front(self): pq = PriorityQueue() assert pq.front() is None pq.enqueue('A', 1) assert pq.front() == (1, 'A') pq.enqueue('B', 2) assert pq.front() == (1, 'A') pq.dequeue() assert pq.front() == (2, 'B') pq.dequeue() assert pq.front() is None
def test_dequeue(self): pq = PriorityQueue([(1, 'A'), (2, 'B'), (3, 'C')]) assert pq.dequeue() == (1, 'A') assert pq.length() == 2 assert pq.dequeue() == (2, 'B') assert pq.length() == 1 assert pq.dequeue() == (3, 'C') assert pq.length() == 0 assert pq.is_empty() is True with self.assertRaises(ValueError): pq.dequeue()
def test_is_empty(self): p = PriorityQueue() assert p.is_empty() is True p.enqueue('A', 1) assert p.is_empty() is False p.enqueue('B', 1) assert p.is_empty() is False p.dequeue() assert p.is_empty() is False p.dequeue() assert p.is_empty() is True
def test_length(self): pq = PriorityQueue() assert pq.length() == 0 pq.enqueue('A', 1) assert pq.length() == 1 pq.enqueue('B', 2) assert pq.length() == 2 assert pq.dequeue() == (1, 'A') assert pq.length() == 1 assert pq.dequeue() == (2, 'B') assert pq.length() == 0
def test_front(self): p = PriorityQueue() assert p.front() is None p.enqueue('A', 2) assert p.front() == 'A' p.enqueue('B', 2) assert p.front() == 'A' p.enqueue('C', 1) assert p.front() == 'C' p.dequeue() assert p.front() == 'A' p.dequeue() assert p.front() == 'B'
def test_dequeue(self): q = PriorityQueue() q.enqueue('A', 1) q.enqueue('B', 2) q.enqueue('C', 3) assert q.dequeue() == 'A' assert q.length() == 2 assert q.dequeue() == 'B' assert q.length() == 1 assert q.dequeue() == 'C' assert q.length() == 0 assert q.is_empty() is True with self.assertRaises(ValueError): q.dequeue()
def test_dequeue(self): p = PriorityQueue() assert p.heap.items == [] p.enqueue('A', 2) assert p.heap.items == [(2, 'A')] p.enqueue('B', 2) assert p.heap.items == [(2, 'A'), (2, 'B')] p.enqueue('C', 1) assert p.heap.items == [(1, 'C'), (2, 'B'), (2, 'A')] p.enqueue('D', 1) assert p.heap.items == [(1, 'C'), (1, 'D'), (2, 'A'), (2, 'B')] p.enqueue('E', 3) assert p.heap.items == [(1, 'C'), (1, 'D'), (2, 'A'), (2, 'B'), (3, 'E')] p.enqueue('F', 2) assert p.heap.items == [(1, 'C'), (1, 'D'), (2, 'A'), (2, 'B'), (3, 'E'), (2, 'F')] assert p.dequeue() == 'C' assert p.heap.items == [(1, 'D'), (2, 'B'), (2, 'A'), (2, 'F'), (3, 'E')] assert p.dequeue() == 'D' assert p.heap.items == [(2, 'A'), (2, 'B'), (3, 'E'), (2, 'F')] assert p.dequeue() == 'A' assert p.heap.items == [(2, 'B'), (2, 'F'), (3, 'E')] assert p.dequeue() == 'B' assert p.heap.items == [(2, 'F'), (3, 'E')] assert p.dequeue() == 'F' assert p.heap.items == [(3, 'E')] assert p.dequeue() == 'E' assert p.heap.items == [] with self.assertRaises(ValueError): p.dequeue()
def dijkstra_search(root, goal, init, domprob, nb_robots, width, height): """Dijkstra search of a solution in a graph. Returns a path if there is any. The priority of each node represent the cost (if each action costs 1) to go from the root to the node. Parameters: root: Node object, the root of the state graph we're searching and building at the same time. goal: bitvector, the state we're searching. init: bitvector, the initial state of the maze. domprob: Domain-Problem object from the pddlpy lib. nb_robots: integer, the number of robots in the maze. width, height: integers, the dimensions of the maze. """ # Priority queue pqueue = PriorityQueue() # an empty set to maintain visited nodes closed_set = set() # a dictionary for path formation meta = dict() # key -> (parent state, action to reach child) # Operator list op_list = list(domprob.operators()) # initialize pqueue.insert(root) meta[root] = (None, None) ground_op_bv = get_ground_operator( op_list, domprob, init, nb_robots, width, height) print("Taille de ground_op : {}".format(len(ground_op_bv[0]))) while not pqueue.empty(): subtree_root = pqueue.dequeue() current_priority = subtree_root.priority if is_goal(subtree_root, goal): return construct_path(subtree_root, meta) # Create current node's children for op in ground_op_bv: subtree_root.build_children(op) for (child, action) in subtree_root.children: # The node has already been processed, so skip over it if child in closed_set: continue # The child is not enqueued to be processed, # so enqueue this level of children to be expanded if child not in pqueue.queue: child.priority = current_priority + 1 # Update the path meta[child] = (subtree_root, action) # Enqueue this node pqueue.insert(child) closed_set.add(subtree_root)
class PQueueTestCase(unittest.TestCase): '''Test creation and use of a priority queue.''' def setUp(self): self.pq = PriorityQueue() self.r1 = Rectangle(0, 150, 200, 50, media.forestgreen, 1) self.o1= Oval(120, 160, 60, 60, media.white, 4) self.o2 = Oval(120, 115, 45, 45, media.yellow, 3) self.o3 = Oval(120, 80, 30, 30, media.orange, 2) def tearDown(self): self.pq = None self.r1 = None self.o1 = None self.o2 = None self.o3 = None def testSize(self): assert self.pq.size() == 0, 'mismatch in predicted pqueue size' def testEnqueueSize(self): self.pq.enqueue(self.r1) assert self.pq.size() == 1, \ 'mismatch in pqueue size after enqueue' def testDequeue(self): self.pq.enqueue(self.r1) result = self.pq.dequeue() assert result is self.r1, \ 'mismatch in dequeued value' def testMultipleEnqueueSize(self): self.pq.enqueue(self.o1) self.pq.enqueue(self.o2) self.pq.enqueue(self.o3) assert self.pq.size() == 3, \ 'mismatch in pqueue size after enqueues' def testMultipleDequeue(self): self.pq.enqueue(self.o1) self.pq.enqueue(self.o2) self.pq.enqueue(self.o3) result = self.pq.dequeue() assert result is self.o3, 'mismatch in dequeuing correct value'
def djkistra(sourceId: int, vertices: list, vertexDict: dict, edgeList: list): sourcePair = Pair(sourceId) visited = set() unvisited = PriorityQueue(contents=[sourcePair]) # build mapping labels -> vertexId & vertexId -> labels labelsDict = { int(v.attributes["label"].value): int(v.attributes["vertexId"].value) for v in vertices } labels = [labelsDict[i] for i in range(len(labelsDict))] previousLabelsDict = {v: k for k, v in labelsDict.items()} vertexDict[sourceId].setCost(0) vertexDict[sourceId].setPrevious(sourceId) while not unvisited.isEmpty(): currentPair = unvisited.dequeue() visited.add(currentPair.getVertexId()) currentVertex = vertexDict[currentPair.getVertexId()] # grab adjacents. adjacents = currentVertex.getAdjacents(edgeList) for e in adjacents: dist = vertexDict[currentVertex.vertexId].getCost() + e.weight for vertex in [e.v1, e.v2]: if vertex not in visited: if vertexDict[vertex].getCost() > dist: vertexDict[vertex].setCost(dist) vertexDict[vertex].setPrevious( currentVertex.getVertexId()) # heapq.heappush(unvisited, Pair(vertex, dist)) unvisited.enqueue(Pair(vertex, dist)) for i in range(len(visited)): print("Vertex:") print(" label: {}".format(i)) print(" cost: {:.2f}".format(vertexDict[labels[i]].getCost())) print(" previous: {}\n".format( previousLabelsDict[vertexDict[labelsDict[i]].getPrevious()])) return labelsDict
def test_length(self): p = PriorityQueue() p.enqueue('A', 1) assert p.length() == 1 p.enqueue('B', 1) assert p.length() == 2 p.enqueue('C', 2) assert p.length() == 3 p.dequeue() assert p.length() == 2 p.dequeue() assert p.length() == 1 p.dequeue() assert p.length() == 0
def dijkstra(source, graph): pQueue = PriorityQueue() graph[source]['dist'] = 0 for v in graph: pQueue.enqueue(v, graph[v]['dist']) while not pQueue.isEmpty(): u = pQueue.dequeue() baseDist = graph[u]['dist'] for w in graph[u]['edgeTo']: edgeLen = graph[u]['edgeTo'][w] newDist = baseDist + edgeLen currentDist = graph[w]['dist'] if newDist < currentDist: graph[w]['dist'] = newDist pQueue.changePriority(w, newDist) distanceList = [] for v in graph: distanceList.append((v, graph[v]['dist'])) return distanceList
def Astar(puzzle8, came_from): frontier = PriorityQueue() cost_so_far = {} frontier.enqueue(puzzle8, 0) cost_so_far[puzzle8.ToString()] = puzzle8.cost came_from[puzzle8.ToString()] = None while not frontier.is_empty(): puzzle8 = frontier.dequeue() if puzzle8.isGoal(): return puzzle8 else: moves = puzzle8.getAllMoves() for move in moves: newpuzzle8 = puzzle8.clone() newpuzzle8.move(*move) new_cost = newpuzzle8.cost if cost_so_far.get(newpuzzle8.ToString()) == None or \ new_cost < cost_so_far[newpuzzle8.ToString()]: cost_so_far[newpuzzle8.ToString()] = new_cost priority = new_cost + newpuzzle8.heuristics frontier.enqueue(newpuzzle8, priority) came_from[newpuzzle8.ToString()] = puzzle8 return None