def strongly_conected(catalog,v1,v2): if m.contains(catalog["connections_scc"]["idscc"],v1)==False or m.contains(catalog["connections_scc"]["idscc"],v2)==False: return False elif scc.stronglyConnected(catalog["connections_scc"],v1,v2)==False: return 0 elif scc.stronglyConnected(catalog["connections_scc"],v1,v2)==True: return True
def areConnected(analyzer, lp1, lp2): analyzer['components'] = scc.KosarajuSCC(analyzer['connections']) connected = scc.stronglyConnected(analyzer['components'], lp1, lp2) if connected: return 1 else: return 0
def stronglyConnectedVertexs(analyzer, vertexa, vertexb): """ Retorna si dos vértices están fuertemente conectados o no """ sccomponents = analyzer['sccomponents'] return scc.stronglyConnected(sccomponents, vertexa, vertexb)
def req1(analyzer,landingp1,landingp2): kosaraju=scc.KosarajuSCC(analyzer['connections_normal']) num_clusters=kosaraju['components'] origin=str(cityname_to_id(analyzer,landingp1)) destination=str(cityname_to_id(analyzer,landingp2)) estan_o_no=scc.stronglyConnected(kosaraju,origin,destination) return (num_clusters,estan_o_no)
def Requirement1(analyzer, landing_point1, landing_point2): tracemalloc.start() delta_time = -1.0 delta_memory = -1.0 start_time = getTime() start_memory = getMemory() analyzer['components'] = scc.KosarajuSCC( analyzer['connections_origin_destination']) connected_components = scc.connectedComponents(analyzer['components']) lp1 = matchLandingPoint(analyzer, landing_point1) lp2 = matchLandingPoint(analyzer, landing_point2) parameter1 = matchGraphKeyOrigin(analyzer, lp1) parameter2 = matchGraphKeyDestination(analyzer, lp2) same_cluster = scc.stronglyConnected(analyzer["components"], parameter1, parameter2) stop_memory = getMemory() stop_time = getTime() tracemalloc.stop() delta_time = stop_time - start_time delta_memory = deltaMemory(start_memory, stop_memory) return connected_components, same_cluster, delta_time, delta_memory
def Requerimiento1(analyzer, landing1, landing2): analyzer['element'] = scc.KosarajuSCC(analyzer['connections_directed']) cluster_number = scc.connectedComponents(analyzer['element']) get_landing1 = mp.get(analyzer['landing_names_id'], landing1) id_landing1 = me.getValue(get_landing1) dict_landing_pareja1 = om.get(analyzer['landing_points'], id_landing1) dict_landing1 = me.getValue(dict_landing_pareja1) lista_cables1 = dict_landing1['cables'] vectorA = lt.getElement(lista_cables1, 1) get_landing2 = mp.get(analyzer['landing_names_id'], landing2) id_landing2 = me.getValue(get_landing2) dict_landing_pareja2 = om.get(analyzer['landing_points'], id_landing2) dict_landing2 = me.getValue(dict_landing_pareja2) lista_cables2 = dict_landing1['cables'] vectorB = lt.getElement(lista_cables2, 1) inform_cluster = scc.stronglyConnected(analyzer['element'], vectorA, vectorB) if inform_cluster == False: print('Los landing points consultados no estan en el mismo cluster') else: print( 'Los landing points cosnultados se encuentran en el mismo cluster') print('El total de clústers presentes en la red es igual a ' + str(cluster_number))
def dfsVertexc(search, graph, vertex, source, sc): try: adjlst = gr.adjacents(graph, vertex) adjslstiter = it.newIterator(adjlst) while (it.hasNext(adjslstiter)): w = it.next(adjslstiter) visited = m.get(search['visited'], w) if visited is None: m.put(search['visited'], w, {'marked': True, 'edgeTo': vertex}) if scc.stronglyConnected(sc, w, source): dfsVertexc(search, graph, w, source, sc) elif w == source and gr.getEdge(graph, vertex, source) != None: cycle = lt.newList() lt.addLast(cycle, vertex) lt.addLast(cycle, w) x = me.getValue(m.get(search['visited'], vertex))['edgeTo'] while x != None: lt.addFirst(cycle, x) x = me.getValue(m.get(search['visited'], x))['edgeTo'] lt.addLast(search['cycles'], cycle) return search except Exception as exp: error.reraise(exp, 'dfs:dfsVertex')
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 req1(catalog, lp1, lp2): grafo = catalog["connections"] landing_points = catalog["landing_points"] traductor = catalog["traduccion"] componentes = scc.KosarajuSCC(grafo) numComponentes = componentes["components"] try: lp1 = lt.getElement(mp.get(traductor, lp1)["value"], 1) vertice1 = lp1 + "|" + lt.getElement( mp.keySet(mp.get(landing_points, lp1)["value"][1]), 1) except TypeError: vertice1 = lp1 try: lp2 = lt.getElement(mp.get(traductor, lp2)["value"], 1) vertice2 = lp2 + "|" + lt.getElement( mp.keySet(mp.get(landing_points, lp2)["value"][1]), 1) except TypeError: vertice2 = lp2 areConnected = scc.stronglyConnected(componentes, vertice1, vertice2) return numComponentes, areConnected
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 clusteres(analyzer,lp1,lp2): cfc=scc.KosarajuSCC(analyzer['connections']) numero=scc.connectedComponents(cfc) vertice1=me.getValue(mp.get(analyzer['nombrelp_codigo'],lp1)) vertice2=me.getValue(mp.get(analyzer['nombrelp_codigo'],lp2)) conectados=scc.stronglyConnected(cfc,vertice1,vertice2) return(numero,conectados)
def clusters(catalogo, lp1, lp2): componentes = scc.KosarajuSCC(catalogo["conexiones"]) conexionlp = scc.stronglyConnected( componentes, m.get(catalogo["invertices"], lp1)["value"], m.get(catalogo["invertices"], lp2)["value"]) return componentes["components"], conexionlp
def Requerimiento1(analyzer, landing_point1, landing_point2): """ Retorna ... """ clusters = scc.KosarajuSCC(analyzer['connections']) numClusters = scc.connectedComponents(clusters) mismoCluster = -1 punto1 = None punto2 = None listaPuntos = mp.valueSet(analyzer['landing_points']) for punto in lt.iterator(listaPuntos): nombre = punto['name'].split(", ")[0] if nombre == landing_point1.title(): punto1 = punto['landing_point_id'] if nombre == landing_point2.title(): punto2 = punto['landing_point_id'] if punto1 is not None and punto2 is not None: entry = mp.get(analyzer["points_vertices"], punto1) if entry is not None: lstLP1 = me.getValue(entry) lp1 = lt.firstElement(lstLP1) entry = mp.get(analyzer["points_vertices"], punto2) if entry is not None: lstLP2 = me.getValue(entry) lp2 = lt.firstElement(lstLP2) if lp1 != "" and lp2 != "": mismoCluster = scc.stronglyConnected(clusters, lp1, lp2) return numClusters, mismoCluster
def req_1(self, lp1, lp2): id_1 = self.name_to_id(lp1) id_2 = self.name_to_id(lp2) respuesta = scc.stronglyConnected(self.clusters, id_1, id_2) if respuesta: graphing_helper(self).all_points_cluster( mp.get(self.clusters['idscc'], id_1)['value']) return respuesta
def clusteredStations(citibike, id1,id2): try: clusters = connectedComponents(citibike) isThereCluster = scc.stronglyConnected(citibike["components"], id1,id2) retorno = (clusters, isThereCluster) except: retorno = (clusters, "") return retorno
def estan_closter(analyzer, pais1, pais2): Entry1 = mp.get(analyzer["landing_points"], pais1) Pais_1 = me.getValue(Entry1) entry2 = mp.get(analyzer["landing_points"], pais2) pais_2 = me.getValue(entry2) booleano = scc.stronglyConnected(analyzer["components"], str(Pais_1["landing_point_id"]), str(pais_2["landing_point_id"])) return booleano
def calcConnectedComponents(catalog, lp1, lp2): """ Usa el algoritmo de Kosaraju Para calcular los componentes connectados del grafo. El numero de clusters (componenetes conectados) y si dos lps estan fuertemente conectados (pertencecen al mismo cluster) """ catalog['components'] = scc.KosarajuSCC(catalog['internet_graph']) num_clusters = scc.connectedComponents(catalog['components']) landpts_cluster = scc.stronglyConnected(catalog['components'], lp1, lp2) return num_clusters, landpts_cluster
def comprobarCamino(cont, initialStation, salidas): lista=[] for a in range(0,len(salidas)): nuevo_scc= scc.KosarajuSCC(cont["connections"]) verdad = scc.stronglyConnected(nuevo_scc, initialStation, salidas[a]) if verdad: lista.append(salidas[a]) if lista == []: lista = "NO EXISTEN" return lista
def ClusterCheck(macrostructure, vertex1, vertex2): connected = scc.KosarajuSCC(macrostructure['connections']) lp1 = lt.getElement((mp.get(macrostructure['lp-names'], vertex1))['value'], 1) lp2 = lt.getElement((mp.get(macrostructure['lp-names'], vertex2))['value'], 1) pertains = scc.stronglyConnected(macrostructure['connections'], lp1, lp2) #pertains = None ans = (int(connected['components']), pertains) return ans
def vertexComponents(analyzer, verta, vertb): analyzer['components'] = scc.KosarajuSCC(analyzer['connections']) numero = scc.connectedComponents(analyzer['components']) try: connect = scc.stronglyConnected(analyzer['components'], verta, vertb) if connect: print("el numero de vertices es: " + str(numero)) return "estan conectados" except: print("el numero de vertices es: " + str(numero)) return "NO estan conectados"
def sameCC(analyzer, station1, station2): vert1 = gr.containsVertex(analyzer["graph"], station1) vert2 = gr.containsVertex(analyzer["graph"], station2) if vert1 is False and vert2 is False: return "0" elif vert1 is False: return "1" elif vert2 is False: return "2" else: return scc.stronglyConnected(analyzer['components'], station1, station2)
def sameCC(graph, station1, station2): """ RETO4 | REQ1 Consulta si dos vértices pertenecen al mismo componente fuertemente conectado. """ sc = scc.KosarajuSCC(graph) if gr.containsVertex(graph, station1) and gr.containsVertex( graph, station2): return scc.stronglyConnected(sc, station1, station2) else: return None
def IsItConnected(analyzer, verta, vertb): """ Calcula los componentes conectados del grafo Se utiliza el algoritmo de Kosaraju """ if gr.containsVertex(analyzer["graph"], verta) and gr.containsVertex( analyzer["graph"], vertb): analyzer['components'] = scc.KosarajuSCC(analyzer['graph']) return scc.stronglyConnected(analyzer['components'], verta, vertb) else: print("La estación no existe") return False
def clustersandlandingpoints(analyzer, lp1, lp2): analyzer['components'] = scc.KosarajuSCC(analyzer['cables']) clusters = scc.connectedComponents(analyzer['components']) a = mp.get(analyzer["landing_points_cables"], lp1) lp1list = me.getValue(a) b = mp.get(analyzer["landing_points_cables"], lp2) lp2list = me.getValue(b) for i in lt.iterator(lp1list): for e in lt.iterator(lp2list): connected = scc.stronglyConnected(analyzer['components'], i, e) if connected: break return (clusters, connected)
def getClusters(catalog, LP1, LP2): SCCc = scc.KosarajuSCC(catalog['connections']) numComponentes1 = scc.connectedComponents(SCCc) boolean = False infoLP1 = me.getValue(mp.get(catalog['landing_points'], LP1)) infoLP2 = me.getValue(mp.get(catalog['landing_points'], LP2)) for cable1 in lt.iterator(infoLP1['cables']): cable_LP1 = formatVertex(LP1, cable1['cable_name']) for cable2 in lt.iterator(infoLP2['cables']): cable_LP2 = formatVertex(LP2, cable2['cable_name']) boolean = scc.stronglyConnected(SCCc, cable_LP1, cable_LP2) if boolean: break return numComponentes1, boolean
def req1(catalog,vera,verb): cities=catalog['cities'] veraid=mp.get(cities,vera)['value'] verbid=mp.get(cities,verb)['value'] scc=sc.KosarajuSCC(catalog['connections']) print('La cantidad de clusteres es: '+str(sc.connectedComponents(scc))+'.') ldka=mp.get(catalog['lpkeys'],veraid)['value'] ldkb=mp.get(catalog['lpkeys'],verbid)['value'] for a in ldka: for b in ldkb: v=sc.stronglyConnected(scc,a,b) if v == True: print('Los landing points {0} y {1} hacen parte de un mismo cluster'.format(veraid,verbid)) break print('Los landing points {0} y {1} no hacen parte de un mismo cluster'.format(veraid,verbid))
def identificar_cluster (graph,lndPoint1,lndPoint2,pMap): idLndP1 = obtener_codeLP(pMap,lndPoint1) idLndP2 = obtener_codeLP(pMap,lndPoint2) sccGraph = scc.KosarajuSCC(graph) sccCant = scc.connectedComponents(sccGraph) clusterLP1 = mp.get(sccGraph['idscc'],idLndP1)['value'] clusterLP2 = mp.get(sccGraph['idscc'],idLndP2)['value'] cfc = scc.stronglyConnected(sccGraph,idLndP1,idLndP2) clts = clusterLP1,clusterLP2 rta = sccCant,cfc return clts,rta
def connected_components(analyzer, landing_name1, landing_name2): #req 1 """ Calcula los componentes conectados del grafo Se utiliza el algoritmo de Kosaraju """ landing_id1 = name_to_id(analyzer, landing_name1) landing_id2 = name_to_id(analyzer, landing_name2) cable1 = lt.getElement( m.get(analyzer['landing_points_cables'], landing_id1)['value'], 1) cable2 = lt.getElement( m.get(analyzer['landing_points_cables'], landing_id2)['value'], 1) verta = format_vertex(landing_id1, cable1) vertb = format_vertex(landing_id2, cable2) analyzer['components'] = scc.KosarajuSCC(analyzer['connections']) connected = scc.stronglyConnected(analyzer['components'], verta, vertb) return scc.connectedComponents(analyzer['components']), connected
def clusterL(analyzer, point1, point2): data = analyzer['cables'] ciclos = scc.KosarajuSCC(data) #numero de componenetes conectados cone= scc.connectedComponents(ciclos) #conectados lista = gr.vertices(data) r = mp.keySet(analyzer['LPnames']) for i in lt.iterator(r): if point1 in i: id1 = (mp.get(analyzer['LPnames'], i))['value'] elif point2 in i: id2 = (mp.get(analyzer['LPnames'], i))['value'] ans = scc.stronglyConnected(ciclos,id1, id2) return cone, ans
def connectedComponents(analyzer, verta, vertb): """ Calcula los componentes conectados del grafo Se utiliza el algoritmo de Kosaraju """ analyzer['components'] = scc.KosarajuSCC(analyzer['connections_distancia']) id_a = traduccion(verta, analyzer) id_b = traduccion(vertb, analyzer) pareja1 = m.get(analyzer['landing_points'], id_a) cableid1 = lt.getElement(me.getValue(pareja1)['conexiones'], 1)['vertice'][1] pareja2 = m.get(analyzer['landing_points'], id_b) cableid2 = lt.getElement(me.getValue(pareja2)['conexiones'], 1)['vertice'][1] vertice1 = (id_a, cableid1) vertice2 = (id_b, cableid2) conectados = scc.stronglyConnected(analyzer['components'], vertice1, vertice2) return (scc.connectedComponents(analyzer['components']), conectados)