def pathTo(search, vertex):
"""
Retorna el camino entre el vertices source y el
vertice vertex
Args:
search: La estructura con el recorrido
vertex: Vertice de destingo
Returns:
Una pila con el camino entre el vertices source y el
vertice vertex
Raises:
Exception
"""
try:
if hasPathTo(search, vertex) is False:
return None
path = stack.newStack()
while vertex != search['source']:
stack.push(path, vertex)
vertex = map.get(search['visited'],
vertex)['value']['edgeTo']
stack.push(path, search['source'])
return path
except Exception as exp:
error.reraise(exp, 'bfs:pathto')
def test_top_pop():
"""
Este test prueba la creacion de una cola y que el orden de salida sea
el correcto para la estructura en cuestion, y que el tamaño se reduzca
para cada salida de objeto
"""
stack = st.newStack(list_type)
assert st.size(stack) == 0
assert st.isEmpty(stack)
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
total = st.size(stack)
while not (st.isEmpty(stack)):
top = st.top(stack)
assert (st.pop(stack) == top)
total -= 1
assert (total == st.size(stack))
def NewDate(trip):
CadaFecha = {
"bicicleta": None,
"Date": None,
'HoraInicio': None,
'HoraFin': None,
"SegundosUsada": None,
"SegundosParqueada": 0,
"RecorridosRealizados": None
}
CadaFecha["Date"] = (datetime.datetime.strptime(
(trip["starttime"][:19]), '%Y-%m-%d %H:%M:%S')).date()
CadaFecha["bicicleta"] = trip["bikeid"]
CadaFecha["HoraInicio"] = datetime.datetime.strptime(
(trip["starttime"][:19]), '%Y-%m-%d %H:%M:%S')
CadaFecha["HoraFin"] = datetime.datetime.strptime((trip["stoptime"][:19]),
'%Y-%m-%d %H:%M:%S')
Delta = CadaFecha["HoraFin"] - CadaFecha["HoraInicio"]
SegundosPorViaje = (Delta.total_seconds())
CadaFecha["SegundosUsada"] = SegundosPorViaje
CadaFecha["RecorridosRealizados"] = stack.newStack()
stack.push(CadaFecha["RecorridosRealizados"],
(trip["start station id"], trip["end station id"]))
return CadaFecha
def routeByResistance(citibike, initialStation, resistanceTime):
try:
dijsktra = djk.Dijkstra(citibike["connections"], initialStation)
vertices = gr.vertices(citibike["connections"])
iterator = it.newIterator(vertices)
trueStations = st.newStack()
stops = m.newMap(numelements=768,
maptype="CHAINING",
loadfactor=1,
comparefunction=compareStopIds)
while it.hasNext(iterator):
element = it.next(iterator)
if element != initialStation and djk.hasPathTo(dijsktra, element) is True:
if m.get(stops, element) is None or getElement(m.get(stops, element))["value"] is False:
if djk.distTo(dijsktra,element) <= resistanceTime:
pila= djk.pathTo(dijsktra,element)
pila2 = djk.pathTo(dijsktra,element)
size_pila = 0
repetition = False
lon_pila = st.size(pila)
watcher = {"value": True}
while size_pila < lon_pila and repetition == False:
pop = st.pop(pila)["vertexB"]
if m.get(stops,pop) is None or getElement(m.get(stops,pop))["value"] is False:
m.put(stops,pop,watcher)
else:
repetition = True
watcher["value"]=False
size_pila +=1
if repetition == False:
st.push(trueStations, pila2)
return trueStations
except:
return None
def addBike(citibike, origin, destination, duration, bike, startTime,stopTime):
bikes = m.get(citibike["bikes"], bike)
initialDate = (datetime.datetime.strptime(startTime[0:19], '%Y-%m-%d %H:%M:%S')).date()
finalTime = stopTime[11:16]
initialTime = startTime[11:16]
if bikes is None:
datesHash = m.newMap(numelements=784,
maptype="PROBING",
loadfactor=0.5,
comparefunction=compareStopIds)
m.put(citibike["bikes"], bike, datesHash)
if m.get(me.getValue(m.get(citibike["bikes"], bike)), initialDate) is None:
datesHash = me.getValue(m.get(citibike["bikes"], bike))
bikes = {"routes":None,
"useTime":0,
"breakTime":0,
"times": None}
bikes["routes"] = lt.newList(datastructure="ARRAY_LIST",
cmpfunction=compareroutes)
bikes["times"]=st.newStack()
m.put(datesHash,initialDate, bikes)
datesHash = me.getValue(m.get(me.getValue(m.get(citibike["bikes"], bike)), initialDate))
if lt.size(datesHash["routes"]) == 0:
lt.addLast(datesHash["routes"], origin)
else:
lt.addLast(datesHash["routes"], destination)
breakTime = seeTime(st.top(datesHash["times"]),initialTime)
datesHash["breakTime"]+=breakTime
datesHash["useTime"]+=duration/60
st.push(datesHash["times"], finalTime)
def pathTo(search, vertex):
"""
Retorna el camino entre source y vertex
en una pila.
Args:
search: La estructura de busqueda
vertex: El vertice de destino
Returns:
Una pila con el camino entre source y vertex
Raises:
Exception
"""
try:
if hasPathTo(search, vertex) is False:
return None
path = stack.newStack()
while vertex != search['source']:
visited_v = map.get(search['visited'], vertex)['value']
edge = visited_v['edgeTo']
stack.push(path, edge)
vertex = e.either(edge)
return path
except Exception as exp:
error.reraise(exp, 'dks:pathto')
def musicaParaEstudiar(catalog, minInstrumental, maxInstrumental, minTempo,
maxTempo):
mapa = catalog['RepsPor_instrumentalness']
Reproducciones_Rango_Instrumentalness = model.Reproducciones_Rango_Instrumentalness(
mapa, minInstrumental, maxInstrumental)
lista_pistas = model.Lista_unicas_Instrumentalness(
Reproducciones_Rango_Instrumentalness)
#Obtenemos la lista
lista_pistas = mp.valueSet(lista_pistas)
#Organizamos por tempo con mapa
om_pistas_tempo = model.OM_pistas_tempo(lista_pistas)
lista_resultado = model.PistasRangoTempo(om_pistas_tempo, minTempo,
maxTempo)
cantidad = 0
retornar = stk.newStack()
for lista in lt.iterator(lista_resultado):
cantidad = cantidad + lt.size(lista)
aleatorios_1 = sample(range(1, lt.size(lista_resultado)), 5)
for pos1 in aleatorios_1:
lista = lt.getElement(lista_resultado, pos1)
pos2 = randint(1, lt.size(lista))
elemento = lt.getElement(lista, pos2)
stk.push(retornar, elemento)
return cantidad, retornar
def pathTowithLimiter(search, vertex, grafo, limit):
"""
Retorna el camino entre el vertices source y el
vertice vertex
Args:
search: La estructura con el recorrido
vertex: Vertice de destingo
Returns:
Una pila con el camino entre el vertices source y el
vertice vertex
Raises:
Exception
"""
try:
if hasPathTo(search, vertex) is False:
return None
path = stk.newStack()
TIEMPO = 0
limit=limit*60
while vertex != search['source']:
stk.push(path, vertex)
papu=vertex
vertex = map.get(search['visited'], vertex)['value']['edgeTo']
edge=graph.getEdge(grafo,vertex,papu)
t=int(edge['weight'])+1200
TIEMPO+=t
if TIEMPO>limit:
return None
stk.push(path, search['source'])
return path,TIEMPO
except Exception as exp:
error.reraise(exp, 'dfs:pathtotuniao')
def test_error_pop():
"""
Este test busca comprobar que es imposible eliminar un objeto
de una pila vacia
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
with pytest.raises(Exception):
st.pop(stack)
def test_push_pop():
"""
Este test prueba que la cola pueda manejar inserciones y eliminaciones
de forma correcta siguiendo un orden establecido, y que no quede
referencia al objeto sacado despues de haberlo removido de la
cola
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
st.push(stack, book5)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book6)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book3)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book10)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book1)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book2)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
assert (st.size(stack) == 4)
assert book9 == st.pop(stack)
assert book7 == st.pop(stack)
assert book4 == st.pop(stack)
assert book8 == st.pop(stack)
assert (st.size(stack) == 0)
def Req3MejorHorario(chicagoAnalyzer, inferior, superior, idStart, idEnd):
"""
Req C\n
Returns: Tiempo de inicio del trayecto, las community areas en medio del trayecto, la duracion del trayecto
"""
#Si no contiene el vertice el proceso se corta de raiz y no hace mas operaciones innecesarias DE MORGAN
if not (gr.containsVertex(chicagoAnalyzer['communityTrip'], idStart)
and gr.containsVertex(chicagoAnalyzer['communityTrip'], idStart)):
return 0
#Lista con las community areas, se entregara como parte de la respuesta
comRoute = lt.newList(datastructure='ARRAY_LIST', cmpfunction=compareDict)
#Conseguir los viajes que sucedieron en el rango de hora especificado
keysInRange = om.keys(chicagoAnalyzer['timeTrip'], inferior, superior)
#Si el rango de horas no contiene alguna hora de trayecto
if (lt.isEmpty(keysInRange)): return 1
#Dijkstra para conseguir la duracion y las comunnity areas para llegar al destino
structure = djk.Dijkstra(chicagoAnalyzer['communityTrip'], idStart)
tripDuration = djk.distTo(structure, idEnd)
path = djk.pathTo(structure, idEnd) if djk.hasPathTo(
structure, idEnd) else st.newStack()
#Se usa _ porque la variable no importa en si, solo es necesario hacerle pop al stack
for _ in range(st.size(path)):
lt.addLast(comRoute, st.pop(path))
#Para conseguir el tiempo en formato Hora:Minuto
#Dado que hay dos for anidados, en comparacion a la complejidad del resto del algoritmo
startTime = None
for time in range(lt.size(keysInRange)):
#starTime antes de hacerle format
startTimeb4F = lt.getElement(keysInRange, time)
route = om.get(chicagoAnalyzer['timeTrip'], startTimeb4F)['value']
#Para conseguir la id del trayecto y con la funcion de getEdgebyTripID() se conseguir ambos vertices
for timeID in range(lt.size(route)):
start, end = getEdgebyTripID(chicagoAnalyzer,
lt.getElement(route, timeID))
#Verificar que sea el arco que buscamos
if start == idStart and lt.isPresent(comRoute, end):
startTime = f'{startTimeb4F.hour:02}:{startTimeb4F.minute:02}'
return startTime, comRoute, tripDuration
return startTime, comRoute, tripDuration
def initStructures(graph):
"""
Args:
graph: El grafo a examinar
source: El vertice fuente
Returns:
Estructura de busqueda inicializada
Raises:
Exception
"""
try:
search = {
'edgeTo': None,
'marked': None,
'onStack': None,
'cycle': None
}
search['edgeTo'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction']
)
search['marked'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
search['onStack'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction']
)
search['cycle'] = st.newStack()
vertices = g.vertices(graph)
for vert in lt.iterator(vertices):
map.put(search['marked'], vert, False)
map.put(search['onStack'], vert, False)
return search
except Exception as exp:
error.reraise(exp, 'cycle:init')
def test_sizeStack():
"""
Se prueba la creacion de una cola y la relacion con el
tamaño al ingresar datos
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
assert st.size(stack) == 10
def test_pushElements():
"""
Se prueba la creacion de una nueva pila, se agregan todos los datos
creados por sistema y se imprime su valor
"""
stack = st.newStack(list_type)
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
iterator = it.newIterator(stack)
while it.hasNext(iterator):
element = it.next(iterator)
print(element)
def DepthFirstOrder(graph):
try:
search = {
'marked': None,
'pre': None,
'post': None,
'reversepost': None
}
search['pre'] = queue.newQueue()
search['post'] = queue.newQueue()
search['reversepost'] = stack.newStack()
search['marked'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
lstvert = g.vertices(graph)
for vertex in lt.iterator(lstvert):
if not (map.contains(search['marked'], vertex)):
dfsVertex(graph, search, vertex)
return search
except Exception as exp:
error.reraise(exp, 'dfo:DFO')
def test_infoElements():
"""
Este test busca confirmar que los datos se almacenen de forma correcta
y que sean los valores correctos en el orden apropiado de la estructura.
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
elem = st.top(stack)
assert (st.size(stack) == 10)
assert (elem == book9)
elem = st.pop(stack)
assert (st.size(stack) == 9)
assert (elem == book9)
elem = st.pop(stack)
assert (st.size(stack) == 8)
assert (elem == book7)
elem = st.top(stack)
assert (st.size(stack) == 8)
assert (elem == book4)
st.push(stack, book9)
assert (st.size(stack) == 9)
elem = st.top(stack)
assert (elem == book9)
def DepthFirstSearch2(graph, source, components):
"""
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:
search = {
'source': source,
'visited': None,
}
search['visited'] = map.newMap(
numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
path = stk.newStack()
cycles = [[]]
weights = [0]
map.put(search['visited'], source, {'marked': True, 'edgeTo': None})
dfs_extra(search, graph, source, components, path, cycles, weights)
cycles.pop()
weights.pop()
for i in range(len(weights)):
weights[i]
return (cycles, weights)
except Exception as exp:
error.reraise(exp, 'dfs:DFS')
def musicaParaFestejar(catalog, minDance, maxDance, minEnergy, maxEnergy):
#mapa ordenado : llaves= dance de la rep, valor: reproducciones con ese dance
mapa_inicial = catalog['RepsPor_danceability']
#lista de todas las reproducciones cuyo dance está en el rango parametro||||
# ||||| por esto, de aqui en adelante todo está dentro del rango de Danceability
#esto es una lista de las listas de reps por cada valor de danceability
repsEn_Rango_danceability = model.repsPor_Rango_danceability(
mapa_inicial, minDance, maxDance)
#map/hashtable de PISTAS con id de pista/track_id como llaves, valor: artist_id, danceability, energy
pistasEn_Rango_danceability = model.ListReps_to_HashPistasUnicas(
repsEn_Rango_danceability)
#se convierte a lista
pistasEn_Rango_danceability = mp.valueSet(pistasEn_Rango_danceability)
# se convierte a un mapa ordenado por Energy : llave=ValorEnergy, Valor=listadePistas con ese valor de energy
Om_pistasEn_Rango_danceability = model.ListPistas_to_OMPistas_porEnergy(
pistasEn_Rango_danceability)
#se obtienen las que tienen el energy en el rango:
lista_resultado = model.PistasPor_Rango_energy(
Om_pistasEn_Rango_danceability, minEnergy, maxEnergy)
cantidad = 0
retornar = stk.newStack()
for pistasConEnergy in lt.iterator(lista_resultado):
cantidad = cantidad + lt.size(pistasConEnergy)
'''if stk.size(retornar) < 5 and :
for track in lt.iterator(pistasConEnergy):
if stk.size(retornar) < 5:
stk.push(retornar, track)'''
aleatorios_1 = sample(range(1, lt.size(lista_resultado)), 5)
for pos1 in aleatorios_1:
lista = lt.getElement(lista_resultado, pos1)
pos2 = randint(1, lt.size(lista))
elemento = lt.getElement(lista, pos2)
stk.push(retornar, elemento)
return cantidad, retornar
def stack():
stack = st.newStack('SINGLE_LINKED')
return stack
def ConsultaRutasCirculares(bikes, vertice, inferior, superior):
ListaCompleta = ListaAdyacentes(bikes, vertice)
lstiterator = it.newIterator(ListaCompleta)
conteoCaminos = 0
stackfinal = stack.newStack()
CadaRuta = queue.newQueue()
ConteoDeRutas = 0
while it.hasNext(lstiterator):
eachaStation = it.next(lstiterator)
primerRecorrido = getEdge(bikes['grafo'], vertice, eachaStation)
search = minimumCostPaths(bikes, eachaStation)
colados = minimumCostPath(bikes, vertice)
if colados and ((stack.size(colados)) * 60 * 20) < superior:
pesoporestaciones = (stack.size(colados)) * 60 * 20
pesocamino = 0
pesoTOTALdos = pesoporestaciones + pesocamino + primerRecorrido[
'weight']
CadaRuta = queue.newQueue()
queue.enqueue(CadaRuta, primerRecorrido)
while (not stack.isEmpty(colados)) and (pesoTOTALdos < superior):
stopDOS = stack.pop(colados)
pesoTOTALdos += stopDOS['weight']
queue.enqueue(CadaRuta, stopDOS)
if inferior < pesoTOTALdos < superior and CadaRuta:
CadaRuta["PesoPorRuta"] = pesoTOTALdos
ConteoDeRutas += 1
stack.push(stackfinal, CadaRuta)
return ConteoDeRutas, stackfinal
#NO BORRAR LO COMENTADO ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
#NO BORRAR LO COMENTADO ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
#NO BORRAR LO COMENTADO ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
"""
#Req 2 funcionando
#Req 2 funcionando
#Req 2 funcionando
ListaCompleta = ListaAdyacentes(bikes, vertice)
lstiterator=it.newIterator(ListaCompleta)
conteoCaminos = 0
stackfinal = stack.newStack()
while it.hasNext(lstiterator):
eachaStation=it.next(lstiterator)
primero = minimumCostPaths(bikes, vertice)
primerpeso = distTo(primero, eachaStation)
FirsPath = minimumCostPath(primero, eachaStation)
Firststop = stack.pop(FirsPath)
segundo = minimumCostPaths(bikes, eachaStation)
SecondPath = minimumCostPath(bikes, vertice)
if SecondPath:
pesoconjunto = (distTo(segundo, vertice)) + primerpeso
stack.push(SecondPath, Firststop)
pathlen = stack.size(SecondPath)
pesofinal = pesoconjunto + (pathlen*20*60)
if inferior < pesofinal < superior:
conteoCaminos += 1
SecondPath["PesoTotal"]=pesofinal
stack.push(stackfinal, SecondPath)
return conteoCaminos, stackfinal
"""
"""
def stack():
stack = st.newStack('ARRAY_LIST')
return stack
