okstra 0.108.0 → 0.109.0

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

@@ -0,0 +1,272 @@
+"""
+=======================
+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

@@ -0,0 +1,142 @@
+"""
+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

@@ -0,0 +1,268 @@
+"""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))