def minimumJumpsPath(analyzer, vertexb): """ Retorna la ruta de saltos mínima entre el punto de conexión inicial y un punto de conexión destino """ paths = analyzer['minimumjumpspaths'] return bfs.pathTo(paths, vertexb)
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 Repeticiones(citibike, rangoI, rangoF): stationI = citibike['StationI'] stationF = citibike['StationF'] edadI = mp.keySet(stationI) edadF = mp.keySet(stationF) infoI = recorridos(edadI, stationI, rangoI, rangoF) infoF = recorridos(edadF, stationF, rangoI, rangoF) sI = maximoDicc(infoI) sF = maximoDicc(infoF) print( "La estación de la que más personas salen, con ese rango de edad es: " + str(sI)) print( "La estación de la que más personas llegan, con ese rango de edad es: " + str(sF)) camino = bfs.BreadhtFisrtSearch(citibike['graph'], sI) caminofinal = bfs.hasPathTo(camino, sF) print("Su camino es el siguiente: ") if caminofinal == True: ultimo = bfs.pathTo(camino, sF) iterador = it.newIterator(ultimo) while it.hasNext(iterador): fila = it.next(iterador) print(fila) else: print("No hay camino para ese rango de edades")
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 getMSTroots(catalog, mst_graph): roots = lt.newList(datastructure='ARRAY_LIST') mst_vertices = gr.vertices(mst_graph) i = 0 # * Ecuentra todas las 'raices' del MST (nodos/vertices con un indegree de 0) while i <= lt.size(mst_vertices): vertex = lt.getElement(mst_vertices, i) indegree = gr.indegree(mst_graph, vertex) outdegree = gr.outdegree(mst_graph, vertex) if indegree == 0 and outdegree > 0: # Outdegree > 0 para asegurar que si se conecta con algo más lt.addLast(roots, vertex) i += 1 longest_branch_dist = 0 longest_branch_bfs = None # Por cada raiz que se econtro, calcula la rama más larga entre esta y una hoja. Guarda la rama más larga entre todas las rices. for root in lt.iterator(roots): info = longestBranch(catalog, mst_graph, root) if info[0] > longest_branch_dist: longest_branch_dist = info[0] end_vertex = info[1] longest_branch_bfs = info[2] path = bfs.pathTo( longest_branch_bfs, end_vertex) # Camino entre la raiz y hoja de la rama más larga return path, longest_branch_dist
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 bfsReq4(analyzer): """Retorna un dict que es la rama más larga con su landing Point final. Args: analyzer Returns: infoRama[dict]: Rama con mayor longitud. """ newBFS = analyzer["BFS"] # BFS del grafo con el vétrtice Bogota-Colombia. distanciaMax = 0 # Se inicia la distancia máxima en 0. infoRama = None for element in (newBFS['visited']['table']['elements'] ): # Por cada elemento se extrae su valor. distancia = element['value'] if distancia is not None: if distancia[ 'distTo'] > distanciaMax: # Se compara la distancua máxima con la del elemento actual. distanciaMax = distancia['distTo'] infoRama = element['value'] path = bfs.pathTo(newBFS, infoRama['edgeTo']) return ( infoRama, path ) # Se retorna la infromación del LP con mayor distancia de Bogota-Colombia.
def path(analyzer, INFOlp1, INFOlp2): varBFS = bfs.BreadhtFisrtSearch(analyzer['landingPoints'], INFOlp1) if bfs.hasPathTo( varBFS, INFOlp2 ) is True: # Si existe un path se retorna la distancia entre el LP destino y origen, junto con el path entre estos dos. path = bfs.pathTo(varBFS, INFOlp2) return path
def rutaresistencia(analyzer, estacion, tiempo): if m.get(analyzer['stationsStart'],estacion) is not None: lista1 = lt.newList("ARRAY_LIST") adyacentes = gr.adjacents(analyzer['graph'], estacion) connectedComponents(analyzer) for h in range (adyacentes['size']): adyacente= lt.getElement(adyacentes,h) fcc = sameCC(analyzer, estacion, adyacente) if fcc: tiempo=0 analyzer['paths'] = bfs.BreadhtFisrtSearch(analyzer["graph"], adyacente) caminos = bfs.pathTo(analyzer["paths"], estacion) primero= caminos['first'] siguiente = primero['next'] for i in range(caminos['size']-1): infoin = primero['info'] if siguiente is not None: infoul = siguiente['info'] arco = gr.getEdge(analyzer["graph"], infoin, infoul) if arco is not None: tiempo += float(arco["weight"]) primero = primero['next'] siguiente = siguiente['next'] lt.addLast(caminos,tiempo) lt.addLast(lista1, caminos) listafinal= lt.newList("ARRAY_LIST") if lista1 is not None: tmi = int(tiempo)*60 while (not stack.isEmpty(lista1)): parada = stack.pop(lista1) if parada['last']['info'] <= tmi : lt.addLast(listafinal, parada) print("la cantidad de rutas es : "+ str(listafinal['size'])) for i in range( listafinal['size'] ): actual = lt.getElement(listafinal,i) print("ruta no: "+ str(i+1)) for j in range(actual['size']-1): info= m.get(analyzer['stationsStart'], lt.getElement(actual,j))['value'] print(str(j+1)+". " + info["nombre"]) print("con una duracion estimada de: "+str(int(actual['last']['info'])/60)+" minutos")
def req7(ip1, ip2, analyzer): """Encuentra si existe un path entre ip1 e ip2 Args: analyzer ip1: Primera dirección de IP ip2: Segunda dirección de IP """ responseip1 = IP.get(ip1, api_key='free') # Se obtiene la información de ip1 responseip2 = IP.get(ip2, api_key='free') # Se obtiene la información de ip2 latitudeIP1 = responseip1.latitude # Se obtiene la latitud de ip1 longitudeIP1 = responseip1.longitude # Se obtiene la longitud de ip1 latitudeIP2 = responseip2.latitude # Se obtiene la latitud de ip2 longitudeIP2 = responseip2.longitude # Se obtiene la longitud de ip2 masCercano_1 = lpMasCercano(analyzer, latitudeIP1, longitudeIP1)[1] lp1 = lt.getElement( mp.get(analyzer['infoLandingPoints'], masCercano_1)['value']['lista'], 1) masCercano_2 = lpMasCercano(analyzer, latitudeIP2, longitudeIP2)[1] lp2 = lt.getElement( mp.get(analyzer['infoLandingPoints'], masCercano_2)['value']['lista'], 1) varBFS = bfs.BreadhtFisrtSearch(analyzer['landingPoints'], lp1) if bfs.hasPathTo( varBFS, lp2 ) is True: # Si existe un path se retorna la distancia entre el LP destino y origen, junto con el path entre estos dos. distancia = rutaReq7(varBFS, lp2) path = bfs.pathTo(varBFS, lp2) return (distancia['distTo'], path) else: return False # En caso de que no encuentre un path la función retorna False.
def doBFS(edgeTo): minigraph = gr.newGraph(datastructure='ADJ_LIST', directed=True, size=1000, comparefunction=cmplandingpoints) keys = mp.keySet(edgeTo) firstVertex = lt.getElement(keys, 1) for i in lt.iterator(keys): vertexA = i vertexB = mp.get(edgeTo, i)['value']['vertexA'] gr.insertVertex(minigraph, vertexA) gr.insertVertex(minigraph, vertexB) for i in lt.iterator(keys): vertexA = i vertexB = mp.get(edgeTo, i)['value']['vertexA'] weight = mp.get(edgeTo, i)['value']['weight'] gr.addEdge(minigraph, vertexA, vertexB, weight) gr.addEdge(minigraph, vertexB, vertexA, weight) distNsize = {} vertexes = gr.vertices(minigraph) mayor = 0 recorrido = bfs.BreadhtFisrtSearch(minigraph, firstVertex) for vertexB in lt.iterator(vertexes): dist = bfs.pathTo(recorrido, vertexB) if dist is not None: size = lt.size(dist) distNsize[size] = dist if size > mayor: mayor = size for i in distNsize.keys(): if i == mayor: caminomaslargo = distNsize[i] return mayor, caminomaslargo, minigraph
def BFS_PathTo(search, vertex): bfs.pathTo(search, vertex)
def test_dfs(graph): search = bfs.BreadhtFisrtSearch(graph, 'Yopal') assert bfs.hasPathTo(search, 'Manizales') is True path = bfs.pathTo(search, 'Manizales') assert stk.size(path) == 4
def cercanas(analyzer, lon1,lat1,lon2,lat2): llaves = m.keySet(analyzer['stationsStart']) ite = it.newIterator(llaves) menor=1000 inicio='' ninicio="" while(it.hasNext(ite)): info=it.next(ite) actual = m.get(analyzer['stationsStart'],info)['value'] latitud = float(actual["latitud"]) longitud= float(actual["longitud"]) distancia= haversine(float(lon1),float(lat1),longitud,latitud) if distancia < menor: menor=distancia inicio=info ninicio = actual["nombre"] print("la estacion mas cercana al punto inicial es : "+ninicio) llaves1 = m.keySet(analyzer['stationsEnd']) ite1 = it.newIterator(llaves1) menor1=1000000000 final='' nfinal="" while(it.hasNext(ite1)): info=it.next(ite1) actual=m.get(analyzer['stationsEnd'],info)['value'] latitud = float(actual["latitud"]) longitud = float(actual["longitud"]) distancia = haversine(float(lon2),float(lat2),longitud,latitud) if distancia < menor1: menor1=distancia final=info nfinal = actual["nombre"] print("la estacion mas cercana al punto final es : "+nfinal) analyzer['paths'] = bfs.BreadhtFisrtSearch(analyzer['graph'], inicio) caminos = bfs.pathTo(analyzer['paths'], final) pasos=1 print(caminos['size']) tiempo=0 if caminos is not None: primero= caminos['first'] siguiente = primero['next'] ultimo=caminos['last'] for i in range(caminos['size']-1): infoin = primero['info'] if siguiente is not None: infoul = siguiente['info'] arco = gr.getEdge(analyzer["graph"], infoin, infoul) if arco is not None: tiempo += float(arco["weight"]) info=m.get(analyzer['stationsStart'],infoin)['value'] print(str(pasos)+". "+ info["nombre"]) pasos+=1 primero = primero['next'] siguiente = siguiente['next'] if ultimo is not None: info=m.get(analyzer['stationsEnd'],ultimo['info'])['value'] print(str(pasos)+". "+ info["nombre"]) print("el tiempo estimado es: "+ str(tiempo/60))
def rutasPorEdad(analyzer, edad): cuantosinicio=0 ninicio='' cuantosfinal=0 nfinal='' llaves = m.keySet(analyzer['stationsStart']) ite = it.newIterator(llaves) while(it.hasNext(ite)): info=it.next(ite) actual=m.get(analyzer['stationsStart'],info)['value'] nocuantos=0 if edad=="0-10": nocuantos = actual["edades"]["0-10"] elif edad=="11-20": nocuantos = actual["edades"]["11-20"] elif edad=="21-30": nocuantos = actual["edades"]["21-30"] elif edad=="31-40": nocuantos = actual["edades"]["31-40"] elif edad=="41-50": nocuantos = actual["edades"]["41-50"] elif edad=="51-60": nocuantos = actual["edades"]["51-60"] elif edad=="60+": nocuantos = actual["edades"]["60+"] if nocuantos >= cuantosinicio : cuantosinicio = nocuantos ninicio = info llaves1 = m.keySet(analyzer['stationsEnd']) ite1 = it.newIterator(llaves1) while(it.hasNext(ite1)): info=it.next(ite1) actual=m.get(analyzer['stationsEnd'],info)['value'] nocuantos=0 if edad=="0-10": nocuantos = actual["edades"]["0-10"] elif edad=="11-20": nocuantos = actual["edades"]["11-20"] elif edad=="21-30": nocuantos = actual["edades"]["21-30"] elif edad=="31-40": nocuantos = actual["edades"]["31-40"] elif edad=="41-50": nocuantos = actual["edades"]["41-50"] elif edad=="51-60": nocuantos = actual["edades"]["51-60"] elif edad=="60+": nocuantos = actual["edades"]["60+"] if nocuantos >= cuantosfinal : cuantosfinal = nocuantos nfinal = info analyzer['paths'] = bfs.BreadhtFisrtSearch(analyzer['graph'], ninicio) caminos = bfs.pathTo(analyzer['paths'], nfinal) pasos=1 tiempo=0 print(caminos['size']) primero= caminos['first'] siguiente = primero['next'] ultimo=caminos['last'] for i in range(caminos['size']-1): infoin = primero['info'] if siguiente is not None: infoul = siguiente['info'] arco = gr.getEdge(analyzer["graph"], infoin, infoul) if arco is not None: tiempo += float(arco["weight"]) info=m.get(analyzer['stationsStart'],infoin)['value'] print(str(pasos)+". "+ info["nombre"]) pasos+=1 primero = primero['next'] siguiente = siguiente['next'] if ultimo is not None: info = m.get(analyzer['stationsEnd'],ultimo['info'])['value'] print(str(pasos)+". "+ info["nombre"]) print("el tiempo estimado es: "+ str(tiempo/60))
from DISClib.Algorithms.Graphs import bfs from DISClib.ADT import list as lt #Ejemplo uso de BFS def comparefunction(searchname, element): if (searchname == element['key']): return 0 elif (searchname < element['key']): return -1 return 1 grafo = gr.newGraph(datastructure='ADJ_LIST', directed=True, size=14000, comparefunction=comparefunction) #DFS gr.insertVertex(grafo, "a") gr.insertVertex(grafo, "b") gr.insertVertex(grafo, "c") gr.addEdge(grafo, "a", "b") gr.addEdge(grafo, "c", "b") search = bfs.BreadhtFisrtSearch(grafo, "b") path = bfs.pathTo(search, "a") print(path)