def test_get_all_v(self):
graph = DiGraph()
tuple0 = (0, 30, 2)
tuple1 = (50, 50, 50)
node0 = NodeData(0, tuple0) # node: key=0 tuple=(0, 30, 2)
node1 = NodeData(2, tuple0) # node: key=2 tuple=(0, 30, 2)
node2 = NodeData(10, tuple1) # node: key=10 tuple=(50, 50, 50)
graph.add_node(node0.get_key(), tuple0)
graph.add_node(node1.get_key(), tuple0)
graph.add_node(node2.get_key(), tuple1)
nodes = [node0, node1, node2]
for node in nodes:
self.assertIn(node, graph.get_all_v().values())
def __dijkstra(self, start_node: NodeData, dest_node: NodeData):
"""
This method marks on each vertex the distance to the source vertex and
@return path - Dict[int, NodeData] that the shortest path from start_node
"""
nodes = self.__graph.get_all_v()
q = PriorityQueue()
path: Dict[int, NodeData] = dict()
q.put(start_node)
for n in nodes.values():
node: NodeData = n
node.set_weight(math.inf)
node.set_info("WHITE")
path[n.get_key()] = None
start_node.set_weight(0)
while not q.empty():
v: NodeData = q.get()
if v.get_info() == "WHITE":
v.set_info("GRAY")
else:
continue
if v.get_key() == dest_node.get_key():
return path
for k, w in self.__graph.all_out_edges_of_node(
v.get_key()).items():
n: NodeData = nodes[k]
if n.get_info() == "WHITE":
weight = v.get_weight() + w
if weight < n.get_weight():
q.put(n)
n.set_weight(weight)
path[n.get_key()] = v
v.set_info("BLACK")
return path
def test_new_node(self):
pos = (1, 2, 3)
node1 = NodeData(1, pos, 3.4)
self.assertEqual(node1.get_key(), 1)
self.assertEqual(node1.get_pos(), (1, 2, 3))
self.assertEqual(node1.get_weight(), 3.4)
self.assertEqual(node1.get_info(), "f")
self.assertEqual(node1.get_tag(), 0)
self.assertEqual(node1.get_dest(), {})
self.assertEqual(node1.get_src(), {})
node2 = NodeData(2)
self.assertEqual(node2.get_key(), 2)
self.assertEqual(node2.get_pos(), None)
self.assertEqual(node2.get_weight(), 0.0)
self.assertEqual(node2.get_info(), "f")
self.assertEqual(node2.get_tag(), 0)
self.assertEqual(node2.get_dest(), {})
self.assertEqual(node2.get_src(), {})
def dijkstra(start: NodeData, key_to_find: int, graph: GraphInterface):
start.set_dist(0)
# counter for how many visited
visited = set()
# using tuple here so the values won't change
unvisited_queue = [(start.get_dist(), start.get_key())]
heapq.heapify(unvisited_queue)
while len(unvisited_queue) and len(visited) != graph.v_size():
current_node: int = heapq.heappop(unvisited_queue)[1]
if current_node not in visited:
visited.add(current_node)
if key_to_find == current_node:
return
for dest, w in graph.all_out_edges_of_node(current_node).items():
if (w + graph.get_all_v().get(current_node).get_dist()) < graph.get_all_v().get(dest).get_dist():
graph.get_all_v().get(dest).set_dist(w + graph.get_all_v().get(current_node).get_dist())
graph.get_all_v().get(dest).set_parent(current_node)
unvisited_queue.append(
(graph.get_all_v().get(dest).get_dist(), dest))
heapq.heapify(unvisited_queue)
def test_equal(self):
node11 = NodeData(1)
node12 = NodeData(2)
node13 = NodeData(3)
graph_one_test = DiGraph()
graph_one_test.add_node(node11.get_key(), (10, 20, 30))
graph_one_test.add_node(node12.get_key(), (10, 20, 30))
graph_one_test.add_node(node13.get_key(), (10, 20, 30))
node110 = NodeData(1)
node120 = NodeData(2)
node130 = NodeData(3)
graph_two_test = DiGraph()
graph_two_test.add_node(node110.get_key(), (10, 20, 30))
graph_two_test.add_node(node120.get_key(), (10, 20, 30))
graph_two_test.add_node(node130.get_key(), (10, 20, 30))
self.assertFalse(graph_one_test is graph_two_test)
self.assertTrue(graph_one_test == graph_two_test)
def _dfs(curr: NodeData, stack, graph: GraphInterface):
global index
curr.set_low_link(index)
curr.set_index(index)
curr.set_visited_in(True)
stack.append(curr)
index += 1
for n in list([graph.get_all_v().get(dest)]
for dest in graph.all_out_edges_of_node(curr.get_key())):
node: NodeData = n.pop()
if node.get_index() is None:
_dfs(node, stack, graph)
curr.set_low_link(min(curr.get_low_link(), node.get_low_link()))
elif node.get_visited_in():
curr.set_low_link(min(curr.get_low_link(), node.get_index()))
if curr.get_low_link() == curr.get_index():
scc = []
while len(stack):
popped_node: NodeData = stack.pop()
popped_node.set_visited_in(False)
scc.append(popped_node)
if popped_node == curr:
break
sccList.append(scc)
def test_all_out_edges_of_node(self):
graph = DiGraph()
tuple0 = (0, 30, 2)
tuple1 = (50, 50, 50)
node0 = NodeData(0, tuple0) # node: key=0 tuple=(0, 30, 2)
node1 = NodeData(1, tuple0) # node: key=1 tuple=(0, 30, 2)
node2 = NodeData(2, tuple1) # node: key=2 tuple=(50, 50, 50)
node3 = NodeData(3, tuple1) # node: key=3 tuple=(50, 50, 50)
graph.add_node(node0.get_key(), tuple0) # add node0
self.assertEqual({}, graph.all_out_edges_of_node(
node0.get_key())) # check the list In empty
graph.add_node(node1.get_key(), tuple0) # add node1
graph.add_node(node2.get_key(), tuple1) # add node2
graph.add_node(node3.get_key(), tuple1) # add node3
graph.add_edge(node1.get_key(), node0.get_key(), 10) # connect 1->0
graph.add_edge(node1.get_key(), node2.get_key(), 15) # connect 1->2
graph.add_edge(node1.get_key(), node3.get_key(), 20) # connect 1->2
ans_list_keys = [node0.get_key(), node2.get_key(), node3.get_key()]
for i in graph.all_out_edges_of_node(node1.get_key()).keys():
self.assertIn(i, ans_list_keys)
graph.remove_node(node2.get_key()) # remove node2
graph.remove_node(node3.get_key()) # remove node3
ans_list_keys = [node0.get_key()]
for i in ans_list_keys:
self.assertIn(i,
graph.all_out_edges_of_node(node1.get_key()).keys())
