okstra 0.130.3 → 0.131.0

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

@@ -1,290 +0,0 @@
-import networkx as nx
-
-__all__ = ["degree_centrality", "betweenness_centrality", "closeness_centrality"]
-
-
-@nx._dispatchable(name="bipartite_degree_centrality")
-def degree_centrality(G, nodes):
-    r"""Compute the degree centrality for nodes in a bipartite network.
-
-    The degree centrality for a node `v` is the fraction of nodes
-    connected to it.
-
-    Parameters
-    ----------
-    G : graph
-       A bipartite network
-
-    nodes : list or container
-      Container with all nodes in one bipartite node set.
-
-    Returns
-    -------
-    centrality : dictionary
-       Dictionary keyed by node with bipartite degree centrality as the value.
-
-    Examples
-    --------
-    >>> G = nx.wheel_graph(5)
-    >>> top_nodes = {0, 1, 2}
-    >>> nx.bipartite.degree_centrality(G, nodes=top_nodes)
-    {0: 2.0, 1: 1.5, 2: 1.5, 3: 1.0, 4: 1.0}
-
-    See Also
-    --------
-    betweenness_centrality
-    closeness_centrality
-    :func:`~networkx.algorithms.bipartite.basic.sets`
-    :func:`~networkx.algorithms.bipartite.basic.is_bipartite`
-
-    Notes
-    -----
-    The nodes input parameter must contain all nodes in one bipartite node set,
-    but the dictionary returned contains all nodes from both bipartite node
-    sets. See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
-    for further details on how bipartite graphs are handled in NetworkX.
-
-    For unipartite networks, the degree centrality values are
-    normalized by dividing by the maximum possible degree (which is
-    `n-1` where `n` is the number of nodes in G).
-
-    In the bipartite case, the maximum possible degree of a node in a
-    bipartite node set is the number of nodes in the opposite node set
-    [1]_.  The degree centrality for a node `v` in the bipartite
-    sets `U` with `n` nodes and `V` with `m` nodes is
-
-    .. math::
-
-        d_{v} = \frac{deg(v)}{m}, \mbox{for} v \in U ,
-
-        d_{v} = \frac{deg(v)}{n}, \mbox{for} v \in V ,
-
-
-    where `deg(v)` is the degree of node `v`.
-
-    References
-    ----------
-    .. [1] Borgatti, S.P. and Halgin, D. In press. "Analyzing Affiliation
-        Networks". In Carrington, P. and Scott, J. (eds) The Sage Handbook
-        of Social Network Analysis. Sage Publications.
-        https://dx.doi.org/10.4135/9781446294413.n28
-    """
-    top = set(nodes)
-    bottom = set(G) - top
-    s = 1.0 / len(bottom)
-    centrality = {n: d * s for n, d in G.degree(top)}
-    s = 1.0 / len(top)
-    centrality.update({n: d * s for n, d in G.degree(bottom)})
-    return centrality
-
-
-@nx._dispatchable(name="bipartite_betweenness_centrality")
-def betweenness_centrality(G, nodes):
-    r"""Compute betweenness centrality for nodes in a bipartite network.
-
-    Betweenness centrality of a node `v` is the sum of the
-    fraction of all-pairs shortest paths that pass through `v`.
-
-    Values of betweenness are normalized by the maximum possible
-    value which for bipartite graphs is limited by the relative size
-    of the two node sets [1]_.
-
-    Let `n` be the number of nodes in the node set `U` and
-    `m` be the number of nodes in the node set `V`, then
-    nodes in `U` are normalized by dividing by
-
-    .. math::
-
-       \frac{1}{2} [m^2 (s + 1)^2 + m (s + 1)(2t - s - 1) - t (2s - t + 3)] ,
-
-    where
-
-    .. math::
-
-        s = (n - 1) \div m , t = (n - 1) \mod m ,
-
-    and nodes in `V` are normalized by dividing by
-
-    .. math::
-
-        \frac{1}{2} [n^2 (p + 1)^2 + n (p + 1)(2r - p - 1) - r (2p - r + 3)] ,
-
-    where,
-
-    .. math::
-
-        p = (m - 1) \div n , r = (m - 1) \mod n .
-
-    Parameters
-    ----------
-    G : graph
-        A bipartite graph
-
-    nodes : list or container
-        Container with all nodes in one bipartite node set.
-
-    Returns
-    -------
-    betweenness : dictionary
-        Dictionary keyed by node with bipartite betweenness centrality
-        as the value.
-
-    Examples
-    --------
-    >>> G = nx.cycle_graph(4)
-    >>> top_nodes = {1, 2}
-    >>> nx.bipartite.betweenness_centrality(G, nodes=top_nodes)
-    {0: 0.25, 1: 0.25, 2: 0.25, 3: 0.25}
-
-    See Also
-    --------
-    degree_centrality
-    closeness_centrality
-    :func:`~networkx.algorithms.bipartite.basic.sets`
-    :func:`~networkx.algorithms.bipartite.basic.is_bipartite`
-
-    Notes
-    -----
-    The nodes input parameter must contain all nodes in one bipartite node set,
-    but the dictionary returned contains all nodes from both node sets.
-    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
-    for further details on how bipartite graphs are handled in NetworkX.
-
-
-    References
-    ----------
-    .. [1] Borgatti, S.P. and Halgin, D. In press. "Analyzing Affiliation
-        Networks". In Carrington, P. and Scott, J. (eds) The Sage Handbook
-        of Social Network Analysis. Sage Publications.
-        https://dx.doi.org/10.4135/9781446294413.n28
-    """
-    top = set(nodes)
-    bottom = set(G) - top
-    n = len(top)
-    m = len(bottom)
-    s, t = divmod(n - 1, m)
-    bet_max_top = (
-        ((m**2) * ((s + 1) ** 2))
-        + (m * (s + 1) * (2 * t - s - 1))
-        - (t * ((2 * s) - t + 3))
-    ) / 2.0
-    p, r = divmod(m - 1, n)
-    bet_max_bot = (
-        ((n**2) * ((p + 1) ** 2))
-        + (n * (p + 1) * (2 * r - p - 1))
-        - (r * ((2 * p) - r + 3))
-    ) / 2.0
-    betweenness = nx.betweenness_centrality(G, normalized=False, weight=None)
-    for node in top:
-        betweenness[node] /= bet_max_top
-    for node in bottom:
-        betweenness[node] /= bet_max_bot
-    return betweenness
-
-
-@nx._dispatchable(name="bipartite_closeness_centrality")
-def closeness_centrality(G, nodes, normalized=True):
-    r"""Compute the closeness centrality for nodes in a bipartite network.
-
-    The closeness of a node is the distance to all other nodes in the
-    graph or in the case that the graph is not connected to all other nodes
-    in the connected component containing that node.
-
-    Parameters
-    ----------
-    G : graph
-        A bipartite network
-
-    nodes : list or container
-        Container with all nodes in one bipartite node set.
-
-    normalized : bool, optional
-      If True (default) normalize by connected component size.
-
-    Returns
-    -------
-    closeness : dictionary
-        Dictionary keyed by node with bipartite closeness centrality
-        as the value.
-
-    Examples
-    --------
-    >>> G = nx.wheel_graph(5)
-    >>> top_nodes = {0, 1, 2}
-    >>> nx.bipartite.closeness_centrality(G, nodes=top_nodes)
-    {0: 1.5, 1: 1.2, 2: 1.2, 3: 1.0, 4: 1.0}
-
-    See Also
-    --------
-    betweenness_centrality
-    degree_centrality
-    :func:`~networkx.algorithms.bipartite.basic.sets`
-    :func:`~networkx.algorithms.bipartite.basic.is_bipartite`
-
-    Notes
-    -----
-    The nodes input parameter must contain all nodes in one bipartite node set,
-    but the dictionary returned contains all nodes from both node sets.
-    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
-    for further details on how bipartite graphs are handled in NetworkX.
-
-
-    Closeness centrality is normalized by the minimum distance possible.
-    In the bipartite case the minimum distance for a node in one bipartite
-    node set is 1 from all nodes in the other node set and 2 from all
-    other nodes in its own set [1]_. Thus the closeness centrality
-    for node `v`  in the two bipartite sets `U` with
-    `n` nodes and `V` with `m` nodes is
-
-    .. math::
-
-        c_{v} = \frac{m + 2(n - 1)}{d}, \mbox{for} v \in U,
-
-        c_{v} = \frac{n + 2(m - 1)}{d}, \mbox{for} v \in V,
-
-    where `d` is the sum of the distances from `v` to all
-    other nodes.
-
-    Higher values of closeness  indicate higher centrality.
-
-    As in the unipartite case, setting normalized=True causes the
-    values to normalized further to n-1 / size(G)-1 where n is the
-    number of nodes in the connected part of graph containing the
-    node.  If the graph is not completely connected, this algorithm
-    computes the closeness centrality for each connected part
-    separately.
-
-    References
-    ----------
-    .. [1] Borgatti, S.P. and Halgin, D. In press. "Analyzing Affiliation
-        Networks". In Carrington, P. and Scott, J. (eds) The Sage Handbook
-        of Social Network Analysis. Sage Publications.
-        https://dx.doi.org/10.4135/9781446294413.n28
-    """
-    closeness = {}
-    path_length = nx.single_source_shortest_path_length
-    top = set(nodes)
-    bottom = set(G) - top
-    n = len(top)
-    m = len(bottom)
-    for node in top:
-        sp = dict(path_length(G, node))
-        totsp = sum(sp.values())
-        if totsp > 0.0 and len(G) > 1:
-            closeness[node] = (m + 2 * (n - 1)) / totsp
-            if normalized:
-                s = (len(sp) - 1) / (len(G) - 1)
-                closeness[node] *= s
-        else:
-            closeness[node] = 0.0
-    for node in bottom:
-        sp = dict(path_length(G, node))
-        totsp = sum(sp.values())
-        if totsp > 0.0 and len(G) > 1:
-            closeness[node] = (n + 2 * (m - 1)) / totsp
-            if normalized:
-                s = (len(sp) - 1) / (len(G) - 1)
-                closeness[node] *= s
-        else:
-            closeness[node] = 0.0
-    return closeness

