def test_is_strongly_connected(self):            
     ncc=nx.number_strongly_connected_components
     for G,C in self.gc:
         if len(C)==1:
             assert_true(nx.is_strongly_connected(G))
         else:
             assert_false(nx.is_strongly_connected(G))
Exemple #2
0
 def test_is_strongly_connected(self):            
     ncc=nx.number_strongly_connected_components
     for G,C in self.gc:
         if len(C)==1:
             assert_true(nx.is_strongly_connected(G))
         else:
             assert_false(nx.is_strongly_connected(G))
Exemple #3
0
def test_scipy_sparse_eigs(G, CN_name, self_link=False, seed_creation=False):
    eps = gm.epsilon
    print 'percentage of non-zero elements: '+str(float(np.count_nonzero(Transition_Matrix))/G.number_of_nodes()**2)
    print 'is strongly connected? '+str(nx.is_strongly_connected(G))+'\nis aperiodic? '+str(nx.is_aperiodic(G))
    M = salsa.get_matrix(G, mat_type='hub', sparse=True)  
    
    CN_index = G.nodes().index(CN_name)
    M = gm.convert_SL_and_CN_weights_to_val(M, val=eps, CN_idx=CN_index, stochastic_out=True)
    new_G = nx.DiGraph(M)  
    
    print 'AFTER get matrix:\npercentage of non-zero elements: ' + str(float(M.getnnz())/G.number_of_nodes()**2)
    print 'is strongly connected? '+str(nx.is_strongly_connected(new_G))+'\nis aperiodic? '+str(nx.is_aperiodic(new_G))
    print 'is stochastic? '+str(gm.check_if_stochastic_matrix(M.todense()))
    print M
    print M.shape[0]
    #M_pow = np.linalg.matrix_power(M.todense(), 111)
    #print M_pow
    e,ev=sp.sparse.linalg.eigen.arpack.eigs(M.copy().T, k=1,sigma=1, which='LM')#, maxiter=100000)
    h = ev/ev.sum()
    print e; print h;
    if (h.imag.sum() != 0.):
        print '##### COMPLEX VECTOR!!!! #####'
    print map(float,h.real)
    '''e1,ev1=sp.linalg.eig(M.todense(),left=True,right=False)
    m=e1.argsort()[-1]
    evMax1=np.array(ev1[:,m]).flatten()
    print '\n\tnp.linalg.eig(left)\n' + str(e1[m]) + '\n' +  str(evMax1)
    '''
    return
Exemple #4
0
def test_hsdf_analysis(n=15, p=0.2, runs=10000, debug=None):
    for run in range(runs) if debug is None else [debug]:
        sdfg = random_sdf_graph(n, p, seed=run)
        vectors = core.check_consistency(sdfg)
        assert nx.is_strongly_connected(sdfg)

        # Analysis of single-rate equivalent
        hsdfg = transform.single_rate_equivalent(sdfg, vectors['q'])
        mg = make_marked_graph(hsdfg)

        # HSDF graph may not be strongly connected, compute its strongly connected components
        condensed = nx.DiGraph()
        idx = 0
        scc_idx = {}
        graph_mcr = None
        for scc in nx.strongly_connected_components(mg):
            idx += 1
            for v in scc:
                scc_idx[v] = idx

            cycletime, _, _ = mcr.compute_mcr(nx.subgraph(mg, scc),
                                              next(iter(scc)))
            condensed.add_node(idx, mcr=cycletime, size=len(scc))
            graph_mcr = cycletime if graph_mcr is None else max(
                cycletime, graph_mcr)

        for v, w in mg.edges_iter():
            if scc_idx[v] != scc_idx[w]:
                condensed.add_edge(scc_idx[v], scc_idx[w])

        critical_size = mg.number_of_nodes()
        for v, data in condensed.nodes(data=True):
            d_in = condensed.in_degree(v)
            d_out = condensed.out_degree(v)
            if d_in == 0:
                critical_size = data['size']
            if d_in == 0 and data['mcr'] < graph_mcr:
                raise AssertionError("Run {}: SCC {} has MCR {} < {}".format(
                    run, v, data['mcr'], graph_mcr))

            if d_in > 1 or d_out > 1:
                pass
                # raise AssertionError("Run {}: SCC {}: in-degree = {}, out-degree = {}".format(run, v, d_in, d_out))

        if debug:
            import pdb
            pdb.set_trace()

        unfolded, _, _ = transform.unfold_depth_first(sdfg, vectors['q'],
                                                      vectors['s'],
                                                      vectors['q'])
        assert nx.is_strongly_connected(unfolded)

        print(
            "Run {:05}: MCR = {}, condensed: {} nodes. HSDF size: {}. Compression: {:.3f}"
            .format(run, graph_mcr, condensed.number_of_nodes(),
                    hsdfg.number_of_nodes(),
                    hsdfg.number_of_nodes() / critical_size))
Exemple #5
0
def generate_random_digraph(n, p, low, high):
    for i in range(100):
        G = nx.gnp_random_graph(n, p, directed = True)
        if nx.is_strongly_connected(G):
            break
    if nx.is_strongly_connected(G) == False:
        print("Unable to generate strongly connected graph, try increase 'p'.")
    density = float(len(G.edges()))/(n*(n-1))
    print("Density: {}".format(density))
    for (n1, n2) in G.edges():
        G[n1][n2]['weight']=random.randint(low, high)
    return G, density
Exemple #6
0
def generateConnexeSensUnique(longueur, largeur, probarete, probsensunique,
                              limite, fonctionpoids, parampoids):
    i = 0
    g = generateSensUnique(longueur, largeur, probarete, probsensunique,
                           fonctionpoids, parampoids)
    while not (nx.is_strongly_connected(g)) and i < limite:
        i += 1
        g = generateSensUnique(longueur, largeur, probarete, probsensunique,
                               fonctionpoids, parampoids)
    if nx.is_strongly_connected(g):
        return g
    else:
        raise nx.ExceededMaxIterations(
            'Pas de graphe fortement connexe généré avant ' + str(limite) +
            ' itérations')
Exemple #7
0
 def directed_stats(self):
     #   UG = nx.to_undirected(g) #claims to not have this function     
     if nx.is_strongly_connected(g): 
         sconl = nx.strongly_connected_components(g)
     else: sconl = 'NA - graph is not strongly connected'
     result = {#"""returns boolean"""
         'scon': nx.is_strongly_connected(g), 
         'sconn': nx.number_connected_components(g),
         # """returns boolean"""        
         'dag': nx.is_directed_acyclic_graph(g),
         # """returns lists"""
         'sconl': nx.strongly_connected_components(g),
         #Conl = connected_component_subgraphs(Ug)
         }
     return result
def test_hsdf_analysis(n = 15, p = 0.2, runs = 10000, debug = None):
    for run in range(runs) if debug is None else [debug]:
        sdfg = random_sdf_graph(n, p, seed = run)
        vectors = core.check_consistency(sdfg)
        assert nx.is_strongly_connected( sdfg )

        # Analysis of single-rate equivalent
        hsdfg = transform.single_rate_equivalent( sdfg, vectors['q'] )
        mg = make_marked_graph(hsdfg)

        # HSDF graph may not be strongly connected, compute its strongly connected components
        condensed = nx.DiGraph()
        idx = 0
        scc_idx = {}
        graph_mcr = None
        for scc in nx.strongly_connected_components(mg):
            idx += 1
            for v in scc:
                scc_idx[v] = idx

            cycletime, _, _ = mcr.compute_mcr(nx.subgraph(mg, scc), next(iter(scc)))
            condensed.add_node(idx, mcr = cycletime, size = len(scc))
            graph_mcr = cycletime if graph_mcr is None else max(cycletime, graph_mcr)

        for v, w in mg.edges_iter():
            if scc_idx[v] != scc_idx[w]:
                condensed.add_edge( scc_idx[v], scc_idx[w] )

        critical_size = mg.number_of_nodes()
        for v, data in condensed.nodes(data = True):
            d_in = condensed.in_degree(v)
            d_out = condensed.out_degree(v)
            if d_in == 0:
                critical_size = data['size']
            if d_in == 0 and data['mcr'] < graph_mcr:
                raise AssertionError("Run {}: SCC {} has MCR {} < {}".format(run, v, data['mcr'], graph_mcr))

            if d_in > 1 or d_out > 1:
                pass
                # raise AssertionError("Run {}: SCC {}: in-degree = {}, out-degree = {}".format(run, v, d_in, d_out))

        if debug:
            import pdb; pdb.set_trace()

        unfolded, _, _ = transform.unfold_depth_first( sdfg, vectors['q'], vectors['s'], vectors['q'] )
        assert nx.is_strongly_connected( unfolded )

        print("Run {:05}: MCR = {}, condensed: {} nodes. HSDF size: {}. Compression: {:.3f}".format(run, graph_mcr, condensed.number_of_nodes(), hsdfg.number_of_nodes(), hsdfg.number_of_nodes() / critical_size))
