def getShortestCoordinate(analyzer, estacionCercanaInicio, estacionCercanaFinal): """ Devuelve la ruta entre una coordenada origen y una final """ lista = [] suma = 0 estructura1 = dfs.DepthFirstSearch(analyzer["trips"], estacionCercanaInicio) estructura2 = dfs.DepthFirstSearch(analyzer["trips"], estacionCercanaFinal) if dfs.hasPathTo(estructura1, estacionCercanaFinal): camino = dfs.pathTo(estructura1, estacionCercanaFinal) getPathNextStations(lista, camino["first"]) lista.append(camino["last"]["info"]) for i in range(1, len(lista)): suma += gr.getEdge(analyzer["trips"], lista[i - 1], lista[i])["weight"] elif dfs.hasPathTo(estructura2, estacionCercanaInicio): camino = dfs.pathTo(estructura1, estacionCercanaInicio) getPathNextStations(lista, camino["first"]) lista.append(camino["last"]["info"]) for i in range(1, len(lista)): suma += gr.getEdge(analyzer["trips"], lista[i - 1], lista[i])["weight"] lista = reverseList(lista) else: suma = -1 return (lista, suma)
def addConnection(Inite, community1, community2, duration): edge = gr.getEdge(Inite["Graph"], community1, community2) if edge is None: gr.addEdge(Inite["Graph"], community1, community2, duration) edge = gr.getEdge(Inite["Graph"], community1, community2) edge["division"] = 1 else: duracion = incremental(edge["weight"], edge["division"], duration) edge["division"] += 1 edge["weight"] = duracion return Inite
def addConnection2(citibike, origin, destination, years, subscriber): edge3 = gr.getEdge(citibike["customers"], origin, destination) if edge3 is None: gr.addEdge(citibike["customers"], origin, destination, years) edge3 = gr.getEdge(citibike["customers"], origin, destination) edge3["division"] = 1 else: diferencial = incremental(edge3["weight"], edge3["division"], years) edge3["division"] += 1 edge3["weight"] = int(diferencial) return citibike
def AñadirConeccion(analyzer, origin, destination, duration): """ Adiciona un arco entre dos estaciones """ edge = gr.getEdge(analyzer["graph"], origin, destination) if edge is None: gr.addEdge(analyzer["graph"], origin, destination, duration) edge = gr.getEdge(analyzer["graph"], origin, destination) edge["Repeticiones"] = 1 else: edge["weight"] = (edge["weight"]+int(duration)) edge["Repeticiones"] += 1 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) edge = gr.getEdge(citibike["graph"], origin, destination) edge["division"] = 1 else: duracion = incremental(edge["weight"], edge["division"], duration) edge["division"] += 1 edge["weight"] = duracion return citibike
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 requerimiento_4(analyzer,station,resistance): try: resistance=resistance*60 recorrido= bfs.BreadhtFisrtSearch(analyzer['connections'],station) size= gr.numVertices(analyzer['connections']) vertexxx= gr.vertices(analyzer['connections']) dicc= {} for i in range(1,size): ids= lt.getElement(vertexxx,i) vertice= m.get(analyzer['coordinates_destiny'],ids)['value']['name'] if bfs.hasPathTo(recorrido,ids): path= bfs.pathTo(recorrido,ids) sizep= st.size(path) if sizep != 1 : init= st.pop(path) summ= 0 dicc[vertice]= [] while sizep >= 2: vertex2= st.pop(path) if vertex2 is None : break arco= gr.getEdge(analyzer['connections'],init,vertex2) summ+= arco['weight'] init= vertex2 if summ > resistance : dicc[str(vertice)]= None else: dicc[str(vertice)].append(poner_bonita_la_ruta(analyzer,arco)) return dicc except Exception as exp: error.reraise(exp, 'model;Req_4')
def addcountry(catalogo, pais): if not pais == None: m.put(catalogo["paises"], pais["CountryName"], pais) m.put(catalogo["capitales"], pais["CapitalName"], pais) gr.insertVertex(catalogo['conexiones'], pais["CapitalName"]) lt.addLast(catalogo["listavertices"], pais["CapitalName"]) if not m.get(catalogo["mapaises"], pais["CountryName"]) == None: listapoints = m.get(catalogo["mapaises"], pais["CountryName"])["value"] for x in range(int(listapoints["size"])): vertice = lt.getElement(listapoints, x) edge = gr.getEdge(catalogo['conexiones'], pais["CapitalName"], vertice) infodestino = m.get(catalogo["vertices"], vertice)["value"] c = math.pi / 180 dist = abs(2 * 6371 * math.asin( math.sqrt( math.sin(c * (float(infodestino["latitude"]) - float(pais["CapitalLatitude"])) / 2)**2 + math.cos(c * float(pais["CapitalLatitude"])) * math.cos(c * float(infodestino["latitude"])) * math.sin(c * (float(infodestino["longitude"]) - float(pais["CapitalLongitude"])) / 2)**2))) if edge is None: gr.addEdge(catalogo['conexiones'], pais["CapitalName"], vertice, dist)
def addConexion_graph(catalog, vertice_origen, vertice_destino, distancia): origen = vertice_origen destino = vertice_destino grafo = catalog['grafo'] edge = gr.getEdge(grafo, origen, destino) if edge is None: gr.addEdge(grafo, origen, destino, distancia)
def req4(citibike, TiempoResistencia, IdEstacionI): tiempoRuta = 0 if gr.containsVertex(citibike["graph"], IdEstacionI): verticesAdy = gr.adjacents(citibike["graph"], IdEstacionI) z = m.get(citibike["namesI"], IdEstacionI) nombreX = en.getValue(z) nombreI = nombreX["nombre"] else: return ("La estación escogida no existe") listaFinal = [] if verticesAdy["size"] == 0: print("La estación escogida no tiene estaciones adyacentes") else: for i in range(0, (verticesAdy["size"] + 1)): tiempoRuta = 0 listaRuta = lt.newList("SINGLED_LINKED") listaArcos = [] vertice = lt.getElement(verticesAdy, i) lt.addLast(listaRuta, vertice) valorArco = gr.getEdge(citibike["graph"], IdEstacionI, vertice)["weight"]["duracion"] listaArcos.append(valorArco) tiempoRuta = int(valorArco) req4Parte2(citibike, TiempoResistencia, vertice, tiempoRuta, listaRuta, listaFinal, IdEstacionI, listaArcos, nombreI) return listaFinal
def req2Parte2(citibike, TiempoI, TiempoF, vertice, tiempoRuta, listaFinal, IdEstacionI, listaRuta, listaArcos): verticesAdy = gr.adjacents(citibike["graph"], vertice) if (verticesAdy["size"] == 0): if int(tiempoRuta) >= int(TiempoI) and int(tiempoRuta) <= int( TiempoF) and (str(listaRuta) + ": " + str(tiempoRuta) + "s " not in listaFinal): print("o") listaFinal.append(str(listaRuta) + ": " + str(tiempoRuta) + "s ") longitud = len(listaArcos) if longitud != 0: x = listaArcos.pop(len(listaArcos) - 1) tiempoRuta -= int(x) y = listaRuta.pop(len(listaRuta) - 1) elif (verticesAdy["size"] != 0): for j in range(0, (verticesAdy["size"] + 1)): vertice2 = lt.getElement(verticesAdy, j) valorArco2 = int( gr.getEdge(citibike["graph"], vertice, vertice2)["weight"]["duracion"]) if int(valorArco2) <= int(TiempoF): tiempoRuta += valorArco2 listaArcos.append(valorArco2) listaRuta.append(vertice2) req2Parte2(citibike, TiempoI, TiempoF, vertice2, tiempoRuta, listaFinal, IdEstacionI, listaRuta, listaArcos) return listaFinal
def addConnection(citibike, origin, destination, duration): """ Adiciona un arco entre dos estaciones """ if origin != destination: edge = gr.getEdge(citibike ["connections"], origin, destination) if edge is None: if m.get(citibike["stations"], origin) is None: repetitions = m.newMap(numelements=1536, maptype="PROBING", loadfactor=0.5, comparefunction=compareStopIds) m.put(citibike["stations"],origin, repetitions) repetitions = me.getValue(m.get(citibike["stations"], origin)) m.put(repetitions,destination, [duration, 1]) gr.addEdge(citibike["connections"], origin, destination, duration) else: one_rep = m.get(citibike["stations"],origin) repetitions = me.getValue(one_rep) two_rep = m.get(repetitions, destination) repetitions_destination = me.getValue(two_rep) repetitions_destination[0]+=duration repetitions_destination[1]+=1 duration = repetitions_destination[0]/repetitions_destination[1] ed.setWeight(edge, duration) return citibike
def getCountriesInLp(analyzer, lp): lpId = None lpCountry = None countries = [] for landingpoint in lt.iterator(analyzer['landingPointsGeo']): location = landingpoint['name'].split(', ') if location[0] == lp: lpId = landingpoint['landing_point_id'] lpCountry = location[-1] break entry = m.get(analyzer['landingPoints'], lpId) lstroutes = entry['value'] for route in lt.iterator(lstroutes): vertex = lpId + '-' + route adjacents = gr.adjacents(analyzer['connections'], vertex) for vertexadj in lt.iterator(adjacents): vertexid = vertexadj.split('-')[0] for landingpoint in lt.iterator(analyzer['landingPointsGeo']): if landingpoint['landing_point_id'] == vertexid: newcountry = landingpoint['name'].split(', ')[-1] found = False for country in countries: if country[0] == newcountry: found = True break if not found and newcountry != lpCountry: distancia = gr.getEdge(analyzer['connections'], vertex, vertexadj)['weight'] countries.append((newcountry, distancia)) break countries.sort(key=lambda x: x[1], reverse=True) return countries
def dfsVertexc(search, graph, vertex, source, sc): try: adjlst = gr.adjacents(graph, vertex) adjslstiter = it.newIterator(adjlst) while (it.hasNext(adjslstiter)): w = it.next(adjslstiter) visited = m.get(search['visited'], w) if visited is None: m.put(search['visited'], w, {'marked': True, 'edgeTo': vertex}) if scc.stronglyConnected(sc, w, source): dfsVertexc(search, graph, w, source, sc) elif w == source and gr.getEdge(graph, vertex, source) != None: cycle = lt.newList() lt.addLast(cycle, vertex) lt.addLast(cycle, w) x = me.getValue(m.get(search['visited'], vertex))['edgeTo'] while x != None: lt.addFirst(cycle, x) x = me.getValue(m.get(search['visited'], x))['edgeTo'] lt.addLast(search['cycles'], cycle) return search except Exception as exp: error.reraise(exp, 'dfs:dfsVertex')
def fallas(analyzer, name): LPid = me.getValue(mp.get(analyzer['LPnames'], name))#id del LP. afectados = gr.adjacents(analyzer['cables'], LPid) paises = mp.newMap(37,comparefunction=LPids) paisesSet = set() ltSort = lt.newList('ARRAY_LIST', cmpfunction=LPids) try: for vertex in lt.iterator(afectados): pais = me.getValue(mp.get(analyzer['landingPoints'], vertex))[2] pais = pais.split(',')[1].strip() #Saca el país, quita la ciudad. paisesSet.add(pais) arc = gr.getEdge(analyzer['cables'], LPid, vertex) if mp.contains(paises, pais): lt.addLast(me.getValue(mp.get(paises, pais)), arc) if not mp.contains(paises, pais): mp.put(paises, pais, lt.newList('ARRAY_LIST', cmpfunction=LPids)) lt.addLast(me.getValue(mp.get(paises, pais)), arc) for pais in paisesSet: ltP = me.getValue(mp.get(paises, pais)) ltPO = sortMaster(ltP, cmpArcW) mp.put(paises, pais, ltPO)#Pone la lista en orden. primero = lt.firstElement(ltPO)#solo compara el cable más largo de ese país. lt.addLast(ltSort, (pais, primero)) ltFinal = sortMaster(ltSort, cmpWtuple) return len(list(paisesSet)), ltFinal except Exception as exp: error.reraise(exp, 'model:Fallas')
def landing_paises(catalog,lista,vertice): newlist=lt.newList(datastructure="ARRAY_LIST") lst_element=[] for element in lt.iterator(lista): distancia=gr.getEdge(catalog["connections"],element,vertice) ciudad=des_vertice(element) lista_grande=m.get(catalog["ciudad_id"],ciudad) if lista_grande!=None: dato=lt.firstElement(lista_grande["value"]["song"]) pais=dato["name"].split(",") if len(pais)>2: if pais[2] not in lst_element: info={"Pais":str(pais[2]),"Distancia": str(round(float(distancia["weight"]),2))} lt.addLast(newlist,info) lst_element.append(pais[2]) elif len(pais)==2: if pais[1] not in lst_element: info={"Pais":str(pais[1]),"Distancia": str(round(float(distancia["weight"]),2))} lt.addLast(newlist,info) lst_element.append(pais[1]) else: if pais[0] not in lst_element: info={"Pais":str(pais[0]),"Distancia": str(round(float(distancia["weight"]),2))} lt.addLast(newlist,info) lst_element.append(pais[0]) return newlist
def addConnection(citibike, origin, destination, duration): edge = gr.getEdge(citibike["graph"], origin, destination) if edge is None: gr.addEdge(citibike["graph"], origin, destination, duration) else: e.updateAverageWeight(edge, duration) return citibike
def recorrido_resistencia(analyzer, initStation, Tmax): newGraph = bfs.BreadhtFisrtSearch(analyzer["graph"], initStation, Tmax) #archivo=open("perro.txt","w") #archivo.write(str(newGraph)) #print(newGraph["visited"]["table"]) keys = m.keySet(newGraph["visited"]) iterator = it.newIterator(keys) rutas = [] while it.hasNext(iterator): station = it.next(iterator) #for el in newGraph["visited"]["table"]["elements"]: #if el["key"]!=None and el["value"]["final"]==True: if me.getValue(m.get(newGraph["visited"], station))["final"] == True: ruta = [] path = bfs.pathTo(newGraph, station) i = 0 while not st.isEmpty(path): entry = st.pop(path) if entry == initStation: ruta = {"Estaciones": [entry], "Duraciones": []} else: ruta["Estaciones"].append(entry) edge = gr.getEdge(analyzer["graph"], ruta["Estaciones"][i - 1], entry) duration = edge['weight'] / 60 ruta["Duraciones"].append(duration) i += 1 rutas.append(ruta) return rutas
def addConnection(citibike, origin, destination, duration, age): """ Adiciona un arco entre dos estaciones """ dicc = citibike['divide'] dicc2 = {} edge = gr.getEdge(citibike['graph'], origin, destination) if origin != destination: if edge is None: dicc2["duracion"] = duration dicc2["contador"] = 1 dicc2["edades"] = [] dicc2["edades"].append(age) gr.addEdge(citibike['graph'], origin, destination, dicc2) dicc[str(origin) + "-" + str(destination)] = 1 else: dicc[str(origin) + "-" + str(destination)] += 1 edge['weight']["contador"] += 1 valor = edge['weight']["duracion"] * ( dicc[str(origin) + "-" + str(destination)] - 1) valor += duration edge['weight']["duracion"] = (valor) / dicc[str(origin) + "-" + str(destination)] edge["weight"]["edades"].append(age) return citibike
def addConnection(analyzer, origen, destino, duracion): arco = gr.getEdge(analyzer["graph"], origen, destino) if arco is None: gr.addEdge(analyzer["graph"], origen, destino, duracion) return analyzer
def req5(analyzer, inputLP): """Recibe un LP de interés. Retorna una lista de los países (adyacentes) ordenados descendentemente según su distancia. Args: analyzer inputLP (str): Landing Point de interés del usuario. Returns: sorted_list (ARRAY_LIST): Lista ordenada. """ verticesConectados = gr.adjacents( analyzer['landingPoints'], inputLP) # Se obtienen los adyacentes del LP que entra por parámetro. numeros = '0123456789' listaPaisesAfectados = lt.newList('ARRAY_LIST') for lp in lt.iterator(verticesConectados): if lp[0] not in numeros: pais = { 'nombre': lp.split('-')[1], 'weight': gr.getEdge(analyzer['landingPoints'], inputLP, lp)['weight'] } lt.addLast(listaPaisesAfectados, pais) # Se agregan los LP adyacentes en una lista. return sortMenorDistancia(listaPaisesAfectados)
def ruta(analyzer, lst, path, vert, res): routePath = path["path"] vertLst = gr.adjacents(analyzer["trips"], vert) iterator = it.newIterator(vertLst) while it.hasNext(iterator): element = it.next(iterator) edge = gr.getEdge(analyzer["trips"], vert, element) time = edge["weight"] + path["time"] posibRoutes = 0 if (float(time) <= float(res)) and (element not in routePath): if posibRoutes > 0: route = newRoute() route["path"] = routePath + "-" + edge["vertexB"] route["time"] = time lstTimes = route["Seg"] lt.addLast(lstTimes, (vert + "-" + edge["vertexB"], edge["weight"])) lt.addLast(lst, route) else: route["path"] = routePath + "-" + edge["vertexB"] route["time"] = time lstTimes = route["Seg"] lt.addLast(lstTimes, (vert + "-" + edge["vertexB"], edge["weight"])) posibRoutes += 1 ruta(analyzer, lst, route, edge["vertexB"], res) return lst
def requerimiento_6(citibike, latitudI, longitudI, latitudF, longitudF): lista = [] DistanciaI = NearestStation(citibike, latitudI, longitudI) DistanciaF = NearestStation(citibike, latitudF, longitudF) stationI = minimoDicc(DistanciaI) stationF = minimoDicc(DistanciaF) camino = bfs.BreadhtFisrtSearch(citibike['graph'], stationI) caminofinal = bfs.hasPathTo(camino, stationF) if caminofinal == True: ultimo = bfs.pathTo(camino, stationF) iterador = it.newIterator(ultimo) while it.hasNext(iterador): fila = it.next(iterador) lista.append(fila) else: print("No hay camino entre las dos estaciones") tiempo = 0 for i in range(0, len(lista) - 1): arco = gr.getEdge(citibike['graph'], lista[i], lista[i + 1])["weight"]["duracion"] tiempo += arco print("La estación incial más cercana es: " + stationI) print("La estación final más cercana es: " + stationF) print("La duración del viaje es de: " + str(tiempo)) print("La ruta es: " + str(lista))
def addConnection(congr, origin, destination, distance): """ Adiciona un arco entre dos Landing Points """ edge = gr.getEdge(congr, origin, destination) if edge is None: gr.addEdge(congr, origin, destination, distance)
def addConnection(analyzer, CA1, CA2, startTime, TripDuration): edge = gr.getEdge(analyzer["graph"], CA1, CA2, startTime) if edge is None: gr.addEdge(analyzer["graph"], CA1, CA2, TripDuration, startTime) else: e.updateAverageWeight(analyzer["graph"], edge, TripDuration) return analyzer
def segunda_consulta(citibike, time1, time2, identificador): present = gr.containsVertex(citibike['graph'], identificador) if present == True: nombre_inicial = identificador #nombre_final = "" dicc = {} lista = lt.newList(cmpfunction=compareroutes) tiempo_total = abs(int(time1) - int(time2)) citibike['components'] = numSCC_2(citibike['graph']) number = numSCC(citibike['graph']) key = gr.adjacents(citibike['graph'], nombre_inicial) tiempo = 0 ite = it.newIterator(key) while tiempo < tiempo_total and it.hasNext(ite): pro = it.next(ite) pertenecer = sameCC(citibike['components'], nombre_inicial, pro) if pertenecer == True: peso = gr.getEdge(citibike["graph"], nombre_inicial, pro) p = peso["weight"] res = abs(tiempo_total - (p + 20)) tiempo = res dicc["inicial"] = nombre_inicial dicc["final"] = pro dicc["tiempo"] = peso lt.addLast(lista, dicc) nombre_inicial = pro #nombre_final = pro answer = (number, lista) else: answer = "La estación no es válida, ingrese otra. " return answer
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'] += round((duration / 60), 2) edge['size'] += 1 edge['weight'] = round((edge['pesos'] / edge['size']), 2) else: gr.addEdge(analyzer['graph'], origin, destination, round((duration / 60), 2)) edge = gr.getEdge(analyzer['graph'], origin, destination) edge['pesos'] += round((duration / 60), 2) edge['size'] += 1 edge['weight'] = round((edge['pesos'] / edge['size']), 2)
def add_edge(analyzer, origin, destination, weight): """ Adiciona un arco entre dos estaciones """ edge = gr.getEdge(analyzer['connections'], origin, destination) if edge is None: gr.addEdge(analyzer['connections'], origin, destination, weight) return analyzer
def addConnectionC(analyzer, origin, destination, distance): """ Adiciona un arco entre dos estaciones """ edge = gr.getEdge(analyzer['graph'], origin, destination) if edge is None: gr.addEdge(analyzer["graph"], origin, destination, distance) return analyzer
def addConnection(citibike, origin, destination, duration): """ Adiciona un arco entre dos estaciones """ edge = gr.getEdge(citibike["connections"], origin, destination) if edge is None: gr.addEdge(citibike["connections"], origin, destination, duration) return citibike