def count_intervalINF(main, m, M): ans = {'events': 0, 'idlist': lt.newList('SINGLE_LINKED')} y = 1 nums = om.keySet(main) while y <= lt.size(nums): num = lt.getElement(nums, y) pair = om.get(main, num) mini = me.getValue(pair) if float(om.minKey(mini)) > m: m == float(om.minKey(mini)) if float(om.maxKey(mini)) < M: M == float(om.maxKey(mini)) sub_nums = get_inter(om.keySet(mini), m, M) x = 1 while x <= lt.size(sub_nums): sub_num = lt.getElement(sub_nums, x) sub_pair = om.get(mini, sub_num) events = me.getValue(sub_pair) z = 1 while z <= lt.size(events): e = lt.getElement(events, z) id = e['artist_id'] ans['events'] += 1 ans['idlist'][id] = 1 z += 1 x += 1 y += 1 return ans
def reque2(main, e, E, d, D): if float(om.minKey(main)) > e: e == float(om.minKey(main)) if float(om.maxKey(main)) < E: E == float(om.maxKey(main)) nums = get_inter(om.keySet(main), e, E) ans = {'idlist': {}, 'for_show': lt.newList('SINGLE_LINKED')} y = 1 while y <= lt.size(nums): num = lt.getElement(nums, y) pair = om.get(main, num) mini = me.getValue(pair) if float(om.minKey(mini)) > d: d == float(om.minKey(mini)) if float(om.maxKey(mini)) < D: D == float(om.maxKey(mini)) sub_nums = get_inter(om.keySet(mini), d, D) x = 1 while x <= lt.size(sub_nums): sub_num = lt.getElement(sub_nums, x) sub_pair = om.get(mini, sub_num) events = me.getValue(sub_pair) z = 1 while z <= lt.size(events): e = lt.getElement(events, z) id = e['track_id'] lt.addFirst(ans['for_show'], e) ans['idlist'][id] = 1 z += 1 x += 1 y += 1 return ans
def reque1_SUP(main, m, M): if (float(om.minKey(main))) > m: m == (float(om.minKey(main))) if (float(om.maxKey(main))) < M: M == (float(om.maxKey(main))) nums = get_inter(om.keySet(main), m, M) dans = count_intervalSUP(main, nums) k = len(dans['id_list'].keys()) ans = {'t_eve': dans['events'], 't_art': k} return ans
def auxiliardelaauxiliar(catalog, initial_date, final_date): """ Retorna una tupla dependiendo si el rango abarca uno o dos años """ initial_year = str(initial_date.year) final_year = str(final_date.year) initial_date_accidents = om.contains(catalog[initial_year], initial_date) final_date_accidents = om.contains(catalog[final_year], final_date) i = 0 if i == 0 and initial_date_accidents and final_date_accidents: if initial_year == final_year: keylow = om.get(catalog[initial_year], initial_date)["key"] keyhigh = om.get(catalog[initial_year], final_date)["key"] return 0, om.keys(catalog[initial_year], keylow, keyhigh) else: keymax = om.maxKey(catalog[initial_year]) dates_initial_year = om.keys(catalog[initial_year], initial_date, keymax) keymin = om.minKey(catalog[final_year]) dates_final_year = om.keys(catalog[final_year], final_date, keymin) return 1, dates_initial_year, dates_final_year return None
def getAccidentsInRange(catalog, initial_date, final_date): """ Reto3 - Req3 Retorna el número de accidentes ocurridos en un rango de fechas """ initial_year = str(initial_date.year) final_year = str(final_date.year) if initial_date == None and final_date == None: print("La fecha ingresada es errónea") else: if initial_year == final_year: keylow = om.get(catalog[initial_year], initial_date)["key"] keyhigh = om.get(catalog[initial_year], final_date)["key"] return 0, om.values(catalog[initial_year], keylow, keyhigh) else: keymax = om.maxKey(catalog[initial_year]) dates_initial_year = om.values(catalog[initial_year], initial_date, keymax) keymin = om.minKey(catalog[final_year]) dates_final_year = om.values(catalog[final_year], final_date, keymin) return 1, dates_initial_year, dates_final_year return None
def getAccidentsByRangeHour(analyzer, initialDate, fecha_final): lst = om.values(analyzer['hourIndex'], initialDate, fecha_final) lstiterator = it.newIterator(lst) tot_accidents = 0 mapa = om.newMap(comparefunction=compareIds) mapa2 = om.newMap(comparefunction=compareIds) while (it.hasNext(lstiterator)): lstdate = it.next(lstiterator) accidentes_max = 0 i = 1 while i <= 4: num = getaccidentesByRangeCodeHour(analyzer, lstdate, str(i)) tot_accidents += num accidentes_max += num i += 1 if om.contains(mapa2, i): om.put(mapa2, i, int(om.get(mapa2, i)['value']) + num) else: om.put(mapa2, i, num) om.put(mapa, accidentes_max, str(lstdate)) resu = om.newMap(comparefunction=compareIds) max_sev = 0 sev = 0 for i in range(1, 6): if om.contains(mapa2, i): val = om.get(mapa2, i) if val['value'] > max_sev: max_sev = val['value'] sev = i om.put(resu, i, val['value']) else: om.put(resu, i, 0) om.put(resu, sev, max_sev) return tot_accidents, om.get(mapa, om.maxKey(mapa)), resu
def genero_escuchados(catalog, valor_minHora, valor_maxHora): """ """ total_reproducciones = lt.newList('ARRAY_LIST') lista_listas_reproducciones = lt.newList('ARRAY_LIST') generos = mp.keySet(catalog['musicaGenero']) iteratorgenero = it.newIterator(generos) while it.hasNext(iteratorgenero): genero = it.next(iteratorgenero) cantidad_genero = lt.newList('ARRAY_LIST') MapGeneros = mp.get(catalog['musicaGenero'], genero) RBTgenero = me.getValue(MapGeneros) valor_min = om.minKey(RBTgenero) valor_max = om.maxKey(RBTgenero) lista_listas_musica = om.values(RBTgenero, valor_min, valor_max) lista_lista_musica = it.newIterator(lista_listas_musica) while it.hasNext(lista_lista_musica): lista_musica = it.next(lista_lista_musica) musicas = it.newIterator(lista_musica) while it.hasNext(musicas): musica = it.next(musicas) fecha = musica['created_at'] fecha = fecha[11:] if fecha >= valor_minHora and fecha <= valor_maxHora: if lt.isPresent(cantidad_genero, (musica['created_at'] + musica['user_id'] + musica['track_id'])) == 0: lt.addLast(cantidad_genero, (musica['created_at'] + musica['user_id'] + musica['track_id'])) if lt.isPresent( total_reproducciones, (musica['created_at'] + musica['user_id'] + musica['track_id'])): lt.addLast( total_reproducciones, (musica['created_at'] + musica['user_id'] + musica['track_id'])) else: if lt.isPresent( total_reproducciones, (musica['created_at'] + musica['user_id'] + musica['track_id'])): lt.addLast( total_reproducciones, (musica['created_at'] + musica['user_id'] + musica['track_id'])) lt.addLast(lista_listas_reproducciones, (genero, lt.size(cantidad_genero))) print('Total of repruductions between ' + valor_minHora + ' and ' + valor_maxHora + ' is ' + str(lt.size(total_reproducciones))) sa.sort(lista_listas_reproducciones, cmptamanio) print('================= GENRES SORTED REPRODUCTIONS ===============') i = 1 while i <= lt.size(lista_listas_reproducciones): print('TOP ' + str(i) + ': ' + str(lt.getElement(lista_listas_reproducciones, i)[0]) + ' with ' + str(lt.getElement(lista_listas_reproducciones, i)[1]) + ' reps') i += 1
def maxKey(analyzer): """ Llave mas grande """ respuesta = om.maxKey(analyzer['fechas']) return (respuesta)
def generos_existentes(catalog, generos): """ Retorna en modo print la informacion de los generos """ lista_repetidos_total = lt.newList('ARRAY_LIST') list_generos = generos.split(",") for genero in list_generos: artistasNoRepetidos = lt.newList('ARRAY_LIST') artistasRepetidos = lt.newList('ARRAY_LIST') MapGeneros = mp.get(catalog['musicaGenero'], genero) RBTgenero = me.getValue(MapGeneros) valor_min = om.minKey(RBTgenero) valor_max = om.maxKey(RBTgenero) lista_listas_musica = om.values(RBTgenero, valor_min, valor_max) lista_lista_musica = it.newIterator(lista_listas_musica) while it.hasNext(lista_lista_musica): lista_musica = it.next(lista_lista_musica) musicas = it.newIterator(lista_musica) while it.hasNext(musicas): musica = it.next(musicas) if int(lt.isPresent(artistasNoRepetidos, musica['artist_id'])) == 0: lt.addLast(artistasNoRepetidos, musica['artist_id']) if int( lt.isPresent( artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0: lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id'])) #if int(lt.isPresent(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0: # lt.addLast(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id'])) else: if int( lt.isPresent( artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0: lt.addLast(artistasRepetidos, (musica['created_at'] + musica['user_id'] + musica['track_id'])) #if int(lt.isPresent(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id']))) == 0: # lt.addLast(lista_repetidos_total, (musica['created_at'] + musica['user_id'] + musica['track_id'])) print( str(genero) + ' is between ' + str(valor_min) + ' and ' + str(valor_max)) print('Total of reproduction: ' + str(lt.size(artistasRepetidos)) + ' Total of unique artists: ' + str(lt.size(artistasNoRepetidos))) print('--------------- Some artists for ' + str(genero) + ' -----------') i = 0 while i <= 9: print('Artist ' + str(i) + ': ' + lt.getElement(artistasNoRepetidos, i)) i += 1 print('Total of reproduction is ' + str(lt.size(lista_repetidos_total)))
def Req5Anexo(arbol): i = 0 while i < 3: mayorVader = om.maxKey(arbol) evento = me.getValue(om.get(arbol, mayorVader)) print('El evento con track_id:', evento['track_id'], 'con un Vader de', mayorVader) om.deleteMax(arbol) i += 1
def infAnalyzer(analyzer): """ Dado un analizador retorna informacion sobre este. """ high = om.height(analyzer['dateIndex']) nodes = om.size(analyzer['dateIndex']) min_key = om.minKey(analyzer['dateIndex']) max_key = om.maxKey(analyzer['dateIndex']) return (high, nodes, min_key, max_key)
def tercera_consulta(citibike): tree = om.newMap(omaptype='RBT', comparefunction=compareroutes) diccionario = {} list_vertext = gr.vertices(citibike["graph"]) ite = it.newIterator(list_vertext) while it.hasNext(ite): vertex = it.next(ite) arrive = gr.indegree(citibike["graph"], vertex) if arrive > 0: om.put(tree, arrive, vertex) l = [] number = om.size(tree) resta = abs(number - 3) less = om.select(tree, resta) greater = om.maxKey(tree) ran = om.values(tree, less, greater) i = it.newIterator(ran) while it.hasNext(i): name = it.next(i) l.append(name) diccionario["llegadas"] = l tree_1 = om.newMap(omaptype='RBT', comparefunction=compareroutes) list_vertext_1 = gr.vertices(citibike["graph"]) ite_1 = it.newIterator(list_vertext_1) while it.hasNext(ite_1): vertex_1 = it.next(ite_1) arrive_1 = gr.outdegree(citibike["graph"], vertex_1) if arrive_1 > 0: om.put(tree_1, arrive_1, vertex_1) print((citibike["graph"])) l_1 = [] number_1 = om.size(tree_1) resta_1 = abs(number_1 - 3) less_1 = om.select(tree_1, resta_1) greater_1 = om.maxKey(tree_1) ran_1 = om.values(tree_1, less_1, greater_1) iterar = it.newIterator(ran_1) while it.hasNext(iterar): name_1 = it.next(iterar) l_1.append(name_1) diccionario["salidas"] = l_1 return diccionario
def AccidentesPorZona( analyzer, RadioParametro, LongitudParametro, LatitudParametro, ): TotalAccidentes = 0 Fechas = om.keys(analyzer["Llaves"], om.minKey(analyzer["Llaves"]), om.maxKey(analyzer["Llaves"])) Lunes = 0 Martes = 0 Miercoles = 0 Jueves = 0 Viernes = 0 Sabado = 0 Domingo = 0 for i in range(1, (lt.size(Fechas) + 1)): Fecha = lt.getElement(Fechas, i) Pareja = om.get(analyzer["Llaves"], Fecha) Accidentes = me.getValue(Pareja) Numero = lt.size(Accidentes) TotalAccidentes = TotalAccidentes + Numero for j in range(1, (lt.size(Accidentes) + 1)): Accidente = lt.getElement(Accidentes, j) if CalculoDeRadio(RadioParametro, LongitudParametro, LatitudParametro, float(Accidente["Start_Lng"]), float(Accidente["Start_Lat"])): dia = Dia(Fecha) if dia == "Lunes": Lunes += 1 elif dia == "Martes": Martes += 1 elif dia == "Miercoles": Miercoles += 1 elif dia == "Jueves": Jueves += 1 elif dia == "Viernes": Viernes += 1 elif dia == "Sabado": Sabado += 1 elif dia == "Domingo": Domingo += 1 Total = Lunes + Martes + Miercoles + Jueves + Viernes + Sabado + Domingo Retorno = lt.newList("ARRAY_LIST", compareIds) lt.addLast(Retorno, Lunes) lt.addLast(Retorno, Martes) lt.addLast(Retorno, Miercoles) lt.addLast(Retorno, Jueves) lt.addLast(Retorno, Viernes) lt.addLast(Retorno, Sabado) lt.addLast(Retorno, Domingo) lt.addLast(Retorno, Total) return Retorno
def test_contains(tree): tree = om.put(tree, 21, 'book21') tree = om.put(tree, 7, 'book7') tree = om.put(tree, 30, 'book30') tree = om.put(tree, 5, 'book5') tree = om.put(tree, 4, 'book4') tree = om.put(tree, 3, 'book3') tree = om.put(tree, 20, 'book20') tree = om.put(tree, 25, 'book25') tree = om.put(tree, 35, 'book35') tree = om.put(tree, 29, 'book29') tree = om.put(tree, 11, 'book11') tree = om.put(tree, 15, 'book15') tree = om.put(tree, 10, 'book10') tree = om.put(tree, 10, 'book10A') assert om.contains(tree, 29) is True assert om.contains(tree, 50) is False assert om.minKey(tree) == 3 assert om.maxKey(tree) == 35 tree = om.put(tree, 50, 'book50') assert om.contains(tree, 50) is True assert om.maxKey(tree) == 50
def majorDestiny(grafo): intree = om.newMap(omaptype="RBT", comparefunction=compareIds) pqiterator = it.newIterator(vertexNamesAge(grafo)) while it.hasNext(pqiterator): vert = it.next(pqiterator) salidas = gr.indegree(grafo, vert) om.put(intree, salidas, vert) if om.isEmpty(intree): return None else: mayor = om.get(intree, om.maxKey(intree)) mayornombre = me.getValue(mayor) return mayornombre
def bono(mapa, punto_referencia1, punto_referencia2, radio): fecha1 = om.minKey(mapa["a-fecha"]) fecha2 = om.maxKey(mapa["a-fecha"]) a_iterar = om.values(mapa["a-fecha"], fecha1, fecha2) a_comparar = Bono.distance(punto_referencia1, punto_referencia2, radio) xd = lt.newList("ARRAY_LIST") for i in range(1, lt.size(a_iterar) + 1): accidentes = lt.getElement(a_iterar, i)["accidentes_en_esta_fecha"] for e in range(1, lt.size(accidentes) + 1): elemento = lt.getElement(accidentes, e) if (Bono.distance(punto_referencia1, elemento["Start_Lat"] + elemento["Start_Lng"], radio) == a_comparar): lt.addLast(elemento["Start_Time"])
def failImpact(analyzer, landingPoint): delta_time = -1.0 delta_memory = -1.0 tracemalloc.start() start_time = getTime() start_memory = getMemory() landingPoint = landingPoint.replace(' ', '').lower() answer = model.failImpact(analyzer, landingPoint) result = answer[1] countries = [] while om.size(result) > 0: distance = om.maxKey(result) countriesList = me.getValue(om.get(result, om.maxKey(result))) for country in lt.iterator(countriesList): countries.append({'country': country, 'distance': distance}) om.remove(result, distance) # country = me.getValue(om.get(result, om.maxKey(result))) # countries.append({'country': country, 'distance': om.maxKey(result)}) # om.deleteMax(result) stop_memory = getMemory() stop_time = getTime() tracemalloc.stop() delta_time = stop_time - start_time delta_memory = deltaMemory(start_memory, stop_memory) return analyzer, answer[0], countries, delta_time, delta_memory
def auxiliarYearIterator(catalog,year_iterator,criteria,down_limit_date,up_limit_date): """ Función Axuiliar de las funciones Auxiliares. """ if criteria == 0: #Caso único para getInRange cuando el rango no soprepasa un año. keylow = om.get(catalog[year_iterator],down_limit_date)['key'] keyhigh = om.get(catalog[year_iterator],up_limit_date)['key'] Year_Dates = om.keys(catalog[year_iterator],keylow,keyhigh) elif criteria == 1: #Caso en el que se necesita las fechas de todo el año. keyhigh = om.maxKey(catalog[year_iterator]) keylow = om.minKey(catalog[year_iterator]) Year_Dates = om.keys(catalog[year_iterator],keylow,keyhigh) elif criteria == 2: #Caso en el que dada una fecha límite superior, se busca la menor llave del árbol. keylow = om.minKey(catalog[year_iterator]) keyhigh = om.get(catalog[year_iterator],up_limit_date)['key'] Year_Dates = om.keys(catalog[year_iterator],keylow,keyhigh) elif criteria == 3: #Caso en el que dada una fecha límite inferior, se busca la mayor llave del árbol. keyhigh = om.maxKey(catalog[year_iterator]) keylow = om.get(catalog[year_iterator],down_limit_date)['key'] Year_Dates = om.keys(catalog[year_iterator],keylow,keyhigh) return Year_Dates
def RankingServicios(analyzer, topN): # print(taxisPorCompania) RankingFinal = lt.newList(datastructure='SINGLE_LINKED', cmpfunction=None) rangoRanking = 0 serviciosPorCompania = ServiciosPorCompania(analyzer) while rangoRanking < topN: if serviciosPorCompania is not None: MayorValor = om.maxKey(serviciosPorCompania) nombre_compania = om.get(serviciosPorCompania, MayorValor) lt.addLast(RankingFinal, nombre_compania) if om.contains(serviciosPorCompania, MayorValor): om.remove(serviciosPorCompania, MayorValor) rangoRanking += 1 return RankingFinal
def llavesEnRango(cont, initialDate, finalDate, anio): llaves = {} if anio['type'] == 0: llaves[anio['anio']] = om.keys(cont[anio['anio']][0]['dateIndex'], initialDate, finalDate) else: for i in range(int(str(initialDate)[:4]), int(str(finalDate)[:4]) + 1): if str(i) in str(initialDate): mayor = om.maxKey(cont[str(i)][0]['dateIndex']) llaves[str(i)] = om.keys(cont[str(i)][0]['dateIndex'], initialDate, mayor) elif str(i) in str(finalDate): menor = om.minKey(cont[str(i)][0]['dateIndex']) llaves[str(i)] = om.keys(cont[str(i)][0]['dateIndex'], menor, finalDate) else: llaves[str(i)] = om.keySet(cont[str(i)][0]['dateIndex']) return llaves
def cargarporanio(cont, anio): if cont[anio][0] != None: accidentfile = cont[anio][1] print("\nCargando información de accidentes .....") controller.loadData(cont[anio][0], accidentfile) print('Accidentes cargados: ' + str(controller.accidentsSize(cont[anio][0]))) print('Altura del arbol: ' + str(controller.indexHeight(cont[anio][0])[0])) print('Elementos en el arbol: ' + str(controller.indexSize(cont[anio][0])[0])) print('Menor Llave: ' + str(controller.minKey(cont[anio][0]))) print('Mayor Llave: ' + str(controller.maxKey(cont[anio][0]))) print('Accidentes cargados: ' + str(controller.accidentsSize(cont[anio][0]))) print('Altura del arbol: ' + str(controller.indexHeight(cont[anio][0])[1])) print('Elementos en el arbol: ' + str(controller.indexSize(cont[anio][0])[1])) print('Menor Llave: ' + str(om.minKey(cont[anio][0]['timeIndex']))) print('Mayor Llave: ' + str(om.maxKey(cont[anio][0]['timeIndex'])))
def getAccidentsByGeographicZone(analyzer, longitud, latitud, radio): cant_accidentes = om.size(analyzer['dateIndex']) llaves = om.keys(analyzer['dateIndex'], om.minKey(analyzer['dateIndex']), om.maxKey(analyzer['dateIndex'])) accidentes = m.newMap(numelements=17, prime=109345121, maptype='CHAINING', loadfactor=0.5, comparefunction=compararDias) accidentes_reportados = 0 i = 1 while i <= cant_accidentes: fecha = om.get(analyzer['dateIndex'], lt.getElement(llaves, i)) lista_accidentes = fecha['value']['lstaccidents'] j = 1 while j <= lt.size(lista_accidentes): accidente = lt.getElement(lista_accidentes, j) long = float(accidente['Start_Lng']) lat = float(accidente['Start_Lat']) distancia = haversine(longitud, latitud, long, lat) if distancia <= radio: fecha = accidente['Start_Time'] anio = fecha[:4] mes = fecha[5:7] dia = fecha[8:10] dia_semana = calcular_dia(int(dia), int(mes), int(anio)) esta_dia = m.contains(accidentes, dia_semana) if not esta_dia: lista = lt.newList(datastructure='SINGLE_LINKED', cmpfunction=None) m.put(accidentes, dia_semana, lista) lis = m.get(accidentes, dia_semana) lis = lis['value'] lt.addLast(lis, accidente) m.put(accidentes, dia_semana, lis) accidentes_reportados += 1 j += 1 i += 1 return accidentes_reportados, accidentes
def test_remove(tree): tree = om.put(tree, 21, 'book21') tree = om.put(tree, 7, 'book7') tree = om.put(tree, 30, 'book30') tree = om.put(tree, 5, 'book5') tree = om.put(tree, 4, 'book4') tree = om.put(tree, 3, 'book3') tree = om.put(tree, 20, 'book20') tree = om.put(tree, 25, 'book25') tree = om.put(tree, 35, 'book35') tree = om.put(tree, 29, 'book29') tree = om.put(tree, 11, 'book11') tree = om.put(tree, 15, 'book15') tree = om.remove(tree, 21) tree = om.put(tree, 10, 'book10') tree = om.put(tree, 10, 'book10A') assert om.contains(tree, 29) is True assert om.contains(tree, 28) is False assert om.minKey(tree) == 3 assert om.maxKey(tree) == 35 om.deleteMin(tree) assert om.contains(tree, 3) is False
def top3salida(analyzer): outree = om.newMap(omaptype="RBT", comparefunction=compareIds) pqiterator = it.newIterator(vertexNames(analyzer)) while it.hasNext(pqiterator): vert = int(it.next(pqiterator)) salidas = gr.outdegree(analyzer["graph"], str(vert)) if not om.contains(outree, salidas): om.put(outree, salidas, str(vert)) else: A = om.get(outree, salidas) B = me.getValue(A) om.put(outree, salidas, str(B)+","+str(vert)) estaciones = lt.newList(datastructure="ARRAY_LIST") while lt.size(estaciones) < 3: val = om.get(outree, om.maxKey(outree)) val1 = me.getValue(val) mayorsalida = val1.split(",") for i in mayorsalida: if lt.size(estaciones) < 3: K = m.get(analyzer["nameIndex"], i) L = me.getValue(K) lt.addLast(estaciones, L) om.deleteMax(outree) return estaciones
def Accidentes_en_radio(catalog, latitud, longitud, radio, medida_r): if medida_r == "M": radio = float(radio) * 1.609 else: radio = float(radio) Latitud = float(latitud) / 57.29577951 Longitud = float(longitud) / 57.29577951 total = 0 maximo = om.maxKey(catalog['Indice_fechas']) minimo = om.minKey(catalog['Indice_fechas']) Valores = om.values(catalog['Indice_fechas'], minimo, maximo) iterador = it.newIterator(Valores) Diccionario = {} while it.hasNext(iterador): valor = it.next(iterador) lista = valor["Accidentes"] iterador2 = it.newIterator(lista) while it.hasNext(iterador2): accidente = it.next(iterador2) latitud2 = float(accidente["Start_Lat"]) / 57.29577951 longitud2 = float(accidente["Start_Lng"]) / 57.29577951 distancia = 3963.0 * math.acos( math.sin(Latitud) * math.sin(latitud2) + math.cos(Latitud) * math.cos(latitud2) * math.cos(longitud2 - Longitud)) distancia *= 1.609344 if distancia <= radio: total += 1 Fecha = accidente['Start_Time'] Fecha_accidente = datetime.datetime.strptime( Fecha, '%Y-%m-%d %H:%M:%S') if Fecha_accidente.date() not in Diccionario: Diccionario[Fecha_accidente.date()] = 0 Diccionario[Fecha_accidente.date()] += 1 else: Diccionario[Fecha_accidente.date()] += 1 return Diccionario, total
def maxKey(analyzer): return om.maxKey(analyzer['dateIndex'])
def maxKey(analyzer): """ Llave mas grande """ return om.maxKey(analyzer['dateIndex'])
def DistanceMaxKey(analyzer): return om.maxKey(analyzer['DistanceIndex'])
def TimeMaxKey(analyzer): return om.maxKey(analyzer['TimeIndex'])
def maxKey(analyzer): """Numero de autores leido """ return om.maxKey(analyzer['dates'])