def test_connected_components_A(self):
g = self.generate_graph(7)
g_algo = GraphAlgo(g)
g_algo.get_graph().add_edge(0, 1, 1)
g_algo.get_graph().add_edge(1, 0, 1)
g_algo.get_graph().add_edge(1, 2, 2)
g_algo.get_graph().add_edge(2, 1, 3)
g_algo.get_graph().add_edge(0, 3, 4)
g_algo.get_graph().add_edge(3, 1, 5)
g_algo.get_graph().add_edge(0, 4, 2)
g_algo.get_graph().add_edge(4, 5, 5)
g_algo.get_graph().add_edge(5, 4, 2)
self.assertEqual(g_algo.connected_component(0), [0, 1, 2, 3])
self.assertEqual(g_algo.connected_component(4), [4, 5])
self.assertEqual(g_algo.connected_component(6), [6])
# generate a graph with 7 vertices -> init graph algo object -> add multiple edges ->
# verify connected components -> add another vertex with no edge -> verify connected components for itself
g1 = GraphAlgo()
self.assertEqual(g1.connected_component(8), [])
# verify connected components on a node that does not exists -> suppose to return an empty list
graph_none = DiGraph()
graph_none = None
g2 = GraphAlgo(graph_none)
self.assertEqual(g1.connected_component(8), [])
def test_connected_component(self):
d1 = DiGraph()
d1.add_node(0, (1, 2, 0))
d1.add_node(1, (4, 7, 0))
d1.add_node(2, (0, 1, 4))
d1.add_node(3, (0, 9, 8))
d1.add_node(4, (4, 4, 0))
d1.add_node(5, (5, 15, 0))
d1.add_node(6, (21, 2, 0))
d1.add_node(7, (13, 13, 0))
d1.add_edge(0, 1, 1)
d1.add_edge(1, 2, 2)
d1.add_edge(2, 3, 3)
d1.add_edge(2, 0, 3)
d1.add_edge(3, 4, 0.5)
d1.add_edge(4, 5, 0.5)
d1.add_edge(4, 7, 0.5)
d1.add_edge(5, 6, 0.5)
d1.add_edge(6, 4, 0.5)
d1.add_edge(6, 7, 0.5)
d1.add_node(8, (6, 8, 0))
d1.add_node(9, (7, 8, 0))
d1.add_edge(8, 9, 1)
d1.add_edge(9, 8, 1)
d1.add_edge(8, 0, 1)
algo = GraphAlgo(d1)
self.assertTrue([2, 1, 0] == algo.connected_component(2))
self.assertTrue([9, 8] == algo.connected_component(9))
self.assertTrue([3] == algo.connected_component(3))
self.assertTrue([7] == algo.connected_component(7))
self.assertTrue([5, 4, 6] == algo.connected_component(5))
def test_connected_component(self):
graph = self.build_graph()
graph_a = GraphAlgo()
GraphAlgo.__init__(graph_a, graph)
is_connected = graph_a.connected_component(3)
y = (len(is_connected))
self.assertEqual(5, y)
for i in range(4):
self.assertTrue(i in is_connected)
graph.remove_edge(2, 3)
GraphAlgo.__init__(graph_a, graph)
is_connected = graph_a.connected_component(3).__getitem__(0)
self.assertEqual(3, is_connected)
graph.remove_edge(3, 4)
graph.add_edge(2, 4, 10)
GraphAlgo.__init__(graph_a, graph)
is_connected = graph_a.connected_component(3).__getitem__(0)
self.assertEqual(3, is_connected)
graph = self.build_empty_graph()
GraphAlgo.__init__(graph_a, graph)
self.assertEqual(0, len(graph_a.connected_components()))
def test_connected_component_a(self):
g = DiGraph()
k = GraphAlgo(g)
for i in range(10):
g.add_node(i)
g.add_edge(3, 4, 1)
g.add_edge(3, 7, 1)
g.add_edge(7, 3, 1)
g.add_edge(7, 5, 1)
g.add_edge(5, 0, 1)
g.add_edge(5, 6, 1)
g.add_edge(4, 5, 1)
g.add_edge(6, 4, 1)
g.add_edge(6, 0, 1)
g.add_edge(6, 2, 1)
g.add_edge(0, 1, 1)
g.add_edge(1, 2, 1)
g.add_edge(2, 0, 1)
l0 = k.connected_component(0)
l1 = k.connected_component(1)
l2 = k.connected_component(2)
l3 = k.connected_component(3)
l4 = k.connected_component(4)
l5 = k.connected_component(5)
l6 = k.connected_component(6)
l7 = k.connected_component(7)
self.assertEqual(l0, l1, l2) # one component
self.assertEqual(l3, l7) # one component
self.assertEqual(l4, l5, l6) # one component
def time_test(g: DiGraph):
random.seed(55555)
algo = GraphAlgo(g)
src = random.randint(0, g.NumberOfNodes)
dest = random.randint(0, g.NumberOfNodes)
startShortest = timer()
algo.shortest_path(src, dest)
endShortest = timer()
startConnected = timer()
algo.connected_components()
endConnected = timer()
component = random.randint(0, g.NumberOfNodes)
startComponent = timer()
algo.connected_component(component)
endComponent = timer()
print("My DiGraph:", g, " ->", "\n", "Shortest Path:",
(endShortest - startShortest), "\n", "Connected Components:",
(endConnected - startConnected), "\n", "Connected Component:",
(endComponent - startComponent), "\n")
MyTestCaseForComparison.shortestPathSumDiGraph += (endShortest -
startShortest)
MyTestCaseForComparison.connectedComponentsDiGraph += (endConnected -
startConnected)
MyTestCaseForComparison.connectedComponenTDiGraph += (endComponent -
startComponent)
def maincheck_our(s):
ga = GraphAlgo()
t = time.time()
ga.load_from_json(s)
t = time.time() - t
print('loaded:', t)
print()
t = time.time()
ga.connected_components()
t = time.time() - t
print('sccs:', t)
print()
r = rnd(x=0)
keys = list(ga.get_graph().get_all_v().keys())
s, e = map(r.choice, [keys, keys])
t = time.time()
ga.connected_component(s)
t = time.time() - t
print('scc:', t)
print()
t = time.time()
ga.shortest_path(s, e)
t = time.time() - t
print('sp:', t)
print()
def test_small_graph(self):
g = DiGraph()
algo = GraphAlgo(g)
self.assertTrue(g.add_node(1))
self.assertTrue(g.add_node(2))
self.assertTrue(g.add_node(3))
self.assertTrue(g.add_node(4))
self.assertTrue(g.add_node(5))
self.assertTrue(g.add_node(6))
self.assertTrue(g.add_edge(1, 3, 9))
self.assertTrue(g.add_edge(1, 2, 3.45))
self.assertTrue(g.add_edge(1, 6, 14))
self.assertTrue(g.add_edge(2, 3, 10))
self.assertTrue(g.add_edge(2, 4, 2.34322))
self.assertTrue(g.add_edge(3, 6, 2))
self.assertTrue(g.add_edge(3, 4, 11))
self.assertTrue(g.add_edge(4, 5, 6))
self.assertTrue(g.add_edge(6, 5, 9))
self.assertEqual(algo.connected_components(), [[5], [6], [4], [3], [2], [1]])
self.assertTrue(g.add_edge(5, 3, 2.1211))
self.assertTrue(g.add_edge(4, 2, 2.34322))
self.assertTrue(g.add_edge(2, 1, 3.45))
self.assertEqual(algo.connected_components(), [[2, 4, 5, 6, 3, 1]])
self.assertEqual(algo.shortest_path(1, 5), (11.79322, [1, 2, 4, 5]))
self.assertEqual(algo.shortest_path(4, 6), (10.1211, [4, 5, 3, 6]))
self.assertTrue(g.add_node(7))
self.assertEqual(algo.connected_components(), [[2, 4, 5, 6, 3, 1], [7]])
self.assertEqual(algo.connected_component(7), [7])
self.assertTrue(g.remove_node(7))
self.assertEqual(algo.connected_components(), [[2, 4, 5, 6, 3, 1]])
self.assertEqual(algo.connected_component(6), [1, 2, 4, 3, 5, 6])
def run_time(file_name: str, src, dest):
graph_algo = GraphAlgo()
dt = 0
for i in range(100):
start = timeit.default_timer()
graph_algo.load_from_json(file_name)
stop = timeit.default_timer()
dt = dt + (stop - start)
print(graph_algo.get_graph())
print("run time of read from json file and build the graph: ", dt / 100)
dt = 0
for i in range(100):
start = timeit.default_timer()
connecteds = graph_algo.connected_components()
stop = timeit.default_timer()
dt = dt + (stop - start)
# print(connecteds)
print("run time of connected_components: ", dt / 100)
dt = 0
for i in range(100):
start = timeit.default_timer()
graph_algo.connected_component(1)
stop = timeit.default_timer()
dt = dt + (stop - start)
print("run time of connected_component: ", dt / 100)
dt = 0
for i in range(100):
start = timeit.default_timer()
graph_algo.shortest_path(src, dest)
stop = timeit.default_timer()
dt = dt + (stop - start)
print("run time of shortest_path: ", dt / 100)
class TestGraphAlgo(TestCase):
def setUp(self):
self.graph = None
self.ga = GraphAlgo()
def test_load_from_json(self):
self.assertTrue(self.ga.load_from_json("../data/G_10_80_0.json"))
self.assertTrue(self.ga.load_from_json("../data/G_10_80_1.json"))
self.assertTrue(self.ga.load_from_json("../data/G_10_80_2.json"))
def test_save_to_json(self):
self.ga.load_from_json("../data/G_10_80_0.json")
self.assertTrue(self.ga.save_to_json("graph1.json"))
self.ga.load_from_json("../data/G_10_80_1.json")
self.assertTrue(self.ga.save_to_json("graph2.json"))
self.ga.load_from_json("../data/G_10_80_2.json")
self.assertTrue(self.ga.save_to_json("graph3.json"))
def test_shortest_path(self):
self.ga.graph = graph_2
self.assertEqual("(6, [1, 2, 4, 3, 5, 0, 6])", str(self.ga.shortest_path(1, 6)))
self.assertEqual("(2, [3, 5, 0])", str(self.ga.shortest_path(3, 0)))
self.assertEqual("(0, [2])", str(self.ga.shortest_path(2, 2)))
# no path
no_path = (inf, [])
self.assertEqual(no_path, self.ga.shortest_path(6, 1))
# shortest path between nodes that one or more of the nodes does not exist in the graph
self.assertRaises(Exception, self.ga.shortest_path, (10, 1))
self.assertRaises(Exception, self.ga.shortest_path, (1, 10))
self.assertRaises(Exception, self.ga.shortest_path, (9, 10))
def test_connected_component(self):
self.ga.graph = graph_3
for i in range(0, 10):
for j in range(10):
if j in range(3):
self.assertEqual([0, 1, 2], sorted(self.ga.connected_component(j)))
if j in range(3, 5):
self.assertEqual([3, 4], sorted(self.ga.connected_component(j)))
if j in range(5, 7):
self.assertEqual([j], self.ga.connected_component(j))
if j in range(8, 11):
self.assertEqual([7, 8, 9], sorted(self.ga.connected_component(j)))
def test_connected_components(self):
self.ga.graph = graph_2
self.assertEqual([[1, 2, 4, 3, 5, 0], [6]], self.ga.connected_components())
self.ga.graph = graph_3
self.assertEqual([[8, 9, 7], [5], [6], [2, 1, 0], [4, 3]], self.ga.connected_components())
def test_plot_graph(self):
# plot graph without positions
self.ga.graph = graph_2
self.ga.plot_graph()
# plot graph with position
self.ga.graph = graph_3
self.ga.plot_graph()
def test_scc2(self):
g = graph_builder(100)
algo = GraphAlgo(g)
for n in g.get_all_v().keys():
self.assertEqual(1, len(algo.connected_component(n)))
self.assertEqual(0,
len(algo.connected_component(200))) # un-existed node
self.assertEqual(100, len(algo.connected_components()))
def test_connected_component(self):
g1 = create_graph()
g2 = GraphAlgo()
g2.init(g1)
self.assertEqual([1, 2, 4, 0], g2.connected_component(1))
g1.remove_edge(4, 0)
g2.init(g1)
self.assertEqual([1, 2, 4], g2.connected_component(1))
def test_connected_component(self):
g = create_graph(2, 6, 7)
ga = GraphAlgo(g)
for i in [3, 4, 2, 5]:
self.assertEqual({3, 4, 2, 5}, set(ga.connected_component(i)))
self.assertEqual([1], ga.connected_component(1))
self.assertEqual([0], ga.connected_component(0))
self.assertEqual([], ga.connected_component(12))
def test_connected_component(self):
graph = GraphAlgo(create_small_graph())
self.assertEqual(graph.connected_component(3), [2, 3])
self.assertEqual(graph.connected_component(0), [0, 1])
self.assertEqual(graph.connected_component(1), [0, 1])
self.assertEqual(graph.connected_component(9), [])
def check_functions(file_path) -> bool:
with open(file_path) as f:
json_data = json.loads(f.read())
nx_graph = nx.DiGraph()
nx_graph.add_nodes_from(elem['id'] for elem in json_data['Nodes'])
nx_graph.add_weighted_edges_from(
(elem['src'], elem['dest'], elem['w']) for elem in json_data['Edges'])
dg_algo = GraphAlgo()
dg_algo.load_from_json(file_path)
# nx.draw(nx_graph, with_labels=True)
# plt.show()
print("JSON file: " + file_path)
start_time = time.time_ns()
dg_algo.shortest_path(0, 5)
end_time = time.time_ns()
resultTime = end_time - start_time
print("Running time Python shortest_path: " + str(resultTime / 1000000) +
" ms")
start_time = time.time_ns()
print("Shortest Path (0,5) (NetworkX Graph):\n" +
str(nx.shortest_path(nx_graph, source=0, target=5, weight='weight')))
end_time = time.time_ns()
resultTime = end_time - start_time
print("Running time NetworkX shortest_path: " + str(resultTime / 1000000) +
" ms")
start_time = time.time_ns()
print(dg_algo.connected_components())
end_time = time.time_ns()
resultTime = end_time - start_time
print("Running time Python connected_components: " +
str(resultTime / 1000000) + " ms")
start_time = time.time_ns()
connected_components_graph = nx.strongly_connected_components(nx_graph)
end_time = time.time_ns()
# for elem in connected_components_graph:
# print(elem)
resultTime = end_time - start_time
print("Running time NetworkX connected_components: " +
str(resultTime / 1000000) + " ms")
start_time = time.time_ns()
dg_algo.connected_component(9)
# for elem in connected_components_graph:
# print(elem)
end_time = time.time_ns()
resultTime = end_time - start_time
print("Running time Python connected_component: " +
str(resultTime / 1000000) + " ms")
def test_connected_component(self):
ga = GraphAlgo(simpleGraphGenerator())
self.assertEqual(
ga.connected_component(1).sort(), [0, 1, 2].sort(), "worng SCC")
self.assertEqual(ga.connected_component(3), [3], "worng SCC")
self.assertIsNone(ga.connected_component(7),
"node 7 is not in the graph")
def test_connected_component(self):
# _________________ Test My DiGraph component _________________
my_graph_algo = GraphAlgo()
my_graph_algo.load_from_json("../Graphs_no_pos/G_30000_240000_0.json")
my_graph = my_graph_algo.g
start = time.time()
my_graph_algo.connected_component(5)
end = time.time()
print("Component - My DiGraph time: " + str(end - start))
class MyTestCase(unittest.TestCase):
def setUp(
self
) -> None: # loads the file to GraphAlgo object ga and networkx DiGraph object nxg
nxr = NXJsonReader()
file = "C:\\Users\\User\\PycharmProjects\\Ex3\\data\\G_30000_240000_1.json"
nxr.read(file)
self.nxg = nxr.get_graph()
self.ga = GraphAlgo()
self.ga.load_from_json(file)
def test_nx_shortest(
self
): # calculate the shortest path and distance 10 times and return average runtime
start = time.time()
for i in range(10):
nx.shortest_path(self.nxg, 1, 25468, weight="weight")
nx.shortest_path_length(self.nxg, 1, 25468, weight="weight")
end = time.time()
print((end - start) / 10)
def test_nx_CCS(
self
): # finds all the connected components 10 times and return average runtime
start = time.time()
for i in range(10):
nx.strongly_connected_components(self.nxg)
end = time.time()
print((end - start) / 10)
def test_GA_shortest(
self
): # calculate the shortest path and distance 10 times and return average runtime
start = time.time()
for i in range(10):
self.ga.shortest_path(1, 25468)
end = time.time()
print((end - start) / 10)
def test_GA_CCS(
self
): # finds all the connected components 10 times and return average runtime
start = time.time()
for i in range(10):
self.ga.connected_components()
end = time.time()
print((end - start) / 10)
def test_GA_CC(
self
): # finds the nodes that are part of 456 component 10 times and return average runtime
start = time.time()
for i in range(10):
self.ga.connected_component(456)
end = time.time()
print((end - start) / 10)
def test_connected_component(self):
g = self.graphForTest1()
ga = GraphAlgo(g)
print(ga.connected_components())
assert ga.connected_component(5) == [5, 6]
assert 0 in ga.connected_component(2)
assert 9 in ga.connected_component(8)
assert 0 not in ga.connected_component(3)
g.add_edge(3, 0, 1)
assert 0 in ga.connected_component(3)
assert len(ga.connected_component(3)) == 5
def test_scc3(self):
g = graph_builder(20)
algo = GraphAlgo(g)
for i in range(20):
g.add_edge(0, i, i)
self.assertEqual(1, len(algo.connected_component(0)))
for i in range(2, 20, 2):
g.add_edge(i, i - 2, i)
# print("scc of node 0:", algo.connected_component(0))
# print(algo.connected_component(0))
self.assertEqual(10, len(algo.connected_component(0)))
def test_big_dfs(self):
# Checking if there is an exception at some scenario
algo = GraphAlgo()
algo.load_from_json("data/A5")
random.seed(55555)
for i in range(1000):
b = random.randint(0, 47)
c = random.randint(0, 47)
algo.graph.remove_edge(b, c)
algo.graph.remove_edge(c, b)
for i in algo.graph.nodes.keys():
algo.connected_component(i)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
graph = DiGraph()
for i in range(10):
graph.add_node(i)
for i in range(9):
graph.add_edge(i, i + 1, 3)
self.ga = GraphAlgo(graph)
def test_Save_and_load(self):
file_name = "ga.json"
self.ga.save_to_json(file_name)
la = GraphAlgo()
la.load_from_json("ga.json")
self.assertEqual(self.ga.Graph, la.Graph)
def test_shortest_path(self):
self.assertEqual(self.ga.shortest_path(0, 1), [3.0, [0, 1]])
self.assertEqual(self.ga.shortest_path(0, 0), [inf, []])
self.assertEqual(self.ga.shortest_path(0, 9), [27.0, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])
self.ga.Graph.add_edge(0, 9, 5)
self.assertEqual(self.ga.shortest_path(0, 9), [5.0, [0, 9]])
def test_connected_components(self):
self.assertEqual(self.ga.connected_components(), [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]])
self.ga.Graph.add_edge(1, 0, 5)
self.assertEqual(self.ga.connected_components(), [[0, 1], [2], [3], [4], [5], [6], [7], [8], [9]])
self.assertEqual(self.ga.connected_component(0), [0, 1])
empty_graph = GraphAlgo()
self.assertEqual(empty_graph.connected_components(), [])
def test_connected_component_none_graph(self):
ga1 = GraphAlgo(None)
self.assertEqual(
"[]",
ga1.connected_component(0).__str__(),
"connected_component returns "
"uncorrected list for none graph")
def compares_run_time_cc_of_node_json(node_id: int, file_name: str) -> list:
"""
Compares the running time of the Connected component method in GraphAlgo and Networkx
The graph is created from json file
:param file_name:
:return:
"""
graph_algo = GraphAlgo()
graph_algo.load_from_json(file_name)
g = nx.Graph()
nx_graph = g.to_directed()
for node in graph_algo.get_graph().get_all_v().values():
nx_graph.add_node(node.key, pos=node.pos)
for edges in graph_algo.get_graph().Edges.values():
for edge in edges.values():
nx_graph.add_edge(edge.src, edge.dest, weight=edge.weight)
start_time = datetime.now()
for cc_of_node in nx.strongly_connected_components(nx_graph):
if node_id in cc_of_node:
nx_results = list(cc_of_node)
end_time = datetime.now()
run_time_nx = end_time - start_time
print("run time of networkx graph:", run_time_nx)
start_time = datetime.now()
my_results = graph_algo.connected_component(node_id)
end_time = datetime.now()
cc = list()
i = 0
for node in my_results:
cc.append(node.key)
i += 1
cc.sort()
run_time_graph_algo = end_time - start_time
print("run time of GraphAlgo :", run_time_graph_algo)
return [nx_results, cc]
def test_connected_component(self):
graph = DiGraph()
graph.add_node(0)
graph.add_node(1)
graph.add_node(2)
graph.add_node(3)
graph.add_node(4)
graph.add_node(5)
graph.add_node(6)
graph.add_node(7)
graph.add_edge(0, 1, 2)
graph.add_edge(1, 2, 2)
graph.add_edge(2, 0, 2)
graph.add_edge(5, 0, 2)
graph.add_edge(5, 6, 2)
graph.add_edge(6, 2, 2)
graph.add_edge(6, 0, 2)
graph.add_edge(6, 4, 2)
graph.add_edge(4, 5, 2)
graph.add_edge(3, 4, 2)
graph.add_edge(3, 7, 2)
graph.add_edge(7, 3, 2)
graph.add_edge(7, 5, 2)
g_algo = GraphAlgo(graph)
answer = [0, 1, 2]
self.assertEqual(g_algo.connected_component(1), answer)
def check2():
""" This function tests the naming, basic testing over A5 json file.
:return:
"""
g_algo = GraphAlgo()
file = 'data/A5'
g_algo.load_from_json(file)
g_algo.get_graph().remove_edge(13, 14)
g_algo.save_to_json(file + "_edited")
dist, path = g_algo.shortest_path(1, 7)
print(dist, path)
dist, path = g_algo.shortest_path(47, 19)
print(dist, path)
dist, path = g_algo.shortest_path(20, 2)
print(dist, path)
dist, path = g_algo.shortest_path(2, 20)
print(dist, path)
print(g_algo.connected_component(0))
print(g_algo.connected_components())
g_algo.plot_graph()
class TestGraphAlgo(unittest.TestCase):
def setUp(self) -> None:
self.g = DiGraph()
self.g.add_node(1)
self.g.add_node(2)
self.g.add_node(3)
self.g.add_node(4)
self.g.add_node(5)
self.g.add_node(6)
self.g.add_edge(1, 2, 3)
self.g.add_edge(1, 3, 2)
self.g.add_edge(2, 5, 3)
self.g.add_edge(3, 1, 1)
self.g.add_edge(3, 4, 2)
self.g.add_edge(4, 3, 1)
self.g.add_edge(4, 5, 1)
self.g.add_edge(6, 2, 1)
self.ga = GraphAlgo(self.g)
def tearDown(self) -> None:
return None
def test_get_graph(self):
self.assertEqual(True, self.ga.save_to_json('testgraph.json'))
self.assertEqual(True, self.ga.load_from_json('testgraph.json'))
self.assertEqual(False, self.ga.load_from_json('noname.json'))
def test_load_save_json(self):
self.assertEqual(self.g, self.ga.get_graph())
def test_shortest_path(self):
self.assertEqual((5, [1, 3, 4, 5]), self.ga.shortest_path(1, 5))
self.assertEqual((inf, []), self.ga.shortest_path(1, 7))
self.assertEqual((inf, []), self.ga.shortest_path(1, 6))
def test_connected_component(self):
self.assertEqual([1, 3, 4], self.ga.connected_component(1))
self.ga.get_graph().remove_node(1)
self.assertEqual([], self.ga.connected_component(1))
self.ga = GraphAlgo(None)
self.assertEqual([], self.ga.connected_component(1))
def test_connected_components(self):
self.assertEqual([[1, 3, 4], [2], [5], [6]],
self.ga.connected_components())
self.ga = GraphAlgo(None)
self.assertEqual([], self.ga.connected_components())
def check5():
ga = GraphAlgo()
file = '../data/G_20000_160000_1.json'
ga.load_from_json(file)
start1 = time.time()
dist, path = ga.shortest_path(25, 300)
# print(dist, path)
end1 = time.time()
print(end1 - start1)
start2 = time.time()
ga.connected_component(900)
end2 = time.time()
print(end2 - start2)
start3 = time.time()
ga.connected_components()
end3 = time.time()
print(end3 - start3)
def my_scc(file_path: str, id1: int, ) -> float:
algo = GraphAlgo(None)
algo.load_from_json(file_path)
start_time = time.perf_counter()
sccs = algo.connected_component(id1)
end_time = time.perf_counter()
# print("scc in g for specific node:", scc, "\n")
return end_time-start_time
def test_connected_component(self):
self.graph = DiGraph()
galg = GraphAlgo(self.graph)
self.assertEqual((float('inf'), []), galg.shortest_path(0, 1))
for i in range(7):
self.graph.add_node(i, (1, 5, 7))
self.graph.add_edge(5, 6, 4)
self.graph.add_edge(3, 4, 3)
self.graph.add_edge(4, 5, 2)
self.graph.add_edge(4, 6, 5)
self.graph.add_edge(4, 3, 2)
self.graph.add_edge(6, 3, 2)
self.assertEqual([1], galg.connected_component(1))
self.assertEqual([4, 3, 6, 5], galg.connected_component(4))
self.assertEqual([5, 4, 3, 6], galg.connected_component(5))
self.assertEqual([2], galg.connected_component(2))
self.assertEqual([1], galg.connected_component(1))
def test_connected_component_time():
"""
checks the time for the connected_component on a big graph
"""
v, e = 10**6, 10**5
seed(2)
g = graphCreator(v)
for i in range(e):
w = random.uniform(0, 30)
n1 = random.randint(0, v - 1)
n2 = random.randint(0, v - 1)
g.add_edge(n1, n2, w)
ga1 = GraphAlgo(g)
n1 = random.randint(0, v - 1)
start = timeit.default_timer()
ga1.connected_component(n1)
end = timeit.default_timer()
print("time for connected_component-> " + str(end - start))
