def test_graph_cracov_easy_path_next(self):
stops_common = [
"Czerwone Maki", "Chmieleniec", "Kampus UJ", "Ruczaj",
"Norymberska", "Grota", "Lipinskiego"
]
nodes = {}
for name in stops_common:
nodes[name] = Node(name)
def conn_nod(a, b, len):
connect_both(nodes[a], nodes[b], len)
nodes_list = [node for node in nodes.values()]
for i in range(0, len(stops_common) - 1):
conn_nod(stops_common[i], stops_common[i + 1], 5)
graph = Graph(nodes_list)
for stop in stops_common[1:]:
self.assert_path_next_move(graph, "Czerwone Maki", stop,
"Chmieleniec")
for stop in stops_common[2:]:
self.assert_path_next_move(graph, "Chmieleniec", stop, "Kampus UJ")
for stop in stops_common[3:]:
self.assert_path_next_move(graph, "Kampus UJ", stop, "Ruczaj")
for stop in stops_common[:2]:
self.assert_path_next_move(graph, "Kampus UJ", stop, "Chmieleniec")
for stop in stops_common[4:]:
self.assert_path_next_move(graph, "Ruczaj", stop, "Norymberska")
def test_has_node():
_graph = Graph()
_node1 = Node(4)
_node2 = Node(5)
_graph.add_node(_node1)
assert _graph.had_node(_node1) == True
assert _graph.had_node(_node2) == False
def __init__(self, truck_id, package_limit, speed, start_of_day,
hub_location):
"""
Create Truck Object
:param truck_id: id of the truck :int
:param package_limit: maximum number of packages truck can hold :int
:param speed: speed of truck in miles per hour :int
:param start_of_day: time of start of day :str
:param hub_location: location of hub :Location
:return: Truck Object
Worst Case Runtime Complexity: O(1)
Best Case Runtime Complexity: O(1)
"""
self._id = truck_id
self._package_limit = package_limit
self._speed = (speed / 60) / 60 # truck speed in miles per second
self._locations = Graph()
self._packages = []
self._start_of_day = start_of_day
self._locations.add_vertex(hub_location.name, hub_location)
self._route = Queue()
self._departure_time = None # departure time in seconds since start
self._distance_traveled = 0.0
self._current_location = None
self._next_location = None
self._route_done = False
def generate_sample_graph(is_directed=False):
'''
Will return a graph obj as such, either undirected or directed based on the optional arg:
undirected
[A] -> {'B', 'C'}
[B] -> {'A', 'D', 'E'}
[C] -> {'A', 'F'}
[D] -> {'B'}
[E] -> {'B', 'F'}
[F] -> {'E', 'C'}
directed
[A] -> {'C', 'B'}
[B] -> {'E', 'D'}
[C] -> {'F'}
[E] -> {'F'}
'''
graph = Graph(is_directed)
graph.add_edge('A', 'B')
graph.add_edge('A', 'C')
graph.add_edge('B', 'D')
graph.add_edge('B', 'E')
graph.add_edge('C', 'F')
graph.add_edge('E', 'F')
return graph
def test_add_node(self):
""" Tests that add_node properly adds nodes to adjecency list """
graph = Graph()
expected_graph = {'a': {'b'}}
graph.add_node('a', ['b'])
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['a'].add('c')
graph.add_node('a', 'c')
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['b'] = set({'a', 'd', 'e'})
graph.add_node('b', ['a', 'd', 'e'])
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['c'] = set('f')
graph.add_node('c', 'f')
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['d'] = set('b')
graph.add_node('d', 'b')
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['e'] = set({'b', 'f'})
graph.add_node('e', 'b')
graph.add_node('e', 'f')
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['f'] = set({'c', 'e'})
graph.add_node('f', 'c')
graph.add_node('f', 'e')
self.assertDictEqual(expected_graph, graph._adjecents)
def setUp(self) -> None:
node1 = GraphNode(data=1)
node2 = GraphNode(data=2)
node3 = GraphNode(data=3)
node4 = GraphNode(data=4)
node5 = GraphNode(data=5)
node6 = GraphNode(data=6)
node7 = GraphNode(data=7)
node8 = GraphNode(data=8)
node9 = GraphNode(data=9)
node10 = GraphNode(data=10)
node11 = GraphNode(data=11)
node12 = GraphNode(data=12)
node13 = GraphNode(data=13)
node14 = GraphNode(data=14)
node15 = GraphNode(data=15)
node1.add_child(node5)
node2.add_children([node5, node9, node10])
node3.add_children([node2, node13, node4])
node4.add_children([node5, node6, node8])
node5.add_children([node3])
node6.add_child(node7)
node9.add_child(node10)
node10.add_child(node11)
node11.add_child(node12)
node13.add_child(node14)
node14.add_child(node15)
my_graph = Graph()
my_graph.add_nodes([
node1, node2, node3, node4, node5, node6, node7, node8, node9,
node10, node11, node12, node13, node14, node15
])
self.my_graph = my_graph
def test_get_edges(self):
"""
A - 1 - B - 2 - C - 1 - D
| |
1 5
| |
E - 1 - F
"""
nodes = {}
for letter in "ABCDEF":
nodes[letter] = Node(letter)
def conn_nod(a, b, len):
connect_both(nodes[a], nodes[b], len)
conn_nod("A", "B", 1)
conn_nod("A", "E", 1)
conn_nod("E", "F", 1)
conn_nod("F", "B", 5)
conn_nod("B", "C", 2)
conn_nod("D", "C", 1)
graph = Graph([nodes[key] for key in nodes])
self.assertEqual(graph["A", "B"], 1)
self.assertEqual(graph["A", "E"], 1)
self.assertEqual(graph["E", "F"], 1)
self.assertEqual(graph["F", "B"], 5)
self.assertEqual(graph["B", "C"], 2)
self.assertEqual(graph["D", "C"], 1)
def test_graph_cracov_easy_path_len(self):
stops_common = [
"Czerwone Maki", "Chmieleniec", "Kampus UJ", "Ruczaj",
"Norymberska", "Grota", "Lipinskiego"
]
nodes = {}
for name in stops_common:
nodes[name] = Node(name)
def conn_nod(a, b, len):
connect_both(nodes[a], nodes[b], len)
def ass_path_len(a, b, i):
self.assert_path_len(
graph, a, b, i,
"between {0} and {1} should be {2}".format(a, b, i))
nodes_list = [node for node in nodes.values()]
conn_nod(stops_common[0], stops_common[1], 5)
conn_nod(stops_common[1], stops_common[2], 5)
conn_nod(stops_common[2], stops_common[3], 5)
conn_nod(stops_common[3], stops_common[4], 5)
conn_nod(stops_common[4], stops_common[5], 5)
conn_nod(stops_common[5], stops_common[6], 5)
graph = Graph(nodes_list)
q = 0
for i in range(0, len(stops_common)):
for q in range(0, len(stops_common)):
self.assert_path_len(graph, stops_common[i], stops_common[q],
abs(i - q) * 5)
def graph():
letters = Graph()
a = letters.add_node("a")
b = letters.add_node("b")
c = letters.add_node("c")
d = letters.add_node("d")
e = letters.add_node("e")
f = letters.add_node("f")
g = letters.add_node("g")
h = letters.add_node("h")
letters.add_edge(a, b)
letters.add_edge(b, c)
letters.add_edge(c, g)
letters.add_edge(a, d)
letters.add_edge(d, e)
letters.add_edge(d, h)
letters.add_edge(d, f)
letters.add_edge(h, f)
return letters
def graph():
realms = Graph()
pandora = realms.add_node("Pandora")
arendelle = realms.add_node("Arendelle")
metroville = realms.add_node("Metroville")
monstropolis = realms.add_node("Monstropolis")
narnia = realms.add_node("Narnia")
naboo = realms.add_node("Naboo")
realms.add_edge(pandora, arendelle)
realms.add_edge(arendelle, pandora)
realms.add_edge(arendelle, metroville)
realms.add_edge(arendelle, monstropolis)
realms.add_edge(metroville, arendelle)
realms.add_edge(metroville, monstropolis)
realms.add_edge(metroville, narnia)
realms.add_edge(monstropolis, arendelle)
realms.add_edge(monstropolis, metroville)
realms.add_edge(monstropolis, naboo)
realms.add_edge(narnia, metroville)
realms.add_edge(narnia, naboo)
realms.add_edge(naboo, metroville)
realms.add_edge(naboo, monstropolis)
realms.add_edge(naboo, narnia)
return realms
def test_add_undirected_edge(self):
print('Test: test_add_undirected_edge')
g = Graph()
n, n1 = g.add_node(), g.add_node()
g.add_undirected_edge(n, n1, 5)
self.assertIn([n1, 5], n.neighbors)
self.assertIn([n, 5], n1.neighbors)
print('Success: test_add_undirected_edge')
def test_bouquet():
g = Graph()
apple = g.add_node("apple")
g.add_edge(apple, apple, 10)
neighbors = g.get_neighbors(apple)
assert len(neighbors) == 1
assert neighbors[0].vertex.value == "apple"
assert neighbors[0].weight == 10
def test_size_empty():
graph = Graph()
expected = 0
actual = graph.size()
assert actual == expected
def test_add_edge():
g = Graph()
apple = g.add_node("apple")
banana = g.add_node("banana")
g.add_edge(apple, banana, 5)
neighbors = g.get_neighbors(apple)
assert len(neighbors) == 1
assert neighbors[0].vertex.value == "banana"
assert neighbors[0].weight == 5
def test_add_node():
graph = Graph()
expected = "spam" # a vertex's value that comes back
actual = graph.add_node("spam").value
assert actual == expected
def generate_graph(voro, width, height):
line_list = sort_lines(voro, width, height)
g = Graph.Graph()
for line in line_list:
g.add_vertex(line[0])
g.add_vertex(line[1])
g.add_edge(line[0], line[1], line_tools.calc_length(line))
return g
def generate_sample_friend_network():
graph = Graph()
graph.add_edge('Alex', 'Bob')
graph.add_edge('Bob', 'Dan')
graph.add_edge('Bob', 'Charlie')
graph.add_edge('Charlie', 'Elsa')
graph.add_edge('Elsa', 'Genna')
return graph
def knight_graph(board_size):
kt_graph = Graph()
for row in range(board_size):
for col in range(board_size):
node_id = pos_to_node_id(row, col, board_size)
new_positions = gen_legal_moves(row, col, board_size)
for e in new_positions:
n_id = pos_to_node_id(e[0], e[1], board_size)
kt_graph.add_edge(node_id, n_id)
return kt_graph
def test_add_edge_interloper_end():
graph = Graph()
end = Vertex("end")
start = graph.add_node("start")
with pytest.raises(KeyError):
graph.add_edge(start, end)
def test_size():
graph = Graph()
graph.add_node("spam")
expected = 1
actual = graph.size()
assert actual == expected
def test_add_node(self):
print('Test: test_add_node')
print('Test: keys are numbers')
g = Graph()
g.add_node()
self.assertEqual(len(g._nodes), 1)
self.assertEqual(g._counter, 1)
print('Test: keys are chars')
g = Graph(letters=True)
g.add_node()
self.assertEqual(len(g._nodes), 1)
self.assertEqual(g._counter, 98)
print('Test: keys are chars (not enough keys)')
for i in range(98, 123):
g.add_node()
self.assertRaises(NotEnoughKeys, g.add_node)
print('Success: test_add_node')
def shortest_reach(n, edges, s):
graph = Graph(False)
for vertex in range(1, n + 1):
graph.add_vertex(vertex)
for begin, end, weight in edges:
graph.add_edge(begin, end, weight)
shortest_paths = graph.dijkstra_shortest_path(s)
return [
value.distance if value.distance != inf else -1
for key, value in sorted(shortest_paths.items()) if key != s
]
def steiner_tree(graph):
leaf_nodes = graph.find_non_terminal_leaves()
# Get a copy of the graph edges
# we are going to delete edges from this dictionary (by setting their value to an empty list)
new_edges = graph.edges.copy()
# Same with the nodes
new_nodes = graph.nodes.copy()
# For all non-terminal leaves in the MST
for leaf in leaf_nodes:
node_num = leaf[0]
edge_num = list(leaf[1].values())[0]
leaf_edge = graph.edges[edge_num]
# Second node connected to the edge
second_node = leaf_edge[0] if leaf_edge[
1] == node_num else leaf_edge[1]
# Setting the value of the chosen edge and node to [] (as if we have deleted it)
new_edges[edge_num] = []
new_nodes[node_num] = []
# Update the second node's degree and edges dictionary
graph.nodes[second_node][0] -= 1
graph.nodes[second_node][1].pop(node_num)
# Checking if the remaining node is a leaf and not a terminal
while graph.nodes[second_node][2] == 0 and graph.nodes[
second_node][0] == 1:
node_num = second_node
node_edges = graph.nodes[second_node][1]
edge_num = list(node_edges.values())[0]
leaf_edge = graph.edges[edge_num]
second_node = leaf_edge[0] if leaf_edge[
1] == node_num else leaf_edge[1]
new_edges[edge_num] = []
new_nodes[node_num] = []
graph.nodes[second_node][0] -= 1
graph.nodes[second_node][1].pop(node_num)
# Making new dictionaries of the updated nodes and edges to make a graph from them
new_graph_nodes = {k: v[2] for k, v in new_nodes.items() if v != []}
edge_number = 1
new_graph_edges = {}
for k, v in new_edges.items():
if v:
new_graph_edges[edge_number] = v
edge_number += 1
steiner_tree = Graph(len(new_graph_nodes), len(new_graph_edges),
new_graph_nodes, new_graph_edges)
return steiner_tree, steiner_tree.graph_weight()
def test_remove_node(self):
print('Test: test_remove_node')
g = Graph()
print('Test: remove a non-existent node')
self.assertRaises(ValueError, g.remove_node, 0)
print('Test: general case')
n = g.add_node()
self.assertEqual(len(g._nodes), 1)
g.remove_node(n.key)
self.assertEqual(len(g._nodes), 0)
print('Success: test_remove_node')
def generate_graph(screen_width, screen_height, num_of_vertices):
points = generate_points.generate_points(screen_width, screen_height,
num_of_vertices)
g = Graph.Graph()
for x in points:
for y in points:
if x != y:
g.add_vertex(x)
g.add_vertex(y)
g.add_edge(x, y, line_tools.calc_length((x, y)))
return g
def make_graph(make_nodes):
nodes = make_nodes
g = Graph(nodes)
g.add_edges(nodes[0], nodes[1], 1)
g.add_edges(nodes[0], nodes[6], 1)
g.add_edges(nodes[0], nodes[7], 1)
g.add_edges(nodes[1], nodes[2], 1)
g.add_edges(nodes[1], nodes[5], 1)
g.add_edges(nodes[2], nodes[3], 1)
g.add_edges(nodes[2], nodes[4], 1)
g.add_edges(nodes[7], nodes[8], 1)
g.add_edges(nodes[8], nodes[9], 1)
return g
def test_neighbours():
_graph = Graph()
_node1 = Node(4)
_node2 = Node(5)
_node3 = Node(6)
_node4 = Node(7)
_graph.add_edges(_node1, _node2, 1)
_graph.add_edges(_node3, _node4, 1)
_graph.add_edges(_node2, _node4, 1)
_graph.add_edges(_node1, _node2, 2)
_graph.add_edges(_node3, _node4, 2)
_graph.add_edges(_node2, _node4, 2)
assert _graph.neighbours(_node2) == ['n0', 'n3']
def make_weighted_graph(make_nodes):
nodes = make_nodes[:6]
g = Graph(nodes)
g.add_edges(nodes[0], nodes[1], 7)
g.add_edges(nodes[0], nodes[2], 9)
g.add_edges(nodes[0], nodes[5], 14)
g.add_edges(nodes[1], nodes[2], 10)
g.add_edges(nodes[1], nodes[3], 15)
g.add_edges(nodes[2], nodes[3], 11)
g.add_edges(nodes[2], nodes[5], 2)
g.add_edges(nodes[3], nodes[4], 6)
g.add_edges(nodes[4], nodes[5], 9)
return g
def test_adjacent():
_graph = Graph()
_node1 = Node(4)
_node2 = Node(5)
_node3 = Node(6)
_node4 = Node(7)
_graph.add_edges(_node1, _node2, 1)
_graph.add_edges(_node3, _node4, 1)
_graph.add_edges(_node2, _node4, 1)
assert _graph.adjacent(_node1, _node2) == True
assert _graph.adjacent(_node3, _node4) == True
assert _graph.adjacent(_node2, _node4) == True
assert _graph.adjacent(_node1, _node4) == False
def test_steiner_tree_algorithm_on_stp_file(path):
comment, graph, terminals = FileHandler.read_stp_file(path)
graph_nodes = {k: 0 for k in range(1, graph['Nodes'] + 1)}
terminal_nodes = [
terminals[k] for k in range(1, terminals['Terminals'] + 1)
]
for terminal in terminal_nodes:
graph_nodes[terminal] = 1
graph = Graph(graph['Nodes'], graph['Edges'], graph_nodes,
{k: graph[k]
for k in range(1, graph['Edges'] + 1)})
mst = Kruskal.kruskal_algorithm(graph)
steiner_tree = SteinerTreeBasedOnKruskal.steiner_tree(mst[0])
return steiner_tree[0], steiner_tree[1]
