making __nonzero__ an alias for __bool__ in rings folder

src/sage/rings/asymptotic/asymptotic_ring.py

@@ -779,7 +779,7 @@ def __hash__(self):
         return hash(str(self))
 
 
-    def __nonzero__(self):
+    def __bool__(self):
         r"""
         Return whether this asymptotic expansion is not identically zero.
 
@@ -803,6 +803,7 @@ def __nonzero__(self):
         """
         return bool(self._summands_)
 
+    __nonzero__ =__bool__
 
     def __eq__(self, other):
         r"""

src/sage/rings/complex_arb.pyx

@@ -1402,7 +1402,7 @@ cdef class ComplexBall(RingElement):
         return (arb_is_nonzero(acb_realref(self.value))
                 or arb_is_nonzero(acb_imagref(self.value)))
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Return ``True`` iff this complex ball is not the zero ball, i.e. if the
         midpoint and radius of its real and imaginary parts are not all zero.
@@ -1427,6 +1427,8 @@ cdef class ComplexBall(RingElement):
         """
         return not acb_is_zero(self.value)
 
+    __nonzero__ =__bool__
+
     def is_exact(self):
         """
         Return ``True`` iff the radius of this ball is zero.

src/sage/rings/complex_interval.pyx

@@ -1389,26 +1389,26 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement):
         """
         raise TypeError("can't convert complex interval to complex")
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Return ``True`` if ``self`` is not known to be exactly zero.
 
         EXAMPLES::
 
-            sage: CIF(RIF(0, 0), RIF(0, 0)).__nonzero__()
-            False
             sage: bool(CIF(RIF(0, 0), RIF(0, 0)))
             False
-            sage: CIF(RIF(1), RIF(0)).__nonzero__()
+            sage: bool(CIF(RIF(1), RIF(0)))
             True
-            sage: CIF(RIF(0), RIF(1)).__nonzero__()
+            sage: bool(CIF(RIF(0), RIF(1)))
             True
-            sage: CIF(RIF(1, 2), RIF(0)).__nonzero__()
+            sage: bool(CIF(RIF(1, 2), RIF(0)))
             True
-            sage: CIF(RIF(-1, 1), RIF(-1, 1)).__nonzero__()
+            sage: bool(CIF(RIF(-1, 1), RIF(-1, 1)))
             True
         """
-        return self.real().__nonzero__() or self.imag().__nonzero__()
+        return self.real().__bool__() or self.imag().__bool__()
+
+    __nonzero__ =__bool__
 
     cpdef _richcmp_(left, right, int op):
         r"""

src/sage/rings/complex_mpc.pyx

@@ -1243,7 +1243,7 @@ cdef class MPComplexNumber(sage.structure.element.FieldElement):
             elif cim<0: return -1
             else: return 0
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Return ``True`` if ``self`` is not zero.
 
@@ -1258,6 +1258,8 @@ cdef class MPComplexNumber(sage.structure.element.FieldElement):
         """
         return not (mpfr_zero_p(self.value.re) and mpfr_zero_p(self.value.im))
 
+    __nonzero__ =__bool__
+
     def is_square(self):
         r"""
         This function always returns true as `\CC` is algebraically closed.

src/sage/rings/complex_number.pyx

@@ -859,7 +859,7 @@ cdef class ComplexNumber(sage.structure.element.FieldElement):
                                       real_string, digit_precision_bound,
                                       imag_string, digit_precision_bound)
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Return ``True`` if ``self`` is not zero. This is an internal function;
         use :meth:`is_zero()` instead.
@@ -872,6 +872,8 @@ cdef class ComplexNumber(sage.structure.element.FieldElement):
         """
         return not (mpfr_zero_p(self.__re) and mpfr_zero_p(self.__im))
 
+    __nonzero__ =__bool__
+
     def prec(self):
         """
         Return precision of this complex number.

src/sage/rings/continued_fraction.py

@@ -986,7 +986,7 @@ def ceil(self):
             return self.quotient(0)
         return self.quotient(0)+1
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Return False if self is zero.
 
@@ -1003,6 +1003,8 @@ def __nonzero__(self):
         """
         return bool(self.quotient(0)) or self.quotient(1) is not Infinity
 
+    __nonzero__ =__bool__
+
     def is_zero(self):
         r"""
         Test whether ``self`` is zero.

src/sage/rings/finite_rings/element_givaro.pyx

