def newAnalyzer():
""" Inicializa el analizador
"""
try:
analyzer = {
"hours":lt.newList("ARRAY_LIST", compare),
"companies":{
"list":lt.newList("ARRAY_LIST",compare),
"taxis":lt.newList("ARRAY_LIST",compare),
"total_taxis":mp.newMinPQ(compare),
"total_services":mp.newMinPQ(compare),
"diccio":{"top_taxis":[],"top_services":[]}},
"NumTrips": 0,
"NumTaxis": 0,
"date":m.newMap(1000,
maptype='CHAINING',
loadfactor=5,
comparefunction=compareMap),
"list_dates":lt.newList("ARRAY_LIST", compare),
"arbol_dates":om.newMap(omaptype='RBT',
comparefunction=compare)
}
createHoursGraph(analyzer["hours"])
return analyzer
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def stationsUsage(analyzer):
indegreePQ = pq.newMinPQ(cmpfunction=compareDegreeMax)
outdegreePQ = pq.newMinPQ(cmpfunction=compareDegreeMax)
lessUsedPQ = pq.newMinPQ(cmpfunction=compareDegreeMin)
vortexLst = gr.vertices(analyzer["graph"])
ite = it.newIterator(vortexLst)
while it.hasNext(ite):
station = it.next(ite)
StationName = getName(analyzer["stationinfo"], station)
#Se obtienen los valores de las estaciones que entran, que salen y su suma
indegree = gr.indegree(analyzer["graph"], station)
outdegree = gr.outdegree2(analyzer["graph"], station)
usage = outdegree + indegree
#Se crean entradas para organizar en el PQ
indegreeEntry = {"key": indegree, "station": StationName}
outdegreeEntry = {"key": outdegree, "station": StationName}
usageEntry = {"key": usage, "station": StationName}
#Se inserta cada entrada en los PQ correspondientes
pq.insert(indegreePQ, indegreeEntry)
pq.insert(lessUsedPQ, usageEntry)
pq.insert(outdegreePQ, outdegreeEntry)
return {"In": indegreePQ, "Out": outdegreePQ, "Usage": lessUsedPQ}
def New_list():
lista = {
"Compañias": None,
"Servicios": None,
"Puntos": None,
"Info": None
}
lista['Compañias'] = mpq.newMinPQ(comparar_taxis)
lista['Servicios'] = mpq.newMinPQ(comparar_taxis)
lista['Puntos'] = mpq.newMinPQ(comparar_taxis)
lista["Info"] = {}
return lista
def topN(theServices,N):
valores=[]
res={}
i=0
n=0
keys= m.keySet(theServices)
values=m.valueSet(theServices)
itv=it.newIterator(values)
itk=it.newIterator(keys)
orden=mpq.newMinPQ(comparemaxpq)
while it.hasNext(itv):
value=it.next(itv)
key= it.next(itk)
if key!= "Independent Owner":
mpq.insert(orden,value[1])
while i<N:
valor=mpq.min(orden)
valores.append(valor)
res[valor]=[]
mpq.delMin(orden)
i+=1
itval=it.newIterator(values)
itke=it.newIterator(keys)
while it.hasNext(itval):
val=it.next(itval)
ke= it.next(itke)
if ke!= "Independent Owner":
for i in valores:
if i==val[1]:
if ke not in res[i] and n<N:
res[i].append(ke)
n+=1
return res
def getBestMTaxisByRange(analyzer, initDate, finalDate, M):
dateslist = om.keys(analyzer['DateIndex'], initDate, finalDate)
if lt.isEmpty(dateslist):
return 0
iterator = it.newIterator(dateslist)
pointdic = {}
while it.hasNext(iterator):
date = it.next(iterator)
dictaxis = me.getValue(om.get(analyzer["DateIndex"], date))
for tid in dictaxis:
if tid not in pointdic:
pointdic[tid] = {
"miles": 0,
"total": 0,
"services": 0,
"points": 0
}
pointdic[tid]["miles"] += dictaxis[tid]["miles"]
pointdic[tid]["total"] += dictaxis[tid]["total"]
pointdic[tid]["services"] += dictaxis[tid]["services"]
if pointdic[tid]["total"] != 0:
pointdic[tid]["points"] = pointdic[tid]["miles"] * pointdic[
tid]["services"] / pointdic[tid]["total"]
qeue = pq.newMinPQ(cmpfunction=compareDegreeMax)
for taxi in pointdic:
points = pointdic[taxi]["points"]
pq.insert(qeue, {"id": taxi, "points": points})
return qeue
def getMaxPointsinDateRange(tree, mindate, maxdate, num):
taxiPoints = m.newMap(numelements=75000, comparefunction=compareTaxiId)
taxiPointsPQ = pq.newMinPQ(comparePoints)
dateRange = om.values(tree, mindate, maxdate)
dateIterator = it.newIterator(dateRange)
while it.hasNext(dateIterator):
elem = it.next(dateIterator)
taxiMap = elem['TaxiMap']
taxiIterator = it.newIterator(m.keySet(taxiMap))
while it.hasNext(taxiIterator):
eleme = it.next(taxiIterator)
if m.contains(taxiPoints, eleme):
entry = me.getValue(m.get(taxiMap, eleme))
add_points = entry['points']
other_entry = me.getValue(m.get(taxiPoints, eleme))
other_entry['points'] += add_points
else:
entry = me.getValue(m.get(taxiMap, eleme))
add_points = entry['points']
other_entry = {'taxi_id': eleme, 'points': add_points}
m.put(taxiPoints, eleme, other_entry)
keyPoints = m.keySet(taxiPoints)
keyIterator = it.newIterator(keyPoints)
while it.hasNext(keyIterator):
el = it.next(keyIterator)
points = me.getValue(m.get(taxiPoints, el))['points']
pq.insert(taxiPointsPQ, (el, points))
cont = 0
taxiList = lt.newList()
while cont < num:
tax = pq.delMin(taxiPointsPQ)
lt.addLast(taxiList, tax)
cont += 1
return taxiList
def prueba2(hola):
mx = min.newMinPQ(compareQuantity)
for h in hola:
x = min.insert(mx, h)
mayor = min.min(mx)
print(mx)
return mayor
def addAnchoQueue(catalog, point, ancho):
if mp.contains(catalog["anchos_landing"], point):
cola = me.getValue(mp.get(catalog["anchos_landing"], point))
pq.insert(cola, ancho)
else:
cola = pq.newMinPQ(cmpfunction_minPQ)
pq.insert(cola, ancho)
mp.put(catalog["anchos_landing"], point, cola)
def P_Q(analyzer):
TopS = pq.newMinPQ(cmpfunction= comparefunction)
TopT = pq.newMinPQ(cmpfunction= comparefunction)
lstcompany = m.keySet(analyzer["Company"])
iterator = it.newIterator(lstcompany)
while it.hasNext(iterator):
i = it.next(iterator)
consulta = m.get(analyzer["Company"], i)['value']
numtaxis = len(consulta["Taxis"])
numservices = (consulta["Services"])
taxisE = {"key": numtaxis, "company": i}
servicesE = {"key": numservices, "company": i}
pq.insert(TopT, taxisE)
pq.insert(TopS, servicesE)
return {"T_taxis": TopT, "T_services": TopS}
def PQmaker(analyzer):
TopServices = pq.newMinPQ(cmpfunction=comparefunction)
TopTaxis = pq.newMinPQ(cmpfunction=comparefunction)
lstcompany = m.keySet(analyzer["Company"])
iterator = it.newIterator(lstcompany)
while it.hasNext(iterator):
element = it.next(iterator)
consulta = m.get(analyzer["Company"], element)['value']
numtaxis = len(consulta["Taxis"])
numservices = (consulta["Services"])
taxisentry = {"key": numtaxis, "company": element}
servicesentry = {"key": numservices, "company": element}
pq.insert(TopTaxis, taxisentry)
pq.insert(TopServices, servicesentry)
return {"T_taxis": TopTaxis, "T_services": TopServices}
def criticalStations(analyzer):
vertexs = gr.vertices(analyzer["connections"])
indegree = mq.newMinPQ(compareinverted)
outdegree = mq.newMinPQ(compareinverted)
degree = mq.newMinPQ(comparenormal)
iterator = it.newIterator(vertexs)
res1 = lt.newList()
res2 = lt.newList()
res3 = lt.newList()
while it.hasNext(iterator):
element = it.next(iterator)
ins = (element,int(gr.indegree(analyzer["connections"],element)))
out = (element,int(gr.outdegree(analyzer["connections"],element)))
deg = (element,int(gr.indegree(analyzer["connections"],element))+int(gr.outdegree(analyzer["connections"],element)))
mq.insert(indegree,ins)
mq.insert(outdegree,out)
mq.insert(degree,deg)
for a in range(1,4):
lt.addLast(res1,mq.delMin(indegree))
lt.addLast(res2,mq.delMin(outdegree))
lt.addLast(res3,mq.delMin(degree))
return (res1,res2,res3)
def getBestNTaxisByDate(analyzer, Date, N):
"""
Para una fecha determinada, retorna el mejores N taxis.
"""
qeue = pq.newMinPQ(cmpfunction=compareDegreeMax)
Date = om.get(analyzer['DateIndex'], Date)
try:
if Date['key'] is not None:
entry = me.getValue(Date)
for taxi in entry:
points = entry[taxi]["points"]
pq.insert(qeue, {"id": taxi, "points": points})
return qeue
except:
return 0
def getMaxPointsinDate(tree, date, num):
dateEntry = om.get(tree, date)
if dateEntry is not None:
minPQ = pq.newMinPQ(comparePoints)
dateValue = me.getValue(dateEntry)
taxiMap = dateValue['TaxiMap']
taxiList = m.keySet(taxiMap)
taxiIterator = it.newIterator(taxiList)
while it.hasNext(taxiIterator):
elem = it.next(taxiIterator)
taxiValue = me.getValue(m.get(taxiMap, elem))
taxipoints = taxiValue['points']
pq.insert(minPQ, (elem, taxipoints))
cont = 0
taxis = lt.newList()
while cont < num:
taxi = pq.delMin(minPQ)
lt.addLast(taxis, taxi)
cont +=1
return taxis
else:
return None
def minpq():
minpq = pq.newMinPQ(greater)
return minpq
import config
from DISClib.ADT import minpq as pq
"""
Encontrar los 5 elementos mas pequeños de un lista
"""
def greater(key1, key2):
if key1 == key2:
return 0
elif key1 < key2:
return -1
else:
return 1
minpq = pq.newMinPQ(greater)
pq.insert(minpq, 5)
pq.insert(minpq, 23)
pq.insert(minpq, 31)
pq.insert(minpq, 15)
print(pq.delMin(minpq))
print(pq.delMin(minpq))
print(pq.delMin(minpq))