def string_chain_solution(lst: List[str]) -> bool:
    """ Checks if the list of string can be chained

    :param lst: list of lowercase no-spaces strings
    :return: True if chaining is possible else False
    """
    """
    idea:
    we create a graph with 26 nodes representing the alphabet. each string will be represented by an edge connecting
    the node of the first letter to the node of the last letter.
    then, we need to check if the graph contains an euler circuit (closed loop going exactly once through every
    edge). this is true if:
    1. the in-degree and out-degree of each node is the same
    2. the graph is strongly connected.
    
    notice that we need to use nx.MultiDiGraph in order to create a directed graph allowing parallel edges.
    """

    g = nx.MultiDiGraph()
    for string in lst:
        first = string[0]
        last = string[-1]
        g.add_edge(first, last)

    for node in g.nodes:
        if g.out_degree(node) != g.in_degree(node):
            return False

    return nx.is_strongly_connected(g)
Exemple #10
0
def component_stats(G, verbose):
	"""Prints out various relevent stats about graphs concerning components.

	Parameters
	----------
	G : networkx.DiGraph
	verbose : bool
	    Set to True if you want explanations of stats

	Returns
	-------

	Note: Writes to terminal.
	"""

	explans = {}
	if verbose == True:
		explans['weakly-connected'] = "(There is an undirected path between each pair of nodes in the directed graph)"
		explans['strongly-connected'] = "(There is a directed path between each pair of nodes in the directed graph)"
		explans['semiconnected'] = ""
	else:
		explans['weakly-connected'] = ""
		explans['strongly-connected'] = ""
		explans['semiconnected'] = ""
		
	
	print "Is the graph weakly connected "+explans['weakly-connected'] +"? "+ str(nx.is_weakly_connected(G)) 
	print "Number of weakly connected components: " + str(nx.number_weakly_connected_components(G))
	print "Is the graph semiconnected "+explans['semiconnected']+ "? " + str(nx.is_semiconnected(G))
	print "Is the graph strongly connected "+explans['strongly-connected']+ "? "+ str(nx.is_strongly_connected(G))
Exemple #11
0
    def get_radius(self):
        logging.info("Radius calculations")
        if nx.is_strongly_connected(self.graph) is False:
            logging.info("Graph is not strongly connected")
            sub_graphs = nx.strongly_connected_component_subgraphs(self.graph)

            logging.info("------------------Subgraphs-----------------")

            count = 0
            for sg in sub_graphs:
                count += 1

            logging.info("Graph has :" + str(count) +
                         " strongly connected subgraphs")

            sub_graphs = nx.strongly_connected_component_subgraphs(self.graph)

            for sg in sub_graphs:
                logging.info("Number of nodes in subgraph is: " +
                             str(len(sg.nodes())))
                radius = nx.radius(sg)
                self.sub_graph_radius.append(radius)
        else:
            self.sub_graph_radius.append(nx.radius(self.graph))

        self.graph_radius = max(self.sub_graph_radius)
        print "Max radius: {}".format(self.graph_radius)
Exemple #12
0
def get_largest_component(G, strongly=False):
    """
    Return the largest weakly or strongly connected component from a directed graph.
    
    Parameters
    ----------
    G : graph
    strongly : bool, if True, return the largest strongly instead of weakly connected component
    
    Returns
    -------
    G : graph
    """

    start_time = time.time()
    original_len = len(G.nodes())

    if strongly:
        # if the graph is not connected and caller did not request retain_all, retain only the largest strongly connected component
        if not nx.is_strongly_connected(G):
            G = max(nx.strongly_connected_component_subgraphs(G), key=len)
            log('Graph was not connected, retained only the largest strongly connected component ({:,} of {:,} total nodes) in {:.2f} seconds'
                .format(len(G.nodes()), original_len,
                        time.time() - start_time))
    else:
        # if the graph is not connected and caller did not request retain_all, retain only the largest weakly connected component
        if not nx.is_weakly_connected(G):
            G = max(nx.weakly_connected_component_subgraphs(G), key=len)
            log('Graph was not connected, retained only the largest weakly connected component ({:,} of {:,} total nodes) in {:.2f} seconds'
                .format(len(G.nodes()), original_len,
                        time.time() - start_time))

    return G
Exemple #13
0
def is_eulerian(G):
    """Returns ``True`` if and only if ``G`` is Eulerian.

    An graph is *Eulerian* if it has an Eulerian circuit. An *Eulerian
    circuit* is a closed walk that includes each edge of a graph exactly
    once.

    Parameters
    ----------
    G : NetworkX graph
       A graph, either directed or undirected.

    Examples
    --------
    >>> nx.is_eulerian(nx.DiGraph({0: [3], 1: [2], 2: [3], 3: [0, 1]}))
    True
    >>> nx.is_eulerian(nx.complete_graph(5))
    True
    >>> nx.is_eulerian(nx.petersen_graph())
    False

    Notes
    -----
    If the graph is not connected (or not strongly connected, for
    directed graphs), this function returns ``False``.

    """
    if G.is_directed():
        # Every node must have equal in degree and out degree and the
        # graph must be strongly connected
        return (all(G.in_degree(n) == G.out_degree(n) for n in G)
                and nx.is_strongly_connected(G))
    # An undirected Eulerian graph has no vertices of odd degree and
    # must be connected.
    return all(d % 2 == 0 for v, d in G.degree()) and nx.is_connected(G)
Exemple #14
0
    def __init__(self, g: nx.Graph):
        self.__g = g
        self.__data_dict = dict()
        self.__communities = dict()
        self.__pagerank = dict()
        self.__hits = dict()
        self.__conn_comp = list()
        self.__bridges = list()
        self.__local_bridges = list()
        self.__neigh_overlap = dict()
        self.__clustering_coefficients = dict()

        if nx.is_directed(self.__g):
            self.__data_dict['Type'] = "Directed"
            self.__data_dict['Connected'] = nx.is_strongly_connected(self.__g)
        else:
            self.__data_dict['Type'] = "Undirected"
            self.__data_dict['Connected'] = nx.is_connected(self.__g)

        self.__degree_stats()
        self.__graph_props()
        self.__basic_info()
        self.__communities_props()
        self.__link_analysis()
        self.__connected_components()

        if self.__data_dict["Type"] == "Undirected":
            self.__find_bridges_overlap()
    def metrics_on_degree_sequence(self):
        # number of nodes
        n = len(self.network.nodes())

        # isolate the sequence of degrees
        degree_sequence = list(self.network.degree())

        # comput number of edges and the metrics on the degree sequence
        nb_nodes = n
        nb_arr = len(self.network.edges())

        avg_degree = np.mean(np.array(degree_sequence)[:, 1])
        med_degree = np.median(np.array(degree_sequence)[:, 1])

        max_degree = max(np.array(degree_sequence)[:, 1])
        min_degree = np.min(np.array(degree_sequence)[:, 1])

        print("Number of nodes : " + str(nb_nodes))
        print("Number of edges : " + str(nb_arr))
        print("Maximum degree : " + str(max_degree))
        print("Minimum degree : " + str(min_degree))
        print("Average degree : " + str(avg_degree))
        print("Median degree : " + str(med_degree))

        print()
        print('This is a weakly connected network: ',
              nx.is_weakly_connected(self.network))
        print('This is a strongly connected network: ',
              nx.is_strongly_connected(self.network))
        print()
Exemple #16
0
def netstats_listsdi(graph):
    G = graph
 #   UG = nx.to_undirected(G) #claims to not have this function     
    if nx.is_strongly_connected(G): 
        sconl = nx.strongly_connected_components(G)
    else: sconl = 'NA - graph is not strongly connected'
    result = {#"""returns boolean"""
              'scon': nx.is_strongly_connected(G), 
              'sconn': nx.number_connected_components(G),
             # """returns boolean"""        
              'dag': nx.is_directed_acyclic_graph(G),
             # """returns lists"""
              'sconl': nx.strongly_connected_components(G),
#              Conl = connected_component_subgraphs(UG)
              }
    return result    
Exemple #17
0
def answer_three():

    # Note: strongly_connected needs direction, weakly_connected needs only connections
    G = answer_one()
    s_con = nx.is_strongly_connected(G)
    w_con = nx.is_weakly_connected(G)
    return (s_con, w_con)