@@ -926,7 +926,7 @@ cdef class FiniteField_givaroElement(FinitePolyExtElement):
         """
         return self.element
 
-    def __nonzero__(FiniteField_givaroElement self):
+    def __bool__(FiniteField_givaroElement self):
         r"""
         Return ``True`` if ``self != k(0)``.
 
@@ -941,6 +941,8 @@ cdef class FiniteField_givaroElement(FinitePolyExtElement):
         """
         return not self._cache.objectptr.isZero(self.element)
 
+    __nonzero__ =__bool__
+
     def is_one(FiniteField_givaroElement self):
         r"""
         Return ``True`` if ``self == k(1)``.

src/sage/rings/finite_rings/element_ntl_gf2e.pyx

@@ -574,7 +574,7 @@ cdef class FiniteField_ntl_gf2eElement(FinitePolyExtElement):
 
         return " + ".join(reversed(_repr))
 
-    def __nonzero__(FiniteField_ntl_gf2eElement self):
+    def __bool__(FiniteField_ntl_gf2eElement self):
         r"""
         Return ``True`` if ``self != k(0)``.
 
@@ -591,6 +591,8 @@ cdef class FiniteField_ntl_gf2eElement(FinitePolyExtElement):
         (<Cache_ntl_gf2e>self._parent._cache).F.restore()
         return not bool(GF2E_IsZero(self.x))
 
+    __nonzero__ =__bool__
+
     def is_one(FiniteField_ntl_gf2eElement self):
         r"""
         Return ``True`` if ``self == k(1)``.

src/sage/rings/finite_rings/element_pari_ffelt.pyx

@@ -560,7 +560,8 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         """
         return not bool(FF_equal0(self.val))
 
-    __nonzero__ = is_unit
+    __bool__ = is_unit
+    __nonzero__ =__bool__
 
     def __pos__(FiniteFieldElement_pari_ffelt self):
         """

src/sage/rings/finite_rings/integer_mod.pyx

@@ -1901,7 +1901,7 @@ cdef class IntegerMod_gmp(IntegerMod_abstract):
         """
         return mpz_cmp_si(self.value, 1) == 0
 
-    def __nonzero__(IntegerMod_gmp self):
+    def __bool__(IntegerMod_gmp self):
         """
         Returns ``True`` if this is not `0`, otherwise
         ``False``.
@@ -1915,6 +1915,8 @@ cdef class IntegerMod_gmp(IntegerMod_abstract):
         """
         return mpz_cmp_si(self.value, 0) != 0
 
+    __nonzero__ =__bool__
+
     cpdef bint is_unit(self):
         """
         Return True iff this element is a unit.
@@ -2297,7 +2299,7 @@ cdef class IntegerMod_int(IntegerMod_abstract):
         """
         return self.ivalue == 1
 
-    def __nonzero__(IntegerMod_int self):
+    def __bool__(IntegerMod_int self):
         """
         Returns ``True`` if this is not `0`, otherwise
         ``False``.
@@ -2311,6 +2313,8 @@ cdef class IntegerMod_int(IntegerMod_abstract):
         """
         return self.ivalue != 0
 
+    __nonzero__ =__bool__
+
     cpdef bint is_unit(IntegerMod_int self):
         """
         Return True iff this element is a unit
@@ -3114,7 +3118,7 @@ cdef class IntegerMod_int64(IntegerMod_abstract):
         """
         return self.ivalue == 1
 
-    def __nonzero__(IntegerMod_int64 self):
+    def __bool__(IntegerMod_int64 self):
         """
         Returns ``True`` if this is not `0`, otherwise
         ``False``.
@@ -3128,6 +3132,8 @@ cdef class IntegerMod_int64(IntegerMod_abstract):
         """
         return self.ivalue != 0
 
+    __nonzero__ =__bool__
+
     cpdef bint is_unit(IntegerMod_int64 self):
         """
         Return True iff this element is a unit.

src/sage/rings/fraction_field_element.pyx

@@ -869,7 +869,7 @@ cdef class FractionFieldElement(FieldElement):
         """
         return self.__numerator.valuation(v) - self.__denominator.valuation(v)
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Return ``True`` if this element is nonzero.
 
@@ -878,16 +878,18 @@ cdef class FractionFieldElement(FieldElement):
             sage: F = ZZ['x,y'].fraction_field()
             sage: x,y = F.gens()
             sage: t = F(0)/x
-            sage: t.__nonzero__()
+            sage: bool(t)
             False
 
         ::
 
-            sage: (1/x).__nonzero__()
+            sage: bool(1/x)
             True
         """
         return not self.__numerator.is_zero()
 
