passagemath-modules 10.6.31rc3__cp314-cp314-musllinux_1_2_aarch64.whl

sage/stats/basic_stats.py

@@ -0,0 +1,489 @@
+# sage_setup: distribution = sagemath-modules
+"""
+Basic Statistics
+
+This file contains basic descriptive functions. Included are the mean,
+median, mode, moving average, standard deviation, and the variance.
+When calling a function on data, there are checks for functions already
+defined for that data type.
+
+The :func:`mean` function returns the arithmetic mean (the sum of all the members
+of a list, divided by the number of members). Further revisions may include
+the geometric and harmonic mean. The :func:`median` function returns the number
+separating the higher half of a sample from the lower half. The :func:`mode`
+returns the most common occurring member of a sample, plus the number of times
+it occurs. If entries occur equally common, the smallest of a list of the most
+common  entries is returned. The :func:`moving_average` is a finite impulse
+response filter, creating a series of averages using a user-defined number of
+subsets of the full data set. The :func:`std` and the :func:`variance` return a
+measurement of how far data points tend to be from the arithmetic mean.
+
+Functions are available in the namespace :mod:`stats`, i.e. you can use them by
+typing ``stats.mean``, ``stats.median``, etc.
+
+REMARK: If all the data you are working with are floating point
+numbers, you may find :class:`stats.TimeSeries` helpful, since it is
+extremely fast and offers many of the same descriptive statistics as
+in the module.
+
+AUTHOR:
+
+- Andrew Hou (11/06/2009)
+"""
+# ***********************************************************************
+#          Copyright (C) 2009, Andrew Hou <amhou@uw.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#            The full text of the GPL is available at:
+#                  https://www.gnu.org/licenses/
+######################################################################
+
+from sage.rings.integer_ring import ZZ
+from sage.misc.lazy_import import lazy_import
+from sage.misc.functional import sqrt
+from sage.misc.superseded import deprecation
+
+lazy_import("sage.symbolic.constants", "NaN")
+lazy_import("numpy", "ndarray", as_="numpy_ndarray")
+lazy_import("sage.stats.time_series", "TimeSeries")
+
+
+def mean(v):
+    """
+    Return the mean of the elements of `v`.
+
+    We define the mean of the empty list to be the (symbolic) NaN,
+    following the convention of MATLAB, Scipy, and R.
+
+    This function is deprecated.  Use :func:`numpy.mean` or :func:`numpy.nanmean`
+    instead.
+
+    INPUT:
+
+    - ``v`` -- list of numbers
+
+    OUTPUT: a number
+
+    EXAMPLES::
+
+        sage: mean(range(4))
+        doctest:warning...
+        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.
+        3/2
+        sage: mean([pi, e])                                                             # needs sage.symbolic
+        1/2*pi + 1/2*e
+        sage: mean([])                                                                  # needs sage.symbolic
+        NaN
+        sage: mean([I, sqrt(2), 3/5])                                                   # needs sage.symbolic
+        1/3*sqrt(2) + 1/3*I + 1/5
+        sage: mean([RIF(1.0103,1.0103), RIF(2)])                                        # needs sage.rings.real_interval_field
+        1.5051500000000000?
+        sage: v = stats.TimeSeries([1..100])                                            # needs numpy
+        sage: mean(v)                                                                   # needs numpy
+        50.5
+    """
+    deprecation(29662, 'sage.stats.basic_stats.mean is deprecated; use numpy.mean or numpy.nanmean instead')
+    if hasattr(v, 'mean'):
+        return v.mean()
+    if not v:
+        return NaN
+    s = sum(v)
+    if isinstance(s, int):
+        # python integers are stupid.
+        return s / ZZ(len(v))
+    return s / len(v)
+
+
+def mode(v):
+    """
+    Return the mode of `v`.
+
+    The mode is the list of the most frequently occurring
+    elements in `v`. If `n` is the most times that any element occurs
+    in `v`, then the mode is the list of elements of `v` that
+    occur `n` times. The list is sorted if possible.
+
+    This function is deprecated.  Use :func:`scipy:scipy.stats.mode` or
+    :func:`statistics.mode` instead.
+
+    .. NOTE::
+
+        The elements of `v` must be hashable.
+
+    INPUT:
+
+    - ``v`` -- list
+
+    OUTPUT: list (sorted if possible)
+
+    EXAMPLES::
+
+        sage: v = [1,2,4,1,6,2,6,7,1]
+        sage: mode(v)
+        doctest:warning...
+        DeprecationWarning: sage.stats.basic_stats.mode is deprecated;
+        use scipy.stats.mode or statistics.mode instead
+        See https://github.com/sagemath/sage/issues/29662 for details.
+        [1]
+        sage: v.count(1)
+        3
+        sage: mode([])
+        []
+
+        sage: mode([1,2,3,4,5])
+        [1, 2, 3, 4, 5]
+        sage: mode([3,1,2,1,2,3])
+        [1, 2, 3]
+        sage: mode([0, 2, 7, 7, 13, 20, 2, 13])
+        [2, 7, 13]
+
+        sage: mode(['sage', 'four', 'I', 'three', 'sage', 'pi'])
+        ['sage']
+
+        sage: class MyClass:
+        ....:   def mode(self):
+        ....:       return [1]
+        sage: stats.mode(MyClass())
+        [1]
+    """
+    deprecation(29662, 'sage.stats.basic_stats.mode is deprecated; use scipy.stats.mode or statistics.mode instead')
+
+    if hasattr(v, 'mode'):
+        return v.mode()
+
+    if not v:
+        return v
+
+    freq = {}
+    for i in v:
+        if i in freq:
+            freq[i] += 1
+        else:
+            freq[i] = 1
+
+    n = max(freq.values())
+    try:
+        return sorted(u for u, f in freq.items() if f == n)
+    except TypeError:
+        return [u for u, f in freq.items() if f == n]
+
+
+def std(v, bias=False):
+    """
+    Return the standard deviation of the elements of `v`.
+
+    We define the standard deviation of the empty list to be NaN,
+    following the convention of MATLAB, Scipy, and R.
+
+    This function is deprecated.  Use :func:`numpy.std` or :func:`numpy.nanstd`
+    instead.
+
+    INPUT:
+
+    - ``v`` -- list of numbers
+
+    - ``bias`` -- boolean (default: ``False``); if ``False``, divide by
+      ``len(v) - 1`` instead of ``len(v)`` to give a less biased
+      estimator (sample) for the standard deviation.
+
+    OUTPUT: a number
+
+    EXAMPLES::
+
+        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
+        See https://github.com/sagemath/sage/issues/29662 for details.
+        doctest:warning...
+        DeprecationWarning: sage.stats.basic_stats.variance is deprecated;
+        use numpy.var or numpy.nanvar instead
+        See https://github.com/sagemath/sage/issues/29662 for details.
+        doctest:warning...
+        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)
+        sage: std([e, pi])
+        sqrt(1/2)*abs(pi - e)
+        sage: std([])
+        NaN
+        sage: std([I, sqrt(2), 3/5])
+        1/15*sqrt(1/2)*sqrt((10*sqrt(2) - 5*I - 3)^2
+        + (5*sqrt(2) - 10*I + 3)^2 + (5*sqrt(2) + 5*I - 6)^2)
+        sage: std([RIF(1.0103, 1.0103), RIF(2)])
+        0.6998235813403261?
+
+        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: std(x, bias=False)
+        1.5811388300841898
+        sage: x = stats.TimeSeries([1..100])
+        sage: std(x)
+        29.011491975882016
+    """
+    deprecation(29662, 'sage.stats.basic_stats.std is deprecated; use numpy.std or numpy.nanstd instead')
+
+    # NOTE: in R bias = False by default, and in Scipy bias=True by
+    # default, and R is more popular.
+
+    if hasattr(v, 'standard_deviation'):
+        return v.standard_deviation(bias=bias)
+
+    if isinstance(v, numpy_ndarray):
+        # accounts for numpy arrays
+        if bias:
+            return v.std()
+        else:
+            return v.std(ddof=1)
+
+    if not v:
+        # standard deviation of empty set defined as NaN
+        return NaN
+
+    return sqrt(variance(v, bias=bias))
+
+
+def variance(v, bias=False):
+    """
+    Return the variance of the elements of `v`.
+
+    We define the variance of the empty list to be NaN,
+    following the convention of MATLAB, Scipy, and R.
+
+    This function is deprecated.  Use :func:`numpy.var` or :func:`numpy.nanvar`
+    instead.
+
+    INPUT:
+
+    - ``v`` -- list of numbers
+
+    - ``bias`` -- boolean (default: ``False``); if ``False``, divide by
+      ``len(v) - 1`` instead of ``len(v)`` to give a less biased
+      estimator (sample) for the standard deviation.
+
+    OUTPUT: a number
+
+    EXAMPLES::
+
+        sage: variance([1..6])
+        doctest:warning...
+        DeprecationWarning: sage.stats.basic_stats.variance is deprecated;
+        use numpy.var or numpy.nanvar instead
+        See https://github.com/sagemath/sage/issues/29662 for details.
+        7/2
+        sage: variance([1..6], bias=True)
+        35/12
+        sage: variance([e, pi])                                                         # needs sage.symbolic
+        1/2*(pi - e)^2
+        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)])                                   # needs sage.rings.real_interval_field
+        0.4897530450000000?
+
+        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.variance(MyClass())
+        1
+        sage: class SillyPythonList:
+        ....:   def __init__(self):
+        ....:       self.__list = [2, 4]
+        ....:   def __len__(self):
+        ....:       return len(self.__list)
+        ....:   def __iter__(self):
+        ....:       return self.__list.__iter__()
+        ....:   def mean(self):
+        ....:       return 3
+        sage: R = SillyPythonList()
+        sage: variance(R)
+        2
+        sage: variance(R, bias=True)
+        1
+
+    TESTS:
+
+    The performance issue from :issue:`10019` is solved::
+
+        sage: variance([1] * 2^18)
+        0
+    """
+    deprecation(29662, 'sage.stats.basic_stats.variance is deprecated; use numpy.var or numpy.nanvar instead')
+
+    if hasattr(v, 'variance'):
+        return v.variance(bias=bias)
+
+    x = 0
+    if isinstance(v, numpy_ndarray):
+        # accounts for numpy arrays
+        if bias:
+            return v.var()
+        else:
+            return v.var(ddof=1)
+    if not v:
+        # variance of empty set defined as NaN
+        return NaN
+
+    mu = mean(v)
+    for vi in v:
+        x += (vi - mu)**2
+    if bias:
+        # population variance
+        if isinstance(x, int):
+            return x / ZZ(len(v))
+        return x / len(v)
+    else:
+        # sample variance
+        if isinstance(x, int):
+            return x / ZZ(len(v)-1)
+        return x / (len(v)-1)
+
+
+def median(v):
+    """
+    Return the median (middle value) of the elements of `v`.
+
+    If `v` is empty, we define the median to be NaN, which is
+    consistent with NumPy (note that R returns NULL).
+    If `v` is comprised of strings, :exc:`TypeError` occurs.
+    For elements other than numbers, the median is a result of :func:`sorted`.
+
+    This function is deprecated.  Use :func:`numpy.median` or :func:`numpy.nanmedian`
+    instead.
+
+    INPUT:
+
+    - ``v`` -- list
+
+    OUTPUT: median element of `v`
+
+    EXAMPLES::
+
+        sage: median([1,2,3,4,5])
+        doctest:warning...
+        DeprecationWarning: sage.stats.basic_stats.median is deprecated;
+        use numpy.median or numpy.nanmedian instead
+        See https://github.com/sagemath/sage/issues/29662 for details.
+        3
+        sage: median([e, pi])                                                           # needs sage.symbolic
+        1/2*pi + 1/2*e
+        sage: median(['sage', 'linux', 'python'])
+        'python'
+        sage: median([])                                                                # needs sage.symbolic
+        NaN
+        sage: class MyClass:
+        ....:    def median(self):
+        ....:       return 1
+        sage: stats.median(MyClass())
+        1
+    """
+    deprecation(29662, 'sage.stats.basic_stats.median is deprecated; use numpy.median or numpy.nanmedian instead')
+
+    if hasattr(v, 'median'):
+        return v.median()
+
+    if not v:
+        # Median of empty set defined as NaN
+        return NaN
+    values = sorted(v)
+    if len(values) % 2:
+        return values[((len(values))+1)//2-1]
+    else:
+        lower = values[(len(values)+1)//2-1]
+        upper = values[len(values)//2]
+        return (lower + upper) / ZZ(2)
+
+
+def moving_average(v, n):
+    """
+    Return the moving average of a list `v`.
+
+    The moving average of a list is often used to smooth out noisy data.
+
+    If `v` is empty, we define the entries of the moving average to be NaN.
+
+    This method is deprecated.  Use :meth:`pandas.Series.rolling` instead.
+
+    INPUT:
+
+    - ``v`` -- list
+
+    - ``n`` -- the number of values used in computing each average
+
+    OUTPUT: list of length ``len(v)-n+1``, since we do not fabric any values
+
+    EXAMPLES::
+
+        sage: moving_average([1..10], 1)
+        doctest:warning...
+        DeprecationWarning: sage.stats.basic_stats.moving_average is deprecated;
+        use pandas.Series.rolling instead
+        See https://github.com/sagemath/sage/issues/29662 for details.
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        sage: moving_average([1..10], 4)
+        [5/2, 7/2, 9/2, 11/2, 13/2, 15/2, 17/2]
+        sage: moving_average([], 1)
+        []
+        sage: moving_average([pi, e, I, sqrt(2), 3/5], 2)                               # needs sage.symbolic
+        [1/2*pi + 1/2*e, 1/2*e + 1/2*I, 1/2*sqrt(2) + 1/2*I,
+         1/2*sqrt(2) + 3/10]
+
+    We check if the input is a time series, and if so use the
+    optimized :meth:`simple_moving_average` method, but with (slightly
+    different) meaning as defined above (the point is that the
+    :meth:`simple_moving_average` on time series returns `n` values::
+
+        sage: a = stats.TimeSeries([1..10])                                             # needs numpy
+        sage: stats.moving_average(a, 3)                                                # needs numpy
+        [2.0000, 3.0000, 4.0000, 5.0000, 6.0000, 7.0000, 8.0000, 9.0000]
+        sage: stats.moving_average(list(a), 3)                                          # needs numpy
+        [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
+    """
+    deprecation(29662, 'sage.stats.basic_stats.moving_average is deprecated; use pandas.Series.rolling instead')
+
+    if not v:
+        return v
+    if isinstance(v, TimeSeries):
+        return v.simple_moving_average(n)[n - 1:]
+    n = int(n)
+    if n <= 0:
+        raise ValueError("n must be positive")
+    nn = ZZ(n)
+    s = sum(v[:n])
+    ans = [s / nn]
+    for i in range(n, len(v)):
+        # add in the i-th value in v to our running sum,
+        # and remove the value n places back.
+        s += v[i] - v[i - n]
+        ans.append(s / nn)
+    return ans

sage/stats/distributions/all.py

@@ -0,0 +1,7 @@
+# sage_setup: distribution = sagemath-modules
+# We lazy_import the following modules since they import numpy which
+# slows down sage startup
+from sage.misc.lazy_import import lazy_import
+lazy_import("sage.stats.distributions.discrete_gaussian_integer", ["DiscreteGaussianDistributionIntegerSampler"])
+lazy_import("sage.stats.distributions.discrete_gaussian_lattice", ["DiscreteGaussianDistributionLatticeSampler"])
+lazy_import("sage.stats.distributions.discrete_gaussian_polynomial", ["DiscreteGaussianDistributionPolynomialSampler"])

sage/stats/distributions/catalog.py

@@ -0,0 +1,34 @@
+# sage_setup: distribution = sagemath-modules
+r"""
+Index of distributions
+
+This catalogue includes the samplers for statistical distributions listed below.
+
+Let ``<tab>`` indicate pressing the :kbd:`Tab` key.  So begin by typing
+``algebras.<tab>`` to the see the currently implemented named algebras.
+
+- :class:`distributions.discrete_gaussian_integer.DiscreteGaussianDistributionIntegerSampler
+  <sage.stats.distributions.discrete_gaussian_integer.DiscreteGaussianDistributionIntegerSampler>`
+- :class:`distributions.discrete_gaussian_lattice.DiscreteGaussianDistributionLatticeSampler
+  <sage.stats.distributions.discrete_gaussian_lattice.DiscreteGaussianDistributionLatticeSampler>`
+- :class:`distributions.discrete_gaussian_polynomial.DiscreteGaussianDistributionPolynomialSampler
+  <sage.stats.distributions.discrete_gaussian_polynomial.DiscreteGaussianDistributionPolynomialSampler>`
+
+To import these names into the global namespace, use::
+
+    sage: from sage.stats.distributions.catalog import *
+"""
+# ****************************************************************************
+#       Copyright (C) 2024 Gareth Ma <grhkm21@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL),
+#  version 2 or later (at your preference).
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.misc.lazy_import import lazy_import
+lazy_import("sage.stats.distributions.discrete_gaussian_integer", ["DiscreteGaussianDistributionIntegerSampler"])
+lazy_import("sage.stats.distributions.discrete_gaussian_lattice", ["DiscreteGaussianDistributionLatticeSampler"])
+lazy_import("sage.stats.distributions.discrete_gaussian_polynomial", ["DiscreteGaussianDistributionPolynomialSampler"])
+del lazy_import

sage/stats/distributions/dgs.h

@@ -0,0 +1,50 @@
+/* sage_setup: distribution = sagemath-modules
+ */
+/**
+ * \file dgs.h
+ *
+ * \brief Discrete Gaussian Samplers over the Integers
+ *
+ * \author Martin Albrecht <martinralbrecht+dgs@googlemail.com>
+ */
+
+/******************************************************************************
+*
+*                        DGS - Discrete Gaussian Samplers
+*
+* Copyright (c) 2014, Martin Albrecht  <martinralbrecht+dgs@googlemail.com>
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the documentation
+*    and/or other materials provided with the distribution.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+* The views and conclusions contained in the software and documentation are
+* those of the authors and should not be interpreted as representing official
+* policies, either expressed or implied, of the FreeBSD Project.
+******************************************************************************/
+
+#ifndef DGS__H
+#define DGS__H
+
+#include "dgs_misc.h"
+#include "dgs_bern.h"
+#include "dgs_gauss.h"
+
+#endif //DGS__H

sage/stats/distributions/dgs.pxd

@@ -0,0 +1,111 @@
+# sage_setup: distribution = sagemath-modules
+"""
+AUTHOR: Martin Albrecht <martinralbrecht@googlemail.com>
+"""
+
+from sage.libs.gmp.mpz cimport mpz_t
+from sage.libs.gmp.random cimport gmp_randstate_t
+from sage.libs.mpfr.types cimport mpfr_t
+from libc.stdint cimport uint64_t
+
+cdef extern from "dgs.h":
+    int DGS_BERN_UNIFORM_DEFAULT_LENGTH
+    int DGS_BERN_UNIFORM_MAX_LENGTH
+
+    ctypedef struct dgs_bern_uniform_t:
+        size_t length
+        size_t count
+        mpz_t tmp
+        uint64_t pool
+
+    dgs_bern_uniform_t *dgs_bern_uniform_init(int length)
+    unsigned long dgs_bern_uniform_call(dgs_bern_uniform_t *self, gmp_randstate_t state)
+    void dgs_bern_uniform_clear(dgs_bern_uniform_t *self)
+
+    ctypedef struct dgs_bern_mp_t:
+        mpfr_t c
+        mpfr_t tmp
+
+    dgs_bern_mp_t *dgs_bern_mp_init(mpfr_t c)
+    unsigned long dgs_bern_mp_call(dgs_bern_mp_t *self, gmp_randstate_t state)
+    void dgs_bern_mp_clear(dgs_bern_mp_t *self)
+
+    ctypedef struct dgs_bern_exp_mp_t:
+        size_t l
+        mpfr_t *c
+        dgs_bern_mp_t **B
+
+    dgs_bern_exp_mp_t* dgs_bern_exp_mp_init(mpfr_t f, size_t l)
+    unsigned long dgs_bern_exp_mp_call(dgs_bern_exp_mp_t *self, mpz_t x, gmp_randstate_t state)
+    void dgs_bern_exp_mp_clear(dgs_bern_exp_mp_t *self)
+
+    ctypedef struct dgs_bern_dp_t:
+        double p
+
+    dgs_bern_dp_t *dgs_bern_dp_init(double p)
+    long dgs_bern_dp_call(dgs_bern_dp_t *self)
+    void dgs_bern_dp_clear(dgs_bern_dp_t *self)
+
+    ctypedef struct dgs_bern_exp_dp_t:
+        size_t l
+        double *p
+        dgs_bern_dp_t **B
+
+    dgs_bern_exp_dp_t* dgs_bern_exp_dp_init(double f, size_t l)
+    long dgs_bern_exp_dp_call(dgs_bern_exp_dp_t *self, long x)
+    void dgs_bern_exp_dp_clear(dgs_bern_exp_dp_t *self)
+
+    ctypedef enum dgs_disc_gauss_alg_t:
+        DGS_DISC_GAUSS_UNIFORM_TABLE
+        DGS_DISC_GAUSS_UNIFORM_ONLINE
+        DGS_DISC_GAUSS_UNIFORM_LOGTABLE
+        DGS_DISC_GAUSS_SIGMA2_LOGTABLE
+
+    ctypedef struct dgs_disc_gauss_sigma2p_t:
+        dgs_bern_uniform_t *B
+
+    dgs_disc_gauss_sigma2p_t *dgs_disc_gauss_sigma2p_init()
+    void dgs_disc_gauss_sigma2p_call(mpz_t rop, dgs_disc_gauss_sigma2p_t *self, gmp_randstate_t state)
+    void dgs_disc_gauss_sigma2p_clear(dgs_disc_gauss_sigma2p_t *self)
+
+    ctypedef struct dgs_disc_gauss_mp_t:
+        mpfr_t sigma
+        mpfr_t c
+        size_t tailcut
+        dgs_disc_gauss_alg_t algorithm
+        dgs_bern_mp_t *B
+        void call(mpz_t rop, dgs_disc_gauss_mp_t *self, gmp_randstate_t state)
+
+        unsigned long upper_bound
+        mpz_t x
+        mpfr_t y
+        mpfr_t *rho
+
+    dgs_disc_gauss_mp_t *dgs_disc_gauss_mp_init(mpfr_t sigma, mpfr_t c, size_t tailcut, dgs_disc_gauss_alg_t algorithm)
+    void dgs_disc_gauss_mp_call_uniform_table(mpz_t rop, dgs_disc_gauss_mp_t *self, gmp_randstate_t state)
+    void dgs_disc_gauss_mp_flush_cache(dgs_disc_gauss_mp_t *self)
+    void dgs_disc_gauss_mp_clear(dgs_disc_gauss_mp_t *self)
+
+    ctypedef struct dgs_disc_gauss_dp_t:
+        double sigma
+        double c
+        size_t tailcut
+        dgs_disc_gauss_alg_t algorithm
+        dgs_bern_uniform_t *B
+        dgs_bern_exp_dp_t *Bexp
+        dgs_disc_gauss_sigma2p_t *D2
+        long (*call)(dgs_disc_gauss_dp_t *self)
+
+        double f
+        long upper_bound
+        long two_upper_bound_plus_one
+        long k
+        double *rho
+
+    dgs_disc_gauss_dp_t *dgs_disc_gauss_dp_init(double sigma, double c, size_t tailcut, dgs_disc_gauss_alg_t algorithm)
+    long dgs_disc_gauss_dp_call_uniform_table(dgs_disc_gauss_dp_t *self)
+    long dgs_disc_gauss_dp_call_uniform_logtable(dgs_disc_gauss_dp_t *self)
+    long dgs_disc_gauss_dp_call_uniform_online(dgs_disc_gauss_dp_t *self)
+    long dgs_disc_gauss_dp_call_sigma2_logtable(dgs_disc_gauss_dp_t *self)
+    void dgs_disc_gauss_dp_flush_cache(dgs_disc_gauss_dp_t *self)
+    void dgs_disc_gauss_dp_clear(dgs_disc_gauss_dp_t *self)