| """Generators - Directed Graphs |
| ---------------------------- |
| """ |
|
|
| import pytest |
|
|
| import networkx as nx |
| from networkx.classes import Graph, MultiDiGraph |
| from networkx.generators.directed import ( |
| gn_graph, |
| gnc_graph, |
| gnr_graph, |
| random_k_out_graph, |
| random_uniform_k_out_graph, |
| scale_free_graph, |
| ) |
|
|
|
|
| class TestGeneratorsDirected: |
| def test_smoke_test_random_graphs(self): |
| gn_graph(100) |
| gnr_graph(100, 0.5) |
| gnc_graph(100) |
| scale_free_graph(100) |
|
|
| gn_graph(100, seed=42) |
| gnr_graph(100, 0.5, seed=42) |
| gnc_graph(100, seed=42) |
| scale_free_graph(100, seed=42) |
|
|
| def test_create_using_keyword_arguments(self): |
| pytest.raises(nx.NetworkXError, gn_graph, 100, create_using=Graph()) |
| pytest.raises(nx.NetworkXError, gnr_graph, 100, 0.5, create_using=Graph()) |
| pytest.raises(nx.NetworkXError, gnc_graph, 100, create_using=Graph()) |
| G = gn_graph(100, seed=1) |
| MG = gn_graph(100, create_using=MultiDiGraph(), seed=1) |
| assert sorted(G.edges()) == sorted(MG.edges()) |
| G = gnr_graph(100, 0.5, seed=1) |
| MG = gnr_graph(100, 0.5, create_using=MultiDiGraph(), seed=1) |
| assert sorted(G.edges()) == sorted(MG.edges()) |
| G = gnc_graph(100, seed=1) |
| MG = gnc_graph(100, create_using=MultiDiGraph(), seed=1) |
| assert sorted(G.edges()) == sorted(MG.edges()) |
|
|
| G = scale_free_graph( |
| 100, |
| alpha=0.3, |
| beta=0.4, |
| gamma=0.3, |
| delta_in=0.3, |
| delta_out=0.1, |
| initial_graph=nx.cycle_graph(4, create_using=MultiDiGraph), |
| seed=1, |
| ) |
| pytest.raises(ValueError, scale_free_graph, 100, 0.5, 0.4, 0.3) |
| pytest.raises(ValueError, scale_free_graph, 100, alpha=-0.3) |
| pytest.raises(ValueError, scale_free_graph, 100, beta=-0.3) |
| pytest.raises(ValueError, scale_free_graph, 100, gamma=-0.3) |
|
|
| def test_parameters(self): |
| G = nx.DiGraph() |
| G.add_node(0) |
|
|
| def kernel(x): |
| return x |
|
|
| assert nx.is_isomorphic(gn_graph(1), G) |
| assert nx.is_isomorphic(gn_graph(1, kernel=kernel), G) |
| assert nx.is_isomorphic(gnc_graph(1), G) |
| assert nx.is_isomorphic(gnr_graph(1, 0.5), G) |
|
|
|
|
| def test_scale_free_graph_negative_delta(): |
| with pytest.raises(ValueError, match="delta_in must be >= 0."): |
| scale_free_graph(10, delta_in=-1) |
| with pytest.raises(ValueError, match="delta_out must be >= 0."): |
| scale_free_graph(10, delta_out=-1) |
|
|
|
|
| def test_non_numeric_ordering(): |
| G = MultiDiGraph([("a", "b"), ("b", "c"), ("c", "a")]) |
| s = scale_free_graph(3, initial_graph=G) |
| assert len(s) == 3 |
| assert len(s.edges) == 3 |
|
|
|
|
| @pytest.mark.parametrize("ig", (nx.Graph(), nx.DiGraph([(0, 1)]))) |
| def test_scale_free_graph_initial_graph_kwarg(ig): |
| with pytest.raises(nx.NetworkXError): |
| scale_free_graph(100, initial_graph=ig) |
|
|
|
|
| class TestRandomKOutGraph: |
| """Unit tests for the |
| :func:`~networkx.generators.directed.random_k_out_graph` function. |
| |
| """ |
|
|
| def test_regularity(self): |
| """Tests that the generated graph is `k`-out-regular.""" |
| n = 10 |
| k = 3 |
| alpha = 1 |
| G = random_k_out_graph(n, k, alpha) |
| assert all(d == k for v, d in G.out_degree()) |
| G = random_k_out_graph(n, k, alpha, seed=42) |
| assert all(d == k for v, d in G.out_degree()) |
|
|
| def test_no_self_loops(self): |
| """Tests for forbidding self-loops.""" |
| n = 10 |
| k = 3 |
| alpha = 1 |
| G = random_k_out_graph(n, k, alpha, self_loops=False) |
| assert nx.number_of_selfloops(G) == 0 |
|
|
| def test_negative_alpha(self): |
| with pytest.raises(ValueError, match="alpha must be positive"): |
| random_k_out_graph(10, 3, -1) |
|
|
|
|
| class TestUniformRandomKOutGraph: |
| """Unit tests for the |
| :func:`~networkx.generators.directed.random_uniform_k_out_graph` |
| function. |
| |
| """ |
|
|
| def test_regularity(self): |
| """Tests that the generated graph is `k`-out-regular.""" |
| n = 10 |
| k = 3 |
| G = random_uniform_k_out_graph(n, k) |
| assert all(d == k for v, d in G.out_degree()) |
| G = random_uniform_k_out_graph(n, k, seed=42) |
| assert all(d == k for v, d in G.out_degree()) |
|
|
| def test_no_self_loops(self): |
| """Tests for forbidding self-loops.""" |
| n = 10 |
| k = 3 |
| G = random_uniform_k_out_graph(n, k, self_loops=False) |
| assert nx.number_of_selfloops(G) == 0 |
| assert all(d == k for v, d in G.out_degree()) |
|
|
| def test_with_replacement(self): |
| n = 10 |
| k = 3 |
| G = random_uniform_k_out_graph(n, k, with_replacement=True) |
| assert G.is_multigraph() |
| assert all(d == k for v, d in G.out_degree()) |
| n = 10 |
| k = 9 |
| G = random_uniform_k_out_graph(n, k, with_replacement=False, self_loops=False) |
| assert nx.number_of_selfloops(G) == 0 |
| assert all(d == k for v, d in G.out_degree()) |
|
|
| def test_without_replacement(self): |
| n = 10 |
| k = 3 |
| G = random_uniform_k_out_graph(n, k, with_replacement=False) |
| assert not G.is_multigraph() |
| assert all(d == k for v, d in G.out_degree()) |
|
|
