passagemath-graphs 10.5.10__cp39-cp39-macosx_14_0_arm64.whl → 10.5.43__cp39-cp39-macosx_14_0_arm64.whl

sage/combinat/cluster_algebra_quiver/cluster_seed.py

@@ -1,28 +1,34 @@
 # sage_setup: distribution = sagemath-graphs
-# sage.doctest: needs sage.graphs sage.modules
+# sage.doctest: needs sage.graphs sage.modules sage.libs.singular
 r"""
-ClusterSeed
+Cluster seeds
 
-A *cluster seed* is a pair `(B,\mathbf{x})` with `B` being a *skew-symmetrizable* `(n+m) \times n` *-matrix*
-and with `\mathbf{x}` being an `n`-tuple of *independent elements* in the field of rational functions in `n` variables.
+A *cluster seed* is a pair `(B,\mathbf{x})` with `B` being a
+*skew-symmetrizable* `(n+m) \times n` *-matrix* and with `\mathbf{x}` being an
+`n`-tuple of *independent elements* in the field of rational functions in `n`
+variables.
 
 For the compendium on the cluster algebra and quiver package see
 [MS2011]_.
 
-AUTHORS:
-
-- Gregg Musiker: Initial Version
-- Christian Stump: Initial Version
-- Aram Dermenjian (2015-07-01): Updating ability to not rely solely on clusters
-- Jesse Levitt (2015-07-01): Updating ability to not rely solely on clusters
-
 REFERENCES:
 
 - [FZ2007]_
-
 - [BDP2013]_
 
-.. SEEALSO:: For mutation types of cluster seeds, see :meth:`sage.combinat.cluster_algebra_quiver.quiver_mutation_type.QuiverMutationType`. Cluster seeds are closely related to :meth:`sage.combinat.cluster_algebra_quiver.quiver.ClusterQuiver`.
+.. SEEALSO::
+
+    For mutation types of cluster seeds, see
+    :meth:`sage.combinat.cluster_algebra_quiver.quiver_mutation_type.QuiverMutationType`.
+    Cluster seeds are closely related to
+    :meth:`sage.combinat.cluster_algebra_quiver.quiver.ClusterQuiver`.
+
+AUTHORS:
+
+- Gregg Musiker: initial version
+- Christian Stump: initial version
+- Aram Dermenjian (2015-07-01): updating ability to not rely solely on clusters
+- Jesse Levitt (2015-07-01): updating ability to not rely solely on clusters
 """
 
 # ****************************************************************************
@@ -333,7 +339,7 @@ class ClusterSeed(SageObject):
                 else:
                     labelset = set(user_labels)
                     # Sanitizes our ``user_labels`` to use Integers instead of ints
-                    user_labels = [ZZ(x) if x in ZZ else x for x in user_labels]
+                    user_labels = [Integer(x) if x in ZZ else x for x in user_labels]
                 if labelset != set(self._nlist + self._mlist) and labelset != set(range(self._n + self._m)):
                     raise ValueError('user_labels conflict with both the given'
                                      ' vertex labels and the default labels')
@@ -3594,7 +3600,7 @@ class ClusterSeed(SageObject):
                             else:
                                 orbits = [index for index in range(n) if index > i or sd2._M[index, i] != 0]
 
-                            clusters[cl2] = [sd2, orbits, clusters[key][2]+[i]]
+                            clusters[cl2] = [sd2, orbits, clusters[key][2] + [i]]
                             if return_paths:
                                 yield (sd2, clusters[cl2][2])
                             else:
@@ -3603,10 +3609,10 @@ class ClusterSeed(SageObject):
             if show_depth and gets_bigger:
                 timer2 = time.time()
                 dc = str(depth_counter)
-                dc += ' ' * (5-len(dc))
+                dc += ' ' * (5 - len(dc))
                 nr = str(len(clusters))
