# -*- encoding: utf-8 -*-
# reaching.py - functions for computing reaching centrality in a graph
#
# Copyright 2015, 2016 NetworkX developers.
#
# This file is part of NetworkX.
#
# NetworkX is distributed under a BSD license; see LICENSE.txt for more
# information.
"""Functions for computing reaching centrality of a node or a graph."""
from __future__ import division
import networkx as nx
from networkx.utils import pairwise
__all__ = ['global_reaching_centrality', 'local_reaching_centrality']
def _average_weight(G, path, weight=None):
"""Returns the average weight of an edge in a weighted path.
`G` is the graph containing the path.
`path` is the list of vertices that define the path.
`weight` is the edge attribute that gives the weight of the edge in
the graph `G`. If None, the graph is assumed to be unweighted, and
the average weight of an edge is assumed to be the multiplicative
inverse of the length of the path.
"""
path_length = len(path) - 1
if path_length <= 0:
return 0
if weight is None:
return 1 / path_length
total_weight = sum(G.edge[i][j][weight] for i, j in pairwise(path))
return total_weight / path_length
[docs]def global_reaching_centrality(G, weight=None, normalized=True):
"""Returns the global reaching centrality of a directed graph.
The *global reaching centrality* of a weighted directed graph is the
average over all nodes of the difference between the local reaching
centrality of the node and the greatest local reaching centrality of
any node in the graph [1]_. For more information on the local
reaching centrality, see :func:`local_reaching_centrality`.
Informally, the local reaching centrality is the proportion of the
graph that is reachable from the neighbors of the node.
Parameters
----------
G : DiGraph
weight : object
Attribute to use for edge weights. If ``None``, each edge weight
is assumed to be one. A higher weight implies a stronger
connection between nodes and a *shorter* path length.
normalized : bool
Whether to normalize the edge weights by the total sum of edge
weights.
Returns
-------
h : float
The global reaching centrality of the graph.
Examples
--------
>>> import networkx as nx
>>> G = nx.DiGraph()
>>> G.add_edge(1, 2)
>>> G.add_edge(1, 3)
>>> nx.global_reaching_centrality(G)
1.0
>>> G.add_edge(3, 2)
>>> nx.global_reaching_centrality(G)
0.75
See also
--------
local_reaching_centrality
References
----------
.. [1] Mones, Enys, Lilla Vicsek, and Tamás Vicsek.
"Hierarchy Measure for Complex Networks."
*PLoS ONE* 7.3 (2012): e33799.
https://dx.doi.org/10.1371/journal.pone.0033799
"""
if nx.is_negatively_weighted(G, weight=weight):
raise nx.NetworkXError('edge weights must be positive')
total_weight = G.size(weight=weight)
if total_weight <= 0:
raise nx.NetworkXError('Size of G must be positive')
# If provided, weights must be interpreted as connection strength
# (so higher weights are more likely to be chosen). However, the
# shortest path algorithms in NetworkX assume the provided "weight"
# is actually a distance (so edges with higher weight are less
# likely to be chosen). Therefore we need to invert the weights when
# computing shortest paths.
#
# If weight is None, we leave it as-is so that the shortest path
# algorithm can use a faster, unweighted algorithm.
if weight is not None:
as_distance = lambda u, v, d: total_weight / d.get(weight, 1)
shortest_paths = nx.shortest_path(G, weight=as_distance)
else:
shortest_paths = nx.shortest_path(G)
centrality = local_reaching_centrality
# TODO This can be trivially parallelized.
lrc = [centrality(G, node, paths=paths, weight=weight,
normalized=normalized)
for node, paths in shortest_paths.items()]
max_lrc = max(lrc)
return sum(max_lrc - c for c in lrc) / (len(G) - 1)
[docs]def local_reaching_centrality(G, v, paths=None, weight=None, normalized=True):
"""Returns the local reaching centrality of a node in a directed
graph.
The *local reaching centrality* of a node in a directed graph is the
proportion of other nodes reachable from that node [1]_.
Parameters
----------
G : DiGraph
A NetworkX graph.
v : node
A node in the directed graph `G`.
paths : dictionary
If this is not ``None`` it must be a dictionary representation
of single-source shortest paths, as computed by, for example,
:func:`networkx.shortest_path` with source node ``v``. Use this
keyword argument if you intend to invoke this function many
times but don't want the paths to be recomputed each time.
weight : object
Attribute to use for edge weights. If ``None``, each edge weight
is assumed to be one. A higher weight implies a stronger
connection between nodes and a *shorter* path length.
normalized : bool
Whether to normalize the edge weights by the total sum of edge
weights.
Returns
-------
h : float
The local reaching centrality of the node ``v`` in the graph
``G``.
Examples
--------
>>> import networkx as nx
>>> G = nx.DiGraph()
>>> G.add_edge(1, 2)
>>> G.add_edge(1, 3)
>>> nx.local_reaching_centrality(G, 3)
0.0
>>> G.add_edge(3, 2)
>>> nx.local_reaching_centrality(G, 3)
0.5
See also
--------
global_reaching_centrality
References
----------
.. [1] Mones, Enys, Lilla Vicsek, and Tamás Vicsek.
"Hierarchy Measure for Complex Networks."
*PLoS ONE* 7.3 (2012): e33799.
https://dx.doi.org/10.1371/journal.pone.0033799
"""
if paths is None:
if nx.is_negatively_weighted(G, weight=weight):
raise nx.NetworkXError('edge weights must be positive')
total_weight = G.size(weight=weight)
if total_weight <= 0:
raise nx.NetworkXError('Size of G must be positive')
if weight is not None:
# Interpret weights as lengths.
as_distance = lambda u, v, d: total_weight / d.get(weight, 1)
paths = nx.shortest_path(G, source=v, weight=as_distance)
else:
paths = nx.shortest_path(G, source=v)
# If the graph is unweighted, simply return the proportion of nodes
# reachable from the source node ``v``.
if weight is None and G.is_directed():
return (len(paths) - 1) / (len(G) - 1)
if normalized and weight is not None:
norm = G.size(weight=weight) / G.size()
else:
norm = 1
# TODO This can be trivially parallelized.
avgw = (_average_weight(G, path, weight=weight) for path in paths.values())
sum_avg_weight = sum(avgw) / norm
return sum_avg_weight / (len(G) - 1)