def requerimiento4(info, nom1, nom2, nom3, nom4, des1, des2): gene1 = tablageneros(nom1) llave = mp.get(gene1, nom1) #Da la llave y el valor de la tabla de hash valor = me.getValue(llave) # El valor de la llave del genero rango1 = om.values(info["generos"], valor[0], valor[1]) diccionario = mp.newMap() diccionarionuevo = mp.newMap() iterador = it.newIterator(rango1) suma1 = 0 while it.hasNext(iterador): actu = it.next(iterador) suma1 += lt.size(actu) iterardentro = it.newIterator(actu) while it.hasNext(iterardentro): actual = it.next(iterardentro) if mp.contains(diccionario, actual["tempo"]): ola = mp.get(diccionario, actual["tempo"]) listo = me.getValue(ola) lt.addLast(listo, actual) else: listo = lt.newList() mp.put(diccionario, actual["tempo"], listo) lt.addLast(listo, actual) if mp.contains(diccionarionuevo, actual["artist_id"]): llaves = mp.get(diccionarionuevo, actual["artist_id"]) valores = me.getValue(llaves) lt.addLast(valores, actual) else: infor = lt.newList() mp.put(diccionarionuevo, actual["artist_id"], infor) lt.addLast(infor, actual) tamano1 = mp.size(diccionarionuevo) gene2 = tablageneros(nom2) llave = mp.get(gene2, nom2) valor2 = me.getValue(llave) rango2 = om.values(info["generos"], valor2[0], valor2[1]) diccionario2 = mp.newMap() diccionarionuevo2 = mp.newMap() iterador = it.newIterator(rango2) suma2 = 0 while it.hasNext(iterador): actu = it.next(iterador) suma2 += lt.size(actu) iterardentro = it.newIterator(actu) while it.hasNext(iterardentro): actual = it.next(iterardentro) if mp.contains(diccionario2, actual["tempo"]): ola = mp.get(diccionario2, actual["tempo"]) listo = me.getValue(ola) lt.addLast(listo, actual) else: listo = lt.newList() mp.put(diccionario2, actual["tempo"], listo) lt.addLast(listo, actual) if mp.contains(diccionarionuevo2, actual["artist_id"]): llaves = mp.get(diccionarionuevo2, actual["artist_id"]) valores = me.getValue(llaves) lt.addLast(valores, actual) else: infor = lt.newList() mp.put(diccionarionuevo2, actual["artist_id"], infor) lt.addLast(infor, actual) tamano2 = mp.size(diccionarionuevo2) gene3 = tablageneros(nom3) llave = mp.get(gene3, nom3) valor3 = me.getValue(llave) rango3 = om.values(info["generos"], valor3[0], valor3[1]) diccionario3 = mp.newMap() diccionarionuevo3 = mp.newMap() iterador = it.newIterator(rango3) suma3 = 0 while it.hasNext(iterador): actu = it.next(iterador) suma3 += lt.size(actu) iterardentro = it.newIterator(actu) while it.hasNext(iterardentro): actual = it.next(iterardentro) if mp.contains(diccionario3, actual["tempo"]): ola = mp.get(diccionario3, actual["tempo"]) listo = me.getValue(ola) lt.addLast(listo, actual) else: listo = lt.newList() mp.put(diccionario3, actual["tempo"], listo) lt.addLast(listo, actual) if mp.contains(diccionarionuevo3, actual["artist_id"]): llaves = mp.get(diccionarionuevo3, actual["artist_id"]) valores = me.getValue(llaves) lt.addLast(valores, actual) else: infor = lt.newList() mp.put(diccionarionuevo3, actual["artist_id"], infor) lt.addLast(infor, actual) tamano3 = mp.size(diccionarionuevo3) diccionarionuevo4 = mp.newMap() total = suma1 + suma2 + suma3 suma4 = 0 if nom4 != "": rango4 = om.values(info["generos"], des1, des2) diccionario4 = mp.newMap() iterador = it.newIterator(rango4) suma4 = 0 while it.hasNext(iterador): actu = it.next(iterador) suma4 += lt.size(actu) iterardentro = it.newIterator(actu) while it.hasNext(iterardentro): actual = it.next(iterardentro) if mp.contains(diccionario4, actual["tempo"]): ola = mp.get(diccionario4, actual["tempo"]) listo = me.getValue(ola) lt.addLast(listo, actual) else: listo = lt.newList() mp.put(diccionario4, actual["tempo"], listo) lt.addLast(listo, actual) if mp.contains(diccionarionuevo4, actual["artist_id"]): llaves = mp.get(diccionarionuevo4, actual["artist_id"]) valores = me.getValue(llaves) lt.addLast(valores, actual) else: infor = lt.newList() mp.put(diccionarionuevo4, actual["artist_id"], infor) lt.addLast(infor, actual) tamano4 = mp.size(diccionarionuevo4) llave1 = mp.keySet(diccionarionuevo) llave2 = mp.keySet(diccionarionuevo2) llave3 = mp.keySet(diccionarionuevo3) iterador = it.newIterator(llave1) primero = lt.newList() while it.hasNext(iterador): actu = it.next(iterador) lt.addLast(primero, actu) artistas1 = lt.subList(primero, 0, 12) iterador = it.newIterator(llave2) segundo = lt.newList() while it.hasNext(iterador): actu = it.next(iterador) lt.addLast(segundo, actu) artistas2 = lt.subList(segundo, 0, 12) iterador = it.newIterator(llave3) tercero = lt.newList() while it.hasNext(iterador): actu = it.next(iterador) lt.addLast(tercero, actu) artistas3 = lt.subList(tercero, 0, 12) return suma1, suma2, suma3, total, suma4, tamano1, tamano2, tamano3, tamano4, artistas1, artistas2, artistas3
delta_time = stop_time - start_time delta_memory = controller.deltaMemory(start_memory, stop_memory) print('Tiempo[ms]: ', f"{delta_time:.3f}", "-", "Memoria [kB]: ", f"{delta_memory:.3f}") elif int(inputs[0]) == 4: delta_time = -1.0 delta_memory = -1.0 tracemalloc.start() start_time = controller.getTime() start_memory = controller.getMemory() print( "Los landing points que sirven como punto de interconexión a más cables en la red son: " ) keys = mp.keySet(cont['interconnections']) for key in lt.iterator(keys): resultado = controller.req2(cont, key) if resultado is not None: print(resultado) stop_memory = controller.getMemory() stop_time = controller.getTime() tracemalloc.stop() delta_time = stop_time - start_time delta_memory = controller.deltaMemory(start_memory, stop_memory) print('Tiempo[ms]: ', f"{delta_time:.3f}", "-", "Memoria [kB]: ", f"{delta_memory:.3f}") pass
def stationbyLocation(analyzer, latitude1, longitude1, latitude2, longitude2): lstverta = m.keySet(analyzer['latitude']) lstverto = m.keySet(analyzer['longitude']) itlstverta = it.newIterator(lstverta) itlstverto = it.newIterator(lstverto)
def cosulta_req5(analyzer, init, end): """ Apartado de la primera parte de la consulta """ mapa_trabajo = mp.newMap(maptype='PROBING', comparefunction=cmpByCarac) hora_1 = (dt.datetime.strptime(init, "%H:%M:%S")).time() hora_2 = (dt.datetime.strptime(end, "%H:%M:%S")).time() arbol_hora = analyzer['EvByHour'] mapa_genders = analyzer['Genders'] genders = mp.keySet(mapa_genders) for gender in lt.iterator(genders): mp.put(mapa_trabajo, gender, 0) arboles_tempo = om.values(arbol_hora, hora_1, hora_2) unique = 0 for arbol_tempo in lt.iterator(arboles_tempo): todos_los_tempos = om.keySet(arbol_tempo) for key in lt.iterator(todos_los_tempos): entry_tempos_unicos = om.get(arbol_tempo, key) estructura = me.getValue(entry_tempos_unicos) unique += lt.size(estructura['mapa_completo']) for gender in lt.iterator(genders): entry_tempos = mp.get(mapa_genders, gender) tempo = me.getValue(entry_tempos) estructuras = om.values(arbol_tempo, tempo[0], tempo[1]) contador = 0 for estructura in lt.iterator(estructuras): reproducciones = lt.size(estructura['mapa_completo']) contador += reproducciones entry_num_reproducciones = mp.get(mapa_trabajo, gender) num_reproducciones = me.getValue(entry_num_reproducciones) num_reproducciones += contador mp.put(mapa_trabajo, gender, num_reproducciones) lista_reproducciones_unicos = lt.newList(datastructure="SINGLE_LINKED") for gender in lt.iterator(genders): entry = mp.get(mapa_trabajo, gender) tupla = (gender, me.getValue(entry)) lt.addLast(lista_reproducciones_unicos, tupla) lista_final = sa.sort(lista_reproducciones_unicos, cmptuples) mapa_hashtag = analyzer['#ByTrack'] mapa_VADER = analyzer['VaderBy#'] keys = mp.keySet(mapa_trabajo) mayor = ('aletoso', 0) for key in lt.iterator(keys): entry = mp.get(mapa_trabajo, key) conteo = me.getValue(entry) if conteo > mayor[1]: mayor = (key, conteo) entry = mp.get(analyzer['Genders'], mayor[0]) tempo = me.getValue(entry) lista_trabajo = lt.newList(datastructure='ARRAY_LIST', cmpfunction=cmptuples) for arbol_tempo in lt.iterator(arboles_tempo): estructuras = om.values(arbol_tempo, tempo[0], tempo[1]) for estructura in lt.iterator(estructuras): mapa = estructura['mapa_unicos'] for key in lt.iterator(mp.keySet(mapa)): entry = mp.get(mapa_hashtag, key) mapa_otra_vez = me.getValue(entry) num_hashtags = 0 prom = 0 for hashtag in lt.iterator(mp.keySet(mapa_otra_vez)): entry = mp.get(mapa_VADER, hashtag) if entry is not None: value = me.getValue(entry) if value is not None: prom += float(value) num_hashtags += 1 try: tres_tupla = (key, num_hashtags, prom / num_hashtags) except: tres_tupla = (key, num_hashtags, 0) lt.addLast(lista_trabajo, tres_tupla) sort_list = sa.sort(lista_trabajo, cmptuples) sublist = lt.subList(sort_list, 1, 10) return lista_final, sublist, unique
def getFirstLandingPoint(analyzer): lpints = m.keySet(analyzer['landingPoints']) entry = m.get(analyzer['landingPoints'],lpints['first']['info']) return entry['value']
def countries(analyzer): return mp.keySet(analyzer["countries"])
def genero_por_tiempo(analyzer, diccionario, hora_min, hora_max): canciones = lt.newList('ARRAY_LIST', comparebyhashtags) ordenados = om.newMap(comparefunction=compare) generos = mp.newMap(maptype='PROBING') ranking = lt.newList('ARRAY_LIST') unicos = lt.newList() for genero in diccionario: mp.put(generos, genero, lt.newList('ARRAY_LIST')) validos = herramienta_lista( om.values(analyzer['created_at'], hora_min, hora_max)) '''Validos es una lista con los mapas de tracks que tienen eventos a la hora indicada''' for i in range(1, lt.size(validos) + 1): mapa_interno = lt.getElement(validos, i) tempo = me.getValue(mp.get(mapa_interno, 'tempo')) for genero in diccionario: lista_tracks = me.getValue(mp.get(generos, genero)) if diccionario[genero][0] <= tempo <= diccionario[genero][1]: lt.addLast(lista_tracks, mapa_interno) '''En este for se analiza cada mapa interno de los tracks para añadirlo a la lista de los generos que le corresponda''' for i in range(1, lt.size(mp.keySet(generos)) + 1): genero = lt.getElement(mp.keySet(generos), i) canciones_genero = me.getValue(mp.get(generos, genero)) om.put(ordenados, lt.size(canciones_genero), genero) '''En este for se analiza cada genero y se suman sus tracks, por lo que quedan en un arbol ordenado para sacar el mayor''' mayor_cantidad = om.maxKey(ordenados) mayor_genero = me.getValue(om.get(ordenados, mayor_cantidad)) for i in range(1, lt.size(me.getValue(mp.get(generos, mayor_genero))) + 1): mapa_interno = lt.getElement( me.getValue(mp.get(generos, mayor_genero)), i) if lt.isPresent(unicos, me.getValue(mp.get(mapa_interno, 'track_id'))) == 0: lt.addLast(unicos, me.getValue(mp.get(mapa_interno, 'track_id'))) cantidad_hashtags = lt.size( me.getValue(mp.get(mapa_interno, 'hashtag'))) lt.addLast(canciones, (mapa_interno, cantidad_hashtags)) '''En este for se analizan los tracks unicos al crear una lista sin repeticiones de estos, además se añade a una lista en forma de tupla con su mapa interno y la cantidad de hashtags que tiene el track ''' maximo = 10 if lt.size(canciones) < maximo: maximo = lt.size(canciones) rank_valores = lt.subList(canciones, 0, maximo) for i in range(1, lt.size(rank_valores) + 1): num_hashtags = lt.getElement(rank_valores, i)[1] track = lt.getElement(rank_valores, i)[0] lista_hashtags = me.getValue(mp.get(track, 'hashtag')) contador = 0 sumatoria = 0 promedio = 0 for i in range(1, lt.size(lista_hashtags) + 1): hashtag = lt.getElement(lista_hashtags, i) if mp.contains(analyzer['sentiments'], hashtag): vader = me.getValue(mp.get(analyzer['sentiments'], hashtag)) sumatoria += vader contador += 1 if contador != 0: promedio = sumatoria / contador tupla = (me.getValue(mp.get(track, 'track_id')), num_hashtags, promedio) lt.addLast(ranking, tupla) mrg.sort(ranking, comparebyhashtags) return ranking, lt.size(validos), ordenados, mayor_genero, lt.size( unicos), generos
def suicidenmeLaSecuela(catalog, countries): mapa_pais = catalog["paises"] mapa_landing = catalog["landing_points"] mapa_cables = catalog["cables"] grafo = catalog["connections"] for country in countries: pais = country["CountryName"] capital = country["CapitalName"] if country["CapitalLatitude"] != "": capitalPos = (float(country["CapitalLatitude"]), float(country["CapitalLongitude"])) if mp.contains(mapa_pais, pais): lt.addFirst(mp.get(mapa_pais, pais)["value"], capital) gr.insertVertex(grafo, capital) landing_points = lt.getElement(mp.get(mapa_pais, pais)["value"], 2) bwMenor = 10000000000000000000000000000000000000 for landing_point in lt.iterator(landing_points): bw = mp.get(mapa_cables, landing_point)["value"] if bw < bwMenor: bwMenor = bw cables = mp.keySet( mp.get(mapa_landing, landing_point)["value"][1]) pos = mp.get(mapa_landing, landing_point)["value"][0] for cable in lt.iterator(cables): destino = landing_point + "|" + cable costo = hs.haversine(capitalPos, pos) gr.addEdge(grafo, capital, destino, costo) mp.put(mapa_cables, capital, bwMenor) elif pais != "": mp.put(mapa_pais, pais, lt.newList(datastructure="SINGLE_LINKED")) lt.addFirst(mp.get(mapa_pais, pais)["value"], capital) gr.insertVertex(grafo, capital) llaves = mp.keySet(mapa_landing) distanciaMin = 1000000000000000000000000000000000000000000000000 landing_point = None for llave in lt.iterator(llaves): pos = mp.get(mapa_landing, llave)["value"][0] costo = hs.haversine(capitalPos, pos) if costo < distanciaMin: distanciaMin = costo landing_point = llave cables = mp.keySet(mp.get(mapa_landing, landing_point)["value"][1]) bw = mp.get(mapa_cables, landing_point)["value"] for cable in lt.iterator(cables): destino = landing_point + "|" + cable gr.addEdge(grafo, capital, destino, distanciaMin) mp.put(mapa_cables, capital, bw)
def suicidenme(catalog, landing_points, connections): mapa_traduccion = catalog["traduccion"] mapa_pais = catalog["paises"] mapa_landing = catalog["landing_points"] mapa_cables = catalog["cables"] mapa_cables_landing = catalog["cables_landing"] grafo = catalog["connections"] for landing_point in landing_points: id = landing_point["landing_point_id"] name = landing_point["name"] particion = name.split(",") nombre = particion[0] pais = particion[len(particion) - 1] if pais[0] == " ": pais = pais[1:] if nombre[0] == " ": nombre = nombre[1:] loc = (float(landing_point["latitude"]), float(landing_point["longitude"])) if not mp.contains(mapa_traduccion, nombre): mp.put(mapa_traduccion, nombre, lt.newList("SINGLE_LINKED")) lista = me.getValue(mp.get(mapa_traduccion, nombre)) lt.addLast(lista, id) else: lista = me.getValue(mp.get(mapa_traduccion, nombre)) lt.addLast(lista, id) mp.put(mapa_traduccion, id, nombre) if not mp.contains(mapa_pais, pais): mp.put(mapa_pais, pais, lt.newList(datastructure="SINGLE_LINKED")) lista = me.getValue(mp.get(mapa_pais, pais)) lt.addLast(lista, lt.newList(datastructure="SINGLE_LINKED")) sublista = lt.getElement(lista, 1) lt.addLast(sublista, id) else: lista = me.getValue(mp.get(mapa_pais, pais)) sublista = lt.getElement(lista, 1) lt.addLast(sublista, id) mp.put(mapa_landing, id, (loc, mp.newMap(maptype="PROBING", loadfactor=0.3), pais)) for num, connection in enumerate(connections): if num % 2 == 0: origin = connection["origin"] destination = connection["destination"] cable_name = connection["cable_name"] capacity = float(connection["capacityTBPS"]) mp.put(mapa_cables, cable_name, capacity) if not mp.contains(mapa_cables_landing, cable_name): mp.put(mapa_cables_landing, cable_name, mp.newMap(maptype="PROBING", loadfactor=0.3)) mp.put( mp.get(mapa_cables_landing, cable_name)["value"], origin, None) mp.put( mp.get(mapa_cables_landing, cable_name)["value"], destination, None) else: mp.put( mp.get(mapa_cables_landing, cable_name)["value"], origin, None) mp.put( mp.get(mapa_cables_landing, cable_name)["value"], destination, None) mapa = me.getValue(mp.get(mapa_landing, origin))[1] mp.put(mapa, cable_name, None) mapa = me.getValue(mp.get(mapa_landing, destination))[1] mp.put(mapa, cable_name, None) #Incersión de Vertices a Grafo con arcos: posOrigin = mp.get(mapa_landing, origin)["value"][0] posDestination = mp.get(mapa_landing, destination)["value"][0] costo = hs.haversine(posOrigin, posDestination) origin = origin + "|" + cable_name destination = destination + "|" + cable_name gr.insertVertex(grafo, origin) gr.insertVertex(grafo, destination) gr.addEdge(grafo, origin, destination, costo) idVertice1 = lt.getElement(gr.vertices(catalog["connections"]), 1).split("|")[0] #Creación de arcos entre vertices de un mismo Landing Point: llaves = mp.keySet(mapa_landing) for llave in lt.iterator(llaves): cables = mp.keySet(mp.get(mapa_landing, llave)["value"][1]) bwMenor = 100000000000000000000000000000000000000000000000000 for cable in lt.iterator(cables): bw = mp.get(mapa_cables, cable)["value"] if bw < bwMenor: bwMenor = bw for cable1 in lt.iterator(cables): if cable != cable1: origen = llave + "|" + cable destino = llave + "|" + cable1 if gr.getEdge(grafo, origen, destino) == None: gr.addEdge(grafo, origen, destino, 0.1) mp.put(mapa_cables, llave, bwMenor) return idVertice1
def failureOfLP(catalog, landingpoint): lp_entry = mp.get(catalog['landingpoints'], landingpoint) lst_cities = lt.newList(datastructure='ARRAY_LIST') lst_lps = lt.newList(datastructure='ARRAY_LIST') if lp_entry is not None: cables = lp_entry['value']['lstcables'] for cable in lt.iterator( mp.keySet(cables) ): # Cables adjacentes al LP por param (LP es solo el numero) if 'Land Cable' in cable: # Estos cables conectan a un lp con una ciudad (Capital del pais donde esta el LP que entra por param) lt.addLast(lst_cities, cable.split('-')[1:]) elif not 'Local Cable' in cable: # Ver los cables adjacentes (que no forman parte de la red local) vertex = landingpoint + "-" + cable # "Arma" los vertices tipo <LP>-<Cable> adjacents = gr.adjacents( catalog['internet_graph'], vertex) # * Estos son los "verdaderos" adjs del LP for adj_vertex in lt.iterator(adjacents): # Para cada adjacente que sea del tipo <LP>-<Cable> y que ya no este en la lista de lps if '-' in adj_vertex and not (lt.isPresent( lst_lps, adj_vertex.split('-')[:1])): lt.addLast(lst_lps, adj_vertex.split('-') [:1]) # Se guarda solo el # del LP lst_countries = locateLPs(catalog, lst_lps) # Donde esta cada LP adj for city in lt.iterator( lst_cities ): # Revisa la lista de ciudades (Se espera que solo haya una - capital de donde esta el LP) country = mp.get(catalog['capitals'], city[0])['value'] if not lt.isPresent(lst_countries, country): # Añade a los paises si no esta todavia lt.addLast(lst_countries, city) lp_lat = mp.get(catalog['landingpoints'], landingpoint)['value']['info']['latitude'] lp_lon = mp.get(catalog['landingpoints'], landingpoint)['value']['info']['longitude'] pre_sort = lt.newList() for country in lt.iterator(lst_countries): # Para cada paiis adjacente, calcula la distancia entre su capital y el LP por param cc_lat = mp.get(catalog['countries'], country)['value']['CapitalLatitude'] cc_lon = mp.get(catalog['countries'], country)['value']['CapitalLongitude'] distance = calcHaversine(lp_lat, lp_lon, cc_lat, cc_lon) lt.addLast( pre_sort, { 'country': country, 'distance': distance, 'CapitalLatitude': cc_lat, 'CapitalLongitude': cc_lon }) # Ordena la lista final en orden descendente en cuanto a la distancia en km entre el LP y los piaises sorted_country = mer.sort(pre_sort, sortCountries) return sorted_country
def getdatesbyrange(cont): initialdate = input('ingrese la fecha inicial') finaldate = input('Ingrese la fecha final') n = int(input('Ingrese número de taxis:')) - 1 initialdate = datetime.datetime.strptime(initialdate, '%Y-%m-%d') initialdate = initialdate.date() finaldate = datetime.datetime.strptime(finaldate, '%Y-%m-%d') finaldate = finaldate.date() crimedates = om.values(cont, initialdate, finaldate) crimedates = crimedates['last'] crimedates = crimedates['info'] a = crimedates['taxiIndex'] millas1 = {} dinero1 = {} servicios1 = {} b = map.keySet(a) i = it.newIterator(b) puntajes = {} while it.hasNext(i): c = it.next(i) millas = 0 servicios = 0 dinero = 0 taxi = map.get(a, c) taxi = me.getValue(taxi) taxi = taxi['lsttrips'] x = it.newIterator(taxi) while it.hasNext(x): w = it.next(x) if float(w['trip_total']) > 0: milla = float(w['trip_miles']) millas += milla money = float(w['trip_total']) dinero += money servicios += 1 if dinero > 0: if not w['taxi_id'] in millas1: millas1[w['taxi_id']] = millas servicios1[w['taxi_id']] = servicios dinero1[w['taxi_id']] = dinero if w['taxi_id'] in millas1: millas1[w['taxi_id']] = millas1[w['taxi_id']] + millas servicios1[w['taxi_id']] = servicios1[w['taxi_id']] dinero1[w['taxi_id']] = dinero1[w['taxi_id']] b = map.keySet(a) i = it.newIterator(b) puntajes = {} millas = 0 dinero = 0 servicios = 0 while it.hasNext(i): c = it.next(i) if c in millas1: millas = millas1[c] dinero = dinero1[c] servicios = servicios1[c] puntaje = (millas / dinero) * servicios puntajes[c] = puntaje puntajes_ord = sorted(puntajes.items(), key=operator.itemgetter(1), reverse=True) num = 1 cent = 0 while n >= 0: print( str(num) + '.' + puntajes_ord[cent][0] + ' con un total de' + ' ' + str(puntajes_ord[cent][1])) num += 1 cent += 1 n -= 1
def createLandCable(catalog, country, capitalCity, lat, lon): """ Se crea canales de comunicación terrestres al grafo --> Adiciona en la capital de cada pais -> Conectar a todos los landinpoints en el pais -> Si no hay en el pais, conectar el LP más cercano (UNO SUBMARINO - Id numerico) """ if capitalCity == '': capitalCity = country + '--' addLPVertex(catalog, capitalCity) # Agregar vertice de la capital addLandingPoint( catalog, { 'landing_point_id': capitalCity, 'id': capitalCity + '-Land-LP-' + country, 'name': capitalCity + ' Land LP ' + country, 'latitude': lat, 'longitude': lon }) # Agrega la capital al mapa de vertices # * Conectar la capital a los LPs del pais lps_in_country = False all_lps = mp.keySet(catalog['landingpoints']) min_distance = 2490239403294 closest_sub_lp = "" for landingPt in lt.iterator(all_lps): current_lp = mp.get(catalog['landingpoints'], landingPt)['value'] distance = calcHaversine(current_lp['info']['latitude'], current_lp['info']['longitude'], lat, lon) # Distancia entre capital y el LP actual if landingPt != capitalCity and country in current_lp['info']['name']: # ! Carga CON LPs centrales addCable(catalog, landingPt, capitalCity, distance) # addCable(catalog, capitalCity, landingPt, distance) lst_cables = current_lp['lstcables'] for cable in lt.iterator(mp.keySet(lst_cables)): # for cable in lt.iterator(lst_cables): # Conecta la capital tambien con los subvertices if not ('Local Cable' in cable) and not ( 'Land Cable' in cable): # ! Solo se conecta a cables submarinos lps_in_country = True # * Si hay landinpoints en el pais de la capital vertexA = formatVertex( current_lp['info']['landing_point_id'], cable) addCable( catalog, vertexA, capitalCity, distance ) # Agrega arco entre el vertice del LP (<lp>-<cable> y la capital) createLocalCable(catalog, capitalCity, False, landingPt) createLocalCable(catalog, landingPt, False, capitalCity) # addCable(catalog, capitalCity, vertexA, distance) else: # * Si no el landpoint no esta en el pais, ver si esta más cerca que el anterior if distance < min_distance: min_distance = distance closest_sub_lp = current_lp['info']['landing_point_id'] if (not lps_in_country): # * Se crea el cable de la capital al lp submarino más cercano (conecta el LP Central) # print(capitalCity, 'cercano', closest_sub_lp, 'disantcia', min_distance ) if (not closest_sub_lp == ""): # ! Carga CON LPs centrales addCable(catalog, closest_sub_lp, capitalCity, min_distance) # addCable(catalog, capitalCity, closest_sub_lp, min_distance) createLocalCable(catalog, closest_sub_lp, False, capitalCity)
def Rango(ListaR, analyzer, especifica): IdTaxis = m.newMap(numelements=37, maptype="CHAINING", loadfactor=0.4, comparefunction=comparecompany) if especifica == False: for i in range(1, lt.size(ListaR) + 1): llave = lt.getElement(ListaR, i) valor = op.get(analyzer["MapaId"], llave) valor = valor["value"] for j in range(1, lt.size(valor) + 1): Dato = lt.getElement(valor, j) TaxiId = lt.getElement(Dato, 1) Precio = float(lt.getElement(Dato, 2)) Millas = float(lt.getElement(Dato, 3)) if m.contains(IdTaxis, TaxiId) == True: Lista4 = lt.newList("ARRAY_LIST") viaje = m.get(IdTaxis, TaxiId) viaje = viaje["value"] Dato1 = float(lt.getElement(viaje, 1)) Dato2 = float(lt.getElement(viaje, 2)) Dato3 = float(lt.getElement(viaje, 3)) PrecioTotal = Precio + Dato1 MillasTotal = Millas + Dato2 TotalViajes = Dato3 + 1 lt.addFirst(Lista4, PrecioTotal) lt.addLast(Lista4, MillasTotal) lt.addLast(Lista4, TotalViajes) m.put(IdTaxis, TaxiId, Lista4) else: Lista5 = lt.newList("ARRAY_LIST") ViajesTotal = 1 lt.addFirst(Lista5, Precio) lt.addLast(Lista5, Millas) lt.addLast(Lista5, ViajesTotal) m.put(IdTaxis, TaxiId, Lista5) else: valor = op.get(analyzer["MapaId"], especifica) valor = valor["value"] for j in range(1, lt.size(valor) + 1): Dato = lt.getElement(valor, j) TaxiId = lt.getElement(Dato, 1) Precio = float(lt.getElement(Dato, 2)) Millas = float(lt.getElement(Dato, 3)) if m.contains(IdTaxis, TaxiId) == True: Lista4 = lt.newList("ARRAY_LIST") viaje = m.get(IdTaxis, TaxiId) viaje = viaje["value"] Dato1 = float(lt.getElement(viaje, 1)) Dato2 = float(lt.getElement(viaje, 2)) Dato3 = float(lt.getElement(viaje, 3)) PrecioTotal = Precio + Dato1 MillasTotal = Millas + Dato2 TotalViajes = Dato3 + 1 lt.addFirst(Lista4, PrecioTotal) lt.addLast(Lista4, MillasTotal) lt.addLast(Lista4, TotalViajes) m.put(IdTaxis, TaxiId, Lista4) else: Lista5 = lt.newList("ARRAY_LIST") ViajesTotal = 1 lt.addFirst(Lista5, Precio) lt.addLast(Lista5, Millas) lt.addLast(Lista5, ViajesTotal) m.put(IdTaxis, TaxiId, Lista5) ListaLlaves = m.keySet(IdTaxis) for k in range(1, lt.size(ListaLlaves) + 1): Llave1 = lt.getElement(ListaLlaves, k) Cambio = m.get(IdTaxis, Llave1) Cambio = Cambio["value"] ActualizacionPrecio = float(lt.getElement(Cambio, 1)) if ActualizacionPrecio == 0: ActualizacionPrecio = 1 ActualizacionMillas = float(lt.getElement(Cambio, 2)) ActualizacionViajes = float(lt.getElement(Cambio, 3)) Puntos = (ActualizacionMillas / ActualizacionPrecio) * ActualizacionViajes m.put(IdTaxis, Llave1, Puntos) return IdTaxis
comidas = map.newMap(12007, maptype='PROBING', comparefunction=comp) #agregar valores, PUT map.put(comidas, "manzana", "fruta") map.put(comidas, "banano", "fruta") map.put(comidas, "lechuga", "verdura") map.put(comidas, "espinaca", "verdura") map.put(comidas, "almendra", "nuez") #Buscar un valor, GET print(map.get(comidas, "manzana")["value"]) print() # #Recorrer todas las llaves, KEYS keys = map.keySet(comidas) i = listiterator.newIterator(keys) while listiterator.hasNext(i): k = listiterator.next(i) print(k) print() # #Recorrer las llaves y los valores keys = map.keySet(comidas) i = listiterator.newIterator(keys) while listiterator.hasNext(i): k = listiterator.next(i) v = map.get(comidas, k)["value"] print(k, v)
def stationsbyres(citibike,idstation,time_max): tiempo = minToseconds(time_max) lista = lt.newList('ARRAY_LIST',compareLists) recorrido = dfs.DepthFirstSearch(citibike['graph'],idstation) #Recorrido por el gráfo con DFS llaves = m.keySet(recorrido['visited']) #Extracción llaves del recorrido iterador = it.newIterator(llaves) #Inicializar Iterador con las llaves while it.hasNext(iterador): id = it.next(iterador) path = dfs.pathTo(recorrido,id) #Encontrar el "path" entre el vertice y el de destino if path is not None: n_lista=lt.newList('ARRAY_LIST') nueva_lista = lt.newList('ARRAY_LIST') while (not stack.isEmpty(path)): ruta = stack.pop(path) #Como path es pila, retornar el tope de la fila lt.addLast(n_lista,ruta) #Agregar a n_lista, la ruta suma = 0 while lt.size(n_lista)> 1 : if suma<= tiempo: german = lt.getElement(n_lista,1) #Hallar vértice 1 hola = lt.getElement(n_lista,2) #Hallar vértice 2 arco = gr.getEdge(citibike['graph'],german,hola) #ENcontrar el arco entre 1 y 2 peso = arco['weight'] #Encontar el peso del arco suma += peso #Suma de los pesos c= lt.removeFirst(n_lista) #Extraigo el primero de la lista lt.addLast(nueva_lista,c) #Lo añado a nueva_lista else: break if lt.isPresent(lista,nueva_lista) == 0: #Si no esta presente nueva lista en lista, lo agregó if lt.size(nueva_lista)<= 1: pass else: lt.addLast(lista,nueva_lista) else: pass count = 1 for a in range(1,lt.size(lista)+1): l = lt.getElement(lista,a) #Accedo a las listas dentro de la lista grande if lt.size(l)==2: print("=========================================") print(bold + "RUTA NÚMERO: "+ end + str(count)) print("\n") verticea = lt.getElement(l,1) verticeb = lt.getElement(l,2) arco = gr.getEdge(citibike['graph'],verticea, verticeb)['weight'] #Encuentro el peso entre dos vertices changeInfo(citibike,l,1) changeInfo(citibike,l,2) print(bold + "Segmento de ruta: " + end) printListContent(l) #Imprime los segmentos de las rutas con la información de "l" print(bold + "Tiempo estimado del segmento: "+ end) convertSecondsToDate(arco) #Convierte los segundos a formato fecha print("\n") count+=1 else: print("=========================================") print(bold + "RUTA NÚMERO: " + end + str(count)) print("\n") while 1 < lt.size(l): ll = lt.newList('ARRAY_LIST') vertice1 = lt.getElement(l,1) vertice2 = lt.getElement(l,2) arco = gr.getEdge(citibike['graph'],vertice1, vertice2)['weight'] #Encuentro el peso entre dos verices lt.addLast(ll,vertice1) lt.addLast(ll,vertice2) changeInfo(citibike,ll,1) changeInfo(citibike,ll,2) print(bold + "Segmento ruta: " + end) printListContent(ll) print(bold + "Tiempo estimado del segmento: "+ end) convertSecondsToDate(arco) #Convierte los segundos a formato fecha print("\n") lt.removeFirst(l) count+=1 print("-------------------------------------------------------") print(bold + "TOTAL DE RUTAS ENCONTRADAS: " + end +str(count-1)) return None
def generotiempo(cat, hora_1, hora_2): m_g = cat["genres"] l_gen_name = mp.keySet(m_g) l_gen_reps = lt.newList(datastructure="ARRAY_LIST") l_max_tracks_genres = "" max_reps_genre = 0 tot_reps = 0 for gen in lt.iterator(l_gen_name): a = mp.get(m_g, gen) m_gen = me.getValue(a) l_reps = om.values(m_gen, hora_1, hora_2) reps = 0 l_gen = lt.newList(datastructure="ARRAY_LIST", cmpfunction=compareValue) for e in lt.iterator(l_reps): size = lt.size(e) reps += size for i in lt.iterator(e): if lt.isPresent(l_gen, i["track_id"]) == 0: lt.addLast(l_gen, i["track_id"]) if reps > max_reps_genre: max_reps_genre = reps l_max_tracks_genres = l_gen tot_reps += reps dic = {"nombre": gen, "reps": reps} lt.addLast(l_gen_reps, dic) unique_tracks = lt.size(l_max_tracks_genres) sorted_gen = sortReps(l_gen_reps, compareReps) top_genre = lt.getElement(sorted_gen, 0) r = lt.newList(datastructure="ARRAY_LIST") m_h = cat["hashtags"] m_s = cat["sentiment"] for i in lt.iterator(l_max_tracks_genres): num_hashtags = 0 sum_vader = 0 a = mp.get(m_h, i) l_hashtags = me.getValue(a) for e in lt.iterator(l_hashtags): h = e["hashtag"].lower() if (e["created_at"] >= hora_1) and (e["created_at"] <= hora_2): if mp.contains(m_s, h): b = mp.get(m_s, h) vader = me.getValue(b) if vader != 100: num_hashtags += 1 sum_vader += vader if num_hashtags == 0: num_hashtags = 1 vader_avg = sum_vader / num_hashtags dic = {} dic["track_id"] = i dic["numero hashtags"] = num_hashtags dic["vader promedio"] = vader_avg lt.addLast(r, dic) sorted_ht = sortReps(r, compareTrackHashtags) top_tracks = lt.subList(sorted_ht, 1, 10) return (tot_reps, sorted_gen, unique_tracks, top_tracks)
def numArtists(catalog): artistList = mp.keySet(catalog["artists"]) return lt.size(artistList)
def lista_normal(mst): normal_list=lt.newList(datastructure="ARRAY_LIST") keys_ss=m.keySet(mst) for element in lt.iterator(keys_ss): lt.addLast(normal_list,m.get(mst,element)) return normal_list
def AddEdges(catalog): """ Agrega el arco entre 2 vertex """ # Obtener la lista de origen origin_keys_list = mp.keySet(catalog['map_connections']) # Iterar sobre la lista de origen origin_keys_iterator = it.newIterator(origin_keys_list) while it.hasNext(origin_keys_iterator): origin = it.next(origin_keys_iterator) # Obtener la tabla de hash de destination destination_map_Entry = mp.get(catalog['map_connections'], origin) destination_map = me.getValue(destination_map_Entry) # Obtener la lista destination destination_keys_list = mp.keySet(destination_map) # Iterar sobra la lista de destination destination_keys_iterator = it.newIterator(destination_keys_list) while it.hasNext(destination_keys_iterator): destination = it.next(destination_keys_iterator) # Obtener la tabla de cables cable_map_Entry = mp.get(destination_map, destination) cable_map = me.getValue(cable_map_Entry) # Obtener la lista de cables cable_keys_list = mp.keySet(cable_map) # Iterar sobre la lista de cables cable_keys_iterator = it.newIterator(cable_keys_list) while it.hasNext(cable_keys_iterator): cable = it.next(cable_keys_iterator) # Obtener los vertex vertex_list = gr.vertices(catalog['graph_landing_points']) # Vertex A vertexA_list = lt.newList('ARRAY_LIST') # Vertex B vertexB_list = lt.newList('ARRAY_LIST') # Vertex A capital vertexAcapital_list = lt.newList('ARRAY_LIST') # Vertex B capital vertexBcapital_list = lt.newList('ARRAY_LIST') # iterar sobre la lista de vertex vertex_list_iterator = it.newIterator(vertex_list) while it.hasNext(vertex_list_iterator): vertex = it.next(vertex_list_iterator) # Separar el vertex vertex_separado = vertex.split("*") # Ver si es origin o destination if vertex_separado[0] == origin and vertex_separado[ 2] == cable and not (mp.contains( catalog['capitals'], vertex_separado[1])): lt.addLast(vertexA_list, vertex) elif vertex_separado[0] == destination and vertex_separado[ 2] == cable and not (mp.contains( catalog['capitals'], vertex_separado[1])): lt.addLast(vertexB_list, vertex) if vertex_separado[0] == origin and mp.contains( catalog['capitals'], vertex_separado[1]): lt.addLast(vertexAcapital_list, vertex) elif vertex_separado[0] == origin and not (mp.contains( catalog['capitals'], vertex_separado[1])): lt.addLast(vertexBcapital_list, vertex) weightNocapital = weightConnection(catalog, origin, destination) # Iterar sobre list Vertex A para unir vertexA_iterator = it.newIterator(vertexA_list) while it.hasNext(vertexA_iterator): vertexA = it.next(vertexA_iterator) # Iterar sobre list Vertex B para unir vertexB_iterator = it.newIterator(vertexB_list) while it.hasNext(vertexB_iterator): vertexB = it.next(vertexB_iterator) gr.addEdge(catalog['graph_landing_points'], vertexA, vertexB, weightNocapital) # Iterar sobre list vertex A para unir vertexAcapital_iterator = it.newIterator(vertexAcapital_list) while it.hasNext(vertexAcapital_iterator): vertexAcapital = it.next(vertexAcapital_iterator) # Iterar sobre list vertex B para unir vertexBcapital_iterator = it.newIterator( vertexBcapital_list) while it.hasNext(vertexBcapital_iterator): vertexBcapital = it.next(vertexBcapital_iterator) gr.addEdge(catalog['graph_landing_points'], vertexAcapital, vertexBcapital, 585.31)
def requerimiento5_parte1(catalog, horamin, horamax): """ Devuelve el total de eventos dados los géneros y un mapa de géneros cuya valor es una tupla que contiene: el número de eventos, los artistas únicos, el mapa de artistas únicos, el valor mínimo y el valor máximo """ # Lista de listas de eventos que cumplen con el rango de horas lista_rango = om.values(catalog['time'], horamin, horamax) # Mapa con cada uno de los géneros musicales como llaves y como valor # tiene una lista donde se guardan los eventos del género mapa_generos = mp.newMap(numelements=11, maptype="PROBING", loadfactor=0.5) # Se recorre la lista de listas, obteniendo cada evento que cumple # con el rango de horas for lista_hora in lt.iterator(lista_rango): for e in lt.iterator(lista_hora): # A cada evento se mira si cumple con el rango de tempo de cada género. # Si es así, se agrega a la lista de eventos en el mapa de géneros. if e["tempo"] >= 60 and e["tempo"] <= 90: if mp.contains(mapa_generos, "Reggae"): lista_eventos = me.getValue(mp.get(mapa_generos, "Reggae")) lt.addLast(lista_eventos, e) else: nueva_lista_eventos = lt.newList("ARRAY_LIST") mp.put(mapa_generos, "Reggae", nueva_lista_eventos) if e["tempo"] >= 70 and e["tempo"] <= 100: if mp.contains(mapa_generos, "Down-tempo"): lista_eventos = me.getValue( mp.get(mapa_generos, "Down-tempo")) lt.addLast(lista_eventos, e) else: nueva_lista_eventos = lt.newList("ARRAY_LIST") mp.put(mapa_generos, "Down-tempo", nueva_lista_eventos) if e["tempo"] >= 90 and e["tempo"] <= 120: if mp.contains(mapa_generos, "Chill-out"): lista_eventos = me.getValue( mp.get(mapa_generos, "Chill-out")) lt.addLast(lista_eventos, e) else: nueva_lista_eventos = lt.newList("ARRAY_LIST") mp.put(mapa_generos, "Chill-out", nueva_lista_eventos) if e["tempo"] >= 85 and e["tempo"] <= 115: if mp.contains(mapa_generos, "Hip-hop"): lista_eventos = me.getValue(mp.get(mapa_generos, "Hip-hop")) lt.addLast(lista_eventos, e) else: nueva_lista_eventos = lt.newList("ARRAY_LIST") mp.put(mapa_generos, "Hip-hop", nueva_lista_eventos) if e["tempo"] >= 120 and e["tempo"] <= 125: if mp.contains(mapa_generos, "Jazz and Funk"): lista_eventos = me.getValue( mp.get(mapa_generos, "Jazz and Funk")) lt.addLast(lista_eventos, e) else: nueva_lista_eventos = lt.newList("ARRAY_LIST") mp.put(mapa_generos, "Jazz and Funk", nueva_lista_eventos) if e["tempo"] >= 100 and e["tempo"] <= 130: if mp.contains(mapa_generos, "Pop"): lista_eventos = me.getValue(mp.get(mapa_generos, "Pop")) lt.addLast(lista_eventos, e) else: nueva_lista_eventos = lt.newList("ARRAY_LIST") mp.put(mapa_generos, "Pop", nueva_lista_eventos) if e["tempo"] >= 60 and e["tempo"] <= 80: if mp.contains(mapa_generos, "R&B"): lista_eventos = me.getValue(mp.get(mapa_generos, "R&B")) lt.addLast(lista_eventos, e) else: nueva_lista_eventos = lt.newList("ARRAY_LIST") mp.put(mapa_generos, "R&B", nueva_lista_eventos) if e["tempo"] >= 110 and e["tempo"] <= 140: if mp.contains(mapa_generos, "Rock"): lista_eventos = me.getValue(mp.get(mapa_generos, "Rock")) lt.addLast(lista_eventos, e) else: nueva_lista_eventos = lt.newList("ARRAY_LIST") mp.put(mapa_generos, "Rock", nueva_lista_eventos) if e["tempo"] >= 100 and e["tempo"] <= 160: if mp.contains(mapa_generos, "Metal"): lista_eventos = me.getValue(mp.get(mapa_generos, "Metal")) lt.addLast(lista_eventos, e) else: nueva_lista_eventos = lt.newList("ARRAY_LIST") mp.put(mapa_generos, "Metal", nueva_lista_eventos) # Conteo con el número de eventos de todos los géneros conteo_total = 0 # Lista donde se guardarán listas [genero, número de eventos] lista_final = lt.newList("ARRAY_LIST") # Se recorre el mapa de géneros: for genero in lt.iterator(mp.keySet(mapa_generos)): lista_eventos = me.getValue(mp.get(mapa_generos, genero)) # Se obtiene el número de eventos por género conteo_genero = lt.size(lista_eventos) conteo_total += conteo_genero # Se crea la lista para cada género lista_genero = lt.newList("ARRAY_LIST") lt.addLast(lista_genero, genero) lt.addLast(lista_genero, conteo_genero) # Se agrega la lista de género a la lista global lt.addLast(lista_final, lista_genero) # Se ordena la lista de generos y número de eventos, según el número de eventos lista_final = SortGeneros(lista_final) # Se obtiene el género con mayor cantidad de eventos, es decir, el primero genero_mayor = lt.firstElement(lt.firstElement(lista_final)) # Se obtiene la lista de eventos del género con más eventos lista_genero_mayor = me.getValue(mp.get(mapa_generos, genero_mayor)) return lista_final, conteo_total, lista_genero_mayor
def connectToCapital(analyzer): countries = mp.keySet(analyzer['countries_map']) countriesUsed = lt.newList(datastructure='SINGLE_LINKED') iterator1 = it.newIterator(analyzer['landing_points']) while it.hasNext(iterator1): landingpoint = it.next(iterator1) name = landingpoint['name'] for i in range(0, lt.size(countries)): country = lt.getElement(countries, i) if country in name: lt.addLast(countriesUsed, country) capital = (mp.get(analyzer['countries_map'], country)['value'])['CapitalName'] if not gr.containsVertex( analyzer['connections_origin_destination'], capital): gr.insertVertex(analyzer['connections_origin_destination'], capital) destination = landingpoint['landing_point_id'] destinationName = mp.get(analyzer['connections_map'], destination)['value'] location1latitude = (mp.get( analyzer['countries_map'], country)['value'])['CapitalLatitude'] location1longitude = (mp.get( analyzer['countries_map'], country)['value'])['CapitalLongitude'] location1 = (float(location1latitude), float(location1longitude)) location2latitude = landingpoint['latitude'] location2longitude = landingpoint['longitude'] location2 = (float(location2latitude), float(location2longitude)) distance = hs.haversine(location1, location2) distance = float(distance) edge = gr.getEdge(analyzer['connections_origin_destination'], capital, destinationName) if edge is None: gr.addEdge(analyzer['connections_origin_destination'], capital, destinationName, distance) countrydict = {'name': country} mp.put(analyzer['landing_points_mapID'], capital[0:4], countrydict) iterator2 = it.newIterator(countries) while it.hasNext(iterator2): country = it.next(iterator2) if not lt.isPresent(countriesUsed, country): lt.addLast(countriesUsed, country) capital = (mp.get(analyzer['countries_map'], country)['value'])['CapitalName'] gr.insertVertex(analyzer['connections_origin_destination'], capital) minorDistance = 10000000000000000000000000000 minorLandingPointID = None iterator3 = it.newIterator(analyzer['landing_points']) while it.hasNext(iterator3): landingpoint = it.next(iterator3) destination = landingpoint['landing_point_id'] location1latitude = (mp.get( analyzer['countries_map'], country)['value'])['CapitalLatitude'] location1longitude = (mp.get( analyzer['countries_map'], country)['value'])['CapitalLongitude'] location1 = (float(location1latitude), float(location1longitude)) location2latitude = landingpoint['latitude'] location2longitude = landingpoint['longitude'] location2 = (float(location2latitude), float(location2longitude)) distance = hs.haversine(location1, location2) distance = float(distance) if distance < minorDistance: minorDistance = distance minorLandingPointID = landingpoint['landing_point_id'] name = mp.get(analyzer['connections_map'], minorLandingPointID)['value'] edge = gr.getEdge(analyzer['connections_origin_destination'], capital, name) if edge is None: gr.addEdge(analyzer['connections_origin_destination'], capital, name, minorDistance) countrydict = {'name': country} mp.put(analyzer['landing_points_mapID'], capital[0:4], country) return analyzer
def req5(catalog, minimo, maximo): dic = catalog["created_at"] llaves = om.keys(dic, minimo, maximo) global lista lista = catalog["lista_canciones"] generos = catalog["generos-intervalos"] llavesGeneros = mp.keySet(generos) mapaGeneros = mp.newMap(numelements=13, loadfactor=0.3, maptype="PROBING") for genero in lt.iterator(llavesGeneros): mp.put(mapaGeneros, genero, lt.newList(datastructure="SINGLE_LINKED")) for llave in lt.iterator(llaves): entry = om.get(dic, llave) referencias = me.getValue(entry) for referencia in lt.iterator(referencias): track = lt.getElement(lista, referencia) for genero in lt.iterator(llavesGeneros): entry = mp.get(generos, genero) intervalo = me.getValue(entry) if track["tempo"] >= intervalo[0] and track["tempo"] <= intervalo[1]: entry = mp.get(mapaGeneros, genero) listaGenero = me.getValue(entry) lt.addLast(listaGenero, referencia) listaTuplas = lt.newList(datastructure="ARRAY_LIST") for key in lt.iterator(llavesGeneros): entry = mp.get(mapaGeneros, key) Lst = me.getValue(entry) tupla = (key, lt.size(Lst)) lt.addLast(listaTuplas, tupla) mergeSort(listaTuplas, cmpfunction) entry = mp.get(mapaGeneros, lt.firstElement(listaTuplas)[0]) lst0 = me.getValue(entry) lst = lt.newList(datastructure="ARRAY_LIST") for elemento in lt.iterator(lst0): lt.addLast(lst, elemento) global TrackId TrackId = catalog["track_id"] eventosUnicos = mp.newMap(maptype="PROBING", loadfactor=0.3) for referencia in lt.iterator(lst): mp.put(eventosUnicos, lt.getElement(lista, referencia)["track_id"], None) mergeSort(lst, cmpfunction2) repetidos = lt.newList(datastructure="SINGLE_LINKED") contador = 0 pos = 0 tracksVader = lt.newList(datastructure="SINGLE_LINKED") while contador < 10 and pos <= lt.size(lst): referencia = lt.getElement(lst, pos) pos += 1 track_id = lt.getElement(lista, referencia)["track_id"] if lt.isPresent(repetidos, track_id) == 0: lt.addLast(repetidos, track_id) entrada = mp.get(catalog["track_id"], track_id) mapa = me.getValue(entrada)[1] hashtagsTrack = mp.keySet(mapa) promedio = 0 for hashtag in lt.iterator(hashtagsTrack): Entrada = mp.get(catalog["hashtags"], hashtag) if Entrada != None: vader = me.getValue(Entrada) promedio += vader if promedio != 0: promedio /= lt.size(hashtagsTrack) info = (track_id, lt.size(hashtagsTrack), promedio) lt.addLast(tracksVader, info) contador += 1 return (listaTuplas, mp.size(eventosUnicos), tracksVader)
return 0 elif (key > key2): return 1 else: return -1 tablaDeSimbolos = mp.newMap(numelements=2, maptype='PROBING', comparefunction=cmpFunction) #put mp.put(tablaDeSimbolos, 'llave1', 'valor1') mp.put(tablaDeSimbolos, 'llave2', 'valor2') mp.put(tablaDeSimbolos, 'llave3', 'valor3') #contains print(mp.contains(tablaDeSimbolos, 'x')) #get v = mp.get(tablaDeSimbolos, 'llave1') print(v['value']) # #delete mp.remove(tablaDeSimbolos, 'llave2') # #Iterar print() for key in lt.iterator(mp.keySet(tablaDeSimbolos)): print(key, ': ', mp.get(tablaDeSimbolos, key)['value'])
def req7(datos, ip1, ip2): vertices = gr.vertices(datos['cables']) ayuda = 0 base = 'http://ip-api.com/json/' ip_1 = base + ip1 ip_2 = base + ip2 mayor_ip1 = 1000000000000000000000000000000000000000000000000000000000 mayor_ip2 = 1000000000000000000000000000000000000000000000000000000000 vertice1 = '' vertice2 = '' posiblesip1 = [] posiblesip2 = [] distancia_ip1 = {} distancia_ip2 = {} info_ip1 = re.get(ip_1).json() info_ip2 = re.get(ip_2).json() ubicacion_ip1 = (info_ip1['lat'], info_ip1['lon']) ubicacion_ip2 = (info_ip2['lat'], info_ip2['lon']) l = mp.keySet(datos['landing']) o = 0 while o < lt.size(l): identificador = lt.getElement(l, o) x = mp.get(datos['landing'], identificador) comparar = x['value']['id'] if ((info_ip1['country']).replace(' ', '')).lower() in comparar: posiblesip1.append(x['value']) elif ((info_ip2['country']).replace(' ', '')).lower() in comparar: posiblesip2.append(x['value']) o += 1 for i in posiblesip1: ubicion = (i['latitude'], i['longitude']) respuesta = distancia_puntos(ubicion, ubicacion_ip1) distancia_ip1[i['id']] = (i, respuesta) for jk in posiblesip2: ubicion1 = (jk['latitude'], jk['longitude']) respuesta1 = distancia_puntos(ubicion1, ubicacion_ip2) distancia_ip2[jk['id']] = (jk, respuesta1) for gh in distancia_ip1: if mayor_ip1 > distancia_ip1[gh][1]: mayor_ip1 = distancia_ip1[gh][1] vertice1 = distancia_ip1[gh][0] for lk in distancia_ip2: if mayor_ip2 > distancia_ip2[lk][1]: mayor_ip2 = distancia_ip2[lk][1] vertice2 = distancia_ip2[lk][0] vertice1 = vertice1['id'] vertice2 = vertice2['id'] while ayuda < lt.size(vertices): ojala = lt.getElement(vertices, ayuda) kfj = ((lt.getElement(vertices, ayuda).replace('-', '')).replace(' ', '')).lower() if vertice1 in kfj: vertice1 = ojala if vertice2 in kfj: vertice2 = ojala ayuda += 1 grafo = datos['cables'] khi = di.Dijkstra(grafo, vertice1) pila = di.pathTo(khi, vertice2) try: tamano = st.size(pila) respuesta = pila except: tamano = 0 respuesta = 'no hay un camino entre las direcciones ip' return tamano, respuesta
def getLastCountry(analyzer): lpints = m.keySet(analyzer['countries']) entry = m.get(analyzer['countries'],lpints['last']['info']) return entry['value']
# id, map.put(animales, "1", {"tipo": "ave", "num_pies": 2, "nombre": "colibri"}) map.put(animales, "2", {"tipo": "insecto", "num_pies": 6, "nombre": "mariposa"}) map.put(animales, "3", {"tipo": "mamifero", "num_pies": 4, "nombre": "perro"}) map.put(animales, "4", {"tipo": "mamifero", "num_pies": 0, "nombre": "ballena"}) map.put(animales, "5", {"tipo": "ave", "num_pies": 2, "nombre": "avestrus"}) #======================================== # Quiero buscar los animales por tipo y num_pies #======================================== animalesPorTipoYNumPies = map.newMap(12007, maptype='PROBING', comparefunction=comp) keys = map.keySet(animales) i = listiterator.newIterator(keys) while listiterator.hasNext(i): k = listiterator.next(i) v = map.get(animales, k)["value"] if map.get(animalesPorTipoYNumPies, v["tipo"] + "$" + str(v["num_pies"])) == None: t = lst.newList('LINKED_LIST') lst.addLast(t, v) map.put(animalesPorTipoYNumPies, v["tipo"] + "$" + str(v["num_pies"]), t) else: lst.addLast( map.get(animalesPorTipoYNumPies, v["tipo"] + "$" + str(v["num_pies"]))["value"], v)
def obtainCompanies(catalog): """ Obtiene los nombres de las compañías (llaves) en el catálogo """ return m.keySet(catalog['companies'])
def crearMapaTracks(catalog, rango_menor, rango_mayor, genero): """ Crea un mapa, donde cada llave es el id de cada canción y los valores son una lista con hashtags asociados a esa canción. Parámetros: catalog = el catálogo donde está guardado todo. rango_menor = el valor menor del rango de interés. rango_mayor = el valor mayor del rango de interés. genero = el genero ingresado por el usuario. Retorna: una tupla, donde [0] es una tabla de Hash, donde cada llave es el id de cada canción y el valor es una lista con los hashtags asociados a esa canción, y donde [1] es el total de canciones únicas de ese género. """ arbol = catalog['date_RBT'] valores = om.values(arbol, rango_menor, rango_mayor) tamaño_tabla = lt.size(valores) cancionesUnicas = mp.newMap(3000, maptype='CHAINING', loadfactor=4.0, comparefunction=compareArtistid) i = 1 while i <= tamaño_tabla: diccionario = lt.getElement(valores, i) tablaGeneros = diccionario['generos'] diccionario_2 = mp.get(tablaGeneros, genero) if diccionario_2 != None: tablaCanciones = diccionario_2['value']['canciones'] llaves = mp.keySet(tablaCanciones) size_llaves = lt.size(llaves) j = 1 while j <= size_llaves: elemento = lt.getElement(llaves, j) pareja = mp.get(tablaCanciones, elemento) llave = me.getKey(pareja) valor = me.getValue(pareja) lista_hashtags = valor esta = mp.contains(cancionesUnicas, llave) if esta == False: mp.put(cancionesUnicas, llave, lista_hashtags) else: pareja = mp.get(cancionesUnicas, llave) valor2 = me.getValue(pareja) k = 1 if valor != None: while k <= lt.size(valor): elemento = lt.getElement(valor, k) esta = lt.isPresent(valor2, elemento) if esta == 0: lt.addLast(valor2, elemento) k += 1 j += 1 i += 1 total = mp.keySet(cancionesUnicas) total_canciones_unicas = lt.size(total) return (cancionesUnicas, total_canciones_unicas)
def thread_cycle(): while True: printMenu() inputs = input('Seleccione una opción para continuar\n>') if int(inputs[0]) == 1: print("Cargando información de los archivos ....") catalog = controller.loadData(connectionsfile, landingpointsfile, countriesfile) lps = lt.firstElement(mp.keySet(catalog["landingpoints"])) lp_info = mp.get(catalog["landingpoints"], lps)['value']['info'] lp_infos = mp.get(catalog["landingpoints"], lps)['value']['lstcables'] print("Cantidad de Landing Points: ", mp.size(catalog["landingpoints"])) print("Cantidad de conexiones entre Landing Points: ", gr.numEdges(catalog["internet_graph"])) print("Cantidad de paises: ", mp.size(catalog["countries"])) lps = lt.firstElement(mp.keySet(catalog["landingpoints"])) lp_info = mp.get(catalog["landingpoints"], lps)['value']['info'] print('Primer landingpoint') print("Landing point id: ", lp_info['landing_point_id'], "id: ", lp_info['id'], "name: ", lp_info['name'], "latitude: ", lp_info['latitude'], "Longitude: ", lp_info["longitude"]) countries = lt.firstElement(mp.keySet(catalog["countries"])) country_info = mp.get(catalog["countries"], countries)['value'] print('Primer pais') print('CountryName: ', country_info['CountryName'], "Population: ", country_info['Population'], "Internet users: ", country_info['Internet users']) elif int(inputs[0]) == 2: lp1 = input('Ingrese el nombre del primer landing point: ') lp2 = input('Ingrese el nombre del segundo landing point: ') optionTwo(catalog, lp1, lp2) elif int(inputs[0]) == 3: optionThree(catalog) elif int(inputs[0]) == 4: country_1 = input('Ingrese el primer país: ') country_2 = input('Ingrese el segundo país: ') optionFour(catalog, country_1, country_2) elif int(inputs[0]) == 5: optionFive(catalog) elif int(inputs[0]) == 6: landingpoint = input('Ingrese el landinpoint: ') optionSix(catalog, landingpoint) elif int(inputs[0]) == 7: optionSeven(catalog) elif int(inputs[0]) == 8: optionEight(catalog) else: sys.exit(0) sys.exit(0)
def Ruta_turistica_circular(graph, tiempo, estacion_inicio): Tiempo = float(tiempo) * 60 kosa = scc.KosarajuSCC(graph["graph"]) est_k_idscc = kosa["idscc"] dfs_recor = dfs.DepthFirstSearchsSCC(graph["graph"], estacion_inicio, est_k_idscc) Lista = m.keySet(dfs_recor["visited"]) iterador = it.newIterator(Lista) L2 = lt.newList() while it.hasNext(iterador): element = it.next(iterador) camino = None if dfs.hasPathTo(dfs_recor, element): vertices = gr.adjacents(graph["graph"], element) it2 = it.newIterator(vertices) while it.hasNext(it2): elemento2 = it.next(it2) if elemento2 == estacion_inicio: camino = dfs.pathTo(dfs_recor, element) if camino != None: lt.addLast(L2, camino) lista_rutas = lst = lt.newList("ARRAY_LIST") iterador2 = it.newIterator(L2) while it.hasNext(iterador2): elemento = it.next(iterador2) lst = [] while (not st.isEmpty(elemento)): stop = st.pop(elemento) lst.append(stop) lt.addLast(lista_rutas, lst) lista_final = lt.newList() iterador_fin = it.newIterator(lista_rutas) while it.hasNext(iterador_fin): lista_pe = it.next(iterador_fin) total = 0 total += (len(lista_pe) - 1) * 20 * 60 edge = gr.getEdge(graph["graph"], lista_pe[len(lista_pe) - 1], lista_pe[0]) peso = float(edge["weight"]) total += peso i = 0 while i < len(lista_pe): estacion = lista_pe[i] j = i + 1 while j != 0 and i < ((len(lista_pe)) - 1): estacion2 = lista_pe[j] edge2 = gr.getEdge(graph["graph"], estacion, estacion2) peso2 = float(edge2["weight"]) total += peso2 j = 0 i += 1 lista_parcial = [] ruta = {"Peso": round(total, 2), "ruta": None} if total <= Tiempo: i = 0 while i < len(lista_pe): estacion1 = lista_pe[i] entry = m.get(graph["Estaciones"], estacion1) valor = me.getValue(entry) nombre = valor["Nombre"] lista_parcial.append(nombre) i += 1 ruta["ruta"] = lista_parcial lt.addLast(lista_final, ruta) return lista_final