-                nr += ' ' * (10-len(nr))
-                print(f"Depth: {dc} found: {nr} Time: {timer2-timer:.2f} s")
+                nr += ' ' * (10 - len(nr))
+                print(f"Depth: {dc} found: {nr} Time: {timer2 - timer:.2f} s")
 
     def mutation_class(self, depth=infinity, show_depth=False, return_paths=False,
                        up_to_equivalence=True, only_sink_source=False):
@@ -4719,7 +4725,7 @@ class ClusterSeed(SageObject):
             for l in range(num_cols):
                 denominator = denominator * (R.gen(l))**vd[i][0][l]
             # Each copy of a vector in vd contributes a factor of the Laurent polynomial calculated from it.
-            final = (numerator/denominator)**vd[i][1]
+            final = (numerator / denominator)**vd[i][1]
             finalP.append(final)
         laurentP = 1
         # The UCA element for the vector a is the product of the elements produced from the vectors in its decomposition.
@@ -4741,10 +4747,8 @@ def _bino(n, k):
         0
     """
     if n >= 0:
-        from sage.arith.misc import binomial
-        return binomial(n, k)
-    else:
-        return 0
+        return Integer(n).binomial(k)
+    return 0
 
 
 def coeff_recurs(p, q, a1, a2, b, c):
@@ -5193,7 +5197,7 @@ class ClusterVariable(FractionFieldElement):
             mt = self._mutation_type._repr_()
             # mt is a string of the shape "['A', 15]"
             # where A is a single letter and 15 is an integer
-            Phi = RootSystem([mt[2: 3], ZZ(mt[6: -1])])
+            Phi = RootSystem([mt[2: 3], Integer(mt[6: -1])])
             Phiplus = Phi.root_lattice().simple_roots()
 
             if self.denominator() == 1:

sage/combinat/cluster_algebra_quiver/interact.py

@@ -1,4 +1,8 @@
 # sage_setup: distribution = sagemath-graphs
+r"""
+Interactive window for cluster seed mutations
+"""
+
 import ipywidgets as widgets
 from sage.misc.latex import latex
 from sage.repl.rich_output.pretty_print import pretty_print

sage/combinat/designs/MOLS_handbook_data.py

@@ -1,11 +1,11 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-Known lower bounds on the number of Mutually Orthogonal Latin
-Squares (MOLS) of a given size.
+Bounds on the number of mutually orthogonal Latin squares
 
-This module consists (almost) entirely of an internal, constant tuple
-of python integers corresponding to Table 3.87 in the Handbook of
-Combinatorial Designs, 2nd edition, by Colbourn and Dinitz. One public
+This module contains known lower bounds on the number of mutually orthogonal
+Latin squares (MOLS) of a given size, and consists (almost) entirely of an
+internal, constant tuple of Python integers corresponding to Table 3.87 in the
+Handbook of Combinatorial Designs, 2nd edition, by Colbourn and Dinitz. One public
 function, :func:`lower_bound`, is provided to access it.
 
 Make sure we have all of the entries::

sage/combinat/designs/bibd.py

@@ -1,6 +1,6 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-Balanced Incomplete Block Designs (BIBD)
+Balanced incomplete block designs (BIBD)
 
 This module gathers everything related to Balanced Incomplete Block Designs. One can build a
 BIBD (or check that it can be built) with :func:`balanced_incomplete_block_design`::
@@ -614,7 +614,7 @@ def BIBD_from_TD(v, k, existence=False):
 
         BIBD = TDkv._blocks
         for i in range(k):
-            BIBD.extend([[x+i*v for x in B] for B in BIBDvk])
+            BIBD.extend([x+i*v for x in B] for B in BIBDvk)
 
     # Second construction
     elif ((v-1) % k == 0 and
@@ -631,7 +631,7 @@ def BIBD_from_TD(v, k, existence=False):
         inf = v*k
         BIBD = TDkv
         for i in range(k):
-            BIBD.extend([[inf if x == v else x+i*v for x in B] for B in BIBDv1k])
+            BIBD.extend([inf if x == v else x+i*v for x in B] for B in BIBDv1k)
 
     # Third construction
     elif ((v-k) % k == 0 and
@@ -651,7 +651,8 @@ def BIBD_from_TD(v, k, existence=False):
         BIBDvpkk = [B for B in BIBDvpkk if min(B) < v]
 
         for i in range(k):
-            BIBD.extend([[(x-v)+inf if x >= v else x+i*v for x in B] for B in BIBDvpkk])
+            BIBD.extend([(x-v)+inf if x >= v else x+i*v for x in B]
+                        for B in BIBDvpkk)
 
         BIBD.append(list(range(k * v, v * k + k)))
 
@@ -1278,14 +1279,14 @@ def BIBD_5q_5_for_q_prime_power(q):
 
     d = (q-1)//4
     B = []
-    F = FiniteField(q,'x')
+    F = FiniteField(q, 'x')
     a = F.primitive_element()
-    L = {b:i for i,b in enumerate(F)}
-    for b in L:
-        B.append([i*q + L[b] for i in range(5)])
+    L = {b: i for i, b in enumerate(F)}
+    for b, Lb in L.items():
+        B.append([i*q + Lb for i in range(5)])
         for i in range(5):
             for j in range(d):
-                B.append([        i*q + L[b          ],
+                B.append([        i*q + Lb,
                           ((i+1) % 5)*q + L[ a**j+b    ],
                           ((i+1) % 5)*q + L[-a**j+b    ],
                           ((i+4) % 5)*q + L[ a**(j+d)+b],

sage/combinat/designs/covering_array.py

@@ -1,13 +1,13 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-Covering Arrays (CA)
+Covering arrays
 
-A Covering Array, denoted `CA(N;t,k,v)`, is an `N` by `k` array with
+A covering array, denoted `CA(N;t,k,v)`, is an `N` by `k` array with
 entries from a set of `v` elements with the property that in every
 selection of `t` columns, every sequence of `t` elements appears in at
 least one row.
 
-An Orthogonal Array, denoted `OA(N;t,k,v)` is a covering array with the
+An orthogonal array, denoted `OA(N;t,k,v)` is a covering array with the
 property that every sequence of `t`-elements appears in exactly one row.
 (See :mod:`sage.combinat.designs.orthogonal_arrays`).
 

sage/combinat/designs/covering_design.py

@@ -49,7 +49,6 @@ Classes and methods
 from urllib.request import urlopen
 from ssl import create_default_context as default_context
 
-from sage.misc.sage_eval import sage_eval
 from sage.structure.sage_object import SageObject
 from sage.rings.rational import Rational
 from sage.arith.misc import binomial
@@ -513,6 +512,8 @@ def best_known_covering_design_www(v, k, t, verbose=False):
     A :exc:`ValueError` is raised if the ``(v, k, t)`` parameters are not
     found in the database.
     """
