コード例 #1
0
 def setup_class(cls):
     cls.P4 = nx.path_graph(4)
     cls.K3 = nx.complete_bipartite_graph(3, 3)
     cls.C4 = nx.cycle_graph(4)
     cls.davis = nx.davis_southern_women_graph()
     cls.top_nodes = [n for n, d in cls.davis.nodes(data=True)
                       if d['bipartite'] == 0]
コード例 #2
0
 def setUp(self):
     self.P4 = nx.path_graph(4)
     self.K3 = nx.complete_bipartite_graph(3, 3)
     self.C4 = nx.cycle_graph(4)
     self.davis = nx.davis_southern_women_graph()
     self.top_nodes = [
         n for n, d in self.davis.nodes(data=True) if d['bipartite'] == 0
     ]
コード例 #3
0
def A2():
    G = nx.davis_southern_women_graph()
    degree_sequence = sorted([d for n, d in G.degree()])
    degree_count = {
        x: degree_sequence.count(x)
        for x in range(max(degree_sequence) + 1)
    }
    return (list(degree_count.keys()), list(degree_count.values()))
コード例 #4
0
 def setup_class(cls):
     cls.Gnp = nx.gnp_random_graph(20, 0.8)
     cls.Anp = _AntiGraph(nx.complement(cls.Gnp))
     cls.Gd = nx.davis_southern_women_graph()
     cls.Ad = _AntiGraph(nx.complement(cls.Gd))
     cls.Gk = nx.karate_club_graph()
     cls.Ak = _AntiGraph(nx.complement(cls.Gk))
     cls.GA = [(cls.Gnp, cls.Anp), (cls.Gd, cls.Ad), (cls.Gk, cls.Ak)]
コード例 #5
0
ファイル: networkxdata.py プロジェクト: luerhard/pyintergraph
def nx_test_graphs():
    yield nxg_gnp_random(directed=True)
    yield nxg_gnp_random(directed=False)
    yield nx.karate_club_graph()
    yield nx.davis_southern_women_graph()
    yield named_graph(directed=False, multigraph=False)
    yield named_graph(directed=False, multigraph=True)
    yield named_graph(directed=True, multigraph=False)
    yield named_graph(directed=True, multigraph=True)
コード例 #6
0
 def setUp(self):
     self.Gnp = nx.gnp_random_graph(20, 0.8)
     self.Anp = _AntiGraph(nx.complement(self.Gnp))
     self.Gd = nx.davis_southern_women_graph()
     self.Ad = _AntiGraph(nx.complement(self.Gd))
     self.Gk = nx.karate_club_graph()
     self.Ak = _AntiGraph(nx.complement(self.Gk))
     self.GA = [(self.Gnp, self.Anp), (self.Gd, self.Ad),
                (self.Gk, self.Ak)]
コード例 #7
0
ファイル: test_gomory_hu.py プロジェクト: Cold5nap/sobolIter
 def test_davis_southern_women_graph(self):
     G = nx.davis_southern_women_graph()
     nx.set_edge_attributes(G, 1, "capacity")
     for flow_func in flow_funcs:
         T = nx.gomory_hu_tree(G, flow_func=flow_func)
         assert nx.is_tree(T)
         for u, v in combinations(G, 2):
             cut_value, edge = self.minimum_edge_weight(T, u, v)
             assert nx.minimum_cut_value(G, u, v) == cut_value
コード例 #8
0
ファイル: test_gomory_hu.py プロジェクト: aparamon/networkx
 def test_davis_southern_women_graph(self):
     G = nx.davis_southern_women_graph()
     nx.set_edge_attributes(G, 1, 'capacity')
     for flow_func in flow_funcs:
         T = nx.gomory_hu_tree(G, flow_func=flow_func)
         assert_true(nx.is_tree(T))
         for u, v in combinations(G, 2):
             cut_value, edge = self.minimum_edge_weight(T, u, v)
             assert_equal(nx.minimum_cut_value(G, u, v),
                          cut_value)
