From 488f5ca49a636fd962779a648d77e306370edf3c Mon Sep 17 00:00:00 2001 From: "kirill.smelkov" Date: Fri, 28 Sep 2007 16:25:03 +0000 Subject: [PATCH] [2/2] port factorials to new-style functions Fix factorials users. --- sympy/concrete/products.py | 2 +- sympy/core/power.py | 2 +- sympy/functions/combinatorial/numbers.py | 6 +++--- sympy/functions/elementary/hyperbolic.py | 16 ++++++++-------- sympy/functions/elementary/trigonometric.py | 16 ++++++++-------- sympy/functions/special/error_functions.py | 2 +- sympy/functions/special/gamma_functions.py | 10 +++++----- sympy/functions/special/zeta_functions.py | 2 +- sympy/solvers/recurr.py | 6 +++--- 9 files changed, 31 insertions(+), 31 deletions(-) diff --git a/sympy/concrete/products.py b/sympy/concrete/products.py index 22be93b..4d007ff 100644 --- a/sympy/concrete/products.py +++ b/sympy/concrete/products.py @@ -102,7 +102,7 @@ class Product(Basic, NoRelMeths, ArithMeths): all_roots = roots(poly) for r in all_roots: - A *= S.RisingFactorial(a-r, n-a+1) + A *= Basic.RisingFactorial(a-r, n-a+1) Q *= n - r if len(all_roots) < poly.degree(): diff --git a/sympy/core/power.py b/sympy/core/power.py index 2df3461..e03e69f 100644 --- a/sympy/core/power.py +++ b/sympy/core/power.py @@ -462,4 +462,4 @@ class Pow(Basic, ArithMeths, RelMeths): def taylor_term(self, n, x, *previous_terms): # of (1+x)**e if n<0: return S.Zero x = Basic.sympify(x) - return S.Binomial(self.exp, n) * x**n + return Basic.Binomial(self.exp, n) * x**n diff --git a/sympy/functions/combinatorial/numbers.py b/sympy/functions/combinatorial/numbers.py index b3a4709..6aea7ea 100644 --- a/sympy/functions/combinatorial/numbers.py +++ b/sympy/functions/combinatorial/numbers.py @@ -205,7 +205,7 @@ class Bernoulli(DefinedFunction): @staticmethod def _calc_bernoulli(n): s = 0 - a = int(S.Binomial(n+3, n-6)) + a = int(Basic.Binomial(n+3, n-6)) for j in xrange(1, n//6+1): s += a * S.Bernoulli(n - 6*j) # Avoid computing each binomial coefficient from scratch @@ -215,7 +215,7 @@ class Bernoulli(DefinedFunction): s = -Rational(n+3, 6) - s else: s = Rational(n+3, 3) - s - return s / S.Binomial(n+3, n) + return s / Basic.Binomial(n+3, n) # We implement a specialized memoization scheme to handle each # case modulo 6 separately @@ -251,7 +251,7 @@ class Bernoulli(DefinedFunction): else: n, result = int(n), [] for k in xrange(n + 1): - result.append(S.Binomial(n, k)*self(k)*sym**(n-k)) + result.append(Basic.Binomial(n, k)*self(k)*sym**(n-k)) return Basic.Add(*result) else: raise ValueError("Bernoulli numbers are defined only" diff --git a/sympy/functions/elementary/hyperbolic.py b/sympy/functions/elementary/hyperbolic.py index 4b39c26..8dead42 100644 --- a/sympy/functions/elementary/hyperbolic.py +++ b/sympy/functions/elementary/hyperbolic.py @@ -60,7 +60,7 @@ class sinh(SingleValuedFunction): p = previous_terms[-2] return p * x**2 / (n*(n-1)) else: - return x**(n) / S.Factorial(n) + return x**(n) / Basic.Factorial(n) def _eval_conjugate(self): return self.func(self[0].conjugate()) @@ -154,7 +154,7 @@ class cosh(SingleValuedFunction): p = previous_terms[-2] return p * x**2 / (n*(n-1)) else: - return x**(n)/S.Factorial(n) + return x**(n)/Basic.Factorial(n) def _eval_conjugate(self): return self.func(self[0].conjugate()) @@ -247,7 +247,7 @@ class tanh(SingleValuedFunction): a = 2**(n+1) B = S.Bernoulli(n+1) - F = S.Factorial(n+1) + F = Basic.Factorial(n+1) return a*(a-1) * B/F * x**n @@ -343,7 +343,7 @@ class coth(SingleValuedFunction): x = Basic.sympify(x) B = S.Bernoulli(n+1) - F = S.Factorial(n+1) + F = Basic.Factorial(n+1) return 2**(n+1) * B/F * x**n @@ -441,8 +441,8 @@ class asinh(SingleValuedFunction): else: k = (n - 1) // 2 - R = S.RisingFactorial(S.Half, k) - F = S.Factorial(k) + R = Basic.RisingFactorial(S.Half, k) + F = Basic.Factorial(k) return (-1)**k * R / F * x**n / n @@ -515,8 +515,8 @@ class acosh(SingleValuedFunction): else: k = (n - 1) // 2 - R = S.RisingFactorial(S.Half, k) - F = S.Factorial(k) + R = Basic.RisingFactorial(S.Half, k) + F = Basic.Factorial(k) return -R / F * S.ImaginaryUnit * x**n / n diff --git a/sympy/functions/elementary/trigonometric.py b/sympy/functions/elementary/trigonometric.py index 456f158..7641ec3 100644 --- a/sympy/functions/elementary/trigonometric.py +++ b/sympy/functions/elementary/trigonometric.py @@ -81,7 +81,7 @@ class sin(SingleValuedFunction): p = previous_terms[-2] return -p * x**2 / (n*(n-1)) else: - return (-1)**(n//2) * x**(n)/S.Factorial(n) + return (-1)**(n//2) * x**(n)/Basic.Factorial(n) def _eval_rewrite_as_exp(self, arg): exp, I = Basic.exp, S.ImaginaryUnit @@ -212,7 +212,7 @@ class cos(SingleValuedFunction): p = previous_terms[-2] return -p * x**2 / (n*(n-1)) else: - return (-1)**(n//2)*x**(n)/S.Factorial(n) + return (-1)**(n//2)*x**(n)/Basic.Factorial(n) def _eval_rewrite_as_exp(self, arg): exp, I = Basic.exp, S.ImaginaryUnit @@ -341,7 +341,7 @@ class tan(SingleValuedFunction): a, b = ((n-1)//2), 2**(n+1) B = S.Bernoulli(n+1) - F = S.Factorial(n+1) + F = Basic.Factorial(n+1) return (-1)**a * b*(b-1) * B/F * x**n @@ -460,7 +460,7 @@ class cot(SingleValuedFunction): x = Basic.sympify(x) B = S.Bernoulli(n+1) - F = S.Factorial(n+1) + F = Basic.Factorial(n+1) return (-1)**((n+1)//2) * 2**(n+1) * B/F * x**n @@ -575,8 +575,8 @@ class asin(SingleValuedFunction): else: k = (n - 1) // 2 - R = S.RisingFactorial(S.Half, k) - F = S.Factorial(k) + R = Basic.RisingFactorial(S.Half, k) + F = Basic.Factorial(k) return R / F * x**n / n @@ -651,8 +651,8 @@ class acos(SingleValuedFunction): else: k = (n - 1) // 2 - R = S.RisingFactorial(S.Half, k) - F = S.Factorial(k) + R = Basic.RisingFactorial(S.Half, k) + F = Basic.Factorial(k) return -R / F * x**n / n diff --git a/sympy/functions/special/error_functions.py b/sympy/functions/special/error_functions.py index ea20353..637bd12 100644 --- a/sympy/functions/special/error_functions.py +++ b/sympy/functions/special/error_functions.py @@ -54,7 +54,7 @@ class erf(SingleValuedFunction): if len(previous_terms) > 2: return -previous_terms[-2] * x**2 * (n-2)/(n*k) else: - return 2*(-1)**k * x**n/(n*S.Factorial(k)*Basic.sqrt(S.Pi)) + return 2*(-1)**k * x**n/(n*Basic.Factorial(k)*Basic.sqrt(S.Pi)) def _eval_as_leading_term(self, x): arg = self[0].as_leading_term(x) diff --git a/sympy/functions/special/gamma_functions.py b/sympy/functions/special/gamma_functions.py index 4955712..2571c8e 100644 --- a/sympy/functions/special/gamma_functions.py +++ b/sympy/functions/special/gamma_functions.py @@ -27,7 +27,7 @@ class gamma(SingleValuedFunction): return S.Infinity elif isinstance(arg, Basic.Integer): if arg.is_positive: - return S.Factorial(arg-1) + return Basic.Factorial(arg-1) else: return S.ComplexInfinity elif isinstance(arg, Basic.Rational): @@ -68,7 +68,7 @@ class gamma(SingleValuedFunction): else: continue - return gamma(terms)*S.RisingFactorial(terms, coeff) + return gamma(terms)*Basic.RisingFactorial(terms, coeff) return self.func(*self[:]) @@ -169,7 +169,7 @@ class polygamma(SingleValuedFunction): if isinstance(n, Basic.Zero): return -S.EulerGamma + S.Harmonic(z-1, 1) elif n.is_odd: - return (-1)**(n+1)*S.Factorial(n)*S.Zeta(n+1, z) + return (-1)**(n+1)*Basic.Factorial(n)*S.Zeta(n+1, z) def _eval_expand_func(self, *args): @@ -181,7 +181,7 @@ class polygamma(SingleValuedFunction): if isinstance(coeff, Basic.Integer): tail = Add(*[ z + i for i in xrange(0, int(coeff)) ]) - return self(n, z-coeff) + (-1)**n*S.Factorial(n)*tail + return self(n, z-coeff) + (-1)**n*Basic.Factorial(n)*tail elif isinstance(z, Basic.Mul): coeff, terms = z.as_coeff_terms() @@ -196,7 +196,7 @@ class polygamma(SingleValuedFunction): return self(n, z) def _eval_rewrite_as_zeta(self, n, z): - return (-1)**(n+1)*S.Factorial(n)*S.Zeta(n+1, z-1) + return (-1)**(n+1)*Basic.Factorial(n)*S.Zeta(n+1, z-1) class loggamma(SingleValuedFunction): diff --git a/sympy/functions/special/zeta_functions.py b/sympy/functions/special/zeta_functions.py index 7f1924c..1e61b53 100644 --- a/sympy/functions/special/zeta_functions.py +++ b/sympy/functions/special/zeta_functions.py @@ -35,7 +35,7 @@ class Zeta(DefinedFunction): if z.is_negative: zeta = (-1)**z * S.Bernoulli(-z+1)/(-z+1) elif z.is_even: - B, F = S.Bernoulli(z), S.Factorial(z) + B, F = S.Bernoulli(z), Basic.Factorial(z) zeta = 2**(z-1) * abs(B) * pi**z / F if a.is_negative: diff --git a/sympy/solvers/recurr.py b/sympy/solvers/recurr.py index 41ab196..2e37368 100644 --- a/sympy/solvers/recurr.py +++ b/sympy/solvers/recurr.py @@ -87,7 +87,7 @@ def rsolve_poly(coeffs, f, n, **hints): for i in xrange(0, r+1): for j in xrange(i, r+1): - polys[i] += S.Binomial(j, i)*coeffs[j] + polys[i] += Basic.Binomial(j, i)*coeffs[j] polys[i] = polys[i].expand() @@ -111,7 +111,7 @@ def rsolve_poly(coeffs, f, n, **hints): for i in xrange(0, r+1): if terms[i][1] - i == b: - degree_poly += terms[i][0]*S.FallingFactorial(x, i) + degree_poly += terms[i][0]*Basic.FallingFactorial(x, i) _nni_roots = nni_roots(degree_poly, x) @@ -193,7 +193,7 @@ def rsolve_poly(coeffs, f, n, **hints): for j in xrange(0, A+1): for k in xrange(0, d+1): - B = S.Binomial(k, i+j) + B = Basic.Binomial(k, i+j) D = delta(polys[j], k) alpha[i] += I[k]*B*D -- 2.11.4.GIT