scipy 1.15.2__cp313-cp313t-macosx_14_0_arm64.whl → 1.16.0rc1__cp313-cp313t-macosx_14_0_arm64.whl

scipy/sparse/_data.py

@@ -124,7 +124,7 @@ class _data_matrix(_spbase):
 
         data = self._deduped_data()
         if dtype is not None:
-            data = data.astype(dtype)
+            data = data.astype(dtype, copy=False)
         return self._with_data(data ** n)
 
     ###########################
@@ -172,9 +172,8 @@ class _minmax_mixin:
     """
 
     def _min_or_max_axis(self, axis, min_or_max, explicit):
+        # already checked that self.shape[axis] is not zero
         N = self.shape[axis]
-        if N == 0:
-            raise ValueError("zero-size array to reduction operation")
         M = self.shape[1 - axis]
         idx_dtype = self._get_index_dtype(maxval=M)
 
@@ -208,13 +207,9 @@ class _minmax_mixin:
 
     def _min_or_max(self, axis, out, min_or_max, explicit):
         if out is not None:
-            raise ValueError("Sparse arrays do not support an 'out' parameter.")
+            raise ValueError("Sparse min/max does not support an 'out' parameter.")
 
-        validateaxis(axis)
-        if self.ndim == 1:
-            if axis not in (None, 0, -1):
-                raise ValueError("axis out of range")
-            axis = None  # avoid calling special axis case. no impact on 1d
+        axis = validateaxis(axis, ndim=self.ndim)
 
         if axis is None:
             if 0 in self.shape:
@@ -228,21 +223,15 @@ class _minmax_mixin:
                 m = min_or_max(zero, m)
             return m
 
-        if axis < 0:
-            axis += 2
-
-        if (axis == 0) or (axis == 1):
-            return self._min_or_max_axis(axis, min_or_max, explicit)
-        else:
-            raise ValueError("axis out of range")
-
-    def _arg_min_or_max_axis(self, axis, argmin_or_argmax, compare, explicit):
-        if self.shape[axis] == 0:
-            raise ValueError("Cannot apply the operation along a zero-sized dimension.")
+        if any(self.shape[d] == 0 for d in axis):
+            raise ValueError("zero-size array to reduction operation")
 
-        if axis < 0:
-            axis += 2
+        if self.ndim == 2:
+            # note: 2D ensures that len(axis)==1 so we pass in the int axis[0]
+            return self._min_or_max_axis(axis[0], min_or_max, explicit)
+        return self._min_or_max_axis_nd(axis, min_or_max, explicit)
 
+    def _argminmax_axis(self, axis, argminmax, compare, explicit):
         zero = self.dtype.type(0)
 
         mat = self.tocsc() if axis == 0 else self.tocsr()
@@ -256,7 +245,7 @@ class _minmax_mixin:
             p, q = mat.indptr[i:i + 2]
             data = mat.data[p:q]
             indices = mat.indices[p:q]
-            extreme_index = argmin_or_argmax(data)
+            extreme_index = argminmax(data)
             extreme_value = data[extreme_index]
             if explicit:
                 if q - p > 0:
@@ -279,26 +268,31 @@ class _minmax_mixin:
 
         return self._ascontainer(ret)
 
-    def _arg_min_or_max(self, axis, out, argmin_or_argmax, compare, explicit):
+    def _argminmax(self, axis, out, argminmax, compare, explicit):
         if out is not None:
-            raise ValueError("Sparse types do not support an 'out' parameter.")
+            minmax = "argmin" if argminmax == np.argmin else "argmax"
+            raise ValueError(f"Sparse {minmax} does not support an 'out' parameter.")
 
-        validateaxis(axis)
-
-        if self.ndim == 1:
-            if axis not in (None, 0, -1):
-                raise ValueError("axis out of range")
-            axis = None  # avoid calling special axis case. no impact on 1d
+        axis = validateaxis(axis, ndim=self.ndim)
 
         if axis is not None:
-            return self._arg_min_or_max_axis(axis, argmin_or_argmax, compare, explicit)
+            if any(self.shape[i] == 0 for i in axis):
+                minmax = "argmin" if argminmax == np.argmin else "argmax"
+                raise ValueError(f"Cannot apply {minmax} along a zero-sized dimension.")
+
+            if self.ndim == 2:
+                # note: 2D ensures that len(axis)==1 so we pass in the int axis[0]
+                return self._argminmax_axis(axis[0], argminmax, compare, explicit)
+            return self._argminmax_axis_nd(axis, argminmax, compare, explicit)
 
         if 0 in self.shape:
-            raise ValueError("Cannot apply the operation to an empty matrix.")
+            minmax = "argmin" if argminmax == np.argmin else "argmax"
+            raise ValueError(f"Cannot apply {minmax} to an empty matrix.")
 
         if self.nnz == 0:
             if explicit:
-                raise ValueError("Cannot apply the operation to zero matrix "
+                minmax = "argmin" if argminmax == np.argmin else "argmax"
+                raise ValueError(f"Cannot apply {minmax} to zero matrix "
                                  "when explicit=True.")
             return 0
 
@@ -306,28 +300,34 @@ class _minmax_mixin:
         mat = self.tocoo()
         # Convert to canonical form: no duplicates, sorted indices.
         mat.sum_duplicates()
-        extreme_index = argmin_or_argmax(mat.data)
+        extreme_index = argminmax(mat.data)
         if explicit:
             return extreme_index
         extreme_value = mat.data[extreme_index]
-        num_col = mat.shape[-1]
 
+        if mat.ndim > 2:
+            mat = mat.reshape(-1)
         # If the min value is less than zero, or max is greater than zero,
         # then we do not need to worry about implicit zeros.
-        if compare(extreme_value, zero):
+        # And we use a "cheap test" for the rare case of no implicit zeros.
+        maxnnz = math.prod(self.shape)
+        if compare(extreme_value, zero) or mat.nnz == maxnnz:
             # cast to Python int to avoid overflow and RuntimeError
-            return int(mat.row[extreme_index]) * num_col + int(mat.col[extreme_index])
-
-        # Cheap test for the rare case where we have no implicit zeros.
-        size = math.prod(self.shape)
-        if size == mat.nnz:
+            if mat.ndim == 1:  # includes nD case that was reshaped above
+                return int(mat.col[extreme_index])
+            # ndim == 2
+            num_col = mat.shape[-1]
             return int(mat.row[extreme_index]) * num_col + int(mat.col[extreme_index])
 
         # At this stage, any implicit zero could be the min or max value.
         # After sum_duplicates(), the `row` and `col` arrays are guaranteed to
         # be sorted in C-order, which means the linearized indices are sorted.
-        linear_indices = mat.row * num_col + mat.col
-        first_implicit_zero_index = _find_missing_index(linear_indices, size)
+        if mat.ndim == 1:  # includes nD case that was reshaped above
+            linear_indices = mat.coords[-1]
+        else:  # ndim == 2
+            num_col = mat.shape[-1]
+            linear_indices = mat.row * num_col + mat.col
+        first_implicit_zero_index = _find_missing_index(linear_indices, maxnnz)
         if extreme_value == zero:
             return min(first_implicit_zero_index, extreme_index)
         return first_implicit_zero_index
@@ -524,7 +524,7 @@ class _minmax_mixin:
 
         explicit : {False, True} optional (default: False)
             When set to True, only explicitly stored elements will be considered.
-            If axis is not None and a row/column has no stored elements, argmax
+            If axis is not None and an axis has no stored elements, argmax
             is undefined, so the index ``0`` is returned for that row/column.
 
             .. versionadded:: 1.15.0
@@ -534,7 +534,7 @@ class _minmax_mixin:
         ind : numpy.matrix or int
             Indices of maximum elements. If matrix, its size along `axis` is 1.
         """
