fix indentation E111 in some pyx files

Author: fchapoton

src/sage/arith/multi_modular.pyx

@@ -116,7 +116,7 @@ cdef class MultiModularBasis_base(object):
         """
         sig_free(self.moduli)
         for i in range(self.n):
-           mpz_clear(self.partial_products[i])
+            mpz_clear(self.partial_products[i])
         sig_free(self.partial_products)
         sig_free(self.C)
         mpz_clear(self.product)
@@ -487,9 +487,9 @@ cdef class MultiModularBasis_base(object):
         count = self.n * mpz_sizeinbase(height, 2) / mpz_sizeinbase(self.partial_products[self.n-1], 2) # an estimate
         count = max(min(count, self.n), 1)
         while count > 1 and mpz_cmp(height, self.partial_products[count-1]) < 0:
-           count -= 1
+            count -= 1
         while mpz_cmp(height, self.partial_products[count-1]) > 0:
-           count += 1
+            count += 1
 
         return count
 

src/sage/categories/action.pyx

@@ -304,7 +304,7 @@ cdef class Action(Functor):
         return S
 
     def codomain(self):
-       return self.underlying_set()
+        return self.underlying_set()
 
     def domain(self):
         return self.underlying_set()
@@ -454,7 +454,7 @@ cdef class PrecomposedAction(Action):
         if right_precomposition is not None:
             rco = right_precomposition._codomain
             if rco is not right:
-              right_precomposition = homset.Hom(rco, right).natural_map() * right_precomposition
+                right_precomposition = homset.Hom(rco, right).natural_map() * right_precomposition
             right = right_precomposition.domain()
         if action._is_left:
             Action.__init__(self, left, US, 1)

src/sage/combinat/degree_sequences.pyx

@@ -441,24 +441,25 @@ cdef init(int n):
     return sequences
 
 cdef inline add_seq():
-     """
-     This function is called whenever a sequence is found.
+    """
+    This function is called whenever a sequence is found.
+
+    Build the degree sequence corresponding to the current state of the
+    algorithm and adds it to the sequences list.
+    """
+    global sequences
+    global N
+    global seq
 
-     Build the degree sequence corresponding to the current state of the
-     algorithm and adds it to the sequences list.
-     """
-     global sequences
-     global N
-     global seq
+    cdef list s = []
+    cdef int i, j
 
-     cdef list s = []
-     cdef int i, j
+    for N > i >= 0:
+        for 0 <= j < seq[i]:
+            s.append(i)
 
-     for N > i >= 0:
-         for 0<= j < seq[i]:
-             s.append(i)
+    sequences.append(s)
 
-     sequences.append(s)
 
 cdef void enum(int k, int M):
     r"""

src/sage/ext/fast_callable.pyx

@@ -1481,55 +1481,56 @@ cdef class ExpressionChoice(Expression):
                                        repr(self._iffalse))
 
 cpdef _expression_binop_helper(s, o, op):
