okstra 0.130.3 → 0.131.0

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

@@ -1,54 +0,0 @@
-"""Functions for generating stochastic graphs from a given weighted directed
-graph.
-
-"""
-
-import networkx as nx
-from networkx.classes import DiGraph, MultiDiGraph
-from networkx.utils import not_implemented_for
-
-__all__ = ["stochastic_graph"]
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable(
-    edge_attrs="weight", mutates_input={"not copy": 1}, returns_graph=True
-)
-def stochastic_graph(G, copy=True, weight="weight"):
-    """Returns a right-stochastic representation of directed graph `G`.
-
-    A right-stochastic graph is a weighted digraph in which for each
-    node, the sum of the weights of all the out-edges of that node is
-    1. If the graph is already weighted (for example, via a 'weight'
-    edge attribute), the reweighting takes that into account.
-
-    Parameters
-    ----------
-    G : directed graph
-        A :class:`~networkx.DiGraph` or :class:`~networkx.MultiDiGraph`.
-
-    copy : boolean, optional
-        If this is True, then this function returns a new graph with
-        the stochastic reweighting. Otherwise, the original graph is
-        modified in-place (and also returned, for convenience).
-
-    weight : edge attribute key (optional, default='weight')
-        Edge attribute key used for reading the existing weight and
-        setting the new weight.  If no attribute with this key is found
-        for an edge, then the edge weight is assumed to be 1. If an edge
-        has a weight, it must be a positive number.
-
-    """
-    if copy:
-        G = MultiDiGraph(G) if G.is_multigraph() else DiGraph(G)
-    # There is a tradeoff here: the dictionary of node degrees may
-    # require a lot of memory, whereas making a call to `G.out_degree`
-    # inside the loop may be costly in computation time.
-    degree = dict(G.out_degree(weight=weight))
-    for u, v, d in G.edges(data=True):
-        if degree[u] == 0:
-            d[weight] = 0
-        else:
-            d[weight] = d.get(weight, 1) / degree[u]
-    nx._clear_cache(G)
-    return G

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