package/runtime/python/okstra_vendor/networkx/algorithms/bipartite/cluster.py

@@ -1,289 +0,0 @@
-"""Functions for computing clustering of pairs"""
-
-import itertools
-
-import networkx as nx
-
-__all__ = [
-    "clustering",
-    "average_clustering",
-    "latapy_clustering",
-    "robins_alexander_clustering",
-]
-
-
-def cc_dot(nu, nv):
-    return len(nu & nv) / len(nu | nv)
-
-
-def cc_max(nu, nv):
-    return len(nu & nv) / max(len(nu), len(nv))
-
-
-def cc_min(nu, nv):
-    return len(nu & nv) / min(len(nu), len(nv))
-
-
-modes = {"dot": cc_dot, "min": cc_min, "max": cc_max}
-
-
-@nx._dispatchable
-def latapy_clustering(G, nodes=None, mode="dot"):
-    r"""Compute a bipartite clustering coefficient for nodes.
-
-    The bipartite clustering coefficient is a measure of local density
-    of connections defined as [1]_:
-
-    .. math::
-
-       c_u = \frac{\sum_{v \in N(N(u))} c_{uv} }{|N(N(u))|}
-
-    where `N(N(u))` are the second order neighbors of `u` in `G` excluding `u`,
-    and `c_{uv}` is the pairwise clustering coefficient between nodes
-    `u` and `v`.
-
-    The mode selects the function for `c_{uv}` which can be:
-
-    `dot`:
-
-    .. math::
-
-       c_{uv}=\frac{|N(u)\cap N(v)|}{|N(u) \cup N(v)|}
-
-    `min`:
-
-    .. math::
-
-       c_{uv}=\frac{|N(u)\cap N(v)|}{min(|N(u)|,|N(v)|)}
-
-    `max`:
-
-    .. math::
-
-       c_{uv}=\frac{|N(u)\cap N(v)|}{max(|N(u)|,|N(v)|)}
-
-
-    Parameters
-    ----------
-    G : graph
-        A bipartite graph
-
-    nodes : list or iterable (optional)
-        Compute bipartite clustering for these nodes. The default
-        is all nodes in G.
-
-    mode : string
-        The pairwise bipartite clustering method to be used in the computation.
-        It must be "dot", "max", or "min".
-
-    Returns
-    -------
-    clustering : dictionary
-        A dictionary keyed by node with the clustering coefficient value.
-
-
-    Examples
-    --------
-    >>> from networkx.algorithms import bipartite
-    >>> G = nx.path_graph(4)  # path graphs are bipartite
-    >>> c = bipartite.clustering(G)
-    >>> c[0]
-    0.5
-    >>> c = bipartite.clustering(G, mode="min")
-    >>> c[0]
-    1.0
-
-    See Also
-    --------
-    robins_alexander_clustering
-    average_clustering
-    networkx.algorithms.cluster.square_clustering
-
-    References
-    ----------
-    .. [1] Latapy, Matthieu, Clémence Magnien, and Nathalie Del Vecchio (2008).
-       Basic notions for the analysis of large two-mode networks.
-       Social Networks 30(1), 31--48.
-    """
-    if not nx.algorithms.bipartite.is_bipartite(G):
-        raise nx.NetworkXError("Graph is not bipartite")
-
-    try:
-        cc_func = modes[mode]
-    except KeyError as err:
-        raise nx.NetworkXError(
-            "Mode for bipartite clustering must be: dot, min or max"
-        ) from err
-
-    if nodes is None:
-        nodes = G
-    ccs = {}
-    for v in nodes:
-        cc = 0.0
-        nbrs2 = {u for nbr in G[v] for u in G[nbr]} - {v}
-        for u in nbrs2:
-            cc += cc_func(set(G[u]), set(G[v]))
-        if cc > 0.0:  # len(nbrs2)>0
-            cc /= len(nbrs2)
-        ccs[v] = cc
-    return ccs
-
-
-clustering = latapy_clustering
-
-
-@nx._dispatchable(name="bipartite_average_clustering")
-def average_clustering(G, nodes=None, mode="dot"):
-    r"""Compute the average bipartite clustering coefficient.
-
-    A clustering coefficient for the whole graph is the average,
-
-    .. math::
-
-       C = \frac{1}{n}\sum_{v \in G} c_v,
-
-    where `n` is the number of nodes in `G`.
-
-    Similar measures for the two bipartite sets can be defined [1]_
-
-    .. math::
-
-       C_X = \frac{1}{|X|}\sum_{v \in X} c_v,
-
-    where `X` is a bipartite set of `G`.
-
-    Parameters
-    ----------
-    G : graph
-        a bipartite graph
-
-    nodes : list or iterable, optional
-        A container of nodes to use in computing the average.
-        The nodes should be either the entire graph (the default) or one of the
-        bipartite sets.
-
-    mode : string
-        The pairwise bipartite clustering method.
-        It must be "dot", "max", or "min"
-
-    Returns
-    -------
-    clustering : float
-       The average bipartite clustering for the given set of nodes or the
-       entire graph if no nodes are specified.
-
-    Examples
-    --------
-    >>> from networkx.algorithms import bipartite
-    >>> G = nx.star_graph(3)  # star graphs are bipartite
-    >>> bipartite.average_clustering(G)
-    0.75
-    >>> X, Y = bipartite.sets(G)
-    >>> bipartite.average_clustering(G, X)
-    0.0
-    >>> bipartite.average_clustering(G, Y)
-    1.0
-
-    See Also
-    --------
-    clustering
-
-    Notes
-    -----
-    The container of nodes passed to this function must contain all of the nodes
-    in one of the bipartite sets ("top" or "bottom") in order to compute
-    the correct average bipartite clustering coefficients.
-    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
-    for further details on how bipartite graphs are handled in NetworkX.
-
-
-    References
-    ----------
-    .. [1] Latapy, Matthieu, Clémence Magnien, and Nathalie Del Vecchio (2008).
-        Basic notions for the analysis of large two-mode networks.
-        Social Networks 30(1), 31--48.
-    """
-    if nodes is None:
-        nodes = G
-    ccs = latapy_clustering(G, nodes=nodes, mode=mode)
-    return sum(ccs[v] for v in nodes) / len(nodes)
-
-
-@nx._dispatchable
-def robins_alexander_clustering(G):
-    r"""Compute the bipartite clustering of G.
-
-    Robins and Alexander [1]_ defined bipartite clustering coefficient as
-    four times the number of four cycles `C_4` divided by the number of
-    three paths `L_3` in a bipartite graph:
-
-    .. math::
-
-       CC_4 = \frac{4 * C_4}{L_3}
-
-    Parameters
-    ----------
-    G : graph
-        a bipartite graph
-
-    Returns
-    -------
-    clustering : float
-       The Robins and Alexander bipartite clustering for the input graph.
-
-    Examples
-    --------
-    >>> from networkx.algorithms import bipartite
-    >>> G = nx.davis_southern_women_graph()
-    >>> print(round(bipartite.robins_alexander_clustering(G), 3))
-    0.468
-
-    See Also
-    --------
-    latapy_clustering
-    networkx.algorithms.cluster.square_clustering
-
-    References
-    ----------
-    .. [1] Robins, G. and M. Alexander (2004). Small worlds among interlocking
-           directors: Network structure and distance in bipartite graphs.
-           Computational & Mathematical Organization Theory 10(1), 69–94.
-
-    """
-    if G.order() < 4 or G.size() < 3:
-        return 0
-    L_3 = _threepaths(G)
-    if L_3 == 0:
-        return 0
-    C_4 = _four_cycles(G)
-    return (4.0 * C_4) / L_3
-
-
-def _four_cycles(G):
-    # Also see `square_clustering` which counts squares in a similar way
-    cycles = 0
-    seen = set()
-    G_adj = G._adj
-    for v in G:
-        seen.add(v)
-        v_neighbors = set(G_adj[v])
-        if len(v_neighbors) < 2:
-            # Can't form a square without at least two neighbors
-            continue
-        two_hop_neighbors = set().union(*(G_adj[u] for u in v_neighbors))
-        two_hop_neighbors -= seen
-        for x in two_hop_neighbors:
-            p2 = len(v_neighbors.intersection(G_adj[x]))
-            cycles += p2 * (p2 - 1)
-    return cycles / 4
-
-
-def _threepaths(G):
-    paths = 0
-    for v in G:
-        for u in G[v]:
-            for w in set(G[u]) - {v}:
-                paths += len(set(G[w]) - {v, u})
-    # Divide by two because we count each three path twice
-    # one for each possible starting point
-    return paths / 2

