def test_f_distribution(): d1 = Symbol("d1", positive=True) d2 = Symbol("d2", positive=True) X = FDistribution("x", d1, d2) assert density(X)(x) == (d2**(d2/2)*sqrt((d1*x)**d1*(d1*x + d2)**(-d1 - d2)) /(x*beta(d1/2, d2/2)))
def test_fisher_z(): d1 = Symbol("d1", positive=True) d2 = Symbol("d2", positive=True) X = FisherZ("x", d1, d2) assert density(X)(x) == (2*d1**(d1/2)*d2**(d2/2)*(d1*exp(2*x) + d2) **(-d1/2 - d2/2)*exp(d1*x)/beta(d1/2, d2/2))
def test_studentt(): nu = Symbol("nu", positive=True) X = StudentT('x', nu) assert density(X)(x) == (1 + x**2/nu)**(-nu/2 - S(1)/2)/(sqrt(nu)*beta(S(1)/2, nu/2)) assert cdf(X)(x) == S(1)/2 + x*gamma(nu/2 + S(1)/2)*hyper((S(1)/2, nu/2 + S(1)/2), (S(3)/2,), -x**2/nu)/(sqrt(pi)*sqrt(nu)*gamma(nu/2))
def test_yule_simon(): from sympy 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), Sum) # To test the cdf function assert cdf(x)(x) == Piecewise((-beta(floor(x), 4)*floor(x) + 1, x >= 1), (0, True))
def test_studentt(): nu = Symbol("nu", positive=True) X = StudentT('x', nu) assert density(X)(x) == (1 + x**2 / nu)**(-nu / 2 - S.Half) / ( sqrt(nu) * beta(S.Half, nu / 2)) assert cdf(X)(x) == S.Half + x * gamma(nu / 2 + S.Half) * hyper( (S.Half, nu / 2 + S.Half), (Rational(3, 2), ), -x**2 / nu) / (sqrt(pi) * sqrt(nu) * gamma(nu / 2))
def test_studentt(): nu = Symbol("nu", positive=True) X = StudentT('x', nu) assert density(X)(x) == (1 + x**2 / nu)**(-nu / 2 - S(1) / 2) / ( sqrt(nu) * beta(S(1) / 2, nu / 2)) assert cdf(X)(x) == S(1) / 2 + x * gamma(nu / 2 + S(1) / 2) * hyper( (S(1) / 2, nu / 2 + S(1) / 2), (S(3) / 2, ), -x**2 / nu) / (sqrt(pi) * sqrt(nu) * gamma(nu / 2))
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_yule_simon(): from sympy 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)) with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed 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_betaprime(): alpha = Symbol("alpha", positive=True) betap = Symbol("beta", positive=True) X = BetaPrime('x', alpha, betap) assert density(X)(x) == x**(alpha - 1)*(x + 1)**(-alpha - betap)/beta(alpha, betap) alpha = Symbol("alpha", positive=False) raises(ValueError, lambda: BetaPrime('x', alpha, betap)) alpha = Symbol("alpha", positive=True) betap = Symbol("beta", positive=False) raises(ValueError, lambda: BetaPrime('x', alpha, betap))
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_hyper(): for x in sorted(exparg): test("erf", x, N(sp.erf(x))) for x in sorted(exparg): test("erfc", x, N(sp.erfc(x))) gamarg = FiniteSet(*(x+S(1)/12 for x in exparg)) betarg = ProductSet(gamarg, gamarg) for x in sorted(gamarg): test("lgamma", x, N(sp.log(abs(sp.gamma(x))))) for x in sorted(gamarg): test("gamma", x, N(sp.gamma(x))) for x, y in sorted(betarg, key=lambda (x, y): (y, x)): test("beta", x, y, N(sp.beta(x, y))) pgamarg = FiniteSet(S(1)/12, S(1)/3, S(3)/2, 5) pgamargp = ProductSet(gamarg & Interval(0, oo, True), pgamarg) for a, x in sorted(pgamargp): test("pgamma", a, x, N(sp.lowergamma(a, x))) for a, x in sorted(pgamargp): test("pgammac", a, x, N(sp.uppergamma(a, x))) for a, x in sorted(pgamargp): test("pgammar", a, x, N(sp.lowergamma(a, x)/sp.gamma(a))) for a, x in sorted(pgamargp): test("pgammarc", a, x, N(sp.uppergamma(a, x)/sp.gamma(a))) for a, x in sorted(pgamargp): test("ipgammarc", a, N(sp.uppergamma(a, x)/sp.gamma(a)), x) pbetargp = [(a, b, x) for a, b, x in ProductSet(betarg, pgamarg) if a > 0 and b > 0 and x < 1] pbetargp.sort(key=lambda (a, b, x): (b, a, x)) for a, b, x in pbetargp: test("pbeta", a, b, x, mp.betainc(mpf(a), mpf(b), x2=mpf(x))) for a, b, x in pbetargp: test("pbetar", a, b, x, mp.betainc(mpf(a), mpf(b), x2=mpf(x), regularized=True)) for a, b, x in pbetargp: test("ipbetar", a, b, mp.betainc(mpf(a), mpf(b), x2=mpf(x), regularized=True), x) for x in sorted(posarg): test("j0", x, N(sp.besselj(0, x))) for x in sorted(posarg): test("j1", x, N(sp.besselj(1, x))) for x in sorted(posarg-FiniteSet(0)): test("y0", x, N(sp.bessely(0, x))) for x in sorted(posarg-FiniteSet(0)): test("y1", x, N(sp.bessely(1, x)))
def test_hyper(): for x in sorted(exparg): test("erf", x, N(sp.erf(x))) for x in sorted(exparg): test("erfc", x, N(sp.erfc(x))) gamarg = FiniteSet(*(x + S(1) / 12 for x in exparg)) betarg = ProductSet(gamarg, gamarg) for x in sorted(gamarg): test("lgamma", x, N(sp.log(abs(sp.gamma(x))))) for x in sorted(gamarg): test("gamma", x, N(sp.gamma(x))) for x, y in sorted(betarg, key=lambda (x, y): (y, x)): test("beta", x, y, N(sp.beta(x, y))) pgamarg = FiniteSet(S(1) / 12, S(1) / 3, S(3) / 2, 5) pgamargp = ProductSet(gamarg & Interval(0, oo, True), pgamarg) for a, x in sorted(pgamargp): test("pgamma", a, x, N(sp.lowergamma(a, x))) for a, x in sorted(pgamargp): test("pgammac", a, x, N(sp.uppergamma(a, x))) for a, x in sorted(pgamargp): test("pgammar", a, x, N(sp.lowergamma(a, x) / sp.gamma(a))) for a, x in sorted(pgamargp): test("pgammarc", a, x, N(sp.uppergamma(a, x) / sp.gamma(a))) for a, x in sorted(pgamargp): test("ipgammarc", a, N(sp.uppergamma(a, x) / sp.gamma(a)), x) pbetargp = [(a, b, x) for a, b, x in ProductSet(betarg, pgamarg) if a > 0 and b > 0 and x < 1] pbetargp.sort(key=lambda (a, b, x): (b, a, x)) for a, b, x in pbetargp: test("pbeta", a, b, x, mp.betainc(mpf(a), mpf(b), x2=mpf(x))) for a, b, x in pbetargp: test("pbetar", a, b, x, mp.betainc(mpf(a), mpf(b), x2=mpf(x), regularized=True)) for a, b, x in pbetargp: test("ipbetar", a, b, mp.betainc(mpf(a), mpf(b), x2=mpf(x), regularized=True), x) for x in sorted(posarg): test("j0", x, N(sp.besselj(0, x))) for x in sorted(posarg): test("j1", x, N(sp.besselj(1, x))) for x in sorted(posarg - FiniteSet(0)): test("y0", x, N(sp.bessely(0, x))) for x in sorted(posarg - FiniteSet(0)): test("y1", x, N(sp.bessely(1, x)))
def test_beta(): from sympy 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 = MpmathPrinter() assert prntr.doprint(expr) == 'mpmath.beta(x, y)'
def test_beta(): a, b = symbols('alpha beta', positive=True) B = Beta('x', a, b) assert pspace(B).domain.set == Interval(0, 1) assert characteristic_function(B)(x) == hyper((a,), (a + b,), I*x) assert density(B)(x) == x**(a - 1)*(1 - x)**(b - 1)/beta(a, b) assert simplify(E(B)) == a / (a + b) assert simplify(variance(B)) == a*b / (a**3 + 3*a**2*b + a**2 + 3*a*b**2 + 2*a*b + b**3 + b**2) # Full symbolic solution is too much, test with numeric version a, b = 1, 2 B = Beta('x', a, b) assert expand_func(E(B)) == a / S(a + b) assert expand_func(variance(B)) == (a*b) / S((a + b)**2 * (a + b + 1))
def test_betaprime(): alpha = Symbol("alpha", positive=True) betap = Symbol("beta", positive=True) X = BetaPrime('x', alpha, betap) assert density(X)(x) == x**(alpha - 1)*(x + 1)**(-alpha - betap)/beta(alpha, betap) alpha = Symbol("alpha", nonpositive=True) raises(ValueError, lambda: BetaPrime('x', alpha, betap)) alpha = Symbol("alpha", positive=True) betap = Symbol("beta", nonpositive=True) raises(ValueError, lambda: BetaPrime('x', alpha, betap)) X = BetaPrime('x', 1, 1) assert median(X) == FiniteSet(1)
def test_beta(): a, b = symbols('alpha beta', positive=True) B = Beta('x', a, b) assert pspace(B).domain.set == Interval(0, 1) dens = density(B) x = Symbol('x') assert dens(x) == x**(a - 1)*(1 - x)**(b - 1) / beta(a, b) assert simplify(E(B)) == a / (a + b) assert simplify(variance(B)) == a*b / (a**3 + 3*a**2*b + a**2 + 3*a*b**2 + 2*a*b + b**3 + b**2) # Full symbolic solution is too much, test with numeric version a, b = 1, 2 B = Beta('x', a, b) assert expand_func(E(B)) == a / S(a + b) assert expand_func(variance(B)) == (a*b) / S((a + b)**2 * (a + b + 1))
def test_beta(): a, b = symbols('alpha beta', positive=True) B = Beta(a, b) assert pspace(B).domain.set == Interval(0, 1) x, dens = Density(B) assert dens == x**(a-1)*(1-x)**(b-1) / beta(a,b) # This is too slow # assert E(B) == a / (a + b) # assert Var(B) == (a*b) / ((a+b)**2 * (a+b+1)) # Full symbolic solution is too much, test with numeric version a, b = 1, 2 B = Beta(a, b) assert E(B) == a / S(a + b) assert Var(B) == (a*b) / S((a+b)**2 * (a+b+1))
def test_beta(): a, b = symbols("alpha beta", positive=True) B = Beta("x", a, b) assert pspace(B).domain.set == Interval(0, 1) dens = density(B) x = Symbol("x") assert dens(x) == x ** (a - 1) * (1 - x) ** (b - 1) / beta(a, b) # This is too slow # assert E(B) == a / (a + b) # assert variance(B) == (a*b) / ((a+b)**2 * (a+b+1)) # Full symbolic solution is too much, test with numeric version a, b = 1, 2 B = Beta("x", a, b) assert expand_func(E(B)) == a / S(a + b) assert expand_func(variance(B)) == (a * b) / S((a + b) ** 2 * (a + b + 1))
def test_beta(): a, b = symbols('alpha beta', positive=True) B = Beta('x', a, b) assert pspace(B).domain.set == Interval(0, 1) dens = density(B) x = Symbol('x') assert dens(x) == x**(a - 1)*(1 - x)**(b - 1) / beta(a, b) # This is too slow # assert E(B) == a / (a + b) # assert variance(B) == (a*b) / ((a+b)**2 * (a+b+1)) # Full symbolic solution is too much, test with numeric version a, b = 1, 2 B = Beta('x', a, b) assert expand_func(E(B)) == a / S(a + b) assert expand_func(variance(B)) == (a*b) / S((a + b)**2 * (a + b + 1))
def test_f_distribution(): d1 = Symbol("d1", positive=True) d2 = Symbol("d2", positive=True) X = FDistribution("x", d1, d2) assert density(X)(x) == (d2**(d2 / 2) * sqrt( (d1 * x)**d1 * (d1 * x + d2)**(-d1 - d2)) / (x * beta(d1 / 2, d2 / 2))) d1 = Symbol("d1", positive=False) raises(ValueError, lambda: FDistribution('x', d1, d1)) d1 = Symbol("d1", positive=True, integer=False) raises(ValueError, lambda: FDistribution('x', d1, d1)) d1 = Symbol("d1", positive=True) d2 = Symbol("d2", positive=False) raises(ValueError, lambda: FDistribution('x', d1, d2)) d2 = Symbol("d2", positive=True, integer=False) raises(ValueError, lambda: FDistribution('x', d1, d2))
def test_f_distribution(): d1 = Symbol("d1", positive=True) d2 = Symbol("d2", positive=True) X = FDistribution("x", d1, d2) assert density(X)(x) == (d2**(d2/2)*sqrt((d1*x)**d1*(d1*x + d2)**(-d1 - d2)) /(x*beta(d1/2, d2/2))) d1 = Symbol("d1", positive=False) raises(ValueError, lambda: FDistribution('x', d1, d1)) d1 = Symbol("d1", positive=True, integer=False) raises(ValueError, lambda: FDistribution('x', d1, d1)) d1 = Symbol("d1", positive=True) d2 = Symbol("d2", positive=False) raises(ValueError, lambda: FDistribution('x', d1, d2)) d2 = Symbol("d2", positive=True, integer=False) raises(ValueError, lambda: FDistribution('x', d1, d2))
def test_beta(): from sympy 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 = Symbol('x'), Symbol('y') assert isinstance(beta(x, y), beta) 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)*(digamma(x) - digamma(x + y)) assert diff(beta(x, y), y) == beta(x, y)*(digamma(y) - digamma(x + y))
def pdf(self, k): rho = self.rho return rho * beta(k, rho + 1)
def test_betaprime(): alpha = Symbol("alpha", positive=True) betap = Symbol("beta", positive=True) X = BetaPrime('x', alpha, betap) assert density(X)(x) == x**(alpha - 1)*(x + 1)**(-alpha - betap)/beta(alpha, betap)
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 = [S(1) / 4, S.Half, S(3) / 4, 1, 10] betavals = [S(1) / 4, S.Half, S(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 _cdf(self, x): return Piecewise((1 - floor(x) * beta(floor(x), self.rho + 1), x >= 1), (0, True))
def test_beta_function(): x, y = Symbol('x'), Symbol('y') assert beta(x,y) == gamma(x)*gamma(y)/gamma(x+y) assert beta(x,y) == beta(y,x) # Symmetric
def test_moment_generating_function(): t = symbols('t', positive=True) # Symbolic tests a, b, c = symbols('a b c') mgf = moment_generating_function(Beta('x', a, b))(t) assert mgf == hyper((a, ), (a + b, ), t) mgf = moment_generating_function(Chi('x', a))(t) assert mgf == sqrt(2)*t*gamma(a/2 + S.Half)*\ hyper((a/2 + S.Half,), (Rational(3, 2),), t**2/2)/gamma(a/2) +\ hyper((a/2,), (S.Half,), t**2/2) mgf = moment_generating_function(ChiSquared('x', a))(t) assert mgf == (1 - 2 * t)**(-a / 2) mgf = moment_generating_function(Erlang('x', a, b))(t) assert mgf == (1 - t / b)**(-a) mgf = moment_generating_function(ExGaussian("x", a, b, c))(t) assert mgf == exp(a * t + b**2 * t**2 / 2) / (1 - t / c) mgf = moment_generating_function(Exponential('x', a))(t) assert mgf == a / (a - t) mgf = moment_generating_function(Gamma('x', a, b))(t) assert mgf == (-b * t + 1)**(-a) mgf = moment_generating_function(Gumbel('x', a, b))(t) assert mgf == exp(b * t) * gamma(-a * t + 1) mgf = moment_generating_function(Gompertz('x', a, b))(t) assert mgf == b * exp(b) * expint(t / a, b) mgf = moment_generating_function(Laplace('x', a, b))(t) assert mgf == exp(a * t) / (-b**2 * t**2 + 1) mgf = moment_generating_function(Logistic('x', a, b))(t) assert mgf == exp(a * t) * beta(-b * t + 1, b * t + 1) mgf = moment_generating_function(Normal('x', a, b))(t) assert mgf == exp(a * t + b**2 * t**2 / 2) mgf = moment_generating_function(Pareto('x', a, b))(t) assert mgf == b * (-a * t)**b * uppergamma(-b, -a * t) mgf = moment_generating_function(QuadraticU('x', a, b))(t) assert str(mgf) == ( "(3*(t*(-4*b + (a + b)**2) + 4)*exp(b*t) - " "3*(t*(a**2 + 2*a*(b - 2) + b**2) + 4)*exp(a*t))/(t**2*(a - b)**3)") mgf = moment_generating_function(RaisedCosine('x', a, b))(t) assert mgf == pi**2 * exp(a * t) * sinh(b * t) / (b * t * (b**2 * t**2 + pi**2)) mgf = moment_generating_function(Rayleigh('x', a))(t) assert mgf == sqrt(2)*sqrt(pi)*a*t*(erf(sqrt(2)*a*t/2) + 1)\ *exp(a**2*t**2/2)/2 + 1 mgf = moment_generating_function(Triangular('x', a, b, c))(t) assert str(mgf) == ("(-2*(-a + b)*exp(c*t) + 2*(-a + c)*exp(b*t) + " "2*(b - c)*exp(a*t))/(t**2*(-a + b)*(-a + c)*(b - c))") mgf = moment_generating_function(Uniform('x', a, b))(t) assert mgf == (-exp(a * t) + exp(b * t)) / (t * (-a + b)) mgf = moment_generating_function(UniformSum('x', a))(t) assert mgf == ((exp(t) - 1) / t)**a mgf = moment_generating_function(WignerSemicircle('x', a))(t) assert mgf == 2 * besseli(1, a * t) / (a * t) # Numeric tests mgf = moment_generating_function(Beta('x', 1, 1))(t) assert mgf.diff(t).subs(t, 1) == hyper((2, ), (3, ), 1) / 2 mgf = moment_generating_function(Chi('x', 1))(t) assert mgf.diff(t).subs(t, 1) == sqrt(2) * hyper( (1, ), (Rational(3, 2), ), S.Half) / sqrt(pi) + hyper( (Rational(3, 2), ), (Rational(3, 2), ), S.Half) + 2 * sqrt(2) * hyper( (2, ), (Rational(5, 2), ), S.Half) / (3 * sqrt(pi)) mgf = moment_generating_function(ChiSquared('x', 1))(t) assert mgf.diff(t).subs(t, 1) == I mgf = moment_generating_function(Erlang('x', 1, 1))(t) assert mgf.diff(t).subs(t, 0) == 1 mgf = moment_generating_function(ExGaussian("x", 0, 1, 1))(t) assert mgf.diff(t).subs(t, 2) == -exp(2) mgf = moment_generating_function(Exponential('x', 1))(t) assert mgf.diff(t).subs(t, 0) == 1 mgf = moment_generating_function(Gamma('x', 1, 1))(t) assert mgf.diff(t).subs(t, 0) == 1 mgf = moment_generating_function(Gumbel('x', 1, 1))(t) assert mgf.diff(t).subs(t, 0) == EulerGamma + 1 mgf = moment_generating_function(Gompertz('x', 1, 1))(t) assert mgf.diff(t).subs(t, 1) == -e * meijerg(((), (1, 1)), ((0, 0, 0), ()), 1) mgf = moment_generating_function(Laplace('x', 1, 1))(t) assert mgf.diff(t).subs(t, 0) == 1 mgf = moment_generating_function(Logistic('x', 1, 1))(t) assert mgf.diff(t).subs(t, 0) == beta(1, 1) mgf = moment_generating_function(Normal('x', 0, 1))(t) assert mgf.diff(t).subs(t, 1) == exp(S.Half) mgf = moment_generating_function(Pareto('x', 1, 1))(t) assert mgf.diff(t).subs(t, 0) == expint(1, 0) mgf = moment_generating_function(QuadraticU('x', 1, 2))(t) assert mgf.diff(t).subs(t, 1) == -12 * e - 3 * exp(2) mgf = moment_generating_function(RaisedCosine('x', 1, 1))(t) assert mgf.diff(t).subs(t, 1) == -2*e*pi**2*sinh(1)/\ (1 + pi**2)**2 + e*pi**2*cosh(1)/(1 + pi**2) mgf = moment_generating_function(Rayleigh('x', 1))(t) assert mgf.diff(t).subs(t, 0) == sqrt(2) * sqrt(pi) / 2 mgf = moment_generating_function(Triangular('x', 1, 3, 2))(t) assert mgf.diff(t).subs(t, 1) == -e + exp(3) mgf = moment_generating_function(Uniform('x', 0, 1))(t) assert mgf.diff(t).subs(t, 1) == 1 mgf = moment_generating_function(UniformSum('x', 1))(t) assert mgf.diff(t).subs(t, 1) == 1 mgf = moment_generating_function(WignerSemicircle('x', 1))(t) assert mgf.diff(t).subs(t, 1) == -2*besseli(1, 1) + besseli(2, 1) +\ besseli(0, 1)
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_studentt(): nu = Symbol("nu", positive=True) X = StudentT('x', nu) assert density(X)(x) == (1 + x**2/nu)**(-nu/2 - 1/2)/(sqrt(nu)*beta(1/2, nu/2))
def test_beta(): x, y = Symbol('x'), Symbol('y') assert isinstance(beta(x, y), beta) 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) * (digamma(x) - digamma(x + y)) assert diff(beta(x, y), y) == beta(x, y) * (digamma(y) - digamma(x + y))
def test_beta_function(): x, y = Symbol('x'), Symbol('y') assert beta(x, y) == gamma(x) * gamma(y) / gamma(x + y) assert beta(x, y) == beta(y, x) # Symmetric
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 test_beta(): x, y = Symbol('x'), Symbol('y') assert isinstance(beta(x, y), beta) 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)