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)
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)
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)
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 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)
class TestNodeColoring(unittest.TestCase):
def setUp(self):
self.N = 6
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1), Edge(0, 3), Edge(1, 3), Edge(1, 4), Edge(1, 2),
Edge(2, 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)
#self.G.show()
def test_us_node_coloring(self):
algorithm = UnorderedSequentialNodeColoring(self.G)
algorithm.run()
for node in self.G.iternodes():
self.assertNotEqual(algorithm.color[node], None)
for edge in self.G.iteredges():
self.assertNotEqual(algorithm.color[edge.source],
algorithm.color[edge.target])
#print algorithm.color
all_colors = set(algorithm.color[node] for node in self.G.iternodes())
self.assertEqual(len(all_colors), 4)
def test_exceptions(self):
self.assertRaises(ValueError, UnorderedSequentialNodeColoring,
Graph(5, directed=True))
def tearDown(self): pass
class TestNodeColoring(unittest.TestCase):
def setUp(self):
self.N = 6
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1),
Edge(0, 3),
Edge(1, 3),
Edge(1, 4),
Edge(1, 2),
Edge(2, 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)
#self.G.show()
def test_brooks_node_coloring(self):
algorithm = BrooksNodeColoring(self.G)
algorithm.run()
for node in self.G.iternodes():
self.assertNotEqual(algorithm.color[node], None)
for edge in self.G.iteredges():
self.assertNotEqual(algorithm.color[edge.source],
algorithm.color[edge.target])
#print algorithm.color
all_colors = set(algorithm.color[node] for node in self.G.iternodes())
self.assertEqual(len(all_colors), 4)
def test_brooks_node_coloring_regular(self):
# Buduje graf 4-regularny planarny z Delta=4.
# Graf jest 3-connected, dlatego algorytm dziala.
self.G.add_edge(Edge(0, 2))
self.G.add_edge(Edge(3, 5))
self.G.add_edge(Edge(0, 5))
algorithm = BrooksNodeColoring(self.G)
algorithm.run()
for node in self.G.iternodes():
self.assertNotEqual(algorithm.color[node], None)
for edge in self.G.iteredges():
self.assertNotEqual(algorithm.color[edge.source],
algorithm.color[edge.target])
#print algorithm.color
all_colors = set(algorithm.color[node] for node in self.G.iternodes())
self.assertEqual(len(all_colors), 3) # best
def test_exceptions(self):
self.assertRaises(ValueError, BrooksNodeColoring,
Graph(5, directed=True))
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 = 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)
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)
def make_halin_outer(n=4):
"""Create a random weighted Halin graph with the set of outer nodes."""
if n < 4:
raise ValueError("number of nodes must be greater than 3")
graph = Graph(n)
weights = list(range(1, 1 + 2 * n - 2))
random.shuffle(weights)
for node in xrange(n):
graph.add_node(node)
# Teraz trzeba dodawac krawedzie, ale nie moze zostac wierzcholek
# stopnia 2. Startuje od gwiazdy.
graph.add_edge(Edge(1, 0, weights.pop()))
graph.add_edge(Edge(2, 0, weights.pop()))
graph.add_edge(Edge(3, 0, weights.pop()))
nodes = set([0, 1, 2, 3])
node = 4
while node < n:
parent = random.sample(nodes, 1)[0]
if graph.degree(parent) == 1: # leaf, we must add two edges
if node + 1 == n:
continue
nodes.add(node)
graph.add_edge(Edge(parent, node, weights.pop()))
node += 1
nodes.add(node)
graph.add_edge(Edge(parent, node, weights.pop()))
node += 1
else: # degree > 2
nodes.add(node)
graph.add_edge(Edge(parent, node, weights.pop()))
node += 1
# Method 1. Finding root without TreeCenter.
for node in graph.iternodes():
if graph.degree(node) > 1: # always present
root = node
break
# Method 2. Finding root with TreeCenter.
# TreeCenter reduces floating point errors for points.
#algorithm = TreeCenter(graph)
#algorithm.run()
#root = algorithm.tree_center[0]
# Wyznaczam slownik z punktami.
algorithm = TreePlotRadiusAngle(graph)
algorithm.run(root)
L = list() # for leafs
for node in algorithm.point_dict:
if graph.degree(node) == 1: # leafs
L.append(node)
# Sortowanie lisci ze wzgledu na kat.
L.sort(key=lambda node: algorithm.point_dict[node][1])
n_leafs = len(L)
for i in range(n_leafs):
graph.add_edge(Edge(L[i], L[(i + 1) % n_leafs], weights.pop()))
return graph, set(L)
def make_halin_outer(n=4):
"""Create a random weighted Halin graph with the set of outer nodes."""
if n < 4:
raise ValueError("number of nodes must be greater than 3")
graph = Graph(n)
weights = list(range(1, 1 + 2 * n - 2))
random.shuffle(weights)
for node in xrange(n):
graph.add_node(node)
# Teraz trzeba dodawac krawedzie, ale nie moze zostac wierzcholek
# stopnia 2. Startuje od gwiazdy.
graph.add_edge(Edge(1, 0, weights.pop()))
graph.add_edge(Edge(2, 0, weights.pop()))
graph.add_edge(Edge(3, 0, weights.pop()))
nodes = set([0, 1, 2, 3])
node = 4
while node < n:
parent = random.sample(nodes, 1)[0]
if graph.degree(parent) == 1: # leaf, we must add two edges
if node + 1 == n:
continue
nodes.add(node)
graph.add_edge(Edge(parent, node, weights.pop()))
node += 1
nodes.add(node)
graph.add_edge(Edge(parent, node, weights.pop()))
node += 1
else: # degree > 2
nodes.add(node)
graph.add_edge(Edge(parent, node, weights.pop()))
node += 1
# Method 1. Finding root without TreeCenter.
for node in graph.iternodes():
if graph.degree(node) > 1: # always present
root = node
break
# Method 2. Finding root with TreeCenter.
# TreeCenter reduces floating point errors for points.
#algorithm = TreeCenter(graph)
#algorithm.run()
#root = algorithm.tree_center[0]
# Wyznaczam slownik z punktami.
algorithm = TreePlotRadiusAngle(graph)
algorithm.run(root)
L = list() # for leafs
for node in algorithm.point_dict:
if graph.degree(node) == 1: # leafs
L.append(node)
# Sortowanie lisci ze wzgledu na kat.
L.sort(key=lambda node: algorithm.point_dict[node][1])
n_leafs = len(L)
for i in range(n_leafs):
graph.add_edge(Edge(L[i], L[(i + 1) % n_leafs], weights.pop()))
return graph, set(L)
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)
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)
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)
class TestNodeColoring2(unittest.TestCase):
def setUp(self):
self.N = 8
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1),
Edge(0, 2),
Edge(0, 7),
Edge(1, 2),
Edge(1, 3),
Edge(2, 3),
Edge(3, 4),
Edge(4, 5),
Edge(4, 6),
Edge(5, 6),
Edge(5, 7),
Edge(6, 7)
]
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_brooks_node_coloring_regular(self):
algorithm = BrooksNodeColoring(self.G)
algorithm.run()
for node in self.G.iternodes():
self.assertNotEqual(algorithm.color[node], None)
for edge in self.G.iteredges():
self.assertNotEqual(algorithm.color[edge.source],
algorithm.color[edge.target])
#print algorithm.color
all_colors = set(algorithm.color[node] for node in self.G.iternodes())
self.assertEqual(len(all_colors), 3)
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)
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)
class TestEdgeColoring(unittest.TestCase):
def setUp(self):
self.N = 6
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1),
Edge(0, 3),
Edge(1, 3),
Edge(1, 4),
Edge(1, 2),
Edge(2, 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)
#self.G.show()
def test_rs_edge_coloring(self):
algorithm = RandomSequentialEdgeColoring(self.G)
algorithm.run()
for edge in self.G.iteredges():
self.assertNotEqual(algorithm.color[edge], None)
for node in self.G.iternodes():
color_set = set()
for edge in self.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), self.G.degree(node))
#print ( algorithm.color )
#algorithm.show_colors()
all_colors = set(algorithm.color[edge] for edge in self.G.iteredges())
self.assertTrue(len(all_colors) in set([4, 5, 6, 7]))
def test_exceptions(self):
self.assertRaises(ValueError, RandomSequentialEdgeColoring,
Graph(5, directed=True))
def tearDown(self):
pass
class TestEdgeColoring(unittest.TestCase):
def setUp(self):
self.N = 6
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1), Edge(0, 3), Edge(1, 3), Edge(1, 4), Edge(1, 2),
Edge(2, 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)
#self.G.show()
def test_ntl_edge_coloring(self):
algorithm = NTLEdgeColoring(self.G)
algorithm.run()
for edge in self.G.iteredges():
self.assertNotEqual(algorithm.color[edge], None)
for node in self.G.iternodes():
color_set = set()
for edge in self.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), self.G.degree(node))
#print algorithm.color
all_colors = set(algorithm.color[edge] for edge in self.G.iteredges())
self.assertEqual(len(all_colors), 5)
def test_exceptions(self):
self.assertRaises(ValueError, NTLEdgeColoring,
Graph(5, directed=True))
def tearDown(self): pass
from graphtheory.structures.graphs import Graph
from graphtheory.hamiltonian.tspbf import BruteForceTSPWithGraph
from graphtheory.hamiltonian.tspnn import NearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tsprnn import RepeatedNearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tspse import SortedEdgeTSPWithGraph
from graphtheory.hamiltonian.tspmst import PrimTSPWithGraph
# Euclidean TSP.
# Nodes are points in a unit square.
# Weights are distances.
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 ..."
from graphtheory.structures.graphs import Graph
from graphtheory.hamiltonian.tspbf import BruteForceTSPWithGraph
from graphtheory.hamiltonian.tspnn import NearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tsprnn import RepeatedNearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tspse import SortedEdgeTSPWithGraph
from graphtheory.hamiltonian.tspmst import PrimTSPWithGraph
# Euclidean TSP.
# Nodes are points in a unit square.
# Weights are distances.
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 ...")
from graphtheory.structures.graphs import Graph
from graphtheory.hamiltonian.tspbf import BruteForceTSPWithGraph
from graphtheory.hamiltonian.tspnn import NearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tsprnn import RepeatedNearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tspse import SortedEdgeTSPWithGraph
from graphtheory.hamiltonian.tspmst import PrimTSPWithGraph
# Euclidean TSP.
# Nodes are points in a unit square.
# Weights are distances.
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 ..." )
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)
from graphtheory.structures.graphs import Graph
from graphtheory.hamiltonian.tspbf import BruteForceTSPWithGraph
from graphtheory.hamiltonian.tspnn import NearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tsprnn import RepeatedNearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tspse import SortedEdgeTSPWithGraph
from graphtheory.hamiltonian.tspmst import PrimTSPWithGraph
# Euclidean TSP.
# Nodes are points in a unit square.
# Weights are distances.
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 ..."
