def test_error_dequeue(queue, books): """ Este test busca comprobar que es imposible eliminar un objeto de una cola vacia """ with pytest.raises(Exception): q.dequeue(queue)
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_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 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 optionFour(): verticeCentral = input( "Ingrese la estación para la cual desea realizar la consulta (Ejemplo 3661, 477): " ) LimiteInferior = (int( input("Ingrese el limite inferior del rango a consultar (Ej 120): ")) ) * 60 LimiteSuperior = (int( input("Ingrese el limite superior del rango a consultar (Ej 240): ")) ) * 60 listaAdyacentes = controller.ListaAdyacentes(cont, verticeCentral, LimiteInferior, LimiteSuperior) print("\nSe encontraron en total {} rutas cíclicas:\n ".format( listaAdyacentes[0])) while (not stack.isEmpty(listaAdyacentes[1])): stop = stack.pop(listaAdyacentes[1]) print( "Esta ruta tarda en total {} minutos, tiene {} estaciones, teniendo en cuenta un tiempo de 20 minutos por estacion. " .format( (round((stop["PesoPorRuta"] / 60), 2)), str(queue.size(stop)), )) while stop and (not queue.isEmpty(stop)): stopDOS = queue.dequeue(stop) print( "-> Parte de la estacion {}, hasta la estación {} y tarda {} minutos en el trayecto. " .format(stopDOS['vertexA'], stopDOS['vertexB'], round((stopDOS['weight'] / 60), 2))) print("\n")
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 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 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 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 ImprimirEnConsola(cola, DatosAdicionales=None): if qe.isEmpty(cola)==False: Centinela = True print("-"*100) while Centinela==True: print("", end=" "*10) print("•" + qe.dequeue(cola)) if qe.isEmpty(cola)==True: Centinela=False print("-"*100) else: print("No se ha encontrado información para el criterio") if DatosAdicionales!=None: if qe.isEmpty(DatosAdicionales)==False: CentinelaAdicionales = True while CentinelaAdicionales==True: dato = qe.dequeue(DatosAdicionales) print(str(dato[0])+str(dato[1])) if qe.isEmpty(DatosAdicionales)==True: CentinelaAdicionales=False
def test_prim2(graph2): search = prim.PrimMST(graph2) weight = prim.weightMST(graph2, search) print('\n') path = search['mst'] while not q.isEmpty(path): edge = q.dequeue(path) print(edge['vertexA'] + "-->" + edge['vertexB'] + " costo: " + str(edge['weight'])) print(str(weight))
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 convertQueueToStr(queue): """ Toma la cola con la ruta más corta y la convierte a un string """ size = qu.size(queue) strRoute = "" for i in range(0, size): stat = qu.dequeue(queue) strRoute = strRoute + str(stat['vertexA']) + " - " strRoute = strRoute + stat['vertexB'] return strRoute
def loadData(DataBase) -> bool: files = getFiles() dialect = csv.excel() dialect.delimiter = ',' while not (queue.isEmpty(files)): with open(queue.dequeue(files), encoding="utf-8") as csvfile: buffer = csv.DictReader(csvfile, dialect=dialect) cont = 0 for element in buffer: cont += 1 Add.addTrip(element, DataBase) if cont == Const.SIZE: print(cont) return True print(cont) return True
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_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 getBestRoute(analyzer, originArea, destinArea, initPos, endPos): """ Busca la mejor ruta entre dos estaciones """ lst = analyzer["hours"] menorTime = float("inf") menorRoute = "" hour = 0 for i in range(initPos,(endPos+1)): dict = lt.getElement(lst, i) if (gr.containsVertex(dict["grafo"], originArea)) and (gr.containsVertex(dict["grafo"], destinArea)): if destinArea == originArea: edge = gr.getEdge(dict["grafo"],originArea,destinArea) if edge is not None: time = edge['weight'] if time < menorTime: menorTime = time menorRoute = originArea+"-"+destinArea hour = dict["hora"] else: search = djk.Dijkstra(dict["grafo"],originArea) queuePath = djk.pathTo(search, destinArea) size = -1 if queuePath is not None: size = qu.size(queuePath) strRoute = "" time = 0 for i in range(0,size): stat = qu.dequeue(queuePath) strRoute = strRoute + str(stat['vertexA'])+ " - " time += stat['weight'] strRoute = strRoute + stat['vertexB'] if (time < menorTime) and (queuePath is not None): menorTime = time menorRoute = strRoute hour = dict["hora"] return (menorTime,menorRoute,hour)
respuesta = 'SI' print( 'Estos dos landing points {} estan fuertemente conectados.'.format( respuesta)) elif int(inputs[0]) == 3: # -------------------------------------------------- REQ 2 -------------------------------------------------- # print("Cargando información de los landing points...") cola_lp, cant_cables_tot = controller.lpInterconexion(catalog) print( "---------------------- Lista primeros 10 landing points con más puntos de interconexión a cables ----------------------" ) contador = 0 while not qu.isEmpty(cola_lp): lp, listavertices = qu.dequeue(cola_lp) cant_cables = lt.size(listavertices) contador = contador + 1 print("TOP {}:".format(contador)) print("Nombre: {}".format(lp['name'])) print("País: {}".format(lp['country'])) print("Identificador: {}".format(lp['landing_point_id'])) print('Con {} cables distintos.'.format(cant_cables)) print( '--------------------------------------------------------------------------------------------------' ) print( 'La cantidad total de cables distintos conectados a estos 10 landing points es: {}.' .format(cant_cables_tot))