convert some loops in groups to python-style

src/sage/groups/perm_gps/partn_ref/canonical_augmentation.pyx

@@ -323,7 +323,7 @@ cdef canonical_generator_data *allocate_cgd(int max_depth, int degree) noexcept:
 
     cdef int i
     cgd.allocd_levels = max_depth
-    for i from 0 <= i < max_depth:
+    for i in range(max_depth):
         cgd.agcl_work_spaces[i]    = NULL
         cgd.dc_work_spaces[i]      = NULL
         cgd.aut_gp_stack[i]        = NULL
@@ -347,7 +347,7 @@ cdef void deallocate_cgd(canonical_generator_data *cgd) noexcept:
     if cgd is NULL:
         return
     cdef int i
-    for i from 0 <= i < cgd.allocd_levels:
+    for i in range(cgd.allocd_levels):
         if cgd.agcl_work_spaces[i] is not NULL:
             deallocate_agcl_work_space(cgd.agcl_work_spaces[i])
         if cgd.ps_stack[i] is not NULL:

src/sage/groups/perm_gps/partn_ref/refinement_lists.pyx

@@ -46,15 +46,15 @@ def is_isomorphic(self, other):
         sig_free(ordering)
         sig_free(output)
         raise MemoryError
-    for i from 0 <= i < (len(self)):
+    for i in range(len(self)):
         ordering[i] = i
 
     cdef bint isomorphic = double_coset(<void *> self, <void *> other, part, ordering, (len(self)), &all_list_children_are_equivalent, &refine_list, &compare_lists, NULL, NULL, output)
 
     PS_dealloc(part)
     sig_free(ordering)
     if isomorphic:
-        output_py = [output[i] for i from 0 <= i < (len(self))]
+        output_py = [output[i] for i in range(len(self))]
     else:
         output_py = False
     sig_free(output)

src/sage/groups/perm_gps/partn_ref/refinement_matrices.pyx

@@ -190,9 +190,9 @@ cdef class MatrixStruct:
         cdef Integer order
         if self.output is NULL:
             self.run()
-        generators = []
-        for i in range(self.output.num_gens):
-            generators.append([self.output.generators[i*self.degree + j] for j from 0 <= j < self.degree])
+        generators = [[self.output.generators[i * self.degree + j]
+                       for j in range(self.degree)]
+                      for i in range(self.output.num_gens)]
         order = Integer()
         SC_order(self.output.group, 0, order.value)
         base = [self.output.group.base_orbits[i][0] for i in range(self.output.group.base_size)]