+    from sage.misc.sage_eval import sage_eval
+
     v = int(v)
     k = int(k)
     t = int(t)

sage/combinat/designs/database.py

@@ -1059,8 +1059,8 @@ def OA_11_185():
     assert all(len(B) in (11,13) or set(B) == set(special_set) for B in PBD)
 
     OA = OA_from_PBD(11,185,[B for B in PBD if len(B) < 17],check=False)[:-185]
-    OA.extend([[i]*11 for i in range(185) if i not in special_set])
-    OA.extend([[special_set[x] for x in B] for B in orthogonal_array(11,17)])
+    OA.extend([i]*11 for i in range(185) if i not in special_set)
+    OA.extend([special_set[x] for x in B] for B in orthogonal_array(11,17))
     return OA
 
 
@@ -1127,7 +1127,7 @@ def OA_10_205():
     GDD = [[relabel[xx] for xx in B if xx in relabel] for B in pplane if p not in B]
 
     # We turn the GDD into a PBD by extending the groups with a new point 204.
-    GDD.extend([[relabel[xx] for xx in G]+[204] for G in groups])
+    GDD.extend([relabel[xx] for xx in G]+[204] for G in groups)
 
     # We build the OA, knowing that the blocks of size 9 are disjoint
     blocks_of_size_9 = [B for B in GDD if len(B) == 9]