コード例 #9
0
 def setUp(self):
     self.Gnp = nx.gnp_random_graph(20, 0.8)
     self.Anp = _AntiGraph(nx.complement(self.Gnp))
     self.Gd = nx.davis_southern_women_graph()
     self.Ad = _AntiGraph(nx.complement(self.Gd))
     self.Gk = nx.karate_club_graph()
     self.Ak = _AntiGraph(nx.complement(self.Gk))
     self.GA = [(self.Gnp, self.Anp),
                (self.Gd, self.Ad),
                (self.Gk, self.Ak)]
コード例 #10
0
def socialnetwork_graphs():
    print("Social networks")
    print("karate club graph")
    G = nx.karate_club_graph()
    draw_graph(G)
    print("Davis Southern women bipartite graph ")
    G = nx.davis_southern_women_graph()
    draw_graph(G)
    print("Florentine families graph ")
    G = nx.florentine_families_graph()
    draw_graph(G)
コード例 #11
0
def test(graph="barbell", algorithm="o_fl", k=-1, v=False, kmin=3, kmax=5):
    """Runs a quic demo
       graph = 'karate', 'barbell', 'women', 'florentine'
         if not a specific graph it will be used as a seed for a random graph
       
       algorithm as
         'fl' = async fluid detection, requires k
         'o_fl' = optimizing fl, requires kmin and kmax
         'gn' = garvin_newman
       
       k = number of communities to look for if applicable
       v = verbose flag
    """
    #generate demo graph
    G = 0
    if graph == "karate":
        G = nx.karate_club_graph()
    elif graph == "barbell":
        G = nx.barbell_graph(5, 1)
    elif graph == "women":
        G = nx.davis_southern_women_graph()
    elif graph == "florentine":
        G = nx.florentine_families_graph()
    else:
        G = nx.planted_partition_graph(5, 10, .85, .1, seed=graph)
    #switch on algorithm
    bestcom = 0

    if algorithm == "fl":
        if k != -1:
            bestcom = async_fluid(G, k)
        else:
            bestcom = async_fluid(G)
    elif algorithm == "o_fl":  #optimized fl
        bestcom = opt_async_fluid(G, kmin, kmax)
    elif algorithm == "gn":
        bestcom = girvan_newman(G, v)

    #Label the data and export in gephi readable format
    comlabel = 1
    for c in bestcom:
        for n in c:
            G.node[n]['community'] = str(comlabel)
        comlabel += 1

    rw.write_file(G, "test.gexf")
コード例 #12
0
def GraphType(num_nodes, str, p=0.05, m=3):
    """
    :param num_nodes: the number of nodes of the graph (if that option is available)
    :param str: the type of graph that is used. We have
                'erdos'         an erdos renyi graph
                'powerlaw'      a graph with powerlaw degree distribution
                'enron'         a social network graph loaded from
                                http://snap.stanford.edu/data/email-Enron.html. (36692 nodes)
                'karateclub'    some karate club graph
                'women'         women social network
    :return: the graph
    """
    if str == 'erdos':
        graph = nx.erdos_renyi_graph(num_nodes, p)
    elif str == 'powerlaw':
        graph = nx.powerlaw_cluster_graph(num_nodes, m, p)
    elif str == 'enron':
        graph = nx.Graph()
        edges = np.loadtxt('Enron.txt',skiprows=4)
        graph.add_edges_from(edges)
    elif str == 'karateclub':
        graph = nx.karate_club_graph()
    elif str == 'women':
        graph = nx.davis_southern_women_graph()
    elif str == 'pair':
        graph = nx.DiGraph()
        graph.add_edge(0,1)
        graph.add_edge(1,0)
    elif str == 'star':
        graph = nx.star_graph(num_nodes)
    elif str == 'cycle':
        graph = nx.cycle_graph(num_nodes)
    elif str == 'config':
        max_degree = int(num_nodes/5)
        #Create some degrees
        degrees = np.asarray(np.round(np.exp(np.log(max_degree) * np.random.uniform(size=num_nodes))), np.int)
        #Ensure the total number of degrees is even
        if sum(degrees) % 2 != 0:
            degrees[np.random.randint(num_nodes)] += 2 * np.random.randint(2) - 1
        #Create a graph and apply the configuration model
        graph = nx.Graph()
        graph = nx.configuration_model(degrees, graph)
        graph = graph.to_directed()

    return graph
