sagemathgh-39683: spaces around modulo in combinat and rings
    
adding some space around `%` signs in a few cython files in combinat and
rings folders

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
    
URL: sagemath#39683
Reported by: Frédéric Chapoton
Reviewer(s): David Coudert

Author: Release Manager

src/sage/combinat/designs/evenly_distributed_sets.pyx

@@ -533,7 +533,7 @@ cdef class EvenlyDistributedSetsBacktracker:
                     x += 1
                 else:
                     kk += 1
-                    x += m - x%m
+                    x += m - x % m
             else:
                 x += 1
 
@@ -554,7 +554,7 @@ cdef class EvenlyDistributedSetsBacktracker:
                     if self.check:
                         self._check_cosets(kk)
                 elif self.cosets[x / m]:
-                    x += m - x%m
+                    x += m - x % m
                 elif kk == 2:
                     if self.min_orb[x] < x:
                         x += 1
@@ -649,12 +649,12 @@ cdef class EvenlyDistributedSetsBacktracker:
         c = 0
         for i in range(self.e):
             c += self.cosets[i]
-        if c != (kk * (kk-1)) / 2:
+        if 2 * c != (kk * (kk-1)):
             raise RuntimeError("the number of elements in cosets is wrong! Got {} instead of {}.".format(c, (kk*(kk-1))/2))
 
         for i in range(kk):
             for j in range(i):
                 if self.cosets[ self.diff[self.B[i]][self.B[j]] / m ] != 1:
-                    raise RuntimeError("self.cosets misses the difference B[{}]-B[{}]".format(i,j))
+                    raise RuntimeError("self.cosets misses the difference B[{}]-B[{}]".format(i, j))
 
         return 0

src/sage/combinat/designs/orthogonal_arrays_find_recursive.pyx

@@ -146,12 +146,13 @@ cpdef find_product_decomposition(int k, int n):
     """
     cdef int n1,n2
     for n1 in range(2, n):
-        n2 = n/n1  # n2 is decreasing along the loop
+        if n % n1:
+            # we want to iterate only through divisors of n1... it seems
+            # faster to use that rather than calling the divisors function
+            continue
+        n2 = n // n1  # n2 is decreasing along the loop
         if n2 < n1:
             break
-        if n%n1:  # we want to iterate only through divisors of n1... it seems
-                  # faster to use that rather than calling the divisors function
-            continue
         if is_available(k, n1) and is_available(k, n2):
             from sage.combinat.designs.orthogonal_arrays import wilson_construction
             return wilson_construction, (None,k,n1,n2,(),False)
@@ -187,11 +188,11 @@ cpdef find_wilson_decomposition_with_one_truncated_group(int k, int n):
     """
     cdef int r,u,m
     # If there exists a TD(k+1,t) then k+1 < t+2, i.e. k <= t
-    for r in range(max(1,k),n-1):
-        u = n%r
+    for r in range(max(1, k), n - 1):
+        u = n % r
         # We ensure that 1<=u, and that there can exists a TD(k,u), i.e k<u+2
         # (unless u == 1)
-        if u == 0 or (u>1 and k >= u+2):
+        if u == 0 or (u > 1 and k >= u + 2):
             continue
 
         m = n // r

src/sage/combinat/designs/subhypergraph_search.pyx

@@ -114,7 +114,7 @@ Methods
 #  Distributed under the terms of the GNU General Public License (GPL)
 #  as published by the Free Software Foundation; either version 2 of
 #  the License, or (at your option) any later version.
-#                  http://www.gnu.org/licenses/
+#                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
 from libc.stdlib cimport qsort
@@ -133,7 +133,7 @@ cdef inline int bs_get(uint64_t * bitset, int index) noexcept:
     r"""
     Return a bit of a bitset
     """
