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