+    __nonzero__ =__bool__
+
     def is_zero(self):
         """
         Return ``True`` if this element is equal to zero.

src/sage/rings/function_field/function_field_element.pyx

@@ -346,7 +346,7 @@ cdef class FunctionFieldElement_polymod(FunctionFieldElement):
         """
         return self._x._repr(name=self.parent().variable_name())
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         EXAMPLES::
 
@@ -361,6 +361,8 @@ cdef class FunctionFieldElement_polymod(FunctionFieldElement):
         """
         return not not self._x
 
+    __nonzero__ =__bool__
+
     def __hash__(self):
         """
         TESTS::
@@ -560,7 +562,7 @@ cdef class FunctionFieldElement_rational(FunctionFieldElement):
         """
         return repr(self._x)
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         EXAMPLES::
 

src/sage/rings/ideal.py

@@ -386,7 +386,7 @@ def _contains_(self, x):
         """
         raise NotImplementedError
 
-    def __nonzero__(self):
+    def __bool__(self):
         r"""
         Return ``True`` if this ideal is not `(0)`.
 
@@ -419,6 +419,8 @@ def __nonzero__(self):
                 return True
         return False
 
+    __nonzero__ =__bool__
+
     def base_ring(self):
         r"""
         Returns the base ring of this ideal.

src/sage/rings/integer.pyx

@@ -4293,7 +4293,7 @@ cdef class Integer(sage.structure.element.EuclideanDomainElement):
         """
         return mpz_cmp_si(self.value, 1) == 0
 
-    def __nonzero__(self):
+    def __bool__(self):
         r"""
         Returns ``True`` if the integer is not `0`, otherwise ``False``.
 
@@ -4306,6 +4306,8 @@ cdef class Integer(sage.structure.element.EuclideanDomainElement):
         """
         return mpz_sgn(self.value) != 0
 
+    __nonzero__ =__bool__
+
     def is_integral(self):
         """
         Return ``True`` since integers are integral, i.e.,

src/sage/rings/laurent_series_ring_element.pyx

@@ -221,9 +221,11 @@ cdef class LaurentSeries(AlgebraElement):
 
         return self.__u.is_monomial()
 
-    def __nonzero__(self):
+    def __bool__(self):
         return not not self.__u
 
+    __nonzero__ =__bool__
+
     def _im_gens_(self, codomain, im_gens):
         return codomain(self(im_gens[0]))
 

src/sage/rings/morphism.pyx

@@ -602,7 +602,7 @@ cdef class RingHomomorphism(RingMap):
             raise TypeError("parent must be a ring homset")
         RingMap.__init__(self, parent)
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Every ring map is nonzero unless the domain or codomain is the
         0 ring, since there is no zero map between rings, since 1 goes
@@ -626,6 +626,8 @@ cdef class RingHomomorphism(RingMap):
         """
         return bool(self.codomain().one())
 
+    __nonzero__ =__bool__
+
     def _repr_type(self):
         """
         Used internally in printing this morphism.

src/sage/rings/multi_power_series_ring_element.py

@@ -220,7 +220,7 @@ class MPowerSeries(PowerSeries):
     #
     # _mul_prec : works just fine
     #
-    # __nonzero__ : works just fine
+    # __bool__ : works just fine
     #
     """
     Multivariate power series; these are the elements of Multivariate Power

src/sage/rings/number_field/number_field_element.pyx

@@ -2265,27 +2265,27 @@ cdef class NumberFieldElement(FieldElement):
         """
         return self._mul_(~right)
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Return True if this number field element is nonzero.
 
         EXAMPLES::
 
             sage: m.<b> = CyclotomicField(17)
-            sage: m(0).__nonzero__()
+            sage: bool(m(0))
             False
-            sage: b.__nonzero__()
+            sage: bool(b)
             True
 
-        Nonzero is used by the bool command::
+        ``__bool__`` is used by the bool command::
 
             sage: bool(b + 1)
             True
-            sage: bool(m(0))
-            False
         """
         return not IsZero_ZZX(self.__numerator)
 
+    __nonzero__ =__bool__
+
     cpdef _neg_(self):
         r"""
         EXAMPLE::