rename __denominator -> _denominator

Author: infmagic2047

src/sage/algebras/quatalg/quaternion_algebra_element.pyx

@@ -1705,10 +1705,10 @@ cdef class QuaternionAlgebraElement_number_field(QuaternionAlgebraElement_abstra
         fmpz_poly_set_ZZX(self.z, (<NumberFieldElement>z).__numerator)
         fmpz_poly_set_ZZX(self.w, (<NumberFieldElement>w).__numerator)
 
-        ZZ_to_mpz(T1, &(<NumberFieldElement>x).__denominator)
-        ZZ_to_mpz(T2, &(<NumberFieldElement>y).__denominator)
-        ZZ_to_mpz(t3, &(<NumberFieldElement>z).__denominator)
-        ZZ_to_mpz(t4, &(<NumberFieldElement>w).__denominator)
+        ZZ_to_mpz(T1, &(<NumberFieldElement>x)._denominator)
+        ZZ_to_mpz(T2, &(<NumberFieldElement>y)._denominator)
+        ZZ_to_mpz(t3, &(<NumberFieldElement>z)._denominator)
+        ZZ_to_mpz(t4, &(<NumberFieldElement>w)._denominator)
 
         mpz_lcm(self.d, T1, T2)
         mpz_lcm(self.d, self.d, t3)
@@ -1766,7 +1766,7 @@ cdef class QuaternionAlgebraElement_number_field(QuaternionAlgebraElement_abstra
         else:
             raise IndexError("quaternion element index out of range")
 
-        mpz_to_ZZ(&item.__denominator, self.d)
+        mpz_to_ZZ(&item._denominator, self.d)
 
         return item
 

src/sage/matrix/matrix_cyclo_dense.pyx

@@ -400,7 +400,7 @@ cdef class Matrix_cyclo_dense(Matrix_dense):
 
         # Set the denominator of x to denom.
         fmpz_get_mpz(tmp, denom)
-        mpz_to_ZZ(&x.__denominator, tmp)
+        mpz_to_ZZ(&x._denominator, tmp)
         fmpz_clear(denom)
         mpz_clear(tmp)
         fmpz_clear(ftmp)

src/sage/rings/fraction_field_element.pyx

@@ -79,7 +79,7 @@ cdef class FractionFieldElement(FieldElement):
         (1, 0)
     """
     cdef object __numerator
-    cdef object __denominator
+    cdef object _denominator
     cdef bint _is_reduced
 
     def __init__(self, parent, numerator, denominator=1,
@@ -109,16 +109,16 @@ cdef class FractionFieldElement(FieldElement):
         FieldElement.__init__(self, parent)
         if coerce:
             self.__numerator   = parent.ring()(numerator)
-            self.__denominator = parent.ring()(denominator)
+            self._denominator = parent.ring()(denominator)
         else:
             self.__numerator   = numerator
-            self.__denominator = denominator
+            self._denominator = denominator
         if reduce and parent.is_exact():
             try:
                 self.reduce()
             except ArithmeticError:
                 pass
-        if self.__denominator.is_zero():
+        if self._denominator.is_zero():
             raise ZeroDivisionError("fraction field element division by zero")
 
     def _im_gens_(self, codomain, im_gens, base_map=None):
@@ -155,7 +155,7 @@ cdef class FractionFieldElement(FieldElement):
             ((-i))/b
         """
         nnum = codomain.coerce(self.__numerator._im_gens_(codomain, im_gens, base_map=base_map))
-        nden = codomain.coerce(self.__denominator._im_gens_(codomain, im_gens, base_map=base_map))
+        nden = codomain.coerce(self._denominator._im_gens_(codomain, im_gens, base_map=base_map))
         return codomain.coerce(nnum/nden)
 
     cpdef reduce(self):
@@ -191,25 +191,25 @@ cdef class FractionFieldElement(FieldElement):
         if self._is_reduced:
             return
         try:
-            g = self.__numerator.gcd(self.__denominator)
+            g = self.__numerator.gcd(self._denominator)
             if not g.is_unit():
                 self.__numerator //= g
-                self.__denominator //= g
+                self._denominator //= g
             self._is_reduced = True
         except AttributeError:
             raise ArithmeticError("unable to reduce because lack of gcd or quo_rem algorithm")
         except TypeError:
             raise ArithmeticError("unable to reduce because gcd algorithm doesn't work on input")
         except NotImplementedError:
             raise ArithmeticError("unable to reduce because gcd algorithm not implemented on input")
-        if not self.__denominator.is_one() and self.__denominator.is_unit():
+        if not self._denominator.is_one() and self._denominator.is_unit():
             try:
-                inv = self.__denominator.inverse_of_unit()
+                inv = self._denominator.inverse_of_unit()
             except Exception:
                 pass
             else:
                 self.__numerator *= inv
-                self.__denominator = self.__denominator.parent().one()
+                self._denominator = self._denominator.parent().one()
 
     def __copy__(self):
         """
@@ -224,7 +224,7 @@ cdef class FractionFieldElement(FieldElement):
             (x + y)/y
         """
         return self.__class__(self._parent, self.__numerator,
-                self.__denominator, coerce=False, reduce=False)
+                self._denominator, coerce=False, reduce=False)
 
     def numerator(self):
         """
@@ -252,7 +252,7 @@ cdef class FractionFieldElement(FieldElement):
             sage: f.denominator()
             y
         """
-        return self.__denominator
+        return self._denominator
 
 
     def is_square(self,root=False):
@@ -399,7 +399,7 @@ cdef class FractionFieldElement(FieldElement):
             sage: ((x+1)/(x^2+1)).subs({x: 1})                                          # optional - sage.rings.number_field
             1
         """
-        if self.__denominator.is_one():
+        if self._denominator.is_one():
             # Handle this case even over rings that don't support reduction, to
             # avoid breaking existing code that carelessly mixes p and p/1
             return hash(self.__numerator)
@@ -414,7 +414,7 @@ cdef class FractionFieldElement(FieldElement):
             self.reduce()
         # Same algorithm as for elements of QQ
         n = hash(self.__numerator)
-        d = hash(self.__denominator)
+        d = hash(self._denominator)
         if d == 1:
             return n
         else:
@@ -443,7 +443,7 @@ cdef class FractionFieldElement(FieldElement):
             sage: h(x0=1)
             (-2*x1*x2 + x1 + 1)/(x1 + x2)
         """
-        return self.__numerator(*x, **kwds) / self.__denominator(*x, **kwds)
+        return self.__numerator(*x, **kwds) / self._denominator(*x, **kwds)
 
     def _is_atomic(self):
         """
@@ -456,7 +456,7 @@ cdef class FractionFieldElement(FieldElement):
             sage: f._is_atomic()
             False
         """
-        return self.__numerator._is_atomic() and self.__denominator._is_atomic()
+        return self.__numerator._is_atomic() and self._denominator._is_atomic()
 
     def _repr_(self):
         """
@@ -477,9 +477,9 @@ cdef class FractionFieldElement(FieldElement):
         if self.is_zero():
             return "0"
         s = "%s" % self.__numerator
-        if self.__denominator != 1:
-            denom_string = str( self.__denominator )
-            if self.__denominator._is_atomic() and not ('*' in denom_string or '/' in denom_string):
+        if self._denominator != 1:
+            denom_string = str( self._denominator )
+            if self._denominator._is_atomic() and not ('*' in denom_string or '/' in denom_string):
                 s = "%s/%s"%(self.__numerator._coeff_repr(no_space=False),denom_string)
             else:
                 s = "%s/(%s)"%(self.__numerator._coeff_repr(no_space=False),denom_string)
@@ -518,10 +518,10 @@ cdef class FractionFieldElement(FieldElement):
         """
         if self.is_zero():
             return "0"
-        if self.__denominator == 1:
+        if self._denominator == 1:
             return latex.latex(self.__numerator)
         return "\\frac{%s}{%s}"%(latex.latex(self.__numerator),
-                                 latex.latex(self.__denominator))
+                                 latex.latex(self._denominator))
 
     def _magma_init_(self, magma):
         """
@@ -578,9 +578,9 @@ cdef class FractionFieldElement(FieldElement):
             (t^2 + 6)/t
         """
         rnum = self.__numerator
