okstra 0.130.4 → 0.131.0

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

@@ -1,172 +0,0 @@
-"""Functions for finding chains in a graph."""
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["chain_decomposition"]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def chain_decomposition(G, root=None):
-    """Returns the chain decomposition of a graph.
-
-    The *chain decomposition* of a graph with respect a depth-first
-    search tree is a set of cycles or paths derived from the set of
-    fundamental cycles of the tree in the following manner. Consider
-    each fundamental cycle with respect to the given tree, represented
-    as a list of edges beginning with the nontree edge oriented away
-    from the root of the tree. For each fundamental cycle, if it
-    overlaps with any previous fundamental cycle, just take the initial
-    non-overlapping segment, which is a path instead of a cycle. Each
-    cycle or path is called a *chain*. For more information, see [1]_.
-
-    Parameters
-    ----------
-    G : undirected graph
-
-    root : node (optional)
-       A node in the graph `G`. If specified, only the chain
-       decomposition for the connected component containing this node
-       will be returned. This node indicates the root of the depth-first
-       search tree.
-
-    Yields
-    ------
-    chain : list
-       A list of edges representing a chain. There is no guarantee on
-       the orientation of the edges in each chain (for example, if a
-       chain includes the edge joining nodes 1 and 2, the chain may
-       include either (1, 2) or (2, 1)).
-
-    Raises
-    ------
-    NodeNotFound
-       If `root` is not in the graph `G`.
-
-    Examples
-    --------
-    >>> G = nx.Graph([(0, 1), (1, 4), (3, 4), (3, 5), (4, 5)])
-    >>> list(nx.chain_decomposition(G))
-    [[(4, 5), (5, 3), (3, 4)]]
-
-    Notes
-    -----
-    The worst-case running time of this implementation is linear in the
-    number of nodes and number of edges [1]_.
-
-    References
-    ----------
-    .. [1] Jens M. Schmidt (2013). "A simple test on 2-vertex-
-       and 2-edge-connectivity." *Information Processing Letters*,
-       113, 241–244. Elsevier. <https://doi.org/10.1016/j.ipl.2013.01.016>
-
-    """
-
-    def _dfs_cycle_forest(G, root=None):
-        """Builds a directed graph composed of cycles from the given graph.
-
-        `G` is an undirected simple graph. `root` is a node in the graph
-        from which the depth-first search is started.
-
-        This function returns both the depth-first search cycle graph
-        (as a :class:`~networkx.DiGraph`) and the list of nodes in
-        depth-first preorder. The depth-first search cycle graph is a
-        directed graph whose edges are the edges of `G` oriented toward
-        the root if the edge is a tree edge and away from the root if
-        the edge is a non-tree edge. If `root` is not specified, this
-        performs a depth-first search on each connected component of `G`
-        and returns a directed forest instead.
-
-        If `root` is not in the graph, this raises :exc:`KeyError`.
-
-        """
-        # Create a directed graph from the depth-first search tree with
-        # root node `root` in which tree edges are directed toward the
-        # root and nontree edges are directed away from the root. For
-        # each node with an incident nontree edge, this creates a
-        # directed cycle starting with the nontree edge and returning to
-        # that node.
-        #
-        # The `parent` node attribute stores the parent of each node in
-        # the DFS tree. The `nontree` edge attribute indicates whether
-        # the edge is a tree edge or a nontree edge.
-        #
-        # We also store the order of the nodes found in the depth-first
-        # search in the `nodes` list.
-        H = nx.DiGraph()
-        nodes = []
-        for u, v, d in nx.dfs_labeled_edges(G, source=root):
-            if d == "forward":
-                # `dfs_labeled_edges()` yields (root, root, 'forward')
-                # if it is beginning the search on a new connected
-                # component.
-                if u == v:
-                    H.add_node(v, parent=None)
-                    nodes.append(v)
-                else:
-                    H.add_node(v, parent=u)
-                    H.add_edge(v, u, nontree=False)
-                    nodes.append(v)
-            # `dfs_labeled_edges` considers nontree edges in both
-            # orientations, so we need to not add the edge if it its
-            # other orientation has been added.
-            elif d == "nontree" and v not in H[u]:
-                H.add_edge(v, u, nontree=True)
-            else:
-                # Do nothing on 'reverse' edges; we only care about
-                # forward and nontree edges.
-                pass
-        return H, nodes
-
-    def _build_chain(G, u, v, visited):
-        """Generate the chain starting from the given nontree edge.
-
-        `G` is a DFS cycle graph as constructed by
-        :func:`_dfs_cycle_graph`. The edge (`u`, `v`) is a nontree edge
-        that begins a chain. `visited` is a set representing the nodes
-        in `G` that have already been visited.
-
-        This function yields the edges in an initial segment of the
-        fundamental cycle of `G` starting with the nontree edge (`u`,
-        `v`) that includes all the edges up until the first node that
-        appears in `visited`. The tree edges are given by the 'parent'
-        node attribute. The `visited` set is updated to add each node in
-        an edge yielded by this function.
-
-        """
-        while v not in visited:
-            yield u, v
-            visited.add(v)
-            u, v = v, G.nodes[v]["parent"]
-        yield u, v
-
-    # Check if the root is in the graph G. If not, raise NodeNotFound
-    if root is not None and root not in G:
-        raise nx.NodeNotFound(f"Root node {root} is not in graph")
-
-    # Create a directed version of H that has the DFS edges directed
-    # toward the root and the nontree edges directed away from the root
-    # (in each connected component).
-    H, nodes = _dfs_cycle_forest(G, root)
-
-    # Visit the nodes again in DFS order. For each node, and for each
-    # nontree edge leaving that node, compute the fundamental cycle for
-    # that nontree edge starting with that edge. If the fundamental
-    # cycle overlaps with any visited nodes, just take the prefix of the
-    # cycle up to the point of visited nodes.
-    #
-    # We repeat this process for each connected component (implicitly,
-    # since `nodes` already has a list of the nodes grouped by connected
-    # component).
-    visited = set()
-    for u in nodes:
-        visited.add(u)
-        # For each nontree edge going out of node u...
-        edges = ((u, v) for u, v, d in H.out_edges(u, data="nontree") if d)
-        for u, v in edges:
-            # Create the cycle or cycle prefix starting with the
-            # nontree edge.
-            chain = list(_build_chain(H, u, v, visited))
-            yield chain

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

