okstra 0.130.4 → 0.131.1

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

@@ -1,302 +0,0 @@
-"""Node assortativity coefficients and correlation measures."""
-
-import networkx as nx
-from networkx.algorithms.assortativity.mixing import (
-    attribute_mixing_matrix,
-    degree_mixing_matrix,
-)
-from networkx.algorithms.assortativity.pairs import node_degree_xy
-
-__all__ = [
-    "degree_pearson_correlation_coefficient",
-    "degree_assortativity_coefficient",
-    "attribute_assortativity_coefficient",
-    "numeric_assortativity_coefficient",
-]
-
-
-@nx._dispatchable(edge_attrs="weight")
-def degree_assortativity_coefficient(G, x="out", y="in", weight=None, nodes=None):
-    """Compute degree assortativity of graph.
-
-    Assortativity measures the similarity of connections
-    in the graph with respect to the node degree.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    x: string ('in','out')
-       The degree type for source node (directed graphs only).
-
-    y: string ('in','out')
-       The degree type for target node (directed graphs only).
-
-    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.
-       The degree is the sum of the edge weights adjacent to the node.
-
-    nodes: list or iterable (optional)
-        Compute degree assortativity only for nodes in container.
-        The default is all nodes.
-
-    Returns
-    -------
-    r : float
-       Assortativity of graph by degree.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4)
-    >>> r = nx.degree_assortativity_coefficient(G)
-    >>> print(f"{r:3.1f}")
-    -0.5
-
-    See Also
-    --------
-    attribute_assortativity_coefficient
-    numeric_assortativity_coefficient
-    degree_mixing_dict
-    degree_mixing_matrix
-
-    Notes
-    -----
-    This computes Eq. (21) in Ref. [1]_ , where e is the joint
-    probability distribution (mixing matrix) of the degrees.  If G is
-    directed than the matrix e is the joint probability of the
-    user-specified degree type for the source and target.
-
-    References
-    ----------
-    .. [1] M. E. J. Newman, Mixing patterns in networks,
-       Physical Review E, 67 026126, 2003
-    .. [2] Foster, J.G., Foster, D.V., Grassberger, P. & Paczuski, M.
-       Edge direction and the structure of networks, PNAS 107, 10815-20 (2010).
-    """
-    if nodes is None:
-        nodes = G.nodes
-
-    degrees = None
-
-    if G.is_directed():
-        indeg = (
-            {d for _, d in G.in_degree(nodes, weight=weight)}
-            if "in" in (x, y)
-            else set()
-        )
-        outdeg = (
-            {d for _, d in G.out_degree(nodes, weight=weight)}
-            if "out" in (x, y)
-            else set()
-        )
-        degrees = set.union(indeg, outdeg)
-    else:
-        degrees = {d for _, d in G.degree(nodes, weight=weight)}
-
-    mapping = {d: i for i, d in enumerate(degrees)}
-    M = degree_mixing_matrix(G, x=x, y=y, nodes=nodes, weight=weight, mapping=mapping)
-
-    return _numeric_ac(M, mapping=mapping)
-
-
-@nx._dispatchable(edge_attrs="weight")
-def degree_pearson_correlation_coefficient(G, x="out", y="in", weight=None, nodes=None):
-    """Compute degree assortativity of graph.
-
-    Assortativity measures the similarity of connections
-    in the graph with respect to the node degree.
-
-    This is the same as degree_assortativity_coefficient but uses the
-    potentially faster scipy.stats.pearsonr function.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    x: string ('in','out')
-       The degree type for source node (directed graphs only).
-
-    y: string ('in','out')
-       The degree type for target node (directed graphs only).
-
-    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.
-       The degree is the sum of the edge weights adjacent to the node.
-
-    nodes: list or iterable (optional)
-        Compute pearson correlation of degrees only for specified nodes.
-        The default is all nodes.
-
-    Returns
-    -------
-    r : float
-       Assortativity of graph by degree.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4)
-    >>> r = nx.degree_pearson_correlation_coefficient(G)
-    >>> print(f"{r:3.1f}")
-    -0.5
-
-    Notes
-    -----
-    This calls scipy.stats.pearsonr.
-
-    References
-    ----------
-    .. [1] M. E. J. Newman, Mixing patterns in networks
-           Physical Review E, 67 026126, 2003
-    .. [2] Foster, J.G., Foster, D.V., Grassberger, P. & Paczuski, M.
-       Edge direction and the structure of networks, PNAS 107, 10815-20 (2010).
-    """
-    import scipy as sp
-
-    xy = node_degree_xy(G, x=x, y=y, nodes=nodes, weight=weight)
-    x, y = zip(*xy)
-    return float(sp.stats.pearsonr(x, y)[0])
-
-
-@nx._dispatchable(node_attrs="attribute")
-def attribute_assortativity_coefficient(G, attribute, nodes=None):
-    """Compute assortativity for node attributes.
-
-    Assortativity measures the similarity of connections
-    in the graph with respect to the given attribute.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    attribute : string
-        Node attribute key
-
-    nodes: list or iterable (optional)
-        Compute attribute assortativity for nodes in container.
-        The default is all nodes.
-
-    Returns
-    -------
-    r: float
-       Assortativity of graph for given attribute
-
-    Examples
-    --------
-    >>> G = nx.Graph()
-    >>> G.add_nodes_from([0, 1], color="red")
-    >>> G.add_nodes_from([2, 3], color="blue")
-    >>> G.add_edges_from([(0, 1), (2, 3)])
-    >>> print(nx.attribute_assortativity_coefficient(G, "color"))
-    1.0
-
-    Notes
-    -----
-    This computes Eq. (2) in Ref. [1]_ , (trace(M)-sum(M^2))/(1-sum(M^2)),
-    where M is the joint probability distribution (mixing matrix)
-    of the specified attribute.
-
-    References
-    ----------
-    .. [1] M. E. J. Newman, Mixing patterns in networks,
-       Physical Review E, 67 026126, 2003
-    """
-    M = attribute_mixing_matrix(G, attribute, nodes)
-    return attribute_ac(M)
-
-
-@nx._dispatchable(node_attrs="attribute")
-def numeric_assortativity_coefficient(G, attribute, nodes=None):
-    """Compute assortativity for numerical node attributes.
-
-    Assortativity measures the similarity of connections
-    in the graph with respect to the given numeric attribute.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    attribute : string
-        Node attribute key.
-
-    nodes: list or iterable (optional)
-        Compute numeric assortativity only for attributes of nodes in
-        container. The default is all nodes.
-
-    Returns
-    -------
-    r: float
-       Assortativity of graph for given attribute
-
-    Examples
-    --------
-    >>> G = nx.Graph()
-    >>> G.add_nodes_from([0, 1], size=2)
-    >>> G.add_nodes_from([2, 3], size=3)
-    >>> G.add_edges_from([(0, 1), (2, 3)])
-    >>> print(nx.numeric_assortativity_coefficient(G, "size"))
-    1.0
-
-    Notes
-    -----
-    This computes Eq. (21) in Ref. [1]_ , which is the Pearson correlation
-    coefficient of the specified (scalar valued) attribute across edges.
-
-    References
-    ----------
-    .. [1] M. E. J. Newman, Mixing patterns in networks
-           Physical Review E, 67 026126, 2003
-    """
-    if nodes is None:
-        nodes = G.nodes
-    vals = {G.nodes[n][attribute] for n in nodes}
-    mapping = {d: i for i, d in enumerate(vals)}
-    M = attribute_mixing_matrix(G, attribute, nodes, mapping)
-    return _numeric_ac(M, mapping)
-
-
-def attribute_ac(M):
-    """Compute assortativity for attribute matrix M.
-
-    Parameters
-    ----------
-    M : numpy.ndarray
-        2D ndarray representing the attribute mixing matrix.
-
-    Notes
-    -----
-    This computes Eq. (2) in Ref. [1]_ , (trace(e)-sum(e^2))/(1-sum(e^2)),
-    where e is the joint probability distribution (mixing matrix)
-    of the specified attribute.
-
-    References
-    ----------
-    .. [1] M. E. J. Newman, Mixing patterns in networks,
-       Physical Review E, 67 026126, 2003
-    """
-    if M.sum() != 1.0:
-        M = M / M.sum()
-    s = (M @ M).sum()
-    t = M.trace()
-    r = (t - s) / (1 - s)
-    return float(r)
-
-
-def _numeric_ac(M, mapping):
-    # M is a 2D numpy array
-    # numeric assortativity coefficient, pearsonr
-    import numpy as np
-
-    if M.sum() != 1.0:
-        M = M / M.sum()
-    x = np.array(list(mapping.keys()))
-    y = x  # x and y have the same support
-    idx = list(mapping.values())
-    a = M.sum(axis=0)
-    b = M.sum(axis=1)
-    vara = (a[idx] * x**2).sum() - ((a[idx] * x).sum()) ** 2
-    varb = (b[idx] * y**2).sum() - ((b[idx] * y).sum()) ** 2
-    xy = np.outer(x, y)
-    ab = np.outer(a[idx], b[idx])
-    return float((xy * (M - ab)).sum() / np.sqrt(vara * varb))

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

