most cython-lint suggestions fixed in algebras/

Author: fchapoton

src/sage/algebras/lie_algebras/lie_algebra_element.pyx

@@ -17,7 +17,6 @@ AUTHORS:
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from copy import copy
 from cpython.object cimport Py_EQ, Py_NE, Py_GT, Py_GE
 
 from sage.misc.repr import repr_lincomb
@@ -119,9 +118,11 @@ cdef class LieAlgebraElement(IndexedFreeModuleElement):
             return s
         names = self.parent().variable_names()
         if base_map is None:
-            base_map = lambda x: x
+            def base_map(x):
+                return x
+
         return codomain.sum(base_map(c) * t._im_gens_(codomain, im_gens, names)
-                            for t, c in self._monomial_coefficients.iteritems())
+                            for t, c in self._monomial_coefficients.items())
 
     cpdef lift(self):
         """
@@ -166,10 +167,10 @@ cdef class LieAlgebraElement(IndexedFreeModuleElement):
         #   does not match the generators index set of the UEA.
         if hasattr(self._parent, '_UEA_names_map'):
             names_map = self._parent._UEA_names_map
-            for t, c in self._monomial_coefficients.iteritems():
+            for t, c in self._monomial_coefficients.items():
                 s += c * gen_dict[names_map[t]]
         else:
-            for t, c in self._monomial_coefficients.iteritems():
+            for t, c in self._monomial_coefficients.items():
                 s += c * gen_dict[t]
         return s
 
@@ -459,7 +460,7 @@ cdef class LieAlgebraElementWrapper(ElementWrapper):
              ((1,3,2), 1), ((1,3), 1)]
         """
         cdef dict d = self.value.monomial_coefficients(copy=False)
-        yield from d.iteritems()
+        yield from d.items()
 
 
 # TODO: Also used for vectors, find a better name
@@ -598,7 +599,8 @@ cdef class LieSubalgebraElementWrapper(LieAlgebraElementWrapper):
         if self._monomial_coefficients is None:
             sm = self.parent().module()
             v = sm.coordinate_vector(self.to_vector())
-            self._monomial_coefficients = {k: v[k] for k in range(len(v)) if v[k]}
+            self._monomial_coefficients = {k: v[k] for k in range(len(v))
+                                           if v[k]}
         if copy:
             return dict(self._monomial_coefficients)
         return self._monomial_coefficients
@@ -861,7 +863,7 @@ cdef class StructureCoefficientsElement(LieAlgebraMatrixWrapper):
         """
         UEA = self._parent.universal_enveloping_algebra()
         gens = UEA.gens()
-        return UEA.sum(c * gens[i] for i, c in self.value.iteritems())
+        return UEA.sum(c * gens[i] for i, c in self.value.items())
 
     cpdef dict monomial_coefficients(self, bint copy=True):
         """
@@ -878,7 +880,7 @@ cdef class StructureCoefficientsElement(LieAlgebraMatrixWrapper):
             {'x': 2, 'z': -3/2}
         """
         I = self._parent._indices
-        return {I[i]: v for i, v in self.value.iteritems()}
+        return {I[i]: v for i, v in self.value.items()}
 
     def __getitem__(self, i):
         """
@@ -1066,7 +1068,8 @@ cdef class UntwistedAffineLieAlgebraElement(Element):
             ( alpha[1] - alphacheck[1] + 2·-alpha[1] )⊗t⁰ + ( -alpha[1] )⊗t¹ + 3⋅c + -2⋅d
         """
         from sage.typeset.unicode_art import unicode_art, unicode_superscript
-        return self._repr_generic(unicode_art, unicode_art, lambda t: "t" + unicode_superscript(t),
+        return self._repr_generic(unicode_art, unicode_art,
+                                  lambda t: "t" + unicode_superscript(t),
                                   unicode_art('⋅'), unicode_art('⊗'))
 
     cpdef dict t_dict(self):
@@ -1269,7 +1272,7 @@ cdef class UntwistedAffineLieAlgebraElement(Element):
         """
         cdef dict d = {}
         for t, g in self._t_dict.items():
-            for k, c in g.monomial_coefficients(copy=False).iteritems():
+            for k, c in g.monomial_coefficients(copy=False).items():
                 d[k, t] = c
         if self._c_coeff:
             d['c'] = self._c_coeff