-    return (bitset[index//64]>>(index%64))&1
+    return (bitset[index // 64] >> (index % 64)) & 1
 
 cdef inline void bs_set(uint64_t * bitset, int index, int bit) noexcept:
     r"""
@@ -142,8 +142,8 @@ cdef inline void bs_set(uint64_t * bitset, int index, int bit) noexcept:
     "bit" *MUST* be equal to either 0 or to 1. The code does not involve any
     "if".
     """
-    bitset[index//64] &= ~((<uint64_t> 1)<<index%64)
-    bitset[index//64] |= (<uint64_t> bit)<<index%64
+    bitset[index // 64] &= ~((<uint64_t> 1) << index % 64)
+    bitset[index // 64] |= (<uint64_t> bit) << index % 64
 
 cdef inline int bs_issubset64(uint64_t * b1, uint64_t b2, int limbs) noexcept:
     r"""

src/sage/rings/fraction_field_element.pyx

@@ -519,13 +519,15 @@ cdef class FractionFieldElement(FieldElement):
         """
         if self.is_zero():
             return "0"
-        s = "%s" % self._numerator
+        s = str(self._numerator)
         if self._denominator != 1:
-            denom_string = str( self._denominator )
+            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)
+                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)
+                s = "%s/(%s)" % (self._numerator._coeff_repr(no_space=False),
+                                 denom_string)
         return s
 
     def _latex_(self):
@@ -563,8 +565,8 @@ cdef class FractionFieldElement(FieldElement):
             return "0"
         if self._denominator == 1:
             return latex.latex(self._numerator)
-        return "\\frac{%s}{%s}"%(latex.latex(self._numerator),
-                                 latex.latex(self._denominator))
+        return "\\frac{%s}{%s}" % (latex.latex(self._numerator),
+                                   latex.latex(self._denominator))
 
     def _magma_init_(self, magma):
         """

src/sage/rings/integer_ring.pyx

@@ -801,13 +801,14 @@ cdef class IntegerRing_class(CommutativeRing):
         cdef integer.Integer n_max, n_min, n_width
         cdef randstate rstate = current_randstate()
         cdef int den = rstate.c_random()-SAGE_RAND_MAX/2
-        if den == 0: den = 1
+        if den == 0:
+            den = 1
         if (distribution is None and x is None) or distribution == "1/n":
             mpz_set_si(value, (SAGE_RAND_MAX/5*2) / den)
         elif distribution is None or distribution == "uniform":
             if y is None:
                 if x is None:
-                    mpz_set_si(value, rstate.c_random()%5 - 2)
+                    mpz_set_si(value, rstate.c_random() % 5 - 2)
                 else:
                     n_max = x if isinstance(x, integer.Integer) else self(x)
                     mpz_urandomm(value, rstate.gmp_state, n_max.value)

src/sage/rings/laurent_series_ring_element.pyx

@@ -332,8 +332,7 @@ cdef class LaurentSeries(AlgebraElement):
         if self.is_zero():
             if self.prec() is infinity:
                 return "0"
-            else:
-                return "O(%s^%s)"%(self._parent.variable_name(),self.prec())
+            return "O(%s^%s)" % (self._parent.variable_name(), self.prec())
         s = " "
         v = self.__u.list()
         valuation = self.__n
@@ -349,28 +348,28 @@ cdef class LaurentSeries(AlgebraElement):
                 if not first:
                     s += " + "
                 if not atomic_repr and (x[1:].find("+") != -1 or x[1:].find("-") != -1):
-                    x = "(%s)"%x
+                    x = "(%s)" % x
                 if e == 1:
-                    var = "*%s"%X
+                    var = "*%s" % X
                 elif e == 0:
                     var = ""
                 else:
-                    var = "*%s^%s"%(X,e)
-                s += "%s%s"%(x,var)
+                    var = "*%s^%s" % (X, e)
+                s += "%s%s" % (x, var)
                 first = False
         s = s.replace(" + -", " - ")
         s = s.replace(" 1*"," ")
         s = s.replace(" -1*", " -")
         if self.prec() == 0:
             bigoh = "O(1)"
         elif self.prec() == 1:
-            bigoh = "O(%s)"%self._parent.variable_name()
+            bigoh = "O(%s)" % self._parent.variable_name()
         else:
-            bigoh = "O(%s^%s)"%(self._parent.variable_name(),self.prec())
+            bigoh = "O(%s^%s)" % (self._parent.variable_name(),self.prec())
         if self.prec() != infinity:
             if s == " ":
                 return bigoh
-            s += " + %s"%bigoh
+            s += " + %s" % bigoh
         return s[1:]
 
     def verschiebung(self, n):
@@ -472,20 +471,20 @@ cdef class LaurentSeries(AlgebraElement):
                 if not first:
                     s += " + "
                 if not atomic_repr and e > 0 and (x[1:].find("+") != -1 or x[1:].find("-") != -1):
-                    x = "\\left(%s\\right)"%x
+                    x = "\\left(%s\\right)" % x
                 if e == 1:
-                    var = "|%s"%X
+                    var = "|%s" % X
                 elif e == 0:
                     var = ""
                 elif e > 0:
-                    var = "|%s^{%s}"%(X,e)
+                    var = "|%s^{%s}" % (X, e)
                 if e >= 0:
-                    s += "%s%s"%(x,var)
+                    s += "%s%s" % (x, var)
                 else: # negative e
                     if e == -1:
-                        s += "\\frac{%s}{%s}"%(x, X)
+                        s += "\\frac{%s}{%s}" % (x, X)
                     else:
-                        s += "\\frac{%s}{%s^{%s}}"%(x, X,-e)
+                        s += "\\frac{%s}{%s^{%s}}" % (x, X, -e)
                 first = False
         s = s.replace(" + -", " - ")
         s = s.replace(" 1|"," ")
@@ -496,12 +495,12 @@ cdef class LaurentSeries(AlgebraElement):
             if pr == 0:
                 bigoh = "O(1)"
             elif pr == 1:
-                bigoh = "O(%s)"%(X,)
+                bigoh = "O(%s)" % (X,)
             else:
-                bigoh = "O(%s^{%s})"%(X,pr)
+                bigoh = "O(%s^{%s})" % (X, pr)
             if s == " ":
                 return bigoh
-            s += " + %s"%bigoh
+            s += " + %s" % bigoh
         return s[1:]
 
     def __hash__(self):

src/sage/rings/morphism.pyx

@@ -2098,9 +2098,9 @@ cdef class RingHomomorphism_from_base(RingHomomorphism):
         """
         RingHomomorphism.__init__(self, parent)
         if underlying.domain() != parent.domain().base():
-            raise ValueError("The given homomorphism has to have the domain %s"%parent.domain().base())
+            raise ValueError("The given homomorphism has to have the domain %s" % parent.domain().base())
         if underlying.codomain() != parent.codomain().base():
-            raise ValueError("The given homomorphism has to have the codomain %s"%parent.codomain().base())
+            raise ValueError("The given homomorphism has to have the codomain %s" % parent.codomain().base())
         if parent.domain().construction()[0] != parent.codomain().construction()[0]:
             raise ValueError(f"domain ({parent.domain()}) and codomain ({parent.codomain()}) must have the same functorial construction over their base rings")
         self._underlying = underlying

src/sage/rings/number_field/number_field_morphisms.pyx

@@ -237,12 +237,12 @@ cdef class EmbeddedNumberFieldMorphism(NumberFieldEmbedding):
         """
         if ambient_field is None:
             if K.coerce_embedding() is None:
-                raise TypeError("No embedding available for %s"%K)
+                raise TypeError("No embedding available for %s" % K)
             Kemb = K
             while Kemb.coerce_embedding() is not None:
                 Kemb = Kemb.coerce_embedding().codomain()
             if L.coerce_embedding() is None:
-                raise TypeError("No embedding available for %s"%L)
+                raise TypeError("No embedding available for %s" % L)
             Lemb = L
             while Lemb.coerce_embedding() is not None:
                 Lemb = Lemb.coerce_embedding().codomain()

src/sage/rings/number_field/totallyreal_data.pyx

@@ -851,7 +851,7 @@ cdef class tr_data:
                     self.a[k] = lrint(ceil(akmin))
                     self.amax[k] = lrint(floor(akmax))
 
-                    if self.a[n-1] == 0 and (n-k)%2 == 1:
+                    if self.a[n-1] == 0 and (n-k) % 2 == 1:
                         # Can replace alpha by -alpha, so if all
                         # "odd" coefficients are zero, may assume next
                         # "odd" coefficient is positive.

src/sage/rings/padics/common_conversion.pyx

@@ -156,7 +156,7 @@ cdef long get_ordp(x, PowComputer_class prime_pow) except? -10000:
             return maxordp
         k = mpz_remove(temp.value, value.value, prime_pow.prime.value)
     else:
-        raise NotImplementedError("Cannot determine p-adic valuation of an element of %s"%parent(x))
+        raise NotImplementedError("Cannot determine p-adic valuation of an element of %s" % parent(x))
     # Should check for overflow
     return k * e
 
@@ -228,7 +228,7 @@ cdef long get_preccap(x, PowComputer_class prime_pow) except? -10000:
         if mpz_cmp_ui(temp.value, 1) != 0:
             raise TypeError("cannot coerce from the given integer mod ring (not a power of the same prime)")
     else:
-        raise NotImplementedError("Cannot determine p-adic precision of an element of %s"%parent(x))
+        raise NotImplementedError("Cannot determine p-adic precision of an element of %s" % parent(x))
     return k * e
 
 cdef long comb_prec(iprec, long prec) except? -10000: