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
