I am done

rl/Lib/site-packages/sympy/stats/sampling/sample_numpy.py

@@ -0,0 +1,105 @@
+from functools import singledispatch
+
+from sympy.external import import_module
+from sympy.stats.crv_types import BetaDistribution, ChiSquaredDistribution, ExponentialDistribution, GammaDistribution, \
+    LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, FDistributionDistribution, GumbelDistribution, LaplaceDistribution, \
+    LogisticDistribution, RayleighDistribution, TriangularDistribution
+from sympy.stats.drv_types import GeometricDistribution, PoissonDistribution, ZetaDistribution
+from sympy.stats.frv_types import BinomialDistribution, HypergeometricDistribution
+
+
+numpy = import_module('numpy')
+
+
+@singledispatch
+def do_sample_numpy(dist, size, rand_state):
+    return None
+
+
+# CRV:
+
+@do_sample_numpy.register(BetaDistribution)
+def _(dist: BetaDistribution, size, rand_state):
+    return rand_state.beta(a=float(dist.alpha), b=float(dist.beta), size=size)
+
+
+@do_sample_numpy.register(ChiSquaredDistribution)
+def _(dist: ChiSquaredDistribution, size, rand_state):
+    return rand_state.chisquare(df=float(dist.k), size=size)
+
+
+@do_sample_numpy.register(ExponentialDistribution)
+def _(dist: ExponentialDistribution, size, rand_state):
+    return rand_state.exponential(1 / float(dist.rate), size=size)
+
+@do_sample_numpy.register(FDistributionDistribution)
+def _(dist: FDistributionDistribution, size, rand_state):
+    return rand_state.f(dfnum = float(dist.d1), dfden = float(dist.d2), size=size)
+
+@do_sample_numpy.register(GammaDistribution)
+def _(dist: GammaDistribution, size, rand_state):
+    return rand_state.gamma(shape = float(dist.k), scale = float(dist.theta), size=size)
+
+@do_sample_numpy.register(GumbelDistribution)
+def _(dist: GumbelDistribution, size, rand_state):
+    return rand_state.gumbel(loc = float(dist.mu), scale = float(dist.beta), size=size)
+
+@do_sample_numpy.register(LaplaceDistribution)
+def _(dist: LaplaceDistribution, size, rand_state):
+    return rand_state.laplace(loc = float(dist.mu), scale = float(dist.b), size=size)
+
+@do_sample_numpy.register(LogisticDistribution)
+def _(dist: LogisticDistribution, size, rand_state):
+    return rand_state.logistic(loc = float(dist.mu), scale = float(dist.s), size=size)
+
+@do_sample_numpy.register(LogNormalDistribution)
+def _(dist: LogNormalDistribution, size, rand_state):
+    return rand_state.lognormal(mean = float(dist.mean), sigma = float(dist.std), size=size)
+
+@do_sample_numpy.register(NormalDistribution)
+def _(dist: NormalDistribution, size, rand_state):
+    return rand_state.normal(loc = float(dist.mean), scale = float(dist.std), size=size)
+
+@do_sample_numpy.register(RayleighDistribution)
+def _(dist: RayleighDistribution, size, rand_state):
+    return rand_state.rayleigh(scale = float(dist.sigma), size=size)
+
+@do_sample_numpy.register(ParetoDistribution)
+def _(dist: ParetoDistribution, size, rand_state):
+    return (numpy.random.pareto(a=float(dist.alpha), size=size) + 1) * float(dist.xm)
+
+@do_sample_numpy.register(TriangularDistribution)
+def _(dist: TriangularDistribution, size, rand_state):
+    return rand_state.triangular(left = float(dist.a), mode = float(dist.b), right = float(dist.c), size=size)
+
+@do_sample_numpy.register(UniformDistribution)
+def _(dist: UniformDistribution, size, rand_state):
+    return rand_state.uniform(low=float(dist.left), high=float(dist.right), size=size)
+
+
+# DRV:
+
+@do_sample_numpy.register(GeometricDistribution)
+def _(dist: GeometricDistribution, size, rand_state):
+    return rand_state.geometric(p=float(dist.p), size=size)
+
+
+@do_sample_numpy.register(PoissonDistribution)
+def _(dist: PoissonDistribution, size, rand_state):
+    return rand_state.poisson(lam=float(dist.lamda), size=size)
+
+
+@do_sample_numpy.register(ZetaDistribution)
+def _(dist: ZetaDistribution, size, rand_state):
+    return rand_state.zipf(a=float(dist.s), size=size)
+
+
+# FRV:
+
+@do_sample_numpy.register(BinomialDistribution)
+def _(dist: BinomialDistribution, size, rand_state):
+    return rand_state.binomial(n=int(dist.n), p=float(dist.p), size=size)
+
+@do_sample_numpy.register(HypergeometricDistribution)
+def _(dist: HypergeometricDistribution, size, rand_state):
+    return rand_state.hypergeometric(ngood = int(dist.N), nbad = int(dist.m), nsample = int(dist.n), size=size)

