remove unused variables in rings/

Author: fchapoton

src/sage/rings/bernoulli_mod_p.pyx

@@ -145,7 +145,6 @@ def bernoulli_mod_p(int p):
     g = primitive_root(p)
     gInv = arith_int.c_inverse_mod_int(g, p)
     gSqr = ((<llong> g) * g) % p
-    gInvSqr = ((<llong> gInv) * gInv) % p
     isOdd = ((p-1)/2) % 2
 
     # STEP 1: compute the polynomials G(X) and J(X)

src/sage/rings/complex_interval.pyx

@@ -1165,7 +1165,6 @@ cdef class ComplexIntervalFieldElement(FieldElement):
 
         - [RL1971]_
         """
-        cdef ComplexIntervalFieldElement result
         x = self._new()
 
         if mpfi_nan_p(self.__re) or mpfi_nan_p(self.__im):

src/sage/rings/function_field/khuri_makdisi.pyx

@@ -153,11 +153,9 @@ cdef class KhuriMakdisi_base(object):
         """
         cdef Matrix mat, perp, vmu
         cdef FreeModuleElement v
-        cdef Py_ssize_t nd, ne, nde, r
+        cdef Py_ssize_t ne, r
 
         ne = we.ncols()
-        nde = wde.ncols()
-        nd = nde - ne
 
         perp = wde.right_kernel_matrix()
         mat = matrix(0, mu_mat.nrows())

src/sage/rings/polynomial/multi_polynomial.pyx

@@ -2948,7 +2948,7 @@ cdef class MPolynomial(CommutativePolynomial):
             (2*x^2 - 3*x - 5*y, -1)
         """
         lc = self.leading_coefficient()
-        n, u = lc.canonical_associate()
+        _, u = lc.canonical_associate()
         return (u.inverse_of_unit() * self, u)
 
 

src/sage/rings/polynomial/polynomial_element.pyx

@@ -74,9 +74,7 @@ import sage.rings.fraction_field_element
 import sage.rings.infinity as infinity
 from sage.misc.latex import latex
 from sage.arith.power cimport generic_power
-from sage.arith.misc import crt
 from sage.arith.long cimport pyobject_to_long
-from sage.misc.mrange import cartesian_product_iterator
 from sage.structure.factorization import Factorization
 from sage.structure.richcmp cimport (richcmp, richcmp_item,
         rich_to_bool, rich_to_bool_sgn)
@@ -6299,7 +6297,7 @@ cdef class Polynomial(CommutativePolynomial):
             (2*x^2 - 3*x - 5, -1)
         """
         lc = self.leading_coefficient()
-        n, u = lc.canonical_associate()
+        _, u = lc.canonical_associate()
         return (u.inverse_of_unit() * self, u)
 
     def lm(self):

src/sage/rings/rational.pyx

@@ -586,7 +586,6 @@ cdef class Rational(sage.structure.element.FieldElement):
     cdef __set_value(self, x, unsigned int base):
         cdef int n
         cdef Rational temp_rational
-        cdef integer.Integer a, b
 
         if isinstance(x, Rational):
             set_from_Rational(self, x)
@@ -610,7 +609,6 @@ cdef class Rational(sage.structure.element.FieldElement):
                 xstr = x.str(base, truncate=(base == 10))
                 if '.' in xstr:
                     exp = (len(xstr) - (xstr.index('.') +1))
-                    p = base**exp
                     pstr = '1'+'0'*exp
                     s = xstr.replace('.','') +'/'+pstr
                     n = mpq_set_str(self.value, str_to_bytes(s), base)
@@ -1880,7 +1878,7 @@ cdef class Rational(sage.structure.element.FieldElement):
             return self
         a = self
         for p in S:
-            e, a = a.val_unit(p)
+            _, a = a.val_unit(p)
         return a
 
     def sqrt(self, prec=None, extend=True, all=False):
@@ -2044,10 +2042,9 @@ cdef class Rational(sage.structure.element.FieldElement):
             sage: RealField(200)(x)                                                     # needs sage.rings.real_mpfr
             3.1415094339622641509433962264150943396226415094339622641509
         """
-        cdef unsigned int alpha, beta
         d = self.denominator()
-        alpha, d = d.val_unit(2)
-        beta, d  = d.val_unit(5)
+        _, d = d.val_unit(2)
+        _, d  = d.val_unit(5)
         from sage.rings.finite_rings.integer_mod import Mod
         return Mod(10, d).multiplicative_order()
 
@@ -2810,7 +2807,7 @@ cdef class Rational(sage.structure.element.FieldElement):
             ...
             ArithmeticError: The inverse of 0 modulo 17 is not defined.
         """
-        cdef unsigned int num, den, a
+        cdef unsigned int num, den
 
         # Documentation from GMP manual:
         # "For the ui variants the return value is the remainder, and

src/sage/rings/ring_extension.pyx

