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 test_initialization(self): """Test public methods on an empty union.""" # Create []. an_empty_graph = DirectedGraph() self.assertEqual(an_empty_graph.n_vertices(), 0) self.assertEqual(an_empty_graph.connected(0, 0), False) self.assertEqual(an_empty_graph.connected(0, 1), False) self.assertEqual(an_empty_graph.neighbors(0), set())
def load_board(cities_filename, routes_filename): board = DirectedGraph() cities: dict[str, City] = _resolve_cities(cities_filename) for city in cities: board.add_node(cities[city].get_name()) _resolve_routes(board, routes_filename) return board, cities
def test_linked_list(self): """Test public methods on a linked list.""" # Build a linked list: # 0 -> 1 -> 2 a_graph = DirectedGraph() a_graph.connect(0, 1) a_graph.connect(1, 2) # Sort. a_sorter = TopologicalSort(a_graph) sorted_vertices = a_sorter.sort() # Only one correct sequence. self.assertEqual(sorted_vertices, (2, 1, 0)) # Check the result using a graph.Reachability object. a_checker = Reachability(a_graph) self.assertTrue(self._sorted(sorted_vertices, a_checker))
def generate_rand_dawg(nchars, nwords, wordlenpdf=None): """ Generate a random DAWG whose word lengths are distributed by function wordlenpdf, using gnerate_rand_lexicon above. input: nchars: number of characters in lexicon nwords: number of words in lexicon wordlenpdf: a function """ rand_lex = generate_rand_lexicon(nchars, nwords, wordlenpdf) G = DirectedGraph() G.parselex(rand_lex) trie_to_dawg(G) return G
def __init__(self, vertex_nums: [int] = [], edges_to_add: [(int, int)] = [], course_list=[]): DirectedGraph.__init__(self, vertex_nums, edges_to_add) self.disjunctionCount = 0 for i in range(len(course_list)): self.add_vertex(i, course_list[i]) for i in range(len(course_list)): destination = self.get_vertex_by_data(course_list[i]) #print("Course = {}. Destination = {}".format(course_list[i], destination.get_data())) self.add_prerequisite_list_to_graph(course_list[i].prerequisites, destination, False)
def readFile(file): try: f = open(file, 'r') lines = f.readlines() mode = 'missing' vertices = [] arestas = [] arcos = [] for l in lines: if ('*vertices' in l): mode = 'vertices' elif ('*arcs' in l): mode = 'arcs' elif ('*edges' in l): mode = 'edges' else: if (mode == 'vertices'): vertices.append(l.replace('\n', '')) elif (mode == 'arcs'): arcos.append(l.replace('\n', '')) elif (mode == 'edges'): arestas.append(l.replace('\n', '')) if (mode == 'arcs'): return DirectedGraph(vertices, arcos) elif (mode == 'edges'): return NonDirectedGraph(vertices, arestas) finally: f.close()
def johnson(g, w): vertexes_g = g.get_v() edges_g = g.get_e() s = NameVertex('s') vertexes_g1 = [s] + vertexes_g edges_g1 = edges_g.copy() for vertex in vertexes_g: edges_g1.append(Edge(s, vertex, 0)) graph2 = DirectedGraph(vertexes_g1, edges_g1) if bellman_ford(graph2, w, s) == False: print("the in put graph contains a negative_weight cycle") else: h = dict() for vertex in vertexes_g1: h[vertex] = vertex.d def weight1(edge): return w(edge) + h[edge.u] - h[edge.v] n = len(vertexes_g) d = dict() for u in vertexes_g: dijkstra(g, weight1, u) d[u] = dict() for v in vertexes_g: d[u][v] = v.d + h[v] - h[u] return d
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 test_binary_tree(self): """Test public methods on a binary tree.""" # Build a binary tree: # 0 # / \ # 1 2 a_graph = DirectedGraph() a_graph.connect(0, 1) a_graph.connect(0, 2) # Sort. a_sorter = TopologicalSort(a_graph) sorted_vertices = a_sorter.sort() # Either of the two sequences is correct. self.assertTrue(sorted_vertices in {(2, 1, 0), (1, 2, 0)}) # Check the result using a graph.Reachability object. a_checker = Reachability(a_graph) self.assertTrue(self._sorted(sorted_vertices, a_checker))
def test_empty_graph(self): """Test public methods on an empty graph.""" # Build an empty graph. a_graph = DirectedGraph() checker = Reachability(a_graph) # Non-existing vertex is always NOT reachable. self.assertFalse(checker.has_path(0, 0)) self.assertFalse(checker.has_path(0, 1))
def test_neighbors(self): """Test root().""" # Create [{1, 2}, {2}, set()]. a_graph = DirectedGraph() a_graph.connect(0, 1) a_graph.connect(0, 2) a_graph.connect(1, 2) # Check neighbors on existing vertices. self.assertEqual(a_graph.neighbors(0), {1, 2}) self.assertEqual(a_graph.neighbors(1), {2}) self.assertEqual(a_graph.neighbors(2), set()) # Check neighbors on non-existing vertices. self.assertEqual(a_graph.neighbors(3), set()) self.assertEqual(a_graph.neighbors(4), set())
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
def test_traverse(self): vertexes_names = [] def traverse_visit_callback(vertex): vertexes_names.append(vertex.name) dg = DirectedGraph("A", "B", "C", "D") dg.add_new_edge("A", "B") dg.add_new_edge("B", "C") dg.add_new_edge("C", "D") # bfs dg.bfs_traverse("A", traverse_visit_callback) assert vertexes_names == ["A", "B", "C", "D"] vertexes_names = [] # dfs dg.dfs_traverse("A", traverse_visit_callback) assert vertexes_names == ["A", "B", "C", "D"]
def test_binary_tree(self): """Test public methods on a binary tree.""" # Build a binary tree: # 0 # / \ # 1 2 a_graph = DirectedGraph() a_graph.connect(0, 1) a_graph.connect(0, 2) checker = Reachability(a_graph) # All the vertices are reachable from the root. self.assertTrue(checker.has_path(0, 1)) self.assertTrue(checker.has_path(0, 2)) # Vertices in another subtree are NOT reachable. self.assertFalse(checker.has_path(1, 2)) self.assertFalse(checker.has_path(2, 1)) # Parent is NOT reachable. self.assertFalse(checker.has_path(1, 0)) self.assertFalse(checker.has_path(2, 0))
def test_implicit_adding_by_connecting(self): """Test connect(), which implicitly calls add().""" # Create []. a_graph = DirectedGraph() # Implicitly add 0, 1, 2 to [], then connect 1 with 2, # which makes [set(), {2}, set()]. a_graph.connect(1, 2) self.assertEqual(a_graph.n_vertices(), 3) # Trivially connected vertices. self.assertEqual(a_graph.connected(0, 0), True) self.assertEqual(a_graph.connected(1, 1), True) self.assertEqual(a_graph.connected(2, 2), True) # Uni-directional connection created by connect(). self.assertEqual(a_graph.connected(1, 2), True) self.assertEqual(a_graph.connected(2, 1), False) # Disconnected vertices. self.assertEqual(a_graph.connected(0, 1), False) self.assertEqual(a_graph.connected(1, 0), False) self.assertEqual(a_graph.connected(0, 2), False) self.assertEqual(a_graph.connected(2, 0), False)
class OpArgMngr(object): """Operator argument manager for storing operator workloads.""" graph = DirectedGraph() ops = {} @staticmethod def add_workload(funcname, *args, **kwargs): key = funcname + "." + str(int(time.time())) OpArgMngr.ops[key] = {'args': args, 'kwargs': kwargs, 'funcname': funcname} def add_assignment(variable, assigned_value):
def test_linked_list(self): """Test public methods on a linked list.""" # Build a linked list: # 0 -> 1 -> 2 a_graph = DirectedGraph() a_graph.connect(0, 1) a_graph.connect(1, 2) checker = Reachability(a_graph) # A vertex is always reachable from/to itself. self.assertTrue(checker.has_path(0, 0)) self.assertTrue(checker.has_path(1, 1)) self.assertTrue(checker.has_path(2, 2)) # A downstream vertex is reachable from an upstream vertex. self.assertTrue(checker.has_path(0, 1)) self.assertTrue(checker.has_path(1, 2)) self.assertTrue(checker.has_path(0, 2)) # A upstream vertex is NOT reachable from an downstream vertex. self.assertFalse(checker.has_path(1, 0)) self.assertFalse(checker.has_path(2, 0)) self.assertFalse(checker.has_path(2, 1))
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)
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
def test_non_consecutive_adding(self): """Test adding vertices non-consecutively.""" # Create []. a_graph = DirectedGraph() # Add 1 to [], which becomes [set(), set()]. # Here 0 is added implicitly. a_graph.add(1) self.assertEqual(a_graph.n_vertices(), 2) self.assertEqual(a_graph.connected(0, 0), True) self.assertEqual(a_graph.connected(0, 1), False) self.assertEqual(a_graph.connected(1, 1), True)
def make_graph(cls, root, strategy): """Compute the graph implied by some GameState.""" graph = DirectedGraph() queue = deque() visited = set() # Add root to queue visited.add(root) queue.append(root) while queue: node = queue.popleft() if not node.is_over: for next in strategy.get_next_states(node): graph.add_arc(node, next) if next not in visited: # Add `next` to queue. visited.add(next) queue.append(next) return graph
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 test_adjacency_matrix(self): dg = DirectedGraph("A", "B", "C", "D") dg.add_new_edge("A", "B") dg.add_new_edge("B", "C") dg.add_new_edge("C", "D") assert dg.adjacency_matrix == [[0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [0, 0, 0, 0]]
class Regex: symbols = { '?': zero_or_one, '*': zero_or_more, # Kleene star '+': one_or_more } def __init__(self, regex): self.regex = regex # Vertices labelled with booleans, edges labelled with character classes (sets of zero or more characters) self.graph = DirectedGraph() self.compile() def compile(self): pass def transition(self, state, char): # 0. Initialize a set of empty string transition destinations empty = set() # 1. Test all the non-empty string transitions #print(self.graph.edges[state]) for dest, label in self.graph.edges[state]: #print(char) #print(label) if char == label or char in label: return dest elif label == '': empty.add(dest) else: #print('Not found') return -1 # 2. Test all the empty string transitions else: destinations = [self.transition(dest, char) for dest in empty if dest >= 0] return destinations[0] if len(destinations) > 0 else -1 def match(self, string): state = 0 strindex = 0 # Negative state number means we've left the graph while strindex < len(string): char = string[strindex] #print('state %d' % state) next_state = self.transition(state, char) if next_state < 0: break else: state = next_state strindex += 1 return self.graph.vertex(state)
def __init__(self, dict_graph): self.graph = DirectedGraph(dict_graph) self.index = 0 self.stack = [] # Runs Tarjan # Set all node index to None for v in self.graph.nodes: v.index = None self.sccs = [] for v in self.graph.nodes: if v.index == None: self.strongconnect(v, self.sccs)
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
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
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
def trans_dc_to_graph_and_calc(dc): vertexes = [] temp_locals = locals() for i in range(dc.n + 1): vetex_name = 'v' + str(i) temp_locals[vetex_name] = NameVertex(vetex_name) vertexes.append(eval(vetex_name)) edges = [] for num in range(dc.m): i = a[num].index(-1) + 1 j = a[num].index(1) + 1 edge = Edge(eval('v' + str(i)), eval('v' + str(j)), b[num]) edges.append(edge) for num in range(1, dc.n + 1): edge = Edge(eval('v0'), eval('v' + str(num)), 0) edges.append(edge) graph1 = DirectedGraph(vertexes, edges) bf_result = bellman_ford(graph1, weight, eval('v0')) result = None if bf_result: result = [] for i in range(1, dc1.n + 1): result.append(getattr(eval('v' + str(i)), 'd')) return result
def __init__(self, config_path, transitions=None, emissions=None, start_id='B', end_id='E', convert_zero=0.000000000001): """ :param config_path: to initialize the model path, sample format is available in ../data/hmm.cfg :param transitions: a list of triplets (from_id, to_id, probability), where from_id and to_id are state labels :param emissions: a list of triplets (emitter_id, emission_id, probability), where emitter_id is a state label :param start_id: label for the initial state, (can not emit obs), used for getting the starting probabilities :param end_id: label for the final state (can not emit obs), only required for the simulations :param convert_zero: a small number to handle missing or zero entries in the emission and transition data, if convert_zero is 0 and there is a missing or zero entry in the probabilities, an exception will be raised """ self.graph = DirectedGraph(node_t=EmitterNode) self.emitters = [] self.convert_zero = convert_zero self.start_id = start_id self.end_id = end_id if isinstance(config_path, basestring): transitions, emissions = load_config(path=config_path) # load from data else: assert (transitions is not None and emissions is not None) self.set_transitions(transitions) # (re)init emitters here self.starting_ps = {child.id: w for [w, child] in self.graph.nodes[self.start_id].children.values()} self.set_emissions(emissions) self.update_emitters()
paths = astar(graph, initial_node, goal_node, h) route = [goal_node] while goal_node != initial_node: route.append(paths[goal_node]) goal_node = paths[goal_node] 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)]
""" Example Single Source Shortest Path. These are drawn from "Algorithms in a Nutshell (1ed)", pp. 154 and 155 Author: George Heineman """ from dijkstra import * from graph import DirectedGraph d = DirectedGraph() d.addEdge(0,1,2) d.addEdge(0,4,4) d.addEdge(1,2,3) d.addEdge(2,4,1) d.addEdge(2,3,5) d.addEdge(3,0,8) d.addEdge(4,3,7) print (d) dist = singleSourceShortest(d, 0) print (dist) d = DirectedGraph() d.addEdge(0,1,6) d.addEdge(0,3,18) d.addEdge(0,2,8) d.addEdge(1,4,11) d.addEdge(4,5,3) d.addEdge(2,3,9)
def write_link_graph(self, link_graph: graph.DirectedGraph) -> str: with open(self.link_graph_dot, "w") as output_stream: link_graph.write_dot(output_stream) return self.link_graph_dot
def setUp(self): self.graph = DirectedGraph()
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_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 setUp(self): self.my_graph = DirectedGraph("My 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 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
class HiddenMarkov(object): def __init__(self, config_path, transitions=None, emissions=None, start_id='B', end_id='E', convert_zero=0.000000000001): """ :param config_path: to initialize the model path, sample format is available in ../data/hmm.cfg :param transitions: a list of triplets (from_id, to_id, probability), where from_id and to_id are state labels :param emissions: a list of triplets (emitter_id, emission_id, probability), where emitter_id is a state label :param start_id: label for the initial state, (can not emit obs), used for getting the starting probabilities :param end_id: label for the final state (can not emit obs), only required for the simulations :param convert_zero: a small number to handle missing or zero entries in the emission and transition data, if convert_zero is 0 and there is a missing or zero entry in the probabilities, an exception will be raised """ self.graph = DirectedGraph(node_t=EmitterNode) self.emitters = [] self.convert_zero = convert_zero self.start_id = start_id self.end_id = end_id if isinstance(config_path, basestring): transitions, emissions = load_config(path=config_path) # load from data else: assert (transitions is not None and emissions is not None) self.set_transitions(transitions) # (re)init emitters here self.starting_ps = {child.id: w for [w, child] in self.graph.nodes[self.start_id].children.values()} self.set_emissions(emissions) self.update_emitters() def set_transitions(self, transitions): for from_id, to_id, p in transitions: log_p, converted = try_to_log(p, convert_zero=self.convert_zero) # use log probabilities if converted: self.graph.add_vertex(from_id, to_id, log_p) else: raise Exception("transition log probability conversion failed for %s" % str(p)) def update_emitters(self): self.emitters = [state for state_id, state in self.graph.nodes.items() if len(state.emission_ps.items()) != 0] # list of emitter nodes def set_emissions(self, emissions): for node_id, obs_id, p in emissions: log_p, converted = try_to_log(p, convert_zero=self.convert_zero) # use log probabilities if converted: if node_id in self.graph.nodes: self.graph.nodes[node_id].emission_ps[obs_id] = log_p else: raise Exception("emission log probability conversion failed for %s" % str(p)) def is_valid(self): valid = (self.emitters is not None and len(self.emitters) > 0 and self.starting_ps is not None and len( self.starting_ps) > 0) #print(self.emitters is not None, len(self.emitters) > 0, self.starting_ps is not None, len( # self.starting_ps) > 0) # valid = valid and other_checks() # Can do more checks here return valid def might_not_stop(self, stop_p=0.0000001): needy_nodes = set() end_id = self.end_id # end node for state in self.emitters: if end_id not in state.children or state.children[end_id][0] < stop_p: # need another node to end needy_nodes.add(state.id) for state_id in needy_nodes: all_needy = True for p, child in self.graph.nodes[state_id].children.values(): # if all kids are needy, then possible infinite loop if child.id not in needy_nodes: all_needy = False break if all_needy: return True return False def simulate(self, limit): if not self.is_valid(): logging.error("The model configuration is not valid, can not simulate..") if self.might_not_stop(): inp = raw_input("This simulation might get into an infinite loop, continue anyway? (y/n)") if inp.lower() != 'y': print("Smart choice!") return else: print("Alright, let's burn some cpu!") states = self.emitters p_ranges = [exp(self.starting_ps[s.id]) for s in states] ix = random_pick(p_ranges) print(ix) node = states[ix] emitted_seq = [] for i in range(limit): if node.id != self.end_id: e = node.emit() print(i, node.id, e) emitted_seq.append(e) else: break candidates = node.children.values() p_ranges = [exp(w) for w, _ in candidates] ix = random_pick(p_ranges) node = candidates[ix][1] return emitted_seq
return j + 1 if __name__ == "__main__": clothing = [ "undershorts", "pants", "belt", "shirt", "tie", "jacket", "socks", "shoes", "watch" ] vertexes = [] for cloth in clothing: temp_locals = locals() temp_locals[cloth] = NameVertex(cloth) vertexes.append(eval(cloth)) edges = [ Edge(undershorts, pants), Edge(undershorts, shoes), Edge(pants, belt), Edge(pants, shoes), Edge(belt, jacket), Edge(shirt, tie), Edge(shirt, belt), Edge(tie, jacket), Edge(socks, shoes) ] g = DirectedGraph(vertexes, edges) results = topological_sort(g) for result in results: #print(result.name, result.d, result.f) print(result.name, end=', ') print()
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"))
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 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
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 __init__(self, username, depth): self.username = username self.depth = depth self.graph = DirectedGraph() self.following_users = []
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"))
class TestGraph(unittest.TestCase): def setUp(self): self.my_graph = DirectedGraph() def test_init(self): self.assertEqual(self.my_graph.nodes, {}) def test_addEdge(self): self.my_graph.addEdge("Emil", "Galin") self.assertEqual(self.my_graph.nodes, {"Emil": ["Galin"], "Galin": []}) def test_getNEighbours(self): self.my_graph.addEdge("Emil", "Galin") self.my_graph.addEdge("Emil", "Pesho") self.my_graph.addEdge("Galin", "Atanas") self.my_graph.addEdge("Atanas", "Dimitrichka") self.assertEqual(self.my_graph.getNeighboursFor("Emil"), ["Galin", "Pesho"]) def test_pathBetween_true(self): self.my_graph.addEdge("Emil", "Galin") self.my_graph.addEdge("Emil", "Pesho") self.my_graph.addEdge("Galin", "Atanas") self.my_graph.addEdge("Atanas", "Dimitrichka") self.assertTrue(self.my_graph.pathBetween("Emil", "Dimitrichka")) def test_pathBetween_false(self): self.my_graph.addEdge("Emil", "Galin") self.my_graph.addEdge("Emil", "Pesho") self.my_graph.addEdge("Galin", "Atanas") self.my_graph.addEdge("Atanas", "Dimitrichka") self.assertFalse(self.my_graph.pathBetween("Atanas", "Emil")) def test_pathBetween_cycle(self): self.my_graph.addEdge("Emil", "Galin") self.my_graph.addEdge("Emil", "Pesho") self.my_graph.addEdge("Galin", "Atanas") self.my_graph.addEdge("Atanas", "Dimitrichka") self.my_graph.addEdge("Dimitrichka", "Emil") print(self.my_graph) self.assertTrue(self.my_graph.pathBetween("Emil", "Dimitrichka"))
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"))
def __init__(self, regex): self.regex = regex # Vertices labelled with booleans, edges labelled with character classes (sets of zero or more characters) self.graph = DirectedGraph() self.compile()
def test_graph(self): graph = DirectedGraph() graph.loadGraph1("graph2.txt") graph.deleteVertex(0) graph.writeGraph1("graph1.txt")
class Locator(object): def __init__(self, regions, outline=None): self.preprocess(regions, outline) def preprocess(self, regions, outline=None): def process_boundary(regions, outline=None): """ Adds an outer triangle and triangulates the interior region. If an outline for the region is not provided, uses the convex hull (thus assuming that the region itself is convex. Arguments: regions -- a set of non-overlapping polygons that tile some part of the plane outline -- the polygonal outline of regions Returns: a bounding triangle for regions and a triangulation for the area between regions and the bounding triangle. """ def add_bounding_triangle(poly): """ Calculates a bounding triangle for a polygon Arguments: poly -- a polygon to-be bound Returns: a bounding polygon for 'poly' """ bounding_tri = min_triangle.boundingTriangle(poly.points) bounding_regions = spatial.triangulatePolygon( bounding_tri, hole=poly.points) return bounding_tri, bounding_regions if not outline: points = reduce(lambda ps, r: ps + r.points, regions, []) outline = spatial.convexHull(points) return add_bounding_triangle(outline) def triangulate_regions(regions): """ Processes a set of regions (non-overlapping polygons tiling a portion of the plane), triangulating any region that is not already a triangle, and storing triangulated relationships in a DAG. Arguments: regions -- a set of non-overlapping polygons that tile some part of the plane Returns: a triangulation for each individual region in 'regions' """ frontier = [] for region in regions: self.dag.add_node(region) # If region is not a triangle, triangulate if region.n > 3: triangles = spatial.triangulatePolygon(region) for triangle in triangles: # Connect DAG self.dag.add_node(triangle) self.dag.connect(triangle, region) # Add to frontier frontier.append(triangle) else: frontier.append(region) return frontier def remove_independent_set(regions): """ Processes a set of regions, detecting and removing an independent set of vertices from the regions' graph representation, and re-triangulating the resulting holes. Arguments: regions -- a set of non-overlapping polygons that tile some part of the plane Returns: a new set of regions covering the same subset of the plane, with fewer vertices """ # Take note of which points are in which regions points_to_regions = {} for idx, region in enumerate(regions): for point in region.points: if point in points_to_regions: points_to_regions[point].add(idx) continue points_to_regions[point] = set([idx]) # Connect graph g = UndirectedGraph() for region in regions: for idx in range(region.n): u = region.points[idx % region.n] v = region.points[(idx + 1) % region.n] if not g.contains(u): g.add_node(u) if not g.contains(v): g.add_node(v) g.connect(u, v) # Avoid adding points from outer triangle removal = g.independent_set(8, avoid=bounding_triangle.points) # Track unaffected regions unaffected_regions = set([i for i in range(len(regions))]) new_regions = [] for p in removal: # Take note of affected regions affected_regions = points_to_regions[p] unaffected_regions.difference_update(points_to_regions[p]) def calculate_bounding_polygon(p, affected_regions): edges = [] point_locations = {} for j, i in enumerate(affected_regions): edge = set(regions[i].points) edge.remove(p) edges.append(edge) for v in edge: if v in point_locations: point_locations[v].add(j) else: point_locations[v] = set([j]) boundary = [] edge = edges.pop() for v in edge: point_locations[v].remove(len(edges)) boundary.append(v) for k in range(len(affected_regions) - 2): v = boundary[-1] i = point_locations[v].pop() edge = edges[i] edge.remove(v) u = edge.pop() point_locations[u].remove(i) boundary.append(u) return shapes.Polygon(boundary) # triangulate hole poly = calculate_bounding_polygon(p, affected_regions) triangles = spatial.triangulatePolygon(poly) for triangle in triangles: self.dag.add_node(triangle) for j in affected_regions: region = regions[j] self.dag.connect(triangle, region) new_regions.append(triangle) for i in unaffected_regions: new_regions.append(regions[i]) return new_regions self.dag = DirectedGraph() # Store copy of regions self.regions = regions # Calculate, triangulate bounding triangle bounding_triangle, boundary = process_boundary(regions, outline) # Store copy of boundary self.boundary = boundary # Iterate until only bounding triangle remains frontier = triangulate_regions(regions + boundary) while len(frontier) > 1: frontier = remove_independent_set(frontier) def locate(self, p): """Locates the point p in one of the initial regions""" polygon, valid = self.annotatedLocate(p) # Result might be valid polygon if not valid: return None return polygon def annotatedLocate(self, p): """ Locates the point p, returning the region and whether or not the region was one of the initial regions (i.e., False if the region was a fabricated boundary region). """ curr = self.dag.root() if not curr.contains(p): return None, False children = self.dag.e[curr] while children: for region in children: if region.contains(p): curr = region break children = self.dag.e[curr] # Is the final region an exterior region? return curr, curr in self.regions
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 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"))