コード例 #13
0
    def _define_graph(self, n_mpi_process):
        # define the graph.
        graph = networkx.davis_southern_women_graph()

        # get the mixing matrix.
        mixing_matrix = networkx.adjacency_matrix(graph).toarray().astype(
            np.float)

        degrees = mixing_matrix.sum(axis=1)
        for node in np.argsort(degrees)[::-1]:
            mixing_matrix[:,
                          node][mixing_matrix[:,
                                              node] == 1] = 1.0 / degrees[node]
            mixing_matrix[node, :][mixing_matrix[node, :] ==
                                   1] = 1.0 / degrees[node]
            mixing_matrix[node, node] = (1 - np.sum(mixing_matrix[node, :]) +
                                         mixing_matrix[node, node])
        return mixing_matrix
コード例 #14
0
ファイル: topologies.py プロジェクト: epfml/powergossip
    def __init__(self, num_workers):
        super().__init__(num_workers)
        assert num_workers == 32

        graph = networkx.davis_southern_women_graph()

        # get the mixing matrix.
        mixing_matrix = networkx.adjacency_matrix(graph).toarray().astype(np.float)

        degrees = mixing_matrix.sum(axis=1) + 1.0  # different from Koloskova et al.
        for node in np.argsort(degrees)[::-1]:
            mixing_matrix[:, node][mixing_matrix[:, node] == 1] = 1.0 / degrees[node]
            mixing_matrix[node, :][mixing_matrix[node, :] == 1] = 1.0 / degrees[node]
            mixing_matrix[node, node] = (
                1 - np.sum(mixing_matrix[node, :]) + mixing_matrix[node, node]
            )

        self.diffusion_matrix = mixing_matrix
        self.name = f"Davis southern women graph"
コード例 #15
0
def test_generalized_similarity():
    """
    Calculate the generalized similarities between events and women 
    in the "classical" Southern Women graph.
    """

    graph = nx.davis_southern_women_graph()
    women, events, eps, iters = generalized.generalized_similarity(graph)

    print("Number of iterations:", iters)
    print("Attained precision:", eps)
    print("Event network:", len(events), "nodes")
    print("Least similar events:", 
          sorted(events.edges(data=True), key=lambda x: x[2]['weight'])[0][0:2])
    print("Women network:", len(women), "nodes")
    print("Least similar women:", 
          sorted(women.edges(data=True), key=lambda x: x[2]['weight'])[0][0:2])
    with open("examples/women.graphml","wb") as ofile:
        nx.write_graphml(women, ofile)
    with open("examples/events.graphml","wb") as ofile:
        nx.write_graphml(events, ofile)
コード例 #16
0
def generate_networks(io_h):
    # Dictionary for storing networks with names for dataset
    list_of_networks = {}
    n_nodes = 1000
    n_edges = np.arange(1, 5, 1)
    connection_probs = np.arange(0.5, 0.7, 0.1)

    processed_networks = io_h.get_ignore_list()

    print('Generating Famous social networks')
    # Append famous social networks to list
    n_name = 'kartae_club'
    if n_name not in processed_networks:
        list_of_networks[n_name] = nx.karate_club_graph()
    n_name = 'davis_southern_women_graph'
    if n_name not in processed_networks:
        list_of_networks[n_name] = nx.davis_southern_women_graph()
    n_name = 'florentine_families_graph'
    if n_name not in processed_networks:
        list_of_networks[n_name] = nx.florentine_families_graph()

    print('Generating Barabasi network')
    for connection in n_edges:
        # Append Barabasi Graph
        n_name = '_'.join(['barabasi_albert_graph', str(connection)])
        if n_name not in processed_networks:
            print('Generating ', n_name)
            list_of_networks[n_name] = nx.barabasi_albert_graph(
                n_nodes, connection)

    print('Generating Random Networks')
    # Generate random networks with connection probabilities
    for con_prob in connection_probs:
        n_name = '_'.join(['erdos_renyi_graph', '{:.1f}'.format(con_prob)])
        if n_name not in processed_networks:
            print('Generating {}'.format(n_name))
            list_of_networks[n_name] = nx.erdos_renyi_graph(n_nodes, con_prob)
    print('Finished Generating Networks')
    return list_of_networks
