def main(script, n='5', *args): # create n Vertices n = int(n) #labels = string.ascii_lowercase + string.ascii_uppercase #vs = [Vertex(c) for c in labels[:n]] v = Vertex('v') v.pos = (1110,-100) w = Vertex('w') w.pos = (20000,40) x = Vertex('x') x.pos = (100,-2000) y = Vertex('y') y.pos = (-15,15000) # create a graph and a layout g = Graph([v, w, x, y]) g.add_all_edges() # layout = CircleLayout(g) # layout = RandomLayout(g) layout = CartesianLayout(g) # draw the graph gw = GraphWorld() gw.show_graph(g, layout) gw.mainloop()
def test_14_construct_from_csv(self): graph = Graph() # Empty csv graph.construct_from_csv('test1.csv') assert graph == Graph() # Varied, different edge weights graph.construct_from_csv('test2.csv') size = graph.size assert size == 3 e_subject = graph.get_edges() e_subject_set = set(e_subject) v_subject = graph.get_vertices() v_subject_set = set(v_subject) vertex_a = Vertex('a') vertex_b = Vertex('b') vertex_c = Vertex('c') vertex_b.adj['a'] = 2.0 vertex_b.adj['c'] = 3.0 vertex_c.adj['b'] = 1.0 vertex_a.adj['b'] = 1.0 v_solution_set = set([vertex_a, vertex_b, vertex_c]) e_solution_set = set([('a', 'b', 1.0), ('b', 'a', 2.0), ('c', 'b', 1.0), ('b', 'c', 3.0)]) assert e_subject_set == e_solution_set assert v_subject_set == v_solution_set
def test_08_add_to_graph(self): graph = Graph() # Test creation of single vertex graph.add_to_graph('a') size = graph.size assert size == 1 subject = graph.get_vertices() assert subject == [Vertex('a')] graph.add_to_graph('b') size = graph.size assert size == 2 subject = graph.get_vertices() subject_set = set(subject) solution_set = set([Vertex('a'), Vertex('b')]) assert subject_set == solution_set # Test creation of edge between existing vertices graph.add_to_graph('a', 'b', 331) size = graph.size assert size == 2 subject = graph.get_edges() assert subject == [('a', 'b', 331)] graph.add_to_graph('b', 'a', 1855) size = graph.size assert size == 2 subject = graph.get_edges() subject_set = set(subject) solution_set = set([('a', 'b', 331), ('b', 'a', 1855)]) assert subject_set == solution_set
def test_get_edge(self): graph = Graph() # (1) neither end vertex exists subject = graph.get_edge('a', 'b') self.assertIsNone(subject) # (2) one end vertex exists graph.vertices['a'] = Vertex('a') subject = graph.get_edge('a', 'b') self.assertIsNone(subject) # (3) both end vertices exist, but no edge graph.vertices['a'] = Vertex('a') graph.vertices['b'] = Vertex('b') subject = graph.get_edge('a', 'b') self.assertIsNone(subject) # (4) a -> b exists but b -> a does not graph.vertices.get('a').adj['b'] = 331 subject = graph.get_edge('a', 'b') self.assertEqual(subject, ('a', 'b', 331)) subject = graph.get_edge('b', 'a') self.assertIsNone(subject) # (5) connect all vertices to center vertex and return all edges graph.vertices['$'] = Vertex('$') for i, char in enumerate(string.ascii_lowercase): graph.vertices[char] = Vertex(char) graph.vertices.get('$').adj[char] = i for i, char in enumerate(string.ascii_lowercase): subject = graph.get_edge('$', char) self.assertEqual(subject, ('$', char, i))
def test_get_vertices(self): graph = Graph() solution = set() # (1) test empty graph subject = graph.get_vertices() self.assertEqual(subject, solution) # (2) test single vertex vertex = Vertex('$') graph.vertices['$'] = vertex solution.add(vertex) subject = graph.get_vertices() self.assertEqual(subject, solution) # (3) test multiple vertices graph = Graph() solution = set() for i, char in enumerate(string.ascii_lowercase): vertex = Vertex(char) graph.vertices[char] = vertex solution.add(vertex) subject = graph.get_vertices() self.assertEqual(subject, solution)
def get_test_graph(): """ Creates and returns a simple test graph :return: a Graph.py representation of a set graph """ one = Vertex(0, 0, 0) two = Vertex(1, 10, 2) one_two = Edge(one, two, 5) three = Vertex(2, 20, 65) two_three = Edge(two, three, 3) four = Vertex(3, 32, 30) one_four = Edge(one, four, 1) five = Vertex(4, 9, 40) four_five = Edge(four, five, 6) six = Vertex(5, 50, 44) four_six = Edge(four, six, 4) seven = Vertex(6, 60, 5) six_seven = Edge(six, seven, 9) eight = Vertex(7, 0, 70) five_eight = Edge(five, eight, 1) nine = Vertex(8, 9, 80) eight_nine = Edge(eight, nine, 3) three_nine = Edge(three, nine, 2) return Graph([ one_two, one_four, two_three, four_five, four_six, six_seven, five_eight, eight_nine, three_nine ])
def test_10_construct_from_matrix(self): graph = Graph() # Test empty matrix matrix = [[]] graph.construct_from_matrix(matrix) size = graph.size assert size == 0 v_subject = graph.get_vertices() e_subject = graph.get_edges() assert v_subject == [] assert e_subject == [] # Test single vertex with no connection matrix = [[None, 'a'], ['a', None]] graph.construct_from_matrix(matrix) size = graph.size assert size == 1 v_subject = graph.get_vertices() e_subject = graph.get_edges() assert v_subject == [Vertex('a')] assert e_subject == [] # Test single vertex with connection graph = Graph() matrix = [[None, 'a'], ['a', 331]] graph.construct_from_matrix(matrix) size = graph.size assert size == 1 e_subject = graph.get_edges() assert e_subject == [('a', 'a', 331)] # Test two vertices with no connection graph = Graph() matrix = [[None, 'a', 'b'], ['a', None, None], ['b', None, None]] graph.construct_from_matrix(matrix) size = graph.size assert size == 2 v_subject = graph.get_vertices() v_subject_set = set(v_subject) e_subject = graph.get_edges() assert v_subject_set == set([Vertex('a'), Vertex('b')]) assert e_subject == [] # Test two vertices with 2-way connection graph = Graph() matrix = [[None, 'a', 'b'], ['a', None, 100], ['b', 200, None]] graph.construct_from_matrix(matrix) size = graph.size assert size == 2 e_subject = graph.get_edges() e_subject_set = set(e_subject) assert e_subject_set == set([('a', 'b', 100), ('b', 'a', 200)])
def test_reset_vertices(self): graph = Graph() # (1) visit all vertices then reset graph.vertices['a'] = Vertex('a') graph.vertices['b'] = Vertex('b') for vertex in graph.vertices.values(): vertex.visited = True graph.reset_vertices() for vertex in graph.vertices.values(): self.assertFalse(vertex.visited)
def test_degree(self): # (1) test a-->b and a-->c vertex = Vertex('a') vertex.adj['b'] = 1 self.assertEqual(vertex.degree(), 1) vertex.adj['c'] = 3 assert vertex.degree() == 2 # (2) test a-->letter for all letters in alphabet vertex = Vertex('a') for i, char in enumerate(string.ascii_lowercase): self.assertEqual(vertex.degree(), i) vertex.adj[char] = i
def test_05_reset_vertices(self): graph = Graph() # Add and visit vertices graph.vertices['a'] = Vertex('a') graph.vertices['b'] = Vertex('b') for vertex in graph.vertices.values(): vertex.visit() # Reset graph and check graph.reset_vertices() for vertex in graph.vertices.values(): assert not vertex.visited
def main(script, n='1000', *args): # # create n Vertices # n = int(n) # labels = string.ascii_lowercase + string.ascii_uppercase # vs = [Vertex(c) for c in labels[:n]] # # # create a graph and a layout # g = RandomGraph(vs) # g.add_random_edges(0.015) # print g.is_connected() # layout = GraphWorld.CircleLayout(g) # # # draw the graph # gw = GraphWorld.GraphWorld() # gw.show_graph(g, layout) # gw.mainloop() for n in range(100, 10000, 1000): for p in range(1, 100): p = p / 100.0 success = 0 for each in range(1000): vs = [Vertex(str(c)) for c in range(n)] g = RandomGraph(vs) g.add_random_edges(p) success += g.is_connected() pct = float(success) / 1000 print 'N: %s\t\tp: %s\t\t pct connected: %s' % (n, p, pct)
def read_graph(vertex_file_path, adjacency_matrix=None): # Initialize list and index vertices = np.array([]) vertex_index = 0 # Try to open the file try: vertex_file = open(vertex_file_path, "r") # If successful, read each line of the file for line in vertex_file.readlines(): # once a first character digit is found, we've reached the data section if line[0].isdigit(): # split the line into index, x, and y values index, x, y = line.split(" ") # Create a vertex object out of these attributes and append it to the list of vertices vertices = np.concatenate( (vertices, Vertex(vertex_index, float(x), float(y))), axis=None) # Increment the vertex index by 1 vertex_index += 1 # When finished, close the file. finally: vertex_file.close() if adjacency_matrix is None: # Create a list of adjacent vertices for all vertices in the list for index, vertex in enumerate(vertices): vertex.adjacent_vertices = [ adjacent_vertex for adjacent_vertex in vertices if adjacent_vertex != vertex ] # Return the list of Vertex objects return vertices
def main(script, n='1000', k='10', *args): n = int(n) #number of vertices k = int(k) #number of edges in regular graph vertices = [Vertex(c) for c in range(n)] g = SmallWorldGraph(vertices) g.add_regular_edges(k) #regular graph's clustering coefficient and avg path length c_zero = g.clustering_coefficient() l_zero = g.average_path_length() print c_zero, l_zero f = open("plots/output.csv", "wb") print 'p\tC\tL' f.write('p,C(p)/C(0),L(p)/L(0)\n') #begin rewiring to tease out small-world network characteristics for log_exp in numpy.arange(-40, 1, 1): #incrementation scheme for logarithmic exponents g = SmallWorldGraph(vertices) g.add_regular_edges(k) p = numpy.power(10, log_exp/10.0) g.rewire(p) print '%s\t%s\t%s' % (p, g.clustering_coefficient()/c_zero, g.average_path_length()/l_zero) f.write('%s,%s,%s\n' % (p, g.clustering_coefficient()/c_zero, g.average_path_length()/l_zero)) f.close()
def main(): env = XYEnvironment(x_size=10, y_size=10, n_grid_x=30, n_grid_y=30) threat1 = GaussThreat(location=(2, 2), shape=(0.5, 0.5), intensity=5) threat2 = GaussThreat(location=(6, 5), shape=(1.0, 1.0), intensity=5) threat3 = GaussThreat(location=(8, 2), shape=(.25, .5), intensity=10) threats = [threat1, threat2, threat3] threat_field = GaussThreatField(threats=threats, offset=2) threat4 = GaussThreat(location=(2, 8), shape=(0.5, 0.5), intensity=5) threat_field.add_threat(threat4) env.add_threat_field(threat_field) print(env) node_list = {} for gridpt in range(env.n_grid): mx = gridpt % env.n_grid_x my = int(gridpt / env.n_grid_x) new_node = XYNode(node_id=gridpt) new_node.pos_x = mx * env.grid_sep_x new_node.pos_y = my * env.grid_sep_y node_list[gridpt] = new_node print(new_node) graph = Graph(env=env) graph.add_vertex(node_list[0]) start_vertex = graph.get_vertex(node_list[0]) print("Start vertex: ", start_vertex) neighbor_list = graph.env.get_neighbors(start_vertex.node) print("neighbor_list") print(neighbor_list) for nbr in neighbor_list: print(nbr) graph.add_edge(start_vertex.node, nbr, 1.0) for neighbor in start_vertex.neighbors: print(neighbor) print("Run A* search") goal_vertex = Vertex(node=node_list[env.n_grid - 1]) print(goal_vertex.node) goal_vertex_found = Astar(graph=graph, start_vertex=start_vertex, goal_vertex=goal_vertex) print(goal_vertex_found) path = [goal_vertex_found.node] reconstruct_path(goal_vertex_found, path) print("Path found :") for waypoint in path: print(waypoint) draw_threat_field(env=env, threat_field=threat_field) ax2 = draw_threat_field_2D(env=env, threat_field=threat_field) draw_path(ax=ax2, path=path) plt.show()
def makeGraph(n='52', k='5', p='0.1'): #create n Vertices n = int(n) k = int(k) p = float(p) names = name_generator() vs = [Vertex(names.next()) for c in range(n)] # create a graph g = SmallWorldGraph(vs, k, p) start = clock() g.char_length() charLength1 = clock() - start start = clock() g.char_length2() charLength2 = clock() - start start = clock() g.char_length3() charLength3 = clock() - start start = clock() g.char_length4() charLength4 = clock() - start return charLength1, charLength2, charLength3, charLength4
def make_helper(): if solvable(): queue = deque() queue.append(self.graph.V[0]) while self.graph.search_data(self.target) == -1: if self.graph.n_vertex >= 9**4: break vertex: Vertex = queue.popleft() for index in range( 4 ): # Generate all adjacent, and add the closest to the target to the queue neg: [int] = vertex.data.copy() pos: [int] = vertex.data.copy() neg[index] -= 1 normalize(neg) pos[index] += 1 normalize(pos) to_add: [[int]] = [neg, pos] for neighbor in to_add: if neighbor not in self.forbidden: existent = self.graph.search_data(neighbor) if existent == -1: addition_ver = Vertex(neighbor.copy()) self.graph.add_vertex(addition_ver) self.graph.add_edge(vertex, addition_ver) if self.graph.search_data( self.target) != -1: return queue.append(addition_ver) else: existent = self.graph.V[existent] self.graph.add_edge(vertex, existent)
def single_time_step(self): """ @Args: None @Returns: None Executes a single time step in a Barabasi-Albert Graph. """ w = Vertex(self.iter_labels.next()) self.add_vertex(w) #We add an equal number of in and out-arcs, so we need to check #if the number of arcs we add is even or odd if self.mo % 2 == 1: m = self.mo - 1 else: m = self.mo #Since the histograms contain more instances of vertices that are more #connected, if we randomly sample them, we'll get preferential #attachment. Adapted from the NetworkX implementation of #Barabasi-Albert graphs. for v in random.sample(self._node_in_histogram, m / 2): self.add_arc(Arc(w, v)) self._node_in_histogram.append(v) for v in random.sample(self._node_out_histogram, m / 2): self.add_arc(Arc(v, w)) self._node_in_histogram.append(w) self._node_out_histogram.append(v) #We've created a bunch of out arcs from our new vertex, #so we need to add those arcs to our histogram. self._node_out_histogram.extend([w for i in range(m / 2)])
def test_graph(self): v = Vertex('v') w = Vertex('w') self.assertEqual(repr(v), "Vertex('v')") e = Edge(v, w) self.assertEqual(repr(e), "Edge(Vertex('v'), Vertex('w'))") g = Graph([v, w], [e]) self.assertEqual( repr(g), "{Vertex('w'): {Vertex('v'): Edge(Vertex('v'), Vertex('w'))}, Vertex('v'): {Vertex('w'): Edge(Vertex('v'), Vertex('w'))}}" ) e2 = g.get_edge(v, w) self.assertEqual(e, e2) e3 = g.get_edge(v, v) self.assertEqual(e3, None) vs = [Vertex(c) for c in 'abcd'] g = Graph(vs) g.add_regular_edges(3) for v in g.vertices(): es = g.out_edges(v) self.assertEqual(len(es), 3) vs = g.out_vertices(v) self.assertEqual(len(vs), 3) g.remove_edge(Edge(Vertex('a'), Vertex('c'))) vs = g.vertices() self.assertEqual(len(vs), 4) es = g.edges() self.assertEqual(len(es), 5) g.add_all_edges() es = g.edges() self.assertEqual(len(es), 6) g2 = eval(repr(g)) self.assertEqual(g, g2)
def insertRecord( self, record ): # recieves a line of the text file and is used to build the graph tokens = record.split(',') # splits the line via the split method if len(tokens) != 6: # check regarding whether the line has 6 commas print('Incorrect Song Record') song = tokens[1] # assings the song artist = tokens[2] # assings the artist neighbors = tokens[5][:len(tokens[5]) - 1].split( ';') # via the split method again, it creates a # list of coArists AKA neighbors for i in range( 0, len(neighbors) ): # This for loop checks if an artist is listed in the list neighbors # this prevents repeated edges when creating the graph if artist in neighbors: neighbors.remove(artist) currentVert = None # inializion of the current vertice if artist in self.vertList: # checks if artist is in the the graph currentVert = self.vertList[ artist] # the vertice is set to the artist at that postion else: currentVert = Vertex(artist) # creation of vertex self.vertList[ artist] = currentVert # Vertex is conneccted to the node self.numVertices += 1 # number of vertices is incremented ## insert info for this artist arr = [] currentVert.addsong( song) # the song is added to the array of songs in the Graph file for nb in neighbors: # iterates through the array neigbors and connects the neighbors together bidirectionally nbVert = None if nb in self.vertList: nbVert = self.vertList[nb] else: nbVert = Vertex(nb) self.vertList[nb] = nbVert self.numVertices += 1 currentVert.addNeighbor(nbVert) nbVert.addNeighbor(currentVert)
def file_read(file_name): with open(file_name) as file: graph = {} line = int(file.readline()) for i in range(0, line): line = file.readline().replace("\n", "").split(" ") key = int(line[1]) value = int(line[0]) if key in graph: vertex = graph.get(key) vertex.add_vertex(value) graph[key] = vertex else: vertex = Vertex([value]) graph[key] = vertex if value not in graph: vertex = Vertex([]) graph[value] = vertex return graph
def add_prefer_vert(self, vid): vs = self.vertices() vert = Vertex(vid) self.add_vertex(vert) for v in vs: k_i = len(self[v]) if random.random() > k_i/float(self.sum_k): continue self.add_edge(Edge(vert, v)) self.sum_k += 1
def add_address(self, a): location_file = open('./files/addressIndex.csv', 'r') # open csv reader = csv.reader(location_file) # reader will be our csv reader for row in reader: if row[2] == a: location = Vertex(int(row[0]), row[1], row[2]) # create a new location/vertex map.add_vertex(location) # add that vertex to the map else: None
def test_distances(self): # (1) test pythagorean triple vertex_a = Vertex('a') vertex_b = Vertex('b', 3, 4) subject = vertex_a.euclidean_distance(vertex_b) self.assertEqual(subject, 5) subject = vertex_b.euclidean_distance(vertex_a) self.assertEqual(subject, 5) subject = vertex_a.taxicab_distance(vertex_b) self.assertEqual(subject, 7) subject = vertex_b.taxicab_distance(vertex_a) self.assertEqual(subject, 7) # (2) test linear difference vertex_a = Vertex('a') vertex_b = Vertex('b', 0, 10) subject = vertex_a.euclidean_distance(vertex_b) self.assertEqual(subject, 10) subject = vertex_b.euclidean_distance(vertex_a) self.assertEqual(subject, 10) subject = vertex_a.taxicab_distance(vertex_b) self.assertEqual(subject, 10) subject = vertex_b.taxicab_distance(vertex_a) self.assertEqual(subject, 10) # (3) test zero distance vertex_a = Vertex('a') vertex_b = Vertex('b') subject = vertex_a.euclidean_distance(vertex_b) self.assertEqual(subject, 0) subject = vertex_b.euclidean_distance(vertex_a) self.assertEqual(subject, 0) subject = vertex_a.taxicab_distance(vertex_b) self.assertEqual(subject, 0) subject = vertex_b.taxicab_distance(vertex_a) self.assertEqual(subject, 0) # (4) test floating point distance vertex_a = Vertex('a') vertex_b = Vertex('b', -5, 5) subject = vertex_a.euclidean_distance(vertex_b) self.assertAlmostEqual(subject, 5 * math.sqrt(2)) subject = vertex_b.euclidean_distance(vertex_a) self.assertAlmostEqual(subject, 5 * math.sqrt(2)) subject = vertex_a.taxicab_distance(vertex_b) self.assertEqual(subject, 10) subject = vertex_b.taxicab_distance(vertex_a) self.assertEqual(subject, 10)
def __init__(self, p, m_0, t): vs = [Vertex('v'+str(i)) for i in xrange(m_0)] RandomGraph.__init__(self, vs, p) self.sum_k = sum([len(self[v]) for v in self]) [self.add_prefer_vert(str(i+m_0)) for i in xrange(t)] self.assign_edge_lengths() self.clust = self.clustering_coefficient() self.length = self.average_length() self.avg_deg = self.average_degree()
def test_get_edges(self): graph = Graph() # (1) test empty graph subject = graph.get_edges() self.assertEqual(subject, set()) # (2) test graph with vertices but no edges graph.vertices['a'] = Vertex('a') graph.vertices['b'] = Vertex('b') subject = graph.get_edges() self.assertEqual(subject, set()) # (3) test graph with one edge graph.vertices.get('a').adj['b'] = 331 subject = graph.get_edges() self.assertEqual(subject, {('a', 'b', 331)}) # (4) test graph with two edges graph = Graph() graph.vertices['a'] = Vertex('a') graph.vertices['b'] = Vertex('b') graph.vertices.get('a').adj['b'] = 331 graph.vertices.get('b').adj['a'] = 1855 subject = graph.get_edges() solution = {('a', 'b', 331), ('b', 'a', 1855)} self.assertEqual(subject, solution) # (5) test entire alphabet graph graph = Graph() solution = set() for i, char in enumerate(string.ascii_lowercase): graph.vertices[char] = Vertex(char) for j, jar in enumerate(string.ascii_lowercase): if i != j: graph.vertices.get(char).adj[jar] = 26 * i + j solution.add((char, jar, 26 * i + j)) subject = graph.get_edges() self.assertEqual(subject, solution)
def __init__(self, N, k, beta): """ Creates a Watts-Strogatz Directed Graph starting with a k-regular graph with N vertices. Rewires the graph with probability beta. """ if k % 2 == 1: raise ValueError, 'k must be even' vs = [Vertex(str(i)) for i in range(N)] DirectedGraph.__init__(self, vs, []) self.add_regular_arcs(k) self.rewire(beta)
def test_get_vertex(self): graph = Graph() # (1) test basic vertex object vertex_a = Vertex('a') graph.vertices['a'] = vertex_a subject = graph.get_vertex('a') self.assertEqual(subject, vertex_a) # (2) test empty case subject = graph.get_vertex('b') self.assertIsNone(subject) # (3) test case with adjacencies vertex_b = Vertex('b') for i, char in enumerate(string.ascii_lowercase): vertex_b.adj[char] = i graph.vertices['b'] = vertex_b subject = graph.get_vertex('b') self.assertEqual(subject, vertex_b)
def AstarPath(env, start, goal): start_node = XYNode(0, *start) goal_node = XYNode(env.n_grid - 1, *goal) graph = Graph(env=env) graph.add_vertex(start_node) start_vertex = graph.get_vertex(start_node) goal_vertex = Vertex(node=goal_node) goal_vertex_found = Astar(graph, start_vertex, goal_vertex) path = [goal_vertex_found.node] reconstruct_path(goal_vertex_found, path) return path
def test_03_get_vertices(self): ### get_vertex ### graph = Graph() # Test basic vertex vertex_a = Vertex('a') graph.vertices['a'] = vertex_a subject = graph.get_vertex('a') assert subject == vertex_a ### get_vertices ### solution = [vertex_a] # Check with two vertices vertex = Vertex('$') graph.vertices['$'] = vertex solution.append(vertex) subject = graph.get_vertices() assert subject == solution
def test_get_edges_vertex(self): # (1) test a-->b and a-->c vertex = Vertex('a') solution = {('b', 1), ('c', 2)} vertex.adj['b'] = 1 vertex.adj['c'] = 2 subject = vertex.get_edges() self.assertEqual(subject, solution) # (2) test empty case vertex = Vertex('a') solution = set() subject = vertex.get_edges() self.assertEqual(subject, solution) # (3) test a-->letter for all letters in alphabet for i, char in enumerate(string.ascii_lowercase): vertex.adj[char] = i solution.add((char, i)) subject = vertex.get_edges() self.assertEqual(subject, solution)