def setUp(self): f = open('assets/data/map_data.json', 'r') decoded = json.loads(f.read()) self.g = graph.Graph() self.g.build_nodes(decoded['metros']) self.g.build_edges(decoded['routes']) self.utils = GraphUtils() f = open('assets/data/test1_map_data.json', 'r') decoded = json.loads(f.read()) self.gSmall = graph.Graph() self.gSmall.build_nodes(decoded['metros']) self.gSmall.build_edges(decoded['routes'])
def grow_a_graph(G, filename): G = graph.Graph() with open(filename, 'r') as gfile: lines = gfile.readlines() verts = lines[0].strip().split()[0] contents = [] for i in range(len(lines)): contents.append([int(n) for n in lines[i].strip().split()]) print contents[0:10] vert_objs = [] vert_objs.append(graph.Vertex(0)) #v0 used in BF print verts for i in range(1, int(verts) + 1): vert_objs.append(vertex.Vertex(i)) j = 1 #current vertex (assumes the input file is sorted by tail vertex) for i in range(1, len(contents)): if contents[i][0] == vert_objs[j].v_id: vert_objs[j].addedge( edge.Edge(vert_objs[j], vert_objs[contents[i][1]], int(contents[i][2]), int(contents[i][2]))) else: j += 1 vert_objs[j].addedge( edge.Edge(vert_objs[j], vert_objs[contents[i][1]], int(contents[i][2]), int(contents[i][2]))) return vert_objs
def Johnson(infile): g = graph.Graph() vs = grow_a_graph(g, infile) v0 = vertex.Vertex(0) ix = 0 for i in range(len(vs)): print ix ix += 1 v0.addedge(edge.Edge(v0, vs[i], 0, 0)) for e in v0.edges: print "v0 has edge to", e.v.v_id, " with len ", e.d vs = [v0] + vs[1:] for i in range(len(vs)): g.addvertices(vs[i]) p_v = Bellman_Ford(g, vs[0]) print p_v g.edges = g.edges[len(g.vertices[0].edges):] g.vertices = g.vertices[1:] #remove artificial zero vertex gw = re_weigh(g, p_v) for e in gw.edges: print e[0].v_id, "->", e[1].v_id, "was", e[3], "now is", e[2] results = [] for v in gw.vertices: gp = gw do_a_dijkstra(gp, v) gp = de_weigh(gp, p_v) results.append([v.value for v in gp.vertices]) print results print min([min(x) for x in results])
def test_graph_add_vertex(self): """--- shall add one vertex to empty graph ---""" graph = gr.Graph() vertex = vx.Vertex("vertex_id", "vertex_value") graph.add_vertex(vertex) self.assertTrue(graph.vertices is not None) self.assertTrue(len(graph.vertices) == 1)
def _preprocess_map(self): # create the area map self.area_map = area_map.AreaMap(self.raw_map, self.pass_test) # create the influence map self.influence_map = influence_map.InfluenceMap(self.area_map) # create the graph self.graph = graph.Graph(self.area_map, self.influence_map) # create shortest path search self.shortest_path = pf_shortest_path.ShortestPathSearch( self.graph, self.area_map, self.precomputed_hops)
def get_features(X, weight=1000): pixels = X g = graph.Graph(np.round(X)) nunreachable = g.pocet_nedosazitelnych(0) ret = np.zeros(weight) if (nunreachable != 0): # visualize_matrix(X) ret += 0 return ret
def test_three_node_graph(): g = graph.Graph() g.add_vertex('a') g.add_vertex('b') g.add_vertex('c') g.add_edge('a', 'b', '10') g.add_edge('a', 'c', '5') assert(g.get_vertex_count() == 3) assert(g.get_adjacent('a') == ['b','c']) assert(g.get_adjacent('b') == ['a']) assert(g.get_adjacent('c') == ['a'])
def testSave(self): self.utils.save_to_disk(self.g) f2 = open('assets/data/map_data_written.json', 'r') decoded = json.loads(f2.read()) self.g2 = graph.Graph() self.g2.build_nodes(decoded['metros']) self.g2.build_edges(decoded['routes']) self.utils = GraphUtils() assert (self.utils.longest_flight(self.g2) == ('SYD', 'LAX', 12051)) assert (self.utils.shortest_flight(self.g2) == ('NYC', 'WAS', 334)) assert (self.utils.average_distance(self.g2) == 2300) assert self.utils.biggest_city(self.g2) == ('TYO', 34000000) assert self.utils.smallest_city(self.g2) == ('ESS', 589900)
def test_all_paths(): g = graph.Graph() 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', 10) g.add_edge('a', 'c', 5) g.add_edge('b', 'c', 15) g.add_edge('c', 'd', 4) g.add_edge('b', 'e', 20) print(g.find_all_paths('a', 'b'))
def test_costs(): g = graph.Graph() 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', 10) g.add_edge('a', 'c', 5) g.add_edge('c', 'd', 21) g.add_edge('b', 'e', 32) g.add_edge('d', 'b', 10) d1= { 'a':20,'b':10,'c':21, 'd':0, 'e':42 } assert(g.shortest_path('d') == d1)
def test_graph(): g = graph.Graph() 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', 10) g.add_edge('a', 'c', 5) g.add_edge('b', 'c', 15) g.add_edge('c', 'd', 4) g.add_edge('b', 'e', 20) assert(g.get_vertex_count()== 5) assert(g.get_edge_cost('a', 'b') == 10) assert(g.get_edge_cost('b', 'e') == 20)
def create_graph(self, exclusion_criterion=None): states = OrderedSet() transitions = [] for trace in self.traces: for trans in trace.transitions: if exclusion_criterion is None or not exclusion_criterion.decide( trans): transitions.append(trans) # TODO maybe add only states that belong to a permitted transition for state in self.states: states.add(state) return graph.Graph(package_name=self.package_name, states=states, transitions=transitions, home_state=self.home_state)
def build_graph_from_vertices_edges(vertices, edges): g = graph.Graph() # 1. add all nodes and create mapping to 0 based index nodes vertex_ids = set([v.id for v in vertices]) id_mapper = dict(zip(vertex_ids, range(len(vertex_ids)))) for v in vertices: g.add_node(graph_types.Vertex(id_mapper[v.id], v.lat, v.lon)) # 2. add all edges that are valid new_edges = [ copy.deepcopy(e) for e in edges if e.s in vertex_ids and e.t in vertex_ids ] for e in new_edges: e.s = id_mapper[e.s] e.t = id_mapper[e.t] g.add_edge(e) return g
def build_graph_from_osm(nodes, ways): assert isinstance(nodes, dict) assert isinstance(ways, list) g = graph.Graph() # 1. add all nodes and create mapping to 0 based index nodes node_ids = nodes.keys() id_mapper = dict(zip(node_ids, range(len(node_ids)))) for n in nodes.values(): g.add_node(graph_types.Vertex(id_mapper[n.osm_id], n.lat, n.lon)) # 2. go through all ways and add edges accordingly for w in ways: for i in range(len(w.nodes) - 1): s_id, t_id = id_mapper[w.nodes[i]], id_mapper[w.nodes[i + 1]] s, t = g.vertices[s_id], g.vertices[t_id] length = geo_tools.distance(s.lat, s.lon, t.lat, t.lon) edge = graph_types.Edge(s_id, t_id, length, w.highway, w.max_speed, w.forward, w.backward, w.name) g.add_edge(edge) return g
import graph.graph as g # file = 'email-Eu-core' file = 'com-amazon.ungraph' graph = g.Graph(file) # print(str(graph.neighbor_of_node(0))) # print(str(graph.get_degree_of_node(0))) # Analyzing # degree_distribution = graph.get_degree_distribution() # print('Degree Distribution <degree>:<probability> = ' + str(degree_distribution)) # clustering_coefficient = graph.get_clustering_coefficient() # print('Clustering coefficient' + str(clustering_coefficient)) # degree_analyzer.plot_store_degree_distribution_log_log(file, degree_distribution) # degree_analyzer.plot_store_degree_distribution(file, degree_distribution) # clustering_analyzer.plot_store_clustering_coefficient_log_log(file, clustering_coefficient, node_degree) # clustering_analyzer.plot_store_clustering_coefficient(file, clustering_coefficient, node_degree, ) print(str(graph.get_degree_correlation())) graph.plot_store_degree_correlation()
for v in G.vertices: if v == root: continue v.value = float('inf') h.insert(v) while len(h.nodes) > 1: m = h.extractmin() ##Only works for directed graphs, otherwise would have to match for E in m.edges: if (E.v in h.nodes) and E.v.value > m.value + E.d: E.v.value = m.value + E.d h.check_parent(h.nodes.index(E.v)) print ".", g1 = graph.Graph() g2 = graph.Graph() vs = grow_a_graph(g1, "/home/apmechev/MOOCS/Algo2/s4/g1.txt") #vs=grow_a_graph(g1,"test.txt") g1.addvertices(vertex.Vertex(0)) for i in range(1, len(vs)): g1.addvertices(vs[i]) v0 = vertex.Vertex(0) v1 = vertex.Vertex(1) v2 = vertex.Vertex(2) v3 = vertex.Vertex(3) v4 = vertex.Vertex(4) v5 = vertex.Vertex(5) v6 = vertex.Vertex(6) v7 = vertex.Vertex(7)
def re_weigh(g, p_v): gp = graph.Graph() for e in g.edges: e[2] = e[3] + p_v[e[0].v_id] - p_v[e[1].v_id] return g
from graph.interface_pb2 import InterfaceType from icmplib import ping from tcolorpy import tcolor def exit_if_none(obj, msg): if obj is None: print(msg) sys.exit(0) parser = argparse.ArgumentParser(description="Ping test midgress address reachability") parser.add_argument("server", type=str, help="The server name to query for") args = parser.parse_args() g = graph.Graph("api.subspace.com:443") # lookup server s = g.get_server(args.server) exit_if_none(s, f"Could not find server {args.server}") p = g.get_pop(s.pop_id) ifaces = g.list_interfaces_by_field(field="pop_bpf_id", value=str(s.pop_bpf_id)) print("\nTesting midgress reachability for:\n") print(f"pop {p.name} {p.graph_id}") print(f"svr {s.name} {s.guid} {s.pop_id} {s.pop_bpf_id}") for iface in ifaces: if not iface.type == InterfaceType.TRANSIT:
def test_empty_graph(): g = graph.Graph() assert(g.get_vertex_count() == 0)
def test_graph_instantiation(self): """--- shall create valid graph instance ---""" graph = gr.Graph() self.assertTrue(graph.vertices is not None) self.assertTrue(graph.edges is not None)
from graph import graph ''' 5 bits per gene: b0b1b2: directional movement b3: move up in z if 1 b4: move down in zif 1 if b3 == 0 and b4 == 0: stay on same level if b3 == 1 and b4 == 1: invalid gene, remove generate N * M genes per chromosome (size of map) ''' geneSet = " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!.," target = "Hi, my name is Jake Si! I like apples." test_map = graph.Graph() class Chromosome: def __init__(self, gene, length, generation=0): self.gene = gene self.fitness = Chromosome.update_fitness(gene, length) self.generation = generation self.length = length def getGeneAtIndex(self, index): return int(self.gene[2 * index] + self.gene[2 * index + 1]) def replaceGeneAtIndex(self, index, n): strN = str(n) if n < 10:
def empty_graph(): return graph.Graph()
def show_recovered(): filename = "recovered.png" graph = g.Graph() res = graph.graph_recovered() res.savefig(os.path.join(app.config["IMAGE"], filename)) return render_template("image.html", filename=filename)
def get_features(X, weight = 1000): pixels = X g = graph.Graph(np.round(X)) unreachable = g.pozice_nedosazitelnych(0) return unreachable