def trace_back(goal_node, start_node, v_distances, visited_nodes, n, mazearray, diags=False): # begin the list of nodes which will represent the path back, starting with the end node path = [goal_node] current_node = goal_node # Set the loop in motion until we get back to the start while current_node != start_node: # Start an empty priority queue for the current node to check all neighbours neighbour_distances = PriorityQueue() neighbours = get_neighbours(current_node, n, diags) # Had some errors during testing, not sure if this is still necessary try: distance = v_distances[current_node] except Exception as e: print(e) # For each neighbour of the current node, add its location and distance # to a priority queue for neighbour, ntype in neighbours: if neighbour in v_distances: distance = v_distances[neighbour] neighbour_distances.push(distance, neighbour) # Pop the lowest value off; that is the next node in our path distance, smallest_neighbour = neighbour_distances.pop() mazearray[smallest_neighbour[0]][smallest_neighbour[1]].update(is_path=True) path.append(smallest_neighbour) current_node = smallest_neighbour mazearray[start_node[0]][start_node[1]].update(is_path=True)
def _shortest_paths(self, start): # Compute a shortest path from start to each other node, if it exists. assert self.has_node(start) infinity = float('infinity') # Keep the nodes ordered by distance from the start node. to_visit = PriorityQueue() # All nodes are initially unreachable from the start node. for node in self.nodes(): self._nodes[node]['distance'] = infinity self._nodes[node]['from'] = None to_visit.enqueue(node, infinity) # Correct the distance of the start node. self._nodes[start]['distance'] = 0 to_visit.set_priority(start, 0) while not to_visit.is_empty(): node = to_visit.dequeue() node_distance = self._nodes[node]['distance'] for neighbour in self.neighbours(node): neighbour_distance = self._nodes[neighbour]['distance'] # Compute the new distance to neighbour, going through node. edge_distance = self._edges[node][neighbour] new_distance = node_distance + edge_distance # If it's shorter going this way, update the distance and path. if new_distance < neighbour_distance: self._nodes[neighbour]['distance'] = new_distance self._nodes[neighbour]['from'] = node to_visit.set_priority(neighbour, new_distance)
def prim(g, n): # Set initial condition for Prim algorithm parent = [None] * n toVisit = [True] * n pq = PriorityQueue() for u in range(n): if u == 0: pq.push([0, u]) else: pq.push([sys.maxint, u]) while not pq.empty(): cost, u = pq.pop() toVisit[u] = False for v in range(0, n): if g[u][v] and toVisit[v] and g[u][v] < pq[v]: parent[v] = u pq.push([g[u][v], v]) print("(origem, destino) -> custo") for i in range(1, n): print("({}, {}) -> {}".format(parent[i], i, g[i][parent[i]])) print("Custo total: {}".format(sum(g[i][parent[i]] for i in range(1, n))))
class Parser(object): """docstring for Parser""" def __init__(self, proxies): super(Parser, self).__init__() self.proxies = proxies self.companies = PriorityQueue() self.parsed = set() def add(self, url, priority = float('inf')): if not url in self.parsed: self.companies.push(url, priority) def pop(self): try: companyID = self.companies.pop() while not companyID: companyID = self.companies.pop() return companyID except IndexError, e: return None except Exception, e: raise
def shortest_path2exit2(self, startsquare): pq = PriorityQueue() distance = dict() pred = dict() on_border = set() for square in self.open_squares(): pq.set_priority(square, Maze.infty) if self.isborder(square): on_border.add(square) pq.set_priority(startsquare, 0) distance[startsquare] = 0 while not pq.is_empty(): square = pq.extract_min() if not square in distance: continue dsquare = distance[square] + 1 for next_sq in self.neighbors(square): if next_sq in pq and \ ((not next_sq in distance) or dsquare < distance[next_sq]): distance[next_sq] = dsquare pq.set_priority(next_sq, dsquare) pred[next_sq] = square min_dist = None min_b = None for b in on_border: if min_dist is None or min_dist > distance[b]: min_dist = distance[b] min_b = b b = min_b path = list() while b != startsquare: path.append(b) b = pred[b] path.append(startsquare) return min_dist, list(reversed(path))
def Dijkstra_algorithm(graph: Graph, starting_node: int) -> DijkstraAlgorithmResult: dist = [INFINITY for _ in range(graph.nodes_count)] prev = [None for _ in range(graph.nodes_count)] dist[starting_node] = 0 prev[starting_node] = starting_node # prepare list of tuples of nodes labels with their starting distances dist_nodes = [ PQNode(key=i, priority=dist[i]) for i in range(0, graph.nodes_count) ] Q = PriorityQueue(raw=dist_nodes) while not Q.is_empty: # pick the closest node fst = Q.pop().key for e in graph.get_neighbourhood(fst): # scan the neighbourhood snd = e.snd weight = e.weight if dist[snd] > dist[fst] + weight: # update if better route found dist[snd] = dist[fst] + weight prev[snd] = fst Q.bottom_bound_flatten_priority(snd, dist[snd]) return DijkstraAlgorithmResult(dist=dist, prev=prev)
def trace_back(goal_node, start_node, v_distances, visited_nodes, n, mazearray, diags=False, visualise=VISUALISE): path = [goal_node] current_node = goal_node while current_node != start_node: neighbour_distances = PriorityQueue() neighbours = get_neighbours(current_node, n, diags) try: distance = v_distances[current_node] except Exception as e: print(e) for neighbour, ntype in neighbours: if neighbour in v_distances: distance = v_distances[neighbour] neighbour_distances.push(distance, neighbour) distance, smallest_neighbour = neighbour_distances.pop() mazearray[smallest_neighbour[0]][smallest_neighbour[1]].update(is_path=True) draw_square(smallest_neighbour[0],smallest_neighbour[1],grid=mazearray) path.append(smallest_neighbour) current_node = smallest_neighbour pygame.display.flip() mazearray[start_node[0]][start_node[1]].update(is_path=True)
def test_insert(): """Test if value is inserted into the queue.""" from priority_queue import PriorityQueue pq = PriorityQueue() item = (1, 'value') pq.insert(item) assert pq.container[0] == (1, 'value')
def test_pop(): """Test if removes highest priority.""" from priority_queue import PriorityQueue pq = PriorityQueue() pq.container = [(2, 'fish'), (3, 'sticks'), (4, 'chix'), (10, 'ticks')] pq.pop() assert pq.container == [(10, 'ticks'), (3, 'sticks'), (4, 'chix')]
def test_PriorityQueue_RemoveElement_ElementIsRemoved(self): priority_queue = PriorityQueue() priority_queue.add("a") priority_queue.remove("a") self.assertFalse("a" in priority_queue)
def __init__(self, world, s_start: (int, int), s_goal: (int, int), view_range=2): # init the graphs self.est_global_map = OccupancyGridMap(x_dim=world.x_dim, y_dim=world.y_dim, exploration_setting='8N') # real_graph self.gt_global_map: OccupancyGridMap = world # init variables self.view_range = view_range self.position = s_start self.goal = s_goal self.back_pointers = {} # procedure initialize self.U = PriorityQueue() self.k_m = 0 self.RHS_VALS = {} self.G_VALS = {} # empty set self.RHS_VALS[s_goal] = 0.0 self.U.insert(s_goal, self.calculate_key(s_goal)) # keeps track of the best path starting from goal to our position self.back_pointers[self.goal] = None # replan self.compute_shortest_path(s_start=s_start)
def color_most_constrained_first(graphs, color): global spills, unspillable, num_unused, used_registers if debug: print 'starting color_most_constrained_first' for v in graphs.vertices(): used_registers[v] = set([]) num_unused[v] = len(registers) - len(used_registers[v]) left = set(graphs.vertices()) - set(reserved_registers) - set(registers) queue = PriorityQueue(left, avail_reg_then_unspill) while not queue.empty(): v = queue.pop() if debug: print 'next to color is ' + v if v not in color.keys(): c = choose_color(v, color, graphs) color[v] = c if debug: print 'color of ' + str(v) + ' is ' + str(c) for u in graphs.interferes_with(v): #if u in graphs.vertices(): used_registers[u] |= set([c]) num_unused[u] = len(registers) - len(used_registers[u]) queue.update(u) if not is_reg(c): spills += 1 # spills happen to unspillable in test2.py on schof! -Jeremy # if v in unspillable[0]: # raise Exception('spilled an unspillable! ' + v) if debug: print 'finished with color_most_constrained_first' return color
def color_most_constrained_first(graphs, color): global spills, unspillable, num_unused, used_registers if debug: print 'starting color_most_constrained_first' for v in graphs.vertices(): used_registers[v] = set([]) num_unused[v] = len(registers) - len(used_registers[v]) left = set(graphs.vertices()) - set(reserved_registers) - set(registers) queue = PriorityQueue(left, avail_reg_then_unspill) while not queue.empty(): v = queue.pop() if debug: print 'next to color is ' + v if v not in color.keys(): c = choose_color(v, color, graphs,False) color[v] = c for u in graphs.interferes_with(v): #if u in graphs.vertices(): queue.update(u) used_registers[u] |= set([c]) num_unused[u] = len(registers) - len(used_registers[u]) if not is_reg(c): spills += 1 # spills happen to unspillable in hw6! -Jeremy # Also, register allocation takes too long on some programs. # if v in unspillable[0]: # raise Exception('spilled an unspillable! ' + v) return color
def __init__(self, map: OccupancyGridMap, s_start: (int, int, int), s_goal: (int, int, int)): """ :param map: the ground truth map of the environment provided by gui :param s_start: start location :param s_goal: end location """ ## we need to also update our occupancy grid map self.new_edges_and_old_costs = None # algorithm start self.s_start = s_start # now takes in an x, y and z self.s_goal = s_goal # now takes in an x, y and z self.s_last = s_start # now takes in an x, y and z self.k_m = 0 # accumulation self.U = PriorityQueue() self.rhs = np.ones((map.x_dim, map.y_dim, map.z_dim)) * np.inf self.g = self.rhs.copy() self.sensed_map = OccupancyGridMap(x_dim=map.x_dim, y_dim=map.y_dim, z_dim=map.z_dim, exploration_setting='26N') self.rhs[self.s_goal] = 0 self.U.insert(self.s_goal, Priority(heuristic(self.s_start, self.s_goal), 0))
def test_not_empty(self): """ A queue with one enqueued value is not empty. """ pq = PriorityQueue() pq.enqueue(Job(1, 'People')) self.assertFalse(pq.is_empty())
def __init__(self, board, data): self.board = board self.data = data self.forward_begin_state = State(self.board, None, None, 0, 0, 0) self.forward_data = Data(data.board_num, data.heuristic, data.time_limit, data.indicators, data.given_solution, data.min_cost_path, data.use_difficulty) self.forward_data.bidirectional_direction = BidirectionalDirection.FORWARD self.forward_f_values = dict() self.forward_open_list = PriorityQueue() self.forward_closed_list = set() state = self.forward_begin_state.run_steps_on_board(data, False, False) self.backward_begin_state = State(state.board, None, None, 0, 0, 0) self.backward_data = Data(data.board_num, data.heuristic, data.time_limit, data.indicators, data.given_solution, data.min_cost_path, data.use_difficulty) self.backward_data.bidirectional_direction = BidirectionalDirection.BACKWARD self.backward_f_values = dict() self.backward_open_list = PriorityQueue() self.backward_closed_list = set() self.forward_data.goal_board = self.backward_begin_state.board self.backward_data.goal_board = self.forward_begin_state.board f = self.forward_begin_state.calculate_f(self.forward_data) self.forward_begin_state.f_value = f self.forward_f_values[hash(self.forward_begin_state.board.grid_to_str())] = f self.forward_open_list.push(self.forward_begin_state) f = self.backward_begin_state.calculate_f(self.backward_data) self.backward_begin_state.f_value = f self.backward_f_values[hash(self.backward_begin_state.board.grid_to_str())] = f self.backward_open_list.push(self.backward_begin_state) self.forward_prev_state = None self.backward_prev_sate = None
def build_tree(self, text): """ Users letter frequency found in text to construct the Huffman tree :param text: Input text to use for calculating letter frequencies """ if not text: raise ValueError self.input = text self.char_freqs = frequencies(self.input) pqueue = PriorityQueue() for k, v in self.char_freqs.items(): pqueue.push(HuffmanNode([k], v, None, None)) left = pqueue.pop() right = pqueue.pop() while left and right: pqueue.push( HuffmanNode(left.char_list + right.char_list, left.freq + right.freq, left, right)) left = pqueue.pop() right = pqueue.pop() self.head = left self.code_dict = {} for c in self.head.char_list: self.code_dict[c] = self.get_code(c)
def test_priority_queue(make_jobs): pq = PriorityQueue() assert pq.jobs == [] assert pq._iterations == 0 pq = PriorityQueue(make_jobs) temp = [p.priority for p in pq.jobs] assert temp == [9, 9, 9, 7, 8, 3, 7, 3, 7, 4]
def prims_mst_alt(g): visited = set() # visited set, already in MST pq = PriorityQueue() # For edges mst = [] # result as a list of edges N = g.num_vert start = 5 # Arbitrarily choose a start node. while len(mst) < N-1: node = g.vert_list[start] visited.add(start) # Check all the neighbours and add them to PQ if needed. for neigh in node.get_neighs(): if neigh not in visited: key = node.get_weight(neigh) edge = (start, neigh, key) pq.decrease_priority(edge, key) while pq.length > 0: u, v, w = pq.extract_min() if v not in visited: break else: print('disconnected') return mst.append((u, v, w)) start = v print(mst)
def a_star(self, map, start, goal): rospy.loginfo("Executing A* from (%d,%d) to (%d,%d)" % (start[0], start[1], goal[0], goal[1])) queue = PriorityQueue(start) visited = set() came_from = {} while queue: #self.yeet(map, visited, queue.get_elements()) element, previous_element = queue.pop() visited.add(element) came_from[element] = previous_element if element == goal: path = [element] while came_from[element]: element = came_from[element] path.append(element) return path[::-1] [ queue.put( (map.euclidean_distance(start, e) + map.euclidean_distance(e, goal) + 100 * map.euclidean_distance(e, element), e, element)) for e in map.get_neighbors(element, threshold2=0) if e not in visited and e not in queue.get_elements() ]
def run_reverse_a_star(self, show_maze=False): if show_maze: maze_vis = MazeVisualization(self.maze) re_compute = True print("Bot's destination is - row: {}, col: {}".format( self.maze.goal.row, self.maze.goal.col)) traversed_path = list() while re_compute: manhattan_heuristic = Utils.compute_heuristic( self.maze, self.bot.pos) start_row = self.maze.goal.row start_col = self.maze.goal.col my_queue = PriorityQueue() my_queue.push(0, manhattan_heuristic[start_row][start_col], self.bot.bot_maze.get_cell(start_row, start_col), None) path = self.compute_path(my_queue, manhattan_heuristic) if path is None: print("Path does not exist") return None, None traversed_path.extend(self.bot.traverse_path(path)) if self.bot.pos.get_co_ordinates( ) == self.maze.goal.get_co_ordinates(): re_compute = False if show_maze: Utils.print_path(traversed_path, maze_vis, "Reverse A*", self.maze.start, self.maze.goal) maze_vis.show_maze() return self.pop_counter, len(traversed_path)
def dijkstra(g, n, origin=0): # Set initial condition for dijkstra algorithm toVisit = [True] * n dist = [sys.maxint] * n pq = PriorityQueue() for u in range(n): if u == origin: pq.push([0, u]) else: pq.push([sys.maxint, u]) while not pq.empty(): cost, u = pq.pop() toVisit[u] = False for v in range(0, n): if g[u][v] != 0 and toVisit[v] and cost + g[u][v] < pq[v]: pq.push([g[u][v] + cost, v]) dist[v] = pq[v] print("(origem, destino) -> custo") for i in range(1, n): print("({}, {}) -> {}".format(origin, i, dist[i]))
def run_a_star_with_agent(self): maze_vis = MazeVisualizer(self.maze) re_compute = True traversed_path = list() manhattan_heuristic = Utils.compute_heuristic(self.maze, self.maze.end) while re_compute: start_row = self.agent.current_loc.row start_col = self.agent.current_loc.col my_queue = PriorityQueue() my_queue.push(0, manhattan_heuristic[start_row][start_col], self.agent.agent_maze.get_cell(start_row, start_col), None) path = self.compute_path(my_queue, manhattan_heuristic) if path is None: print("Path does not exist") return None, None traversed_path.extend(self.agent.traverse_path(path)) if self.agent.current_loc.get_co_ordinates( ) == self.maze.end.get_co_ordinates(): re_compute = False Utils.print_path(traversed_path, maze_vis, "A*", self.maze.start, self.maze.end) print("\nTotal popped nodes are: ", self.pop_counter) maze_vis.show_maze() return self.pop_counter, len(traversed_path)
def run_adaptive_a_star(self): maze_vis = MazeVisualizer(self.maze) traversed_path = [self.agent.current_loc] re_compute = True print("Agent's destination is - row: {}, col: {}".format( self.maze.end.row, self.maze.end.col)) while re_compute: start_row = self.agent.current_loc.row start_col = self.agent.current_loc.col my_queue = PriorityQueue() my_queue.push(0, self.heuristics[start_row][start_col], self.agent.agent_maze.get_cell(start_row, start_col), None) path = self.compute_path(my_queue) if path is None: print("Path does not exists\n") return None, None traversed_path.extend(self.agent.traverse_path(path)) if self.agent.current_loc.get_co_ordinates( ) == self.maze.end.get_co_ordinates(): re_compute = False print("Adaptive * path exists\n") self.update_heuristics(traversed_path) Utils.print_path(traversed_path, maze_vis, "Adaptive A*", self.maze.start, self.maze.end) maze_vis.show_maze() return self.pop_counter, len(traversed_path)
def test_assign_priority_via_insert(): new_pq = PriorityQueue() for i in range(5): new_pq.insert(Job(priority= i+1)) new_pq.jobs[-1].time_created -= 100 new_pq.insert(Job(priority=6)) assert [job.priority for job in new_pq.jobs] == [8,5,6,1,4,2]
def execute_algorithm(self, show_maze=False): if show_maze: maze_vis = MazeVisualization(self.maze) traversed_path = [self.bot.pos] re_compute = True print("Bot's destination is - row: {}, col: {}".format( self.maze.goal.row, self.maze.goal.col)) while re_compute: start_row = self.bot.pos.row start_col = self.bot.pos.col my_queue = PriorityQueue() my_queue.push(0, self.heuristics[start_row][start_col], self.bot.bot_maze.get_cell(start_row, start_col), None) path = self.find_path(my_queue) if path is None: print("Path does not exists\n") return None, None traversed_path.extend(self.bot.traverse_path(path)) if self.bot.pos.get_co_ordinates( ) == self.maze.goal.get_co_ordinates(): re_compute = False self.time_end = time.time() print("Adaptive * path exists\n") self.update_heuristics(traversed_path) if show_maze: Utils.print_path(traversed_path, maze_vis, "Adaptive A*", self.maze.start, self.maze.goal) maze_vis.show_maze() return self.pop_counter, len(traversed_path) - 1
class Search: def __init__(self, goal_state, search_type="bfs"): self.goal_state = goal_state self.open_list = PriorityQueue() self.closed_list = [] self.id_count = 1 self._open_list_pop_count = 0 self._open_list_add_count = 0 self._closed_list_add_count = 0 self.search_type = search_type def swapPositions(self, lst, pos1, pos2): lst[pos1], lst[pos2] = lst[pos2], lst[pos1] return lst def getPathTaken(self, goal): path = [goal] node = goal found_original = False while not found_original: for closed in self.closed_list: if node.parent_stateid == closed.stateid: node = closed path.append(node) if node.stateid == 1: found_original = True break path.reverse() return path def getOpenListNode(self): self._open_list_pop_count += 1 return self.open_list.pop() def checkForDuplicates(self, nodes): to_pop = [] for i in nodes: for k in self.closed_list: if i.state == k.state: to_pop.append(i) break for j in self.open_list: if i.state == j.state: if i.priority > j.priority: self.open_list.remove(j) else: to_pop.append(i) break for item in to_pop: nodes.remove(item) return nodes def returnResults(self, path): return ( "Length Of Path To Get To Goal: {}".format(len(path)), "Nodes Pushed To Open List: {}".format(self._open_list_add_count), "Nodes Pushed To Closed List: {}".format( self._closed_list_add_count), )
def test_enqueue_dequeue_one(self): """ Enqueueing a single value is immediately dequeable. """ pq = PriorityQueue() j = Job(5, 'The') pq.enqueue(j) self.assertEqual(j, pq.dequeue())
def new_pq(): pq = PriorityQueue() for index,value in enumerate([3,3,4,9,7,7,9,9,7,8]): pq.insert(Job(priority=value)) if not index % 3: pq._iterations = 0 pq._iterations = 0 return pq
def test_4(self): array = [randint(100000, 150000) for i in range(randint(30, 60))] array_max = max(array) queue = PriorityQueue() for element in array: queue.insert(element) max_element = queue.extract_max() self.assertEqual(max_element, array_max, msg=array)
def solve_board(board, data): global DATA DATA = data steps = 0 f_values = dict() f = board.calculate_f(steps, DATA) f_values[hash(grid_to_str(board.grid))] = f first_state = State(board, None, None, f, steps, 0) open_list = PriorityQueue() closed_list = set() # Step 1: Put the start node on a list called OPEN of unexpanded nodes. # Calculate f(s) and associate its value with node s. open_list.push(first_state) # Step 2: If OPEN is empty, exit with failure, no solution exists. while open_list.is_empty(): # Step 3: Select from OPEN a node i at which f is minimum. If several nodes qualify, # choose a goal node if there is one, otherwise choose among them arbitrarily. state = open_list.pop().state # Step 4: Remove node i from OPEN and place it on a list called CLOSED, of expanded nodes. DATA.scanned_nodes = DATA.scanned_nodes + 1 closed_list.add(hash(grid_to_str(state.board.grid))) # Step 5: If i is a goal node, exit with success; a solution has been found. if state.goal_state(): solution_steps = get_solution_steps(state) solution_str = create_solution_string(solution_steps, state) DATA.finalize(solution_str, len(solution_steps), open_list) return solution_str # Step 6: Expand node i, creating nodes for all of its successors. For every successor node j of i: # Step 6.1: Calculate f(j) expanded_states = expand_state(state) for expanded_state in expanded_states: # Step 6.2: If j is neither in OPEN nor in CLOSED, then add it to OPEN with its f value. # Attach a pointer from j back to its predecessor i if hash(grid_to_str(expanded_state.board.grid)) not in f_values: open_list.push(expanded_state) f_values[hash(grid_to_str( expanded_state.board.grid))] = expanded_state.f_value else: # Step 6.3: If j was already on either OPEN or CLOSED, compare the f value just calculated for j with # the value previously associated with the node. if expanded_state.f_value < f_values[hash( grid_to_str(expanded_state.board.grid))]: f_values[hash(grid_to_str( expanded_state.board.grid))] = expanded_state.f_value # Step 6.3.1: Substitute it for the old value. if is_expansion_in_closed_list(expanded_state, closed_list): # Step 6.3.2: Point j back to i instead of to its previously found predecessor. # Step 6.3.3: If node j was on the CLOSED list, move it back to OPEN open_list.push(expanded_state) remove_state(expanded_state, closed_list) DATA.finalize("FAILED", 0, open_list) return None
def test_PriorityQueue_NonEmptyQueueToString_ReturnsCorrectString(self): priority_queue = PriorityQueue() priority_queue.add("a", 2) priority_queue.add("b", 3) priority_queue.add("c", 1) s = str(priority_queue) self.assertEquals(s, "<PriorityQueue[(c,1),(a,2),(b,3)]>")
def __init__(self, dim, res, dx, real): super().__init__(dim, res, dx, real) self.priority_queue = PriorityQueue(dim, res, real) self.surface_grid = ti.Vector.field(dim, dtype=ti.i32, shape=reduce( lambda x, y: x * y, res)) self.total_sg = ti.field(dtype=ti.i32, shape=())
def __init__(self, goal_state, search_type="bfs"): self.goal_state = goal_state self.open_list = PriorityQueue() self.closed_list = [] self.id_count = 1 self._open_list_pop_count = 0 self._open_list_add_count = 0 self._closed_list_add_count = 0 self.search_type = search_type
def test_PriorityQueue_RemoveFirstElement_StatesRemaingCorrect(self): priority_queue = PriorityQueue() priority_queue.add("a", 1) priority_queue.add("b", 2) priority_queue.remove("a") self.assertEquals(list(priority_queue), [('b', 2)]) self.assertEquals(len(priority_queue), 1)
def test_sequence2(self): Q = PriorityQueue() Q.insert(1) Q.insert(2) Q.insert(3) self.assertEqual(Q.extract_max(), 3) self.assertEqual(Q.extract_max(), 2) self.assertEqual(Q.extract_max(), 1) with self.assertRaises(NoMoreDataError): Q.extract_max()
def test_PriorityQueue_ChangePriorityUsingAddRemoveElement_PeekReturnsLowestElement(self): priority_queue = PriorityQueue() priority_queue.add("a", 2) priority_queue.add("b", 3) priority_queue.add("c", 1) priority_queue.add("d", 0) priority_queue.remove("c") priority_queue.add("c", 4) elm, pri = priority_queue.peek() self.assertEquals(elm, "d")
def k_nearest(points, center, k): pq = PriorityQueue() for point in points: distance_square = (point[0] - center[0])**2 + (point[1] - center[1])**2 distance = math.sqrt(distance_square) node = Node(point, distance) pq.enque(node) for _ in range(k): print(pq.deque())
def test_PriorityQueue_GetPriority_ReturnsCorrectPriority(self): priority_queue = PriorityQueue() priority_queue.add("a", 0) priority_queue.add("b", 1) p_a = priority_queue.get_priority("a") p_b = priority_queue.get_priority("b") self.assertEquals(p_a, 0) self.assertEquals(p_b, 1)
def run_algorithm(self): """ run the algorithm :return: True is there is a path from strat to end, False otherwise """ open_list = PriorityQueue(f=self.f) open_list.append(self.start_point) closed_list = set() while not len(open_list) == 0: next_n = open_list.pop() closed_list.add(next_n) if self.end_point == next_n: self.value = next_n.total_value() self.path = next_n.arrived_from return True else: self.path_count += 1 for suc in next_n.successors: suc.arrived_from = next_n.arrived_from + [self.get_direction(next_n.x, next_n.y, suc.x, suc.y)] suc.fathers = next_n.fathers + [next_n] if suc not in closed_list and suc not in open_list: open_list.append(copy.deepcopy(suc)) elif suc in open_list and self.f(suc) < open_list[suc]: del open_list[suc] open_list.append(copy.deepcopy(suc)) self.path = self.NO_PATH return False
def test_insert_key(): pq = PriorityQueue() pq.insert_key(24) pq.insert_key(12) pq.insert_key(1) pq.insert_key(35) assert(pq.contains(24) == True) assert(pq.contains(12) == True) assert(pq.contains(1) == True) assert(pq.contains(35) == True) assert(pq.contains(10) == False)
class StockExchange(object): def __init__(self): self.buyers = PriorityQueue() self.sellers = PriorityQueue() def buy(self, buy_order): '''Input a buy order, regardless of any suitable sell order.''' self.buyers.push(buy_order, buy_order) # use order value for key and value. def sell(self, sell_order): '''Input a sell order, regardless of any suitable buy order.''' self.sellers.push(sell_order, sell_order) # use order value for key and value. def get_buyers(self): '''Return a list of all pending buyers.''' summary = 'Pending Buyers: \n' for buyer in self.buyers.elements(): summary += ('$' + str(buyer._key) + '\n') return summary def get_sellers(self): '''Return a list of all pending sellers.''' summary = 'Pending Sellers: \n' for seller in self.sellers.elements(): summary += ('$' + str(seller._key) + '\n') return summary def process(self): '''Process buy orders in an optimal match-up fashion. O(n2) time.''' # A buy order for $x can only be processed if there is an existing sell order with price $y # such that $x >= $y. summary = '' temp_buyers = PriorityQueue() # Create a temp pq for buyers while self.buyers.peek() is not None: # Iterate all buyers buyer = self.buyers.pop() # Get the next buyer temp_sellers = PriorityQueue() buyer_matched = False # Assume there's no match for this buyer while self.sellers.peek() is not None: seller = self.sellers.pop() # Get the next seller if buyer._key >= seller._key: # This is a valid matchup buyer_matched = True summary += ('Buyer $' + str(buyer._key) + ' matched with seller $' + str(seller._key) + '\n') else: # if this seller was no good, push it on the temp seller pq temp_sellers.push(seller._key, seller._value) self.sellers = temp_sellers # Copy the temp seller pq back to the original if not buyer_matched: temp_buyers.push(buyer._key, buyer._value) self.buyers = temp_buyers # Copy the temp buyer pq back to the original return summary
def test_get_max(): pq = PriorityQueue() pq.insert_key(24) pq.insert_key(12) pq.insert_key(1) pq.insert_key(35) assert(pq.get_max() == 35)
def __init__(self, proxies): super(Parser, self).__init__() self.proxies = proxies self.companies = PriorityQueue() self.parsed = set()
def test_extract_max(): pq = PriorityQueue() pq.insert_key(24) pq.insert_key(12) pq.insert_key(1) pq.insert_key(35) assert(pq.extract_max() == 35) assert(pq.extract_max() == 24)
def trial(trial_no, num_actions): """Perform one test run of the priority queue.""" logging.info("Trial %s", trial_no) pq = PriorityQueue() insert_delete(pq, int(num_actions)) items = [] while not pq.empty(): items.append(pq.get()) if len(items) < 2: logging.info("Order is trivially preserved; fewer than 2 items.") preserved = True for i1, i2 in it.izip(items, items[1:]): if i1 >= i2: preserved = False break logging.info("Order%s preserved.", {True: "", False: " not"}[preserved]) log_items(items)
def test_assign_priority_via_pop(): new_pq = PriorityQueue() for _ in range(4): new_pq.insert(Job(priority=1)) new_pq.jobs[3].time_created -= 100 new_pq.pop() assert [job.priority for job in new_pq.jobs] == [6, 1, 1] new_pq.jobs[2].time_created -= 100 new_pq._iterations = 4 new_pq.pop() assert [job.priority for job in new_pq.jobs] == [6, 1]
def astar(start_gamestate, heuristic=heuristic_3, targets=range(1,17), q=False): """ parameters: start_gamestate -- a Gamestate object heuristic -- a function targets -- a list of (row, col) positions which need to be in the correct spot on the board. Determines goal state. q -- quiet flag. If False, print out info to give some indication of progress """ start_time = time.time() cur_state = start_gamestate cur_actions = [] prev_len = -1 fringe = PriorityQueue() visited_states = set([cur_state]) while not cur_state.is_goal_state(targets): # print info to the screen # pretty poor way to track program's progress if not q and len(cur_actions) > prev_len: print len(cur_actions), time.time() - start_time prev_len = len(cur_actions) # push neighboring states onto fringe for action in cur_state.get_legal_actions(): successor = cur_state.get_successor(action) if successor not in visited_states: # add neighbor to fringe # g = len(cur_actions) + 1 # h = heuristic priority = len(cur_actions) + 1 + heuristic(cur_state, targets) # remember state as visited visited_states.add(successor) fringe.push( (successor, cur_actions + [action]), priority ) # get next state from fringe, skipping ones we've seen already cur_state, cur_actions = fringe.pop() return cur_actions, cur_state
def astar(self, animate=False): empty_space_count = self.image.histogram()[255] fringe = PriorityQueue() fringe.push(self.start, self.heuristic(self.start)) explored = set() while fringe: if len(explored) % 100000 == 0: print "Explored %d/%d nodes! %.3f%% done!" % (len(explored), empty_space_count, len(explored)/float(empty_space_count)) node, cost = fringe.pop() if node == self.end: self.path = [node] while self.parents[node]: self.path.append(self.parents[node]) node = self.parents[node] explored.add(node) for neighbor in self.neighbors(node): if neighbor in explored: continue g_score = self.g_scores[node] + 1 if neighbor not in fringe or g_score < self.g_scores[neighbor]: self.parents[neighbor] = node self.g_scores[neighbor] = g_score fringe.push(neighbor, g_score + self.heuristic(neighbor)) print "No Solution"
class LRUCache(object): """A least-recently-used cache.""" def __init__(self, maxsize=100): self.items = {} self.oldest = PriorityQueue(key=lambda item: item['timestamp']) self.maxsize = maxsize self.numitems = 0 def insert(self, key, value): """Insert a piece of data into the cache.""" if self.numitems >= self.maxsize: throw_away = self.oldest.get() del self.items[throw_away['key']] self.numitems -= 1 pq_data = {'key': key, 'timestamp': time.time()} self.items[key] = { 'index': self.oldest.put(pq_data), 'value': value } self.numitems += 1 def update(self, key): """Update the timestamp of a piece of data in the cache.""" index = self.items[key]['index'] self.oldest[index]['timestamp'] = time.time() self.oldest.heap.heapify_down(index) def remove(self, key): """Remove a piece of data from the cache.""" index = self.items[key]['index'] thrown_away = self.oldest.delete(index) del self.items[key] self.numitems -= 1 def __contains__(self, key): return key in self.items def __getitem__(self, key): return self.items[key]['value']
def merge_streams(streams): """Merges sorted streams into one sorted list. :param streams: list of MyStream objects. :return: sorted list of integers. """ min_buffer = PriorityQueue() all_streams_are_empty = False iterations = 0 next_i = None while not all_streams_are_empty: all_streams_are_empty = True for i, stream in enumerate(streams): while not stream.empty: if (next_i is not None) and i != next_i: break new_int = stream.pop() if new_int is not None: min_buffer.insert((i, new_int)) if iterations < 1: # first step is to get the top # "layer" of all streams break else: # if we already have our top "layer" # we will run the main sorting algorithm next_i, min_int = min_buffer.pop_min() yield min_int # return minimums one by one next_i = None if streams[next_i].empty else next_i all_streams_are_empty = all_streams_are_empty and stream.empty iterations += 1 while len(min_buffer): # when all streams became empty # we just ineratively pop all heap content yield min_buffer.pop_min() print ('DEBUG: heap (list) of real size == %s were allocated ' 'during sorting.' % len(min_buffer.heap))
def test_PriorityQueue_ChangePriority_GetPriorityReturnsNewPriority(self): priority_queue = PriorityQueue() priority_queue.add("a", 0) priority_queue.change_priority("a", 5) p_a = priority_queue.get_priority("a") self.assertEquals(p_a, 5)
def test_PriorityQueue_Peek_ReturnsElementWithLowestPriority(self): priority_queue = PriorityQueue() priority_queue.add("a", 2) priority_queue.add("b", 3) priority_queue.add("c", 1) elm, pri = priority_queue.peek() self.assertEquals(elm, "c")
def __construct_trie(self): queue = PriorityQueue.heapify([Huffman.Node(k, v) for (k, v) in self.frequencies.items()]) self.num_tries_nodes = queue.size() while queue.size() > 1: x = queue.del_min() y = queue.del_min() parent = Huffman.Node(0, x.freq + y.freq, x, y, ) queue.insert(parent) self.num_tries_nodes += 1 self.trie = queue.del_min()
def test_PriorityQueue_PopAllSmallerThan_LIstIsEmpty(self): priority_queue = PriorityQueue() priority_queue.add("a", 2) priority_queue.add("b", 1) priority_queue.remove("b") l = priority_queue.pop_smaller_than(3) self.assertEquals(list(priority_queue), [])
def aStar(grid_map, source): grid_max = np.amax(grid_map) if grid_max == 0: grid_max = 1 def heuristic(current): (t,y) = current return NUM_GRIDS_Y-y def neighbors(current): res = [] (t,y) = current if t+1 < grid_map.shape[1]: num_offset = int(round(CHICKEN_MAX_SPEED/GRID_Y)) for yy in range(-num_offset, num_offset+1): neighbor = (t+1, y+yy) if neighbor[1] < NUM_GRIDS_Y and neighbor[1] >= 0: res.append(neighbor) return res def checkGoal(current): (t, y) = current if (y >= NUM_GRIDS_Y - EXTRA_GRIDS): return True return False frontier = PriorityQueue() frontier.put(source, 0) came_from = {} cost_so_far = {} came_from[source] = None cost_so_far[source] = 0 while not frontier.empty(): current = frontier.pop() if checkGoal(current): break for next in neighbors(current): new_cost = cost_so_far[current] + (np.exp(COEFF*grid_map[next[1]][next[0]]/grid_max)-1)/EXP_COEFF*NUM_GRIDS_Y if next not in cost_so_far or new_cost < cost_so_far[next]: cost_so_far[next] = new_cost priority = new_cost + heuristic(next) frontier.put(next, priority) came_from[next] = current goal=sorted(came_from.keys())[-1] return came_from, goal
def __init__(self, root_node, goal_node): """ Initializes the AStar object and sets function that determines the order in which the nodes are evaluated. Precondition: nodes can be any type of object, but must be able to be compared by str(node1) == str(node2) """ self.goal_node = goal_node # min heap for the fringe self.fringe = PriorityQueue() self.fringe.add_node( root_node, self.h_score(root_node) ) # min cost to node self.min_node_score = {} self.min_node_score[ str(root_node) ] = 0 # path to start self.came_from = {} self.nodes_visited = 0
def search(self): pq = PriorityQueue(self.heuristic) pq.put((self.start, [])) while not pq.empty(): self.space = max(self.space, len(pq)) state, path = pq.get() self.nodes_visited += 1 if state.is_goal(): yield path for move, board in state.successors(): if self.check_duplicates and board in self.visited: continue elif self.check_duplicates: self.visited += [board] if self.check_symmetrical: self.visited += board.get_symmetrically_equivalent_boards() pq.put((board, path + [move]))