okstra 0.130.3 → 0.131.0

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/treewidth.py

@@ -1,255 +0,0 @@
-"""Functions for computing treewidth decomposition.
-
-Treewidth of an undirected graph is a number associated with the graph.
-It can be defined as the size of the largest vertex set (bag) in a tree
-decomposition of the graph minus one.
-
-`Wikipedia: Treewidth <https://en.wikipedia.org/wiki/Treewidth>`_
-
-The notions of treewidth and tree decomposition have gained their
-attractiveness partly because many graph and network problems that are
-intractable (e.g., NP-hard) on arbitrary graphs become efficiently
-solvable (e.g., with a linear time algorithm) when the treewidth of the
-input graphs is bounded by a constant [1]_ [2]_.
-
-There are two different functions for computing a tree decomposition:
-:func:`treewidth_min_degree` and :func:`treewidth_min_fill_in`.
-
-.. [1] Hans L. Bodlaender and Arie M. C. A. Koster. 2010. "Treewidth
-      computations I.Upper bounds". Inf. Comput. 208, 3 (March 2010),259-275.
-      http://dx.doi.org/10.1016/j.ic.2009.03.008
-
-.. [2] Hans L. Bodlaender. "Discovering Treewidth". Institute of Information
-      and Computing Sciences, Utrecht University.
-      Technical Report UU-CS-2005-018.
-      http://www.cs.uu.nl
-
-.. [3] K. Wang, Z. Lu, and J. Hicks *Treewidth*.
-      https://web.archive.org/web/20210507025929/http://web.eecs.utk.edu/~cphill25/cs594_spring2015_projects/treewidth.pdf
-
-"""
-
-import itertools
-import sys
-from heapq import heapify, heappop, heappush
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["treewidth_min_degree", "treewidth_min_fill_in"]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable(returns_graph=True)
-def treewidth_min_degree(G):
-    """Returns a treewidth decomposition using the Minimum Degree heuristic.
-
-    The heuristic chooses the nodes according to their degree, i.e., first
-    the node with the lowest degree is chosen, then the graph is updated
-    and the corresponding node is removed. Next, a new node with the lowest
-    degree is chosen, and so on.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    Returns
-    -------
-    Treewidth decomposition : (int, Graph) tuple
-          2-tuple with treewidth and the corresponding decomposed tree.
-    """
-    deg_heuristic = MinDegreeHeuristic(G)
-    return treewidth_decomp(G, lambda graph: deg_heuristic.best_node(graph))
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable(returns_graph=True)
-def treewidth_min_fill_in(G):
-    """Returns a treewidth decomposition using the Minimum Fill-in heuristic.
-
-    The heuristic chooses a node from the graph, where the number of edges
-    added turning the neighborhood of the chosen node into clique is as
-    small as possible.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    Returns
-    -------
-    Treewidth decomposition : (int, Graph) tuple
-        2-tuple with treewidth and the corresponding decomposed tree.
-    """
-    return treewidth_decomp(G, min_fill_in_heuristic)
-
-
-class MinDegreeHeuristic:
-    """Implements the Minimum Degree heuristic.
-
-    The heuristic chooses the nodes according to their degree
-    (number of neighbors), i.e., first the node with the lowest degree is
-    chosen, then the graph is updated and the corresponding node is
-    removed. Next, a new node with the lowest degree is chosen, and so on.
-    """
-
-    def __init__(self, graph):
-        self._graph = graph
-
-        # nodes that have to be updated in the heap before each iteration
-        self._update_nodes = []
-
-        self._degreeq = []  # a heapq with 3-tuples (degree,unique_id,node)
-        self.count = itertools.count()
-
-        # build heap with initial degrees
-        for n in graph:
-            self._degreeq.append((len(graph[n]), next(self.count), n))
-        heapify(self._degreeq)
-
-    def best_node(self, graph):
-        # update nodes in self._update_nodes
-        for n in self._update_nodes:
-            # insert changed degrees into degreeq
-            heappush(self._degreeq, (len(graph[n]), next(self.count), n))
-
-        # get the next valid (minimum degree) node
-        while self._degreeq:
-            (min_degree, _, elim_node) = heappop(self._degreeq)
-            if elim_node not in graph or len(graph[elim_node]) != min_degree:
-                # outdated entry in degreeq
-                continue
-            elif min_degree == len(graph) - 1:
-                # fully connected: abort condition
-                return None
-
-            # remember to update nodes in the heap before getting the next node
-            self._update_nodes = graph[elim_node]
-            return elim_node
-
-        # the heap is empty: abort
-        return None
-
-
-def min_fill_in_heuristic(graph_dict):
-    """Implements the Minimum Degree heuristic.
-
-    graph_dict: dict keyed by node to sets of neighbors (no self-loops)
-
-    Returns the node from the graph, where the number of edges added when
-    turning the neighborhood of the chosen node into clique is as small as
-    possible. This algorithm chooses the nodes using the Minimum Fill-In
-    heuristic. The running time of the algorithm is :math:`O(V^3)` and it uses
-    additional constant memory.
-    """
-
-    if len(graph_dict) == 0:
-        return None
-
-    min_fill_in_node = None
-
-    min_fill_in = sys.maxsize
-
-    # sort nodes by degree
-    nodes_by_degree = sorted(graph_dict, key=lambda x: len(graph_dict[x]))
-    min_degree = len(graph_dict[nodes_by_degree[0]])
-
-    # abort condition (handle complete graph)
-    if min_degree == len(graph_dict) - 1:
-        return None
-
-    for node in nodes_by_degree:
-        num_fill_in = 0
-        nbrs = graph_dict[node]
-        for nbr in nbrs:
-            # count how many nodes in nbrs current nbr is not connected to
-            # subtract 1 for the node itself
-            num_fill_in += len(nbrs - graph_dict[nbr]) - 1
-            if num_fill_in >= 2 * min_fill_in:
-                break
-
-        num_fill_in /= 2  # divide by 2 because of double counting
-
-        if num_fill_in < min_fill_in:  # update min-fill-in node
-            if num_fill_in == 0:
-                return node
-            min_fill_in = num_fill_in
-            min_fill_in_node = node
-
-    return min_fill_in_node
-
-
-@nx._dispatchable(returns_graph=True)
-def treewidth_decomp(G, heuristic=min_fill_in_heuristic):
-    """Returns a treewidth decomposition using the passed heuristic.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-    heuristic : heuristic function
-
-    Returns
-    -------
-    Treewidth decomposition : (int, Graph) tuple
-        2-tuple with treewidth and the corresponding decomposed tree.
-    """
-
-    # make dict-of-sets structure
-    graph_dict = {n: set(G[n]) - {n} for n in G}
-
-    # stack containing nodes and neighbors in the order from the heuristic
-    node_stack = []
-
-    # get first node from heuristic
-    elim_node = heuristic(graph_dict)
-    while elim_node is not None:
-        # connect all neighbors with each other
-        nbrs = graph_dict[elim_node]
-        for u, v in itertools.permutations(nbrs, 2):
-            if v not in graph_dict[u]:
-                graph_dict[u].add(v)
-
-        # push node and its current neighbors on stack
-        node_stack.append((elim_node, nbrs))
-
-        # remove node from graph_dict
-        for u in graph_dict[elim_node]:
-            graph_dict[u].remove(elim_node)
-
-        del graph_dict[elim_node]
-        elim_node = heuristic(graph_dict)
-
-    # the abort condition is met; put all remaining nodes into one bag
-    decomp = nx.Graph()
-    first_bag = frozenset(graph_dict.keys())
-    decomp.add_node(first_bag)
-
-    treewidth = len(first_bag) - 1
-
-    while node_stack:
-        # get node and its neighbors from the stack
-        (curr_node, nbrs) = node_stack.pop()
-
-        # find a bag all neighbors are in
-        old_bag = None
-        for bag in decomp.nodes:
-            if nbrs <= bag:
-                old_bag = bag
-                break
-
-        if old_bag is None:
-            # no old_bag was found: just connect to the first_bag
-            old_bag = first_bag
-
-        # create new node for decomposition
-        nbrs.add(curr_node)
-        new_bag = frozenset(nbrs)
-
-        # update treewidth
-        treewidth = max(treewidth, len(new_bag) - 1)
-
-        # add edge to decomposition (implicitly also adds the new node)
-        decomp.add_edge(old_bag, new_bag)
-
-    return treewidth, decomp

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/vertex_cover.py

