passagemath-modules 10.5.32__cp310-cp310-macosx_14_0_arm64.whl → 10.6.20__cp310-cp310-macosx_14_0_arm64.whl

sage/schemes/projective/cohomology.py

@@ -0,0 +1,510 @@
+# sage_setup: distribution = sagemath-modules
+# sage.doctest: needs sage.libs.singular
+r"""
+Cohomology of coherent sheaves
+
+This module implements Maruyama's method for computing the cohomology of
+coherent sheaves on projective schemes. This module is internal, and is not
+intended for direct use. Use :meth:`cohomology` method of coherent sheaves on
+projective schemes.
+
+Maruyama's method is explained and proved in detail in [Kudo2017]_. Here we
+summary the main results necessary to understand the implementation.
+
+Let `M` be a graded module finitely generated over the homogeneous coordinate
+ring `S` of the projective `r`-space over a field `k`. We aim for computing the
+cohomology groups `H^q(\tilde M)` for the coherent sheaf `\tilde M`.
+
+Let `S=k[x_0,x_2,\dots,x_r]`. Then `M` is a quotient of the free module
+`\bigoplus_{i=1}^{t}S` by a submodule. Let
+
+.. MATH::
+
+    0\to\bigoplus_{j=1}^{t_{r+1}}S(-m^{(r+1)}_j)\overset{f_{r+1}}{\longrightarrow}\dots
+    \overset{f_1}{\longrightarrow}\bigoplus_{j=1}^{t_0}S(-m^{(0)}_j)\overset{f_0}{\longrightarrow}M\to 0
+
+be a minimal free resolution of `M`. Then it induces a complex of (top) cohomology groups
+
+.. MATH::
+
+    \bigoplus_{j=1}^{t_{i+1}}H^r(\OO_{\PP^r}(-m^{(i+1)}_j))\overset{H^r(f_{i+1})}{\longrightarrow}
+    \bigoplus_{j=1}^{t_i}H^r(\OO_{\PP^r}(-m^{(i)}_j))\overset{H^r(f_{i})}{\longrightarrow}
+    \bigoplus_{j=1}^{t_{i-1}}H^r(\OO_{\PP^r}(-m^{(i-1)}_j)),
+
+where `i` runs from `1` to `r`. Now it holds that
+
+.. MATH::
+
+    H^q(\tilde M)\cong \ker H^r(f_{r-q})/\im H^r(f_{r-q+1})
+
+for `1\le q\le r - 1` and
+
+.. MATH::
+
+    H^r(\tilde M)\cong \bigoplus_{j=1}^{t_0}H^r(\OO_{\PP^r}(-m^{(0)}_j))/\im H^r(f_1)
+
+and `\dim H^0(\tilde M)` can be computed by the formula
+
+.. MATH::
+
+    \begin{split}
+    &\dim \bigoplus_{j=1}^{t_{0}}H^0(\OO_{\PP^r}(-m^{(0)}_j))
+    -\dim \bigoplus_{j=1}^{t_{r+1}}H^r(\OO_{\PP^r}(-m^{(r+1)}_j))
+    +\dim \bigoplus_{j=1}^{t_{r}}H^r(\OO_{\PP^r}(-m^{(r)}_j)) \\
+    &\quad -\rank H^0(f_1)-\rank H^r(f_r)
+    \end{split}
+
+in which the complex of (bottom) cohomology groups
+
+.. MATH::
+
+    \bigoplus_{j=1}^{t_{i+1}}H^0(\OO_{\PP^r}(-m^{(i+1)}_j))\overset{H^0(f_{i+1})}{\longrightarrow}
+    \bigoplus_{j=1}^{t_i}H^0(\OO_{\PP^r}(-m^{(i)}_j))\overset{H^0(f_{i})}{\longrightarrow}
+    \bigoplus_{j=1}^{t_{i-1}}H^0(\OO_{\PP^r}(-m^{(i-1)}_j)),
+
+where `i` runs from `1` to `r` is used.
+
+The implemented algorithm works more generally for twisted coherent sheaves and
+accepts as input shifted graded module `M(-n)` with shift `n`.
+
+EXAMPLES:
+
+We define the Fermat cubic surface (a curve in `\PP^2`) and compute its cohomology groups::
+
+    sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+    sage: X = P2.subscheme([x^4 + y^4 + z^4])
+    sage: sh = X.structure_sheaf()
+    sage: sh.cohomology(1)
+    3
+
+Internally the cohomology is computed by Maruyama's method::
+
+    sage: sh._cohomology
+    Maruyama Method using S(0) <-- S(-4) <-- 0
+    sage: sh._cohomology.H(1)
+    Vector space quotient V/W of dimension 3 over Rational Field where
+    V: Vector space of degree 3 and dimension 3 over Rational Field
+    Basis matrix:
+    [1 0 0]
+    [0 1 0]
+    [0 0 1]
+    W: Vector space of degree 3 and dimension 0 over Rational Field
+    Basis matrix:
+    []
+    sage: sh._cohomology.H(1).dimension() == sh.cohomology(1)
+    True
+    sage: sh.cohomology(2)
+    0
+    sage: sh._cohomology.H(2)
+    Vector space quotient V/W of dimension 0 over Rational Field where
+    V: Vector space of dimension 0 over Rational Field
+    W: Vector space of degree 0 and dimension 0 over Rational Field
+    Basis matrix:
+    []
+    sage: sh._cohomology.H(2).dimension() == sh.cohomology(2)
+    True
+
+The rather complicated form (as a quotient of vector spaces) of the `r`-th
+cohomology group ``H(r)`` reflects the internal representation of the
+cohomology group in terms of the cohomology groups of twisted structure sheaves
+of a projective space.
+
+On the other hand, it is not clear how to represent `H^0(\tilde M)` in terms of
+twisted structure sheaves of a projective space. Hence it is merely created
+as a vector space over `k` with the correct dimension::
+
+    sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+    sage: X = P2.subscheme([x^4 + y^4 + z^4])
+    sage: sh = X.structure_sheaf()
+    sage: sh.cohomology(0)
+    1
+    sage: sh._cohomology.H(0)
+    Vector space of dimension 1 over Rational Field
+"""
+
+from sage.structure.sage_object import SageObject
+from sage.misc.flatten import flatten
+from sage.combinat.integer_lists.invlex import IntegerListsLex
+from sage.modules.free_module import VectorSpace
+from sage.modules.free_module_element import vector
+from sage.rings.integer import Integer
+
+
+class CohomologyGroupBottom(SageObject):
+    r"""
+    Bottom cohomology group of the twisted structure sheaf of a projective space.
+
+    INPUT:
+
+    - ``S`` -- a direct sum of copies of the coordinate ring of a projective space
+
+    - ``shifts`` -- shifts of the component rings of ``S``
+
+    This represents `\bigoplus_{j=1}^{t_i}H^0(\OO_{\PP^r}(-m^{(i)}_j))` for shifts `m^{(i)}_j`.
+
+    EXAMPLES::
+
+        sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+        sage: X = P2.subscheme([x^4 + y^4 + z^4])
+        sage: c = X.structure_sheaf()._cohomology
+        sage: c.cohomology_group_bottom(0)
+        Bottom Cohomology Group of dimension 1
+    """
+    def __init__(self, S, shifts):
+        """
+        Initialize.
+
+        TESTS::
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: c = X.structure_sheaf(twist=1)._cohomology
+            sage: c.cohomology_group_bottom(0)
+            Bottom Cohomology Group of dimension 3
+        """
+        self.graded_ring = S
+        self.shifts = shifts
+
+        n = S.ngens()
+
+        basis = []
+        summands_basis = []
+        summands_index = []
+        rank = 0
+        for m in self.shifts:
+            # list of integer vectors whose entries are all non-negative integers and sum to -m
+            l = [vector(e) for e in IntegerListsLex(length=n, min_sum=-m, max_sum=-m)]
+            basis += l
+            summands_basis.append(l)
+            summands_index.append(rank)
+            rank += len(l)
+
+        self.summands_basis = summands_basis
+        self.summands_index = summands_index
+        self.basis = basis
+        self.vector_space = VectorSpace(S.base_ring(), rank)
+        self.rank = rank
+
+    def __repr__(self):
+        r"""
+        Return the string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: c = X.structure_sheaf()._cohomology
+            sage: c.cohomology_group_bottom(0)
+            Bottom Cohomology Group of dimension 1
+        """
+        return f'Bottom Cohomology Group of dimension {self.rank}'
+
+
+class CohomologyGroupTop(SageObject):
+    r"""
+    Top cohomology group of the twisted structure sheaf of a projective space.
+
+    INPUT:
+
+    - ``S`` -- a direct sum of copies of the coordinate ring of a projective space
+
+    - ``shifts`` -- shifts of the component rings of ``S``
+
+    This represents `\bigoplus_{j=1}^{t_i}H^r(\OO_{\PP^r}(-m^{(i)}_j))` for shifts `m^{(i)}_j`.
+
+    EXAMPLES::
+
+        sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+        sage: X = P2.subscheme([x^4 + y^4 + z^4])
+        sage: c = X.structure_sheaf()._cohomology
+        sage: c.cohomology_group_top(0)
+        Top Cohomology Group of dimension 0
+    """
+    def __init__(self, S, shifts):
+        """
+        Initialize.
+
+        TESTS::
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: c = X.structure_sheaf(twist=1)._cohomology
+            sage: c.cohomology_group_top(1)
+            Top Cohomology Group of dimension 1
+        """
+        self.graded_ring = S
+        self.shifts = shifts
+
+        n = S.ngens()
+
+        basis = []
+        summands_basis = []
+        summands_index = []
+        rank = 0
+        for m in self.shifts:
+            # list of integer vectors whose entries are all negative integers and sum to -m
+            l = [-vector(e) for e in IntegerListsLex(length=n, min_sum=m, max_sum=m, min_part=1)]
+            basis += l
+            summands_basis.append(l)
+            summands_index.append(rank)
+            rank += len(l)
+
+        self.summands_basis = summands_basis
+        self.summands_index = summands_index
+        self.basis = basis
+        self.vector_space = VectorSpace(S.base_ring(), rank)
+        self.rank = rank
+
+    def __repr__(self):
+        r"""
+        Return the string representation.
+
+        EXAMPLES::
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: c = X.structure_sheaf()._cohomology
+            sage: c.cohomology_group_top(1)
+            Top Cohomology Group of dimension 3
+        """
+        return f'Top Cohomology Group of dimension {self.rank}'
+
+
+class MaruyamaMethod(SageObject):
+    r"""
+    This class implements Maruyama's method to compute the cohomology group
+    `H^q(\tilde M(n))` as a vector space over the base field `k` and
+    `h^q(\tilde M(n))=\dim_kH^q(\tilde M(n))` where `n` denotes the twist.
+
+    INPUT:
+
+    - ``M`` -- a quotient of a free module over `S` by a submodule, where `S`
+      is a multi-variate polynomial ring
+
+    - ``twist`` -- (default: 0) an integer
+
+    This class provides :meth:`H` and :meth:`h` as public interface, and all
+    other methods are internal.
+
+    EXAMPLES::
+
+        sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+        sage: X = P2.subscheme([x^4 + y^4 + z^4])
+        sage: sh = X.structure_sheaf(1)  # twisted sheaf
+        sage: sh._cohomology
+        Maruyama Method using S(1) <-- S(-3) <-- 0
+    """
+    def __init__(self, M, twist=0):
+        """
+        Initialize.
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: sh = X.structure_sheaf(1)  # twisted sheaf
+            sage: c = sh._cohomology
+            sage: TestSuite(c).run(skip=['_test_pickling'])
+        """
+        shifts = [-twist for i in range(M.cover().degree())]
+        self.resolution = M.relations().graded_free_resolution(shifts=shifts)
+        self.base_ring = self.resolution.target().base_ring()
+        self.coefficient_field = self.base_ring.base_ring()
+        self.projective_space_dimension = self.base_ring.ngens() - 1
+
+    def __repr__(self):
+        """
+        Return the string representation.
+
+        EXAMPLES::
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: X.structure_sheaf()._cohomology
+            Maruyama Method using S(0) <-- S(-4) <-- 0
+        """
+        return f'Maruyama Method using {self.resolution}'
+
+    def cohomology_group_bottom(self, i):
+        r"""
+        Return `i`-th bottom cohomology group `\bigoplus_{j=1}^{t_i}H^0(\OO_{\PP^r}(-m^{(i)}_j))`
+
+        EXAMPLES::
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: c = X.structure_sheaf()._cohomology
+            sage: c.cohomology_group_bottom(1)
+            Bottom Cohomology Group of dimension 0
+        """
+        S = self.base_ring
+        shifts = self.resolution.shifts(i)
+        return CohomologyGroupBottom(S, shifts)
+
+    def cohomology_group_top(self, i):
+        r"""
+        Return `i`-th top cohomology group `\bigoplus_{j=1}^{t_i}H^r(\OO_{\PP^r}(-m^{(i)}_j))`
+
+        EXAMPLES::
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: c = X.structure_sheaf()._cohomology
+            sage: c.cohomology_group_top(1)
+            Top Cohomology Group of dimension 3
+        """
+        S = self.base_ring
+        shifts = self.resolution.shifts(i)
+        return CohomologyGroupTop(S, shifts)
+
+    def differential_bottom(self, i):
+        r"""
+        Return the `i`-th bottom differential map `H^0(f_i)`.
+
+        EXAMPLES::
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: c = X.structure_sheaf()._cohomology
+            sage: c.differential_bottom(1)
+            Vector space morphism represented as left-multiplication by the matrix:
+            []
+            Domain: Vector space of dimension 0 over Rational Field
+            Codomain: Vector space of dimension 1 over Rational Field
+        """
+        H1 = self.cohomology_group_bottom(i)
+        H0 = self.cohomology_group_bottom(i - 1)
+        M = self.resolution.differential(i).matrix()
+        K = self.coefficient_field
+        zero = K.zero()
+
+        assert M.ncols() == len(H1.summands_basis)
+        assert M.nrows() == len(H0.summands_basis)
+
+        A = []
+        for i in range(M.ncols()):
+            basis = H1.summands_basis[i]
+            for v in basis:
+                image = [zero for e in range(H0.rank)]
+                for j in range(M.nrows()):
+                    f = M[j,i]
+                    basis = H0.summands_basis[j]
+                    for c, m in zip(f.coefficients(), f.exponents()):
+                        u = v + vector(m)
+                        assert (sum(u) == -H0.shifts[j])
+                        if any(e < 0 for e in u):
+                            continue
+                        k = H0.summands_index[j] + basis.index(u)
+                        image[k] += c
+                A.append(vector(K, image))
+
+        return H1.vector_space.hom(A, codomain=H0.vector_space, side='right')
+
+    def differential_top(self, i):
+        r"""
+        Return the `i`-th top differential map `H^r(f_i)`.
+
+        EXAMPLES::
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: c = X.structure_sheaf()._cohomology
+            sage: c.differential_top(1)
+            Vector space morphism represented as left-multiplication by the matrix:
+            []
+            Domain: Vector space of dimension 3 over Rational Field
+            Codomain: Vector space of dimension 0 over Rational Field
+        """
+        H1 = self.cohomology_group_top(i)
+        H0 = self.cohomology_group_top(i - 1)
+        M = self.resolution.differential(i).matrix()
+        K = self.coefficient_field
+        zero = K.zero()
+
+        assert M.ncols() == len(H1.summands_basis)
+        assert M.nrows() == len(H0.summands_basis)
+
+        A = []
+        for i in range(M.ncols()):
+            basis = H1.summands_basis[i]
+            for v in basis:
+                image = [zero for e in range(H0.rank)]
+                for j in range(M.nrows()):
+                    f = M[j,i]
+                    basis = H0.summands_basis[j]
+                    for c, m in zip(f.coefficients(), f.exponents()):
+                        u = v + vector(m)
+                        assert (sum(u) == -H0.shifts[j])
+                        if any(e >= 0 for e in u):
+                            continue
+                        k = H0.summands_index[j] + basis.index(u)
+                        image[k] += c
+                A.append(vector(K, image))
+
+        return H1.vector_space.hom(A, codomain=H0.vector_space, side='right')
+
+    def H(self, q):
+        r"""
+        Return the `q`-th cohomology group `H^q(\tilde M)`.
+
+        INPUT:
+
+        - ``q`` -- non-negative integer
+
+        EXAMPLES::
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: c = X.structure_sheaf()._cohomology
+            sage: c.H(1)
+            Vector space quotient V/W of dimension 3 over Rational Field where
+            V: Vector space of degree 3 and dimension 3 over Rational Field
+            Basis matrix:
+            [1 0 0]
+            [0 1 0]
+            [0 0 1]
+            W: Vector space of degree 3 and dimension 0 over Rational Field
+            Basis matrix:
+            []
+        """
+        r = self.projective_space_dimension
+        if q == r:
+            return self.cohomology_group_top(0).vector_space.quotient(self.differential_top(1).image())
+        elif 1 <= q and q < r:
+            return self.differential_top(r - q).kernel().quotient(self.differential_top(r - q + 1).image())
+        elif q == 0:
+            # 0th cohomology group of (global sections) is not realized in
+            # terms of cohomology groups and differential maps of twisted
+            # structure sheaves of the projective space.
+            return VectorSpace(self.coefficient_field, self.h(0))
+        elif q > r:
+            return VectorSpace(self.coefficient_field, 0)
+        raise IndexError('index must be non-negative')
+
+    def h(self, q):
+        r"""
+        Return the dimension `h^q(\tilde M)` of the `q`-th cohomology group `H^q(\tilde M)`.
+
+        INPUT:
+
+        - ``q`` -- non-negative integer
+
+        EXAMPLES::
+
+            sage: P2.<x,y,z> = ProjectiveSpace(QQ, 2)
+            sage: X = P2.subscheme([x^4 + y^4 + z^4])
+            sage: c = X.structure_sheaf()._cohomology
+            sage: c.h(1)
+            3
+        """
+        r = self.projective_space_dimension
+        if q == r:
+            return self.cohomology_group_top(0).rank - self.differential_top(1).rank()
+        elif 1 <= q and q < r:
+            return self.differential_top(r - q).kernel().dimension() - self.differential_top(r - q + 1).rank()
+        elif q == 0:
+            a = (self.cohomology_group_bottom(0).rank - self.cohomology_group_top(r + 1).rank
+                 + self.cohomology_group_top(r).rank)
+            b = self.differential_bottom(1).rank() + self.differential_top(r).rank()
+            return a - b
+        elif q > r:
+            return Integer(0)
+        raise IndexError('index must be non-negative')

