okstra 0.130.4 → 0.131.1

package/runtime/python/okstra_vendor/networkx/algorithms/flow/edmondskarp.py

@@ -1,241 +0,0 @@
-"""
-Edmonds-Karp algorithm for maximum flow problems.
-"""
-
-import networkx as nx
-from networkx.algorithms.flow.utils import build_residual_network
-
-__all__ = ["edmonds_karp"]
-
-
-def edmonds_karp_core(R, s, t, cutoff):
-    """Implementation of the Edmonds-Karp algorithm."""
-    R_nodes = R.nodes
-    R_pred = R.pred
-    R_succ = R.succ
-
-    inf = R.graph["inf"]
-
-    def augment(path):
-        """Augment flow along a path from s to t."""
-        # Determine the path residual capacity.
-        flow = inf
-        it = iter(path)
-        u = next(it)
-        for v in it:
-            attr = R_succ[u][v]
-            flow = min(flow, attr["capacity"] - attr["flow"])
-            u = v
-        if flow * 2 > inf:
-            raise nx.NetworkXUnbounded("Infinite capacity path, flow unbounded above.")
-        # Augment flow along the path.
-        it = iter(path)
-        u = next(it)
-        for v in it:
-            R_succ[u][v]["flow"] += flow
-            R_succ[v][u]["flow"] -= flow
-            u = v
-        return flow
-
-    def bidirectional_bfs():
-        """Bidirectional breadth-first search for an augmenting path."""
-        pred = {s: None}
-        q_s = [s]
-        succ = {t: None}
-        q_t = [t]
-        while True:
-            q = []
-            if len(q_s) <= len(q_t):
-                for u in q_s:
-                    for v, attr in R_succ[u].items():
-                        if v not in pred and attr["flow"] < attr["capacity"]:
-                            pred[v] = u
-                            if v in succ:
-                                return v, pred, succ
-                            q.append(v)
-                if not q:
-                    return None, None, None
-                q_s = q
-            else:
-                for u in q_t:
-                    for v, attr in R_pred[u].items():
-                        if v not in succ and attr["flow"] < attr["capacity"]:
-                            succ[v] = u
-                            if v in pred:
-                                return v, pred, succ
-                            q.append(v)
-                if not q:
-                    return None, None, None
-                q_t = q
-
-    # Look for shortest augmenting paths using breadth-first search.
-    flow_value = 0
-    while flow_value < cutoff:
-        v, pred, succ = bidirectional_bfs()
-        if pred is None:
-            break
-        path = [v]
-        # Trace a path from s to v.
-        u = v
-        while u != s:
-            u = pred[u]
-            path.append(u)
-        path.reverse()
-        # Trace a path from v to t.
-        u = v
-        while u != t:
-            u = succ[u]
-            path.append(u)
-        flow_value += augment(path)
-
-    return flow_value
-
-
-def edmonds_karp_impl(G, s, t, capacity, residual, cutoff):
-    """Implementation of the Edmonds-Karp algorithm."""
-    if s not in G:
-        raise nx.NetworkXError(f"node {str(s)} not in graph")
-    if t not in G:
-        raise nx.NetworkXError(f"node {str(t)} not in graph")
-    if s == t:
-        raise nx.NetworkXError("source and sink are the same node")
-
-    if residual is None:
-        R = build_residual_network(G, capacity)
-    else:
-        R = residual
-
-    # Initialize/reset the residual network.
-    for u in R:
-        for e in R[u].values():
-            e["flow"] = 0
-
-    if cutoff is None:
-        cutoff = float("inf")
-    R.graph["flow_value"] = edmonds_karp_core(R, s, t, cutoff)
-
-    return R
-
-
-@nx._dispatchable(edge_attrs={"capacity": float("inf")}, returns_graph=True)
-def edmonds_karp(
-    G, s, t, capacity="capacity", residual=None, value_only=False, cutoff=None
-):
-    """Find a maximum single-commodity flow using the Edmonds-Karp algorithm.
-
-    This function returns the residual network resulting after computing
-    the maximum flow. See below for details about the conventions
-    NetworkX uses for defining residual networks.
-
-    This algorithm has a running time of $O(n m^2)$ for $n$ nodes and $m$
-    edges.
-
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Edges of the graph are expected to have an attribute called
-        'capacity'. If this attribute is not present, the edge is
-        considered to have infinite capacity.
-
-    s : node
-        Source node for the flow.
-
-    t : node
-        Sink node for the flow.
-
-    capacity : string
-        Edges of the graph G are expected to have an attribute capacity
-        that indicates how much flow the edge can support. If this
-        attribute is not present, the edge is considered to have
-        infinite capacity. Default value: 'capacity'.
-
-    residual : NetworkX graph
-        Residual network on which the algorithm is to be executed. If None, a
-        new residual network is created. Default value: None.
-
-    value_only : bool
-        If True compute only the value of the maximum flow. This parameter
-        will be ignored by this algorithm because it is not applicable.
-
-    cutoff : integer, float
-        If specified, the algorithm will terminate when the flow value reaches
-        or exceeds the cutoff. In this case, it may be unable to immediately
-        determine a minimum cut. Default value: None.
-
-    Returns
-    -------
-    R : NetworkX DiGraph
-        Residual network after computing the maximum flow.
-
-    Raises
-    ------
-    NetworkXError
-        The algorithm does not support MultiGraph and MultiDiGraph. If
-        the input graph is an instance of one of these two classes, a
-        NetworkXError is raised.
-
-    NetworkXUnbounded
-        If the graph has a path of infinite capacity, the value of a
-        feasible flow on the graph is unbounded above and the function
-        raises a NetworkXUnbounded.
-
-    See also
-    --------
-    :meth:`maximum_flow`
-    :meth:`minimum_cut`
-    :meth:`preflow_push`
-    :meth:`shortest_augmenting_path`
-
-    Notes
-    -----
-    The residual network :samp:`R` from an input graph :samp:`G` has the
-    same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair
-    of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a
-    self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists
-    in :samp:`G`.
-
-    For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']`
-    is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists
-    in :samp:`G` or zero otherwise. If the capacity is infinite,
-    :samp:`R[u][v]['capacity']` will have a high arbitrary finite value
-    that does not affect the solution of the problem. This value is stored in
-    :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`,
-    :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and
-    satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`.
-
-    The flow value, defined as the total flow into :samp:`t`, the sink, is
-    stored in :samp:`R.graph['flow_value']`. If :samp:`cutoff` is not
-    specified, reachability to :samp:`t` using only edges :samp:`(u, v)` such
-    that :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum
-    :samp:`s`-:samp:`t` cut.
-
-    Examples
-    --------
-    >>> from networkx.algorithms.flow import edmonds_karp
-
-    The functions that implement flow algorithms and output a residual
-    network, such as this one, are not imported to the base NetworkX
-    namespace, so you have to explicitly import them from the flow package.
-
-    >>> G = nx.DiGraph()
-    >>> G.add_edge("x", "a", capacity=3.0)
-    >>> G.add_edge("x", "b", capacity=1.0)
-    >>> G.add_edge("a", "c", capacity=3.0)
-    >>> G.add_edge("b", "c", capacity=5.0)
-    >>> G.add_edge("b", "d", capacity=4.0)
-    >>> G.add_edge("d", "e", capacity=2.0)
-    >>> G.add_edge("c", "y", capacity=2.0)
-    >>> G.add_edge("e", "y", capacity=3.0)
-    >>> R = edmonds_karp(G, "x", "y")
-    >>> flow_value = nx.maximum_flow_value(G, "x", "y")
-    >>> flow_value
-    3.0
-    >>> flow_value == R.graph["flow_value"]
-    True
-
-    """
-    R = edmonds_karp_impl(G, s, t, capacity, residual, cutoff)
-    R.graph["algorithm"] = "edmonds_karp"
-    nx._clear_cache(R)
-    return R

