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
