okstra 0.130.3 → 0.131.0

package/runtime/python/okstra_vendor/networkx/algorithms/centrality/subgraph_alg.py

@@ -1,361 +0,0 @@
-"""
-Subraph centrality and communicability betweenness.
-"""
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = [
-    "subgraph_centrality_exp",
-    "subgraph_centrality",
-    "communicability_betweenness_centrality",
-    "estrada_index",
-]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def subgraph_centrality_exp(G, *, normalized=False):
-    r"""Returns the subgraph centrality for each node of G.
-
-    Subgraph centrality  of a node `n` is the sum of weighted closed
-    walks of all lengths starting and ending at node `n`. The weights
-    decrease with path length. Each closed walk is associated with a
-    connected subgraph ([1]_).
-
-    Parameters
-    ----------
-    G: graph
-    normalized : bool
-        If True, normalize the centrality values using the largest eigenvalue of the
-        adjacency matrix so that the centrality values are generally between 0 and 1.
-
-    Returns
-    -------
-    nodes:dictionary
-        Dictionary of nodes with subgraph centrality as the value.
-
-    Raises
-    ------
-    NetworkXError
-        If the graph is not undirected and simple.
-
-    See Also
-    --------
-    subgraph_centrality:
-        Alternative algorithm of the subgraph centrality for each node of G.
-
-    Notes
-    -----
-    This version of the algorithm exponentiates the adjacency matrix.
-
-    The subgraph centrality of a node `u` in G can be found using
-    the matrix exponential of the adjacency matrix of G [1]_,
-
-    .. math::
-
-        SC(u)=(e^A)_{uu} .
-
-    Examples
-    --------
-    (Example from [1]_)
-
-    >>> G = nx.Graph(
-    ...     [
-    ...         (1, 2),
-    ...         (1, 5),
-    ...         (1, 8),
-    ...         (2, 3),
-    ...         (2, 8),
-    ...         (3, 4),
-    ...         (3, 6),
-    ...         (4, 5),
-    ...         (4, 7),
-    ...         (5, 6),
-    ...         (6, 7),
-    ...         (7, 8),
-    ...     ]
-    ... )
-    >>> sc = nx.subgraph_centrality_exp(G)
-    >>> print([f"{node} {sc[node]:0.2f}" for node in sorted(sc)])
-    ['1 3.90', '2 3.90', '3 3.64', '4 3.71', '5 3.64', '6 3.71', '7 3.64', '8 3.90']
-    >>> sc = nx.subgraph_centrality(G, normalized=True)
-    >>> print([f"{node} {sc[node]:0.3f}" for node in sorted(sc)])
-    ['1 0.194', '2 0.194', '3 0.181', '4 0.184', '5 0.181', '6 0.184', '7 0.181', '8 0.194']
-
-    References
-    ----------
-    .. [1] Ernesto Estrada, Juan A. Rodriguez-Velazquez,
-       "Subgraph centrality in complex networks",
-       Physical Review E 71, 056103 (2005).
-       https://arxiv.org/abs/cond-mat/0504730
-
-    """
-    # alternative implementation that calculates the matrix exponential
-    import scipy as sp
-
-    nodelist = list(G)  # ordering of nodes in matrix
-    A = nx.to_numpy_array(G, nodelist)
-    # convert to 0-1 matrix
-    A[A != 0.0] = 1
-    expA = sp.linalg.expm(A)
-    values = map(float, expA.diagonal())
-    if normalized:
-        values = values / values.max()
-    # convert diagonal to dictionary keyed by node
-    sc = dict(zip(nodelist, values))
-    return sc
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def subgraph_centrality(G, *, normalized=False):
-    r"""Returns subgraph centrality for each node in G.
-
-    Subgraph centrality  of a node `n` is the sum of weighted closed
-    walks of all lengths starting and ending at node `n`. The weights
-    decrease with path length. Each closed walk is associated with a
-    connected subgraph ([1]_).
-
-    Parameters
-    ----------
-    G: Graph
-    normalized : bool
-        If True, normalize the centrality values using the largest eigenvalue of the
-        adjacency matrix so that the centrality values are generally between 0 and 1.
-
-    Returns
-    -------
-    nodes : dictionary
-       Dictionary of nodes with subgraph centrality as the value.
-
-    Raises
-    ------
-    NetworkXError
-       If the graph is not undirected and simple.
-
-    See Also
-    --------
-    subgraph_centrality_exp:
-        Alternative algorithm of the subgraph centrality for each node of G.
-
-    Notes
-    -----
-    This version of the algorithm computes eigenvalues and eigenvectors
-    of the adjacency matrix.
-
-    Subgraph centrality of a node `u` in G can be found using
-    a spectral decomposition of the adjacency matrix [1]_,
-
-    .. math::
-
-       SC(u)=\sum_{j=1}^{N}(v_{j}^{u})^2 e^{\lambda_{j}},
-
-    where `v_j` is an eigenvector of the adjacency matrix `A` of G
-    corresponding to the eigenvalue `\lambda_j`.
-
-    Examples
-    --------
-    (Example from [1]_)
-
-    >>> G = nx.Graph(
-    ...     [
-    ...         (1, 2),
-    ...         (1, 5),
-    ...         (1, 8),
-    ...         (2, 3),
-    ...         (2, 8),
-    ...         (3, 4),
-    ...         (3, 6),
-    ...         (4, 5),
-    ...         (4, 7),
-    ...         (5, 6),
-    ...         (6, 7),
-    ...         (7, 8),
-    ...     ]
-    ... )
-    >>> sc = nx.subgraph_centrality(G)
-    >>> print([f"{node} {sc[node]:0.2f}" for node in sorted(sc)])
-    ['1 3.90', '2 3.90', '3 3.64', '4 3.71', '5 3.64', '6 3.71', '7 3.64', '8 3.90']
-    >>> sc = nx.subgraph_centrality(G, normalized=True)
-    >>> print([f"{node} {sc[node]:0.3f}" for node in sorted(sc)])
-    ['1 0.194', '2 0.194', '3 0.181', '4 0.184', '5 0.181', '6 0.184', '7 0.181', '8 0.194']
-
-    References
-    ----------
-    .. [1] Ernesto Estrada, Juan A. Rodriguez-Velazquez,
-       "Subgraph centrality in complex networks",
-       Physical Review E 71, 056103 (2005).
-       https://arxiv.org/abs/cond-mat/0504730
-
-    """
-    import numpy as np
-
-    nodelist = list(G)  # ordering of nodes in matrix
-    A = nx.to_numpy_array(G, nodelist)
-    # convert to 0-1 matrix
-    A[np.nonzero(A)] = 1
-    w, v = np.linalg.eigh(A)
-    vsquare = np.array(v) ** 2
-    if normalized:
-        expw = np.exp(w - w.max())
-    else:
-        expw = np.exp(w)
-    xg = vsquare @ expw
-    # convert vector dictionary keyed by node
-    sc = dict(zip(nodelist, map(float, xg)))
-    return sc
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def communicability_betweenness_centrality(G):
-    r"""Returns subgraph communicability for all pairs of nodes in G.
-
-    Communicability betweenness measure makes use of the number of walks
-    connecting every pair of nodes as the basis of a betweenness centrality
-    measure.
-
-    Parameters
-    ----------
-    G: graph
-
-    Returns
-    -------
-    nodes : dictionary
-        Dictionary of nodes with communicability betweenness as the value.
-
-    Raises
-    ------
-    NetworkXError
-        If the graph is not undirected and simple.
-
-    Notes
-    -----
-    Let `G=(V,E)` be a simple undirected graph with `n` nodes and `m` edges,
-    and `A` denote the adjacency matrix of `G`.
-
-    Let `G(r)=(V,E(r))` be the graph resulting from
-    removing all edges connected to node `r` but not the node itself.
-
-    The adjacency matrix for `G(r)` is `A+E(r)`,  where `E(r)` has nonzeros
-    only in row and column `r`.
-
-    The subraph betweenness of a node `r`  is [1]_
-
-    .. math::
-
-         \omega_{r} = \frac{1}{C}\sum_{p}\sum_{q}\frac{G_{prq}}{G_{pq}},
-         p\neq q, q\neq r,
-
-    where
-    `G_{prq}=(e^{A}_{pq} - (e^{A+E(r)})_{pq}`  is the number of walks
-    involving node r,
-    `G_{pq}=(e^{A})_{pq}` is the number of closed walks starting
-    at node `p` and ending at node `q`,
-    and `C=(n-1)^{2}-(n-1)` is a normalization factor equal to the
-    number of terms in the sum.
-
-    The resulting `\omega_{r}` takes values between zero and one.
-    The lower bound cannot be attained for a connected
-    graph, and the upper bound is attained in the star graph.
-
-    References
-    ----------
-    .. [1] Ernesto Estrada, Desmond J. Higham, Naomichi Hatano,
-       "Communicability Betweenness in Complex Networks"
-       Physica A 388 (2009) 764-774.
-       https://arxiv.org/abs/0905.4102
-
-    Examples
-    --------
-    >>> G = nx.Graph([(0, 1), (1, 2), (1, 5), (5, 4), (2, 4), (2, 3), (4, 3), (3, 6)])
-    >>> cbc = nx.communicability_betweenness_centrality(G)
-    >>> print([f"{node} {cbc[node]:0.2f}" for node in sorted(cbc)])
-    ['0 0.03', '1 0.45', '2 0.51', '3 0.45', '4 0.40', '5 0.19', '6 0.03']
-    """
-    import numpy as np
-    import scipy as sp
-
-    nodelist = list(G)  # ordering of nodes in matrix
-    n = len(nodelist)
-    A = nx.to_numpy_array(G, nodelist)
-    # convert to 0-1 matrix
-    A[np.nonzero(A)] = 1
-    expA = sp.linalg.expm(A)
-    mapping = dict(zip(nodelist, range(n)))
-    cbc = {}
-    for v in G:
-        # remove row and col of node v
-        i = mapping[v]
-        row = A[i, :].copy()
-        col = A[:, i].copy()
-        A[i, :] = 0
-        A[:, i] = 0
-        B = (expA - sp.linalg.expm(A)) / expA
-        # sum with row/col of node v and diag set to zero
-        B[i, :] = 0
-        B[:, i] = 0
-        B -= np.diag(np.diag(B))
-        cbc[v] = float(B.sum())
-        # put row and col back
-        A[i, :] = row
-        A[:, i] = col
-    # rescale when more than two nodes
-    order = len(cbc)
-    if order > 2:
-        scale = 1.0 / ((order - 1.0) ** 2 - (order - 1.0))
-        cbc = {node: value * scale for node, value in cbc.items()}
-    return cbc
-
-
-@nx._dispatchable
-def estrada_index(G):
-    r"""Returns the Estrada index of a the graph G.
-
-    The Estrada Index is a topological index of folding or 3D "compactness" ([1]_).
-
-    Parameters
-    ----------
-    G: graph
-
-    Returns
-    -------
-    estrada index: float
-
-    Raises
-    ------
-    NetworkXError
-        If the graph is not undirected and simple.
-
-    Notes
-    -----
-    Let `G=(V,E)` be a simple undirected graph with `n` nodes  and let
-    `\lambda_{1}\leq\lambda_{2}\leq\cdots\lambda_{n}`
-    be a non-increasing ordering of the eigenvalues of its adjacency
-    matrix `A`. The Estrada index is ([1]_, [2]_)
-
-    .. math::
-        EE(G)=\sum_{j=1}^n e^{\lambda _j}.
-
-    References
-    ----------
-    .. [1] E. Estrada, "Characterization of 3D molecular structure",
-       Chem. Phys. Lett. 319, 713 (2000).
-       https://doi.org/10.1016/S0009-2614(00)00158-5
-    .. [2] José Antonio de la Peñaa, Ivan Gutman, Juan Rada,
-       "Estimating the Estrada index",
-       Linear Algebra and its Applications. 427, 1 (2007).
-       https://doi.org/10.1016/j.laa.2007.06.020
-
-    Examples
-    --------
-    >>> G = nx.Graph([(0, 1), (1, 2), (1, 5), (5, 4), (2, 4), (2, 3), (4, 3), (3, 6)])
-    >>> ei = nx.estrada_index(G)
-    >>> print(f"{ei:0.5}")
-    20.55
-    """
-    return sum(subgraph_centrality(G).values())

