okstra 0.130.4 → 0.131.0

package/runtime/python/okstra_vendor/networkx/generators/nonisomorphic_trees.py

@@ -1,259 +0,0 @@
-"""
-Implementation of the Wright, Richmond, Odlyzko and McKay (WROM)
-algorithm for the enumeration of all non-isomorphic free trees of a
-given order.  Rooted trees are represented by level sequences, i.e.,
-lists in which the i-th element specifies the distance of vertex i to
-the root.
-
-"""
-
-__all__ = ["nonisomorphic_trees", "number_of_nonisomorphic_trees"]
-
-from functools import lru_cache
-
-import networkx as nx
-
-
-@nx._dispatchable(graphs=None, returns_graph=True)
-def nonisomorphic_trees(order):
-    """Generate nonisomorphic trees of specified `order`.
-
-    Parameters
-    ----------
-    order : int
-       order of the desired tree(s)
-
-    Yields
-    ------
-    `networkx.Graph` instances
-       A tree with `order` number of nodes that is not isomorphic to any other
-       yielded tree.
-
-    Raises
-    ------
-    ValueError
-       If `order` is negative.
-
-    Examples
-    --------
-    There are 11 unique (non-isomorphic) trees with 7 nodes.
-
-    >>> n = 7
-    >>> nit_list = list(nx.nonisomorphic_trees(n))
-    >>> len(nit_list) == nx.number_of_nonisomorphic_trees(n) == 11
-    True
-
-    All trees yielded by the generator have the specified order.
-
-    >>> all(len(G) == n for G in nx.nonisomorphic_trees(n))
-    True
-
-    Each tree is nonisomorphic to every other tree yielded by the generator.
-    >>> seen = []
-    >>> for G in nx.nonisomorphic_trees(n):
-    ...     assert not any(nx.is_isomorphic(G, H) for H in seen)
-    ...     seen.append(G)
-
-    See Also
-    --------
-    number_of_nonisomorphic_trees
-    """
-    if order < 0:
-        raise ValueError("order must be non-negative")
-    if order == 0:
-        # Idiom for empty generator, i.e. list(nonisomorphic_trees(0)) == []
-        return
-        yield
-    if order == 1:
-        yield nx.empty_graph(1)
-        return
-    # start at the path graph rooted at its center
-    layout = list(range(order // 2 + 1)) + list(range(1, (order + 1) // 2))
-
-    while layout is not None:
-        layout = _next_tree(layout)
-        if layout is not None:
-            yield _layout_to_graph(layout)
-            layout = _next_rooted_tree(layout)
-
-
-@nx._dispatchable(graphs=None)
-def number_of_nonisomorphic_trees(order):
-    """Returns the number of nonisomorphic trees of the specified `order`.
-
-    Based on an algorithm by Alois P. Heinz in
-    `OEIS entry A000055 <https://oeis.org/A000055>`_. Complexity is ``O(n ** 3)``.
-
-    Parameters
-    ----------
-    order : int
-       Order of the desired tree(s).
-
-    Returns
-    -------
-    int
-       Number of nonisomorphic trees with `order` number of nodes.
-
-    Raises
-    ------
-    ValueError
-       If `order` is negative.
-
-    Examples
-    --------
-    >>> nx.number_of_nonisomorphic_trees(10)
-    106
-
-    See Also
-    --------
-    nonisomorphic_trees
-    """
-    if order < 0:
-        raise ValueError("order must be non-negative")
-    return _unlabeled_trees(order)
-
-
-@lru_cache(None)
-def _unlabeled_trees(n):
-    """Implements OEIS A000055 (number of unlabeled trees)."""
-
-    value = 0
-    for k in range(n + 1):
-        value += _rooted_trees(k) * _rooted_trees(n - k)
-    if n % 2 == 0:
-        value -= _rooted_trees(n // 2)
-    return _rooted_trees(n) - value // 2
-
-
-@lru_cache(None)
-def _rooted_trees(n):
-    """Implements OEIS A000081 (number of unlabeled rooted trees)."""
-
-    if n < 2:
-        return n
-    value = 0
-    for j in range(1, n):
-        for d in range(1, n):
-            if j % d == 0:
-                value += d * _rooted_trees(d) * _rooted_trees(n - j)
-    return value // (n - 1)
-
-
-def _next_rooted_tree(predecessor, p=None):
-    """One iteration of the Beyer-Hedetniemi algorithm."""
-
-    if p is None:
-        p = len(predecessor) - 1
-        while predecessor[p] == 1:
-            p -= 1
-    if p == 0:
-        return None
-
-    q = p - 1
-    while predecessor[q] != predecessor[p] - 1:
-        q -= 1
-    result = list(predecessor)
-    for i in range(p, len(result)):
-        result[i] = result[i - p + q]
-    return result
-
-
-def _next_tree(candidate):
-    """One iteration of the Wright, Richmond, Odlyzko and McKay
-    algorithm."""
-
-    # valid representation of a free tree if:
-    # there are at least two vertices at layer 1
-    # (this is always the case because we start at the path graph)
-    left, rest = _split_tree(candidate)
-
-    # and the left subtree of the root
-    # is less high than the tree with the left subtree removed
-    left_height = max(left)
-    rest_height = max(rest)
-    valid = rest_height >= left_height
-
-    if valid and rest_height == left_height:
-        # and, if left and rest are of the same height,
-        # if left does not encompass more vertices
-        if len(left) > len(rest):
-            valid = False
-        # and, if they have the same number or vertices,
-        # if left does not come after rest lexicographically
-        elif len(left) == len(rest) and left > rest:
-            valid = False
-
-    if valid:
-        return candidate
-    else:
-        # jump to the next valid free tree
-        p = len(left)
-        new_candidate = _next_rooted_tree(candidate, p)
-        if candidate[p] > 2:
-            new_left, new_rest = _split_tree(new_candidate)
-            new_left_height = max(new_left)
-            suffix = range(1, new_left_height + 2)
-            new_candidate[-len(suffix) :] = suffix
-        return new_candidate
-
-
-def _split_tree(layout):
-    """Returns a tuple of two layouts, one containing the left
-    subtree of the root vertex, and one containing the original tree
-    with the left subtree removed."""
-
-    one_found = False
-    m = None
-    for i in range(len(layout)):
-        if layout[i] == 1:
-            if one_found:
-                m = i
-                break
-            else:
-                one_found = True
-
-    if m is None:
-        m = len(layout)
-
-    left = [layout[i] - 1 for i in range(1, m)]
-    rest = [0] + [layout[i] for i in range(m, len(layout))]
-    return (left, rest)
-
-
-def _layout_to_matrix(layout):
-    """Create the adjacency matrix for the tree specified by the
-    given layout (level sequence)."""
-
-    result = [[0] * len(layout) for i in range(len(layout))]
-    stack = []
-    for i in range(len(layout)):
-        i_level = layout[i]
-        if stack:
-            j = stack[-1]
-            j_level = layout[j]
-            while j_level >= i_level:
-                stack.pop()
-                j = stack[-1]
-                j_level = layout[j]
-            result[i][j] = result[j][i] = 1
-        stack.append(i)
-    return result
-
-
-def _layout_to_graph(layout):
-    """Create a NetworkX Graph for the tree specified by the
-    given layout(level sequence)"""
-    G = nx.Graph()
-    stack = []
-    for i in range(len(layout)):
-        i_level = layout[i]
-        if stack:
-            j = stack[-1]
-            j_level = layout[j]
-            while j_level >= i_level:
-                stack.pop()
-                j = stack[-1]
-                j_level = layout[j]
-            G.add_edge(i, j)
-        stack.append(i)
-    return G

package/runtime/python/okstra_vendor/networkx/generators/random_clustered.py

@@ -1,117 +0,0 @@
-"""Generate graphs with given degree and triangle sequence."""
-
-import networkx as nx
-from networkx.utils import py_random_state
-
-__all__ = ["random_clustered_graph"]
-
-
-@py_random_state(2)
-@nx._dispatchable(graphs=None, returns_graph=True)
-def random_clustered_graph(joint_degree_sequence, create_using=None, seed=None):
-    r"""Generate a random graph with the given joint independent edge degree and
-    triangle degree sequence.
-
-    This uses a configuration model-like approach to generate a random graph
-    (with parallel edges and self-loops) by randomly assigning edges to match
-    the given joint degree sequence.
-
-    The joint degree sequence is a list of pairs of integers of the form
-    $[(d_{1,i}, d_{1,t}), \dotsc, (d_{n,i}, d_{n,t})]$. According to this list,
-    vertex $u$ is a member of $d_{u,t}$ triangles and has $d_{u, i}$ other
-    edges. The number $d_{u,t}$ is the *triangle degree* of $u$ and the number
-    $d_{u,i}$ is the *independent edge degree*.
-
-    Parameters
-    ----------
-    joint_degree_sequence : list of integer pairs
-        Each list entry corresponds to the independent edge degree and
-        triangle degree of a node.
-    create_using : NetworkX graph constructor, optional (default MultiGraph)
-       Graph type to create. If graph instance, then cleared before populated.
-    seed : integer, random_state, or None (default)
-        Indicator of random number generation state.
-        See :ref:`Randomness<randomness>`.
-
-    Returns
-    -------
-    G : MultiGraph
-        A graph with the specified degree sequence. Nodes are labeled
-        starting at 0 with an index corresponding to the position in
-        deg_sequence.
-
-    Raises
-    ------
-    NetworkXError
-        If the independent edge degree sequence sum is not even
-        or the triangle degree sequence sum is not divisible by 3.
-
-    Notes
-    -----
-    As described by Miller [1]_ (see also Newman [2]_ for an equivalent
-    description).
-
-    A non-graphical degree sequence (not realizable by some simple
-    graph) is allowed since this function returns graphs with self
-    loops and parallel edges.  An exception is raised if the
-    independent degree sequence does not have an even sum or the
-    triangle degree sequence sum is not divisible by 3.
-
-    This configuration model-like construction process can lead to
-    duplicate edges and loops.  You can remove the self-loops and
-    parallel edges (see below) which will likely result in a graph
-    that doesn't have the exact degree sequence specified.  This
-    "finite-size effect" decreases as the size of the graph increases.
-
-    References
-    ----------
-    .. [1] Joel C. Miller. "Percolation and epidemics in random clustered
-           networks". In: Physical review. E, Statistical, nonlinear, and soft
-           matter physics 80 (2 Part 1 August 2009).
-    .. [2] M. E. J. Newman. "Random Graphs with Clustering".
-           In: Physical Review Letters 103 (5 July 2009)
-
-    Examples
-    --------
-    >>> deg = [(1, 0), (1, 0), (1, 0), (2, 0), (1, 0), (2, 1), (0, 1), (0, 1)]
-    >>> G = nx.random_clustered_graph(deg)
-
-    To remove parallel edges:
-
-    >>> G = nx.Graph(G)
-
-    To remove self loops:
-
-    >>> G.remove_edges_from(nx.selfloop_edges(G))
-
-    """
-    # In Python 3, zip() returns an iterator. Make this into a list.
-    joint_degree_sequence = list(joint_degree_sequence)
-
-    N = len(joint_degree_sequence)
-    G = nx.empty_graph(N, create_using, default=nx.MultiGraph)
-    if G.is_directed():
-        raise nx.NetworkXError("Directed Graph not supported")
-
-    ilist = []
-    tlist = []
-    for n in G:
-        degrees = joint_degree_sequence[n]
-        for icount in range(degrees[0]):
-            ilist.append(n)
-        for tcount in range(degrees[1]):
-            tlist.append(n)
-
-    if len(ilist) % 2 != 0 or len(tlist) % 3 != 0:
-        raise nx.NetworkXError("Invalid degree sequence")
-
-    seed.shuffle(ilist)
-    seed.shuffle(tlist)
-    while ilist:
-        G.add_edge(ilist.pop(), ilist.pop())
-    while tlist:
-        n1 = tlist.pop()
-        n2 = tlist.pop()
-        n3 = tlist.pop()
-        G.add_edges_from([(n1, n2), (n1, n3), (n2, n3)])
-    return G