okstra 0.130.4 → 0.131.1

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

@@ -1,272 +0,0 @@
-"""
-=======================
-Distance-regular graphs
-=======================
-"""
-
-from collections import defaultdict
-from itertools import combinations_with_replacement
-from math import log
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-from .distance_measures import diameter
-
-__all__ = [
-    "is_distance_regular",
-    "is_strongly_regular",
-    "intersection_array",
-    "global_parameters",
-]
-
-
-@nx._dispatchable
-def is_distance_regular(G):
-    """Returns True if the graph is distance regular, False otherwise.
-
-    A connected graph G is distance-regular if for any nodes x,y
-    and any integers i,j=0,1,...,d (where d is the graph
-    diameter), the number of vertices at distance i from x and
-    distance j from y depends only on i,j and the graph distance
-    between x and y, independently of the choice of x and y.
-
-    Parameters
-    ----------
-    G: Networkx graph (undirected)
-
-    Returns
-    -------
-    bool
-      True if the graph is Distance Regular, False otherwise
-
-    Examples
-    --------
-    >>> G = nx.hypercube_graph(6)
-    >>> nx.is_distance_regular(G)
-    True
-
-    See Also
-    --------
-    intersection_array, global_parameters
-
-    Notes
-    -----
-    For undirected and simple graphs only
-
-    References
-    ----------
-    .. [1] Brouwer, A. E.; Cohen, A. M.; and Neumaier, A.
-        Distance-Regular Graphs. New York: Springer-Verlag, 1989.
-    .. [2] Weisstein, Eric W. "Distance-Regular Graph."
-        http://mathworld.wolfram.com/Distance-RegularGraph.html
-
-    """
-    try:
-        intersection_array(G)
-        return True
-    except nx.NetworkXError:
-        return False
-
-
-def global_parameters(b, c):
-    """Returns global parameters for a given intersection array.
-
-    Given a distance-regular graph G with diameter d and integers b_i,
-    c_i,i = 0,....,d such that for any 2 vertices x,y in G at a distance
-    i=d(x,y), there are exactly c_i neighbors of y at a distance of i-1 from x
-    and b_i neighbors of y at a distance of i+1 from x.
-
-    Thus, a distance regular graph has the global parameters,
-    [[c_0,a_0,b_0],[c_1,a_1,b_1],......,[c_d,a_d,b_d]] for the
-    intersection array  [b_0,b_1,.....b_{d-1};c_1,c_2,.....c_d]
-    where a_i+b_i+c_i=k , k= degree of every vertex.
-
-    Parameters
-    ----------
-    b : list
-
-    c : list
-
-    Returns
-    -------
-    iterable
-       An iterable over three tuples.
-
-    Examples
-    --------
-    >>> G = nx.dodecahedral_graph()
-    >>> b, c = nx.intersection_array(G)
-    >>> list(nx.global_parameters(b, c))
-    [(0, 0, 3), (1, 0, 2), (1, 1, 1), (1, 1, 1), (2, 0, 1), (3, 0, 0)]
-
-    References
-    ----------
-    .. [1] Weisstein, Eric W. "Global Parameters."
-       From MathWorld--A Wolfram Web Resource.
-       http://mathworld.wolfram.com/GlobalParameters.html
-
-    See Also
-    --------
-    intersection_array
-    """
-    return ((y, b[0] - x - y, x) for x, y in zip(b + [0], [0] + c))
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def intersection_array(G):
-    """Returns the intersection array of a distance-regular graph.
-
-    Given a distance-regular graph G with integers b_i, c_i,i = 0,....,d
-    such that for any 2 vertices x,y in G at a distance i=d(x,y), there
-    are exactly c_i neighbors of y at a distance of i-1 from x and b_i
-    neighbors of y at a distance of i+1 from x.
-
-    A distance regular graph's intersection array is given by,
-    [b_0,b_1,.....b_{d-1};c_1,c_2,.....c_d]
-
-    Parameters
-    ----------
-    G: Networkx graph (undirected)
-
-    Returns
-    -------
-    b,c: tuple of lists
-
-    Examples
-    --------
-    >>> G = nx.icosahedral_graph()
-    >>> nx.intersection_array(G)
-    ([5, 2, 1], [1, 2, 5])
-
-    References
-    ----------
-    .. [1] Weisstein, Eric W. "Intersection Array."
-       From MathWorld--A Wolfram Web Resource.
-       http://mathworld.wolfram.com/IntersectionArray.html
-
-    See Also
-    --------
-    global_parameters
-    """
-    # the input graph is very unlikely to be distance-regular: here are the
-    # number a(n) of connected simple graphs, and the number b(n) of
-    # distance-regular graphs among them:
-    #
-    #    n  | 1 2 3 4  5   6   7     8      9       10
-    #  -----+------------------------------------------------------------------
-    #  a(n) | 1 1 2 6 21 112 853 11117 261080 11716571 https://oeis.org/A001349
-    #  b(n) | 1 1 1 2  2   4   2     5      4        7 https://oeis.org/A241814
-    #
-    # in light of this, let's compute shortest path lengths as we go instead of
-    # precomputing them all
-    # test for regular graph (all degrees must be equal)
-    if not nx.is_regular(G) or not nx.is_connected(G):
-        raise nx.NetworkXError("Graph is not distance regular.")
-
-    path_length = defaultdict(dict)
-    bint = {}  # 'b' intersection array
-    cint = {}  # 'c' intersection array
-
-    # see https://doi.org/10.1016/j.ejc.2004.07.004, Theorem 1.5, page 81:
-    # the diameter of a distance-regular graph is at most (8 log_2 n) / 3,
-    # so let's compute it as we go in the hope that we can stop early
-    diam = 0
-    max_diameter_for_dr_graphs = (8 * log(len(G), 2)) / 3
-    for u, v in combinations_with_replacement(G, 2):
-        # compute needed shortest path lengths
-        pl_u = path_length[u]
-        if v not in pl_u:
-            pl_u.update(nx.single_source_shortest_path_length(G, u))
-            for x, distance in pl_u.items():
-                path_length[x][u] = distance
-
-        i = path_length[u][v]
-        diam = max(diam, i)
-
-        # diameter too large: graph can't be distance-regular
-        if diam > max_diameter_for_dr_graphs:
-            raise nx.NetworkXError("Graph is not distance regular.")
-
-        vnbrs = G[v]
-        # compute needed path lengths
-        for n in vnbrs:
-            pl_n = path_length[n]
-            if u not in pl_n:
-                pl_n.update(nx.single_source_shortest_path_length(G, n))
-                for x, distance in pl_n.items():
-                    path_length[x][n] = distance
-
-        # number of neighbors of v at a distance of i-1 from u
-        c = sum(1 for n in vnbrs if pl_u[n] == i - 1)
-        # number of neighbors of v at a distance of i+1 from u
-        b = sum(1 for n in vnbrs if pl_u[n] == i + 1)
-        # b, c are independent of u and v
-        if cint.get(i, c) != c or bint.get(i, b) != b:
-            raise nx.NetworkXError("Graph is not distance regular")
-        bint[i] = b
-        cint[i] = c
-
-    return (
-        [bint.get(j, 0) for j in range(diam)],
-        [cint.get(j + 1, 0) for j in range(diam)],
-    )
-
-
-# TODO There is a definition for directed strongly regular graphs.
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def is_strongly_regular(G):
-    """Returns True if and only if the given graph is strongly
-    regular.
-
-    An undirected graph is *strongly regular* if
-
-    * it is regular,
-    * each pair of adjacent vertices has the same number of neighbors in
-      common,
-    * each pair of nonadjacent vertices has the same number of neighbors
-      in common.
-
-    Each strongly regular graph is a distance-regular graph.
-    Conversely, if a distance-regular graph has diameter two, then it is
-    a strongly regular graph. For more information on distance-regular
-    graphs, see :func:`is_distance_regular`.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        An undirected graph.
-
-    Returns
-    -------
-    bool
-        Whether `G` is strongly regular.
-
-    Examples
-    --------
-
-    The cycle graph on five vertices is strongly regular. It is
-    two-regular, each pair of adjacent vertices has no shared neighbors,
-    and each pair of nonadjacent vertices has one shared neighbor::
-
-        >>> G = nx.cycle_graph(5)
-        >>> nx.is_strongly_regular(G)
-        True
-
-    """
-    # Here is an alternate implementation based directly on the
-    # definition of strongly regular graphs:
-    #
-    #     return (all_equal(G.degree().values())
-    #             and all_equal(len(common_neighbors(G, u, v))
-    #                           for u, v in G.edges())
-    #             and all_equal(len(common_neighbors(G, u, v))
-    #                           for u, v in non_edges(G)))
-    #
-    # We instead use the fact that a distance-regular graph of diameter
-    # two is strongly regular.
-    return is_distance_regular(G) and diameter(G) == 2

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