Exemple #18
0
def is_eulerian(G):
    """Returns True if and only if `G` is Eulerian.

    A graph is *Eulerian* if it has an Eulerian circuit. An *Eulerian
    circuit* is a closed walk that includes each edge of a graph exactly
    once.

    Parameters
    ----------
    G : NetworkX graph
       A graph, either directed or undirected.

    Examples
    --------
    >>> nx.is_eulerian(nx.DiGraph({0: [3], 1: [2], 2: [3], 3: [0, 1]}))
    True
    >>> nx.is_eulerian(nx.complete_graph(5))
    True
    >>> nx.is_eulerian(nx.petersen_graph())
    False

    Notes
    -----
    If the graph is not connected (or not strongly connected, for
    directed graphs), this function returns False.

    """
    if G.is_directed():
        # Every node must have equal in degree and out degree and the
        # graph must be strongly connected
        return (all(G.in_degree(n) == G.out_degree(n) for n in G)
                and nx.is_strongly_connected(G))
    # An undirected Eulerian graph has no vertices of odd degree and
    # must be connected.
    return all(d % 2 == 0 for v, d in G.degree()) and nx.is_connected(G)
def create_shortest_path_matrix(weighted=False, discount_highways=False):
    G = nx.DiGraph()

    logging.info("Loading graph to NetworkX from database...")
    c = connection.cursor()
    if discount_highways:
        c.execute("SELECT l.beg_node_id, l.end_node_id, (CASE WHEN l.link_type='1' THEN 0.5 WHEN l.link_type='2' THEN 0.5 ELSE 1.0 END) FROM microsim_link l")
    else:
        c.execute("SELECT l.beg_node_id, l.end_node_id, l.length/l.lane_count AS resistance FROM microsim_link l")
    G.add_weighted_edges_from(c.fetchall())

    logging.debug("Road network is strongly connected: %s" % repr(nx.is_strongly_connected(G)))

    logging.info("Computing shortest paths...")
    if weighted:
        sp = nx.all_pairs_dijkstra_path_length(G)
    else:
        sp = nx.all_pairs_shortest_path_length(G)

    logging.info("Converting shortest paths into matrix...")
    c.execute("SELECT ROW_NUMBER() OVER (ORDER BY id), beg_node_id, end_node_id FROM microsim_link")
    links = c.fetchall()
    N_LINKS = len(links)
    shortest_paths = np.zeros((N_LINKS, N_LINKS))
    for col_idx, _, col_end_node in links:
        for row_idx, _, row_end_node in links:
            if col_idx == row_idx:
                continue
            nodes = sp[col_end_node]
            if row_end_node not in nodes:
                shortest_paths[row_idx - 1, col_idx - 1] = float(N_LINKS)
            else:
                shortest_paths[row_idx - 1, col_idx - 1] = nodes[row_end_node]
    logging.info("Shortest path matrix complete.")
    return shortest_paths
def draw_graph(nodes, edges, graphs_dir, default_lang='all'):
    lang_graph = nx.MultiDiGraph()
    lang_graph.add_nodes_from(nodes)
    for edge in edges:
        if edges[edge] == 0:
            lang_graph.add_edge(edge[0], edge[1])
        else:
            lang_graph.add_edge(edge[0], edge[1], weight=float(edges[edge]), label=str(edges[edge]))

    # print graph info in stdout
    # degree centrality
    print('-----------------\n\n')
    print(default_lang)
    print(nx.info(lang_graph))
    try:
        # When ties are associated to some positive aspects such as friendship or collaboration,
        #  indegree is often interpreted as a form of popularity, and outdegree as gregariousness.
        DC = nx.degree_centrality(lang_graph)
        max_dc = max(DC.values())
        max_dc_list = [item for item in DC.items() if item[1] == max_dc]
    except ZeroDivisionError:
        max_dc_list = []
    # https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81%D0%BD%D1%8B%D0%B5_%D1%81%D0%B5%D1%82%D0%B8
    print('maxdc', str(max_dc_list), sep=': ')
    # assortativity coef
    AC = nx.degree_assortativity_coefficient(lang_graph)
    print('AC', str(AC), sep=': ')
    # connectivity
    print("Слабо-связный граф: ", nx.is_weakly_connected(lang_graph))
    print("количество слабосвязанных компонент: ", nx.number_weakly_connected_components(lang_graph))
    print("Сильно-связный граф: ", nx.is_strongly_connected(lang_graph))
    print("количество сильносвязанных компонент: ", nx.number_strongly_connected_components(lang_graph))
    print("рекурсивные? компоненты: ", nx.number_attracting_components(lang_graph))
    print("число вершинной связности: ", nx.node_connectivity(lang_graph))
    print("число рёберной связности: ", nx.edge_connectivity(lang_graph))
    # other info
    print("average degree connectivity: ", nx.average_degree_connectivity(lang_graph))
    print("average neighbor degree: ", sorted(nx.average_neighbor_degree(lang_graph).items(),
                                              key=itemgetter(1), reverse=True))
    # best for small graphs, and our graphs are pretty small
    print("pagerank: ", sorted(nx.pagerank_numpy(lang_graph).items(), key=itemgetter(1), reverse=True))

    plt.figure(figsize=(16.0, 9.0), dpi=80)
    plt.axis('off')
    pos = graphviz_layout(lang_graph)
    nx.draw_networkx_edges(lang_graph, pos, alpha=0.5, arrows=True)
    nx.draw_networkx(lang_graph, pos, node_size=1000, font_size=12, with_labels=True, node_color='green')
    nx.draw_networkx_edge_labels(lang_graph, pos, edges)

    # saving file to draw it with dot-graphviz
    # changing overall graph view, default is top-bottom
    lang_graph.graph['graph'] = {'rankdir': 'LR'}
    # marking with blue nodes with maximum degree centrality
    for max_dc_node in max_dc_list:
        lang_graph.node[max_dc_node[0]]['fontcolor'] = 'blue'
    write_dot(lang_graph, os.path.join(graphs_dir, default_lang + '_links.dot'))

    # plt.show()
    plt.savefig(os.path.join(graphs_dir, 'python_' + default_lang + '_graph.png'), dpi=100)
    plt.close()
Exemple #21
0
def is_strongly_connected(G):
    # checking connectivity
    # the goal of the network is to be strongly connected
    if nx.is_strongly_connected(G):
        print('The directed graph is strongly connected')
    else:
        print('The directed graph is not strongly connected.')
Exemple #22
0
    def _update_after_countermeasure(self, target):
        new_components = []
        if target in self.links_to_strong_components:
            component_id = self.links_to_strong_components[target]
            subgraph = self.nxGraph.subgraph(
                self.strong_components[component_id]['nodes'])
            is_still_strong = is_strongly_connected(subgraph)

            if is_still_strong:
                return
            else:
                self._remove_strong_component(component_id)
                # Find new components
                strong_components_nodes = get_strongly_connected_components(
                    subgraph)
                # Add new components to list of components
                for component in strong_components_nodes:
                    new_components.append(self.components_index)
                    self._workout_strong_component(component)

        searcher = GraphSearcher(self.previousCopy)
        nodes_to_target = searcher.get_sources_to_target_node(target)

        self._update_nodes_threat(nodes_to_target)
        # Remove newly created component from update list
        for index in new_components:
            self.strong_components_to_update.remove(index)
def write_distance_info(G, report_file):
    report_file.write("===DISTANCE_INFO_STRONGLY_CONNECTED===\n")
    if nx.is_strongly_connected(G):
        report_file.write("Center: {}\n".format(nx.center(G)))
        report_file.write("Diameter: {}\n".format(nx.diameter(G)))
        report_file.write("Periphery: {}\n".format(nx.periphery(G)))
        report_file.write("Radius: {}\n".format(nx.radius(G)))
    else:
        report_file.write("Center: +INF\n")
        report_file.write("Diameter: +INF\n")
        report_file.write("Periphery: +INF\n")
        report_file.write("Radius: +INF\n")

    report_file.write("===DISTANCE_INFO_WEAKLY_CONNECTED===\n")
    if nx.is_weakly_connected(G):
        undirected_G = nx.to_undirected(G)
        report_file.write("Center: {}\n".format(nx.center(undirected_G)))
        report_file.write("Diameter: {}\n".format(nx.diameter(undirected_G)))
        report_file.write("Periphery: {}\n".format(nx.periphery(undirected_G)))
        report_file.write("Radius: {}\n".format(nx.radius(undirected_G)))
    else:
        report_file.write("Center: +INF\n")
        report_file.write("Diameter: +INF\n")
        report_file.write("Periphery: +INF\n")
        report_file.write("Radius: +INF\n")
Exemple #24
0
def answer_three():

    # Your Code Here
    G = answer_one()
    is_strongly_connected = nx.is_strongly_connected(G)
    is_weakly_connected = nx.is_weakly_connected(G)
    return (is_strongly_connected, is_weakly_connected)  # Your Answer Here