def main():
    g = nx.Graph()
    nodes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,32]
    edges= [(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 10), (1, 2), (1, 3), (1, 7),
            (2, 3), (2, 32), (2, 7), (2, 8), (2, 9),(3, 7),(4, 10), (4, 6),(5, 10), (5, 6)]
    g.add_nodes_from(nodes)
    g.add_edges_from(edges)
    source = 0
    
    #the default method delivered from the networkx
    print list(nx.bfs_edges(g,0))
    
    #call to the bfs
    final_edges = bfs(g,source)
    display_graph(final_edges)
    print "bfs done"
    #Call to the pivot random walk
    pivot_random_walk(g,source,20)
    print "pivot random done"
    #Call to the pivot random walk
    g= nx.davis_southern_women_graph()
    weighted_independence(g,25)
    print "completion"
コード例 #18
0
ファイル: test_kcomponents.py プロジェクト: Harshi3030/algos
def test_davis_southern_women_detail_3_and_4():
    solution = {
        3: [
            {
                'Nora Fayette',
                'E10',
                'Myra Liddel',
                'E12',
                'E14',
                'Frances Anderson',
                'Evelyn Jefferson',
                'Ruth DeSand',
                'Helen Lloyd',
                'Eleanor Nye',
                'E9',
                'E8',
                'E5',
                'E4',
                'E7',
                'E6',
                'E1',
                'Verne Sanderson',
                'E3',
                'E2',
                'Theresa Anderson',
                'Pearl Oglethorpe',
                'Katherina Rogers',
                'Brenda Rogers',
                'E13',
                'Charlotte McDowd',
                'Sylvia Avondale',
                'Laura Mandeville',
            },
        ],
        4: [
            {
                'Nora Fayette',
                'E10',
                'Verne Sanderson',
                'E12',
                'Frances Anderson',
                'Evelyn Jefferson',
                'Ruth DeSand',
                'Helen Lloyd',
                'Eleanor Nye',
                'E9',
                'E8',
                'E5',
                'E4',
                'E7',
                'E6',
                'Myra Liddel',
                'E3',
                'Theresa Anderson',
                'Katherina Rogers',
                'Brenda Rogers',
                'Charlotte McDowd',
                'Sylvia Avondale',
                'Laura Mandeville',
            },
        ],
    }
    G = nx.davis_southern_women_graph()
    result = nx.k_components(G)
    for k, components in result.items():
        if k < 3:
            continue
        assert_true(len(components) == len(solution[k]))
        for component in components:
            assert_true(component in solution[k])
コード例 #19
0
ファイル: test_kcomponents.py プロジェクト: Harshi3030/algos
def test_davis_southern_women():
    G = nx.davis_southern_women_graph()
    result = nx.k_components(G)
    _check_connectivity(G, result)
コード例 #20
0
ファイル: dwc10.py プロジェクト: yasasp/Dwave-Challenges
# BusBar500kV, 31-Mar-2019
# D-Wave Challenge 10

import networkx as nx
import dwave_networkx as dnx
from dwave.system.composites import EmbeddingComposite
from dwave.system.samplers import DWaveSampler