@@ -1437,7 +1440,7 @@ class FreeLieAlgebraElement(LieAlgebraElement):
         if not self:
             return s
         gen_dict = UEA.gens_dict()
-        for t, c in self._monomial_coefficients.iteritems():
+        for t, c in self._monomial_coefficients.items():
             s += c * t.lift(gen_dict)
         return s
 
@@ -1446,6 +1449,7 @@ class FreeLieAlgebraElement(LieAlgebraElement):
         Return ``self`` as a list of pairs ``(m, c)`` where ``m`` is a
         basis key (i.e., a key of one of the basis elements)
         and ``c`` is its coefficient.
+
         This list is sorted from highest to lowest degree.
 
         EXAMPLES::
@@ -1455,8 +1459,10 @@ class FreeLieAlgebraElement(LieAlgebraElement):
             sage: elt.list()
             [([x, y], -1), (x, 1)]
         """
-        k = lambda x: (-x[0]._grade, x[0]) if isinstance(x[0], GradedLieBracket) else (-1, x[0])
-        return sorted((<dict>self._monomial_coefficients).iteritems(), key=k)
+        def k(x):
+            y = x[0]
+            return (-y._grade, y) if isinstance(y, GradedLieBracket) else (-1, y)
+        return sorted((<dict>self._monomial_coefficients).items(), key=k)
 
     def _bracket_(self, y):
         """
@@ -1479,16 +1485,16 @@ class FreeLieAlgebraElement(LieAlgebraElement):
 
         cdef dict d = {}
         zero = self.base_ring().zero()
-        for ml, cl in self._monomial_coefficients.iteritems():  # The left monomials
-            for mr, cr in y._monomial_coefficients.iteritems():  # The right monomials
+        for ml, cl in self._monomial_coefficients.items():  # The left monomials
+            for mr, cr in y._monomial_coefficients.items():  # The right monomials
                 if ml == mr:
                     continue
                 if ml < mr:  # Make sure ml < mr
                     a, b = ml, mr
                 else:
                     a, b = mr, ml
                     cr = -cr
-                for b_elt, coeff in self.parent()._rewrite_bracket(a, b).iteritems():
+                for b_elt, coeff in self.parent()._rewrite_bracket(a, b).items():
                     d[b_elt] = d.get(b_elt, zero) + cl * cr * coeff
                     if d[b_elt] == zero:
                         del d[b_elt]

src/sage/algebras/quatalg/quaternion_algebra_cython.pyx

@@ -43,6 +43,7 @@ from sage.libs.flint.fmpz cimport fmpz_set_mpz
 from sage.libs.flint.fmpq cimport fmpq_canonicalise
 from sage.libs.flint.fmpq_mat cimport fmpq_mat_entry_num, fmpq_mat_entry_den, fmpq_mat_entry
 
+
 def integral_matrix_and_denom_from_rational_quaternions(v, reverse=False):
     r"""
     Given a list of rational quaternions, return matrix `A` over `\ZZ`
@@ -95,7 +96,6 @@ def integral_matrix_and_denom_from_rational_quaternions(v, reverse=False):
 
     # Now fill in each row x of A, multiplying it by q = d/denom(x)
     cdef mpz_t q
-    cdef mpz_t* row
     cdef mpz_t tmp
     mpz_init(q)
     mpz_init(tmp)
@@ -104,26 +104,27 @@ def integral_matrix_and_denom_from_rational_quaternions(v, reverse=False):
         mpz_fdiv_q(q, d.value, x.d)
         if reverse:
             mpz_mul(tmp, q, x.x)
-            A.set_unsafe_mpz(n-i-1,3,tmp)
+            A.set_unsafe_mpz(n-i-1, 3, tmp)
             mpz_mul(tmp, q, x.y)
-            A.set_unsafe_mpz(n-i-1,2,tmp)
+            A.set_unsafe_mpz(n-i-1, 2, tmp)
             mpz_mul(tmp, q, x.z)
-            A.set_unsafe_mpz(n-i-1,1,tmp)
+            A.set_unsafe_mpz(n-i-1, 1, tmp)
             mpz_mul(tmp, q, x.w)
-            A.set_unsafe_mpz(n-i-1,0,tmp)
+            A.set_unsafe_mpz(n-i-1, 0, tmp)
         else:
             mpz_mul(tmp, q, x.x)
-            A.set_unsafe_mpz(i,0,tmp)
+            A.set_unsafe_mpz(i, 0, tmp)
             mpz_mul(tmp, q, x.y)
-            A.set_unsafe_mpz(i,1,tmp)
+            A.set_unsafe_mpz(i, 1, tmp)
             mpz_mul(tmp, q, x.z)
-            A.set_unsafe_mpz(i,2,tmp)
+            A.set_unsafe_mpz(i, 2, tmp)
             mpz_mul(tmp, q, x.w)
-            A.set_unsafe_mpz(i,3,tmp)
+            A.set_unsafe_mpz(i, 3, tmp)
     mpz_clear(q)
     mpz_clear(tmp)
     return A, d
 
+
 def rational_matrix_from_rational_quaternions(v, reverse=False):
     r"""
     Return matrix over the rationals whose rows have entries the
