def test_peek_dequeue():
"""
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
"""
queue = q.newQueue(list_type)
assert q.size(queue) == 0
assert q.isEmpty(queue)
queue = q.newQueue(list_type)
q.enqueue(queue, book5)
q.enqueue(queue, book6)
q.enqueue(queue, book3)
q.enqueue(queue, book10)
q.enqueue(queue, book1)
q.enqueue(queue, book2)
q.enqueue(queue, book8)
q.enqueue(queue, book4)
q.enqueue(queue, book7)
q.enqueue(queue, book9)
total = q.size(queue)
while not (q.isEmpty(queue)):
peek = q.peek(queue)
assert(q.dequeue(queue) == peek)
total -= 1
assert (total == q.size(queue))
def efe3(actor, PsXNomDeAct, LlavesCriteriosAdicionales):
n = 0
ColaActores = qe.newQueue()
ColaAdicionales = qe.newQueue()
Puntajes = []
Directores = lt.newList()
Centinela = True
while Centinela == True:
if mp.contains(PsXNomDeAct, actor + str(n)):
pelicula = mp.get(PsXNomDeAct, actor + str(n))["value"]
qe.enqueue(
ColaActores,
pelicula["title"] + " (" + pelicula["release_date"][-4:] + ")")
Puntajes.append(float(pelicula["vote_average"]))
lt.addLast(Directores, pelicula["director_name"])
n = n + 1
else:
Centinela = False
if len(Puntajes) != 0:
qe.enqueue(ColaAdicionales,
[LlavesCriteriosAdicionales[0],
qe.size(ColaActores)])
qe.enqueue(
ColaAdicionales,
[LlavesCriteriosAdicionales[1],
sum(Puntajes) / len(Puntajes)])
mD = statistics.mode(Directores["elements"])[0][0]
qe.enqueue(ColaAdicionales, [LlavesCriteriosAdicionales[2], mD])
return (ColaActores, ColaAdicionales)
else:
qe.enqueue(ColaAdicionales, 0)
qe.enqueue(ColaAdicionales, 0)
qe.enqueue(ColaAdicionales, "No hay directores con colaboraciones")
return (ColaActores, ColaAdicionales)
def efe12(productora, PsXComDePro, LlavesCriteriosAdicionales):
n = 0
ColaPeliculas = qe.newQueue()
ColaAdicionales = qe.newQueue()
Puntajes = []
Centinela = True
while Centinela == True:
if mp.contains(PsXComDePro, productora + str(n)):
pelicula = mp.get(PsXComDePro, productora + str(n))["value"]
qe.enqueue(
ColaPeliculas,
pelicula["title"] + " (" + pelicula["release_date"][-4:] + ")")
Puntajes.append(float(pelicula["vote_average"]))
n = n + 1
else:
Centinela = False
if len(Puntajes) != 0:
qe.enqueue(ColaAdicionales,
[LlavesCriteriosAdicionales[0],
qe.size(ColaPeliculas)])
qe.enqueue(
ColaAdicionales,
[LlavesCriteriosAdicionales[1],
sum(Puntajes) / len(Puntajes)])
return (ColaPeliculas, ColaAdicionales)
else:
qe.enqueue(ColaAdicionales, qe.size(ColaPeliculas))
qe.enqueue(ColaAdicionales, 0)
return (ColaPeliculas, ColaAdicionales)
def nearbyStations(database, longitude, latitude):
aspir = queue.newQueue()
queue.enqueue(
aspir, orderedmap.ceiling(database['position']['latitude'], latitude))
queue.enqueue(
aspir, orderedmap.ceiling(database['position']['longitude'],
longitude))
queue.enqueue(
aspir, orderedmap.floor(database['position']['longitude'], longitude))
queue.enqueue(aspir,
orderedmap.floor(database['position']['latitude'], latitude))
val = None
wID = None
while not queue.isEmpty(aspir):
id = queue.dequeue(aspir)
id = mapentry.getValue(id)
element = map.get(database['station'], id)
element = mapentry.getValue(element)
dist = abs(
Calc.distance(element['latitude'], latitude, element['longitude'],
longitude))
if val is None:
val = dist
wID = id
if dist < val:
val = dist
wID = id
return wID
def RutaMinima(catalog, paisA, paisB):
mapaLP = catalog['landing_points']
mapaCountries = catalog['countries']
mapaCountries2 = catalog['countries2']
grafo = catalog['grafo']
capitalA = me.getValue(mp.get(mapaCountries, paisA))['CapitalName']
capitalB = me.getValue(mp.get(mapaCountries, paisB))['CapitalName']
dijkstra = djk.Dijkstra(grafo, capitalA)
distancia_total = djk.distTo(dijkstra, capitalB)
ruta_cruda = djk.pathTo(dijkstra, capitalB)
ruta = qu.newQueue('ARRAY_LIST')
previo = None
while not stk.isEmpty(ruta_cruda):
punto = stk.pop(ruta_cruda)['vertexB']
dist = djk.distTo(dijkstra, punto)
if not mp.contains(mapaCountries2, punto):
punto = 'Landing point ' + punto.split('-')[0]
print(dist)
print(punto)
p_d = (punto, dist)
if not previo == punto:
qu.enqueue(ruta, p_d)
previo = punto
return ruta, distancia_total
def f6(cont, s1, tMAX):
cola = qe.newQueue()
listaDeListasDeTuplas = model.buscarEstacionesBFS(cont,s1,tMAX)
for i in listaDeListasDeTuplas:
for j in i:
qe.enqueue(cola, s1 + "-->" + str(j[0]) + ". La duración esperada de esta ruta es " + str(j[1]) + " minutos")
return cola
def f9(cont,age):
cola = qe.newQueue()
qe.enqueue(cola,"Las estaciones adyacentes que más utilizan las personas de este grupo de edad, con suscripción de 3 días son: ")
retorno = model.idEstPublicidad(cont,age)
for i in retorno:
qe.enqueue(cola,i)
return cola
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 f3(analyzer,s1,s2):
cola = qe.newQueue()
qe.enqueue(cola, "Hay " + str(model.numSCC(analyzer)) + " clústeres en el grafo")
if model.sameCC(analyzer,s1,s2)==False:
qe.enqueue(cola, "Las dos estaciones NO pertenecen al mismo clúster")
else:
qe.enqueue(cola, "Las dos estaciones SI pertenecen al mismo clúster")
return cola
def f5(cont):
cola = qe.newQueue()
Top3Salida = model.Top3Salida(cont)
Top3Llegada = model.Top3Llegada(cont)
Top3Total = model.Top3Total(cont)
qe.enqueue(cola, "Las 3 estaciones principales de llegada (en orden) son: " + Top3Llegada[0] + " " + Top3Llegada[1] + " " + Top3Llegada[2])
qe.enqueue(cola, "Las 3 estaciones principales de salida (en orden) son: " + Top3Salida[0] + " " + Top3Salida[1] + " " + Top3Salida[2])
qe.enqueue(cola, "Las 3 estaciones menos usadas en total (en orden) son: " + Top3Total[1] + " " + Top3Total[2] + " " + Top3Total[3])
return cola
def bfsVertex(search, graph, source, maxtime):
"""
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)
if not (it.hasNext(adjslstiter)):
visited_v["final"] = True
c = 0
while (it.hasNext(adjslstiter)):
if c == 1 and vertex != source:
break
total_time = 0
w = it.next(adjslstiter)
if not (it.hasNext(adjslstiter)) and c == 0:
visited_v["final"] = True
edge = g.getEdge(graph, vertex, w)
time = edge['weight'] / 60
visited_w = map.get(search['visited'], w)
if visited_w is None:
if visited_v["final"] == False:
dist_to_w = visited_v['distTo'] + time
total_time = dist_to_w
if total_time <= maxtime:
visited_w = {
'marked': True,
'edgeTo': vertex,
"distTo": dist_to_w,
"final": False
}
map.put(search['visited'], w, visited_w)
queue.enqueue(adjsqueue, w)
c = 1
return search
except Exception as exp:
error.reraise(exp, 'bfs:bfsVertex')
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.
"""
queue = q.newQueue(list_type)
assert (q.size(queue) == 0)
assert (q.isEmpty(queue))
queue = q.newQueue(list_type)
q.enqueue(queue, book5)
q.enqueue(queue, book6)
q.enqueue(queue, book3)
q.enqueue(queue, book10)
q.enqueue(queue, book1)
q.enqueue(queue, book2)
q.enqueue(queue, book8)
q.enqueue(queue, book4)
q.enqueue(queue, book7)
q.enqueue(queue, book9)
elem = q.peek(queue)
assert (q.size(queue) == 10)
assert (elem == book5)
elem = q.dequeue(queue)
assert (q.size(queue) == 9)
assert (elem == book5)
elem = q.dequeue(queue)
assert (q.size(queue) == 8)
assert (elem == book6)
elem = q.peek(queue)
assert (q.size(queue) == 8)
assert (elem == book3)
q.enqueue(queue, book9)
assert (q.size(queue) == 9)
elem = q.peek(queue)
assert (elem == book3)
def initSearch(graph, source):
"""
Inicializa la estructura de busqueda y deja
todos los arcos en infinito.
Se inserta en la cola el vertice source
Args:
graph: El grafo a examinar
source: El vertice fuente
Returns:
Estructura de busqueda inicializada
Raises:
Exception
"""
try:
search = {
'source': source,
'edgeTo': None,
'distTo': None,
'qvertex': None,
'onQ': None,
'cost': 0,
'spt': None,
'cycle': False
}
search['edgeTo'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
search['distTo'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
search['onQ'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
search['spt'] = g.newGraph(size=g.numVertices(graph),
directed=True,
comparefunction=graph['comparefunction'])
vertices = g.vertices(graph)
for vert in lt.iterator(vertices):
map.put(search['distTo'], vert, math.inf)
map.put(search['onQ'], vert, False)
g.insertVertex(search['spt'], vert)
newq = q.newQueue()
search['qvertex'] = newq
return search
except Exception as exp:
error.reraise(exp, 'bellman:init')
def test_error_dequeue():
"""
Este test busca comprobar que es imposible eliminar un objeto de
una cola vacia
"""
queue = q.newQueue(list_type)
assert (q.size(queue) == 0)
assert(q.isEmpty(queue))
with pytest.raises(Exception):
q.dequeue(queue)
def test_enqueue_dequeue():
"""
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
"""
queue = q.newQueue(list_type)
assert (q.size(queue) == 0)
assert (q.isEmpty(queue))
q.enqueue(queue, book5)
assert(q.size(queue) == 1)
assert(q.peek(queue) == q.dequeue(queue))
assert(q.size(queue) == 0)
q.enqueue(queue, book6)
assert(q.size(queue) == 1)
assert(q.peek(queue) == q.dequeue(queue))
assert(q.size(queue) == 0)
q.enqueue(queue, book3)
assert(q.size(queue) == 1)
assert(q.peek(queue) == q.dequeue(queue))
assert(q.size(queue) == 0)
q.enqueue(queue, book10)
assert(q.size(queue) == 1)
assert(q.peek(queue) == q.dequeue(queue))
assert(q.size(queue) == 0)
q.enqueue(queue, book1)
assert(q.size(queue) == 1)
assert(q.peek(queue) == q.dequeue(queue))
assert(q.size(queue) == 0)
q.enqueue(queue, book2)
assert(q.size(queue) == 1)
assert(q.peek(queue) == q.dequeue(queue))
assert(q.size(queue) == 0)
q.enqueue(queue, book8)
q.enqueue(queue, book4)
q.enqueue(queue, book7)
q.enqueue(queue, book9)
assert (q.size(queue) == 4)
assert book8 == q.dequeue(queue)
assert book4 == q.dequeue(queue)
assert book7 == q.dequeue(queue)
assert book9 == q.dequeue(queue)
assert (q.size(queue) == 0)
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_sizeQueue():
"""
Se prueba la creacion de una cola y la relacion con el tamaño al
ingresar datos
"""
queue = q.newQueue(list_type)
assert (q.size(queue) == 0)
assert (q.isEmpty(queue))
queue = q.newQueue(list_type)
q.enqueue(queue, book5)
q.enqueue(queue, book6)
q.enqueue(queue, book3)
q.enqueue(queue, book10)
q.enqueue(queue, book1)
q.enqueue(queue, book2)
q.enqueue(queue, book8)
q.enqueue(queue, book4)
q.enqueue(queue, book7)
q.enqueue(queue, book9)
assert q.size(queue) == 10
def efe5(país, PsXPais____):
n = 0
ColaPeliculas = qe.newQueue()
Centinela = True
while Centinela == True:
if mp.contains(PsXPais____, país + str(n)):
pelicula = mp.get(PsXPais____, país + str(n))["value"]
qe.enqueue(
ColaPeliculas,
pelicula["title"] + " (" + pelicula["release_date"][-4:] +
") " + "Dirigida por: " + pelicula["director_name"])
n = n + 1
else:
Centinela = False
return (ColaPeliculas, None)
def initSearch(graph):
"""
Inicializa la estructura de busqueda y deja
todos los arcos en infinito.
Se inserta en la cola el vertice source
Args:
graph: El grafo a examinar
source: El vertice fuente
Returns:
Estructura de busqueda inicializada
Raises:
Exception
"""
try:
search = {
'edgeTo': None,
'distTo': None,
'marked': None,
'pq': None,
'mst': None
}
search['edgeTo'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
search['distTo'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
search['marked'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
vertices = g.vertices(graph)
for vert in lt.iterator(vertices):
map.put(search['distTo'], vert, math.inf)
map.put(search['marked'], vert, False)
search['pq'] = pq.newIndexMinPQ(cmpfunction=graph['comparefunction'])
search['mst'] = q.newQueue()
return search
except Exception as exp:
error.reraise(exp, 'bellman:init')
def lpInterconexion(catalog):
rbt = model.lpInterconexion(catalog)
lista_listas_LandingPoints = om.valueSet(rbt)
cola_retornar = qu.newQueue()
total_cables_resultado = mp.newMap(loadfactor=4.0)
contador = 0
for lista in lt.iterator(lista_listas_LandingPoints):
for tupla_lp_listavertices in lt.iterator(lista):
if contador > 9:
break
else:
lista_vertices = tupla_lp_listavertices[1]
for vertice in lt.iterator(lista_vertices):
# cable = vertice.split('-')[2]
mp.put(total_cables_resultado, vertice, vertice)
qu.enqueue(cola_retornar, tupla_lp_listavertices)
contador = contador + 1
total_cables_resultado = mp.size(total_cables_resultado)
return cola_retornar, total_cables_resultado
def test_queueElements():
"""
Se prueba la creacion de una nueva cola, se agregan todos los datos
creados por sistema y se imprime su valor
"""
queue = q.newQueue(list_type)
q.enqueue(queue, book5)
q.enqueue(queue, book6)
q.enqueue(queue, book3)
q.enqueue(queue, book10)
q.enqueue(queue, book1)
q.enqueue(queue, book2)
q.enqueue(queue, book8)
q.enqueue(queue, book4)
q.enqueue(queue, book7)
q.enqueue(queue, book9)
iterator = it.newIterator(queue)
while it.hasNext(iterator):
element = it.next(iterator)
result = ("".join(str(key) + ": " + str(value) + ", "
for key, value in element.items()))
print(result)
def f4(cont,s1,tMIN,tMAX):
cola = qe.newQueue()
qe.enqueue(cola,"Nota: se parte del supuesto de que un turista toma 20 minutos conociendo los alrededores en cada parada.")
listaCand = model.CandidatasCirculares(cont,s1)
if lt.isEmpty(listaCand):
qe.enqueue(cola,"No se encontraron rutas.")
return cola
listaFinal = model.buscarEstaciónesFinales(cont,s1,listaCand)
if lt.isEmpty(listaFinal):
qe.enqueue(cola,"No se encontraron rutas.")
return cola
qe.enqueue(cola,"Se encontraron las siguientes rutas: ")
iterador = it.newIterator(listaFinal)
C = True
while C:
dixx = it.next(iterador)
llave = list(dixx.keys())[0]
valor = list(dixx.values())[0]
tupla = model.CostoMinimoCircular(cont,s1,llave,valor)
if (tMIN*60)<tupla[1]<(tMAX*60):
qe.enqueue(cola,(tupla[0] + " , duración esperada en minutos: " + str(round(tupla[1]/60)) ))
if not it.hasNext(iterador):
C = False
return cola
def f8(cont,lat1,lon1,lat2,lon2):
cola = qe.newQueue()
lista = model.RutaTuristica(cont,lat1,lon1,lat2,lon2)
for i in lista:
qe.enqueue(cola,i)
return cola
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
"""
"""
Cada hora llega un paciente a una cola, cada paciente dura 1.5 horas en ser atendido
¿De que longitud es la cola despues de 5 horas?
"""
def greater(key1, key2):
if key1['t'] == key2['t']:
return 0
elif key1['t'] < key2['t']:
return -1
else:
return 1
cola_de_espera = queue.newQueue()
minpq = pq.newMinPQ(greater)
pq.insert(minpq, {'t': 0, 'evento': 'llegada'})
pq.insert(minpq, {'t': 5, 'evento': 'fin'})
iters = 0
while not pq.isEmpty(minpq) and iters < 100:
p = pq.delMin(minpq)
if p['evento'] == 'llegada':
queue.enqueue(cola_de_espera, 1)
pq.insert(minpq, {'t': p['t'] + 1, 'evento': 'llegada'})
print('llegada')
if p['evento'] == 'fin':
def f7(cont,age):
cola = qe.newQueue()
qe.enqueue(cola,model.RutaEdad(cont,age))
return cola
def queue():
queue = q.newQueue('ARRAY_LIST')
return queue
def queue():
queue = q.newQueue('SINGLE_LINKED')
return queue
def getFiles() -> queue:
files = queue.newQueue()
for filename in os.listdir(Const.data_dir):
if filename.endswith('.csv'):
queue.enqueue(files, Const.data_dir + filename)
return files