package/runtime/python/okstra_vendor/networkx/algorithms/flow/gomory_hu.py

@@ -1,178 +0,0 @@
-"""
-Gomory-Hu tree of undirected Graphs.
-"""
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-from .edmondskarp import edmonds_karp
-from .utils import build_residual_network
-
-default_flow_func = edmonds_karp
-
-__all__ = ["gomory_hu_tree"]
-
-
-@not_implemented_for("directed")
-@nx._dispatchable(edge_attrs={"capacity": float("inf")}, returns_graph=True)
-def gomory_hu_tree(G, capacity="capacity", flow_func=None):
-    r"""Returns the Gomory-Hu tree of an undirected graph G.
-
-    A Gomory-Hu tree of an undirected graph with capacities is a
-    weighted tree that represents the minimum s-t cuts for all s-t
-    pairs in the graph.
-
-    It only requires `n-1` minimum cut computations instead of the
-    obvious `n(n-1)/2`. The tree represents all s-t cuts as the
-    minimum cut value among any pair of nodes is the minimum edge
-    weight in the shortest path between the two nodes in the
-    Gomory-Hu tree.
-
-    The Gomory-Hu tree also has the property that removing the
-    edge with the minimum weight in the shortest path between
-    any two nodes leaves two connected components that form
-    a partition of the nodes in G that defines the minimum s-t
-    cut.
-
-    See Examples section below for details.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Undirected graph
-
-    capacity : string
-        Edges of the graph G are expected to have an attribute capacity
-        that indicates how much flow the edge can support. If this
-        attribute is not present, the edge is considered to have
-        infinite capacity. Default value: 'capacity'.
-
-    flow_func : function
-        Function to perform the underlying flow computations. Default value
-        :func:`edmonds_karp`. This function performs better in sparse graphs
-        with right tailed degree distributions.
-        :func:`shortest_augmenting_path` will perform better in denser
-        graphs.
-
-    Returns
-    -------
-    Tree : NetworkX graph
-        A NetworkX graph representing the Gomory-Hu tree of the input graph.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        Raised if the input graph is directed.
-
-    NetworkXError
-        Raised if the input graph is an empty Graph.
-
-    Examples
-    --------
-    >>> G = nx.karate_club_graph()
-    >>> nx.set_edge_attributes(G, 1, "capacity")
-    >>> T = nx.gomory_hu_tree(G)
-    >>> # The value of the minimum cut between any pair
-    ... # of nodes in G is the minimum edge weight in the
-    ... # shortest path between the two nodes in the
-    ... # Gomory-Hu tree.
-    ... def minimum_edge_weight_in_shortest_path(T, u, v):
-    ...     path = nx.shortest_path(T, u, v, weight="weight")
-    ...     return min((T[u][v]["weight"], (u, v)) for (u, v) in zip(path, path[1:]))
-    >>> u, v = 0, 33
-    >>> cut_value, edge = minimum_edge_weight_in_shortest_path(T, u, v)
-    >>> cut_value
-    10
-    >>> nx.minimum_cut_value(G, u, v)
-    10
-    >>> # The Gomory-Hu tree also has the property that removing the
-    ... # edge with the minimum weight in the shortest path between
-    ... # any two nodes leaves two connected components that form
-    ... # a partition of the nodes in G that defines the minimum s-t
-    ... # cut.
-    ... cut_value, edge = minimum_edge_weight_in_shortest_path(T, u, v)
-    >>> T.remove_edge(*edge)
-    >>> U, V = list(nx.connected_components(T))
-    >>> # Thus U and V form a partition that defines a minimum cut
-    ... # between u and v in G. You can compute the edge cut set,
-    ... # that is, the set of edges that if removed from G will
-    ... # disconnect u from v in G, with this information:
-    ... cutset = set()
-    >>> for x, nbrs in ((n, G[n]) for n in U):
-    ...     cutset.update((x, y) for y in nbrs if y in V)
-    >>> # Because we have set the capacities of all edges to 1
-    ... # the cutset contains ten edges
-    ... len(cutset)
-    10
-    >>> # You can use any maximum flow algorithm for the underlying
-    ... # flow computations using the argument flow_func
-    ... from networkx.algorithms import flow
-    >>> T = nx.gomory_hu_tree(G, flow_func=flow.boykov_kolmogorov)
-    >>> cut_value, edge = minimum_edge_weight_in_shortest_path(T, u, v)
-    >>> cut_value
-    10
-    >>> nx.minimum_cut_value(G, u, v, flow_func=flow.boykov_kolmogorov)
-    10
-
-    Notes
-    -----
-    This implementation is based on Gusfield approach [1]_ to compute
-    Gomory-Hu trees, which does not require node contractions and has
-    the same computational complexity than the original method.
-
-    See also
-    --------
-    :func:`minimum_cut`
-    :func:`maximum_flow`
-
-    References
-    ----------
-    .. [1] Gusfield D: Very simple methods for all pairs network flow analysis.
-           SIAM J Comput 19(1):143-155, 1990.
-
-    """
-    if flow_func is None:
-        flow_func = default_flow_func
-
-    if len(G) == 0:  # empty graph
-        msg = "Empty Graph does not have a Gomory-Hu tree representation"
-        raise nx.NetworkXError(msg)
-
-    # Start the tree as a star graph with an arbitrary node at the center
-    tree = {}
-    labels = {}
-    iter_nodes = iter(G)
-    root = next(iter_nodes)
-    for n in iter_nodes:
-        tree[n] = root
-
-    # Reuse residual network
-    R = build_residual_network(G, capacity)
-
-    # For all the leaves in the star graph tree (that is n-1 nodes).
-    for source in tree:
-        # Find neighbor in the tree
-        target = tree[source]
-        # compute minimum cut
-        cut_value, partition = nx.minimum_cut(
-            G, source, target, capacity=capacity, flow_func=flow_func, residual=R
-        )
-        labels[(source, target)] = cut_value
-        # Update the tree
-        # Source will always be in partition[0] and target in partition[1]
-        for node in partition[0]:
-            if node != source and node in tree and tree[node] == target:
-                tree[node] = source
-                labels[node, source] = labels.get((node, target), cut_value)
-        #
-        if target != root and tree[target] in partition[0]:
-            labels[source, tree[target]] = labels[target, tree[target]]
-            labels[target, source] = cut_value
-            tree[source] = tree[target]
-            tree[target] = source
-
-    # Build the tree
-    T = nx.Graph()
-    T.add_nodes_from(G)
-    T.add_weighted_edges_from(((u, v, labels[u, v]) for u, v in tree.items()))
-    return T