def failImpact(analyzer, landingPoint): # Se obtiene el id del landing point a partir de su nombre vertexId = me.getValue(mp.get(analyzer['landingPointNames'], landingPoint)) # Se obtiene la entrada del mapa para el landing point lp = me.getValue(mp.get(analyzer['landingPoints'], vertexId)) # Se obtiene el nombre del país del landing point que falla countryName = lp['country'] # Se obtienen los datos del país del landing point que falla country = me.getValue(mp.get(analyzer['countries'], countryName)) # Se crea un mapa para almacenar los nombres de los países que estan conectados al landing point que falla countries = mp.newMap(numelements=300, maptype='PROBING') # Se obtienen los vértices adyacentes para cada uno de los vertices del landing point for vertex in lt.iterator(lp['vertices']): # Los vertices adyacentes se almacenan en una lista adjVertices = gr.adjacents(analyzer['connections'], vertex) # Para cada vertice adyacente, se obtiene el país for adjVertex in lt.iterator(adjVertices): # Si el vertice adyacente corresponde al vertice de la ciudad capital, se intenta agregar el país actual if adjVertex == country['vertex']: # Se verifica que el país no exista en el listado de resultado if not mp.contains(countries, countryName): # Se obtiene el arco para poder saber la distancia y se agrega el pais al listado de resultado ctryEdge = gr.getEdge(analyzer['connections'], vertex, country['vertex']) mp.put(countries, countryName, ctryEdge['weight']) else: # Si el vertice no corresponde a un vertice de capital, se obtiene su id y luego su entrada en el mapa de landing points adjVertexId = adjVertex.split('-')[0] adjLP = me.getValue( mp.get(analyzer['landingPoints'], adjVertexId)) # Se verifica si el país del landing point adyacente ya existe en el listado, y si no, se agrega if not mp.contains(countries, adjLP['country']): adjEdge = gr.getEdge(analyzer['connections'], vertex, adjVertex) mp.put(countries, adjLP['country'], adjEdge['weight']) countriesList = mp.keySet(countries) # Se crea un mapa ordenado para el resultado result = om.newMap('BST') for ctry in lt.iterator(countriesList): distance = me.getValue(mp.get(countries, ctry)) if om.contains(result, distance): ctryList = me.getValue(om.get(result, distance)) lt.addLast(ctryList, ctry) else: newList = lt.newList('SINGLE_LINKED', compareCountries) lt.addLast(newList, ctry) om.put(result, distance, newList) return mp.size(countries), result
def getRoute(self, area1, area2) -> Route: if not self.containsArea(area1): graph.insertVertex(self.Routes, area1) if not self.containsArea(area2): graph.insertVertex(self.Routes, area2) route = graph.getEdge(self.Routes, area1, area2) if route is None: route = Route() graph.addEdge(self.Routes, area1, area2, route) route = graph.getEdge(self.Routes, area1, area2) return route['weight']
def addTrip(chicagoAnalyzer, origin, destiny, tripTime, idTrip): """ Crea el arco(camino) entre los dos vertices(el de origen y el de destino) """ edge = gr.getEdge(chicagoAnalyzer['communityTrip'], origin, destiny) if edge is None: gr.addEdge(chicagoAnalyzer['communityTrip'], origin, destiny, tripTime) edge = gr.getEdge(chicagoAnalyzer['communityTrip'], origin, destiny) m.put(chicagoAnalyzer['tripID_edge'], idTrip, edge) return chicagoAnalyzer
def addConnection(analyzer, origin, destination, duration): """ Adiciona un arco entre dos estaciones """ edge = gr.getEdge(analyzer['graph'], origin, destination) if edge is not None: edge['pesos'] += duration edge['size'] += 1 edge['weight'] = round((edge['pesos'] / edge['size']), 2) else: gr.addEdge(analyzer['graph'], origin, destination, duration) edge = gr.getEdge(analyzer['graph'], origin, destination) edge['pesos'] += duration edge['size'] += 1 edge['weight'] = round((edge['pesos'] / edge['size']), 2)
def updateRoute(trip: dict, DataBase: dict) -> None: startId = int(trip["start station id"]) endId = int(trip["end station id"]) tripTime = int(trip["tripduration"]) edgeRoute = graph.getEdge(DataBase['graph'], startId, endId) if edgeRoute is None: weight = Structure.newWeight() graph.addEdge(DataBase['graph'], startId, endId, weight) edgeRoute = graph.getEdge(DataBase['graph'], startId, endId) weight = edge.weight(edgeRoute) weight['time'] = aveTime(weight, tripTime) weight['users'] += 1
def addEdge(analyzer, originPoint, destinationPoint, distance): edge = gr.getEdge(analyzer['connections'], originPoint, destinationPoint) # Se intenta crear un arco. Primero se verifica si existe if edge is None: gr.addEdge(analyzer['connections'], originPoint, destinationPoint, distance) return analyzer
def dfsVertex(search, graph, vertex): """ Funcion auxiliar para calcular un recorrido DFS Args: search: Estructura para almacenar el recorrido vertex: Vertice de inicio del recorrido. Returns: Una estructura para determinar los vertices conectados a source Raises: Exception """ try: result = False adjlst = g.adjacents(graph, vertex) adjslstiter = it.newIterator(adjlst) while (it.hasNext(adjslstiter)): w = it.next(adjslstiter) if w == vertex: result = True visited = map.get(search['visited'], w) if visited is None: map.put( search['visited'], w, { 'marked': True, 'edgeTo': vertex, 'peso': edge.weight(gr.getEdge(graph, vertex, w)) }) dfsVertex(search, graph, w) return (search, result) except Exception as exp: error.reraise(exp, 'dfs:dfsVertex')
def pathTowithLimiter(search, vertex, grafo, limit): """ Retorna el camino entre el vertices source y el vertice vertex Args: search: La estructura con el recorrido vertex: Vertice de destingo Returns: Una pila con el camino entre el vertices source y el vertice vertex Raises: Exception """ try: if hasPathTo(search, vertex) is False: return None path = stk.newStack() TIEMPO = 0 limit=limit*60 while vertex != search['source']: stk.push(path, vertex) papu=vertex vertex = map.get(search['visited'], vertex)['value']['edgeTo'] edge=graph.getEdge(grafo,vertex,papu) t=int(edge['weight'])+1200 TIEMPO+=t if TIEMPO>limit: return None stk.push(path, search['source']) return path,TIEMPO except Exception as exp: error.reraise(exp, 'dfs:pathtotuniao')
def bfsVertex(search, graph, source, time, camino): """ Funcion auxiliar para calcular un recorrido BFS Args: search: Estructura para almacenar el recorrido vertex: Vertice de inicio del recorrido. Returns: Una estructura para determinar los vertices conectados a source Raises: Exception """ try: adjsqueue = queue.newQueue() queue.enqueue(adjsqueue, source) while not (queue.isEmpty(adjsqueue)): lista = [] tiempo = time vertex = queue.dequeue(adjsqueue) visited_v = map.get(search['visited'], vertex)['value'] adjslst = g.adjacents(graph, vertex) adjslstiter = it.newIterator(adjslst) while (it.hasNext(adjslstiter)): w = it.next(adjslstiter) visited_w = map.get(search['visited'], w) if ed.weight(g.getEdge(graph, vertex, w)) <= tiempo: lista.append(w) tiempo = tiempo - ed.weight(g.getEdge(graph, vertex, w)) else: camino.append(lista) if visited_w is None: dist_to_w = visited_v['distTo'] + 1 visited_w = { 'marked': True, 'edgeTo': vertex, "distTo": dist_to_w } map.put(search['visited'], w, visited_w) queue.enqueue(adjsqueue, w) return search except Exception as exp: error.reraise(exp, 'bfs:bfsVertex')
def addConnection(analyzer, origin, destination, weight): """ Adiciona un arco entre dos vértices del grafo """ graph = analyzer['connections'] edge = gr.getEdge(graph, origin, destination) if edge is None: gr.addEdge(graph, origin, destination, weight) return analyzer
def addConnection(catalog, graph, origin, destination, weight): """ Adiciona un arco entre dos estaciones """ edge = gr.getEdge(catalog[graph], origin, destination) if edge is None: gr.addEdge(catalog[graph], origin, destination, weight) #gr.addEdge(catalog[graph], destination, origin, weight) return catalog
def bfsVertex(search, graph, source, maxtime): """ Funcion auxiliar para calcular un recorrido BFS Args: search: Estructura para almacenar el recorrido vertex: Vertice de inicio del recorrido. Returns: Una estructura para determinar los vertices conectados a source Raises: Exception """ try: adjsqueue = queue.newQueue() queue.enqueue(adjsqueue, source) while not queue.isEmpty(adjsqueue): vertex = queue.dequeue(adjsqueue) visited_v = map.get(search['visited'], vertex)['value'] adjslst = g.adjacents(graph, vertex) adjslstiter = it.newIterator(adjslst) if not (it.hasNext(adjslstiter)): visited_v["final"] = True c = 0 while (it.hasNext(adjslstiter)): if c == 1 and vertex != source: break total_time = 0 w = it.next(adjslstiter) if not (it.hasNext(adjslstiter)) and c == 0: visited_v["final"] = True edge = g.getEdge(graph, vertex, w) time = edge['weight'] / 60 visited_w = map.get(search['visited'], w) if visited_w is None: if visited_v["final"] == False: dist_to_w = visited_v['distTo'] + time total_time = dist_to_w if total_time <= maxtime: visited_w = { 'marked': True, 'edgeTo': vertex, "distTo": dist_to_w, "final": False } map.put(search['visited'], w, visited_w) queue.enqueue(adjsqueue, w) c = 1 return search except Exception as exp: error.reraise(exp, 'bfs:bfsVertex')
def getTargetEdge(trip: dict, DataBase: dict) -> edge: startId = int(trip["start station id"]) endId = int(trip["end station id"]) target = selectTarget(trip) if not (map.contains(DataBase['target'], target)): targetGraph = Structure.newTargetGraph() map.put(DataBase['target'], target, targetGraph) targetGraph = mapentry.getValue(map.get(DataBase['target'], target)) if not (graph.containsVertex(targetGraph, startId)): graph.insertVertex(targetGraph, startId) if not (graph.containsVertex(targetGraph, endId)): graph.insertVertex(targetGraph, endId) edgeRoute = graph.getEdge(targetGraph, startId, endId) if edgeRoute is None: graph.addEdge(targetGraph, startId, endId, 0) edgeRoute = graph.getEdge(targetGraph, startId, endId) return edgeRoute
def AddSameLanding_pointEdge(catalog): """ Unen los mismo landing_point """ # Obtener la lista de landing_point landing_point_list = mp.keySet(catalog['map_landing_points']) # Iterar sobre la lista de landing_point landing_point_iterator = it.newIterator(landing_point_list) while it.hasNext(landing_point_iterator): landing_point = it.next(landing_point_iterator) # Obtener el map de landing_point landing_point_mapEntry = mp.get(catalog['map_landing_points'], landing_point) landing_point_map = me.getValue(landing_point_mapEntry) # Obtener la lista de ciudades ciudades_list = mp.keySet(landing_point_map) # Iterar sobre ciudades i = 0 ciudades_iterator = it.newIterator(ciudades_list) while i < int(lt.size(ciudades_list)): ciudad = it.next(ciudades_iterator) # Crear la lista de vertex A vertexA_list = lt.newList('ARRAY_LIST') # Obtener la lista de vertex vertex_list = gr.vertices(catalog['graph_landing_points']) # iterar sobre la lista de vertices vertex_iterator = it.newIterator(vertex_list) while it.hasNext(vertex_iterator): vertex = it.next(vertex_iterator) # Separar el vertice vertex_separado = vertex.split("*") # Obtener la lista filtrada de vertices if vertex_separado[0] == landing_point and vertex_separado[ 1] == ciudad and not mp.contains( catalog['capitals'], vertex_separado[1]): lt.addLast(vertexA_list, vertex) # Iterar sobre vertexA_list vertexA_iterator = it.newIterator(vertexA_list) while it.hasNext(vertexA_iterator): vertexA = it.next(vertexA_iterator) # Iterar sobre vertexA_list vertexB_iterator = it.newIterator(vertexA_list) while it.hasNext(vertexB_iterator): vertexB = it.next(vertexB_iterator) if gr.getEdge(catalog['graph_landing_points'], vertexA, vertexB) == None: gr.addEdge(catalog['graph_landing_points'], vertexA, vertexB, float(0.1)) i += 1
def add_capital_edges(self, country): if country == "Colombia": country = country capital = self.get_capital_id_safe(country) cities = mp.get(self.point_country, country) if cities: city_it = ll_it.newIterator(cities['value']) while ll_it.hasNext(city_it): city = ll_it.next(city_it) if capital != city: if not gp.getEdge(self.connections_map, capital, city): gp.addEdge(self.connections_map, capital, city, self.haversine(capital, city)) gp.addEdge(self.connections_map, city, capital, self.haversine(capital, city))
def test_getEdgesGraph(graph): g.insertVertex(graph, 'Bogota') g.insertVertex(graph, 'Yopal') g.insertVertex(graph, 'Cali') g.insertVertex(graph, 'Medellin') g.insertVertex(graph, 'Pasto') g.insertVertex(graph, 'Barranquilla') g.insertVertex(graph, 'Manizales') g.addEdge(graph, 'Bogota', 'Yopal', 2) g.addEdge(graph, 'Bogota', 'Medellin', 3) g.addEdge(graph, 'Bogota', 'Pasto', 1) g.addEdge(graph, 'Bogota', 'Cali', 10) g.addEdge(graph, 'Yopal', 'Medellin', 20) g.addEdge(graph, 'Medellin', 'Pasto', 4) g.addEdge(graph, 'Cali', 'Pasto', 6) g.addEdge(graph, 'Cali', 'Barranquilla', 3) g.addEdge(graph, 'Barranquilla', 'Manizales', 10) g.addEdge(graph, 'Pasto', 'Manizales', 8) assert g.numVertices(graph) == 7 assert g.numEdges(graph) == 10 edge = g.getEdge(graph, 'Pasto', 'Medellin') assert edge['weight'] == 4
def addConnection(catalog, origin, destination, distance): edge = gr.getEdge(catalog['connections'], origin, destination) if edge is None: gr.addEdge(catalog['connections'], origin, destination, distance)
def addEdges(grafo, origin, destination, weight): edge = gr.getEdge(grafo, origin, destination) if edge is None: gr.addEdge(grafo, origin, destination, weight)
def addEdge(catalog, origin, destination, weight): edge = gr.getEdge(catalog['connections'], origin, destination) if edge is None: gr.addEdge(catalog['connections'], origin, destination, weight)