problem10 = [(nx.florentine_families_graph(),
              'families in Renaissance-era Florence'),
             (nx.karate_club_graph(), 'Karate club'),
             (nx.davis_southern_women_graph(), 'Davis Southern women graph')]
for G, text in problem10:
    shots = 1000
    number_of_rounds = 10
    min_max_cut_set = []
    for n in range(number_of_rounds):
        sampler = EmbeddingComposite(DWaveSampler())
        max_cut = dnx.maximum_cut(G, sampler, num_reads=shots)
        min_max_cut_set.append(min(len(max_cut), len(set(G) - set(max_cut))))
    print('Max Cut for %s graph is %s.' % (text, min(min_max_cut_set)))
コード例 #21
0
ファイル: test_kcomponents.py プロジェクト: 4c656554/networkx
def test_davis_southern_women_detail_3_and_4():
    solution = {
        3: [{
            'Nora Fayette',
            'E10',
            'Myra Liddel',
            'E12',
            'E14',
            'Frances Anderson',
            'Evelyn Jefferson',
            'Ruth DeSand',
            'Helen Lloyd',
            'Eleanor Nye',
            'E9',
            'E8',
            'E5',
            'E4',
            'E7',
            'E6',
            'E1',
            'Verne Sanderson',
            'E3',
            'E2',
            'Theresa Anderson',
            'Pearl Oglethorpe',
            'Katherina Rogers',
            'Brenda Rogers',
            'E13',
            'Charlotte McDowd',
            'Sylvia Avondale',
            'Laura Mandeville',
            },
        ],
        4: [{
            'Nora Fayette',
            'E10',
            'Verne Sanderson',
            'E12',
            'Frances Anderson',
            'Evelyn Jefferson',
            'Ruth DeSand',
            'Helen Lloyd',
            'Eleanor Nye',
            'E9',
            'E8',
            'E5',
            'E4',
            'E7',
            'E6',
            'Myra Liddel',
            'E3',
            'Theresa Anderson',
            'Katherina Rogers',
            'Brenda Rogers',
            'Charlotte McDowd',
            'Sylvia Avondale',
            'Laura Mandeville',
            },
        ],
    }
    G = nx.davis_southern_women_graph()
    result = nx.k_components(G)
    for k, components in result.items():
        if k < 3:
            continue
        assert_true(len(components) == len(solution[k]))
        for component in components:
            assert_true(component in solution[k])
コード例 #22
0
def test_biconnected_davis():
    D = nx.davis_southern_women_graph()
    bcc = list(nx.biconnected_components(D))[0]
    assert_true(set(D) == bcc)  # All nodes in a giant bicomponent
    # So no articulation points
    assert_equal(len(list(nx.articulation_points(D))), 0)