sage/stats/basic_stats.py

@@ -193,8 +193,8 @@ def std(v, bias=False):
 
     EXAMPLES::
 
-        sage: # needs sage.symbolic
-        sage: std([1..6], bias=True)
+        sage: data = [random() for i in [1 .. 20]]
+        sage: s = std(data)
         doctest:warning...
         DeprecationWarning: sage.stats.basic_stats.std is deprecated;
         use numpy.std or numpy.nanstd instead
@@ -207,6 +207,11 @@ def std(v, bias=False):
         DeprecationWarning: sage.stats.basic_stats.mean is deprecated;
         use numpy.mean or numpy.nanmean instead
         See https://github.com/sagemath/sage/issues/29662 for details.
+        sage: s  # random
+        0.29487771726609185
+
+        sage: # needs sage.symbolic
+        sage: std([1..6], bias=True)
         1/2*sqrt(35/3)
         sage: std([1..6], bias=False)
         sqrt(7/2)
@@ -230,12 +235,6 @@ def std(v, bias=False):
         sage: x = stats.TimeSeries([1..100])
         sage: std(x)
         29.011491975882016
-
-    TESTS::
-
-        sage: data = [random() for i in [1 .. 20]]
-        sage: std(data)  # random
-        0.29487771726609185
     """
     deprecation(29662, 'sage.stats.basic_stats.std is deprecated; use numpy.std or numpy.nanstd instead')
 
@@ -291,24 +290,27 @@ def variance(v, bias=False):
         35/12
         sage: variance([e, pi])                                                         # needs sage.symbolic
         1/2*(pi - e)^2
-        sage: variance([])
+        sage: variance([])                                                              # needs sage.symbolic
         NaN
         sage: variance([I, sqrt(2), 3/5])                                               # needs sage.symbolic
         1/450*(10*sqrt(2) - 5*I - 3)^2 + 1/450*(5*sqrt(2) - 10*I + 3)^2
         + 1/450*(5*sqrt(2) + 5*I - 6)^2
-        sage: variance([RIF(1.0103, 1.0103), RIF(2)])
+        sage: variance([RIF(1.0103, 1.0103), RIF(2)])                                   # needs sage.rings.real_interval_field
         0.4897530450000000?
-        sage: import numpy                                                              # needs numpy
-        sage: if int(numpy.version.short_version[0]) > 1:                               # needs numpy
-        ....:     _ = numpy.set_printoptions(legacy="1.25")                                 # needs numpy
-        sage: x = numpy.array([1,2,3,4,5])                                              # needs numpy
-        sage: variance(x, bias=False)                                                   # needs numpy
+
+        sage: # needs numpy
+        sage: import numpy
+        sage: if int(numpy.version.short_version[0]) > 1:
+        ....:     _ = numpy.set_printoptions(legacy="1.25")
+        sage: x = numpy.array([1,2,3,4,5])
+        sage: variance(x, bias=False)
         2.5
         sage: x = stats.TimeSeries([1..100])
         sage: variance(x)
         841.6666666666666
         sage: variance(x, bias=True)
         833.25
+
         sage: class MyClass:
         ....:   def variance(self, bias=False):
         ....:      return 1

sage/stats/distributions/dgs_misc.h

@@ -50,14 +50,21 @@
  * \brief Macro to help with branch prediction.
  */
 
+#ifdef __GNUC__
 #define __DGS_LIKELY(cond)    __builtin_expect ((cond) != 0, 1)
+#else
+#define __DGS_LIKELY(cond) (cond)
+#endif
 
 /**
  * \brief Macro to help with branch prediction.
  */
 
+#ifdef __GNUC__
 #define __DGS_UNLIKELY(cond)  __builtin_expect ((cond) != 0, 0)
-
+#else
+#define __DGS_UNLIKELY(cond) (cond)
+#endif
 
 static int const dgs_radix = sizeof(unsigned long)<<3;
 static unsigned long const dgs_ffff = -1;
@@ -69,9 +76,9 @@ static inline unsigned long _dgs_randomb_libc(size_t nbits) {
   size_t n = __DGS_LSB_BITMASK(nbits);
   assert(((RAND_MAX | (RAND_MAX >> 1)) == RAND_MAX));
   if (__DGS_LIKELY(n <= RAND_MAX))
-    return random() & n;
+    return rand() & n;
   assert(RAND_MAX >= __DGS_LSB_BITMASK(22));
-  unsigned long pool = (((unsigned long)random()) << 0) ^ (((unsigned long)random()) << 22) ^ (((unsigned long)random()) << 44);
+  unsigned long pool = (((unsigned long)rand()) << 0) ^ (((unsigned long)rand()) << 22) ^ (((unsigned long)rand()) << 44);
   return pool & n;
 }
 
@@ -80,7 +87,7 @@ static inline unsigned long _dgs_randomm_libc(unsigned long n) {
   long r;
   unsigned long k = RAND_MAX/n;
   do {
-    r = random();
+    r = rand();
   } while (r >= k*n);
   return r%n;
 }

sage/stats/distributions/discrete_gaussian_integer.pyx

@@ -1,6 +1,8 @@
 # sage_setup: distribution = sagemath-modules
 # sage.doctest: needs sage.symbolic
-#
+# distutils: libraries = GSL_LIBRARIES
+# distutils: library_dirs = GSL_LIBDIR
+# distutils: include_dirs = GSL_INCDIR
 # distutils: sources = sage/stats/distributions/dgs_gauss_mp.c sage/stats/distributions/dgs_gauss_dp.c sage/stats/distributions/dgs_bern.c
 # distutils: depends = sage/stats/distributions/dgs_gauss.h sage/stats/distributions/dgs_bern.h sage/stats/distributions/dgs_misc.h
 # distutils: extra_compile_args = -D_XOPEN_SOURCE=600
@@ -345,10 +347,10 @@ cdef class DiscreteGaussianDistributionIntegerSampler(SageObject):
             -3
         """
         if sigma <= 0.0:
-            raise ValueError("sigma must be > 0.0 but got %f"%sigma)
+            raise ValueError("sigma must be > 0.0 but got %f" % sigma)
 
         if tau < 1:
-            raise ValueError("tau must be >= 1 but got %d"%tau)
+            raise ValueError("tau must be >= 1 but got %d" % tau)
 
         if algorithm is None:
             if sigma*tau <= DiscreteGaussianDistributionIntegerSampler.table_cutoff:
@@ -363,15 +365,15 @@ cdef class DiscreteGaussianDistributionIntegerSampler(SageObject):
         elif algorithm == "uniform+online":
             algorithm = DGS_DISC_GAUSS_UNIFORM_ONLINE
         elif algorithm == "uniform+logtable":
-            if (c%1):
+            if (c % 1):
                 raise ValueError("algorithm 'uniform+logtable' requires c%1 == 0")
             algorithm = DGS_DISC_GAUSS_UNIFORM_LOGTABLE
         elif algorithm == "sigma2+logtable":
-            if (c%1):
+            if (c % 1):
                 raise ValueError("algorithm 'uniform+logtable' requires c%1 == 0")
             algorithm = DGS_DISC_GAUSS_SIGMA2_LOGTABLE
         else:
-            raise ValueError("Algorithm '%s' not supported by class 'DiscreteGaussianDistributionIntegerSampler'"%(algorithm))
+            raise ValueError("Algorithm '%s' not supported by class 'DiscreteGaussianDistributionIntegerSampler'" % (algorithm))
 
         if precision == "mp":
             if not isinstance(sigma, RealNumber):
@@ -398,7 +400,7 @@ cdef class DiscreteGaussianDistributionIntegerSampler(SageObject):
             self.sigma = RR(sigma)
             self.c = RR(c)
         else:
-            raise ValueError("Parameter precision '%s' not supported."%precision)
+            raise ValueError(f"Parameter precision '{precision}' not supported")
 
         self.tau = Integer(tau)
         self.algorithm = algorithm_str