package/runtime/python/okstra_vendor/networkx/algorithms/centrality/trophic.py

@@ -1,181 +0,0 @@
-"""Trophic levels"""
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["trophic_levels", "trophic_differences", "trophic_incoherence_parameter"]
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable(edge_attrs="weight")
-def trophic_levels(G, weight="weight"):
-    r"""Compute the trophic levels of nodes.
-
-    The trophic level of a node $i$ is
-
-    .. math::
-
-        s_i = 1 + \frac{1}{k^{in}_i} \sum_{j} a_{ij} s_j
-
-    where $k^{in}_i$ is the in-degree of i
-
-    .. math::
-
-        k^{in}_i = \sum_{j} a_{ij}
-
-    and nodes with $k^{in}_i = 0$ have $s_i = 1$ by convention.
-
-    These are calculated using the method outlined in Levine [1]_.
-
-    Parameters
-    ----------
-    G : DiGraph
-        A directed networkx graph
-
-    Returns
-    -------
-    nodes : dict
-        Dictionary of nodes with trophic level as the value.
-
-    References
-    ----------
-    .. [1] Stephen Levine (1980) J. theor. Biol. 83, 195-207
-    """
-
-    basal_nodes = [n for n, deg in G.in_degree if deg == 0]
-    if not basal_nodes:
-        raise nx.NetworkXError(
-            "This graph has no basal nodes (nodes with no incoming edges)."
-            "Trophic levels are not defined without at least one basal node."
-        )
-
-    reachable_nodes = {
-        node for layer in nx.bfs_layers(G, sources=basal_nodes) for node in layer
-    }
-
-    if len(reachable_nodes) != len(G.nodes):
-        raise nx.NetworkXError(
-            "Trophic levels are only defined for graphs where every node has a path "
-            "from a basal node (basal nodes are nodes with no incoming edges)."
-        )
-
-    import numpy as np
-
-    # find adjacency matrix
-    a = nx.adjacency_matrix(G, weight=weight).T.toarray()
-
-    # drop rows/columns where in-degree is zero
-    rowsum = np.sum(a, axis=1)
-    p = a[rowsum != 0][:, rowsum != 0]
-    # normalise so sum of in-degree weights is 1 along each row
-    p = p / rowsum[rowsum != 0][:, np.newaxis]
-
-    # calculate trophic levels
-    nn = p.shape[0]
-    i = np.eye(nn)
-    try:
-        n = np.linalg.inv(i - p)
-    except np.linalg.LinAlgError as err:
-        # LinAlgError is raised when there is a non-basal node
-        msg = (
-            "Trophic levels are only defined for graphs where every "
-            + "node has a path from a basal node (basal nodes are nodes "
-            + "with no incoming edges)."
-        )
-        raise nx.NetworkXError(msg) from err
-    y = n.sum(axis=1) + 1
-
-    levels = {}
-
-    # all nodes with in-degree zero have trophic level == 1
-    zero_node_ids = (node_id for node_id, degree in G.in_degree if degree == 0)
-    for node_id in zero_node_ids:
-        levels[node_id] = 1
-
-    # all other nodes have levels as calculated
-    nonzero_node_ids = (node_id for node_id, degree in G.in_degree if degree != 0)
-    for i, node_id in enumerate(nonzero_node_ids):
-        levels[node_id] = y.item(i)
-
-    return levels
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable(edge_attrs="weight")
-def trophic_differences(G, weight="weight"):
-    r"""Compute the trophic differences of the edges of a directed graph.
-
-    The trophic difference $x_ij$ for each edge is defined in Johnson et al.
-    [1]_ as:
-
-    .. math::
-        x_ij = s_j - s_i
-
-    Where $s_i$ is the trophic level of node $i$.
-
-    Parameters
-    ----------
-    G : DiGraph
-        A directed networkx graph
-
-    Returns
-    -------
-    diffs : dict
-        Dictionary of edges with trophic differences as the value.
-
-    References
-    ----------
-    .. [1] Samuel Johnson, Virginia Dominguez-Garcia, Luca Donetti, Miguel A.
-        Munoz (2014) PNAS "Trophic coherence determines food-web stability"
-    """
-    levels = trophic_levels(G, weight=weight)
-    diffs = {}
-    for u, v in G.edges:
-        diffs[(u, v)] = levels[v] - levels[u]
-    return diffs
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable(edge_attrs="weight")
-def trophic_incoherence_parameter(G, weight="weight", cannibalism=False):
-    r"""Compute the trophic incoherence parameter of a graph.
-
-    Trophic coherence is defined as the homogeneity of the distribution of
-    trophic distances: the more similar, the more coherent. This is measured by
-    the standard deviation of the trophic differences and referred to as the
-    trophic incoherence parameter $q$ by [1].
-
-    Parameters
-    ----------
-    G : DiGraph
-        A directed networkx graph
-
-    cannibalism: Boolean
-        If set to False, self edges are not considered in the calculation
-
-    Returns
-    -------
-    trophic_incoherence_parameter : float
-        The trophic coherence of a graph
-
-    References
-    ----------
-    .. [1] Samuel Johnson, Virginia Dominguez-Garcia, Luca Donetti, Miguel A.
-        Munoz (2014) PNAS "Trophic coherence determines food-web stability"
-    """
-    import numpy as np
-
-    if cannibalism:
-        diffs = trophic_differences(G, weight=weight)
-    else:
-        # If no cannibalism, remove self-edges
-        self_loops = list(nx.selfloop_edges(G))
-        if self_loops:
-            # Make a copy so we do not change G's edges in memory
-            G_2 = G.copy()
-            G_2.remove_edges_from(self_loops)
-        else:
-            # Avoid copy otherwise
-            G_2 = G
-        diffs = trophic_differences(G_2, weight=weight)
-    return float(np.std(list(diffs.values())))