Exemple #25
0
def gen_network(graph,machines,basedata):
    """ Generates an LLD network from a graph
        distributing participants in a list of machines
    """
    network = ET.Element('network')
    #network.set('type',graphtype)
    network.set('participants',str(graph.number_of_nodes()))
    network.set('edges',str(graph.size()))
    network.set('density',str(NX.density(graph)))

    network.set('connected',str(NX.is_weakly_connected(graph)))
    network.set('stronglyconnected',str(NX.is_strongly_connected(graph)))

    for node in graph.nodes_iter():
        nodelement = ET.SubElement(network,'participant')
        nodelement.set('id','participant'+str(node))
        hostelem = ET.SubElement(nodelement,'host')
        #hostelem.text = 'node'+str(int(node) % len(machines))
        hostelem.text = machines[int(node) % len(machines)]
        portelem = ET.SubElement(nodelement,'port')
        portelem.text = str(20500+int(node))
        baseelem = ET.SubElement(nodelement,'basedata')
        baseelem.text = basedata
        nodelement.append(gen_dynamic())
        for source in gen_sources(graph,node):
            nodelement.append(source)
    return network
Exemple #26
0
def get_largest_component(G, strongly=False):
    """
    Return the largest weakly or strongly connected component from a directed graph.
    Parameters
    ----------
    G : networkx multidigraph
    strongly : bool
        if True, return the largest strongly instead of weakly connected component
    Returns
    -------
    networkx multidigraph
    """


    original_len = len(list(G.nodes()))

    if strongly:
        # if the graph is not connected and caller did not request retain_all, retain only the largest strongly connected component
        if not nx.is_strongly_connected(G):
            G = max(nx.strongly_connected_component_subgraphs(G), key=len)
            
    else:
        # if the graph is not connected and caller did not request retain_all, retain only the largest weakly connected component
        if not nx.is_weakly_connected(G):
            G = max(nx.weakly_connected_component_subgraphs(G), key=len)
            
    return G
Exemple #27
0
def test_synthetic_network_with_custom_stops():
    # Load in the GeoJSON as a JSON and convert to a dictionary
    geojson_path = fixture('synthetic_east_bay.geojson')
    with open(geojson_path, 'r') as gjf:
        reference_geojson = json.load(gjf)

    # Add in specific, custom stops under new properties key
    custom_stops = [[-122.29225158691406, 37.80876678753658],
                    [-122.28886127471924, 37.82341261847038],
                    [-122.2701072692871, 37.83005652796547]]
    reference_geojson['features'][0]['properties']['stops'] = custom_stops

    G1 = load_synthetic_network_as_graph(reference_geojson)

    # Sanity check the outputs against the custom stops input
    assert len(list(G1.nodes())) == (len(custom_stops) + 2)
    assert len(list(G1.edges())) == (len(custom_stops) + 1)

    # Go back to the GeoJSON and set optional bidirectional flag
    reference_geojson['features'][0]['properties']['bidirectional'] = True

    G2 = load_synthetic_network_as_graph(reference_geojson)

    # We re-use the same stop nodes for both directions
    nodes = list(G2.nodes())
    assert len(nodes) == (len(custom_stops) + 2)

    # Double the number of edges as before
    edges = list(G2.edges())
    assert len(edges) == (len(custom_stops) + 1) * 2

    # But now, by asking for a bidirectional graph, we can assert strong
    assert nx.is_strongly_connected(G2)
Exemple #28
0
    def component(self):
        rslt = {}
        if self.directed == 'directed':
            rslt['is_strongly_connected'] = nx.is_strongly_connected(
                self.graph)

            strong = nx.strongly_connected_components(self.graph)
            strong_nodes = []
            for n in strong:
                strong_nodes.append(list(n)[0])
            rslt['strongly_connected'] = strong_nodes

            rslt[
                'number_strongly_connected_components'] = nx.number_strongly_connected_components(
                    self.graph)
            rslt['is_semiconnected'] = nx.is_semiconnected(self.graph)

            weak = nx.weakly_connected_components(self.graph)
            weak_nodes = []
            for n in weak:
                weak_nodes.append(list(n)[0])
            rslt['wealy_connected'] = weak_nodes

            rslt['is_weakly_connected'] = nx.is_weakly_connected(self.graph)
            rslt[
                'number_weakly_connected_components'] = nx.number_weakly_connected_components(
                    self.graph)

        fname_component = self.DIR + '/component.json'
        with open(fname_component, "w") as f:
            json.dump(rslt, f, cls=SetEncoder, indent=2)
        print(fname_component)
def get_network_stats(g):
    """
    Compute basic properties of a network

    :param g: input network as an NetworkX graph
    :return: dictionary with basic network properties as keys
    """
    result = {}

    result['num_nodes'] = nx.number_of_nodes(g)
    result['num_edges'] = nx.number_of_edges(g)
    result['transitivity'] = nx.transitivity(g)

    if nx.is_directed(g):
        if nx.is_weakly_connected(g):
            result['average_shortest_path'] = nx.average_shortest_path_length(
                g)
        if nx.is_strongly_connected(g):
            result['diameter'] = nx.diameter(g)

    else:
        result['average_shortest_path'] = nx.average_shortest_path_length(g)
        result['diameter'] = nx.diameter(g)

    result['reciprocity'] = nx.reciprocity(g)

    return result
Exemple #30
0
    def find_all_path(self):

        # here we used a undirected graph to find path for
        # strongly conn graph and non-strongly conn graph

        if is_strongly_connected(self.create_graph('di')):
            graph = self.create_graph('di')
        else:
            graph = self.create_graph('')

        followers = set(self.nodes) - self.leaders
        followers_paths = dict()

        for node in followers:
            generator = all_simple_paths(graph,
                                         source=node,
                                         target=self.leaders)
            paths = list()

            for path in generator:
                paths.append(path)

            followers_paths[node] = paths
        # dict with list of lists
        self.followers_paths = followers_paths
def answer_three():
        
    G = answer_one()
    part1 = nx.is_strongly_connected(G)
    part2 = nx.is_weakly_connected(G)
    
    return part1,part2
Exemple #32
0
def connected_watts_strogatz_graph(n, k, p, tries=100):
    """Returns a connected Watts–Strogatz small-world graph.
    Attempts to generate a connected graph by repeated generation of
    Watts–Strogatz small-world graphs.  An exception is raised if the maximum
    number of tries is exceeded.
    Parameters
    ----------
    n : int
        The number of nodes
    k : int
        Each node is joined with its `k` nearest neighbors in a ring
        topology.
    p : float
        The probability of rewiring each edge
    tries : int
        Number of attempts to generate a connected graph.
    -----
    """
    for i in range(tries):
        G = watts_strogatz_graph(n, k, p)
        if nx.is_strongly_connected(G):
            return G
    # raise nx.NetworkXError('Maximum number of tries exceeded')
    print('Warning: Maximum number of tries exceeded: the network '
          'is NOT strongly connected')
    return G
Exemple #33
0
def connected_directed_networkgraph(n=20):
    G = nx.DiGraph()
    nodes = [i for i in range(1,n+1)]
    cyclenodes = cycle(nodes)
    G.add_nodes_from(nodes)   # add n nodes

    # ## agent につき1~2本の in/out edge を生成
    # inum = np.random.choice((1,2,),1)[0]
    # onum = np.random.choice((1,2,),1)[0]
    for i in range(0,n):
        ## agent につき1~2本の in/out edge を生成
        inum = np.random.choice((1,2,3,),1)[0]
        onum = np.random.choice((1,2,3,),1)[0]
        ## 各agentの周辺4 nodeへランダムに edge 生成
        neighbors = cyclenodes.forward(i,4) + cyclenodes.backward(i,4)
        ineighbors = np.random.choice(neighbors,inum,replace=False)
        oneighbors = np.random.choice(neighbors,onum,replace=False)
        for j in ineighbors:
            G.add_edge(nodes[i],j)
        for j in oneighbors:
            G.add_edge(j,nodes[i])
    
    if not nx.is_strongly_connected(G):
        raise Exception()
    else:
        print("connected")

    (adjMat, maxdeg) = __network_constructure(G)

    return (G, adjMat, maxdeg)
