Merge pull request #68 from skirpichev/gruntz-use-subs

Removed SubsSet in gruntz, use xreplace()

sympy/concrete/tests/test_gosper.py

@@ -43,7 +43,8 @@ def test_gosper_sum():
     # issue 6033:
     assert gosper_sum(
         n*(n + a + b)*a**n*b**n/(factorial(n + a)*factorial(n + b)), \
-        (n, 0, m)) == -a*b*(exp(m*log(a))*exp(m*log(b))*factorial(a)* \
+        (n, 0, m)).rewrite(factorial) == \
+        -a*b*(exp(m*log(a))*exp(m*log(b))*factorial(a)* \
         factorial(b) - factorial(a + m)*factorial(b + m))/(factorial(a)* \
         factorial(b)*factorial(a + m)*factorial(b + m))
 

sympy/core/expr.py

@@ -2771,15 +2771,15 @@ def aseries(self, x, n=6, bound=0, hir=False):
             xpos = Dummy('x', positive=True, finite=True)
             return self.subs(x, xpos).aseries(xpos, n, bound, hir).subs(xpos, x)
 
-        omega, exps = mrv(self, x)
+        omega = mrv(self, x)
         if x in omega:
             s = self.subs(x, exp(x)).aseries(x, n, bound, hir).subs(x, log(x))
             if s.getO():
                 o = Order(1/x**n, (x, S.Infinity))
                 return s + o
             return s
         d = Dummy('d', positive=True)
-        f, logw = rewrite(exps, omega, x, d)
+        f, logw = rewrite(self, x, d)
 
         if self in omega:
             # Need to find a canonical representative

sympy/functions/combinatorial/factorials.py

@@ -168,6 +168,10 @@ def _eval_rewrite_as_gamma(self, n):
         from sympy import gamma
         return gamma(n + 1)
 
+    def _eval_rewrite_as_tractable(self, n):
+        from sympy import loggamma, exp
+        return exp(loggamma(n + 1))
+
     def _eval_rewrite_as_Product(self, n):
         from sympy import Product
         if n.is_nonnegative and n.is_integer:
@@ -459,6 +463,9 @@ def _eval_rewrite_as_gamma(self, x, k):
         from sympy import gamma
         return gamma(x + k) / gamma(x)
 
+    def _eval_rewrite_as_tractable(self, x, k):
+        return self._eval_rewrite_as_gamma(x, k).rewrite('tractable')
+
     def _eval_is_integer(self):
         return fuzzy_and((self.args[0].is_integer, self.args[1].is_integer,
                           self.args[1].is_nonnegative))

sympy/functions/combinatorial/tests/test_comb_factorials.py

@@ -1,6 +1,6 @@
 from sympy import (S, Symbol, symbols, factorial, factorial2, binomial,
-                   rf, ff, gamma, polygamma, EulerGamma, O, pi, nan,
-                   oo, zoo, simplify, expand_func, Product)
+                   rf, ff, gamma, polygamma, EulerGamma, O, pi, nan, exp,
+                   oo, zoo, simplify, expand_func, Product, loggamma)
 from sympy.functions.combinatorial.factorials import subfactorial
 from sympy.functions.special.gamma_functions import uppergamma
 from sympy.utilities.pytest import XFAIL
@@ -44,6 +44,9 @@ def test_rf_eval_apply():
     assert rf(n, m + pi).is_integer is False
     assert rf(pi, m).is_integer is False
 
+    assert rf(x, y).rewrite('tractable') == \
+        exp(-loggamma(x))*exp(loggamma(x + y))
+
 
 def test_ff_eval_apply():
     x, y = symbols('x,y')
@@ -151,6 +154,7 @@ def test_factorial_rewrite():
 
     assert factorial(n).rewrite(gamma) == gamma(n + 1)
     assert str(factorial(k).rewrite(Product)) == 'Product(_i, (_i, 1, k))'
+    assert factorial(n).rewrite('tractable') == exp(loggamma(n + 1))
 
 
 def test_factorial2():

sympy/functions/combinatorial/tests/test_comb_numbers.py

@@ -217,7 +217,7 @@ def test_harmonic_rewrite_polygamma():
     assert expand_func(harmonic(n+4)) == harmonic(n) + 1/(n + 4) + 1/(n + 3) + 1/(n + 2) + 1/(n + 1)
     assert expand_func(harmonic(n-4)) == harmonic(n) - 1/(n - 1) - 1/(n - 2) - 1/(n - 3) - 1/n
 
-    assert harmonic(n, m).rewrite("tractable") == harmonic(n, m).rewrite(polygamma)
+    assert harmonic(n, m).rewrite("tractable") == harmonic(n, m).rewrite(polygamma).rewrite(gamma).rewrite("tractable")
 
 @XFAIL
 def test_harmonic_limit_fail():