def test_only_critical(self):
        # tests only critical vertices in form of trees, paths and stars,
        # expected the algorithm correctly augments G and the augmenting set
        # cardinality correspond the simple bound on Eswaran-Tarjan.
        D: nx.DiGraph = nx.DiGraph()

        nx.add_star(D, {i for i in range(1, 5)})
        nx.add_path(D, {i for i in range(5, 10)})
        D.add_nodes_from({i for i in range(10, 20)})

        G, A, M = D_to_bipartite(D)
        assert_true(is_correctly_augmented(G, A))
        sources, sinks, isolated = get_sources_sinks_isolated(D)
        s, t, q = len(sources), len(sinks), len(isolated)
        L = bipartite_matching_augmentation(G, A)
        assert_equal(len(L), max(s, t) + q)

        D.clear()
        D = nx.balanced_tree(2, 13, nx.DiGraph())
        D.remove_node(0)
        G, A, M = D_to_bipartite(D)
        sources, sinks, isolated = get_sources_sinks_isolated(D)
        s, t, q = len(sources), len(sinks), len(isolated)
        for i in range(1):
            L = bipartite_matching_augmentation(G, A)
        assert_true(is_correctly_augmented(G, A, L))
        assert_equal(len(L), max(s, t) + q)
Example #2
0
def topology():
    """
    Function used for create new Graph.
    Execute this func first.
    """
    try:
        attr = param()
        core_nodes = attr['core_nodes']
        total_ce = attr['total_ce']
        total_rr = attr['total_rr']
        sum_nodes = attr['sum_nodes']
        ls = attr['ls']
        if total_ce > 0:
            nodes_ce = sorted(
                map(lambda x: 'CE{}'.format(x), range(0, total_ce)))
        #Generate nodes with name 'RX', where X is serial number
        nodes = sorted(map(lambda x: 'R{}'.format(x), range(0, core_nodes)))
        # Peers for CE nodes
        pe_peers = random.sample(nodes, total_ce)
        if total_rr > 0:
            pe_peers = random.sample(nodes[1:], total_ce)
            G = nx.DiGraph(name='Network topology - Star')
            nx.add_star(G, nodes)
            gen_edge(G, nodes, total_rr, core_nodes, pe_peers, sum_nodes,
                     total_ce, nodes_ce, ls)
        else:
            G = nx.complete_graph(core_nodes)
            gen_edge(G, nodes, total_rr, core_nodes, pe_peers, sum_nodes,
                     total_ce, nodes_ce, ls)
        return G
    except AddressValueError as value_error:
        print('Error: {}'.format(value_error))
    except ZeroDivisionError:
        print('Not valid core_nodes. Allowed  maximum 16 nodes!')
    def setUp(self):
        self.partitions = []

        graph = nx.Graph()
        nx.add_star(graph, range(20))
        nx.add_path(graph, range(10))
        self.partitions.append(
            NxPartitionGraphBased(
                graph, representation={node: node % 6
                                       for node in graph}))

        graph = nx.DiGraph()
        nx.add_star(graph, range(20))
        nx.add_path(graph, range(10))
        self.partitions.append(
            NxPartitionGraphBased(
                graph, representation={node: node % 6
                                       for node in graph}))

        self.uniform_icl_ex = IntegratedCompleteLikelihoodExact(
            is_directed=False,
            hyperprior=IntegratedCompleteLikelihoodExact.UNIFORM_HYPERPRIOR)

        self.jeffrey_icl_ex = IntegratedCompleteLikelihoodExact(
            is_directed=False,
            hyperprior=IntegratedCompleteLikelihoodExact.JEFFREY_HYPERPRIOR)
Example #4
0
 def test_star(self):
     """Closeness centrality: star """
     G = nx.Graph()
     nx.add_star(G, ['a', 'b', 'c', 'd'])
     b = nx.current_flow_closeness_centrality(G)
     b_answer = {'a': 1.0 / 3, 'b': 0.6 / 3, 'c': 0.6 / 3, 'd': 0.6 / 3}
     for n in sorted(G):
         assert almost_equal(b[n], b_answer[n])