-   r"""
-   Make an Expression for (s op o).  Either s or o (or both) must already
-   be an expression.
-
-   EXAMPLES::
-
-       sage: from sage.ext.fast_callable import _expression_binop_helper, ExpressionTreeBuilder
-       sage: var('x,y')
-       (x, y)
-       sage: etb = ExpressionTreeBuilder(vars=(x,y))
-       sage: x = etb(x)
-
-   Now x is an Expression, but y is not.  Still, all the following
-   cases work::
-
-       sage: _expression_binop_helper(x, x, operator.add)
-       add(v_0, v_0)
-       sage: _expression_binop_helper(x, y, operator.add)
-       add(v_0, v_1)
-       sage: _expression_binop_helper(y, x, operator.add)
-       add(v_1, v_0)
-
-   """
-   # The Cython way of handling operator overloading on cdef classes
-   # (which is inherited from Python) is quite annoying.  Inside the
-   # code for a binary operator, you know that either the first or
-   # second argument (or both) is a member of your class, but you
-   # don't know which.
-
-   # If there is an arithmetic operator between an Expression and
-   # a non-Expression, I want to convert the non-Expression into
-   # an Expression.  But to do that, I need the ExpressionTreeBuilder
-   # from the Expression.
-
-   cdef Expression self
-   cdef Expression other
-
-   if not isinstance(o, Expression):
-       self = s
-       other = self._etb(o)
-   elif not isinstance(s, Expression):
-       other = o
-       self = other._etb(s)
-   else:
-       self = s
-       other = o
-       assert self._etb is other._etb
-
-   return ExpressionCall(self._etb, op, [self, other])
+    r"""
+    Make an Expression for (s op o).  Either s or o (or both) must already
+    be an expression.
+
+    EXAMPLES::
+
+        sage: from sage.ext.fast_callable import _expression_binop_helper, ExpressionTreeBuilder
+        sage: var('x,y')
+        (x, y)
+        sage: etb = ExpressionTreeBuilder(vars=(x,y))
+        sage: x = etb(x)
+
+    Now x is an Expression, but y is not.  Still, all the following
+    cases work::
+
+        sage: _expression_binop_helper(x, x, operator.add)
+        add(v_0, v_0)
+        sage: _expression_binop_helper(x, y, operator.add)
+        add(v_0, v_1)
+        sage: _expression_binop_helper(y, x, operator.add)
+        add(v_1, v_0)
+
+    """
+    # The Cython way of handling operator overloading on cdef classes
+    # (which is inherited from Python) is quite annoying.  Inside the
+    # code for a binary operator, you know that either the first or
+    # second argument (or both) is a member of your class, but you
+    # don't know which.
+
+    # If there is an arithmetic operator between an Expression and
+    # a non-Expression, I want to convert the non-Expression into
+    # an Expression.  But to do that, I need the ExpressionTreeBuilder
+    # from the Expression.
+
+    cdef Expression self
+    cdef Expression other
+
+    if not isinstance(o, Expression):
+        self = s
+        other = self._etb(o)
+    elif not isinstance(s, Expression):
+        other = o
+        self = other._etb(s)
+    else:
+        self = s
+        other = o
+        assert self._etb is other._etb
+
+    return ExpressionCall(self._etb, op, [self, other])
+
 
 class IntegerPowerFunction(object):
     r"""

src/sage/graphs/bliss.pyx

@@ -861,15 +861,16 @@ cdef Graph *bliss_graph(G, partition, vert2int, int2vert):
         vert2int[v] = i
         int2vert[i] = v
 
-    for x,y in G.edge_iterator(labels=False):
-       g.add_edge(vert2int[x], vert2int[y])
+    for x, y in G.edge_iterator(labels=False):
+        g.add_edge(vert2int[x], vert2int[y])
 
     if partition:
         for i in range(1, len(partition)):
             for v in partition[i]:
                 g.change_color(vert2int[v], i)
     return g
 
+
 cdef Digraph *bliss_digraph(G, partition, vert2int, int2vert):
     r"""
     Return a bliss copy of a digraph G

src/sage/graphs/distances_all_pairs.pyx

@@ -591,7 +591,7 @@ def is_distance_regular(G, parameters=False):
     for u in range(n):
         for v in range(n):
             if u == v:
-               continue
+                continue
 
             d = distance_matrix[u * n + v]
             if d == infinity:

src/sage/graphs/graph_coloring.pyx

@@ -1190,7 +1190,7 @@ def b_coloring(g, k, value_only=True, solver=None, verbose=0,
 
     # a color class is used if and only if it has one b-vertex
     for i in range(k):
-       p.add_constraint(p.sum(b[w,i] for w in g) - is_used[i], min=0, max=0)
+        p.add_constraint(p.sum(b[w,i] for w in g) - is_used[i], min=0, max=0)
 
 
     # We want to maximize the number of used colors

src/sage/graphs/strongly_regular_db.pyx

@@ -1341,7 +1341,7 @@ def is_unitary_dual_polar(int v,int k,int l,int mu):
     if p**t != q or t % 2:
         return
     if (r < 0 and q != -r - 1) or (s < 0 and q != -s - 1):
-       return
+        return
     t //= 2
     # we have correct mu, negative eigenvalue, and q=p^(2t)
     if (v == (q**2*p**t + 1)*(q*p**t + 1)  and

src/sage/graphs/trees.pyx

@@ -229,9 +229,9 @@ cdef class TreeIterator:
         if p <= h1:
             h1 = p - 1
         if p <= r:
-           needr = 1
+            needr = 1
         elif p <= h2:
-           needh2 = 1
+            needh2 = 1
         elif l[h2 - 1] == l[h1 - 1] - 1 and n - h2 == r - h1:
             if p <= c:
                 needc = 1

src/sage/interacts/library_cython.pyx

@@ -40,10 +40,12 @@ cpdef julia(ff_j, z, int iterations):
         1.0 + 3.0*I
     """
     for i in range(iterations):
-         z = ff_j(z)
-         if z.abs() > 2: break
+        z = ff_j(z)
+        if z.abs() > 2:
+            break
     return z
 
+
 cpdef mandel(ff_m, z, int iterations):
     """
     Helper function for the Mandelbrot Fractal interact example.