okstra 0.130.3 → 0.131.0

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

@@ -1,88 +0,0 @@
-"""Functions for computing the harmonic centrality of a graph."""
-
-from functools import partial
-
-import networkx as nx
-
-__all__ = ["harmonic_centrality"]
-
-
-@nx._dispatchable(edge_attrs="distance")
-def harmonic_centrality(G, nbunch=None, distance=None, sources=None):
-    r"""Compute harmonic centrality for nodes.
-
-    Harmonic centrality [1]_ of a node `u` is the sum of the reciprocal
-    of the shortest path distances from all other nodes to `u`
-
-    .. math::
-
-        C(u) = \sum_{v \neq u} \frac{1}{d(v, u)}
-
-    where `d(v, u)` is the shortest-path distance between `v` and `u`.
-
-    If `sources` is given as an argument, the returned harmonic centrality
-    values are calculated as the sum of the reciprocals of the shortest
-    path distances from the nodes specified in `sources` to `u` instead
-    of from all nodes to `u`.
-
-    Notice that higher values indicate higher centrality.
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph
-
-    nbunch : container (default: all nodes in G)
-      Container of nodes for which harmonic centrality values are calculated.
-
-    sources : container (default: all nodes in G)
-      Container of nodes `v` over which reciprocal distances are computed.
-      Nodes not in `G` are silently ignored.
-
-    distance : edge attribute key, optional (default=None)
-      Use the specified edge attribute as the edge distance in shortest
-      path calculations.  If `None`, then each edge will have distance equal to 1.
-
-    Returns
-    -------
-    nodes : dictionary
-      Dictionary of nodes with harmonic centrality as the value.
-
-    See Also
-    --------
-    betweenness_centrality, load_centrality, eigenvector_centrality,
-    degree_centrality, closeness_centrality
-
-    Notes
-    -----
-    If the 'distance' keyword is set to an edge attribute key then the
-    shortest-path length will be computed using Dijkstra's algorithm with
-    that edge attribute as the edge weight.
-
-    References
-    ----------
-    .. [1] Boldi, Paolo, and Sebastiano Vigna. "Axioms for centrality."
-           Internet Mathematics 10.3-4 (2014): 222-262.
-    """
-
-    nbunch = set(G.nbunch_iter(nbunch) if nbunch is not None else G.nodes)
-    sources = set(G.nbunch_iter(sources) if sources is not None else G.nodes)
-
-    centrality = {u: 0 for u in nbunch}
-
-    transposed = False
-    if len(nbunch) < len(sources):
-        transposed = True
-        nbunch, sources = sources, nbunch
-        if nx.is_directed(G):
-            G = nx.reverse(G, copy=False)
-
-    spl = partial(nx.shortest_path_length, G, weight=distance)
-    for v in sources:
-        dist = spl(v)
-        for u, d_uv in dist.items():
-            # Ignore self-loops and edges with 0 weight
-            if d_uv != 0 and u in nbunch:
-                centrality[v if transposed else u] += 1 / d_uv
-
-    return centrality

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

