okstra 0.130.3 → 0.131.0

package/runtime/python/okstra_vendor/networkx/linalg/attrmatrix.py

@@ -1,466 +0,0 @@
-"""
-Functions for constructing matrix-like objects from graph attributes.
-"""
-
-import networkx as nx
-
-__all__ = ["attr_matrix", "attr_sparse_matrix"]
-
-
-def _node_value(G, node_attr):
-    """Returns a function that returns a value from G.nodes[u].
-
-    We return a function expecting a node as its sole argument. Then, in the
-    simplest scenario, the returned function will return G.nodes[u][node_attr].
-    However, we also handle the case when `node_attr` is None (returns the node)
-    or when `node_attr` is a function itself.
-
-    Parameters
-    ----------
-    G : graph
-        A NetworkX graph
-
-    node_attr : {None, str, callable}
-        Specification of how the value of the node attribute should be obtained
-        from the node attribute dictionary.
-
-    Returns
-    -------
-    value : function
-        A function expecting a node as its sole argument. The function will
-        returns a value from G.nodes[u] that depends on `edge_attr`.
-
-    """
-    if node_attr is None:
-
-        def value(u):
-            return u
-
-    elif not callable(node_attr):
-        # assume it is a key for the node attribute dictionary
-        def value(u):
-            return G.nodes[u][node_attr]
-
-    else:
-        # Advanced:  Allow users to specify something else.
-        #
-        # For example,
-        #     node_attr = lambda u: G.nodes[u].get('size', .5) * 3
-        #
-        value = node_attr
-
-    return value
-
-
-def _edge_value(G, edge_attr):
-    """Returns a function that returns a value from G[u][v].
-
-    Suppose there exists an edge between u and v.  Then we return a function
-    expecting u and v as arguments.  For Graph and DiGraph, G[u][v] is
-    the edge attribute dictionary, and the function (essentially) returns
-    G[u][v][edge_attr].  However, we also handle cases when `edge_attr` is None
-    and when it is a function itself. For MultiGraph and MultiDiGraph, G[u][v]
-    is a dictionary of all edges between u and v.  In this case, the returned
-    function sums the value of `edge_attr` for every edge between u and v.
-
-    Parameters
-    ----------
-    G : graph
-       A NetworkX graph
-
-    edge_attr : {None, str, callable}
-        Specification of how the value of the edge attribute should be obtained
-        from the edge attribute dictionary, G[u][v].  For multigraphs, G[u][v]
-        is a dictionary of all the edges between u and v.  This allows for
-        special treatment of multiedges.
-
-    Returns
-    -------
-    value : function
-        A function expecting two nodes as parameters. The nodes should
-        represent the from- and to- node of an edge. The function will
-        return a value from G[u][v] that depends on `edge_attr`.
-
-    """
-
-    if edge_attr is None:
-        # topological count of edges
-
-        if G.is_multigraph():
-
-            def value(u, v):
-                return len(G[u][v])
-
-        else:
-
-            def value(u, v):
-                return 1
-
-    elif not callable(edge_attr):
-        # assume it is a key for the edge attribute dictionary
-
-        if edge_attr == "weight":
-            # provide a default value
-            if G.is_multigraph():
-
-                def value(u, v):
-                    return sum(d.get(edge_attr, 1) for d in G[u][v].values())
-
-            else:
-
-                def value(u, v):
-                    return G[u][v].get(edge_attr, 1)
-
-        else:
-            # otherwise, the edge attribute MUST exist for each edge
-            if G.is_multigraph():
-
-                def value(u, v):
-                    return sum(d[edge_attr] for d in G[u][v].values())
-
-            else:
-
-                def value(u, v):
-                    return G[u][v][edge_attr]
-
-    else:
-        # Advanced:  Allow users to specify something else.
-        #
-        # Alternative default value:
-        #     edge_attr = lambda u,v: G[u][v].get('thickness', .5)
-        #
-        # Function on an attribute:
-        #     edge_attr = lambda u,v: abs(G[u][v]['weight'])
-        #
-        # Handle Multi(Di)Graphs differently:
-        #     edge_attr = lambda u,v: numpy.prod([d['size'] for d in G[u][v].values()])
-        #
-        # Ignore multiple edges
-        #     edge_attr = lambda u,v: 1 if len(G[u][v]) else 0
-        #
-        value = edge_attr
-
-    return value
-
-
-@nx._dispatchable(edge_attrs={"edge_attr": None}, node_attrs="node_attr")
-def attr_matrix(
-    G,
-    edge_attr=None,
-    node_attr=None,
-    normalized=False,
-    rc_order=None,
-    dtype=None,
-    order=None,
-):
-    """Returns the attribute matrix using attributes from `G` as a numpy array.
-
-    If only `G` is passed in, then the adjacency matrix is constructed.
-
-    Let A be a discrete set of values for the node attribute `node_attr`. Then
-    the elements of A represent the rows and columns of the constructed matrix.
-    Now, iterate through every edge e=(u,v) in `G` and consider the value
-    of the edge attribute `edge_attr`.  If ua and va are the values of the
-    node attribute `node_attr` for u and v, respectively, then the value of
-    the edge attribute is added to the matrix element at (ua, va).
-
-    Parameters
-    ----------
-    G : graph
-        The NetworkX graph used to construct the attribute matrix.
-
-    edge_attr : str, optional (default: number of edges for each matrix element)
-        Each element of the matrix represents a running total of the
-        specified edge attribute for edges whose node attributes correspond
-        to the rows/cols of the matrix. The attribute must be present for
-        all edges in the graph. If no attribute is specified, then we
-        just count the number of edges whose node attributes correspond
-        to the matrix element.
-
-    node_attr : str, optional (default: use nodes of the graph)
-        Each row and column in the matrix represents a particular value
-        of the node attribute.  The attribute must be present for all nodes
-        in the graph. Note, the values of this attribute should be reliably
-        hashable. So, float values are not recommended. If no attribute is
-        specified, then the rows and columns will be the nodes of the graph.
-
-    normalized : bool, optional (default: False)
-        If True, then each row is normalized by the summation of its values.
-
-    rc_order : list, optional (default: order of nodes in G)
-        A list of the node attribute values. This list specifies the ordering
-        of rows and columns of the array. If no ordering is provided, then
-        the ordering will be the same as the node order in `G`.
-        When `rc_order` is `None`, the function returns a 2-tuple ``(matrix, ordering)``
-
-    Other Parameters
-    ----------------
-    dtype : NumPy data-type, optional
-        A valid NumPy dtype used to initialize the array. Keep in mind certain
-        dtypes can yield unexpected results if the array is to be normalized.
-        The parameter is passed to numpy.zeros(). If unspecified, the NumPy
-        default is used.
-
-    order : {'C', 'F'}, optional
-        Whether to store multidimensional data in C- or Fortran-contiguous
-        (row- or column-wise) order in memory. This parameter is passed to
-        numpy.zeros(). If unspecified, the NumPy default is used.
-
-    Returns
-    -------
-    M : 2D NumPy ndarray
-        The attribute matrix.
-
-    ordering : list
-        If `rc_order` was specified, then only the attribute matrix is returned.
-        However, if `rc_order` was None, then the ordering used to construct
-        the matrix is returned as well.
-
-    Examples
-    --------
-    Construct an adjacency matrix:
-
-    >>> G = nx.Graph()
-    >>> G.add_edge(0, 1, thickness=1, weight=3)
-    >>> G.add_edge(0, 2, thickness=2)
-    >>> G.add_edge(1, 2, thickness=3)
-    >>> nx.attr_matrix(G, rc_order=[0, 1, 2])
-    array([[0., 1., 1.],
-           [1., 0., 1.],
-           [1., 1., 0.]])
-
-    Alternatively, we can obtain the matrix describing edge thickness.
-
-    >>> nx.attr_matrix(G, edge_attr="thickness", rc_order=[0, 1, 2])
-    array([[0., 1., 2.],
-           [1., 0., 3.],
-           [2., 3., 0.]])
-
-    We can also color the nodes and ask for the probability distribution over
-    all edges (u,v) describing:
-
-        Pr(v has color Y | u has color X)
-
-    >>> G.nodes[0]["color"] = "red"
-    >>> G.nodes[1]["color"] = "red"
-    >>> G.nodes[2]["color"] = "blue"
-    >>> rc = ["red", "blue"]
-    >>> nx.attr_matrix(G, node_attr="color", normalized=True, rc_order=rc)
-    array([[0.33333333, 0.66666667],
-           [1.        , 0.        ]])
-
-    For example, the above tells us that for all edges (u,v):
-
-        Pr( v is red  | u is red)  = 1/3
-        Pr( v is blue | u is red)  = 2/3
-
-        Pr( v is red  | u is blue) = 1
-        Pr( v is blue | u is blue) = 0
-
-    Finally, we can obtain the total weights listed by the node colors.
-
-    >>> nx.attr_matrix(G, edge_attr="weight", node_attr="color", rc_order=rc)
-    array([[3., 2.],
-           [2., 0.]])
-
-    Thus, the total weight over all edges (u,v) with u and v having colors:
-
-        (red, red)   is 3   # the sole contribution is from edge (0,1)
-        (red, blue)  is 2   # contributions from edges (0,2) and (1,2)
-        (blue, red)  is 2   # same as (red, blue) since graph is undirected
-        (blue, blue) is 0   # there are no edges with blue endpoints
-
-    """
-    import numpy as np
-
-    edge_value = _edge_value(G, edge_attr)
-    node_value = _node_value(G, node_attr)
-
-    if rc_order is None:
-        ordering = list({node_value(n) for n in G})
-    else:
-        ordering = rc_order
-
-    N = len(ordering)
-    undirected = not G.is_directed()
-    index = dict(zip(ordering, range(N)))
-    M = np.zeros((N, N), dtype=dtype, order=order)
-
-    seen = set()
-    for u, nbrdict in G.adjacency():
-        for v in nbrdict:
-            # Obtain the node attribute values.
-            i, j = index[node_value(u)], index[node_value(v)]
-            if v not in seen:
-                M[i, j] += edge_value(u, v)
-                if undirected:
-                    M[j, i] = M[i, j]
-
-        if undirected:
-            seen.add(u)
-
-    if normalized:
-        M /= M.sum(axis=1).reshape((N, 1))
-
-    if rc_order is None:
-        return M, ordering
-    else:
-        return M
-
-
-@nx._dispatchable(edge_attrs={"edge_attr": None}, node_attrs="node_attr")
-def attr_sparse_matrix(
-    G, edge_attr=None, node_attr=None, normalized=False, rc_order=None, dtype=None
-):
-    """Returns a SciPy sparse array using attributes from G.
-
-    If only `G` is passed in, then the adjacency matrix is constructed.
-
-    Let A be a discrete set of values for the node attribute `node_attr`. Then
-    the elements of A represent the rows and columns of the constructed matrix.
-    Now, iterate through every edge e=(u,v) in `G` and consider the value
-    of the edge attribute `edge_attr`.  If ua and va are the values of the
-    node attribute `node_attr` for u and v, respectively, then the value of
-    the edge attribute is added to the matrix element at (ua, va).
-
-    Parameters
-    ----------
-    G : graph
-        The NetworkX graph used to construct the NumPy matrix.
-
-    edge_attr : str, optional (default: number of edges for each matrix element)
-        Each element of the matrix represents a running total of the
-        specified edge attribute for edges whose node attributes correspond
-        to the rows/cols of the matrix. The attribute must be present for
-        all edges in the graph. If no attribute is specified, then we
-        just count the number of edges whose node attributes correspond
-        to the matrix element.
-
-    node_attr : str, optional (default: use nodes of the graph)
-        Each row and column in the matrix represents a particular value
-        of the node attribute.  The attribute must be present for all nodes
-        in the graph. Note, the values of this attribute should be reliably
-        hashable. So, float values are not recommended. If no attribute is
-        specified, then the rows and columns will be the nodes of the graph.
-
-    normalized : bool, optional (default: False)
-        If True, then each row is normalized by the summation of its values.
-
-    rc_order : list, optional (default: order of nodes in G)
-        A list of the node attribute values. This list specifies the ordering
-        of rows and columns of the array and the return value. If no ordering
-        is provided, then the ordering will be that of nodes in `G`.
-
-    Other Parameters
-    ----------------
-    dtype : NumPy data-type, optional
-        A valid NumPy dtype used to initialize the array. Keep in mind certain
-        dtypes can yield unexpected results if the array is to be normalized.
-        The parameter is passed to numpy.zeros(). If unspecified, the NumPy
-        default is used.
-
-    Returns
-    -------
-    M : SciPy sparse array
-        The attribute matrix.
-
-    ordering : list
-        If `rc_order` was specified, then only the matrix is returned.
-        However, if `rc_order` was None, then the ordering used to construct
-        the matrix is returned as well.
-
-    Examples
-    --------
-    Construct an adjacency matrix:
-
-    >>> G = nx.Graph()
-    >>> G.add_edge(0, 1, thickness=1, weight=3)
-    >>> G.add_edge(0, 2, thickness=2)
-    >>> G.add_edge(1, 2, thickness=3)
-    >>> M = nx.attr_sparse_matrix(G, rc_order=[0, 1, 2])
-    >>> M.toarray()
-    array([[0., 1., 1.],
-           [1., 0., 1.],
-           [1., 1., 0.]])
-
-    Alternatively, we can obtain the matrix describing edge thickness.
-
-    >>> M = nx.attr_sparse_matrix(G, edge_attr="thickness", rc_order=[0, 1, 2])
-    >>> M.toarray()
-    array([[0., 1., 2.],
-           [1., 0., 3.],
-           [2., 3., 0.]])
-
-    We can also color the nodes and ask for the probability distribution over
-    all edges (u,v) describing:
-
-        Pr(v has color Y | u has color X)
-
-    >>> G.nodes[0]["color"] = "red"
-    >>> G.nodes[1]["color"] = "red"
-    >>> G.nodes[2]["color"] = "blue"
-    >>> rc = ["red", "blue"]
-    >>> M = nx.attr_sparse_matrix(G, node_attr="color", normalized=True, rc_order=rc)
-    >>> M.toarray()
-    array([[0.33333333, 0.66666667],
-           [1.        , 0.        ]])
-
-    For example, the above tells us that for all edges (u,v):
-
-        Pr( v is red  | u is red)  = 1/3
-        Pr( v is blue | u is red)  = 2/3
-
-        Pr( v is red  | u is blue) = 1
-        Pr( v is blue | u is blue) = 0
-
-    Finally, we can obtain the total weights listed by the node colors.
-
-    >>> M = nx.attr_sparse_matrix(G, edge_attr="weight", node_attr="color", rc_order=rc)
-    >>> M.toarray()
-    array([[3., 2.],
-           [2., 0.]])
-
-    Thus, the total weight over all edges (u,v) with u and v having colors:
-
-        (red, red)   is 3   # the sole contribution is from edge (0,1)
-        (red, blue)  is 2   # contributions from edges (0,2) and (1,2)
-        (blue, red)  is 2   # same as (red, blue) since graph is undirected
-        (blue, blue) is 0   # there are no edges with blue endpoints
-
-    """
-    import numpy as np
-    import scipy as sp
-
-    edge_value = _edge_value(G, edge_attr)
-    node_value = _node_value(G, node_attr)
-
-    if rc_order is None:
-        ordering = list({node_value(n) for n in G})
-    else:
-        ordering = rc_order
-
-    N = len(ordering)
-    undirected = not G.is_directed()
-    index = dict(zip(ordering, range(N)))
-    M = sp.sparse.lil_array((N, N), dtype=dtype)
-
-    seen = set()
-    for u, nbrdict in G.adjacency():
-        for v in nbrdict:
-            # Obtain the node attribute values.
-            i, j = index[node_value(u)], index[node_value(v)]
-            if v not in seen:
-                M[i, j] += edge_value(u, v)
-                if undirected:
-                    M[j, i] = M[i, j]
-
-        if undirected:
-            seen.add(u)
-
-    if normalized:
-        M *= 1 / M.sum(axis=1)[:, np.newaxis]  # in-place mult preserves sparse
-
-    if rc_order is None:
-        return M, ordering
-    else:
-        return M

