def test_Kn_even(self): N = 10 self.assertEqual(N % 2, 0) gf = GraphFactory(Graph) G = gf.make_complete(N) algorithm = CompleteGraphEdgeColoring(G) algorithm.run() for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge], None) for node in G.iternodes(): color_set = set() for edge in G.iteroutedges(node): if edge.source > edge.target: color_set.add(algorithm.color[~edge]) else: color_set.add(algorithm.color[edge]) self.assertEqual(len(color_set), G.degree(node)) #print algorithm.color #algorithm.show_colors() all_colors = set(algorithm.color[edge] for edge in G.iteredges()) self.assertEqual(len(all_colors), N - 1)
#!/usr/bin/python import math import random import timeit from graphtheory.structures.edges import Edge from graphtheory.structures.graphs import Graph from graphtheory.structures.factory import GraphFactory from graphtheory.hamiltonian.tspbf import BruteForceTSPWithGraph from graphtheory.hamiltonian.tspnn import NearestNeighborTSPWithGraph from graphtheory.hamiltonian.tsprnn import RepeatedNearestNeighborTSPWithGraph from graphtheory.hamiltonian.tspse import SortedEdgeTSPWithGraph V = 8 graph_factory = GraphFactory(Graph) G = graph_factory.make_complete(V, False) E = G.e() #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())
class TestWheel(unittest.TestCase): def setUp(self): self.graph_factory = GraphFactory(Graph) def test_k4(self): # complete graph K4 = W4 G = self.graph_factory.make_complete(n=4, directed=False) self.assertTrue(is_wheel(G)) algorithm = WheelGraph(G) algorithm.run() self.assertEqual(algorithm.hub, 0) def test_wheel_true(self): v = 10 G = Graph(v, False) for node in range(v): G.add_node(node) hub = 0 for node in range(1, v): G.add_edge(Edge(hub, node)) G.add_edge(Edge(node, node+1 if node < v-1 else 1)) self.assertTrue(is_wheel(G)) algorithm = WheelGraph(G) algorithm.run() self.assertEqual(algorithm.hub, hub) def test_is_wheel(self): G = self.graph_factory.make_complete(n=3, directed=False) self.assertFalse(is_wheel(G)) self.assertRaises(ValueError, lambda: WheelGraph(G).run()) def test_wheel_false(self): # 0---+ +---5 windmill graph # |\ \ / /| https://en.wikipedia.org/wiki/Windmill_graph # | 1---3---4 | # |/ / \ \| # 2---+ +---6 v = 7 G = Graph(v, False) for node in range(v): G.add_node(node) edges = [ Edge(0, 1), Edge(1, 2), Edge(0, 2), Edge(4, 5), Edge(5, 6), Edge(4, 6), Edge(0, 3), Edge(1, 3), Edge(2, 3), Edge(3, 5), Edge(3, 4), Edge(3, 6)] for edge in edges: G.add_edge(edge) self.assertFalse(is_wheel(G)) self.assertRaises(ValueError, lambda: WheelGraph(G).run()) def test_wheel_false2(self): # 1---2 missing Edge(0, 3) or Edge(1, 3) # |\ /| # | 0 | # |/ | # 4---3 v = 5 G = Graph(v, False) for node in range(v): G.add_node(node) edges = [ Edge(0, 1), Edge(0, 2), Edge(0, 4), Edge(1, 2), Edge(2, 3), Edge(3, 4), Edge(1, 4)] for edge in edges: G.add_edge(edge) G.add_edge(Edge(2, 4)) # bad edge self.assertFalse(is_wheel(G)) self.assertRaises(ValueError, lambda: WheelGraph(G).run()) def tearDown(self): pass
#!/usr/bin/python import math import random import timeit from graphtheory.structures.edges import Edge from graphtheory.structures.graphs import Graph from graphtheory.structures.factory import GraphFactory from graphtheory.hamiltonian.tspbf import BruteForceTSPWithGraph from graphtheory.hamiltonian.tspnn import NearestNeighborTSPWithGraph from graphtheory.hamiltonian.tsprnn import RepeatedNearestNeighborTSPWithGraph from graphtheory.hamiltonian.tspse import SortedEdgeTSPWithGraph V = 8 graph_factory = GraphFactory(Graph) G = graph_factory.make_complete(V, False) E = G.e() #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())
def setUp(self): self.N = 5 # number of nodes graph_factory = GraphFactory(Graph) self.G = graph_factory.make_complete(self.N, True)
class TestNodeColoring(unittest.TestCase): def setUp(self): self.graph_factory = GraphFactory(Graph) def test_k4(self): # graf K4 = W4 G = self.graph_factory.make_complete(n=4, directed=False) # Sa 4 mozliwosci narysowania K4 na plaszczyznie bez przeciec. algorithm = HalinNodeColoring(G, outer=set([1, 2, 3])) algorithm.run() parent = {0: None, 1: 0, 2: 0, 3: 0} self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 4) # 2---3 numeracja wg cyklu Hamiltona # |\ /| wheel graph W_5 # | 0 | # |/ \| # 1---4 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) algorithm = HalinNodeColoring(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) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) # 2-------3 numeracja wg cyklu Hamiltona # |\ /| 3-prism graph # | 1---4 | cubic, planar # |/ \| # 0-------5 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 = HalinNodeColoring(G, outer=set([0, 2, 3, 5])) #algorithm = HalinNodeColoring(G, outer=set([0, 1, 4, 5])) #algorithm = HalinNodeColoring(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) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) # 2-------3 numeracja wg cyklu Hamiltona # |\ / \ heptahedral graph 2 # | 1---4---5 http://mathworld.wolfram.com/HalinGraph.html # |/ \ / # 0-------6 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) algorithm = HalinNodeColoring(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) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) # 0-----7-----6 numeracja wg cyklu Hamiltona # |\ | /| # | 2---3---4 | # |/ \| # 1-----------5 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) algorithm = HalinNodeColoring(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) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) # 2-------3 numeracja wg cyklu Hamiltona # / \ / \ # 1---7---6---4 # \ / \ / # 0-------5 def test_halin8b(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, 7), 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) algorithm = HalinNodeColoring(G, outer=set([0, 1, 2, 3, 4, 5])) algorithm.run() #print "halin8b outer", algorithm.outer parent = {0: 7, 1: 7, 2: 7, 3: 6, 4: 6, 5: 6, 6: None, 7: 6} self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) # 1---2---3 numeracja wg cyklu Hamiltona # |\ \ /| # | 7---6 | # |/ / \| # 0---5---4 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) algorithm = HalinNodeColoring(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) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) # 1-----4---5-----8 numeracja wg cyklu Hamiltona # |\ | | /| graf kubiczny # | 2---3---6---7 | # |/ \| # 0---------------9 def test_halin10j(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, 6), Edge(4, 5), Edge(5, 6), Edge(5, 8), Edge(6, 7), Edge(7, 8), Edge(7, 9), Edge(8, 9) ] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) algorithm = HalinNodeColoring(G, outer=set([0, 1, 4, 5, 8, 9])) algorithm.run() #print "halin10j outer", algorithm.outer parent = { 0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 6, 6: 3, 7: 6, 8: 7, 9: 7 } self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) # 1-----4---------5 numeracja wg cyklu Hamiltona # |\ | /| graf kubiczny # | 2---3---8---7 | # |/ | \| # 0---------9-----6 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) algorithm = HalinNodeColoring(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) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) # --4---5-- # / \ / \ # 0 3 6 numeracja wg cyklu Hamiltona # |\ | /| graf kubiczny # | 1---2---7 | # |/ \| # 9-----------8 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) algorithm = HalinNodeColoring(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) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) # 10---8---7 wachlarz nieparzysty # / \ | / \ # / 9 \ # / | \ # 0---2---3---4---6 # \ / \ / # 1-----------5 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 = HalinNodeColoring(G, outer=set([0, 1, 5, 6, 7, 8, 10])) algorithm.run() #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) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) # -----------11 # / / \ # 0-------1--10---9 numeracja wg cyklu Hamiltona # | | | cubic Frucht graph # 4---3---2---7---8 # \ / \ / # 5-----------6 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 = HalinNodeColoring(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) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) # 0---------15--------14 cubic # / \ | / \ # 2---1---6---7---8---13--12 # \ / \ / # 3---5 9---11 # \ / \ / # 4---------------10 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 = HalinNodeColoring(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) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3) def tearDown(self): pass
class TestGraphFactory(unittest.TestCase): def setUp(self): self.N = 10 # number of nodes self.graph_factory = GraphFactory(Graph) def test_complete(self): G = self.graph_factory.make_complete(n=self.N, directed=False) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), self.N) self.assertEqual(G.e(), self.N * (self.N-1) // 2) aset = set(edge.weight for edge in G.iteredges()) self.assertEqual(G.e(), len(aset)) def test_complete_directed(self): G = self.graph_factory.make_complete(n=self.N, directed=True) self.assertTrue(G.is_directed()) self.assertEqual(G.v(), self.N) self.assertEqual(G.e(), self.N * (self.N-1) // 2) aset = set(edge.weight for edge in G.iteredges()) self.assertEqual(G.e(), len(aset)) def test_cyclic(self): G = self.graph_factory.make_cyclic(n=self.N, directed=False) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), self.N) self.assertEqual(G.e(), self.N) aset = set(edge.weight for edge in G.iteredges()) self.assertEqual(G.e(), len(aset)) self.assertRaises(ValueError, self.graph_factory.make_cyclic, 1) self.assertRaises(ValueError, self.graph_factory.make_cyclic, 2) def test_cyclic_directed(self): G = self.graph_factory.make_cyclic(n=self.N, directed=True) self.assertTrue(G.is_directed()) self.assertEqual(G.v(), self.N) self.assertEqual(G.e(), self.N) aset = set(edge.weight for edge in G.iteredges()) self.assertEqual(G.e(), len(aset)) self.assertRaises(ValueError, self.graph_factory.make_cyclic, 1) self.assertRaises(ValueError, self.graph_factory.make_cyclic, 2) def test_sparse(self): m_edges = 2 * self.N G = self.graph_factory.make_sparse(n=self.N, directed=False, m=m_edges) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), self.N) self.assertEqual(G.e(), m_edges) aset = set(edge.weight for edge in G.iteredges()) self.assertEqual(G.e(), len(aset)) def test_tree(self): G = self.graph_factory.make_tree(n=self.N) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), self.N) self.assertEqual(G.e(), self.N-1) aset = set(edge.weight for edge in G.iteredges()) self.assertEqual(G.e(), len(aset)) def test_connected(self): m_edges = 2 * self.N G = self.graph_factory.make_connected(n=self.N, m=m_edges) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), self.N) self.assertEqual(G.e(), m_edges) aset = set(edge.weight for edge in G.iteredges()) self.assertEqual(G.e(), len(aset)) def test_random(self): G = self.graph_factory.make_random( n=self.N, directed=False, edge_probability=0.1) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), self.N) aset = set(edge.weight for edge in G.iteredges()) self.assertEqual(G.e(), len(aset)) def test_random_directed(self): G = self.graph_factory.make_random( n=self.N, directed=True, edge_probability=0.1) self.assertTrue(G.is_directed()) self.assertEqual(G.v(), self.N) aset = set(edge.weight for edge in G.iteredges()) self.assertEqual(G.e(), len(aset)) def test_bipartite(self): N1, N2 = 5, 6 G = self.graph_factory.make_bipartite(N1, N2, directed=False, edge_probability=0.1) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), N1 + N2) aset = set(edge.weight for edge in G.iteredges()) self.assertEqual(G.e(), len(aset)) # We use the fact that nodes are in two sets # [0 ... N1-1], [N1 ... N1+N2-1]. for edge in G.iteredges(): self.assertEqual(edge.source < N1, edge.target >= N1) def test_grid(self): size = 4 G = self.graph_factory.make_grid(size) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), size * size) self.assertEqual(G.e(), 2 * size * (size-1)) self.assertRaises(ValueError, self.graph_factory.make_grid, 2) def test_grid_periodic(self): size = 4 G = self.graph_factory.make_grid_periodic(size) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), size * size) self.assertEqual(G.e(), 2 * size * size) self.assertRaises( ValueError, self.graph_factory.make_grid_periodic, 2) def test_triangle(self): size = 4 G = self.graph_factory.make_triangle(size) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), size * size) self.assertEqual(G.e(), 3 * size * size -4 * size + 1) self.assertRaises(ValueError, self.graph_factory.make_triangle, 2) def test_triangle_periodic(self): size = 4 G = self.graph_factory.make_triangle_periodic(size) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), size * size) self.assertEqual(G.e(), 3 * size * size) self.assertRaises( ValueError, self.graph_factory.make_triangle_periodic, 2) def test_ladder(self): size = 4 G = self.graph_factory.make_ladder(size) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), 2 * size) self.assertEqual(G.e(), 3 * size -2) self.assertRaises(ValueError, self.graph_factory.make_ladder, 2) def test_prism(self): size = 4 G = self.graph_factory.make_prism(size) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), 2 * size) self.assertEqual(G.e(), 3 * size) self.assertRaises( ValueError, self.graph_factory.make_prism, 2) def test_antiprism(self): size = 4 G = self.graph_factory.make_antiprism(size) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), 2 * size) self.assertEqual(G.e(), 4 * size) self.assertRaises( ValueError, self.graph_factory.make_antiprism, 2) def test_flow_network(self): G = self.graph_factory.make_flow_network(self.N) self.assertTrue(G.is_directed()) self.assertEqual(G.v(), self.N) self.assertTrue(G.e() > self.N - 2) def test_necklace(self): G = self.graph_factory.make_necklace(n=self.N, directed=False) self.assertEqual(G.v(), self.N) self.assertEqual(G.e(), 3 * self.N // 2) self.assertRaises(ValueError, self.graph_factory.make_necklace, 1) self.assertRaises(ValueError, self.graph_factory.make_necklace, 2) self.assertRaises(ValueError, self.graph_factory.make_necklace, 3) self.assertRaises(ValueError, self.graph_factory.make_necklace, 5) #G = self.graph_factory.make_necklace(n=6, directed=False) #G.show() def test_wheel(self): G = self.graph_factory.make_wheel(n=self.N, directed=False) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), self.N) self.assertEqual(G.e(), 2 * self.N - 2) self.assertTrue(is_wheel(G)) self.assertRaises(ValueError, self.graph_factory.make_wheel, 1) self.assertRaises(ValueError, self.graph_factory.make_wheel, 2) self.assertRaises(ValueError, self.graph_factory.make_wheel, 3) def test_fake_wheel(self): G = self.graph_factory.make_fake_wheel(n=self.N, directed=False) self.assertFalse(G.is_directed()) self.assertEqual(G.v(), self.N) self.assertEqual(G.e(), 2 * self.N - 2) self.assertFalse(is_wheel(G)) self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 1) self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 2) self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 3) self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 4) self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 5) self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 6) def tearDown(self): pass
class TestHalinGraphTreeDecomposition(unittest.TestCase): def setUp(self): self.graph_factory = GraphFactory(Graph) def test_k4(self): # graf K4 = W4 G = self.graph_factory.make_complete(n=4, directed=False) # Sa 4 mozliwosci narysowania K4 na plaszczyznie bez przeciec. #print "k4 ..." algorithm = HalinGraphTreeDecomposition(G, outer=set([1, 2, 3])) algorithm.run() parent = {0: None, 1: 0, 2: 0, 3: 0} self.assertEqual(algorithm.parent, parent) order = [1, 2, 3, 0] self.assertEqual(algorithm.order, order) self.assertEqual(len(algorithm.cliques), G.v()-3) # 2---3 numeracja wg cyklu Hamiltona # |\ /| wheel graph W_5 # | 0 | # |/ \| # 1---4 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) # 2-------3 numeracja wg cyklu Hamiltona # |\ /| 3-prism graph # | 1---4 | cubic, planar # |/ \| # 0-------5 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) # 2-------3 numeracja wg cyklu Hamiltona # |\ / \ heptahedral graph 2 # | 1---4---5 http://mathworld.wolfram.com/HalinGraph.html # |/ \ / # 0-------6 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) # 0-----7-----6 numeracja wg cyklu Hamiltona # |\ | /| # | 2---3---4 | # |/ \| # 1-----------5 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) # 2-------3 numeracja wg cyklu Hamiltona # / \ / \ # 1---7---6---4 # \ / \ / # 0-------5 def test_halin8b(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, 7), 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 "halin8b ..." algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 2, 3, 4, 5])) algorithm.run() #print "halin8b outer", algorithm.outer parent = {0: 7, 1: 7, 2: 7, 3: 6, 4: 6, 5: 6, 6: None, 7: 6} self.assertEqual(algorithm.parent, parent) #order = [1, 7, 0, 2, 3, 4, 5, 6] order = [4, 6, 0, 1, 2, 3, 5, 7] self.assertEqual(algorithm.order, order) self.assertEqual(len(algorithm.cliques), G.v()-3) # 1---2---3 numeracja wg cyklu Hamiltona # |\ \ /| # | 7---6 | # |/ / \| # 0---5---4 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) # 1-----4---5-----8 numeracja wg cyklu Hamiltona # |\ | | /| graf kubiczny # | 2---3---6---7 | # |/ \| # 0---------------9 def test_halin10j(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, 6), Edge(4, 5), Edge(5, 6), Edge(5, 8), Edge(6, 7), Edge(7, 8), Edge(7, 9), Edge(8, 9)] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) #print "halin10j ..." algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 4, 5, 8, 9])) algorithm.run() #print "halin10j outer", algorithm.outer parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 6, 6: 3, 7: 6, 8: 7, 9: 7} self.assertEqual(algorithm.parent, parent) order = [7, 2, 8, 6, 0, 1, 4, 5, 9, 3] self.assertEqual(algorithm.order, order) self.assertEqual(len(algorithm.cliques), G.v()-3) # 1-----4---------5 numeracja wg cyklu Hamiltona # |\ | /| graf kubiczny # | 2---3---8---7 | # |/ | \| # 0---------9-----6 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) # --4---5-- # / \ / \ # 0 3 6 numeracja wg cyklu Hamiltona # |\ | /| graf kubiczny # | 1---2---7 | # |/ \| # 9-----------8 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) # 10---8---7 wachlarz nieparzysty # / \ | / \ # / 9 \ # / | \ # 0---2---3---4---6 # \ / \ / # 1-----------5 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) # -----------11 # / / \ # 0-------1--10---9 numeracja wg cyklu Hamiltona # | | | cubic Frucht graph # 4---3---2---7---8 # \ / \ / # 5-----------6 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) # 0---------15--------14 cubic # / \ | / \ # 2---1---6---7---8---13--12 # \ / \ / # 3---5 9---11 # \ / \ / # 4---------------10 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 tearDown(self): pass
class TestHalinGraph(unittest.TestCase): def setUp(self): self.graph_factory = GraphFactory(Graph) def test_k4(self): # graf K4 = W4 G = self.graph_factory.make_complete(n=4, directed=False) # Sa 4 mozliwosci narysowania K4 na plaszczyznie bez przeciec. algorithm = HalinGraph(G) algorithm.run() self.assertTrue(algorithm.is_outer_k4()) # 2---3 numeracja wg cyklu Hamiltona # |\ /| wheel graph W_5 # | 0 | # |/ \| # 1---4 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) algorithm = HalinGraph(G) algorithm.run() #print "wheel5 outer", algorithm.outer self.assertEqual(algorithm.outer, set([1, 2, 3, 4])) self.assertTrue(algorithm.is_outer_k4()) # 2-------3 numeracja wg cyklu Hamiltona # |\ /| 3-prism graph # | 1---4 | cubic, planar # |/ \| # 0-------5 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) algorithm = HalinGraph(G) algorithm.run() #print "3prism outer", algorithm.outer #self.assertEqual(algorithm.outer, set([0, 2, 3, 5])) self.assertEqual(algorithm.outer, set([0, 1, 4, 5])) #self.assertEqual(algorithm.outer, set([1, 2, 3, 4])) self.assertTrue(algorithm.is_outer_k4()) # 4-------5 4-prism graph # |\ /| non-Halin graph # | 0---1 | Hamiltonian [0, 1, 2, 3, 7, 6, 5, 4] # | | | | cubic, planar # | 3---2 | # |/ \| # 7-------6 def test_4prism(self): N = 8 G = Graph(N, False) edges = [Edge(0, 1), Edge(1, 2), Edge(2, 3), Edge(3, 0), Edge(4, 5), Edge(5, 6), Edge(6, 7), Edge(7, 4), Edge(0, 4), Edge(1, 5), Edge(2, 6), Edge(3, 7)] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) #G.show() algorithm = HalinGraph(G) self.assertRaises(ValueError, algorithm.run) # 2-------3 numeracja wg cyklu Hamiltona # |\ / \ heptahedral graph 2 # | 1---4---5 http://mathworld.wolfram.com/HalinGraph.html # |/ \ / # 0-------6 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) algorithm = HalinGraph(G) algorithm.run() #print "halin7 outer", algorithm.outer self.assertEqual(algorithm.outer, set([0, 2, 3, 5, 6])) self.assertTrue(algorithm.is_outer_k4()) # 0-----7-----6 numeracja wg cyklu Hamiltona # |\ | /| # | 2---3---4 | # |/ \| # 1-----------5 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) algorithm = HalinGraph(G) algorithm.run() #print "halin8a outer", algorithm.outer # Sa dwie mozliwosci narysowania tego grafu. self.assertEqual(algorithm.outer, set([0, 1, 5, 6, 7])) #self.assertEqual(algorithm.outer, set([1, 2, 3, 4, 5])) self.assertTrue(algorithm.is_outer_k4()) # 2-------3 numeracja wg cyklu Hamiltona # / \ / \ # 1---7---6---4 # \ / \ / # 0-------5 def test_halin8b(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, 7), 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) algorithm = HalinGraph(G) algorithm.run() #print "halin8b outer", algorithm.outer self.assertEqual(algorithm.outer, set([0, 1, 2, 3, 4, 5])) self.assertTrue(algorithm.is_outer_k4()) # 1---2---3 numeracja wg cyklu Hamiltona # |\ \ /| # | 7---6 | # |/ / \| # 0---5---4 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) algorithm = HalinGraph(G) algorithm.run() #print "halin8c outer", algorithm.outer self.assertEqual(algorithm.outer, set([0, 1, 2, 3, 4, 5])) self.assertTrue(algorithm.is_outer_k4()) # 1-----4---5-----8 numeracja wg cyklu Hamiltona # |\ | | /| graf kubiczny # | 2---3---6---7 | # |/ \| # 0---------------9 def test_halin10j(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, 6), Edge(4, 5), Edge(5, 6), Edge(5, 8), Edge(6, 7), Edge(7, 8), Edge(7, 9), Edge(8, 9)] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) algorithm = HalinGraph(G) algorithm.run() #print "halin10j outer", algorithm.outer self.assertEqual(algorithm.outer, set([0, 1, 4, 5, 8, 9])) self.assertTrue(algorithm.is_outer_k4()) # 1-----4---------5 numeracja wg cyklu Hamiltona # |\ | /| graf kubiczny # | 2---3---8---7 | # |/ | \| # 0---------9-----6 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) algorithm = HalinGraph(G) algorithm.run() #print "halin10k outer", algorithm.outer self.assertEqual(algorithm.outer, set([0, 1, 4, 5, 6, 9])) self.assertTrue(algorithm.is_outer_k4()) # --4---5-- # / \ / \ # 0 3 6 numeracja wg cyklu Hamiltona # |\ | /| graf kubiczny # | 1---2---7 | # |/ \| # 9-----------8 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) algorithm = HalinGraph(G) algorithm.run() #print "halin10l outer", algorithm.outer self.assertEqual(algorithm.outer, set([0, 4, 5, 6, 8, 9])) self.assertTrue(algorithm.is_outer_k4()) # -----------11 # / / \ # 0-------1--10---9 numeracja wg cyklu Hamiltona # | | | cubic Frucht graph # 4---3---2---7---8 # \ / \ / # 5-----------6 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) algorithm = HalinGraph(G) algorithm.run() #print "frucht12 outer", algorithm.outer self.assertEqual(algorithm.outer, set([0, 4, 5, 6, 8, 9, 11])) self.assertTrue(algorithm.is_outer_k4()) def tearDown(self): pass
#!/usr/bin/python import unittest from graphtheory.structures.edges import Edge from graphtheory.structures.graphs import Graph from graphtheory.structures.factory import GraphFactory from graphtheory.seriesparallel.sptools import make_random_spgraph from graphtheory.seriesparallel.sptools import find_peo_spgraph1 from graphtheory.seriesparallel.sptools import find_peo_spgraph2 print("Testing random sp-graph ...") G = make_random_spgraph(15) #G.show() print("peo1 {}".format(find_peo_spgraph1(G))) print("peo2 {}".format(find_peo_spgraph2(G))) print("Testing complete graph ...") gf = GraphFactory(Graph) G = gf.make_complete(4) #G.show() #print ( "peo1 {}".format(find_peo_spgraph1(G)) ) # ValueError #print ( "peo2 {}".format(find_peo_spgraph2(G)) ) # ValueError print("Testing cyclic graph ...") G = gf.make_cyclic(10) #G.show() print("peo1 {}".format(find_peo_spgraph1(G))) print("peo2 {}".format(find_peo_spgraph2(G))) # EOF