Merge pull request #2586 from cowlicks/inequalities-override

ENH: sparse: implement inequality ops for sparse matrices

scipy/sparse/base.py

@@ -233,6 +233,18 @@ def __eq__(self, other):
     def __ne__(self, other):
         return self.tocsr().__ne__(other)
 
+    def __lt__(self,other):
+        return self.tocsr().__lt__(other)
+
+    def __gt__(self,other):
+        return self.tocsr().__gt__(other)
+
+    def __le__(self,other):
+        return self.tocsr().__le__(other)
+
+    def __ge__(self,other):
+        return self.tocsr().__ge__(other)
+
     def __abs__(self):
         return abs(self.tocsr())
 

scipy/sparse/bsr.py

@@ -517,7 +517,8 @@ def _binopt(self, other, op, in_shape=None, out_shape=None):
         indptr = np.empty_like(self.indptr)
         indices = np.empty(max_bnnz, dtype=np.intc)
 
-        if op == '_ne_':
+        bool_ops = ['_ne_', '_lt_', '_gt_', '_le_', '_ge_']
+        if op in bool_ops:
             data = np.empty(R*C*max_bnnz, dtype=np.bool_)
         else:
             data = np.empty(R*C*max_bnnz, dtype=upcast(self.dtype,other.dtype))

scipy/sparse/compressed.py

@@ -177,7 +177,7 @@ def __eq__(self, other):
             res = self._binopt(other_arr,'_ne_')
             if other == 0:
                 warn("Comparing a sparse matrix with 0 using == is inefficient"
-                        ", try using != instead.")
+                        ", try using != instead.", SparseEfficiencyWarning)
                 all_true = self.__class__(np.ones(self.shape, dtype=np.bool_))
                 return all_true - res
             else:
@@ -189,7 +189,7 @@ def __eq__(self, other):
         # Sparse other.
         elif isspmatrix(other):
             warn("Comparing sparse matrices using == is inefficient, try using"
-                    " != instead.")
+                    " != instead.", SparseEfficiencyWarning)
             #TODO sparse broadcasting
             if self.shape != other.shape:
                 return False
@@ -206,7 +206,7 @@ def __ne__(self, other):
         if isscalarlike(other):
             if other != 0:
                 warn("Comparing a sparse matrix with a nonzero scalar using !="
-                     " is inefficient, try using == instead.")
+                     " is inefficient, try using == instead.", SparseEfficiencyWarning)
                 all_true = self.__class__(np.ones(self.shape), dtype=np.bool_)
                 res = (self == other)
                 return all_true - res
@@ -228,6 +228,132 @@ def __ne__(self, other):
         else:
             return True
 
+    def __lt__(self, other):
+        # Scalar other.
+        if isscalarlike(other):
+            if 0 < other:
+                warn("Comparing a sparse matrix with a scalar greater than "
+                     "zero using < is inefficient, try using > instead.", SparseEfficiencyWarning)
+                other_arr = np.empty(self.shape)
+                other_arr.fill(other)
+                other_arr = self.__class__(other_arr)
+                return self._binopt(other_arr, '_lt_')
+            else:
+                other_arr = self.copy()
+                other_arr.data[:] = other
+                return self._binopt(other_arr, '_lt_')
+        # Dense other.
+        elif isdense(other):
+            return self.todense() < other
+        # Sparse other.
+        elif isspmatrix(other):
+            #TODO sparse broadcasting
+            if self.shape != other.shape:
+                raise ValueError("inconsistent shapes")
+            elif self.format != other.format:
+                other = other.asformat(self.format)
+            return self._binopt(other, '_lt_')
+        else:
+            raise ValueError("Operands could not be compared.")
+
+    def __gt__(self, other):
+        # Scalar other.
+        if isscalarlike(other):
+            if 0 > other:
+                warn("Comparing a sparse matrix with a scalar less than zero "
+                     "using > is inefficient, try using < instead.", SparseEfficiencyWarning)
+                other_arr = np.empty(self.shape)
+                other_arr.fill(other)
+                other_arr = self.__class__(other_arr)
+                return self._binopt(other_arr, '_gt_')
+            else:
+                other_arr = self.copy()
+                other_arr.data[:] = other
+                return self._binopt(other_arr, '_gt_')
+        # Dense other.
+        elif isdense(other):
+            return self.todense() > other
+        # Sparse other.
+        elif isspmatrix(other):
+            #TODO sparse broadcasting
+            if self.shape != other.shape:
+                raise ValueError("inconsistent shapes")
+            elif self.format != other.format:
+                other = other.asformat(self.format)
+            return self._binopt(other, '_gt_')
+        else:
+            raise ValueError("Operands could not be compared.")
+
+    def __le__(self,other):
+        # Scalar other.
+        if isscalarlike(other):
+            if 0 == other:
+                raise NotImplementedError(" >= and <= don't work with 0.")
+            elif 0 <= other:
+                warn("Comparing a sparse matrix with a scalar less than zero "
+                     "using <= is inefficient, try using < instead.", SparseEfficiencyWarning)
+                other_arr = np.empty(self.shape)
+                other_arr.fill(other)
+                other_arr = self.__class__(other_arr)
+                return self._binopt(other_arr, '_le_')
+            else:
+                # Casting as other's type avoids corner case like
+                # ``spmatrix(True) < -2'' from being True.
+                other_arr = self.astype(type(other)).copy()
+                other_arr.data[:] = other
+                return self._binopt(other_arr, '_le_')
+        # Dense other.
+        elif isdense(other):
+            return self.todense() <= other
+        # Sparse other.
+        elif isspmatrix(other):
+            #TODO sparse broadcasting
+            if self.shape != other.shape:
+                raise ValueError("inconsistent shapes")
+            elif self.format != other.format:
+                other = other.asformat(self.format)
+            warn("Comparing sparse matrices using >= and <= is inefficient, "
+                 "using <, >, or !=, instead.", SparseEfficiencyWarning)
+            all_true = self.__class__(np.ones(self.shape))
+            res = self._binopt(other, '_gt_')
+            return all_true - res
+        else:
+            raise ValueError("Operands could not be compared.")
+
+    def __ge__(self,other):
+        # Scalar other.
+        if isscalarlike(other):
+            if 0 == other:
+                raise NotImplementedError(" >= and <= don't work with 0.")
+            elif 0 >= other:
+                warn("Comparing a sparse matrix with a scalar greater than zero"
+                     " using >= is inefficient, try using < instead.", SparseEfficiencyWarning)
+                other_arr = np.empty(self.shape)
+                other_arr.fill(other)
+                other_arr = self.__class__(other_arr)
+                return self._binopt(other_arr, '_ge_')
+            else:
+                other_arr = self.astype(type(other)).copy()
+                other_arr.data[:] = other
+                return self._binopt(other_arr, '_ge_')
+        # Dense other.
+        elif isdense(other):
+            return self.todense() >= other
+        # Sparse other.
+        elif isspmatrix(other):
+            #TODO sparse broadcasting
+            if self.shape != other.shape:
+                raise ValueError("inconsistent shapes")
+            elif self.format != other.format:
+                other = other.asformat(self.format)
+            warn("Comparing sparse matrices using >= and <= is inefficient, "
+                 "try using <, >, or !=, instead.", SparseEfficiencyWarning)
+            all_true = self.__class__(np.ones(self.shape))
+            res = self._binopt(other, '_lt_')
+            return all_true - res
+        else:
+            raise ValueError("Operands could not be compared.")
+
     #################################
     # Arithmatic operator overrides #
     #################################
