def load_linqs_data(content_file, cites_file): ''' Create a DirectedGraph object and add Nodes and Edges This is specific to the data files provided at http://linqs.cs.umd.edu/projects/projects/lbc/index.html Return two items 1. graph object, 2. the list of domain labels (e.g., ['AI', 'IR']) ''' linqs_graph = DirectedGraph() domain_labels = [] id_obj_map = {} with open(content_file, 'r') as node_file: for line in node_file: line_info = line.split('\n')[0].split('\t') n = Node(line_info[0], map(float, line_info[1:-1]), line_info[-1]) # id, feature vector, label linqs_graph.add_node(n) if line_info[-1] not in domain_labels: domain_labels.append(line_info[-1]) id_obj_map[line_info[0]] = n with open(cites_file, 'r') as edge_file: for line in edge_file: line_info = line.split('\n')[0].split('\t') if line_info[0] in id_obj_map.keys( ) and line_info[1] in id_obj_map.keys(): from_node = id_obj_map[line_info[1]] to_node = id_obj_map[line_info[0]] linqs_graph.add_edge(Edge(from_node, to_node)) print "domain labels" print domain_labels return linqs_graph, domain_labels
class GitHubAPI: def __init__(self, username, depth): self.username = username self.depth = depth self.graph = DirectedGraph() self.following_users = [] def get_following_for(self, name): self.following_users = requests.get("https://api.github.com/users/{}/following".format(name)) print(self.following_users.json()) return self.following_users def following(self, name): following_users = self.get_following_for(name) following_names = [] for i in range(len(following_users.json())): print(len(following_users.json())) following_names.append(following_users.json()[i]["login"]) return following_names def build_graph(self, name): neighbors = self.following(name) for neighbor in neighbors: self.graph.add_edge(name, neighbor) print(self.graph)
def invert_graph(G): _G = DirectedGraph() for u in G.all_vertexes(): connections = [(u.data, v) for u, v in G.get_vertex(u).items()] for v, w in connections: _G.add_edge(v, u, w) return _G
def load_linqs_data(content_file, cites_file): ''' Create a DirectedGraph object and add Nodes and Edges This is specific to the data files provided at http://linqs.cs.umd.edu/projects/projects/lbc/index.html Return two items 1. graph object, 2. the list of domain labels (e.g., ['AI', 'IR']) ''' linqs_graph=DirectedGraph() domain_labels=[] id_obj_map={} with open(content_file, 'r') as node_file: for line in node_file: line_info=line.split('\n')[0].split('\t') n=Node(line_info[0],map(float,line_info[1:-1]),line_info[-1])# id, feature vector, label linqs_graph.add_node(n) if line_info[-1] not in domain_labels: domain_labels.append(line_info[-1]) id_obj_map[line_info[0]]=n with open(cites_file,'r') as edge_file: for line in edge_file: line_info=line.split('\n')[0].split('\t') if line_info[0] in id_obj_map.keys() and line_info[1] in id_obj_map.keys(): from_node=id_obj_map[line_info[1]] to_node=id_obj_map[line_info[0]] linqs_graph.add_edge(Edge(from_node,to_node)) return linqs_graph,domain_labels
def init_map(self): graph = DirectedGraph() orientations = [Orientation.up, Orientation.left, Orientation.down, Orientation.right] if self.debug: print '> Mapper::init_map Adding all nodes' # Add all nodes to graph for r in xrange(0, self.max_rows): for c in xrange(0, self.max_cols): for o in orientations: graph.add_node((r,c,o)) # Add turn right and left to all node. # Add move to all posible nodes for node in graph.nodes: graph.add_edge(node, (node[0], node[1], (node[2]+1)%4)) graph.add_edge(node, (node[0], node[1], (node[2]-1)%4)) if node[2] == Orientation.up and (node[0]+1, node[1], node[2]) in graph.nodes: graph.add_edge(node, (node[0]+1, node[1], node[2])) elif node[2] == Orientation.left and (node[0], node[1]-1, node[2]) in graph.nodes: graph.add_edge(node, (node[0], node[1]-1, node[2])) elif node[2] == Orientation.down and (node[0]-1, node[1], node[2]) in graph.nodes: graph.add_edge(node, (node[0]-1, node[1], node[2])) elif node[2] == Orientation.right and (node[0], node[1]+1, node[2]) in graph.nodes: graph.add_edge(node, (node[0], node[1]+1, node[2])) return graph
def main(): G = DirectedGraph() G.add_vertex('A') G.add_vertex('B') G.add_vertex('C') G.add_vertex('D') G.add_vertex('E') G.add_edge('A', 'B') G.add_edge('B', 'C') G.add_edge('B', 'D') G.add_edge('A', 'E') print(strongly_connected(G))
def generate_directed_subgraph(original_graph, nodes_subset) -> DirectedGraph: new_graph = DirectedGraph() for node in original_graph.get_nodes(): if node in nodes_subset: new_graph.add_node(node) for edge in original_graph.get_edges(): if edge[0] in nodes_subset and edge[1] in nodes_subset: new_graph.add_edge(edge[0], edge[1], edge[2]) return new_graph
class GitHubModule: URL_PATTERN = "https://api.github.com/users/{}/follow\ ers?client_id={}&client_secret={}" CLIENT_ID = "6fd2017ecf6841cd6666" CLIENT_SECRET = "19e84bb54b28974bbc2260a778b28c1139f91360" def __init__(self, parent): self.parent = parent self.graph = DirectedGraph() self.fill_graph(self.parent) def fill_graph_for_user(self, user): url = self.URL_PATTERN.format(user, self.CLIENT_ID, self.CLIENT_SECRET) user_followers = requests.get(url) followers_dict = user_followers.json() for follower in followers_dict: self.graph.add_edge(user, follower["login"]) def fill_graph(self, user): self.fill_graph_for_user(user) followers = set(self.graph.nodes[user]) temp = set() # use set to prevent repetitions for i in range(2): # two more levels of depth for follower in followers: self.fill_graph_for_user(follower) for name in self.graph.nodes[follower]: temp.add(name) followers = temp.copy() temp = set() def following(self): users_the_parent_follows = [] for user in self.graph.nodes.keys(): if self.parent in self.graph.nodes[user]: users_the_parent_follows.append(user) return users_the_parent_follows def is_following(self, user): if user in self.graph.nodes.keys(): return self.parent in self.graph.nodes[user] return False
class TaskTemplateResolver(): def __init__(self, task_templates=[]): self.template_graph = DirectedGraph() self.templates = {} self.template_parameters = {} self.namespaces = {} for template in task_templates: self.add_task_template(template) def add_task_template(self, template): template_id = _ns_template_id(template.namespace, template.id) self.templates[template_id] = template self.template_parameters[template_id] = dict(template.parameters) self.template_graph.add_node(template_id) self.namespaces[template.namespace] = True for task_id in template.dependencies: qualified_task_id = _ns_template_id(template.namespace, task_id) if '.' in task_id: self.template_graph.add_edge(task_id, template_id) else: self.template_graph.add_edge(qualified_task_id, template_id) def resolve_task_graph(self, template_id): if template_id not in self.templates: raise KeyError(template_id) reverse_graph = self.template_graph.reverse() nodes = reverse_graph.bfs_walk_graph(template_id) for node in nodes: template = self.templates[node] for parent_node in reverse_graph[node]: inherited_params = self.template_parameters[parent_node] params = self.template_parameters[node] inherited_params.update(params) task_graph = self.template_graph.subgraph(nodes) for node in nodes: template = self.templates[node] params = self.template_parameters[node] task = template.resolve_task(params) task_graph.node[node]['task'] = task return task_graph
class GraphTest(unittest.TestCase): def setUp(self): self.graph = DirectedGraph() def test_add_edge(self): self.graph.add_edge('A', 'B') self.assertTrue(('A', 'B') in self.graph.edges) def test_get_neighbours(self): self.graph.add_edge('A', 'B') self.graph.add_edge('A', 'C') self.graph.add_edge('D', 'A') self.assertEqual(self.graph.get_neighbours('A'), {'B', 'C'}) def test_path_between(self): self.graph.add_edge('A', 'B') self.graph.add_edge('C', 'B') self.graph.add_edge('D', 'A') self.assertEqual(self.graph.path_between('D', 'B'), (True, 2)) self.assertEqual(self.graph.path_between('D', 'C'), (False, 0))
def load_linqs_data(content_file, cites_file): if not os.path.isfile(content_file): raise IOError('No content file') return if not os.path.isfile(cites_file): raise IOError('No cites file') return graph = DirectedGraph() domain_labels = [] content_file_reader = open(content_file, 'r') for line_str in content_file_reader: tokens = line_str.split('\t') node_id = tokens[0] feature_vector = tokens[1:-1] label = tokens[-1].strip() new_node = Node(node_id, feature_vector, label) graph.add_node(new_node) domain_labels.append(tokens[-1].strip()) cites_file_reader = open(cites_file, 'r') citations = dict() for line in cites_file_reader: tokens2 = line.split('\t') from_node = tokens2[1].strip() to_node = tokens2[0].strip() endge = Edge(from_node, to_node) graph.add_edge(endge) return graph, set(domain_labels)
class GraphTests(unittest.TestCase): def setUp(self): self.graph = DirectedGraph() def test_add_node(self): self.graph.add_node("Rado") self.assertTrue(self.graph.has_node("Rado")) def test_add_edge(self): self.graph.add_edge("Rado", "Ivo") self.assertEqual(self.graph.info, {"Rado": ["Ivo"], "Ivo": []}) def test_get_neighbors_for(self): self.graph.add_edge("Rado", "Gosho") self.assertEqual(self.graph.get_neighbors_for("Rado"), ["Gosho"]) def test_path_between(self): self.graph.add_edge("Rado", "Gosho") self.graph.add_edge("Rado", "Ani") self.graph.add_edge("Gosho", "Ivo") self.assertTrue(self.graph.path_between("Rado", "Ani")) self.assertFalse(self.graph.path_between("Ani", "Ivo")) self.assertTrue(self.graph.path_between("Rado", "Ivo"))
class GitHubNetwork: def __init__(self, username, depth): self.username = username self.depth = depth self.request = requests.get( 'https://api.github.com/users/' + self.username + '/followers') self.social_graph = DirectedGraph() def following(self): request_json = self.request.json() for each_person in request_json: self.social_graph.add_edge(self.username, each_person['login']) return self.social_graph.nodes def is_following(self, user): if self.social_graph.path_between(self.username, user): return True return False def steps_to(self, username): pass
def test_path_between_true(self): newGraph = DirectedGraph() newGraph.add_edge("1", "2") newGraph.add_edge("2", "3") newGraph.add_edge("3", "4") self.assertTrue(newGraph.path_between("1", "4"))
def test_addEdge_two_node_not_exists(self): newGraph = DirectedGraph() newGraph.add_edge("1", "2") self.assertTrue(("1", "2") in newGraph.links) self.assertTrue("1" in newGraph.nodes) self.assertTrue("2" in newGraph.nodes)
def test_addEdge_one_node_not_exist(self): newGraph = DirectedGraph() newGraph.nodes.append("1") newGraph.add_edge("1", "2") self.assertTrue(("1", "2") in newGraph.links) print(newGraph)
def test_get_neighbours_for_not_empty(self): newGraph = DirectedGraph() newGraph.add_edge("1", "2") newGraph.add_edge("1", "3") self.assertEqual(["2", "3"], newGraph.get_neighbours_for("1"))
def main(): n = 10 edges = [((1, 2), 5)] g = DirectedGraph() for i in range(9): g.add_vertex(i) g.add_edge(0, 1, 4) g.add_edge(0, 7, 8) g.add_edge(1, 2, 8) g.add_edge(1, 7, 11) g.add_edge(2, 3, 7) g.add_edge(2, 8, 2) g.add_edge(2, 5, 4) g.add_edge(3, 4, 9) g.add_edge(3, 5, 14) g.add_edge(4, 5, 10) g.add_edge(5, 6, 2) g.add_edge(6, 7, 1) g.add_edge(6, 8, 6) g.add_edge(7, 8, 7) print(bidirectional(g, 0, 8))
class TestGraph(unittest.TestCase): def setUp(self): self.my_graph = DirectedGraph() def test_init(self): self.assertEqual(self.my_graph.nodes, {}) def test_add_edge(self): self.my_graph.add_edge("modzozo", "RadoRado") self.assertEqual(self.my_graph.nodes, {"modzozo": ["RadoRado"], "RadoRado": []}) def test_get_neighbours(self): self.my_graph.add_edge("modzozo", "RadoRado") self.my_graph.add_edge("modzozo", "mod") self.assertEqual(self.my_graph.get_neighbours_for("modzozo"), ["RadoRado", "mod"]) def test_path_between_true(self): self.my_graph.add_edge("modzozo", "RadoRado") self.my_graph.add_edge("modzozo", "mod") self.my_graph.add_edge("RadoRado", "Rado") self.my_graph.add_edge("Rado", "zozo") self.assertTrue(self.my_graph.path_between("modzozo", "zozo")) def test_path_between_false(self): self.my_graph.add_edge("modzozo", "RadoRado") self.my_graph.add_edge("modzozo", "mod") self.my_graph.add_edge("RadoRado", "Rado") self.my_graph.add_edge("Rado", "zozo") self.assertFalse(self.my_graph.path_between("Rado", "modzozo")) def test_path_between_cycle(self): self.my_graph.add_edge("modzozo", "RadoRado") self.my_graph.add_edge("modzozo", "mod") self.my_graph.add_edge("RadoRado", "Rado") self.my_graph.add_edge("Rado", "zozo") self.my_graph.add_edge("zozo", "modzozo") self.assertTrue(self.my_graph.path_between("modzozo", "zozo"))
def test_ford_fulkerson(): graph = DirectedGraph() graph.add_node('s') graph.add_node('a') graph.add_node('b') graph.add_node('c') graph.add_node('d') graph.add_node('t') graph.add_edge('s', 'a', 10) graph.add_edge('s', 'c', 10) graph.add_edge('a', 'b', 4) graph.add_edge('a', 'c', 2) graph.add_edge('a', 'd', 8) graph.add_edge('b', 't', 10) graph.add_edge('c', 'd', 9) graph.add_edge('d', 'b', 6) graph.add_edge('d', 't', 10) flux = ford_fulkerson(graph, 's', 't') assert flux == 19, 'Flux expected was 19, found: {}'.format(flux)
class DirectedGraphTests(unittest.TestCase): def setUp(self): self.graph = DirectedGraph() def test_add_edge_non_existing_nodes(self): self.graph.add_edge("Ionko", "Dingo") self.assertEqual(self.graph.nodes, {"Ionko": ["Dingo"], "Dingo": []}) def test_add_edge_only_one_existing_node(self): self.graph.add_edge("Ionko", "Dingo") self.graph.add_edge("Dingo", "Penka") self.assertEqual(self.graph.nodes, { "Ionko": ["Dingo"], "Dingo": ["Penka"], "Penka": [] }) def test_add_edge_existing_nodes(self): self.graph.add_edge("Ionko", "Dingo") self.graph.add_edge("Dingo", "Ionko") self.assertEqual(self.graph.nodes, { "Ionko": ["Dingo"], "Dingo": ["Ionko"] }) def test_get_neighbours_for_existing_nodes(self): self.graph.add_edge("Ionko", "Dingo") self.assertEqual(self.graph.get_neighbours_for("Ionko"), ["Dingo"]) def test_get_neighbours_for_non_existing_nodes(self): self.assertEqual(self.graph.get_neighbours_for("ASDF"), []) def test_path_between_direct_neighbours(self): self.graph.add_edge("Ionko", "Dingo") self.assertTrue(self.graph.path_between("Ionko", "Dingo")) self.assertFalse(self.graph.path_between("Dingo", "Ionko")) def test_path_between_cyclic_neighbours(self): self.graph.add_edge("1", "2") self.graph.add_edge("2", "3") self.graph.add_edge("2", "4") self.graph.add_edge("4", "5") self.graph.add_edge("4", "6") self.graph.add_edge("3", "2") self.assertTrue(self.graph.path_between("2", "6")) self.assertFalse(self.graph.path_between("6", "2")) def test_path_between_indirect_neighbours(self): self.graph.add_edge("1", "2") self.graph.add_edge("2", "3") self.graph.add_edge("2", "4") self.graph.add_edge("4", "5") self.graph.add_edge("4", "6") self.assertTrue(self.graph.path_between("1", "6")) self.assertFalse(self.graph.path_between("6", "5"))
def test_ford_fulkerson_multiple_sources_two_sources_with_limit(): graph = DirectedGraph() graph.add_node('s') graph.add_node('s2') graph.add_node('a') graph.add_node('b') graph.add_node('c') graph.add_node('d') graph.add_node('t') graph.add_edge('s', 'a', 10) graph.add_edge('s', 'c', 10) graph.add_edge('a', 'b', 4) graph.add_edge('a', 'c', 2) graph.add_edge('a', 'd', 8) graph.add_edge('b', 't', 10) graph.add_edge('c', 'd', 9) graph.add_edge('d', 'b', 6) graph.add_edge('d', 't', 10) graph.add_edge('s2', 'b', 5) sources_limit = {'s': 14, 's2': 1} flux = ford_fulkerson_multiple_sources_and_limits(graph, ['s', 's2'], 't', sources_limit) assert flux == 15, 'Flux expected was 15, found: {}'.format(flux)
def test_ford_fulkerson_multiple_sources_two_sources(): graph = DirectedGraph() graph.add_node('s') graph.add_node('s2') graph.add_node('a') graph.add_node('b') graph.add_node('c') graph.add_node('d') graph.add_node('t') graph.add_edge('s', 'a', 10) graph.add_edge('s', 'c', 10) graph.add_edge('a', 'b', 4) graph.add_edge('a', 'c', 2) graph.add_edge('a', 'd', 8) graph.add_edge('b', 't', 10) graph.add_edge('c', 'd', 9) graph.add_edge('d', 'b', 6) graph.add_edge('d', 't', 10) graph.add_edge('s2', 'b', 5) flux = ford_fulkerson_multiple_sources(graph, ['s', 's2'], 't') assert flux == 20, 'Flux expected was 19, found: {}'.format(flux)
class GraphTest (unittest.TestCase): def setUp(self): self.sample_graph = DirectedGraph() def test_graph_init(self): self.assertEqual(self.sample_graph.graph, {}) def test_add_edge(self): self.sample_graph.add_edge("A", "B") self.assertIn("A", self.sample_graph.graph) self.assertIn("B", self.sample_graph.graph["A"]) self.sample_graph.add_edge("A", "D") self.assertIn("A", self.sample_graph.graph) self.assertIn("D", self.sample_graph.graph["A"]) self.sample_graph.add_edge("B", "C") self.assertIn("A", self.sample_graph.graph) self.assertIn("B", self.sample_graph.graph["A"]) self.assertIn("B", self.sample_graph.graph) self.assertIn("C", self.sample_graph.graph["B"]) def test_get_neighbours_for(self): self.sample_graph.add_edge("A", "B") self.sample_graph.add_edge("A", "D") self.assertEqual(["B", "D"], self.sample_graph.get_neighbours_for("A")) def test_path_between(self): self.sample_graph.add_edge("A", "B") self.sample_graph.add_edge("B", "C") self.assertTrue(self.sample_graph.path_between("A", "C")) self.assertFalse(self.sample_graph.path_between("A", "D")) self.assertFalse(self.sample_graph.path_between("A", "E")) def test_to_str(self): self.sample_graph.add_edge("A", "B") self.assertEqual(self.sample_graph.to_str(), "A ---> ['B']")
class FileLoader(object): def __init__(self): self.walls = {} self.starts = [] self.goals = [] self.keys = [] self.max_cols = None self.max_rows = None self.undirected_graph = UndirectedGraph() self.directed_graph = DirectedGraph() self.distance_node = {} self.node_distance = {} def read_map(self, file_name): print 'Reading File' f = open(file_name, 'r') # Reading walls: [row, col, up, left, down, right] print '\t> Parsing walls' [self.max_rows, self.max_cols] = f.readline().split(' ') self.max_rows = int(self.max_rows) self.max_cols = int(self.max_cols) for i in range(0, self.max_rows*self.max_cols): data = f.readline().split(' ') print 'data: ', data data = map(int, data) self.walls[(data[0],data[1])] = (data[2],data[3],data[4], data[5]) # Reading starts print '\t> Parsing ', f.readline() MAX_START = int(f.readline()) for i in range(0, MAX_START): data = f.readline().split(' ') if data[2][0] == 'u': orientation = 0 elif data[2][0] == 'l': orientation = 1 elif data[2][0] == 'd': orientation = 2 else: orientation = 3 self.starts.append((int(data[0]),int(data[1]),orientation)) # Reading Goals print '\t> Parsing ', f.readline() MAX_GOALS = int(f.readline()) for i in range(0, MAX_GOALS): data = f.readline().split(' ') row = int(data[0]) col = int(data[1]) self.goals.append((row,col)) # Reading Keys print '\t> Parsing ', f.readline() MAX_KEYS = int(f.readline()) for i in range(0, MAX_KEYS): data = f.readline().split(' ') row = int(data[0]) col = int(data[1]) self.keys.append((row,col)) f.close() def generate_undirected_graph(self): orientations = [Orientation.up, Orientation.left, Orientation.down, Orientation.right] for w in self.walls.keys(): row = w[0] col = w[1] for o in orientations: self.undirected_graph.add_node((row,col,o)) self.undirected_graph.add_edge((row,col,Orientation.up), (row,col,Orientation.left)) self.undirected_graph.add_edge((row,col,Orientation.left), (row,col,Orientation.down)) self.undirected_graph.add_edge((row,col,Orientation.down), (row,col,Orientation.right)) self.undirected_graph.add_edge((row,col,Orientation.right), (row,col,Orientation.up)) for node, ws in self.walls.items(): if ws[0] == 0: self.undirected_graph.add_edge((node[0],node[1],Orientation.up), (node[0]+1,node[1],Orientation.up)) if ws[1] == 0: self.undirected_graph.add_edge((node[0],node[1],Orientation.left), (node[0],node[1]-1,Orientation.left)) if ws[2] == 0: self.undirected_graph.add_edge((node[0],node[1],Orientation.down), (node[0]-1,node[1],Orientation.down)) if ws[3] == 0: self.undirected_graph.add_edge((node[0],node[1],Orientation.right), (node[0],node[1]+1,Orientation.right)) def generate_directed_graph(self): orientations = [Orientation.up, Orientation.left, Orientation.down, Orientation.right] for w in self.walls.keys(): row = w[0] col = w[1] for o in orientations: self.directed_graph.add_node((row,col,o)) self.directed_graph.add_edge((row,col,Orientation.up), (row,col,Orientation.left)) self.directed_graph.add_edge((row,col,Orientation.left), (row,col,Orientation.up)) self.directed_graph.add_edge((row,col,Orientation.left), (row,col,Orientation.down)) self.directed_graph.add_edge((row,col,Orientation.down), (row,col,Orientation.left)) self.directed_graph.add_edge((row,col,Orientation.down), (row,col,Orientation.right)) self.directed_graph.add_edge((row,col,Orientation.right), (row,col,Orientation.down)) self.directed_graph.add_edge((row,col,Orientation.right), (row,col,Orientation.up)) self.directed_graph.add_edge((row,col,Orientation.up), (row,col,Orientation.right)) for node, ws in self.walls.items(): if ws[0] == 0: self.directed_graph.add_edge((node[0],node[1],Orientation.up), (node[0]+1,node[1],Orientation.up)) if ws[1] == 0: self.directed_graph.add_edge((node[0],node[1],Orientation.left), (node[0],node[1]-1,Orientation.left)) if ws[2] == 0: self.directed_graph.add_edge((node[0],node[1],Orientation.down), (node[0]-1,node[1],Orientation.down)) if ws[3] == 0: self.directed_graph.add_edge((node[0],node[1],Orientation.right), (node[0],node[1]+1,Orientation.right)) def estimate_distances(self): #print '> Exploring distances' nodes = self.undirected_graph.nodes for node in nodes: #print '\t>>Localization::estimate_distances Node ', node distance = 0 orientation = node[2] aux_node = node test_node = node while True: if orientation == Orientation.up: test_node = (aux_node[0] + 1, aux_node[1], aux_node[2]) elif orientation == Orientation.left: test_node = (aux_node[0], aux_node[1] - 1, aux_node[2]) elif orientation == Orientation.down: test_node = (aux_node[0] - 1, aux_node[1], aux_node[2]) elif orientation == Orientation.right: test_node = (aux_node[0], aux_node[1] + 1, aux_node[2]) if not test_node in self.undirected_graph.edges[aux_node]: #BUG break aux_node = test_node distance = distance + 1 self.distance_node.setdefault(distance, []) self.distance_node[distance].append(node) self.node_distance[node] = distance
class DirectedGraphTests(unittest.TestCase): def setUp(self): self.graph = DirectedGraph() def test_add_edge_non_existing_nodes(self): self.graph.add_edge("Ionko", "Dingo") self.assertEqual(self.graph.nodes, {"Ionko": ["Dingo"], "Dingo": []}) def test_add_edge_only_one_existing_node(self): self.graph.add_edge("Ionko", "Dingo") self.graph.add_edge("Dingo", "Penka") self.assertEqual(self.graph.nodes, {"Ionko": ["Dingo"], "Dingo": ["Penka"], "Penka": []}) def test_add_edge_existing_nodes(self): self.graph.add_edge("Ionko", "Dingo") self.graph.add_edge("Dingo", "Ionko") self.assertEqual(self.graph.nodes, {"Ionko": ["Dingo"], "Dingo": ["Ionko"]}) def test_get_neighbours_for_existing_nodes(self): self.graph.add_edge("Ionko", "Dingo") self.assertEqual(self.graph.get_neighbours_for("Ionko"), ["Dingo"]) def test_get_neighbours_for_non_existing_nodes(self): self.assertEqual(self.graph.get_neighbours_for("ASDF"), []) def test_path_between_direct_neighbours(self): self.graph.add_edge("Ionko", "Dingo") self.assertTrue(self.graph.path_between("Ionko", "Dingo")) self.assertFalse(self.graph.path_between("Dingo", "Ionko")) def test_path_between_cyclic_neighbours(self): self.graph.add_edge("1", "2") self.graph.add_edge("2", "3") self.graph.add_edge("2", "4") self.graph.add_edge("4", "5") self.graph.add_edge("4", "6") self.graph.add_edge("3", "2") self.assertTrue(self.graph.path_between("2", "6")) self.assertFalse(self.graph.path_between("6", "2")) def test_path_between_indirect_neighbours(self): self.graph.add_edge("1", "2") self.graph.add_edge("2", "3") self.graph.add_edge("2", "4") self.graph.add_edge("4", "5") self.graph.add_edge("4", "6") self.assertTrue(self.graph.path_between("1", "6")) self.assertFalse(self.graph.path_between("6", "5"))
class GraphTest(unittest.TestCase): def setUp(self): self.sample_graph = DirectedGraph() def test_graph_init(self): self.assertEqual(self.sample_graph.graph, {}) def test_add_edge(self): self.sample_graph.add_edge("A", "B") self.assertIn("A", self.sample_graph.graph) self.assertIn("B", self.sample_graph.graph["A"]) self.sample_graph.add_edge("A", "D") self.assertIn("A", self.sample_graph.graph) self.assertIn("D", self.sample_graph.graph["A"]) self.sample_graph.add_edge("B", "C") self.assertIn("A", self.sample_graph.graph) self.assertIn("B", self.sample_graph.graph["A"]) self.assertIn("B", self.sample_graph.graph) self.assertIn("C", self.sample_graph.graph["B"]) def test_get_neighbours_for(self): self.sample_graph.add_edge("A", "B") self.sample_graph.add_edge("A", "D") self.assertEqual(["B", "D"], self.sample_graph.get_neighbours_for("A")) def test_path_between(self): self.sample_graph.add_edge("A", "B") self.sample_graph.add_edge("B", "C") self.assertTrue(self.sample_graph.path_between("A", "C")) self.assertFalse(self.sample_graph.path_between("A", "D")) self.assertFalse(self.sample_graph.path_between("A", "E")) def test_to_str(self): self.sample_graph.add_edge("A", "B") self.assertEqual(self.sample_graph.to_str(), "A ---> ['B']")
route.reverse() return route # Testing algorithm if __name__ == '__main__': import math sldist = lambda c1, c2: math.sqrt((c2[0] - c1[0])**2 + (c2[1] - c1[1])**2) g = DirectedGraph() g.add_node((0, 0)) g.add_node((1, 1)) g.add_node((1, 0)) g.add_node((0, 1)) g.add_node((2, 2)) g.add_edge((0, 0), (1, 1), 1.5) g.add_edge((0, 0), (0, 1), 1.2) g.add_edge((0, 0), (1, 0), 1) g.add_edge((1, 0), (2, 2), 2) g.add_edge((0, 1), (2, 2), 2) g.add_edge((1, 1), (2, 2), 1.5) assert shortest_path(g, (0, 0), (2, 2), sldist) == [(0, 0), (1, 1), (2, 2)] g.distances[((0, 0), (1, 1))] = 2 g.distances[((1, 1), (0, 0))] = 2 assert shortest_path(g, (0, 0), (2, 2), sldist) == [(0, 0), (1, 0), (2, 2)] g.distances[((0, 0), (1, 0))] = 1.3 g.distances[((1, 0), (0, 0))] = 1.3
def main(): g = DirectedGraph() for i in range(9): g.add_vertex(i) g.add_edge(0, 1, 4) g.add_edge(0, 7, 8) g.add_edge(1, 2, 8) g.add_edge(1, 7, 11) g.add_edge(2, 3, 7) g.add_edge(2, 8, 2) g.add_edge(2, 5, 4) g.add_edge(3, 4, 9) g.add_edge(3, 5, 14) g.add_edge(4, 5, 10) g.add_edge(5, 6, 2) g.add_edge(6, 7, 1) g.add_edge(6, 8, 6) g.add_edge(7, 8, 7) print(g) prim(g)
class TestGraph(unittest.TestCase): def setUp(self): self.my_graph = DirectedGraph("My Graph") def test_init(self): self.assertEqual(self.my_graph.name, "My Graph") self.assertEqual(self.my_graph.edges, {}) def test_add_edge(self): self.my_graph.add_edge("Ivo", "Boqn") self.assertIn("Ivo", self.my_graph.edges.keys()) self.assertIn("Boqn", self.my_graph.edges["Ivo"]) def test_get_neighbors_for(self): self.my_graph.add_edge("Ivo", "Djihad") self.my_graph.add_edge("Ivo", "Ahmed") self.assertEqual(["Djihad", "Ahmed"], self.my_graph.get_neighbors_for("Ivo")) def test_str(self): self.my_graph.add_edge("Ivo", "Djihad") self.my_graph.add_edge("Ivo", "Ahmed") self.my_graph.__str__() def test_path_between(self): self.my_graph.add_edge("misho", 'pesho') self.my_graph.add_edge("pesho", 'mitko') self.my_graph.add_edge("mitko", 'stefcho') self.assertTrue(self.my_graph.path_between("misho", "stefcho"))