Example #5
0
 def test_star(self):
     """Betweenness centrality: star """
     G = nx.Graph()
     nx.add_star(G, ['a', 'b', 'c', 'd'])
     b = nx.current_flow_betweenness_centrality(G, normalized=True)
     b_answer = {'a': 1.0, 'b': 0.0, 'c': 0.0, 'd': 0.0}
     for n in sorted(G):
         assert_almost_equal(b[n], b_answer[n])
 def test_star(self):
     """Closeness centrality: star"""
     G = nx.Graph()
     nx.add_star(G, ["a", "b", "c", "d"])
     b = nx.current_flow_closeness_centrality(G)
     b_answer = {"a": 1.0 / 3, "b": 0.6 / 3, "c": 0.6 / 3, "d": 0.6 / 3}
     for n in sorted(G):
         assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
 def test_star(self):
     """Betweenness centrality: star """
     G = nx.Graph()
     nx.add_star(G, ["a", "b", "c", "d"])
     b = nx.current_flow_betweenness_centrality_subset(G, list(G), list(G), normalized=True)
     b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
     for n in sorted(G):
         assert_almost_equal(b[n], b_answer[n])
 def test_star(self):
     """Closeness centrality: star """
     G = nx.Graph()
     nx.add_star(G, ["a", "b", "c", "d"])
     b = nx.current_flow_closeness_centrality(G)
     b_answer = {"a": 1.0 / 3, "b": 0.6 / 3, "c": 0.6 / 3, "d": 0.6 / 3}
     for n in sorted(G):
         assert almost_equal(b[n], b_answer[n])
 def test_star(self):
     """Betweenness centrality: star"""
     G = nx.Graph()
     nx.add_star(G, ["a", "b", "c", "d"])
     b = nx.current_flow_betweenness_centrality(G, normalized=True)
     b_answer = {"a": 1.0, "b": 0.0, "c": 0.0, "d": 0.0}
     for n in sorted(G):
         assert almost_equal(b[n], b_answer[n])
 def test_star(self):
     """Closeness centrality: star """
     G=nx.Graph()
     nx.add_star(G, ['a', 'b', 'c', 'd'])
     b=nx.current_flow_closeness_centrality(G)
     b_answer={'a': 1.0/3, 'b': 0.6/3, 'c': 0.6/3, 'd':0.6/3}
     for n in sorted(G):
         assert_almost_equal(b[n],b_answer[n])
Example #11
0
 def test_star(self):
     """Betweenness centrality: star"""
     G = nx.Graph()
     nx.add_star(G, ["a", "b", "c", "d"])
     b = nx.current_flow_betweenness_centrality(G, normalized=True)
     b_answer = {"a": 1.0, "b": 0.0, "c": 0.0, "d": 0.0}
     for n in sorted(G):
         assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
 def test_star(self):
     """Betweenness centrality: star """
     G=nx.Graph()
     nx.add_star(G, ['a', 'b', 'c', 'd'])
     b=nx.current_flow_betweenness_centrality(G,normalized=True)
     b_answer={'a': 1.0, 'b': 0.0, 'c': 0.0, 'd':0.0}
     for n in sorted(G):
         assert_almost_equal(b[n],b_answer[n])
 def test_star(self):
     "Approximate current-flow betweenness centrality: star"
     G = nx.Graph()
     nx.add_star(G, ["a", "b", "c", "d"])
     b = nx.current_flow_betweenness_centrality(G, normalized=True)
     epsilon = 0.1
     ba = approximate_cfbc(G, normalized=True, epsilon=0.5 * epsilon)
     for n in sorted(G):
         np.testing.assert_allclose(b[n], ba[n], atol=epsilon)