rl/Lib/site-packages/sympy/stats/sampling/sample_pymc.py

@@ -0,0 +1,99 @@
+from functools import singledispatch
+from sympy.external import import_module
+from sympy.stats.crv_types import BetaDistribution, CauchyDistribution, ChiSquaredDistribution, ExponentialDistribution, \
+    GammaDistribution, LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, \
+    GaussianInverseDistribution
+from sympy.stats.drv_types import PoissonDistribution, GeometricDistribution, NegativeBinomialDistribution
+from sympy.stats.frv_types import BinomialDistribution, BernoulliDistribution
+
+
+try:
+    import pymc
+except ImportError:
+    pymc = import_module('pymc3')
+
+@singledispatch
+def do_sample_pymc(dist):
+    return None
+
+
+# CRV:
+
+@do_sample_pymc.register(BetaDistribution)
+def _(dist: BetaDistribution):
+    return pymc.Beta('X', alpha=float(dist.alpha), beta=float(dist.beta))
+
+
+@do_sample_pymc.register(CauchyDistribution)
+def _(dist: CauchyDistribution):
+    return pymc.Cauchy('X', alpha=float(dist.x0), beta=float(dist.gamma))
+
+
+@do_sample_pymc.register(ChiSquaredDistribution)
+def _(dist: ChiSquaredDistribution):
+    return pymc.ChiSquared('X', nu=float(dist.k))
+
+
+@do_sample_pymc.register(ExponentialDistribution)
+def _(dist: ExponentialDistribution):
+    return pymc.Exponential('X', lam=float(dist.rate))
+
+
+@do_sample_pymc.register(GammaDistribution)
+def _(dist: GammaDistribution):
+    return pymc.Gamma('X', alpha=float(dist.k), beta=1 / float(dist.theta))
+
+
+@do_sample_pymc.register(LogNormalDistribution)
+def _(dist: LogNormalDistribution):
+    return pymc.Lognormal('X', mu=float(dist.mean), sigma=float(dist.std))
+
+
+@do_sample_pymc.register(NormalDistribution)
+def _(dist: NormalDistribution):
+    return pymc.Normal('X', float(dist.mean), float(dist.std))
+
+
+@do_sample_pymc.register(GaussianInverseDistribution)
+def _(dist: GaussianInverseDistribution):
+    return pymc.Wald('X', mu=float(dist.mean), lam=float(dist.shape))
+
+
+@do_sample_pymc.register(ParetoDistribution)
+def _(dist: ParetoDistribution):
+    return pymc.Pareto('X', alpha=float(dist.alpha), m=float(dist.xm))
+
+
+@do_sample_pymc.register(UniformDistribution)
+def _(dist: UniformDistribution):
+    return pymc.Uniform('X', lower=float(dist.left), upper=float(dist.right))
+
+
+# DRV:
+
+@do_sample_pymc.register(GeometricDistribution)
+def _(dist: GeometricDistribution):
+    return pymc.Geometric('X', p=float(dist.p))
+
+
+@do_sample_pymc.register(NegativeBinomialDistribution)
+def _(dist: NegativeBinomialDistribution):
+    return pymc.NegativeBinomial('X', mu=float((dist.p * dist.r) / (1 - dist.p)),
+                                  alpha=float(dist.r))
+
+
+@do_sample_pymc.register(PoissonDistribution)
+def _(dist: PoissonDistribution):
+    return pymc.Poisson('X', mu=float(dist.lamda))
+
+
+# FRV:
+
+@do_sample_pymc.register(BernoulliDistribution)
+def _(dist: BernoulliDistribution):
+    return pymc.Bernoulli('X', p=float(dist.p))
+
+
+@do_sample_pymc.register(BinomialDistribution)
+def _(dist: BinomialDistribution):
+    return pymc.Binomial('X', n=int(dist.n), p=float(dist.p))