@@ -1,331 +0,0 @@
-"""Katz centrality."""
-
-import math
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["katz_centrality", "katz_centrality_numpy"]
-
-
-@not_implemented_for("multigraph")
-@nx._dispatchable(edge_attrs="weight")
-def katz_centrality(
-    G,
-    alpha=0.1,
-    beta=1.0,
-    max_iter=1000,
-    tol=1.0e-6,
-    nstart=None,
-    normalized=True,
-    weight=None,
-):
-    r"""Compute the Katz centrality for the nodes of the graph G.
-
-    Katz centrality computes the centrality for a node based on the centrality
-    of its neighbors. It is a generalization of the eigenvector centrality. The
-    Katz centrality for node $i$ is
-
-    .. math::
-
-        x_i = \alpha \sum_{j} A_{ij} x_j + \beta,
-
-    where $A$ is the adjacency matrix of graph G with eigenvalues $\lambda$.
-
-    The parameter $\beta$ controls the initial centrality and
-
-    .. math::
-
-        \alpha < \frac{1}{\lambda_{\max}}.
-
-    Katz centrality computes the relative influence of a node within a
-    network by measuring the number of the immediate neighbors (first
-    degree nodes) and also all other nodes in the network that connect
-    to the node under consideration through these immediate neighbors.
-
-    Extra weight can be provided to immediate neighbors through the
-    parameter $\beta$.  Connections made with distant neighbors
-    are, however, penalized by an attenuation factor $\alpha$ which
-    should be strictly less than the inverse largest eigenvalue of the
-    adjacency matrix in order for the Katz centrality to be computed
-    correctly. More information is provided in [1]_.
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph.
-
-    alpha : float, optional (default=0.1)
-      Attenuation factor
-
-    beta : scalar or dictionary, optional (default=1.0)
-      Weight attributed to the immediate neighborhood. If not a scalar, the
-      dictionary must have a value for every node.
-
-    max_iter : integer, optional (default=1000)
-      Maximum number of iterations in power method.
-
-    tol : float, optional (default=1.0e-6)
-      Error tolerance used to check convergence in power method iteration.
-
-    nstart : dictionary, optional
-      Starting value of Katz iteration for each node.
-
-    normalized : bool, optional (default=True)
-      If True normalize the resulting values.
-
-    weight : None or string, optional (default=None)
-      If None, all edge weights are considered equal.
-      Otherwise holds the name of the edge attribute used as weight.
-      In this measure the weight is interpreted as the connection strength.
-
-    Returns
-    -------
-    nodes : dictionary
-       Dictionary of nodes with Katz centrality as the value.
-
-    Raises
-    ------
-    NetworkXError
-       If the parameter `beta` is not a scalar but lacks a value for at least
-       one node
-
-    PowerIterationFailedConvergence
-        If the algorithm fails to converge to the specified tolerance
-        within the specified number of iterations of the power iteration
-        method.
-
-    Examples
-    --------
-    >>> import math
-    >>> G = nx.path_graph(4)
-    >>> phi = (1 + math.sqrt(5)) / 2.0  # largest eigenvalue of adj matrix
-    >>> centrality = nx.katz_centrality(G, 1 / phi - 0.01)
-    >>> for n, c in sorted(centrality.items()):
-    ...     print(f"{n} {c:.2f}")
-    0 0.37
-    1 0.60
-    2 0.60
-    3 0.37
-
-    See Also
-    --------
-    katz_centrality_numpy
-    eigenvector_centrality
-    eigenvector_centrality_numpy
-    :func:`~networkx.algorithms.link_analysis.pagerank_alg.pagerank`
-    :func:`~networkx.algorithms.link_analysis.hits_alg.hits`
-
-    Notes
-    -----
-    Katz centrality was introduced by [2]_.
-
-    This algorithm it uses the power method to find the eigenvector
-    corresponding to the largest eigenvalue of the adjacency matrix of ``G``.
-    The parameter ``alpha`` should be strictly less than the inverse of largest
-    eigenvalue of the adjacency matrix for the algorithm to converge.
-    You can use ``max(nx.adjacency_spectrum(G))`` to get $\lambda_{\max}$ the largest
-    eigenvalue of the adjacency matrix.
-    The iteration will stop after ``max_iter`` iterations or an error tolerance of
-    ``number_of_nodes(G) * tol`` has been reached.
-
-    For strongly connected graphs, as $\alpha \to 1/\lambda_{\max}$, and $\beta > 0$,
-    Katz centrality approaches the results for eigenvector centrality.
-
-    For directed graphs this finds "left" eigenvectors which corresponds
-    to the in-edges in the graph. For out-edges Katz centrality,
-    first reverse the graph with ``G.reverse()``.
-
-    References
-    ----------
-    .. [1] Mark E. J. Newman:
-       Networks: An Introduction.
-       Oxford University Press, USA, 2010, p. 720.
-    .. [2] Leo Katz:
-       A New Status Index Derived from Sociometric Index.
-       Psychometrika 18(1):39–43, 1953
-       https://link.springer.com/content/pdf/10.1007/BF02289026.pdf
-    """
-    if len(G) == 0:
-        return {}
-
-    nnodes = G.number_of_nodes()
-
-    if nstart is None:
-        # choose starting vector with entries of 0
-        x = {n: 0 for n in G}
-    else:
-        x = nstart
-
-    try:
-        b = dict.fromkeys(G, float(beta))
-    except (TypeError, ValueError, AttributeError) as err:
-        b = beta
-        if set(beta) != set(G):
-            raise nx.NetworkXError(
-                "beta dictionary must have a value for every node"
-            ) from err
-
-    # make up to max_iter iterations
-    for _ in range(max_iter):
-        xlast = x
-        x = dict.fromkeys(xlast, 0)
-        # do the multiplication y^T = Alpha * x^T A + Beta
-        for n in x:
-            for nbr in G[n]:
-                x[nbr] += xlast[n] * G[n][nbr].get(weight, 1)
-        for n in x:
-            x[n] = alpha * x[n] + b[n]
-
-        # check convergence
-        error = sum(abs(x[n] - xlast[n]) for n in x)
-        if error < nnodes * tol:
-            if normalized:
-                # normalize vector
-                try:
-                    s = 1.0 / math.hypot(*x.values())
-                except ZeroDivisionError:
-                    s = 1.0
-            else:
-                s = 1
-            for n in x:
-                x[n] *= s
-            return x
-    raise nx.PowerIterationFailedConvergence(max_iter)
-
-
-@not_implemented_for("multigraph")
-@nx._dispatchable(edge_attrs="weight")
-def katz_centrality_numpy(G, alpha=0.1, beta=1.0, normalized=True, weight=None):
-    r"""Compute the Katz centrality for the graph G.
-
-    Katz centrality computes the centrality for a node based on the centrality
-    of its neighbors. It is a generalization of the eigenvector centrality. The
-    Katz centrality for node $i$ is
-
-    .. math::
-
-        x_i = \alpha \sum_{j} A_{ij} x_j + \beta,
-
-    where $A$ is the adjacency matrix of graph G with eigenvalues $\lambda$.
-
-    The parameter $\beta$ controls the initial centrality and
-
-    .. math::
-
-        \alpha < \frac{1}{\lambda_{\max}}.
-
-    Katz centrality computes the relative influence of a node within a
-    network by measuring the number of the immediate neighbors (first
-    degree nodes) and also all other nodes in the network that connect
-    to the node under consideration through these immediate neighbors.
-
-    Extra weight can be provided to immediate neighbors through the
-    parameter $\beta$.  Connections made with distant neighbors
-    are, however, penalized by an attenuation factor $\alpha$ which
-    should be strictly less than the inverse largest eigenvalue of the
-    adjacency matrix in order for the Katz centrality to be computed
-    correctly. More information is provided in [1]_.
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph
-
-    alpha : float
-      Attenuation factor
-
-    beta : scalar or dictionary, optional (default=1.0)
-      Weight attributed to the immediate neighborhood. If not a scalar the
-      dictionary must have an value for every node.
-
-    normalized : bool
-      If True normalize the resulting values.
-
-    weight : None or string, optional
-      If None, all edge weights are considered equal.
-      Otherwise holds the name of the edge attribute used as weight.
-      In this measure the weight is interpreted as the connection strength.
-
-    Returns
-    -------
-    nodes : dictionary
-       Dictionary of nodes with Katz centrality as the value.
-
-    Raises
-    ------
-    NetworkXError
-       If the parameter `beta` is not a scalar but lacks a value for at least
-       one node
-
-    Examples
-    --------
-    >>> import math
-    >>> G = nx.path_graph(4)
-    >>> phi = (1 + math.sqrt(5)) / 2.0  # largest eigenvalue of adj matrix
-    >>> centrality = nx.katz_centrality_numpy(G, 1 / phi)
-    >>> for n, c in sorted(centrality.items()):
-    ...     print(f"{n} {c:.2f}")
-    0 0.37
-    1 0.60
-    2 0.60
-    3 0.37
-
-    See Also
-    --------
-    katz_centrality
-    eigenvector_centrality_numpy
-    eigenvector_centrality
-    :func:`~networkx.algorithms.link_analysis.pagerank_alg.pagerank`
-    :func:`~networkx.algorithms.link_analysis.hits_alg.hits`
-
-    Notes
-    -----
-    Katz centrality was introduced by [2]_.
-
-    This algorithm uses a direct linear solver to solve the above equation.
-    The parameter ``alpha`` should be strictly less than the inverse of largest
-    eigenvalue of the adjacency matrix for there to be a solution.
-    You can use ``max(nx.adjacency_spectrum(G))`` to get $\lambda_{\max}$ the largest
-    eigenvalue of the adjacency matrix.
-
-    For strongly connected graphs, as $\alpha \to 1/\lambda_{\max}$, and $\beta > 0$,
-    Katz centrality approaches the results for eigenvector centrality.
-
-    For directed graphs this finds "left" eigenvectors which corresponds
-    to the in-edges in the graph. For out-edges Katz centrality,
-    first reverse the graph with ``G.reverse()``.
-
-    References
-    ----------
-    .. [1] Mark E. J. Newman:
-       Networks: An Introduction.
-       Oxford University Press, USA, 2010, p. 173.
-    .. [2] Leo Katz:
-       A New Status Index Derived from Sociometric Index.
-       Psychometrika 18(1):39–43, 1953
-       https://link.springer.com/content/pdf/10.1007/BF02289026.pdf
-    """
-    import numpy as np
-
-    if len(G) == 0:
-        return {}
-    try:
-        nodelist = beta.keys()
-        if set(nodelist) != set(G):
-            raise nx.NetworkXError("beta dictionary must have a value for every node")
-        b = np.array(list(beta.values()), dtype=float)
-    except AttributeError:
-        nodelist = list(G)
-        try:
-            b = np.ones((len(nodelist), 1)) * beta
-        except (TypeError, ValueError, AttributeError) as err:
-            raise nx.NetworkXError("beta must be a number") from err
-
-    A = nx.adjacency_matrix(G, nodelist=nodelist, weight=weight).todense().T
-    n = A.shape[0]
-    centrality = np.linalg.solve(np.eye(n, n) - (alpha * A), b).squeeze()
-
-    # Normalize: rely on truediv to cast to float, then tolist to make Python numbers
-    norm = np.sign(sum(centrality)) * np.linalg.norm(centrality) if normalized else 1
-    return dict(zip(nodelist, (centrality / norm).tolist()))

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