@@ -1,131 +0,0 @@
-"""Generator for Sudoku graphs
-
-This module gives a generator for n-Sudoku graphs. It can be used to develop
-algorithms for solving or generating Sudoku puzzles.
-
-A completed Sudoku grid is a 9x9 array of integers between 1 and 9, with no
-number appearing twice in the same row, column, or 3x3 box.
-
-+---------+---------+---------+
-| | 8 6 4 | | 3 7 1 | | 2 5 9 |
-| | 3 2 5 | | 8 4 9 | | 7 6 1 |
-| | 9 7 1 | | 2 6 5 | | 8 4 3 |
-+---------+---------+---------+
-| | 4 3 6 | | 1 9 2 | | 5 8 7 |
-| | 1 9 8 | | 6 5 7 | | 4 3 2 |
-| | 2 5 7 | | 4 8 3 | | 9 1 6 |
-+---------+---------+---------+
-| | 6 8 9 | | 7 3 4 | | 1 2 5 |
-| | 7 1 3 | | 5 2 8 | | 6 9 4 |
-| | 5 4 2 | | 9 1 6 | | 3 7 8 |
-+---------+---------+---------+
-
-
-The Sudoku graph is an undirected graph with 81 vertices, corresponding to
-the cells of a Sudoku grid. It is a regular graph of degree 20. Two distinct
-vertices are adjacent if and only if the corresponding cells belong to the
-same row, column, or box. A completed Sudoku grid corresponds to a vertex
-coloring of the Sudoku graph with nine colors.
-
-More generally, the n-Sudoku graph is a graph with n^4 vertices, corresponding
-to the cells of an n^2 by n^2 grid. Two distinct vertices are adjacent if and
-only if they belong to the same row, column, or n by n box.
-
-References
-----------
-.. [1] Herzberg, A. M., & Murty, M. R. (2007). Sudoku squares and chromatic
-    polynomials. Notices of the AMS, 54(6), 708-717.
-.. [2] Sander, Torsten (2009), "Sudoku graphs are integral",
-    Electronic Journal of Combinatorics, 16 (1): Note 25, 7pp, MR 2529816
-.. [3] Wikipedia contributors. "Glossary of Sudoku." Wikipedia, The Free
-    Encyclopedia, 3 Dec. 2019. Web. 22 Dec. 2019.
-"""
-
-import networkx as nx
-from networkx.exception import NetworkXError
-
-__all__ = ["sudoku_graph"]
-
-
-@nx._dispatchable(graphs=None, returns_graph=True)
-def sudoku_graph(n=3):
-    """Returns the n-Sudoku graph. The default value of n is 3.
-
-    The n-Sudoku graph is a graph with n^4 vertices, corresponding to the
-    cells of an n^2 by n^2 grid. Two distinct vertices are adjacent if and
-    only if they belong to the same row, column, or n-by-n box.
-
-    Parameters
-    ----------
-    n: integer
-       The order of the Sudoku graph, equal to the square root of the
-       number of rows. The default is 3.
-
-    Returns
-    -------
-    NetworkX graph
-        The n-Sudoku graph Sud(n).
-
-    Examples
-    --------
-    >>> G = nx.sudoku_graph()
-    >>> G.number_of_nodes()
-    81
-    >>> G.number_of_edges()
-    810
-    >>> sorted(G.neighbors(42))
-    [6, 15, 24, 33, 34, 35, 36, 37, 38, 39, 40, 41, 43, 44, 51, 52, 53, 60, 69, 78]
-    >>> G = nx.sudoku_graph(2)
-    >>> G.number_of_nodes()
-    16
-    >>> G.number_of_edges()
-    56
-
-    References
-    ----------
-    .. [1] Herzberg, A. M., & Murty, M. R. (2007). Sudoku squares and chromatic
-       polynomials. Notices of the AMS, 54(6), 708-717.
-    .. [2] Sander, Torsten (2009), "Sudoku graphs are integral",
-       Electronic Journal of Combinatorics, 16 (1): Note 25, 7pp, MR 2529816
-    .. [3] Wikipedia contributors. "Glossary of Sudoku." Wikipedia, The Free
-       Encyclopedia, 3 Dec. 2019. Web. 22 Dec. 2019.
-    """
-
-    if n < 0:
-        raise NetworkXError("The order must be greater than or equal to zero.")
-
-    n2 = n * n
-    n3 = n2 * n
-    n4 = n3 * n
-
-    # Construct an empty graph with n^4 nodes
-    G = nx.empty_graph(n4)
-
-    # A Sudoku graph of order 0 or 1 has no edges
-    if n < 2:
-        return G
-
-    # Add edges for cells in the same row
-    for row_no in range(n2):
-        row_start = row_no * n2
-        for j in range(1, n2):
-            for i in range(j):
-                G.add_edge(row_start + i, row_start + j)
-
-    # Add edges for cells in the same column
-    for col_no in range(n2):
-        for j in range(col_no, n4, n2):
-            for i in range(col_no, j, n2):
-                G.add_edge(i, j)
-
-    # Add edges for cells in the same box
-    for band_no in range(n):
-        for stack_no in range(n):
-            box_start = n3 * band_no + n * stack_no
-            for j in range(1, n2):
-                for i in range(j):
-                    u = box_start + (i % n) + n2 * (i // n)
-                    v = box_start + (j % n) + n2 * (j // n)
-                    G.add_edge(u, v)
-
-    return G

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

@@ -1,74 +0,0 @@
-"""
-Time Series Graphs
-"""
-
-import itertools
-
-import networkx as nx
-
-__all__ = ["visibility_graph"]
-
-
-@nx._dispatchable(graphs=None, returns_graph=True)
-def visibility_graph(series):
-    """
-    Return a Visibility Graph of an input Time Series.
-
-    A visibility graph converts a time series into a graph. The constructed graph
-    uses integer nodes to indicate which event in the series the node represents.
-    Edges are formed as follows: consider a bar plot of the series and view that
-    as a side view of a landscape with a node at the top of each bar. An edge
-    means that the nodes can be connected by a straight "line-of-sight" without
-    being obscured by any bars between the nodes.
-
-    The resulting graph inherits several properties of the series in its structure.
-    Thereby, periodic series convert into regular graphs, random series convert
-    into random graphs, and fractal series convert into scale-free networks [1]_.
-
-    Parameters
-    ----------
-    series : Sequence[Number]
-       A Time Series sequence (iterable and sliceable) of numeric values
-       representing times.
-
-    Returns
-    -------
-    NetworkX Graph
-        The Visibility Graph of the input series
-
-    Examples
-    --------
-    >>> series_list = [range(10), [2, 1, 3, 2, 1, 3, 2, 1, 3, 2, 1, 3]]
-    >>> for s in series_list:
-    ...     g = nx.visibility_graph(s)
-    ...     print(g)
-    Graph with 10 nodes and 9 edges
-    Graph with 12 nodes and 18 edges
-
-    References
-    ----------
-    .. [1] Lacasa, Lucas, Bartolo Luque, Fernando Ballesteros, Jordi Luque, and Juan Carlos Nuno.
-           "From time series to complex networks: The visibility graph." Proceedings of the
-           National Academy of Sciences 105, no. 13 (2008): 4972-4975.
-           https://www.pnas.org/doi/10.1073/pnas.0709247105
-    """
-
-    # Sequential values are always connected
-    G = nx.path_graph(len(series))
-    nx.set_node_attributes(G, dict(enumerate(series)), "value")
-
-    # Check all combinations of nodes n series
-    for (n1, t1), (n2, t2) in itertools.combinations(enumerate(series), 2):
-        # check if any value between obstructs line of sight
-        slope = (t2 - t1) / (n2 - n1)
-        offset = t2 - slope * n2
-
-        obstructed = any(
-            t >= slope * n + offset
-            for n, t in enumerate(series[n1 + 1 : n2], start=n1 + 1)
-        )
-
-        if not obstructed:
-            G.add_edge(n1, n2)
-
-    return G