@@ -344,7 +344,7 @@ def random_tests(n=10, nrows_max=50, ncols_max=50, nsymbols_max=10, perms_per_ma
         for i in range(perms_per_matrix):
             perm = [a-1 for a in list(S.random_element())]
             NN = matrix(GF(nsymbols), nrows, ncols)
-            for j from 0 <= j < ncols:
+            for j in range(ncols):
                 NN.set_column(perm[j], MM.column(j))
             N = MatrixStruct(NN)
             # now N is a random permutation of M
@@ -356,7 +356,7 @@ def random_tests(n=10, nrows_max=50, ncols_max=50, nsymbols_max=10, perms_per_ma
             M_C = matrix(GF(nsymbols), nrows, ncols)
             N_C = matrix(GF(nsymbols), nrows, ncols)
 
-            for j from 0 <= j < ncols:
+            for j in range(ncols):
                 M_C.set_column(M_relab[j], MM.column(j))
                 N_C.set_column(N_relab[j], NN.column(j))
 

src/sage/groups/perm_gps/partn_ref/refinement_python.pyx

@@ -200,7 +200,7 @@ cdef class PythonPartitionStack:
             [7, 7, 7, 7, 7, 7, -1]
         """
         cdef int i
-        return [self.c_ps.entries[i] for i from 0 <= i < self.c_ps.degree]
+        return [self.c_ps.entries[i] for i in range(self.c_ps.degree)]
 
     def set_entry(self, int i, int entry):
         """
@@ -230,7 +230,7 @@ cdef class PythonPartitionStack:
         """
         return self.c_ps.entries[i]
 
-    def levels(self):
+    def levels(self) -> list:
         """
         Return the levels array as a Python list of ints.
 
@@ -243,7 +243,7 @@ cdef class PythonPartitionStack:
             sage: P.levels()
             [7, 7, 7, 7, 7, 7, -1]
         """
-        return [self.c_ps.levels[i] for i from 0 <= i < self.c_ps.degree]
+        return [self.c_ps.levels[i] for i in range(self.c_ps.degree)]
 
     def set_level(self, int i, int level):
         """
@@ -325,7 +325,7 @@ cdef class PythonPartitionStack:
         """
         cdef int i
         cdef list partition = [], cell = []
-        for i from 0 <= i < self.c_ps.degree:
+        for i in range(self.c_ps.degree):
             cell.append(self.c_ps.entries[i])
             if self.c_ps.levels[i] <= k:
                 partition.append(cell)
@@ -387,7 +387,7 @@ cdef int refine_and_return_invariant_python(PartitionStack *PS, void *S, int *ce
     cdef object S_obj = <object> S
     PS_copy_from_to(PS, Py_PS.c_ps)
     cdef int i
-    cdef list ctrb_py = [cells_to_refine_by[i] for i from 0 <= i < ctrb_len]
+    cdef list ctrb_py = [cells_to_refine_by[i] for i in range(ctrb_len)]
     return S_obj.rari_fn(Py_PS, S_obj.obj, ctrb_py)
 
 cdef int compare_structures_python(int *gamma_1, int *gamma_2, void *S1, void *S2, int degree) noexcept:
@@ -396,8 +396,8 @@ cdef int compare_structures_python(int *gamma_1, int *gamma_2, void *S1, void *S
     """
     cdef int i
     cdef object S1_obj = <object> S1, S2_obj = <object> S2
-    cdef list gamma_1_py = [gamma_1[i] for i from 0 <= i < degree]
-    cdef list gamma_2_py = [gamma_2[i] for i from 0 <= i < degree]
+    cdef list gamma_1_py = [gamma_1[i] for i in range(degree)]
+    cdef list gamma_2_py = [gamma_2[i] for i in range(degree)]
     return S1_obj.cs_fn(gamma_1_py, gamma_2_py, S1_obj.obj, S2_obj.obj, degree)
 
 
@@ -473,7 +473,8 @@ def aut_gp_and_can_lab_python(S, partition, n,
     if canonical_label:
         return_tuple.append([output.relabeling[i] for i in range(n)])
     if base:
-        return_tuple.append([output.group.base_orbits[i][0] for i from 0 <= i < output.group.base_size])
+        return_tuple.append([output.group.base_orbits[i][0]
+                             for i in range(output.group.base_size)])
     if order:
         I = Integer()
         SC_order(output.group, 0, I.value)
@@ -544,7 +545,7 @@ def double_coset_python(S1, S2, partition1, ordering2, n,
         sig_free(ordering)
         sig_free(output)
         raise MemoryError
-    for i from 0 <= i < n:
+    for i in range(n):
         ordering[i] = ordering2[i]
 
     cdef bint isomorphic = double_coset(<void *> obj_wrapper1, <void *> obj_wrapper2,
@@ -556,7 +557,7 @@ def double_coset_python(S1, S2, partition1, ordering2, n,
     PS_dealloc(part)
     sig_free(ordering)
     if isomorphic:
-        output_py = [output[i] for i from 0 <= i < n]
+        output_py = [output[i] for i in range(n)]
     else:
         output_py = False
     sig_free(output)

src/sage/groups/perm_gps/partn_ref/refinement_sets.pyx

@@ -150,8 +150,8 @@ def set_stab_py(generators, sett, relab=False):
         raise MemoryError
     bitset_init(&subset_sett.bits, n)
     subset_sett.scratch = <int *> sig_malloc((3*n+1) * sizeof(int))
-    for i from 0 <= i < len(generators):
-        for j from 0 <= j < n:
+    for i in range(len(generators)):
+        for j in range(n):
             gens[n*i + j] = generators[i][j]
     if SC_insert(supergroup, 0, gens, n_gens):
         SC_dealloc(supergroup)
@@ -170,10 +170,10 @@ def set_stab_py(generators, sett, relab=False):
     if stabilizer is NULL:
         raise MemoryError
     stab_gens = []
-    for i from 0 <= i < stabilizer.num_gens:
-        stab_gens.append([stabilizer.generators[i*n+j] for j from 0 <= j < n])
+    for i in range(stabilizer.num_gens):
+        stab_gens.append([stabilizer.generators[i*n+j] for j in range(n)])
     if relab:
-        relabeling = [stabilizer.relabeling[j] for j from 0 <= j < n]
+        relabeling = [stabilizer.relabeling[j] for j in range(n)]
     deallocate_agcl_output(stabilizer)
     if relab:
         return stab_gens, relabeling
@@ -397,9 +397,9 @@ def sets_isom_py(generators, set1, set2):
     bitset_init(&subset_sett2.bits, n)
     subset_sett1.scratch = <int *> sig_malloc((3*n+1) * sizeof(int))
     subset_sett2.scratch = <int *> sig_malloc((3*n+1) * sizeof(int))
-    for i from 0 <= i < len(generators):
-        for j from 0 <= j < n:
-            gens[n*i + j] = generators[i][j]
+    for i in range(len(generators)):
+        for j in range(n):
+            gens[n * i + j] = generators[i][j]
     if SC_insert(supergroup, 0, gens, n_gens):
         raise MemoryError
     sig_free(gens)
@@ -418,7 +418,7 @@ def sets_isom_py(generators, set1, set2):
     sig_free(subset_sett1)
     sig_free(subset_sett2)
     if isomorphic:
-        output_py = [isom[i] for i from 0 <= i < n]
+        output_py = [isom[i] for i in range(n)]
     else:
         output_py = False
     sig_free(isom)
@@ -637,15 +637,15 @@ cdef int allocate_subset_gen_2(int degree, int max_size, iterator *it) noexcept:
     if cgd is NULL:
         return 1
     cdef int i, j
-    for i from 0 <= i < max_size + 1:
+    for i in range(max_size + 1):
         cgd.object_stack[i] = allocate_subset(degree)
         cgd.parent_stack[i] = allocate_subset(degree)
         cgd.iterator_stack[i].data = allocate_sgd(degree)
         cgd.iterator_stack[i].next = &subset_generator_next
         if cgd.iterator_stack[i].data is NULL or \
            cgd.object_stack[i] is NULL or \
            cgd.parent_stack[i] is NULL:
-            for j from 0 <= j <= i:
+            for j in range(i + 1):
                 deallocate_sgd(cgd.iterator_stack[i].data)
                 free_subset(cgd.object_stack[i])
                 free_subset(cgd.parent_stack[i])
@@ -821,9 +821,9 @@ def sets_modulo_perm_group(list generators, int max_size,
         SC_dealloc(group)
         sig_free(gens)
         raise MemoryError
-    for i from 0 <= i < len(generators):
-        for j from 0 <= j < n:
-            gens[n*i + j] = generators[i][j]
+    for i in range(len(generators)):
+        for j in range(n):
+            gens[n * i + j] = generators[i][j]
     if SC_insert(group, 0, gens, n_gens):
         SC_dealloc(group)
         sig_free(gens)

src/sage/groups/perm_gps/partn_ref2/refinement_generic.pyx

@@ -345,7 +345,7 @@ cdef class LabelledBranching:
             sig_free(self.father)
             raise MemoryError('allocating LabelledBranching')
         cdef int i
-        for i from 0 <= i < self.n:
+        for i in range(self.n):
             self.father[i] = -1
 
     def __dealloc__(self):
@@ -402,10 +402,10 @@ cdef class LabelledBranching:
         [Feu13]_.
         """
         cdef int i, j, k
-        for i from 0 <= i < self.n:
+        for i in range(self.n):
             self.act_perm[part.entries[i]] = i
 
-        for i from 0 <= i < self.n:
+        for i in range(self.n):
             j = self.father[i]
             if j != -1:
                 j = self.act_perm[j]
@@ -735,7 +735,7 @@ cdef class PartitionRefinement_generic:
         while i>=0:
             pos = self._fixed_not_minimized[i]
             if self._minimization_allowed_on_col(pos):
-                for j from 0 <= j < self._n:
+                for j in range(self._n):
                     if self._part.entries[j] == pos:
                         my_final_pos = j
                         break

src/sage/groups/perm_gps/permgroup_element.pyx

@@ -1101,7 +1101,7 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
             if not isinstance(i, (list, tuple, str)):
                 raise ValueError("must be in the domain or a list, tuple or string")
 
-            permuted = [i[self.perm[j]] for j from 0 <= j < self.n]
+            permuted = [i[self.perm[j]] for j in range(self.n)]
             if isinstance(i, tuple):
                 permuted = tuple(permuted)
             elif isinstance(i, str):
@@ -1372,7 +1372,7 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
         cdef PermutationGroupElement prod = left._new_c()
         cdef PermutationGroupElement right = <PermutationGroupElement>_right
         cdef int i
-        for i from 0 <= i < left.n:
+        for i in range(left.n):
             prod.perm[i] = right.perm[left.perm[i]]
         return prod
 
@@ -1441,7 +1441,7 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
         """
         cdef PermutationGroupElement inv = self._new_c()
         cdef int i
-        for i from 0 <= i < self.n:
+        for i in range(self.n):
             inv.perm[self.perm[i]] = i
         return inv
 
@@ -1467,7 +1467,7 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
             [2, 3, 1]
         """
         cdef int i
-        return [self.perm[i]+1 for i from 0 <= i < self.n]
+        return [self.perm[i] + 1 for i in range(self.n)]
 
     def _gap_cycle_string(self):
         r"""
@@ -1524,7 +1524,7 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
 
         cdef int i
         from_gap = self._parent._domain_from_gap
-        return [from_gap[self.perm[i]+1] for i from 0 <= i < self.n]
+        return [from_gap[self.perm[i] + 1] for i in range(self.n)]
 
     def __hash__(self):
         r"""
@@ -1921,9 +1921,8 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
         cycle_type.sort(reverse=True)
         if as_list:
             return cycle_type
-        else:
-            from sage.combinat.partition import _Partitions
-            return _Partitions(cycle_type)
+        from sage.combinat.partition import _Partitions
+        return _Partitions(cycle_type)
 
     def has_descent(self, i, side='right', positive=False) -> bool:
         r"""
@@ -2003,7 +2002,7 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
         M = MatrixSpace(ZZ, self.n, self.n, sparse=True)
         cdef int i
         entries = {}
-        for i from 0 <= i < self.n:
+        for i in range(self.n):
             entries[i, self.perm[i]] = 1
         return M(entries)
 
@@ -2171,17 +2170,17 @@ cdef bint is_valid_permutation(int* perm, int n) noexcept:
     """
     cdef int i, ix
     # make everything is in bounds
-    for i from 0 <= i < n:
+    for i in range(n):
         if not 0 <= perm[i] < n:
             return False
     # mark hit points by sign
-    for i from 0 <= i < n:
-        ix = -1-perm[i] if perm[i] < 0 else perm[i]
-        perm[ix] = -1-perm[ix]
+    for i in range(n):
+        ix = -1 - perm[i] if perm[i] < 0 else perm[i]
+        perm[ix] = -1 - perm[ix]
     # make sure everything is hit once, and reset signs
-    for i from 0 <= i < n:
+    for i in range(n):
         if perm[i] >= 0:
             return False
-        perm[i] = -1-perm[i]
+        perm[i] = -1 - perm[i]
 
     return True