@@ -1,255 +0,0 @@
-"""
-Mixing matrices for node attributes and degree.
-"""
-
-import networkx as nx
-from networkx.algorithms.assortativity.pairs import node_attribute_xy, node_degree_xy
-from networkx.utils import dict_to_numpy_array
-
-__all__ = [
-    "attribute_mixing_matrix",
-    "attribute_mixing_dict",
-    "degree_mixing_matrix",
-    "degree_mixing_dict",
-    "mixing_dict",
-]
-
-
-@nx._dispatchable(node_attrs="attribute")
-def attribute_mixing_dict(G, attribute, nodes=None, normalized=False):
-    """Returns dictionary representation of mixing matrix for attribute.
-
-    Parameters
-    ----------
-    G : graph
-       NetworkX graph object.
-
-    attribute : string
-       Node attribute key.
-
-    nodes: list or iterable (optional)
-        Unse nodes in container to build the dict. The default is all nodes.
-
-    normalized : bool (default=False)
-       Return counts if False or probabilities if True.
-
-    Examples
-    --------
-    >>> G = nx.Graph()
-    >>> G.add_nodes_from([0, 1], color="red")
-    >>> G.add_nodes_from([2, 3], color="blue")
-    >>> G.add_edge(1, 3)
-    >>> d = nx.attribute_mixing_dict(G, "color")
-    >>> print(d["red"]["blue"])
-    1
-    >>> print(d["blue"]["red"])  # d symmetric for undirected graphs
-    1
-
-    Returns
-    -------
-    d : dictionary
-       Counts or joint probability of occurrence of attribute pairs.
-    """
-    xy_iter = node_attribute_xy(G, attribute, nodes)
-    return mixing_dict(xy_iter, normalized=normalized)
-
-
-@nx._dispatchable(node_attrs="attribute")
-def attribute_mixing_matrix(G, attribute, nodes=None, mapping=None, normalized=True):
-    """Returns mixing matrix for attribute.
-
-    Parameters
-    ----------
-    G : graph
-       NetworkX graph object.
-
-    attribute : string
-       Node attribute key.
-
-    nodes: list or iterable (optional)
-        Use only nodes in container to build the matrix. The default is
-        all nodes.
-
-    mapping : dictionary, optional
-       Mapping from node attribute to integer index in matrix.
-       If not specified, an arbitrary ordering will be used.
-
-    normalized : bool (default=True)
-       Return counts if False or probabilities if True.
-
-    Returns
-    -------
-    m: numpy array
-       Counts or joint probability of occurrence of attribute pairs.
-
-    Notes
-    -----
-    If each node has a unique attribute value, the unnormalized mixing matrix
-    will be equal to the adjacency matrix. To get a denser mixing matrix,
-    the rounding can be performed to form groups of nodes with equal values.
-    For example, the exact height of persons in cm (180.79155222, 163.9080892,
-    163.30095355, 167.99016217, 168.21590163, ...) can be rounded to (180, 163,
-    163, 168, 168, ...).
-
-    Definitions of attribute mixing matrix vary on whether the matrix
-    should include rows for attribute values that don't arise. Here we
-    do not include such empty-rows. But you can force them to appear
-    by inputting a `mapping` that includes those values.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(3)
-    >>> gender = {0: "male", 1: "female", 2: "female"}
-    >>> nx.set_node_attributes(G, gender, "gender")
-    >>> mapping = {"male": 0, "female": 1}
-    >>> mix_mat = nx.attribute_mixing_matrix(G, "gender", mapping=mapping)
-    >>> mix_mat
-    array([[0.  , 0.25],
-           [0.25, 0.5 ]])
-    """
-    d = attribute_mixing_dict(G, attribute, nodes)
-    a = dict_to_numpy_array(d, mapping=mapping)
-    if normalized:
-        a = a / a.sum()
-    return a
-
-
-@nx._dispatchable(edge_attrs="weight")
-def degree_mixing_dict(G, x="out", y="in", weight=None, nodes=None, normalized=False):
-    """Returns dictionary representation of mixing matrix for degree.
-
-    Parameters
-    ----------
-    G : graph
-        NetworkX graph object.
-
-    x: string ('in','out')
-       The degree type for source node (directed graphs only).
-
-    y: string ('in','out')
-       The degree type for target node (directed graphs only).
-
-    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.
-       The degree is the sum of the edge weights adjacent to the node.
-
-    normalized : bool (default=False)
-        Return counts if False or probabilities if True.
-
-    Returns
-    -------
-    d: dictionary
-       Counts or joint probability of occurrence of degree pairs.
-    """
-    xy_iter = node_degree_xy(G, x=x, y=y, nodes=nodes, weight=weight)
-    return mixing_dict(xy_iter, normalized=normalized)
-
-
-@nx._dispatchable(edge_attrs="weight")
-def degree_mixing_matrix(
-    G, x="out", y="in", weight=None, nodes=None, normalized=True, mapping=None
-):
-    """Returns mixing matrix for attribute.
-
-    Parameters
-    ----------
-    G : graph
-       NetworkX graph object.
-
-    x: string ('in','out')
-       The degree type for source node (directed graphs only).
-
-    y: string ('in','out')
-       The degree type for target node (directed graphs only).
-
-    nodes: list or iterable (optional)
-        Build the matrix using only nodes in container.
-        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.
-       The degree is the sum of the edge weights adjacent to the node.
-
-    normalized : bool (default=True)
-       Return counts if False or probabilities if True.
-
-    mapping : dictionary, optional
-       Mapping from node degree to integer index in matrix.
-       If not specified, an arbitrary ordering will be used.
-
-    Returns
-    -------
-    m: numpy array
-       Counts, or joint probability, of occurrence of node degree.
-
-    Notes
-    -----
-    Definitions of degree mixing matrix vary on whether the matrix
-    should include rows for degree values that don't arise. Here we
-    do not include such empty-rows. But you can force them to appear
-    by inputting a `mapping` that includes those values. See examples.
-
-    Examples
-    --------
-    >>> G = nx.star_graph(3)
-    >>> mix_mat = nx.degree_mixing_matrix(G)
-    >>> mix_mat
-    array([[0. , 0.5],
-           [0.5, 0. ]])
-
-    If you want every possible degree to appear as a row, even if no nodes
-    have that degree, use `mapping` as follows,
-
-    >>> max_degree = max(deg for n, deg in G.degree)
-    >>> mapping = {x: x for x in range(max_degree + 1)}  # identity mapping
-    >>> mix_mat = nx.degree_mixing_matrix(G, mapping=mapping)
-    >>> mix_mat
-    array([[0. , 0. , 0. , 0. ],
-           [0. , 0. , 0. , 0.5],
-           [0. , 0. , 0. , 0. ],
-           [0. , 0.5, 0. , 0. ]])
-    """
-    d = degree_mixing_dict(G, x=x, y=y, nodes=nodes, weight=weight)
-    a = dict_to_numpy_array(d, mapping=mapping)
-    if normalized:
-        a = a / a.sum()
-    return a
-
-
-def mixing_dict(xy, normalized=False):
-    """Returns a dictionary representation of mixing matrix.
-
-    Parameters
-    ----------
-    xy : list or container of two-tuples
-       Pairs of (x,y) items.
-
-    attribute : string
-       Node attribute key
-
-    normalized : bool (default=False)
-       Return counts if False or probabilities if True.
-
-    Returns
-    -------
-    d: dictionary
-       Counts or Joint probability of occurrence of values in xy.
-    """
-    d = {}
-    psum = 0.0
-    for x, y in xy:
-        if x not in d:
-            d[x] = {}
-        if y not in d:
-            d[y] = {}
-        v = d[x].get(y, 0)
-        d[x][y] = v + 1
-        psum += 1
-
-    if normalized:
-        for _, jdict in d.items():
-            for j in jdict:
-                jdict[j] /= psum
-    return d

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