@@ -165,7 +166,7 @@ def rational_matrix_from_rational_quaternions(v, reverse=False):
             fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, n-i-1, 1), x.z)
             fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, n-i-1, 0), x.w)
 
-            if mpz_cmp_si(x.d,1):
+            if mpz_cmp_si(x.d, 1):
                 for j in range(4):
                     fmpz_set_mpz(fmpq_mat_entry_den(A._matrix, n-i-1, j), x.d)
                     fmpq_canonicalise(fmpq_mat_entry(A._matrix, n-i-1, j))
@@ -177,13 +178,14 @@ def rational_matrix_from_rational_quaternions(v, reverse=False):
             fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, i, 2), x.z)
             fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, i, 3), x.w)
 
-            if mpz_cmp_si(x.d,1):
+            if mpz_cmp_si(x.d, 1):
                 for j in range(4):
                     fmpz_set_mpz(fmpq_mat_entry_den(A._matrix, i, j), x.d)
                     fmpq_canonicalise(fmpq_mat_entry(A._matrix, i, j))
 
     return A
 
+
 def rational_quaternions_from_integral_matrix_and_denom(A, Matrix_integer_dense H, Integer d, reverse=False):
     r"""
     Given an integral matrix and denominator, returns a list of
@@ -221,7 +223,7 @@ def rational_quaternions_from_integral_matrix_and_denom(A, Matrix_integer_dense
     cdef Integer a, b
     a = Integer(A.invariants()[0])
     b = Integer(A.invariants()[1])
-    cdef Py_ssize_t i, j
+    cdef Py_ssize_t i
     cdef mpz_t tmp
     mpz_init(tmp)
 
@@ -236,26 +238,26 @@ def rational_quaternions_from_integral_matrix_and_denom(A, Matrix_integer_dense
         mpz_set(x.a, a.value)
         mpz_set(x.b, b.value)
         if reverse:
-            H.get_unsafe_mpz(i,3,tmp)
+            H.get_unsafe_mpz(i, 3, tmp)
             mpz_init_set(x.x, tmp)
-            H.get_unsafe_mpz(i,2,tmp)
+            H.get_unsafe_mpz(i, 2, tmp)
             mpz_init_set(x.y, tmp)
-            H.get_unsafe_mpz(i,1,tmp)
+            H.get_unsafe_mpz(i, 1, tmp)
             mpz_init_set(x.z, tmp)
-            H.get_unsafe_mpz(i,0,tmp)
+            H.get_unsafe_mpz(i, 0, tmp)
             mpz_init_set(x.w, tmp)
         else:
-            H.get_unsafe_mpz(i,0,tmp)
+            H.get_unsafe_mpz(i, 0, tmp)
             mpz_init_set(x.x, tmp)
-            H.get_unsafe_mpz(i,1,tmp)
+            H.get_unsafe_mpz(i, 1, tmp)
             mpz_init_set(x.y, tmp)
-            H.get_unsafe_mpz(i,2,tmp)
+            H.get_unsafe_mpz(i, 2, tmp)
             mpz_init_set(x.z, tmp)
-            H.get_unsafe_mpz(i,3,tmp)
+            H.get_unsafe_mpz(i, 3, tmp)
             mpz_init_set(x.w, tmp)
         mpz_init_set(x.d, d.value)
-        # WARNING -- we do *not* canonicalize the entries in the quaternion.  This is
-        # I think _not_ needed for quaternion_element.pyx
+        # WARNING -- we do *not* canonicalize the entries in the quaternion.
+        # This is I think _not_ needed for quaternion_element.pyx
         v.append(x)
     mpz_clear(tmp)
     return v