def _compute_formula(f, x, P, Q, k, m, k_max): """Computes the formula for f.""" from sympy.polys import roots sol = [] for i in range(k_max + 1, k_max + m + 1): r = f.diff(x, i).limit(x, 0) / factorial(i) if r is S.Zero: continue kterm = m*k + i res = r p = P.subs(k, kterm) q = Q.subs(k, kterm) c1 = p.subs(k, 1/k).leadterm(k)[0] c2 = q.subs(k, 1/k).leadterm(k)[0] res *= (-c1 / c2)**k for r, mul in roots(p, k).items(): res *= rf(-r, k)**mul for r, mul in roots(q, k).items(): res /= rf(-r, k)**mul sol.append((res, kterm)) return sol
def hyper_re(DE, r, k): """Converts a DE into a RE. Performs the substitution: .. math:: x^l f^j(x) \\to (k + 1 - l)_j . a_{k + j - l} Normalises the terms so that lowest order of a term is always r(k). Examples ======== >>> from sympy import Function, Derivative >>> from sympy.series.formal import hyper_re >>> from sympy.abc import x, k >>> f, r = Function('f'), Function('r') >>> hyper_re(-f(x) + Derivative(f(x)), r, k) (k + 1)*r(k + 1) - r(k) >>> hyper_re(-x*f(x) + Derivative(f(x), x, x), r, k) (k + 2)*(k + 3)*r(k + 3) - r(k) See Also ======== sympy.series.formal.exp_re """ RE = S.Zero g = DE.atoms(Function).pop() x = g.atoms(Symbol).pop() mini = None for t in Add.make_args(DE.expand()): coeff, d = t.as_independent(g) c, v = coeff.as_independent(x) l = v.as_coeff_exponent(x)[1] if isinstance(d, Derivative): j = len(d.args[1:]) else: j = 0 RE += c * rf(k + 1 - l, j) * r(k + j - l) if mini is None or j - l < mini: mini = j - l RE = RE.subs(k, k - mini) m = Wild('m') return RE.collect(r(k + m))
def hyper_re(DE, r, k): """Converts a DE into a RE. Performs the substitution: .. math:: x^l f^j(x) \\to (k + 1 - l)_j . a_{k + j - l} Normalises the terms so that lowest order of a term is always r(k). Examples ======== >>> from sympy import Function, Derivative >>> from sympy.series.formal import hyper_re >>> from sympy.abc import x, k >>> f, r = Function('f'), Function('r') >>> hyper_re(-f(x) + Derivative(f(x)), r, k) (k + 1)*r(k + 1) - r(k) >>> hyper_re(-x*f(x) + Derivative(f(x), (x, 2)), r, k) (k + 2)*(k + 3)*r(k + 3) - r(k) See Also ======== sympy.series.formal.exp_re """ RE = S.Zero g = DE.atoms(Function).pop() x = g.atoms(Symbol).pop() mini = None for t in Add.make_args(DE.expand()): coeff, d = t.as_independent(g) c, v = coeff.as_independent(x) l = v.as_coeff_exponent(x)[1] if isinstance(d, Derivative): j = d.derivative_count else: j = 0 RE += c * rf(k + 1 - l, j) * r(k + j - l) if mini is None or j - l < mini: mini = j - l RE = RE.subs(k, k - mini) m = Wild('m') return RE.collect(r(k + m))
def pdf(self, *syms): n, theta = self.n, self.theta condi = isinstance(self.n, Integer) if not (isinstance(syms[0], IndexedBase) or condi): raise ValueError("Please use IndexedBase object for syms as " "the dimension is symbolic") term_1 = factorial(n)/rf(theta, n) if condi: term_2 = Mul.fromiter(theta**syms[j]/((j+1)**syms[j]*factorial(syms[j])) for j in range(n)) cond = Eq(sum([(k + 1)*syms[k] for k in range(n)]), n) return Piecewise((term_1 * term_2, cond), (0, True)) syms = syms[0] j, k = symbols('j, k', positive=True, integer=True) term_2 = Product(theta**syms[j]/((j+1)**syms[j]*factorial(syms[j])), (j, 0, n - 1)) cond = Eq(Sum((k + 1)*syms[k], (k, 0, n - 1)), n) return Piecewise((term_1 * term_2, cond), (0, True))
def test_rsolve_hyper(): assert rsolve_hyper([-1, -1, 1], 0, n) in [ C0 * (S.Half - S.Half * sqrt(5))**n + C1 * (S.Half + S.Half * sqrt(5))**n, C1 * (S.Half - S.Half * sqrt(5))**n + C0 * (S.Half + S.Half * sqrt(5))**n, ] assert rsolve_hyper([n**2 - 2, -2 * n - 1, 1], 0, n) in [ C0 * rf(sqrt(2), n) + C1 * rf(-sqrt(2), n), C1 * rf(sqrt(2), n) + C0 * rf(-sqrt(2), n), ] assert rsolve_hyper([n**2 - k, -2 * n - 1, 1], 0, n) in [ C0 * rf(sqrt(k), n) + C1 * rf(-sqrt(k), n), C1 * rf(sqrt(k), n) + C0 * rf(-sqrt(k), n), ] assert rsolve_hyper([2 * n * (n + 1), -n**2 - 3 * n + 2, n - 1], 0, n) == C1 * factorial(n) + C0 * 2**n assert rsolve_hyper( [n + 2, -(2 * n + 3) * (17 * n**2 + 51 * n + 39), n + 1], 0, n) == None assert rsolve_hyper([-n - 1, -1, 1], 0, n) == None assert rsolve_hyper([-1, 1], n, n).expand() == C0 + n**2 / 2 - n / 2 assert rsolve_hyper([-1, 1], 1 + n, n).expand() == C0 + n**2 / 2 + n / 2 assert rsolve_hyper([-1, 1], 3 * (n + n**2), n).expand() == C0 + n**3 - n assert rsolve_hyper([-a, 1], 0, n).expand() == C0 * a**n assert rsolve_hyper( [-a, 0, 1], 0, n).expand() == (-1)**n * C1 * a**(n / 2) + C0 * a**(n / 2) assert rsolve_hyper([1, 1, 1], 0, n).expand() == \ C0*(Rational(-1, 2) - sqrt(3)*I/2)**n + C1*(Rational(-1, 2) + sqrt(3)*I/2)**n assert rsolve_hyper([1, -2 * n / a - 2 / a, 1], 0, n) is None
def _eval_nseries(self, x, n, logx): x0 = self.args[0].limit(x, 0) if not (x0.is_Integer and x0 <= 0): return super(gamma, self)._eval_nseries(x, n, logx) t = self.args[0] - x0 return (gamma(t + 1) / rf(self.args[0], -x0 + 1))._eval_nseries(x, n, logx)
def test_rf_eval_apply(): x, y = symbols('x,y') n, k = symbols('n k', integer=True) m = Symbol('m', integer=True, nonnegative=True) assert rf(nan, y) is nan assert rf(x, nan) is nan assert unchanged(rf, x, y) assert rf(oo, 0) == 1 assert rf(-oo, 0) == 1 assert rf(oo, 6) is oo assert rf(-oo, 7) is -oo assert rf(-oo, 6) is oo assert rf(oo, -6) is oo assert rf(-oo, -7) is oo assert rf(-1, pi) == 0 assert rf(-5, 1 + I) == 0 assert unchanged(rf, -3, k) assert unchanged(rf, x, Symbol('k', integer=False)) assert rf(-3, Symbol('k', integer=False)) == 0 assert rf(Symbol('x', negative=True, integer=True), Symbol('k', integer=False)) == 0 assert rf(x, 0) == 1 assert rf(x, 1) == x assert rf(x, 2) == x * (x + 1) assert rf(x, 3) == x * (x + 1) * (x + 2) assert rf(x, 5) == x * (x + 1) * (x + 2) * (x + 3) * (x + 4) assert rf(x, -1) == 1 / (x - 1) assert rf(x, -2) == 1 / ((x - 1) * (x - 2)) assert rf(x, -3) == 1 / ((x - 1) * (x - 2) * (x - 3)) assert rf(1, 100) == factorial(100) assert rf(x**2 + 3 * x, 2) == (x**2 + 3 * x) * (x**2 + 3 * x + 1) assert isinstance(rf(x**2 + 3 * x, 2), Mul) assert rf(x**3 + x, -2) == 1 / ((x**3 + x - 1) * (x**3 + x - 2)) assert rf(Poly(x**2 + 3 * x, x), 2) == Poly(x**4 + 8 * x**3 + 19 * x**2 + 12 * x, x) assert isinstance(rf(Poly(x**2 + 3 * x, x), 2), Poly) raises(ValueError, lambda: rf(Poly(x**2 + 3 * x, x, y), 2)) assert rf(Poly(x**3 + x, x), -2) == 1 / (x**6 - 9 * x**5 + 35 * x**4 - 75 * x**3 + 94 * x**2 - 66 * x + 20) raises(ValueError, lambda: rf(Poly(x**3 + x, x, y), -2)) assert rf(x, m).is_integer is None assert rf(n, k).is_integer is None assert rf(n, m).is_integer is True assert rf(n, k + pi).is_integer is False assert rf(n, m + pi).is_integer is False assert rf(pi, m).is_integer is False def check(x, k, o, n): a, b = Dummy(), Dummy() r = lambda x, k: o(a, b).rewrite(n).subs({a: x, b: k}) for i in range(-5, 5): for j in range(-5, 5): assert o(i, j) == r(i, j), (o, n, i, j) check(x, k, rf, ff) check(x, k, rf, binomial) check(n, k, rf, factorial) check(x, y, rf, factorial) check(x, y, rf, binomial) assert rf(x, k).rewrite(ff) == ff(x + k - 1, k) assert rf(x, k).rewrite(gamma) == Piecewise( (gamma(k + x) / gamma(x), x > 0), ((-1)**k * gamma(1 - x) / gamma(-k - x + 1), True)) assert rf(5, k).rewrite(gamma) == gamma(k + 5) / 24 assert rf(x, k).rewrite(binomial) == factorial(k) * binomial(x + k - 1, k) assert rf(n, k).rewrite(factorial) == Piecewise( (factorial(k + n - 1) / factorial(n - 1), n > 0), ((-1)**k * factorial(-n) / factorial(-k - n), True)) assert rf(5, k).rewrite(factorial) == factorial(k + 4) / 24 assert rf(x, y).rewrite(factorial) == rf(x, y) assert rf(x, y).rewrite(binomial) == rf(x, y) import random from mpmath import rf as mpmath_rf for i in range(100): x = -500 + 500 * random.random() k = -500 + 500 * random.random() assert (abs(mpmath_rf(x, k) - rf(x, k)) < 10**(-15))
def test_ff_eval_apply(): x, y = symbols('x,y') n, k = symbols('n k', integer=True) m = Symbol('m', integer=True, nonnegative=True) assert ff(nan, y) is nan assert ff(x, nan) is nan assert unchanged(ff, x, y) assert ff(oo, 0) == 1 assert ff(-oo, 0) == 1 assert ff(oo, 6) is oo assert ff(-oo, 7) is -oo assert ff(-oo, 6) is oo assert ff(oo, -6) is oo assert ff(-oo, -7) is oo assert ff(x, 0) == 1 assert ff(x, 1) == x assert ff(x, 2) == x * (x - 1) assert ff(x, 3) == x * (x - 1) * (x - 2) assert ff(x, 5) == x * (x - 1) * (x - 2) * (x - 3) * (x - 4) assert ff(x, -1) == 1 / (x + 1) assert ff(x, -2) == 1 / ((x + 1) * (x + 2)) assert ff(x, -3) == 1 / ((x + 1) * (x + 2) * (x + 3)) assert ff(100, 100) == factorial(100) assert ff(2 * x**2 - 5 * x, 2) == (2 * x**2 - 5 * x) * (2 * x**2 - 5 * x - 1) assert isinstance(ff(2 * x**2 - 5 * x, 2), Mul) assert ff(x**2 + 3 * x, -2) == 1 / ((x**2 + 3 * x + 1) * (x**2 + 3 * x + 2)) assert ff(Poly(2 * x**2 - 5 * x, x), 2) == Poly(4 * x**4 - 28 * x**3 + 59 * x**2 - 35 * x, x) assert isinstance(ff(Poly(2 * x**2 - 5 * x, x), 2), Poly) raises(ValueError, lambda: ff(Poly(2 * x**2 - 5 * x, x, y), 2)) assert ff(Poly(x**2 + 3 * x, x), -2) == 1 / (x**4 + 12 * x**3 + 49 * x**2 + 78 * x + 40) raises(ValueError, lambda: ff(Poly(x**2 + 3 * x, x, y), -2)) assert ff(x, m).is_integer is None assert ff(n, k).is_integer is None assert ff(n, m).is_integer is True assert ff(n, k + pi).is_integer is False assert ff(n, m + pi).is_integer is False assert ff(pi, m).is_integer is False assert isinstance(ff(x, x), ff) assert ff(n, n) == factorial(n) def check(x, k, o, n): a, b = Dummy(), Dummy() r = lambda x, k: o(a, b).rewrite(n).subs({a: x, b: k}) for i in range(-5, 5): for j in range(-5, 5): assert o(i, j) == r(i, j), (o, n) check(x, k, ff, rf) check(x, k, ff, gamma) check(n, k, ff, factorial) check(x, k, ff, binomial) check(x, y, ff, factorial) check(x, y, ff, binomial) assert ff(x, k).rewrite(rf) == rf(x - k + 1, k) assert ff(x, k).rewrite(gamma) == Piecewise( (gamma(x + 1) / gamma(-k + x + 1), x >= 0), ((-1)**k * gamma(k - x) / gamma(-x), True)) assert ff(5, k).rewrite(gamma) == 120 / gamma(6 - k) assert ff(n, k).rewrite(factorial) == Piecewise( (factorial(n) / factorial(-k + n), n >= 0), ((-1)**k * factorial(k - n - 1) / factorial(-n - 1), True)) assert ff(5, k).rewrite(factorial) == 120 / factorial(5 - k) assert ff(x, k).rewrite(binomial) == factorial(k) * binomial(x, k) assert ff(x, y).rewrite(factorial) == ff(x, y) assert ff(x, y).rewrite(binomial) == ff(x, y) import random from mpmath import ff as mpmath_ff for i in range(100): x = -500 + 500 * random.random() k = -500 + 500 * random.random() a = mpmath_ff(x, k) b = ff(x, k) assert (abs(a - b) < abs(a) * 10**(-15))
def _eval_nseries(self, x, n, logx): x0 = self.args[0].limit(x, 0) if not (x0.is_Integer and x0 <= 0): return super(gamma, self)._eval_nseries(x, n, logx) t = self.args[0] - x0 return (gamma(t + 1)/rf(self.args[0], -x0 + 1))._eval_nseries(x, n, logx)
def test_gammasimp(): R = Rational # was part of test_combsimp_gamma() in test_combsimp.py assert gammasimp(gamma(x)) == gamma(x) assert gammasimp(gamma(x + 1) / x) == gamma(x) assert gammasimp(gamma(x) / (x - 1)) == gamma(x - 1) assert gammasimp(x * gamma(x)) == gamma(x + 1) assert gammasimp((x + 1) * gamma(x + 1)) == gamma(x + 2) assert gammasimp(gamma(x + y) * (x + y)) == gamma(x + y + 1) assert gammasimp(x / gamma(x + 1)) == 1 / gamma(x) assert gammasimp((x + 1)**2 / gamma(x + 2)) == (x + 1) / gamma(x + 1) assert gammasimp(x*gamma(x) + gamma(x + 3)/(x + 2)) == \ (x + 2)*gamma(x + 1) assert gammasimp(gamma(2 * x) * x) == gamma(2 * x + 1) / 2 assert gammasimp(gamma(2 * x) / (x - S.Half)) == 2 * gamma(2 * x - 1) assert gammasimp(gamma(x) * gamma(1 - x)) == pi / sin(pi * x) assert gammasimp(gamma(x) * gamma(-x)) == -pi / (x * sin(pi * x)) assert gammasimp(1/gamma(x + 3)/gamma(1 - x)) == \ sin(pi*x)/(pi*x*(x + 1)*(x + 2)) assert gammasimp(factorial(n + 2)) == gamma(n + 3) assert gammasimp(binomial(n, k)) == \ gamma(n + 1)/(gamma(k + 1)*gamma(-k + n + 1)) assert powsimp(gammasimp( gamma(x)*gamma(x + S.Half)*gamma(y)/gamma(x + y))) == \ 2**(-2*x + 1)*sqrt(pi)*gamma(2*x)*gamma(y)/gamma(x + y) assert gammasimp(1/gamma(x)/gamma(x - Rational(1, 3))/gamma(x + Rational(1, 3))) == \ 3**(3*x - Rational(3, 2))/(2*pi*gamma(3*x - 1)) assert simplify( gamma(S.Half + x / 2) * gamma(1 + x / 2) / gamma(1 + x) / sqrt(pi) * 2**x) == 1 assert gammasimp(gamma(Rational(-1, 4)) * gamma(Rational(-3, 4))) == 16 * sqrt(2) * pi / 3 assert powsimp(gammasimp(gamma(2*x)/gamma(x))) == \ 2**(2*x - 1)*gamma(x + S.Half)/sqrt(pi) # issue 6792 e = (-gamma(k) * gamma(k + 2) + gamma(k + 1)**2) / gamma(k)**2 assert gammasimp(e) == -k assert gammasimp(1 / e) == -1 / k e = (gamma(x) + gamma(x + 1)) / gamma(x) assert gammasimp(e) == x + 1 assert gammasimp(1 / e) == 1 / (x + 1) e = (gamma(x) + gamma(x + 2)) * (gamma(x - 1) + gamma(x)) / gamma(x) assert gammasimp(e) == (x**2 + x + 1) * gamma(x + 1) / (x - 1) e = (-gamma(k) * gamma(k + 2) + gamma(k + 1)**2) / gamma(k)**2 assert gammasimp(e**2) == k**2 assert gammasimp(e**2 / gamma(k + 1)) == k / gamma(k) a = R(1, 2) + R(1, 3) b = a + R(1, 3) assert gammasimp(gamma(2 * k) / gamma(k) * gamma(k + a) * gamma(k + b)) == 3 * 2**(2 * k + 1) * 3**( -3 * k - 2) * sqrt(pi) * gamma(3 * k + R(3, 2)) / 2 # issue 9699 assert gammasimp( (x + 1) * factorial(x) / gamma(y)) == gamma(x + 2) / gamma(y) assert gammasimp(rf(x + n, k) * binomial(n, k)).simplify() == Piecewise( (gamma(n + 1) * gamma(k + n + x) / (gamma(k + 1) * gamma(n + x) * gamma(-k + n + 1)), n > -x), ((-1)**k * gamma(n + 1) * gamma(-n - x + 1) / (gamma(k + 1) * gamma(-k + n + 1) * gamma(-k - n - x + 1)), True)) A, B = symbols('A B', commutative=False) assert gammasimp(e * B * A) == gammasimp(e) * B * A # check iteration assert gammasimp(gamma(2 * k) / gamma(k) * gamma(-k - R(1, 2))) == (-2**(2 * k + 1) * sqrt(pi) / (2 * ((2 * k + 1) * cos(pi * k)))) assert gammasimp( gamma(k) * gamma(k + R(1, 3)) * gamma(k + R(2, 3)) / gamma(k * R(3, 2))) == (3 * 2**(3 * k + 1) * 3**(-3 * k - S.Half) * sqrt(pi) * gamma(k * R(3, 2) + S.Half) / 2) # issue 6153 assert gammasimp(gamma(Rational(1, 4)) / gamma(Rational(5, 4))) == 4 # was part of test_combsimp() in test_combsimp.py assert gammasimp(binomial(n + 2, k + S.Half)) == gamma(n + 3)/ \ (gamma(k + R(3, 2))*gamma(-k + n + R(5, 2))) assert gammasimp(binomial(n + 2, k + 2.0)) == \ gamma(n + 3)/(gamma(k + 3.0)*gamma(-k + n + 1)) # issue 11548 assert gammasimp(binomial(0, x)) == sin(pi * x) / (pi * x) e = gamma(n + Rational(1, 3)) * gamma(n + R(2, 3)) assert gammasimp(e) == e assert gammasimp(gamma(4*n + S.Half)/gamma(2*n - R(3, 4))) == \ 2**(4*n - R(5, 2))*(8*n - 3)*gamma(2*n + R(3, 4))/sqrt(pi) i, m = symbols('i m', integer=True) e = gamma(exp(i)) assert gammasimp(e) == e e = gamma(m + 3) assert gammasimp(e) == e e = gamma(m + 1) / (gamma(i + 1) * gamma(-i + m + 1)) assert gammasimp(e) == e p = symbols("p", integer=True, positive=True) assert gammasimp(gamma(-p + 4)) == gamma(-p + 4)
def test_rational_products(): assert product(1 + 1/k, (k, 1, n)) == rf(2, n)/factorial(n)