Exemple #34
0
 def reduce (self, collapse=False) :
     """Merge the nodes that avec the same DTX (distance to exit)
      - always if collapse is True
      - only if they are SCC themselves otherwise
     """
     if collapse :
         classes = [v for k, v in sorted(self._nodeattr("dtx").items())]
         name = "dtx-min"
         def label (num, members) :
             return "(%s)" % num
         def attrs (num, members) :
             return {"dtx" : self.nodes[iter(members).next()]["dtx"],
                     "shape" : "hexagon" if any(self.nodes[m]["init"]
                                                for m in members) else "circle"}
     else :
         classes = []
         for nodes in self._nodeattr("dtx").values() :
             if nx.is_strongly_connected(self.subgraph(nodes)) :
                 classes.append(nodes)
             else :
                 classes.extend({n} for n in nodes)
         classes.sort(key=min)
         name = "dtx-scc"
         def label (num, members) :
             if len(members) == 1 :
                 first = iter(members).next()
                 return "%s/%s" % (first, self.nodes[first]["dtx"])
             else :
                 return "(%s)" % num
         def attrs (num, members) :
             return {"dtx" : self.nodes[iter(members).next()]["dtx"],
                     "shape" : "hexagon" if any(self.nodes[m]["init"]
                                                for m in members) else "circle"}
     return ReducedKernelGraph.build(self, classes, label, attrs, name, "circo")
Exemple #35
0
def load_graph(graph_name):
    folder_path = path.join('graphs', graph_name)

    graph_data = deserialize_dict(
        file_path=path.join(folder_path, 'graph_data.pkl.gz'))
    graph = ox.load_graphml(filename='graph.graphml', folder=folder_path)
    # graph = nx.MultiDiGraph(nx.read_graphml(path.join(folder_path, 'graph.graphml'), node_type=int))

    if not nx.is_strongly_connected(graph):
        graph = ox.get_largest_component(graph, strongly=True)

    node_mapping = {node: i for i, node in enumerate(sorted(graph.nodes()))}
    graph = nx.relabel_nodes(graph, node_mapping)

    # Ensure nodes and edges are ordered consistently
    G = nx.MultiDiGraph()
    for node, data in sorted(graph.nodes(data=True), key=lambda t: t[0]):
        data['demand'] = 0
        G.add_node(node, **data)

    for src, dst, data in sorted(graph.edges(data=True),
                                 key=lambda t: (t[0], t[1])):
        # Remove parallel edges and self-loops
        if src == dst or (src in G and dst in G[src]):
            continue

        # Dummy data for compatibility with plotter
        data['zero'] = 0
        G.add_edge(src, dst, key=0, **data)

    G.graph['crs'] = graph_data['crs']
    G.graph['name'] = graph_data['name']
    G = ox.project_graph(G, to_crs=graph_data['crs'])

    return G.to_directed()
Exemple #36
0
def create_connected_graph(N, E):
    G = nx.random_tree(N)
    if nx.is_connected(G) == False:
        raise Exception('Not a spanning tree!')
    for (i, j) in G.edges:  #Adds data to spanning tree portion of graph
        p = random.random()
        q = 0.5 * p
        G.edges[i, j]['length'] = -np.log(p)
        G.edges[i, j]['interdicted_length'] = -np.log(q) + np.log(p)
    G_comp = nx.complete_graph(N)
    while G.number_of_edges() < 0.5 * E:  #generates remaining edges with data
        edge = random.sample(list(set(G_comp.edges) - set(G.edges)), 1)
        for (i, j) in edge:
            p = random.random()
            q = 0.5 * p
            G.add_edge(i,
                       j,
                       length=-np.log(p),
                       interdicted_length=-np.log(q) + np.log(p))
    G = G.to_directed()
    if nx.is_strongly_connected(G) == False:
        raise Exception('Directed graph is not strongly connected')
    nx.draw(G, with_labels=True)
    plt.show()
    plt.savefig("path.png")
    return G
Exemple #37
0
    def get_relation_node_free_graph(self):
        if nx.is_strongly_connected(self):
            raise ArgGraphException(('Cannot produce relation node free graph.'
                                     'Arggraph contains cycles.'))
        if False in [self.out_degree(node) <= 1 for node in self.nodes()]:
            raise ArgGraphException(('Cannot produce relation node free graph.'
                                     'Nodes with multiple outgoing edges.'))

        a = ArgGraph(self)

        if ('relation-node-free' in a.graph
                and a.graph['relation-node-free'] == True):
            return a

        # reduce multi-source relations to adu.addsource->adu
        for rel_node in [
                node for node, d in a.nodes(data=True)
                if a.out_degree(node) >= 1 and d['type'] == 'rel'
        ]:
            sources = sorted_nicely([
                source for source in a.predecessors(rel_node)
                if a.node[source]['type'] == 'adu'
            ])
            for source in sources[1:]:
                a.remove_edge(source, rel_node)
                a.add_edge(source, sources[0], type="add")

        # first reduce rel->rel
        remove_nodes = []
        remove_edges = []
        for (src, trg, d) in a.edges(data=True):
            if a.node[src]['type'] == 'rel' and a.node[trg]['type'] == 'rel':
                src_pre = a.predecessor_by_edge_type(src, 'src')[0]
                trg_pre = a.predecessor_by_edge_type(trg, 'src')[0]
                a.remove_edge(src, trg)
                a.add_edge(src_pre, trg_pre, type=d['type'])
                remove_edges.append((
                    src_pre,
                    src,
                ))
                remove_nodes.append(src)

        for src, trg in remove_edges:
            a.remove_edge(src, trg)
        for node in remove_nodes:
            a.remove_node(node)

        # then reduce rel->adu (remaining relnodes)
        for (src, trg, d) in a.edges(data=True):
            if a.node[src]['type'] == 'rel' and a.node[trg]['type'] == 'adu':
                src_pre = a.predecessors(src)[0]
                a.add_edge(src_pre, trg, type=d['type'])
                a.remove_edge(src_pre, src)
                a.remove_edge(src, trg)
                a.remove_node(src)

        a.graph['relation-node-free'] = True

        return a
    def test_load_call_graph_return_edges_file_granularity(self):
        # Act
        graph = self.target.load_call_graph(granularity=Gran.FILE)

        # Assert
        self.assertTrue(nx.is_strongly_connected(graph))
        for (u, v) in nx.get_edge_attributes(graph, 'call'):
            self.assertTrue('return' in graph[v][u])
Exemple #39
0
 def check_strongly_connected(self):
     # Checks strongly connected components and returns the number of nodes in components with at least 2 nodes
     if nx.is_strongly_connected(self.network):
         print('Directed graph is strongly connected for all nodes')
     elif nx.is_weakly_connected(self.network):
         print('Directed graph is only weakly connected')
     else:
         print('Directed graph is not connected at all')
def prog_27(fname):
    graph = nx.DiGraph()
    f = open(fname)

    ns,es = map(int, f.readline().strip().split())

    graph.add_nodes_from(range(1,ns+1))

    for line in f:
        e1,e2 = map(int, line.strip().split())
        graph.add_edge(e1,e2)

    f.close()

    print nx.is_strongly_connected(graph)
        # print 'xxxxxxxx'

    print nx.number_strongly_connected_components(graph)
Exemple #41
0
def test_networkx_methods():
    reducible_G = nx.DiGraph(np.matrix([[1,0],[0,1]]))
    print 'reducible- is strongly connected? ' + str(nx.is_strongly_connected(reducible_G)) #False
    print 'reducible- strongly connected components: ' + str(nx.strongly_connected_components(reducible_G)) #[[0], [1]]
    print 'reducible- is aperiodic? ' + str(nx.is_aperiodic(reducible_G)) #True
    
    irreducible_periodic_G = nx.DiGraph(np.matrix([[0,1],[1,0]]))
    print '\nirreducible_periodic- is strongly connected? ' + str(nx.is_strongly_connected(irreducible_periodic_G)) #True
    print 'irreducible_periodic- strongly connected components: ' + str(nx.strongly_connected_components(irreducible_periodic_G)) #[[0, 1]]
    print 'irreducible_periodic- is aperiodic? ' + str(nx.is_aperiodic(irreducible_periodic_G)) #False (2)
    
    ergodic_G = nx.DiGraph(np.matrix([[0,1,1,0],[1,0,0,1],[0,1,0,0],[0,1,0,0]]))
    modified_G = nx.DiGraph(salsa.get_matrix(ergodic_G, mat_type='hub', sparse=False))
    print 'modified- is strongly connected? ' + str(nx.is_strongly_connected(modified_G)) #False
    print 'modified- strongly connected components: ' + str(nx.strongly_connected_components(modified_G)) #[[0, 2, 3], [1]]
    print 'modified- is aperiodic? ' + str(nx.is_aperiodic(modified_G)) #True

    return
    def test_load_call_graph_return_edges_file_granularity(self):
        # Act
        test_graph = self.test_loader.load_call_graph(granularity=Gran.FILE)

        # Assert
        call_edges = nx.get_edge_attributes(test_graph, 'call')

        self.assertTrue(nx.is_strongly_connected(test_graph))
        for (u, v) in call_edges:
            self.assertTrue('return' in test_graph[v][u])
