scipy 1.15.3__cp313-cp313-macosx_14_0_arm64.whl → 1.16.0rc1__cp313-cp313-macosx_14_0_arm64.whl

scipy/sparse/tests/test_base.py

@@ -28,6 +28,9 @@ import random
 from numpy.testing import (assert_equal, assert_array_equal,
         assert_array_almost_equal, assert_almost_equal, assert_,
         assert_allclose, suppress_warnings)
+from numpy.exceptions import ComplexWarning
+
+from types import GenericAlias
 
 import scipy.linalg
 
@@ -36,14 +39,13 @@ from scipy.sparse import (csc_matrix, csr_matrix, dok_matrix,
         coo_matrix, lil_matrix, dia_matrix, bsr_matrix,
         csc_array, csr_array, dok_array,
         coo_array, lil_array, dia_array, bsr_array,
-        eye, issparse, SparseEfficiencyWarning, sparray)
+        eye, issparse, SparseEfficiencyWarning, sparray, spmatrix)
 from scipy.sparse._base import _formats
 from scipy.sparse._sputils import (supported_dtypes, isscalarlike,
                                    get_index_dtype, asmatrix, matrix)
 from scipy.sparse.linalg import splu, expm, inv
 
 from scipy._lib.decorator import decorator
-from scipy._lib._util import ComplexWarning
 
 IS_COLAB = ('google.colab' in sys.modules)
 
@@ -1021,10 +1023,8 @@ class _TestCommon:
                 assert_array_almost_equal(dat.sum(), datsp.sum())
                 assert_equal(dat.sum().dtype, datsp.sum().dtype)
                 assert_(np.isscalar(datsp.sum(axis=None)))
-                assert_array_almost_equal(dat.sum(axis=None),
-                                          datsp.sum(axis=None))
-                assert_equal(dat.sum(axis=None).dtype,
-                             datsp.sum(axis=None).dtype)
+                assert_array_almost_equal(dat.sum(axis=None), datsp.sum(axis=None))
+                assert_equal(dat.sum(axis=None).dtype, datsp.sum(axis=None).dtype)
                 assert_array_almost_equal(dat.sum(axis=0), datsp.sum(axis=0))
                 assert_equal(dat.sum(axis=0).dtype, datsp.sum(axis=0).dtype)
                 assert_array_almost_equal(dat.sum(axis=1), datsp.sum(axis=1))
@@ -1033,6 +1033,8 @@ class _TestCommon:
                 assert_equal(dat.sum(axis=-2).dtype, datsp.sum(axis=-2).dtype)
                 assert_array_almost_equal(dat.sum(axis=-1), datsp.sum(axis=-1))
                 assert_equal(dat.sum(axis=-1).dtype, datsp.sum(axis=-1).dtype)
+                assert_array_almost_equal(dat.sum(axis=(0, 1)), datsp.sum(axis=(0, 1)))
+                assert_equal(dat.sum(axis=(0, 1)).dtype, datsp.sum(axis=(0, 1)).dtype)
 
         for dtype in self.checked_dtypes:
             for j in range(len(matrices)):
@@ -1045,10 +1047,15 @@ class _TestCommon:
                      [-6, 7, 9]])
         datsp = self.spcreator(dat)
 