@@ -1,150 +0,0 @@
-"""
-Laplacian centrality measures.
-"""
-
-import networkx as nx
-
-__all__ = ["laplacian_centrality"]
-
-
-@nx._dispatchable(edge_attrs="weight")
-def laplacian_centrality(
-    G, normalized=True, nodelist=None, weight="weight", walk_type=None, alpha=0.95
-):
-    r"""Compute the Laplacian centrality for nodes in the graph `G`.
-
-    The Laplacian Centrality of a node ``i`` is measured by the drop in the
-    Laplacian Energy after deleting node ``i`` from the graph. The Laplacian Energy
-    is the sum of the squared eigenvalues of a graph's Laplacian matrix.
-
-    .. math::
-
-        C_L(u_i,G) = \frac{(\Delta E)_i}{E_L (G)} = \frac{E_L (G)-E_L (G_i)}{E_L (G)}
-
-        E_L (G) = \sum_{i=0}^n \lambda_i^2
-
-    Where $E_L (G)$ is the Laplacian energy of graph `G`,
-    E_L (G_i) is the Laplacian energy of graph `G` after deleting node ``i``
-    and $\lambda_i$ are the eigenvalues of `G`'s Laplacian matrix.
-    This formula shows the normalized value. Without normalization,
-    the numerator on the right side is returned.
-
-    Parameters
-    ----------
-    G : graph
-        A networkx graph
-
-    normalized : bool (default = True)
-        If True the centrality score is scaled so the sum over all nodes is 1.
-        If False the centrality score for each node is the drop in Laplacian
-        energy when that node is removed.
-
-    nodelist : list, optional (default = None)
-        The rows and columns are ordered according to the nodes in nodelist.
-        If nodelist is None, then the ordering is produced by G.nodes().
-
-    weight: string or None, optional (default=`weight`)
-        Optional parameter `weight` to compute the Laplacian matrix.
-        The edge data key used to compute each value in the matrix.
-        If None, then each edge has weight 1.
-
-    walk_type : string or None, optional (default=None)
-        Optional parameter `walk_type` used when calling
-        :func:`directed_laplacian_matrix <networkx.directed_laplacian_matrix>`.
-        One of ``"random"``, ``"lazy"``, or ``"pagerank"``. If ``walk_type=None``
-        (the default), then a value is selected according to the properties of `G`:
-        - ``walk_type="random"`` if `G` is strongly connected and aperiodic
-        - ``walk_type="lazy"`` if `G` is strongly connected but not aperiodic
-        - ``walk_type="pagerank"`` for all other cases.
-
-    alpha : real (default = 0.95)
-        Optional parameter `alpha` used when calling
-        :func:`directed_laplacian_matrix <networkx.directed_laplacian_matrix>`.
-        (1 - alpha) is the teleportation probability used with pagerank.
-
-    Returns
-    -------
-    nodes : dictionary
-       Dictionary of nodes with Laplacian centrality as the value.
-
-    Examples
-    --------
-    >>> G = nx.Graph()
-    >>> edges = [(0, 1, 4), (0, 2, 2), (2, 1, 1), (1, 3, 2), (1, 4, 2), (4, 5, 1)]
-    >>> G.add_weighted_edges_from(edges)
-    >>> sorted((v, f"{c:0.2f}") for v, c in laplacian_centrality(G).items())
-    [(0, '0.70'), (1, '0.90'), (2, '0.28'), (3, '0.22'), (4, '0.26'), (5, '0.04')]
-
-    Notes
-    -----
-    The algorithm is implemented based on [1]_ with an extension to directed graphs
-    using the ``directed_laplacian_matrix`` function.
-
-    Raises
-    ------
-    NetworkXPointlessConcept
-        If the graph `G` is the null graph.
-    ZeroDivisionError
-        If the graph `G` has no edges (is empty) and normalization is requested.
-
-    References
-    ----------
-    .. [1] Qi, X., Fuller, E., Wu, Q., Wu, Y., and Zhang, C.-Q. (2012).
-       Laplacian centrality: A new centrality measure for weighted networks.
-       Information Sciences, 194:240-253.
-       https://math.wvu.edu/~cqzhang/Publication-files/my-paper/INS-2012-Laplacian-W.pdf
-
-    See Also
-    --------
-    :func:`~networkx.linalg.laplacianmatrix.directed_laplacian_matrix`
-    :func:`~networkx.linalg.laplacianmatrix.laplacian_matrix`
-    """
-    import numpy as np
-    import scipy as sp
-
-    if len(G) == 0:
-        raise nx.NetworkXPointlessConcept("null graph has no centrality defined")
-    if G.size(weight=weight) == 0:
-        if normalized:
-            raise ZeroDivisionError("graph with no edges has zero full energy")
-        return {n: 0 for n in G}
-
-    if nodelist is not None:
-        nodeset = set(G.nbunch_iter(nodelist))
-        if len(nodeset) != len(nodelist):
-            raise nx.NetworkXError("nodelist has duplicate nodes or nodes not in G")
-        nodes = nodelist + [n for n in G if n not in nodeset]
-    else:
-        nodelist = nodes = list(G)
-
-    if G.is_directed():
-        lap_matrix = nx.directed_laplacian_matrix(G, nodes, weight, walk_type, alpha)
-    else:
-        lap_matrix = nx.laplacian_matrix(G, nodes, weight).toarray()
-
-    full_energy = np.sum(lap_matrix**2)
-
-    # calculate laplacian centrality
-    laplace_centralities_dict = {}
-    for i, node in enumerate(nodelist):
-        # remove row and col i from lap_matrix
-        all_but_i = list(np.arange(lap_matrix.shape[0]))
-        all_but_i.remove(i)
-        A_2 = lap_matrix[all_but_i, :][:, all_but_i]
-
-        # Adjust diagonal for removed row
-        new_diag = lap_matrix.diagonal() - abs(lap_matrix[:, i])
-        np.fill_diagonal(A_2, new_diag[all_but_i])
-
-        if len(all_but_i) > 0:  # catches degenerate case of single node
-            new_energy = np.sum(A_2**2)
-        else:
-            new_energy = 0.0
-
-        lapl_cent = full_energy - new_energy
-        if normalized:
-            lapl_cent = lapl_cent / full_energy
-
-        laplace_centralities_dict[node] = float(lapl_cent)
-
-    return laplace_centralities_dict