package/runtime/python/okstra_vendor/networkx/linalg/bethehessianmatrix.py

@@ -1,77 +0,0 @@
-"""Bethe Hessian or deformed Laplacian matrix of graphs."""
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["bethe_hessian_matrix"]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def bethe_hessian_matrix(G, r=None, nodelist=None):
-    r"""Returns the Bethe Hessian matrix of G.
-
-    The Bethe Hessian is a family of matrices parametrized by r, defined as
-    H(r) = (r^2 - 1) I - r A + D where A is the adjacency matrix, D is the
-    diagonal matrix of node degrees, and I is the identify matrix. It is equal
-    to the graph laplacian when the regularizer r = 1.
-
-    The default choice of regularizer should be the ratio [2]_
-
-    .. math::
-      r_m = \left(\sum k_i \right)^{-1}\left(\sum k_i^2 \right) - 1
-
-    Parameters
-    ----------
-    G : Graph
-       A NetworkX graph
-    r : float
-       Regularizer parameter
-    nodelist : list, optional
-       The rows and columns are ordered according to the nodes in nodelist.
-       If nodelist is None, then the ordering is produced by ``G.nodes()``.
-
-    Returns
-    -------
-    H : scipy.sparse.csr_array
-      The Bethe Hessian matrix of `G`, with parameter `r`.
-
-    Examples
-    --------
-    >>> k = [3, 2, 2, 1, 0]
-    >>> G = nx.havel_hakimi_graph(k)
-    >>> H = nx.bethe_hessian_matrix(G)
-    >>> H.toarray()
-    array([[ 3.5625, -1.25  , -1.25  , -1.25  ,  0.    ],
-           [-1.25  ,  2.5625, -1.25  ,  0.    ,  0.    ],
-           [-1.25  , -1.25  ,  2.5625,  0.    ,  0.    ],
-           [-1.25  ,  0.    ,  0.    ,  1.5625,  0.    ],
-           [ 0.    ,  0.    ,  0.    ,  0.    ,  0.5625]])
-
-    See Also
-    --------
-    bethe_hessian_spectrum
-    adjacency_matrix
-    laplacian_matrix
-
-    References
-    ----------
-    .. [1] A. Saade, F. Krzakala and L. Zdeborová
-       "Spectral Clustering of Graphs with the Bethe Hessian",
-       Advances in Neural Information Processing Systems, 2014.
-    .. [2] C. M. Le, E. Levina
-       "Estimating the number of communities in networks by spectral methods"
-       arXiv:1507.00827, 2015.
-    """
-    import scipy as sp
-
-    if nodelist is None:
-        nodelist = list(G)
-    if r is None:
-        r = sum(d**2 for v, d in nx.degree(G)) / sum(d for v, d in nx.degree(G)) - 1
-    A = nx.to_scipy_sparse_array(G, nodelist=nodelist, format="csr")
-    n, m = A.shape
-    D = sp.sparse.dia_array((A.sum(axis=1), 0), shape=(m, n)).tocsr()
-    I = sp.sparse.eye_array(m, n, format="csr")
-    return (r**2 - 1) * I - r * A + D

