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