def afectedCountries (analyzer, vertex): adjacentedges = gr.adjacentEdges(analyzer['connections'], vertex) map = mp.newMap(numelements=100,maptype='PROBING') lstedges = adjacentedges.copy() i = 1 while i <= lt.size(lstedges): edge = lt.getElement(lstedges, i) pais = edge['vertexB'].split(',') if len(pais) > 3: pais = pais[len(pais)-1] else: pais = pais[0] contains = mp.contains(map, pais) if contains: entry = mp.get(map, pais) entry = me.getValue(entry) if e.weight(edge) < entry[0]: mp.put(map, pais, (e.weight(edge), i)) lt.deleteElement(lstedges, entry[1]) else: lt.deleteElement(lstedges, i) else: mp.put(map, pais, (e.weight(edge), i)) i += 1 orderededges = mergeSortEdges(lstedges, lt.size(lstedges))[0] return (adjacentedges, orderededges)
def scan(graph, search, vertex): """ Args: search: La estructura de busqueda vertex: El vertice destino Returns: El costo total para llegar de source a vertex. Infinito si no existe camino Raises: Exception """ try: map.put(search['marked'], vertex, True) edges = g.adjacentEdges(graph, vertex) for edge in lt.iterator(edges): w = e.other(edge, vertex) if (not map.get(search['marked'], w)['value']): if (e.weight(edge) < map.get(search['distTo'], w)['value']): map.put(search['distTo'], w, e.weight(edge)) map.put(search['edgeTo'], w, edge) if (pq.contains(search['pq'], w)): pq.decreaseKey(search['pq'], w, map.get(search['distTo'], w)['value']) else: pq.insert(search['pq'], w, map.get(search['distTo'], w)['value']) return search except Exception as exp: error.reraise(exp, 'bellman:disto')
def relax(search, edge): """ Relaja el peso de los arcos del grafo con la nueva de un nuevo arco Args: search: La estructura de busqueda edge: El nuevo arco Returns: El grafo con los arcos relajados Raises: Exception """ try: v = e.either(edge) w = e.other(edge, v) visited_v = map.get(search['visited'], v)['value'] visited_w = map.get(search['visited'], w)['value'] distw = visited_w['distTo'] distv = visited_v['distTo'] + e.weight(edge)[0] if (visited_w is None) or (distw > distv): distow = visited_v['distTo'] + e.weight(edge)[0] map.put(search['visited'], w, { 'marked': True, 'edgeTo': edge, 'distTo': distow }) if iminpq.contains(search['iminpq'], w): iminpq.decreaseKey(search['iminpq'], w, distow) else: iminpq.insert(search['iminpq'], w, distow) return search except Exception as exp: error.reraise(exp, 'dks:relax')
def PaisesAfectados(catalog, nombreLanding): landing = mp.get(catalog["LandingPointN"], nombreLanding) listaPaises = "NE" if landing != None: #listaPaises = lt.newList('ARRAY_LIST') tablitaPaises = mp.newMap(numelements=10, maptype='PROBING', comparefunction=compareCountryNames) landing = me.getValue(landing) datosLanding = lt.getElement( me.getValue(mp.get(catalog["LandingPointI"], landing))['lstData'], 1) paisLanding = datosLanding["name"].split(",") paisLanding = paisLanding[len(paisLanding) - 1].strip() h = paisLanding edge = gr.getEdge(catalog["connectionsDistance"], paisLanding, landing) peso = e.weight(edge) / 1000 #lt.addLast(listaPaises,paisLanding) mp.put(tablitaPaises, paisLanding, peso) adyacentes = gr.adjacentEdges(catalog["connectionsDistance"], landing) for arco in lt.iterator(adyacentes): OtroVertex = e.other(arco, landing) if not mp.contains(catalog['countriesInfo'], OtroVertex): adyacentes2 = gr.adjacentEdges(catalog["connectionsDistance"], OtroVertex) for arco2 in lt.iterator(adyacentes2): OtroVertex2 = e.other(arco2, OtroVertex) if not mp.contains(catalog['countriesInfo'], OtroVertex2) and OtroVertex2 != landing: peso = e.weight(arco2) / 1000 id = OtroVertex2.split("*")[0] datosLanding = lt.getElement( me.getValue(mp.get(catalog["LandingPointI"], id))['lstData'], 1) paisLanding = datosLanding["name"].split(",") paisLanding = paisLanding[len(paisLanding) - 1].strip() #if lt.isPresent(listaPaises,paisLanding)==0: # lt.addLast(listaPaises,paisLanding) pais = mp.get(tablitaPaises, paisLanding) if pais != None: pais = me.getValue(pais) if (peso < pais): mp.put(tablitaPaises, paisLanding, peso) #ACA else: mp.put(tablitaPaises, paisLanding, peso) #ACA #heap = pq.newMinPQ(cmpfunction=compareDistance) listaPaises = lt.newList('ARRAY_LIST') for pais in lt.iterator(mp.keySet(tablitaPaises)): elemento = me.getValue(mp.get(tablitaPaises, pais)) #pq.insert(heap,(pais,elemento)) lt.addLast(listaPaises, (pais, elemento)) merge.sort(listaPaises, compareDistance) return listaPaises
def req4(citibike, resis, inicio): "William Mendez" pendientes = [] #str del id encontrados = {} #{llegada: (origen, duracion)} primeros = gr.adjacents(citibike['graph'], inicio) iterator = it.newIterator(primeros) while it.hasNext(iterator): element = it.next(iterator) # print(element) durac = ed.weight(gr.getEdge(citibike['graph'], inicio, element)) / 60 if durac <= resis: encontrados[element] = (inicio, round(durac, 2)) pendientes.append(element) while len(pendientes) > 0: for i in pendientes: adya = gr.adjacents(citibike['graph'], i) if adya['size'] != 0: # print(adya) iterator = it.newIterator(adya) while it.hasNext(iterator): element = it.next(iterator) # print(element) if element not in encontrados.keys() and \ element not in pendientes and element != inicio: durac = 0 llega = i # print(i, element) while llega != inicio: # print(durac) durac += encontrados[llega][1] llega = encontrados[llega][0] # print(durac) relativ = ed.weight( gr.getEdge(citibike['graph'], i, element)) / 60 # print(durac, relativ, durac + relativ, resis) if (durac + relativ) <= resis: encontrados[element] = (i, round(relativ, 2)) pendientes.append(element) pendientes.remove(i) # print(len(pendientes)) # print(encontrados) return encontrados
def weightMST(graph, search): weight = 0.0 # edgesMST(graph, search) edges = search['mst'] for edge in lt.iterator(edges): weight = weight + e.weight(edge) return weight
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 Dijkstra(graph, source, inicio, fin): """ Implementa el algoritmo de Dijkstra Args: graph: El grafo de busqueda source: El vertice de inicio Returns: Un nuevo grafo vacío Raises: Exception """ try: search = initSearch(graph, source) while not iminpq.isEmpty(search['iminpq']): v = iminpq.delMin(search['iminpq']) edges = g.adjacentEdges(graph, v) if edges is not None: edgesiter = it.newIterator(edges) while (it.hasNext(edgesiter)): edge = it.next(edgesiter) peso = e.weight(edge) v = e.either(edge) if v == source: if peso[0] < fin and peso[0] > inicio: relax(search, edge) else: relax(search, edge) return search except Exception as exp: error.reraise(exp, 'dks:dijkstra')
def relax(graph, search, v): """ Relaja el peso de los arcos del grafo Args: search: La estructura de busqueda v: Vertice desde donde se relajan los pesos Returns: El grafo con los arcos relajados Raises: Exception """ try: edges = g.adjacentEdges(graph, v) if edges is not None: for edge in lt.iterator(edges): v = e.either(edge) w = e.other(edge) distv = map.get(search['distTo'], v)['value'] distw = map.get(search['distTo'], w)['value'] distweight = distv + e.weight(edge) if (distw > distweight): map.put(search['distTo'], w, distweight) map.put(search['edgeTo'], w, edge) if (not map.get(search['onQ'], w)['value']): q.enqueue(search['qvertex'], w) map.put(search['onQ'], w, True) cost = search['cost'] if ((cost % g.numVertices(graph)) == 0): findneg = findNegativeCycle(graph, search) if (hasNegativecycle(findneg)): return search['cost'] = cost + 1 return search except Exception as exp: error.reraise(exp, 'bellman:relax')
def GrafosPorCiclo(analyzer, origen, VDC): """ Genera un grafo por cada ciclo diferente relacionado al origen y los añade a GPCC (diccionario) """ #GPCC = Grafos Por Cada Ciclo GPCC = {} if VDC == False: return False else: for Valor in VDC: Cierre = False GPCC[Valor] = gr.newGraph(datastructure="ADJ_LIST", directed=True, size=6, comparefunction=comparer) gr.insertVertex(GPCC[Valor], origen) actual = origen mismo = origen Adjacentes = adj.adjacents(analyzer["graph"], actual) Adjacentes["cmpfunction"] = comparador while Cierre == False: a = it.newIterator(VDC[Valor]) while it.hasNext(a): b = it.next(a) if actual != mismo: Adjacentes = adj.adjacents(analyzer["graph"], actual) Adjacentes["cmpfunction"] = comparador mismo = actual if not gr.containsVertex(GPCC[Valor], b): if lt.isPresent(Adjacentes, origen) != 0 and actual != origen and b != origen: gr.insertVertex(GPCC[Valor], b) Tartalia = gr.getEdge(analyzer["graph"], actual, origen) Peso = int(ed.weight(Tartalia)/Tartalia["Repeticiones"]) adj.addEdge(GPCC[Valor], actual, origen, Peso) actual = b Cierre = True elif lt.isPresent(Adjacentes, b) != 0 and b != origen: gr.insertVertex(GPCC[Valor], b) Tartalia = gr.getEdge(analyzer["graph"], actual, b) Peso = int(ed.weight(Tartalia)/Tartalia["Repeticiones"]) adj.addEdge(GPCC[Valor], actual, b, Peso) actual = b elif actual == origen and lt.size(VDC[Valor]) == 1: Cierre = True return GPCC
def buscarMayor(search): buscar = 0 edges = search["mst"] for edge in lt.iterator(edges): peso = e.weight(edge) if peso > buscar: buscar = peso return buscar
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 buscarMenor(search): buscar = math.inf edges = search["mst"] #dicc = {} for edge in lt.iterator(edges): peso = float(e.weight(edge)) #dicc[peso] = None if peso != 1 and peso != 0 and peso < buscar: buscar = peso #print(dicc.keys()) return buscar
def addConnection(graph, origin, destination, duration): """ Adiciona un arco entre dos community areas """ edge = gr.getEdge(graph, origin, destination) if edge is None: gr.addEdge(graph, origin, destination, duration) else: weight = e.weight(edge) prom = (duration + weight)/2 edge['weight'] = prom return graph
def addConnection(analyzer, origin, destination, duration): """ Adiciona un arco entre dos estaciones """ edge = gr.getEdge(analyzer["trips"], origin, destination) if edge is None: gr.addEdge(analyzer["trips"], origin, destination, duration) else: weight = e.weight(edge) prom = (duration + weight) / 2 edge['weight'] = prom return analyzer
def addConnection(citibike, origin, destination, duration): """ Adiciona un arco entre dos estaciones """ edge = gr.getEdge(citibike['graph'], origin, destination) if edge is None: gr.addEdge(citibike['graph'], origin, destination, duration) else: prev_duration = int(ed.weight(edge)) duration += prev_duration ed.updateWeight(edge, duration) return citibike
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 findNegativeCycle(graph, search): """ Identifica ciclos negativos en el grafo """ try: vertices = g.vertices(graph) for vert in lt.iterator(vertices): edge = map.get(search['edgeTo'], vert) if (edge is not None): edge = edge['value'] g.addEdge(search['spt'], e.either(edge), e.other(edge), e.weight(edge)) finder = c.DirectedCycle(search['spt']) search['cycle'] = not st.isEmpty(c.cycle(finder)) return search except Exception as exp: error.reraise(exp, 'bellman:pathto')
def caminoMin(caminosMinimos, pais1, pais2): """ Se consigue la distancia y el camino que conecta la fuente del grafo Caminos minimos con el Pais2. Si la distancia es infinito, lo cual indica que no hay camino, esta se remplaza por -1. #PROXIMAMENTE: Pasar el camino a una lista para que sea facil de imprimir en el view""" caminos = lt.newList('ARRAY_LIST', cmpfunction=compareCountryNames) camino = djk.pathTo(caminosMinimos, pais2) distancia = djk.distTo(caminosMinimos, pais2) if distancia == math.inf: distancia = -1 else: for elemento in lt.iterator(camino): dato = lt.newList('ARRAY_LIST') land1 = e.either(elemento) peso = e.weight(elemento) land2 = e.other(elemento, e.either(elemento)) lt.addLast(dato, land1) lt.addLast(dato, peso) lt.addLast(dato, land2) lt.addLast(caminos, dato) return caminos, distancia
def Requirement3(analyzer, country1, country2): tracemalloc.start() delta_time = -1.0 delta_memory = -1.0 start_time = getTime() start_memory = getMemory() capital1 = (mp.get(analyzer['countries_map'], country1)['value'])['CapitalName'] capital2 = (mp.get(analyzer['countries_map'], country2)['value'])['CapitalName'] analyzer['paths'] = djk.Dijkstra( analyzer['connections_origin_destination'], capital1) path = djk.pathTo(analyzer['paths'], capital2) distance = djk.distTo(analyzer['paths'], capital2) listKm = lt.newList('ARRAY_LIST') iterator1 = it.newIterator(path) while it.hasNext(iterator1): component = it.next(iterator1) vertexA = edge.either(component) vertexB = edge.other(component, vertexA) weight = edge.weight(component) string = 'Ir ' + str(weight) + ' Km desde ' + vertexA + ' a ' + vertexB lt.addLast(listKm, string) stop_memory = getMemory() stop_time = getTime() tracemalloc.stop() delta_time = stop_time - start_time delta_memory = deltaMemory(start_memory, stop_memory) return (listKm, distance, delta_time, delta_memory)
def TiempoNecesariomod(analyzer, GPCC, limites): if GPCC == False: return False else: Ideal = {} Pesos = {} for A in GPCC: Pesos[A] = 0 n = it.newIterator(gr.edges(GPCC[A])) if it.hasNext(n): d = it.next(n) Pesos[A] += ed.weight(d) LimiteInferior = 0*60 LimiteSuperior = limites*60 for B in Pesos: if Pesos[B] >= LimiteInferior and Pesos[B] <= LimiteSuperior: Ideal[B] = GPCC[B] if len(Ideal) == 0: return "Vacio" else: return Ideal
def test_edgeMethods(graph): edge = e.newEdge('Bogota', 'Cali') assert 'Bogota' == e.either(edge) assert 'Cali' == e.other(edge, e.either(edge)) assert e.weight(edge) == 0
def cmpKm(edge1, edge2): return float(e.weight(edge1)) > float(e.weight(edge2))
def circulargraph(analyzer, StartStationid, avaibleTimemin, avaibleTimemax): r = {"R_Especifico": {}} rutas = 0 totalrutas = -1 Kosaraju = connectedComponents(analyzer) verticeslst = gr.vertices(analyzer['graph']) vertices = it.newIterator(verticeslst) bfs_startstation = dfs.DepthFirstSearch(analyzer['graph'], StartStationid) while it.hasNext(vertices): time = -20 vertice = it.next(vertices) if sameCC(analyzer, StartStationid, vertice): totalrutas += 1 if (gr.getEdge(analyzer['graph'], vertice, StartStationid)) != None: tiempo_vuelta = e.weight( gr.getEdge(analyzer['graph'], vertice, StartStationid)) tiempo_vuelta = tiempo_vuelta pila_ida = (dfs.pathTo(bfs_startstation, vertice)) v1 = st.pop(pila_ida) time += (20 * st.size(pila_ida)) while not st.isEmpty(pila_ida): v2 = st.pop(pila_ida) time += e.weight(gr.getEdge(analyzer['graph'], v1, v2)) v1 = v2 if time / 60 > avaibleTimemax: break else: bfs_backstation = dfs.DepthFirstSearch(analyzer['graph'], vertice) pila_ida = (dfs.pathTo(bfs_startstation, vertice)) pila_vuelta = (dfs.pathTo(bfs_backstation, vertice)) v1v = st.pop(pila_vuelta) v1 = st.pop(pila_ida) time += (20 * (st.size(pila_ida) + st.size(pila_vuelta))) while not st.isEmpty(pila_ida): v2 = st.pop(pila_ida) time += e.weight(gr.getEdge(analyzer['graph'], v1, v2)) v1 = v2 if time / 60 > avaibleTimemax: break while not st.isEmpty(pila_vuelta): v2v = st.pop(pila_vuelta) time += e.weight(gr.getEdge(analyzer['graph'], v1v, v2v)) v1v = v2v if time / 60 > avaibleTimemax: break time = round(time / 60, 2) if time >= avaibleTimemin and time <= avaibleTimemax: rutas += 1 StartStationName = getName(analyzer["stationinfo"], StartStationid) FinalStationName = getName(analyzer["stationinfo"], vertice) r["R_Especifico"][rutas] = { "Nombre_station_Inicio": StartStationName, "Nombre_station_Final": FinalStationName, "tiempo en min ": time } elif sameCC(analyzer, StartStationid, vertice) == None: pass return (totalrutas, rutas, r)
for value in lt.iterator(result[0][0]): print(value) print('El anterior landing point tiene un total de ', result[0][1], ' interconexiones con cables') print("\nTiempo [ms]: ", f"{result[1][0]:.3f}", " || ", "Memoria [kB]: ", f"{result[1][1]:.3f}") elif int(inputs[0]) == 4: origin = input('Ingrese el pais de origen: ') destination = input('Ingrese el pais de destino: ') result = controller.requerimiento3(analyzer, origin, destination) if result[0] is not None: distance = 0 while (not stack.isEmpty(result[0])): edge = stack.pop(result[0]) distance += e.weight(edge) print(edge) print('La distancia es de ', distance, ' Km') else: print('No es posible establecer una conexion') print("\nTiempo [ms]: ", f"{result[1][0]:.3f}", " || ", "Memoria [kB]: ", f"{result[1][1]:.3f}") vermap = input('Desea observar el camino grafica en el mapa?') if vermap == 'si': webbrowser.open('mapa.html') elif int(inputs[0]) == 5: result = controller.requerimiento4(analyzer) distance = 0 while (not lt.isEmpty(result[0][0])): edge = lt.removeLast(result[0][0])