コード例 #23
0
def gen_laplacian(data_num=DATA_NUM, opt=27, cache=False):
    label = None

    if cache:
        print('Loading cached graph')
        graph = pk.load(open('tmp/g.pk', 'rb'))
    else:
        print('Generating graph opt {}'.format(opt))

        if 1 == opt:
            graph = gen_rand_graph(data_num=data_num)
        if 2 == opt:
            top_num = random.randint(1, data_num)
            bottom_num = data_num - top_num
            graph = nx.bipartite.random_graph(top_num, bottom_num, 0.9)
            label = [d['bipartite'] for n, d in graph.nodes(data=True)]
        elif 3 == opt:
            graph = nx.balanced_tree(4, 5)
        elif 4 == opt:
            graph = nx.complete_graph(data_num)
        elif 5 == opt:
            no1 = random.randint(1, data_num)
            no2 = random.randint(1, int(data_num / no1))
            no3 = data_num / no1 / no2
            graph = nx.complete_multipartite_graph(no1, no2, no3)
        elif 6 == opt:
            graph = nx.circular_ladder_graph(data_num)
        elif 7 == opt:
            graph = nx.cycle_graph(data_num)
        elif 8 == opt:
            graph = nx.dorogovtsev_goltsev_mendes_graph(5)
        elif 9 == opt:
            top_num = int(random.random() * data_num)
            bottom_num = data_num / top_num
            graph = nx.grid_2d_graph(top_num, bottom_num)
        elif 10 == opt:
            no1 = random.randint(1, data_num)
            no2 = random.randint(1, int(data_num / no1))
            no3 = data_num / no1 / no2
            graph = nx.grid_graph([no1, no2, no3])
        elif 11 == opt:
            graph = nx.hypercube_graph(10)
        elif 12 == opt:
            graph = nx.ladder_graph(data_num)
        elif 13 == opt:
            top_num = int(random.random() * data_num)
            bottom_num = data_num - top_num
            graph = nx.lollipop_graph(top_num, bottom_num)
        elif 14 == opt:
            graph = nx.path_graph(data_num)
        elif 15 == opt:
            graph = nx.star_graph(data_num)
        elif 16 == opt:
            graph = nx.wheel_graph(data_num)
        elif 17 == opt:
            graph = nx.margulis_gabber_galil_graph(35)
        elif 18 == opt:
            graph = nx.chordal_cycle_graph(data_num)
        elif 19 == opt:
            graph = nx.fast_gnp_random_graph(data_num, random.random())
        elif 20 == opt:  # jump eigen value
            graph = nx.gnp_random_graph(data_num, random.random())
        elif 21 == opt:  # disconnected graph
            graph = nx.dense_gnm_random_graph(data_num, data_num / 2)
        elif 22 == opt:  # disconnected graph
            graph = nx.gnm_random_graph(data_num, data_num / 2)
        elif 23 == opt:
            graph = nx.erdos_renyi_graph(data_num, data_num / 2)
        elif 24 == opt:
            graph = nx.binomial_graph(data_num, data_num / 2)
        elif 25 == opt:
            graph = nx.newman_watts_strogatz_graph(data_num, 5,
                                                   random.random())
        elif 26 == opt:
            graph = nx.watts_strogatz_graph(data_num, 5, random.random())
        elif 26 == opt:  # smooth eigen
            graph = nx.connected_watts_strogatz_graph(data_num, 5,
                                                      random.random())
        elif 27 == opt:  # smooth eigen
            graph = nx.random_regular_graph(5, data_num)
        elif 28 == opt:  # smooth eigen
            graph = nx.barabasi_albert_graph(data_num, 5)
        elif 29 == opt:  # smooth eigen
            graph = nx.powerlaw_cluster_graph(data_num, 5, random.random())
        elif 30 == opt:  # smooth eigen
            graph = nx.duplication_divergence_graph(data_num, random.random())
        elif 31 == opt:
            p = random.random()
            q = random.random()
            graph = nx.random_lobster(data_num, p, q)
        elif 32 == opt:
            p = random.random()
            q = random.random()
            k = random.random()

            graph = nx.random_shell_graph([(data_num / 3, 50, p),
                                           (data_num / 3, 40, q),
                                           (data_num / 3, 30, k)])
        elif 33 == opt:  # smooth eigen
            top_num = int(random.random() * data_num)
            bottom_num = data_num - top_num
            graph = nx.k_random_intersection_graph(top_num, bottom_num, 3)
        elif 34 == opt:
            graph = nx.random_geometric_graph(data_num, .1)
        elif 35 == opt:
            graph = nx.waxman_graph(data_num)
        elif 36 == opt:
            graph = nx.geographical_threshold_graph(data_num, .5)
        elif 37 == opt:
            top_num = int(random.random() * data_num)
            bottom_num = data_num - top_num
            graph = nx.uniform_random_intersection_graph(
                top_num, bottom_num, .5)

        elif 39 == opt:
            graph = nx.navigable_small_world_graph(data_num)
        elif 40 == opt:
            graph = nx.random_powerlaw_tree(data_num, tries=200)
        elif 41 == opt:
            graph = nx.karate_club_graph()
        elif 42 == opt:
            graph = nx.davis_southern_women_graph()
        elif 43 == opt:
            graph = nx.florentine_families_graph()
        elif 44 == opt:
            graph = nx.complete_multipartite_graph(data_num, data_num,
                                                   data_num)

        # OPT 1
        # norm_lap = nx.normalized_laplacian_matrix(graph).toarray()

        # OPT 2: renormalized

        # pk.dump(graph, open('tmp/g.pk', 'wb'))

    # plot_graph(graph, label)
    # note difference: normalized laplacian and normalzation by eigenvalue
    norm_lap, eigval, eigvec = normalize_lap(graph)

    return graph, norm_lap, eigval, eigvec