@@ -1,83 +0,0 @@
-"""Functions for computing an approximate minimum weight vertex cover.
-
-A |vertex cover|_ is a subset of nodes such that each edge in the graph
-is incident to at least one node in the subset.
-
-.. _vertex cover: https://en.wikipedia.org/wiki/Vertex_cover
-.. |vertex cover| replace:: *vertex cover*
-
-"""
-
-import networkx as nx
-
-__all__ = ["min_weighted_vertex_cover"]
-
-
-@nx._dispatchable(node_attrs="weight")
-def min_weighted_vertex_cover(G, weight=None):
-    r"""Returns an approximate minimum weighted vertex cover.
-
-    The set of nodes returned by this function is guaranteed to be a
-    vertex cover, and the total weight of the set is guaranteed to be at
-    most twice the total weight of the minimum weight vertex cover. In
-    other words,
-
-    .. math::
-
-       w(S) \leq 2 * w(S^*),
-
-    where $S$ is the vertex cover returned by this function,
-    $S^*$ is the vertex cover of minimum weight out of all vertex
-    covers of the graph, and $w$ is the function that computes the
-    sum of the weights of each node in that given set.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    weight : string, optional (default = None)
-        If None, every node has weight 1. If a string, use this node
-        attribute as the node weight. A node without this attribute is
-        assumed to have weight 1.
-
-    Returns
-    -------
-    min_weighted_cover : set
-        Returns a set of nodes whose weight sum is no more than twice
-        the weight sum of the minimum weight vertex cover.
-
-    Notes
-    -----
-    For a directed graph, a vertex cover has the same definition: a set
-    of nodes such that each edge in the graph is incident to at least
-    one node in the set. Whether the node is the head or tail of the
-    directed edge is ignored.
-
-    This is the local-ratio algorithm for computing an approximate
-    vertex cover. The algorithm greedily reduces the costs over edges,
-    iteratively building a cover. The worst-case runtime of this
-    implementation is $O(m \log n)$, where $n$ is the number
-    of nodes and $m$ the number of edges in the graph.
-
-    References
-    ----------
-    .. [1] Bar-Yehuda, R., and Even, S. (1985). "A local-ratio theorem for
-       approximating the weighted vertex cover problem."
-       *Annals of Discrete Mathematics*, 25, 27–46
-       <http://www.cs.technion.ac.il/~reuven/PDF/vc_lr.pdf>
-
-    """
-    cost = dict(G.nodes(data=weight, default=1))
-    # While there are uncovered edges, choose an uncovered and update
-    # the cost of the remaining edges.
-    cover = set()
-    for u, v in G.edges():
-        if u in cover or v in cover:
-            continue
-        if cost[u] <= cost[v]:
-            cover.add(u)
-            cost[v] -= cost[u]
-        else:
-            cover.add(v)
-            cost[u] -= cost[v]
-    return cover

