# 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

```