@@ -479,16 +479,16 @@ class RingExtensionFactory(UniqueFactory):
             sage: RingExtension.create_object((8,9,0), key, **extra_args)
             Rational Field over its base
         """
-        defining_morphism, gens, names = key
+        defining_morphism, _, _ = key
         constructors = extra_args['constructors']
         if len(constructors) == 0:
             raise NotImplementedError("no constructor available for this extension")
-        for (constructor, kwargs) in constructors[:-1]:
+        for constructor, kwargs in constructors[:-1]:
             try:
                 return constructor(defining_morphism, **kwargs)
             except (NotImplementedError, ValueError, TypeError):
                 pass
-        (constructor, kwargs) = constructors[-1]
+        constructor, kwargs = constructors[-1]
         return constructor(defining_morphism, **kwargs)
 
 

src/sage/rings/ring_extension_morphism.pyx

@@ -835,20 +835,20 @@ cdef class MapRelativeRingToFreeModule(Map):
         # We compute the matrix of our isomorphism (over base)
         from sage.rings.ring_extension import common_base
         base = common_base(K, L, False)
-        EK, iK, jK = K.free_module(base, map=True)
-        EL, iL, jL = L.free_module(base, map=True)
+        EK, iK, _ = K.free_module(base, map=True)
+        _, _, jL = L.free_module(base, map=True)
 
         self._dimK = EK.dimension()
         self._iK = iK
         self._jL = jL
 
-        M = [ ]
+        M = []
         for x in self._basis:
             for v in EK.basis():
                 y = x * f(iK(v))
                 M.append(jL(y))
         from sage.matrix.matrix_space import MatrixSpace
-        self._matrix = MatrixSpace(base,len(M))(M).inverse_of_unit()
+        self._matrix = MatrixSpace(base, len(M))(M).inverse_of_unit()
 
     def is_injective(self):
         r"""

src/sage/rings/tate_algebra_element.pyx

@@ -1170,8 +1170,6 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
             sage: A(x + 2*x^2 + x^3, prec=5)
             ...00001*x^3 + ...00001*x + ...00010*x^2 + O(2^5 * <x, y>)
         """
-        base = self._parent.base_ring()
-        nvars = self._parent.ngens()
         vars = self._parent.variable_names()
         s = ""
         for t in self._terms_c():
@@ -1229,9 +1227,6 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
             sage: f._latex_()
             '...0000000001x^{3} + ...0000000001x + ...00000000010x^{2}'
         """
-        base = self._parent.base_ring()
-        nvars = self._parent.ngens()
-        vars = self._parent.variable_names()
         s = ""
         for t in self.terms():
             if t.valuation() >= self._prec:
@@ -1246,7 +1241,6 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
         if self._prec is not Infinity:
             if s != "":
                 s += " + "
-            sv = ",".join(vars)
             if self._prec == 0:
                 s += "O\\left(%s\\right)" % self._parent.integer_ring()._latex_()
             elif self._prec == 1:
@@ -1968,16 +1962,15 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
         parent = self._parent
         base = parent.base_ring()
         if base.is_field():
-            for (e,c) in self._poly.__repn.items():
+            for e, c in self._poly.__repn.items():
                 coeffs[e] = c << n
             ans._prec = self._prec + n
         else:
             field = base.fraction_field()
-            ngens = parent.ngens()
-            for (e,c) in self._poly.__repn.items():
+            for e, c in self._poly.__repn.items():
                 minval = ZZ(e.dotprod(<ETuple>parent._log_radii)).ceil()
                 coeffs[e] = field(base(c) >> (minval-n)) << minval
-            ans._prec = max(ZZ(0), self._prec + n)
+            ans._prec = max(ZZ.zero(), self._prec + n)
         ans._poly = PolyDict(coeffs, None)
         return ans
 
@@ -2453,12 +2446,10 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
             sage: f.valuation()
             -4
         """
-        cdef TateAlgebraTerm t
         cdef list terms = self._terms_c()
         if terms:
             return min(terms[0].valuation(), self._prec)
-        else:
-            return self._prec
+        return self._prec
 
     def precision_relative(self):
         """
@@ -3244,7 +3235,6 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
             divisors = [divisors]
             onedivisor = True
         A = _pushout_family(divisors, self._parent)
-        f = A(self)
         divisors = [A(d) for d in divisors]
         q, r = (<TateAlgebraElement>self)._quo_rem_c(divisors, quo, rem, False)
         if quo and onedivisor:

src/sage/rings/tate_algebra_ideal.pyx

@@ -432,7 +432,7 @@ def groebner_basis_buchberger(I, prec, py_integral):
          ...0000000001*x^2*y + ...1210121020 + O(3^10 * <x, y>),
          ...000000001*y^2 + ...210121020*x + O(3^9 * <x, y>)]
     """
-    cdef list gb, rgb, indices, ts, S = [ ]
+    cdef list gb, rgb, indices, S = [ ]
     cdef int i, j, l
     cdef TateAlgebraTerm ti, tj, t
     cdef TateAlgebraElement f, g, r, s
@@ -642,7 +642,6 @@ cdef TateAlgebraElement regular_reduce(sgb, TateAlgebraTerm s, TateAlgebraElemen
     cdef list terms = v._terms_c()
     cdef int index = 0
     cdef int i
-    cdef bint in_rem
 
     f = v._new_c()
     f._poly = PolyDict(v._poly.__repn, None)
@@ -872,7 +871,6 @@ def groebner_basis_pote(I, prec, verbose=0):
         # we add signatures
         sgb = [ (None, g) for g in gb if g ]
         # We compute initial J-pairs
-        l = len(sgb)
         p = (term_one, f.add_bigoh(prec))
         Jpairs = [ ]
         for P in sgb:
@@ -1159,7 +1157,6 @@ def groebner_basis_vapote(I, prec, verbose=0, interrupt_red_with_val=False, inte
         # we add signatures
         sgb = [ (None, g) for g in gb if g ]
         # We compute initial J-pairs
-        l = len(sgb)
         p = (term_one, f.add_bigoh(prec))
         Jpairs = [ ]
         for P in sgb: