def top_rank(k,rank): pq = PriorityQueue() for u in rank.keys(): pq.add(u, -rank[u]) # We use negative value because PriorityQueue returns first values whose priority value is lower out=[] for i in range(k): out.append(pq.pop()) return out
def top(G,measure,k): pq = PriorityQueue() cen=measure(G) for u in G.nodes(): pq.add(u, -cen[u]) # We use negative value because PriorityQueue returns first values whose priority value is lower out=[] for i in range(k): out.append(pq.pop()) return out
def test_sift_down(test_list): from priorityq import PriorityQueue new_queue = PriorityQueue(test_list) new_queue.pop() print(new_queue.queue) for idx, item in enumerate(new_queue.queue): if idx < (len(new_queue.queue) - 1) // 2: assert item > new_queue.queue[idx * 2 + 1] assert item > new_queue.queue[idx * 2 + 2]
def test_pop_removes_raises_error_after_popping_all_values(): """Test pop method removed first value in highest priority.""" from priorityq import PriorityQueue p = PriorityQueue() p.insert(8, 2) p.insert(10, 2) p.pop() p.pop() with pytest.raises(IndexError): p.pop()
def test_pop_removes_highest_priority(): """Test pop method removed first value in highest priority.""" from priorityq import PriorityQueue p = PriorityQueue() for i in range(3): p.insert(i) p.insert(8, 2) p.insert(10, 2) assert p.pop() == 8
def test_peek_shows_highest_priority(): """Test the peek method to show highest priority value.""" from priorityq import PriorityQueue p = PriorityQueue() for i in range(3): p.insert(i) p.insert(8, 2) p.insert(10, 2) p.insert(0, 33) assert p.peek() == 0
def dijkstra(self, start_node): """Find the shortest path to nodes from starting node.""" if not self.has_node(start_node): raise IndexError('Node not in this weighted graph.') current_node = (start_node, 0) visited = {} priorityq = PriorityQueue() priorityq.insert(current_node, 0) paths = {} while priorityq.size() > 0: current_node = priorityq.pop() next_nodes = self[current_node[0]] for key, value in next_nodes.items(): distance_from_start_node = value + current_node[1] if key not in visited or distance_from_start_node < visited[ key]: if key == start_node: continue visited.update({key: distance_from_start_node}) path = current_node[0] + key paths[path] = distance_from_start_node priorityq.insert((key, distance_from_start_node), distance_from_start_node) print(paths) return visited
def top_parallel(G,k,j): pq = PriorityQueue() with Parallel(n_jobs=j) as parallel: #Run in parallel diameter function on each processor by passing to each processor only the subset of nodes on which it works result=parallel(delayed(closeness_par)(G,X) for X in chunks(G.nodes(), math.ceil(len(G.nodes())/j))) for u in result:#u is a dict for el in u.keys(): pq.add(el, -u[el]) # We use negative value because PriorityQueue returns first values whose priority value is lower out=[] for i in range(k): out.append(pq.pop()) return out
def top_hits_parall(G,k,num_node,j): pq = PriorityQueue() pq2=PriorityQueue() auth_n,hubs_n=parallel_hits(G,k,j) for u in G.nodes(): pq.add(u, -auth_n[u]) # We use negative value because PriorityQueue returns first values whose priority value is lower for u in G.nodes(): pq2.add(u, -hubs_n[u]) # We use negative value because PriorityQueue returns first values whose priority value is lower out=[] out2=[] for i in range(num_node): out.append(pq.pop()) out2.append(pq2.pop()) return out,out2
def get_pq(): pq = PriorityQueue() pq.insert(PrioritizedItem(3, 'A')) pq.insert(PrioritizedItem(1, 'B')) pq.insert(PrioritizedItem(3, 'C')) pq.insert(PrioritizedItem(2, 'D')) pq.insert(PrioritizedItem(3, 'E')) return pq
def test_pop_on_emptied_queue_raises_error(): """Test pop method on empties priority queue raises error.""" from priorityq import PriorityQueue p = PriorityQueue() p.insert(2) p.pop() with pytest.raises(IndexError): p.pop()
def bwt_cluster_naive(G): eb, nb = betweenness(G) pq = PriorityQueue() for i in eb.keys(): pq.add(i, -eb[i]) graph = G.copy() done = False while not done: edge = tuple(sorted(pq.pop())) graph.remove_edges_from([edge]) list_connected_comp = list(nx.connected_components(graph)) if len(list(nx.connected_components(graph))) == 4: done = True return list_connected_comp
def top_betweenness(G,k,j): #PARALLELIZZAZIONE pq=PriorityQueue() with Parallel(n_jobs=j) as parallel: #Run in parallel diameter function on each processor by passing to each processor only the subset of nodes on which it works lista=parallel(delayed(betweenness_par)(G,X) for X in chunks(G.nodes(), math.ceil(len(G.nodes())/j))) #Aggregates the results for j in lista: for i in j[1].keys(): pq.add(i,-j[1][i])#Fase di assemblaggio out=[] for i in range(k): out.append(pq.pop()) return out
def bwt_cluster_parallel(G,j): #PARALLELIZZAZIONE pq=PriorityQueue() with Parallel(n_jobs=j) as parallel: #Run in parallel diameter function on each processor by passing to each processor only the subset of nodes on which it works lista=parallel(delayed(betweenness_par)(G,X) for X in chunks(G.nodes(), math.ceil(len(G.nodes())/j))) #Aggregates the results for j in lista: for i in j[0].keys(): pq.add(i,-j[0][i])#Fase di assemblaggio graph=G.copy() done=False while not done: edge=tuple(sorted(pq.pop())) graph.remove_edges_from([edge]) list_connected_comp=list(nx.connected_components(graph)) if len(list(nx.connected_components(graph))) == 4: done = True return list_connected_comp
def astar_distance(self, startnodeval, endnodeval): from priorityq import PriorityQueue p_queue = PriorityQueue(prop="min") best_solution = None endnode = self._node_list[self._node_list.index(Node(endnodeval))] startnode = self._node_list[self._node_list.index(Node(startnodeval))] distance_traveled = 0 remaining_distance_estimate = self._calculate_distance( startnode.coordinates, endnode.coordinates) # We need to keep track of the real distance traveled, along with # the "estimate", so the things in the queue now look like: # (priority, (distance_traveled, [path])) priority = distance_traveled + remaining_distance_estimate p_queue.insert((priority, (distance_traveled, [startnodeval]))) while True: try: current = p_queue.pop() except IndexError: break if current[1][1][-1] == endnodeval: if (not best_solution) or (current[1][0] < best_solution[0]): best_solution = current[1] continue for neighbor in self.neighbors(current[1][1][-1]): if neighbor not in current[1][1]: new_distance = self._edge_list[self._edge_list.index( Edge(current[1][1][-1], neighbor))].weight distance_traveled = current[1][0] + new_distance newnode = self._node_list[self._node_list.index( Node(neighbor))] remaining_distance_estimate = self._calculate_distance( newnode.coordinates, endnode.coordinates) priority = distance_traveled + remaining_distance_estimate p_queue.insert((priority, (distance_traveled, current[1][1] + [neighbor]))) return best_solution
def dijkstra(self, startnodeval, endnodeval): from priorityq import PriorityQueue p_queue = PriorityQueue(prop="min") best_solution = None p_queue.insert((0, [startnodeval])) while True: try: current = p_queue.pop() except IndexError: break if current[1][-1] == endnodeval: if (not best_solution) or (current[0] < best_solution[0]): best_solution = current continue for neighbor in self.neighbors(current[1][-1]): if neighbor not in current[1]: distance = self._edge_list[self._edge_list.index( Edge(current[1][-1], neighbor))].weight p_queue.insert( (current[0] + distance, current[1] + [neighbor])) return best_solution
def test_initialization_empty_dict(): """Test if to see if created.""" from priorityq import PriorityQueue new_priq = PriorityQueue() assert new_priq.pq_dict == {}
def hierarchical(G,sample=None): if sample is None: sample=G.nodes() # Create a priority queue with each pair of nodes indexed by distance pq = PriorityQueue() for u in sample: for v in sample: if u != v: if (u, v) in G.edges() or (v, u) in G.edges(): pq.add(frozenset([frozenset([u]), frozenset([v])]), 0) else: pq.add(frozenset([frozenset([u]), frozenset([v])]), 1) # Start with a cluster for each node clusters = set(frozenset([u]) for u in sample) done = False while not done: # Merge closest clusters s = list(pq.pop()) clusters.remove(s[0]) clusters.remove(s[1]) # Update the distance of other clusters from the merged cluster for w in clusters: e1 = pq.remove(frozenset([s[0], w])) e2 = pq.remove(frozenset([s[1], w])) if e1 == 0 or e2 == 0: pq.add(frozenset([s[0] | s[1], w]), 0) else: pq.add(frozenset([s[0] | s[1], w]), 1) clusters.add((s[0] | s[1])) if len(clusters) ==4: done = True return clusters
def test_insert(test_list, test_val): from priorityq import PriorityQueue new_queue = PriorityQueue(test_list) new_queue.insert(test_val) assert test_val in new_queue.queue
def test_gen_order_1(): pq = PriorityQueue() assert pq._gen_order() == 1 assert pq._gen_order() == 2
def priority_queue(): """Priority queue for use in test.""" from priorityq import PriorityQueue priority_queue = PriorityQueue() return priority_queue
def test_peek(populated_pq, insert_item, result_pq): from priorityq import PriorityQueue pq = PriorityQueue() pq._container = result_pq assert pq.peek() == result_pq[0]
def test_pop(populated_pq, pop_values): from priorityq import PriorityQueue pq = PriorityQueue() pq._container = populated_pq for i in range(len(pq._container)): assert pq.pop() == pop_values[i]
def test_insert_on_empty(): from priorityq import PriorityQueue pq = PriorityQueue() pq.insert((7, "banana")) assert pq._container == [(7, "banana")]
def test_peek(): """Test insert method.""" from priorityq import PriorityQueue pq = PriorityQueue() pq.insert(*DATA[0]) assert pq.peek() == DATA[0][1]
def priority_queue_full(): """Priority queue for use in test.""" from priorityq import PriorityQueue priority_queue = PriorityQueue() priority_queue.insert(15, 5) priority_queue.insert(12, 3) priority_queue.insert(11, 1) priority_queue.insert(6, 2) priority_queue.insert(17) priority_queue.insert(3) return priority_queue
def test_insert(): """Test insert method.""" from priorityq import PriorityQueue pq = PriorityQueue() pq.insert(*DATA[0]) assert pq.dict[DATA[0][0]][0] == DATA[0][1]
def test_priority_que_init(): """Make sure they don't provide any arguments.""" from priorityq import PriorityQueue with pytest.raises(TypeError): new_pqueue = PriorityQueue(1)
def test_insert(populated_pq, insert_item, result_pq): from priorityq import PriorityQueue pq = PriorityQueue() pq._container = populated_pq pq.insert(insert_item) assert pq._container == result_pq
def test_pop(test_list): from priorityq import PriorityQueue new_queue = PriorityQueue(test_list) pop_val = new_queue.pop() assert pop_val not in new_queue.queue