def test_catalan():
n = Symbol('n', integer=True)
m = Symbol('n', integer=True, positive=True)
catalans = [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786]
for i, c in enumerate(catalans):
assert catalan(i) == c
assert catalan(n).rewrite(factorial).subs(n, i) == c
assert catalan(n).rewrite(Product).subs(n, i).doit() == c
assert catalan(x) == catalan(x)
assert catalan(2 *
x).rewrite(binomial) == binomial(4 * x, 2 * x) / (2 * x + 1)
assert catalan(Rational(1, 2)).rewrite(gamma) == 8 / (3 * pi)
assert catalan(Rational(1, 2)).rewrite(factorial).rewrite(gamma) ==\
8 / (3 * pi)
assert catalan(3 * x).rewrite(gamma) == 4**(
3 * x) * gamma(3 * x + Rational(1, 2)) / (sqrt(pi) * gamma(3 * x + 2))
assert catalan(x).rewrite(hyper) == hyper((-x + 1, -x), (2, ), 1)
assert catalan(n).rewrite(factorial) == factorial(
2 * n) / (factorial(n + 1) * factorial(n))
assert isinstance(catalan(n).rewrite(Product), catalan)
assert isinstance(catalan(m).rewrite(Product), Product)
assert diff(catalan(x), x) == (polygamma(0, x + Rational(1, 2)) -
polygamma(0, x + 2) + log(4)) * catalan(x)
assert catalan(x).evalf() == catalan(x)
c = catalan(S.Half).evalf()
assert str(c) == '0.848826363156775'
c = catalan(I).evalf(3)
assert sstr((re(c), im(c))) == '(0.398, -0.0209)'
def test_catalan():
n = Symbol('n', integer=True)
m = Symbol('n', integer=True, positive=True)
catalans = [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786]
for i, c in enumerate(catalans):
assert catalan(i) == c
assert catalan(n).rewrite(factorial).subs({n: i}) == c
assert catalan(n).rewrite(Product).subs({n: i}).doit() == c
assert catalan(x) == catalan(x)
assert catalan(2*x).rewrite(binomial) == binomial(4*x, 2*x)/(2*x + 1)
assert catalan(Rational(1, 2)).rewrite(gamma) == 8/(3*pi)
assert catalan(Rational(1, 2)).rewrite(factorial).rewrite(gamma) ==\
8 / (3 * pi)
assert catalan(3*x).rewrite(gamma) == 4**(
3*x)*gamma(3*x + Rational(1, 2))/(sqrt(pi)*gamma(3*x + 2))
assert catalan(x).rewrite(hyper) == hyper((-x + 1, -x), (2,), 1)
assert catalan(n).rewrite(factorial) == factorial(2*n) / (factorial(n + 1)
* factorial(n))
assert isinstance(catalan(n).rewrite(Product), catalan)
assert isinstance(catalan(m).rewrite(Product), Product)
assert diff(catalan(x), x) == (polygamma(
0, x + Rational(1, 2)) - polygamma(0, x + 2) + log(4))*catalan(x)
assert catalan(x).evalf() == catalan(x)
c = catalan(Rational(1, 2)).evalf()
assert str(c) == '0.848826363156775'
c = catalan(I).evalf(3)
assert sstr((re(c), im(c))) == '(0.398, -0.0209)'
def test_harmonic_rewrite_polygamma():
n = Symbol("n")
m = Symbol("m")
assert harmonic(n).rewrite(digamma) == polygamma(0, n + 1) + EulerGamma
assert harmonic(n).rewrite(trigamma) == polygamma(0, n + 1) + EulerGamma
assert harmonic(n).rewrite(polygamma) == polygamma(0, n + 1) + EulerGamma
assert harmonic(
n,
3).rewrite(polygamma) == polygamma(2, n + 1) / 2 - polygamma(2, 1) / 2
assert harmonic(n, m).rewrite(polygamma) == (-1)**m * (
polygamma(m - 1, 1) - polygamma(m - 1, n + 1)) / factorial(m - 1)
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).rewrite(gamma).rewrite("tractable")
assert expand_func(harmonic(n, 2)).func is harmonic
def _eval_rewrite_as_Sum(self, ap, bq, z):
from diofant.functions import factorial, RisingFactorial, Piecewise
from diofant import Sum
n = Dummy("n", integer=True)
rfap = Tuple(*[RisingFactorial(a, n) for a in ap])
rfbq = Tuple(*[RisingFactorial(b, n) for b in bq])
coeff = Mul(*rfap) / Mul(*rfbq)
return Piecewise((Sum(coeff * z**n / factorial(n),
(n, 0, oo)), self.convergence_statement),
(self, True))
def test_Function():
assert mcode(f(x, y, z)) == "f[x, y, z]"
assert mcode(sin(x) ** cos(x)) == "Sin[x]^Cos[x]"
assert mcode(sign(x)) == "Sign[x]"
assert mcode(atanh(x), user_functions={"atanh": "ArcTanh"}) == "ArcTanh[x]"
assert (mcode(meijerg(((1, 1), (3, 4)), ((1,), ()), x)) ==
"MeijerG[{{1, 1}, {3, 4}}, {{1}, {}}, x]")
assert (mcode(hyper((1, 2, 3), (3, 4), x)) ==
"HypergeometricPFQ[{1, 2, 3}, {3, 4}, x]")
assert mcode(Min(x, y)) == "Min[x, y]"
assert mcode(Max(x, y)) == "Max[x, y]"
assert mcode(Max(x, 2)) == "Max[2, x]" # issue sympy/sympy#15344
assert mcode(binomial(x, y)) == "Binomial[x, y]"
assert mcode(log(x)) == "Log[x]"
assert mcode(tan(x)) == "Tan[x]"
assert mcode(cot(x)) == "Cot[x]"
assert mcode(asin(x)) == "ArcSin[x]"
assert mcode(acos(x)) == "ArcCos[x]"
assert mcode(atan(x)) == "ArcTan[x]"
assert mcode(acot(x)) == "ArcCot[x]"
assert mcode(sinh(x)) == "Sinh[x]"
assert mcode(cosh(x)) == "Cosh[x]"
assert mcode(tanh(x)) == "Tanh[x]"
assert mcode(coth(x)) == "Coth[x]"
assert mcode(asinh(x)) == "ArcSinh[x]"
assert mcode(acosh(x)) == "ArcCosh[x]"
assert mcode(atanh(x)) == "ArcTanh[x]"
assert mcode(acoth(x)) == "ArcCoth[x]"
assert mcode(sech(x)) == "Sech[x]"
assert mcode(csch(x)) == "Csch[x]"
assert mcode(erfc(x)) == "Erfc[x]"
assert mcode(conjugate(x)) == "Conjugate[x]"
assert mcode(re(x)) == "Re[x]"
assert mcode(im(x)) == "Im[x]"
assert mcode(polygamma(x, y)) == "PolyGamma[x, y]"
assert mcode(factorial(x)) == "Factorial[x]"
assert mcode(factorial2(x)) == "Factorial2[x]"
assert mcode(rf(x, y)) == "Pochhammer[x, y]"
assert mcode(gamma(x)) == "Gamma[x]"
assert mcode(zeta(x)) == "Zeta[x]"
assert mcode(Heaviside(x)) == "UnitStep[x]"
assert mcode(fibonacci(x)) == "Fibonacci[x]"
assert mcode(polylog(x, y)) == "PolyLog[x, y]"
class myfunc1(Function):
@classmethod
def eval(cls, x):
pass
class myfunc2(Function):
@classmethod
def eval(cls, x, y):
pass
pytest.raises(ValueError,
lambda: mcode(myfunc1(x),
user_functions={"myfunc1": ["Myfunc1"]}))
assert mcode(myfunc1(x),
user_functions={"myfunc1": "Myfunc1"}) == "Myfunc1[x]"
assert mcode(myfunc2(x, y),
user_functions={"myfunc2": [(lambda *x: False,
"Myfunc2")]}) == "myfunc2[x, y]"
def euler_maclaurin(self, m=0, n=0, eps=0, eval_integral=True):
"""
Return an Euler-Maclaurin approximation of self, where m is the
number of leading terms to sum directly and n is the number of
terms in the tail.
With m = n = 0, this is simply the corresponding integral
plus a first-order endpoint correction.
Returns (s, e) where s is the Euler-Maclaurin approximation
and e is the estimated error (taken to be the magnitude of
the first omitted term in the tail):
>>> from diofant.abc import k, a, b
>>> Sum(1/k, (k, 2, 5)).doit().evalf()
1.28333333333333
>>> s, e = Sum(1/k, (k, 2, 5)).euler_maclaurin()
>>> s
-log(2) + 7/20 + log(5)
>>> from diofant import sstr
>>> print(sstr((s.evalf(), e.evalf()), full_prec=True))
(1.26629073187415, 0.0175000000000000)
The endpoints may be symbolic:
>>> s, e = Sum(1/k, (k, a, b)).euler_maclaurin()
>>> s
-log(a) + log(b) + 1/(2*b) + 1/(2*a)
>>> e
Abs(1/(12*b**2) - 1/(12*a**2))
If the function is a polynomial of degree at most 2n+1, the
Euler-Maclaurin formula becomes exact (and e = 0 is returned):
>>> Sum(k, (k, 2, b)).euler_maclaurin()
(b**2/2 + b/2 - 1, 0)
>>> Sum(k, (k, 2, b)).doit()
b**2/2 + b/2 - 1
With a nonzero eps specified, the summation is ended
as soon as the remainder term is less than the epsilon.
"""
from diofant.functions import bernoulli, factorial
from diofant.integrals import Integral
m = int(m)
n = int(n)
f = self.function
if len(self.limits) != 1:
raise ValueError("More than 1 limit")
i, a, b = self.limits[0]
if (a > b) is S.true:
if a - b == 1:
return S.Zero, S.Zero
a, b = b + 1, a - 1
f = -f
s = S.Zero
if m:
if b.is_Integer and a.is_Integer:
m = min(m, b - a + 1)
if not eps or f.is_polynomial(i):
for k in range(m):
s += f.subs(i, a + k)
else:
term = f.subs(i, a)
if term:
test = abs(term.evalf(3)) < eps
if test == S.true:
return s, abs(term)
elif not (test == S.false):
# a symbolic Relational class, can't go further
return term, S.Zero
s += term
for k in range(1, m):
term = f.subs(i, a + k)
if abs(term.evalf(3)) < eps and term != 0:
return s, abs(term)
s += term
if b - a + 1 == m:
return s, S.Zero
a += m
x = Dummy('x')
I = Integral(f.subs(i, x), (x, a, b))
if eval_integral:
I = I.doit()
s += I
def fpoint(expr):
if b is S.Infinity:
return expr.subs(i, a), 0
return expr.subs(i, a), expr.subs(i, b)
fa, fb = fpoint(f)
iterm = (fa + fb) / 2
g = f.diff(i)
for k in range(1, n + 2):
ga, gb = fpoint(g)
term = bernoulli(2 * k) / factorial(2 * k) * (gb - ga)
if (eps and term and abs(term.evalf(3)) < eps) or (k > n):
break
s += term
g = g.diff(i, 2, simplify=False)
return s + iterm, abs(term)
def test_Function():
assert mcode(f(x, y, z)) == "f[x, y, z]"
assert mcode(sin(x) ** cos(x)) == "Sin[x]^Cos[x]"
assert mcode(sign(x)) == "Sign[x]"
assert mcode(atanh(x), user_functions={"atanh": "ArcTanh"}) == "ArcTanh[x]"
assert (mcode(meijerg(((1, 1), (3, 4)), ((1,), ()), x)) ==
"MeijerG[{{1, 1}, {3, 4}}, {{1}, {}}, x]")
assert (mcode(hyper((1, 2, 3), (3, 4), x)) ==
"HypergeometricPFQ[{1, 2, 3}, {3, 4}, x]")
assert mcode(Min(x, y)) == "Min[x, y]"
assert mcode(Max(x, y)) == "Max[x, y]"
assert mcode(Max(x, 2)) == "Max[2, x]" # issue sympy/sympy#15344
assert mcode(binomial(x, y)) == "Binomial[x, y]"
assert mcode(log(x)) == "Log[x]"
assert mcode(tan(x)) == "Tan[x]"
assert mcode(cot(x)) == "Cot[x]"
assert mcode(asin(x)) == "ArcSin[x]"
assert mcode(acos(x)) == "ArcCos[x]"
assert mcode(atan(x)) == "ArcTan[x]"
assert mcode(sinh(x)) == "Sinh[x]"
assert mcode(cosh(x)) == "Cosh[x]"
assert mcode(tanh(x)) == "Tanh[x]"
assert mcode(coth(x)) == "Coth[x]"
assert mcode(sech(x)) == "Sech[x]"
assert mcode(csch(x)) == "Csch[x]"
assert mcode(erfc(x)) == "Erfc[x]"
assert mcode(conjugate(x)) == "Conjugate[x]"
assert mcode(re(x)) == "Re[x]"
assert mcode(im(x)) == "Im[x]"
assert mcode(polygamma(x, y)) == "PolyGamma[x, y]"
assert mcode(factorial(x)) == "Factorial[x]"
assert mcode(factorial2(x)) == "Factorial2[x]"
assert mcode(rf(x, y)) == "Pochhammer[x, y]"
assert mcode(gamma(x)) == "Gamma[x]"
assert mcode(zeta(x)) == "Zeta[x]"
assert mcode(asinh(x)) == "ArcSinh[x]"
assert mcode(Heaviside(x)) == "UnitStep[x]"
assert mcode(fibonacci(x)) == "Fibonacci[x]"
assert mcode(polylog(x, y)) == "PolyLog[x, y]"
assert mcode(atanh(x)) == "ArcTanh[x]"
class myfunc1(Function):
@classmethod
def eval(cls, x):
pass
class myfunc2(Function):
@classmethod
def eval(cls, x, y):
pass
pytest.raises(ValueError,
lambda: mcode(myfunc1(x),
user_functions={"myfunc1": ["Myfunc1"]}))
assert mcode(myfunc1(x),
user_functions={"myfunc1": "Myfunc1"}) == "Myfunc1[x]"
assert mcode(myfunc2(x, y),
user_functions={"myfunc2": [(lambda *x: False,
"Myfunc2")]}) == "myfunc2[x, y]"
def test_harmonic_rewrite_polygamma():
n = Symbol("n")
m = Symbol("m")
assert harmonic(n).rewrite(digamma) == polygamma(0, n + 1) + EulerGamma
assert harmonic(n).rewrite(trigamma) == polygamma(0, n + 1) + EulerGamma
assert harmonic(n).rewrite(polygamma) == polygamma(0, n + 1) + EulerGamma
assert harmonic(n, 3).rewrite(polygamma) == polygamma(2, n + 1)/2 - polygamma(2, 1)/2
assert harmonic(n, m).rewrite(polygamma) == (-1)**m*(polygamma(m - 1, 1) - polygamma(m - 1, n + 1))/factorial(m - 1)
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).rewrite(gamma).rewrite("tractable")
assert isinstance(expand_func(harmonic(n, 2)), harmonic)
assert expand_func(harmonic(n + Rational(1, 2))) == expand_func(harmonic(n + Rational(1, 2)))
assert expand_func(harmonic(Rational(-1, 2))) == harmonic(Rational(-1, 2))
assert expand_func(harmonic(x)) == harmonic(x)