scipy 1.15.2__cp312-cp312-macosx_14_0_arm64.whl → 1.16.0__cp312-cp312-macosx_14_0_arm64.whl

scipy/sparse/_compressed.py

@@ -3,7 +3,6 @@ __all__ = []
 
 from warnings import warn
 import itertools
-import operator
 
 import numpy as np
 from scipy._lib._util import _prune_array, copy_if_needed
@@ -13,12 +12,14 @@ from ._data import _data_matrix, _minmax_mixin
 from . import _sparsetools
 from ._sparsetools import (get_csr_submatrix, csr_sample_offsets, csr_todense,
                            csr_sample_values, csr_row_index, csr_row_slice,
-                           csr_column_index1, csr_column_index2)
+                           csr_column_index1, csr_column_index2, csr_diagonal,
+                           expandptr, csr_has_canonical_format, csr_eliminate_zeros,
+                           csr_sum_duplicates, csr_has_sorted_indices, csr_sort_indices,
+                           csr_matmat_maxnnz, csr_matmat)
 from ._index import IndexMixin
-from ._sputils import (upcast, upcast_char, to_native, isdense, isshape,
-                       getdtype, isscalarlike, isintlike, downcast_intp_index,
-                       get_sum_dtype, check_shape, get_index_dtype, broadcast_shapes,
-                       is_pydata_spmatrix)
+from ._sputils import (upcast, upcast_char, to_native, isshape,
+                       getdtype, isintlike, downcast_intp_index,
+                       get_sum_dtype, check_shape, get_index_dtype, broadcast_shapes)
 
 
 class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
@@ -238,135 +239,6 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
         res.eliminate_zeros()
         return res
 
