Source code for networkx.algorithms.wiener

"""Functions related to the Wiener Index of a graph.

The Wiener Index is a topological measure of a graph
related to the distance between nodes and their degree.
The Schultz Index and Gutman Index are similar measures.
They are used categorize molecules via the network of
atoms connected by chemical bonds. The indices are
correlated with functional aspects of the molecules.

References
----------
.. [1] `Wikipedia: Wiener Index <https://en.wikipedia.org/wiki/Wiener_index>`_
.. [2] M.V. Diudeaa and I. Gutman, Wiener-Type Topological Indices,
       Croatica Chemica Acta, 71 (1998), 21-51.
       https://hrcak.srce.hr/132323
"""

import itertools as it

import networkx as nx

__all__ = ["wiener_index", "schultz_index", "gutman_index"]


[docs] @nx._dispatchable(edge_attrs="weight") def wiener_index(G, weight=None): """Returns the Wiener index of the given graph. The *Wiener index* of a graph is the sum of the shortest-path (weighted) distances between each pair of reachable nodes. For pairs of nodes in undirected graphs, only one orientation of the pair is counted. Parameters ---------- G : NetworkX graph weight : string or None, optional (default: None) If None, every edge has weight 1. If a string, use this edge attribute as the edge weight. Any edge attribute not present defaults to 1. The edge weights are used to computing shortest-path distances. Returns ------- number The Wiener index of the graph `G`. Raises ------ NetworkXError If the graph `G` is not connected. Notes ----- If a pair of nodes is not reachable, the distance is assumed to be infinity. This means that for graphs that are not strongly-connected, this function returns ``inf``. The Wiener index is not usually defined for directed graphs, however this function uses the natural generalization of the Wiener index to directed graphs. Examples -------- The Wiener index of the (unweighted) complete graph on *n* nodes equals the number of pairs of the *n* nodes, since each pair of nodes is at distance one:: >>> n = 10 >>> G = nx.complete_graph(n) >>> nx.wiener_index(G) == n * (n - 1) / 2 True Graphs that are not strongly-connected have infinite Wiener index:: >>> G = nx.empty_graph(2) >>> nx.wiener_index(G) inf References ---------- .. [1] `Wikipedia: Wiener Index <https://en.wikipedia.org/wiki/Wiener_index>`_ """ connected = nx.is_strongly_connected(G) if G.is_directed() else nx.is_connected(G) if not connected: return float("inf") spl = nx.shortest_path_length(G, weight=weight) total = sum(it.chain.from_iterable(nbrs.values() for node, nbrs in spl)) # Need to account for double counting pairs of nodes in undirected graphs. return total if G.is_directed() else total / 2
[docs] @nx.utils.not_implemented_for("directed") @nx.utils.not_implemented_for("multigraph") @nx._dispatchable(edge_attrs="weight") def schultz_index(G, weight=None): r"""Returns the Schultz Index (of the first kind) of `G` The *Schultz Index* [3]_ of a graph is the sum over all node pairs of distances times the sum of degrees. Consider an undirected graph `G`. For each node pair ``(u, v)`` compute ``dist(u, v) * (deg(u) + deg(v)`` where ``dist`` is the shortest path length between two nodes and ``deg`` is the degree of a node. The Schultz Index is the sum of these quantities over all (unordered) pairs of nodes. Parameters ---------- G : NetworkX graph The undirected graph of interest. weight : string or None, optional (default: None) If None, every edge has weight 1. If a string, use this edge attribute as the edge weight. Any edge attribute not present defaults to 1. The edge weights are used to computing shortest-path distances. Returns ------- number The first kind of Schultz Index of the graph `G`. Examples -------- The Schultz Index of the (unweighted) complete graph on *n* nodes equals the number of pairs of the *n* nodes times ``2 * (n - 1)``, since each pair of nodes is at distance one and the sum of degree of two nodes is ``2 * (n - 1)``. >>> n = 10 >>> G = nx.complete_graph(n) >>> nx.schultz_index(G) == (n * (n - 1) / 2) * (2 * (n - 1)) True Graph that is disconnected >>> nx.schultz_index(nx.empty_graph(2)) inf References ---------- .. [1] I. Gutman, Selected properties of the Schultz molecular topological index, J. Chem. Inf. Comput. Sci. 34 (1994), 1087–1089. https://doi.org/10.1021/ci00021a009 .. [2] M.V. Diudeaa and I. Gutman, Wiener-Type Topological Indices, Croatica Chemica Acta, 71 (1998), 21-51. https://hrcak.srce.hr/132323 .. [3] H. P. Schultz, Topological organic chemistry. 1. Graph theory and topological indices of alkanes,i J. Chem. Inf. Comput. Sci. 29 (1989), 239–257. """ if not nx.is_connected(G): return float("inf") spl = nx.shortest_path_length(G, weight=weight) d = dict(G.degree, weight=weight) return sum(dist * (d[u] + d[v]) for u, info in spl for v, dist in info.items()) / 2
[docs] @nx.utils.not_implemented_for("directed") @nx.utils.not_implemented_for("multigraph") @nx._dispatchable(edge_attrs="weight") def gutman_index(G, weight=None): r"""Returns the Gutman Index for the graph `G`. The *Gutman Index* measures the topology of networks, especially for molecule networks of atoms connected by bonds [1]_. It is also called the Schultz Index of the second kind [2]_. Consider an undirected graph `G` with node set ``V``. The Gutman Index of a graph is the sum over all (unordered) pairs of nodes of nodes ``(u, v)``, with distance ``dist(u, v)`` and degrees ``deg(u)`` and ``deg(v)``, of ``dist(u, v) * deg(u) * deg(v)`` Parameters ---------- G : NetworkX graph weight : string or None, optional (default: None) If None, every edge has weight 1. If a string, use this edge attribute as the edge weight. Any edge attribute not present defaults to 1. The edge weights are used to computing shortest-path distances. Returns ------- number The Gutman Index of the graph `G`. Examples -------- The Gutman Index of the (unweighted) complete graph on *n* nodes equals the number of pairs of the *n* nodes times ``(n - 1) * (n - 1)``, since each pair of nodes is at distance one and the product of degree of two vertices is ``(n - 1) * (n - 1)``. >>> n = 10 >>> G = nx.complete_graph(n) >>> nx.gutman_index(G) == (n * (n - 1) / 2) * ((n - 1) * (n - 1)) True Graphs that are disconnected >>> G = nx.empty_graph(2) >>> nx.gutman_index(G) inf References ---------- .. [1] M.V. Diudeaa and I. Gutman, Wiener-Type Topological Indices, Croatica Chemica Acta, 71 (1998), 21-51. https://hrcak.srce.hr/132323 .. [2] I. Gutman, Selected properties of the Schultz molecular topological index, J. Chem. Inf. Comput. Sci. 34 (1994), 1087–1089. https://doi.org/10.1021/ci00021a009 """ if not nx.is_connected(G): return float("inf") spl = nx.shortest_path_length(G, weight=weight) d = dict(G.degree, weight=weight) return sum(dist * d[u] * d[v] for u, vinfo in spl for v, dist in vinfo.items()) / 2