scipy 1.16.2__cp314-cp314-win_arm64.whl

scipy/sparse/tests/test_coo.py

@@ -0,0 +1,1119 @@
+import math
+import numpy as np
+from numpy.testing import assert_equal, assert_allclose, suppress_warnings
+import pytest
+from scipy.linalg import block_diag
+from scipy.sparse import coo_array, random_array, SparseEfficiencyWarning
+from .._coo import _block_diag, _extract_block_diag
+
+
+def test_shape_constructor():
+    empty1d = coo_array((3,))
+    assert empty1d.shape == (3,)
+    assert_equal(empty1d.toarray(), np.zeros((3,)))
+
+    empty2d = coo_array((3, 2))
+    assert empty2d.shape == (3, 2)
+    assert_equal(empty2d.toarray(), np.zeros((3, 2)))
+
+    empty_nd = coo_array((2,3,4,6,7))
+    assert empty_nd.shape == (2,3,4,6,7)
+    assert_equal(empty_nd.toarray(), np.zeros((2,3,4,6,7)))
+
+
+def test_dense_constructor():
+    # 1d
+    res1d = coo_array([1, 2, 3])
+    assert res1d.shape == (3,)
+    assert_equal(res1d.toarray(), np.array([1, 2, 3]))
+
+    # 2d
+    res2d = coo_array([[1, 2, 3], [4, 5, 6]])
+    assert res2d.shape == (2, 3)
+    assert_equal(res2d.toarray(), np.array([[1, 2, 3], [4, 5, 6]]))
+
+    # 4d
+    arr4d = np.array([[[[3, 7], [1, 0]], [[6, 5], [9, 2]]],
+                      [[[4, 3], [2, 8]], [[7, 5], [1, 6]]],
+                      [[[0, 9], [4, 3]], [[2, 1], [7, 8]]]])
+    res4d = coo_array(arr4d)
+    assert res4d.shape == (3, 2, 2, 2)
+    assert_equal(res4d.toarray(), arr4d)
+
+    # 9d
+    np.random.seed(12)
+    arr9d = np.random.randn(2,3,4,7,6,5,3,2,4)
+    res9d = coo_array(arr9d)
+    assert res9d.shape == (2,3,4,7,6,5,3,2,4)
+    assert_equal(res9d.toarray(), arr9d)
+
+    # storing nan as element of sparse array
+    nan_3d = coo_array([[[1, np.nan]], [[3, 4]], [[5, 6]]])
+    assert nan_3d.shape == (3, 1, 2)
+    assert_equal(nan_3d.toarray(), np.array([[[1, np.nan]], [[3, 4]], [[5, 6]]]))
+
+
+def test_dense_constructor_with_shape():
+    res1d = coo_array([1, 2, 3], shape=(3,))
+    assert res1d.shape == (3,)
+    assert_equal(res1d.toarray(), np.array([1, 2, 3]))
+
+    res2d = coo_array([[1, 2, 3], [4, 5, 6]], shape=(2, 3))
+    assert res2d.shape == (2, 3)
+    assert_equal(res2d.toarray(), np.array([[1, 2, 3], [4, 5, 6]]))
+
+    res3d = coo_array([[[3]], [[4]]], shape=(2, 1, 1))
+    assert res3d.shape == (2, 1, 1)
+    assert_equal(res3d.toarray(), np.array([[[3]], [[4]]]))
+
+    np.random.seed(12)
+    arr7d = np.random.randn(2,4,1,6,5,3,2)
+    res7d = coo_array((arr7d), shape=(2,4,1,6,5,3,2))
+    assert res7d.shape == (2,4,1,6,5,3,2)
+    assert_equal(res7d.toarray(), arr7d)
+
+
+def test_dense_constructor_with_inconsistent_shape():
+    with pytest.raises(ValueError, match='inconsistent shapes'):
+        coo_array([1, 2, 3], shape=(4,))
+
+    with pytest.raises(ValueError, match='inconsistent shapes'):
+        coo_array([1, 2, 3], shape=(3, 1))
+
+    with pytest.raises(ValueError, match='inconsistent shapes'):
+        coo_array([[1, 2, 3]], shape=(3,))
+
+    with pytest.raises(ValueError, match='inconsistent shapes'):
+        coo_array([[[3]], [[4]]], shape=(1, 1, 1))
+
+    with pytest.raises(ValueError,
+                       match='axis 0 index 2 exceeds matrix dimension 2'):
+        coo_array(([1], ([2],)), shape=(2,))
+
+    with pytest.raises(ValueError,
+                       match='axis 1 index 3 exceeds matrix dimension 3'):
+        coo_array(([1,3], ([0, 1], [0, 3], [1, 1])), shape=(2, 3, 2))
+
+    with pytest.raises(ValueError, match='negative axis 0 index: -1'):
+        coo_array(([1], ([-1],)))
+
+    with pytest.raises(ValueError, match='negative axis 2 index: -1'):
+        coo_array(([1], ([0], [2], [-1])))
+
+
+def test_1d_sparse_constructor():
+    empty1d = coo_array((3,))
+    res = coo_array(empty1d)
+    assert res.shape == (3,)
+    assert_equal(res.toarray(), np.zeros((3,)))
+
+
+def test_1d_tuple_constructor():
+    res = coo_array(([9,8], ([1,2],)))
+    assert res.shape == (3,)
+    assert_equal(res.toarray(), np.array([0, 9, 8]))
+
+
+def test_1d_tuple_constructor_with_shape():
+    res = coo_array(([9,8], ([1,2],)), shape=(4,))
+    assert res.shape == (4,)
+    assert_equal(res.toarray(), np.array([0, 9, 8, 0]))
+
+def test_non_subscriptability():
+    coo_2d = coo_array((2, 2))
+
+    with pytest.raises(TypeError,
+                        match="'coo_array' object does not support item assignment"):
+        coo_2d[0, 0] = 1
+
+    with pytest.raises(TypeError,
+                       match="'coo_array' object is not subscriptable"):
+        coo_2d[0, :]
+
+def test_reshape_overflow():
+    # see gh-22353 : new idx_dtype can need to be int64 instead of int32
+    M, N = (1045507, 523266)
+    coords = (np.array([M - 1], dtype='int32'), np.array([N - 1], dtype='int32'))
+    A = coo_array(([3.3], coords), shape=(M, N))
+
+    # need new idx_dtype to not overflow
+    B = A.reshape((M * N, 1))
+    assert B.coords[0].dtype == np.dtype('int64')
+    assert B.coords[0][0] == (M * N) - 1
+
+    # need idx_dtype to stay int32 if before and after can be int32
+    C = A.reshape(N, M)
+    assert C.coords[0].dtype == np.dtype('int32')
+    assert C.coords[0][0] == N - 1
+
+def test_reshape():
+    arr1d = coo_array([1, 0, 3])
+    assert arr1d.shape == (3,)
+
+    col_vec = arr1d.reshape((3, 1))
+    assert col_vec.shape == (3, 1)
+    assert_equal(col_vec.toarray(), np.array([[1], [0], [3]]))
+
+    row_vec = arr1d.reshape((1, 3))
+    assert row_vec.shape == (1, 3)
+    assert_equal(row_vec.toarray(), np.array([[1, 0, 3]]))
+
+    # attempting invalid reshape
+    with pytest.raises(ValueError, match="cannot reshape array"):
+        arr1d.reshape((3,3))
+
+    # attempting reshape with a size 0 dimension
+    with pytest.raises(ValueError, match="cannot reshape array"):
+        arr1d.reshape((3,0))
+
+    arr2d = coo_array([[1, 2, 0], [0, 0, 3]])
+    assert arr2d.shape == (2, 3)
+
+    flat = arr2d.reshape((6,))
+    assert flat.shape == (6,)
+    assert_equal(flat.toarray(), np.array([1, 2, 0, 0, 0, 3]))
+
+    # 2d to 3d
+    to_3d_arr = arr2d.reshape((2, 3, 1))
+    assert to_3d_arr.shape == (2, 3, 1)
+    assert_equal(to_3d_arr.toarray(), np.array([[[1], [2], [0]], [[0], [0], [3]]]))
+
+    # attempting invalid reshape
+    with pytest.raises(ValueError, match="cannot reshape array"):
+        arr2d.reshape((1,3))
+
+
+def test_nnz():
+    arr1d = coo_array([1, 0, 3])
+    assert arr1d.shape == (3,)
+    assert arr1d.nnz == 2
+
+    arr2d = coo_array([[1, 2, 0], [0, 0, 3]])
+    assert arr2d.shape == (2, 3)
+    assert arr2d.nnz == 3
+
+
+def test_transpose():
+    arr1d = coo_array([1, 0, 3]).T
+    assert arr1d.shape == (3,)
+    assert_equal(arr1d.toarray(), np.array([1, 0, 3]))
+
+    arr2d = coo_array([[1, 2, 0], [0, 0, 3]]).T
+    assert arr2d.shape == (3, 2)
+    assert_equal(arr2d.toarray(), np.array([[1, 0], [2, 0], [0, 3]]))
+
+
+def test_transpose_with_axis():
+    arr1d = coo_array([1, 0, 3]).transpose(axes=(0,))
+    assert arr1d.shape == (3,)
+    assert_equal(arr1d.toarray(), np.array([1, 0, 3]))
+
+    arr2d = coo_array([[1, 2, 0], [0, 0, 3]]).transpose(axes=(0, 1))
+    assert arr2d.shape == (2, 3)
+    assert_equal(arr2d.toarray(), np.array([[1, 2, 0], [0, 0, 3]]))
+
+    with pytest.raises(ValueError, match="axes don't match matrix dimensions"):
+        coo_array([1, 0, 3]).transpose(axes=(0, 1))
+
+    with pytest.raises(ValueError, match="repeated axis in transpose"):
+        coo_array([[1, 2, 0], [0, 0, 3]]).transpose(axes=(1, 1))
+
+
+def test_1d_row_and_col():
+    res = coo_array([1, -2, -3])
+    assert_equal(res.col, np.array([0, 1, 2]))
+    assert_equal(res.row, np.zeros_like(res.col))
+    assert res.row.dtype == res.col.dtype
+    assert res.row.flags.writeable is False
+
+    res.col = [1, 2, 3]
+    assert len(res.coords) == 1
+    assert_equal(res.col, np.array([1, 2, 3]))
+    assert res.row.dtype == res.col.dtype
+
+    with pytest.raises(ValueError, match="cannot set row attribute"):
+        res.row = [1, 2, 3]
+
+
+def test_1d_toformats():
+    res = coo_array([1, -2, -3])
+    for f in [res.tobsr, res.tocsc, res.todia, res.tolil]:
+        with pytest.raises(ValueError, match='Cannot convert'):
+            f()
+    for f in [res.tocoo, res.tocsr, res.todok]:
+        assert_equal(f().toarray(), res.toarray())
+
+
+@pytest.mark.parametrize('arg', [1, 2, 4, 5, 8])
+def test_1d_resize(arg: int):
+    den = np.array([1, -2, -3])
+    res = coo_array(den)
+    den.resize(arg, refcheck=False)
+    res.resize(arg)
+    assert res.shape == den.shape
+    assert_equal(res.toarray(), den)
+
+
+@pytest.mark.parametrize('arg', zip([1, 2, 3, 4], [1, 2, 3, 4]))
+def test_1d_to_2d_resize(arg: tuple[int, int]):
+    den = np.array([1, 0, 3])
+    res = coo_array(den)
+
+    den.resize(arg, refcheck=False)
+    res.resize(arg)
+    assert res.shape == den.shape
+    assert_equal(res.toarray(), den)
+
+
+@pytest.mark.parametrize('arg', [1, 4, 6, 8])
+def test_2d_to_1d_resize(arg: int):
+    den = np.array([[1, 0, 3], [4, 0, 0]])
+    res = coo_array(den)
+    den.resize(arg, refcheck=False)
+    res.resize(arg)
+    assert res.shape == den.shape
+    assert_equal(res.toarray(), den)
+
+
+def test_sum_duplicates():
+    # 1d case
+    arr1d = coo_array(([2, 2, 2], ([1, 0, 1],)))
+    assert arr1d.nnz == 3
+    assert_equal(arr1d.toarray(), np.array([2, 4]))
+    arr1d.sum_duplicates()
+    assert arr1d.nnz == 2
+    assert_equal(arr1d.toarray(), np.array([2, 4]))
+
+    # 4d case
+    arr4d = coo_array(([2, 3, 7], ([1, 0, 1], [0, 2, 0], [1, 2, 1], [1, 0, 1])))
+    assert arr4d.nnz == 3
+    expected = np.array(  # noqa: E501
+        [[[[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [3, 0]]],
+         [[[0, 0], [0, 9], [0, 0]], [[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]]]]
+    )
+    assert_equal(arr4d.toarray(), expected)
+    arr4d.sum_duplicates()
+    assert arr4d.nnz == 2
+    assert_equal(arr4d.toarray(), expected)
+
+    # when there are no duplicates
+    arr_nodups = coo_array(([1, 2, 3, 4], ([0, 1, 2, 3],)))
+    assert arr_nodups.nnz == 4
+    arr_nodups.sum_duplicates()
+    assert arr_nodups.nnz == 4
+
+
+def test_eliminate_zeros():
+    arr1d = coo_array(([0, 0, 1], ([1, 0, 1],)))
+    assert arr1d.nnz == 3
+    assert arr1d.count_nonzero() == 1
+    assert_equal(arr1d.toarray(), np.array([0, 1]))
+    arr1d.eliminate_zeros()
+    assert arr1d.nnz == 1
+    assert arr1d.count_nonzero() == 1
+    assert_equal(arr1d.toarray(), np.array([0, 1]))
+    assert_equal(arr1d.col, np.array([1]))
+    assert_equal(arr1d.row, np.array([0]))
+
+
+def test_1d_add_dense():
+    den_a = np.array([0, -2, -3, 0])
+    den_b = np.array([0, 1, 2, 3])
+    exp = den_a + den_b
+    res = coo_array(den_a) + den_b
+    assert type(res) is type(exp)
+    assert_equal(res, exp)
+
+
+def test_1d_add_sparse():
+    den_a = np.array([0, -2, -3, 0])
+    den_b = np.array([0, 1, 2, 3])
+    dense_sum = den_a + den_b
+    # this routes through CSR format
+    sparse_sum = coo_array(den_a) + coo_array(den_b)
+    assert_equal(dense_sum, sparse_sum.toarray())
+
+
+def test_1d_matmul_vector():
+    den_a = np.array([0, -2, -3, 0])
+    den_b = np.array([0, 1, 2, 3])
+    exp = den_a @ den_b
+    res = coo_array(den_a) @ den_b
+    assert np.ndim(res) == 0
+    assert_equal(res, exp)
+
+
+def test_1d_matmul_multivector():
+    den = np.array([0, -2, -3, 0])
+    other = np.array([[0, 1, 2, 3], [3, 2, 1, 0]]).T
+    exp = den @ other
+    res = coo_array(den) @ other
+    assert type(res) is type(exp)
+    assert_equal(res, exp)
+
+
+def test_2d_matmul_multivector():
+    # sparse-sparse matmul
+    den = np.array([[0, 1, 2, 3], [3, 2, 1, 0]])
+    arr2d = coo_array(den)
+    exp = den @ den.T
+    res = arr2d @ arr2d.T
+    assert_equal(res.toarray(), exp)
+
+    # sparse-dense matmul for self.ndim = 2
+    den = np.array([[0, 4, 3, 0, 5], [1, 0, 7, 3, 4]])
+    arr2d = coo_array(den)
+    exp = den @ den.T
+    res = arr2d @ den.T
+    assert_equal(res, exp)
+
+    # sparse-dense matmul for self.ndim = 1
+    den_a = np.array([[0, 4, 3, 0, 5], [1, 0, 7, 3, 4]])
+    den_b = np.array([0, 1, 6, 0, 4])
+    arr1d = coo_array(den_b)
+    exp = den_b @ den_a.T
+    res = arr1d @ den_a.T
+    assert_equal(res, exp)
+
+    # sparse-dense matmul for self.ndim = 1 and other.ndim = 2
+    den_a = np.array([1, 0, 2])
+    den_b = np.array([[3], [4], [0]])
+    exp = den_a @ den_b
+    res = coo_array(den_a) @ den_b
+    assert_equal(res, exp)
+    res = coo_array(den_a) @ list(den_b)
+    assert_equal(res, exp)
+
+
+def test_1d_diagonal():
+    den = np.array([0, -2, -3, 0])
+    with pytest.raises(ValueError, match='diagonal requires two dimensions'):
+        coo_array(den).diagonal()
+
+
+@pytest.mark.parametrize('shape', [(0,), (7,), (4,7), (0,0,0), (3,6,2),
+                                   (1,0,3), (7,9,3,2,4,5)])
+def test_nd_todense(shape):
+    np.random.seed(12)
+    arr = np.random.randint(low=0, high=5, size=shape)
+    assert_equal(coo_array(arr).todense(), arr)
+
+
+@pytest.mark.parametrize('shape', [(0,), (7,), (4,7), (0,0,0), (3,6,2),
+                                   (1,0,3), (7,9,3,2,4,5)])
+def test_nd_sparse_constructor(shape):
+    empty_arr = coo_array(shape)
+    res = coo_array(empty_arr)
+    assert res.shape == (shape)
+    assert_equal(res.toarray(), np.zeros(shape))
+
+
+@pytest.mark.parametrize('shape', [(0,), (7,), (4,7), (0,0,0), (3,6,2),
+                                   (1,0,3), (7,9,3,2,4,5)])
+def test_nd_tuple_constructor(shape):
+    np.random.seed(12)
+    arr = np.random.randn(*shape)
+    res = coo_array(arr)
+    assert res.shape == shape
+    assert_equal(res.toarray(), arr)
+
+
+@pytest.mark.parametrize('shape', [(0,), (7,), (4,7), (0,0,0), (3,6,2),
+                                   (1,0,3), (7,9,3,2,4,5)])
+def test_nd_tuple_constructor_with_shape(shape):
+    np.random.seed(12)
+    arr = np.random.randn(*shape)
+    res = coo_array(arr, shape=shape)
+    assert res.shape == shape
+    assert_equal(res.toarray(), arr)
+
+
+def test_tuple_constructor_for_dim_size_zero():
+    # arrays with a dimension of size 0
+    with pytest.raises(ValueError, match='exceeds matrix dimension'):
+        coo_array(([9, 8], ([1, 2], [1, 0], [2, 1])), shape=(3,4,0))
+
+    empty_arr = coo_array(([], ([], [], [], [])), shape=(4,0,2,3))
+    assert_equal(empty_arr.toarray(), np.empty((4,0,2,3)))
+
+
+@pytest.mark.parametrize(('shape', 'new_shape'), [((4,9,6,5), (3,6,15,4)),
+                                                  ((4,9,6,5), (36,30)),
+                                                  ((4,9,6,5), (1080,)),
+                                                  ((4,9,6,5), (2,3,2,2,3,5,3)),])
+def test_nd_reshape(shape, new_shape):
+    # reshaping a 4d sparse array
+    rng = np.random.default_rng(23409823)
+
+    arr4d = random_array(shape, density=0.6, rng=rng, dtype=int)
+    assert arr4d.shape == shape
+    den4d = arr4d.toarray()
+
+    exp_arr = den4d.reshape(new_shape)
+    res_arr = arr4d.reshape(new_shape)
+    assert res_arr.shape == new_shape
+    assert_equal(res_arr.toarray(), exp_arr)
+
+
+@pytest.mark.parametrize('shape', [(0,), (7,), (4,7), (0,0,0), (3,6,2),
+                                   (1,0,3), (7,9,3,2,4,5)])
+def test_nd_nnz(shape):
+    rng = np.random.default_rng(23409823)
+
+    arr = random_array(shape, density=0.6, rng=rng, dtype=int)
+    assert arr.nnz == np.count_nonzero(arr.toarray())
+
+
+@pytest.mark.parametrize('shape', [(0,), (7,), (4,7), (0,0,0), (3,6,2),
+                                   (1,0,3), (7,9,3,2,4,5)])
+def test_nd_transpose(shape):
+    rng = np.random.default_rng(23409823)
+
+    arr = random_array(shape, density=0.6, rng=rng, dtype=int)
+    exp_arr = arr.toarray().T
+    trans_arr = arr.transpose()
+    assert trans_arr.shape == shape[::-1]
+    assert_equal(exp_arr, trans_arr.toarray())
+
+
+@pytest.mark.parametrize(('shape', 'axis_perm'), [((3,), (0,)),
+                                                  ((2,3), (0,1)),
+                                                  ((2,4,3,6,5,3), (1,2,0,5,3,4)),])
+def test_nd_transpose_with_axis(shape, axis_perm):
+    rng = np.random.default_rng(23409823)
+
+    arr = random_array(shape, density=0.6, rng=rng, dtype=int)
+    trans_arr = arr.transpose(axes=axis_perm)
+    assert_equal(trans_arr.toarray(), np.transpose(arr.toarray(), axes=axis_perm))
+
+
+def test_transpose_with_inconsistent_axis():
+    with pytest.raises(ValueError, match="axes don't match matrix dimensions"):
+        coo_array([1, 0, 3]).transpose(axes=(0, 1))
+
+    with pytest.raises(ValueError, match="repeated axis in transpose"):
+        coo_array([[1, 2, 0], [0, 0, 3]]).transpose(axes=(1, 1))
+
+
+def test_nd_eliminate_zeros():
+    # for 3d sparse arrays
+    arr3d = coo_array(([1, 0, 0, 4], ([0, 1, 1, 2], [0, 1, 0, 1], [1, 1, 2, 0])))
+    assert arr3d.nnz == 4
+    assert arr3d.count_nonzero() == 2
+    assert_equal(arr3d.toarray(), np.array([[[0, 1, 0], [0, 0, 0]],
+                                    [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [4, 0, 0]]]))
+    arr3d.eliminate_zeros()
+    assert arr3d.nnz == 2
+    assert arr3d.count_nonzero() == 2
+    assert_equal(arr3d.toarray(), np.array([[[0, 1, 0], [0, 0, 0]],
+                                    [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [4, 0, 0]]]))
+
+    # for a 5d sparse array when all elements of data array are 0
+    coords = ([0, 1, 1, 2], [0, 1, 0, 1], [1, 1, 2, 0], [0, 0, 2, 3], [1, 0, 0, 2])
+    arr5d = coo_array(([0, 0, 0, 0], coords))
+    assert arr5d.nnz == 4
+    assert arr5d.count_nonzero() == 0
+    arr5d.eliminate_zeros()
+    assert arr5d.nnz == 0
+    assert arr5d.count_nonzero() == 0
+    assert_equal(arr5d.col, np.array([]))
+    assert_equal(arr5d.row, np.array([]))
+    assert_equal(arr5d.coords, ([], [], [], [], []))
+
+
+@pytest.mark.parametrize('shape', [(0,), (7,), (4,7), (0,0,0), (3,6,2),
+                                   (1,0,3), (7,9,3,2,4,5)])
+def test_nd_add_dense(shape):
+    rng = np.random.default_rng(23409823)
+    sp_x = random_array(shape, density=0.6, rng=rng, dtype=int)
+    sp_y = random_array(shape, density=0.6, rng=rng, dtype=int)
+    den_x, den_y = sp_x.toarray(), sp_y.toarray()
+    exp = den_x + den_y
+    res = sp_x + den_y
+    assert type(res) is type(exp)
+    assert_equal(res, exp)
+
+
+@pytest.mark.parametrize('shape', [(0,), (7,), (4,7), (0,0,0), (3,6,2),
+                                   (1,0,3), (7,9,3,2,4,5)])
+def test_nd_add_sparse(shape):
+    rng = np.random.default_rng(23409823)
+    sp_x = random_array((shape), density=0.6, rng=rng, dtype=int)
+    sp_y = random_array((shape), density=0.6, rng=rng, dtype=int)
+    den_x, den_y = sp_x.toarray(), sp_y.toarray()
+
+    dense_sum = den_x + den_y
+    sparse_sum = sp_x + sp_y
+    assert_equal(dense_sum, sparse_sum.toarray())
+
+
+def test_add_sparse_with_inf():
+    # addition of sparse arrays with an inf element
+    den_a = np.array([[[0], [np.inf]], [[-3], [0]]])
+    den_b = np.array([[[0], [1]], [[2], [3]]])
+    dense_sum = den_a + den_b
+    sparse_sum = coo_array(den_a) + coo_array(den_b)
+    assert_equal(dense_sum, sparse_sum.toarray())
+
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), [((7,), (12,)),
+                                                  ((6,4), (6,5)),
+                                                  ((5,9,3,2), (9,5,2,3)),])
+def test_nd_add_sparse_with_inconsistent_shapes(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+
+    arr_a = random_array((a_shape), density=0.6, rng=rng, dtype=int)
+    arr_b = random_array((b_shape), density=0.6, rng=rng, dtype=int)
+    with pytest.raises(ValueError, match="inconsistent shapes"):
+        arr_a + arr_b
+
+
+@pytest.mark.parametrize('shape', [(0,), (7,), (4,7), (0,0,0), (3,6,2),
+                                   (1,0,3), (7,9,3,2,4,5)])
+def test_nd_sub_dense(shape):
+    rng = np.random.default_rng(23409823)
+    sp_x = random_array(shape, density=0.6, rng=rng, dtype=int)
+    sp_y = random_array(shape, density=0.6, rng=rng, dtype=int)
+    den_x, den_y = sp_x.toarray(), sp_y.toarray()
+    exp = den_x - den_y
+    res = sp_x - den_y
+    assert type(res) is type(exp)
+    assert_equal(res, exp)
+
+
+@pytest.mark.parametrize('shape', [(0,), (7,), (4,7), (0,0,0), (3,6,2),
+                                   (1,0,3), (7,9,3,2,4,5)])
+def test_nd_sub_sparse(shape):
+    rng = np.random.default_rng(23409823)
+
+    sp_x = random_array(shape, density=0.6, rng=rng, dtype=int)
+    sp_y = random_array(shape, density=0.6, rng=rng, dtype=int)
+    den_x, den_y = sp_x.toarray(), sp_y.toarray()
+
+    dense_sum = den_x - den_y
+    sparse_sum = sp_x - sp_y
+    assert_equal(dense_sum, sparse_sum.toarray())
+
+
+def test_nd_sub_sparse_with_nan():
+    # subtraction of sparse arrays with a nan element
+    den_a = np.array([[[0], [np.nan]], [[-3], [0]]])
+    den_b = np.array([[[0], [1]], [[2], [3]]])
+    dense_sum = den_a - den_b
+    sparse_sum = coo_array(den_a) - coo_array(den_b)
+    assert_equal(dense_sum, sparse_sum.toarray())
+
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), [((7,), (12,)),
+                                                  ((6,4), (6,5)),
+                                                  ((5,9,3,2), (9,5,2,3)),])
+def test_nd_sub_sparse_with_inconsistent_shapes(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+
+    arr_a = random_array((a_shape), density=0.6, rng=rng, dtype=int)
+    arr_b = random_array((b_shape), density=0.6, rng=rng, dtype=int)
+    with pytest.raises(ValueError, match="inconsistent shapes"):
+        arr_a - arr_b
+
+
+mat_vec_shapes = [
+    ((2, 3, 4, 5), (5,)),
+    ((0, 0), (0,)),
+    ((2, 3, 4, 7, 8), (8,)),
+    ((4, 4, 2, 0), (0,)),
+    ((6, 5, 3, 2, 4), (4, 1)),
+    ((2,5), (5,)),
+    ((2, 5), (5, 1)),
+    ((3,), (3, 1)),
+    ((4,), (4,))
+]
+@pytest.mark.parametrize(('mat_shape', 'vec_shape'), mat_vec_shapes)
+def test_nd_matmul_vector(mat_shape, vec_shape):
+    rng = np.random.default_rng(23409823)
+
+    sp_x = random_array(mat_shape, density=0.6, rng=rng, dtype=int)
+    sp_y = random_array(vec_shape, density=0.6, rng=rng, dtype=int)
+    den_x, den_y = sp_x.toarray(), sp_y.toarray()
+    exp = den_x @ den_y
+    res = sp_x @ den_y
+    assert_equal(res,exp)
+    res = sp_x @ list(den_y)
+    assert_equal(res,exp)
+
+
+mat_mat_shapes = [
+    ((2, 3, 4, 5), (2, 3, 5, 7)),
+    ((0, 0), (0,)),
+    ((4, 4, 2, 0), (0,)),
+    ((7, 8, 3), (3,)),
+    ((7, 8, 3), (3, 1)),
+    ((6, 5, 3, 2, 4), (4, 3)),
+    ((1, 3, 2, 4), (6, 5, 1, 4, 3)),
+    ((6, 1, 1, 2, 4), (1, 3, 4, 3)),
+    ((4,), (2, 4, 3)),
+    ((3,), (5, 6, 7, 3, 2)),
+    ((4,), (4, 3)),
+    ((2, 5), (5, 1)),
+]
+@pytest.mark.parametrize(('mat_shape1', 'mat_shape2'), mat_mat_shapes)
+def test_nd_matmul(mat_shape1, mat_shape2):
+    rng = np.random.default_rng(23409823)
+
+    sp_x = random_array(mat_shape1, density=0.6, random_state=rng, dtype=int)
+    sp_y = random_array(mat_shape2, density=0.6, random_state=rng, dtype=int)
+    den_x, den_y = sp_x.toarray(), sp_y.toarray()
+    exp = den_x @ den_y
+    # sparse-sparse
+    res = sp_x @ sp_y
+    assert_equal(res.toarray(), exp)
+    # sparse-dense
+    res = sp_x @ den_y
+    assert_equal(res, exp)
+    res = sp_x @ list(den_y)
+    assert_equal(res, exp)
+
+    # dense-sparse
+    res = den_x @ sp_y
+    assert_equal(res, exp)
+
+
+def test_nd_matmul_sparse_with_inconsistent_arrays():
+    rng = np.random.default_rng(23409823)
+
+    sp_x = random_array((4,5,7,6,3), density=0.6, random_state=rng, dtype=int)
+    sp_y = random_array((1,5,3,2,5), density=0.6, random_state=rng, dtype=int)
+    with pytest.raises(ValueError, match="matmul: dimension mismatch with signature"):
+        sp_x @ sp_y
+    with pytest.raises(ValueError, match="matmul: dimension mismatch with signature"):
+        sp_x @ (sp_y.toarray())
+
+    sp_z = random_array((1,5,3,2), density=0.6, random_state=rng, dtype=int)
+    with pytest.raises(ValueError, match="Batch dimensions are not broadcastable"):
+        sp_x @ sp_z
+    with pytest.raises(ValueError, match="Batch dimensions are not broadcastable"):
+        sp_x @ (sp_z.toarray())
+
+
+def test_dot_1d_1d(): # 1-D inner product
+    a = coo_array([1,2,3])
+    b = coo_array([4,5,6])
+    exp = np.dot(a.toarray(), b.toarray())
+    res = a.dot(b)
+    assert_equal(res, exp)
+    res = a.dot(b.toarray())
+    assert_equal(res, exp)
+
+
+def test_dot_sparse_scalar():
+    a = coo_array([[1, 2], [3, 4], [5, 6]])
+    b = 3
+    res = a.dot(b)
+    exp = np.dot(a.toarray(), b)
+    assert_equal(res.toarray(), exp)
+
+
+def test_dot_with_inconsistent_shapes():
+    arr_a = coo_array([[[1, 2]], [[3, 4]]])
+    arr_b = coo_array([4, 5, 6])
+    with pytest.raises(ValueError, match="not aligned for n-D dot"):
+        arr_a.dot(arr_b)
+
+
+def test_matmul_dot_not_implemented():
+    arr_a = coo_array([[1, 2], [3, 4]])
+    with pytest.raises(TypeError, match="argument not supported type"):
+        arr_a.dot(None)
+    with pytest.raises(TypeError, match="arg not supported type"):
+        arr_a.tensordot(None)
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        arr_a @ None
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        None @ arr_a
+
+
+dot_shapes = [
+    ((3,3), (3,3)), ((4,6), (6,7)), ((1,4), (4,1)), # matrix multiplication 2-D
+    ((3,2,4,7), (7,)), ((5,), (6,3,5,2)), # dot of n-D and 1-D arrays
+    ((3,2,4,7), (7,1)), ((1,5,), (6,3,5,2)),
+    ((4,6), (3,2,6,4)), ((2,8,7), (4,5,7,7,2)), # dot of n-D and m-D arrays
+    ((4,5,7,6), (3,2,6,4)),
+]
+@pytest.mark.parametrize(('a_shape', 'b_shape'), dot_shapes)
+def test_dot_nd(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+
+    arr_a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    arr_b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+
+    exp = np.dot(arr_a.toarray(), arr_b.toarray())
+    # sparse-dense
+    res = arr_a.dot(arr_b.toarray())
+    assert_equal(res, exp)
+    res = arr_a.dot(list(arr_b.toarray()))
+    assert_equal(res, exp)
+    # sparse-sparse
+    res = arr_a.dot(arr_b)
+    assert_equal(res.toarray(), exp)
+
+
+tensordot_shapes_and_axes = [
+    ((4,6), (6,7), ([1], [0])),
+    ((3,2,4,7), (7,), ([3], [0])),
+    ((5,), (6,3,5,2), ([0], [2])),
+    ((4,5,7,6), (3,2,6,4), ([0, 3], [3, 2])),
+    ((2,8,7), (4,5,7,8,2), ([0, 1, 2], [4, 3, 2])),
+    ((4,5,3,2,6), (3,2,6,7,8), 3),
+    ((4,5,7), (7,3,7), 1),
+    ((2,3,4), (2,3,4), ([0, 1, 2], [0, 1, 2])),
+]
+@pytest.mark.parametrize(('a_shape', 'b_shape', 'axes'), tensordot_shapes_and_axes)
+def test_tensordot(a_shape, b_shape, axes):
+    rng = np.random.default_rng(23409823)
+
+    arr_a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    arr_b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+
+    exp = np.tensordot(arr_a.toarray(), arr_b.toarray(), axes=axes)
+
+    # sparse-dense
+    res = arr_a.tensordot(arr_b.toarray(), axes=axes)
+    assert_equal(res, exp)
+    res = arr_a.tensordot(list(arr_b.toarray()), axes=axes)
+    assert_equal(res, exp)
+
+    # sparse-sparse
+    res = arr_a.tensordot(arr_b, axes=axes)
+    if type(res) is coo_array:
+        assert_equal(res.toarray(), exp)
+    else:
+        assert_equal(res, exp)
+
+
+def test_tensordot_with_invalid_args():
+    rng = np.random.default_rng(23409823)
+
+    arr_a = random_array((3,4,5), density=0.6, random_state=rng, dtype=int)
+    arr_b = random_array((3,4,6), density=0.6, random_state=rng, dtype=int)
+
+    axes = ([2], [2]) # sizes of 2nd axes of both shapes do not match
+    with pytest.raises(ValueError, match="sizes of the corresponding axes must match"):
+        arr_a.tensordot(arr_b, axes=axes)
+
+    arr_a = random_array((5,4,2,3,7), density=0.6, random_state=rng, dtype=int)
+    arr_b = random_array((4,6,3,2), density=0.6, random_state=rng, dtype=int)
+
+    axes = ([2,0,1], [1,3]) # lists have different lengths
+    with pytest.raises(ValueError, match="axes lists/tuples must be of the"
+                       " same length"):
+        arr_a.tensordot(arr_b, axes=axes)
+
+
+@pytest.mark.parametrize(('actual_shape', 'broadcast_shape'),
+                         [((1,3,5,4), (2,3,5,4)), ((2,1,5,4), (6,2,3,5,4)),
+                          ((1,1,7,8,9), (4,5,6,7,8,9)), ((1,3), (4,5,3)),
+                          ((7,8,1), (7,8,5)), ((3,1), (3,4)), ((1,), (5,)),
+                          ((1,1,1), (4,5,6)), ((1,3,1,5,4), (8,2,3,9,5,4)),])
+def test_broadcast_to(actual_shape, broadcast_shape):
+    rng = np.random.default_rng(23409823)
+
+    arr = random_array(actual_shape, density=0.6, random_state=rng, dtype=int)
+    res = arr._broadcast_to(broadcast_shape)
+    exp = np.broadcast_to(arr.toarray(), broadcast_shape)
+    assert_equal(res.toarray(), exp)
+
+
+@pytest.mark.parametrize(('shape'), [(4,5,6,7,8), (6,4),
+                                     (5,9,3,2), (9,5,2,3,4),])
+def test_block_diag(shape):
+    rng = np.random.default_rng(23409823)
+    sp_x = random_array(shape, density=0.6, random_state=rng, dtype=int)
+    den_x = sp_x.toarray()
+
+    # converting n-d numpy array to an array of slices of 2-D matrices,
+    # to pass as argument into scipy.linalg.block_diag
+    num_slices = int(np.prod(den_x.shape[:-2]))
+    reshaped_array = den_x.reshape((num_slices,) + den_x.shape[-2:])
+    matrices = [reshaped_array[i, :, :] for i in range(num_slices)]
+    exp = block_diag(*matrices)
+
+    res = _block_diag(sp_x)
+
+    assert_equal(res.toarray(), exp)
+
+
+@pytest.mark.parametrize(('shape'), [(4,5,6,7,8), (6,4),
+                                     (5,9,3,2), (9,5,2,3,4),])
+def test_extract_block_diag(shape):
+    rng = np.random.default_rng(23409823)
+    sp_x = random_array(shape, density=0.6, random_state=rng, dtype=int)
+    res = _extract_block_diag(_block_diag(sp_x), shape)
+
+    assert_equal(res.toarray(), sp_x.toarray())
+
+
+add_sub_shapes = [
+    ((3,4), (3,4)), ((3,4,6), (3,4,6)), ((3,7,5), (3,7,5))
+]
+@pytest.mark.parametrize(('a_shape', 'b_shape'), add_sub_shapes)
+def test_add_no_broadcasting(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+
+    res = a + b
+    exp = np.add(a.toarray(), b.toarray())
+    assert_equal(res.toarray(), exp)
+    res = a + b.toarray()
+    assert_equal(res, exp)
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), add_sub_shapes)
+def test_sub_no_broadcasting(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+
+    res = a - b
+    exp = np.subtract(a.toarray(), b.toarray())
+    assert_equal(res.toarray(), exp)
+
+    res = a - b.toarray()
+    assert_equal(res, exp)
+
+argmax_argmin_shapes_axis = [
+    ((3,), None), ((3,), 0),
+    ((4,6), 1), ((7,3), 0), ((3,5), None),
+    ((2,8,7), 2), ((2,8,7), 0),
+    ((2,0), 0), ((3,0,0,2), 0),
+    ((3,2,4,7), None), ((3,2,4,7), 1), ((3,2,4,7), 0), ((3,2,4,7), 2),
+    ((3,2,4,7), -2), ((4,5,7,8,2), 4), ((4,5,7,8,2), -3),
+]
+@pytest.mark.parametrize(('shape', 'axis'), argmax_argmin_shapes_axis)
+def test_argmax_argmin(shape, axis):
+    rng = np.random.default_rng(23409823)
+    a = random_array(shape, density=0.6, random_state=rng, dtype=int)
+
+    res = a.argmax(axis=axis)
+    exp = np.argmax(a.toarray(), axis=axis)
+    assert_equal(res, exp)
+
+    res = a.argmin(axis=axis)
+    exp = np.argmin(a.toarray(), axis=axis)
+    assert_equal(res, exp)
+
+
+max_min_shapes_axis = [
+    ((3,), None), ((3,), 0),
+    ((4,6), 1), ((7,3), 0), ((3,5), None),
+    ((2,8,7), 2), ((2,8,7), 0),
+    ((3,2,4,7), None), ((3,2,4,7), 1), ((3,2,4,7), 0), ((3,2,4,7), 2),
+    ((4,5,7,8,2), 4), ((4,5,8,1), 3), ((4,6), (0,)), ((4,6), (0,1)),
+    ((3,0,2), 2), ((3,0,2), (0,2)), ((3,0), 0),
+    ((3,7,8,5), (0,1)), ((3,7,8,5), (2,1)), ((3,7,8,5), (2,0)),
+    ((3,7,8,5), (0,-2)), ((3,7,8,5), (-1,2)), ((3,7,8,5), (3)),
+    ((3,7,8,5), (0,1,2)), ((3,7,8,5), (0,1,2,3)),
+]
+@pytest.mark.parametrize(('shape', 'axis'), max_min_shapes_axis)
+def test_min_max(shape, axis):
+    rng = np.random.default_rng(23409823)
+    a = random_array(shape, density=0.6, random_state=rng, dtype=int)
+
+    res_min = a.min(axis=axis)
+    exp_min = np.min(a.toarray(), axis=axis)
+    res_max = a.max(axis=axis)
+    exp_max = np.max(a.toarray(), axis=axis)
+    res_nanmin = a.nanmin(axis=axis)
+    exp_nanmin = np.nanmin(a.toarray(), axis=axis)
+    res_nanmax = a.nanmax(axis=axis)
+    exp_nanmax = np.nanmax(a.toarray(), axis=axis)
+
+    for res, exp in [(res_min, exp_min), (res_max, exp_max),
+                     (res_nanmin, exp_nanmin), (res_nanmax, exp_nanmax)]:
+        if np.issubdtype(type(res), np.number):
+            assert_equal(res, exp)
+        else:
+            assert_equal(res.toarray(), exp)
+
+
+def test_min_max_full():
+    for a in (coo_array([[[1, 2, 3, 4]]]), coo_array([[1, 2, 3, 4]])):
+        assert a.min() == 1
+        assert (-a).max() == -1
+
+
+sum_mean_params = [
+    ((3,), None, None), ((3,), 0, None),
+    ((4,6), 1, None), ((7,3), 0, None), ((3,5), None, None),
+    ((2,8,7), 2, None), ((2,8,7), 0, np.zeros((8,7))),
+    ((3,2,4,7), None, None), ((3,2,4,7), 1, np.zeros((3,4,7))),
+    ((3,2,4,7), 0, None), ((4,5,7,8,2), 4, None),
+    ((4,5,8,1), 3, None), ((4,6), (0,), None), ((4,6), (0,1), None),
+    ((3,0,2), 2, None), ((3,0,2), (0,2), None), ((3,0), 0, None),
+    ((3,7,8,5), (0,1), np.zeros((8,5))), ((3,7,8,5), (2,1), None),
+    ((3,7,8,5), (0,-2), None), ((3,7,8,5), (-1,2), np.zeros((3,7))),
+    ((3,7,8,5), (3), None), ((3,7,8,5), (0,1,2), np.zeros((5,))),
+    ((3,7,8,5), (0,1,2,3), None),
+]
+@pytest.mark.parametrize(('shape', 'axis', 'out'), sum_mean_params)
+def test_sum(shape, axis, out):
+    rng = np.random.default_rng(23409823)
+    a = random_array(shape, density=0.6, random_state=rng, dtype=int)
+
+    res = a.sum(axis=axis, out=out)
+    exp = np.sum(a.toarray(), axis=axis)
+    assert_equal(res, exp)
+    if out is not None:
+        assert_equal(out, exp)
+        assert id(res) == id(out)
+
+
+@pytest.mark.parametrize(('shape', 'axis', 'out'), sum_mean_params)
+def test_mean(shape, axis, out):
+    rng = np.random.default_rng(23409823)
+    a = random_array(shape, density=0.6, random_state=rng, dtype=int)
+
+    res = a.mean(axis=axis, out=out)
+    exp = np.mean(a.toarray(), axis=axis)
+    assert_allclose(res, exp)
+    if out is not None:
+        assert id(res) == id(out)
+        assert_allclose(out, exp)
+
+
+def test_pow_abs_round():
+    rng = np.random.default_rng(23409823)
+    a = random_array((3,6,5,2,4), density=0.6, random_state=rng, dtype=int)
+    assert_allclose((a**3).toarray(), np.power(a.toarray(), 3))
+    assert_allclose((a**7).toarray(), np.power(a.toarray(), 7))
+    assert_allclose(round(a).toarray(), np.round(a.toarray()))
+    assert_allclose(abs(a).toarray(), np.abs(a.toarray()))
+
+
+#bitwise_op_and_compare_broadcast_shapes = [
+#    ((3,4), (3,4)), ((1,4), (2,1)), ((3,5), (1,)), ((1,), (7,8)),
+#    ((3,4,6), (3,4,6)), ((4,3), (2,1,3)), ((2,1,3), (4,3)),
+#    ((3,5,4), (1,)), ((1,), (7,8,4)), ((16,1,6), (2,6)), ((3,7,5), (3,7,5)),
+#    ((16,2,6), (1,2,6)), ((7,8), (5,7,8)), ((4,5,1), (5,1)),
+#    ((6,8,3), (4,1,1,3)), ((1,1,1), (3,4,2)), ((3,4,2), (1,1,1,1,1)),
+bitwise_op_and_compare_shapes = [
+    ((3,4), (3,4)), ((3,4,6), (3,4,6)), ((3,7,5), (3,7,5)),
+]
+@pytest.mark.parametrize(('a_shape', 'b_shape'), bitwise_op_and_compare_shapes)
+def test_boolean_comparisons(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+    with sup:
+        assert_equal((a==b).toarray(), a.toarray()==b.toarray())
+        assert_equal((a!=b).toarray(), a.toarray()!=b.toarray())
+        assert_equal((a>=b).toarray(), a.toarray()>=b.toarray())
+        assert_equal((a<=b).toarray(), a.toarray()<=b.toarray())
+        assert_equal((a>b).toarray(), a.toarray()>b.toarray())
+        assert_equal((a<b).toarray(), a.toarray()<b.toarray())
+        assert_equal((a==b).toarray(), np.bitwise_not((a!=b).toarray()))
+        assert_equal((a>=b).toarray(), np.bitwise_not((a<b).toarray()))
+        assert_equal((a<=b).toarray(), np.bitwise_not((a>b).toarray()))
+
+
+def test_boolean_comparisons_with_scalar():
+    rng = np.random.default_rng(23409823)
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = random_array((5,4,8,7), density=0.6, random_state=rng, dtype=int)
+    with sup:
+        assert_equal((a==0).toarray(), a.toarray()==0)
+        assert_equal((a!=0).toarray(), a.toarray()!=0)
+        assert_equal((a>=1).toarray(), a.toarray()>=1)
+        assert_equal((a<=1).toarray(), a.toarray()<=1)
+        assert_equal((a>0).toarray(), a.toarray()>0)
+        assert_equal((a<0).toarray(), a.toarray()<0)
+
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), bitwise_op_and_compare_shapes)
+def test_multiply(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+    res = a * b
+    exp = np.multiply(a.toarray(), b.toarray())
+    assert_equal(res.toarray(), exp)
+
+
+def test_multiply_with_scalar():
+    rng = np.random.default_rng(23409823)
+    a = random_array((3,5,4), density=0.6, random_state=rng, dtype=int)
+    res = a * 7
+    exp = np.multiply(a.toarray(), 7)
+    assert_equal(res.toarray(), exp)
+
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), bitwise_op_and_compare_shapes)
+def test_divide(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = np.arange(1, 1 + math.prod(b_shape)).reshape(b_shape)
+    res = a / b
+    exp = a.toarray() / b
+    assert_allclose(res.toarray(), exp)
+
+    res = a / b
+    assert_allclose(res.toarray(), exp)
+
+
+def test_divide_with_scalar():
+    rng = np.random.default_rng(23409823)
+    a = random_array((3,5,4), density=0.6, random_state=rng, dtype=int)
+    res = a / 7
+    exp = a.toarray() / 7
+    assert_allclose(res.toarray(), exp)
+
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), bitwise_op_and_compare_shapes)
+def test_maximum(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+    with sup:
+        res = a.maximum(b)
+        exp = np.maximum(a.toarray(), b.toarray())
+        assert_equal(res.toarray(), exp)
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), bitwise_op_and_compare_shapes)
+def test_minimum(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+    with sup:
+        res = a.minimum(b)
+        exp = np.minimum(a.toarray(), b.toarray())
+        assert_equal(res.toarray(), exp)
+
+
+def test_maximum_with_scalar():
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = coo_array([0,1,6])
+    b = coo_array([[15, 0], [14, 5], [0, -12]])
+    c = coo_array([[[[3,0], [2,4]], [[8,9], [-3,12]]],
+                   [[[5,2], [3,0]], [[0,7], [0,-6]]]])
+    with sup:
+        assert_equal(a.maximum(5).toarray(), np.maximum(a.toarray(), 5))
+        assert_equal(b.maximum(9).toarray(), np.maximum(b.toarray(), 9))
+        assert_equal(c.maximum(5).toarray(), np.maximum(c.toarray(), 5))
+
+def test_minimum_with_scalar():
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = coo_array([0,1,6])
+    b = coo_array([[15, 0], [14, 5], [0, -12]])
+    c = coo_array([[[[3,0], [2,4]], [[8,9], [-3,12]]],
+                   [[[5,2], [3,0]], [[0,7], [0,-6]]]])
+    with sup:
+        assert_equal(a.minimum(5).toarray(), np.minimum(a.toarray(), 5))
+        assert_equal(b.minimum(9).toarray(), np.minimum(b.toarray(), 9))
+        assert_equal(c.minimum(5).toarray(), np.minimum(c.toarray(), 5))