81 lines
2.4 KiB
Python
81 lines
2.4 KiB
Python
"""Function for computing walks in a graph.
|
|
"""
|
|
|
|
import networkx as nx
|
|
|
|
__all__ = ["number_of_walks"]
|
|
|
|
|
|
@nx._dispatch
|
|
def number_of_walks(G, walk_length):
|
|
"""Returns the number of walks connecting each pair of nodes in `G`
|
|
|
|
A *walk* is a sequence of nodes in which each adjacent pair of nodes
|
|
in the sequence is adjacent in the graph. A walk can repeat the same
|
|
edge and go in the opposite direction just as people can walk on a
|
|
set of paths, but standing still is not counted as part of the walk.
|
|
|
|
This function only counts the walks with `walk_length` edges. Note that
|
|
the number of nodes in the walk sequence is one more than `walk_length`.
|
|
The number of walks can grow very quickly on a larger graph
|
|
and with a larger walk length.
|
|
|
|
Parameters
|
|
----------
|
|
G : NetworkX graph
|
|
|
|
walk_length : int
|
|
A nonnegative integer representing the length of a walk.
|
|
|
|
Returns
|
|
-------
|
|
dict
|
|
A dictionary of dictionaries in which outer keys are source
|
|
nodes, inner keys are target nodes, and inner values are the
|
|
number of walks of length `walk_length` connecting those nodes.
|
|
|
|
Raises
|
|
------
|
|
ValueError
|
|
If `walk_length` is negative
|
|
|
|
Examples
|
|
--------
|
|
|
|
>>> G = nx.Graph([(0, 1), (1, 2)])
|
|
>>> walks = nx.number_of_walks(G, 2)
|
|
>>> walks
|
|
{0: {0: 1, 1: 0, 2: 1}, 1: {0: 0, 1: 2, 2: 0}, 2: {0: 1, 1: 0, 2: 1}}
|
|
>>> total_walks = sum(sum(tgts.values()) for _, tgts in walks.items())
|
|
|
|
You can also get the number of walks from a specific source node using the
|
|
returned dictionary. For example, number of walks of length 1 from node 0
|
|
can be found as follows:
|
|
|
|
>>> walks = nx.number_of_walks(G, 1)
|
|
>>> walks[0]
|
|
{0: 0, 1: 1, 2: 0}
|
|
>>> sum(walks[0].values()) # walks from 0 of length 1
|
|
1
|
|
|
|
Similarly, a target node can also be specified:
|
|
|
|
>>> walks[0][1]
|
|
1
|
|
|
|
"""
|
|
import numpy as np
|
|
|
|
if walk_length < 0:
|
|
raise ValueError(f"`walk_length` cannot be negative: {walk_length}")
|
|
|
|
A = nx.adjacency_matrix(G, weight=None)
|
|
# TODO: Use matrix_power from scipy.sparse when available
|
|
# power = sp.sparse.linalg.matrix_power(A, walk_length)
|
|
power = np.linalg.matrix_power(A.toarray(), walk_length)
|
|
result = {
|
|
u: {v: power[u_idx, v_idx] for v_idx, v in enumerate(G)}
|
|
for u_idx, u in enumerate(G)
|
|
}
|
|
return result
|