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
