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
def setUp(self):
self.N = 5 # number of nodes
graph_factory = GraphFactory(Graph)
self.G = graph_factory.make_complete(self.N, True)
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