コード例 #24
0
def test_davis_southern_women():
    G = nx.davis_southern_women_graph()
    result = nx.k_components(G)
    _check_connectivity(G, result)
コード例 #25
0
import networkx as nx
import matplotlib.pylab as plt
from plot_multigraph import plot_multigraph

graphs = [
  ('karate_club_graph', nx.karate_club_graph()),
  ('davis_southern_women_graph', nx.davis_southern_women_graph()),
  ('florentine_families_graph', nx.florentine_families_graph()),
]

plot_multigraph(graphs, 2, 2, node_size=50)
plt.savefig('graphs/social.png')
コード例 #26
0
def test_ra_clustering_davis():
    G = nx.davis_southern_women_graph()
    cc4 = round(bipartite.robins_alexander_clustering(G), 3)
    assert_equal(cc4, 0.468)
コード例 #27
0
def create_example_viz(filename):
    filename = ensure_html_filename(filename)

    graph = nx.davis_southern_women_graph()
    create_viz_html(graph, filename)
コード例 #28
0
ファイル: test_cluster.py プロジェクト: ProgVal/networkx
def test_ra_clustering_davis():
    G = nx.davis_southern_women_graph()
    cc4 = round(bipartite.robins_alexander_clustering(G), 3)
    assert_equal(cc4, 0.468)
コード例 #29
0
ファイル: test_dag.py プロジェクト: aparamon/networkx
def test_is_aperiodic_bipartite():
    # Bipartite graph
    G = nx.DiGraph(nx.davis_southern_women_graph())
    assert_false(nx.is_aperiodic(G))
コード例 #30
0
ファイル: antigraph.py プロジェクト: rvu95/networkx
        adj_iter : iterator
           An iterator of (node, adjacency set) for all nodes in
           the graph.

        """
        for n in self.adj:
            yield (n, set(self.adj) - set(self.adj[n]) - set([n]))


if __name__ == '__main__':
    # Build several pairs of graphs, a regular graph
    # and the AntiGraph of it's complement, which behaves
    # as if it were the original graph.
    Gnp = nx.gnp_random_graph(20,0.8)
    Anp = AntiGraph(nx.complement(Gnp))
    Gd = nx.davis_southern_women_graph()
    Ad = AntiGraph(nx.complement(Gd))
    Gk = nx.karate_club_graph()
    Ak = AntiGraph(nx.complement(Gk))
    pairs = [(Gnp, Anp), (Gd, Ad), (Gk, Ak)]
    # test connected components
    for G, A in pairs:
        gc = [set(c) for c in nx.connected_components(G)]
        ac = [set(c) for c in nx.connected_components(A)]
        for comp in ac:
            assert comp in gc
    # test biconnected components
    for G, A in pairs:
        gc = [set(c) for c in nx.biconnected_components(G)]
        ac = [set(c) for c in nx.biconnected_components(A)]
        for comp in ac:
コード例 #31
0
def test_davis_southern_women():
    G = nx.davis_southern_women_graph()
    _check_connectivity(G)
コード例 #32
0
==========

Davis Southern Club Women

Shows how to make unipartite projections of the graph and compute the
properties of those graphs.

These data were collected by Davis et al. in the 1930s.
They represent observed attendance at 14 social events by 18 Southern women.
The graph is bipartite (clubs, women).
"""
import matplotlib.pyplot as plt
import networkx as nx
import networkx.algorithms.bipartite as bipartite