-        return self._arg_min_or_max(axis, out, np.argmax, np.greater, explicit)
+        return self._argminmax(axis, out, np.argmax, np.greater, explicit)
 
     def argmin(self, axis=None, out=None, *, explicit=False):
         """Return indices of minimum elements along an axis.
@@ -556,7 +556,7 @@ class _minmax_mixin:
 
         explicit : {False, True} optional (default: False)
             When set to True, only explicitly stored elements will be considered.
-            If axis is not None and a row/column has no stored elements, argmin
+            If axis is not None and an axis has no stored elements, argmin
             is undefined, so the index ``0`` is returned for that row/column.
 
             .. versionadded:: 1.15.0
@@ -566,4 +566,4 @@ class _minmax_mixin:
          ind : numpy.matrix or int
             Indices of minimum elements. If matrix, its size along `axis` is 1.
         """
-        return self._arg_min_or_max(axis, out, np.argmin, np.less, explicit)
+        return self._argminmax(axis, out, np.argmin, np.less, explicit)

scipy/sparse/_dia.py

@@ -11,9 +11,10 @@ from ._matrix import spmatrix
 from ._base import issparse, _formats, _spbase, sparray
 from ._data import _data_matrix
 from ._sputils import (
-    isshape, upcast_char, getdtype, get_sum_dtype, validateaxis, check_shape
+    isdense, isscalarlike, isshape, upcast_char, getdtype, get_sum_dtype,
+    validateaxis, check_shape
 )
