def _expr_big(cls, z, n):
if n.is_even:
return (n - Rational(1, 2)) * pi * I + log(
sqrt(z) / 2) + I * asin(1 / sqrt(z))
else:
return (n - Rational(1, 2)) * pi * I + log(
sqrt(z) / 2) - I * asin(1 / sqrt(z))
def test_trigintegrate_mixed():
assert trigintegrate(sin(x) * sec(x), x) == -log(sin(x)**2 - 1) / 2
assert trigintegrate(sin(x) * csc(x), x) == x
assert trigintegrate(sin(x) * cot(x), x) == sin(x)
assert trigintegrate(cos(x) * sec(x), x) == x
assert trigintegrate(cos(x) * csc(x), x) == log(cos(x)**2 - 1) / 2
assert trigintegrate(cos(x) * tan(x), x) == -cos(x)
assert trigintegrate(cos(x)*cot(x), x) == log(cos(x) - 1)/2 \
- log(cos(x) + 1)/2 + cos(x)
def test_trigintegrate_mixed():
assert trigintegrate(sin(x)*sec(x), x) == -log(sin(x)**2 - 1)/2
assert trigintegrate(sin(x)*csc(x), x) == x
assert trigintegrate(sin(x)*cot(x), x) == sin(x)
assert trigintegrate(cos(x)*sec(x), x) == x
assert trigintegrate(cos(x)*csc(x), x) == log(cos(x)**2 - 1)/2
assert trigintegrate(cos(x)*tan(x), x) == -cos(x)
assert trigintegrate(cos(x)*cot(x), x) == log(cos(x) - 1)/2 \
- log(cos(x) + 1)/2 + cos(x)
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 singularities(f, x):
"""Find singularities of real-valued function `f` with respect to `x`.
Examples
========
>>> from diofant import Symbol, exp, log
>>> from diofant.abc import x
>>> singularities(1/(1 + x), x) == {-1}
True
>>> singularities(exp(1/x) + log(x + 1), x) == {-1, 0}
True
>>> singularities(exp(1/log(x + 1)), x) == {0}
True
Notes
=====
Removable singularities are not supported now.
References
==========
.. [1] http://en.wikipedia.org/wiki/Mathematical_singularity
"""
f, x = sympify(f), sympify(x)
guess, res = set(), set()
assert x.is_Symbol
if f.is_number:
return set()
elif f.is_polynomial(x):
return set()
elif f.func in (Add, Mul):
guess = guess.union(*[singularities(a, x) for a in f.args])
elif f.func is Pow:
if f.exp.is_number and f.exp.is_negative:
guess = {v for v in solve(f.base, x) if v.is_real}
else:
guess |= singularities(log(f.base)*f.exp, x)
elif f.func in (log, sign) and len(f.args) == 1:
guess |= singularities(f.args[0], x)
guess |= {v for v in solve(f.args[0], x) if v.is_real}
else: # pragma: no cover
raise NotImplementedError
for s in guess:
l = Limit(f, x, s, dir="real")
try:
r = l.doit()
if r == l or f.subs(x, s) != r: # pragma: no cover
raise NotImplementedError
except PoleError:
res.add(s)
return res
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]"
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 compare(a, b, x):
r"""
Determine order relation between two functons.
Returns
=======
{1, 0, -1}
Respectively, if `a(x) \succ b(x)`, `a(x) \asymp b(x)`
or `b(x) \succ a(x)`.
Examples
========
>>> from diofant import Symbol, exp
>>> x = Symbol('x', real=True, positive=True)
>>> m = Symbol('m', real=True, positive=True)
>>> compare(x, x**2, x)
0
>>> compare(1/x, x**m, x)
0
>>> compare(exp(x), exp(x**2), x)
-1
>>> compare(exp(x), x**5, x)
1
"""
# The log(exp(...)) must always be simplified here for termination.
la = a.exp if a.is_Pow and a.base is S.Exp1 else log(a)
lb = b.exp if b.is_Pow and b.base is S.Exp1 else log(b)
c = limitinf(la / lb, x)
if c.is_zero:
return -1
elif c.is_infinite:
return 1
else:
return 0
def ispow2(d, log2=False):
if not d.is_Pow:
return False
e = d.exp
if e.is_Rational and e.q == 2 or symbolic and fraction(e)[1] == 2:
return True
if log2:
q = 1
if e.is_Rational:
q = e.q
elif symbolic:
d = fraction(e)[1]
if d.is_Integer:
q = d
if q != 1 and log(q, 2).is_Integer:
return True
return False
def mrv_leadterm(e, x):
"""
Compute the leading term of the series.
Returns
=======
tuple
The leading term `c_0 w^{e_0}` of the series of `e` in terms
of the most rapidly varying subexpression `w` in form of
the pair ``(c0, e0)`` of Expr.
Examples
========
>>> from diofant import Symbol, exp
>>> x = Symbol('x', real=True, positive=True)
>>> mrv_leadterm(1/exp(-x + exp(-x)) - exp(x), x)
(-1, 0)
"""
if not e.has(x):
return e, S.Zero
e = e.replace(lambda f: f.is_Pow and f.base != S.Exp1 and f.exp.has(x),
lambda f: exp(log(f.base) * f.exp))
e = e.replace(
lambda f: f.is_Mul and sum(a.is_Pow for a in f.args) > 1,
lambda f: Mul(
exp(Add(*[a.exp for a in f.args
if a.is_Pow and a.base is S.Exp1])), *
[a for a in f.args if not a.is_Pow or a.base is not S.Exp1]))
# The positive dummy, w, is used here so log(w*2) etc. will expand.
# TODO: For limits of complex functions, the algorithm would have to
# be improved, or just find limits of Re and Im components separately.
w = Dummy("w", real=True, positive=True)
e, logw = rewrite(e, x, w)
lt = e.compute_leading_term(w, logx=logw)
return lt.as_coeff_exponent(w)
def _expr_big_minus(cls, x, n):
return log(1 + x) + 2 * n * pi * I
def _expr_big(cls, x, n):
return log(x - 1) + (2 * n - 1) * pi * I
def _expr_small_minus(cls, x):
return log(1 + x)
def _expr_small(cls, x):
return log(1 - x)
def test_harmonic_rational():
ne = Integer(6)
no = Integer(5)
pe = Integer(8)
po = Integer(9)
qe = Integer(10)
qo = Integer(13)
Heee = harmonic(ne + pe / qe)
Aeee = (-log(10) + 2 * (-1 / Integer(4) + sqrt(5) / 4) *
log(sqrt(-sqrt(5) / 8 + 5 / Integer(8))) + 2 *
(-sqrt(5) / 4 - 1 / Integer(4)) *
log(sqrt(sqrt(5) / 8 + 5 / Integer(8))) + pi *
(1 / Integer(4) + sqrt(5) / 4) /
(2 * sqrt(-sqrt(5) / 8 + 5 / Integer(8))) +
13944145 / Integer(4720968))
Heeo = harmonic(ne + pe / qo)
Aeeo = (-log(26) + 2 * log(sin(3 * pi / 13)) * cos(4 * pi / 13) +
2 * log(sin(2 * pi / 13)) * cos(32 * pi / 13) +
2 * log(sin(5 * pi / 13)) * cos(80 * pi / 13) -
2 * log(sin(6 * pi / 13)) * cos(5 * pi / 13) -
2 * log(sin(4 * pi / 13)) * cos(pi / 13) +
pi * cot(5 * pi / 13) / 2 -
2 * log(sin(pi / 13)) * cos(3 * pi / 13) +
2422020029 / Integer(702257080))
Heoe = harmonic(ne + po / qe)
Aeoe = (
-log(20) + 2 *
(1 / Integer(4) + sqrt(5) / 4) * log(-1 / Integer(4) + sqrt(5) / 4) +
2 * (-1 / Integer(4) + sqrt(5) / 4) *
log(sqrt(-sqrt(5) / 8 + 5 / Integer(8))) + 2 *
(-sqrt(5) / 4 - 1 / Integer(4)) *
log(sqrt(sqrt(5) / 8 + 5 / Integer(8))) + 2 *
(-sqrt(5) / 4 + 1 / Integer(4)) * log(1 / Integer(4) + sqrt(5) / 4) +
11818877030 / Integer(4286604231) + pi *
(sqrt(5) / 8 + 5 / Integer(8)) / sqrt(-sqrt(5) / 8 + 5 / Integer(8)))
Heoo = harmonic(ne + po / qo)
Aeoo = (-log(26) + 2 * log(sin(3 * pi / 13)) * cos(54 * pi / 13) +
2 * log(sin(4 * pi / 13)) * cos(6 * pi / 13) +
2 * log(sin(6 * pi / 13)) * cos(108 * pi / 13) -
2 * log(sin(5 * pi / 13)) * cos(pi / 13) -
2 * log(sin(pi / 13)) * cos(5 * pi / 13) +
pi * cot(4 * pi / 13) / 2 -
2 * log(sin(2 * pi / 13)) * cos(3 * pi / 13) +
11669332571 / Integer(3628714320))
Hoee = harmonic(no + pe / qe)
Aoee = (-log(10) + 2 * (-1 / Integer(4) + sqrt(5) / 4) *
log(sqrt(-sqrt(5) / 8 + 5 / Integer(8))) + 2 *
(-sqrt(5) / 4 - 1 / Integer(4)) *
log(sqrt(sqrt(5) / 8 + 5 / Integer(8))) + pi *
(1 / Integer(4) + sqrt(5) / 4) /
(2 * sqrt(-sqrt(5) / 8 + 5 / Integer(8))) +
779405 / Integer(277704))
Hoeo = harmonic(no + pe / qo)
Aoeo = (-log(26) + 2 * log(sin(3 * pi / 13)) * cos(4 * pi / 13) +
2 * log(sin(2 * pi / 13)) * cos(32 * pi / 13) +
2 * log(sin(5 * pi / 13)) * cos(80 * pi / 13) -
2 * log(sin(6 * pi / 13)) * cos(5 * pi / 13) -
2 * log(sin(4 * pi / 13)) * cos(pi / 13) +
pi * cot(5 * pi / 13) / 2 -
2 * log(sin(pi / 13)) * cos(3 * pi / 13) +
53857323 / Integer(16331560))
Hooe = harmonic(no + po / qe)
Aooe = (
-log(20) + 2 *
(1 / Integer(4) + sqrt(5) / 4) * log(-1 / Integer(4) + sqrt(5) / 4) +
2 * (-1 / Integer(4) + sqrt(5) / 4) *
log(sqrt(-sqrt(5) / 8 + 5 / Integer(8))) + 2 *
(-sqrt(5) / 4 - 1 / Integer(4)) *
log(sqrt(sqrt(5) / 8 + 5 / Integer(8))) + 2 *
(-sqrt(5) / 4 + 1 / Integer(4)) * log(1 / Integer(4) + sqrt(5) / 4) +
486853480 / Integer(186374097) + pi *
(sqrt(5) / 8 + 5 / Integer(8)) / sqrt(-sqrt(5) / 8 + 5 / Integer(8)))
Hooo = harmonic(no + po / qo)
Aooo = (-log(26) + 2 * log(sin(3 * pi / 13)) * cos(54 * pi / 13) +
2 * log(sin(4 * pi / 13)) * cos(6 * pi / 13) +
2 * log(sin(6 * pi / 13)) * cos(108 * pi / 13) -
2 * log(sin(5 * pi / 13)) * cos(pi / 13) -
2 * log(sin(pi / 13)) * cos(5 * pi / 13) +
pi * cot(4 * pi / 13) / 2 -
2 * log(sin(2 * pi / 13)) * cos(3 * pi / 13) +
383693479 / Integer(125128080))
H = [Heee, Heeo, Heoe, Heoo, Hoee, Hoeo, Hooe, Hooo]
A = [Aeee, Aeeo, Aeoe, Aeoo, Aoee, Aoeo, Aooe, Aooo]
for h, a in zip(H, A):
e = expand_func(h).doit()
assert cancel(e / a) == 1
assert h.n() == a.n()
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_RootSum():
r = RootSum(x**3 + x + 3, Lambda(y, log(y*z)))
assert mcode(r) == ("RootSum[Function[{x}, x^3 + x + 3], "
"Function[{y}, Log[y*z]]]")
def test_harmonic_rational():
ne = Integer(6)
no = Integer(5)
pe = Integer(8)
po = Integer(9)
qe = Integer(10)
qo = Integer(13)
Heee = harmonic(ne + pe/qe)
Aeee = (-log(10) + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+ 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+ pi*(Rational(1, 4) + sqrt(5)/4)/(2*sqrt(-sqrt(5)/8 + Rational(5, 8)))
+ Rational(13944145, 4720968))
Heeo = harmonic(ne + pe/qo)
Aeeo = (-log(26) + 2*log(sin(3*pi/13))*cos(4*pi/13) + 2*log(sin(2*pi/13))*cos(32*pi/13)
+ 2*log(sin(5*pi/13))*cos(80*pi/13) - 2*log(sin(6*pi/13))*cos(5*pi/13)
- 2*log(sin(4*pi/13))*cos(pi/13) + pi*cot(5*pi/13)/2 - 2*log(sin(pi/13))*cos(3*pi/13)
+ Rational(2422020029, 702257080))
Heoe = harmonic(ne + po/qe)
Aeoe = (-log(20) + 2*(Rational(1, 4) + sqrt(5)/4)*log(Rational(-1, 4) + sqrt(5)/4)
+ 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+ 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+ 2*(-sqrt(5)/4 + Rational(1, 4))*log(Rational(1, 4) + sqrt(5)/4)
+ Rational(11818877030, 4286604231) + pi*(sqrt(5)/8 + Rational(5, 8))/sqrt(-sqrt(5)/8 + Rational(5, 8)))
Heoo = harmonic(ne + po/qo)
Aeoo = (-log(26) + 2*log(sin(3*pi/13))*cos(54*pi/13) + 2*log(sin(4*pi/13))*cos(6*pi/13)
+ 2*log(sin(6*pi/13))*cos(108*pi/13) - 2*log(sin(5*pi/13))*cos(pi/13)
- 2*log(sin(pi/13))*cos(5*pi/13) + pi*cot(4*pi/13)/2
- 2*log(sin(2*pi/13))*cos(3*pi/13) + Rational(11669332571, 3628714320))
Hoee = harmonic(no + pe/qe)
Aoee = (-log(10) + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+ 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+ pi*(Rational(1, 4) + sqrt(5)/4)/(2*sqrt(-sqrt(5)/8 + Rational(5, 8)))
+ Rational(779405, 277704))
Hoeo = harmonic(no + pe/qo)
Aoeo = (-log(26) + 2*log(sin(3*pi/13))*cos(4*pi/13) + 2*log(sin(2*pi/13))*cos(32*pi/13)
+ 2*log(sin(5*pi/13))*cos(80*pi/13) - 2*log(sin(6*pi/13))*cos(5*pi/13)
- 2*log(sin(4*pi/13))*cos(pi/13) + pi*cot(5*pi/13)/2
- 2*log(sin(pi/13))*cos(3*pi/13) + Rational(53857323, 16331560))
Hooe = harmonic(no + po/qe)
Aooe = (-log(20) + 2*(Rational(1, 4) + sqrt(5)/4)*log(Rational(-1, 4) + sqrt(5)/4)
+ 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+ 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+ 2*(-sqrt(5)/4 + Rational(1, 4))*log(Rational(1, 4) + sqrt(5)/4)
+ Rational(486853480, 186374097) + pi*(sqrt(5)/8 + Rational(5, 8))/sqrt(-sqrt(5)/8 + Rational(5, 8)))
Hooo = harmonic(no + po/qo)
Aooo = (-log(26) + 2*log(sin(3*pi/13))*cos(54*pi/13) + 2*log(sin(4*pi/13))*cos(6*pi/13)
+ 2*log(sin(6*pi/13))*cos(108*pi/13) - 2*log(sin(5*pi/13))*cos(pi/13)
- 2*log(sin(pi/13))*cos(5*pi/13) + pi*cot(4*pi/13)/2
- 2*log(sin(2*pi/13))*cos(3*pi/13) + Rational(383693479, 125128080))
H = [Heee, Heeo, Heoe, Heoo, Hoee, Hoeo, Hooe, Hooo]
A = [Aeee, Aeeo, Aeoe, Aeoo, Aoee, Aoeo, Aooe, Aooo]
for h, a in zip(H, A):
e = expand_func(h).doit()
assert cancel(e/a) == 1
assert h.evalf() == a.evalf()
def test_harmonic_rational():
ne = Integer(6)
no = Integer(5)
pe = Integer(8)
po = Integer(9)
qe = Integer(10)
qo = Integer(13)
Heee = harmonic(ne + pe / qe)
Aeee = (-log(10) + 2 * (Rational(-1, 4) + sqrt(5) / 4) *
log(sqrt(-sqrt(5) / 8 + Rational(5, 8))) + 2 *
(-sqrt(5) / 4 - Rational(1, 4)) *
log(sqrt(sqrt(5) / 8 + Rational(5, 8))) + pi *
(Rational(1, 4) + sqrt(5) / 4) /
(2 * sqrt(-sqrt(5) / 8 + Rational(5, 8))) +
Rational(13944145, 4720968))
Heeo = harmonic(ne + pe / qo)
Aeeo = (-log(26) + 2 * log(sin(3 * pi / 13)) * cos(4 * pi / 13) +
2 * log(sin(2 * pi / 13)) * cos(32 * pi / 13) +
2 * log(sin(5 * pi / 13)) * cos(80 * pi / 13) -
2 * log(sin(6 * pi / 13)) * cos(5 * pi / 13) -
2 * log(sin(4 * pi / 13)) * cos(pi / 13) +
pi * cot(5 * pi / 13) / 2 -
2 * log(sin(pi / 13)) * cos(3 * pi / 13) +
Rational(2422020029, 702257080))
Heoe = harmonic(ne + po / qe)
Aeoe = (
-log(20) + 2 *
(Rational(1, 4) + sqrt(5) / 4) * log(Rational(-1, 4) + sqrt(5) / 4) +
2 * (Rational(-1, 4) + sqrt(5) / 4) *
log(sqrt(-sqrt(5) / 8 + Rational(5, 8))) + 2 *
(-sqrt(5) / 4 - Rational(1, 4)) *
log(sqrt(sqrt(5) / 8 + Rational(5, 8))) + 2 *
(-sqrt(5) / 4 + Rational(1, 4)) * log(Rational(1, 4) + sqrt(5) / 4) +
Rational(11818877030, 4286604231) + pi *
(sqrt(5) / 8 + Rational(5, 8)) / sqrt(-sqrt(5) / 8 + Rational(5, 8)))
Heoo = harmonic(ne + po / qo)
Aeoo = (-log(26) + 2 * log(sin(3 * pi / 13)) * cos(54 * pi / 13) +
2 * log(sin(4 * pi / 13)) * cos(6 * pi / 13) +
2 * log(sin(6 * pi / 13)) * cos(108 * pi / 13) -
2 * log(sin(5 * pi / 13)) * cos(pi / 13) -
2 * log(sin(pi / 13)) * cos(5 * pi / 13) +
pi * cot(4 * pi / 13) / 2 -
2 * log(sin(2 * pi / 13)) * cos(3 * pi / 13) +
Rational(11669332571, 3628714320))
Hoee = harmonic(no + pe / qe)
Aoee = (-log(10) + 2 * (Rational(-1, 4) + sqrt(5) / 4) *
log(sqrt(-sqrt(5) / 8 + Rational(5, 8))) + 2 *
(-sqrt(5) / 4 - Rational(1, 4)) *
log(sqrt(sqrt(5) / 8 + Rational(5, 8))) + pi *
(Rational(1, 4) + sqrt(5) / 4) /
(2 * sqrt(-sqrt(5) / 8 + Rational(5, 8))) +
Rational(779405, 277704))
Hoeo = harmonic(no + pe / qo)
Aoeo = (-log(26) + 2 * log(sin(3 * pi / 13)) * cos(4 * pi / 13) +
2 * log(sin(2 * pi / 13)) * cos(32 * pi / 13) +
2 * log(sin(5 * pi / 13)) * cos(80 * pi / 13) -
2 * log(sin(6 * pi / 13)) * cos(5 * pi / 13) -
2 * log(sin(4 * pi / 13)) * cos(pi / 13) +
pi * cot(5 * pi / 13) / 2 -
2 * log(sin(pi / 13)) * cos(3 * pi / 13) +
Rational(53857323, 16331560))
Hooe = harmonic(no + po / qe)
Aooe = (
-log(20) + 2 *
(Rational(1, 4) + sqrt(5) / 4) * log(Rational(-1, 4) + sqrt(5) / 4) +
2 * (Rational(-1, 4) + sqrt(5) / 4) *
log(sqrt(-sqrt(5) / 8 + Rational(5, 8))) + 2 *
(-sqrt(5) / 4 - Rational(1, 4)) *
log(sqrt(sqrt(5) / 8 + Rational(5, 8))) + 2 *
(-sqrt(5) / 4 + Rational(1, 4)) * log(Rational(1, 4) + sqrt(5) / 4) +
Rational(486853480, 186374097) + pi *
(sqrt(5) / 8 + Rational(5, 8)) / sqrt(-sqrt(5) / 8 + Rational(5, 8)))
Hooo = harmonic(no + po / qo)
Aooo = (-log(26) + 2 * log(sin(3 * pi / 13)) * cos(54 * pi / 13) +
2 * log(sin(4 * pi / 13)) * cos(6 * pi / 13) +
2 * log(sin(6 * pi / 13)) * cos(108 * pi / 13) -
2 * log(sin(5 * pi / 13)) * cos(pi / 13) -
2 * log(sin(pi / 13)) * cos(5 * pi / 13) +
pi * cot(4 * pi / 13) / 2 -
2 * log(sin(2 * pi / 13)) * cos(3 * pi / 13) +
Rational(383693479, 125128080))
H = [Heee, Heeo, Heoe, Heoo, Hoee, Hoeo, Hooe, Hooo]
A = [Aeee, Aeeo, Aeoe, Aeoo, Aoee, Aoeo, Aooe, Aooo]
for h, a in zip(H, A):
e = expand_func(h).doit()
assert cancel(e / a) == 1
assert h.evalf() == a.evalf()
def _expr_small(cls, z):
return log(Rational(1, 2) + sqrt(1 - z) / 2)
def _expr_small_minus(cls, z):
return log(Rational(1, 2) + sqrt(1 + z) / 2)
def f(rv):
if not (rv.is_Add or rv.is_Mul):
return rv
def gooda(a):
# bool to tell whether the leading ``a`` in ``a*log(x)``
# could appear as log(x**a)
return (a is not S.NegativeOne
and # -1 *could* go, but we disallow
(a.is_extended_real
or force and a.is_extended_real is not False))
def goodlog(l):
# bool to tell whether log ``l``'s argument can combine with others
a = l.args[0]
return a.is_positive or force and a.is_nonpositive is not False
other = []
logs = []
log1 = defaultdict(list)
for a in Add.make_args(rv):
if a.func is log and goodlog(a):
log1[()].append(([], a))
elif not a.is_Mul:
other.append(a)
else:
ot = []
co = []
lo = []
for ai in a.args:
if ai.is_Rational and ai < 0:
ot.append(S.NegativeOne)
co.append(-ai)
elif ai.func is log and goodlog(ai):
lo.append(ai)
elif gooda(ai):
co.append(ai)
else:
ot.append(ai)
if len(lo) > 1:
logs.append((ot, co, lo))
elif lo:
log1[tuple(ot)].append((co, lo[0]))
else:
other.append(a)
# if there is only one log at each coefficient and none have
# an exponent to place inside the log then there is nothing to do
if not logs and all(
len(log1[k]) == 1 and log1[k][0] == [] for k in log1):
return rv
# collapse multi-logs as far as possible in a canonical way
# TODO: see if x*log(a)+x*log(a)*log(b) -> x*log(a)*(1+log(b))?
# -- in this case, it's unambiguous, but if it were were a log(c) in
# each term then it's arbitrary whether they are grouped by log(a) or
# by log(c). So for now, just leave this alone; it's probably better to
# let the user decide
for o, e, l in logs:
l = list(ordered(l))
e = log(l.pop(0).args[0]**Mul(*e))
while l:
li = l.pop(0)
e = log(li.args[0]**e)
c, l = Mul(*o), e
if l.func is log: # it should be, but check to be sure
log1[(c, )].append(([], l))
else:
other.append(c * l)
# logs that have the same coefficient can multiply
for k in list(log1.keys()):
log1[Mul(*k)] = log(
logcombine(Mul(*[l.args[0]**Mul(*c) for c, l in log1.pop(k)]),
force=force))
# logs that have oppositely signed coefficients can divide
for k in ordered(list(log1.keys())):
if k not in log1: # already popped as -k
continue
if -k in log1:
# figure out which has the minus sign; the one with
# more op counts should be the one
num, den = k, -k
if num.count_ops() > den.count_ops():
num, den = den, num
other.append(
num * log(log1.pop(num).args[0] / log1.pop(den).args[0]))
else:
other.append(k * log1.pop(k))
return Add(*other)
def _expr_big_minus(self, z, n):
if n.is_even:
return pi * I * n + log(Rational(1, 2) + sqrt(1 + z) / 2)
else:
return pi * I * n + log(sqrt(1 + z) / 2 - Rational(1, 2))
def _integrate(field=None):
irreducibles = set()
for poly in reducibles:
for z in poly.free_symbols:
if z in V:
break # should this be: `irreducibles |= \
else: # set(root_factors(poly, z, filter=field))`
continue # and the line below deleted?
# |
# V
irreducibles |= set(root_factors(poly, z, filter=field))
log_coeffs, log_part = [], []
B = _symbols('B', len(irreducibles))
# Note: the ordering matters here
for poly, b in reversed(list(ordered(zip(irreducibles, B)))):
if poly.has(*V):
poly_coeffs.append(b)
log_part.append(b * log(poly))
# TODO: Currently it's better to use symbolic expressions here instead
# of rational functions, because it's simpler and FracElement doesn't
# give big speed improvement yet. This is because cancelation is slow
# due to slow polynomial GCD algorithms. If this gets improved then
# revise this code.
candidate = poly_part / poly_denom + Add(*log_part)
h = F - _derivation(candidate) / denom
raw_numer = h.as_numer_denom()[0]
# Rewrite raw_numer as a polynomial in K[coeffs][V] where K is a field
# that we have to determine. We can't use simply atoms() because log(3),
# sqrt(y) and similar expressions can appear, leading to non-trivial
# domains.
syms = set(poly_coeffs) | set(V)
non_syms = set()
def find_non_syms(expr):
if expr.is_Integer or expr.is_Rational:
pass # ignore trivial numbers
elif expr in syms:
pass # ignore variables
elif not expr.has(*syms):
non_syms.add(expr)
elif expr.is_Add or expr.is_Mul or expr.is_Pow:
list(map(find_non_syms, expr.args))
else:
# TODO: Non-polynomial expression. This should have been
# filtered out at an earlier stage.
raise PolynomialError
try:
find_non_syms(raw_numer)
except PolynomialError:
return
else:
ground, _ = construct_domain(non_syms, field=True)
coeff_ring = PolyRing(poly_coeffs, ground)
ring = PolyRing(V, coeff_ring)
numer = ring.from_expr(raw_numer)
solution = solve_lin_sys(numer.coeffs(), coeff_ring)
if solution is None:
return
else:
solution = [(coeff_ring.symbols[coeff_ring.index(k)], v.as_expr())
for k, v in solution.items()]
return candidate.subs(solution).subs(
list(zip(poly_coeffs, [S.Zero] * len(poly_coeffs))))
def _denest_pow(eq):
"""
Denest powers.
This is a helper function for powdenest that performs the actual
transformation.
"""
from diofant.simplify.simplify import logcombine
b, e = eq.as_base_exp()
if b.is_Pow and e != 1:
new = b._eval_power(e)
if new is not None:
eq = new
b, e = new.as_base_exp()
# denest exp with log terms in exponent
if b is S.Exp1 and e.is_Mul:
logs = []
other = []
for ei in e.args:
if any(ai.func is log for ai in Add.make_args(ei)):
logs.append(ei)
else:
other.append(ei)
logs = logcombine(Mul(*logs))
return Pow(exp(logs), Mul(*other))
_, be = b.as_base_exp()
if be is S.One and not (b.is_Mul or b.is_Rational and b.q != 1
or b.is_positive):
return eq
# denest eq which is either pos**e or Pow**e or Mul**e or
# Mul(b1**e1, b2**e2)
# handle polar numbers specially
polars, nonpolars = [], []
for bb in Mul.make_args(b):
if bb.is_polar:
polars.append(bb.as_base_exp())
else:
nonpolars.append(bb)
if len(polars) == 1 and not polars[0][0].is_Mul:
return Pow(polars[0][0], polars[0][1] * e) * powdenest(
Mul(*nonpolars)**e)
elif polars:
return Mul(*[powdenest(bb**(ee*e)) for (bb, ee) in polars]) \
* powdenest(Mul(*nonpolars)**e)
if b.is_Integer:
# use log to see if there is a power here
logb = expand_log(log(b))
if logb.is_Mul:
c, logb = logb.args
e *= c
base = logb.args[0]
return Pow(base, e)
# if b is not a Mul or any factor is an atom then there is nothing to do
if not b.is_Mul or any(s.is_Atom for s in Mul.make_args(b)):
return eq
# let log handle the case of the base of the argument being a Mul, e.g.
# sqrt(x**(2*i)*y**(6*i)) -> x**i*y**(3**i) if x and y are positive; we
# will take the log, expand it, and then factor out the common powers that
# now appear as coefficient. We do this manually since terms_gcd pulls out
# fractions, terms_gcd(x+x*y/2) -> x*(y + 2)/2 and we don't want the 1/2;
# gcd won't pull out numerators from a fraction: gcd(3*x, 9*x/2) -> x but
# we want 3*x. Neither work with noncommutatives.
def nc_gcd(aa, bb):
a, b = [i.as_coeff_Mul() for i in [aa, bb]]
c = gcd(a[0], b[0]).as_numer_denom()[0]
g = Mul(*(a[1].args_cnc(cset=True)[0] & b[1].args_cnc(cset=True)[0]))
return _keep_coeff(c, g)
glogb = expand_log(log(b))
if glogb.is_Add:
args = glogb.args
g = reduce(nc_gcd, args)
if g != 1:
cg, rg = g.as_coeff_Mul()
glogb = _keep_coeff(cg, rg * Add(*[a / g for a in args]))
# now put the log back together again
if glogb.func is log or not glogb.is_Mul:
if glogb.args[0].is_Pow:
glogb = _denest_pow(glogb.args[0])
if (abs(glogb.exp) < 1) is S.true:
return Pow(glogb.base, glogb.exp * e)
return eq
# the log(b) was a Mul so join any adds with logcombine
add = []
other = []
for a in glogb.args:
if a.is_Add:
add.append(a)
else:
other.append(a)
return Pow(exp(logcombine(Mul(*add))), e * Mul(*other))
def _diff_wrt_parameter(self, idx):
# Differentiation wrt a parameter can only be done in very special
# cases. In particular, if we want to differentiate with respect to
# `a`, all other gamma factors have to reduce to rational functions.
#
# Let MT denote mellin transform. Suppose T(-s) is the gamma factor
# appearing in the definition of G. Then
#
# MT(log(z)G(z)) = d/ds T(s) = d/da T(s) + ...
#
# Thus d/da G(z) = log(z)G(z) - ...
# The ... can be evaluated as a G function under the above conditions,
# the formula being most easily derived by using
#
# d Gamma(s + n) Gamma(s + n) / 1 1 1 \
# -- ------------ = ------------ | - + ---- + ... + --------- |
# ds Gamma(s) Gamma(s) \ s s + 1 s + n - 1 /
#
# which follows from the difference equation of the digamma function.
# (There is a similar equation for -n instead of +n).
# We first figure out how to pair the parameters.
an = list(self.an)
ap = list(self.aother)
bm = list(self.bm)
bq = list(self.bother)
if idx < len(an):
an.pop(idx)
else:
idx -= len(an)
if idx < len(ap):
ap.pop(idx)
else:
idx -= len(ap)
if idx < len(bm):
bm.pop(idx)
else:
bq.pop(idx - len(bm))
pairs1 = []
pairs2 = []
for l1, l2, pairs in [(an, bq, pairs1), (ap, bm, pairs2)]:
while l1:
x = l1.pop()
found = None
for i, y in enumerate(l2):
if not Mod((x - y).simplify(), 1):
found = i
break
if found is None:
raise NotImplementedError('Derivative not expressible '
'as G-function?')
y = l2[i]
l2.pop(i)
pairs.append((x, y))
# Now build the result.
res = log(self.argument) * self
for a, b in pairs1:
sign = 1
n = a - b
base = b
if n < 0:
sign = -1
n = b - a
base = a
for k in range(n):
res -= sign * meijerg(self.an + (base + k + 1, ), self.aother,
self.bm, self.bother +
(base + k + 0, ), self.argument)
for a, b in pairs2:
sign = 1
n = b - a
base = a
if n < 0:
sign = -1
n = a - b
base = b
for k in range(n):
res -= sign * meijerg(
self.an, self.aother + (base + k + 1, ), self.bm +
(base + k + 0, ), self.bother, self.argument)
return res
def test_RootSum():
r = RootSum(x**3 + x + 3, Lambda(y, log(y*z)))
assert mcode(r) == ("RootSum[Function[{x}, x^3 + x + 3], "
"Function[{y}, Log[y*z]]]")
def heurisch(f,
x,
rewrite=False,
hints=None,
mappings=None,
retries=3,
degree_offset=0,
unnecessary_permutations=None):
"""
Compute indefinite integral using heuristic Risch algorithm.
This is a heuristic approach to indefinite integration in finite
terms using the extended heuristic (parallel) Risch algorithm, based
on Manuel Bronstein's "Poor Man's Integrator" [1]_.
The algorithm supports various classes of functions including
transcendental elementary or special functions like Airy,
Bessel, Whittaker and Lambert.
Note that this algorithm is not a decision procedure. If it isn't
able to compute the antiderivative for a given function, then this is
not a proof that such a functions does not exist. One should use
recursive Risch algorithm in such case. It's an open question if
this algorithm can be made a full decision procedure.
This is an internal integrator procedure. You should use toplevel
'integrate' function in most cases, as this procedure needs some
preprocessing steps and otherwise may fail.
Parameters
==========
heurisch(f, x, rewrite=False, hints=None)
f : Expr
expression
x : Symbol
variable
rewrite : Boolean, optional
force rewrite 'f' in terms of 'tan' and 'tanh', default False.
hints : None or list
a list of functions that may appear in anti-derivate. If
None (default) - no suggestions at all, if empty list - try
to figure out.
Examples
========
>>> from diofant import tan
>>> from diofant.integrals.heurisch import heurisch
>>> from diofant.abc import x, y
>>> heurisch(y*tan(x), x)
y*log(tan(x)**2 + 1)/2
References
==========
.. [1] Manuel Bronstein's "Poor Man's Integrator",
http://www-sop.inria.fr/cafe/Manuel.Bronstein/pmint/index.html
.. [2] K. Geddes, L. Stefanus, On the Risch-Norman Integration
Method and its Implementation in Maple, Proceedings of
ISSAC'89, ACM Press, 212-217.
.. [3] J. H. Davenport, On the Parallel Risch Algorithm (I),
Proceedings of EUROCAM'82, LNCS 144, Springer, 144-157.
.. [4] J. H. Davenport, On the Parallel Risch Algorithm (III):
Use of Tangents, SIGSAM Bulletin 16 (1982), 3-6.
.. [5] J. H. Davenport, B. M. Trager, On the Parallel Risch
Algorithm (II), ACM Transactions on Mathematical
Software 11 (1985), 356-362.
See Also
========
diofant.integrals.integrals.Integral.doit
diofant.integrals.integrals.Integral
diofant.integrals.heurisch.components
"""
f = sympify(f)
if x not in f.free_symbols:
return f * x
if not f.is_Add:
indep, f = f.as_independent(x)
else:
indep = S.One
rewritables = {
(sin, cos, cot): tan,
(sinh, cosh, coth): tanh,
}
if rewrite:
for candidates, rule in rewritables.items():
f = f.rewrite(candidates, rule)
else:
for candidates in rewritables.keys():
if f.has(*candidates):
break
else:
rewrite = True
terms = components(f, x)
if hints is not None:
if not hints:
a = Wild('a', exclude=[x])
b = Wild('b', exclude=[x])
c = Wild('c', exclude=[x])
for g in set(terms): # using copy of terms
if g.is_Function:
if g.func is li:
M = g.args[0].match(a * x**b)
if M is not None:
terms.add(
x *
(li(M[a] * x**M[b]) -
(M[a] * x**M[b])**(-1 / M[b]) * Ei(
(M[b] + 1) * log(M[a] * x**M[b]) / M[b])))
# terms.add( x*(li(M[a]*x**M[b]) - (x**M[b])**(-1/M[b])*Ei((M[b]+1)*log(M[a]*x**M[b])/M[b])) )
# terms.add( x*(li(M[a]*x**M[b]) - x*Ei((M[b]+1)*log(M[a]*x**M[b])/M[b])) )
# terms.add( li(M[a]*x**M[b]) - Ei((M[b]+1)*log(M[a]*x**M[b])/M[b]) )
elif g.is_Pow:
if g.base is S.Exp1:
M = g.exp.match(a * x**2)
if M is not None:
if M[a].is_positive:
terms.add(erfi(sqrt(M[a]) * x))
else: # M[a].is_negative or unknown
terms.add(erf(sqrt(-M[a]) * x))
M = g.exp.match(a * x**2 + b * x + c)
if M is not None:
if M[a].is_positive:
terms.add(
sqrt(pi / 4 * (-M[a])) *
exp(M[c] - M[b]**2 / (4 * M[a])) * erfi(
sqrt(M[a]) * x + M[b] /
(2 * sqrt(M[a]))))
elif M[a].is_negative:
terms.add(
sqrt(pi / 4 * (-M[a])) *
exp(M[c] - M[b]**2 / (4 * M[a])) * erf(
sqrt(-M[a]) * x - M[b] /
(2 * sqrt(-M[a]))))
M = g.exp.match(a * log(x)**2)
if M is not None:
if M[a].is_positive:
terms.add(
erfi(
sqrt(M[a]) * log(x) + 1 /
(2 * sqrt(M[a]))))
if M[a].is_negative:
terms.add(
erf(
sqrt(-M[a]) * log(x) - 1 /
(2 * sqrt(-M[a]))))
elif g.exp.is_Rational and g.exp.q == 2:
M = g.base.match(a * x**2 + b)
if M is not None and M[b].is_positive:
if M[a].is_positive:
terms.add(asinh(sqrt(M[a] / M[b]) * x))
elif M[a].is_negative:
terms.add(asin(sqrt(-M[a] / M[b]) * x))
M = g.base.match(a * x**2 - b)
if M is not None and M[b].is_positive:
if M[a].is_positive:
terms.add(acosh(sqrt(M[a] / M[b]) * x))
elif M[a].is_negative:
terms.add((-M[b] / 2 * sqrt(-M[a]) * atan(
sqrt(-M[a]) * x / sqrt(M[a] * x**2 - M[b]))
))
else:
terms |= set(hints)
for g in set(terms): # using copy of terms
terms |= components(cancel(g.diff(x)), x)
# TODO: caching is significant factor for why permutations work at all. Change this.
V = _symbols('x', len(terms))
# sort mapping expressions from largest to smallest (last is always x).
mapping = list(
reversed(
list(
zip(*ordered( #
[(a[0].as_independent(x)[1], a)
for a in zip(terms, V)])))[1])) #
rev_mapping = {v: k for k, v in mapping} #
if mappings is None: #
# optimizing the number of permutations of mapping #
assert mapping[-1][0] == x # if not, find it and correct this comment
unnecessary_permutations = [mapping.pop(-1)]
mappings = permutations(mapping)
else:
unnecessary_permutations = unnecessary_permutations or []
def _substitute(expr):
return expr.subs(mapping)
for mapping in mappings:
mapping = list(mapping)
mapping = mapping + unnecessary_permutations
diffs = [_substitute(cancel(g.diff(x))) for g in terms]
denoms = [g.as_numer_denom()[1] for g in diffs]
if all(h.is_polynomial(*V)
for h in denoms) and _substitute(f).is_rational_function(*V):
denom = reduce(lambda p, q: lcm(p, q, *V), denoms)
break
else:
if not rewrite:
result = heurisch(
f,
x,
rewrite=True,
hints=hints,
unnecessary_permutations=unnecessary_permutations)
if result is not None:
return indep * result
return
numers = [cancel(denom * g) for g in diffs]
def _derivation(h):
return Add(*[d * h.diff(v) for d, v in zip(numers, V)])
def _deflation(p):
for y in V:
if not p.has(y):
continue
if _derivation(p) is not S.Zero:
c, q = p.as_poly(y).primitive()
return _deflation(c) * gcd(q, q.diff(y)).as_expr()
else:
return p
def _splitter(p):
for y in V:
if not p.has(y):
continue
if _derivation(y) is not S.Zero:
c, q = p.as_poly(y).primitive()
q = q.as_expr()
h = gcd(q, _derivation(q), y)
s = quo(h, gcd(q, q.diff(y), y), y)
c_split = _splitter(c)
if s.as_poly(y).degree() == 0:
return c_split[0], q * c_split[1]
q_split = _splitter(cancel(q / s))
return c_split[0] * q_split[0] * s, c_split[1] * q_split[1]
else:
return S.One, p
special = {}
for term in terms:
if term.is_Function:
if term.func is tan:
special[1 + _substitute(term)**2] = False
elif term.func is tanh:
special[1 + _substitute(term)] = False
special[1 - _substitute(term)] = False
elif term.func is LambertW:
special[_substitute(term)] = True
F = _substitute(f)
P, Q = F.as_numer_denom()
u_split = _splitter(denom)
v_split = _splitter(Q)
polys = set(list(v_split) + [u_split[0]] + list(special.keys()))
s = u_split[0] * Mul(*[k for k, v in special.items() if v])
polified = [p.as_poly(*V) for p in [s, P, Q]]
if None in polified:
return
# --- definitions for _integrate ---
a, b, c = [p.total_degree() for p in polified]
poly_denom = (s * v_split[0] * _deflation(v_split[1])).as_expr()
def _exponent(g):
if g.is_Pow:
if g.exp.is_Rational and g.exp.q != 1:
if g.exp.p > 0:
return g.exp.p + g.exp.q - 1
else:
return abs(g.exp.p + g.exp.q)
else:
return 1
elif not g.is_Atom and g.args:
return max([_exponent(h) for h in g.args])
else:
return 1
A, B = _exponent(f), a + max(b, c)
if A > 1 and B > 1:
monoms = itermonomials(V, A + B - 1 + degree_offset)
else:
monoms = itermonomials(V, A + B + degree_offset)
poly_coeffs = _symbols('A', len(monoms))
poly_part = Add(*[
poly_coeffs[i] * monomial for i, monomial in enumerate(ordered(monoms))
])
reducibles = set()
for poly in polys:
if poly.has(*V):
try:
factorization = factor(poly, greedy=True)
except PolynomialError:
factorization = poly
factorization = poly
if factorization.is_Mul:
reducibles |= set(factorization.args)
else:
reducibles.add(factorization)
def _integrate(field=None):
irreducibles = set()
for poly in reducibles:
for z in poly.free_symbols:
if z in V:
break # should this be: `irreducibles |= \
else: # set(root_factors(poly, z, filter=field))`
continue # and the line below deleted?
# |
# V
irreducibles |= set(root_factors(poly, z, filter=field))
log_coeffs, log_part = [], []
B = _symbols('B', len(irreducibles))
# Note: the ordering matters here
for poly, b in reversed(list(ordered(zip(irreducibles, B)))):
if poly.has(*V):
poly_coeffs.append(b)
log_part.append(b * log(poly))
# TODO: Currently it's better to use symbolic expressions here instead
# of rational functions, because it's simpler and FracElement doesn't
# give big speed improvement yet. This is because cancelation is slow
# due to slow polynomial GCD algorithms. If this gets improved then
# revise this code.
candidate = poly_part / poly_denom + Add(*log_part)
h = F - _derivation(candidate) / denom
raw_numer = h.as_numer_denom()[0]
# Rewrite raw_numer as a polynomial in K[coeffs][V] where K is a field
# that we have to determine. We can't use simply atoms() because log(3),
# sqrt(y) and similar expressions can appear, leading to non-trivial
# domains.
syms = set(poly_coeffs) | set(V)
non_syms = set()
def find_non_syms(expr):
if expr.is_Integer or expr.is_Rational:
pass # ignore trivial numbers
elif expr in syms:
pass # ignore variables
elif not expr.has(*syms):
non_syms.add(expr)
elif expr.is_Add or expr.is_Mul or expr.is_Pow:
list(map(find_non_syms, expr.args))
else:
# TODO: Non-polynomial expression. This should have been
# filtered out at an earlier stage.
raise PolynomialError
try:
find_non_syms(raw_numer)
except PolynomialError:
return
else:
ground, _ = construct_domain(non_syms, field=True)
coeff_ring = PolyRing(poly_coeffs, ground)
ring = PolyRing(V, coeff_ring)
numer = ring.from_expr(raw_numer)
solution = solve_lin_sys(numer.coeffs(), coeff_ring)
if solution is None:
return
else:
solution = [(coeff_ring.symbols[coeff_ring.index(k)], v.as_expr())
for k, v in solution.items()]
return candidate.subs(solution).subs(
list(zip(poly_coeffs, [S.Zero] * len(poly_coeffs))))
if not (F.free_symbols - set(V)):
solution = _integrate('Q')
if solution is None:
solution = _integrate()
else:
solution = _integrate()
if solution is not None:
antideriv = solution.subs(rev_mapping)
antideriv = cancel(antideriv).expand(force=True)
if antideriv.is_Add:
antideriv = antideriv.as_independent(x)[1]
return indep * antideriv
else:
if retries >= 0:
result = heurisch(
f,
x,
mappings=mappings,
rewrite=rewrite,
hints=hints,
retries=retries - 1,
unnecessary_permutations=unnecessary_permutations)
if result is not None:
return indep * result
return