-    def __eq__(self, other):
-        # Scalar other.
-        if isscalarlike(other):
-            if np.isnan(other):
-                return self.__class__(self.shape, dtype=np.bool_)
-
-            if other == 0:
-                warn("Comparing a sparse matrix with 0 using == is inefficient"
-                     ", try using != instead.", SparseEfficiencyWarning,
-                     stacklevel=3)
-                all_true = self.__class__(np.ones(self.shape, dtype=np.bool_))
-                inv = self._scalar_binopt(other, operator.ne)
-                return all_true - inv
-            else:
-                return self._scalar_binopt(other, operator.eq)
-        # Dense other.
-        elif isdense(other):
-            return self.todense() == other
-        # Pydata sparse other.
-        elif is_pydata_spmatrix(other):
-            return NotImplemented
-        # Sparse other.
-        elif issparse(other):
-            warn("Comparing sparse matrices using == is inefficient, try using"
-                 " != instead.", SparseEfficiencyWarning, stacklevel=3)
-            # TODO sparse broadcasting
-            if self.shape != other.shape:
-                return False
-            elif self.format != other.format:
-                other = other.asformat(self.format)
-            res = self._binopt(other, '_ne_')
-            all_true = self.__class__(np.ones(self.shape, dtype=np.bool_))
-            return all_true - res
-        else:
-            return NotImplemented
-
-    def __ne__(self, other):
-        # Scalar other.
-        if isscalarlike(other):
-            if np.isnan(other):
-                warn("Comparing a sparse matrix with nan using != is"
-                     " inefficient", SparseEfficiencyWarning, stacklevel=3)
-                all_true = self.__class__(np.ones(self.shape, dtype=np.bool_))
-                return all_true
-            elif other != 0:
-                warn("Comparing a sparse matrix with a nonzero scalar using !="
-                     " is inefficient, try using == instead.",
-                     SparseEfficiencyWarning, stacklevel=3)
-                all_true = self.__class__(np.ones(self.shape), dtype=np.bool_)
-                inv = self._scalar_binopt(other, operator.eq)
-                return all_true - inv
-            else:
-                return self._scalar_binopt(other, operator.ne)
-        # Dense other.
-        elif isdense(other):
-            return self.todense() != other
-        # Pydata sparse other.
-        elif is_pydata_spmatrix(other):
-            return NotImplemented
-        # Sparse other.
-        elif issparse(other):
-            # TODO sparse broadcasting
-            if self.shape != other.shape:
-                return True
-            elif self.format != other.format:
-                other = other.asformat(self.format)
-            return self._binopt(other, '_ne_')
-        else:
-            return NotImplemented
-
-    def _inequality(self, other, op, op_name, bad_scalar_msg):
-        # Scalar other.
-        if isscalarlike(other):
-            if 0 == other and op_name in ('_le_', '_ge_'):
-                raise NotImplementedError(" >= and <= don't work with 0.")
-            elif op(0, other):
-                warn(bad_scalar_msg, SparseEfficiencyWarning, stacklevel=3)
-                other_arr = np.empty(self.shape, dtype=np.result_type(other))
-                other_arr.fill(other)
-                other_arr = self.__class__(other_arr)
-                return self._binopt(other_arr, op_name)
-            else:
-                return self._scalar_binopt(other, op)
-        # Dense other.
-        elif isdense(other):
-            return op(self.todense(), other)
-        # Sparse other.
-        elif issparse(other):
-            # TODO sparse broadcasting
-            if self.shape != other.shape:
-                raise ValueError("inconsistent shapes")
-            elif self.format != other.format:
-                other = other.asformat(self.format)
-            if op_name not in ('_ge_', '_le_'):
-                return self._binopt(other, op_name)
-
-            warn("Comparing sparse matrices using >= and <= is inefficient, "
-                 "using <, >, or !=, instead.",
-                 SparseEfficiencyWarning, stacklevel=3)
-            all_true = self.__class__(np.ones(self.shape, dtype=np.bool_))
-            res = self._binopt(other, '_gt_' if op_name == '_le_' else '_lt_')
-            return all_true - res
-        else:
-            return NotImplemented
-
-    def __lt__(self, other):
-        return self._inequality(other, operator.lt, '_lt_',
-                                "Comparing a sparse matrix with a scalar "
-                                "greater than zero using < is inefficient, "
-                                "try using >= instead.")
-
-    def __gt__(self, other):
-        return self._inequality(other, operator.gt, '_gt_',
-                                "Comparing a sparse matrix with a scalar "
-                                "less than zero using > is inefficient, "
-                                "try using <= instead.")
-
-    def __le__(self, other):
-        return self._inequality(other, operator.le, '_le_',
-                                "Comparing a sparse matrix with a scalar "
-                                "greater than zero using <= is inefficient, "
-                                "try using > instead.")
-
-    def __ge__(self, other):
-        return self._inequality(other, operator.ge, '_ge_',
-                                "Comparing a sparse matrix with a scalar "
-                                "less than zero using >= is inefficient, "
-                                "try using < instead.")
-
     #################################
     # Arithmetic operator overrides #
     #################################
@@ -388,12 +260,9 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
     def _sub_sparse(self, other):
         return self._binopt(other, '_minus_')
 
-    def multiply(self, other):
-        """Point-wise multiplication by array/matrix, vector, or scalar."""
-        # Scalar multiplication.
-        if isscalarlike(other):
-            return self._mul_scalar(other)
-        # Sparse matrix or vector.
+    def _multiply_2d_with_broadcasting(self, other):
+        """Element-wise multiplication by array/matrix, vector, or scalar."""
+        # Called after checking that other is not scalarlike and self.ndim <=2
         if issparse(other):
             if self.shape == other.shape:
                 other = self.__class__(other)
@@ -437,7 +306,7 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
             if sN == 1 and sM == oM:
                 new_self = _make_diagonal_csr(self.toarray().ravel(), is_array)
                 return new_self._matmul_sparse(other)
-            raise ValueError("inconsistent shapes")
+            raise ValueError(f"inconsistent shapes {self.shape} and {other.shape}")
 
         # Assume other is a dense matrix/array, which produces a single-item
         # object array if other isn't convertible to ndarray.
@@ -473,7 +342,7 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
             elif other2d.shape[1] == self.shape[-1]:  # Dense 2d matrix.
                 data = np.multiply(ret.data, other2d[:, ret.col])
             else:
