def initSearch(graph, source): """ Inicializa la estructura de busqueda y deja todos los arcos en infinito. Se inserta en la cola el vertice source Args: graph: El grafo a examinar source: El vertice fuente Returns: Estructura de busqueda inicializada Raises: Exception """ try: search = { 'source': source, 'edgeTo': None, 'distTo': None, 'qvertex': None, 'onQ': None, 'cost': 0, 'spt': None, 'cycle': False } search['edgeTo'] = map.newMap(numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) search['distTo'] = map.newMap(numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) search['onQ'] = map.newMap(numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) search['spt'] = g.newGraph(size=g.numVertices(graph), directed=True, comparefunction=graph['comparefunction']) vertices = g.vertices(graph) for vert in lt.iterator(vertices): map.put(search['distTo'], vert, math.inf) map.put(search['onQ'], vert, False) g.insertVertex(search['spt'], vert) newq = q.newQueue() search['qvertex'] = newq return search except Exception as exp: error.reraise(exp, 'bellman:init')
def KosarajuUnicoSCC(graph, vertex): """ Implementa el algoritmo de Kosaraju para encontrar los componentes conectados de un grafo dirigido Args: graph: El grafo a examinar Returns: Una estructura con los componentes conectados Raises: Exception """ try: scc_u = { 'idscc': None, 'marked': None, 'grmarked': None, 'components': 0 } scc_u['idscc'] = map.newMap(g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) scc_u['marked'] = map.newMap(g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) scc_u['grmarked'] = map.newMap( g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) # Se calcula el grafo reverso de graph greverse = reverseGraph(graph) # Se calcula el DFO del reverso de graph dforeverse = dfo.DepthFirstOrder(greverse) grevrevpost = dforeverse['reversepost'] # Se recorre el grafo en el orden dado por reversepost (G-reverso) scc_u['components'] = 0 while (not stack.isEmpty(grevrevpost)): vert = stack.pop(grevrevpost) if vert == str(vertex): if not map.contains(scc_u['marked'], vert): scc_u['components'] += 1 sccCount(graph, scc_u, vert) return scc_u except Exception as exp: error.reraise(exp, 'scc_u:Kosaraju')
def reverseGraph(graph): """ Retornar el reverso del grafo graph """ try: greverse = g.newGraph(size=g.numVertices(graph), directed=True, comparefunction=graph['comparefunction']) lstvert = g.vertices(graph) itervert = it.newIterator(lstvert) while it.hasNext(itervert): vert = it.next(itervert) g.insertVertex(greverse, vert) itervert = it.newIterator(lstvert) while it.hasNext(itervert): vert = it.next(itervert) lstadj = g.adjacents(graph, vert) iteradj = it.newIterator(lstadj) while it.hasNext(iteradj): adj = it.next(iteradj) g.addEdge(greverse, adj, vert) return greverse except Exception as exp: error.reraise(exp, 'scc:reverse')
def cargar_datos(): data = model.landing_points("Data/landing_points.csv", "Data/connections.csv", "Data/countries.csv") landing_points = gp.numVertices(data.connections_map) connections = gp.numEdges(data.connections_map) // 2 countries = mp.size(data.countries) return data, landing_points, connections, countries
def relax(graph, search, v): """ Relaja el peso de los arcos del grafo Args: search: La estructura de busqueda v: Vertice desde donde se relajan los pesos Returns: El grafo con los arcos relajados Raises: Exception """ try: edges = g.adjacentEdges(graph, v) if edges is not None: for edge in lt.iterator(edges): v = e.either(edge) w = e.other(edge) distv = map.get(search['distTo'], v)['value'] distw = map.get(search['distTo'], w)['value'] distweight = distv + e.weight(edge) if (distw > distweight): map.put(search['distTo'], w, distweight) map.put(search['edgeTo'], w, edge) if (not map.get(search['onQ'], w)['value']): q.enqueue(search['qvertex'], w) map.put(search['onQ'], w, True) cost = search['cost'] if ((cost % g.numVertices(graph)) == 0): findneg = findNegativeCycle(graph, search) if (hasNegativecycle(findneg)): return search['cost'] = cost + 1 return search except Exception as exp: error.reraise(exp, 'bellman:relax')
def BreadhtFisrtSearch(graph, source, time, camino): """ Genera un recorrido BFS sobre el grafo graph Args: graph: El grafo a recorrer source: Vertice de inicio del recorrido. Returns: Una estructura para determinar los vertices conectados a source Raises: Exception """ try: search = {'source': source, 'visited': None, 'caminos': []} search['visited'] = map.newMap( numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) map.put(search['visited'], source, { 'marked': True, 'edgeTo': None, 'distTo': 0 }) bfsVertex(search, graph, source, time, camino) return search except Exception as exp: error.reraise(exp, 'bfs:BFS')
def initSearch(graph): """ Inicializa la estructura de busqueda y deja todos los arcos en infinito. Se inserta en la cola el vertice source Args: graph: El grafo a examinar source: El vertice fuente Returns: Estructura de busqueda inicializada Raises: Exception """ try: search = { 'edgeTo': None, 'distTo': None, 'marked': None, 'pq': None, 'mst': None } search['edgeTo'] = map.newMap(numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) search['distTo'] = map.newMap(numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) search['marked'] = map.newMap(numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) vertices = g.vertices(graph) for vert in lt.iterator(vertices): map.put(search['distTo'], vert, math.inf) map.put(search['marked'], vert, False) search['pq'] = pq.newIndexMinPQ(cmpfunction=graph['comparefunction']) search['mst'] = q.newQueue() return search except Exception as exp: error.reraise(exp, 'bellman:init')
def test_insertVertex(graph): g.insertVertex(graph, 'Bogota') g.insertVertex(graph, 'Yopal') g.insertVertex(graph, 'Cali') g.insertVertex(graph, 'Medellin') g.insertVertex(graph, 'Pasto') g.insertVertex(graph, 'Barranquilla') g.insertVertex(graph, 'Manizales') assert g.numVertices(graph) == 7
def initStructures(graph): """ Args: graph: El grafo a examinar source: El vertice fuente Returns: Estructura de busqueda inicializada Raises: Exception """ try: search = { 'edgeTo': None, 'marked': None, 'onStack': None, 'cycle': None } search['edgeTo'] = map.newMap(numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction'] ) search['marked'] = map.newMap(numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) search['onStack'] = map.newMap(numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction'] ) search['cycle'] = st.newStack() vertices = g.vertices(graph) for vert in lt.iterator(vertices): map.put(search['marked'], vert, False) map.put(search['onStack'], vert, False) return search except Exception as exp: error.reraise(exp, 'cycle:init')
def req4(catalog): grafo = catalog['graph_landing_points'] vertices_grafo = gr.vertices(grafo) vertice1 = lt.getElement(vertices_grafo, 0) MST = dijsktra.Dijkstra(grafo, vertice1) vertice2 = lt.getElement(vertices_grafo, (lt.size(vertices_grafo) - 1)) num_nodos = gr.numVertices(MST) #para hallar costo total hacer un dist to con vertice inicial y final distancia_total = dijsktra.distTo(MST, vertice2) return num_nodos, distancia_total
def criticalInfrastructure(analyzer): vertex = gr.numVertices(analyzer["connections"]) tree = pr.PrimMST(analyzer["connections"]) weight = pr.weightMST(analyzer["connections"], tree) branch = pr.edgesMST(analyzer["connections"], tree) branch = branch["edgeTo"]["table"]["elements"] max = 0 for i in range(len(branch)): value = branch[i]["value"] if (value != None) and (float(value["weight"]) > max): max = value["weight"] return vertex, weight, max
def initSearch(graph, source): """ Inicializa la estructura de busqueda y deja todos los arcos en infinito. Se inserta en la cola indexada el vertice source Args: graph: El grafo a examinar source: El vertice fuente Returns: Estructura de busqueda inicializada Raises: Exception """ try: search = { 'source': source, 'visited': None, 'iminpq': None } search['visited'] = map.newMap(numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction'] ) vertices = g.vertices(graph) itvertices = it.newIterator(vertices) while (it.hasNext(itvertices)): vert = it.next(itvertices) map.put(search['visited'], vert, {'marked': False, 'edgeTo': None, 'distTo': math.inf} ) map.put(search['visited'], source, {'marked': True, 'edgeTo': None, 'distTo': 0} ) pq = iminpq.newIndexMinPQ( cmpfunction=graph['comparefunction'] ) search['iminpq'] = pq iminpq.insert(search['iminpq'], source, 0) return search except Exception as exp: error.reraise(exp, 'dks:init')
def DepthFirstOrder(graph): try: search = { 'marked': None, 'pre': None, 'post': None, 'reversepost': None } search['pre'] = queue.newQueue() search['post'] = queue.newQueue() search['reversepost'] = stack.newStack() search['marked'] = map.newMap(numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) lstvert = g.vertices(graph) for vertex in lt.iterator(lstvert): if not (map.contains(search['marked'], vertex)): dfsVertex(graph, search, vertex) return search except Exception as exp: error.reraise(exp, 'dfo:DFO')
def test_getEdgesGraph(graph): g.insertVertex(graph, 'Bogota') g.insertVertex(graph, 'Yopal') g.insertVertex(graph, 'Cali') g.insertVertex(graph, 'Medellin') g.insertVertex(graph, 'Pasto') g.insertVertex(graph, 'Barranquilla') g.insertVertex(graph, 'Manizales') g.addEdge(graph, 'Bogota', 'Yopal', 2) g.addEdge(graph, 'Bogota', 'Medellin', 3) g.addEdge(graph, 'Bogota', 'Pasto', 1) g.addEdge(graph, 'Bogota', 'Cali', 10) g.addEdge(graph, 'Yopal', 'Medellin', 20) g.addEdge(graph, 'Medellin', 'Pasto', 4) g.addEdge(graph, 'Cali', 'Pasto', 6) g.addEdge(graph, 'Cali', 'Barranquilla', 3) g.addEdge(graph, 'Barranquilla', 'Manizales', 10) g.addEdge(graph, 'Pasto', 'Manizales', 8) assert g.numVertices(graph) == 7 assert g.numEdges(graph) == 10 edge = g.getEdge(graph, 'Pasto', 'Medellin') assert edge['weight'] == 4
def TotalVertices(catalog): return gr.numVertices(catalog["connections"])
print(pais + " se encontraría afectado y tiene un Landing Point a " + str(distancia) + " kilómetros.") i += 1 catalog = None """ Menu principal """ while True: printMenu() inputs = input('Seleccione una opción para continuar\n') if int(inputs[0]) == 1: print("Cargando información de los archivos ....") analyzer = controller.initialize() controller.loadData(analyzer) vertices= gr.numVertices(analyzer['connections']) aristas= gr.numEdges(analyzer['connections']) print("El numero de vertices cargados es: " + str(vertices)) print("El numero de arcos en el grafo es: " + str(aristas)) elif int(inputs[0]) == 2: landing_point1 = input('Ingrese el landing point A: ') landing_point2 = input('Ingrese el landing point B: ') componentes = controller.componentesConectados(analyzer) estan = controller.estanLosDosLandingPoints(analyzer, landing_point1, landing_point2) print('*' * 25) print('El número de clústers es: ' + str(componentes)) print_Req1(landing_point1, landing_point2, estan) elif int(inputs[0]) == 3:
def test_insertEdges(graph): assert g.numVertices(graph) == 7 assert g.numEdges(graph) == 10
def getCriticalInfrastructure(catalog): mst = prim.PrimMST(catalog['connections']) print(gr.numVertices(mst)) pass
def numVertices(dataBase): return graph.numVertices(dataBase['graph'])
def totalStations(chicagoAnalyzer): """ Retorna el total de vertices del grafo """ return gr.numVertices(chicagoAnalyzer['communityTrip'])
def totalStops(analyzer): """ Retorna la cantidad total de vertices del grafo """ return gr.numVertices(analyzer['connections'])
Menú principal """ while True: printMenu() inputs = input("Seleccione una opción para continuar\n") if int(inputs[0]) == 1: print() print("Inicializando....\n") analyzer = initAnalyzer() elif int(inputs[0]) == 2: print() print("Cargando información de las conexiones....\n") data = loadData(analyzer) print("Total puntos de conexión: " + str(gr.numVertices(analyzer['connections']))) print("Total conexiones: " + str(gr.numEdges(analyzer['connections']))) print("Total países: " + str(mp.size(analyzer['countries'])) + "\n") printFirstLandingPoint(analyzer) printLastCountry(analyzer) elif int(inputs[0]) == 3: print() landingpointnamea = str(input("Ingrese punto de conexión: ")) landingpointnameb = str(input("Ingrese punto de conexión: ")) landingpointa = controller.getLandingPoint(analyzer, landingpointnamea) landingpointb = controller.getLandingPoint(analyzer, landingpointnameb) vertexa = controller.getVertexByLandingPoint(analyzer, landingpointa) vertexb = controller.getVertexByLandingPoint(analyzer, landingpointb) sccomponents = controller.stronglyConnectedComponents(analyzer) scvertexs = controller.stronglyConnectedVertexs(