Exemple #43
0
    def get_relation_node_free_graph(self):
        if nx.is_strongly_connected(self):
            raise ArgGraphException(('Cannot produce relation node free graph.'
                                     'Arggraph contains cycles.'))
        if False in [self.out_degree(node) <= 1 for node in self.nodes()]:
            raise ArgGraphException(('Cannot produce relation node free graph.'
                                    'Nodes with multiple outgoing edges.'))

        a = ArgGraph(self)

        if ('relation-node-free' in a.graph and
                a.graph['relation-node-free'] == True):
            return a

        # reduce multi-source relations to adu.addsource->adu
        for rel_node in [node for node, d in a.nodes(data=True)
                         if a.out_degree(node) >= 1 and d['type'] == 'rel']:
            sources = sorted_nicely(
                [source for source in a.predecessors(rel_node)
                 if a.node[source]['type'] == 'adu']
            )
            for source in sources[1:]:
                a.remove_edge(source, rel_node)
                a.add_edge(source, sources[0], type="add")

        # first reduce rel->rel
        remove_nodes = []
        remove_edges = []
        for (src, trg, d) in a.edges(data=True):
            if a.node[src]['type'] == 'rel' and a.node[trg]['type'] == 'rel':
                src_pre = a.predecessor_by_edge_type(src, 'src')[0]
                trg_pre = a.predecessor_by_edge_type(trg, 'src')[0]
                a.remove_edge(src, trg)
                a.add_edge(src_pre, trg_pre, type=d['type'])
                remove_edges.append((src_pre, src, ))
                remove_nodes.append(src)

        for src, trg in remove_edges:
            a.remove_edge(src, trg)
        for node in remove_nodes:
            a.remove_node(node)

        # then reduce rel->adu (remaining relnodes)
        for (src, trg, d) in a.edges(data=True):
            if a.node[src]['type'] == 'rel' and a.node[trg]['type'] == 'adu':
                src_pre = a.predecessors(src)[0]
                a.add_edge(src_pre, trg, type=d['type'])
                a.remove_edge(src_pre, src)
                a.remove_edge(src, trg)
                a.remove_node(src)

        a.graph['relation-node-free'] = True

        return a
def output_conectivity_info (graph, path):
    """Output connectivity information about the graph.
       graph : (networkx.Graph)
       path: (String) contains the path to the output file
    """
    with open(path, 'w') as out:
        out.write('***Conectivity***\n')
        out.write('Is weakly connected: %s\n' % nx.is_weakly_connected(graph))
        out.write('Number of weakly connected components: %d\n' % nx.number_weakly_connected_components(graph))
        out.write('Is strongly connected: %s\n' % nx.is_strongly_connected(graph))
        out.write('Number of strongly connected components: %d' % nx.number_strongly_connected_components(graph))
Exemple #45
0
def test_eig_error():
    #graph_file = '/home/michal/SALSA_files/tmp/real_run/graph_11'
    #G = gm.read_graph_from_file(graph_file)
    graph_list = [(354, 354, {'weight': 0.5}),\
                  (354, 13291, {'weight': 0.25}),\
                  (354, 11354, {'weight': 0.25}),\
                  (15204, 15204, {'weight': 0.5}),\
                  (15204, 14639, {'weight': 0.5}),\
                  (11210, 6898, {'weight': 0.25}),\
                  (11210, 11210, {'weight': 0.5}),\
                  (11210, 11354, {'weight': 0.25}),\
                  (13291, 354, {'weight': 0.5}),\
                  (13291, 13291, {'weight': 0.5}),\
                  (14639, 13236, {'weight': 0.16666666666666666}),\
                  (14639, 6898, {'weight': 0.16666666666666666}),\
                  (14639, 15204, {'weight': 0.25}),\
                  (14639, 14639, {'weight': 0.41666666666666663}),\
                  (6898, 6898, {'weight': 0.6111111111111112}),\
                  (6898, 13236, {'weight': 0.1111111111111111}),\
                  (6898, 11210, {'weight': 0.16666666666666666}),\
                  (6898, 14639, {'weight': 0.1111111111111111}),\
                  (13236, 6898, {'weight': 0.3333333333333333}),\
                  (13236, 13236, {'weight': 0.3333333333333333}),\
                  (13236, 14639, {'weight': 0.3333333333333333}),\
                  (11354, 11210, {'weight': 0.25}),\
                  (11354, 354, {'weight': 0.25}),\
                  (11354, 11354, {'weight': 0.5})]
    #(11354, 11354, {'weight': 0.5})]

    G = nx.DiGraph(graph_list)
    #print G.edges(data=True)
    print '--- eig_calc: is sub graph stochastic? ' + str(gm.check_if_stochastic_matrix(nx.to_numpy_matrix(G)))#; sys.stdout.flush()
    print '--- eig_calc: is sub graph strongly connected? ' + str(nx.is_strongly_connected(G))#; sys.stdout.flush()
    print '--- eig_calc: is sub graph aperiodic? ' + str(nx.is_aperiodic(G));# sys.stdout.flush()
    #np_mat = nx.to_numpy_matrix(G)
    #print 'det= '+ str(np.linalg.det(np_mat))
    print salsa.eig_calc(G)
    '''try:
        print salsa.eig_calc(G)
    except RuntimeError: 
        max_weight = max(e[2]['weight'] for e in G.edges_iter(data=True))
        noise = 1e-13
        for e in G.edges_iter(data=True):
            if e[2]['weight'] == max_weight:
                e[2]['weight'] += noise
        if not gm.check_if_stochastic_matrix(nx.to_numpy_matrix(G)):
            nx.stochastic_graph(G, copy=False)
        print salsa.eig_calc(G)'''
    
    

    
    return
Exemple #46
0
    def test_enterprise_graph_properties(self):
        """ EnterpriseTopology graph must be directed, containt 1577 nodes, be
        strongly connected and the paths need to be symmetric"""

        topo = self.topo

        self.assertTrue(topo.graph.is_directed())
        self.assertEqual(len(topo.graph.nodes()) + len(topo.leaves), 1577)
        self.assertTrue(nx.is_strongly_connected(topo.graph))
        for src in topo.graph.nodes():
            for dst in topo.graph.nodes():
                self.assertEqual(topo.paths[src][dst],
                                 list(reversed(topo.paths[dst][src])))
def mcr_apx(g, upper= True, estimate_mcr = None):
    assert g.is_consistent()
    assert nx.is_strongly_connected(g)
    # mrsdfg = transform.multi_rate_equivalent(g)
    pess = transform.single_rate_apx(g, upper)
    mg = make_marked_graph( pess )
    #print("size of HSDFG: {}".format(mg.number_of_nodes()))
    try:
        ratio, cycle, _ = mcr.compute_mcr( mg, estimate = Fraction( estimate_mcr, g.tpi ) if estimate_mcr is not None else None)
    except mcr.InfeasibleException as ex:
        ratio, cycle = None, ex.cycle

    if ratio is None:
        return None, cycle
    else:
        return ratio * g.tpi, cycle
Exemple #48
0
def get_largest_component(G, strongly=False):
    """
    Return a subgraph of the largest weakly or strongly connected component
    from a directed graph.

    Parameters
    ----------
    G : networkx multidigraph
    strongly : bool
        if True, return the largest strongly instead of weakly connected
        component

    Returns
    -------
    G : networkx multidigraph
        the largest connected component subgraph from the original graph
    """

    start_time = time.time()
    original_len = len(list(G.nodes()))

    if strongly:
        # if the graph is not connected retain only the largest strongly connected component
        if not nx.is_strongly_connected(G):
            
            # get all the strongly connected components in graph then identify the largest
            sccs = nx.strongly_connected_components(G)
            largest_scc = max(sccs, key=len)
            G = induce_subgraph(G, largest_scc)
            
            msg = ('Graph was not connected, retained only the largest strongly '
                   'connected component ({:,} of {:,} total nodes) in {:.2f} seconds')
            log(msg.format(len(list(G.nodes())), original_len, time.time()-start_time))
    else:
        # if the graph is not connected retain only the largest weakly connected component
        if not nx.is_weakly_connected(G):
            
            # get all the weakly connected components in graph then identify the largest
            wccs = nx.weakly_connected_components(G)
            largest_wcc = max(wccs, key=len)
            G = induce_subgraph(G, largest_wcc)
            
            msg = ('Graph was not connected, retained only the largest weakly '
                   'connected component ({:,} of {:,} total nodes) in {:.2f} seconds')
            log(msg.format(len(list(G.nodes())), original_len, time.time()-start_time))

    return G
