okstra 0.130.4 → 0.131.1

package/runtime/python/okstra_vendor/networkx/algorithms/sparsifiers.py

@@ -1,296 +0,0 @@
-"""Functions for computing sparsifiers of graphs."""
-
-import math
-
-import networkx as nx
-from networkx.utils import not_implemented_for, py_random_state
-
-__all__ = ["spanner"]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@py_random_state(3)
-@nx._dispatchable(edge_attrs="weight", returns_graph=True)
-def spanner(G, stretch, weight=None, seed=None):
-    """Returns a spanner of the given graph with the given stretch.
-
-    A spanner of a graph G = (V, E) with stretch t is a subgraph
-    H = (V, E_S) such that E_S is a subset of E and the distance between
-    any pair of nodes in H is at most t times the distance between the
-    nodes in G.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        An undirected simple graph.
-
-    stretch : float
-        The stretch of the spanner.
-
-    weight : object
-        The edge attribute to use as distance.
-
-    seed : integer, random_state, or None (default)
-        Indicator of random number generation state.
-        See :ref:`Randomness<randomness>`.
-
-    Returns
-    -------
-    NetworkX graph
-        A spanner of the given graph with the given stretch.
-
-    Raises
-    ------
-    ValueError
-        If a stretch less than 1 is given.
-
-    Notes
-    -----
-    This function implements the spanner algorithm by Baswana and Sen,
-    see [1].
-
-    This algorithm is a randomized las vegas algorithm: The expected
-    running time is O(km) where k = (stretch + 1) // 2 and m is the
-    number of edges in G. The returned graph is always a spanner of the
-    given graph with the specified stretch. For weighted graphs the
-    number of edges in the spanner is O(k * n^(1 + 1 / k)) where k is
-    defined as above and n is the number of nodes in G. For unweighted
-    graphs the number of edges is O(n^(1 + 1 / k) + kn).
-
-    References
-    ----------
-    [1] S. Baswana, S. Sen. A Simple and Linear Time Randomized
-    Algorithm for Computing Sparse Spanners in Weighted Graphs.
-    Random Struct. Algorithms 30(4): 532-563 (2007).
-    """
-    if stretch < 1:
-        raise ValueError("stretch must be at least 1")
-
-    k = (stretch + 1) // 2
-
-    # initialize spanner H with empty edge set
-    H = nx.empty_graph()
-    H.add_nodes_from(G.nodes)
-
-    # phase 1: forming the clusters
-    # the residual graph has V' from the paper as its node set
-    # and E' from the paper as its edge set
-    residual_graph = _setup_residual_graph(G, weight)
-    # clustering is a dictionary that maps nodes in a cluster to the
-    # cluster center
-    clustering = {v: v for v in G.nodes}
-    sample_prob = math.pow(G.number_of_nodes(), -1 / k)
-    size_limit = 2 * math.pow(G.number_of_nodes(), 1 + 1 / k)
-
-    i = 0
-    while i < k - 1:
-        # step 1: sample centers
-        sampled_centers = set()
-        for center in set(clustering.values()):
-            if seed.random() < sample_prob:
-                sampled_centers.add(center)
-
-        # combined loop for steps 2 and 3
-        edges_to_add = set()
-        edges_to_remove = set()
-        new_clustering = {}
-        for v in residual_graph.nodes:
-            if clustering[v] in sampled_centers:
-                continue
-
-            # step 2: find neighboring (sampled) clusters and
-            # lightest edges to them
-            lightest_edge_neighbor, lightest_edge_weight = _lightest_edge_dicts(
-                residual_graph, clustering, v
-            )
-            neighboring_sampled_centers = (
-                set(lightest_edge_weight.keys()) & sampled_centers
-            )
-
-            # step 3: add edges to spanner
-            if not neighboring_sampled_centers:
-                # connect to each neighboring center via lightest edge
-                for neighbor in lightest_edge_neighbor.values():
-                    edges_to_add.add((v, neighbor))
-                # remove all incident edges
-                for neighbor in residual_graph.adj[v]:
-                    edges_to_remove.add((v, neighbor))
-
-            else:  # there is a neighboring sampled center
-                closest_center = min(
-                    neighboring_sampled_centers, key=lightest_edge_weight.get
-                )
-                closest_center_weight = lightest_edge_weight[closest_center]
-                closest_center_neighbor = lightest_edge_neighbor[closest_center]
-
-                edges_to_add.add((v, closest_center_neighbor))
-                new_clustering[v] = closest_center
-
-                # connect to centers with edge weight less than
-                # closest_center_weight
-                for center, edge_weight in lightest_edge_weight.items():
-                    if edge_weight < closest_center_weight:
-                        neighbor = lightest_edge_neighbor[center]
-                        edges_to_add.add((v, neighbor))
-
-                # remove edges to centers with edge weight less than
-                # closest_center_weight
-                for neighbor in residual_graph.adj[v]:
-                    nbr_cluster = clustering[neighbor]
-                    nbr_weight = lightest_edge_weight[nbr_cluster]
-                    if (
-                        nbr_cluster == closest_center
-                        or nbr_weight < closest_center_weight
-                    ):
-                        edges_to_remove.add((v, neighbor))
-
-        # check whether iteration added too many edges to spanner,
-        # if so repeat
-        if len(edges_to_add) > size_limit:
-            # an iteration is repeated O(1) times on expectation
-            continue
-
-        # iteration succeeded
-        i = i + 1
-
-        # actually add edges to spanner
-        for u, v in edges_to_add:
-            _add_edge_to_spanner(H, residual_graph, u, v, weight)
-
-        # actually delete edges from residual graph
-        residual_graph.remove_edges_from(edges_to_remove)
-
-        # copy old clustering data to new_clustering
-        for node, center in clustering.items():
-            if center in sampled_centers:
-                new_clustering[node] = center
-        clustering = new_clustering
-
-        # step 4: remove intra-cluster edges
-        for u in residual_graph.nodes:
-            for v in list(residual_graph.adj[u]):
-                if clustering[u] == clustering[v]:
-                    residual_graph.remove_edge(u, v)
-
-        # update residual graph node set
-        for v in list(residual_graph.nodes):
-            if v not in clustering:
-                residual_graph.remove_node(v)
-
-    # phase 2: vertex-cluster joining
-    for v in residual_graph.nodes:
-        lightest_edge_neighbor, _ = _lightest_edge_dicts(residual_graph, clustering, v)
-        for neighbor in lightest_edge_neighbor.values():
-            _add_edge_to_spanner(H, residual_graph, v, neighbor, weight)
-
-    return H
-
-
-def _setup_residual_graph(G, weight):
-    """Setup residual graph as a copy of G with unique edges weights.
-
-    The node set of the residual graph corresponds to the set V' from
-    the Baswana-Sen paper and the edge set corresponds to the set E'
-    from the paper.
-
-    This function associates distinct weights to the edges of the
-    residual graph (even for unweighted input graphs), as required by
-    the algorithm.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        An undirected simple graph.
-
-    weight : object
-        The edge attribute to use as distance.
-
-    Returns
-    -------
-    NetworkX graph
-        The residual graph used for the Baswana-Sen algorithm.
-    """
-    residual_graph = G.copy()
-
-    # establish unique edge weights, even for unweighted graphs
-    for u, v in G.edges():
-        if not weight:
-            residual_graph[u][v]["weight"] = (id(u), id(v))
-        else:
-            residual_graph[u][v]["weight"] = (G[u][v][weight], id(u), id(v))
-
-    return residual_graph
-
-
-def _lightest_edge_dicts(residual_graph, clustering, node):
-    """Find the lightest edge to each cluster.
-
-    Searches for the minimum-weight edge to each cluster adjacent to
-    the given node.
-
-    Parameters
-    ----------
-    residual_graph : NetworkX graph
-        The residual graph used by the Baswana-Sen algorithm.
-
-    clustering : dictionary
-        The current clustering of the nodes.
-
-    node : node
-        The node from which the search originates.
-
-    Returns
-    -------
-    lightest_edge_neighbor, lightest_edge_weight : dictionary, dictionary
-        lightest_edge_neighbor is a dictionary that maps a center C to
-        a node v in the corresponding cluster such that the edge from
-        the given node to v is the lightest edge from the given node to
-        any node in cluster. lightest_edge_weight maps a center C to the
-        weight of the aforementioned edge.
-
-    Notes
-    -----
-    If a cluster has no node that is adjacent to the given node in the
-    residual graph then the center of the cluster is not a key in the
-    returned dictionaries.
-    """
-    lightest_edge_neighbor = {}
-    lightest_edge_weight = {}
-    for neighbor in residual_graph.adj[node]:
-        nbr_center = clustering[neighbor]
-        weight = residual_graph[node][neighbor]["weight"]
-        if (
-            nbr_center not in lightest_edge_weight
-            or weight < lightest_edge_weight[nbr_center]
-        ):
-            lightest_edge_neighbor[nbr_center] = neighbor
-            lightest_edge_weight[nbr_center] = weight
-    return lightest_edge_neighbor, lightest_edge_weight
-
-
-def _add_edge_to_spanner(H, residual_graph, u, v, weight):
-    """Add the edge {u, v} to the spanner H and take weight from
-    the residual graph.
-
-    Parameters
-    ----------
-    H : NetworkX graph
-        The spanner under construction.
-
-    residual_graph : NetworkX graph
-        The residual graph used by the Baswana-Sen algorithm. The weight
-        for the edge is taken from this graph.
-
-    u : node
-        One endpoint of the edge.
-
-    v : node
-        The other endpoint of the edge.
-
-    weight : object
-        The edge attribute to use as distance.
-    """
-    H.add_edge(u, v)
-    if weight:
-        H[u][v][weight] = residual_graph[u][v]["weight"][0]

