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)
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
class TestGraphUndirected(unittest.TestCase):
def setUp(self):
self.N = 4 # number of nodes
self.G = Graph(self.N)
self.nodes = ["A", "B", "C", "D"]
self.edges = [
Edge("A", "B", 2),
Edge("B", "C", 4),
Edge("C", "A", 6),
Edge("C", "D", 3),
Edge("D", "B", 5)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#self.G.show()
def test_undirected(self):
self.assertFalse(self.G.is_directed())
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 5)
self.G.del_node("B")
self.assertEqual(self.G.v(), 3)
self.assertEqual(self.G.e(), 2)
def test_iteredges(self):
inedges_B = list(self.G.iterinedges("B"))
outedges_B = list(self.G.iteroutedges("B"))
#print inedges_B, outedges_B
self.assertEqual(len(inedges_B), 3)
self.assertEqual(len(outedges_B), 3)
def test_iteredges_connected(self):
start_edge = next(self.G.iteredges())
A = set([start_edge.source, start_edge.target])
for edge in self.G.iteredges_connected(start_edge):
B = set([edge.source, edge.target])
self.assertTrue(len(A & B) > 0)
A.update(B)
#print ( A )
def test_copy(self):
T = self.G.copy()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_transpose(self):
T = self.G.transpose()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(~edge))
def test_complement(self):
T = self.G.complement()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.N * (self.N - 1) / 2 - self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertFalse(self.G.has_edge(edge))
for edge in self.G.iteredges():
self.assertFalse(T.has_edge(edge))
def test_subgraph(self):
T = self.G.subgraph(["A", "B", "C"])
self.assertEqual(T.v(), 3)
self.assertEqual(T.e(), 3)
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_degree(self):
self.assertEqual(self.G.degree("A"), 2)
self.assertEqual(self.G.degree("B"), 3)
self.assertEqual(self.G.degree("C"), 3)
self.assertEqual(self.G.degree("D"), 2)
def test_add_graph_undirected(self):
T = Graph(self.N)
for node in self.nodes:
T.add_node(node)
T.add_edge(Edge("A", "D", 9))
self.assertEqual(T.v(), self.N)
self.assertEqual(T.e(), 1)
self.G.add_graph(T)
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 6)
def test_load_save(self):
name1 = "undirected_graph.txt"
name2 = "undirected_graph.lgl"
name3 = "undirected_graph.ncol"
self.G.save(name1)
self.G.save_lgl(name2)
self.G.save_ncol(name3)
T = Graph.load(name1)
self.assertEqual(self.G, T)
def tearDown(self):
pass
class TestGraphUndirected(unittest.TestCase):
def setUp(self):
self.N = 4 # number of nodes
self.G = Graph(self.N)
self.nodes = ["A", "B", "C", "D"]
self.edges = [
Edge("A", "B", 2), Edge("B", "C", 4), Edge("C", "A", 6),
Edge("C", "D", 3), Edge("D", "B", 5)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#self.G.show()
def test_undirected(self):
self.assertFalse(self.G.is_directed())
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 5)
self.G.del_node("B")
self.assertEqual(self.G.v(), 3)
self.assertEqual(self.G.e(), 2)
def test_iteredges(self):
inedges_B = list(self.G.iterinedges("B"))
outedges_B = list(self.G.iteroutedges("B"))
#print inedges_B, outedges_B
self.assertEqual(len(inedges_B), 3)
self.assertEqual(len(outedges_B), 3)
def test_copy(self):
T = self.G.copy()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_transpose(self):
T = self.G.transpose()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(~edge))
def test_complement(self):
T = self.G.complement()
self.assertEqual(T.v(), self.G.v())
self.assertEqual(T.e(), self.N*(self.N-1)/2 - self.G.e())
for node in T.iternodes():
self.assertTrue(self.G.has_node(node))
for edge in T.iteredges():
self.assertFalse(self.G.has_edge(edge))
for edge in self.G.iteredges():
self.assertFalse(T.has_edge(edge))
def test_subgraph(self):
T = self.G.subgraph(["A", "B", "C"])
self.assertEqual(T.v(), 3)
self.assertEqual(T.e(), 3)
for edge in T.iteredges():
self.assertTrue(self.G.has_edge(edge))
def test_degree(self):
self.assertEqual(self.G.degree("A"), 2)
self.assertEqual(self.G.degree("B"), 3)
self.assertEqual(self.G.degree("C"), 3)
self.assertEqual(self.G.degree("D"), 2)
def test_add_graph_undirected(self):
T = Graph(self.N)
for node in self.nodes:
T.add_node(node)
T.add_edge(Edge("A", "D", 9))
self.assertEqual(T.v(), self.N)
self.assertEqual(T.e(), 1)
self.G.add_graph(T)
self.assertEqual(self.G.v(), self.N)
self.assertEqual(self.G.e(), 6)
def test_load_save(self):
name1 = "undirected_graph.txt"
name2 = "undirected_graph.lgl"
name3 = "undirected_graph.ncol"
self.G.save(name1)
self.G.save_lgl(name2)
self.G.save_ncol(name3)
T = Graph.load(name1)
self.assertEqual(self.G, T)
def tearDown(self): pass
for i in range(V):
G.add_node((random.random(), random.random()))
for source in G.iternodes():
for target in G.iternodes():
if source < target:
x0, y0 = source
x1, y1 = target
weight = math.hypot(x1 - x0, y1 - y0)
G.add_edge(Edge(source, target, weight))
#G.show()
print("Calculate parameters ...")
print("Nodes: {} {}".format(G.v(), V))
print("Edges: {} {}".format(G.e(), E))
print("Directed: {}".format(G.is_directed()))
print("Delta: {}".format(max(G.degree(node) for node in G.iternodes())))
print("Testing BruteForceTSPWithGraph ...")
t1 = timeit.Timer(lambda: BruteForceTSPWithGraph(G).run())
print("{} {} {}".format(V, E, t1.timeit(1))) # single run
print("Testing NearestNeighborTSPWithGraph ...")
t1 = timeit.Timer(lambda: NearestNeighborTSPWithGraph(G).run())
print("{} {} {}".format(V, E, t1.timeit(1))) # single run
print("Testing RepeatedNearestNeighborTSPWithGraph ...")
t1 = timeit.Timer(lambda: RepeatedNearestNeighborTSPWithGraph(G).run())
print("{} {} {}".format(V, E, t1.timeit(1))) # single run
print("Testing SortedEdgeTSPWithGraph ...")
t1 = timeit.Timer(lambda: SortedEdgeTSPWithGraph(G).run())
for i in xrange(V):
G.add_node((random.random(), random.random()))
for source in G.iternodes():
for target in G.iternodes():
if source < target:
x0, y0 = source
x1, y1 = target
weight = math.hypot(x1-x0, y1-y0)
G.add_edge(Edge(source, target, weight))
#G.show()
print "Calculate parameters ..."
print "Nodes:", G.v(), V
print "Edges:", G.e(), E
print "Directed:", G.is_directed()
print "Delta:", max(G.degree(node) for node in G.iternodes())
print "Testing BruteForceTSPWithGraph ..."
t1 = timeit.Timer(lambda: BruteForceTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
print "Testing NearestNeighborTSPWithGraph ..."
t1 = timeit.Timer(lambda: NearestNeighborTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
print "Testing RepeatedNearestNeighborTSPWithGraph ..."
t1 = timeit.Timer(lambda: RepeatedNearestNeighborTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
print "Testing SortedEdgeTSPWithGraph ..."
t1 = timeit.Timer(lambda: SortedEdgeTSPWithGraph(G).run())
for i in range(V):
G.add_node((random.random(), random.random()))
for source in G.iternodes():
for target in G.iternodes():
if source < target:
x0, y0 = source
x1, y1 = target
weight = math.hypot(x1-x0, y1-y0)
G.add_edge(Edge(source, target, weight))
#G.show()
print ( "Calculate parameters ..." )
print ( "Nodes: {} {}".format( G.v(), V ))
print ( "Edges: {} {}".format( G.e(), E ))
print ( "Directed: {}".format( G.is_directed() ))
print ( "Delta: {}".format( max(G.degree(node) for node in G.iternodes()) ))
print ( "Testing BruteForceTSPWithGraph ..." )
t1 = timeit.Timer(lambda: BruteForceTSPWithGraph(G).run())
print ( "{} {} {}".format(V, E, t1.timeit(1)) ) # single run
print ( "Testing NearestNeighborTSPWithGraph ..." )
t1 = timeit.Timer(lambda: NearestNeighborTSPWithGraph(G).run())
print ( "{} {} {}".format(V, E, t1.timeit(1)) ) # single run
print ( "Testing RepeatedNearestNeighborTSPWithGraph ..." )
t1 = timeit.Timer(lambda: RepeatedNearestNeighborTSPWithGraph(G).run())
print ( "{} {} {}".format(V, E, t1.timeit(1)) ) # single run
print ( "Testing SortedEdgeTSPWithGraph ..." )
t1 = timeit.Timer(lambda: SortedEdgeTSPWithGraph(G).run())
for i in xrange(V):
G.add_node((random.random(), random.random()))
for source in G.iternodes():
for target in G.iternodes():
if source < target:
x0, y0 = source
x1, y1 = target
weight = math.hypot(x1 - x0, y1 - y0)
G.add_edge(Edge(source, target, weight))
#G.show()
print "Calculate parameters ..."
print "Nodes:", G.v(), V
print "Edges:", G.e(), E
print "Directed:", G.is_directed()
print "Delta:", max(G.degree(node) for node in G.iternodes())
print "Testing BruteForceTSPWithGraph ..."
t1 = timeit.Timer(lambda: BruteForceTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
print "Testing NearestNeighborTSPWithGraph ..."
t1 = timeit.Timer(lambda: NearestNeighborTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
print "Testing RepeatedNearestNeighborTSPWithGraph ..."
t1 = timeit.Timer(lambda: RepeatedNearestNeighborTSPWithGraph(G).run())
print V, E, t1.timeit(1) # single run
print "Testing SortedEdgeTSPWithGraph ..."
t1 = timeit.Timer(lambda: SortedEdgeTSPWithGraph(G).run())