-        rden = self.__denominator
+        rden = self._denominator
         snum = (<FractionFieldElement> right).__numerator
-        sden = (<FractionFieldElement> right).__denominator
+        sden = (<FractionFieldElement> right)._denominator
 
         if (rnum.is_zero()):
             return <FractionFieldElement> right
@@ -602,7 +602,7 @@ cdef class FractionFieldElement(FieldElement):
                             self._parent.ring().one(), coerce=False,
                             reduce=False)
                     else:
-                        tden = self.__denominator * sden
+                        tden = self._denominator * sden
                         e    = tnum.gcd(d)
                         if not e.is_unit():
                             tnum = tnum // e
@@ -625,9 +625,9 @@ cdef class FractionFieldElement(FieldElement):
                 pass
 
         rnum = self.__numerator
-        rden = self.__denominator
+        rden = self._denominator
         snum = (<FractionFieldElement> right).__numerator
-        sden = (<FractionFieldElement> right).__denominator
+        sden = (<FractionFieldElement> right)._denominator
 
         return self.__class__(self._parent, rnum*sden + rden*snum, rden*sden,
             coerce=False, reduce=False)
@@ -653,9 +653,9 @@ cdef class FractionFieldElement(FieldElement):
             3/(t + 1)
         """
         rnum = self.__numerator
-        rden = self.__denominator
+        rden = self._denominator
         snum = (<FractionFieldElement> right).__numerator
-        sden = (<FractionFieldElement> right).__denominator
+        sden = (<FractionFieldElement> right)._denominator
 
         if (rnum.is_zero() or snum.is_zero()):
             return self._parent.zero()
@@ -690,9 +690,9 @@ cdef class FractionFieldElement(FieldElement):
                 pass
 
         rnum = self.__numerator
-        rden = self.__denominator
+        rden = self._denominator
         snum = (<FractionFieldElement> right).__numerator
-        sden = (<FractionFieldElement> right).__denominator
+        sden = (<FractionFieldElement> right)._denominator
 
         return self.__class__(self._parent, rnum * snum, rden * sden,
             coerce=False, reduce=False)
@@ -718,7 +718,7 @@ cdef class FractionFieldElement(FieldElement):
             (x*z - x + z - 1)/(z - 3)
         """
         snum = (<FractionFieldElement> right).__numerator