def mindrevosod(n):
    graf = nx.Graph()
    graf.add_nodes_from([i for i in range(n)])
    graf.add_edge(0, n // 2)
    sez1 = [i for i in range(n // 2)]
    sez2 = [i for i in range(n // 2, n)]
    nx.add_star(graf, sez1)
    nx.add_star(graf, sez2)
    return graf
 def test_star(self):
     "Approximate current-flow betweenness centrality: star"
     G=nx.Graph()
     nx.add_star(G, ['a', 'b', 'c', 'd'])
     b=nx.current_flow_betweenness_centrality(G,normalized=True)
     epsilon=0.1
     ba = approximate_cfbc(G,normalized=True, epsilon=0.5*epsilon)
     for n in sorted(G):
         assert_allclose(b[n],ba[n],atol=epsilon)
 def test_star(self):
     """Betweenness centrality: star """
     G = nx.Graph()
     nx.add_star(G, ['a', 'b', 'c', 'd'])
     b = nx.current_flow_betweenness_centrality_subset(G,
                                                       list(G),
                                                       list(G),
                                                       normalized=True)
     b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
     for n in sorted(G):
         assert almost_equal(b[n], b_answer[n])
Example #17
0
 def test_add_star(self):
     G = self.G.copy()
     nlist = [12, 13, 14, 15]
     nx.add_star(G, nlist)
     assert_edges_equal(G.edges(nlist), [(12, 13), (12, 14), (12, 15)])
     G = self.G.copy()
     nx.add_star(G, nlist, weight=2.0)
     assert_edges_equal(G.edges(nlist, data=True),
                        [(12, 13, {'weight': 2.}),
                         (12, 14, {'weight': 2.}),
                         (12, 15, {'weight': 2.})])
Example #18
0
 def test_add_star(self):
     G = self.G.copy()
     nlist = [12, 13, 14, 15]
     nx.add_star(G, nlist)
     assert_edges_equal(G.edges(nlist), [(12, 13), (12, 14), (12, 15)])
     G = self.G.copy()
     nx.add_star(G, nlist, weight=2.0)
     assert_edges_equal(G.edges(nlist, data=True),
                        [(12, 13, {'weight': 2.}),
                         (12, 14, {'weight': 2.}),
                         (12, 15, {'weight': 2.})])
Example #19
0
def starTopology(G, nodes, number_of_rr, logical_system):
    """
    Function used for create Graph of type a star.
    """
    nx.add_star(G, nodes)
    loopbacks = net.genNet()
    #get loopback address for nodes
    loaddress = loopbacks.pop(0)    
    # set loopback addres for RR
    nx.set_node_attributes(G, {'R0': {'type':'Route-Reflector', 'loopback': loaddress}}) 
    # set loopback addres for other nodes
    [*map(lambda node: nx.set_node_attributes(G, {node: {'loopback':loaddress}}),nodes[1:])] 
    genEdge(G, nodes, logical_system)
    return G
Example #20
0
    def test_add_star(self):
        G = self.G.copy()
        nlist = [12, 13, 14, 15]
        nx.add_star(G, nlist)
        assert edges_equal(G.edges(nlist), [(12, 13), (12, 14), (12, 15)])

        G = self.G.copy()
        nx.add_star(G, nlist, weight=2.0)
        assert edges_equal(
            G.edges(nlist, data=True),
            [
                (12, 13, {
                    "weight": 2.0
                }),
                (12, 14, {
                    "weight": 2.0
                }),
                (12, 15, {
                    "weight": 2.0
                }),
            ],
        )

        G = self.G.copy()
        nlist = [12]
        nx.add_star(G, nlist)
        assert nodes_equal(G, list(self.G) + nlist)

        G = self.G.copy()
        nlist = []
        nx.add_star(G, nlist)
        assert nodes_equal(G.nodes, self.Gnodes)
        assert edges_equal(G.edges, self.G.edges)
    def setUp(self):
        self.partitions = []

        graph = nx.Graph()
        nx.add_star(graph, range(20))
        nx.add_path(graph, range(10))
        self.partitions.append(NxPartitionGraphBased(graph, representation={node: node % 6 for node in graph}))

        graph = nx.DiGraph()
        nx.add_star(graph, range(20))
        nx.add_path(graph, range(10))
        self.partitions.append(NxPartitionGraphBased(graph, representation={node: node % 6 for node in graph}))

        self.non_degree_corrected = NewmanReinertNonDegreeCorrected(is_directed=False)

        self.degree_corrected = NewmanReinertDegreeCorrected(is_directed=False)
Example #22
0
    def setUp(self):
        self.graphs = []

        graph = nx.Graph()
        nx.add_path(graph, range(4))
        self.graphs.append(graph)

        graph = nx.Graph()
        nx.add_path(graph, range(10))
        self.graphs.append(graph)

        graph = nx.DiGraph()
        nx.add_star(graph, range(4))
        self.graphs.append(graph)

        graph = nx.DiGraph()
        nx.add_star(graph, range(10))
        self.graphs.append(graph)

        graph = nx.karate_club_graph()
        self.graphs.append(graph)

        self.block_sizes = [2, 4, 2, 4, 3]

        self.partitions = [
            NxPartition(graph,
                        representation={
                            node: node % self.block_sizes[i]
                            for node in graph
                        }) for i, graph in enumerate(self.graphs)
        ]

        self.representations = [{
            node: node % self.block_sizes[i]
            for node in graph
        } for i, graph in enumerate(self.graphs)]
        self.is_directed = [graph.is_directed() for graph in self.graphs]
        self.nodes = [len(graph.nodes) for graph in self.graphs]
        self.edges = [len(graph.edges) for graph in self.graphs]
Example #23
0
def example_networkx():
    G = networkx.Graph()
    networkx.add_star(G, [0, 1, 2, 3, 4])
    networkx.add_path(G, [4, 5, 6, 7, 8])
    networkx.add_star(G, [8, 9, 10, 11, 12])
    networkx.add_path(G, [6, 13, 14, 15])
    networkx.add_star(G, [15, 16, 17, 18])
    return G
Example #24
0
File: docs.py Project: twosigma/nxv
def build_logo():
    shutil.rmtree("docs/_static/logo", ignore_errors=True)
    os.makedirs("docs/_static/logo", exist_ok=True)
    graph = nx.Graph()
    nx.add_path(graph, [0, 1, 2, 3, 4, 5, 0])
    nx.add_star(graph, [6, 0, 1, 2, 3, 4, 5])
    style = nxv.Style(
        graph={
            "pad": 1 / 8,
            "bgcolor": "#00000000",
            "size": "1,1",
            "ratio": 1,
        },
        node=lambda u, d: {
            "shape": "circle",
            "label": None,
            "width": 3 / 4,
            "style": "filled",
            "fillcolor": "#009AA6" if u % 2 else "#E37222",
            "penwidth": 5,
        },
        edge={"penwidth": 5},
    )
    path = "docs/_static/logo/logo.svg"
    LOGGER.info(f"Rendering {path}")
    with open(path, "wb") as f:
        f.write(nxv.render(graph, style, algorithm="neato", format="svg"))
    for size in [16, 32, 40, 48, 64, 128, 256]:
        style_with_dpi = nxv.compose([style, nxv.Style(graph={"dpi": size})])
        path = f"docs/_static/logo/logo-{size}.png"
        LOGGER.info(f"Rendering {path}")
        with open(path, "wb") as f:
            f.write(
                nxv.render(graph,
                           style_with_dpi,
                           algorithm="neato",
                           format="png"))
    def setUp(self):
        if self.is_directed:
            self.weighted_graph = nx.DiGraph()
        else:
            self.weighted_graph = nx.Graph()

        nx.add_star(self.weighted_graph, range(5))
        nx.add_path(self.weighted_graph, range(4, 10))
        # add a selfloop
        self.weighted_graph.add_edge(4, 4)

        self.covariate_graph = self.weighted_graph.copy()

        for from_node in self.weighted_graph:
            for to_node in self.weighted_graph:
                if self.weighted_graph.has_edge(from_node, to_node):
                    self.weighted_graph[from_node][to_node][
                        "weight"] = from_node + to_node
                    self.covariate_graph[from_node][to_node][
                        "covariate"] = from_node + to_node

        representation = {node: node % 3 for node in self.weighted_graph}
        self.weighted_partition = self.comparision_class(
            self.weighted_graph,
            representation=representation,
            weighted_graph=True)
        self.covariate_partition = self.test_class(
            self.covariate_graph,
            weighted_graph=False,
            with_covariate=True,
            representation=representation)

        self.unweighted_partition = self.comparision_class(
            self.weighted_graph,
            representation=representation,
            weighted_graph=False)
Example #26
0
    def remove_edges_from(self, ebunch):
        for e in ebunch:
            u, v = e[0:2]
            self.remove_edge(u, v)

    def clear(self):
        super().clear()
        self.fh.write("Clear graph\n")


G = PrintGraph()
G.add_node("foo")
G.add_nodes_from("bar", weight=8)
G.remove_node("b")
G.remove_nodes_from("ar")
print("Nodes in G: ", G.nodes(data=True))
G.add_edge(0, 1, weight=10)
print("Edges in G: ", G.edges(data=True))
G.remove_edge(0, 1)
G.add_edges_from(zip(range(0, 3), range(1, 4)), weight=10)
print("Edges in G: ", G.edges(data=True))
G.remove_edges_from(zip(range(0, 3), range(1, 4)))
print("Edges in G: ", G.edges(data=True))

G = PrintGraph()
nx.add_path(G, range(10))
nx.add_star(G, range(9, 13))
pos = nx.spring_layout(G, seed=225)  # Seed for reproducible layout
nx.draw(G, pos)
plt.show()
Example #27
0
    def __init__(self):
        self.pandemic = nx.Graph()
        self.blueCities = ["San Francisco", "Chicago", "Montreal", "New York", "Atlanta", "Washington", "London", "Madrid", "Essen", "Paris", "Milan", "St. Petersburg"]
        self.yellowCities = ["Los Angeles", "Mexico City", "Miami", "Bogota", "Lima", "Santiago", "Buenos Aires", "Sao Paulo", "Lagos", "Kinshasa", "Johannesburg", "Khartoum"]
        self.blackCities = ["Algiers", "Istanbul", "Cairo", "Moscow", "Baghdad", "Riyadh", "Tehran", "Karachi", "Mumbai", "Delhi", "Chennai", "Kolkata"]
        self.redCities = ["Bangkok", "Jakarta", "Beijing", "Shanghai", "Hong Kong", "Ho Chi Minh City", "Seoul", "Taipei", "Manila", "Sydney", "Tokyo", "Osaka"]
        
        self.pandemic.add_nodes_from(self.blueCities, color="blue", cubes=0)
        self.pandemic.add_nodes_from(self.yellowCities, color="yellow", cubes=0)
        self.pandemic.add_nodes_from(self.blackCities, color="black", cubes=0)
        self.pandemic.add_nodes_from(self.redCities, color="red", cubes=0)

        nx.add_star(self.pandemic, ["San Francisco", "Tokyo", "Manila", "Los Angeles", "Chicago"])
        nx.add_star(self.pandemic, ["Chicago", "San Francisco", "Los Angeles", "Mexico City", "Atlanta", "Montreal"])
        nx.add_star(self.pandemic, ["Montreal", "Chicago", "Washington", "New York"])
        nx.add_star(self.pandemic, ["New York", "Montreal", "Washington", "London", "Madrid"])
        nx.add_star(self.pandemic, ["Atlanta", "Chicago", "Washington", "Miami"])
        nx.add_star(self.pandemic, ["Washington", "Miami", "Atlanta", "Montreal", "New York"])
        nx.add_star(self.pandemic, ["London", "New York", "Madrid", "Paris", "Essen"])
        nx.add_star(self.pandemic, ["Madrid", "Washington", "London", "Paris", "Algiers", "Sao Paulo"])
        nx.add_star(self.pandemic, ["Essen", "London", "Paris", "Milan", "St. Petersburg"])
        nx.add_star(self.pandemic, ["Paris", "London", "Madrid", "Algiers", "Milan", "Essen"])
        nx.add_star(self.pandemic, ["Milan", "Essen", "Paris", "Istanbul"])
        nx.add_star(self.pandemic, ["St. Petersburg", "Essen", "Istanbul", "Moscow"])

        nx.add_star(self.pandemic, ["Los Angeles", "Sydney", "San Francisco", "Chicago", "Mexico City"])
        nx.add_star(self.pandemic, ["Mexico City", "Los Angeles", "Chicago", "Miami", "Bogota", "Lima"])
        nx.add_star(self.pandemic, ["Miami", "Atlanta", "Washington", "Bogota", "Mexico City"])
        nx.add_star(self.pandemic, ["Bogota", "Mexico City", "Miami", "Sao Paulo", "Buenos Aires", "Lima"])
        nx.add_star(self.pandemic, ["Lima", "Mexico City", "Bogota", "Santiago"])
        nx.add_star(self.pandemic, ["Santiago", "Lima", "Buenos Aires"])
        nx.add_star(self.pandemic, ["Buenos Aires", "Santiago", "Bogota", "Sao Paulo"])
        nx.add_star(self.pandemic, ["Sao Paulo", "Bogota", "Buenos Aires", "Madrid", "Lagos"])
        nx.add_star(self.pandemic, ["Lagos", "Sao Paulo", "Kinshasa", "Khartoum"])
        nx.add_star(self.pandemic, ["Kinshasa", "Lagos", "Johannesburg", "Khartoum"])
        nx.add_star(self.pandemic, ["Johannesburg", "Kinshasa", "Khartoum"])
        nx.add_star(self.pandemic, ["Khartoum", "Lagos", "Kinshasa", "Johannesburg", "Cairo"])

        nx.add_star(self.pandemic, ["Algiers", "Madrid", "Paris", "Istanbul", "Cairo"])
        nx.add_star(self.pandemic, ["Istanbul", "Milan", "St. Petersburg", "Moscow", "Baghdad", "Cairo", "Algiers"])
        nx.add_star(self.pandemic, ["Cairo", "Algiers", "Istanbul", "Baghdad", "Riyadh"])
        nx.add_star(self.pandemic, ["Moscow", "St. Petersburg", "Tehran", "Istanbul"])
        nx.add_star(self.pandemic, ["Baghdad", "Istanbul", "Cairo", "Riyadh", "Karachi", "Tehran"])
        nx.add_star(self.pandemic, ["Algiers", "Cairo", "Baghdad", "Karachi"])
        nx.add_star(self.pandemic, ["Tehran", "Moscow", "Delhi", "Karachi", "Baghdad"])
        nx.add_star(self.pandemic, ["Karachi", "Tehran", "Delhi", "Mumbai", "Riyadh", "Baghdad"])
        nx.add_star(self.pandemic, ["Mumbai", "Karachi", "Delhi", "Chennai"])
        nx.add_star(self.pandemic, ["Delhi", "Tehran", "Karachi", "Mumbai", "Chennai", "Kolkata"])
        nx.add_star(self.pandemic, ["Chennai", "Mumbai", "Delhi", "Kolkata", "Bangkok", "Jakarta"])
        nx.add_star(self.pandemic, ["Kolkata", "Delhi", "Chennai", "Bangkok", "Hong Kong"])

        nx.add_star(self.pandemic, ["Bangkok", "Chennai", "Kolkata", "Hong Kong", "Ho Chi Minh City", "Jakarta"])
        nx.add_star(self.pandemic, ["Jakarta", "Chennai", "Bangkok", "Ho Chi Minh City", "Sydney"])
        nx.add_star(self.pandemic, ["Beijing", "Seoul", "Shanghai"])
        nx.add_star(self.pandemic, ["Shanghai", "Beijing", "Seoul", "Tokyo", "Taipei", "Hong Kong"])
        nx.add_star(self.pandemic, ["Hong Kong", "Shanghai", "Taipei", "Manila", "Ho Chi Minh City", "Bangkok", "Kolkata"])
        nx.add_star(self.pandemic, ["Ho Chi Minh City", "Bangkok", "Hong Kong", "Manila", "Jakarta"])
        nx.add_star(self.pandemic, ["Seoul", "Beijing", "Shanghai", "Tokyo"])
        nx.add_star(self.pandemic, ["Taipei", "Bangkok", "Hong Kong", "Manila", "Osaka"])
        nx.add_star(self.pandemic, ["Manila", "Taipei", "Hong Kong", "Ho Chi Minh City", "Sydney", "San Francisco"])
        nx.add_star(self.pandemic, ["Sydney", "Jakarta", "Manila", "Los Angeles"])
        nx.add_star(self.pandemic, ["Tokyo", "Seoul", "Shanghai", "Osaka", "San Francisco"])
        nx.add_star(self.pandemic, ["Osaka", "Taipei", "Tokyo"])

        #Freezes the board, so no more nodes or edges can be added to the graph
        nx.freeze(self.pandemic)

        self.outbreakCounter = 0
Example #28
0
    def remove_edges_from(self, ebunch):
        for e in ebunch:
            u, v = e[0:2]
            self.remove_edge(u, v)

    def clear(self):
        Graph.clear(self)
        self.fh.write("Clear graph\n")


if __name__ == '__main__':
    G = PrintGraph()
    G.add_node('foo')
    G.add_nodes_from('bar', weight=8)
    G.remove_node('b')
    G.remove_nodes_from('ar')
    print("Nodes in G: ", G.nodes(data=True))
    G.add_edge(0, 1, weight=10)
    print("Edges in G: ", G.edges(data=True))
    G.remove_edge(0, 1)
    G.add_edges_from(zip(range(0, 3), range(1, 4)), weight=10)
    print("Edges in G: ", G.edges(data=True))
    G.remove_edges_from(zip(range(0, 3), range(1, 4)))
    print("Edges in G: ", G.edges(data=True))

    G = PrintGraph()
    nx.add_path(G, range(10))
    nx.add_star(G, range(9, 13))
    nx.draw(G)
    plt.show()
Example #29
0
G.add_node(1)                
G.add_nodes_from([3, 4, 5])

# 辺の追加 (頂点も必要に応じて追加されます)
G.add_edge(1, 2)                                    
G.add_edges_from([(1, 3), (2, 5), (3, 4), (4, 5)])

# 辺の削除
G.remove_edge(3, 4)                    
G.remove_edges_from([(1, 3), (2, 5)])

# 頂点の削除 (削除された頂点に接続されている辺も削除されます)
G.remove_node(5)
G.remove_nodes_from([3, 4])

# 指定したパス上の頂点と辺を追加
nx.add_path(G, [1, 2, 3, 4, 5])  # 1 → 2 → 3 → 4 → 5

# 指定した閉路上の頂点と辺を追加
nx.add_cycle(G, [1, 2, 3, 4, 5])  # 1 → 2 → 3 → 4 → 5 → 1

# 放射状に頂点と辺を追加
nx.add_star(G, [1, 2, 3, 4, 5])  # 1 → 2, 1 → 3, 1 → 4, 1 → 5

import networkx as nx

G = nx.DiGraph()
nx.add_path(G, [3, 5, 4, 1, 0, 2, 7, 8, 9, 6])
nx.add_path(G, [3, 0, 6, 4, 2, 7, 1, 9, 8, 5])

nx.nx_agraph.view_pygraphviz(G, prog='fdp')  # pygraphvizが必要
Example #30
0
def plot(matchers,strings,matcher_names=None,ax=None):
    """
    Plots strings and their parent groups for multiple matchers as a graph, with
    groups represented as nodes that connect strings

    Arguments:
    matchers -- a matcher or list of matchers to plot
    strings  -- a string or list of strings to plot (all connected strings will
                also be plotted)
    matcher_names -- (optional) a list of strings to label matchers in the plot
                     legend
    ax -- (optional) a matplotlib axis object to draw the plot on.
    """
    if isinstance(matchers,Matcher):
        matchers = [matchers]

    if isinstance(strings,str):
        strings = [strings]

    if not matcher_names:
        matcher_names = [f'matcher{i}' for i in range(len(matchers))]
    elif not (len(matcher_names) == len(matchers)):
        raise ValueError('matcher_names must be the same length as matchers')

    varname = lambda x: f'{x=}'.split('=')[0]

    # First build graph representation of the parent groups
    G = nx.Graph()
    for i,matcher in enumerate(matchers):
        m_groups = set(matcher[strings])
        for g in m_groups:
            group_node = f'{matcher_names[i]}: {g}'
            string_nodes = matcher.groups[g]
            G.add_nodes_from(string_nodes,type='string',color='w')
            if len(string_nodes) > 1:
                G.add_nodes_from([group_node],type='group',color=f'C{i}',label=group_node)
                nx.add_star(G,[group_node] + string_nodes,color=f'C{i}')

    # Now plot graph components in a grid
    components = sorted(nx.connected_components(G),key=len,reverse=True)

    n_grid = int(np.ceil(np.sqrt(len(components))))
    grid_xy = [(x,-y) for y in range(n_grid) for x in range(n_grid)]

    if ax is None:
        fig, ax = plt.subplots()

    for i,component in enumerate(components):
        G_sub = G.subgraph(component)

        x0,y0 = grid_xy[i]

        # Position nodes
        if len(component) > 1:
            pos = nx.random_layout(G_sub)
            pos = nx.kamada_kawai_layout(G_sub,pos=pos,scale=0.25)
            pos = {n:(x0+x,y0+y) for n,(x,y) in pos.items()}
        else:
            pos = {list(component)[0]:(x0,y0)}

        edges = list(G_sub.edges(data=True))

        edge_coord = [[pos[n0],pos[n1]] for n0,n1,d in edges]
        edge_colors = [mplt.colors.to_rgba(d['color']) for n0,n1,d in edges]

        lc = mplt.collections.LineCollection(edge_coord,color=edge_colors,zorder=0)

        ax.add_collection(lc)

        for node,d in G_sub.nodes(data=True):
            x,y = pos[node]
            if d['type'] == 'group':
                ax.scatter(x,y,color=mplt.colors.to_rgb(d['color']),label=d['label'],s=50,zorder=2)
            else:
                ax.scatter(x,y,color='w',s=200,zorder=1)
                ax.text(x,y,node,ha='center',va='center',zorder=3)

    ax.axis('off')

    legend_handles = [mplt.lines.Line2D([],[],color=mplt.colors.to_rgb(f'C{i}'),markersize=15,marker='.',label=f'{name}')
                        for i,name in enumerate(matcher_names)]
    plt.legend(handles=legend_handles,
                bbox_to_anchor=(0.5,-0.2),loc='lower center',
                ncol=3,borderaxespad=0)

    return ax