@@ -1,142 +0,0 @@
-"""
-Dominance algorithms.
-"""
-
-from functools import reduce
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["immediate_dominators", "dominance_frontiers"]
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable
-def immediate_dominators(G, start):
-    """Returns the immediate dominators of all nodes of a directed graph.
-
-    Parameters
-    ----------
-    G : a DiGraph or MultiDiGraph
-        The graph where dominance is to be computed.
-
-    start : node
-        The start node of dominance computation.
-
-    Returns
-    -------
-    idom : dict keyed by nodes
-        A dict containing the immediate dominators of each node reachable from
-        `start`, except for `start` itself.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is undirected.
-
-    NetworkXError
-        If `start` is not in `G`.
-
-    Notes
-    -----
-    The immediate dominators are the parents of their corresponding nodes in
-    the dominator tree. Every node reachable from `start` has an immediate
-    dominator, except for `start` itself.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(1, 2), (1, 3), (2, 5), (3, 4), (4, 5)])
-    >>> sorted(nx.immediate_dominators(G, 1).items())
-    [(2, 1), (3, 1), (4, 3), (5, 1)]
-
-    References
-    ----------
-    .. [1] Cooper, Keith D., Harvey, Timothy J. and Kennedy, Ken.
-           "A simple, fast dominance algorithm." (2006).
-           https://hdl.handle.net/1911/96345
-    .. [2] Lengauer, Thomas; Tarjan, Robert Endre (July 1979).
-           "A fast algorithm for finding dominators in a flowgraph".
-           ACM Transactions on Programming Languages and Systems. 1 (1): 121--141.
-           https://dl.acm.org/doi/10.1145/357062.357071
-    """
-    if start not in G:
-        raise nx.NetworkXError("start is not in G")
-
-    idom = {start: None}
-
-    order = list(nx.dfs_postorder_nodes(G, start))
-    dfn = {u: i for i, u in enumerate(order)}
-    order.pop()
-    order.reverse()
-
-    def intersect(u, v):
-        while u != v:
-            while dfn[u] < dfn[v]:
-                u = idom[u]
-            while dfn[u] > dfn[v]:
-                v = idom[v]
-        return u
-
-    changed = True
-    while changed:
-        changed = False
-        for u in order:
-            new_idom = reduce(intersect, (v for v in G.pred[u] if v in idom))
-            if u not in idom or idom[u] != new_idom:
-                idom[u] = new_idom
-                changed = True
-
-    del idom[start]
-    return idom
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable
-def dominance_frontiers(G, start):
-    """Returns the dominance frontiers of all nodes of a directed graph.
-
-    Parameters
-    ----------
-    G : a DiGraph or MultiDiGraph
-        The graph where dominance is to be computed.
-
-    start : node
-        The start node of dominance computation.
-
-    Returns
-    -------
-    df : dict keyed by nodes
-        A dict containing the dominance frontiers of each node reachable from
-        `start` as lists.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is undirected.
-
-    NetworkXError
-        If `start` is not in `G`.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(1, 2), (1, 3), (2, 5), (3, 4), (4, 5)])
-    >>> sorted((u, sorted(df)) for u, df in nx.dominance_frontiers(G, 1).items())
-    [(1, []), (2, [5]), (3, [5]), (4, [5]), (5, [])]
-
-    References
-    ----------
-    .. [1] Cooper, Keith D., Harvey, Timothy J. and Kennedy, Ken.
-           "A simple, fast dominance algorithm." (2006).
-           https://hdl.handle.net/1911/96345
-    """
-    idom = nx.immediate_dominators(G, start) | {start: None}
-
-    df = {u: set() for u in idom}
-    for u in idom:
-        if u == start or len(G.pred[u]) >= 2:
-            for v in G.pred[u]:
-                if v in idom:
-                    while v != idom[u]:
-                        df[v].add(u)
-                        v = idom[v]
-    return df

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

