cylint: some fixes in combinat/(crystals,matrices,words)

Author: fchapoton

src/sage/combinat/crystals/letters.pyx

@@ -319,6 +319,7 @@ class ClassicalCrystalOfLetters(UniqueRepresentation, Parent):
     # temporary workaround while an_element is overridden by Parent
     _an_element_ = EnumeratedSets.ParentMethods._an_element_
 
+
 # Utility. Note: much of this class should be factored out at some point!
 cdef class Letter(Element):
     r"""
@@ -2571,6 +2572,7 @@ class CrystalOfBKKLetters(ClassicalCrystalOfLetters):
 
     Element = BKKLetter
 
+
 #################
 # Type q(n) queer
 #################
@@ -2981,6 +2983,7 @@ cdef class LetterWrapped(Element):
         """
         return self.value.phi(i)
 
+
 class ClassicalCrystalOfLettersWrapped(ClassicalCrystalOfLetters):
     r"""
     Crystal of letters by wrapping another crystal.

src/sage/combinat/crystals/pbw_datum.pxd

@@ -1,4 +1,3 @@
 cpdef tuple compute_new_lusztig_datum(list enhanced_braid_chain, initial_lusztig_datum)
 cpdef tuple tropical_plucker_relation(tuple a, lusztig_datum)
 cpdef list enhance_braid_move_chain(braid_move_chain, cartan_type)
-

src/sage/combinat/crystals/pbw_datum.pyx

@@ -30,6 +30,7 @@ from sage.combinat.root_system.braid_move_calculator import BraidMoveCalculator
 
 cimport cython
 
+
 class PBWDatum():
     """
     Helper class which represents a PBW datum.
@@ -277,7 +278,8 @@ class PBWData(): # UniqueRepresentation?
         w0 = self.weyl_group.long_element()
         return tuple([i] + (si * w0).reduced_word())
 
-#enhanced_braid_chain is an ugly data structure.
+
+# enhanced_braid_chain is an ugly data structure.
 @cython.boundscheck(False)
 @cython.wraparound(False)
 cpdef tuple compute_new_lusztig_datum(list enhanced_braid_chain, initial_lusztig_datum):