-from ._sparsetools import dia_matvec
+from ._sparsetools import dia_matmat, dia_matvec, dia_matvecs
 
 
 class _dia_base(_data_matrix):
@@ -89,10 +90,10 @@ class _dia_base(_data_matrix):
             raise ValueError('data array must have rank 2')
 
         if self.data.shape[0] != len(self.offsets):
-            raise ValueError('number of diagonals (%d) '
-                    'does not match the number of offsets (%d)'
-                    % (self.data.shape[0], len(self.offsets)))
-
+            raise ValueError(
+                f'number of diagonals ({self.data.shape[0]}) does not match the number '
+                f'of offsets ({len(self.offsets)})'
+            )
         if len(np.unique(self.offsets)) != len(self.offsets):
             raise ValueError('offset array contains duplicate values')
 
@@ -142,16 +143,13 @@ class _dia_base(_data_matrix):
     _getnnz.__doc__ = _spbase._getnnz.__doc__
 
     def sum(self, axis=None, dtype=None, out=None):
-        validateaxis(axis)
-
-        if axis is not None and axis < 0:
-            axis += 2
+        axis = validateaxis(axis)
 
         res_dtype = get_sum_dtype(self.dtype)
         num_rows, num_cols = self.shape
         ret = None
 
-        if axis == 0:
+        if axis == (0,):
             mask = self._data_mask()
             x = (self.data * mask).sum(axis=0)
             if x.shape[0] == num_cols:
@@ -161,7 +159,7 @@ class _dia_base(_data_matrix):
                 res[:x.shape[0]] = x
             ret = self._ascontainer(res, dtype=res_dtype)
 