package/runtime/python/okstra_vendor/networkx/linalg/graphmatrix.py

@@ -1,168 +0,0 @@
-"""
-Adjacency matrix and incidence matrix of graphs.
-"""
-
-import networkx as nx
-
-__all__ = ["incidence_matrix", "adjacency_matrix"]
-
-
-@nx._dispatchable(edge_attrs="weight")
-def incidence_matrix(
-    G, nodelist=None, edgelist=None, oriented=False, weight=None, *, dtype=None
-):
-    """Returns incidence matrix of G.
-
-    The incidence matrix assigns each row to a node and each column to an edge.
-    For a standard incidence matrix a 1 appears wherever a row's node is
-    incident on the column's edge.  For an oriented incidence matrix each
-    edge is assigned an orientation (arbitrarily for undirected and aligning to
-    direction for directed).  A -1 appears for the source (tail) of an edge and
-    1 for the destination (head) of the edge.  The elements are zero otherwise.
-
-    Parameters
-    ----------
-    G : graph
-       A NetworkX graph
-
-    nodelist : list, optional   (default= all nodes in G)
-       The rows are ordered according to the nodes in nodelist.
-       If nodelist is None, then the ordering is produced by G.nodes().
-
-    edgelist : list, optional (default= all edges in G)
-       The columns are ordered according to the edges in edgelist.
-       If edgelist is None, then the ordering is produced by G.edges().
-
-    oriented: bool, optional (default=False)
-       If True, matrix elements are +1 or -1 for the head or tail node
-       respectively of each edge.  If False, +1 occurs at both nodes.
-
-    weight : string or None, optional (default=None)
-       The edge data key used to provide each value in the matrix.
-       If None, then each edge has weight 1.  Edge weights, if used,
-       should be positive so that the orientation can provide the sign.
-
-    dtype : a NumPy dtype or None (default=None)
-        The dtype of the output sparse array. This type should be a compatible
-        type of the weight argument, eg. if weight would return a float this
-        argument should also be a float.
-        If None, then the default for SciPy is used.
-
-    Returns
-    -------
-    A : SciPy sparse array
-      The incidence matrix of G.
-
-    Notes
-    -----
-    For MultiGraph/MultiDiGraph, the edges in edgelist should be
-    (u,v,key) 3-tuples.
-
-    "Networks are the best discrete model for so many problems in
-    applied mathematics" [1]_.
-
-    References
-    ----------
-    .. [1] Gil Strang, Network applications: A = incidence matrix,
-       http://videolectures.net/mit18085f07_strang_lec03/
-    """
-    import scipy as sp
-
-    if nodelist is None:
-        nodelist = list(G)
-    if edgelist is None:
-        if G.is_multigraph():
-            edgelist = list(G.edges(keys=True))
-        else:
-            edgelist = list(G.edges())
-    A = sp.sparse.lil_array((len(nodelist), len(edgelist)), dtype=dtype)
-    node_index = {node: i for i, node in enumerate(nodelist)}
-    for ei, e in enumerate(edgelist):
-        (u, v) = e[:2]
-        if u == v:
-            continue  # self loops give zero column
-        try:
-            ui = node_index[u]
-            vi = node_index[v]
-        except KeyError as err:
-            raise nx.NetworkXError(
-                f"node {u} or {v} in edgelist but not in nodelist"
-            ) from err
-        if weight is None:
-            wt = 1
-        else:
-            if G.is_multigraph():
-                ekey = e[2]
-                wt = G[u][v][ekey].get(weight, 1)
-            else:
-                wt = G[u][v].get(weight, 1)
-        if oriented:
-            A[ui, ei] = -wt
-            A[vi, ei] = wt
-        else:
-            A[ui, ei] = wt
-            A[vi, ei] = wt
-    return A.asformat("csc")
-
-
-@nx._dispatchable(edge_attrs="weight")
-def adjacency_matrix(G, nodelist=None, dtype=None, weight="weight"):
-    """Returns adjacency matrix of `G`.
-
-    Parameters
-    ----------
-    G : graph
-       A NetworkX graph
-
-    nodelist : list, optional
-       The rows and columns are ordered according to the nodes in `nodelist`.
-       If ``nodelist=None`` (the default), then the ordering is produced by
-       ``G.nodes()``.
-
-    dtype : NumPy data-type, optional
-        The desired data-type for the array.
-        If `None`, then the NumPy default is used.
-
-    weight : string or None, optional (default='weight')
-       The edge data key used to provide each value in the matrix.
-       If None, then each edge has weight 1.
-
-    Returns
-    -------
-    A : SciPy sparse array
-      Adjacency matrix representation of G.
-
-    Notes
-    -----
-    For directed graphs, entry ``i, j`` corresponds to an edge from ``i`` to ``j``.
-
-    If you want a pure Python adjacency matrix representation try
-    :func:`~networkx.convert.to_dict_of_dicts` which will return a
-    dictionary-of-dictionaries format that can be addressed as a
-    sparse matrix.
-
-    For multigraphs with parallel edges the weights are summed.
-    See :func:`networkx.convert_matrix.to_numpy_array` for other options.
-
-    The convention used for self-loop edges in graphs is to assign the
-    diagonal matrix entry value to the edge weight attribute
-    (or the number 1 if the edge has no weight attribute).  If the
-    alternate convention of doubling the edge weight is desired the
-    resulting SciPy sparse array can be modified as follows::
-
-        >>> G = nx.Graph([(1, 1)])
-        >>> A = nx.adjacency_matrix(G)
-        >>> A.toarray()
-        array([[1]])
-        >>> A.setdiag(A.diagonal() * 2)
-        >>> A.toarray()
-        array([[2]])
-
-    See Also
-    --------
-    to_numpy_array
-    to_scipy_sparse_array
-    to_dict_of_dicts
-    adjacency_spectrum
-    """
-    return nx.to_scipy_sparse_array(G, nodelist=nodelist, dtype=dtype, weight=weight)