def gen_indirect_graph_er(nodes, threshold):
g = PIIndirectGraph()
for u in range(0, nodes):
for v in range(0, nodes):
if u != v:
a = random()
if a < threshold:
g.add_arch(u, v)
return g
def gen_real_graph():
inputFile = open("as19991212.txt", "r")
for i in range(0, 4):
inputFile.readline()
g = PIIndirectGraph()
for line in inputFile:
(a, b) = line.split()
if a != b:
g.add_arch(a, b)
return g
def test_remove(self):
g = PIIndirectGraph()
g.add_arch(1, 2)
g.add_arch(1, 3)
g.add_arch(1, 3)
g.add_arch(3, 1)
g.add_arch(3, 2)
self.assertSetEqual(g.get_adj_list(1), {2, 3})
def mst_approx(graph, r=0):
"""
:param graph: G = (V,E) connected graph, not oriented and weighted
:param r: a vertex of graph G
:return: minimum coverage Tree
"""
keys = dict()
parents = dict()
adj_matrix = graph.get_adj_matrix()
for v in range(graph.get_vertices()):
keys[v] = math.inf
parents[v] = None
keys[r] = 0
tree = [(keys[v], v) for v in range(graph.get_vertices())]
Q = PriorityQueue(tree)
while not Q.is_empty():
weight, u = Q.extract_min() # extract smallest item from the heap
# Assumes indexes of the nodes are 1..n
for v in range(graph.get_vertices()): # for each nodes in adj list
# check if heapq contains value;
# if w(u,v) < key[v];
# if u is a noose
# u is already extracted from Q
if (keys[v], v) in Q and adj_matrix[u][v] < keys[v]:
old_weight = keys[v] # Old value of weight
old_index = Q.heap.index(
(old_weight, v)) # Get position of tuple in the list
keys[v] = adj_matrix[u][v] # Update weight
parents[v] = u # Update parent
Q.heap[old_index] = (keys[v], v
) # Update heap list value with new tuple
min_heap._siftdown(Q.heap, 0,
old_index) # decrease_key in the queue
# end if
# end for
# end while
tree = {(v, parents[v]) for v in range(graph.get_vertices()) if v != r}
i_graph = PIIndirectGraph()
for (i, j) in tree:
i_graph.add_arch(i, j)
visited, _ = i_graph.get_dfs_path_from_node(r)
return get_cycle_cost(graph, visited)
def gen_indirect_graph_upa(m, n):
class UPATrial:
_numNodes = 0
_nodeNumbers = []
def __init__(self, num_nodes):
self._numNodes = num_nodes
self._nodeNumbers = [
node for node in range(num_nodes) for _ in range(num_nodes)
]
def run_trial(self, num_nodes):
cont = 0
new_neighbours = set()
for _ in range(num_nodes):
v = choice(self._nodeNumbers)
if v not in new_neighbours:
cont += 1
new_neighbours.add(v)
for _ in range(0, cont):
self._nodeNumbers.append(self._numNodes)
self._nodeNumbers.extend(list(new_neighbours))
self._numNodes += 1
return new_neighbours
graph_nodes = set(range(0, m))
g = PIIndirectGraph()
for a in graph_nodes:
for b in graph_nodes:
if a != b:
g.add_arch(a, b)
trial = UPATrial(m)
for u in range(m, n):
new_graph_nodes = trial.run_trial(m)
graph_nodes.add(u)
for v in new_graph_nodes:
g.add_arch(u, v)
return g
def test_no_loops(self):
with pytest.raises(Exception):
g = PIIndirectGraph()
g.add_arch(1, 1)
def test_bfs(self):
g = PIIndirectGraph()
g.add_arch(1, 2)
g.add_arch(2, 3)
g.add_arch(1, 4)
g.add_arch(4, 5)
g.add_arch(5, 6)
g.add_arch(6, 4)
g.add_arch(3, 6)
predecessors, distances, path = g.get_bfs_path_from_node(1)
self.assertDictEqual(predecessors, {
1: None,
2: 1,
3: 2,
4: 1,
5: 4,
6: 4
})
self.assertDictEqual(distances, {1: 0, 2: 1, 3: 2, 4: 1, 5: 2, 6: 2})
self.assertSetEqual(path, {1, 2, 3, 4, 5, 6})
predecessors, distances, path = g.get_bfs_path_from_node(6)
self.assertDictEqual(predecessors, {
1: 4,
2: 3,
3: 6,
4: 6,
5: 6,
6: None
})
self.assertDictEqual(distances, {1: 2, 2: 2, 3: 1, 4: 1, 5: 1, 6: 0})
self.assertSetEqual(path, {1, 2, 3, 4, 5, 6})
predecessors, distances, path = g.get_bfs_path_from_node(7)
self.assertDictEqual(predecessors, {
1: None,
2: None,
3: None,
4: None,
5: None,
6: None
})
self.assertDictEqual(distances, {
1: inf,
2: inf,
3: inf,
4: inf,
5: inf,
6: inf
})
self.assertSetEqual(path, set())
def test_node_degree(self):
g = PIIndirectGraph()
g.add_arch(4, 1)
g.add_arch(5, 1)
g.add_arch(6, 1)
g.add_arch(1, 2)
g.add_arch(1, 3)
g.add_arch(1, 4)
g.add_arch(1, 5)
self.assertEqual(g.get_node_degree(1), 5)
self.assertEqual(g.get_node_degree(4), 1)
self.assertEqual(g.get_node_degree(7), 0)
def test_connected_components(self):
g = PIIndirectGraph()
g.add_arch(4, 1)
g.add_arch(5, 1)
g.add_arch(6, 1)
g.add_arch(1, 2)
g.add_arch(1, 3)
g.add_arch(1, 4)
g.add_arch(1, 5)
self.assertEqual(g.get_connected_components(),
{frozenset({1, 2, 3, 4, 5, 6})})
def test_append_and_get(self):
g = PIIndirectGraph()
g.add_arch(1, 2)
g.add_arch(1, 3)
g.add_arch(1, 3)
g.add_arch(3, 1)
g.add_arch(3, 2)
g.add_node(4)
self.assertSetEqual(g.get_node_list(), {1, 2, 3, 4})
self.assertSetEqual(g.get_arch_list(), {(1, 2), (1, 3), (2, 3)})
g.remove_arch(2, 1)
self.assertSetEqual(g.get_node_list(), {1, 2, 3, 4})
self.assertSetEqual(g.get_arch_list(), {(1, 3), (2, 3)})
g.remove_node(3)
g.remove_node(5)
self.assertSetEqual(g.get_node_list(), {1, 2, 4})
self.assertSetEqual(g.get_arch_list(), set())
def test_dfs(self):
g = PIIndirectGraph()
g.add_arch(1, 2)
g.add_arch(2, 3)
g.add_arch(1, 4)
g.add_arch(4, 5)
g.add_arch(5, 6)
g.add_arch(6, 4)
g.add_arch(3, 6)
nodes_visited, nodes_predecessors = g.get_dfs_path_from_node(1)
self.assertSetEqual(nodes_visited, {1, 2, 3, 4, 5, 6})
self.assertDictEqual(nodes_predecessors, {
1: None,
2: 1,
3: 2,
6: 3,
4: 6,
5: 4
})
nodes_visited, nodes_predecessors = g.get_dfs_path_from_node(6)
self.assertSetEqual(nodes_visited, {1, 2, 3, 4, 5, 6})
self.assertDictEqual(nodes_predecessors, {
1: 2,
2: 3,
3: 6,
4: 1,
5: 4,
6: None
})
nodes_visited, nodes_predecessors = g.get_dfs_path_from_node(7)
self.assertSetEqual(nodes_visited, set())
self.assertDictEqual(nodes_predecessors, {
1: None,
2: None,
3: None,
4: None,
5: None,
6: None
})