Exemple #49
0
def all_eulerian_cycles(g,start=None) :
    if not isinstance(g,nx.MultiDiGraph) :
        raise Exception("expect nx.MultiDiGraph")
    if not nx.euler.is_eulerian(g) :
        raise Exception("g is not eulerian")

    all_graphs = set([g])
    while True:
        tosimplify_g = next(ifilter(lambda gr : not is_simple(gr), all_graphs),None)
        if not tosimplify_g :
            break
        multivertex = next(ifilter(lambda v : in_degree(tosimplify_g,v) > 1,tosimplify_g.nodes()),None)
        assert multivertex

        for incoming in tosimplify_g.in_edges(multivertex) :
            for outgoing in tosimplify_g.out_edges(multivertex) :
                #modify simplify_g to add the bypass edge

                newvertex = Node(multivertex.kmer)
                tosimplify_g.add_edge(incoming[0],newvertex)
                tosimplify_g.add_edge(newvertex,outgoing[1])
                tosimplify_g.remove_edge(*incoming)
                tosimplify_g.remove_edge(*outgoing)

                simplified = tosimplify_g.copy()
                if nx.is_strongly_connected(simplified) :
                    all_graphs.add(simplified)
                #else :
                    #print "not sc : ", simplified.edges()

                #revert all modifications
                tosimplify_g.add_edge(*outgoing)
                tosimplify_g.add_edge(*incoming)
                tosimplify_g.remove_edge(newvertex,outgoing[1])
                tosimplify_g.remove_edge(incoming[0],newvertex)
                assert len(tosimplify_g.in_edges(newvertex)) == 0
                assert len(tosimplify_g.out_edges(newvertex)) == 0
                tosimplify_g.remove_node(newvertex)

        all_graphs.remove(tosimplify_g)

    for g in all_graphs :
        assert nx.euler.is_eulerian(g)

        start = next(ifilter(lambda n : n.start==True,g.nodes()),None)
        assert start != None
        yield nx.euler.eulerian_circuit(g,start)
Exemple #50
0
def validate_cuts(G, s, t, solnValue, partition, capacity, flow_func):
    assert_true(all(n in G for n in partition[0]),
                msg=msg.format(flow_func.__name__))
    assert_true(all(n in G for n in partition[1]),
                msg=msg.format(flow_func.__name__))
    cutset = compute_cutset(G, partition)
    assert_true(all(G.has_edge(u, v) for (u, v) in cutset),
                msg=msg.format(flow_func.__name__))
    assert_equal(solnValue, sum(G[u][v][capacity] for (u, v) in cutset),
                msg=msg.format(flow_func.__name__))
    H = G.copy()
    H.remove_edges_from(cutset)
    if not G.is_directed():
        assert_false(nx.is_connected(H), msg=msg.format(flow_func.__name__))
    else:
        assert_false(nx.is_strongly_connected(H),
                     msg=msg.format(flow_func.__name__))
def validate_ibgp(anm):
    import networkx as nx
    #TODO: repeat for ibgp v6
    #TODO: test if overlay is present, if not then warn
    if not anm.has_overlay("ibgp_v4"):
        return # no ibgp v4  - eg if ip addressing disabled

    g_ibgp_v4 = anm['ibgp_v4']

    for asn, devices in ank_utils.groupby("asn", g_ibgp_v4):
        asn_subgraph = g_ibgp_v4.subgraph(devices)
        graph = asn_subgraph._graph
        # get subgraph
        if not nx.is_strongly_connected(graph):
            g_ibgp_v4.log.warning("iBGP v4 topology for ASN%s is disconnected" % asn)
            #TODO: list connected components - but not the primary?
        else:
            g_ibgp_v4.log.debug("iBGP v4 topology for ASN%s is connected" % asn)
Exemple #52
0
    def nodes_by_eccentricity(graph):
        if len(graph) == 1:
            return graph.nodes()
# need to crop the global shortest paths otherwise get 
#NetworkXError: Graph not connected: infinite path length
        eccentricities = {}
        try:
            eccentricities = nx.eccentricity(graph)
        except nx.exception.NetworkXError:
# If not strongly connected, perform eccentricities per connected component
            if not nx.is_strongly_connected(graph):
                #TODO: provide this function inside ANK, add memoization for intensive operation
                for component_nodes in nx.strongly_connected_components(graph):
                    eccentricities.update(nx.eccentricity(graph.subgraph(component_nodes)))

# sort nodes by name, stability sort ensures that lexical order is used as tie-breaker for equal eccen.
        nodes_sorted = sorted(graph.nodes(), key = lambda x: x.fqdn)
        return sorted(nodes_sorted, key = lambda n: eccentricities[n])
    def is_connected(C):
        """
        Return `True` if the square connection matrix `C` is connected, i.e., every
        unit is reachable from every other unit, otherwise `False`.

        Note
        ----

        This function only performs the check if the NetworkX package is available:

          https://networkx.github.io/

        """
        if nx is None:
            return True

        G = nx.from_numpy_matrix(C, create_using=nx.DiGraph())
        return nx.is_strongly_connected(G)
Exemple #54
0
def is_eulerian(G):
    """Return True if G is an Eulerian graph, False otherwise.

    An Eulerian graph is a graph with an Eulerian circuit.

    Parameters
    ----------
    G : graph
       A NetworkX Graph

    Examples
    --------
    >>> nx.is_eulerian(nx.DiGraph({0:[3], 1:[2], 2:[3], 3:[0, 1]}))
    True
    >>> nx.is_eulerian(nx.complete_graph(5))
    True
    >>> nx.is_eulerian(nx.petersen_graph())
    False

    Notes
    -----
    This implementation requires the graph to be connected
    (or strongly connected for directed graphs).
    """
    if G.is_directed():
        # Every node must have equal in degree and out degree
        for n in G.nodes_iter():
            if G.in_degree(n) != G.out_degree(n):
                return False
        # Must be strongly connected
        if not nx.is_strongly_connected(G):
            return False
    else:
        # An undirected Eulerian graph has no vertices of odd degrees
        for v, d in G.degree_iter():
            if d % 2 != 0:
                return False
        # Must be connected
        if not nx.is_connected(G):
            return False
    return True
Exemple #55
0
 def test_on_directed_strongly_connected_graph(self):
     """
     Test on a small directed strongly connected graph.
     """
     # make the strongly connected directed graph:
     params_dscg = {'num_nodes': 200, 'num_edges': 1800, 'seed': 0, 
                    'directed': True}
     graph = make_graph(**params_dscg)
     assert(nx.is_strongly_connected(graph))
     # first run dijkstra_sssp
     dist, _ = dijkstra_sssp.solve(graph, source=0, weight='weight')
     # then networkx's dijkstra
     nx_dist = nx.single_source_dijkstra_path_length(graph, source=0, 
                                                     weight='weight')
     # finally, compare results
     inf = float('inf')
     for node in graph.nodes_iter():
         if dist[node] != inf:
             # node was reachable
             self.assertEqual(dist[node], nx_dist[node])
         else:
             # node was unreachable
             self.assertTrue(node not in nx_dist)
             self.assertEqual(dist[node], inf)
Exemple #56
0
def _transition_matrix(G, nodelist=None, weight='weight',
                       walk_type=None, alpha=0.95):
    """Returns the transition matrix of G.

    This is a row stochastic giving the transition probabilities while
    performing a random walk on the graph. Depending on the value of walk_type,
    P can be the transition matrix induced by a random walk, a lazy random walk,
    or a random walk with teleportation (PageRank).

    Parameters
    ----------
    G : DiGraph
       A NetworkX graph

    nodelist : list, optional
       The rows and columns are ordered according to the nodes in nodelist.
       If nodelist is None, then the ordering is produced by G.nodes().

    weight : string or None, optional (default='weight')
       The edge data key used to compute each value in the matrix.
       If None, then each edge has weight 1.

    walk_type : string or None, optional (default=None)
       If None, `P` is selected depending on the properties of the
       graph. Otherwise is one of 'random', 'lazy', or 'pagerank'

    alpha : real
       (1 - alpha) is the teleportation probability used with pagerank

    Returns
    -------
    P : NumPy array
      transition matrix of G.

    Raises
    ------
    NetworkXError
        If walk_type not specified or alpha not in valid range
    """

    import scipy as sp
    from scipy.sparse import identity, spdiags
    if walk_type is None:
        if nx.is_strongly_connected(G):
            if nx.is_aperiodic(G):
                walk_type = "random"
            else:
                walk_type = "lazy"
        else:
            walk_type = "pagerank"

    M = nx.to_scipy_sparse_matrix(G, nodelist=nodelist, weight=weight,
                                  dtype=float)
    n, m = M.shape
    if walk_type in ["random", "lazy"]:
        DI = spdiags(1.0 / sp.array(M.sum(axis=1).flat), [0], n, n)
        if walk_type == "random":
            P = DI * M
        else:
            I = identity(n)
            P = (I + DI * M) / 2.0

    elif walk_type == "pagerank":
        if not (0 < alpha < 1):
            raise nx.NetworkXError('alpha must be between 0 and 1')
        # this is using a dense representation
        M = M.todense()
        # add constant to dangling nodes' row
        dangling = sp.where(M.sum(axis=1) == 0)
        for d in dangling[0]:
            M[d] = 1.0 / n
        # normalize
        M = M / M.sum(axis=1)
        P = alpha * M + (1 - alpha) / n
    else:
        raise nx.NetworkXError("walk_type must be random, lazy, or pagerank")

    return P
