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 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 test_sift_up(test_list):
from priorityq import PriorityQueue
new_queue = PriorityQueue(test_list)
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_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 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 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 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_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 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 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 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 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 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 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 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 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 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 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