rl/Lib/site-packages/sympy/stats/sampling/sample_scipy.py

@@ -0,0 +1,167 @@
+from functools import singledispatch
+
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.exponential import exp
+from sympy.utilities.lambdify import lambdify
+from sympy.external import import_module
+from sympy.stats import DiscreteDistributionHandmade
+from sympy.stats.crv import SingleContinuousDistribution
+from sympy.stats.crv_types import ChiSquaredDistribution, ExponentialDistribution, GammaDistribution, \
+    LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, BetaDistribution, \
+    StudentTDistribution, CauchyDistribution
+from sympy.stats.drv_types import GeometricDistribution, LogarithmicDistribution, NegativeBinomialDistribution, \
+    PoissonDistribution, SkellamDistribution, YuleSimonDistribution, ZetaDistribution
+from sympy.stats.frv import SingleFiniteDistribution
+
+
+scipy = import_module("scipy", import_kwargs={'fromlist':['stats']})
+
+
+@singledispatch
+def do_sample_scipy(dist, size, seed):
+    return None
+
+
+# CRV
+
+@do_sample_scipy.register(SingleContinuousDistribution)
+def _(dist: SingleContinuousDistribution, size, seed):
+    # if we don't need to make a handmade pdf, we won't
+    import scipy.stats
+
+    z = Dummy('z')
+    handmade_pdf = lambdify(z, dist.pdf(z), ['numpy', 'scipy'])
+
+    class scipy_pdf(scipy.stats.rv_continuous):
+        def _pdf(dist, x):
+            return handmade_pdf(x)
+
+    scipy_rv = scipy_pdf(a=float(dist.set._inf),
+                         b=float(dist.set._sup), name='scipy_pdf')
+    return scipy_rv.rvs(size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ChiSquaredDistribution)
+def _(dist: ChiSquaredDistribution, size, seed):
+    # same parametrisation
+    return scipy.stats.chi2.rvs(df=float(dist.k), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ExponentialDistribution)
+def _(dist: ExponentialDistribution, size, seed):
+    # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.expon.html#scipy.stats.expon
+    return scipy.stats.expon.rvs(scale=1 / float(dist.rate), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(GammaDistribution)
+def _(dist: GammaDistribution, size, seed):
+    # https://stackoverflow.com/questions/42150965/how-to-plot-gamma-distribution-with-alpha-and-beta-parameters-in-python
+    return scipy.stats.gamma.rvs(a=float(dist.k), scale=float(dist.theta), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(LogNormalDistribution)
+def _(dist: LogNormalDistribution, size, seed):
+    # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.lognorm.html
+    return scipy.stats.lognorm.rvs(scale=float(exp(dist.mean)), s=float(dist.std), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(NormalDistribution)
+def _(dist: NormalDistribution, size, seed):
+    return scipy.stats.norm.rvs(loc=float(dist.mean), scale=float(dist.std), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ParetoDistribution)
+def _(dist: ParetoDistribution, size, seed):
+    # https://stackoverflow.com/questions/42260519/defining-pareto-distribution-in-python-scipy
+    return scipy.stats.pareto.rvs(b=float(dist.alpha), scale=float(dist.xm), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(StudentTDistribution)
+def _(dist: StudentTDistribution, size, seed):
+    return scipy.stats.t.rvs(df=float(dist.nu), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(UniformDistribution)
+def _(dist: UniformDistribution, size, seed):
+    # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.uniform.html
+    return scipy.stats.uniform.rvs(loc=float(dist.left), scale=float(dist.right - dist.left), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(BetaDistribution)
+def _(dist: BetaDistribution, size, seed):
+    # same parametrisation
+    return scipy.stats.beta.rvs(a=float(dist.alpha), b=float(dist.beta), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(CauchyDistribution)
+def _(dist: CauchyDistribution, size, seed):
+    return scipy.stats.cauchy.rvs(loc=float(dist.x0), scale=float(dist.gamma), size=size, random_state=seed)
+
+
+# DRV:
+
+@do_sample_scipy.register(DiscreteDistributionHandmade)
+def _(dist: DiscreteDistributionHandmade, size, seed):
+    from scipy.stats import rv_discrete
+
+    z = Dummy('z')
+    handmade_pmf = lambdify(z, dist.pdf(z), ['numpy', 'scipy'])
+
+    class scipy_pmf(rv_discrete):
+        def _pmf(dist, x):
+            return handmade_pmf(x)
+
+    scipy_rv = scipy_pmf(a=float(dist.set._inf), b=float(dist.set._sup),
+                         name='scipy_pmf')
+    return scipy_rv.rvs(size=size, random_state=seed)
+
+
+@do_sample_scipy.register(GeometricDistribution)
+def _(dist: GeometricDistribution, size, seed):
+    return scipy.stats.geom.rvs(p=float(dist.p), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(LogarithmicDistribution)
+def _(dist: LogarithmicDistribution, size, seed):
+    return scipy.stats.logser.rvs(p=float(dist.p), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(NegativeBinomialDistribution)
+def _(dist: NegativeBinomialDistribution, size, seed):
+    return scipy.stats.nbinom.rvs(n=float(dist.r), p=float(dist.p), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(PoissonDistribution)
+def _(dist: PoissonDistribution, size, seed):
+    return scipy.stats.poisson.rvs(mu=float(dist.lamda), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(SkellamDistribution)
+def _(dist: SkellamDistribution, size, seed):
+    return scipy.stats.skellam.rvs(mu1=float(dist.mu1), mu2=float(dist.mu2), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(YuleSimonDistribution)
+def _(dist: YuleSimonDistribution, size, seed):
+    return scipy.stats.yulesimon.rvs(alpha=float(dist.rho), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ZetaDistribution)
+def _(dist: ZetaDistribution, size, seed):
+    return scipy.stats.zipf.rvs(a=float(dist.s), size=size, random_state=seed)
+
+
+# FRV:
+
+@do_sample_scipy.register(SingleFiniteDistribution)
+def _(dist: SingleFiniteDistribution, size, seed):
+    # scipy can handle with custom distributions
+
+    from scipy.stats import rv_discrete
+    density_ = dist.dict
+    x, y = [], []
+    for k, v in density_.items():
+        x.append(int(k))
+        y.append(float(v))
+    scipy_rv = rv_discrete(name='scipy_rv', values=(x, y))
+    return scipy_rv.rvs(size=size, random_state=seed)

rl/Lib/site-packages/sympy/stats/sampling/tests/test_sample_continuous_rv.py

@@ -0,0 +1,181 @@
+from sympy.core.numbers import oo
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import exp
+from sympy.sets.sets import Interval
+from sympy.external import import_module
+from sympy.stats import Beta, Chi, Normal, Gamma, Exponential, LogNormal, Pareto, ChiSquared, Uniform, sample, \
+    BetaPrime, Cauchy, GammaInverse, GaussianInverse, StudentT, Weibull, density, ContinuousRV, FDistribution, \
+    Gumbel, Laplace, Logistic, Rayleigh, Triangular
+from sympy.testing.pytest import skip, raises
+
+
+def test_sample_numpy():
+    distribs_numpy = [
+        Beta("B", 1, 1),
+        Normal("N", 0, 1),
+        Gamma("G", 2, 7),
+        Exponential("E", 2),
+        LogNormal("LN", 0, 1),
+        Pareto("P", 1, 1),
+        ChiSquared("CS", 2),
+        Uniform("U", 0, 1),
+        FDistribution("FD", 1, 2),
+        Gumbel("GB", 1, 2),
+        Laplace("L", 1, 2),
+        Logistic("LO", 1, 2),
+        Rayleigh("R", 1),
+        Triangular("T", 1, 2, 2),
+    ]
+    size = 3
+    numpy = import_module('numpy')
+    if not numpy:
+        skip('Numpy is not installed. Abort tests for _sample_numpy.')
+    else:
+        for X in distribs_numpy:
+            samps = sample(X, size=size, library='numpy')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+               lambda: sample(Chi("C", 1), library='numpy'))
+    raises(NotImplementedError,
+           lambda: Chi("C", 1).pspace.distribution.sample(library='tensorflow'))
+
+
+def test_sample_scipy():
+    distribs_scipy = [
+        Beta("B", 1, 1),
+        BetaPrime("BP", 1, 1),
+        Cauchy("C", 1, 1),
+        Chi("C", 1),
+        Normal("N", 0, 1),
+        Gamma("G", 2, 7),
+        GammaInverse("GI", 1, 1),
+        GaussianInverse("GUI", 1, 1),
+        Exponential("E", 2),
+        LogNormal("LN", 0, 1),
+        Pareto("P", 1, 1),
+        StudentT("S", 2),
+        ChiSquared("CS", 2),
+        Uniform("U", 0, 1)
+    ]
+    size = 3
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests for _sample_scipy.')
+    else:
+        for X in distribs_scipy:
+            samps = sample(X, size=size, library='scipy')
+            samps2 = sample(X, size=(2, 2), library='scipy')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+            for i in range(2):
+                for j in range(2):
+                    assert samps2[i][j] in X.pspace.domain.set
+
+
+def test_sample_pymc():
+    distribs_pymc = [
+        Beta("B", 1, 1),
+        Cauchy("C", 1, 1),
+        Normal("N", 0, 1),
+        Gamma("G", 2, 7),
+        GaussianInverse("GI", 1, 1),
+        Exponential("E", 2),
+        LogNormal("LN", 0, 1),
+        Pareto("P", 1, 1),
+        ChiSquared("CS", 2),
+        Uniform("U", 0, 1)
+    ]
+    size = 3
+    pymc = import_module('pymc')
+    if not pymc:
+        skip('PyMC is not installed. Abort tests for _sample_pymc.')
+    else:
+        for X in distribs_pymc:
+            samps = sample(X, size=size, library='pymc')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+               lambda: sample(Chi("C", 1), library='pymc'))
+
+
+def test_sampling_gamma_inverse():
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests for sampling of gamma inverse.')
+    X = GammaInverse("x", 1, 1)
+    assert sample(X) in X.pspace.domain.set
+
+
+def test_lognormal_sampling():
+    # Right now, only density function and sampling works
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    for i in range(3):
+        X = LogNormal('x', i, 1)
+        assert sample(X) in X.pspace.domain.set
+
+    size = 5
+    samps = sample(X, size=size)
+    for samp in samps:
+        assert samp in X.pspace.domain.set
+
+
+def test_sampling_gaussian_inverse():
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests for sampling of Gaussian inverse.')
+    X = GaussianInverse("x", 1, 1)
+    assert sample(X, library='scipy') in X.pspace.domain.set
+
+
+def test_prefab_sampling():
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    N = Normal('X', 0, 1)
+    L = LogNormal('L', 0, 1)
+    E = Exponential('Ex', 1)
+    P = Pareto('P', 1, 3)
+    W = Weibull('W', 1, 1)
+    U = Uniform('U', 0, 1)
+    B = Beta('B', 2, 5)
+    G = Gamma('G', 1, 3)
+
+    variables = [N, L, E, P, W, U, B, G]
+    niter = 10
+    size = 5
+    for var in variables:
+        for _ in range(niter):
+            assert sample(var) in var.pspace.domain.set
+            samps = sample(var, size=size)
+            for samp in samps:
+                assert samp in var.pspace.domain.set
+
+
+def test_sample_continuous():
+    z = Symbol('z')
+    Z = ContinuousRV(z, exp(-z), set=Interval(0, oo))
+    assert density(Z)(-1) == 0
+
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    assert sample(Z) in Z.pspace.domain.set
+    sym, val = list(Z.pspace.sample().items())[0]
+    assert sym == Z and val in Interval(0, oo)
+
+    libraries = ['scipy', 'numpy', 'pymc']
+    for lib in libraries:
+        try:
+            imported_lib = import_module(lib)
+            if imported_lib:
+                s0, s1, s2 = [], [], []
+                s0 = sample(Z, size=10, library=lib, seed=0)
+                s1 = sample(Z, size=10, library=lib, seed=0)
+                s2 = sample(Z, size=10, library=lib, seed=1)
+                assert all(s0 == s1)
+                assert all(s1 != s2)
+        except NotImplementedError:
+            continue

rl/Lib/site-packages/sympy/stats/sampling/tests/test_sample_discrete_rv.py

@@ -0,0 +1,99 @@
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.external import import_module
+from sympy.stats import Geometric, Poisson, Zeta, sample, Skellam, DiscreteRV, Logarithmic, NegativeBinomial, YuleSimon
+from sympy.testing.pytest import skip, raises, slow
+
+
+def test_sample_numpy():
+    distribs_numpy = [
+        Geometric('G', 0.5),
+        Poisson('P', 1),
+        Zeta('Z', 2)
+    ]
+    size = 3
+    numpy = import_module('numpy')
+    if not numpy:
+        skip('Numpy is not installed. Abort tests for _sample_numpy.')
+    else:
+        for X in distribs_numpy:
+            samps = sample(X, size=size, library='numpy')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+               lambda: sample(Skellam('S', 1, 1), library='numpy'))
+    raises(NotImplementedError,
+           lambda: Skellam('S', 1, 1).pspace.distribution.sample(library='tensorflow'))
+
+
+def test_sample_scipy():
+    p = S(2)/3
+    x = Symbol('x', integer=True, positive=True)
+    pdf = p*(1 - p)**(x - 1) # pdf of Geometric Distribution
+    distribs_scipy = [
+        DiscreteRV(x, pdf, set=S.Naturals),
+        Geometric('G', 0.5),
+        Logarithmic('L', 0.5),
+        NegativeBinomial('N', 5, 0.4),
+        Poisson('P', 1),
+        Skellam('S', 1, 1),
+        YuleSimon('Y', 1),
+        Zeta('Z', 2)
+    ]
+    size = 3
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests for _sample_scipy.')
+    else:
+        for X in distribs_scipy:
+            samps = sample(X, size=size, library='scipy')
+            samps2 = sample(X, size=(2, 2), library='scipy')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+            for i in range(2):
+                for j in range(2):
+                    assert samps2[i][j] in X.pspace.domain.set
+
+
+def test_sample_pymc():
+    distribs_pymc = [
+        Geometric('G', 0.5),
+        Poisson('P', 1),
+        NegativeBinomial('N', 5, 0.4)
+    ]
+    size = 3
+    pymc = import_module('pymc')
+    if not pymc:
+        skip('PyMC is not installed. Abort tests for _sample_pymc.')
+    else:
+        for X in distribs_pymc:
+            samps = sample(X, size=size, library='pymc')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+               lambda: sample(Skellam('S', 1, 1), library='pymc'))
+
+@slow
+def test_sample_discrete():
+    X = Geometric('X', S.Half)
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests')
+    assert sample(X) in X.pspace.domain.set
+    samps = sample(X, size=2) # This takes long time if ran without scipy
+    for samp in samps:
+        assert samp in X.pspace.domain.set
+
+    libraries = ['scipy', 'numpy', 'pymc']
+    for lib in libraries:
+        try:
+            imported_lib = import_module(lib)
+            if imported_lib:
+                s0, s1, s2 = [], [], []
+                s0 = sample(X, size=10, library=lib, seed=0)
+                s1 = sample(X, size=10, library=lib, seed=0)
+                s2 = sample(X, size=10, library=lib, seed=1)
+                assert all(s0 == s1)
+                assert not all(s1 == s2)
+        except NotImplementedError:
+            continue

rl/Lib/site-packages/sympy/stats/sampling/tests/test_sample_finite_rv.py

@@ -0,0 +1,94 @@
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.external import import_module
+from sympy.stats import Binomial, sample, Die, FiniteRV, DiscreteUniform, Bernoulli, BetaBinomial, Hypergeometric, \
+    Rademacher
+from sympy.testing.pytest import skip, raises
+
+def test_given_sample():
+    X = Die('X', 6)
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    assert sample(X, X > 5) == 6
+
+def test_sample_numpy():
+    distribs_numpy = [
+        Binomial("B", 5, 0.4),
+        Hypergeometric("H", 2, 1, 1)
+    ]
+    size = 3
+    numpy = import_module('numpy')
+    if not numpy:
+        skip('Numpy is not installed. Abort tests for _sample_numpy.')
+    else:
+        for X in distribs_numpy:
+            samps = sample(X, size=size, library='numpy')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+               lambda: sample(Die("D"), library='numpy'))
+    raises(NotImplementedError,
+           lambda: Die("D").pspace.sample(library='tensorflow'))
+
+
+def test_sample_scipy():
+    distribs_scipy = [
+        FiniteRV('F', {1: S.Half, 2: Rational(1, 4), 3: Rational(1, 4)}),
+        DiscreteUniform("Y", list(range(5))),
+        Die("D"),
+        Bernoulli("Be", 0.3),
+        Binomial("Bi", 5, 0.4),
+        BetaBinomial("Bb", 2, 1, 1),
+        Hypergeometric("H", 1, 1, 1),
+        Rademacher("R")
+    ]
+
+    size = 3
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests for _sample_scipy.')
+    else:
+        for X in distribs_scipy:
+            samps = sample(X, size=size)
+            samps2 = sample(X, size=(2, 2))
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+            for i in range(2):
+                for j in range(2):
+                    assert samps2[i][j] in X.pspace.domain.set
+
+
+def test_sample_pymc():
+    distribs_pymc = [
+        Bernoulli('B', 0.2),
+        Binomial('N', 5, 0.4)
+    ]
+    size = 3
+    pymc = import_module('pymc')
+    if not pymc:
+        skip('PyMC is not installed. Abort tests for _sample_pymc.')
+    else:
+        for X in distribs_pymc:
+            samps = sample(X, size=size, library='pymc')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+                          lambda: (sample(Die("D"), library='pymc')))
+
+
+def test_sample_seed():
+    F = FiniteRV('F', {1: S.Half, 2: Rational(1, 4), 3: Rational(1, 4)})
+    size = 10
+    libraries = ['scipy', 'numpy', 'pymc']
+    for lib in libraries:
+        try:
+            imported_lib = import_module(lib)
+            if imported_lib:
+                s0 = sample(F, size=size, library=lib, seed=0)
+                s1 = sample(F, size=size, library=lib, seed=0)
+                s2 = sample(F, size=size, library=lib, seed=1)
+                assert all(s0 == s1)
+                assert not all(s1 == s2)
+        except NotImplementedError:
+            continue