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 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 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 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 relax(graph, search, v):
"""
Relaja el peso de los arcos del grafo
Args:
search: La estructura de busqueda
v: Vertice desde donde se relajan los pesos
Returns:
El grafo con los arcos relajados
Raises:
Exception
"""
try:
edges = g.adjacentEdges(graph, v)
if edges is not None:
for edge in lt.iterator(edges):
v = e.either(edge)
w = e.other(edge)
distv = map.get(search['distTo'], v)['value']
distw = map.get(search['distTo'], w)['value']
distweight = distv + e.weight(edge)
if (distw > distweight):
map.put(search['distTo'], w, distweight)
map.put(search['edgeTo'], w, edge)
if (not map.get(search['onQ'], w)['value']):
q.enqueue(search['qvertex'], w)
map.put(search['onQ'], w, True)
cost = search['cost']
if ((cost % g.numVertices(graph)) == 0):
findneg = findNegativeCycle(graph, search)
if (hasNegativecycle(findneg)):
return
search['cost'] = cost + 1
return search
except Exception as exp:
error.reraise(exp, 'bellman:relax')
def BellmanFord(graph, source):
"""
Implementa el algoritmo de Bellman-Ford
Args:
graph: El grafo de busqueda
source: El vertice de inicio
Returns:
La estructura search con los caminos de peso mínimos
Raises:
Exception
"""
try:
search = initSearch(graph, source)
map.put(search['distTo'], source, 0.0)
q.enqueue(search['qvertex'], source)
map.put(search['onQ'], source, True)
while (not q.isEmpty(search['qvertex'])
and (not hasNegativecycle(search))):
v = q.dequeue(search['qvertex'])
map.put(search['onQ'], v, False)
relax(graph, search, v)
return search
except Exception as exp:
error.reraise(exp, 'bf:BellmanFord')
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 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 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 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 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 edgesMST(graph, search):
"""
Args:
search: La estructura de busqueda
vertex: El vertice de destino
Returns:
Una pila con el camino entre source y vertex
Raises:
Exception
"""
try:
vertices = g.vertices(graph)
for vert in lt.iterator(vertices):
e = map.get(search['edgeTo'], vert)
if (e is not None):
q.enqueue(search['mst'], e['value'])
return search
except Exception as exp:
error.reraise(exp, 'bellman:pathto')
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 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 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 test_infoElements(queue, books):
"""
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.
"""
q.enqueue(queue, books[5])
q.enqueue(queue, books[6])
q.enqueue(queue, books[3])
q.enqueue(queue, books[10])
q.enqueue(queue, books[1])
q.enqueue(queue, books[2])
q.enqueue(queue, books[8])
q.enqueue(queue, books[4])
q.enqueue(queue, books[7])
elem = q.peek(queue)
assert (elem == books[5])
elem = q.dequeue(queue)
assert (elem == books[5])
elem = q.dequeue(queue)
assert (q.size(queue) == 7)
assert (elem == books[6])
elem = q.peek(queue)
assert (q.size(queue) == 7)
assert (elem == books[3])
q.enqueue(queue, books[9])
assert (q.size(queue) == 8)
elem = q.peek(queue)
assert (elem == books[3])
def test_sizeQueue(queue, books):
"""
Se prueba la creacion de una cola y la relacion con el tamaño al
ingresar datos
"""
assert (q.size(queue) == 0)
assert (q.isEmpty(queue))
q.enqueue(queue, books[5])
q.enqueue(queue, books[6])
q.enqueue(queue, books[3])
q.enqueue(queue, books[10])
q.enqueue(queue, books[1])
q.enqueue(queue, books[2])
q.enqueue(queue, books[8])
q.enqueue(queue, books[4])
q.enqueue(queue, books[7])
assert q.size(queue) == 9
def test_queueElements(queue, books):
"""
Se prueba la creacion de una nueva cola, se agregan todos los datos
creados por sistema y se imprime su valor
"""
q.enqueue(queue, books[5])
q.enqueue(queue, books[6])
q.enqueue(queue, books[3])
q.enqueue(queue, books[10])
q.enqueue(queue, books[1])
q.enqueue(queue, books[2])
q.enqueue(queue, books[8])
q.enqueue(queue, books[4])
q.enqueue(queue, books[7])
q.enqueue(queue, books[9])
while not q.isEmpty(queue):
element = q.dequeue(queue)
result = ("".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items()))
print(result)
def test_enqueue_dequeue(queue, books):
"""
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
"""
q.enqueue(queue, books[5])
assert (q.size(queue) == 1)
assert (q.peek(queue) == q.dequeue(queue))
assert (q.size(queue) == 0)
q.enqueue(queue, books[6])
assert (q.size(queue) == 1)
assert (q.peek(queue) == q.dequeue(queue))
assert (q.size(queue) == 0)
q.enqueue(queue, books[3])
assert (q.size(queue) == 1)
assert (q.peek(queue) == q.dequeue(queue))
assert (q.size(queue) == 0)
q.enqueue(queue, books[10])
assert (q.size(queue) == 1)
assert (q.peek(queue) == q.dequeue(queue))
assert (q.size(queue) == 0)
q.enqueue(queue, books[1])
assert (q.size(queue) == 1)
assert (q.peek(queue) == q.dequeue(queue))
assert (q.size(queue) == 0)
q.enqueue(queue, books[2])
assert (q.size(queue) == 1)
assert (q.peek(queue) == q.dequeue(queue))
assert (q.size(queue) == 0)
q.enqueue(queue, books[8])
q.enqueue(queue, books[4])
q.enqueue(queue, books[7])
q.enqueue(queue, books[9])
assert (q.size(queue) == 4)
assert books[8] == q.dequeue(queue)
assert books[4] == q.dequeue(queue)
assert books[7] == q.dequeue(queue)
assert books[9] == q.dequeue(queue)
assert (q.size(queue) == 0)
def test_peek_dequeue(queue, books):
"""
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
"""
q.enqueue(queue, books[5])
q.enqueue(queue, books[6])
q.enqueue(queue, books[3])
q.enqueue(queue, books[10])
q.enqueue(queue, books[1])
q.enqueue(queue, books[2])
q.enqueue(queue, books[8])
q.enqueue(queue, books[4])
q.enqueue(queue, books[7])
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 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':
break
iters = iters + 1
print(queue.size(cola_de_espera))
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 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 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 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 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 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 f7(cont,age):
cola = qe.newQueue()
qe.enqueue(cola,model.RutaEdad(cont,age))
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