def estacionesCriticas(dataBase) -> dict:
top3In = list.newList()
top3Out = list.newList()
bot3 = list.newList()
analysis = Analysis.topViajes(dataBase)
i = 0
while i < 3:
list.addLast(top3In, list.removeFirst(analysis[0]))
list.addLast(top3Out, list.removeFirst(analysis[1]))
list.addFirst(bot3, list.removeLast(analysis[2]))
i += 1
del analysis
return (top3In, top3Out, bot3)
def sortVideos(catalog, size, country, category_name):
catalog2 = lt.newList(catalog["videos"]["type"],
catalog["videos"]["cmpfunction"])
idcategoria = sacaridcategoria(catalog, category_name)
if catalog["videos"]["type"] == "ARRAY_LIST":
for x in catalog["videos"]["elements"]:
if (x["category_id"] == idcategoria) and (x["country"] == country):
lt.addFirst(catalog2, x)
if catalog2["size"] < size:
print("Excede el tamaño de la lista, ingrese un valor válido")
else:
sub_list = catalog2.copy()
start_time = time.process_time()
sorted_list = ms.sort(sub_list, cmpVideosByViews)
stop_time = time.process_time()
elapsed_time_mseg = (stop_time - start_time) * 1000
return elapsed_time_mseg, sorted_list
def videos_a_dias_trending(videos):
nodiccionario = lt.newList("ARRAY_LIST")
listaids = []
for x in videos["elements"]:
if not x["video_id"] == "#NAME?":
if not x["video_id"] in listaids:
listaids.append(x["video_id"])
lt.addFirst(nodiccionario, {
"id": x["video_id"],
"apariciones": 1
})
else:
for y in nodiccionario["elements"]:
if y["id"] == x["video_id"]:
y["apariciones"] += 1
diccionariosorteado = ms.sort(nodiccionario, cmpVideosByAppearances)
return diccionariosorteado
def addInterconnection(analyzer,connection):
if not mp.contains(analyzer['interconnections'], connection['origin']):
lista=lt.newList('ARRAY_LIST')
lt.addLast(lista,1)
lt.addLast(lista,connection['cable_id'])
mp.put(analyzer['interconnections'],connection['origin'],lista)
elif mp.contains(analyzer['interconnections'], connection['origin']):
entry=mp.get(analyzer['interconnections'],connection['origin'])
lista=me.getValue(entry)
esta=False
for i in lt.iterator(lista):
if i==connection['cable_id']:
esta=True
if not esta:
numero=lt.removeFirst(lista)
numero+=1
lt.addFirst(lista,numero)
def requerimientoB(analyzer, FechaI, FechaF, FechaO):
ListaR = op.keys(analyzer["MapaId"], FechaI, FechaF)
ListaU = op.keys(analyzer["MapaId"], FechaO, FechaO)
if lt.isEmpty(ListaR) == True:
OrdenadaR = False
else:
PuntosR = Rango(ListaR, analyzer, False)
OrdenadaR = DiciaLista(PuntosR)
if lt.isEmpty(ListaU) == True:
OrdenadaU = False
else:
PuntosU = Rango(ListaU, analyzer, FechaO)
OrdenadaU = DiciaLista(PuntosU)
ListaFinal = lt.newList("ARRAY_LIST")
lt.addFirst(ListaFinal, OrdenadaU)
lt.addLast(ListaFinal, OrdenadaR)
return ListaFinal
def cargar_generos(catalogo, genre, pelicula, promedio, vote):
mapa = catalogo["genres"]
mapa2 = catalogo["genres_vote"]
pareja = mp.get(mapa, genre)
pareja2 = mp.get(mapa2, genre)
if pareja == None:
#print("Nuevo director",director,pelicula)
lista = lt.newList(datastructure="SINGLE_LINKED")
lt.addFirst(lista, (pelicula, promedio))
mp.put(mapa, genre, lista)
else:
lt.addLast(pareja["value"], (pelicula, promedio))
if pareja2 == None:
mp.put(mapa2, genre, float(vote))
else:
pareja2["value"] += float(vote)
def orden_companias(lst, cantidad_companias):
dict_companias = {}
iterator = it.newIterator(lst)
lista_resultado = lt.newList('SINGLE_LINKED', None)
while it.hasNext(iterator):
taxi = it.next(iterator)
if taxi['company'] not in dict_companias:
dict_companias[taxi['company']] = 1
else:
dict_companias[taxi['company']] += 1
lst_companies = lt.newList(datastructure='SINGLE_LINKED', cmpfunction=None)
lt.addFirst(lst_companies, dict_companias.values())
sh.shellSort(lst_companies, cmp_values)
contador = 1
while contador <= cantidad_companias:
lt.addFirst(lista_resultado, lt.getElement(lst_companies, contador))
contador += 1
return lista_resultado
def push(stack, element):
""" Agrega el elemento element en el tope de la pila.
Args:
stack: La pila donde se insetará el elemento
element: El elemento a insertar
Returns:
La pila modificada
Raises:
Exception
"""
try:
lt.addFirst(stack, element)
return stack
except Exception as exp:
error.reraise(exp, 'TADStack->Push: ')
def add_lat_lo(citibike, trip):
mapa = citibike["mapa_lat_lon"]
estacion_inicio = trip["start station id"]
latitud_inicio = trip["start station latitude"]
longitud_inicio = trip["start station longitude"]
llave = latitud_inicio + "," + longitud_inicio
estacion_final = trip["end station id"]
latitud_final = trip["end station latitude"]
longitud_final = trip["end station longitude"]
llavev2 = latitud_final + "," + longitud_final
existe = m.get(mapa, "todos")
if existe is None:
lista_owo = lt.newList("ARRAY_LIST")
a_ver = []
if llave not in a_ver:
a_ver.append(llave)
if llavev2 not in a_ver:
a_ver.append(llavev2)
lt.addLast(lista_owo, a_ver)
for i in a_ver:
lt.addLast(lista_owo, i)
m.put(mapa, "todos", lista_owo)
else:
existe = me.getValue(existe)
lista = lt.getElement(existe, 1)
lt.removeFirst(existe)
no_estan = []
if llave not in lista:
lista.append(llave)
no_estan.append(llave)
if llavev2 not in lista:
lista.append(llavev2)
no_estan.append(llavev2)
lt.addFirst(existe, lista)
for i in no_estan:
lt.addLast(existe, i)
EXadd_lat_lon(mapa, llave, estacion_inicio)
EXadd_lat_lon(mapa, llavev2, estacion_final)
def landing_principales(analyzer):
vertices = gr.vertices(analyzer['connections'])
max=0
lista=lt.newList('ARRAYLIST')
for i in range(lt.size(vertices)):
vertice=lt.getElement(vertices,i)
grado=gr.degree(analyzer['connections'],vertice)
if grado == max:
lt.addLast(lista,vertice)
if grado > max:
max=grado
lista=lt.newList('ARRAYLIST')
lt.addFirst(lista,vertice)
vermax=lt.getElement(lista,0)
return vermax[0], max
def updateTimeIndex(severityEntry:dict, accident:dict,accidentDate: datetime, )->None:
"""
Actualiza las entradas del indice Time.
parametros:
severityEntry(OrderedMap): Contiene un TimeIndex
accident(dict): Contiene la informacion acerca del accidente
"""
id = accident['ID']
accidentTime = blockTime(accidentDate.time())
entryExist = om.contains(severityEntry,accidentTime)
if entryExist:
timeEntry = om.get(severityEntry, accidentTime)
timeEntry = me.getValue(timeEntry)
else:
timeEntry = newIDList()
om.put(severityEntry,accidentTime,timeEntry)
lt.addFirst(timeEntry['idList'],id)
timeEntry['size'] += 1
def addCategoryAndCountry(catalog, video):
"""
Para el req 1, en un mapa añade llaves que son la union de una categoria y un pais y como valor guarda una lista de videos
"""
existsCategoryAndCountry = mp.contains(
catalog['categoriesAndCountries'],
(video['category_id'] + video['country'].lower().strip()))
if existsCategoryAndCountry:
existing = mp.get(
catalog['categoriesAndCountries'],
(video['category_id'] + video['country'].lower().strip()))
existingList = me.getValue(existing)
lt.addLast(existingList, video)
else:
lists = lt.newList('ARRAY_LIST')
lt.addFirst(lists, video)
mp.put(catalog['categoriesAndCountries'],
(video['category_id'] + video['country'].lower().strip()),
lists)
def topViajes(dataBase) -> tuple:
stations = dataBase['station']
topIn = list.newList()
topOut = list.newList()
topTrips = list.newList()
keys = map.keySet(stations)
keys = listiterator.newIterator(keys)
while listiterator.hasNext(keys):
key = listiterator.next(keys)
station = map.get(stations, key)
station = mapentry.getValue(station)
list.addFirst(topIn, {
'station': station['name'],
'value': station['tripsIn']
})
list.addFirst(topOut, {
'station': station['name'],
'value': station['tripsOut']
})
list.addFirst(topTrips, {
'station': station['name'],
'value': station['trips']
})
mergesort.mergesort(topIn, Comparation.tripsVal)
mergesort.mergesort(topOut, Comparation.tripsVal)
mergesort.mergesort(topTrips, Comparation.tripsVal)
return (topIn, topOut, topTrips)
def sort_sublist(catalog, numlen, category, country, tag, indicator):
lista_trabajo = lt.newList('SINGLE_LINKED')
if indicator == 1:
function = cmpVideosByViews
for i in lt.iterator(catalog['videos']):
if i['country'] == country and int(i['category_id']) == category:
lt.addFirst(lista_trabajo, i)
else:
function = cmpVideosByLikes
for i in lt.iterator(catalog['videos']):
if i['country'] == country and (tag in i['tags']):
lt.addFirst(lista_trabajo, i)
sorted_list = mg.sort(lista_trabajo, function)
try:
resultado = lt.subList(sorted_list, 1, numlen)
except:
resultado = 'No existen tantos videos, intente con un número más pequeño...'
return resultado
def addMovieByActor(catalog, actorName, movie):
actors = catalog['actors']
existactor = mp.contains(actors, actorName)
actor = None
if existactor:
entry = mp.get(actors, actorName)
actor = me.getValue(entry)
else:
actor = {
'name': actorName,
'movies': lt.newList('ARRAY_LIST', compareActorsByName),
'directors': lt.newList('ARRAY_LIST', compareDirectorsByName),
'votes': 0.0,
'vote_average': 0.0,
'vote_count': 0
}
mp.put(actors, actorName, actor)
kv1 = mp.get(catalog['moviesIds'], movie['id'])
movie1 = me.getValue(kv1)
lt.addLast(actor['movies'], movie1)
movieavg = me.getValue(kv1)['vote_average']
moviecount = me.getValue(kv1)['vote_count']
actor['votes'] += float(movieavg)
actor['vote_average'] = actor['votes'] / float(actor['movies']['size'])
actor['vote_count'] += int(moviecount)
director = actor['directors']
namedic = movie['director_name']
if director['size'] == 0 or director == None:
lt.addFirst(director, {'name': namedic, 'veces': 1})
else:
if existe(director, 'name', namedic):
for i in range(director['size']):
element = lt.getElement(director, i)
if (element['name'] == namedic):
element['veces'] += 1
break
else:
lt.addLast(director, {'name': namedic, 'veces': 1})
def addLanding(analyzer,line):
a=lt.isEmpty(analyzer['list'])
if a==True:
origin=line['\ufefforigin']
cable_id=line['cable_id']
lableo=origin+"-"+cable_id
addPoint(analyzer, lableo)
length=line['cable_length']
if length!='n.a.':
length=length.strip(" km").replace(",", "")
length=float(length)
else:
length=0.1
lt.addFirst(analyzer['list'], (lableo,length))
#mp.put(analyzer['names'], line['name'], lableo)
else:
#origin=line['\ufefforigin']
cable_id=line['cable_id']
last=lt.getElement(analyzer['list'], lt.size(analyzer['list']))
lableo=last[0]
lengthl=last[1]
destination=line['\ufefforigin']
labled=destination+"-"+cable_id
length=line['cable_length']
if length!='n.a.':
length=length.strip(" km").replace(",", "")
length=float(length)
else:
length=0
#addPoint(analyzer,lableo)
addPoint(analyzer,labled)
addLine(analyzer,lengthl,lableo,labled)
lt.addLast(analyzer['list'], (labled,length))
def createCategoryMap(catalog, idList):
iterator = slit.newIterator(idList)
while slit.hasNext(iterator):
video = slit.next(iterator)
"""
Categorizacion por categorias
"""
existingCategory = mp.contains(catalog['CategoriesById'],
video['category_id'])
if existingCategory:
existsCategory = mp.get(catalog['CategoriesById'],
video['category_id'])
categoryList = me.getValue(existsCategory)
lt.addLast(categoryList, video)
else:
newCategoryList = lt.newList('ARRAY_LIST')
lt.addFirst(newCategoryList, video)
mp.put(catalog['CategoriesById'], video['category_id'],
newCategoryList)
def req_3(self, category: str):
repeticiones = mp.newMap(numelements=20000)
for video in category_iterator(self, category):
video_id = lt.getElement(video[0], 1)
video_pair = mp.get(repeticiones, video_id)
if video_pair:
mp.put(repeticiones, video_id,
(video, video_pair['value'][1] + 1))
else:
mp.put(repeticiones, video_id, (video, 1))
videos_ids = mp.valueSet(repeticiones)
id_iter = lliterator.newIterator(videos_ids)
maximo = 0
max_vid = 0
while lliterator.hasNext(id_iter):
video = lliterator.next(id_iter)
video_rep = video[1]
if video_rep > maximo:
maximo = video_rep
max_vid = video[0]
res = lt.newList()
res_vid = mp.get(repeticiones, video_id)['value']
lt.addFirst(res, res_vid[0])
return (res, res_vid[1])
def estacionesCriticas(analyzer):
cuenta= 0
estaciones= gr.vertices(analyzer["graph"])
listaEntrada= lt.newList("ARRAY_LIST", comparestations)
listaSalida= lt.newList("ARRAY_LIST", comparestations)
listaSolitarias= lt.newList("ARRAY_LIST", comparestations)
entradasConcurridas= lt.newList("ARRAY_LIST", compareSizes)
salidasConcurridas= lt.newList("ARRAY_LIST", compareSizes)
estacionesSolitarias= lt.newList("ARRAY_LIST", compareSizes)
while cuenta<lt.size(estaciones):
estacion= lt.getElement(estaciones, cuenta)
entrada= gr.indegree(analyzer["graph"], estacion)
lt.addFirst(entradasConcurridas,entrada)
salida= gr.outdegree(analyzer["graph"], estacion)
lt.addFirst(salidasConcurridas,salida)
bidireccional= gr.degree(analyzer["graph"], estacion)
lt.addFirst(estacionesSolitarias,bidireccional)
cuenta+= 1
entradasOrg= sel.selectionSort(entradasConcurridas,lessequal)
salidasOrg= sel.selectionSort(salidasConcurridas,lessequal)
solitariasOrg= sel.selectionSort(estacionesSolitarias,lessequal)
for conteo in range(0,3):
if entrada == lt.getElement(entradasOrg, conteo):
lt.insertElement(listaEntrada, estacion, conteo)
if salida == lt.getElement(salidasOrg, conteo):
lt.insertElement(listaSalida, estacion, conteo)
if bidireccional == lt.getElement(solitariasOrg, conteo):
lt.insertElement(listaSolitarias, estacion, conteo)
if lt.size(listaEntrada) > 3:
lt.removeLast(listaEntrada)
if lt.size(listaSalida) > 3:
lt.removeLast(listaSalida)
if lt.size(listaSolitarias) > 3:
lt.removeLast(listaSolitarias)
return (listaEntrada, listaSalida, listaSolitarias)
def addMap(analyzer, trip):
if trip["trip_total"] != "" and trip["trip_miles"] != "" and float(
trip["trip_total"]) > 0 and float(trip["trip_miles"]) > 0:
llave = trip["trip_start_timestamp"]
llave = str(llave[0:10])
valor1 = trip["taxi_id"]
valor2 = float(trip["trip_total"])
valor3 = float(trip["trip_miles"])
Lista = lt.newList("ARRAY_LIST")
if op.contains(analyzer["MapaId"], llave[0:10]) == True:
Valor = op.get(analyzer["MapaId"], llave[0:10])
Valor = Valor["value"]
Lista3 = lt.newList("ARRAY_LIST")
lt.addFirst(Lista3, valor1)
lt.addLast(Lista3, valor2)
lt.addLast(Lista3, valor3)
lt.addLast(Valor, Lista3)
else:
Lista2 = lt.newList("ARRAY_LIST")
lt.addFirst(Lista2, valor1)
lt.addLast(Lista2, valor2)
lt.addLast(Lista2, valor3)
lt.addFirst(Lista, Lista2)
op.put(analyzer["MapaId"], llave[0:10], Lista)
def req5(cont, miniH, miniM, miniS, maxH, maxM, maxS, sentiment, user, cat2):
sentimen = cf.data_dir + sentiment
input_file3 = csv.DictReader(open(sentimen, encoding="utf-8"),
delimiter=",")
user = cf.data_dir + user #
input_file2 = csv.DictReader(open(user, encoding="utf-8"), delimiter=",")
lst = lt.newList()
for hashtag in input_file2:
lt.addLast(lst, hashtag)
new = it.newIterator(lst) # Ponerlo en controller
sss = lt.newList() #
for senti in input_file3:
lt.addLast(sss, senti)
itet = it.newIterator(
sss
) # Ponerlo en otro controllorer junto con el sentimen y el input_file3 csv.DictReader()
filtrada1 = total(cont, miniH, miniM, miniS, maxH, maxM, maxS)
newsaw = it.newIterator(filtrada1)
while it.hasNext(newsaw):
l = it.next(newsaw)
#cantidad2+=lt.size(l)
#print(cantidad2) #Reproducciones
nuevo = it.newIterator(l)
while it.hasNext(nuevo):
pedazo = it.next(
nuevo) #Mira cada track cumplido con el primer filtro
#ax=mp.get(pedazo,'hashtag')
ex = mp.get(pedazo, 'tempo')
ix = mp.get(pedazo, 'horas')
ox = mp.get(pedazo, 'track_id')
ux = mp.get(pedazo, 'user_id')
ax = mp.get(pedazo, 'artist_id')
#tax=me.getValue(ax)
tex = me.getValue(ex)
tix = me.getValue(ix)
tox = me.getValue(ox)
tux = me.getValue(ux)
tax = me.getValue(ax)
cantidad = 0
vader_avg = 0
while it.hasNext(new):
hashtag = it.next(
new
) #Buscar el hashtag aqui y su valor vader tambien #Mira cada hashtag
if hashtag['track_id'] == tox:
hasht = hashtag['hashtag'].lower(
) #Se busca los que sean iguales al track_id (todos los hashtag del track_id respectivo)
while it.hasNext(itet):
senti = it.next(
itet
) #Se busca basicamente que tenga un valor_vader
if senti['hashtag'].lower() == hasht:
if senti['vader_avg'] != '' and senti[
'vader_avg'] != None:
vader_avg += float(senti['vader_avg'])
cantidad += 1
break
itet = it.newIterator(sss)
new = it.newIterator(lst)
nuevodic = {}
nuevodic['tempo'] = int(tex)
nuevodic['horas'] = tix
nuevodic['track_id'] = tox
nuevodic['artist_id'] = tax
nuevodic['cantidad'] = cantidad
nuevodic['user_id'] = tux
if nuevodic['cantidad'] != 0:
vader_avg = vader_avg / cantidad
nuevodic['vader_avg'] = vader_avg
model.addTrack(cat2, nuevodic)
generos = lt.newList()
lista = [
'POP', 'REGGAE', 'DOWN-TEMPO', 'CHILL-OUT', 'HIP-HOP', 'JAZZ AND FUNK',
'R&B', 'ROCK', 'METAL'
]
#return generos
for gen in lista:
lt.addLast(generos, gen)
fua = it.newIterator(generos)
top = 0
nombretop = ""
listatop = None
cantidadT = 0
resp1 = lt.newList()
while it.hasNext(fua):
genero = it.next(fua)
if genero == "POP":
minimo = 100.0
maximo = 130.0
elif genero == 'REGGAE':
minimo = 60.0
maximo = 90.0
elif genero == 'DOWN-TEMPO': ###
minimo = 70.0
maximo = 100.0
elif genero == 'CHILL-OUT': #
minimo = 90.0
maximo = 120.0
elif genero == 'HIP-HOP': #
minimo = 85.0
maximo = 115.0
elif genero == 'JAZZ AND FUNK':
minimo = 120.0
maximo = 125.0
elif genero == 'R&B':
minimo = 60.0
maximo = 80.0
elif genero == "ROCK":
minimo = 110.0
maximo = 140.0
else:
minimo = 100.0
maximo = 160.0
pra = req4('tempo', minimo, maximo, cat2)
artistas = pra[0][0]
reproducciones = pra[0][1]
lista = pra[0][2]
cantidadT += reproducciones
if top < reproducciones:
top = reproducciones
nombretop = genero
listatop = lista
x = 1
cantidad = lt.size(lista)
lt.addLast(
resp1, {
"genero": genero,
"artista": artistas,
"reproducciones": reproducciones,
'minimo': minimo,
'maximo': maximo
})
newisi = it.newIterator(listatop)
lst = lt.newList("SINGLE_LINKED")
paaa = lt.newList("SINGLE_LINKED")
while it.hasNext(newisi):
pedazo = it.next(
newisi
) #Esto devuelve un mapa de la lista iterando (mapa de la lista(cada elemento))
nex = mp.get(
pedazo, 'track_id'
) #Devuelve la llave danceability y el valor respectivo del mapa en forma de diccionario
tax = me.getValue(
ax
) #Devuelve el valor de danceability del track sacado en el mapa de it.next(video)
fex = me.getValue(nex)
if lt.isPresent(lst, fex) == 0:
lt.addLast(paaa, pedazo)
lt.addLast(lst, fex)
totalu = lt.size(paaa)
x = 1
vistos = lt.newList()
n = 1
resp2 = lt.newList("SINGLE_LINKED")
while n <= 10:
rand = random.randint(1, totalu) #
track = lt.getElement(
paaa, rand) #Lo mismo que it.next(de un iterador de lista)
id = me.getValue(mp.get(track, 'track_id'))
hashte = me.getValue(mp.get(track, 'cantidad'))
vader = me.getValue(mp.get(track, 'vader_avg'))
if lt.isPresent(vistos, id) == 0:
lt.addFirst(
resp2, {
"0": str(x) + ':' + str(id),
"hashte": hashte,
"vader_avg": vader_avg
})
lt.addLast(vistos, id)
x += 1
n += 1
return [resp1, cantidadT, genero, totalu, resp2]
def añadir(lst, element):
lt.addFirst(lst, element)
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 addListAccident(lst, accident):
lt.addFirst(lst, accident)
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