@@ -1135,13 +1135,13 @@ def OA_10_205():
 
     OA = OA_from_PBD(10,205,[B for B in GDD if len(B) != 9],check=False)[:-205]
 
-    OA.extend([[B[xx] for xx in R]
-               for R in orthogonal_array(10,9)
-               for B in blocks_of_size_9])
+    OA.extend([B[xx] for xx in R]
+              for R in orthogonal_array(10,9)
+              for B in blocks_of_size_9)
 
     # The missing [i,i,...] blocks
-    OA.extend([[i]*10
-               for i in set(range(205)).difference(blocks_of_size_9_union)])
+    OA.extend([i]*10
+              for i in set(range(205)).difference(blocks_of_size_9_union))
 
     return OA
 
@@ -1628,7 +1628,8 @@ def OA_10_796():
     OA = OA_relabel(OA,17,47,blocks=[OA[0]]) # making sure [46]*17 is a block
     PBD = [[i*47+x for i,x in enumerate(B) if (x < 46 or i < 13)] for B in OA]
     extra_point = 10000
-    PBD.extend([list(range(i*47,(i+1)*47-int(i >= 13)))+[extra_point] for i in range(17)]) # Adding the columns
+    PBD.extend(list(range(i*47,(i+1)*47-int(i >= 13)))+[extra_point]
+               for i in range(17))  # Adding the columns
 
     rel = {v:i for i,v in enumerate(set(range(17*47)).difference([(i+1)*47-1 for i in range(13,17)]))}
     rel[extra_point] = len(rel)
@@ -1646,7 +1647,7 @@ def OA_10_796():
     for B in PBD:
         if len(B) >= 47:
             B.sort(key=lambda x:int(x == extra_point))
-            OA.extend([[B[i] for i in BB] for BB in iOA[len(B)]])
+            OA.extend([B[i] for i in BB] for BB in iOA[len(B)])
             span.update(B[:-1])
         else:
             others.append(B)

sage/combinat/designs/designs_pyx.pyx

@@ -12,7 +12,8 @@ from sage.data_structures.bitset_base cimport *
 
 from libc.string cimport memset
 
-from cysignals.memory cimport sig_malloc, sig_calloc, sig_realloc, sig_free
+from cysignals.memory cimport sig_malloc, sig_realloc, sig_free
+from memory_allocator cimport MemoryAllocator
 
 from sage.misc.unknown import Unknown
 
