def test_exceptions(self):
self.assertRaises(ValueError, MatchingFordFulkersonSet,
Graph(2, directed=True))
self.assertRaises(ValueError, MatchingFordFulkersonList,
Graph(2, directed=True))
self.assertRaises(ValueError, MatchingFordFulkersonColor,
Graph(2, directed=True))
def test_exceptions(self):
self.assertRaises(ValueError, UnorderedSequentialIndependentSet1,
Graph(5, directed=True))
self.assertRaises(ValueError, UnorderedSequentialIndependentSet2,
Graph(5, directed=True))
self.assertRaises(ValueError, UnorderedSequentialIndependentSet3,
Graph(5, directed=True))
def test_exceptions(self):
self.G.add_edge(Edge(0, 4))
algorithm = BipartiteGraphBFS(self.G)
self.assertRaises(ValueError, algorithm.run)
algorithm = BipartiteGraphDFS(self.G)
self.assertRaises(ValueError, algorithm.run)
self.assertRaises(ValueError, BipartiteGraphBFS, Graph(2,
directed=True))
self.assertRaises(ValueError, BipartiteGraphDFS, Graph(2,
directed=True))
def test_exceptions(self):
self.assertRaises(ValueError, FordFulkerson, Graph())
self.assertRaises(ValueError, FordFulkersonSparse, Graph())
self.assertRaises(ValueError, FordFulkersonWithEdges, Graph())
self.assertRaises(ValueError, FordFulkersonRecursive, Graph())
self.assertRaises(ValueError, lambda: FordFulkerson(self.G).run(0, 0))
self.assertRaises(ValueError,
lambda: FordFulkersonSparse(self.G).run(0, 0))
self.assertRaises(ValueError,
lambda: FordFulkersonWithEdges(self.G).run(0, 0))
self.assertRaises(ValueError,
lambda: FordFulkersonRecursive(self.G).run(0, 0))
self.assertRaises(
ValueError,
lambda: FordFulkersonRecursiveWithEdges(self.G).run(0, 0))
def test_3prism(self):
N = 6
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(1, 2),
Edge(2, 3),
Edge(3, 4),
Edge(4, 5),
Edge(0, 5),
Edge(1, 4),
Edge(2, 0),
Edge(3, 5)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "3prism ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 2, 3, 5]))
#algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 4, 5]))
#algorithm = HalinGraphTreeDecomposition(G, outer=set([1, 2, 3, 4]))
algorithm.run()
#print "3prism outer", algorithm.outer
parent = {0: 1, 1: None, 2: 1, 3: 4, 4: 1, 5: 4}
self.assertEqual(algorithm.parent, parent)
#order = [1, 0, 2, 3, 5, 4]
order = [4, 0, 2, 3, 5, 1]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
def test_halin16(self):
N = 16
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(0, 2),
Edge(0, 15),
Edge(1, 2),
Edge(1, 6),
Edge(2, 3),
Edge(3, 4),
Edge(3, 5),
Edge(4, 5),
Edge(4, 10),
Edge(5, 6),
Edge(6, 7),
Edge(7, 8),
Edge(7, 15),
Edge(8, 9),
Edge(8, 13),
Edge(9, 10),
Edge(9, 11),
Edge(10, 11),
Edge(11, 12),
Edge(12, 13),
Edge(12, 14),
Edge(13, 14),
Edge(14, 15)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin16 ..."
algorithm = HalinGraphTreeDecomposition(
G, outer=set([0, 2, 3, 4, 10, 11, 12, 14, 15]))
algorithm.run()
#print "halin16 outer", algorithm.outer
parent = {
0: 1,
1: None,
2: 1,
3: 5,
4: 5,
5: 6,
6: 1,
7: 6,
8: 7,
9: 8,
10: 9,
11: 9,
12: 13,
13: 8,
14: 13,
15: 7
}
self.assertEqual(algorithm.parent, parent)
order = [5, 9, 13, 1, 11, 12, 8, 2, 3, 6, 0, 4, 10, 14, 15, 7]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
def test_wheel5(self):
N = 5
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(0, 2),
Edge(0, 3),
Edge(0, 4),
Edge(1, 2),
Edge(2, 3),
Edge(3, 4),
Edge(4, 1)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "wheel5 ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([1, 2, 3, 4]))
algorithm.run()
#print "wheel5 outer", algorithm.outer
#print "wheel5 cycle", algorithm.cycle
parent = {0: None, 1: 0, 2: 0, 3: 0, 4: 0}
self.assertEqual(algorithm.parent, parent)
order = [1, 2, 3, 4, 0]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
def test_halin8c(self):
N = 8
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(0, 5),
Edge(0, 7),
Edge(1, 2),
Edge(1, 7),
Edge(2, 3),
Edge(2, 6),
Edge(3, 4),
Edge(3, 6),
Edge(4, 5),
Edge(4, 6),
Edge(5, 6),
Edge(6, 7)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin8c ..."
algorithm = HalinGraphTreeDecomposition(G,
outer=set([0, 1, 2, 3, 4, 5]))
algorithm.run()
#print "halin8c outer", algorithm.outer
parent = {0: 7, 1: 7, 2: 6, 3: 6, 4: 6, 5: 6, 6: None, 7: 6}
self.assertEqual(algorithm.parent, parent)
#order = [7, 0, 1, 2, 3, 4, 5, 6] # wersja z indeksami
order = [3, 4, 6, 0, 1, 2, 5, 7] # wersja z linkami
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
def test_halin8a(self):
N = 8
G = Graph(N, False)
edges = [
Edge(0, 1),
Edge(0, 2),
Edge(0, 7),
Edge(1, 2),
Edge(1, 5),
Edge(2, 3),
Edge(3, 4),
Edge(3, 7),
Edge(4, 5),
Edge(4, 6),
Edge(5, 6),
Edge(6, 7)
]
for node in range(N):
G.add_node(node)
for edge in edges:
G.add_edge(edge)
#print "halin8a ..."
algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 7, 6, 5, 1]))
algorithm.run()
#print "halin8a outer", algorithm.outer
parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 4, 6: 4, 7: 3}
self.assertEqual(algorithm.parent, parent)
#order = [2, 4, 0, 1, 5, 6, 7, 3]
order = [4, 2, 0, 1, 5, 6, 7, 3]
self.assertEqual(algorithm.order, order)
self.assertEqual(len(algorithm.cliques), G.v() - 3)
def test_scc(self):
algorithm = StronglyConnectedComponents(self.G)
algorithm.run()
self.assertEqual(algorithm.n_scc, self.expected_n_scc)
self.assertEqual(algorithm.scc, self.expected_scc)
self.assertRaises(ValueError, StronglyConnectedComponents,
Graph(1, False))
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_center_two2(self):
T = Graph(2)
T.add_edge(Edge(0, 1))
algorithm = TreeCenter(T)
algorithm.run()
self.assertEqual(algorithm.tree_center, [0, 1])
self.assertEqual(algorithm.tree_radius, 1)
def setUp(self):
self.N = 5
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1),
Edge(0, 2),
Edge(1, 2),
Edge(1, 3),
Edge(1, 4)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#self.G.show()
node1 = Node(0, 1, "edge")
node2 = Node(0, 2, "edge")
node3 = Node(2, 1, "edge")
node4 = Node(1, 3, "edge")
node5 = Node(1, 4, "edge")
node6 = Node(0, 1, "series", node2, node3)
node7 = Node(0, 1, "parallel", node1, node6)
node8 = Node(0, 1, "jackknife", node7, node4)
node9 = Node(0, 1, "jackknife", node8, node5)
self.root = node9
def setUp(self):
# The modified graph (unique weights) from Cormen.
self.N = 9 # number of nodes
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1, 4),
Edge(0, 7, 8),
Edge(1, 7, 11),
Edge(1, 2, 12),
Edge(7, 8, 7),
Edge(8, 2, 2),
Edge(8, 6, 6),
Edge(7, 6, 1),
Edge(2, 3, 13),
Edge(2, 5, 5),
Edge(6, 5, 3),
Edge(3, 5, 14),
Edge(3, 4, 9),
Edge(5, 4, 10)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
def test_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 make_random_spgraph(n):
"""Make a series-parallel graph with n vertices."""
if n < 2:
raise ValueError("bad n")
graph = Graph(n)
for node in xrange(n):
graph.add_node(node)
source = 0
sink = n - 1
edge_list = [Edge(source, sink)]
node = n - 2
while node > 0:
# Losowanie krawedzi na ktorej bedzie operacja.
i = random.randrange(0, len(edge_list))
swap(edge_list, i, -1)
edge = edge_list[-1]
# Losowanie operacji.
if edge.target == sink:
action = random.choice(["series", "parallel", "jackknife"])
else:
action = random.choice(["series", "parallel"])
if action == "series":
edge_list.pop()
edge_list.append(Edge(edge.source, node))
edge_list.append(Edge(node, edge.target))
elif action == "parallel":
edge_list.append(Edge(edge.source, node))
edge_list.append(Edge(node, edge.target))
elif action == "jackknife":
edge_list.append(Edge(edge.target, node))
node -= 1
for edge in edge_list:
graph.add_edge(edge)
return graph
def setUp(self):
self.N = 8 # number of nodes
self.G = Graph(self.N, directed=True)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1),
Edge(1, 4),
Edge(4, 0),
Edge(4, 5),
Edge(1, 5),
Edge(1, 2),
Edge(5, 6),
Edge(6, 5),
Edge(2, 6),
Edge(2, 3),
Edge(3, 2),
Edge(6, 7),
Edge(3, 7)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
#self.G.show()
self.expected_scc = {0: 0, 1: 0, 2: 1, 3: 1, 4: 0, 5: 2, 6: 2, 7: 3}
self.expected_n_scc = 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)
def test_exceptions(self):
self.assertRaises(ValueError, BipartiteGraphEdgeColoring,
Graph(5, directed=True))
gf = GraphFactory(Graph)
G = gf.make_cyclic(4)
#G.show()
G.add_edge(Edge(0, 2)) # nie bedzie dwudzielny
self.assertRaises(ValueError, BipartiteGraphEdgeColoring, G)
def test_exceptions(self):
self.assertRaises(ValueError, CompleteBipartiteGraphEdgeColoring,
Graph(5, directed=True))
gf = GraphFactory(Graph)
G = gf.make_bipartite(2, 2, False, 1)
#G.show()
G.del_edge(Edge(0, 2)) # nie bedzie pelny dwudzielny
self.assertRaises(ValueError, CompleteBipartiteGraphEdgeColoring, G)
def test_tree_three_nodes(self):
T = Graph(3)
for node in (0, 1, 2):
T.add_node(node)
for edge in (Edge(0, 1), Edge(1, 2)):
T.add_edge(edge)
algorithm = TreePlot(T)
algorithm.run()
self.assertEqual(len(algorithm.point_dict), 3)
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 setUp(self):
self.N = 7
self.G = Graph(self.N)
self.nodes = range(self.N)
self.edges = [Edge(0, 1), Edge(1, 3), Edge(1, 2),
Edge(1, 4), Edge(2, 5), Edge(2, 6)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
def test_dijkstra_for_path_not_found(self):
print("Testing Matrix 2nd time")
self.N = 8 # number of nodes
self.G = Graph(self.N, directed=True)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1, 65),
Edge(1, 8, 41),
Edge(1, 2, 35),
Edge(2, 3, 56),
Edge(3, 4, 4),
Edge(3, 6, 20),
Edge(5, 2, 30),
Edge(6, 5, 18),
Edge(6, 7, 15),
Edge(8, 3, 28)
]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
# self.G.show()
algorithm = Dijkstra(self.G)
source = 0
algorithm.run(source)
target = 7
path_expected = [0, 1, 8, 3, 6, 7]
distance_expected = 169
self.assertEqual(path_expected, algorithm.path(target))
self.assertEqual(distance_expected, algorithm.distance[target])
algorithm2 = DijkstraMatrix(self.G)
algorithm2.run(source)
self.assertEqual(path_expected, algorithm.path(target))
self.assertEqual(distance_expected, algorithm.distance[target])
source = 2
target = 8
algorithm.run(source)
try:
algorithm.path(target)
except:
pass
else:
self.fail("Path exception was not raised!")
algorithm2.run(source)
try:
algorithm2.path(target)
except:
pass
else:
self.fail("Path exception was not raised!")
def setUp(self):
self.N = 4 # number of nodes
self.G = Graph(self.N, directed=True) # directed graph
self.nodes = range(self.N)
self.edges = [
Edge(0, 1, 1), Edge(0, 2, 5), Edge(1, 2, 1), Edge(1, 3, 3),
Edge(2, 3, 1)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
def setUp(self):
self.N = 7 # number of nodes
self.G = Graph(self.N, directed=False)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1), Edge(0, 4), Edge(1, 4), Edge(2, 3), Edge(2, 5),
Edge(3, 5), Edge(4, 5), Edge(4, 6), Edge(5, 6)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
def setUp(self):
self.N = 6 # number of nodes
self.G = Graph(self.N, directed=True)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1), Edge(3, 0), Edge(1, 4), Edge(4, 3), Edge(2, 4),
Edge(4, 5), Edge(5, 2)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
def setUp(self):
self.N = 5 # number of nodes
self.G = Graph(self.N, directed=False)
self.nodes = range(self.N)
self.edges = [
Edge(0, 2, 6), Edge(0, 3, 3), Edge(1, 0, 3), Edge(2, 3, 2),
Edge(3, 1, 1), Edge(4, 1, 4), Edge(4, 3, 2)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
def setUp(self):
self.N = 4 # number of nodes
self.G = Graph(self.N, directed=True)
self.nodes = range(self.N)
self.edges = [
Edge(0, 1, 3), Edge(0, 2, 6), Edge(1, 2, 4), Edge(1, 3, 5),
Edge(2, 3, 2), Edge(3, 0, -5), Edge(3, 1, -3)]
for node in self.nodes:
self.G.add_node(node)
for edge in self.edges:
self.G.add_edge(edge)
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)