@@ -314,17 +316,18 @@ cpdef tuple compute_new_lusztig_datum(list enhanced_braid_chain, initial_lusztig
     """
     cdef tuple interval_of_change
     # Does not currently check that len(initial_lusztig_datum) is appropriate
-    cdef list new_lusztig_datum = list(initial_lusztig_datum) #shallow copy
+    cdef list new_lusztig_datum = list(initial_lusztig_datum)  # shallow copy
     cdef int i
     for i in range(1, len(enhanced_braid_chain)):
         interval_of_change, type_data = enhanced_braid_chain[i]
-        a,b = interval_of_change
+        a, b = interval_of_change
         old_interval_datum = new_lusztig_datum[a:b]
         new_interval_datum = tropical_plucker_relation(type_data, old_interval_datum)
         new_lusztig_datum[a:b] = new_interval_datum
     return tuple(new_lusztig_datum)
 
-# The tropical plucker relations
+
+# The tropical Plücker relations
 @cython.boundscheck(False)
 @cython.wraparound(False)
 cpdef tuple tropical_plucker_relation(tuple a, lusztig_datum):
@@ -395,6 +398,7 @@ cpdef tuple tropical_plucker_relation(tuple a, lusztig_datum):
         return tuple(reversed(tropical_plucker_relation((a[1], a[0]),
                                                         reversed_lusztig_datum)))
 
+
 # Maybe we need to be more specific, and pass not the Cartan type, but the root lattice?
 # TODO: Move to PBW_data?
 @cython.boundscheck(False)

src/sage/combinat/crystals/spins.pxd

@@ -18,4 +18,3 @@ cdef class Spin_crystal_type_D_element(Spin):
     cpdef Spin f(self, int i)
     cpdef int epsilon(self, int i)
     cpdef int phi(self, int i)
-

src/sage/combinat/crystals/spins.pyx

@@ -99,6 +99,7 @@ def CrystalOfSpins(ct):
     else:
         raise NotImplementedError
 
+
 #########################
 # Type D spins
 #########################
@@ -135,6 +136,7 @@ def CrystalOfSpinsPlus(ct):
     else:
         raise NotImplementedError
 
+
 def CrystalOfSpinsMinus(ct):
     r"""
     Return the minus spin crystal of the given type D.
@@ -168,6 +170,7 @@ def CrystalOfSpinsMinus(ct):
     else:
         raise NotImplementedError
 
+
 class GenericCrystalOfSpins(UniqueRepresentation, Parent):
     """
     A generic crystal of spins.
@@ -181,11 +184,11 @@ class GenericCrystalOfSpins(UniqueRepresentation, Parent):
         """
         self._cartan_type = CartanType(ct)
         if case == "spins":
-            self.rename("The crystal of spins for type %s"%ct)
+            self.rename("The crystal of spins for type %s" % ct)
         elif case == "plus":
-            self.rename("The plus crystal of spins for type %s"%ct)
+            self.rename("The plus crystal of spins for type %s" % ct)
         else:
-            self.rename("The minus crystal of spins for type %s"%ct)
+            self.rename("The minus crystal of spins for type %s" % ct)
 
         self.Element = element_class
         Parent.__init__(self, category=ClassicalCrystals())
@@ -250,6 +253,7 @@ class GenericCrystalOfSpins(UniqueRepresentation, Parent):
             raise ValueError("both elements must be in this crystal")
         return self._digraph_closure.has_edge(x, y)
 
+
 cdef class Spin(Element):
     """
     A spin letter in the crystal of spins.

src/sage/combinat/crystals/tensor_product_element.pxd

@@ -32,4 +32,3 @@ cdef class InfinityQueerCrystalOfTableauxElement(TensorProductOfQueerSuperCrysta
     cdef list _row_lengths
 
 cdef Py_ssize_t count_leading(list row, letter)
-

src/sage/combinat/crystals/tensor_product_element.pyx

@@ -1158,7 +1158,7 @@ cdef class InfinityCrystalOfTableauxElementTypeD(InfinityCrystalOfTableauxElemen
         return ret
 
 #####################################################################
-## BKK crystal elements
+#  BKK crystal elements
 
 cdef class TensorProductOfSuperCrystalsElement(TensorProductOfRegularCrystalsElement):
     r"""
@@ -1405,7 +1405,7 @@ cdef class CrystalOfBKKTableauxElement(TensorProductOfSuperCrystalsElement):
         return Tableau(tab).conjugate()
 
 #####################################################################
-## Queer crystal elements
+#  Queer crystal elements
 
 cdef class TensorProductOfQueerSuperCrystalsElement(TensorProductOfRegularCrystalsElement):
     r"""

src/sage/combinat/matrices/dancing_links.pyx

@@ -330,7 +330,6 @@ cdef class dancing_linksWrapper:
         """
         return PyObject_RichCompare(left._rows, right._rows, op)
 
-
     def get_solution(self):
         """
         Return the current solution.
@@ -473,7 +472,7 @@ cdef class dancing_linksWrapper:
         from copy import copy
         rows = copy(self._rows)
         ncols = self.ncols()
-        for i,row_index in enumerate(indices):
+        for i, row_index in enumerate(indices):
             # in the line below we want the creation of a new list
             rows[row_index] = rows[row_index] + [ncols+i]
         return dlx_solver(rows)
@@ -546,8 +545,8 @@ cdef class dancing_linksWrapper:
         if not 0 <= column < self.ncols():
             raise ValueError("column(={}) must be in range(ncols) "
                              "where ncols={}".format(column, self.ncols()))
-        indices = [i for (i,row) in enumerate(self._rows) if column in row]
-        return {i:self.restrict([i]) for i in indices}
+        indices = (i for i, row in enumerate(self._rows) if column in row)
+        return {i: self.restrict([i]) for i in indices}
 
     def solutions_iterator(self):
         r"""
@@ -792,7 +791,7 @@ cdef class dancing_linksWrapper:
                 L.append(dlx.get_solution())
             return L
 
-        indices = [i for (i,row) in enumerate(self._rows) if column in row]
+        indices = [i for i, row in enumerate(self._rows) if column in row]
         L = []
         for (args_kwds, val) in all_solutions(indices):
             L.extend(val)
@@ -892,7 +891,7 @@ cdef class dancing_linksWrapper:
                 N += 1
             return N
 
-        indices = [i for (i,row) in enumerate(self._rows) if column in row]
+        indices = [i for i, row in enumerate(self._rows) if column in row]
         return sum(val for (args_kwds, val) in nb_sol(indices))
 
     @cached_method
@@ -935,7 +934,7 @@ cdef class dancing_linksWrapper:
         # Note that row number i is associated to SAT variable i+1 to
         # avoid a variable zero
         columns = [[] for _ in range(self.ncols())]
-        for i,row in enumerate(self.rows(), start=1):
+        for i, row in enumerate(self.rows(), start=1):
             for a in row:
                 columns[a].append(i)
 
@@ -946,8 +945,8 @@ cdef class dancing_linksWrapper:
         # At most one 1 in each column
         import itertools
         for clause in columns:
-            for p,q in itertools.combinations(clause, 2):
-                sub_clause = [-p,-q]
+            for p, q in itertools.combinations(clause, 2):
+                sub_clause = [-p, -q]
                 s.add_clause(sub_clause)
 
         return s
@@ -995,13 +994,12 @@ cdef class dancing_linksWrapper:
             sage: d = dlx_solver(rows)
             sage: d.one_solution_using_sat_solver() is None
             True
-
         """
         sat_solver = self.to_sat_solver(solver)
         solution = sat_solver()
         if not solution:
             return None
-        return [key for (key,val) in enumerate(solution, start=-1) if val]
+        return [key for key, val in enumerate(solution, start=-1) if val]
 
     @cached_method
     def to_milp(self, solver=None):
@@ -1123,18 +1121,17 @@ cdef class dancing_linksWrapper:
             sage: d = dlx_solver(rows)
             sage: d.one_solution_using_milp_solver() is None
             True
-
         """
         from sage.numerical.mip import MIPSolverException
-        p,x = self.to_milp(solver)
+        p, x = self.to_milp(solver)
         try:
             p.solve()
         except MIPSolverException:
             return None
-        else:
-            soln = p.get_values(x, convert=bool, tolerance=integrality_tolerance)
-            support = sorted(key for key in soln if soln[key])
-            return support
+
+        soln = p.get_values(x, convert=bool, tolerance=integrality_tolerance)
+        return sorted(key for key in soln if soln[key])
+
 
 def dlx_solver(rows):
     """

src/sage/combinat/words/word_char.pyx

@@ -32,6 +32,7 @@ import itertools
 # the maximum value of a size_t
 cdef size_t SIZE_T_MAX = -(<size_t> 1)
 
+
 def reversed_word_iterator(WordDatatype_char w):
     r"""
     This function exists only because it is not possible to use yield in the
@@ -48,6 +49,7 @@ def reversed_word_iterator(WordDatatype_char w):
     for i in range(w._length-1, -1, -1):
         yield w._data[i]
 
+
 cdef class WordDatatype_char(WordDatatype):
     r"""
     A Fast class for words represented by an array ``unsigned char *``.
@@ -361,7 +363,7 @@ cdef class WordDatatype_char(WordDatatype):
         """
         cdef Py_ssize_t i, start, stop, step, slicelength
         cdef unsigned char * data
-        cdef size_t j,k
+        cdef size_t j, k
         if isinstance(key, slice):
             # here the key is a slice
             PySlice_GetIndicesEx(key,
@@ -374,7 +376,7 @@ cdef class WordDatatype_char(WordDatatype):
                 return self._new_c(self._data+start, stop-start, self)
             data = <unsigned char *>check_allocarray(slicelength, sizeof(unsigned char))
             j = 0
-            for k in range(start,stop,step):
+            for k in range(start, stop, step):
                 data[j] = self._data[k]
                 j += 1
             return self._new_c(data, slicelength, None)
@@ -392,7 +394,7 @@ cdef class WordDatatype_char(WordDatatype):
 
     def __iter__(self):
         r"""
-        Iterator over the letter of self
+        Iterator over the letters of ``self``.
 
         EXAMPLES::
 
@@ -406,7 +408,7 @@ cdef class WordDatatype_char(WordDatatype):
 
     def __reversed__(self):
         r"""
-        Reversed iterator over the letter of self
+        Reversed iterator over the letters of ``self``.
 
         EXAMPLES::
 

src/sage/combinat/words/word_datatypes.pxd

@@ -1,4 +1,3 @@
 cdef class WordDatatype():
     cdef public _parent
     cdef _hash
-