def getRadius(analyzer, lat1, lon1, rad):
"""
sacarle accidente por acc
"""
lista=lt.newList()
actualizar(lista)
iterador= it.newIterator(analyzer['accidents'])
radius = rad # in miles
cuantos=0
while(it.hasNext(iterador)):
info = it.next(iterador)
lat2 = info['Start_Lat']
lon2 = info['Start_Lng']
date = info['Start_Time']
accidentDate = datetime.datetime.strptime(date, '%Y-%m-%d %H:%M:%S')
a = haversine(lon1, lat1, float(lon2), float(lat2))
if a <= radius:
cuantos += 1
dia= accidentDate.date().weekday()
camb = lt.getElement(lista, dia)
camb['veces']+=1
veces=0
mayor=''
for i in range(7):
el=lt.getElement(lista, i)
if(el['veces']> veces):
veces = el['veces']
mayor = el['dia']
print("los accidentes en ese radio fueron : "+ str(cuantos)+" , el dia de la semana con mayor \n accidentes en ese radio es: "+ str(mayor)+", con: "+ str(veces))
def cont_accidents(lst):
iterator=it.newIterator(lst)
sum_accidents=0
while it.hasNext(iterator):
date=it.next(iterator)
sum_accidents=lt.size(date["lstaccidents"])+ sum_accidents
return sum_accidents
def req21(Taxis, date1, date2, num):
num = int(num)
dates = om.values(Taxis["dateIndex"], date1, date2)
contador = 1
res = lt.newList('SINGLELINKED', compareDates)
while contador <= num:
mayor = 0
pos = 0
iter = 0
iterator = it.newIterator(dates)
while it.hasNext(iterator):
iter += 1
element = it.next(iterator)
pq = element["maxpq"]
x = imaxpq.max(pq)
if x != None:
if x > mayor:
mayor = x
pos = iter
pq = lt.getElement(dates, pos)
pq = pq["maxpq"]
y = imaxpq.delMax(pq)
lt.addLast(res, y)
contador += 1
return res
def recorridos(lista, mapa, rangoI, rangoF):
dicc = {}
iterador = it.newIterator(lista)
while it.hasNext(iterador):
fila = it.next(iterador)
edades = m.get(mapa, fila)
edades2 = en.getValue(edades)
iterador2 = it.newIterator(edades2)
while it.hasNext(iterador2):
eda = int(it.next(iterador2))
if eda >= rangoI and eda <= rangoF:
if fila not in dicc:
dicc[fila] = 1
else:
dicc[fila] += 1
return dicc
def requerimiento_7(citibike, rangoI, rangoF):
dicc = {}
lista = m.keySet(citibike['suscripcion'])
iterador = it.newIterator(lista)
while it.hasNext(iterador):
info = it.next(iterador)
if info == "Customer":
info2 = m.get(citibike['suscripcion'], info)
listaX = en.getValue(info2)
for i in range(0, len(listaX) - 1):
if int(listaX[i][0]) <= int(rangoF) and int(
listaX[i][0]) >= int(rangoI):
if listaX[i][1] + "-" + listaX[i][2] not in dicc:
dicc[listaX[i][1] + "-" + listaX[i][2]] = 1
else:
dicc[listaX[i][1] + "-" + listaX[i][2]] += 1
x = (max(dicc.values()))
for i in dicc:
if x == float(dicc[i]):
va = i
print("Las estaciones adyacentes más utilizadas son: " + str(va))
print("Con un total de viajes de: " + str(x))
print("")
print("Las estaciones que cumplen las condiciones son las siguientes: ")
for i in dicc:
llave = i
valor = dicc[i]
print(str(i) + ": " + str(dicc[i]))
def top3lessUsed(analyzer):
totaltree = om.newMap(omaptype="RBT", comparefunction=compareIds)
pqiterator = it.newIterator(vertexNames(analyzer))
while it.hasNext(pqiterator):
vert = int(it.next(pqiterator))
salidas = gr.outdegree(analyzer["graph"], str(vert))
destinos = gr.indegree(analyzer["graph"], str(vert))
usototal = salidas + destinos
if not om.contains(totaltree, usototal):
om.put(totaltree, usototal, str(vert))
else:
A = om.get(totaltree, usototal)
B = me.getValue(A)
om.put(totaltree, usototal, str(B)+","+str(vert))
estaciones = lt.newList(datastructure="ARRAY_LIST")
while lt.size(estaciones) < 3:
val = om.get(totaltree, om.minKey(totaltree))
val1 = me.getValue(val)
menortotal = val1.split(",")
for i in menortotal:
if lt.size(estaciones) < 3:
K = m.get(analyzer["nameIndex"], i)
L = me.getValue(K)
lt.addLast(estaciones, L)
om.deleteMin(totaltree)
return estaciones
def requerimiento_3(citibike):
lista = gr.vertices(citibike['grafo'])
dicc1 = {}
dicc2 = {}
dicc3 = {}
iterador = it.newIterator(lista)
while it.hasNext(iterador):
fila = it.next(iterador)
out = gr.outdegree(citibike['grafo'], fila)
ins = gr.indegree(citibike['grafo'], fila)
dicc1[fila] = out
dicc2[fila] = ins
dicc3[fila] = out + ins
salida = mayores(dicc1)
llegada = mayores(dicc2)
ambos = menores(dicc3)
nombres_salida = encontrar(dicc1, salida)
nombres_llegada = encontrar(dicc2, llegada)
nombres_ambos = encontrar(dicc3, ambos)
print("Las 3 mejores estaciones de salida son: ")
nombresI(nombres_salida, citibike)
print("\nLas 3 mejores estaciones de llegada son: ")
nombresF(nombres_llegada, citibike)
print("\nLas 3 peores estaciones de llegada/salida son: ")
for i in range(0, 3):
if mp.contains(citibike["namesI"], nombres_ambos[i]):
z = m.get(citibike["namesI"], nombres_ambos[i])
nombreX = en.getValue(z)
nombreI = nombreX["nombre"]
print(nombreI)
else:
z = m.get(citibike["namesF"], nombres_ambos[i])
nombreX = en.getValue(z)
nombreI = nombreX["nombre"]
print(nombreI)
def R4(tag,pais,num,catalog):
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
l1=model.lportyp(tag,pais,catalog['videos'])
if l1==None:
return 'No hay información para el país y/o tag ingresados.'
else:
orde=model.sortVideos(l1,lt.size(l1),model.cmpVideosbyLikes)[1]
final=model.sacar(num,orde)
if final==None:
return 'El número ingresado excede la cantidad de videos que cumplen con los requisitos.'
else:
c=''
i=it.newIterator(final)
n=0
while it.hasNext(i):
n+=1
v=it.next(i)
c=c+'\nPuesto '+str(n)+'\ntitle: '+v['title']+'; channel_title: '+v['channel_title']+'; publish_time: '+str(v['publish_time'])+'; views: '+str(v['views'])+'; likes: '+str(v['likes'])+'; dislikes: '+str(v['dislikes'])+'; tags: '+v['tags']+'\n'
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return ('Información de los '+str(num)+' videos con más views en '+pais+' con el tag de '+tag+':\n'+c,delta_time, delta_memory)
def R1(categoria,pais,num,catalog):
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
ID=model.categoriaporID(categoria,catalog)
if ID==None:
return 'Categoría no válida'
else:
l=model.lporcyp(ID,pais,catalog['videos'])
if l==None:
return 'País no válido.'
else:
l2=model.sortVideos(l,lt.size(l),model.cmpVideosbyViews)[1]
if num>lt.size(l2):
return 'El número ingresado excede la cantidad de videos que cumplen con los requisitos. Intente con un número igual o menor a '+str(lt.size(l))
else:
n=0
c=''
final=lt.subList(l2,1,num)
i=it.newIterator(final)
while it.hasNext(i):
n+=1
vid=it.next(i)
c=c+'\nPuesto '+str(n)+'\ntrending_date: '+str(vid['trending_date'])+'; title: '+vid['title']+'; channel_title: '+vid['channel_title']+'; publish_time: '+vid['publish_time']+'; views: '+vid['views']+'; likes: '+vid['likes']+ '; dislikes: '+vid['dislikes']+'\n'
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return ('Información de los '+str(num)+' videos con más views en '+pais+' para la categoría de '+categoria+':\n'+c,delta_time, delta_memory)
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 getClosestStation(analyzer, coords):
"""
Retorna el ID de la estacion mas cercana a las coordenadas dadas
Args:
analyzer: Estructura de datos principal
coords: Coordenadas de donde se quiere hallar la estacion mas cercana
"""
map = analyzer["stationinfo"]
stations = m.keySet(
map) #Obtiene los id de todas las estaciones en el analizador
ite = it.newIterator(stations)
closestDist = -1
closestID = ""
while it.hasNext(ite):
id = it.next(ite)
station = me.getValue(m.get(map, id))
dist = getDistance(station["Coordinates"], coords)
if closestDist == -1:
closestDist = dist
closestID = station["StationID"]
else:
if dist < closestDist:
closestDist = dist
closestID = station["StationID"]
return closestID
def stationsUsage(analyzer):
indegreePQ = pq.newMinPQ(cmpfunction=compareDegreeMax)
outdegreePQ = pq.newMinPQ(cmpfunction=compareDegreeMax)
lessUsedPQ = pq.newMinPQ(cmpfunction=compareDegreeMin)
vortexLst = gr.vertices(analyzer["graph"])
ite = it.newIterator(vortexLst)
while it.hasNext(ite):
station = it.next(ite)
StationName = getName(analyzer["stationinfo"], station)
#Se obtienen los valores de las estaciones que entran, que salen y su suma
indegree = gr.indegree(analyzer["graph"], station)
outdegree = gr.outdegree2(analyzer["graph"], station)
usage = outdegree + indegree
#Se crean entradas para organizar en el PQ
indegreeEntry = {"key": indegree, "station": StationName}
outdegreeEntry = {"key": outdegree, "station": StationName}
usageEntry = {"key": usage, "station": StationName}
#Se inserta cada entrada en los PQ correspondientes
pq.insert(indegreePQ, indegreeEntry)
pq.insert(lessUsedPQ, usageEntry)
pq.insert(outdegreePQ, outdegreeEntry)
return {"In": indegreePQ, "Out": outdegreePQ, "Usage": lessUsedPQ}
def parteC(analyzer, communityAreaOrigin, communityAreaDestination, rangeTime):
answer = {"bestTime": "No identificada", "route": None, "duration": inf}
graph = analyzer['AreaGraph']
rangeTime2 = rangeTime.split("-")
ls = aboutQuarterHour(rangeTime2[0])
totalq = allQuartersInRange(rangeTime)
totalq.append(ls)
endVertexes = []
vertexes = gr.vertices(graph)
iterator = it.newIterator(vertexes)
while it.hasNext(iterator):
vertex2 = it.next(iterator)
vertex2 = vertex2.split("-")
if communityAreaDestination == vertex2[0]:
endVertexes.append("-".join(vertex2))
for i in totalq:
initialVertex = communityAreaOrigin + "-" + i
if gr.containsVertex(graph, initialVertex):
print("A")
search = djk.Dijkstra(graph, initialVertex)
print("B")
for k in endVertexes:
if djk.hasPathTo(search, k):
duration = str(djk.distTo(search, k))
route = djk.pathTo(search, k)
if float(duration) < float(answer["duration"]):
answer["duration"] = duration
answer["route"] = route
answer["bestTime"] = i
return answer
def getAccidentsByRangeHour(analyzer, initialDate, fecha_final):
lst = om.values(analyzer['hourIndex'], initialDate, fecha_final)
lstiterator = it.newIterator(lst)
tot_accidents = 0
mapa = om.newMap(comparefunction=compareIds)
mapa2 = om.newMap(comparefunction=compareIds)
while (it.hasNext(lstiterator)):
lstdate = it.next(lstiterator)
accidentes_max = 0
i = 1
while i <= 4:
num = getaccidentesByRangeCodeHour(analyzer, lstdate, str(i))
tot_accidents += num
accidentes_max += num
i += 1
if om.contains(mapa2, i):
om.put(mapa2, i, int(om.get(mapa2, i)['value']) + num)
else:
om.put(mapa2, i, num)
om.put(mapa, accidentes_max, str(lstdate))
resu = om.newMap(comparefunction=compareIds)
max_sev = 0
sev = 0
for i in range(1, 6):
if om.contains(mapa2, i):
val = om.get(mapa2, i)
if val['value'] > max_sev:
max_sev = val['value']
sev = i
om.put(resu, i, val['value'])
else:
om.put(resu, i, 0)
om.put(resu, sev, max_sev)
return tot_accidents, om.get(mapa, om.maxKey(mapa)), resu
def dfsVertex(graph, search, vertex):
"""
Genera un recorrido DFS sobre el grafo graph
Args:
graph: El grafo a recorrer
source: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
queue.enqueue(search['pre'], vertex)
map.put(search['marked'], vertex, True)
lstadjacents = g.adjacents(graph, vertex)
adjiterator = it.newIterator(lstadjacents)
while it.hasNext(adjiterator):
adjvert = it.next(adjiterator)
if not map.contains(search['marked'], adjvert):
dfsVertex(
graph,
search,
adjvert,
)
queue.enqueue(search['post'], vertex)
stack.push(search['reversepost'], vertex)
return search
except Exception as exp:
error.reraise(exp, 'dfo:dfsVertex')
def bfsVertex(search, graph, source):
"""
Funcion auxiliar para calcular un recorrido BFS
Args:
search: Estructura para almacenar el recorrido
vertex: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
adjsqueue = queue.newQueue()
queue.enqueue(adjsqueue, source)
while not (queue.isEmpty(adjsqueue)):
vertex = queue.dequeue(adjsqueue)
visited_v = map.get(search['visited'], vertex)['value']
adjslst = g.adjacents(graph, vertex)
adjslstiter = it.newIterator(adjslst)
while (it.hasNext(adjslstiter)):
w = it.next(adjslstiter)
visited_w = map.get(search['visited'], w)
if visited_w is None:
dist_to_w = visited_v['distTo'] + 1
visited_w = {
'marked': True,
'edgeTo': vertex,
"distTo": dist_to_w
}
map.put(search['visited'], w, visited_w)
queue.enqueue(adjsqueue, w)
return search
except Exception as exp:
error.reraise(exp, 'bfs:bfsVertex')
def R4_EstadoMasAcc(analyzer, fechaIni, fechaFin):
lsta = om.values(analyzer["dateIndex"], fechaIni, fechaFin)
ite = it.newIterator(lsta)
entreFech = 0
while it.hasNext(ite):
lt_next = it.next(ite)["lstaccidents"]
entreFech += lt.size(lt_next)
# estado con más accidentes
estadoMas = None
estados = travel(lsta, ["State"])
contEst = {}
for i in estados:
if i in contEst:
contEst[i] += 1
else:
contEst[i] = 1
mayorV = max(contEst.keys)
estadoMas = mayorV.getValue
# fecha con más accidentes
fechaMas = None
fech = travel(lsta, ["Start_Time"])
contFech = {}
for i in fech:
if i in contFech:
contFech[i] += 1
else:
contFech[i] = 1
mayorValue = max(contFech.keys)
fechaMas = mayorValue.getValue
return (estadoMas, fechaMas)
def travel_map(Map, tree=False):
lst = om.keySet(Map) if tree else m.keySet(Map)
iter = it.newIterator(lst)
while it.hasNext(iter):
key = it.next(iter)
value = om.get(Map, key) if tree else m.get(Map, key)
yield key, (None if value is None else value["value"])
def recomendarRutas(analyzer, agerange):
ageGraph = crearGrafoEdad(analyzer, agerange)
mayorsalida = majorStart(ageGraph["grafo"])
mayordestino = majorDestiny(ageGraph["grafo"])
if mayorsalida == None or mayordestino == None:
return "No existen rutas para este rango de edad"
else:
pesos = lt.newList(datastructure="ARRAY_LIST")
pathiterator = it.newIterator(ageGraph["lista"])
while it.hasNext(pathiterator):
viaje = it.next(pathiterator)
if viaje["start station id"] == mayorsalida and viaje["end station id"] == mayordestino:
lt.addLast(pesos, viaje["tripduration"])
if lt.isEmpty(pesos):
econ = None
else:
mrg.mergesort(pesos, lessfunction)
econ = lt.firstElement(pesos)
sal = m.get(analyzer["nameIndex"], mayorsalida)
salnombre = me.getValue(sal)
dest = m.get(analyzer["nameIndex"], mayordestino)
destnombre = me.getValue(dest)
W = {"salida":salnombre,
"destino":destnombre,
"tiempo":econ}
return W
def printListContent(lst):
"""
Imprime el contenido de una lista
"""
iterator = it.newIterator(lst)
while it.hasNext(iterator):
print("- " + it.next(iterator))
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 findStationsInRange(citibike,ageRange,lst1,lst2):
"""
Añade a las listas pasadas por parámetro las estaciones que se encuentren dentro del rango ingresado
"""
iterator = it.newIterator(citibike['stations']) #Lugar donde se encuentra la información de todas las estaicones
while it.hasNext(iterator):
info = it.next(iterator)
ocurredDate = info['starttime']
year=int(ocurredDate[:4])
birthYear = int(info['birth year'])
if ageRange[0] == "0":
initRange = int(ageRange[0])
finalRange = int(ageRange[2]+ageRange[3])
elif ageRange == "60+" or ageRange=="60 +":
initRange = 60
finalRange = 120
else:
initRange = int(ageRange[0]+ageRange[1])
finalRange = int(ageRange[3]+ageRange[4])
if year - birthYear >= initRange and year - birthYear <= finalRange:
start = info['start station id']
end = info['end station id']
lt.addLast(lst1,start) #Se añade a la lista de salidas
lt.addLast(lst2,end) #Se añade a la lista de llegadas
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 getEdge(graph, vertexa, vertexb):
"""
Retorna el arco asociado a los vertices vertexa ---- vertexb
Args:
graph: El grafo sobre el que se ejecuta la operacion
vertexa: Vertice de inicio
vertexb: Vertice destino
Returns:
El arco que une los verices vertexa y vertexb
Raises:
Exception
"""
try:
element = map.get(graph['vertices'], vertexa)
lst = element['value']
itvertex = it.newIterator(lst)
while (it.hasNext(itvertex)):
edge = it.next(itvertex)
if (graph['directed']):
if (e.either(edge) == vertexa
and (e.other(edge, e.either(edge)) == vertexb)):
return edge
elif (e.either(edge) == vertexa
or (e.other(edge, e.either(edge)) == vertexa)):
if (e.either(edge) == vertexb
or (e.other(edge, e.either(edge)) == vertexb)):
return edge
return None
except Exception as exp:
error.reraise(exp, 'ajlist:getedge')
def req3(catalog, pais_a, pais_b):
#sacar capital a partir de país
entry1 = mp.get(catalog['map_countries'], pais_a)
vert1 = me.getValue(entry1)['CapitalName']
entry2 = mp.get(catalog['map_countries'], pais_b)
vert2 = me.getValue(entry2)['CapitalName']
grafo = catalog['graph_landing_points']
lista_ruta = lt.newList()
vertices = gr.vertices(catalog['graph_landing_points'])
landing_point_a = None
landing_point_b = None
for vert in lt.iterator(vertices):
vertexa = vert.split(sep='*')
if vertexa[1] == vert1:
landing_point_a = vert
elif vertexa[1] == vert2:
landing_point_b = vert
for vert in lt.iterator(vertices):
vertexb = vert.split(sep='*')
if vertexb[1] == vert2:
landing_point_b = vert
elif vertexb[1] == vert1:
landing_point_a = vert
MST = dijsktra.Dijkstra(grafo, landing_point_a)
distancia_total = dijsktra.distTo(MST, landing_point_b)
camino_pila = dijsktra.pathTo(MST, landing_point_b)
iterador = it.newIterator(camino_pila)
while it.hasNext(iterador):
ruta = st.pop(camino_pila)
lt.addLast(lista_ruta, ruta)
return distancia_total, lista_ruta
def adjacents(graph, vertex):
"""
Retorna una lista con todos los vertices adyacentes al vertice vertex
Args:
graph: El grafo sobre el que se ejecuta la operacion
vertex: El vertice del que se quiere la lista
Returns:
La lista de adyacencias
Raises:
Exception
"""
try:
element = map.get(graph['vertices'], vertex)
lst = element['value']
lstresp = lt.newList()
iter = it.newIterator(lst)
while (it.hasNext(iter)):
edge = it.next(iter)
v = e.either(edge)
if (v == vertex):
lt.addLast(lstresp, e.other(edge, v))
else:
lt.addLast(lstresp, v)
return lstresp
except Exception as exp:
error.reraise(exp, 'ajlist:adjacents')
def MejorHora(Taxis, límite_Inferior, límite_Superior, vertexA, vertexB):
Mejor = 200000
lstHours = lt.newList("SINGLE_LINKED")
for i in Taxis["lst"]:
timeHash = datetime.datetime.strptime(i, "%H:%M")
if (timeHash.hour > límite_Inferior.hour) and (timeHash.hour <
límite_Superior.hour):
lt.addLast(lstHours, timeHash)
if (timeHash.hour == límite_Inferior.hour
and timeHash.minute >= límite_Inferior.minute):
lt.addLast(lstHours, timeHash)
if (timeHash.hour == límite_Superior
and timeHash.minute <= límite_Superior.minute):
lt.addLast(lstHours, timeHash)
listiterator = it.newIterator(lstHours)
while it.hasNext(listiterator):
start_time = it.next(listiterator)
Graph = me.getValue(m.get(Taxis["Hash"], start_time.time()))
dijsktra = djk.Dijkstra(Graph, vertexA)
if djk.hasPathTo(dijsktra, vertexB):
path = djk.pathTo(dijsktra, vertexB)
path = lt.firstElement(path)
if path["weight"] < Mejor:
Mejor = path["weight"]
Tiempo = start_time.time()
return (Tiempo, Mejor)
def Dijkstra(graph, source):
"""
Implementa el algoritmo de Dijkstra
Args:
graph: El grafo de busqueda
source: El vertice de inicio
Returns:
Un nuevo grafo vacío
Raises:
Exception
"""
try:
search = initSearch(graph, source)
while not iminpq.isEmpty(search['iminpq']):
v = iminpq.delMin(search['iminpq'])
edges = g.adjacentEdges(graph, v)
if edges is not None:
edgesiter = it.newIterator(edges)
while (it.hasNext(edgesiter)):
edge = it.next(edgesiter)
relax(search, edge)
return search
except Exception as exp:
error.reraise(exp, 'dks:dijkstra')
def dfsVertex(search, graph, vertex):
"""
Funcion auxiliar para calcular un recorrido DFS
Args:
search: Estructura para almacenar el recorrido
vertex: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
adjlst = g.adjacents(graph, vertex)
adjslstiter = it.newIterator(adjlst)
while (it.hasNext(adjslstiter)):
w = it.next(adjslstiter)
visited = map.get(search['visited'], w)
if visited is None:
map.put(search['visited'],
w, {'marked': True, 'edgeTo': vertex})
dfsVertex(search, graph, w)
return search
except Exception as exp:
error.reraise(exp, 'dfs:dfsVertex')
def estaciones_por_rango(cont, rango):
camino_mostrar=[]
buscar_rango_hash=m.get(cont["births"],rango)
if buscar_rango_hash == None:
tupla = (0,0,0,0,0,0)
else:
variable1= me.getValue(buscar_rango_hash)
variable2 =m.get(variable1, "Intro")
variable3 = me.getValue(variable2)
variable4 = m.get(variable3, "Max")
variablesIntro = me.getValue(variable4)
variable5 =m.get(variable1, "Outro")
variable6 = me.getValue(variable5)
variable7 = m.get(variable6, "Max")
variablesOutro = me.getValue(variable7)
if variablesIntro[1] != variablesOutro[1]:
cont = minimumCostPaths(cont,variablesIntro[1])
camino = minimumCostPath(cont,variablesOutro[1])
tiempo = djk.distTo(cont["paths"],variablesOutro[1])
iterator = it.newIterator(camino)
while it.hasNext(iterator):
element=it.next(iterator)
camino_mostrar.append(element)
else:
camino="NINGUNO porque la estacion " +str(variablesIntro[1]) +" es la que mas viajes recibe y más arroja"
tiempo=0
tupla =(variablesIntro[1],variablesIntro[0],variablesOutro[1],variablesOutro[0],camino_mostrar,round(tiempo,2))
return tupla
