def test_one_arg_where(s):
x = s.todense()
expected = np.where(x)
actual = sparse.where(s)
assert len(expected) == len(actual)
for e, a in zip(expected, actual):
assert_eq(e, a, compare_dtype=False)
def test_one_arg_where():
s = sparse.random((2, 3, 4), density=0.5)
x = s.todense()
expected = np.where(x)
actual = sparse.where(s)
assert len(expected) == len(actual)
for e, a in zip(expected, actual):
assert_eq(e, a, compare_dtype=False)
def test_three_arg_where(arg):
cs, xs, ys = arg
c = cs.todense()
x = xs.todense()
y = ys.todense()
expected = np.where(c, x, y)
actual = sparse.where(cs, xs, ys)
assert isinstance(actual, COO)
assert_eq(expected, actual)
def test_three_arg_where(shapes):
cs = sparse.random(shapes[0], density=0.5).astype(np.bool)
xs = sparse.random(shapes[1], density=0.5)
ys = sparse.random(shapes[2], density=0.5)
c = cs.todense()
x = xs.todense()
y = ys.todense()
expected = np.where(c, x, y)
actual = sparse.where(cs, xs, ys)
assert isinstance(actual, COO)
assert_eq(expected, actual)
def directed_laplacian_matrix(G, nodelist=None, weight='weight',alpha=0.95):
import scipy as sp
M = nx.to_scipy_sparse_matrix(G, nodelist=nodelist, weight=weight,
dtype=float)
n, m = M.shape
if not (0 < alpha < 1):
raise nx.NetworkXError('alpha must be between 0 and 1')
# this is using a dense representation
M = M.todense()
# add constant to dangling nodes' row
dangling = sp.where(M.sum(axis=1) == 0)
for d in dangling[0]:
M[d] = 1.0 / n
# normalize
M = M / M.sum(axis=1)
P = alpha * M + (1 - alpha) / n
evals, evecs = linalg.eigs(P.T, k=1,tol=1E-2)
v = evecs.flatten().real
p = v / v.sum()
sqrtp = sp.sqrt(p)
I = sp.identity(len(G))
Q = spdiags(sqrtp, [0], n, n) * (I-P) * spdiags(1.0 / sqrtp, [0], n, n)
return Q
def test_two_arg_where():
cs = sparse.random((2, 3, 4), density=0.5).astype(np.bool)
xs = sparse.random((2, 3, 4), density=0.5)
with pytest.raises(ValueError):
sparse.where(cs, xs)
def test_one_arg_where_dense():
x = np.random.rand(2, 3, 4)
with pytest.raises(ValueError):
sparse.where(x)
def test_two_arg_where(cs, xs):
cs = cs.astype(np.bool_)
with pytest.raises(ValueError):
sparse.where(cs, xs)
def _transition_matrix(G,
nodelist=None,
weight='weight',
walk_type=None,
alpha=0.95):
"""Returns the transition matrix of G.
This is a row stochastic giving the transition probabilities while
performing a random walk on the graph. Depending on the value of walk_type,
P can be the transition matrix induced by a random walk, a lazy random walk,
or a random walk with teleportation (PageRank).
Parameters
----------
G : DiGraph
A NetworkX graph
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().
weight : string or None, optional (default='weight')
The edge data key used to compute each value in the matrix.
If None, then each edge has weight 1.
walk_type : string or None, optional (default=None)
If None, `P` is selected depending on the properties of the
graph. Otherwise is one of 'random', 'lazy', or 'pagerank'
alpha : real
(1 - alpha) is the teleportation probability used with pagerank
Returns
-------
P : NumPy array
transition matrix of G.
Raises
------
NetworkXError
If walk_type not specified or alpha not in valid range
"""
import scipy as sp
from scipy.sparse import identity, spdiags
if walk_type is None:
if nx.is_strongly_connected(G):
if nx.is_aperiodic(G):
walk_type = "random"
else:
walk_type = "lazy"
else:
walk_type = "pagerank"
M = nx.to_scipy_sparse_matrix(G,
nodelist=nodelist,
weight=weight,
dtype=float)
n, m = M.shape
if walk_type in ["random", "lazy"]:
DI = spdiags(1.0 / sp.array(M.sum(axis=1).flat), [0], n, n)
if walk_type == "random":
P = DI * M
else:
I = identity(n)
P = (I + DI * M) / 2.0
elif walk_type == "pagerank":
if not (0 < alpha < 1):
raise nx.NetworkXError('alpha must be between 0 and 1')
# this is using a dense representation
M = M.todense()
# add constant to dangling nodes' row
dangling = sp.where(M.sum(axis=1) == 0)
for d in dangling[0]:
M[d] = 1.0 / n
# normalize
M = M / M.sum(axis=1)
P = alpha * M + (1 - alpha) / n
else:
raise nx.NetworkXError("walk_type must be random, lazy, or pagerank")
return P
