def requerimiento1(catalog, point1, point2): catalog['compo'] = scc.KosarajuSCC(catalog['connections']) k = 1 g = 1 tr1 = False tr2 = False while k <= lt.size(gr.vertices(catalog['connections'])) and not tr1: j = lt.getElement(gr.vertices(catalog['connections']), k) idd1 = j.split("-", 1) ll1 = mp.get(catalog['points'], idd1[0]) name1 = ll1['value']['name'] if point1.lower() in name1.lower(): ver1 = j tr1 = True k += 1 while g <= lt.size(gr.vertices(catalog['connections'])) and not tr2: i = lt.getElement(gr.vertices(catalog['connections']), g) idd2 = i.split("-", 1) ll2 = mp.get(catalog['points'], idd2[0]) name2 = ll2['value']['name'] if point2.lower() in name2.lower(): ver2 = i tr2 = True g += 1 con = scc.stronglyConnected(catalog['compo'], ver1, ver2) requerimiento8(catalog) return scc.connectedComponents(catalog['compo']), con
def addCapitalLandingPoint(analyzer, filtered_dict): """ Se agrega el nombre de la capital a un landing point Args: analyzer filtered_dict Returns: Analyzer """ # nombre: Capital-Country origen = filtered_dict['CapitalName'] + '-' + filtered_dict['CountryName'] pais = filtered_dict['CountryName'] # Conexiones con los del mismo país listaMismoPais = listaLandingsMismoPais(analyzer, pais) if lt.size(listaMismoPais) == 0: masCercano, distancia = findClosest(analyzer, pais) for vertice in lt.iterator(gr.vertices(analyzer['landingPoints'])): if masCercano in vertice: addLandingPoint(analyzer, origen) # Landing point de la capital. addConnection(analyzer, origen, vertice, distancia) addConnection(analyzer, vertice, origen, distancia) # ---------- ELSE ------------- else: for vertice in lt.iterator(gr.vertices(analyzer['landingPoints'])): for landing in lt.iterator( listaMismoPais ): # Cada LandingPoint en la lista (mismo país) if landing in vertice: addLandingPoint(analyzer, origen) # Landing point de la capital. distancia = getDistanceCapital(analyzer, pais, landing) addConnection(analyzer, origen, vertice, distancia) addConnection(analyzer, vertice, origen, distancia) return analyzer
def cantidadClusters(analyzer, id1, id2): #Req. 1 """ ----------REQUERIMIENTO 1------------ OUTPUTS: TUPLE: (1,2) 1: Clusters 2: Sí dos nodos están en el mismo clúster 3: Variable del algoritmo """ try: var = scc.KosarajuSCC(analyzer['graph']) vertices = gr.vertices(analyzer['graph']) clusters = {'size': 0} iterator = it.newIterator(vertices) while it.hasNext(iterator): current = it.next(iterator) cod = m.get(var['idscc'], current)['value'] if cod not in clusters: clusters[cod] = lt.newList(cmpfunction=compareConnections) clusters['size'] += 1 lt.addLast(clusters[cod], current) conected = False if m.get(var['idscc'], id1) != None and m.get(var['idscc'], id2) != None: conected = scc.stronglyConnected(var, id1, id2) return (clusters, conected, var) except: return -1
def routeByResistance(citibike, initialStation, resistanceTime): try: dijsktra = djk.Dijkstra(citibike["connections"], initialStation) vertices = gr.vertices(citibike["connections"]) iterator = it.newIterator(vertices) trueStations = st.newStack() stops = m.newMap(numelements=768, maptype="CHAINING", loadfactor=1, comparefunction=compareStopIds) while it.hasNext(iterator): element = it.next(iterator) if element != initialStation and djk.hasPathTo(dijsktra, element) is True: if m.get(stops, element) is None or getElement(m.get(stops, element))["value"] is False: if djk.distTo(dijsktra,element) <= resistanceTime: pila= djk.pathTo(dijsktra,element) pila2 = djk.pathTo(dijsktra,element) size_pila = 0 repetition = False lon_pila = st.size(pila) watcher = {"value": True} while size_pila < lon_pila and repetition == False: pop = st.pop(pila)["vertexB"] if m.get(stops,pop) is None or getElement(m.get(stops,pop))["value"] is False: m.put(stops,pop,watcher) else: repetition = True watcher["value"]=False size_pila +=1 if repetition == False: st.push(trueStations, pila2) return trueStations except: return None
def getMSTroots(catalog, mst_graph): roots = lt.newList(datastructure='ARRAY_LIST') mst_vertices = gr.vertices(mst_graph) i = 0 # * Ecuentra todas las 'raices' del MST (nodos/vertices con un indegree de 0) while i <= lt.size(mst_vertices): vertex = lt.getElement(mst_vertices, i) indegree = gr.indegree(mst_graph, vertex) outdegree = gr.outdegree(mst_graph, vertex) if indegree == 0 and outdegree > 0: # Outdegree > 0 para asegurar que si se conecta con algo más lt.addLast(roots, vertex) i += 1 longest_branch_dist = 0 longest_branch_bfs = None # Por cada raiz que se econtro, calcula la rama más larga entre esta y una hoja. Guarda la rama más larga entre todas las rices. for root in lt.iterator(roots): info = longestBranch(catalog, mst_graph, root) if info[0] > longest_branch_dist: longest_branch_dist = info[0] end_vertex = info[1] longest_branch_bfs = info[2] path = bfs.pathTo( longest_branch_bfs, end_vertex) # Camino entre la raiz y hoja de la rama más larga return path, longest_branch_dist
def ancho_banda(analyzer,pais,cable): vertices=gr.vertices(analyzer['connections']) lista_paises=lt.newList('ARRAYLIST') lista_pais_nu=lt.newList('ARRAYLIST') lista_final=lt.newList('ARRAYLIST') capacidad =float(me.getValue(mp.get(analyzer['cable_capacidad'],cable))) for i in range(lt.size(vertices)): vertice=lt.getElement(vertices,i) if vertice[1]==cable: pais2=me.getValue(mp.get(analyzer['vertice_pais'],vertice)) if pais2 != pais and lt.isPresent(lista_paises,pais2) == 0: interna=me.getValue(mp.get(analyzer['countries'],pais2)) numero_usuarios=float(me.getValue(mp.get(interna,'Internet users'))) x=(pais2,numero_usuarios) lt.addLast(lista_pais_nu,x) lt.addLast(lista_paises,pais2) for j in range(1,lt.size(lista_pais_nu)+1): tupla=lt.getElement(lista_pais_nu,j) ancho=(capacidad/tupla[1])*1000000 valor=(tupla[0],ancho) if lt.isPresent(lista_final,valor)==0: lt.addFirst(lista_final,valor) return lista_final
def minSpanTree(graph): search = prim.PrimMST(graph) vertices = gr.vertices(graph) mst = gr.newGraph(datastructure='ADJ_LIST', directed=False, size=14000, comparefunction=compareStopIds) for vert in lt.iterator(vertices): gr.insertVertex(mst, vert) keys = m.keySet(search['edgeTo']) totalWeight = 0 for key in lt.iterator(keys): edge = m.get(search['edgeTo'], key) gr.addEdge(mst, edge['value']['vertexA'], edge['value']['vertexB'], edge['value']['weight']) totalWeight += edge['value']['weight'] longest = longestPath(mst) sizeMst = (gr.numVertices(mst)) results = (sizeMst, totalWeight, longest) return results
def max_rama(mst): grafo = mst['grafo'] max_rama = 0 for vertice1 in lt.iterator(gr.vertices(grafo)): dijsktra = djk.initSearch(grafo, vertice1) # print('iniciando dijsktra para el vertice {}'.format(vertice1)) for vertice2 in lt.iterator(gr.vertices(grafo)): # print('revisando camino hacia el vertice {}'.format(vertice2)) if not vertice1 == vertice2: if djk.hasPathTo(dijsktra, vertice2): # print('el vertice {} tiene camino'.format(vertice2)) rama = djk.distTo(dijsktra, vertice2) # print(rama) if rama > max_rama: max_rama = rama return max_rama
def servedCables(analyzer): lstvert = gr.vertices(analyzer['connections']) map = mp.newMap(numelements=2000,maptype='PROBING') maxvert = lt.newList() maxdeg = 0 for vert in lt.iterator(lstvert): vertex = vert.split(',') contains = mp.contains(map, vertex[0]) if not contains: mp.put(map, vertex[0], 'exist') degree = numEdges(analyzer, vert) landingpoint = mp.contains(analyzer['landingpoints'], vertex[0]) if landingpoint: dataentry = mp.get(analyzer['landingpoints'], vertex[0]) lstpoint = me.getValue(dataentry)['points'] if lt.size(lstpoint) >= 2: degree -= 2 for key in lt.iterator(lstpoint): if key != vert: degree += (numEdges(analyzer, key)-2) if degree > maxdeg: maxvert = lt.newList() lt.addLast(maxvert, vert) maxdeg = degree elif degree == maxdeg: lt.addLast(maxvert, vert) return (maxvert, maxdeg)
def simulateFailure(analyzer, lp_name): ''' Calcula la lista de paises afectados ''' lp_fail = formatVertex(analyzer, lp_name) landing_points = gr.vertices(analyzer['connections']) adj_edges_list = [] vert_dist_list = [] info_out_list = [] for lp in lt.iterator(landing_points): lp_id = int(lp.split('*')[0]) if lp_fail == lp_id: adj_edges, vert_dist, info_out = LandingPointNN(analyzer, lp) adj_edges_list.append(adj_edges) vert_dist_list.append(vert_dist) info_out_list.append(info_out) vert_dist_map = {} info_out_map = {} countries = [] for i in range(len(vert_dist_list)): dists = vert_dist_list[i] verts = info_out_list[i] for k, v in dists.items(): vert_dist_map[k] = v for k, v in verts.items(): info_out_map[k] = v countries.append(v['name'].split(', ')[-1]) sort_vals = sorted(vert_dist_map.items(), key=lambda x: x[1], reverse=True) affected_countries = list(dict.fromkeys(countries)) n_affected = len(affected_countries) return sort_vals, vert_dist_map, info_out_map, n_affected
def mostConnectedLandingPoint(analyzer): ''' Calcula los landing points mas conectados ''' landing_points = gr.vertices(analyzer['connections']) lp_degs = {} # organize in dict for lp in lt.iterator(landing_points): deg_ = gr.degree(analyzer['connections'], lp) try: lp_degs[deg_].append(lp) except Exception as exp: lp_degs[deg_] = list() lp_degs[deg_].append(lp) degs_list = (lp_degs.keys()) max_deg = max(degs_list) # get max degree max_lps = lp_degs[max_deg] info_out = {} # save info of each max landing point for lp in max_lps: _, _, info_lp = LandingPointNN(analyzer, lp) neigbors = [int(nn.split('*')[0]) for nn in info_lp.keys()] lp_id = int(lp.split('*')[0]) lp_info = m.get(analyzer['landing_points'], lp_id)['value'] info_out[lp] = { 'name': lp_info['name'], 'deg': max_deg, 'lat': lp_info['latitude'], 'lon': lp_info['longitude'], 'neighbors': neigbors } return max_deg, max_lps, info_out
def touristicRoute(latIn, lonIn, latFn, lonFn, analyzer): vertexs = gr.vertices(analyzer["connections"]) iterator = it.newIterator(vertexs) sal = () lleg = () while it.hasNext(iterator): element = it.next(iterator) locationp = m.get(analyzer["location"],element) location = me.getValue(locationp) distance1 = distance(latIn,location[0],lonIn,location[1]) distance2 = distance(latFn,location[0],lonFn,location[1]) try: if sal == (): sal = (element,distance1) elif distance1 < sal[1] or (distance1<=sal[1] and gr.outdegree(analyzer["connections"],element)>gr.outdegree(analyzer["connections"],sal[1])): sal = (element,distance1) except: pass try: if lleg == (): lleg = (element,distance2) elif distance2 < lleg[1] or (distance2<=lleg[1] and gr.indegree(analyzer["connections"],element)>gr.indegree(analyzer["connections"],lleg[1])): lleg = (element,distance2) except: pass analyzer = minimumCostPaths(analyzer,sal[0]) minpath = minimumCostPath(analyzer,lleg[0]) time = djk.distTo(analyzer["paths"],lleg[0]) return (sal[0],lleg[0],minpath,time)
def requerimiento_4(analyzer,station,resistance): try: resistance=resistance*60 recorrido= bfs.BreadhtFisrtSearch(analyzer['connections'],station) size= gr.numVertices(analyzer['connections']) vertexxx= gr.vertices(analyzer['connections']) dicc= {} for i in range(1,size): ids= lt.getElement(vertexxx,i) vertice= m.get(analyzer['coordinates_destiny'],ids)['value']['name'] if bfs.hasPathTo(recorrido,ids): path= bfs.pathTo(recorrido,ids) sizep= st.size(path) if sizep != 1 : init= st.pop(path) summ= 0 dicc[vertice]= [] while sizep >= 2: vertex2= st.pop(path) if vertex2 is None : break arco= gr.getEdge(analyzer['connections'],init,vertex2) summ+= arco['weight'] init= vertex2 if summ > resistance : dicc[str(vertice)]= None else: dicc[str(vertice)].append(poner_bonita_la_ruta(analyzer,arco)) return dicc except Exception as exp: error.reraise(exp, 'model;Req_4')
def MostConnectionLPs(macrostructure): final = [] answers = [] vertices = gr.vertices(macrostructure['connections']) most_connections = 0 for index in range(0, lt.size(vertices)): vertex = lt.getElement(vertices, int(index)) connections = gr.degree(macrostructure['connections'], vertex) if connections == most_connections: answers.append(vertex) if connections > most_connections: answers = [] most_connections = connections answers.append(vertex) for ver in answers: info = lt.newList("ARRAY_LIST") datos = mp.get(macrostructure['lp'], ver)['value'] nom_pais = (lt.getElement(datos, 2)).split(', ') nombre = nom_pais[0] pais = nom_pais[1] lt.addLast(info, nombre) lt.addLast(info, pais) lt.addLast(info, ver) final.append(info) return final, most_connections
def Requirement2(analyzer): tracemalloc.start() delta_time = -1.0 delta_memory = -1.0 start_time = getTime() start_memory = getMemory() vertices = gr.vertices(analyzer["connections_origin_destination"]) size_max = 0 iterator1 = it.newIterator(vertices) while it.hasNext(iterator1): element = it.next(iterator1) adjacents = gr.adjacents(analyzer["connections_origin_destination"], element) size = lt.size(adjacents) if size >= size_max: size_max = size result = greaterLandingPoint(analyzer, element) stop_memory = getMemory() stop_time = getTime() tracemalloc.stop() delta_time = stop_time - start_time delta_memory = deltaMemory(start_memory, stop_memory) return size_max, result, delta_time, delta_memory
def recomendadorRutas(analizador,limiteinf,limitesup): listvertices=gr.vertices(analizador['connections']) iterator=it.newIterator(listvertices) mostsalida=[None,0] mostllegada=[None,0] ruta=[] while it.hasNext(iterator): verticerevisado=it.next(iterator) ctotal=0 ctotal2=0 for age in range(limiteinf,limitesup+1): if m.contains(analizador['agestartrank'],verticerevisado): diccionario=m.get(analizador['agestartrank'],verticerevisado)['value'] cantidad=diccionario.get(age,0) ctotal+=cantidad if m.contains(analizador['agefinishrank'],verticerevisado): diccionario2=m.get(analizador['agefinishrank'],verticerevisado)['value'] cantidad2=diccionario2.get(age,0) ctotal2+=cantidad2 if ctotal>mostsalida[1]: mostsalida[1]=ctotal mostsalida[0]=verticerevisado if ctotal2>mostllegada[1]: mostllegada[1]=ctotal2 mostllegada[0]=verticerevisado if mostsalida[0] != mostllegada[0]: search=djk.Dijkstra(analizador['connections'],mostsalida[0]) resultado=djk.pathTo(search,mostllegada[0]) iterator=it.newIterator(resultado) while it.hasNext(iterator): informacion=it.next(iterator) ruta.append({'Desde':m.get(analizador['nameverteces'],informacion['vertexA'])['value'],'Hasta':m.get(analizador['nameverteces'],informacion['vertexB'])['value'],'Duracion':informacion['weight']/60}) return ruta
def req5(datos, landingpoint): vertices = gr.vertices(datos['cables']) tamano = lt.size(vertices) p = 0 e = 0 final = [] paises = mp.keySet(datos['pais']) pais = [] numero = 0 while p < int(tamano): b = lt.getElement(vertices, p) if landingpoint in b: j = gr.adjacents(datos['cables'], b) l = 0 while l < lt.size(j): l += 1 y = lt.getElement(j, l) x = y.split('-') if x[0] not in pais: pais.append(x[0]) numero += 1 p += 1 while e < lt.size(paises): w = (lt.getElement(paises, e).lower()).replace(' ', '') esta(w, pais, final) e += 1 return final
def requerimiento_3(citibike): lista = gr.vertices(citibike['grafo']) dicc1 = {} dicc2 = {} dicc3 = {} iterador = it.newIterator(lista) while it.hasNext(iterador): fila = it.next(iterador) out = gr.outdegree(citibike['grafo'], fila) ins = gr.indegree(citibike['grafo'], fila) dicc1[fila] = out dicc2[fila] = ins dicc3[fila] = out + ins salida = mayores(dicc1) llegada = mayores(dicc2) ambos = menores(dicc3) nombres_salida = encontrar(dicc1, salida) nombres_llegada = encontrar(dicc2, llegada) nombres_ambos = encontrar(dicc3, ambos) print("Las 3 mejores estaciones de salida son: ") nombresI(nombres_salida, citibike) print("\nLas 3 mejores estaciones de llegada son: ") nombresF(nombres_llegada, citibike) print("\nLas 3 peores estaciones de llegada/salida son: ") for i in range(0, 3): if mp.contains(citibike["namesI"], nombres_ambos[i]): z = m.get(citibike["namesI"], nombres_ambos[i]) nombreX = en.getValue(z) nombreI = nombreX["nombre"] print(nombreI) else: z = m.get(citibike["namesF"], nombres_ambos[i]) nombreX = en.getValue(z) nombreI = nombreX["nombre"] print(nombreI)
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 parteC(analyzer, communityAreaOrigin, communityAreaDestination, rangeTime): answer = {"bestTime": "No identificada", "route": None, "duration": inf} graph = analyzer['AreaGraph'] rangeTime2 = rangeTime.split("-") ls = aboutQuarterHour(rangeTime2[0]) totalq = allQuartersInRange(rangeTime) totalq.append(ls) endVertexes = [] vertexes = gr.vertices(graph) iterator = it.newIterator(vertexes) while it.hasNext(iterator): vertex2 = it.next(iterator) vertex2 = vertex2.split("-") if communityAreaDestination == vertex2[0]: endVertexes.append("-".join(vertex2)) for i in totalq: initialVertex = communityAreaOrigin + "-" + i if gr.containsVertex(graph, initialVertex): print("A") search = djk.Dijkstra(graph, initialVertex) print("B") for k in endVertexes: if djk.hasPathTo(search, k): duration = str(djk.distTo(search, k)) route = djk.pathTo(search, k) if float(duration) < float(answer["duration"]): answer["duration"] = duration answer["route"] = route answer["bestTime"] = i return answer
def ruta_circula(graph, ref_table, tiempo, id_estacion): vertices = gr.vertices(graph) it_vertices = it.newIterator(vertices) list_station = [] while it.hasNext(it_vertices): actual_vertex = it.next(it_vertices) if id_estacion == actual_vertex: confirmador = gr.adjacents(graph, id_estacion) it_confirmador = it.newIterator(confirmador) while it.hasNext(it_confirmador): ad_vertex = it.next(it_confirmador) pt1 = Camino_corto(graph, ad_vertex, id_estacion) if pt1: if not lt.isEmpty(pt1): estacion_final = lt.firstElement(pt1) final = conversor_id_nombre(estacion_final["vertexA"], ref_table) final2 = conversor_id_nombre(estacion_final["vertexB"], ref_table) peso = estacion_final["weight"] list_station.append((final, final2, peso)) for i in list_station: if i[2] > tiempo: list_station.remove(i) return list_station
def requerimiento4(catalog): pri = prim.PrimMST(catalog['connections']) peso = prim.weightMST(catalog['connections'], pri) mst = prim.edgesMST(catalog['connections'], pri)['mst'] m = folium.Map(location=[4.6, -74.083333], tiles="Stamen Terrain") for st in lt.iterator(mst): cv = st['vertexA'].split("-", 1) ce = st['vertexB'].split("-", 1) infov = mp.get(catalog['points'], cv[0])['value'] infoe = mp.get(catalog['points'], ce[0])['value'] addPointConneMst(catalog, st['vertexA'], st['vertexB'], st['weight']) folium.PolyLine(locations=[(float(infov['latitude']), float(infov['longitude'])), (float(infoe['latitude']), float(infoe['longitude']))], tooltip=str(cv[1])).add_to(m) folium.Marker([float(infov['latitude']), float(infov['longitude'])], popup=str(infov['name'])).add_to(m) folium.Marker([float(infoe['latitude']), float(infoe['longitude'])], popup=str(infoe['name'])).add_to(m) m.save('mapa_req4.html') gramst = catalog['mst'] vert = gr.vertices(gramst) num = lt.size(vert) primero = lt.firstElement(vert) mayor = 0 camino = None dijta = djk.Dijkstra(catalog['mst'], primero) for v in lt.iterator(vert): ruta = djk.pathTo(dijta, v) x = lt.size(ruta) if x > mayor: mayor = x camino = ruta return num, peso, camino
def nombre_codigo(analyzer): vertices = gr.vertices(analyzer['connections']) for i in range(lt.size(vertices)): vertice=(lt.getElement(vertices,i)) if mp.contains(analyzer['landing'],(vertice[0])) == True: lista_interna=me.getValue(mp.get(analyzer['landing'],(vertice[0]))) nombre=((me.getValue(mp.get(lista_interna,'name'))).split(', '))[0] mp.put(analyzer['nombrelp_codigo'],nombre,vertice)
def vertice_pais(analyzer): vertices = gr.vertices(analyzer['connections']) for i in range(lt.size(vertices)): vertice=(lt.getElement(vertices,i)) if mp.contains(analyzer['landing'],(vertice[0])) == True: lista_interna=me.getValue(mp.get(analyzer['landing'],(vertice[0]))) pais=((me.getValue(mp.get(lista_interna,'name'))).split(', '))[-1] mp.put(analyzer['vertice_pais'],vertice,pais)
def addPais(catalog, pais): try: if pais['CapitalName'] != '': idorigen = pais['CapitalName'].replace("-", "").lower() else: idorigen = pais['CountryName'].replace("-", "").lower() loc1 = (float(pais['CapitalLatitude']), float(pais['CapitalLongitude'])) distancia = -1 destino = None des = None for j in lt.iterator(gr.vertices(catalog['connections'])): idd = j.split("-", 1) ll = mp.get(catalog['points'], idd[0]) i = ll['value'] loc2 = (float(i['latitude']), float(i['longitude'])) d = hs.haversine(loc1, loc2) if distancia == -1 and len(idd[1]) > 2: distancia = d des = idd destino = i elif distancia > d and len(idd[1]) > 2: distancia = d des = idd destino = i idedestino = destino['landing_point_id'] origen = formatVertex(idorigen, pais['CountryCode']) addVer(catalog, origen) point = {'landing_point_id': idorigen, 'id': str(idorigen) + '-' + pais['CountryName'], 'name': str(idorigen) + ', ' + pais['CountryName'], 'latitude': pais['CapitalLatitude'], 'longitude': pais['CapitalLongitude']} addPoint(catalog, point) for h in lt.iterator(gr.vertices(catalog['connections'])): hdd = h.split("-", 1) if des[0] == hdd[0]: cable = hdd[1] destino = formatVertex(idedestino, cable) addVer(catalog, destino) addConne(catalog, origen, destino, distancia) addConne(catalog, destino, origen, distancia) addPointcable(catalog, idorigen, pais['CountryCode']) addPointcable(catalog, idedestino, cable) addPointcable(catalog, idedestino, pais['CountryCode']) addPointcable(catalog, idorigen, cable) addMismoPais(catalog, pais) return catalog except Exception as exp: error.reraise(exp, 'model:addPais')
def IP(ana, IP1, IP2): congr = ana['connections'] countries = ana['countries'] countryKeys = m.keySet(countries) points = ana['points'] info1 = ipapi.location(IP1) hav1 = {'latitude': info1['latitude'], 'longitude': info1['longitude']} info2 = ipapi.location(IP2) if IP2 == '8.8.8.8': lat2 = -122.08286045229197 lon2 = 37.417661109182816 hav2 = {'latitude': lat2, 'longitude': lon2} else: hav2 = {'latitude': info2['latitude'], 'longitude': info2['longitude']} vertices = gr.vertices(congr) point1 = None point2 = None menor1 = 9999999999999 menor2 = 9999999999999 for i in range(0, lt.size(vertices)): vert = lt.getElement(vertices, i) code = vert.split('*')[0] try: int(code) lPoint = me.getValue(m.get(points, code)) dist1 = haversine(hav1, lPoint) dist2 = haversine(hav2, lPoint) if dist1 < menor1: menor1 = dist1 point1 = vert if dist2 < menor2: menor2 = dist2 point2 = vert except: capital = code n = 0 found = False while n < lt.size(countryKeys) and found == False: key = lt.getElement(countryKeys, n + 1) info = me.getValue(m.get(countries, key)) Capital = info['CapitalName'] if capital == Capital: found = True capLat = info['CapitalLatitude'] capLon = info['CapitalLongitude'] hav = {'latitude': capLat, 'longitude': capLon} dist1 = haversine(hav1, hav) dist2 = haversine(hav2, hav) if dist1 < menor1: menor1 = dist1 point1 = vert if dist2 < menor2: menor2 = dist2 point2 = vert n += 1 ana['IPs'] = djk.Dijkstra(ana['connections'], point1) path = djk.pathTo(ana['IPs'], point2) return path, point1, point2
def estaciones_criticas(citibike): listavertices = lt.newList("ARRAY_LIST") grafo = citibike["graph"] vertices = gr.vertices(grafo) iterador = it.newIterator(vertices) while it.hasNext(iterador): elemento = it.next(iterador) entry = m.get(citibike["Estaciones"], elemento) valor = me.getValue(entry) indegree = valor["viajes_llegada"] outdegree = valor["viajes_salida"] menor_ut = indegree + outdegree estacion = {} estacion["Estacion"] = elemento estacion["indegree"] = indegree estacion["outdegree"] = outdegree estacion["menor_ut"] = menor_ut lt.addLast(listavertices, estacion) lista = [] sort.insertionSort(listavertices, great) indegree_list = lt.subList(listavertices, 1, 3) iterador = it.newIterator(indegree_list) while it.hasNext(iterador): element = it.next(iterador)["Estacion"] entry = m.get(citibike["Estaciones"], element) if entry is not None: value = me.getValue(entry) nombre = value["Nombre"] lista.append(nombre) sort.insertionSort(listavertices, great2) outdegree_ = lt.subList(listavertices, 1, 3) iterador2 = it.newIterator(outdegree_) while it.hasNext(iterador2): element = it.next(iterador2)["Estacion"] entry = m.get(citibike["Estaciones"], element) if entry is not None: value = me.getValue(entry) nombre = value["Nombre"] lista.append(nombre) sort.insertionSort(listavertices, less) menor_u_ = lt.subList(listavertices, 1, 3) iterador3 = it.newIterator(menor_u_) while it.hasNext(iterador3): element = it.next(iterador3)["Estacion"] entry = m.get(citibike["Estaciones"], element) if entry is not None: value = me.getValue(entry) nombre = value["Nombre"] lista.append(nombre) return lista
def requerimiento5(catalog, poin): paisesf = lt.newList(datastructure='ARRAY_LIST') k = 1 tr1 = False while k <= lt.size(gr.vertices(catalog['connections'])) and not tr1: j = lt.getElement(gr.vertices(catalog['connections']), k) idd1 = j.split("-", 1) ll1 = mp.get(catalog['points'], idd1[0]) name1 = ll1['value']['name'] if poin.lower() in name1.lower(): ver1 = ll1 tr1 = True k += 1 ca = ver1['value'] tamca = lt.size(ca['cables']) for coun in lt.iterator(catalog['countries']): if coun['CapitalName'] != '': cap = coun['CapitalName'].replace("-", "").lower() else: cap = coun['CountryName'].replace("-", "").lower() tr2 = False ll2 = mp.get(catalog['points'], cap)['value'] g = 1 while g <= tamca and not tr2: c = lt.getElement(ca['cables'], g) if lt.isPresent(ll2['cables'], c) != 0: tr2 = True distanci = hs.haversine((float(ca['latitude']),float(ca['longitude'])), (float(coun['CapitalLatitude']), float(coun['CapitalLongitude']))) lt.addLast(paisesf, (coun['CountryName'], distanci, cap, c)) g += 1 paisesf = paisesf.copy() ordee = sa.sort(paisesf, kmdes) m = folium.Map(location=[4.6, -74.083333], tiles="Stamen Terrain") infov = ca folium.Marker([float(infov['latitude']), float(infov['longitude'])], popup=str(infov['name'])).add_to(m) ad = ordee for e in lt.iterator(ad): ce = e[2] infoe = mp.get(catalog['points'], ce)['value'] folium.Marker([float(infoe['latitude']), float(infoe['longitude'])], popup=str(infoe['name'])).add_to(m) folium.PolyLine(locations=[(float(infov['latitude']), float(infov['longitude'])), (float(infoe['latitude']), float(infoe['longitude']))], tooltip=str(e[3])).add_to(m) m.save('mapa_req5.html') return ordee
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 greaterDegree(ana): congr = ana['connections'] vertices = gr.vertices(congr) countries = ana['countries'] points = ana['points'] keysCountries = m.keySet(countries) mayor = -1 llaves = [] size = lt.size(vertices) for i in range(0, size): vertex = lt.getElement(vertices, i) degree = gr.degree(ana['connections'], vertex) if degree > mayor: mayor = degree llaves = [] llaves.append(vertex) elif degree == mayor: llaves.append(vertex) mayores = lt.newList() M = folium.Map() for llave in llaves: encontrado = False i = 0 while i < lt.size(keysCountries) and encontrado == False: country = lt.getElement(keysCountries, i) info = me.getValue(m.get(countries, country)) cap = info['CapitalName'] if cap == llave: encontrado = True lat = info['CapitalLatitude'] lon = info['CapitalLongitude'] loc = lat, lon name = country + ', ' + cap folium.Marker(loc, name, icon=folium.Icon(color='red', icon_color='white')).add_to(M) adj = gr.adjacents(congr, llave) for i in range(0, lt.size(adj)): vert = lt.getElement(adj, i) code = vert.split('*')[0] info = me.getValue(m.get(points, code)) latP = info['latitude'] lonP = info['longitude'] locP = latP, lonP name = info['name'] folium.Marker( locP, name, icon=folium.Icon(color='green', icon_color='white')).add_to(M) M.save('greater.html') i += 1 retorno = llave, country lt.addLast(mayores, retorno) return mayores, mayor