def test_dok_indexing():
s = sparse.DOK((3, 3))
s[1, 2] = 0.5
x = s.todense()
assert_eq(x[1::-1], s[1::-1])
def test_to_scipy_sparse():
s = sparse.random((3, 5), density=0.5)
a = s.to_scipy_sparse()
b = scipy.sparse.coo_matrix(s.todense())
assert_eq(a, b)
def test_advanced_indexing(index):
s = sparse.random((2, 3, 4), density=0.5)
x = s.todense()
assert_eq(x[index], s[index])
def test_transpose(axis):
x = sparse.random((2, 3, 4), density=0.25)
y = x.todense()
xx = x.transpose(axis)
yy = y.transpose(axis)
assert_eq(xx, yy)
def test_moveaxis(source, destination):
x = sparse.random((2, 3, 4, 5), density=0.25)
y = x.todense()
xx = sparse.moveaxis(x, source, destination)
yy = np.moveaxis(y, source, destination)
assert_eq(xx, yy)
def test_eye(N, M):
m = M or N
for k in [0, N - 2, N + 2, m - 2, m + 2]:
assert_eq(sparse.eye(N, M=M, k=k), np.eye(N, M=M, k=k))
assert_eq(sparse.eye(N, M=M, k=k, dtype="i4"),
np.eye(N, M=M, k=k, dtype="i4"))
def test_np_matrix():
x = np.random.rand(10, 1).view(type=np.matrix)
s = sparse.COO.from_numpy(x)
assert_eq(x, s)
def test_stack(y):
"""stack(), by design, does not allow for mixed type inputs"""
x = y.todense()
xx = np.stack([x, x])
yy = np.stack([y, y])
assert_eq(xx, yy)
def test_ternary(func, arg_order, y):
x = y.todense()
xx = func(x, x, x)
args = [(x, y)[i] for i in arg_order]
yy = func(*args)
assert_eq(xx, yy)
def test_convert_to_numpy(s):
x = s.todense()
assert_eq(x, s)
def test_unary(func, y):
x = y.todense()
xx = func(x)
yy = func(y)
assert_eq(xx, yy)
def test_convert_from_numpy():
x = np.random.rand(2, 3, 4)
s = DOK(x)
assert_eq(x, s)
def test_convert_from_coo(s1):
s2 = DOK(s1)
assert_eq(s1, s2)
def test_convert_to_coo(s1):
s2 = sparse.COO(s1)
assert_eq(s1, s2)
def test_empty(self):
x = np.array([])
assert_eq(np.roll(x, 1), sparse.roll(sparse.as_coo(x), 1))
def test_tensordot(a_shape, b_shape, axes, a_format, b_format):
sa = sparse.random(a_shape, density=0.5, format=a_format)
sb = sparse.random(b_shape, density=0.5, format=b_format)
a = sa.todense()
b = sb.todense()
a_b = np.tensordot(a, b, axes)
# tests for return_type=None
sa_sb = sparse.tensordot(sa, sb, axes)
sa_b = sparse.tensordot(sa, b, axes)
a_sb = sparse.tensordot(a, sb, axes)
assert_eq(a_b, sa_sb)
assert_eq(a_b, sa_b)
assert_eq(a_b, a_sb)
if all(isinstance(arr, COO) for arr in [sa, sb]):
assert isinstance(sa_sb, COO)
else:
assert isinstance(sa_sb, GCXS)
assert isinstance(sa_b, np.ndarray)
assert isinstance(a_sb, np.ndarray)
# tests for return_type=COO
sa_b = sparse.tensordot(sa, b, axes, return_type=COO)
a_sb = sparse.tensordot(a, sb, axes, return_type=COO)
assert_eq(a_b, sa_b)
assert_eq(a_b, a_sb)
assert isinstance(sa_b, COO)
assert isinstance(a_sb, COO)
# tests form return_type=GCXS
sa_b = sparse.tensordot(sa, b, axes, return_type=GCXS)
a_sb = sparse.tensordot(a, sb, axes, return_type=GCXS)
assert_eq(a_b, sa_b)
assert_eq(a_b, a_sb)
assert isinstance(sa_b, GCXS)
assert isinstance(a_sb, GCXS)
# tests for return_type=np.ndarray
sa_sb = sparse.tensordot(sa, sb, axes, return_type=np.ndarray)
assert_eq(a_b, sa_sb)
assert isinstance(sa_sb, np.ndarray)
def test_clip():
x = np.array([[0, 0, 1, 0, 2], [5, 0, 0, 3, 0]])
s = sparse.COO.from_numpy(x)
assert_eq(s.clip(min=1), x.clip(min=1))
assert_eq(s.clip(max=3), x.clip(max=3))
assert_eq(s.clip(min=1, max=3), x.clip(min=1, max=3))
assert_eq(s.clip(min=1, max=3.0), x.clip(min=1, max=3.0))
assert_eq(np.clip(s, 1, 3), np.clip(x, 1, 3))
with pytest.raises(ValueError):
s.clip()
out = sparse.COO.from_numpy(np.zeros_like(x))
out2 = s.clip(min=1, max=3, out=out)
assert out is out2
assert_eq(out, x.clip(min=1, max=3))
def test_argwhere():
s = sparse.random((2, 3, 4), density=0.5)
x = s.todense()
assert_eq(np.argwhere(s), np.argwhere(x), compare_dtype=False)
def test_full():
assert_eq(sparse.full(5, 9), np.full(5, 9))
assert_eq(sparse.full(5, 9, dtype="f8"), np.full(5, 9, dtype="f8"))
assert_eq(sparse.full((5, 4), 9.5), np.full((5, 4), 9.5))
assert_eq(sparse.full((5, 4), 9.5, dtype="i4"),
np.full((5, 4), 9.5, dtype="i4"))
def test_asformat(format):
s = sparse.random((2, 3, 4), density=0.5, format="coo")
s2 = s.asformat(format)
assert_eq(s, s2)
def test_diagonal():
a = sparse.random((4, 4), density=0.5)
assert_eq(sparse.diagonal(a, offset=0), np.diagonal(a.todense(), offset=0))
assert_eq(sparse.diagonal(a, offset=1), np.diagonal(a.todense(), offset=1))
assert_eq(sparse.diagonal(a, offset=2), np.diagonal(a.todense(), offset=2))
a = sparse.random((4, 5, 4, 6), density=0.5)
assert_eq(
sparse.diagonal(a, offset=0, axis1=0, axis2=2),
np.diagonal(a.todense(), offset=0, axis1=0, axis2=2),
)
assert_eq(
sparse.diagonal(a, offset=1, axis1=0, axis2=2),
np.diagonal(a.todense(), offset=1, axis1=0, axis2=2),
)
assert_eq(
sparse.diagonal(a, offset=2, axis1=0, axis2=2),
np.diagonal(a.todense(), offset=2, axis1=0, axis2=2),
)
def test_1d(self, shift):
xs = sparse.random((100, ), density=0.5)
x = xs.todense()
assert_eq(np.roll(x, shift), sparse.roll(xs, shift))
assert_eq(np.roll(x, shift), sparse.roll(x, shift))
def test_swapaxes(axis1, axis2):
x = sparse.random((2, 3, 4), density=0.25)
y = x.todense()
xx = x.swapaxes(axis1, axis2)
yy = y.swapaxes(axis1, axis2)
assert_eq(xx, yy)
def test_2d(self, shift, ax):
xs = sparse.random((10, 10), density=0.5)
x = xs.todense()
assert_eq(np.roll(x, shift, axis=ax), sparse.roll(xs, shift, axis=ax))
assert_eq(np.roll(x, shift, axis=ax), sparse.roll(x, shift, axis=ax))
def test_reshape(a, b):
s = sparse.random(a, density=0.5)
x = s.todense()
assert_eq(x.reshape(b), s.reshape(b))
def test_multiaxis(self, shift, ax):
xs = sparse.random((9, 9, 9), density=0.5)
x = xs.todense()
assert_eq(np.roll(x, shift, axis=ax), sparse.roll(xs, shift, axis=ax))
assert_eq(np.roll(x, shift, axis=ax), sparse.roll(x, shift, axis=ax))
def test_reductions_fv(reduction, random_sparse_small, axis, keepdims, kwargs):
x = random_sparse_small + np.random.randint(-1, 1, dtype="i4")
y = x.todense()
xx = getattr(x, reduction)(axis=axis, keepdims=keepdims, **kwargs)
yy = getattr(y, reduction)(axis=axis, keepdims=keepdims, **kwargs)
assert_eq(xx, yy)
def test_original_is_copied(self, shift, ax):
xs = sparse.random((10, 10), density=0.5)
xc = COO(np.copy(xs.coords), np.copy(xs.data), shape=xs.shape)
sparse.roll(xs, shift, axis=ax)
assert_eq(xs, xc)
def test_scipy_sparse_interface():
n = 100
m = 10
row = np.random.randint(0, n, size=n, dtype=np.uint16)
col = np.random.randint(0, m, size=n, dtype=np.uint16)
data = np.ones(n, dtype=np.uint8)
inp = (data, (row, col))
x = scipy.sparse.coo_matrix(inp)
xx = sparse.COO(inp)
assert_eq(x, xx, check_nnz=False)
assert_eq(x.T, xx.T, check_nnz=False)
assert_eq(xx.to_scipy_sparse(), x, check_nnz=False)
assert_eq(COO.from_scipy_sparse(xx.to_scipy_sparse()), xx, check_nnz=False)
assert_eq(x, xx, check_nnz=False)
assert_eq(x.T.dot(x), xx.T.dot(xx), check_nnz=False)
assert isinstance(x + xx, COO)
assert isinstance(xx + x, COO)
def test_dok_concat_stack(func, s1, s2):
x1 = s1.todense()
x2 = s2.todense()
assert_eq(func([s1, s2]), func([x1, x2]))
