def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ digraph = Digraph() print("Loading map from file...") with open(map_filename, 'r') as file: for line in file: parts = line.split() src = Node(parts[0]) dest = Node(parts[1]) edge = WeightedEdge(src, dest, int(parts[2]), int(parts[3])) edge = WeightedEdge(src, dest, int(parts[2]), int(parts[3])) if not digraph.has_node(src): digraph.add_node(src) if not digraph.has_node(dest): digraph.add_node(dest) digraph.add_edge(edge) return digraph
def test_add_edge_to_nonexistent_node_raises(self): node_not_in_graph = Node('q') no_src = WeightedEdge(self.nb, node_not_in_graph, 5, 5) no_dest = WeightedEdge(node_not_in_graph, self.na, 5, 5) with self.assertRaises(ValueError): self.g.add_edge(no_src) with self.assertRaises(ValueError): self.g.add_edge(no_dest)
def setUp(self): # set up nodes self.na = Node('a') self.nb = Node('b') self.nc = Node('c') # set up weighted edges self.e1 = WeightedEdge(self.na, self.nb, 15, 10) self.e2 = WeightedEdge(self.na, self.nc, 14, 6) self.e3 = WeightedEdge(self.nb, self.nc, 3, 1) self.print_strings = ["a->b (15, 10)", 'a->c (14, 6)', 'b->c (3, 1)']
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ # TODO # print("Loading map from file...") file = open(map_filename, 'r') # open the file g = Digraph() for line in file: # read each line of the file line = line.strip('\n') # remove the \n character line = line.split(' ') for i in range(0, 2): nod = Node(line[i]) if not g.has_node(nod): g.add_node(nod) wei_edge = WeightedEdge(Node(line[0]), Node(line[1]), int(line[2]), int(line[3])) g.add_edge(wei_edge) file.close() return g
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ # read map-file mapFile = open(map_filename, "r") mitGraph = Digraph() nodeMap = dict() # each entry for line in mapFile: # [src, dest, total dist, outdoot dist] info = line.strip("\n").split(" ") for i in range(2): if not info[i] in nodeMap: thisNode = Node(info[i]) mitGraph.add_node(thisNode) nodeMap[info[i]] = thisNode mitGraph.add_edge( WeightedEdge(nodeMap[info[0]], nodeMap[info[1]], int(info[2]), int(info[3])) ) return mitGraph
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("Loading map from file...") # MY_CODE map_graph = Digraph() with open(map_filename, 'r') as f: for line in f: src, dest, total_dist, outdoor_dist = line.split(' ') src = Node(src) dest = Node(dest) if not map_graph.has_node(src): map_graph.add_node(src) if not map_graph.has_node(dest): map_graph.add_node(dest) edge = WeightedEdge(src, dest, int(total_dist), int(outdoor_dist)) map_graph.add_edge(edge) return map_graph
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ # print("Loading map from file...") inFile = open(map_filename, 'r') graph = Digraph() for line in inFile: linedata = line.split(' ') scr = Node(linedata[0]) des = Node(linedata[1]) graph.nodes.add(scr) graph.nodes.add(des) if not scr in graph.edges: graph.add_node(scr) if not des in graph.edges: graph.add_node(des) edge = WeightedEdge(scr, des, int(linedata[2]), int(linedata[3])) graph.add_edge(edge) return graph
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ g = Digraph() with open(map_filename) as f: data = f.read().strip() dataList = data.split('\n') for mapEdge in dataList: edgeList = mapEdge.split(' ') # from to TD, DO fromN = Node(edgeList[0]) toN = Node(edgeList[1]) if not g.has_node(fromN): g.add_node(fromN) if not g.has_node(toN): g.add_node(toN) g.add_edge(WeightedEdge(fromN, toN, edgeList[2], edgeList[3])) return g
def JohnsonAlgorithm(graph: WeightedDirectedGraph, verbose=True): graph_edges_with_extra_node = graph.edges + [ WeightedEdge('new_node', 0, node) for node in graph.nodes ] graph_with_extra_node = WeightedDirectedGraph( graph_edges_with_extra_node.copy()) try: bf_shortest_distances, predecessors = BellmanFord( graph_with_extra_node, 'new_node', verbose=False) except Exception as e: return str(e) for edge in graph.edges: edge.weight = edge.weight + bf_shortest_distances[ edge.head] - bf_shortest_distances[edge.tail] all_pairs_shortest_distance = {} for source_node in graph.nodes: if verbose: print('\nShortest Distance with vertex ' + str(source_node) + ' as the source:\n') dijkstra_shortest_distances, predecessors = Dijkstra(graph, source_node, verbose=verbose) dijkstra_shortest_distances = { k: (v + bf_shortest_distances[k] - bf_shortest_distances[source_node]) for k, v in dijkstra_shortest_distances.items() } all_pairs_shortest_distance[source_node] = dijkstra_shortest_distances return all_pairs_shortest_distance
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("Loading map from file...") f=open(map_filename,'r') g=Digraph() for line in f: src, dest, total_distance, outdoor_distance = line.split() src_node=Node(src) dest_node=Node(dest) src_dest=WeightedEdge(src_node, dest_node, total_distance, outdoor_distance) if not g.has_node(src_node): g.add_node(src_node) if not g.has_node(dest_node): g.add_node(dest_node) g.add_edge(src_dest) f.close() return g
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("Loading map from file...") inFile = open(map_filename, 'r') digraph = Digraph() for line in inFile: mapEntry = line.split() #mapEntry(list) src = Node(mapEntry[0]) dest = Node(mapEntry[1]) total_distance = int(mapEntry[2]) outdoor_distance = int(mapEntry[3]) edge = WeightedEdge(src, dest, total_distance, outdoor_distance) if not digraph.has_node(src): digraph.add_node(src) if not digraph.has_node(dest): digraph.add_node(dest) digraph.add_edge(edge) return digraph
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ graph = Digraph() with open(map_filename) as file: for line in file.readlines(): el = line.strip('\n').split(' ') # Add nodes if they're not already in the graph for node in el[:2]: if not graph.has_node(node): graph.add_node(node) graph.add_edge(WeightedEdge(*el)) return graph
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ g = Digraph() # Create a digraph object print("Loading map from file...") with open(map_filename, "r") as f: for passage in f: # For each entry, store four info From, To, TotalD, OutD = passage.split() node_src, node_dest = Node(From), Node(To) if not g.has_node(node_src): g.add_node(node_src) if not g.has_node(node_dest): g.add_node(node_dest) g.add_edge( WeightedEdge(node_src, node_dest, int(TotalD), int(OutD))) return g
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("Loading map from file...") graph = Digraph() # 创建空图 with open(map_filename) as file: for line in file: elements = line.split() # 按空格分割成list src = Node(elements[0]) dest = Node(elements[1]) total_distance = int(elements[2]) # 数字类型 outdoor_distance = int(elements[3]) # 数字类型 if not graph.has_node(src): graph.add_node(src) if not graph.has_node(dest): graph.add_node(dest) graph.add_edge(WeightedEdge(src, dest, total_distance, outdoor_distance)) return graph
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("Loading map from file...") g = Digraph() with open(map_filename, "r") as file: for line in file: (src, dst, tot_dist, outdoor_dist) = line.split(' ') tot_dist = int(tot_dist) outdoor_dist = int(outdoor_dist) if not g.has_node(Node(src)): g.add_node(Node(src)) if not g.has_node(Node(dst)): g.add_node(Node(dst)) g.add_edge(WeightedEdge(src, dst, tot_dist, outdoor_dist)) return g
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ d = Digraph() with open(map_filename) as f: for line in f: data = line.split(' ') assert (len(data) == 4) src = Node(data[0]) dest = Node(data[1]) edge = WeightedEdge(src, dest, data[2], data[3]) if not d.has_node(src): d.add_node(src) if not d.has_node(dest): d.add_node(dest) d.add_edge(edge) f.close() return d
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("Loading map from file...") campus_map = Digraph() with open(map_filename, 'r') as file_handle: for line in file_handle: # 32 36 70 0 info = line.strip().split( ) # info = ["32","36","70","0"] strip返回一个去掉前后端的line的副本 from_node = Node(info[0]) to_node = Node(info[1]) if not campus_map.has_node(from_node): campus_map.add_node(from_node) if not campus_map.has_node(to_node): campus_map.add_node(to_node) cur_edge = WeightedEdge(from_node, to_node, int(info[2]), int(info[3])) # 假设cur_edge不存在重复的情况,也就是说mit_map.txt没有提供重复的数据 campus_map.add_edge(cur_edge) return campus_map
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ #print("Loading map from file...") campus_graph = Digraph() # 实例化Digraph with open(map_filename) as file_object: lines = file_object.readlines() for line in lines: list = line.split() if not campus_graph.has_node(Node(list[0])): campus_graph.add_node(Node(list[0])) # 若不在即加入 if not campus_graph.has_node(Node(list[1])): campus_graph.add_node(Node(list[1])) campus_graph.add_edge( WeightedEdge( # 将该边加入 Node(list[0]), Node(list[1]), list[2], list[3])) return campus_graph
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ digraph = Digraph() count = 0 with open(map_filename, 'r') as file: for line in file: line_list = line.split(' ') count += 1 src = Node(line_list[0]) dest = Node(line_list[1]) if not digraph.has_node(src): digraph.add_node(src) if not digraph.has_node(dest): digraph.add_node(dest) weighted_edge = WeightedEdge(src, dest, line_list[2], line_list[3]) digraph.add_edge(weighted_edge) return digraph
def load_map(mapFilename): """ Parses the map file and constructs a directed graph Parameters: mapFilename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a directed graph representing the map """ print "Loading map from file..." mitMap = WeightedDigraph() f = open('mit_map.txt', 'r') for l in f: line = l.split() mitMap.addNode(line[0]) mitMap.addNode(line[1]) newEdge = WeightedEdge(line[0], line[1], line[2], line[3]) mitMap.addEdge(newEdge) return mitMap
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("Loading map from file...") D = Digraph() with open(map_filename, 'r') as f: for count, line in enumerate(f): src, dest, total_dist, out_dist = line.split(' ') source = Node(src) destination = Node(dest) we = WeightedEdge(source, destination, total_dist, out_dist) D = _add_node(D, source, destination) D.add_edge(we) return D
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("Loading map from file...") graph = Digraph() f = open(map_filename, 'r') for line in f: line = line.split() src = Node(line[0]) dst = Node(line[1]) for node in [src, dst]: if not graph.has_node(node): graph.add_node(node) edge = WeightedEdge(src, dst, int(line[2]), int(line[3])) graph.add_edge(edge) f.close() return graph
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("\n\nLoading map from file...") g = Digraph() with open(map_filename) as file: for line in file: s, t, total, outdoor = line.split() s, t = map(Node, (s, t)) if not g.has_node(s): g.add_node(s) if not g.has_node(t): g.add_node(t) edge = WeightedEdge(s, t, *map(int, (total, outdoor))) g.add_edge(edge) return g
def buildGraph(mapEntries): g = Digraph() nodelist = [] #createing nodelist and adding nodes for eachEntry in mapEntries: eachEntrySource = eachEntry[0] eachEntryDest = eachEntry[1] if eachEntrySource not in nodelist: #making sure the node is unique nodelist.append(eachEntrySource) g.add_node(Node(eachEntrySource)) if eachEntryDest not in nodelist: nodelist.append(eachEntryDest) g.add_node(Node(eachEntryDest)) #creating edges for eachEntry in mapEntries: src = Node(eachEntry[0]) #eachEntrySource Node dest = Node(eachEntry[1]) #"eachEntryDest" tD = eachEntry[2] #eachEntryTotalDistance oD = eachEntry[3] #eachEntryOutdoorDistance g.add_edge(WeightedEdge(src, dest, tD, oD)) #Adding the weighted edge kind return g
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("Loading map from file...") openfile = open(map_filename, 'r') gph = Digraph() for line in openfile: NewLine = line.strip('\n').split(" ") a, b, c, d = NewLine a, b = Node(a), Node(b) c, d = int(c), int(d) if a not in gph.nodes: gph.add_node(a) if b not in gph.nodes: gph.add_node(b) DirEdge = WeightedEdge(a, b, c, d) gph.add_edge(DirEdge) openfile.close() return gph
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("Loading map from file...") graph = Digraph() with open(map_filename, 'r') as f1: list1 = f1.readlines() for item in list1: src, dest, total, outdoors = item[0:-1].split(' ') if (graph.has_node(Node(src)) == 0): graph.add_node(Node(src)) if (graph.has_node(Node(dest)) == 0): graph.add_node(Node(dest)) graph.add_edge(WeightedEdge(Node(src), Node(dest), total, outdoors)) # TODO return graph
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ # TODO print("Loading map from file...") f = open(map_filename) line_list = [] for line in f: clean_line = line.rstrip() line_list.append(clean_line) f.close() src_li = [] dest_li = [] weighted_edge_li = [] for string in line_list: param = string.split(' ') src_li.append(Node(param[0])) dest_li.append(Node(param[1])) edge = WeightedEdge(src_li[-1], dest_li[-1], int(param[2]), int(param[3])) weighted_edge_li.append(edge) map = Digraph() for i in range(len(src_li)): try: map.add_node(src_li[i]) map.add_node(dest_li[i]) except ValueError as error: print(error) continue # will go next iter of this for-loop directly, skipping any code below it for i in range(len(src_li)): try: map.add_edge(weighted_edge_li[i]) except ValueError as error1: print(error1) continue return map
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ # TODO print("Loading map from file...") # Format for the graph file: # Starting node, destination node, total weight of edge (distance), total distance spent outside # So steps: # 1. Create graph object # For every line: # 0. Save all numbers in variables (source, destination, total_distance, outdoor_distance) # 1. Create source_node object # 2.Create destination node object # 3. If graph has not(source_node) object: # add_node to graph # else get node from graph and save in src variable # Do the same for destination object # 4. Create weightedEdge object from variables and objects # 5. Add edge to graph # Problem 2c: Testing load_map # Include the lines used to test load_map below, but comment them out g = Digraph() with open(map_filename) as f: for line in f: input = line.split() source = input[0] destination = input[1] total_distance = input[2] outdoor_distance = input[3] src_object = Node(source) dest_object = Node(destination) if not (g.has_node(src_object)): g.add_node(src_object) if not (g.has_node(dest_object)): g.add_node(dest_object) edge_object = WeightedEdge(src_object, dest_object, total_distance, outdoor_distance) if edge_object not in g.get_edges_for_node(src_object): g.add_edge(edge_object) return g
def make_graph(som, values): """make graph from an iterable with vertices and their values edge weight between vertices with values a and b is defined as min(a, b) """ edges = set() for node, value in zip(som.nodes, values): if node.x < som.width - 1: node2 = som.node_at(node.x + 1, node.y) value2 = values[node2.n] edges.add(WeightedEdge(node, node2, min(value, value2))) if node.y < som.height - 1: node2 = som.node_at(node.x, node.y + 1) value2 = values[node2.n] edges.add(WeightedEdge(node, node2, min(value, value2))) return {'vertices': set(som.nodes), 'edges': edges}
def load_map(map_filename): """ Parses the map file and constructs a directed graph Parameters: map_filename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a Digraph representing the map """ print("Loading map from file...") # Open map_filename for reading and parse each line to get the edge parameters # Assumes map_filename is properly formatted newdigraph = Digraph() # Initialize new digraph with open(map_filename, mode='r') as fID: for tline in fID: # Split on space edge_params = tline.split(' ') # edge_params will have the following format: # edge_params[0]: Source Node, string # edge_params[1]: Destination Node, string # edge_params[2]: Total Distance, int # edge_params[3]: Distance Outdoors, int for idx, param in enumerate(edge_params): if idx < 2: # Node names, staying as strings. Strip newline edge_params[idx] = edge_params[idx].replace('/n', '') else: # Distances, cast as integers. This strips the newline edge_params[idx] = int(edge_params[idx]) # Check to see if our source node is in the digraph we're generating, # add if it's not if not newdigraph.has_node(edge_params[0]): newdigraph.add_node(edge_params[0]) # Check to see if our destination node is in the digraph we're # generating, add if it's not if not newdigraph.has_node(edge_params[1]): newdigraph.add_node(edge_params[1]) newdigraph.add_edge( WeightedEdge(edge_params[0], edge_params[1], edge_params[2], edge_params[3])) return newdigraph
def load_map(mapFilename): """ Parses the map file and constructs a directed graph Parameters: mapFilename : name of the map file Assumes: Each entry in the map file consists of the following four positive integers, separated by a blank space: From To TotalDistance DistanceOutdoors e.g. 32 76 54 23 This entry would become an edge from 32 to 76. Returns: a directed graph representing the map """ # TODO print "Loading map from file..." infile = open('./' + str(mapFilename), 'r') graph = WeightedDigraph() # add nodes for line in infile: # each line in file line = line.strip() # strip "\n" from line line = line.split(' ') node1, node2 = line[0], line[1] # take nodes #print node1, node2, type(node1), type(node2) try: graph.addNode(Node(node1)) # note: add a node, not a string! except ValueError as e: #node 1 already exist pass try: graph.addNode(Node(node2)) except ValueError as e: # node 2 already exist pass infile.close() # add edges infile = open('./' + str(mapFilename), 'r') for line in infile: # each line in file line = line.strip() # strip "\n" from line line = line.split(' ') node1, node2 = Node(line[0]), Node(line[1]) # take nodes totDist, outDist = int(line[2]), int(line[3]) edge = WeightedEdge(Node(node1), Node(node2), totDist, outDist) graph.addEdge(edge) return graph
class TestWeightedEdge(TestCase): def setUp(self): # set up nodes self.na = Node('a') self.nb = Node('b') self.nc = Node('c') # set up weighted edges self.e1 = WeightedEdge(self.na, self.nb, 15, 10) self.e2 = WeightedEdge(self.na, self.nc, 14, 6) self.e3 = WeightedEdge(self.nb, self.nc, 3, 1) self.print_strings = ["a->b (15, 10)", 'a->c (14, 6)', 'b->c (3, 1)'] def test_getTotalDistance(self): self.assertEqual(self.e1.getTotalDistance(), 15) self.assertEqual(self.e2.getTotalDistance(), 14) self.assertEqual(self.e3.getTotalDistance(), 3) e_instance = random.choice([self.e1, self.e2, self.e3]) self.assertIsInstance(e_instance.getTotalDistance(), int) def test_getOutdoorDistance(self): self.assertEqual(self.e1.getOutdoorDistance(), 10) self.assertEqual(self.e2.getOutdoorDistance(), 6) self.assertEqual(self.e3.getOutdoorDistance(), 1) e_instance = random.choice([self.e1, self.e2, self.e3]) self.assertIsInstance(e_instance.getOutdoorDistance(), int) def test___str__(self): self.assertEqual(str(self.e1), self.print_strings[0]) self.assertEqual(str(self.e2), self.print_strings[1]) self.assertEqual(str(self.e3), self.print_strings[2])
def setUp(self): # set up nodes self.na = Node('a') self.nb = Node('b') self.nc = Node('c') # set up weighted edges self.e1 = WeightedEdge(self.na, self.nb, 15, 10) self.e2 = WeightedEdge(self.na, self.nc, 14, 6) self.e3 = WeightedEdge(self.nb, self.nc, 3, 1) self.g = WeightedDigraph() self.g.addNode(self.na) self.g.addNode(self.nb) self.g.addNode(self.nc) self.g.addEdge(self.e1) self.g.addEdge(self.e2) self.g.addEdge(self.e3) self.print_strings = ["a->b (15.0, 10.0)", 'a->c (14.0, 6.0)', 'b->c (3.0, 1.0)']
class TestWeightedDigraph(TestCase): def setUp(self): # set up nodes self.na = Node('a') self.nb = Node('b') self.nc = Node('c') # set up weighted edges self.e1 = WeightedEdge(self.na, self.nb, 15, 10) self.e2 = WeightedEdge(self.na, self.nc, 14, 6) self.e3 = WeightedEdge(self.nb, self.nc, 3, 1) self.g = WeightedDigraph() self.g.addNode(self.na) self.g.addNode(self.nb) self.g.addNode(self.nc) self.g.addEdge(self.e1) self.g.addEdge(self.e2) self.g.addEdge(self.e3) self.print_strings = ["a->b (15.0, 10.0)", 'a->c (14.0, 6.0)', 'b->c (3.0, 1.0)'] def test_addEdge(self): self.assertEquals(self.g.hasNode(self.e1.getDestination()), True) self.assertEquals(self.g.hasNode(self.e1.getSource()), True) self.assertEquals(self.g.hasNode(self.e2.getDestination()), True) self.assertEquals(self.g.hasNode(self.e2.getSource()), True) self.assertEquals(self.g.hasNode(self.e3.getDestination()), True) self.assertEquals(self.g.hasNode(self.e3.getSource()), True) def test_childrenOf(self): for node in self.g.nodes: children = self.g.childrenOf(node) for child in children: self.assertIsInstance(child, Node) def test___str__(self): my_str = str(self.g) test_list = split(str(self.g), '\n') print('my_str is: {0}'.format(my_str)) print('test_list is: {0}'.format(test_list)) self.assertEqual(test_list[0], self.print_strings[0]) self.assertEqual(test_list[1], self.print_strings[1]) self.assertEqual(test_list[2], self.print_strings[2])