-        else:
+        else:  # axis is None or (1,)
             row_sums = np.zeros((num_rows, 1), dtype=res_dtype)
             one = np.ones(num_cols, dtype=res_dtype)
             dia_matvec(num_rows, num_cols, len(self.offsets),
@@ -174,21 +172,19 @@ class _dia_base(_data_matrix):
 
             ret = self._ascontainer(row_sums.sum(axis=axis))
 
-        if out is not None and out.shape != ret.shape:
-            raise ValueError("dimensions do not match")
-
         return ret.sum(axis=(), dtype=dtype, out=out)
 
     sum.__doc__ = _spbase.sum.__doc__
 
-    def _add_sparse(self, other):
+    def _add_sparse(self, other, sub=False):
         # If other is not DIA format, let them handle us instead.
         if not isinstance(other, _dia_base):
             return other._add_sparse(self)
 
         # Fast path for exact equality of the sparsity structure.
         if np.array_equal(self.offsets, other.offsets):
-            return self._with_data(self.data + other.data)
+            return self._with_data(self.data - other.data if sub else
+                                   self.data + other.data)
 
         # Find the union of the offsets (which will be sorted and unique).
         new_offsets = np.union1d(self.offsets, other.offsets)
@@ -201,26 +197,91 @@ class _dia_base(_data_matrix):
         # permutation of the existing offsets and the diagonal lengths match.
         if self_d == other_d and len(new_offsets) == len(self.offsets):
             new_data = self.data[_invert_index(self_idx)]
-            new_data[other_idx, :] += other.data
+            if sub:
+                new_data[other_idx, :] -= other.data
+            else:
+                new_data[other_idx, :] += other.data
         elif self_d == other_d and len(new_offsets) == len(other.offsets):
-            new_data = other.data[_invert_index(other_idx)]
+            if sub:
+                new_data = -other.data[_invert_index(other_idx)]
+            else:
+                new_data = other.data[_invert_index(other_idx)]
             new_data[self_idx, :] += self.data
         else:
             # Maximum diagonal length of the result.
             d = min(self.shape[0] + new_offsets[-1], self.shape[1])
 
-            # Add all diagonals to a freshly-allocated data array.
+            # Add all diagonals to a freshly allocated data array.
             new_data = np.zeros(
                 (len(new_offsets), d),
                 dtype=np.result_type(self.data, other.data),
             )
             new_data[self_idx, :self_d] += self.data[:, :d]
-            new_data[other_idx, :other_d] += other.data[:, :d]
+            if sub:
+                new_data[other_idx, :other_d] -= other.data[:, :d]
+            else:
+                new_data[other_idx, :other_d] += other.data[:, :d]
         return self._dia_container((new_data, new_offsets), shape=self.shape)
 
+    def _sub_sparse(self, other):
+        # If other is not DIA format, use default handler.
+        if not isinstance(other, _dia_base):
+            return super()._sub_sparse(other)
+
+        return self._add_sparse(other, sub=True)
+
     def _mul_scalar(self, other):
         return self._with_data(self.data * other)
 
+    def multiply(self, other):
+        if isscalarlike(other):
+            return self._mul_scalar(other)
+
+        if isdense(other):
+            if other.ndim > 2:
+                return self.toarray() * other
+
+            # Use default handler for pathological cases.
+            if 0 in self.shape or 1 in self.shape or 0 in other.shape:
+                return super().multiply(other)
+
+            other = np.atleast_2d(other)
+            other_rows, other_cols = other.shape
+            rows, cols = self.shape
+            L = min(self.data.shape[1], cols)
+            data = self.data[:, :L].astype(np.result_type(self.data, other))
+            if other_rows == 1:
+                data *= other[0, :L]
+            elif other_rows != rows:
+                raise ValueError('inconsistent shapes')
+            else:
+                j = np.arange(L)
+                if L > rows:
+                    i = (j - self.offsets[:, None]) % rows
+                else:  # can use faster method
+                    i = j - self.offsets[:, None] % rows
+                if other_cols == 1:
+                    j = 0
+                elif other_cols != cols:
+                    raise ValueError('inconsistent shapes')
+                data *= other[i, j]
+            return self._with_data(data)
+
+        # If other is not DIA format or needs broadcasting (unreasonable
+        # use case for DIA anyway), use default handler.
+        if not isinstance(other, _dia_base) or other.shape != self.shape:
+            return super().multiply(other)
+
+        # Find common offsets (unique diagonals don't contribute)
+        # and indices corresponding to them in multiplicand and multiplier.
+        offsets, self_idx, other_idx = \
+            np.intersect1d(self.offsets, other.offsets,
+                           assume_unique=True, return_indices=True)
+        # Only overlapping length of diagonals can have non-zero products.
+        L = min(self.data.shape[1], other.data.shape[1])
+        data = self.data[self_idx, :L] * other.data[other_idx, :L]
+        return self._dia_container((data, offsets), shape=self.shape)
+
     def _matmul_vector(self, other):
         x = other
 
@@ -236,6 +297,29 @@ class _dia_base(_data_matrix):
 
         return y
 
+    def _matmul_multivector(self, other):
+        res = np.zeros((self.shape[0], other.shape[1]),
+                       dtype=np.result_type(self.data, other))
+        dia_matvecs(*self.shape, *self.data.shape, self.offsets, self.data,
+                    other.shape[1], other, res)
+        return res
+
+    def _matmul_sparse(self, other):
+        # If other is not DIA format, use default handler.
+        if not isinstance(other, _dia_base):
+            return super()._matmul_sparse(other)
+
+        # If any dimension is zero, return empty array immediately.
+        if 0 in self.shape or 0 in other.shape:
+            return self._dia_container((self.shape[0], other.shape[1]))
+
+        offsets, data = dia_matmat(*self.shape, *self.data.shape,
+                                   self.offsets, self.data,
+                                   other.shape[1], *other.data.shape,
+                                   other.offsets, other.data)
+        return self._dia_container((data.reshape(len(offsets), -1), offsets),
+                                   (self.shape[0], other.shape[1]))
+
     def _setdiag(self, values, k=0):
         M, N = self.shape
 

scipy/sparse/_dok.py

@@ -5,7 +5,6 @@ __docformat__ = "restructuredtext en"
 __all__ = ['dok_array', 'dok_matrix', 'isspmatrix_dok']
 
 import itertools
-from warnings import warn
 import numpy as np
 
 from ._matrix import spmatrix
@@ -421,28 +420,6 @@ class _dok_base(_spbase, IndexMixin, dict):
 
     transpose.__doc__ = _spbase.transpose.__doc__
 
-    def conjtransp(self):
-        """DEPRECATED: Return the conjugate transpose.
-
-        .. deprecated:: 1.14.0
-
-            `conjtransp` is deprecated and will be removed in v1.16.0.
-            Use ``.T.conj()`` instead.
-        """
-        msg = ("`conjtransp` is deprecated and will be removed in v1.16.0. "
-                   "Use `.T.conj()` instead.")
-        warn(msg, DeprecationWarning, stacklevel=2)
-
-        if self.ndim == 1:
-            new = self.tocoo()
-            new.data = new.data.conjugate()
-            return new
-
-        M, N = self.shape
-        new = self._dok_container((N, M), dtype=self.dtype)
-        new._dict = {(right, left): np.conj(val) for (left, right), val in self.items()}
-        return new
-
     def copy(self):
         new = self._dok_container(self.shape, dtype=self.dtype)
         new._dict.update(self._dict)

scipy/sparse/_index.py

@@ -329,12 +329,12 @@ class IndexMixin:
         # Check bounds
         max_indx = x.max()
         if max_indx >= length:
-            raise IndexError('index (%d) out of range' % max_indx)
+            raise IndexError(f'index ({max_indx}) out of range')
 
         min_indx = x.min()
         if min_indx < 0:
             if min_indx < -length:
-                raise IndexError('index (%d) out of range' % min_indx)
+                raise IndexError(f'index ({min_indx}) out of range')
             if x is idx or not x.flags.owndata:
                 x = x.copy()
             x[x < 0] += length
@@ -346,7 +346,7 @@ class IndexMixin:
         M, N = self.shape
         i = int(i)
         if i < -M or i >= M:
-            raise IndexError('index (%d) out of range' % i)
+            raise IndexError(f'index ({i}) out of range')
         if i < 0:
             i += M
         return self._get_intXslice(i, slice(None))
@@ -357,7 +357,7 @@ class IndexMixin:
         M, N = self.shape
         i = int(i)
         if i < -N or i >= N:
-            raise IndexError('index (%d) out of range' % i)
+            raise IndexError(f'index ({i}) out of range')
         if i < 0:
             i += N
         return self._get_sliceXint(slice(None), i)

scipy/sparse/_matrix.py

@@ -144,3 +144,26 @@ class spmatrix:
             `numpy.matrix` object that shares the same memory.
         """
         return super().todense(order, out)
+
+    @classmethod
+    def __class_getitem__(cls, arg, /):
+        """
+        Return a parametrized wrapper around the `~scipy.sparse.spmatrix` type.
+
+        .. versionadded:: 1.16.0
+
+        Returns
+        -------
+        alias : types.GenericAlias
+            A parametrized `~scipy.sparse.spmatrix` type.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from scipy.sparse import coo_matrix
+
+        >>> coo_matrix[np.int8]
+        scipy.sparse._coo.coo_matrix[numpy.int8]
+        """
+        from types import GenericAlias
+        return GenericAlias(cls, arg)

scipy/sparse/_sputils.py

@@ -134,7 +134,7 @@ def getdtype(dtype, a=None, default=None):
 
     if newdtype not in supported_dtypes:
         supported_dtypes_fmt = ", ".join(t.__name__ for t in supported_dtypes)
-        raise ValueError(f"scipy.sparse does not support dtype {newdtype.name}. "
+        raise ValueError(f"scipy.sparse does not support dtype {newdtype}. "
                          f"The only supported types are: {supported_dtypes_fmt}.")
     return newdtype
 
@@ -403,27 +403,42 @@ def isdense(x) -> bool:
     return isinstance(x, np.ndarray)
 
 
-def validateaxis(axis) -> None:
+def validateaxis(axis, *, ndim=2) -> tuple[int, ...] | None:
     if axis is None:
-        return
-    axis_type = type(axis)
-
-    # In NumPy, you can pass in tuples for 'axis', but they are
-    # not very useful for sparse matrices given their limited
-    # dimensions, so let's make it explicit that they are not
-    # allowed to be passed in
-    if isinstance(axis, tuple):
-        raise TypeError("Tuples are not accepted for the 'axis' parameter. "
-                        "Please pass in one of the following: "
-                        "{-2, -1, 0, 1, None}.")
-
-    # If not a tuple, check that the provided axis is actually
-    # an integer and raise a TypeError similar to NumPy's
-    if not np.issubdtype(np.dtype(axis_type), np.integer):
-        raise TypeError(f"axis must be an integer, not {axis_type.__name__}")
-
-    if not (-2 <= axis <= 1):
-        raise ValueError("axis out of range")
+        return None
+
+    if axis == ():
+        raise ValueError(
+            "sparse does not accept 0D axis (). Either use toarray (for dense) "
+            "or copy (for sparse)."
+        )
+
+    if not isinstance(axis, tuple):
+        # If not a tuple, check that the provided axis is actually
+        # an integer and raise a TypeError similar to NumPy's
+        if not np.issubdtype(np.dtype(type(axis)), np.integer):
+            raise TypeError(f'axis must be an integer/tuple of ints, not {type(axis)}')
+        axis = (axis,)
+
+    canon_axis = []
+    for ax in axis:
+        if not isintlike(ax):
+            raise TypeError(f"axis must be an integer. (given {ax})")
+        if ax < 0:
+            ax += ndim
+        if ax < 0 or ax >= ndim:
+            raise ValueError("axis out of range for ndim")
+        canon_axis.append(ax)
+
+    len_axis = len(canon_axis)
+    if len_axis != len(set(canon_axis)):
+        raise ValueError("duplicate value in axis")
+    elif len_axis > ndim:
+        raise ValueError("axis tuple has too many elements")
+    elif len_axis == ndim:
+        return None
+    else:
+        return tuple(canon_axis)
 
 
 def check_shape(args, current_shape=None, *, allow_nd=(2,)) -> tuple[int, ...]:
@@ -509,7 +524,7 @@ def broadcast_shapes(*shapes):
     """
     if not shapes:
         return ()
-    shapes = [shp if isinstance(shp, (tuple, list)) else (shp,) for shp in shapes]
+    shapes = [shp if isinstance(shp, tuple | list) else (shp,) for shp in shapes]
     big_shp = max(shapes, key=len)
     out = list(big_shp)
     for shp in shapes:

scipy/sparse/base.py

@@ -6,20 +6,11 @@ from scipy._lib.deprecation import _sub_module_deprecation
 
 
 __all__ = [  # noqa: F822
-    'MAXPRINT',
     'SparseEfficiencyWarning',
-    'SparseFormatWarning',
     'SparseWarning',
-    'asmatrix',
-    'check_reshape_kwargs',
-    'check_shape',
-    'get_sum_dtype',
-    'isdense',
-    'isscalarlike',
     'issparse',
     'isspmatrix',
     'spmatrix',
-    'validateaxis',
 ]
 
 

scipy/sparse/bsr.py

@@ -6,23 +6,9 @@ from scipy._lib.deprecation import _sub_module_deprecation
 
 
 __all__ = [  # noqa: F822
-    'bsr_matmat',
     'bsr_matrix',
-    'bsr_matvec',
-    'bsr_matvecs',
-    'bsr_sort_indices',
-    'bsr_tocsr',
-    'bsr_transpose',
-    'check_shape',
-    'csr_matmat_maxnnz',
-    'getdata',
-    'getdtype',
-    'isshape',
     'isspmatrix_bsr',
     'spmatrix',
-    'to_native',
-    'upcast',
-    'warn',
 ]
 
 

scipy/sparse/compressed.py

@@ -6,30 +6,7 @@ from scipy._lib.deprecation import _sub_module_deprecation
 
 
 __all__ = [  # noqa: F822
-    'IndexMixin',
     'SparseEfficiencyWarning',
-    'check_shape',
-    'csr_column_index1',
-    'csr_column_index2',
-    'csr_row_index',
-    'csr_row_slice',
-    'csr_sample_offsets',
-    'csr_sample_values',
-    'csr_todense',
-    'downcast_intp_index',
-    'get_csr_submatrix',
-    'get_sum_dtype',
-    'getdtype',
-    'is_pydata_spmatrix',
-    'isdense',
-    'isintlike',
-    'isscalarlike',
-    'isshape',
-    'operator',
-    'to_native',
-    'upcast',
-    'upcast_char',
-    'warn',
 ]