package/runtime/python/okstra_vendor/networkx/algorithms/bipartite/covering.py

@@ -1,57 +0,0 @@
-"""Functions related to graph covers."""
-
-import networkx as nx
-from networkx.algorithms.bipartite.matching import hopcroft_karp_matching
-from networkx.algorithms.covering import min_edge_cover as _min_edge_cover
-from networkx.utils import not_implemented_for
-
-__all__ = ["min_edge_cover"]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable(name="bipartite_min_edge_cover")
-def min_edge_cover(G, matching_algorithm=None):
-    """Returns a set of edges which constitutes
-    the minimum edge cover of the graph.
-
-    The smallest edge cover can be found in polynomial time by finding
-    a maximum matching and extending it greedily so that all nodes
-    are covered.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        An undirected bipartite graph.
-
-    matching_algorithm : function
-        A function that returns a maximum cardinality matching in a
-        given bipartite graph. The function must take one input, the
-        graph ``G``, and return a dictionary mapping each node to its
-        mate. If not specified,
-        :func:`~networkx.algorithms.bipartite.matching.hopcroft_karp_matching`
-        will be used. Other possibilities include
-        :func:`~networkx.algorithms.bipartite.matching.eppstein_matching`,
-
-    Returns
-    -------
-    set
-        A set of the edges in a minimum edge cover of the graph, given as
-        pairs of nodes. It contains both the edges `(u, v)` and `(v, u)`
-        for given nodes `u` and `v` among the edges of minimum edge cover.
-
-    Notes
-    -----
-    An edge cover of a graph is a set of edges such that every node of
-    the graph is incident to at least one edge of the set.
-    A minimum edge cover is an edge covering of smallest cardinality.
-
-    Due to its implementation, the worst-case running time of this algorithm
-    is bounded by the worst-case running time of the function
-    ``matching_algorithm``.
-    """
-    if G.order() == 0:  # Special case for the empty graph
-        return set()
-    if matching_algorithm is None:
-        matching_algorithm = hopcroft_karp_matching
-    return _min_edge_cover(G, matching_algorithm=matching_algorithm)