@@ -1,160 +0,0 @@
-import networkx as nx
-
-__all__ = ["average_neighbor_degree"]
-
-
-@nx._dispatchable(edge_attrs="weight")
-def average_neighbor_degree(G, source="out", target="out", nodes=None, weight=None):
-    r"""Returns the average degree of the neighborhood of each node.
-
-    In an undirected graph, the neighborhood `N(i)` of node `i` contains the
-    nodes that are connected to `i` by an edge.
-
-    For directed graphs, `N(i)` is defined according to the parameter `source`:
-
-        - if source is 'in', then `N(i)` consists of predecessors of node `i`.
-        - if source is 'out', then `N(i)` consists of successors of node `i`.
-        - if source is 'in+out', then `N(i)` is both predecessors and successors.
-
-    The average neighborhood degree of a node `i` is
-
-    .. math::
-
-        k_{nn,i} = \frac{1}{|N(i)|} \sum_{j \in N(i)} k_j
-
-    where `N(i)` are the neighbors of node `i` and `k_j` is
-    the degree of node `j` which belongs to `N(i)`. For weighted
-    graphs, an analogous measure can be defined [1]_,
-
-    .. 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 : string ("in"|"out"|"in+out"), optional (default="out")
-       Directed graphs only.
-       Use "in"- or "out"-neighbors of source node.
-
-    target : string ("in"|"out"|"in+out"), optional (default="out")
-       Directed graphs only.
-       Use "in"- or "out"-degree for target node.
-
-    nodes : list or iterable, optional (default=G.nodes)
-        Compute neighbor degree only for specified 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 node to the average degree of its neighbors.
-
-    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[0, 1]["weight"] = 5
-    >>> G.edges[2, 3]["weight"] = 3
-
-    >>> nx.average_neighbor_degree(G)
-    {0: 2.0, 1: 1.5, 2: 1.5, 3: 2.0}
-    >>> nx.average_neighbor_degree(G, weight="weight")
-    {0: 2.0, 1: 1.1666666666666667, 2: 1.25, 3: 2.0}
-
-    >>> G = nx.DiGraph()
-    >>> nx.add_path(G, [0, 1, 2, 3])
-    >>> nx.average_neighbor_degree(G, source="in", target="in")
-    {0: 0.0, 1: 0.0, 2: 1.0, 3: 1.0}
-
-    >>> nx.average_neighbor_degree(G, source="out", target="out")
-    {0: 1.0, 1: 1.0, 2: 0.0, 3: 0.0}
-
-    See Also
-    --------
-    average_degree_connectivity
-
-    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).
-    """
-    if G.is_directed():
-        if source == "in":
-            source_degree = G.in_degree
-        elif source == "out":
-            source_degree = G.out_degree
-        elif source == "in+out":
-            source_degree = G.degree
-        else:
-            raise nx.NetworkXError(
-                f"source argument {source} must be 'in', 'out' or 'in+out'"
-            )
-
-        if target == "in":
-            target_degree = G.in_degree
-        elif target == "out":
-            target_degree = G.out_degree
-        elif target == "in+out":
-            target_degree = G.degree
-        else:
-            raise nx.NetworkXError(
-                f"target argument {target} must be 'in', 'out' or 'in+out'"
-            )
-    else:
-        if source != "out" or target != "out":
-            raise nx.NetworkXError(
-                f"source and target arguments are only supported for directed graphs"
-            )
-        source_degree = target_degree = G.degree
-
-    # precompute target degrees -- should *not* be weighted degree
-    t_deg = dict(target_degree())
-
-    # Set up both predecessor and successor neighbor dicts leaving empty if not needed
-    G_P = G_S = {n: {} for n in G}
-    if G.is_directed():
-        # "in" or "in+out" cases: G_P contains predecessors
-        if "in" in source:
-            G_P = G.pred
-        # "out" or "in+out" cases: G_S contains successors
-        if "out" in source:
-            G_S = G.succ
-    else:
-        # undirected leave G_P empty but G_S is the adjacency
-        G_S = G.adj
-
-    # Main loop: Compute average degree of neighbors
-    avg = {}
-    for n, deg in source_degree(nodes, weight=weight):
-        # handle degree zero average
-        if deg == 0:
-            avg[n] = 0.0
-            continue
-
-        # we sum over both G_P and G_S, but one of the two is usually empty.
-        if weight is None:
-            avg[n] = (
-                sum(t_deg[nbr] for nbr in G_S[n]) + sum(t_deg[nbr] for nbr in G_P[n])
-            ) / deg
-        else:
-            avg[n] = (
-                sum(dd.get(weight, 1) * t_deg[nbr] for nbr, dd in G_S[n].items())
-                + sum(dd.get(weight, 1) * t_deg[nbr] for nbr, dd in G_P[n].items())
-            ) / deg
-    return avg