@@ -763,7 +889,8 @@ def _binopt(self, other, op):
         indptr = np.empty_like(self.indptr)
         indices = np.empty(maxnnz, dtype=np.intc)
 
-        if op == '_ne_':
+        bool_ops = ['_ne_', '_lt_', '_gt_', '_le_', '_ge_']
+        if op in bool_ops:
             data = np.empty(maxnnz, dtype=np.bool_)
         else:
             data = np.empty(maxnnz, dtype=upcast(self.dtype,other.dtype))

scipy/sparse/sparsetools/bsr.h

@@ -601,6 +601,42 @@ void bsr_ne_bsr(const I n_row, const I n_col, const I R, const I C,
     bsr_binop_bsr(n_row,n_col,R,C,Ap,Aj,Ax,Bp,Bj,Bx,Cp,Cj,Cx,std::not_equal_to<T>());
 }
 
+template <class I, class T, class T2>
+void bsr_lt_bsr(const I n_row, const I n_col, const I R, const I C, 
+                   const I Ap[], const I Aj[], const T Ax[],
+                   const I Bp[], const I Bj[], const T Bx[],
+                         I Cp[],       I Cj[],      T2 Cx[])
+{
+    bsr_binop_bsr(n_row,n_col,R,C,Ap,Aj,Ax,Bp,Bj,Bx,Cp,Cj,Cx,std::less<T>());
+}
+
+template <class I, class T, class T2>
+void bsr_gt_bsr(const I n_row, const I n_col, const I R, const I C, 
+                   const I Ap[], const I Aj[], const T Ax[],
+                   const I Bp[], const I Bj[], const T Bx[],
+                         I Cp[],       I Cj[],      T2 Cx[])
+{
+    bsr_binop_bsr(n_row,n_col,R,C,Ap,Aj,Ax,Bp,Bj,Bx,Cp,Cj,Cx,std::greater<T>());
+}
+
+template <class I, class T, class T2>
+void bsr_le_bsr(const I n_row, const I n_col, const I R, const I C, 
+                   const I Ap[], const I Aj[], const T Ax[],
+                   const I Bp[], const I Bj[], const T Bx[],
+                         I Cp[],       I Cj[],      T2 Cx[])
+{
+    bsr_binop_bsr(n_row,n_col,R,C,Ap,Aj,Ax,Bp,Bj,Bx,Cp,Cj,Cx,std::less_equal<T>());
+}
+
+template <class I, class T, class T2>
+void bsr_ge_bsr(const I n_row, const I n_col, const I R, const I C, 
+                   const I Ap[], const I Aj[], const T Ax[],
+                   const I Bp[], const I Bj[], const T Bx[],
+                         I Cp[],       I Cj[],      T2 Cx[])
+{
+    bsr_binop_bsr(n_row,n_col,R,C,Ap,Aj,Ax,Bp,Bj,Bx,Cp,Cj,Cx,std::greater_equal<T>());
+}
+
 template <class I, class T>
 void bsr_elmul_bsr(const I n_row, const I n_col, const I R, const I C, 
                    const I Ap[], const I Aj[], const T Ax[],

scipy/sparse/sparsetools/bsr.i

@@ -23,3 +23,7 @@ INSTANTIATE_ALL(bsr_minus_bsr)
 INSTANTIATE_ALL(bsr_sort_indices)
 
 INSTANTIATE_BOOL_OUT(bsr_ne_bsr)
+INSTANTIATE_BOOL_OUT(bsr_lt_bsr)
+INSTANTIATE_BOOL_OUT(bsr_gt_bsr)
+INSTANTIATE_BOOL_OUT(bsr_le_bsr)
+INSTANTIATE_BOOL_OUT(bsr_ge_bsr)