okstra 0.130.4 → 0.131.1

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

@@ -1,407 +0,0 @@
-"""
-Capacity scaling minimum cost flow algorithm.
-"""
-
-__all__ = ["capacity_scaling"]
-
-from itertools import chain
-from math import log
-
-import networkx as nx
-
-from ...utils import BinaryHeap, arbitrary_element, not_implemented_for
-
-
-def _detect_unboundedness(R):
-    """Detect infinite-capacity negative cycles."""
-    G = nx.DiGraph()
-    G.add_nodes_from(R)
-
-    # Value simulating infinity.
-    inf = R.graph["inf"]
-    # True infinity.
-    f_inf = float("inf")
-    for u in R:
-        for v, e in R[u].items():
-            # Compute the minimum weight of infinite-capacity (u, v) edges.
-            w = f_inf
-            for k, e in e.items():
-                if e["capacity"] == inf:
-                    w = min(w, e["weight"])
-            if w != f_inf:
-                G.add_edge(u, v, weight=w)
-
-    if nx.negative_edge_cycle(G):
-        raise nx.NetworkXUnbounded(
-            "Negative cost cycle of infinite capacity found. "
-            "Min cost flow may be unbounded below."
-        )
-
-
-@not_implemented_for("undirected")
-def _build_residual_network(G, demand, capacity, weight):
-    """Build a residual network and initialize a zero flow."""
-    if sum(G.nodes[u].get(demand, 0) for u in G) != 0:
-        raise nx.NetworkXUnfeasible("Sum of the demands should be 0.")
-
-    R = nx.MultiDiGraph()
-    R.add_nodes_from(
-        (u, {"excess": -G.nodes[u].get(demand, 0), "potential": 0}) for u in G
-    )
-
-    inf = float("inf")
-    # Detect selfloops with infinite capacities and negative weights.
-    for u, v, e in nx.selfloop_edges(G, data=True):
-        if e.get(weight, 0) < 0 and e.get(capacity, inf) == inf:
-            raise nx.NetworkXUnbounded(
-                "Negative cost cycle of infinite capacity found. "
-                "Min cost flow may be unbounded below."
-            )
-
-    # Extract edges with positive capacities. Self loops excluded.
-    if G.is_multigraph():
-        edge_list = [
-            (u, v, k, e)
-            for u, v, k, e in G.edges(data=True, keys=True)
-            if u != v and e.get(capacity, inf) > 0
-        ]
-    else:
-        edge_list = [
-            (u, v, 0, e)
-            for u, v, e in G.edges(data=True)
-            if u != v and e.get(capacity, inf) > 0
-        ]
-    # Simulate infinity with the larger of the sum of absolute node imbalances
-    # the sum of finite edge capacities or any positive value if both sums are
-    # zero. This allows the infinite-capacity edges to be distinguished for
-    # unboundedness detection and directly participate in residual capacity
-    # calculation.
-    inf = (
-        max(
-            sum(abs(R.nodes[u]["excess"]) for u in R),
-            2
-            * sum(
-                e[capacity]
-                for u, v, k, e in edge_list
-                if capacity in e and e[capacity] != inf
-            ),
-        )
-        or 1
-    )
-    for u, v, k, e in edge_list:
-        r = min(e.get(capacity, inf), inf)
-        w = e.get(weight, 0)
-        # Add both (u, v) and (v, u) into the residual network marked with the
-        # original key. (key[1] == True) indicates the (u, v) is in the
-        # original network.
-        R.add_edge(u, v, key=(k, True), capacity=r, weight=w, flow=0)
-        R.add_edge(v, u, key=(k, False), capacity=0, weight=-w, flow=0)
-
-    # Record the value simulating infinity.
-    R.graph["inf"] = inf
-
-    _detect_unboundedness(R)
-
-    return R
-
-
-def _build_flow_dict(G, R, capacity, weight):
-    """Build a flow dictionary from a residual network."""
-    inf = float("inf")
-    flow_dict = {}
-    if G.is_multigraph():
-        for u in G:
-            flow_dict[u] = {}
-            for v, es in G[u].items():
-                flow_dict[u][v] = {
-                    # Always saturate negative selfloops.
-                    k: (
-                        0
-                        if (
-                            u != v or e.get(capacity, inf) <= 0 or e.get(weight, 0) >= 0
-                        )
-                        else e[capacity]
-                    )
-                    for k, e in es.items()
-                }
-            for v, es in R[u].items():
-                if v in flow_dict[u]:
-                    flow_dict[u][v].update(
-                        (k[0], e["flow"]) for k, e in es.items() if e["flow"] > 0
-                    )
-    else:
-        for u in G:
-            flow_dict[u] = {
-                # Always saturate negative selfloops.
-                v: (
-                    0
-                    if (u != v or e.get(capacity, inf) <= 0 or e.get(weight, 0) >= 0)
-                    else e[capacity]
-                )
-                for v, e in G[u].items()
-            }
-            flow_dict[u].update(
-                (v, e["flow"])
-                for v, es in R[u].items()
-                for e in es.values()
-                if e["flow"] > 0
-            )
-    return flow_dict
-
-
-@nx._dispatchable(
-    node_attrs="demand", edge_attrs={"capacity": float("inf"), "weight": 0}
-)
-def capacity_scaling(
-    G, demand="demand", capacity="capacity", weight="weight", heap=BinaryHeap
-):
-    r"""Find a minimum cost flow satisfying all demands in digraph G.
-
-    This is a capacity scaling successive shortest augmenting path algorithm.
-
-    G is a digraph with edge costs and capacities and in which nodes
-    have demand, i.e., they want to send or receive some amount of
-    flow. A negative demand means that the node wants to send flow, a
-    positive demand means that the node want to receive flow. A flow on
-    the digraph G satisfies all demand if the net flow into each node
-    is equal to the demand of that node.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        DiGraph or MultiDiGraph on which a minimum cost flow satisfying all
-        demands is to be found.
-
-    demand : string
-        Nodes of the graph G are expected to have an attribute demand
-        that indicates how much flow a node wants to send (negative
-        demand) or receive (positive demand). Note that the sum of the
-        demands should be 0 otherwise the problem in not feasible. If
-        this attribute is not present, a node is considered to have 0
-        demand. Default value: 'demand'.
-
-    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'.
-
-    weight : string
-        Edges of the graph G are expected to have an attribute weight
-        that indicates the cost incurred by sending one unit of flow on
-        that edge. If not present, the weight is considered to be 0.
-        Default value: 'weight'.
-
-    heap : class
-        Type of heap to be used in the algorithm. It should be a subclass of
-        :class:`MinHeap` or implement a compatible interface.
-
-        If a stock heap implementation is to be used, :class:`BinaryHeap` is
-        recommended over :class:`PairingHeap` for Python implementations without
-        optimized attribute accesses (e.g., CPython) despite a slower
-        asymptotic running time. For Python implementations with optimized
-        attribute accesses (e.g., PyPy), :class:`PairingHeap` provides better
-        performance. Default value: :class:`BinaryHeap`.
-
-    Returns
-    -------
-    flowCost : integer
-        Cost of a minimum cost flow satisfying all demands.
-
-    flowDict : dictionary
-        If G is a digraph, a dict-of-dicts keyed by nodes such that
-        flowDict[u][v] is the flow on edge (u, v).
-        If G is a MultiDiGraph, a dict-of-dicts-of-dicts keyed by nodes
-        so that flowDict[u][v][key] is the flow on edge (u, v, key).
-
-    Raises
-    ------
-    NetworkXError
-        This exception is raised if the input graph is not directed,
-        not connected.
-
-    NetworkXUnfeasible
-        This exception is raised in the following situations:
-
-            * The sum of the demands is not zero. Then, there is no
-              flow satisfying all demands.
-            * There is no flow satisfying all demand.
-
-    NetworkXUnbounded
-        This exception is raised if the digraph G has a cycle of
-        negative cost and infinite capacity. Then, the cost of a flow
-        satisfying all demands is unbounded below.
-
-    Notes
-    -----
-    This algorithm does not work if edge weights are floating-point numbers.
-
-    See also
-    --------
-    :meth:`network_simplex`
-
-    Examples
-    --------
-    A simple example of a min cost flow problem.
-
-    >>> G = nx.DiGraph()
-    >>> G.add_node("a", demand=-5)
-    >>> G.add_node("d", demand=5)
-    >>> G.add_edge("a", "b", weight=3, capacity=4)
-    >>> G.add_edge("a", "c", weight=6, capacity=10)
-    >>> G.add_edge("b", "d", weight=1, capacity=9)
-    >>> G.add_edge("c", "d", weight=2, capacity=5)
-    >>> flowCost, flowDict = nx.capacity_scaling(G)
-    >>> flowCost
-    24
-    >>> flowDict
-    {'a': {'b': 4, 'c': 1}, 'd': {}, 'b': {'d': 4}, 'c': {'d': 1}}
-
-    It is possible to change the name of the attributes used for the
-    algorithm.
-
-    >>> G = nx.DiGraph()
-    >>> G.add_node("p", spam=-4)
-    >>> G.add_node("q", spam=2)
-    >>> G.add_node("a", spam=-2)
-    >>> G.add_node("d", spam=-1)
-    >>> G.add_node("t", spam=2)
-    >>> G.add_node("w", spam=3)
-    >>> G.add_edge("p", "q", cost=7, vacancies=5)
-    >>> G.add_edge("p", "a", cost=1, vacancies=4)
-    >>> G.add_edge("q", "d", cost=2, vacancies=3)
-    >>> G.add_edge("t", "q", cost=1, vacancies=2)
-    >>> G.add_edge("a", "t", cost=2, vacancies=4)
-    >>> G.add_edge("d", "w", cost=3, vacancies=4)
-    >>> G.add_edge("t", "w", cost=4, vacancies=1)
-    >>> flowCost, flowDict = nx.capacity_scaling(
-    ...     G, demand="spam", capacity="vacancies", weight="cost"
-    ... )
-    >>> flowCost
-    37
-    >>> flowDict
-    {'p': {'q': 2, 'a': 2}, 'q': {'d': 1}, 'a': {'t': 4}, 'd': {'w': 2}, 't': {'q': 1, 'w': 1}, 'w': {}}
-    """
-    R = _build_residual_network(G, demand, capacity, weight)
-
-    inf = float("inf")
-    # Account cost of negative selfloops.
-    flow_cost = sum(
-        0
-        if e.get(capacity, inf) <= 0 or e.get(weight, 0) >= 0
-        else e[capacity] * e[weight]
-        for u, v, e in nx.selfloop_edges(G, data=True)
-    )
-
-    # Determine the maximum edge capacity.
-    wmax = max(chain([-inf], (e["capacity"] for u, v, e in R.edges(data=True))))
-    if wmax == -inf:
-        # Residual network has no edges.
-        return flow_cost, _build_flow_dict(G, R, capacity, weight)
-
-    R_nodes = R.nodes
-    R_succ = R.succ
-
-    delta = 2 ** int(log(wmax, 2))
-    while delta >= 1:
-        # Saturate Δ-residual edges with negative reduced costs to achieve
-        # Δ-optimality.
-        for u in R:
-            p_u = R_nodes[u]["potential"]
-            for v, es in R_succ[u].items():
-                for k, e in es.items():
-                    flow = e["capacity"] - e["flow"]
-                    if e["weight"] - p_u + R_nodes[v]["potential"] < 0:
-                        flow = e["capacity"] - e["flow"]
-                        if flow >= delta:
-                            e["flow"] += flow
-                            R_succ[v][u][(k[0], not k[1])]["flow"] -= flow
-                            R_nodes[u]["excess"] -= flow
-                            R_nodes[v]["excess"] += flow
-        # Determine the Δ-active nodes.
-        S = set()
-        T = set()
-        S_add = S.add
-        S_remove = S.remove
-        T_add = T.add
-        T_remove = T.remove
-        for u in R:
-            excess = R_nodes[u]["excess"]
-            if excess >= delta:
-                S_add(u)
-            elif excess <= -delta:
-                T_add(u)
-        # Repeatedly augment flow from S to T along shortest paths until
-        # Δ-feasibility is achieved.
-        while S and T:
-            s = arbitrary_element(S)
-            t = None
-            # Search for a shortest path in terms of reduce costs from s to
-            # any t in T in the Δ-residual network.
-            d = {}
-            pred = {s: None}
-            h = heap()
-            h_insert = h.insert
-            h_get = h.get
-            h_insert(s, 0)
-            while h:
-                u, d_u = h.pop()
-                d[u] = d_u
-                if u in T:
-                    # Path found.
-                    t = u
-                    break
-                p_u = R_nodes[u]["potential"]
-                for v, es in R_succ[u].items():
-                    if v in d:
-                        continue
-                    wmin = inf
-                    # Find the minimum-weighted (u, v) Δ-residual edge.
-                    for k, e in es.items():
-                        if e["capacity"] - e["flow"] >= delta:
-                            w = e["weight"]
-                            if w < wmin:
-                                wmin = w
-                                kmin = k
-                                emin = e
-                    if wmin == inf:
-                        continue
-                    # Update the distance label of v.
-                    d_v = d_u + wmin - p_u + R_nodes[v]["potential"]
-                    if h_insert(v, d_v):
-                        pred[v] = (u, kmin, emin)
-            if t is not None:
-                # Augment Δ units of flow from s to t.
-                while u != s:
-                    v = u
-                    u, k, e = pred[v]
-                    e["flow"] += delta
-                    R_succ[v][u][(k[0], not k[1])]["flow"] -= delta
-                # Account node excess and deficit.
-                R_nodes[s]["excess"] -= delta
-                R_nodes[t]["excess"] += delta
-                if R_nodes[s]["excess"] < delta:
-                    S_remove(s)
-                if R_nodes[t]["excess"] > -delta:
-                    T_remove(t)
-                # Update node potentials.
-                d_t = d[t]
-                for u, d_u in d.items():
-                    R_nodes[u]["potential"] -= d_u - d_t
-            else:
-                # Path not found.
-                S_remove(s)
-        delta //= 2
-
-    if any(R.nodes[u]["excess"] != 0 for u in R):
-        raise nx.NetworkXUnfeasible("No flow satisfying all demands.")
-
-    # Calculate the flow cost.
-    for u in R:
-        for v, es in R_succ[u].items():
-            for e in es.values():
-                flow = e["flow"]
-                if flow > 0:
-                    flow_cost += flow * e["weight"]
-
-    return flow_cost, _build_flow_dict(G, R, capacity, weight)

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