@@ -1,268 +0,0 @@
-"""Functions for computing dominating sets in a graph."""
-
-import math
-from heapq import heappop, heappush
-from itertools import chain, count
-
-import networkx as nx
-
-__all__ = [
-    "dominating_set",
-    "is_dominating_set",
-    "connected_dominating_set",
-    "is_connected_dominating_set",
-]
-
-
-@nx._dispatchable
-def dominating_set(G, start_with=None):
-    r"""Finds a dominating set for the graph G.
-
-    A *dominating set* for a graph with node set *V* is a subset *D* of
-    *V* such that every node not in *D* is adjacent to at least one
-    member of *D* [1]_.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    start_with : node (default=None)
-        Node to use as a starting point for the algorithm.
-
-    Returns
-    -------
-    D : set
-        A dominating set for G.
-
-    Notes
-    -----
-    This function is an implementation of algorithm 7 in [2]_ which
-    finds some dominating set, not necessarily the smallest one.
-
-    See also
-    --------
-    is_dominating_set
-
-    References
-    ----------
-    .. [1] https://en.wikipedia.org/wiki/Dominating_set
-
-    .. [2] Abdol-Hossein Esfahanian. Connectivity Algorithms.
-        http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
-
-    """
-    all_nodes = set(G)
-    if start_with is None:
-        start_with = nx.utils.arbitrary_element(all_nodes)
-    if start_with not in G:
-        raise nx.NetworkXError(f"node {start_with} is not in G")
-    dominating_set = {start_with}
-    dominated_nodes = set(G[start_with])
-    remaining_nodes = all_nodes - dominated_nodes - dominating_set
-    while remaining_nodes:
-        # Choose an arbitrary node and determine its undominated neighbors.
-        v = remaining_nodes.pop()
-        undominated_nbrs = set(G[v]) - dominating_set
-        # Add the node to the dominating set and the neighbors to the
-        # dominated set. Finally, remove all of those nodes from the set
-        # of remaining nodes.
-        dominating_set.add(v)
-        dominated_nodes |= undominated_nbrs
-        remaining_nodes -= undominated_nbrs
-    return dominating_set
-
-
-@nx._dispatchable
-def is_dominating_set(G, nbunch):
-    """Checks if `nbunch` is a dominating set for `G`.
-
-    A *dominating set* for a graph with node set *V* is a subset *D* of
-    *V* such that every node not in *D* is adjacent to at least one
-    member of *D* [1]_.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    nbunch : iterable
-        An iterable of nodes in the graph `G`.
-
-    Returns
-    -------
-    dominating : bool
-        True if `nbunch` is a dominating set of `G`, false otherwise.
-
-    See also
-    --------
-    dominating_set
-
-    References
-    ----------
-    .. [1] https://en.wikipedia.org/wiki/Dominating_set
-
-    """
-    testset = {n for n in nbunch if n in G}
-    nbrs = set(chain.from_iterable(G[n] for n in testset))
-    return len(set(G) - testset - nbrs) == 0
-
-
-@nx.utils.not_implemented_for("directed")
-@nx._dispatchable
-def connected_dominating_set(G):
-    """Returns a connected dominating set.
-
-    A *dominating set* for a graph *G* with node set *V* is a subset *D* of *V*
-    such that every node not in *D* is adjacent to at least one member of *D*
-    [1]_. A *connected dominating set* is a dominating set *C* that induces a
-    connected subgraph of *G* [2]_.
-    Note that connected dominating sets are not unique in general and that there
-    may be other connected dominating sets.
-
-    Parameters
-    ----------
-    G : NewtorkX graph
-        Undirected connected graph.
-
-    Returns
-    -------
-    connected_dominating_set : set
-        A dominating set of nodes which induces a connected subgraph of G.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If G is directed.
-
-    NetworkXError
-        If G is disconnected.
-
-    Examples
-    ________
-    >>> G = nx.Graph(
-    ...     [
-    ...         (1, 2),
-    ...         (1, 3),
-    ...         (1, 4),
-    ...         (1, 5),
-    ...         (1, 6),
-    ...         (2, 7),
-    ...         (3, 8),
-    ...         (4, 9),
-    ...         (5, 10),
-    ...         (6, 11),
-    ...         (7, 12),
-    ...         (8, 12),
-    ...         (9, 12),
-    ...         (10, 12),
-    ...         (11, 12),
-    ...     ]
-    ... )
-    >>> nx.connected_dominating_set(G)
-    {1, 2, 3, 4, 5, 6, 7}
-
-    Notes
-    -----
-    This function implements Algorithm I in its basic version as described
-    in [3]_. The idea behind the algorithm is the following: grow a tree *T*,
-    starting from a node with maximum degree. Throughout the growing process,
-    nonleaf nodes in *T* are our connected dominating set (CDS), leaf nodes in
-    *T* are marked as "seen" and nodes in G that are not yet in *T* are marked as
-    "unseen". We maintain a max-heap of all "seen" nodes, and track the number
-    of "unseen" neighbors for each node. At each step we pop the heap top -- a
-    "seen" (leaf) node with maximal number of "unseen" neighbors, add it to the
-    CDS and mark all its "unseen" neighbors as "seen". For each one of the newly
-    created "seen" nodes, we also decrement the number of "unseen" neighbors for
-    all its neighbors. The algorithm terminates when there are no more "unseen"
-    nodes.
-    Runtime complexity of this implementation is $O(|E|*log|V|)$ (amortized).
-
-    References
-    ----------
-    .. [1] https://en.wikipedia.org/wiki/Dominating_set
-    .. [2] https://en.wikipedia.org/wiki/Connected_dominating_set
-    .. [3] Guha, S. and Khuller, S.
-           *Approximation Algorithms for Connected Dominating Sets*,
-           Algorithmica, 20, 374-387, 1998.
-
-    """
-    if len(G) == 0:
-        return set()
-
-    if not nx.is_connected(G):
-        raise nx.NetworkXError("G must be a connected graph")
-
-    if len(G) == 1:
-        return set(G)
-
-    G_succ = G._adj  # For speed-up
-
-    # Use the count c to avoid comparing nodes
-    c = count()
-
-    # Keep track of the number of unseen nodes adjacent to each node
-    unseen_degree = dict(G.degree)
-
-    # Find node with highest degree and update its neighbors
-    (max_deg_node, max_deg) = max(unseen_degree.items(), key=lambda x: x[1])
-    for nbr in G_succ[max_deg_node]:
-        unseen_degree[nbr] -= 1
-
-    # Initially all nodes except max_deg_node are unseen
-    unseen = set(G) - {max_deg_node}
-
-    # We want a max-heap of the unseen-degree using heapq, which is a min-heap
-    # So we store the negative of the unseen-degree
-    seen = [(-max_deg, next(c), max_deg_node)]
-
-    connected_dominating_set = set()
-
-    # Main loop
-    while unseen:
-        (neg_deg, cnt, u) = heappop(seen)
-        # Check if u's unseen-degree changed while in the heap
-        if -neg_deg > unseen_degree[u]:
-            heappush(seen, (-unseen_degree[u], cnt, u))
-            continue
-        # Mark all u's unseen neighbors as seen and add them to the heap
-        for v in G_succ[u]:
-            if v in unseen:
-                unseen.remove(v)
-                for nbr in G_succ[v]:
-                    unseen_degree[nbr] -= 1
-                heappush(seen, (-unseen_degree[v], next(c), v))
-        # Add u to the dominating set
-        connected_dominating_set.add(u)
-
-    return connected_dominating_set
-
-
-@nx.utils.not_implemented_for("directed")
-@nx._dispatchable
-def is_connected_dominating_set(G, nbunch):
-    """Checks if `nbunch` is a connected dominating set for `G`.
-
-    A *dominating set* for a graph *G* with node set *V* is a subset *D* of
-    *V* such that every node not in *D* is adjacent to at least one
-    member of *D* [1]_. A *connected dominating set* is a dominating
-    set *C* that induces a connected subgraph of *G* [2]_.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Undirected graph.
-
-    nbunch : iterable
-        An iterable of nodes in the graph `G`.
-
-    Returns
-    -------
-    connected_dominating : bool
-        True if `nbunch` is connected dominating set of `G`, false otherwise.
-
-    References
-    ----------
-    .. [1] https://en.wikipedia.org/wiki/Dominating_set
-    .. [2] https://en.wikipedia.org/wiki/Connected_dominating_set
-
-    """
-    return nx.is_dominating_set(G, nbunch) and nx.is_connected(nx.subgraph(G, nbunch))