def setup_class(cls):
G = nx.DiGraph()
edges = [
(1, 2),
(1, 3),
(2, 4),
(3, 2),
(3, 5),
(4, 2),
(4, 5),
(4, 6),
(5, 6),
(5, 7),
(5, 8),
(6, 8),
(7, 1),
(7, 5),
(7, 8),
(8, 6),
(8, 7),
]
G.add_edges_from(edges, weight=2.0)
cls.G = G.reverse()
cls.G.alpha = 0.1
cls.G.evc = [
0.3289589783189635,
0.2832077296243516,
0.3425906003685471,
0.3970420865198392,
0.41074871061646284,
0.272257430756461,
0.4201989685435462,
0.34229059218038554,
]
H = nx.DiGraph(edges)
cls.H = G.reverse()
cls.H.alpha = 0.1
cls.H.evc = [
0.3289589783189635,
0.2832077296243516,
0.3425906003685471,
0.3970420865198392,
0.41074871061646284,
0.272257430756461,
0.4201989685435462,
0.34229059218038554,
]
def test_k5(self):
G = nx.complete_graph(5, create_using=nx.DiGraph())
assert list(nx.clustering(G, weight="weight").values()) == [1, 1, 1, 1, 1]
assert nx.average_clustering(G, weight="weight") == 1
G.remove_edge(1, 2)
assert list(nx.clustering(G, weight="weight").values()) == [
11.0 / 12.0,
1.0,
1.0,
11.0 / 12.0,
11.0 / 12.0,
]
assert nx.clustering(G, [1, 4], weight="weight") == {1: 1.0, 4: 11.0 / 12.0}
G.remove_edge(2, 1)
assert list(nx.clustering(G, weight="weight").values()) == [
5.0 / 6.0,
1.0,
1.0,
5.0 / 6.0,
5.0 / 6.0,
]
assert nx.clustering(G, [1, 4], weight="weight") == {
1: 1.0,
4: 0.83333333333333337,
}
def setup_method(cls):
G = nx.Graph()
G.add_nodes_from([0, 1], fish='one')
G.add_nodes_from([2, 3], fish='two')
G.add_nodes_from([4], fish='red')
G.add_nodes_from([5], fish='blue')
G.add_edges_from([(0, 1), (2, 3), (0, 4), (2, 5)])
cls.G = G
D = nx.DiGraph()
D.add_nodes_from([0, 1], fish='one')
D.add_nodes_from([2, 3], fish='two')
D.add_nodes_from([4], fish='red')
D.add_nodes_from([5], fish='blue')
D.add_edges_from([(0, 1), (2, 3), (0, 4), (2, 5)])
cls.D = D
S = nx.Graph()
S.add_nodes_from([0, 1], fish='one')
S.add_nodes_from([2, 3], fish='two')
S.add_nodes_from([4], fish='red')
S.add_nodes_from([5], fish='blue')
S.add_edge(0, 0)
S.add_edge(2, 2)
cls.S = S
def test_path(self):
G = nx.path_graph(10, create_using=nx.DiGraph())
assert list(nx.clustering(G).values()) == [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
]
assert nx.clustering(G) == {
0: 0.0,
1: 0.0,
2: 0.0,
3: 0.0,
4: 0.0,
5: 0.0,
6: 0.0,
7: 0.0,
8: 0.0,
9: 0.0,
}
def test_disconnected_graph():
# https://github.com/networkx/networkx/issues/1144
G = nx.Graph()
G.add_edges_from([(0, 1), (1, 2), (2, 0), (3, 4)])
assert not nx.is_tree(G)
G = nx.DiGraph()
G.add_edges_from([(0, 1), (1, 2), (2, 0), (3, 4)])
assert not nx.is_tree(G)
def setup_class(cls):
cls.G = nx.path_graph(9)
cls.DG = nx.path_graph(9, create_using=nx.DiGraph())
cls.Gv = nx.to_undirected(cls.DG)
cls.DGv = nx.to_directed(cls.G)
cls.Rv = cls.DG.reverse()
cls.graphs = [cls.G, cls.DG, cls.Gv, cls.DGv, cls.Rv]
for G in cls.graphs:
G.edges, G.nodes, G.degree
def test_directed_find_cores(self):
"""core number had a bug for directed graphs found in issue #1959"""
# small example where too timid edge removal can make cn[2] = 3
G = nx.DiGraph()
edges = [(1, 2), (2, 1), (2, 3), (2, 4), (3, 4), (4, 3)]
G.add_edges_from(edges)
assert nx.core_number(G) == {1: 2, 2: 2, 3: 2, 4: 2}
# small example where too aggressive edge removal can make cn[2] = 2
more_edges = [(1, 5), (3, 5), (4, 5), (3, 6), (4, 6), (5, 6)]
G.add_edges_from(more_edges)
assert nx.core_number(G) == {1: 3, 2: 3, 3: 3, 4: 3, 5: 3, 6: 3}
def setup_class(cls):
cls.NXGraph = nx.DiGraph
data_dir = os.path.expandvars("${GS_TEST_DIR}/ldbc_sample")
cls.single_label_g = ldbc_sample_single_label(data_dir, True)
cls.multi_label_g = ldbc_sample_multi_labels(data_dir, True)
cls.duplicated_oid_g = ldbc_sample_with_duplicated_oid(data_dir, True)
# FIXME: this is tricky way to create a str gs graph
les_g = nx.les_miserables_graph()
di_les_g = nx.DiGraph()
di_les_g.add_edges_from(di_les_g.edges.data())
cls.str_oid_g = g(di_les_g)
def gnm_random_graph(n, m, seed=None, directed=False):
"""Returns a $G_{n,m}$ random graph.
In the $G_{n,m}$ model, a graph is chosen uniformly at random from the set
of all graphs with $n$ nodes and $m$ edges.
This algorithm should be faster than :func:`dense_gnm_random_graph` for
sparse graphs.
Parameters
----------
n : int
The number of nodes.
m : int
The number of edges.
seed : integer, random_state, or None (default)
Indicator of random number generation state.
See :ref:`Randomness<randomness>`.
directed : bool, optional (default=False)
If True return a directed graph
See also
--------
dense_gnm_random_graph
"""
if directed:
G = nx.DiGraph()
else:
G = nx.Graph()
G.add_nodes_from(range(n))
if n == 1:
return G
max_edges = n * (n - 1)
if not directed:
max_edges /= 2.0
if m >= max_edges:
return complete_graph(n, create_using=G)
nlist = list(G)
edge_count = 0
while edge_count < m:
# generate random edge,u,v
u = seed.choice(nlist)
v = seed.choice(nlist)
if u == v or G.has_edge(u, v):
continue
else:
G.add_edge(u, v)
edge_count = edge_count + 1
return G
def gnp_random_graph(n, p, seed=None, directed=False):
"""Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph
or a binomial graph.
The $G_{n,p}$ model chooses each of the possible edges with probability $p$.
The functions :func:`binomial_graph` and :func:`erdos_renyi_graph` are
aliases of this function.
Parameters
----------
n : int
The number of nodes.
p : float
Probability for edge creation.
seed : integer, random_state, or None (default)
Indicator of random number generation state.
See :ref:`Randomness<randomness>`.
directed : bool, optional (default=False)
If True, this function returns a directed graph.
See Also
--------
fast_gnp_random_graph
Notes
-----
This algorithm [2]_ runs in $O(n^2)$ time. For sparse graphs (that is, for
small values of $p$), :func:`fast_gnp_random_graph` is a faster algorithm.
References
----------
.. [1] P. Erdős and A. Rényi, On Random Graphs, Publ. Math. 6, 290 (1959).
.. [2] E. N. Gilbert, Random Graphs, Ann. Math. Stat., 30, 1141 (1959).
"""
if directed:
edges = itertools.permutations(range(n), 2)
G = nx.DiGraph()
else:
edges = itertools.combinations(range(n), 2)
G = nx.Graph()
G.add_nodes_from(range(n))
if p <= 0:
return G
if p >= 1:
return complete_graph(n, create_using=G)
for e in edges:
if seed.random() < p:
G.add_edge(*e)
return G
def setup_method(self):
G = nx.DiGraph()
edges = [(1, 3), (1, 5), (2, 1), (3, 5), (5, 4), (5, 3), (6, 5)]
G.add_edges_from(edges, weight=1)
self.G = G
self.G.a = dict(
zip(sorted(G),
[0.000000, 0.000000, 0.366025, 0.133975, 0.500000, 0.000000]))
self.G.h = dict(
zip(sorted(G),
[0.366025, 0.000000, 0.211325, 0.000000, 0.211325, 0.211325]))
def setup_class(cls):
G = nx.DiGraph()
edges = [
(1, 2),
(1, 3),
# 2 is a dangling node
(3, 1),
(3, 2),
(3, 5),
(4, 5),
(4, 6),
(5, 4),
(5, 6),
(6, 4),
]
G.add_edges_from(edges)
cls.G = G
cls.G.pagerank = dict(
zip(
sorted(G),
[
0.03721197,
0.05395735,
0.04150565,
0.37508082,
0.20599833,
0.28624589,
],
))
cls.dangling_node_index = 1
cls.dangling_edges = {1: 2, 2: 3, 3: 0, 4: 0, 5: 0, 6: 0}
cls.G.dangling_pagerank = dict(
zip(
sorted(G),
[
0.10844518, 0.18618601, 0.0710892, 0.2683668, 0.15919783,
0.20671497
],
))
def setup_method(self):
# self.K = nx.krackhardt_kite_graph()
self.P3 = nx.path_graph(3)
self.K5 = nx.complete_graph(5)
# F = nx.Graph() # Florentine families
# F.add_edge('Acciaiuoli', 'Medici')
# F.add_edge('Castellani', 'Peruzzi')
# F.add_edge('Castellani', 'Strozzi')
# F.add_edge('Castellani', 'Barbadori')
# F.add_edge('Medici', 'Barbadori')
# F.add_edge('Medici', 'Ridolfi')
# F.add_edge('Medici', 'Tornabuoni')
# F.add_edge('Medici', 'Albizzi')
# F.add_edge('Medici', 'Salviati')
# F.add_edge('Salviati', 'Pazzi')
# F.add_edge('Peruzzi', 'Strozzi')
# F.add_edge('Peruzzi', 'Bischeri')
# F.add_edge('Strozzi', 'Ridolfi')
# F.add_edge('Strozzi', 'Bischeri')
# F.add_edge('Ridolfi', 'Tornabuoni')
# F.add_edge('Tornabuoni', 'Guadagni')
# F.add_edge('Albizzi', 'Ginori')
# F.add_edge('Albizzi', 'Guadagni')
# F.add_edge('Bischeri', 'Guadagni')
# F.add_edge('Guadagni', 'Lamberteschi')
# self.F = F
G = nx.DiGraph()
G.add_edge(0, 5)
G.add_edge(1, 5)
G.add_edge(2, 5)
G.add_edge(3, 5)
G.add_edge(4, 5)
G.add_edge(5, 6)
G.add_edge(5, 7)
G.add_edge(5, 8)
self.G = G
def test_bfs_edges_reverse(self):
D = nx.DiGraph()
D.add_edges_from([(0, 1), (1, 2), (1, 3), (2, 4), (3, 4)])
edges = nx.builtin.bfs_edges(D, source=4, reverse=True)
assert list(edges) == [(4, 2), (4, 3), (2, 1), (1, 0)]
def bfs_tree(G, source, reverse=False, depth_limit=None):
T = nx.DiGraph()
T.add_node(source)
edges_gen = bfs_edges(G, source, reverse=reverse, depth_limit=depth_limit)
T.add_edges_from(edges_gen)
return T
def fast_gnp_random_graph(n, p, seed=None, directed=False):
"""Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph or
a binomial graph.
Parameters
----------
n : int
The number of nodes.
p : float
Probability for edge creation.
seed : integer, random_state, or None (default)
Indicator of random number generation state.
See :ref:`Randomness<randomness>`.
directed : bool, optional (default=False)
If True, this function returns a directed graph.
Notes
-----
The $G_{n,p}$ graph algorithm chooses each of the $[n (n - 1)] / 2$
(undirected) or $n (n - 1)$ (directed) possible edges with probability $p$.
This algorithm [1]_ runs in $O(n + m)$ time, where `m` is the expected number of
edges, which equals $p n (n - 1) / 2$. This should be faster than
:func:`gnp_random_graph` when $p$ is small and the expected number of edges
is small (that is, the graph is sparse).
See Also
--------
gnp_random_graph
References
----------
.. [1] Vladimir Batagelj and Ulrik Brandes,
"Efficient generation of large random networks",
Phys. Rev. E, 71, 036113, 2005.
"""
G = empty_graph(n)
if p <= 0 or p >= 1:
return nx.gnp_random_graph(n, p, seed=seed, directed=directed)
w = -1
lp = math.log(1.0 - p)
if directed:
G = nx.DiGraph(G)
# Nodes in graph are from 0,n-1 (start with v as the first node index).
v = 0
while v < n:
lr = math.log(1.0 - seed.random())
w = w + 1 + int(lr / lp)
if v == w: # avoid self loops
w = w + 1
while v < n <= w:
w = w - n
v = v + 1
if v == w: # avoid self loops
w = w + 1
if v < n:
G.add_edge(v, w)
else:
# Nodes in graph are from 0,n-1 (start with v as the second node index).
v = 1
while v < n:
lr = math.log(1.0 - seed.random())
w = w + 1 + int(lr / lp)
while w >= v and v < n:
w = w - v
v = v + 1
if v < n:
G.add_edge(v, w)
return G
def test_digraphs_equal(self):
G = nx.path_graph(4, create_using=nx.DiGraph())
H = nx.DiGraph()
nx.add_path(H, range(4))
self._test_equal(G, H)
def setup_method(self):
self.DG = nx.path_graph(9, create_using=nx.DiGraph())
self.uv = nx.to_undirected(self.DG)
def test_dag_nontree():
G = nx.DiGraph()
G.add_edges_from([(0, 1), (0, 2), (1, 2)])
assert not nx.is_tree(G)
assert nx.is_directed_acyclic_graph(G)
def test_emptybranch():
G = nx.DiGraph()
G.add_nodes_from(range(10))
assert nx.is_branching(G)
assert not nx.is_arborescence(G)
def setup_method(self):
self.G = nx.path_graph(9, create_using=nx.DiGraph())
self.rv = nx.reverse_view(self.G)
def setup_class(cls):
G = nx.DiGraph()
edges = [
(1, 2),
(1, 3),
(2, 4),
(3, 2),
(3, 5),
(4, 2),
(4, 5),
(4, 6),
(5, 6),
(5, 7),
(5, 8),
(6, 8),
(7, 1),
(7, 5),
(7, 8),
(8, 6),
(8, 7),
]
G.add_edges_from(edges, weight=2.0)
cls.G = G.reverse()
cls.G.evc = [
0.25368793,
0.19576478,
0.32817092,
0.40430835,
0.48199885,
0.15724483,
0.51346196,
0.32475403,
]
H = nx.DiGraph()
edges = [
(1, 2),
(1, 3),
(2, 4),
(3, 2),
(3, 5),
(4, 2),
(4, 5),
(4, 6),
(5, 6),
(5, 7),
(5, 8),
(6, 8),
(7, 1),
(7, 5),
(7, 8),
(8, 6),
(8, 7),
]
G.add_edges_from(edges)
cls.H = G.reverse()
cls.H.evc = [
0.25368793,
0.19576478,
0.32817092,
0.40430835,
0.48199885,
0.15724483,
0.51346196,
0.32475403,
]
def test_error_on_wrong_nx_type(self):
g = self.single_label_g
with pytest.raises(TypeError):
nx_g = nx.DiGraph(g)
def setup_method(cls):
cls.P4 = nx.path_graph(4)
cls.D = nx.DiGraph()
cls.D.add_edges_from([(0, 2), (0, 3), (1, 3), (2, 3)])
cls.S = nx.Graph()
cls.S.add_edges_from([(0, 0), (1, 1)])
def test_path():
G = nx.DiGraph()
nx.add_path(G, range(5))
assert nx.is_branching(G)
assert nx.is_arborescence(G)
def test_triangle_and_edge(self):
G = nx.cycle_graph(3, create_using=nx.DiGraph())
G.add_edge(0, 4, weight=2)
assert nx.clustering(G)[0] == 1.0 / 6.0
assert nx.clustering(G, weight="weight")[0] == 1.0 / 12.0
def test_clustering(self):
G = nx.DiGraph()
assert list(nx.clustering(G).values()) == []
assert nx.clustering(G) == {}
def random_uniform_k_out_graph(n, k, self_loops=True, with_replacement=True, seed=None):
"""Returns a random `k`-out graph with uniform attachment.
A random `k`-out graph with uniform attachment is a multidigraph
generated by the following algorithm. For each node *u*, choose
`k` nodes *v* uniformly at random (with replacement). Add a
directed edge joining *u* to *v*.
Parameters
----------
n : int
The number of nodes in the returned graph.
k : int
The out-degree of each node in the returned graph.
self_loops : bool
If True, self-loops are allowed when generating the graph.
with_replacement : bool
If True, neighbors are chosen with replacement and the
returned graph will be a directed multigraph. Otherwise,
neighbors are chosen without replacement and the returned graph
will be a directed graph.
seed : integer, random_state, or None (default)
Indicator of random number generation state.
See :ref:`Randomness<randomness>`.
Returns
-------
NetworkX graph
A `k`-out-regular directed graph generated according to the
above algorithm. It will be a multigraph if and only if
`with_replacement` is True.
Raises
------
ValueError
If `with_replacement` is False and `k` is greater than
`n`.
See also
--------
random_k_out_graph
Notes
-----
The return digraph or multidigraph may not be strongly connected, or
even weakly connected.
If `with_replacement` is True, this function is similar to
:func:`random_k_out_graph`, if that function had parameter `alpha`
set to positive infinity.
"""
if with_replacement:
create_using = nx.MultiDiGraph()
def sample(v, nodes):
if not self_loops:
nodes = nodes - {v}
return (seed.choice(list(nodes)) for i in range(k))
else:
create_using = nx.DiGraph()
def sample(v, nodes):
if not self_loops:
nodes = nodes - {v}
return seed.sample(nodes, k)
G = nx.empty_graph(n, create_using)
nodes = set(G)
for u in G:
G.add_edges_from((u, v) for v in sample(u, nodes))
return G