@@ -1,238 +0,0 @@
-"""
-Dinitz' algorithm for maximum flow problems.
-"""
-
-from collections import deque
-
-import networkx as nx
-from networkx.algorithms.flow.utils import build_residual_network
-from networkx.utils import pairwise
-
-__all__ = ["dinitz"]
-
-
-@nx._dispatchable(edge_attrs={"capacity": float("inf")}, returns_graph=True)
-def dinitz(G, s, t, capacity="capacity", residual=None, value_only=False, cutoff=None):
-    """Find a maximum single-commodity flow using Dinitz' 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^2 m)$ for $n$ nodes and $m$
-    edges [1]_.
-
-
-    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 dinitz
-
-    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 = dinitz(G, "x", "y")
-    >>> flow_value = nx.maximum_flow_value(G, "x", "y")
-    >>> flow_value
-    3.0
-    >>> flow_value == R.graph["flow_value"]
-    True
-
-    References
-    ----------
-    .. [1] Dinitz' Algorithm: The Original Version and Even's Version.
-           2006. Yefim Dinitz. In Theoretical Computer Science. Lecture
-           Notes in Computer Science. Volume 3895. pp 218-240.
-           https://doi.org/10.1007/11685654_10
-
-    """
-    R = dinitz_impl(G, s, t, capacity, residual, cutoff)
-    R.graph["algorithm"] = "dinitz"
-    nx._clear_cache(R)
-    return R
-
-
-def dinitz_impl(G, s, t, capacity, residual, cutoff):
-    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
-
-    # Use an arbitrary high value as infinite. It is computed
-    # when building the residual network.
-    INF = R.graph["inf"]
-
-    if cutoff is None:
-        cutoff = INF
-
-    R_succ = R.succ
-    R_pred = R.pred
-
-    def breath_first_search():
-        parents = {}
-        vertex_dist = {s: 0}
-        queue = deque([(s, 0)])
-        # Record all the potential edges of shortest augmenting paths
-        while queue:
-            if t in parents:
-                break
-            u, dist = queue.popleft()
-            for v, attr in R_succ[u].items():
-                if attr["capacity"] - attr["flow"] > 0:
-                    if v in parents:
-                        if vertex_dist[v] == dist + 1:
-                            parents[v].append(u)
-                    else:
-                        parents[v] = deque([u])
-                        vertex_dist[v] = dist + 1
-                        queue.append((v, dist + 1))
-        return parents
-
-    def depth_first_search(parents):
-        # DFS to find all the shortest augmenting paths
-        """Build a path using DFS starting from the sink"""
-        total_flow = 0
-        u = t
-        # path also functions as a stack
-        path = [u]
-        # The loop ends with no augmenting path left in the layered graph
-        while True:
-            if len(parents[u]) > 0:
-                v = parents[u][0]
-                path.append(v)
-            else:
-                path.pop()
-                if len(path) == 0:
-                    break
-                v = path[-1]
-                parents[v].popleft()
-            # Augment the flow along the path found
-            if v == s:
-                flow = INF
-                for u, v in pairwise(path):
-                    flow = min(flow, R_pred[u][v]["capacity"] - R_pred[u][v]["flow"])
-                for u, v in pairwise(reversed(path)):
-                    R_pred[v][u]["flow"] += flow
-                    R_pred[u][v]["flow"] -= flow
-                    # Find the proper node to continue the search
-                    if R_pred[v][u]["capacity"] - R_pred[v][u]["flow"] == 0:
-                        parents[v].popleft()
-                        while path[-1] != v:
-                            path.pop()
-                total_flow += flow
-                v = path[-1]
-            u = v
-        return total_flow
-
-    flow_value = 0
-    while flow_value < cutoff:
-        parents = breath_first_search()
-        if t not in parents:
-            break
-        this_flow = depth_first_search(parents)
-        if this_flow * 2 > INF:
-            raise nx.NetworkXUnbounded("Infinite capacity path, flow unbounded above.")
-        flow_value += this_flow
-
-    R.graph["flow_value"] = flow_value
-    return R