package/runtime/python/okstra_vendor/networkx/algorithms/centrality/voterank_alg.py

@@ -1,95 +0,0 @@
-"""Algorithm to select influential nodes in a graph using VoteRank."""
-
-import networkx as nx
-
-__all__ = ["voterank"]
-
-
-@nx._dispatchable
-def voterank(G, number_of_nodes=None):
-    """Select a list of influential nodes in a graph using VoteRank algorithm
-
-    VoteRank [1]_ computes a ranking of the nodes in a graph G based on a
-    voting scheme. With VoteRank, all nodes vote for each of its in-neighbors
-    and the node with the highest votes is elected iteratively. The voting
-    ability of out-neighbors of elected nodes is decreased in subsequent turns.
-
-    Parameters
-    ----------
-    G : graph
-        A NetworkX graph.
-
-    number_of_nodes : integer, optional
-        Number of ranked nodes to extract (default all nodes).
-
-    Returns
-    -------
-    voterank : list
-        Ordered list of computed seeds.
-        Only nodes with positive number of votes are returned.
-
-    Examples
-    --------
-    >>> G = nx.Graph([(0, 1), (0, 2), (0, 3), (1, 4)])
-    >>> nx.voterank(G)
-    [0, 1]
-
-    The algorithm can be used both for undirected and directed graphs.
-    However, the directed version is different in two ways:
-    (i) nodes only vote for their in-neighbors and
-    (ii) only the voting ability of elected node and its out-neighbors are updated:
-
-    >>> G = nx.DiGraph([(0, 1), (2, 1), (2, 3), (3, 4)])
-    >>> nx.voterank(G)
-    [2, 3]
-
-    Notes
-    -----
-    Each edge is treated independently in case of multigraphs.
-
-    References
-    ----------
-    .. [1] Zhang, J.-X. et al. (2016).
-        Identifying a set of influential spreaders in complex networks.
-        Sci. Rep. 6, 27823; doi: 10.1038/srep27823.
-    """
-    influential_nodes = []
-    vote_rank = {}
-    if len(G) == 0:
-        return influential_nodes
-    if number_of_nodes is None or number_of_nodes > len(G):
-        number_of_nodes = len(G)
-    if G.is_directed():
-        # For directed graphs compute average out-degree
-        avgDegree = sum(deg for _, deg in G.out_degree()) / len(G)
-    else:
-        # For undirected graphs compute average degree
-        avgDegree = sum(deg for _, deg in G.degree()) / len(G)
-    # step 1 - initiate all nodes to (0,1) (score, voting ability)
-    for n in G.nodes():
-        vote_rank[n] = [0, 1]
-    # Repeat steps 1b to 4 until num_seeds are elected.
-    for _ in range(number_of_nodes):
-        # step 1b - reset rank
-        for n in G.nodes():
-            vote_rank[n][0] = 0
-        # step 2 - vote
-        for n, nbr in G.edges():
-            # In directed graphs nodes only vote for their in-neighbors
-            vote_rank[n][0] += vote_rank[nbr][1]
-            if not G.is_directed():
-                vote_rank[nbr][0] += vote_rank[n][1]
-        for n in influential_nodes:
-            vote_rank[n][0] = 0
-        # step 3 - select top node
-        n = max(G.nodes, key=lambda x: vote_rank[x][0])
-        if vote_rank[n][0] == 0:
-            return influential_nodes
-        influential_nodes.append(n)
-        # weaken the selected node
-        vote_rank[n] = [0, 0]
-        # step 4 - update voterank properties
-        for _, nbr in G.edges(n):
-            vote_rank[nbr][1] -= 1 / avgDegree
-            vote_rank[nbr][1] = max(vote_rank[nbr][1], 0)
-    return influential_nodes