package/runtime/python/okstra_vendor/networkx/algorithms/assortativity/__init__.py

@@ -1,5 +0,0 @@
-from networkx.algorithms.assortativity.connectivity import *
-from networkx.algorithms.assortativity.correlation import *
-from networkx.algorithms.assortativity.mixing import *
-from networkx.algorithms.assortativity.neighbor_degree import *
-from networkx.algorithms.assortativity.pairs import *

package/runtime/python/okstra_vendor/networkx/algorithms/assortativity/connectivity.py

@@ -1,122 +0,0 @@
-from collections import defaultdict
-
-import networkx as nx
-
-__all__ = ["average_degree_connectivity"]
-
-
-@nx._dispatchable(edge_attrs="weight")
-def average_degree_connectivity(
-    G, source="in+out", target="in+out", nodes=None, weight=None
-):
-    r"""Compute the average degree connectivity of graph.
-
-    The average degree connectivity is the average nearest neighbor degree of
-    nodes with degree k. For weighted graphs, an analogous measure can
-    be computed using the weighted average neighbors degree defined in
-    [1]_, for a node `i`, as
-
-    .. math::
-
-        k_{nn,i}^{w} = \frac{1}{s_i} \sum_{j \in N(i)} w_{ij} k_j
-
-    where `s_i` is the weighted degree of node `i`,
-    `w_{ij}` is the weight of the edge that links `i` and `j`,
-    and `N(i)` are the neighbors of node `i`.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    source :  "in"|"out"|"in+out" (default:"in+out")
-       Directed graphs only. Use "in"- or "out"-degree for source node.
-
-    target : "in"|"out"|"in+out" (default:"in+out"
-       Directed graphs only. Use "in"- or "out"-degree for target node.
-
-    nodes : list or iterable (optional)
-        Compute neighbor connectivity for these nodes. The default is all
-        nodes.
-
-    weight : string or None, optional (default=None)
-       The edge attribute that holds the numerical value used as a weight.
-       If None, then each edge has weight 1.
-
-    Returns
-    -------
-    d : dict
-       A dictionary keyed by degree k with the value of average connectivity.
-
-    Raises
-    ------
-    NetworkXError
-        If either `source` or `target` are not one of 'in',
-        'out', or 'in+out'.
-        If either `source` or `target` is passed for an undirected graph.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4)
-    >>> G.edges[1, 2]["weight"] = 3
-    >>> nx.average_degree_connectivity(G)
-    {1: 2.0, 2: 1.5}
-    >>> nx.average_degree_connectivity(G, weight="weight")
-    {1: 2.0, 2: 1.75}
-
-    See Also
-    --------
-    average_neighbor_degree
-
-    References
-    ----------
-    .. [1] A. Barrat, M. Barthélemy, R. Pastor-Satorras, and A. Vespignani,
-       "The architecture of complex weighted networks".
-       PNAS 101 (11): 3747–3752 (2004).
-    """
-    # First, determine the type of neighbors and the type of degree to use.
-    if G.is_directed():
-        if source not in ("in", "out", "in+out"):
-            raise nx.NetworkXError('source must be one of "in", "out", or "in+out"')
-        if target not in ("in", "out", "in+out"):
-            raise nx.NetworkXError('target must be one of "in", "out", or "in+out"')
-        direction = {"out": G.out_degree, "in": G.in_degree, "in+out": G.degree}
-        neighbor_funcs = {
-            "out": G.successors,
-            "in": G.predecessors,
-            "in+out": G.neighbors,
-        }
-        source_degree = direction[source]
-        target_degree = direction[target]
-        neighbors = neighbor_funcs[source]
-        # `reverse` indicates whether to look at the in-edge when
-        # computing the weight of an edge.
-        reverse = source == "in"
-    else:
-        if source != "in+out" or target != "in+out":
-            raise nx.NetworkXError(
-                f"source and target arguments are only supported for directed graphs"
-            )
-        source_degree = G.degree
-        target_degree = G.degree
-        neighbors = G.neighbors
-        reverse = False
-    dsum = defaultdict(int)
-    dnorm = defaultdict(int)
-    # Check if `source_nodes` is actually a single node in the graph.
-    source_nodes = source_degree(nodes)
-    if nodes in G:
-        source_nodes = [(nodes, source_degree(nodes))]
-    for n, k in source_nodes:
-        nbrdeg = target_degree(neighbors(n))
-        if weight is None:
-            s = sum(d for n, d in nbrdeg)
-        else:  # weight nbr degree by weight of (n,nbr) edge
-            if reverse:
-                s = sum(G[nbr][n].get(weight, 1) * d for nbr, d in nbrdeg)
-            else:
-                s = sum(G[n][nbr].get(weight, 1) * d for nbr, d in nbrdeg)
-        dnorm[k] += source_degree(n, weight=weight)
-        dsum[k] += s
-
-    # normalize
-    return {k: avg if dnorm[k] == 0 else avg / dnorm[k] for k, avg in dsum.items()}