Exemple #57
0
import networkx as nx

G = nx.DiGraph()

u = [0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9]
v = [1, 5, 7, 7, 8, 9, 0, 3, 3, 0, 0, 4, 8, 9, 9, 2, 5, 0, 1, 5, 3, 4, 6, 9, 2, 8, 9, 4, 6, 6, 6, 6, 3, 3, 4, 6, 7, 7, 0, 7]
w = zip (u,v)


#w = [(0,1),(0,1),(1,2),(1,3),(1,4),(1,5),(1,5),(1,6),(2,0),(2,0),(3,2),(3,2),(4,3),(4,7),(5,4),(5,9),(5,9),(6,7),(6,9),(7,3),(7,8),(8,1),(8,7),(9,6),(9,8)]

G.add_edges_from(w)

p = nx.is_strongly_connected(G)

print(p)

for i in G.edges():
    print("\n")
    for path in nx.all_simple_paths(G,source=i[0], target=i[1]):
       print(i) 
       print(path)
Exemple #58
0
	def backward_reachability(self,system,inputs,show_dfs=False,verbose=0,max_fixed_point_size=4,environment=None,plt=None):
		accepted_set = self.graph['accept']

		initial_state_found = False
		accepted_set_circled = False

		control_dict = {str(u):u for u in inputs}

		initial_control_set = set([(a,None) for a in accepted_set])
		initial_accepted_set = accepted_set
		initial_fixed_point_iterator = DijkstraFixedPoint(self,self.generate_all_predecessor_set(initial_accepted_set),initial_accepted_set)

		to_visit = collections.deque([(initial_control_set,initial_fixed_point_iterator)])

		iter_loop = 0
		while to_visit and not (initial_state_found and accepted_set_circled):
			e = to_visit[-1]

			accepted_control,fixed_point_iterator = e
			accepted_set = set([x[0] for x in accepted_control])

			if verbose==2:
				print " "*len(to_visit) + "| iter "+str(len(to_visit))


			if verbose==1:
				pass


			found,nodes = fixed_point_iterator.next_fixed_point(max_fixed_point_size)
			
			if not found:
				if len(to_visit)>1:
					to_visit.pop()
				else:
					print "No solution found"
					return

			iter_loop += 1

			if found:
				#print "."*len(accepted_set) + "|"*len(nodes)

				outgoing_edges = [(u,v) for u,l in nodes.items() for v in self.get_labelled_successors(u)[l] if v in accepted_set]
				#need_fairness = not all([u[0]==v[0] for u,v in outgoing_edges])
				need_fairness = not all([any([v[0]==u[0] for v in self.get_labelled_successors(n)[l] if (v in accepted_set) and v!=u]) for n,l in nodes.items() for u in self.get_labelled_successors(n)[l] if u not in accepted_set])
				if verbose==3:
					print "Need Fairness:",need_fairness

					if need_fairness:
						print "!!!!!!!!!!!!!!!!!!", iter_loop
				controls = [control_dict[l] for l in nodes.values()]

				sG = nx.DiGraph()
				# convert = {n:i for i,n in enumerate(nodes.keys())}
				# edges = []
				keep_edges = [(u,v)for u,l in nodes.items() if l!=None for v in self.get_labelled_successors(u)[l]]
				sG = nx.DiGraph(self.subgraph(nodes.keys()))
				sG.remove_edges_from(set(sG.edges()).difference(set(keep_edges)))

				try:
					nx.set_node_attributes(sG,'control',{n:control_dict[l] for n,l in nodes.items() if n in sG.nodes()})
				except KeyError:
					print sG.edges()
					print nodes.keys()
					raise KeyError

				# check if accepted states are accessible from every nodes:
				# print nx.is_strongly_connected(sG),self.subgraph(nodes.keys()).edges()
				if nx.is_strongly_connected(sG)==False:
					continue

				if verbose==2:
					print sG.edges(data=True)
				
				#fair_control = system.is_loop_fair(controls)
				fair_control = system.is_graph_fair(sG)

				if fair_control or need_fairness==False:
					if verbose==2:
						print "need_fairness",need_fairness,"fair_control",fair_control,[str(c) for c in controls]
						print "Add fair loop",nodes
					X = accepted_control.union(set(nodes.items()))
					node_set = [x[0] for x in X]
					Y =  self.generate_all_predecessor_set(node_set)
					it = DijkstraFixedPoint(self,Y,node_set)

					to_visit.append((X,it))

				else:
					if verbose==2:
						print "Unfair loop",controls

				new_set = accepted_set.union(set(nodes.keys()))
				if self.graph['initial'].issubset(new_set):
					initial_state_found = True
					if verbose==2:
						print "Path to initial_set found!!!!"

				cycle_accept_set = [(u,l) for u in self.graph['accept'] for l,succ in self.get_labelled_successors(u).items() if set(succ).issubset(new_set)]

				if environment:
					soluce = accepted_control.union(set(nodes.items()))
					print soluce
					node_controls = {n:(control_dict[l] if l else None) for n,l in soluce}
					environment.show_controls(plt,node_controls,"automaton/iter"+str(iter_loop)+".png")

					print "Accept cycle",len(cycle_accept_set),"Initial set found",self.graph['initial'].issubset(new_set)
					
				if cycle_accept_set and self.graph['initial'].issubset(new_set):
					soluce = accepted_control.union(set(nodes.items()))
					print "Solution found!!!"
					print sG.edges()
					break

				if verbose==0:
					sys.stdout.write(str(len(accepted_set)) +"/" +str(len(nodes)) + "\t" + str(iter_loop)+'\r')
					sys.stdout.flush()


				if show_dfs:
					c = {n:"red" for n in accepted_set}
					c.update({n:"green" for n in nodes})
					ec = {e:"red" for e in [(u,v) for u,l in accepted_control if l!=None for v in self.get_labelled_successors(u)[l]]}
					ec.update( {e:"blue" for e in [(u,v) for u,l in nodes.items() if l!=None for v in self.get_labelled_successors(u)[l]]} )
					self.show("buchi",colors=c,edges_color=ec)
					raw_input()


		print len(to_visit)
		if verbose==3:
			G = copy.deepcopy(self)
			keep_edges = [(u,v)for u,l in nodes.items() if l!=None for v in self.get_labelled_successors(u)[l]]
			keep_nodes = [n for e in keep_edges for n in e]
			print keep_nodes
			G.remove_nodes_from(list(set(G.nodes()).difference(set(keep_nodes))))
			G.remove_edges_from(list(set(G.edges()).difference(set(keep_edges))))
			G.graph['accept'] = G.graph['accept'].intersection(set(keep_nodes))
			G.graph['initial'] = G.graph['initial'].intersection(set(keep_nodes))
			c = {n:"red" for n in accepted_set.intersection(set(keep_nodes))}
			c.update({n:"green" for n in set(nodes.keys()).intersection(set(keep_nodes))})
			ec = {e:"blue" for e in [(u,v) for u,l in nodes.items() if l!=None for v in self.get_labelled_successors(u)[l]] if e in keep_edges}

			G.show("buchi",colors=c,edges_color=ec)


		cycle_accept_set = [(u,l) for u in self.graph['accept'] for l,succ in self.get_labelled_successors(u).items() if set(succ).issubset(new_set)]
		if verbose==2:
			print cycle_accept_set
		solution = {u:l for u,l in soluce}
		for u,l in cycle_accept_set:
			solution[u] = l
		if verbose==2:
			print solution


		plan = copy.deepcopy(self)
		for n,l in solution.items():
			plan.remove_labeled_edge_except(n,l)
		#plan.show("plan_all")
		plan.remove_ambiguites()
		plan.minimize()

		# plan.show("plan2")
		# return 

		if verbose==2:
			print self.graph['initial']

		nx.set_node_attributes(plan,"apply_control",None)
		control = nx.get_node_attributes(plan,"apply_control")
		for n in plan.nodes():
			c = list(plan.get_successor_labels(n))
			if len(c)==0:
				print "Control not found:", n, s
			else:
				s = c[0]
				if len(c)!=1:
					print "Too many controls",n,c
					s = c[0] 
			control[n] = control_dict[s]

		nx.set_node_attributes(plan,"apply_control",control)

		return plan
 def test_is_strongly_connected(self):
     for G, C in self.gc:
         if len(C) == 1:
             assert_true(nx.is_strongly_connected(G))
         else:
             assert_false(nx.is_strongly_connected(G))