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