-                raise ValueError("inconsistent shapes")
+                raise ValueError(f"inconsistent shapes {self.shape} and {other.shape}")
             idx_dtype = self._get_index_dtype(ret.col,
                                               maxval=ret.nnz * other2d.shape[0])
             row = np.repeat(np.arange(other2d.shape[0], dtype=idx_dtype), ret.nnz)
@@ -490,7 +359,7 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
             elif other2d.shape[0] == self.shape[0]:  # Dense 2d array.
                 data = np.multiply(ret.data[:, None], other2d[ret.row])
             else:
-                raise ValueError("inconsistent shapes")
+                raise ValueError(f"inconsistent shapes {self.shape} and {other.shape}")
             idx_dtype = self._get_index_dtype(ret.row,
                                               maxval=ret.nnz * other2d.shape[1])
             row = np.repeat(ret.row.astype(idx_dtype, copy=False), other2d.shape[1])
@@ -507,7 +376,7 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
         elif other2d.shape[1] == 1 and self.shape[0] == other2d.shape[0]:
             data = np.multiply(ret.data, other2d[ret.row].ravel())
         else:
-            raise ValueError("inconsistent shapes")
+            raise ValueError(f"inconsistent shapes {self.shape} and {other.shape}")
         ret.data = data.view(np.ndarray).ravel()
         return ret
 
@@ -560,39 +429,40 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
             new_shape += (N,)
         faux_shape = (M if self.ndim == 2 else 1, N if o_ndim == 2 else 1)
 
-        major_dim = self._swap((M, N))[0]
         other = self.__class__(other)  # convert to this format
+        index_arrays = (self.indptr, self.indices, other.indptr, other.indices)
 
-        idx_dtype = self._get_index_dtype((self.indptr, self.indices,
-                                     other.indptr, other.indices))
-
-        fn = getattr(_sparsetools, self.format + '_matmat_maxnnz')
-        nnz = fn(M, N,
-                 np.asarray(self.indptr, dtype=idx_dtype),
-                 np.asarray(self.indices, dtype=idx_dtype),
-                 np.asarray(other.indptr, dtype=idx_dtype),
-                 np.asarray(other.indices, dtype=idx_dtype))
+        M, N = self._swap((M, N))
+        s, o = self._swap((self, other))
+
+        idx_dtype = self._get_index_dtype(index_arrays)
+        s_indptr = np.asarray(s.indptr, dtype=idx_dtype)
+        s_indices = np.asarray(s.indices, dtype=idx_dtype)
+        o_indptr = np.asarray(o.indptr, dtype=idx_dtype)
+        o_indices = np.asarray(o.indices, dtype=idx_dtype)
+
+        nnz = csr_matmat_maxnnz(M, N, s_indptr, s_indices, o_indptr, o_indices)
         if nnz == 0:
             if new_shape == ():
                 return np.array(0, dtype=upcast(self.dtype, other.dtype))
             return self.__class__(new_shape, dtype=upcast(self.dtype, other.dtype))
 
-        idx_dtype = self._get_index_dtype((self.indptr, self.indices,
-                                     other.indptr, other.indices),
-                                    maxval=nnz)
+        new_idx_dtype = self._get_index_dtype(index_arrays, maxval=nnz)
+        if new_idx_dtype != idx_dtype:
+            idx_dtype = new_idx_dtype
+            s_indptr = np.asarray(s.indptr, dtype=idx_dtype)
+            s_indices = np.asarray(s.indices, dtype=idx_dtype)
+            o_indptr = np.asarray(o.indptr, dtype=idx_dtype)
+            o_indices = np.asarray(o.indices, dtype=idx_dtype)
 
-        indptr = np.empty(major_dim + 1, dtype=idx_dtype)
+        indptr = np.empty(M + 1, dtype=idx_dtype)
         indices = np.empty(nnz, dtype=idx_dtype)
         data = np.empty(nnz, dtype=upcast(self.dtype, other.dtype))
 