-        sden = (<FractionFieldElement> right).__denominator
+        sden = (<FractionFieldElement> right)._denominator
 
         if snum.is_zero():
             raise ZeroDivisionError("fraction field element division by zero")
@@ -743,9 +743,9 @@ cdef class FractionFieldElement(FieldElement):
             sage: int(K(.5))
             0
         """
-        if self.__denominator != 1:
+        if self._denominator != 1:
             self.reduce()
-        if self.__denominator == 1:
+        if self._denominator == 1:
             return int(self.__numerator)
         else:
             raise TypeError("denominator must equal 1")
@@ -758,7 +758,7 @@ cdef class FractionFieldElement(FieldElement):
             sage: float(x/x + y/y)
             2.0
         """
-        return float(self.__numerator) / float(self.__denominator)
+        return float(self.__numerator) / float(self._denominator)
 
     def __complex__(self):
         """
@@ -768,7 +768,7 @@ cdef class FractionFieldElement(FieldElement):
             sage: complex(x/(I*x) + (I*y)/y)
             0j
         """
-        return complex(self.__numerator) / complex(self.__denominator)
+        return complex(self.__numerator) / complex(self._denominator)
 
     def _rational_(self):
         r"""
@@ -822,12 +822,12 @@ cdef class FractionFieldElement(FieldElement):
             sage: A(C(u))                                                               # optional - sage.rings.number_field
             u
         """
-        if self.__denominator.is_one():
+        if self._denominator.is_one():
             return R(self.__numerator)
         else:
             self.reduce()
             num = R(self.__numerator)
-            inv_den = R(self.__denominator).inverse_of_unit()
+            inv_den = R(self._denominator).inverse_of_unit()
             return num * inv_den
 
     _real_double_ = _conversion