@@ -306,7 +307,8 @@ def is_orthogonal_array(OA, int k, int n, int t=2, verbose=False, terminology='O
     cdef int i,j,l
 
     # A copy of OA
-    cdef unsigned short * OAc = <unsigned short *> sig_malloc(k*n2*sizeof(unsigned short))
+    cdef MemoryAllocator mem = MemoryAllocator()
+    cdef unsigned short * OAc = <unsigned short *> mem.malloc(k*n2*sizeof(unsigned short))
 
     cdef unsigned short * C1
     cdef unsigned short * C2
@@ -322,7 +324,6 @@ def is_orthogonal_array(OA, int k, int n, int t=2, verbose=False, terminology='O
                 if verbose:
                     print({"OA": "{} is not in the interval [0..{}]".format(x,n-1),
                            "MOLS": "Entry {} was expected to be in the interval [0..{}]".format(x,n-1)}[terminology])
-                sig_free(OAc)
                 return False
             OAc[j*n2+i] = x
 
@@ -339,14 +340,12 @@ def is_orthogonal_array(OA, int k, int n, int t=2, verbose=False, terminology='O
                 bitset_add(seen,n*C1[l]+C2[l])
 
             if bitset_len(seen) != n2: # Have we seen all pairs ?
-                sig_free(OAc)
                 bitset_free(seen)
                 if verbose:
                     print({"OA": "Columns {} and {} are not orthogonal".format(i,j),
                            "MOLS": "Squares {} and {} are not orthogonal".format(i,j)}[terminology])
                 return False
 
-    sig_free(OAc)
     bitset_free(seen)
     return True
 
@@ -470,9 +469,8 @@ def is_group_divisible_design(groups, blocks, v, G=None, K=None, lambd=1, verbos
                     print("{} does not belong to [0,...,{}]".format(x, n-1))
                 return False
 
-    cdef unsigned short * matrix = <unsigned short *> sig_calloc(n*n, sizeof(unsigned short))
-    if matrix is NULL:
-        raise MemoryError
+    cdef MemoryAllocator mem = MemoryAllocator()
+    cdef unsigned short * matrix = <unsigned short *> mem.calloc(n*n, sizeof(unsigned short))
 
     # Counts the number of occurrences of each pair of points
     for b in blocks:
@@ -501,7 +499,6 @@ def is_group_divisible_design(groups, blocks, v, G=None, K=None, lambd=1, verbos
             if not len(g) in G:
                 if verbose:
                     print("a group has size {} while G={}".format(len(g),list(G)))
-                sig_free(matrix)
                 return False
 
     # Checks that two points of the same group were never covered
@@ -514,7 +511,6 @@ def is_group_divisible_design(groups, blocks, v, G=None, K=None, lambd=1, verbos
                 if matrix[ii*n+jj] != 0:
                     if verbose:
                         print("the pair ({},{}) belongs to a group but appears in some block".format(ii, jj))
-                    sig_free(matrix)
                     return False
 
                 # We fill the entries with what is expected by the next loop
@@ -527,11 +523,8 @@ def is_group_divisible_design(groups, blocks, v, G=None, K=None, lambd=1, verbos
             if matrix[i*n+j] != l:
                 if verbose:
                     print("the pair ({},{}) has been seen {} times but lambda={}".format(i,j,matrix[i*n+j],l))
-                sig_free(matrix)
                 return False
 
-    sig_free(matrix)
-
     return True if not guess_groups else (True, groups)
 
 
@@ -823,9 +816,9 @@ def is_quasi_difference_matrix(M, G, int k, int lmbda, int mu, int u, verbose=Fa
 
     # Width of the matrix
     for R in M:
-        if len(R)!=k:
+        if len(R) != k:
             if verbose:
-                print("The matrix has {} columns but k={}".format(len(R),k))
+                print("The matrix has {} columns but k={}".format(len(R), k))
             return False
 
     # When |G|=0
@@ -837,16 +830,11 @@ def is_quasi_difference_matrix(M, G, int k, int lmbda, int mu, int u, verbose=Fa
     cdef dict group_to_int = {v:i for i,v in enumerate(int_to_group)}
 
     # Allocations
-    cdef int ** x_minus_y     = <int **> sig_malloc((n+1)*sizeof(int *))
-    cdef int * x_minus_y_data = <int *>  sig_malloc((n+1)*(n+1)*sizeof(int))
-    cdef int * M_c            = <int *>  sig_malloc(k*M_nrows*sizeof(int))
-    cdef int * G_seen         = <int *>  sig_malloc((n+1)*sizeof(int))
-    if (x_minus_y == NULL or x_minus_y_data == NULL or M_c == NULL or G_seen == NULL):
-        sig_free(x_minus_y)
-        sig_free(x_minus_y_data)
-        sig_free(G_seen)
-        sig_free(M_c)
-        raise MemoryError
+    cdef MemoryAllocator mem = MemoryAllocator()
+    cdef int ** x_minus_y = <int **> mem.malloc((n+1)*sizeof(int *))
+    cdef int * x_minus_y_data = <int *> mem.malloc((n+1)*(n+1)*sizeof(int))
+    cdef int * M_c = <int *> mem.malloc(k*M_nrows*sizeof(int))
+    cdef int * G_seen = <int *> mem.malloc((n+1)*sizeof(int))
 
     # The "x-y" table. If g_i, g_j \in G, then x_minus_y[i][j] is equal to
     # group_to_int[g_i-g_j].
@@ -884,10 +872,6 @@ def is_quasi_difference_matrix(M, G, int k, int lmbda, int mu, int u, verbose=Fa
                     if bit:
                         if verbose:
                             print("Row {} contains more than one empty entry".format(i))
-                        sig_free(x_minus_y_data)
-                        sig_free(x_minus_y)
-                        sig_free(G_seen)
-                        sig_free(M_c)
                         return False
                     bit = True
 
@@ -901,10 +885,6 @@ def is_quasi_difference_matrix(M, G, int k, int lmbda, int mu, int u, verbose=Fa
                 if verbose:
                     print("Column {} contains {} empty entries instead of the expected "
                           "lambda.u={}.{}={}".format(j, ii, lmbda, u, lmbda*u))
-                sig_free(x_minus_y_data)
-                sig_free(x_minus_y)
-                sig_free(G_seen)
-                sig_free(M_c)
                 return False
 
     # We are now ready to test every pair of columns
@@ -918,10 +898,6 @@ def is_quasi_difference_matrix(M, G, int k, int lmbda, int mu, int u, verbose=Fa
                 if verbose:
                     print("Columns {} and {} generate 0 exactly {} times "
                           "instead of the expected mu(={})".format(i,j,G_seen[0],mu))
-                sig_free(x_minus_y_data)
-                sig_free(x_minus_y)
-                sig_free(G_seen)
-                sig_free(M_c)
                 return False
 
             for ii in range(1,n): # bad number of g_ii\in G
@@ -930,16 +906,8 @@ def is_quasi_difference_matrix(M, G, int k, int lmbda, int mu, int u, verbose=Fa
                         print("Columns {} and {} do not generate all elements of G "
                          "exactly lambda(={}) times. The element {} appeared {} "
                          "times as a difference.".format(i,j,lmbda,int_to_group[ii],G_seen[ii]))
-                    sig_free(x_minus_y_data)
-                    sig_free(x_minus_y)
-                    sig_free(G_seen)
-                    sig_free(M_c)
                     return False
 
-    sig_free(x_minus_y_data)
-    sig_free(x_minus_y)
-    sig_free(G_seen)
-    sig_free(M_c)
     return True
 
 

sage/combinat/designs/difference_family.py

@@ -293,8 +293,8 @@ def is_difference_family(G, D, v=None, k=None, l=None, verbose=False):
 
         # Normalized number of occurrences added to counter
         stabi = len(stab[i])
-        for gg in tmp_counter:
-            counter[gg] += tmp_counter[gg]//stabi
+        for gg, tmp_gg in tmp_counter.items():
+            counter[gg] += tmp_gg // stabi
 
     # Check the counter and report any error
     too_few = []
@@ -1580,7 +1580,7 @@ def is_relative_difference_set(R, G, H, params, verbose=False):
     - ``H`` -- list; a submodule of ``G`` of order `n`
     - ``params`` -- tuple in the form `(m, n, k, d)`
     - ``verbose`` -- boolean (default: ``False``); if ``True``, the function
-      will be verbose when the sequences do not satisfy the contraints
+      will be verbose when the sequences do not satisfy the constraints
 
     EXAMPLES::
 
@@ -1660,7 +1660,7 @@ def is_supplementary_difference_set(Ks, v=None, lmbda=None, G=None, verbose=Fals
     - ``lmbda`` -- integer; the parameter `\lambda` of the supplementary difference sets
     - ``G`` -- a group of order `v`
     - ``verbose`` -- boolean (default: ``False``); if ``True``, the function will
-      be verbose when the sets do not satisfy the contraints
+      be verbose when the sets do not satisfy the constraints
 
     EXAMPLES::
 
@@ -1758,7 +1758,7 @@ def supplementary_difference_set_from_rel_diff_set(q, existence=False, check=Tru
     OUTPUT:
 
     If ``existence=False``, the function returns the 4 sets (containing integers),
-    or raises an error if ``q`` does not satify the constraints.
+    or raises an error if ``q`` does not satisfy the constraints.
     If ``existence=True``, the function returns a boolean representing whether
     supplementary difference sets can be constructed.
 
@@ -3085,7 +3085,7 @@ def are_complementary_difference_sets(G, A, B, verbose=False):
     - ``A`` -- set of elements of ``G``
     - ``B`` -- set of elements of ``G``
     - ``verbose`` -- boolean (default: ``False``); if ``True`` the function will
-      be verbose when the sets do not satisfy the contraints
+      be verbose when the sets do not satisfy the constraints
 
     EXAMPLES::
 

sage/combinat/designs/difference_matrices.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-graphs
 # sage.doctest: needs sage.rings.finite_rings
 r"""
-Difference Matrices
+Difference matrices
 
 This module gathers code related to difference matrices. One can build those
 objects (or know if they can be built) with :func:`difference_matrix`::

sage/combinat/designs/evenly_distributed_sets.pyx

@@ -19,14 +19,15 @@ Classes and methods
 
 cimport cython
 
-from sage.categories.fields import Fields
 from libc.limits cimport UINT_MAX
 from libc.string cimport memset, memcpy
-
-from cysignals.memory cimport check_malloc, check_calloc, sig_free
+from memory_allocator cimport MemoryAllocator
 
 from sage.rings.integer cimport smallInteger
 
+from sage.categories.fields import Fields
+
+
 cdef class EvenlyDistributedSetsBacktracker:
     r"""
     Set of evenly distributed subsets in finite fields.
@@ -169,17 +170,8 @@ cdef class EvenlyDistributedSetsBacktracker:
     cdef unsigned int * cosets   # e array: cosets of differences of elts in B
     cdef unsigned int * t        # e array: temporary variable for updates
 
-    def __dealloc__(self):
-        if self.diff != NULL:
-            sig_free(self.diff[0])
-            sig_free(self.diff)
-        if self.ratio != NULL:
-            sig_free(self.ratio[0])
-            sig_free(self.ratio)
-        sig_free(self.min_orb)
-        sig_free(self.B)
-        sig_free(self.cosets)
-        sig_free(self.t)
+    # MANAGEMENT OF MEMORY
+    cdef MemoryAllocator mem
 
     def __init__(self, K, k, up_to_isomorphism=True, check=False):
         r"""
@@ -229,20 +221,21 @@ cdef class EvenlyDistributedSetsBacktracker:
         self.m = (q - 1) // e
         self.K = K
 
-        self.diff    = <unsigned int **> check_calloc(q, sizeof(unsigned int *))
-        self.diff[0] = <unsigned int *>  check_malloc(q*q*sizeof(unsigned int))
+        self.mem = MemoryAllocator()
+        self.diff = <unsigned int **> self.mem.calloc(q, sizeof(unsigned int *))
+        self.diff[0] = <unsigned int *> self.mem.malloc(q*q*sizeof(unsigned int))
         for i in range(1, self.q):
             self.diff[i] = self.diff[i-1] + q
 
-        self.ratio    = <unsigned int **> check_calloc(q, sizeof(unsigned int *))
-        self.ratio[0] = <unsigned int *>  check_malloc(q*q*sizeof(unsigned int))
+        self.ratio = <unsigned int **> self.mem.calloc(q, sizeof(unsigned int *))
+        self.ratio[0] = <unsigned int *> self.mem.malloc(q*q*sizeof(unsigned int))
         for i in range(1, self.q):
             self.ratio[i] = self.ratio[i-1] + q
 
-        self.B       = <unsigned int *> check_malloc(k*sizeof(unsigned int))
-        self.min_orb = <unsigned int *> check_malloc(q*sizeof(unsigned int))
-        self.cosets  = <unsigned int *> check_malloc(e*sizeof(unsigned int))
-        self.t       = <unsigned int *> check_malloc(e*sizeof(unsigned int))
+        self.B = <unsigned int *> self.mem.malloc(k*sizeof(unsigned int))
+        self.min_orb = <unsigned int *> self.mem.malloc(q*sizeof(unsigned int))
+        self.cosets = <unsigned int *> self.mem.malloc(e*sizeof(unsigned int))
+        self.t = <unsigned int *> self.mem.malloc(e*sizeof(unsigned int))
 
         x = K.multiplicative_generator()
         list_K = []

sage/combinat/designs/ext_rep.py

@@ -1,13 +1,13 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-External Representations of Block Designs
+External representations of block designs
 
-The "ext_rep" module is an API to the abstract tree represented by
+This module is an API to the abstract tree represented by
 an XML document containing the External Representation of a list of
 block designs. The module also provides the related I/O operations for
-reading/writing ext-rep files or data. The parsing is based on expat.
+reading/writing ``ext-rep`` files or data. The parsing is based on expat.
 
-This is a modified form of the module ext_rep.py (version 0.8)
+This is a modified form of the module ``ext_rep.py`` (version 0.8)
 written by Peter Dobcsanyi [Do2009]_ peter@designtheory.org.
 
 .. TODO::
@@ -16,12 +16,9 @@ written by Peter Dobcsanyi [Do2009]_ peter@designtheory.org.
     information about things like automorphism groups, transitivity, cycle type
     representatives, etc, but none of this data is made available through the
     current implementation.
-
-Functions
----------
 """
 
-###########################################################################
+# ***********************************************************************
 # This software is released under the terms of the GNU General Public
 # License, version 2 or above (your choice). For details on licensing,
 # see the accompanying documentation.
@@ -29,9 +26,9 @@ Functions
 # This is a modified form of the module ext_rep.py (version 0.8)
 # written by Peter Dobcsanyi peter@designtheory.org.
 #
-# Copyright 2004 by Peter Dobcsanyi peter@designtheory.org, and copyright
-# 2009 Carlo Hamalainen carlo.hamalainen@gmail.com
-###########################################################################
+# Copyright 2004 Peter Dobcsanyi peter@designtheory.org
+#           2009 Carlo Hamalainen carlo.hamalainen@gmail.com
+# ***********************************************************************
 
 import sys
 import xml.parsers.expat
@@ -598,7 +595,6 @@ def _encode_attribute(string):
         sage: _encode_attribute('E')
         'E'
     """
-
     if pattern_integer.match(string):
         return int(string)
     elif pattern_decimal.match(string):
@@ -611,8 +607,7 @@ class XTree:
     '''
     A lazy class to wrap a rooted tree representing an XML document.
     The tree's nodes are tuples of the structure:
-
-        (name, {dictionary of attributes}, [list of children])
+    (name, {dictionary of attributes}, [list of children])
 
     Methods and services of an XTree object ``t``:
 

sage/combinat/designs/gen_quadrangles_with_spread.pyx

@@ -268,7 +268,7 @@ def generalised_quadrangle_hermitian_with_ovoid(const int q):
     TESTS::
 
         sage: from sage.combinat.designs.gen_quadrangles_with_spread import \
-              is_GQ_with_spread, dual_GQ_ovoid
+        ....: is_GQ_with_spread, dual_GQ_ovoid
         sage: t = designs.generalised_quadrangle_hermitian_with_ovoid(3)
         sage: t = dual_GQ_ovoid(*t)
         sage: is_GQ_with_spread(*t, s=3, t=9)