-        fn = getattr(_sparsetools, self.format + '_matmat')
-        fn(M, N, np.asarray(self.indptr, dtype=idx_dtype),
-           np.asarray(self.indices, dtype=idx_dtype),
-           self.data,
-           np.asarray(other.indptr, dtype=idx_dtype),
-           np.asarray(other.indices, dtype=idx_dtype),
-           other.data,
-           indptr, indices, data)
+        csr_matmat(M, N,
+                   s_indptr, s_indices, s.data,
+                   o_indptr, o_indices, o.data,
+                   indptr, indices, data)
 
         if new_shape == ():
             return np.array(data[0])
@@ -604,57 +474,17 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
         return res
 
     def diagonal(self, k=0):
-        rows, cols = self.shape
-        if k <= -rows or k >= cols:
+        M, N = self._swap(self.shape)
+        k, _ = self._swap((k, -k))
+
+        if k <= -M or k >= N:
             return np.empty(0, dtype=self.data.dtype)
-        fn = getattr(_sparsetools, self.format + "_diagonal")
-        y = np.empty(min(rows + min(k, 0), cols - max(k, 0)),
-                     dtype=upcast(self.dtype))
-        fn(k, self.shape[0], self.shape[1], self.indptr, self.indices,
-           self.data, y)
+        y = np.empty(min(M + min(k, 0), N - max(k, 0)), dtype=upcast(self.dtype))
+        csr_diagonal(k, M, N, self.indptr, self.indices, self.data, y)
         return y
 
     diagonal.__doc__ = _spbase.diagonal.__doc__
 
-    #####################
-    # Other binary ops  #
-    #####################
-
-    def _maximum_minimum(self, other, npop, op_name, dense_check):
-        if isscalarlike(other):
-            if dense_check(other):
-                warn("Taking maximum (minimum) with > 0 (< 0) number results"
-                     " to a dense matrix.", SparseEfficiencyWarning,
-                     stacklevel=3)
-                other_arr = np.empty(self.shape, dtype=np.asarray(other).dtype)
-                other_arr.fill(other)
-                other_arr = self.__class__(other_arr)
-                return self._binopt(other_arr, op_name)
-            else:
-                self.sum_duplicates()
-                new_data = npop(self.data, np.asarray(other))
-                mat = self.__class__((new_data, self.indices, self.indptr),
-                                     dtype=new_data.dtype, shape=self.shape)
-                return mat
-        elif isdense(other):
-            return npop(self.todense(), other)
-        elif issparse(other):
-            return self._binopt(other, op_name)
-        else:
-            raise ValueError("Operands not compatible.")
-
-    def maximum(self, other):
-        return self._maximum_minimum(other, np.maximum,
-                                     '_maximum_', lambda x: np.asarray(x) > 0)
-
-    maximum.__doc__ = _spbase.maximum.__doc__
-
-    def minimum(self, other):
-        return self._maximum_minimum(other, np.minimum,
-                                     '_minimum_', lambda x: np.asarray(x) < 0)
-
-    minimum.__doc__ = _spbase.minimum.__doc__
-
     #####################
     # Reduce operations #
     #####################
@@ -663,8 +493,8 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
         """Sum the array/matrix over the given axis.  If the axis is None, sum
         over both rows and columns, returning a scalar.
         """
-        # The _spbase base class already does axis=0 and axis=1 efficiently
-        # so we only do the case axis=None here
+        # The _spbase base class already does axis=None and major axis efficiently
+        # so we only do the case axis= minor axis
         if (self.ndim == 2 and not hasattr(self, 'blocksize') and
                 axis in self._swap(((1, -1), (0, -2)))[0]):
             # faster than multiplication for large minor axis in CSC/CSR
@@ -677,12 +507,8 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
             if axis % 2 == 1:
                 ret = ret.T
 
-            if out is not None and out.shape != ret.shape:
-                raise ValueError('dimensions do not match')
-
             return ret.sum(axis=(), dtype=dtype, out=out)
         else:
-            # _spbase handles the situations when axis is in {None, -2, -1, 0, 1}
             return _spbase.sum(self, axis=axis, dtype=dtype, out=out)
 
     sum.__doc__ = _spbase.sum.__doc__
@@ -1155,7 +981,7 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
         major_dim, minor_dim = self._swap(self.shape)
         minor_indices = self.indices
         major_indices = np.empty(len(minor_indices), dtype=self.indices.dtype)
-        _sparsetools.expandptr(major_dim, self.indptr, major_indices)
+        expandptr(major_dim, self.indptr, major_indices)
         coords = self._swap((major_indices, minor_indices))
 
         return self._coo_container(
@@ -1193,7 +1019,7 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
         This is an *in place* operation.
         """
         M, N = self._swap(self._shape_as_2d)
-        _sparsetools.csr_eliminate_zeros(M, N, self.indptr, self.indices, self.data)
+        csr_eliminate_zeros(M, N, self.indptr, self.indices, self.data)
         self.prune()  # nnz may have changed
 
     @property
@@ -1213,10 +1039,10 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
             # not sorted => not canonical
             self._has_canonical_format = False
         elif not hasattr(self, '_has_canonical_format'):
+            M = len(self.indptr) - 1
             self.has_canonical_format = bool(
-                _sparsetools.csr_has_canonical_format(
-                    len(self.indptr) - 1, self.indptr, self.indices)
-                )
+                csr_has_canonical_format(M, self.indptr, self.indices)
+            )
         return self._has_canonical_format
 
     @has_canonical_format.setter
@@ -1235,7 +1061,7 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
         self.sort_indices()
 
         M, N = self._swap(self._shape_as_2d)
-        _sparsetools.csr_sum_duplicates(M, N, self.indptr, self.indices, self.data)
+        csr_sum_duplicates(M, N, self.indptr, self.indices, self.data)
 
         self.prune()  # nnz may have changed
         self.has_canonical_format = True
@@ -1250,10 +1076,10 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
         """
         # first check to see if result was cached
         if not hasattr(self, '_has_sorted_indices'):
+            M = len(self.indptr) - 1
             self._has_sorted_indices = bool(
-                _sparsetools.csr_has_sorted_indices(
-                    len(self.indptr) - 1, self.indptr, self.indices)
-                )
+                csr_has_sorted_indices(M, self.indptr, self.indices)
+            )
         return self._has_sorted_indices
 
     @has_sorted_indices.setter
@@ -1275,10 +1101,9 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
     def sort_indices(self):
         """Sort the indices of this array/matrix *in place*
         """
-
         if not self.has_sorted_indices:
-            _sparsetools.csr_sort_indices(len(self.indptr) - 1, self.indptr,
-                                          self.indices, self.data)
+            M = len(self.indptr) - 1
+            csr_sort_indices(M, self.indptr, self.indices, self.data)
             self.has_sorted_indices = True
 
     def prune(self):
@@ -1357,7 +1182,7 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
         other = self.__class__(other)
 
         # e.g. csr_plus_csr, csr_minus_csr, etc.
-        fn = getattr(_sparsetools, self.format + op + self.format)
+        fn = getattr(_sparsetools, "csr" + op + "csr")
 
         maxnnz = self.nnz + other.nnz
         idx_dtype = self._get_index_dtype((self.indptr, self.indices,
@@ -1372,7 +1197,7 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
         else:
             data = np.empty(maxnnz, dtype=upcast(self.dtype, other.dtype))
 
-        M, N = self._shape_as_2d
+        M, N = self._swap(self._shape_as_2d)
         fn(M, N,
            np.asarray(self.indptr, dtype=idx_dtype),
            np.asarray(self.indices, dtype=idx_dtype),
@@ -1392,7 +1217,7 @@ class _cs_matrix(_data_matrix, _minmax_mixin, IndexMixin):
         Divide this matrix by a second sparse matrix.
         """
         if other.shape != self.shape:
-            raise ValueError('inconsistent shapes')
+            raise ValueError(f"inconsistent shapes {self.shape} and {other.shape}")
 
         r = self._binopt(other, '_eldiv_')