G = nx.davis_southern_women_graph()
women = G.graph['top']
clubs = G.graph['bottom']

print("Biadjacency tar_matrix")
print(bipartite.biadjacency_matrix(G, women, clubs))

# project bipartite graph onto women nodes
W = bipartite.projected_graph(G, women)
print('')
print("#Friends, Member")
for w in women:
    print('%d %s' % (W.degree(w), w))

# project bipartite graph onto women nodes keeping number of co-occurence
# the degree computed is weighted and counts the total number of shared contacts
コード例 #33
0
ファイル: test_biconnected.py プロジェクト: NikitaVAP/pycdb
def test_biconnected_davis():
    D = nx.davis_southern_women_graph()
    bcc = list(biconnected.biconnected_components(D))[0]
    assert_true(set(D) == bcc) # All nodes in a giant bicomponent
    # So no articulation points
    assert_equal(list(biconnected.articulation_points(D)),[])
コード例 #34
0
ファイル: test_kcomponents.py プロジェクト: 4c656554/networkx
def test_davis_southern_women():
    G = nx.davis_southern_women_graph()
    _check_connectivity(G)
コード例 #35
0
def test_davis_southern_women_detail_3_and_4():
    solution = {
        3: [{
            "Nora Fayette",
            "E10",
            "Myra Liddel",
            "E12",
            "E14",
            "Frances Anderson",
            "Evelyn Jefferson",
            "Ruth DeSand",
            "Helen Lloyd",
            "Eleanor Nye",
            "E9",
            "E8",
            "E5",
            "E4",
            "E7",
            "E6",
            "E1",
            "Verne Sanderson",
            "E3",
            "E2",
            "Theresa Anderson",
            "Pearl Oglethorpe",
            "Katherina Rogers",
            "Brenda Rogers",
            "E13",
            "Charlotte McDowd",
            "Sylvia Avondale",
            "Laura Mandeville",
        }],
        4: [{
            "Nora Fayette",
            "E10",
            "Verne Sanderson",
            "E12",
            "Frances Anderson",
            "Evelyn Jefferson",
            "Ruth DeSand",
            "Helen Lloyd",
            "Eleanor Nye",
            "E9",
            "E8",
            "E5",
            "E4",
            "E7",
            "E6",
            "Myra Liddel",
            "E3",
            "Theresa Anderson",
            "Katherina Rogers",
            "Brenda Rogers",
            "Charlotte McDowd",
            "Sylvia Avondale",
            "Laura Mandeville",
        }],
    }
    G = nx.davis_southern_women_graph()
    result = nx.k_components(G)
    for k, components in result.items():
        if k < 3:
            continue
        assert len(components) == len(solution[k])
        for component in components:
            assert component in solution[k]
コード例 #36
0
def test_is_aperiodic_bipartite():
    # Bipartite graph
    G = nx.DiGraph(nx.davis_southern_women_graph())
    assert not nx.is_aperiodic(G)
コード例 #37
0
import networkx as nx
import matplotlib.pylab as plt
from plot_multigraph import plot_multigraph

graphs = [
    ('karate_club_graph', nx.karate_club_graph()),
    ('davis_southern_women_graph', nx.davis_southern_women_graph()),
    ('florentine_families_graph', nx.florentine_families_graph()),
]

plot_multigraph(graphs, 2, 2, node_size=50)
plt.savefig('graphs/social.png')
コード例 #38
-1
 def setUp(self):
     self.P4 = nx.path_graph(4)
     self.K3 = nx.complete_bipartite_graph(3,3)
     self.C4 = nx.cycle_graph(4)
     self.davis = nx.davis_southern_women_graph()
     self.top_nodes = [n for n,d in self.davis.nodes(data=True) 
                       if d['bipartite']==0]