def test_Compound_Distribution(): X = Normal('X', 2, 4) N = NormalDistribution(X, 4) C = CompoundDistribution(N) assert C.is_Continuous assert C.set == Interval(-oo, oo) assert C.pdf(x, evaluate=True).simplify() == exp(-x**2 / 64 + x / 16 - S(1) / 16) / (8 * sqrt(pi)) assert not isinstance(CompoundDistribution(NormalDistribution(2, 3)), CompoundDistribution) M = MultivariateNormalDistribution([1, 2], [[2, 1], [1, 2]]) raises(NotImplementedError, lambda: CompoundDistribution(M)) X = Beta('X', 2, 4) B = BernoulliDistribution(X, 1, 0) C = CompoundDistribution(B) assert C.is_Finite assert C.set == {0, 1} y = symbols('y', negative=False, integer=True) assert C.pdf(y, evaluate=True) == Piecewise( (S(1) / (30 * beta(2, 4)), Eq(y, 0)), (S(1) / (60 * beta(2, 4)), Eq(y, 1)), (0, True)) k, t, z = symbols('k t z', positive=True, real=True) G = Gamma('G', k, t) X = PoissonDistribution(G) C = CompoundDistribution(X) assert C.is_Discrete assert C.set == S.Naturals0 assert C.pdf(z, evaluate=True).simplify() == t**z*(t + 1)**(-k - z)*gamma(k \ + z)/(gamma(k)*gamma(z + 1))
def test_beta_scipy(): if not scipy: skip("scipy not installed") f = beta(x, y) F = lambdify((x, y), f, modules='scipy') assert abs(beta(1.3, 2.3) - F(1.3, 2.3)) <= 1e-10
def apply(m, n=1): m = sympify(m) n = sympify(n) x = Symbol.x(real=True) return Equality(Integral[x:0:S.Pi / 2](cos(x)**(m - 1) * sin(x)**(n - 1)), beta(m / 2, n / 2) / 2)
def test_yule_simon(): from sympy.core.singleton import S rho = S(3) x = YuleSimon('x', rho) assert simplify(E(x)) == rho / (rho - 1) assert simplify(variance(x)) == rho**2 / ((rho - 1)**2 * (rho - 2)) assert isinstance(E(x, evaluate=False), Expectation) # To test the cdf function assert cdf(x)(x) == Piecewise((-beta(floor(x), 4) * floor(x) + 1, x >= 1), (0, True))
def test_beta(): a, b, x = symbols("a b x", positive=True) e = x**(a - 1) * (-x + 1)**(b - 1) / beta(a, b) Q = QQ[a, b].get_field() h1 = expr_to_holonomic(e, x, domain=Q) _, Dx = DifferentialOperators(Q.old_poly_ring(x), 'Dx') h2 = HolonomicFunction((a + x * (-a - b + 2) - 1) + (x**2 - x) * Dx, x) assert h1 == h2
def test_betainc(): a, b, x1, x2 = symbols('a b x1 x2') assert unchanged(betainc, a, b, x1, x2) assert unchanged(betainc, a, b, 0, x1) assert betainc(1, 2, 0, -5).is_real == True assert betainc(1, 2, 0, x2).is_real is None assert conjugate(betainc(I, 2, 3 - I, 1 + 4*I)) == betainc(-I, 2, 3 + I, 1 - 4*I) assert betainc(a, b, 0, 1).rewrite(Integral).dummy_eq(beta(a, b).rewrite(Integral)) assert betainc(1, 2, 0, x2).rewrite(hyper) == x2*hyper((1, -1), (2,), x2) assert betainc(1, 2, 3, 3).evalf() == 0
def test_beta(): from sympy.functions.special.beta_functions import beta expr = beta(x, y) prntr = SciPyPrinter() assert prntr.doprint(expr) == 'scipy.special.beta(x, y)' prntr = NumPyPrinter() assert prntr.doprint(expr) == 'math.gamma(x)*math.gamma(y)/math.gamma(x + y)' prntr = PythonCodePrinter() assert prntr.doprint(expr) == 'math.gamma(x)*math.gamma(y)/math.gamma(x + y)' prntr = PythonCodePrinter({'allow_unknown_functions': True}) assert prntr.doprint(expr) == 'math.gamma(x)*math.gamma(y)/math.gamma(x + y)' prntr = MpmathPrinter() assert prntr.doprint(expr) == 'mpmath.beta(x, y)'
def test_beta(): x, y = symbols('x y') t = Dummy('t') assert unchanged(beta, x, y) assert beta(5, -3).is_real == True assert beta(3, y).is_real is None assert expand_func(beta(x, y)) == gamma(x)*gamma(y)/gamma(x + y) assert expand_func(beta(x, y) - beta(y, x)) == 0 # Symmetric assert expand_func(beta(x, y)) == expand_func(beta(x, y + 1) + beta(x + 1, y)).simplify() assert diff(beta(x, y), x) == beta(x, y)*(polygamma(0, x) - polygamma(0, x + y)) assert diff(beta(x, y), y) == beta(x, y)*(polygamma(0, y) - polygamma(0, x + y)) assert conjugate(beta(x, y)) == beta(conjugate(x), conjugate(y)) raises(ArgumentIndexError, lambda: beta(x, y).fdiff(3)) assert beta(x, y).rewrite(gamma) == gamma(x)*gamma(y)/gamma(x + y) assert beta(x).rewrite(gamma) == gamma(x)**2/gamma(2*x) assert beta(x, y).rewrite(Integral).dummy_eq(Integral(t**(x - 1) * (1 - t)**(y - 1), (t, 0, 1)))
def test_beta_binomial(): # verify parameters raises(ValueError, lambda: BetaBinomial('b', .2, 1, 2)) raises(ValueError, lambda: BetaBinomial('b', 2, -1, 2)) raises(ValueError, lambda: BetaBinomial('b', 2, 1, -2)) assert BetaBinomial('b', 2, 1, 1) # test numeric values nvals = range(1, 5) alphavals = [Rational(1, 4), S.Half, Rational(3, 4), 1, 10] betavals = [Rational(1, 4), S.Half, Rational(3, 4), 1, 10] for n in nvals: for a in alphavals: for b in betavals: X = BetaBinomial('X', n, a, b) assert E(X) == moment(X, 1) assert variance(X) == cmoment(X, 2) # test symbolic n, a, b = symbols('a b n') assert BetaBinomial('x', n, a, b) n = 2 # Because we're using for loops, can't do symbolic n a, b = symbols('a b', positive=True) X = BetaBinomial('X', n, a, b) t = Symbol('t') assert E(X).expand() == moment(X, 1).expand() assert variance(X).expand() == cmoment(X, 2).expand() assert skewness(X) == smoment(X, 3) assert characteristic_function(X)(t) == exp(2*I*t)*beta(a + 2, b)/beta(a, b) +\ 2*exp(I*t)*beta(a + 1, b + 1)/beta(a, b) + beta(a, b + 2)/beta(a, b) assert moment_generating_function(X)(t) == exp(2*t)*beta(a + 2, b)/beta(a, b) +\ 2*exp(t)*beta(a + 1, b + 1)/beta(a, b) + beta(a, b + 2)/beta(a, b)
def test_beta_math(): f = beta(x, y) F = lambdify((x, y), f, modules='math') assert abs(beta(1.3, 2.3) - F(1.3, 2.3)) <= 1e-10
def _cdf(self, x): return Piecewise((1 - floor(x) * beta(floor(x), self.rho + 1), x >= 1), (0, True))
def pdf(self, k): rho = self.rho return rho * beta(k, rho + 1)
def densi_frac(p_val, c_val, m_val, n_val, pri_val, frac_type): """Calculates the prior density of a ratio of beta distributions.\ Is used in interval calculations. Parameters ========== p_val : Number of exposed in group one c_val : Number of exposed in group two m_val : Total number in group one n_val : Total number in group two pri_val : Tuple containing belief parameters for the two beta distributions,\ B(c_val + pi1, n_val - c_val + pi2) and B(p_val + pi3, m_val - p_val + pi4),\ given in the order: pi1, pi2, pi3, pi4 frac_type : Desired ratio - relative risk ("risk") or odds ratio ("odds") Returns ======= The denstity function for these inputs Raises ====== TypeError Count inputs must be integers ValueError frac_type must be "risk" or "odds" C must be larger than pi1 N - C must be larger than pi2 P must be larger than pi3 M - P must be larger than pi4 One or more counts are negative P + N + pi1 + pi2 + pi3 must be positive 'P + pi3 + 1 must be positive C + M + pi1 + pi2 + pi3 must be positive C + pi3 + 1 must be positive See Also ======= distri_frac : Posterior density Examples ======== >>> densi_frac(56, 126, 366, 354, (0, 0, 0, 0), "risk") >>> densi_frac(25, 108, 123, 313, (0, 0, 0, 0), "risk") """ if not (isinstance(p_val, int) and isinstance(c_val, int) and isinstance(m_val, int) and isinstance(n_val, int)): raise TypeError('Count inputs must be integers') if c_val <= pri_val[0]: raise ValueError('C ({:f}) must be larger than pi1 ({:f})'.format( c_val, pri_val[0])) elif n_val - c_val <= pri_val[1]: raise ValueError('N - C ({:f}) must be larger than pi2 ({:f})'.format( n_val - c_val, pri_val[1])) elif p_val <= pri_val[2]: raise ValueError('P ({:f}) must be larger than pi3 ({:f})'.format( p_val, pri_val[2])) elif m_val - p_val <= pri_val[3]: raise ValueError('M - P ({:f}) must be larger than pi4 ({:f})'.format( m_val - p_val, pri_val[3])) elif c_val < 0 or p_val < 0 or n_val < 0 or m_val < 0: raise ValueError('One or more counts are negative') else: if frac_type == 'risk': dens = Piecewise( (beta(alpha + theta, b) / (beta(alpha, b) * beta(theta, phi)) * z**(theta - 1) * hyper( (alpha + theta, 1 - phi), (alpha + theta + b, ), z), z <= 1), # this comma needs to be here for hyper to work ^ (beta(alpha + theta, phi) / (beta(alpha, b) * beta(theta, phi)) * z**(-(1 + alpha)) * hyper((alpha + theta, 1 - b), (alpha + theta + phi, ), 1 / z), z > 1)) # this comma needs to be here for hyper to work ^ elif frac_type == 'odds': dens = Piecewise( (beta(alpha + theta, b + phi) / (beta(alpha, b) * beta(theta, phi)) * z**(theta - 1) * hyper( (alpha + theta, theta + phi), (alpha + theta + b + phi, ), z), z <= 1), (beta(alpha + theta, b + phi) / (beta(alpha, b) * beta(theta, phi)) * z**(-(1 + phi)) * hyper( (phi + theta, phi + b), (alpha + theta + b + phi, ), 1 / z), z > 1)) else: raise ValueError('frac_type must be "risk" or "odds"') dens = dens.subs({ alpha: C + PI_1, b: N - C + PI_2, theta: P + PI_3, phi: M - P + PI_4 }) return dens