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)