@@ -1,443 +0,0 @@
-"""
-Algorithms for chordal graphs.
-
-A graph is chordal if every cycle of length at least 4 has a chord
-(an edge joining two nodes not adjacent in the cycle).
-https://en.wikipedia.org/wiki/Chordal_graph
-"""
-
-import sys
-
-import networkx as nx
-from networkx.algorithms.components import connected_components
-from networkx.utils import arbitrary_element, not_implemented_for
-
-__all__ = [
-    "is_chordal",
-    "find_induced_nodes",
-    "chordal_graph_cliques",
-    "chordal_graph_treewidth",
-    "NetworkXTreewidthBoundExceeded",
-    "complete_to_chordal_graph",
-]
-
-
-class NetworkXTreewidthBoundExceeded(nx.NetworkXException):
-    """Exception raised when a treewidth bound has been provided and it has
-    been exceeded"""
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def is_chordal(G):
-    """Checks whether G is a chordal graph.
-
-    A graph is chordal if every cycle of length at least 4 has a chord
-    (an edge joining two nodes not adjacent in the cycle).
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph.
-
-    Returns
-    -------
-    chordal : bool
-      True if G is a chordal graph and False otherwise.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
-
-    Examples
-    --------
-    >>> e = [
-    ...     (1, 2),
-    ...     (1, 3),
-    ...     (2, 3),
-    ...     (2, 4),
-    ...     (3, 4),
-    ...     (3, 5),
-    ...     (3, 6),
-    ...     (4, 5),
-    ...     (4, 6),
-    ...     (5, 6),
-    ... ]
-    >>> G = nx.Graph(e)
-    >>> nx.is_chordal(G)
-    True
-
-    Notes
-    -----
-    The routine tries to go through every node following maximum cardinality
-    search. It returns False when it finds that the separator for any node
-    is not a clique.  Based on the algorithms in [1]_.
-
-    Self loops are ignored.
-
-    References
-    ----------
-    .. [1] R. E. Tarjan and M. Yannakakis, Simple linear-time algorithms
-       to test chordality of graphs, test acyclicity of hypergraphs, and
-       selectively reduce acyclic hypergraphs, SIAM J. Comput., 13 (1984),
-       pp. 566–579.
-    """
-    if len(G.nodes) <= 3:
-        return True
-    return len(_find_chordality_breaker(G)) == 0
-
-
-@nx._dispatchable
-def find_induced_nodes(G, s, t, treewidth_bound=sys.maxsize):
-    """Returns the set of induced nodes in the path from s to t.
-
-    Parameters
-    ----------
-    G : graph
-      A chordal NetworkX graph
-    s : node
-        Source node to look for induced nodes
-    t : node
-        Destination node to look for induced nodes
-    treewidth_bound: float
-        Maximum treewidth acceptable for the graph H. The search
-        for induced nodes will end as soon as the treewidth_bound is exceeded.
-
-    Returns
-    -------
-    induced_nodes : Set of nodes
-        The set of induced nodes in the path from s to t in G
-
-    Raises
-    ------
-    NetworkXError
-        The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
-        If the input graph is an instance of one of these classes, a
-        :exc:`NetworkXError` is raised.
-        The algorithm can only be applied to chordal graphs. If the input
-        graph is found to be non-chordal, a :exc:`NetworkXError` is raised.
-
-    Examples
-    --------
-    >>> G = nx.Graph()
-    >>> G = nx.generators.classic.path_graph(10)
-    >>> induced_nodes = nx.find_induced_nodes(G, 1, 9, 2)
-    >>> sorted(induced_nodes)
-    [1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-    Notes
-    -----
-    G must be a chordal graph and (s,t) an edge that is not in G.
-
-    If a treewidth_bound is provided, the search for induced nodes will end
-    as soon as the treewidth_bound is exceeded.
-
-    The algorithm is inspired by Algorithm 4 in [1]_.
-    A formal definition of induced node can also be found on that reference.
-
-    Self Loops are ignored
-
-    References
-    ----------
-    .. [1] Learning Bounded Treewidth Bayesian Networks.
-       Gal Elidan, Stephen Gould; JMLR, 9(Dec):2699--2731, 2008.
-       http://jmlr.csail.mit.edu/papers/volume9/elidan08a/elidan08a.pdf
-    """
-    if not is_chordal(G):
-        raise nx.NetworkXError("Input graph is not chordal.")
-
-    H = nx.Graph(G)
-    H.add_edge(s, t)
-    induced_nodes = set()
-    triplet = _find_chordality_breaker(H, s, treewidth_bound)
-    while triplet:
-        (u, v, w) = triplet
-        induced_nodes.update(triplet)
-        for n in triplet:
-            if n != s:
-                H.add_edge(s, n)
-        triplet = _find_chordality_breaker(H, s, treewidth_bound)
-    if induced_nodes:
-        # Add t and the second node in the induced path from s to t.
-        induced_nodes.add(t)
-        for u in G[s]:
-            if len(induced_nodes & set(G[u])) == 2:
-                induced_nodes.add(u)
-                break
-    return induced_nodes
-
-
-@nx._dispatchable
-def chordal_graph_cliques(G):
-    """Returns all maximal cliques of a chordal graph.
-
-    The algorithm breaks the graph in connected components and performs a
-    maximum cardinality search in each component to get the cliques.
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph
-
-    Yields
-    ------
-    frozenset of nodes
-        Maximal cliques, each of which is a frozenset of
-        nodes in `G`. The order of cliques is arbitrary.
-
-    Raises
-    ------
-    NetworkXError
-        The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
-        The algorithm can only be applied to chordal graphs. If the input
-        graph is found to be non-chordal, a :exc:`NetworkXError` is raised.
-
-    Examples
-    --------
-    >>> e = [
-    ...     (1, 2),
-    ...     (1, 3),
-    ...     (2, 3),
-    ...     (2, 4),
-    ...     (3, 4),
-    ...     (3, 5),
-    ...     (3, 6),
-    ...     (4, 5),
-    ...     (4, 6),
-    ...     (5, 6),
-    ...     (7, 8),
-    ... ]
-    >>> G = nx.Graph(e)
-    >>> G.add_node(9)
-    >>> cliques = [c for c in chordal_graph_cliques(G)]
-    >>> cliques[0]
-    frozenset({1, 2, 3})
-    """
-    for C in (G.subgraph(c).copy() for c in connected_components(G)):
-        if C.number_of_nodes() == 1:
-            if nx.number_of_selfloops(C) > 0:
-                raise nx.NetworkXError("Input graph is not chordal.")
-            yield frozenset(C.nodes())
-        else:
-            unnumbered = set(C.nodes())
-            v = arbitrary_element(C)
-            unnumbered.remove(v)
-            numbered = {v}
-            clique_wanna_be = {v}
-            while unnumbered:
-                v = _max_cardinality_node(C, unnumbered, numbered)
-                unnumbered.remove(v)
-                numbered.add(v)
-                new_clique_wanna_be = set(C.neighbors(v)) & numbered
-                sg = C.subgraph(clique_wanna_be)
-                if _is_complete_graph(sg):
-                    new_clique_wanna_be.add(v)
-                    if not new_clique_wanna_be >= clique_wanna_be:
-                        yield frozenset(clique_wanna_be)
-                    clique_wanna_be = new_clique_wanna_be
-                else:
-                    raise nx.NetworkXError("Input graph is not chordal.")
-            yield frozenset(clique_wanna_be)
-
-
-@nx._dispatchable
-def chordal_graph_treewidth(G):
-    """Returns the treewidth of the chordal graph G.
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph
-
-    Returns
-    -------
-    treewidth : int
-        The size of the largest clique in the graph minus one.
-
-    Raises
-    ------
-    NetworkXError
-        The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
-        The algorithm can only be applied to chordal graphs. If the input
-        graph is found to be non-chordal, a :exc:`NetworkXError` is raised.
-
-    Examples
-    --------
-    >>> e = [
-    ...     (1, 2),
-    ...     (1, 3),
-    ...     (2, 3),
-    ...     (2, 4),
-    ...     (3, 4),
-    ...     (3, 5),
-    ...     (3, 6),
-    ...     (4, 5),
-    ...     (4, 6),
-    ...     (5, 6),
-    ...     (7, 8),
-    ... ]
-    >>> G = nx.Graph(e)
-    >>> G.add_node(9)
-    >>> nx.chordal_graph_treewidth(G)
-    3
-
-    References
-    ----------
-    .. [1] https://en.wikipedia.org/wiki/Tree_decomposition#Treewidth
-    """
-    if not is_chordal(G):
-        raise nx.NetworkXError("Input graph is not chordal.")
-
-    max_clique = -1
-    for clique in nx.chordal_graph_cliques(G):
-        max_clique = max(max_clique, len(clique))
-    return max_clique - 1
-
-
-def _is_complete_graph(G):
-    """Returns True if G is a complete graph."""
-    if nx.number_of_selfloops(G) > 0:
-        raise nx.NetworkXError("Self loop found in _is_complete_graph()")
-    n = G.number_of_nodes()
-    if n < 2:
-        return True
-    e = G.number_of_edges()
-    max_edges = (n * (n - 1)) / 2
-    return e == max_edges
-
-
-def _find_missing_edge(G):
-    """Given a non-complete graph G, returns a missing edge."""
-    nodes = set(G)
-    for u in G:
-        missing = nodes - set(list(G[u].keys()) + [u])
-        if missing:
-            return (u, missing.pop())
-
-
-def _max_cardinality_node(G, choices, wanna_connect):
-    """Returns a the node in choices that has more connections in G
-    to nodes in wanna_connect.
-    """
-    max_number = -1
-    for x in choices:
-        number = len([y for y in G[x] if y in wanna_connect])
-        if number > max_number:
-            max_number = number
-            max_cardinality_node = x
-    return max_cardinality_node
-
-
-def _find_chordality_breaker(G, s=None, treewidth_bound=sys.maxsize):
-    """Given a graph G, starts a max cardinality search
-    (starting from s if s is given and from an arbitrary node otherwise)
-    trying to find a non-chordal cycle.
-
-    If it does find one, it returns (u,v,w) where u,v,w are the three
-    nodes that together with s are involved in the cycle.
-
-    It ignores any self loops.
-    """
-    if len(G) == 0:
-        raise nx.NetworkXPointlessConcept("Graph has no nodes.")
-    unnumbered = set(G)
-    if s is None:
-        s = arbitrary_element(G)
-    unnumbered.remove(s)
-    numbered = {s}
-    current_treewidth = -1
-    while unnumbered:  # and current_treewidth <= treewidth_bound:
-        v = _max_cardinality_node(G, unnumbered, numbered)
-        unnumbered.remove(v)
-        numbered.add(v)
-        clique_wanna_be = set(G[v]) & numbered
-        sg = G.subgraph(clique_wanna_be)
-        if _is_complete_graph(sg):
-            # The graph seems to be chordal by now. We update the treewidth
-            current_treewidth = max(current_treewidth, len(clique_wanna_be))
-            if current_treewidth > treewidth_bound:
-                raise nx.NetworkXTreewidthBoundExceeded(
-                    f"treewidth_bound exceeded: {current_treewidth}"
-                )
-        else:
-            # sg is not a clique,
-            # look for an edge that is not included in sg
-            (u, w) = _find_missing_edge(sg)
-            return (u, v, w)
-    return ()
-
-
-@not_implemented_for("directed")
-@nx._dispatchable(returns_graph=True)
-def complete_to_chordal_graph(G):
-    """Return a copy of G completed to a chordal graph
-
-    Adds edges to a copy of G to create a chordal graph. A graph G=(V,E) is
-    called chordal if for each cycle with length bigger than 3, there exist
-    two non-adjacent nodes connected by an edge (called a chord).
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Undirected graph
-
-    Returns
-    -------
-    H : NetworkX graph
-        The chordal enhancement of G
-    alpha : Dictionary
-            The elimination ordering of nodes of G
-
-    Notes
-    -----
-    There are different approaches to calculate the chordal
-    enhancement of a graph. The algorithm used here is called
-    MCS-M and gives at least minimal (local) triangulation of graph. Note
-    that this triangulation is not necessarily a global minimum.
-
-    https://en.wikipedia.org/wiki/Chordal_graph
-
-    References
-    ----------
-    .. [1] Berry, Anne & Blair, Jean & Heggernes, Pinar & Peyton, Barry. (2004)
-           Maximum Cardinality Search for Computing Minimal Triangulations of
-           Graphs.  Algorithmica. 39. 287-298. 10.1007/s00453-004-1084-3.
-
-    Examples
-    --------
-    >>> from networkx.algorithms.chordal import complete_to_chordal_graph
-    >>> G = nx.wheel_graph(10)
-    >>> H, alpha = complete_to_chordal_graph(G)
-    """
-    H = G.copy()
-    alpha = {node: 0 for node in H}
-    if nx.is_chordal(H):
-        return H, alpha
-    chords = set()
-    weight = {node: 0 for node in H.nodes()}
-    unnumbered_nodes = list(H.nodes())
-    for i in range(len(H.nodes()), 0, -1):
-        # get the node in unnumbered_nodes with the maximum weight
-        z = max(unnumbered_nodes, key=lambda node: weight[node])
-        unnumbered_nodes.remove(z)
-        alpha[z] = i
-        update_nodes = []
-        for y in unnumbered_nodes:
-            if G.has_edge(y, z):
-                update_nodes.append(y)
-            else:
-                # y_weight will be bigger than node weights between y and z
-                y_weight = weight[y]
-                lower_nodes = [
-                    node for node in unnumbered_nodes if weight[node] < y_weight
-                ]
-                if nx.has_path(H.subgraph(lower_nodes + [z, y]), y, z):
-                    update_nodes.append(y)
-                    chords.add((z, y))
-        # during calculation of paths the weights should not be updated
-        for node in update_nodes:
-            weight[node] += 1
-    H.add_edges_from(chords)
-    return H, alpha