class TestDominatingSet2(unittest.TestCase):
def setUp(self):
self.N = 7
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1),
Edge(1, 3),
Edge(1, 2),
Edge(1, 4),
Edge(2, 5),
Edge(2, 6)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#self.G.show()
def test_borie_dset(self):
algorithm = BorieDominatingSet(self.G)
algorithm.run()
expected1 = set([1, 2])
self.assertEqual(algorithm.cardinality, len(expected1))
self.assertEqual(algorithm.dominating_set, expected1)
# Testing dset.
neighbors = set(algorithm.dominating_set)
for node in algorithm.dominating_set:
neighbors.update(self.G.iteradjacent(node))
self.assertEqual(len(neighbors), self.G.v())
def test_tree_dset1(self):
algorithm = TreeDominatingSet1(self.G)
algorithm.run()
expected1 = set([1, 2])
self.assertEqual(algorithm.cardinality, len(expected1))
self.assertEqual(algorithm.dominating_set, expected1)
# Testing dset.
neighbors = set(algorithm.dominating_set)
for node in algorithm.dominating_set:
neighbors.update(self.G.iteradjacent(node))
self.assertEqual(len(neighbors), self.G.v())
def test_tree_dset2(self):
algorithm = TreeDominatingSet2(self.G)
algorithm.run()
expected1 = set([1, 2])
self.assertEqual(algorithm.cardinality, len(expected1))
self.assertEqual(algorithm.dominating_set, expected1)
# Testing dset.
neighbors = set(algorithm.dominating_set)
for node in algorithm.dominating_set:
neighbors.update(self.G.iteradjacent(node))
self.assertEqual(len(neighbors), self.G.v())
def tearDown(self):
pass
class TestAcyclicUdirectedGraph(unittest.TestCase):
def setUp(self):
# The graph from Cormen p.607 changed.
self.N = 8 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 4),
Edge(0, 1),
Edge(1, 5),
Edge(5, 2),
Edge(2, 6),
Edge(6, 3),
Edge(6, 7)
]
self.cycle_edges = [Edge(5, 6), Edge(2, 3), Edge(3, 7)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
#self.G.show()
def test_detect_no_cycles(self):
self.assertEqual(self.G.v(), self.N)
algorithm = AcyclicGraphDFS(self.G)
algorithm.run(1) # it is safe, because G is connected
parent_expected = {1: None, 0: 1, 3: 6, 2: 5, 5: 1, 4: 0, 7: 6, 6: 2}
self.assertEqual(algorithm.parent, parent_expected)
self.assertTrue(is_acyclic(self.G))
def test_detect_cycle1(self):
self.assertEqual(self.G.v(), self.N)
self.G.add_edge(self.cycle_edges[0])
algorithm = AcyclicGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertFalse(is_acyclic(self.G))
def test_detect_cycle2(self):
self.assertEqual(self.G.v(), self.N)
self.G.add_edge(self.cycle_edges[1])
algorithm = AcyclicGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertFalse(is_acyclic(self.G))
def test_detect_cycle3(self):
self.assertEqual(self.G.v(), self.N)
self.G.add_edge(self.cycle_edges[2])
algorithm = AcyclicGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertFalse(is_acyclic(self.G))
def tearDown(self):
pass
class TestBipartiteGraph(unittest.TestCase):
def setUp(self):
self.N = 6 # number of nodes
self.G = Graph(self.N, directed=False)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1),
Edge(1, 2),
Edge(0, 3),
Edge(1, 4),
Edge(2, 5),
Edge(3, 4),
Edge(4, 5)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
#self.G.show()
def test_bipartite_bfs(self):
self.assertEqual(self.G.v(), self.N)
algorithm = BipartiteGraphBFS(self.G)
algorithm.run(0)
color_expected = {0: 0, 2: 0, 4: 0, 1: 1, 3: 1, 5: 1}
self.assertEqual(algorithm.color, color_expected)
def test_bipartite_dfs(self):
self.assertEqual(self.G.v(), self.N)
algorithm = BipartiteGraphDFS(self.G)
algorithm.run(0)
color_expected = {0: 0, 2: 0, 4: 0, 1: 1, 3: 1, 5: 1}
self.assertEqual(algorithm.color, color_expected)
def test_is_bipartite(self):
self.assertTrue(is_bipartite(self.G))
def test_exceptions(self):
self.G.add_edge(Edge(0, 4))
algorithm = BipartiteGraphBFS(self.G)
self.assertRaises(ValueError, algorithm.run)
algorithm = BipartiteGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertRaises(ValueError, BipartiteGraphBFS, Graph(2,
directed=True))
self.assertRaises(ValueError, BipartiteGraphDFS, Graph(2,
directed=True))
def tearDown(self):
pass
class TestAcyclicDirectedGraph(unittest.TestCase):
def setUp(self):
# The graph from
self.N = 8 # number of nodes
self.G = Graph(self.N, directed=True)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1),
Edge(1, 2),
Edge(2, 3),
Edge(0, 4),
Edge(4, 5),
Edge(5, 6),
Edge(5, 7),
Edge(5, 2),
Edge(0, 7)
]
self.cycle_edges = [Edge(3, 1), Edge(5, 4)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
#self.G.show()
def test_detect_no_directed_cycles(self):
self.assertEqual(self.G.v(), self.N)
algorithm = AcyclicGraphDFS(self.G)
algorithm.run(0) # in order to easy test
parent_expected = {0: None, 2: 1, 1: 0, 4: 0, 3: 2, 6: 5, 5: 4, 7: 5}
#parent_expected = {0: None, 2: 1, 1: 0, 4: 0, 3: 2, 6: 5, 5: 4, 7: 0}
self.assertEqual(algorithm.parent, parent_expected)
self.assertTrue(is_acyclic(self.G))
def test_detect_directed_cycle1(self):
self.assertEqual(self.G.v(), self.N)
self.G.add_edge(self.cycle_edges[0])
algorithm = AcyclicGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertFalse(is_acyclic(self.G))
def test_detect_directed_cycle2(self):
self.assertEqual(self.G.v(), self.N)
self.G.add_edge(self.cycle_edges[1])
algorithm = AcyclicGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertFalse(is_acyclic(self.G))
def tearDown(self):
pass
class TestTopologicalSorting(unittest.TestCase):
def setUp(self):
# Knuth s.273 t.1
self.N = 10 # number of nodes
self.G = Graph(self.N, directed=True)
self.nodes = range(self.N)
self.edges = [
Edge(9, 2), Edge(3, 7), Edge(7, 5), Edge(5, 8), Edge(8, 6),
Edge(4, 6), Edge(1, 3), Edge(7, 4), Edge(9, 5), Edge(2, 8)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
def test_topsort_queue(self):
self.assertEqual(self.G.v(), self.N)
algorithm = TopologicalSortQueue(self.G)
algorithm.run()
idx = dict((node, i) for (i, node) in enumerate(algorithm.sorted_nodes))
for edge in self.edges:
self.assertTrue(idx[edge.source] < idx[edge.target])
def test_topsort_dfs(self):
self.assertEqual(self.G.v(), self.N)
algorithm = TopologicalSortDFS(self.G)
algorithm.run()
idx = dict((node, i) for (i, node) in enumerate(algorithm.sorted_nodes))
for edge in self.edges:
self.assertTrue(idx[edge.source] < idx[edge.target])
def test_topsort_set(self):
self.assertEqual(self.G.v(), self.N)
algorithm = TopologicalSortSet(self.G)
algorithm.run()
idx = dict((node, i) for (i, node) in enumerate(algorithm.sorted_nodes))
for edge in self.edges:
self.assertTrue(idx[edge.source] < idx[edge.target])
def test_topsort_list(self):
self.assertEqual(self.G.v(), self.N)
algorithm = TopologicalSortList(self.G)
algorithm.run()
idx = dict((node, i) for (i, node) in enumerate(algorithm.sorted_nodes))
for edge in self.edges:
self.assertTrue(idx[edge.source] < idx[edge.target])
def tearDown(self): pass
class TestKruskal(unittest.TestCase):
def setUp(self):
# The graph (unique weights) from
# http://en.wikipedia.org/wiki/Boruvka's_algorithm
self.N = 7 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1, 7), Edge(1, 2, 11), Edge(0, 3, 4),
Edge(3, 1, 9), Edge(4, 1, 10), Edge(2, 4, 5), Edge(3, 4, 15),
Edge(3, 5, 6), Edge(5, 4, 12), Edge(5, 6, 13), Edge(4, 6, 8)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
def test_mst(self):
self.assertEqual(self.G.v(), self.N)
algorithm = KruskalMST(self.G)
algorithm.run()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-1)
mst_weight_expected = 40
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 7), Edge(0, 3, 4), Edge(2, 4, 5), Edge(1, 4, 10),
Edge(4, 6, 8), Edge(3, 5, 6)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def test_mst_sorted(self):
self.assertEqual(self.G.v(), self.N)
algorithm = KruskalMSTSorted(self.G)
algorithm.run()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-1)
mst_weight_expected = 40
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 7), Edge(0, 3, 4), Edge(2, 4, 5), Edge(1, 4, 10),
Edge(4, 6, 8), Edge(3, 5, 6)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def tearDown(self): pass
class TestKruskalCormen(unittest.TestCase):
def setUp(self):
# The modified graph (unique weights) from Cormen.
self.N = 9 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(1, 7, 11), Edge(1, 2, 12),
Edge(7, 8, 7), Edge(8, 2, 2), Edge(8, 6, 6), Edge(7, 6, 1),
Edge(2, 3, 13), Edge(2, 5, 5), Edge(6, 5, 3), Edge(3, 5, 14),
Edge(3, 4, 9), Edge(5, 4, 10)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
def test_kruskal(self):
self.assertEqual(self.G.v(), self.N)
algorithm = KruskalMST(self.G)
algorithm.run()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-1)
mst_weight_expected = 42
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(8, 2, 2), Edge(7, 6, 1),
Edge(2, 5, 5), Edge(6, 5, 3), Edge(3, 4, 9), Edge(5, 4, 10)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def test_kruskal_sorted(self):
self.assertEqual(self.G.v(), self.N)
algorithm = KruskalMSTSorted(self.G)
algorithm.run()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-1)
mst_weight_expected = 42
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(8, 2, 2), Edge(7, 6, 1),
Edge(2, 5, 5), Edge(6, 5, 3), Edge(3, 4, 9), Edge(5, 4, 10)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def tearDown(self): pass
class TestKruskal(unittest.TestCase):
def setUp(self):
# The graph (unique weights) from
# http://en.wikipedia.org/wiki/Boruvka's_algorithm
self.N = 7 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1, 7), Edge(1, 2, 11), Edge(0, 3, 4),
Edge(3, 1, 9), Edge(4, 1, 10), Edge(2, 4, 5), Edge(3, 4, 15),
Edge(3, 5, 6), Edge(5, 4, 12), Edge(5, 6, 13), Edge(4, 6, 8)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
def test_kruskal(self):
self.assertEqual(self.G.v(), self.N)
algorithm = KruskalMST(self.G)
algorithm.run()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-1)
mst_weight_expected = 40
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 7), Edge(0, 3, 4), Edge(2, 4, 5), Edge(1, 4, 10),
Edge(4, 6, 8), Edge(3, 5, 6)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def test_kruskal_sorted(self):
self.assertEqual(self.G.v(), self.N)
algorithm = KruskalMSTSorted(self.G)
algorithm.run()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-1)
mst_weight_expected = 40
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 7), Edge(0, 3, 4), Edge(2, 4, 5), Edge(1, 4, 10),
Edge(4, 6, 8), Edge(3, 5, 6)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def tearDown(self): pass
class TestKruskalCormen(unittest.TestCase):
def setUp(self):
# The modified graph (unique weights) from Cormen.
self.N = 9 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(1, 7, 11), Edge(1, 2, 12),
Edge(7, 8, 7), Edge(8, 2, 2), Edge(8, 6, 6), Edge(7, 6, 1),
Edge(2, 3, 13), Edge(2, 5, 5), Edge(6, 5, 3), Edge(3, 5, 14),
Edge(3, 4, 9), Edge(5, 4, 10)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
def test_mst_cormen(self):
self.assertEqual(self.G.v(), self.N)
algorithm = KruskalMST(self.G)
algorithm.run()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-1)
mst_weight_expected = 42
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(8, 2, 2), Edge(7, 6, 1),
Edge(2, 5, 5), Edge(6, 5, 3), Edge(3, 4, 9), Edge(5, 4, 10)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def test_mst_cormen_sorted(self):
self.assertEqual(self.G.v(), self.N)
algorithm = KruskalMSTSorted(self.G)
algorithm.run()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-1)
mst_weight_expected = 42
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(8, 2, 2), Edge(7, 6, 1),
Edge(2, 5, 5), Edge(6, 5, 3), Edge(3, 4, 9), Edge(5, 4, 10)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def tearDown(self): pass
class TestAcyclicUdirectedGraph(unittest.TestCase):
def setUp(self):
# The graph from Cormen p.607 changed.
self.N = 8 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 4), Edge(0, 1), Edge(1, 5), Edge(5, 2), Edge(2, 6),
Edge(6, 3), Edge(6, 7)]
self.cycle_edges = [Edge(5, 6), Edge(2, 3), Edge(3, 7)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
#self.G.show()
def test_detect_no_cycles(self):
self.assertEqual(self.G.v(), self.N)
algorithm = AcyclicGraphDFS(self.G)
algorithm.run(1) # it is safe, because G is connected
parent_expected = {1: None, 0: 1, 3: 6, 2: 5, 5: 1, 4: 0, 7: 6, 6: 2}
self.assertEqual(algorithm.parent, parent_expected)
self.assertTrue(is_acyclic(self.G))
def test_detect_cycle1(self):
self.assertEqual(self.G.v(), self.N)
self.G.add_edge(self.cycle_edges[0])
algorithm = AcyclicGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertFalse(is_acyclic(self.G))
def test_detect_cycle2(self):
self.assertEqual(self.G.v(), self.N)
self.G.add_edge(self.cycle_edges[1])
algorithm = AcyclicGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertFalse(is_acyclic(self.G))
def test_detect_cycle3(self):
self.assertEqual(self.G.v(), self.N)
self.G.add_edge(self.cycle_edges[2])
algorithm = AcyclicGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertFalse(is_acyclic(self.G))
def tearDown(self): pass
def test_wheel5(self):
N = 5
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(0, 2),
Edge(0, 3),
Edge(0, 4),
Edge(1, 2),
Edge(2, 3),
Edge(3, 4),
Edge(4, 1)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "wheel5 ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([1, 2, 3, 4]))
algorithm.run()
#print "wheel5 outer", algorithm.outer
#print "wheel5 cycle", algorithm.cycle
parent = {0: None, 1: 0, 2: 0, 3: 0, 4: 0}
self.assertEqual(algorithm.parent, parent)
order = [1, 2, 3, 4, 0]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
def test_halin16(self):
N = 16
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(0, 2),
Edge(0, 15),
Edge(1, 2),
Edge(1, 6),
Edge(2, 3),
Edge(3, 4),
Edge(3, 5),
Edge(4, 5),
Edge(4, 10),
Edge(5, 6),
Edge(6, 7),
Edge(7, 8),
Edge(7, 15),
Edge(8, 9),
Edge(8, 13),
Edge(9, 10),
Edge(9, 11),
Edge(10, 11),
Edge(11, 12),
Edge(12, 13),
Edge(12, 14),
Edge(13, 14),
Edge(14, 15)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin16 ..."
algorithm = HalinGraphTreeDecomposition(
G, outer=set([0, 2, 3, 4, 10, 11, 12, 14, 15]))
algorithm.run()
#print "halin16 outer", algorithm.outer
parent = {
0: 1,
1: None,
2: 1,
3: 5,
4: 5,
5: 6,
6: 1,
7: 6,
8: 7,
9: 8,
10: 9,
11: 9,
12: 13,
13: 8,
14: 13,
15: 7
}
self.assertEqual(algorithm.parent, parent)
order = [5, 9, 13, 1, 11, 12, 8, 2, 3, 6, 0, 4, 10, 14, 15, 7]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
def test_3prism(self):
N = 6
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(1, 2),
Edge(2, 3),
Edge(3, 4),
Edge(4, 5),
Edge(0, 5),
Edge(1, 4),
Edge(2, 0),
Edge(3, 5)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "3prism ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 2, 3, 5]))
#algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 4, 5]))
#algorithm = HalinGraphTreeDecomposition(G, outer=set([1, 2, 3, 4]))
algorithm.run()
#print "3prism outer", algorithm.outer
parent = {0: 1, 1: None, 2: 1, 3: 4, 4: 1, 5: 4}
self.assertEqual(algorithm.parent, parent)
#order = [1, 0, 2, 3, 5, 4]
order = [4, 0, 2, 3, 5, 1]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
def test_halin8c(self):
N = 8
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(0, 5),
Edge(0, 7),
Edge(1, 2),
Edge(1, 7),
Edge(2, 3),
Edge(2, 6),
Edge(3, 4),
Edge(3, 6),
Edge(4, 5),
Edge(4, 6),
Edge(5, 6),
Edge(6, 7)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin8c ..."
algorithm = HalinGraphTreeDecomposition(G,
outer=set([0, 1, 2, 3, 4, 5]))
algorithm.run()
#print "halin8c outer", algorithm.outer
parent = {0: 7, 1: 7, 2: 6, 3: 6, 4: 6, 5: 6, 6: None, 7: 6}
self.assertEqual(algorithm.parent, parent)
#order = [7, 0, 1, 2, 3, 4, 5, 6] # wersja z indeksami
order = [3, 4, 6, 0, 1, 2, 5, 7] # wersja z linkami
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
def test_halin8a(self):
N = 8
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(0, 2),
Edge(0, 7),
Edge(1, 2),
Edge(1, 5),
Edge(2, 3),
Edge(3, 4),
Edge(3, 7),
Edge(4, 5),
Edge(4, 6),
Edge(5, 6),
Edge(6, 7)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin8a ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 7, 6, 5, 1]))
algorithm.run()
#print "halin8a outer", algorithm.outer
parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 4, 6: 4, 7: 3}
self.assertEqual(algorithm.parent, parent)
#order = [2, 4, 0, 1, 5, 6, 7, 3]
order = [4, 2, 0, 1, 5, 6, 7, 3]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
class TestBoruvkaDisconnectedGraph(unittest.TestCase):
def setUp(self):
# The modified graph (unique weights) from Cormen.
self.N = 9 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(1, 7, 11), Edge(1, 2, 12),
Edge(7, 8, 7), Edge(8, 2, 2), Edge(8, 6, 6), Edge(7, 6, 1),
Edge(3, 5, 14), Edge(3, 4, 9), Edge(5, 4, 10)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
def test_boruvka(self):
self.assertEqual(self.G.v(), self.N)
algorithm = BoruvkaMST(self.G)
algorithm.run()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-2) # 2 components
mst_weight_expected = 40
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(8, 2, 2), Edge(7, 6, 1),
Edge(6, 8, 6), Edge(3, 4, 9), Edge(5, 4, 10)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def tearDown(self): pass
def test_add_graph_undirected(self):
T = Graph(self.N)
for node in self.nodes:
T.add_node(node)
T.add_edge(Edge("A", "D", 9))
self.assertEqual(T.v(), self.N)
self.assertEqual(T.e(), 1)
self.G.add_graph(T)
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 6)
class TestBipartiteGraph(unittest.TestCase):
def setUp(self):
self.N = 6 # number of nodes
self.G = Graph(self.N, directed=False)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1), Edge(1, 2), Edge(0, 3), Edge(1, 4), Edge(2, 5),
Edge(3, 4), Edge(4, 5)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
#self.G.show()
def test_bipartite_bfs(self):
self.assertEqual(self.G.v(), self.N)
algorithm = BipartiteGraphBFS(self.G)
algorithm.run(0)
color_expected = {0: 0, 2: 0, 4: 0, 1: 1, 3: 1, 5: 1}
self.assertEqual(algorithm.color, color_expected)
def test_bipartite_dfs(self):
self.assertEqual(self.G.v(), self.N)
algorithm = BipartiteGraphDFS(self.G)
algorithm.run(0)
color_expected = {0: 0, 2: 0, 4: 0, 1: 1, 3: 1, 5: 1}
self.assertEqual(algorithm.color, color_expected)
def test_is_bipartite(self):
self.assertTrue(is_bipartite(self.G))
def test_exceptions(self):
self.G.add_edge(Edge(0, 4))
algorithm = BipartiteGraphBFS(self.G)
self.assertRaises(ValueError, algorithm.run)
algorithm = BipartiteGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertRaises(ValueError, BipartiteGraphBFS, Graph(2, directed=True))
self.assertRaises(ValueError, BipartiteGraphDFS, Graph(2, directed=True))
def tearDown(self): pass
def test_add_graph_undirected(self):
T = Graph(self.N)
for node in self.nodes:
T.add_node(node)
T.add_edge(Edge("A", "D", 9))
self.assertEqual(T.v(), self.N)
self.assertEqual(T.e(), 1)
self.G.add_graph(T)
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 6)
class TestAcyclicDirectedGraph(unittest.TestCase):
def setUp(self):
# The graph from
self.N = 8 # number of nodes
self.G = Graph(self.N, directed=True)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1), Edge(1, 2), Edge(2, 3), Edge(0, 4), Edge(4, 5),
Edge(5, 6), Edge(5, 7), Edge(5, 2), Edge(0, 7)]
self.cycle_edges = [Edge(3, 1), Edge(5, 4)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
#self.G.show()
def test_detect_no_directed_cycles(self):
self.assertEqual(self.G.v(), self.N)
algorithm = AcyclicGraphDFS(self.G)
algorithm.run(0) # in order to easy test
parent_expected = {0: None, 2: 1, 1: 0, 4: 0, 3: 2, 6: 5, 5: 4, 7: 5}
#parent_expected = {0: None, 2: 1, 1: 0, 4: 0, 3: 2, 6: 5, 5: 4, 7: 0}
self.assertEqual(algorithm.parent, parent_expected)
self.assertTrue(is_acyclic(self.G))
def test_detect_directed_cycle1(self):
self.assertEqual(self.G.v(), self.N)
self.G.add_edge(self.cycle_edges[0])
algorithm = AcyclicGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertFalse(is_acyclic(self.G))
def test_detect_directed_cycle2(self):
self.assertEqual(self.G.v(), self.N)
self.G.add_edge(self.cycle_edges[1])
algorithm = AcyclicGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertFalse(is_acyclic(self.G))
def tearDown(self): pass
def test_frucht12(self):
N = 10
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(0, 4),
Edge(0, 11),
Edge(1, 2),
Edge(1, 10),
Edge(2, 3),
Edge(2, 7),
Edge(3, 4),
Edge(3, 5),
Edge(4, 5),
Edge(5, 6),
Edge(6, 7),
Edge(6, 8),
Edge(7, 8),
Edge(8, 9),
Edge(9, 10),
Edge(9, 11),
Edge(10, 11)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "frucht12 ..."
algorithm = HalinGraphTreeDecomposition(G,
outer=set(
[0, 4, 5, 6, 8, 9, 11]))
algorithm.run()
#print "frucht12 outer", algorithm.outer
parent = {
0: 1,
1: None,
2: 1,
3: 2,
4: 3,
5: 3,
6: 7,
7: 2,
8: 7,
9: 10,
10: 1,
11: 10
}
self.assertEqual(algorithm.parent, parent)
#order = [10, 3, 7, 11, 1, 0, 4, 5, 6, 8, 9, 2]
order = [10, 7, 3, 11, 1, 0, 4, 5, 6, 8, 9, 2]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
def test_halin11(self):
N = 11
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(0, 2),
Edge(0, 10),
Edge(1, 2),
Edge(1, 5),
Edge(2, 3),
Edge(3, 4),
Edge(3, 9),
Edge(4, 5),
Edge(4, 6),
Edge(5, 6),
Edge(6, 7),
Edge(7, 8),
Edge(7, 9),
Edge(8, 9),
Edge(8, 10),
Edge(9, 10)
] # E=17
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
algorithm = HalinGraphTreeDecomposition(G,
outer=set(
[0, 1, 5, 6, 7, 8, 10]))
algorithm.run()
#print "halin11 ..."
#print "halin11 outer", algorithm.outer
parent = {
0: 2,
1: 2,
2: None,
3: 2,
4: 3,
5: 4,
6: 4,
7: 9,
8: 9,
9: 3,
10: 9
}
self.assertEqual(algorithm.parent, parent)
order = [4, 8, 9, 2, 0, 1, 5, 6, 7, 10, 3]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
class TestGraphLadder(unittest.TestCase):
def setUp(self):
self.N = 8 # number of nodes
self.G = Graph(self.N)
self.edges = [
Edge(0, 1, 2),
Edge(0, 2, 1),
Edge(2, 3, 5),
Edge(1, 3, 3),
Edge(2, 4, 4),
Edge(3, 5, 6),
Edge(4, 6, 7),
Edge(4, 5, 8),
Edge(5, 7, 9),
Edge(6, 7, 10)
]
for edge in self.edges:
self.G.add_edge(edge)
def test_basic(self):
self.assertFalse(self.G.is_directed())
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), len(self.edges))
def test_edges(self):
for edge in self.edges:
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(self.G.weight(edge), edge.weight)
self.assertFalse(self.G.has_edge(Edge(0, 3)))
self.assertEqual(self.G.weight(Edge(0, 3)), 0) # no edge
def test_del(self):
self.assertEqual(self.G.e(), 10)
self.G.del_node(7)
self.assertEqual(self.G.e(), 8)
self.G.del_node(2)
self.assertEqual(self.G.e(), 5)
def test_adjacent(self):
for node in self.G.iteradjacent(0):
self.assertTrue(node in [1, 2])
for node in self.G.iteradjacent(2):
self.assertTrue(node in [0, 3, 4])
def tearDown(self):
pass
def test_halin10k(self):
N = 10
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(0, 2),
Edge(0, 9),
Edge(1, 2),
Edge(1, 4),
Edge(2, 3),
Edge(3, 4),
Edge(3, 8),
Edge(4, 5),
Edge(5, 6),
Edge(5, 7),
Edge(6, 7),
Edge(6, 9),
Edge(7, 8),
Edge(8, 9)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin10k ..."
algorithm = HalinGraphTreeDecomposition(G,
outer=set([0, 1, 4, 5, 6, 9]))
algorithm.run()
#print "halin10k outer", algorithm.outer
parent = {
0: 2,
1: 2,
2: None,
3: 2,
4: 3,
5: 7,
6: 7,
7: 8,
8: 3,
9: 8
}
self.assertEqual(algorithm.parent, parent)
order = [7, 2, 6, 8, 0, 1, 4, 5, 9, 3]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
def test_wheel5(self):
N = 5
G = Graph(N, False)
edges = [Edge(0, 1), Edge(0, 2), Edge(0, 3), Edge(0, 4),
Edge(1, 2), Edge(2, 3), Edge(3, 4), Edge(4, 1)]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "wheel5 ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([1, 2, 3, 4]))
algorithm.run()
#print "wheel5 outer", algorithm.outer
#print "wheel5 cycle", algorithm.cycle
parent = {0: None, 1: 0, 2: 0, 3: 0, 4: 0}
self.assertEqual(algorithm.parent, parent)
order = [1, 2, 3, 4, 0]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v()-3)
def test_halin8c(self):
N = 8
G = Graph(N, False)
edges = [Edge(0, 1), Edge(0, 5), Edge(0, 7), Edge(1, 2),
Edge(1, 7), Edge(2, 3), Edge(2, 6), Edge(3, 4), Edge(3, 6),
Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7)]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin8c ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 2, 3, 4, 5]))
algorithm.run()
#print "halin8c outer", algorithm.outer
parent = {0: 7, 1: 7, 2: 6, 3: 6, 4: 6, 5: 6, 6: None, 7: 6}
self.assertEqual(algorithm.parent, parent)
#order = [7, 0, 1, 2, 3, 4, 5, 6] # wersja z indeksami
order = [3, 4, 6, 0, 1, 2, 5, 7] # wersja z linkami
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v()-3)
def test_halin7(self):
N = 7
G = Graph(N, False)
edges = [Edge(0, 1), Edge(0, 2), Edge(0, 6), Edge(1, 2),
Edge(1, 4), Edge(2, 3), Edge(3, 4), Edge(3, 5),
Edge(4, 5), Edge(4, 6), Edge(5, 6)]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin7 ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 2, 3, 5, 6]))
algorithm.run()
#print "halin7 outer", algorithm.outer
parent = {0: 1, 1: None, 2: 1, 3: 4, 4: 1, 5: 4, 6: 4}
self.assertEqual(algorithm.parent, parent)
#order = [1, 0, 2, 3, 5, 6, 4]
order = [5, 4, 0, 2, 3, 6, 1]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v()-3)
def test_halin10k(self):
N = 10
G = Graph(N, False)
edges = [Edge(0, 1), Edge(0, 2), Edge(0, 9), Edge(1, 2),
Edge(1, 4), Edge(2, 3), Edge(3, 4), Edge(3, 8),
Edge(4, 5), Edge(5, 6), Edge(5, 7), Edge(6, 7),
Edge(6, 9), Edge(7, 8), Edge(8, 9)]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin10k ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 4, 5, 6, 9]))
algorithm.run()
#print "halin10k outer", algorithm.outer
parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 7, 6: 7, 7: 8, 8: 3, 9: 8}
self.assertEqual(algorithm.parent, parent)
order = [7, 2, 6, 8, 0, 1, 4, 5, 9, 3]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v()-3)
def test_halin8a(self):
N = 8
G = Graph(N, False)
edges = [Edge(0, 1), Edge(0, 2), Edge(0, 7), Edge(1, 2),
Edge(1, 5), Edge(2, 3), Edge(3, 4), Edge(3, 7),
Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7)]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin8a ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 7, 6, 5, 1]))
algorithm.run()
#print "halin8a outer", algorithm.outer
parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 4, 6: 4, 7: 3}
self.assertEqual(algorithm.parent, parent)
#order = [2, 4, 0, 1, 5, 6, 7, 3]
order = [4, 2, 0, 1, 5, 6, 7, 3]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v()-3)
def test_halin11(self):
N = 11
G = Graph(N, False)
edges = [Edge(0, 1), Edge(0, 2), Edge(0, 10), Edge(1, 2),
Edge(1, 5), Edge(2, 3), Edge(3, 4), Edge(3, 9),
Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7),
Edge(7, 8), Edge(7, 9), Edge(8, 9), Edge(8, 10),
Edge(9, 10)] # E=17
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 5, 6, 7, 8, 10]))
algorithm.run()
#print "halin11 ..."
#print "halin11 outer", algorithm.outer
parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 4, 6: 4, 7: 9, 8: 9, 9: 3, 10: 9}
self.assertEqual(algorithm.parent, parent)
order = [4, 8, 9, 2, 0, 1, 5, 6, 7, 10, 3]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v()-3)
def test_halin10l(self):
N = 10
G = Graph(N, False)
edges = [Edge(0, 1), Edge(0, 4), Edge(0, 9), Edge(1, 2),
Edge(1, 9), Edge(2, 3), Edge(2, 7), Edge(3, 4),
Edge(3, 5), Edge(4, 5), Edge(5, 6), Edge(6, 7),
Edge(6, 8), Edge(7, 8), Edge(8, 9)]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin10l ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 4, 5, 6, 8, 9]))
algorithm.run()
#print "halin10l outer", algorithm.outer
parent = {0: 1, 1: None, 2: 1, 3: 2, 4: 3, 5: 3, 6: 7, 7: 2, 8: 7, 9: 1}
self.assertEqual(algorithm.parent, parent)
#order = [3, 1, 7, 0, 4, 5, 6, 8, 9, 2]
order = [3, 7, 1, 0, 4, 5, 6, 8, 9, 2]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v()-3)
class TestGraphLadder(unittest.TestCase):
def setUp(self):
self.N = 8 # number of nodes
self.G = Graph(self.N)
self.edges = [
Edge(0, 1, 2), Edge(0, 2, 1), Edge(2, 3, 5),
Edge(1, 3, 3), Edge(2, 4, 4), Edge(3, 5, 6), Edge(4, 6, 7),
Edge(4, 5, 8), Edge(5, 7, 9), Edge(6, 7, 10)]
for edge in self.edges:
self.G.add_edge(edge)
def test_basic(self):
self.assertFalse(self.G.is_directed())
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), len(self.edges))
def test_edges(self):
for edge in self.edges:
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(self.G.weight(edge), edge.weight)
self.assertFalse(self.G.has_edge(Edge(0, 3)))
self.assertEqual(self.G.weight(Edge(0, 3)), 0) # no edge
def test_del(self):
self.assertEqual(self.G.e(), 10)
self.G.del_node(7)
self.assertEqual(self.G.e(), 8)
self.G.del_node(2)
self.assertEqual(self.G.e(), 5)
def test_adjacent(self):
for node in self.G.iteradjacent(0):
self.assertTrue(node in [1, 2])
for node in self.G.iteradjacent(2):
self.assertTrue(node in [0, 3, 4])
def tearDown(self): pass
def test_halin16(self):
N = 16
G = Graph(N, False)
edges = [Edge(0, 1), Edge(0, 2), Edge(0, 15), Edge(1, 2),
Edge(1, 6), Edge(2, 3), Edge(3, 4), Edge(3, 5),
Edge(4, 5), Edge(4, 10), Edge(5, 6), Edge(6, 7),
Edge(7, 8), Edge(7, 15), Edge(8, 9), Edge(8, 13),
Edge(9, 10), Edge(9, 11), Edge(10, 11), Edge(11, 12),
Edge(12, 13), Edge(12, 14), Edge(13, 14), Edge(14, 15)]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin16 ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 2, 3, 4, 10, 11, 12, 14, 15]))
algorithm.run()
#print "halin16 outer", algorithm.outer
parent = {0: 1, 1: None, 2: 1, 3: 5, 4: 5, 5: 6, 6: 1, 7: 6,
8: 7, 9: 8, 10: 9, 11: 9, 12: 13, 13: 8, 14: 13, 15: 7}
self.assertEqual(algorithm.parent, parent)
order = [5, 9, 13, 1, 11, 12, 8, 2, 3, 6, 0, 4, 10, 14, 15, 7]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v()-3)
class TestGraphUndirected(unittest.TestCase):
def setUp(self):
self.N = 4 # number of nodes
self.G = Graph(self.N)
self.nodes = ["A", "B", "C", "D"]
self.edges = [
Edge("A", "B", 2),
Edge("B", "C", 4),
Edge("C", "A", 6),
Edge("C", "D", 3),
Edge("D", "B", 5)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#self.G.show()
def test_undirected(self):
self.assertFalse(self.G.is_directed())
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 5)
self.G.del_node("B")
self.assertEqual(self.G.v(), 3)
self.assertEqual(self.G.e(), 2)
def test_iteredges(self):
inedges_B = list(self.G.iterinedges("B"))
outedges_B = list(self.G.iteroutedges("B"))
#print inedges_B, outedges_B
self.assertEqual(len(inedges_B), 3)
self.assertEqual(len(outedges_B), 3)
def test_iteredges_connected(self):
start_edge = next(self.G.iteredges())
A = set([start_edge.source, start_edge.target])
for edge in self.G.iteredges_connected(start_edge):
B = set([edge.source, edge.target])
self.assertTrue(len(A & B) > 0)
A.update(B)
#print ( A )
def test_copy(self):
T = self.G.copy()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_transpose(self):
T = self.G.transpose()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(~edge))
def test_complement(self):
T = self.G.complement()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.N * (self.N - 1) / 2 - self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertFalse(self.G.has_edge(edge))
for edge in self.G.iteredges():
self.assertFalse(T.has_edge(edge))
def test_subgraph(self):
T = self.G.subgraph(["A", "B", "C"])
self.assertEqual(T.v(), 3)
self.assertEqual(T.e(), 3)
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_degree(self):
self.assertEqual(self.G.degree("A"), 2)
self.assertEqual(self.G.degree("B"), 3)
self.assertEqual(self.G.degree("C"), 3)
self.assertEqual(self.G.degree("D"), 2)
def test_add_graph_undirected(self):
T = Graph(self.N)
for node in self.nodes:
T.add_node(node)
T.add_edge(Edge("A", "D", 9))
self.assertEqual(T.v(), self.N)
self.assertEqual(T.e(), 1)
self.G.add_graph(T)
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 6)
def test_load_save(self):
name1 = "undirected_graph.txt"
name2 = "undirected_graph.lgl"
name3 = "undirected_graph.ncol"
self.G.save(name1)
self.G.save_lgl(name2)
self.G.save_ncol(name3)
T = Graph.load(name1)
self.assertEqual(self.G, T)
def tearDown(self):
pass
class TestGraphDirected(unittest.TestCase):
def setUp(self):
self.N = 4 # number of nodes
self.G = Graph(self.N, directed=True)
self.nodes = ["A", "B", "C", "D"]
self.edges = [
Edge("A", "B", 2),
Edge("B", "C", 4),
Edge("C", "A", 6),
Edge("C", "D", 3),
Edge("D", "B", 5)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#self.G.show()
def test_directed(self):
self.assertTrue(self.G.is_directed())
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 5)
self.G.del_node("B")
self.assertEqual(self.G.v(), 3)
self.assertEqual(self.G.e(), 2)
def test_cmp(self):
T = Graph(self.N)
self.assertFalse(T == self.G, "directed and undirected graphs")
T = Graph(self.N, directed=True)
for node in ["A", "B", "C", "X"]:
T.add_node(node)
self.assertFalse(T == self.G, "nodes are different")
T.del_node("X")
self.assertFalse(T == self.G, "numbers of nodes are different")
T.add_node("D")
T.add_edge(Edge("A", "B", 2))
T.add_edge(Edge("B", "C", 4))
T.add_edge(Edge("C", "A", 6))
T.add_edge(Edge("C", "D", 3))
self.assertFalse(T == self.G, "edge numbers are different")
T.add_edge(Edge("D", "B", 7))
self.assertFalse(T == self.G, "edge weights are different")
T.del_edge(Edge("D", "B", 7))
T.add_edge(Edge("B", "D", 5))
self.assertFalse(T == self.G, "edge directions are different")
T.del_edge(Edge("B", "D", 5))
T.add_edge(Edge("D", "B", 5))
self.assertTrue(T == self.G, "graphs are the same")
def test_iteredges(self):
inedges_B = list(self.G.iterinedges("B"))
outedges_B = list(self.G.iteroutedges("B"))
#print inedges_B, outedges_B
self.assertEqual(len(inedges_B), 2)
self.assertEqual(len(outedges_B), 1)
def test_copy(self):
T = self.G.copy()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_transpose(self):
T = self.G.transpose()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(~edge))
def test_complement(self):
T = self.G.complement()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.N * (self.N - 1) - self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertFalse(self.G.has_edge(edge))
for edge in self.G.iteredges():
self.assertFalse(T.has_edge(edge))
def test_subgraph(self):
T = self.G.subgraph(["A", "B", "C"])
self.assertEqual(T.v(), 3)
self.assertEqual(T.e(), 3)
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_add_graph_directed(self):
T = Graph(self.N, directed=True)
for node in self.nodes:
T.add_node(node)
T.add_edge(Edge("A", "D", 9))
self.assertEqual(T.v(), self.N)
self.assertEqual(T.e(), 1)
self.G.add_graph(T)
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 6)
def test_degree(self):
self.assertEqual(self.G.indegree("A"), 1)
self.assertEqual(self.G.indegree("B"), 2)
self.assertEqual(self.G.indegree("C"), 1)
self.assertEqual(self.G.indegree("D"), 1)
self.assertEqual(self.G.outdegree("A"), 1)
self.assertEqual(self.G.outdegree("B"), 1)
self.assertEqual(self.G.outdegree("C"), 2)
self.assertEqual(self.G.outdegree("D"), 1)
def test_exceptions(self):
self.assertRaises(ValueError, self.G.add_edge, Edge("A", "A", 1))
self.assertRaises(ValueError, self.G.add_edge, Edge("A", "B", 2))
self.assertRaises(ValueError, self.G.degree, "A")
def tearDown(self):
pass
V = 8 # number of nodes
E = V*(V-1) // 2 # number of edges
G = Graph(n=V, directed=False)
for i in range(V):
G.add_node((random.random(), random.random()))
for source in G.iternodes():
for target in G.iternodes():
if source < target:
x0, y0 = source
x1, y1 = target
weight = math.hypot(x1-x0, y1-y0)
G.add_edge(Edge(source, target, weight))
#G.show()
print ( "Calculate parameters ..." )
print ( "Nodes: {} {}".format( G.v(), V ))
print ( "Edges: {} {}".format( G.e(), E ))
print ( "Directed: {}".format( G.is_directed() ))
print ( "Delta: {}".format( max(G.degree(node) for node in G.iternodes()) ))
print ( "Testing BruteForceTSPWithGraph ..." )
t1 = timeit.Timer(lambda: BruteForceTSPWithGraph(G).run())
print ( "{} {} {}".format(V, E, t1.timeit(1)) ) # single run
print ( "Testing NearestNeighborTSPWithGraph ..." )
t1 = timeit.Timer(lambda: NearestNeighborTSPWithGraph(G).run())
print ( "{} {} {}".format(V, E, t1.timeit(1)) ) # single run
print ( "Testing RepeatedNearestNeighborTSPWithGraph ..." )
t1 = timeit.Timer(lambda: RepeatedNearestNeighborTSPWithGraph(G).run())
print ( "{} {} {}".format(V, E, t1.timeit(1)) ) # single run
V = 8 # number of nodes
E = V * (V - 1) // 2 # number of edges
G = Graph(n=V, directed=False)
for i in range(V):
G.add_node((random.random(), random.random()))
for source in G.iternodes():
for target in G.iternodes():
if source < target:
x0, y0 = source
x1, y1 = target
weight = math.hypot(x1 - x0, y1 - y0)
G.add_edge(Edge(source, target, weight))
#G.show()
print("Calculate parameters ...")
print("Nodes: {} {}".format(G.v(), V))
print("Edges: {} {}".format(G.e(), E))
print("Directed: {}".format(G.is_directed()))
print("Delta: {}".format(max(G.degree(node) for node in G.iternodes())))
print("Testing BruteForceTSPWithGraph ...")
t1 = timeit.Timer(lambda: BruteForceTSPWithGraph(G).run())
print("{} {} {}".format(V, E, t1.timeit(1))) # single run
print("Testing NearestNeighborTSPWithGraph ...")
t1 = timeit.Timer(lambda: NearestNeighborTSPWithGraph(G).run())
print("{} {} {}".format(V, E, t1.timeit(1))) # single run
print("Testing RepeatedNearestNeighborTSPWithGraph ...")
t1 = timeit.Timer(lambda: RepeatedNearestNeighborTSPWithGraph(G).run())
print("{} {} {}".format(V, E, t1.timeit(1))) # single run
class TestGraphDirected(unittest.TestCase):
def setUp(self):
self.N = 4 # number of nodes
self.G = Graph(self.N, directed=True)
self.nodes = ["A", "B", "C", "D"]
self.edges = [
Edge("A", "B", 2), Edge("B", "C", 4), Edge("C", "A", 6),
Edge("C", "D", 3), Edge("D", "B", 5)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#self.G.show()
def test_directed(self):
self.assertTrue(self.G.is_directed())
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 5)
self.G.del_node("B")
self.assertEqual(self.G.v(), 3)
self.assertEqual(self.G.e(), 2)
def test_cmp(self):
T = Graph(self.N)
self.assertFalse(T == self.G, "directed and undirected graphs")
T = Graph(self.N, directed=True)
for node in ["A", "B", "C", "X"]:
T.add_node(node)
self.assertFalse(T == self.G, "nodes are different")
T.del_node("X")
self.assertFalse(T == self.G, "numbers of nodes are different")
T.add_node("D")
T.add_edge(Edge("A", "B", 2))
T.add_edge(Edge("B", "C", 4))
T.add_edge(Edge("C", "A", 6))
T.add_edge(Edge("C", "D", 3))
self.assertFalse(T == self.G, "edge numbers are different")
T.add_edge(Edge("D", "B", 7))
self.assertFalse(T == self.G, "edge weights are different")
T.del_edge(Edge("D", "B", 7))
T.add_edge(Edge("B", "D", 5))
self.assertFalse(T == self.G, "edge directions are different")
T.del_edge(Edge("B", "D", 5))
T.add_edge(Edge("D", "B", 5))
self.assertTrue(T == self.G, "graphs are the same")
def test_iteredges(self):
inedges_B = list(self.G.iterinedges("B"))
outedges_B = list(self.G.iteroutedges("B"))
#print inedges_B, outedges_B
self.assertEqual(len(inedges_B), 2)
self.assertEqual(len(outedges_B), 1)
def test_copy(self):
T = self.G.copy()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_transpose(self):
T = self.G.transpose()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(~edge))
def test_complement(self):
T = self.G.complement()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.N*(self.N-1) - self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertFalse(self.G.has_edge(edge))
for edge in self.G.iteredges():
self.assertFalse(T.has_edge(edge))
def test_subgraph(self):
T = self.G.subgraph(["A", "B", "C"])
self.assertEqual(T.v(), 3)
self.assertEqual(T.e(), 3)
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_add_graph_directed(self):
T = Graph(self.N, directed=True)
for node in self.nodes:
T.add_node(node)
T.add_edge(Edge("A", "D", 9))
self.assertEqual(T.v(), self.N)
self.assertEqual(T.e(), 1)
self.G.add_graph(T)
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 6)
def test_degree(self):
self.assertEqual(self.G.indegree("A"), 1)
self.assertEqual(self.G.indegree("B"), 2)
self.assertEqual(self.G.indegree("C"), 1)
self.assertEqual(self.G.indegree("D"), 1)
self.assertEqual(self.G.outdegree("A"), 1)
self.assertEqual(self.G.outdegree("B"), 1)
self.assertEqual(self.G.outdegree("C"), 2)
self.assertEqual(self.G.outdegree("D"), 1)
def test_exceptions(self):
self.assertRaises(ValueError, self.G.add_edge, Edge("A", "A", 1))
self.assertRaises(ValueError, self.G.add_edge, Edge("A", "B", 2))
self.assertRaises(ValueError, self.G.degree, "A")
def tearDown(self): pass
class TestDFS(unittest.TestCase):
def setUp(self):
# The graph from Cormen p.607
self.N = 8 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 4, 2), Edge(0, 1, 3), Edge(1, 5, 4), Edge(5, 2, 5),
Edge(5, 6, 6), Edge(2, 6, 7), Edge(2, 3, 8), Edge(6, 3, 9),
Edge(6, 7, 10), Edge(3, 7, 11)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
#self.G.show()
def test_dfs_with_stack(self):
self.assertEqual(self.G.v(), self.N)
pre_order = []
post_order = []
algorithm = DFSWithStack(self.G)
algorithm.run(1, pre_action=lambda node: pre_order.append(node),
post_action=lambda node: post_order.append(node))
pre_order_expected = [1, 0, 5, 2, 6, 3, 7, 4]
post_order_expected = [1, 5, 6, 7, 3, 2, 0, 4]
self.assertEqual(pre_order, pre_order_expected)
self.assertEqual(post_order, post_order_expected)
dd_expected = {0: 2, 1: 1, 2: 5, 3: 8, 4: 14, 5: 3, 6: 6, 7: 9}
ff_expected = {0: 15, 1: 4, 2: 13, 3: 12, 4: 16, 5: 7, 6: 10, 7: 11}
self.assertEqual(algorithm.dd, dd_expected)
self.assertEqual(algorithm.ff, ff_expected)
parent_expected = {0: 1, 1: None, 2: 5, 3: 6, 4: 0, 5: 1, 6: 5, 7: 6}
self.assertEqual(algorithm.parent, parent_expected)
self.assertEqual(algorithm.path(1, 7), [1, 5, 6, 7])
self.assertEqual(algorithm.path(1, 4), [1, 0, 4])
#algorithm.dag.show()
self.assertEqual(algorithm.dag.v(), self.N)
self.assertEqual(algorithm.dag.e(), self.N-1)
self.assertTrue(algorithm.dag.is_directed())
for edge in algorithm.dag.iteredges():
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(edge.weight, self.G.weight(edge))
def test_dfs_with_recursion(self):
self.assertEqual(self.G.v(), self.N)
pre_order = []
post_order = []
algorithm = DFSWithRecursion(self.G)
algorithm.run(1, pre_action=lambda node: pre_order.append(node),
post_action=lambda node: post_order.append(node))
pre_order_expected = [1, 0, 4, 5, 2, 3, 6, 7]
post_order_expected = [4, 0, 7, 6, 3, 2, 5, 1]
self.assertEqual(pre_order, pre_order_expected)
self.assertEqual(post_order, post_order_expected)
dd_expected = {0: 2, 1: 1, 2: 7, 3: 8, 4: 3, 5: 6, 6: 9, 7: 10}
ff_expected = {0: 5, 1: 16, 2: 14, 3: 13, 4: 4, 5: 15, 6: 12, 7: 11}
self.assertEqual(algorithm.dd, dd_expected)
self.assertEqual(algorithm.ff, ff_expected)
parent_expected = {0: 1, 1: None, 2: 5, 3: 2, 4: 0, 5: 1, 6: 3, 7: 6}
self.assertEqual(algorithm.parent, parent_expected)
self.assertEqual(algorithm.path(1, 7), [1, 5, 2, 3, 6, 7])
self.assertEqual(algorithm.path(1, 4), [1, 0, 4])
#algorithm.dag.show()
self.assertEqual(algorithm.dag.v(), self.N)
self.assertEqual(algorithm.dag.e(), self.N-1)
self.assertTrue(algorithm.dag.is_directed())
for edge in algorithm.dag.iteredges():
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(edge.weight, self.G.weight(edge))
def test_simple_dfs_with_recursion(self):
self.assertEqual(self.G.v(), self.N)
pre_order = []
post_order = []
algorithm = SimpleDFS(self.G)
algorithm.run(1, pre_action=lambda node: pre_order.append(node),
post_action=lambda node: post_order.append(node))
pre_order_expected = [1, 0, 4, 5, 2, 3, 6, 7]
post_order_expected = [4, 0, 7, 6, 3, 2, 5, 1]
self.assertEqual(pre_order, pre_order_expected)
self.assertEqual(post_order, post_order_expected)
parent_expected = {0: 1, 1: None, 2: 5, 3: 2, 4: 0, 5: 1, 6: 3, 7: 6}
self.assertEqual(algorithm.parent, parent_expected)
self.assertEqual(algorithm.path(1, 7), [1, 5, 2, 3, 6, 7])
self.assertEqual(algorithm.path(1, 4), [1, 0, 4])
#algorithm.dag.show()
self.assertEqual(algorithm.dag.v(), self.N)
self.assertEqual(algorithm.dag.e(), self.N-1)
self.assertTrue(algorithm.dag.is_directed())
for edge in algorithm.dag.iteredges():
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(edge.weight, self.G.weight(edge))
def tearDown(self): pass
class TestDFS(unittest.TestCase):
def setUp(self):
# The graph from Cormen p.607
self.N = 8 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 4, 2),
Edge(0, 1, 3),
Edge(1, 5, 4),
Edge(5, 2, 5),
Edge(5, 6, 6),
Edge(2, 6, 7),
Edge(2, 3, 8),
Edge(6, 3, 9),
Edge(6, 7, 10),
Edge(3, 7, 11)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
#self.G.show()
def test_dfs_with_stack(self):
self.assertEqual(self.G.v(), self.N)
pre_order = []
post_order = []
algorithm = DFSWithStack(self.G)
algorithm.run(1,
pre_action=lambda node: pre_order.append(node),
post_action=lambda node: post_order.append(node))
pre_order_expected = [1, 0, 5, 2, 6, 3, 7, 4]
post_order_expected = [1, 5, 6, 7, 3, 2, 0, 4]
self.assertEqual(pre_order, pre_order_expected)
self.assertEqual(post_order, post_order_expected)
dd_expected = {0: 2, 1: 1, 2: 5, 3: 8, 4: 14, 5: 3, 6: 6, 7: 9}
ff_expected = {0: 15, 1: 4, 2: 13, 3: 12, 4: 16, 5: 7, 6: 10, 7: 11}
self.assertEqual(algorithm.dd, dd_expected)
self.assertEqual(algorithm.ff, ff_expected)
parent_expected = {0: 1, 1: None, 2: 5, 3: 6, 4: 0, 5: 1, 6: 5, 7: 6}
self.assertEqual(algorithm.parent, parent_expected)
self.assertEqual(algorithm.path(1, 7), [1, 5, 6, 7])
self.assertEqual(algorithm.path(1, 4), [1, 0, 4])
#algorithm.dag.show()
self.assertEqual(algorithm.dag.v(), self.N)
self.assertEqual(algorithm.dag.e(), self.N - 1)
self.assertTrue(algorithm.dag.is_directed())
for edge in algorithm.dag.iteredges():
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(edge.weight, self.G.weight(edge))
def test_dfs_with_recursion(self):
self.assertEqual(self.G.v(), self.N)
pre_order = []
post_order = []
algorithm = DFSWithRecursion(self.G)
algorithm.run(1,
pre_action=lambda node: pre_order.append(node),
post_action=lambda node: post_order.append(node))
pre_order_expected = [1, 0, 4, 5, 2, 3, 6, 7]
post_order_expected = [4, 0, 7, 6, 3, 2, 5, 1]
self.assertEqual(pre_order, pre_order_expected)
self.assertEqual(post_order, post_order_expected)
dd_expected = {0: 2, 1: 1, 2: 7, 3: 8, 4: 3, 5: 6, 6: 9, 7: 10}
ff_expected = {0: 5, 1: 16, 2: 14, 3: 13, 4: 4, 5: 15, 6: 12, 7: 11}
self.assertEqual(algorithm.dd, dd_expected)
self.assertEqual(algorithm.ff, ff_expected)
parent_expected = {0: 1, 1: None, 2: 5, 3: 2, 4: 0, 5: 1, 6: 3, 7: 6}
self.assertEqual(algorithm.parent, parent_expected)
self.assertEqual(algorithm.path(1, 7), [1, 5, 2, 3, 6, 7])
self.assertEqual(algorithm.path(1, 4), [1, 0, 4])
#algorithm.dag.show()
self.assertEqual(algorithm.dag.v(), self.N)
self.assertEqual(algorithm.dag.e(), self.N - 1)
self.assertTrue(algorithm.dag.is_directed())
for edge in algorithm.dag.iteredges():
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(edge.weight, self.G.weight(edge))
def test_simple_dfs_with_recursion(self):
self.assertEqual(self.G.v(), self.N)
pre_order = []
post_order = []
algorithm = SimpleDFS(self.G)
algorithm.run(1,
pre_action=lambda node: pre_order.append(node),
post_action=lambda node: post_order.append(node))
pre_order_expected = [1, 0, 4, 5, 2, 3, 6, 7]
post_order_expected = [4, 0, 7, 6, 3, 2, 5, 1]
self.assertEqual(pre_order, pre_order_expected)
self.assertEqual(post_order, post_order_expected)
parent_expected = {0: 1, 1: None, 2: 5, 3: 2, 4: 0, 5: 1, 6: 3, 7: 6}
self.assertEqual(algorithm.parent, parent_expected)
self.assertEqual(algorithm.path(1, 7), [1, 5, 2, 3, 6, 7])
self.assertEqual(algorithm.path(1, 4), [1, 0, 4])
#algorithm.dag.show()
self.assertEqual(algorithm.dag.v(), self.N)
self.assertEqual(algorithm.dag.e(), self.N - 1)
self.assertTrue(algorithm.dag.is_directed())
for edge in algorithm.dag.iteredges():
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(edge.weight, self.G.weight(edge))
def tearDown(self):
pass
class TestBFS(unittest.TestCase):
def setUp(self):
# The graph from Cormen p.607
self.N = 8 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 4, 2),
Edge(0, 1, 3),
Edge(1, 5, 4),
Edge(5, 2, 5),
Edge(5, 6, 6),
Edge(2, 6, 7),
Edge(2, 3, 8),
Edge(6, 3, 9),
Edge(6, 7, 10),
Edge(3, 7, 11)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
#self.G.show()
def test_bfs(self):
self.assertEqual(self.G.v(), self.N)
pre_order = []
post_order = []
algorithm = BFSWithQueue(self.G)
algorithm.run(1,
pre_action=lambda node: pre_order.append(node),
post_action=lambda node: post_order.append(node))
order_expected = [1, 0, 5, 4, 2, 6, 3, 7]
self.assertEqual(pre_order, order_expected)
self.assertEqual(post_order, order_expected)
distance_expected = {0: 1, 1: 0, 2: 2, 3: 3, 4: 2, 5: 1, 6: 2, 7: 3}
self.assertEqual(algorithm.distance, distance_expected)
parent_expected = {0: 1, 1: None, 2: 5, 3: 2, 4: 0, 5: 1, 6: 5, 7: 6}
self.assertEqual(algorithm.parent, parent_expected)
self.assertEqual(algorithm.path(1, 7), [1, 5, 6, 7])
self.assertEqual(algorithm.path(1, 4), [1, 0, 4])
self.assertRaises(ValueError, algorithm.path, 4, 7)
#algorithm.dag.show()
self.assertEqual(algorithm.dag.v(), self.N)
self.assertEqual(algorithm.dag.e(), self.N - 1)
self.assertTrue(algorithm.dag.is_directed())
for edge in algorithm.dag.iteredges():
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(edge.weight, self.G.weight(edge))
def test_simple_bfs(self):
self.assertEqual(self.G.v(), self.N)
pre_order = []
post_order = []
algorithm = SimpleBFS(self.G)
algorithm.run(1,
pre_action=lambda node: pre_order.append(node),
post_action=lambda node: post_order.append(node))
order_expected = [1, 0, 5, 4, 2, 6, 3, 7]
self.assertEqual(pre_order, order_expected)
self.assertEqual(post_order, order_expected)
parent_expected = {0: 1, 1: None, 2: 5, 3: 2, 4: 0, 5: 1, 6: 5, 7: 6}
self.assertEqual(algorithm.parent, parent_expected)
self.assertEqual(algorithm.path(1, 7), [1, 5, 6, 7])
self.assertEqual(algorithm.path(1, 4), [1, 0, 4])
self.assertRaises(ValueError, algorithm.path, 4, 7)
#algorithm.dag.show()
self.assertEqual(algorithm.dag.v(), self.N)
self.assertEqual(algorithm.dag.e(), self.N - 1)
self.assertTrue(algorithm.dag.is_directed())
for edge in algorithm.dag.iteredges():
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(edge.weight, self.G.weight(edge))
def tearDown(self):
pass
V = 8 # number of nodes
E = V*(V-1)/2 # number of edges
G = Graph(n=V, directed=False)
for i in xrange(V):
G.add_node((random.random(), random.random()))
for source in G.iternodes():
for target in G.iternodes():
if source < target:
x0, y0 = source
x1, y1 = target
weight = math.hypot(x1-x0, y1-y0)
G.add_edge(Edge(source, target, weight))
#G.show()
print "Calculate parameters ..."
print "Nodes:", G.v(), V
print "Edges:", G.e(), E
print "Directed:", G.is_directed()
print "Delta:", max(G.degree(node) for node in G.iternodes())
print "Testing BruteForceTSPWithGraph ..."
t1 = timeit.Timer(lambda: BruteForceTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
print "Testing NearestNeighborTSPWithGraph ..."
t1 = timeit.Timer(lambda: NearestNeighborTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
print "Testing RepeatedNearestNeighborTSPWithGraph ..."
t1 = timeit.Timer(lambda: RepeatedNearestNeighborTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
V = 8 # number of nodes
E = V * (V - 1) / 2 # number of edges
G = Graph(n=V, directed=False)
for i in xrange(V):
G.add_node((random.random(), random.random()))
for source in G.iternodes():
for target in G.iternodes():
if source < target:
x0, y0 = source
x1, y1 = target
weight = math.hypot(x1 - x0, y1 - y0)
G.add_edge(Edge(source, target, weight))
#G.show()
print "Calculate parameters ..."
print "Nodes:", G.v(), V
print "Edges:", G.e(), E
print "Directed:", G.is_directed()
print "Delta:", max(G.degree(node) for node in G.iternodes())
print "Testing BruteForceTSPWithGraph ..."
t1 = timeit.Timer(lambda: BruteForceTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
print "Testing NearestNeighborTSPWithGraph ..."
t1 = timeit.Timer(lambda: NearestNeighborTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
print "Testing RepeatedNearestNeighborTSPWithGraph ..."
t1 = timeit.Timer(lambda: RepeatedNearestNeighborTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
class TestBFS(unittest.TestCase):
def setUp(self):
# The graph from Cormen p.607
self.N = 8 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 4, 2), Edge(0, 1, 3), Edge(1, 5, 4), Edge(5, 2, 5),
Edge(5, 6, 6), Edge(2, 6, 7), Edge(2, 3, 8), Edge(6, 3, 9),
Edge(6, 7, 10), Edge(3, 7, 11)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
#self.G.show()
def test_bfs(self):
self.assertEqual(self.G.v(), self.N)
pre_order = []
post_order = []
algorithm = BFSWithQueue(self.G)
algorithm.run(1, pre_action=lambda node: pre_order.append(node),
post_action=lambda node: post_order.append(node))
order_expected = [1, 0, 5, 4, 2, 6, 3, 7]
self.assertEqual(pre_order, order_expected)
self.assertEqual(post_order, order_expected)
distance_expected = {0: 1, 1: 0, 2: 2, 3: 3, 4: 2, 5: 1, 6: 2, 7: 3}
self.assertEqual(algorithm.distance, distance_expected)
parent_expected = {0: 1, 1: None, 2: 5, 3: 2, 4: 0, 5: 1, 6: 5, 7: 6}
self.assertEqual(algorithm.parent, parent_expected)
self.assertEqual(algorithm.path(1, 7), [1, 5, 6, 7])
self.assertEqual(algorithm.path(1, 4), [1, 0, 4])
self.assertRaises(ValueError, algorithm.path, 4, 7)
#algorithm.dag.show()
self.assertEqual(algorithm.dag.v(), self.N)
self.assertEqual(algorithm.dag.e(), self.N-1)
self.assertTrue(algorithm.dag.is_directed())
for edge in algorithm.dag.iteredges():
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(edge.weight, self.G.weight(edge))
def test_simple_bfs(self):
self.assertEqual(self.G.v(), self.N)
pre_order = []
post_order = []
algorithm = SimpleBFS(self.G)
algorithm.run(1, pre_action=lambda node: pre_order.append(node),
post_action=lambda node: post_order.append(node))
order_expected = [1, 0, 5, 4, 2, 6, 3, 7]
self.assertEqual(pre_order, order_expected)
self.assertEqual(post_order, order_expected)
parent_expected = {0: 1, 1: None, 2: 5, 3: 2, 4: 0, 5: 1, 6: 5, 7: 6}
self.assertEqual(algorithm.parent, parent_expected)
self.assertEqual(algorithm.path(1, 7), [1, 5, 6, 7])
self.assertEqual(algorithm.path(1, 4), [1, 0, 4])
self.assertRaises(ValueError, algorithm.path, 4, 7)
#algorithm.dag.show()
self.assertEqual(algorithm.dag.v(), self.N)
self.assertEqual(algorithm.dag.e(), self.N-1)
self.assertTrue(algorithm.dag.is_directed())
for edge in algorithm.dag.iteredges():
self.assertTrue(self.G.has_edge(edge))
self.assertEqual(edge.weight, self.G.weight(edge))
def tearDown(self): pass
class TestGraphUndirected(unittest.TestCase):
def setUp(self):
self.N = 4 # number of nodes
self.G = Graph(self.N)
self.nodes = ["A", "B", "C", "D"]
self.edges = [
Edge("A", "B", 2), Edge("B", "C", 4), Edge("C", "A", 6),
Edge("C", "D", 3), Edge("D", "B", 5)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#self.G.show()
def test_undirected(self):
self.assertFalse(self.G.is_directed())
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 5)
self.G.del_node("B")
self.assertEqual(self.G.v(), 3)
self.assertEqual(self.G.e(), 2)
def test_iteredges(self):
inedges_B = list(self.G.iterinedges("B"))
outedges_B = list(self.G.iteroutedges("B"))
#print inedges_B, outedges_B
self.assertEqual(len(inedges_B), 3)
self.assertEqual(len(outedges_B), 3)
def test_copy(self):
T = self.G.copy()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_transpose(self):
T = self.G.transpose()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(~edge))
def test_complement(self):
T = self.G.complement()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.N*(self.N-1)/2 - self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertFalse(self.G.has_edge(edge))
for edge in self.G.iteredges():
self.assertFalse(T.has_edge(edge))
def test_subgraph(self):
T = self.G.subgraph(["A", "B", "C"])
self.assertEqual(T.v(), 3)
self.assertEqual(T.e(), 3)
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_degree(self):
self.assertEqual(self.G.degree("A"), 2)
self.assertEqual(self.G.degree("B"), 3)
self.assertEqual(self.G.degree("C"), 3)
self.assertEqual(self.G.degree("D"), 2)
def test_add_graph_undirected(self):
T = Graph(self.N)
for node in self.nodes:
T.add_node(node)
T.add_edge(Edge("A", "D", 9))
self.assertEqual(T.v(), self.N)
self.assertEqual(T.e(), 1)
self.G.add_graph(T)
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 6)
def test_load_save(self):
name1 = "undirected_graph.txt"
name2 = "undirected_graph.lgl"
name3 = "undirected_graph.ncol"
self.G.save(name1)
self.G.save_lgl(name2)
self.G.save_ncol(name3)
T = Graph.load(name1)
self.assertEqual(self.G, T)
def tearDown(self): pass
class TestPrimDisconnectedGraph(unittest.TestCase):
def setUp(self):
# The modified graph (unique weights) from Cormen.
self.N = 9 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(1, 7, 11), Edge(1, 2, 12),
Edge(7, 8, 7), Edge(8, 2, 2), Edge(8, 6, 6), Edge(7, 6, 1),
Edge(3, 5, 14), Edge(3, 4, 9), Edge(5, 4, 10)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
def test_prim(self):
self.assertEqual(self.G.v(), self.N)
algorithm = PrimMST(self.G)
algorithm.run()
algorithm.to_tree()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-2) # 2 components
mst_weight_expected = 40
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(8, 2, 2), Edge(7, 6, 1),
Edge(6, 8, 6), Edge(3, 4, 9), Edge(5, 4, 10)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def test_prim_with_edges(self):
self.assertEqual(self.G.v(), self.N)
algorithm = PrimMSTWithEdges(self.G)
algorithm.run()
algorithm.to_tree()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-2) # 2 components
mst_weight_expected = 40
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(8, 2, 2), Edge(7, 6, 1),
Edge(6, 8, 6), Edge(3, 4, 9), Edge(5, 4, 10)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def test_prim_matrix(self):
self.assertEqual(self.G.v(), self.N)
algorithm = PrimMatrixMST(self.G)
algorithm.run()
algorithm.to_tree()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N-2) # 2 components
mst_weight_expected = 40
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 4), Edge(0, 7, 8), Edge(8, 2, 2), Edge(7, 6, 1),
Edge(6, 8, 6), Edge(3, 4, 9), Edge(5, 4, 10)]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def test_prim_connected(self):
self.assertRaises(ValueError, PrimConnectedMST, self.G)
def test_prim_trivial(self):
self.assertRaises(ValueError, PrimTrivialMST, self.G)
def tearDown(self): pass
class TestPrimDisconnectedGraph(unittest.TestCase):
def setUp(self):
# The modified graph (unique weights) from Cormen.
self.N = 9 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1, 4),
Edge(0, 7, 8),
Edge(1, 7, 11),
Edge(1, 2, 12),
Edge(7, 8, 7),
Edge(8, 2, 2),
Edge(8, 6, 6),
Edge(7, 6, 1),
Edge(3, 5, 14),
Edge(3, 4, 9),
Edge(5, 4, 10)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#print self.G
def test_prim(self):
self.assertEqual(self.G.v(), self.N)
algorithm = PrimMST(self.G)
algorithm.run()
algorithm.to_tree()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N - 2) # 2 components
mst_weight_expected = 40
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 4),
Edge(0, 7, 8),
Edge(8, 2, 2),
Edge(7, 6, 1),
Edge(6, 8, 6),
Edge(3, 4, 9),
Edge(5, 4, 10)
]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def test_prim_with_edges(self):
self.assertEqual(self.G.v(), self.N)
algorithm = PrimMSTWithEdges(self.G)
algorithm.run()
algorithm.to_tree()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N - 2) # 2 components
mst_weight_expected = 40
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 4),
Edge(0, 7, 8),
Edge(8, 2, 2),
Edge(7, 6, 1),
Edge(6, 8, 6),
Edge(3, 4, 9),
Edge(5, 4, 10)
]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def test_prim_matrix(self):
self.assertEqual(self.G.v(), self.N)
algorithm = PrimMatrixMST(self.G)
algorithm.run()
algorithm.to_tree()
self.assertEqual(algorithm.mst.v(), self.N)
self.assertEqual(algorithm.mst.e(), self.N - 2) # 2 components
mst_weight_expected = 40
mst_weight = sum(edge.weight for edge in algorithm.mst.iteredges())
self.assertEqual(mst_weight, mst_weight_expected)
mst_edges_expected = [
Edge(0, 1, 4),
Edge(0, 7, 8),
Edge(8, 2, 2),
Edge(7, 6, 1),
Edge(6, 8, 6),
Edge(3, 4, 9),
Edge(5, 4, 10)
]
for edge in mst_edges_expected:
self.assertTrue(algorithm.mst.has_edge(edge))
def test_prim_connected(self):
self.assertRaises(ValueError, PrimConnectedMST, self.G)
def test_prim_trivial(self):
self.assertRaises(ValueError, PrimTrivialMST, self.G)
def tearDown(self):
pass