@@ -847,7 +847,7 @@ cdef class FractionFieldElement(FieldElement):
         Returns self raised to the `right^{th}` power.
 
         Note that we need to check whether or not right is negative so we
-        don't set ``__numerator`` or ``__denominator`` to an element of the
+        don't set ``__numerator`` or ``_denominator`` to an element of the
         fraction field instead of the underlying ring.
 
         EXAMPLES::
@@ -877,7 +877,7 @@ cdef class FractionFieldElement(FieldElement):
             1
         """
         snum = (<FractionFieldElement> self).__numerator
-        sden = (<FractionFieldElement> self).__denominator
+        sden = (<FractionFieldElement> self)._denominator
         if right == 0:
             R = self.parent().ring()
             return self.__class__(self.parent(),
@@ -904,7 +904,7 @@ cdef class FractionFieldElement(FieldElement):
             (4*t^2 + 4*t)/(t + 2)
         """
         return self.__class__(self._parent,
-            -self.__numerator, self.__denominator,
+            -self.__numerator, self._denominator,
             coerce=False, reduce=False)
 
     def __abs__(self):
@@ -915,7 +915,7 @@ cdef class FractionFieldElement(FieldElement):
             sage: abs(FractionFieldElement(QQ, -2, 3, coerce=False))
             2/3
         """
-        return abs(self.__numerator) / abs(self.__denominator)
+        return abs(self.__numerator) / abs(self._denominator)
 
     def __invert__(self):
         """
@@ -929,7 +929,7 @@ cdef class FractionFieldElement(FieldElement):
         if self.is_zero():
             raise ZeroDivisionError("Cannot invert 0")
         return self.__class__(self._parent,
-            self.__denominator, self.__numerator, coerce=False, reduce=False)
+            self._denominator, self.__numerator, coerce=False, reduce=False)
 
     cpdef _richcmp_(self, other, int op):
         """
@@ -952,8 +952,8 @@ cdef class FractionFieldElement(FieldElement):
             False
         """
         return richcmp(self.__numerator *
-                       (<FractionFieldElement>other).__denominator,
-                       self.__denominator *
+                       (<FractionFieldElement>other)._denominator,
+                       self._denominator *
                        (<FractionFieldElement>other).__numerator, op)
 
     def valuation(self, v=None):
@@ -972,7 +972,7 @@ cdef class FractionFieldElement(FieldElement):
             sage: f.valuation(x^2 + 1)
             1
         """
-        return self.__numerator.valuation(v) - self.__denominator.valuation(v)
+        return self.__numerator.valuation(v) - self._denominator.valuation(v)
 
     def __bool__(self):
         """
@@ -1025,7 +1025,7 @@ cdef class FractionFieldElement(FieldElement):
             sage: (x/y).is_one()
             False
         """
-        return self.__numerator == self.__denominator
+        return self.__numerator == self._denominator
 
     def _symbolic_(self, ring):
         """
@@ -1044,7 +1044,7 @@ cdef class FractionFieldElement(FieldElement):
             sage: symbolic_expression(elt)                                              # optional - sage.symbolic
             2/3*(x + y)/(x - y)
         """
-        return ring(self.__numerator)/ring(self.__denominator)
+        return ring(self.__numerator)/ring(self._denominator)
 
     def __reduce__(self):
         """
@@ -1058,7 +1058,7 @@ cdef class FractionFieldElement(FieldElement):
             True
         """
         return (make_element,
-                (self._parent, self.__numerator, self.__denominator))
+                (self._parent, self.__numerator, self._denominator))
 
     def _evaluate_polynomial(self, pol):
         """
@@ -1170,8 +1170,8 @@ cdef class FractionFieldElement_1poly_field(FractionFieldElement):
         """
         See :meth:`reduce`.
         """
-        invlc = ~self.__denominator.leading_coefficient()
-        self.__denominator = self.__denominator.monic()
+        invlc = ~self._denominator.leading_coefficient()
+        self._denominator = self._denominator.monic()
         self.__numerator *= invlc
 
     def is_integral(self):