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 hasJumpsPathTo(analyzer, vertexb):
"""
Retorna si existe una ruta de saltos mínima entre el punto de
conexión inicial y un punto de conexión destino
"""
paths = analyzer['minimumjumpspaths']
return bfs.hasPathTo(paths, vertexb)
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 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 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 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 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