-        assert_raises(ValueError, datsp.sum, axis=3)
-        assert_raises(TypeError, datsp.sum, axis=(0, 1))
-        assert_raises(TypeError, datsp.sum, axis=1.5)
-        assert_raises(ValueError, datsp.sum, axis=1, out=out)
+        with assert_raises(ValueError, match="axis out of range"):
+            datsp.sum(axis=3)
+        with assert_raises(ValueError, match="axis out of range"):
+            datsp.sum(axis=(0, 3))
+        with assert_raises(TypeError, match="axis must be an integer"):
+            datsp.sum(axis=1.5)
+        # error msg varies by sparray (1d result) or spmatrix (2d result)
+        with assert_raises(ValueError, match="do.*n.t match.*shape|wrong.*dimensions"):
+            datsp.mean(axis=1, out=out)
 
     def test_sum_dtype(self):
         dat = array([[0, 1, 2],
@@ -1088,9 +1095,9 @@ class _TestCommon:
         assert_array_almost_equal(dat_out, datsp_out)
 
         # check that wrong shape out parameter raises
-        with assert_raises(ValueError, match="output parameter.*wrong.*dimension"):
+        with assert_raises(ValueError, match="output parameter"):
             datsp.sum(out=array([0]))
-        with assert_raises(ValueError, match="output parameter.*wrong.*dimension"):
+        with assert_raises(ValueError, match="output parameter"):
             datsp.sum(out=array([[0]] if self.is_array_test else 0))
 
     def test_numpy_sum(self):
@@ -1106,6 +1113,21 @@ class _TestCommon:
         assert_array_almost_equal(dat_sum, datsp_sum)
         assert_equal(dat_sum.dtype, datsp_sum.dtype)
 
+    def test_sum_mean_container_type(self):
+        dat = array([[0, 1, 2],
+                     [3, -4, 5],
+                     [-6, 7, 9]])
+        datsp = self.spcreator(dat)
+
+        assert isscalarlike(datsp.sum())
+        matrix_or_array = ndarray if self.is_array_test else np.matrix
+        assert isinstance(datsp.sum(axis=0), matrix_or_array)
+        assert isinstance(datsp.sum(axis=1), matrix_or_array)
+
+        assert isscalarlike(datsp.mean())
+        assert isinstance(datsp.mean(axis=0), matrix_or_array)
+        assert isinstance(datsp.mean(axis=1), matrix_or_array)
+
     def test_mean(self):
         keep = not self.is_array_test
         def check(dtype):
@@ -1137,21 +1159,31 @@ class _TestCommon:
                 dat.mean(axis=-1, keepdims=keep), datsp.mean(axis=-1)
             )
             assert_equal(dat.mean(axis=-1).dtype, datsp.mean(axis=-1).dtype)
+            assert_array_almost_equal(
+                dat.mean(axis=(0, 1), keepdims=keep), datsp.mean(axis=(0, 1))
+            )
+            assert_equal(dat.mean(axis=(0, 1)).dtype, datsp.mean(axis=(0, 1)).dtype)
+
 
         for dtype in self.checked_dtypes:
             check(dtype)
 
-    def test_mean_invalid_params(self):
+    def test_mean_invalid_param(self):
         out = self.asdense(np.zeros((1, 3)))
         dat = array([[0, 1, 2],
                      [3, -4, 5],
                      [-6, 7, 9]])
         datsp = self.spcreator(dat)
 
-        assert_raises(ValueError, datsp.mean, axis=3)
-        assert_raises(TypeError, datsp.mean, axis=(0, 1))
-        assert_raises(TypeError, datsp.mean, axis=1.5)
-        assert_raises(ValueError, datsp.mean, axis=1, out=out)
+        with assert_raises(ValueError, match="axis out of range"):
+            datsp.mean(axis=3)
+        with assert_raises(ValueError, match="axis out of range"):
+            datsp.mean(axis=(0, 3))
+        with assert_raises(TypeError, match="axis must be an integer"):
+            datsp.mean(axis=1.5)
+        # error msg varies by sparray (1d result) or spmatrix (2d result)
+        with assert_raises(ValueError, match="do.*n.t match.*shape|wrong.*dimensions"):
+            datsp.mean(axis=1, out=out)
 
     def test_mean_dtype(self):
         dat = array([[0, 1, 2],
@@ -1649,7 +1681,10 @@ class _TestCommon:
                 except ValueError:
                     assert_raises(ValueError, i.multiply, j)
                     continue
-                sp_mult = i.multiply(j)
+                try:
+                    sp_mult = i.multiply(j)
+                except ValueError:
+                    continue
                 if issparse(sp_mult):
                     assert_almost_equal(sp_mult.toarray(), dense_mult)
                 else:
@@ -1695,13 +1730,7 @@ class _TestCommon:
         B = self.spcreator(A)
 
         if self.is_array_test:  # sparrays use element-wise power
-            # Todo: Add 1+3j to tested exponent list when np1.24 is no longer supported
-            #    Complex exponents of 0 (our implicit fill value) change in numpy-1.25
-            #    from `(nan+nanj)` to `0`. Old value makes array element-wise result
-            #    dense and is hard to check for without any `isnan` method.
-            # So while untested here, element-wise complex exponents work with np>=1.25.
-            # for exponent in [1, 2, 2.2, 3, 1+3j]:
-            for exponent in [1, 2, 2.2, 3]:
+            for exponent in [1, 2, 2.2, 3, 1+3j]:
                 ret_sp = B**exponent
                 ret_np = A**exponent
                 assert_array_equal(ret_sp.toarray(), ret_np)
@@ -2072,8 +2101,8 @@ class _TestCommon:
 
             with suppress_warnings() as sup:
                 sup.filter(SparseEfficiencyWarning,
-                           "Taking maximum .minimum. with > 0 .< 0. number "
-                           "results to a dense matrix")
+                           "Taking (maximum|minimum) with a (positive|negative) number "
+                           "results in a dense matrix")
 
                 max_s = A.maximum(B)
                 min_s = A.minimum(B)
@@ -2366,20 +2395,14 @@ class _TestInplaceArithmetic:
 
         # Matrix multiply from __rmatmul__
         y = a.copy()
-        # skip this test if numpy doesn't support __imatmul__ yet.
-        # move out of the try/except once numpy 1.24 is no longer supported.
-        try:
-            y @= b.T
-        except TypeError:
-            pass
-        else:
-            x = a.copy()
-            y = a.copy()
-            with assert_raises(ValueError, match="dimension mismatch"):
-                x @= b
-            x = x.dot(a.T)
-            y @= b.T
-            assert_array_equal(x, y)
+        y @= b.T
+        x = a.copy()
+        y = a.copy()
+        with assert_raises(ValueError, match="dimension mismatch"):
+            x @= b
+        x = x.dot(a.T)
+        y @= b.T
+        assert_array_equal(x, y)
 
         # Floor division is not supported
         with assert_raises(TypeError, match="unsupported operand"):
@@ -3720,9 +3743,11 @@ class _TestMinMax:
         X = self.spcreator(np.arange(1, 10).reshape(3, 3))
         assert_equal(X.min(), 1)
         assert_equal(X.min().dtype, X.dtype)
+        assert_equal(X.min(explicit=True), 1)
 
         X = -X
         assert_equal(X.max(), -1)
+        assert_equal(X.max(explicit=True), -1)
 
         # and a fully sparse matrix
         Z = self.spcreator(np.zeros((1, 1)))
@@ -3797,6 +3822,7 @@ class _TestMinMax:
             assert_array_equal(
                 X.min(axis=axis).toarray(), D.min(axis=axis, keepdims=keep)
             )
+        assert_equal(X.max(axis=(0, 1)), D.max(axis=(0, 1), keepdims=keep))
 
         for axis in axes_even:
             expected_max = D[-1, :]
@@ -3844,6 +3870,38 @@ class _TestMinMax:
             assert_equal(X.max(axis=axis, explicit=ex).toarray(), D.max(axis=axis))
             assert_equal(X.min(axis=axis, explicit=ex).toarray(), D.min(axis=axis))
 
+    def test_minmax_container_type(self):
+        dat = array([[0, 1, 2],
+                     [3, -4, 5],
+                     [-6, 7, 9]])
+        datsp = self.spcreator(dat)
+        matrix_or_array = ndarray if self.is_array_test else np.matrix
+        spmatrix_or_sparray = sparray if self.is_array_test else spmatrix
+
+        assert isscalarlike(datsp.min())
+        assert isinstance(datsp.min(axis=0), spmatrix_or_sparray)
+        assert isinstance(datsp.min(axis=1), spmatrix_or_sparray)
+
+        assert isscalarlike(datsp.max())
+        assert isinstance(datsp.max(axis=0), spmatrix_or_sparray)
+        assert isinstance(datsp.max(axis=1), spmatrix_or_sparray)
+
+        assert isscalarlike(datsp.nanmin())
+        assert isinstance(datsp.nanmin(axis=0), spmatrix_or_sparray)
+        assert isinstance(datsp.nanmin(axis=1), spmatrix_or_sparray)
+
+        assert isscalarlike(datsp.nanmax())
+        assert isinstance(datsp.nanmax(axis=0), spmatrix_or_sparray)
+        assert isinstance(datsp.nanmax(axis=1), spmatrix_or_sparray)
+
+        assert isscalarlike(datsp.argmin())
+        assert isinstance(datsp.argmin(axis=0), matrix_or_array)
+        assert isinstance(datsp.argmin(axis=1), matrix_or_array)
+
+        assert isscalarlike(datsp.argmax())
+        assert isinstance(datsp.argmax(axis=0), matrix_or_array)
+        assert isinstance(datsp.argmax(axis=1), matrix_or_array)
+
     def test_nanminmax(self):
         D = self.asdense(np.arange(50).reshape(5,10), dtype=float)
         D[1, :] = 0
@@ -3862,6 +3920,10 @@ class _TestMinMax:
         assert np.isscalar(X_nan_minimum)
         assert X_nan_minimum == np.nanmin(D)
 
+        X_nan_minimum = X.nanmin(axis=(0, 1))
+        assert np.isscalar(X_nan_minimum)
+        assert X_nan_minimum == np.nanmin(D, axis=(0, 1))
+
         axes = [-2, -1, 0, 1]
         for axis in axes:
             X_nan_maxima = X.nanmax(axis=axis)
@@ -3879,11 +3941,12 @@ class _TestMinMax:
         datsp = self.spcreator(dat)
 
         for fname in ('min', 'max'):
+            datfunc = getattr(dat, fname)
             func = getattr(datsp, fname)
             assert_raises(ValueError, func, axis=3)
-            assert_raises(TypeError, func, axis=(0, 1))
             assert_raises(TypeError, func, axis=1.5)
             assert_raises(ValueError, func, axis=1, out=1)
+            assert_equal(func(axis=(0, 1)), datfunc(axis=(0, 1)))
 
     def test_numpy_minmax(self):
         # See gh-5987
@@ -3933,6 +3996,13 @@ class _TestMinMax:
             assert_equal(mat.argmax(axis=1), np.argmax(D, axis=1))
             assert_equal(mat.argmin(axis=1), np.argmin(D, axis=1))
 
+        # full matrix with explicit=True
+        mat = self.spcreator(self.asdense(D5))
+        assert_equal(mat.argmax(explicit=True), 5)
+        assert_equal((-mat).argmax(explicit=True), 2)
+        assert_equal(mat.argmin(explicit=True), 2)
+        assert_equal((-mat).argmin(explicit=True), 5)
+
         # zero-size matrices
         D6 = self.spcreator(np.empty((0, 5)))
         D7 = self.spcreator(np.empty((5, 0)))
@@ -4355,6 +4425,12 @@ class TestCSRMatrix(_MatrixMixin, TestCSR):
         with suppress_warnings() as sup:
             sup.filter(SparseEfficiencyWarning, "Changing the sparsity structure")
             return csr_matrix(*args, **kwargs)
+    
+    def test_spmatrix_subscriptable(self):
+        result = csr_matrix[np.int8]
+        assert isinstance(result, GenericAlias)
+        assert result.__origin__ is csr_matrix
+        assert result.__args__ == (np.int8,)
 
 
 TestCSRMatrix.init_class()
@@ -4890,6 +4966,17 @@ class TestCOO(sparse_test_class(getset=False,
         # Using __ne__ and nnz instead
         assert_((mat1.reshape((1001, 3000001), order='C') != mat2).nnz == 0)
         assert_((mat2.reshape((3000001, 1001), order='F') != mat1).nnz == 0)
+    
+    def test_sparray_subscriptable(self):
+        result = coo_array[np.int8, tuple[int]]
+        assert isinstance(result, GenericAlias)
+        assert result.__origin__ is coo_array
+        assert result.__args__ == (np.int8, tuple[int])
+
+        result = coo_array[np.int8]
+        assert isinstance(result, GenericAlias)
+        assert result.__origin__ is coo_array
+        assert result.__args__ == (np.int8,)
 
 
 class TestCOOMatrix(_MatrixMixin, TestCOO):
@@ -4962,6 +5049,40 @@ class TestDIA(sparse_test_class(getset=False, slicing=False, slicing_assign=Fals
         csc = dia.tocsc()
         assert csc.indices.dtype == np.int32
 
+    def test_add_sparse(self):
+        # test format and cases not covered by common add tests
+        A = diag([1, 2])
+        B = A + diag([3], 1)
+        Asp = dia_matrix(A)
+        Bsp = dia_matrix(B)
+
+        Csp = Asp + Bsp
+        assert isinstance(Csp, dia_matrix)
+        assert_array_equal(Csp.toarray(), A + B)
+
+        Csp = Bsp + Asp
+        assert isinstance(Csp, dia_matrix)
+        assert_array_equal(Csp.toarray(), B + A)
+
+    def test_sub_sparse(self):
+        # test format and cases not covered by common sub tests
+        A = diag([1, 2])
+        B = A + diag([3], 1)
+        Asp = dia_matrix(A)
+        Bsp = dia_matrix(B)
+
+        Csp = Asp - Bsp
+        assert isinstance(Csp, dia_matrix)
+        assert_array_equal(Csp.toarray(), A - B)
+
+        Csp = Bsp - Asp
+        assert isinstance(Csp, dia_matrix)
+        assert_array_equal(Csp.toarray(), B - A)
+
+        Bsp = Bsp.asformat('csr')
+        assert_array_equal((Asp - Bsp).toarray(), A - B)
+        assert_array_equal((Bsp - Asp).toarray(), B - A)
+
     def test_mul_scalar(self):
         # repro for gh-20434
         m = self.dia_container([[1, 2], [0, 4]])
@@ -4973,6 +5094,50 @@ class TestDIA(sparse_test_class(getset=False, slicing=False, slicing_assign=Fals
         assert isinstance(res2, m.__class__)
         assert_array_equal(res2.toarray(), [[3, 6], [0, 12]])
 
+    def test_matmul_dia(self):
+        # test DIA structure of DIA @ DIA:
+
+        # that all and only needed elements are used and produced
+        A = array([[1, 2, 3],
+                   [4, 5, 6]])
+        B = array([[11, 12],
+                   [13, 14],
+                   [15, 16]])
+        Asp = dia_matrix(A)
+        Bsp = dia_matrix(B)
+        Asp.data[Asp.data == 0] = -1  # poison outside elements
+        Bsp.data[Bsp.data == 0] = -1
+        assert_array_equal(Asp.toarray(), A)
+        assert_array_equal(Bsp.toarray(), B)
+
+        C = A @ B
+        Csp = Asp @ Bsp
+        assert isinstance(Csp, dia_matrix)
+        assert_array_equal(Csp.toarray(), C)
+        assert_array_equal(Csp.offsets, [-1, 0, 1])
+        assert_array_equal(Csp.data, dia_matrix(C).data)
+
+        C = B @ A
+        Csp = Bsp @ Asp
+        assert isinstance(Csp, dia_matrix)
+        assert_array_equal(Csp.toarray(), C)
+        assert_array_equal(Csp.offsets, [-2, -1, 0, 1, 2])
+        assert_array_equal(Csp.data, dia_matrix(C).data)
+
+        # short data and that order of input offsets doesn't matter
+        Asp = dia_matrix(([[0., 1., 2.], [3., 4., 5.]], [1, -2]), (5, 5))
+        Bsp = dia_matrix(([[6., 7., 8.], [0., 0., 9.]], [-1, 2]), (5, 5))
+
+        Csp = Asp @ Bsp
+        assert_array_equal(Csp.offsets, array([-3, 0]))
+        assert_array_equal(Csp.data, [[24., 35., 0.],
+                                      [6., 14., 27.]])
+
+        Csp = Bsp @ Asp
+        assert_array_equal(Csp.offsets, array([-3, 0]))
+        assert_array_equal(Csp.data, [[24., 0., 0.],
+                                      [27., 6., 14.]])
+
 
 class TestDIAMatrix(_MatrixMixin, TestDIA):
     spcreator = dia_matrix

scipy/sparse/tests/test_common1d.py

@@ -4,13 +4,13 @@ import pytest
 
 import numpy as np
 from numpy.testing import assert_equal, assert_allclose
+from numpy.exceptions import ComplexWarning
 
 from scipy.sparse import (
         bsr_array, csc_array, dia_array, lil_array,
         coo_array, csr_array, dok_array,
     )
 from scipy.sparse._sputils import supported_dtypes, matrix
-from scipy._lib._util import ComplexWarning
 
 
 sup_complex = np.testing.suppress_warnings()
@@ -136,10 +136,10 @@ class TestCommon1D:
         dat = np.array([0, 1, 2])
         datsp = spcreator(dat)
 
-        with pytest.raises(ValueError, match='axis must be None, -1 or 0'):
+        with pytest.raises(ValueError, match='axis out of range'):
             datsp.sum(axis=1)
-        with pytest.raises(TypeError, match='Tuples are not accepted'):
-            datsp.sum(axis=(0, 1))
+        with pytest.raises(ValueError, match='axis out of range'):
+            datsp.sum(axis=(0, 3))
         with pytest.raises(TypeError, match='axis must be an integer'):
             datsp.sum(axis=1.5)
         with pytest.raises(ValueError, match='output parameter.*wrong.*dimension'):
@@ -176,11 +176,11 @@ class TestCommon1D:
         datsp = spcreator(dat)
         with pytest.raises(ValueError, match='axis out of range'):
             datsp.mean(axis=3)
-        with pytest.raises(TypeError, match='Tuples are not accepted'):
-            datsp.mean(axis=(0, 1))
+        with pytest.raises(ValueError, match='axis out of range'):
+            datsp.mean(axis=(0, 3))
         with pytest.raises(TypeError, match='axis must be an integer'):
             datsp.mean(axis=1.5)
-        with pytest.raises(ValueError, match='output parameter.*wrong.*dimension'):
+        with pytest.raises(ValueError, match='out.*not match shape'):
             datsp.mean(axis=1, out=out)
 
     def test_sum_dtype(self, spcreator):

scipy/sparse/tests/test_construct.py

@@ -673,7 +673,7 @@ class TestConstructUtils:
         assert isinstance(bmat([[Gm.tocsc(), Gm]], format="csr"), spmatrix)
         assert isinstance(bmat([[Gm, Gm]], format="csc"), spmatrix)
 
-    @pytest.mark.slow
+    @pytest.mark.xslow
     @pytest.mark.thread_unsafe
     @pytest.mark.xfail_on_32bit("Can't create large array for test")
     def test_concatenate_int32_overflow(self):