package/runtime/python/okstra_vendor/networkx/algorithms/structuralholes.py

@@ -1,374 +0,0 @@
-"""Functions for computing measures of structural holes."""
-
-import networkx as nx
-
-__all__ = ["constraint", "local_constraint", "effective_size"]
-
-
-@nx._dispatchable(edge_attrs="weight")
-def mutual_weight(G, u, v, weight=None):
-    """Returns the sum of the weights of the edge from `u` to `v` and
-    the edge from `v` to `u` in `G`.
-
-    `weight` is the edge data key that represents the edge weight. If
-    the specified key is `None` or is not in the edge data for an edge,
-    that edge is assumed to have weight 1.
-
-    Pre-conditions: `u` and `v` must both be in `G`.
-
-    """
-    try:
-        a_uv = G[u][v].get(weight, 1)
-    except KeyError:
-        a_uv = 0
-    try:
-        a_vu = G[v][u].get(weight, 1)
-    except KeyError:
-        a_vu = 0
-    return a_uv + a_vu
-
-
-@nx._dispatchable(edge_attrs="weight")
-def normalized_mutual_weight(G, u, v, norm=sum, weight=None):
-    """Returns normalized mutual weight of the edges from `u` to `v`
-    with respect to the mutual weights of the neighbors of `u` in `G`.
-
-    `norm` specifies how the normalization factor is computed. It must
-    be a function that takes a single argument and returns a number.
-    The argument will be an iterable of mutual weights
-    of pairs ``(u, w)``, where ``w`` ranges over each (in- and
-    out-)neighbor of ``u``. Commons values for `normalization` are
-    ``sum`` and ``max``.
-
-    `weight` can be ``None`` or a string, if None, all edge weights
-    are considered equal. Otherwise holds the name of the edge
-    attribute used as weight.
-
-    """
-    scale = norm(mutual_weight(G, u, w, weight) for w in set(nx.all_neighbors(G, u)))
-    return 0 if scale == 0 else mutual_weight(G, u, v, weight) / scale
-
-
-@nx._dispatchable(edge_attrs="weight")
-def effective_size(G, nodes=None, weight=None):
-    r"""Returns the effective size of all nodes in the graph ``G``.
-
-    The *effective size* of a node's ego network is based on the concept
-    of redundancy. A person's ego network has redundancy to the extent
-    that her contacts are connected to each other as well. The
-    nonredundant part of a person's relationships is the effective
-    size of her ego network [1]_.  Formally, the effective size of a
-    node $u$, denoted $e(u)$, is defined by
-
-    .. math::
-
-       e(u) = \sum_{v \in N(u) \setminus \{u\}}
-       \left(1 - \sum_{w \in N(v)} p_{uw} m_{vw}\right)
-
-    where $N(u)$ is the set of neighbors of $u$ and $p_{uw}$ is the
-    normalized mutual weight of the (directed or undirected) edges
-    joining $u$ and $v$, for each vertex $u$ and $v$ [1]_. And $m_{vw}$
-    is the mutual weight of $v$ and $w$ divided by $v$ highest mutual
-    weight with any of its neighbors. The *mutual weight* of $u$ and $v$
-    is the sum of the weights of edges joining them (edge weights are
-    assumed to be one if the graph is unweighted).
-
-    For the case of unweighted and undirected graphs, Borgatti proposed
-    a simplified formula to compute effective size [2]_
-
-    .. math::
-
-       e(u) = n - \frac{2t}{n}
-
-    where `t` is the number of ties in the ego network (not including
-    ties to ego) and `n` is the number of nodes (excluding ego).
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        The graph containing ``v``. Directed graphs are treated like
-        undirected graphs when computing neighbors of ``v``.
-
-    nodes : container, optional
-        Container of nodes in the graph ``G`` to compute the effective size.
-        If None, the effective size of every node is computed.
-
-    weight : None or string, optional
-      If None, all edge weights are considered equal.
-      Otherwise holds the name of the edge attribute used as weight.
-
-    Returns
-    -------
-    dict
-        Dictionary with nodes as keys and the effective size of the node as values.
-
-    Notes
-    -----
-    Isolated nodes, including nodes which only have self-loop edges, do not
-    have a well-defined effective size::
-
-        >>> G = nx.path_graph(3)
-        >>> G.add_edge(4, 4)
-        >>> nx.effective_size(G)
-        {0: 1.0, 1: 2.0, 2: 1.0, 4: nan}
-
-    Burt also defined the related concept of *efficiency* of a node's ego
-    network, which is its effective size divided by the degree of that
-    node [1]_. So you can easily compute efficiency:
-
-    >>> G = nx.DiGraph()
-    >>> G.add_edges_from([(0, 1), (0, 2), (1, 0), (2, 1)])
-    >>> esize = nx.effective_size(G)
-    >>> efficiency = {n: v / G.degree(n) for n, v in esize.items()}
-
-    See also
-    --------
-    constraint
-
-    References
-    ----------
-    .. [1] Burt, Ronald S.
-           *Structural Holes: The Social Structure of Competition.*
-           Cambridge: Harvard University Press, 1995.
-
-    .. [2] Borgatti, S.
-           "Structural Holes: Unpacking Burt's Redundancy Measures"
-           CONNECTIONS 20(1):35-38.
-           http://www.analytictech.com/connections/v20(1)/holes.htm
-
-    """
-
-    def redundancy(G, u, v, weight=None):
-        nmw = normalized_mutual_weight
-        r = sum(
-            nmw(G, u, w, weight=weight) * nmw(G, v, w, norm=max, weight=weight)
-            for w in set(nx.all_neighbors(G, u))
-        )
-        return 1 - r
-
-    # Check if scipy is available
-    try:
-        # Needed for errstate
-        import numpy as np
-
-        # make sure nx.adjacency_matrix will not raise
-        import scipy as sp
-
-        has_scipy = True
-    except:
-        has_scipy = False
-
-    if nodes is None and has_scipy:
-        # In order to compute constraint of all nodes,
-        # algorithms based on sparse matrices can be much faster
-
-        # Obtain the adjacency matrix
-        P = nx.adjacency_matrix(G, weight=weight)
-
-        # Calculate mutual weights
-        mutual_weights1 = P + P.T
-        mutual_weights2 = mutual_weights1.copy()
-
-        with np.errstate(divide="ignore"):
-            # Mutual_weights1 = Normalize mutual weights by row sums
-            mutual_weights1 /= mutual_weights1.sum(axis=1)[:, np.newaxis]
-
-            # Mutual_weights2 = Normalize mutual weights by row max
-            mutual_weights2 /= mutual_weights2.max(axis=1).toarray()
-
-        # Calculate effective sizes
-        r = 1 - (mutual_weights1 @ mutual_weights2.T).toarray()
-        effective_size = ((mutual_weights1 > 0) * r).sum(axis=1)
-
-        # Special treatment: isolated nodes (ignoring selfloops) marked with "nan"
-        sum_mutual_weights = mutual_weights1.sum(axis=1) - mutual_weights1.diagonal()
-        isolated_nodes = sum_mutual_weights == 0
-        effective_size[isolated_nodes] = float("nan")
-        # Use tolist() to automatically convert numpy scalars -> Python scalars
-        return dict(zip(G, effective_size.tolist()))
-
-    # Results for only requested nodes
-    effective_size = {}
-    if nodes is None:
-        nodes = G
-    # Use Borgatti's simplified formula for unweighted and undirected graphs
-    if not G.is_directed() and weight is None:
-        for v in nodes:
-            # Effective size is not defined for isolated nodes, including nodes
-            # with only self-edges
-            if all(u == v for u in G[v]):
-                effective_size[v] = float("nan")
-                continue
-            E = nx.ego_graph(G, v, center=False, undirected=True)
-            effective_size[v] = len(E) - (2 * E.size()) / len(E)
-    else:
-        for v in nodes:
-            # Effective size is not defined for isolated nodes, including nodes
-            # with only self-edges
-            if all(u == v for u in G[v]):
-                effective_size[v] = float("nan")
-                continue
-            effective_size[v] = sum(
-                redundancy(G, v, u, weight) for u in set(nx.all_neighbors(G, v))
-            )
-    return effective_size
-
-
-@nx._dispatchable(edge_attrs="weight")
-def constraint(G, nodes=None, weight=None):
-    r"""Returns the constraint on all nodes in the graph ``G``.
-
-    The *constraint* is a measure of the extent to which a node *v* is
-    invested in those nodes that are themselves invested in the
-    neighbors of *v*. Formally, the *constraint on v*, denoted `c(v)`,
-    is defined by
-
-    .. math::
-
-       c(v) = \sum_{w \in N(v) \setminus \{v\}} \ell(v, w)
-
-    where $N(v)$ is the subset of the neighbors of `v` that are either
-    predecessors or successors of `v` and $\ell(v, w)$ is the local
-    constraint on `v` with respect to `w` [1]_. For the definition of local
-    constraint, see :func:`local_constraint`.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        The graph containing ``v``. This can be either directed or undirected.
-
-    nodes : container, optional
-        Container of nodes in the graph ``G`` to compute the constraint. If
-        None, the constraint of every node is computed.
-
-    weight : None or string, optional
-      If None, all edge weights are considered equal.
-      Otherwise holds the name of the edge attribute used as weight.
-
-    Returns
-    -------
-    dict
-        Dictionary with nodes as keys and the constraint on the node as values.
-
-    See also
-    --------
-    local_constraint
-
-    References
-    ----------
-    .. [1] Burt, Ronald S.
-           "Structural holes and good ideas".
-           American Journal of Sociology (110): 349–399.
-
-    """
-
-    # Check if scipy is available
-    try:
-        # Needed for errstate
-        import numpy as np
-
-        # make sure nx.adjacency_matrix will not raise
-        import scipy as sp
-
-        has_scipy = True
-    except:
-        has_scipy = False
-
-    if nodes is None and has_scipy:
-        # In order to compute constraint of all nodes,
-        # algorithms based on sparse matrices can be much faster
-
-        # Obtain the adjacency matrix
-        P = nx.adjacency_matrix(G, weight=weight)
-
-        # Calculate mutual weights
-        mutual_weights = P + P.T
-
-        # Normalize mutual weights by row sums
-        sum_mutual_weights = mutual_weights.sum(axis=1)
-        with np.errstate(divide="ignore"):
-            mutual_weights /= sum_mutual_weights[:, np.newaxis]
-
-        # Calculate local constraints and constraints
-        local_constraints = (mutual_weights + mutual_weights @ mutual_weights) ** 2
-        constraints = ((mutual_weights > 0) * local_constraints).sum(axis=1)
-
-        # Special treatment: isolated nodes marked with "nan"
-        isolated_nodes = sum_mutual_weights - 2 * mutual_weights.diagonal() == 0
-        constraints[isolated_nodes] = float("nan")
-        # Use tolist() to automatically convert numpy scalars -> Python scalars
-        return dict(zip(G, constraints.tolist()))
-
-    # Result for only requested nodes
-    constraint = {}
-    if nodes is None:
-        nodes = G
-    for v in nodes:
-        # Constraint is not defined for isolated nodes
-        if len(G[v]) == 0:
-            constraint[v] = float("nan")
-            continue
-        constraint[v] = sum(
-            local_constraint(G, v, n, weight) for n in set(nx.all_neighbors(G, v))
-        )
-    return constraint
-
-
-@nx._dispatchable(edge_attrs="weight")
-def local_constraint(G, u, v, weight=None):
-    r"""Returns the local constraint on the node ``u`` with respect to
-    the node ``v`` in the graph ``G``.
-
-    Formally, the *local constraint on u with respect to v*, denoted
-    $\ell(u, v)$, is defined by
-
-    .. math::
-
-       \ell(u, v) = \left(p_{uv} + \sum_{w \in N(v)} p_{uw} p_{wv}\right)^2,
-
-    where $N(v)$ is the set of neighbors of $v$ and $p_{uv}$ is the
-    normalized mutual weight of the (directed or undirected) edges
-    joining $u$ and $v$, for each vertex $u$ and $v$ [1]_. The *mutual
-    weight* of $u$ and $v$ is the sum of the weights of edges joining
-    them (edge weights are assumed to be one if the graph is
-    unweighted).
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        The graph containing ``u`` and ``v``. This can be either
-        directed or undirected.
-
-    u : node
-        A node in the graph ``G``.
-
-    v : node
-        A node in the graph ``G``.
-
-    weight : None or string, optional
-      If None, all edge weights are considered equal.
-      Otherwise holds the name of the edge attribute used as weight.
-
-    Returns
-    -------
-    float
-        The constraint of the node ``v`` in the graph ``G``.
-
-    See also
-    --------
-    constraint
-
-    References
-    ----------
-    .. [1] Burt, Ronald S.
-           "Structural holes and good ideas".
-           American Journal of Sociology (110): 349–399.
-
-    """
-    nmw = normalized_mutual_weight
-    direct = nmw(G, u, v, weight=weight)
-    indirect = sum(
-        nmw(G, u, w, weight=weight) * nmw(G, w, v, weight=weight)
-        for w in set(nx.all_neighbors(G, u))
-    )
-    return (direct + indirect) ** 2