def addCapital_V_E(analyzer, element):
graph_distance = analyzer["connections_distance"]
graph_capacity = analyzer["connections_capacity"]
country = element["CountryName"].lower()
city = element["CapitalName"].lower()
if not gr.containsVertex(graph_distance, (city, 0)):
gr.insertVertex(graph_distance, (city, 0))
if not gr.containsVertex(graph_capacity, (city, 0)):
gr.insertVertex(graph_capacity, (city, 0))
if mp.get(analyzer["vertices"], country) != None:
mapa = mp.get(analyzer["vertices"], country)["value"]
lista = mp.keySet(mapa)
i = 1
while i <= lt.size(lista):
lp_cable = lt.getElement(lista, i)
info_lp_cable = mp.get(mapa, lp_cable)["value"]
tuple_place_cablename = lp_cable
id_place = tuple_place_cablename[0]
location = mp.get(analyzer["location_dado_id"], id_place)["value"]
edge_identifier = (tuple_place_cablename, (city, 0))
cost = {"distance": None, "capacity": None}
cost["distance"] = float(
hs.haversine(location, (float(element["CapitalLatitude"]),
float(element["CapitalLongitude"]))))
cost["capacity"] = float(info_lp_cable["capacityTBPS"])
mp.put(analyzer["edges"], edge_identifier, cost)
gr.addEdge(graph_distance, tuple_place_cablename, (city, 0),
cost["distance"])
gr.addEdge(graph_distance, (city, 0), tuple_place_cablename,
cost["distance"])
gr.addEdge(graph_capacity, tuple_place_cablename, (city, 0),
cost["capacity"])
gr.addEdge(graph_capacity, (city, 0), tuple_place_cablename,
cost["capacity"])
i += 1
else:
sinMar(analyzer, country, city)
def loadconnections_distancia(analyzer, connection):
grafo = analyzer["connections_distancia"]
mapa = analyzer["landing_points"]
peso = 0
if not gr.containsVertex(grafo,
(connection["origin"], connection["cable_id"])):
gr.insertVertex(grafo, (connection["origin"], connection["cable_id"]))
pareja1 = m.get(mapa, connection["origin"])
valor1 = me.getValue(pareja1)
lt.addLast(
valor1["conexiones"], {
'vertice': (connection["origin"], connection["cable_id"]),
"capacityTBPS": connection["capacityTBPS"]
})
lt.addLast(valor1["vecinos"],
(connection["destination"], connection["cable_id"],
connection['cable_length'][:-3].replace(',', '')))
if not gr.containsVertex(
grafo, (connection["destination"], connection["cable_id"])):
gr.insertVertex(grafo,
(connection["destination"], connection["cable_id"]))
pareja2 = m.get(mapa, connection["destination"])
valor2 = me.getValue(pareja2)
lt.addLast(
valor2["conexiones"], {
'vertice': (connection["destination"], connection["cable_id"]),
"capacityTBPS": connection["capacityTBPS"]
})
lt.addLast(valor2["vecinos"],
(connection["origin"], connection["cable_id"],
connection['cable_length'][:-3].replace(',', '')))
if connection["cable_length"] != 'n.a.':
peso = float(connection["cable_length"][:-3].replace(',', ''))
else:
par1 = m.get(mapa, connection["origin"])
lat1 = me.getValue(par1)['latitude']
lon1 = me.getValue(par1)['longitude']
par2 = m.get(mapa, connection["destination"])
lat2 = me.getValue(par2)['latitude']
lon2 = me.getValue(par2)['longitude']
peso = hs.haversine((float(lat1), float(lon1)),
((float(lat2), float(lon2))))
gr.addEdge(grafo, (connection["origin"], connection["cable_id"]),
(connection["destination"], connection["cable_id"]), peso)
gr.addEdge(grafo, (connection["destination"], connection["cable_id"]),
(connection["origin"], connection["cable_id"]), peso)
def grafoEdades(listaViajes):
grafo = gr.newGraph(datastructure="ADJ_LIST",
directed=True,
size=1000,
comparefunction=comparer)
iteEdades = it.newIterator(listaViajes)
while it.hasNext(iteEdades):
viaje = it.next(iteEdades)
estacion1 = viaje["start station id"]
estacion2 = viaje["end station id"]
duracion = int(viaje["tripduration"])
if not gr.containsVertex(grafo, estacion1):
gr.insertVertex(grafo, estacion1)
if not gr.containsVertex(grafo, estacion2):
gr.insertVertex(grafo, estacion2)
gr.addEdge(grafo, estacion1, estacion2, duracion)
return grafo
def relateSameLandings(analyzer):
lststops = mp.keySet(analyzer['landing_connections'])
for key in lt.iterator(lststops):
gr.insertVertex(analyzer['connections'], key)
lstroutes = mp.get(analyzer['landing_connections'],
key)['value']['cables']
prevrout = None
for route in lt.iterator(lstroutes):
route = key + '-' + route
if prevrout is not None:
addSantiConnection(analyzer, prevrout, route, 100)
addSantiConnection(analyzer, route, prevrout, 100)
addSantiConnection(analyzer, key, route, 100)
addSantiConnection(analyzer, key, prevrout, 100)
addSantiConnection(analyzer, prevrout, key, 100)
addSantiConnection(analyzer, route, key, 100)
prevrout = route
def addLP_graph(catalog, lp, cable):
mapa_lps = catalog['landing_points']
mapa_paises = catalog['countries']
lp_cable = lp + '-' + cable
grafo = catalog['grafo']
if not gr.containsVertex(grafo, lp_cable):
gr.insertVertex(grafo, lp_cable)
#de aqui en adelante lo que se hace es conectar este vertice con la capital de su pais
# print(lp, mp.contains(mapa_lps, lp))
pais = me.getValue(mp.get(mapa_lps, lp))['country']
capital = me.getValue(mp.get(mapa_paises, pais))['CapitalName']
distancia = calcularDistancia(catalog, lp, pais)
addConexion_graph(catalog, lp_cable, capital, distancia)
addConexion_graph(catalog, capital, lp_cable, distancia)
def add_country(analyzer,file):
for line in file:
key=line['CountryName']
value=mp.newMap(numelements=20,maptype='PROBING')
mp.put(value,'CapitalName',line['CapitalName'])
mp.put(value,'CapitalLatitude',line['CapitalLatitude'])
mp.put(value,'CapitalLongitude',line['CapitalLongitude'])
mp.put(value,'CountryCode',line['CountryCode'])
mp.put(value,'ContinentName',line['ContinentName'])
mp.put(value,'Population',line['Population'])
usuarios=line['Internet users'].replace('.','')
mp.put(value,'Internet users',usuarios)
mp.put(analyzer['countries'],str(key),value)
gr.insertVertex(analyzer['connections'],(line['CapitalName'],'1'))
key2=line['CapitalName']
value2=line['CountryName']
mp.put(analyzer['capital_pais'],key2,value2)
mp.put(analyzer['pais_capital'],value2,key2)
def addcapital_internet(analyzer, capital):
grafo = analyzer["connections_internet"]
lista_landing = m.valueSet(analyzer["landing_points"])
if capital['CapitalLatitude'] != '':
menor = None
dist = None
for punto in lt.iterator(lista_landing):
distancia = hs.haversine(
(float(capital['CapitalLatitude']),
float(capital['CapitalLongitude'])),
(float(punto['latitude']), float(punto['longitude'])))
if dist == None or distancia < dist:
dist = distancia
menor = punto
internet = minimo_internet(menor)
gr.insertVertex(grafo, (capital['CapitalName'], 'capital'))
gr.addEdge(grafo, (capital['CapitalName'], 'capital'),
lt.getElement(menor['conexiones'], 1)['vertice'], internet)
def createMSTgraph(catalog, mst):
"""Usa la lista del MST dada por el prim para crear el grafo correspondiente"""
catalog['mst'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=3600,
comparefunction=cmpLandingPoints)
for edge in lt.iterator(mst):
vertexA = edge['vertexA']
vertexB = edge['vertexB']
weight = edge['weight']
if not gr.containsVertex(catalog['mst'], vertexA):
gr.insertVertex(catalog['mst'], vertexA)
if not gr.containsVertex(catalog['mst'], vertexB):
gr.insertVertex(catalog['mst'], vertexB)
edge = gr.getEdge(catalog['mst'], vertexA, vertexB)
if edge is None:
gr.addEdge(catalog['mst'], vertexA, vertexB, weight)
return catalog['mst']
def addServiceToGraph(analyzer, service):
graph = analyzer['AreaGraph']
originArea = service['pickup_community_area']
destinationArea = service['dropoff_community_area']
startTime = convertTime(str(service['trip_start_timestamp']))
endTime = convertTime(str(service['trip_end_timestamp']))
try:
duration = float(service["trip_seconds"])
except:
duration = None
if (originArea != destinationArea) and (startTime != None) and (endTime != None) and (duration != None) and (originArea != "") and (destinationArea != ""):
originArea = str(int(float(originArea)))
destinationArea = str(int(float(destinationArea)))
originVertex = originArea + "-" + startTime
destinationvertex = destinationArea + "-" + endTime
if not gr.containsVertex(graph, originVertex):
gr.insertVertex(graph, originVertex)
if not gr.containsVertex(graph, destinationvertex):
gr.insertVertex(graph, destinationvertex)
addConnection(graph, originVertex, destinationvertex, duration)
def addcapital_distancia(analyzer, capital):
grafo = analyzer["connections_distancia"]
lista_landing = m.valueSet(analyzer["landing_points"])
m.put(analyzer['paises'], capital['CountryName'], capital['CapitalName'])
gr.insertVertex(grafo, (capital['CapitalName'], 'capital'))
for punto in lt.iterator(lista_landing):
en_pais = False
try:
pais = punto['name'].split(',')[1].strip()
except:
pais = 0
if pais == capital['CountryName']:
en_pais = True
dist = hs.haversine(
(float(capital['CapitalLatitude']),
float(capital['CapitalLongitude'])),
(float(punto['latitude']), float(punto['longitude'])))
gr.addEdge(grafo, (capital['CapitalName'], 'capital'),
lt.getElement(punto['conexiones'], 1)['vertice'], dist)
gr.addEdge(grafo,
lt.getElement(punto['conexiones'], 1)['vertice'],
(capital['CapitalName'], 'capital'), dist)
if en_pais == False:
menor = None
dist = None
for punto in lt.iterator(lista_landing):
distancia = hs.haversine(
(float(capital['CapitalLatitude']),
float(capital['CapitalLongitude'])),
(float(punto['latitude']), float(punto['longitude'])))
if dist == None or distancia < dist:
dist = distancia
menor = punto
gr.addEdge(grafo, (capital['CapitalName'], 'capital'),
lt.getElement(menor['conexiones'], 1)['vertice'], dist)
gr.addEdge(grafo,
lt.getElement(menor['conexiones'], 1)['vertice'],
(capital['CapitalName'], 'capital'), dist)
def graphPrim(mst):
'''for vertice in lt.iterator(mp.keySet(mst['edgeTo'])):
print(vertice)
edgeTo = me.getValue(mp.get(mst['edgeTo'], vertice))
print(edgeTo)'''
grafo = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
comparefunction=CompareLandingPoints,
size=2300)
for conexion in lt.iterator(mp.valueSet(mst['edgeTo'])):
vertexA = conexion['vertexA']
vertexB = conexion['vertexB']
weight = conexion['weight']
gr.insertVertex(grafo, vertexA)
gr.insertVertex(grafo, vertexB)
gr.addEdge(grafo, vertexA, vertexB, weight)
mst['grafo'] = grafo
# print('AQUI ',lt.size(gr.edges(grafo)))
# print('AQUI: ', lt.size(gr.vertices(grafo)))
return grafo
def doBFS(edgeTo):
minigraph = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=cmplandingpoints)
keys = mp.keySet(edgeTo)
firstVertex = lt.getElement(keys, 1)
for i in lt.iterator(keys):
vertexA = i
vertexB = mp.get(edgeTo, i)['value']['vertexA']
gr.insertVertex(minigraph, vertexA)
gr.insertVertex(minigraph, vertexB)
for i in lt.iterator(keys):
vertexA = i
vertexB = mp.get(edgeTo, i)['value']['vertexA']
weight = mp.get(edgeTo, i)['value']['weight']
gr.addEdge(minigraph, vertexA, vertexB, weight)
gr.addEdge(minigraph, vertexB, vertexA, weight)
distNsize = {}
vertexes = gr.vertices(minigraph)
mayor = 0
recorrido = bfs.BreadhtFisrtSearch(minigraph, firstVertex)
for vertexB in lt.iterator(vertexes):
dist = bfs.pathTo(recorrido, vertexB)
if dist is not None:
size = lt.size(dist)
distNsize[size] = dist
if size > mayor:
mayor = size
for i in distNsize.keys():
if i == mayor:
caminomaslargo = distNsize[i]
return mayor, caminomaslargo, minigraph
def req4(analyzer):
estructura = pr.PrimMST(analyzer["connections_distance"])
costo_total = pr.weightMST(analyzer["connections_distance"], estructura)
grafo_mst = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=5000,
comparefunction=None)
i = 1
while i <= lt.size(estructura["mst"]):
arista = lt.getElement(estructura["mst"], i)
verticeA = arista["vertexA"]
verticeB = arista["vertexB"]
weight = arista["weight"]
if not gr.containsVertex(grafo_mst, verticeA):
gr.insertVertex(grafo_mst, verticeA)
if not gr.containsVertex(grafo_mst, verticeB):
gr.insertVertex(grafo_mst, verticeB)
gr.addEdge(grafo_mst, verticeA, verticeB, weight)
gr.addEdge(grafo_mst, verticeB, verticeA, weight)
i += 1
num_vertices = gr.numVertices(grafo_mst)
vertices_mst = gr.vertices(grafo_mst)
inicio = lt.firstElement(estructura["mst"])["vertexA"]
final = lt.lastElement(estructura["mst"])["vertexB"]
estructura_dfs = dfs.DepthFirstSearch(grafo_mst, inicio)
caminoo = dfs.pathTo(estructura_dfs, final)
return num_vertices, costo_total, caminoo
def addConnection(connection, structure):
origin = connection['origin']
if not gr.containsVertex(structure['connections'], origin):
gr.insertVertex(structure['connections'], origin)
destination = connection['destination']
if not gr.containsVertex(structure['connections'], destination):
gr.insertVertex(structure['connections'], destination)
originp = mp.get(structure['landing_points'], origin)
originll = (float(originp['value']['latitude']),
float(originp['value']['longitude']))
destinationp = mp.get(structure['landing_points'], destination)
destinationll = (float(destinationp['value']['latitude']),
float(destinationp['value']['longitude']))
length = round(haversine.haversine(originll, destinationll), 2)
edge = gr.getEdge(structure['connections'], origin, destination)
if edge is None:
gr.addEdge(structure['connections'], origin, destination, length)
return structure
def addVer(catalogo, vertice):
m.put(catalogo["vertices"], vertice["landing_point_id"], vertice)
m.put(catalogo["invertices"], vertice["name"].split(",")[0],
vertice["landing_point_id"])
lt.addLast(catalogo["listavertices"], vertice["landing_point_id"])
if not gr.containsVertex(catalogo['conexiones'],
vertice["landing_point_id"]):
gr.insertVertex(catalogo['conexiones'], vertice["landing_point_id"])
pais = vertice["name"].split(",")
if len(pais) > 1:
if len(pais[1]) > 3:
if not m.contains(catalogo["mapaises"], pais[1].strip(" ")):
m.put(catalogo["mapaises"], pais[1].strip(" "),
lt.newList("ARRAY_LIST"))
lt.addLast(
m.get(catalogo["mapaises"], pais[1].strip(" "))["value"],
vertice["landing_point_id"])
else:
if not m.contains(catalogo["mapaises"], pais[2].strip(" ")):
m.put(catalogo["mapaises"], pais[2].strip(" "),
lt.newList("ARRAY_LIST"))
lt.addLast(
m.get(catalogo["mapaises"], pais[2].strip(" "))["value"],
vertice["landing_point_id"])
def addRoutes(analyzer, registro):
#print(registro)
areaSalida = registro["pickup_community_area"]
#print(registro['pickup_community_area'])
areaLlegada = registro["dropoff_community_area"]
if areaSalida == "" or areaSalida == None and areaLlegada == "" or areaLlegada == None:
areaSalida = 0
areaLlegada = 0
elif areaSalida != "" or areaSalida != None and areaLlegada == "" or areaLlegada == None:
areaSalida = registro["pickup_community_area"]
areaLlegada = 0
elif areaSalida == "" or areaSalida == None and areaLlegada != "" or areaLlegada != None:
areaSalida = 0
areaLlegada = registro["dropoff_community_area"]
elif (areaSalida != areaLlegada) and (areaSalida != None) and (areaLlegada
!= None):
tInicialComp = registro["trip_start_timestamp"]
if tInicialComp == "" or tInicialComp == None:
tInicialComp = 0
tFinalComp = registro["trip_end_timestamp"]
if tFinalComp == "" or tFinalComp == None:
tFinalComp = 0
duracion = float(registro["trip_seconds"])
tInicialComp = tInicialComp.replace("T", " ")
tInicialComp = tInicialComp.split()
tInicial = tInicialComp[1]
tFinalComp = tFinalComp.replace("T", " ")
tFinalComp = tFinalComp.split()
tFinal = tFinalComp[1]
#print(areaSalida)
print(areaLlegada)
if gr.containsVertex(analyzer['grafoAreas'], areaSalida) != True:
gr.insertVertex(analyzer['grafoAreas'], areaSalida)
if gr.containsVertex(analyzer['grafoAreas'], tInicial) != True:
gr.insertVertex(analyzer['grafoAreas'], tInicial)
if gr.containsVertex(analyzer['grafoAreas'], areaLlegada) != True:
gr.insertVertex(analyzer['grafoAreas'], areaLlegada)
if gr.containsVertex(analyzer['grafoAreas'], tFinal) != True:
gr.insertVertex(analyzer['grafoAreas'], tFinal)
#print(analyzer['grafoAreas'])
gr.addEdge(analyzer['grafoAreas'],
str(areaSalida) + " " + tInicial,
str(areaLlegada) + " " + tFinal, duracion)
def addGroundConnections(analyzer):
"""Agrega las conexiones por tierra"""
index = 20000
prefix = "Capital Connection "
listacountries = mp.keySet(analyzer['countries2'])
for country in lt.iterator(listacountries):
selectcount = mp.get(analyzer['countries2'], country)
countri = me.getValue(selectcount)
cable = prefix + country
origin = str(index) + '-' + cable
lp = mp.get(analyzer['landing_points2'], country)
gr.insertVertex(analyzer['connections'], origin)
boole = lp is not None
if boole:
mp.put(analyzer['capitals'], country.lower(), origin)
lp = me.getValue(lp)
lp = lp['cables']
for landingPoint in lt.iterator(lp):
destination = landingPoint['landing_point_id'] + '-' + cable
gr.insertVertex(analyzer['connections'], destination)
dist = haversine.haversine(float(countri['CapitalLatitude']),
float(countri['CapitalLongitude']),
float(landingPoint['latitude']),
float(landingPoint['longitude']))
gr.addEdge(analyzer['connections'], destination, origin, dist)
gr.addEdge(analyzer['connections'], origin, destination, dist)
addConnectionToLandingMapVer2(origin, cable, analyzer)
addConnectionToLandingMapVer2(destination, cable, analyzer)
index += 1
else:
closestLP = None
minDistance = 100000000
for landingPoint in lt.iterator(analyzer['landing_point_list']):
distance = haversine.haversine(
float(countri['CapitalLatitude']),
float(countri['CapitalLongitude']),
float(landingPoint['latitude']),
float(landingPoint['longitude']))
if distance < minDistance:
closestLP = landingPoint
minDistance = distance
destination = closestLP['landing_point_id'] + '-' + cable
gr.insertVertex(analyzer['connections'], destination)
gr.addEdge(analyzer['connections'], destination, origin, distance)
gr.addEdge(analyzer['connections'], origin, destination, distance)
addConnectionToLandingMapVer2(origin, cable, analyzer)
addConnectionToLandingMapVer2(destination, cable, analyzer)
index += 1
def añadirAreaAlGrafo(analyzer, archivo):
origen = archivo["pickup_community_area"]
destino = archivo["dropoff_community_area"]
horainicio = time_converter(archivo["trip_start_timestamp"])
horafin = time_converter(archivo["trip_end_timestamp"])
if archivo["trip_seconds"] == "":
archivo["trip_seconds"] = 0
duracion = float(archivo["trip_seconds"])
if origen == destino or (destino == "" or origen == ""):
None
else:
if gr.containsVertex(analyzer["Grafo por CA"], origen+"-"+horainicio) and gr.containsVertex(analyzer["Grafo por CA"],destino+"-"+horafin):
gr.addEdge(analyzer["Grafo por CA"], (origen+"-"+horainicio), (destino+"-"+horafin), duracion)
elif (not gr.containsVertex(analyzer["Grafo por CA"], origen+"-"+horainicio)) and gr.containsVertex(analyzer["Grafo por CA"], destino+"-"+horafin):
gr.insertVertex(analyzer["Grafo por CA"], origen+"-"+horainicio)
gr.addEdge(analyzer["Grafo por CA"], (origen+"-"+horainicio), (destino+"-"+horafin), duracion)
elif gr.containsVertex(analyzer["Grafo por CA"], origen+"-"+horainicio) and (not gr.containsVertex(analyzer["Grafo por CA"], destino+"-"+horafin)):
gr.insertVertex(analyzer["Grafo por CA"], destino+"-"+horafin)
gr.addEdge(analyzer["Grafo por CA"], (origen+"-"+horainicio), (destino+"-"+horafin), duracion)
else:
gr.insertVertex(analyzer["Grafo por CA"], origen+"-"+horainicio)
gr.insertVertex(analyzer["Grafo por CA"], destino+"-"+horafin)
gr.addEdge(analyzer["Grafo por CA"], (origen+"-"+horainicio), (destino+"-"+horafin), duracion)
def GrafosPorCiclo(analyzer, origen, VDC):
"""
Genera un grafo por cada ciclo diferente relacionado al origen y los añade a
GPCC (diccionario)
"""
#GPCC = Grafos Por Cada Ciclo
GPCC = {}
if VDC == False:
return False
else:
for Valor in VDC:
Cierre = False
GPCC[Valor] = gr.newGraph(datastructure="ADJ_LIST",
directed=True,
size=6,
comparefunction=comparer)
gr.insertVertex(GPCC[Valor], origen)
actual = origen
mismo = origen
Adjacentes = adj.adjacents(analyzer["graph"], actual)
Adjacentes["cmpfunction"] = comparador
while Cierre == False:
a = it.newIterator(VDC[Valor])
while it.hasNext(a):
b = it.next(a)
if actual != mismo:
Adjacentes = adj.adjacents(analyzer["graph"], actual)
Adjacentes["cmpfunction"] = comparador
mismo = actual
if not gr.containsVertex(GPCC[Valor], b):
if lt.isPresent(Adjacentes, origen) != 0 and actual != origen and b != origen:
gr.insertVertex(GPCC[Valor], b)
Tartalia = gr.getEdge(analyzer["graph"], actual, origen)
Peso = int(ed.weight(Tartalia)/Tartalia["Repeticiones"])
adj.addEdge(GPCC[Valor], actual, origen, Peso)
actual = b
Cierre = True
elif lt.isPresent(Adjacentes, b) != 0 and b != origen:
gr.insertVertex(GPCC[Valor], b)
Tartalia = gr.getEdge(analyzer["graph"], actual, b)
Peso = int(ed.weight(Tartalia)/Tartalia["Repeticiones"])
adj.addEdge(GPCC[Valor], actual, b, Peso)
actual = b
elif actual == origen and lt.size(VDC[Valor]) == 1:
Cierre = True
return GPCC
def addAge2(citibike, edad, station):
if not gr.containsVertex(citibike['ages2'], station):
gr.insertVertex(citibike['ages2'], station)
gr.addEdge(citibike['ages2'], station, "salida", 0)
else:
edge = gr.getEdge(citibike['ages2'], str(edad), station)
if edge is None:
gr.addEdge(citibike['ages2'], str(edad), station, 1)
gr.addEdge(citibike['ages2'], station, "salida", 0)
else:
peso = edge['weight']
if peso != 0:
gr.removeVertex(citibike['ages2'], station)
gr.removeVertex(citibike['ages2'], str(edad))
gr.insertVertex(citibike['ages2'], station)
gr.insertVertex(citibike['ages2'], str(edad))
gr.addEdge(citibike['ages2'], station, "salida", 0)
gr.addEdge(citibike['ages2'], str(edad), station,
1 / (1 + 1 / peso))
else:
print("El peso es 0")
def addVertex(congr, vertex):
vert = gr.containsVertex(congr, vertex)
if vert == False:
gr.insertVertex(congr, vertex)
def newAnalyzer():
""" Inicializa el analizador
stops: Tabla de hash para guardar los vertices del grafo
connections: Grafo para representar las rutas entre estaciones
components: Almacena la informacion de los componentes conectados
paths: Estructura que almancena los caminos de costo minimo desde un
vertice determinado a todos los otros vértices del grafo
"""
try:
citybike = {
'stops': None,
'connections': None,
'components': None,
'paths': None,
'graph': None,
'distance': None,
'ages1': None,
'ages2': None,
'adjacente1': None,
'adjacente2': None
}
citybike['stops'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareStopIds)
citybike['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=14000,
comparefunction=compareStopIds)
citybike['graph'] = gr.newGraph(datastructure="ADJ_LIST",
directed=True,
size=1000,
comparefunction=compareStations)
citybike['distance'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareStopIds)
citybike['ages1'] = gr.newGraph(datastructure="ADJ_LIST",
directed=True,
size=10,
comparefunction=compareStopIds)
citybike['ages2'] = gr.newGraph(datastructure="ADJ_LIST",
directed=True,
size=10,
comparefunction=compareStopIds)
citybike['adjacente1'] = gr.newGraph(datastructure="ADJ_LIST",
directed=True,
size=1000,
comparefunction=compareStopIds)
citybike['adjacente2'] = gr.newGraph(datastructure="ADJ_LIST",
directed=True,
size=1000,
comparefunction=compareStopIds)
for i in range(0, 7):
gr.insertVertex(citybike['ages1'], str(i))
gr.insertVertex(citybike['ages2'], str(i))
gr.insertVertex(citybike['ages2'], "salida")
gr.insertVertex(citybike['ages1'], "salida")
for i in range(0, 7):
gr.insertVertex(citybike['adjacente1'], str(i))
gr.insertVertex(citybike['adjacente2'], str(i))
gr.insertVertex(citybike['adjacente2'], "salida")
gr.insertVertex(citybike['adjacente1'], "salida")
return citybike
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def AñadirEstacion(analyzer, estacion):
if not gr.containsVertex(analyzer["graph"], estacion):
gr.insertVertex(analyzer["graph"], estacion)
return analyzer
def addLandingPoint(analyzer, landingpoint):
if not gr.containsVertex(analyzer["cables"], landingpoint):
gr.insertVertex(analyzer["cables"], landingpoint)
return analyzer
def addStation(citibike, stationid):
if not gr.containsVertex(citibike["graph"], stationid):
gr.insertVertex(citibike["graph"], stationid)
return citibike
def addStation(analyzer, stationID):
if not gr.containsVertex(analyzer["graph"], stationID):
gr.insertVertex(analyzer["graph"], stationID)
return analyzer
def Añadir_comunity_area(Taxis, CAid):
if not gr.containsVertex(Taxis["communityAreas"], CAid):
gr.insertVertex(Taxis["communityAreas"], CAid)
return Taxis
def crearVertices(analyzer, landing_pointId):
grafo = analyzer['connections']
vertice = landing_pointId['landing_point_id']
gr.insertVertex(grafo, vertice)
def addStation2(citibike, stationid):
if not gr.containsVertex(citibike["customers"], stationid):
gr.insertVertex(citibike["customers"], stationid)
return citibike
def addStationV2(grafo, vertex):
if not gr.containsVertex(grafo, vertex):
gr.insertVertex(grafo, vertex)
return grafo
