def _expr_big(cls, z, n):
if n.is_even:
return (n - S.Half) * pi * I + log(
sqrt(z) / 2) + I * asin(1 / sqrt(z))
else:
return (n - S.Half) * pi * I + log(
sqrt(z) / 2) - I * asin(1 / sqrt(z))
def test_C99CodePrinter__precision():
n = symbols('n', integer=True)
f32_printer = C99CodePrinter(dict(type_aliases={real: float32}))
f64_printer = C99CodePrinter(dict(type_aliases={real: float64}))
f80_printer = C99CodePrinter(dict(type_aliases={real: float80}))
assert f32_printer.doprint(sin(x+2.1)) == 'sinf(x + 2.1F)'
assert f64_printer.doprint(sin(x+2.1)) == 'sin(x + 2.1000000000000001)'
assert f80_printer.doprint(sin(x+Float('2.0'))) == 'sinl(x + 2.0L)'
for printer, suffix in zip([f32_printer, f64_printer, f80_printer], ['f', '', 'l']):
def check(expr, ref):
assert printer.doprint(expr) == ref.format(s=suffix, S=suffix.upper())
check(Abs(n), 'abs(n)')
check(Abs(x + 2.0), 'fabs{s}(x + 2.0{S})')
check(sin(x + 4.0)**cos(x - 2.0), 'pow{s}(sin{s}(x + 4.0{S}), cos{s}(x - 2.0{S}))')
check(exp(x*8.0), 'exp{s}(8.0{S}*x)')
check(exp2(x), 'exp2{s}(x)')
check(expm1(x*4.0), 'expm1{s}(4.0{S}*x)')
check(Mod(n, 2), '((n) % (2))')
check(Mod(2*n + 3, 3*n + 5), '((2*n + 3) % (3*n + 5))')
check(Mod(x + 2.0, 3.0), 'fmod{s}(1.0{S}*x + 2.0{S}, 3.0{S})')
check(Mod(x, 2.0*x + 3.0), 'fmod{s}(1.0{S}*x, 2.0{S}*x + 3.0{S})')
check(log(x/2), 'log{s}((1.0{S}/2.0{S})*x)')
check(log10(3*x/2), 'log10{s}((3.0{S}/2.0{S})*x)')
check(log2(x*8.0), 'log2{s}(8.0{S}*x)')
check(log1p(x), 'log1p{s}(x)')
check(2**x, 'pow{s}(2, x)')
check(2.0**x, 'pow{s}(2.0{S}, x)')
check(x**3, 'pow{s}(x, 3)')
check(x**4.0, 'pow{s}(x, 4.0{S})')
check(sqrt(3+x), 'sqrt{s}(x + 3)')
check(Cbrt(x-2.0), 'cbrt{s}(x - 2.0{S})')
check(hypot(x, y), 'hypot{s}(x, y)')
check(sin(3.*x + 2.), 'sin{s}(3.0{S}*x + 2.0{S})')
check(cos(3.*x - 1.), 'cos{s}(3.0{S}*x - 1.0{S})')
check(tan(4.*y + 2.), 'tan{s}(4.0{S}*y + 2.0{S})')
check(asin(3.*x + 2.), 'asin{s}(3.0{S}*x + 2.0{S})')
check(acos(3.*x + 2.), 'acos{s}(3.0{S}*x + 2.0{S})')
check(atan(3.*x + 2.), 'atan{s}(3.0{S}*x + 2.0{S})')
check(atan2(3.*x, 2.*y), 'atan2{s}(3.0{S}*x, 2.0{S}*y)')
check(sinh(3.*x + 2.), 'sinh{s}(3.0{S}*x + 2.0{S})')
check(cosh(3.*x - 1.), 'cosh{s}(3.0{S}*x - 1.0{S})')
check(tanh(4.0*y + 2.), 'tanh{s}(4.0{S}*y + 2.0{S})')
check(asinh(3.*x + 2.), 'asinh{s}(3.0{S}*x + 2.0{S})')
check(acosh(3.*x + 2.), 'acosh{s}(3.0{S}*x + 2.0{S})')
check(atanh(3.*x + 2.), 'atanh{s}(3.0{S}*x + 2.0{S})')
check(erf(42.*x), 'erf{s}(42.0{S}*x)')
check(erfc(42.*x), 'erfc{s}(42.0{S}*x)')
check(gamma(x), 'tgamma{s}(x)')
check(loggamma(x), 'lgamma{s}(x)')
check(ceiling(x + 2.), "ceil{s}(x + 2.0{S})")
check(floor(x + 2.), "floor{s}(x + 2.0{S})")
check(fma(x, y, -z), 'fma{s}(x, y, -z)')
check(Max(x, 8.0, x**4.0), 'fmax{s}(8.0{S}, fmax{s}(x, pow{s}(x, 4.0{S})))')
check(Min(x, 2.0), 'fmin{s}(2.0{S}, x)')
def test_C99CodePrinter__precision():
n = symbols('n', integer=True)
f32_printer = C99CodePrinter(dict(type_aliases={real: float32}))
f64_printer = C99CodePrinter(dict(type_aliases={real: float64}))
f80_printer = C99CodePrinter(dict(type_aliases={real: float80}))
assert f32_printer.doprint(sin(x+2.1)) == 'sinf(x + 2.1F)'
assert f64_printer.doprint(sin(x+2.1)) == 'sin(x + 2.1000000000000001)'
assert f80_printer.doprint(sin(x+Float('2.0'))) == 'sinl(x + 2.0L)'
for printer, suffix in zip([f32_printer, f64_printer, f80_printer], ['f', '', 'l']):
def check(expr, ref):
assert printer.doprint(expr) == ref.format(s=suffix, S=suffix.upper())
check(Abs(n), 'abs(n)')
check(Abs(x + 2.0), 'fabs{s}(x + 2.0{S})')
check(sin(x + 4.0)**cos(x - 2.0), 'pow{s}(sin{s}(x + 4.0{S}), cos{s}(x - 2.0{S}))')
check(exp(x*8.0), 'exp{s}(8.0{S}*x)')
check(exp2(x), 'exp2{s}(x)')
check(expm1(x*4.0), 'expm1{s}(4.0{S}*x)')
check(Mod(n, 2), '((n) % (2))')
check(Mod(2*n + 3, 3*n + 5), '((2*n + 3) % (3*n + 5))')
check(Mod(x + 2.0, 3.0), 'fmod{s}(1.0{S}*x + 2.0{S}, 3.0{S})')
check(Mod(x, 2.0*x + 3.0), 'fmod{s}(1.0{S}*x, 2.0{S}*x + 3.0{S})')
check(log(x/2), 'log{s}((1.0{S}/2.0{S})*x)')
check(log10(3*x/2), 'log10{s}((3.0{S}/2.0{S})*x)')
check(log2(x*8.0), 'log2{s}(8.0{S}*x)')
check(log1p(x), 'log1p{s}(x)')
check(2**x, 'pow{s}(2, x)')
check(2.0**x, 'pow{s}(2.0{S}, x)')
check(x**3, 'pow{s}(x, 3)')
check(x**4.0, 'pow{s}(x, 4.0{S})')
check(sqrt(3+x), 'sqrt{s}(x + 3)')
check(Cbrt(x-2.0), 'cbrt{s}(x - 2.0{S})')
check(hypot(x, y), 'hypot{s}(x, y)')
check(sin(3.*x + 2.), 'sin{s}(3.0{S}*x + 2.0{S})')
check(cos(3.*x - 1.), 'cos{s}(3.0{S}*x - 1.0{S})')
check(tan(4.*y + 2.), 'tan{s}(4.0{S}*y + 2.0{S})')
check(asin(3.*x + 2.), 'asin{s}(3.0{S}*x + 2.0{S})')
check(acos(3.*x + 2.), 'acos{s}(3.0{S}*x + 2.0{S})')
check(atan(3.*x + 2.), 'atan{s}(3.0{S}*x + 2.0{S})')
check(atan2(3.*x, 2.*y), 'atan2{s}(3.0{S}*x, 2.0{S}*y)')
check(sinh(3.*x + 2.), 'sinh{s}(3.0{S}*x + 2.0{S})')
check(cosh(3.*x - 1.), 'cosh{s}(3.0{S}*x - 1.0{S})')
check(tanh(4.0*y + 2.), 'tanh{s}(4.0{S}*y + 2.0{S})')
check(asinh(3.*x + 2.), 'asinh{s}(3.0{S}*x + 2.0{S})')
check(acosh(3.*x + 2.), 'acosh{s}(3.0{S}*x + 2.0{S})')
check(atanh(3.*x + 2.), 'atanh{s}(3.0{S}*x + 2.0{S})')
check(erf(42.*x), 'erf{s}(42.0{S}*x)')
check(erfc(42.*x), 'erfc{s}(42.0{S}*x)')
check(gamma(x), 'tgamma{s}(x)')
check(loggamma(x), 'lgamma{s}(x)')
check(ceiling(x + 2.), "ceil{s}(x + 2.0{S})")
check(floor(x + 2.), "floor{s}(x + 2.0{S})")
check(fma(x, y, -z), 'fma{s}(x, y, -z)')
check(Max(x, 8.0, x**4.0), 'fmax{s}(8.0{S}, fmax{s}(x, pow{s}(x, 4.0{S})))')
check(Min(x, 2.0), 'fmin{s}(2.0{S}, x)')
def _expr_big(cls, z, n):
if n.is_even:
return (n - S(1)/2)*pi*I + log(sqrt(z)/2) + I*asin(1/sqrt(z))
else:
return (n - S(1)/2)*pi*I + log(sqrt(z)/2) - I*asin(1/sqrt(z))
def _expr_small(cls, z):
return asin(sqrt(z))/sqrt(z)
def _expr_small(cls, a, z):
return sqrt(z)/sqrt(1 - z)*sin(2*a*asin(sqrt(z)))
def test_jscode_functions():
assert jscode(sin(x) ** cos(x)) == "Math.pow(Math.sin(x), Math.cos(x))"
assert jscode(sinh(x) * cosh(x)) == "Math.sinh(x)*Math.cosh(x)"
assert jscode(Max(x, y) + Min(x, y)) == "Math.max(x, y) + Math.min(x, y)"
assert jscode(tanh(x)*acosh(y)) == "Math.tanh(x)*Math.acosh(y)"
assert jscode(asin(x)-acos(y)) == "-Math.acos(y) + Math.asin(x)"
def heurisch(f, x, rewrite=False, hints=None, mappings=None, retries=3):
"""
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".
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.
Specification
=============
heurisch(f, x, rewrite=False, hints=None)
where
f : expression
x : symbol
rewrite -> force rewrite 'f' in terms of 'tan' and 'tanh'
hints -> a list of functions that may appear in anti-derivate
- hints = None --> no suggestions at all
- hints = [ ] --> try to figure out
- hints = [f1, ..., fn] --> we know better
Examples
========
>>> from sympy import tan
>>> from sympy.integrals.heurisch import heurisch
>>> from sympy.abc import x, y
>>> heurisch(y*tan(x), x)
y*log(tan(x)**2 + 1)/2
See Manuel Bronstein's "Poor Man's Integrator":
[1] http://www-sop.inria.fr/cafe/Manuel.Bronstein/pmint/index.html
For more information on the implemented algorithm refer to:
[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
========
sympy.integrals.integrals.Integral.doit
sympy.integrals.integrals.Integral
components
"""
f = sympify(f)
if not f.is_Add:
indep, f = f.as_independent(x)
else:
indep = S.One
if not f.has(x):
return indep * f * x
rewritables = {
(sin, cos, cot): tan,
(sinh, cosh, coth): tanh,
}
if rewrite:
for candidates, rule in rewritables.iteritems():
f = f.rewrite(candidates, rule)
else:
for candidates in rewritables.iterkeys():
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):
if g.is_Function:
if g.func is exp:
M = g.args[0].match(a * x**2)
if M is not None:
terms.add(erf(sqrt(-M[a]) * x))
M = g.args[0].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])) *
erf(-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.args[0].match(a * log(x)**2)
if M is not None:
if M[a].is_positive:
terms.add(-I * erf(I *
(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.is_Pow:
if 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):
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))
mapping = dict(zip(terms, V))
rev_mapping = {}
for k, v in mapping.iteritems():
rev_mapping[v] = k
if mappings is None:
# Pre-sort mapping in order of largest to smallest expressions (last is always x).
def _sort_key(arg):
return default_sort_key(arg[0].as_independent(x)[1])
mapping = sorted(mapping.items(), key=_sort_key, reverse=True)
mappings = permutations(mapping)
def _substitute(expr):
return expr.subs(mapping)
for mapping in mappings:
# TODO: optimize this by not generating permutations where mapping[-1] != x.
if mapping[-1][0] != x:
continue
mapping = list(mapping)
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)
if result is not None:
return indep * result
return None
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 C.LambertW:
special[_substitute(term)] = True
F = _substitute(f)
P, Q = F.as_numer_denom()
u_split = _splitter(denom)
v_split = _splitter(Q)
polys = list(v_split) + [u_split[0]] + special.keys()
s = u_split[0] * Mul(*[k for k, v in special.iteritems() if v])
polified = [p.as_poly(*V) for p in [s, P, Q]]
if None in polified:
return None
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 = monomials(V, A + B - 1)
else:
monoms = monomials(V, A + B)
poly_coeffs = _symbols('A', len(monoms))
poly_part = Add(
*[poly_coeffs[i] * monomial for i, monomial in enumerate(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.atoms(Symbol):
if z in V:
break
else:
continue
irreducibles |= set(root_factors(poly, z, filter=field))
log_coeffs, log_part = [], []
B = _symbols('B', len(irreducibles))
for i, poly in enumerate(irreducibles):
if poly.has(*V):
log_coeffs.append(B[i])
log_part.append(log_coeffs[-1] * log(poly))
coeffs = poly_coeffs + log_coeffs
candidate = poly_part / poly_denom + Add(*log_part)
h = F - _derivation(candidate) / denom
numer = h.as_numer_denom()[0].expand(force=True)
equations = defaultdict(lambda: S.Zero)
for term in Add.make_args(numer):
coeff, dependent = term.as_independent(*V)
equations[dependent] += coeff
solution = solve(equations.values(), *coeffs)
return (solution, candidate, coeffs) if solution else None
if not (F.atoms(Symbol) - set(V)):
result = _integrate('Q')
if result is None:
result = _integrate()
else:
result = _integrate()
if result is not None:
(solution, candidate, coeffs) = result
antideriv = candidate.subs(solution)
for coeff in coeffs:
if coeff not in solution:
antideriv = antideriv.subs(coeff, S.Zero)
antideriv = antideriv.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)
if result is not None:
return indep * result
return None
def heurisch(f, x, **kwargs):
"""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".
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.
Specification
============
heurisch(f, x, rewrite=False, hints=None)
where
f : expression
x : symbol
rewrite -> force rewrite 'f' in terms of 'tan' and 'tanh'
hints -> a list of functions that may appear in anti-derivate
- hints = None --> no suggestions at all
- hints = [ ] --> try to figure out
- hints = [f1, ..., fn] --> we know better
Examples
========
>>> from sympy import tan
>>> from sympy.integrals.risch import heurisch
>>> from sympy.abc import x, y
>>> heurisch(y*tan(x), x)
y*log(1 + tan(x)**2)/2
See Manuel Bronstein's "Poor Man's Integrator":
[1] http://www-sop.inria.fr/cafe/Manuel.Bronstein/pmint/index.html
For more information on the implemented algorithm refer to:
[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.
"""
f = sympify(f)
if not f.is_Add:
indep, f = f.as_independent(x)
else:
indep = S.One
if not f.has(x):
return indep * f * x
rewritables = {
(sin, cos, cot) : tan,
(sinh, cosh, coth) : tanh,
}
rewrite = kwargs.pop('rewrite', False)
if rewrite:
for candidates, rule in rewritables.iteritems():
f = f.rewrite(candidates, rule)
else:
for candidates in rewritables.iterkeys():
if f.has(*candidates):
break
else:
rewrite = True
terms = components(f, x)
hints = kwargs.get('hints', None)
if hints is not None:
if not hints:
a = Wild('a', exclude=[x])
b = Wild('b', exclude=[x])
for g in set(terms):
if g.is_Function:
if g.func is exp:
M = g.args[0].match(a*x**2)
if M is not None:
terms.add(erf(sqrt(-M[a])*x))
M = g.args[0].match(a*log(x)**2)
if M is not None:
if M[a].is_positive:
terms.add(-I*erf(I*(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.is_Pow:
if 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):
terms |= components(cancel(g.diff(x)), x)
V = _symbols('x', len(terms))
mapping = dict(zip(terms, V))
rev_mapping = {}
for k, v in mapping.iteritems():
rev_mapping[v] = k
def substitute(expr):
return expr.subs(mapping)
diffs = [ substitute(cancel(g.diff(x))) for g in terms ]
denoms = [ g.as_numer_denom()[1] for g in diffs ]
try:
denom = reduce(lambda p, q: lcm(p, q, *V), denoms)
except PolynomialError:
# lcm can fail with this. See issue 1418.
return None
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 C.LambertW:
special[substitute(term)] = True
F = substitute(f)
P, Q = F.as_numer_denom()
u_split = splitter(denom)
v_split = splitter(Q)
polys = list(v_split) + [ u_split[0] ] + special.keys()
s = u_split[0] * Mul(*[ k for k, v in special.iteritems() if v ])
polified = [ p.as_poly(*V) for p in [s, P, Q] ]
if None in polified:
return
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:
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 = monomials(V, A + B - 1)
else:
monoms = monomials(V, A + B)
poly_coeffs = _symbols('A', len(monoms))
poly_part = Add(*[ poly_coeffs[i]*monomial
for i, monomial in enumerate(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.atoms(Symbol):
if z in V:
break
else:
continue
irreducibles |= set(root_factors(poly, z, filter=field))
log_coeffs, log_part = [], []
B = _symbols('B', len(irreducibles))
for i, poly in enumerate(irreducibles):
if poly.has(*V):
log_coeffs.append(B[i])
log_part.append(log_coeffs[-1] * log(poly))
coeffs = poly_coeffs + log_coeffs
candidate = poly_part/poly_denom + Add(*log_part)
h = F - derivation(candidate) / denom
numer = h.as_numer_denom()[0].expand()
equations = {}
for term in Add.make_args(numer):
coeff, dependent = term.as_independent(*V)
if dependent in equations:
equations[dependent] += coeff
else:
equations[dependent] = coeff
solution = solve(equations.values(), *coeffs)
if solution is not None:
return (solution, candidate, coeffs)
else:
return None
if not (F.atoms(Symbol) - set(V)):
result = integrate('Q')
if result is None:
result = integrate()
else:
result = integrate()
if result is not None:
(solution, candidate, coeffs) = result
antideriv = candidate.subs(solution)
for coeff in coeffs:
if coeff not in solution:
antideriv = antideriv.subs(coeff, S.Zero)
antideriv = antideriv.subs(rev_mapping)
antideriv = cancel(antideriv).expand()
if antideriv.is_Add:
antideriv = antideriv.as_independent(x)[1]
return indep * antideriv
else:
if not rewrite:
result = heurisch(f, x, rewrite=True, **kwargs)
if result is not None:
return indep * result
return None
def _expr_small(cls, a, z):
return sqrt(z) / sqrt(1 - z) * sin(2 * a * asin(sqrt(z)))
def test_jscode_functions():
assert jscode(sin(x)**cos(x)) == "Math.pow(Math.sin(x), Math.cos(x))"
assert jscode(sinh(x) * cosh(x)) == "Math.sinh(x)*Math.cosh(x)"
assert jscode(Max(x, y) + Min(x, y)) == "Math.max(x, y) + Math.min(x, y)"
assert jscode(tanh(x) * acosh(y)) == "Math.tanh(x)*Math.acosh(y)"
assert jscode(asin(x) - acos(y)) == "-Math.acos(y) + Math.asin(x)"
def test_C99CodePrinter__precision():
n = symbols("n", integer=True)
f32_printer = C99CodePrinter(dict(type_aliases={real: float32}))
f64_printer = C99CodePrinter(dict(type_aliases={real: float64}))
f80_printer = C99CodePrinter(dict(type_aliases={real: float80}))
assert f32_printer.doprint(sin(x + 2.1)) == "sinf(x + 2.1F)"
assert f64_printer.doprint(sin(x + 2.1)) == "sin(x + 2.1000000000000001)"
assert f80_printer.doprint(sin(x + Float("2.0"))) == "sinl(x + 2.0L)"
for printer, suffix in zip([f32_printer, f64_printer, f80_printer], ["f", "", "l"]):
def check(expr, ref):
assert printer.doprint(expr) == ref.format(s=suffix, S=suffix.upper())
check(Abs(n), "abs(n)")
check(Abs(x + 2.0), "fabs{s}(x + 2.0{S})")
check(
sin(x + 4.0) ** cos(x - 2.0),
"pow{s}(sin{s}(x + 4.0{S}), cos{s}(x - 2.0{S}))",
)
check(exp(x * 8.0), "exp{s}(8.0{S}*x)")
check(exp2(x), "exp2{s}(x)")
check(expm1(x * 4.0), "expm1{s}(4.0{S}*x)")
check(Mod(n, 2), "((n) % (2))")
check(Mod(2 * n + 3, 3 * n + 5), "((2*n + 3) % (3*n + 5))")
check(Mod(x + 2.0, 3.0), "fmod{s}(1.0{S}*x + 2.0{S}, 3.0{S})")
check(Mod(x, 2.0 * x + 3.0), "fmod{s}(1.0{S}*x, 2.0{S}*x + 3.0{S})")
check(log(x / 2), "log{s}((1.0{S}/2.0{S})*x)")
check(log10(3 * x / 2), "log10{s}((3.0{S}/2.0{S})*x)")
check(log2(x * 8.0), "log2{s}(8.0{S}*x)")
check(log1p(x), "log1p{s}(x)")
check(2 ** x, "pow{s}(2, x)")
check(2.0 ** x, "pow{s}(2.0{S}, x)")
check(x ** 3, "pow{s}(x, 3)")
check(x ** 4.0, "pow{s}(x, 4.0{S})")
check(sqrt(3 + x), "sqrt{s}(x + 3)")
check(Cbrt(x - 2.0), "cbrt{s}(x - 2.0{S})")
check(hypot(x, y), "hypot{s}(x, y)")
check(sin(3.0 * x + 2.0), "sin{s}(3.0{S}*x + 2.0{S})")
check(cos(3.0 * x - 1.0), "cos{s}(3.0{S}*x - 1.0{S})")
check(tan(4.0 * y + 2.0), "tan{s}(4.0{S}*y + 2.0{S})")
check(asin(3.0 * x + 2.0), "asin{s}(3.0{S}*x + 2.0{S})")
check(acos(3.0 * x + 2.0), "acos{s}(3.0{S}*x + 2.0{S})")
check(atan(3.0 * x + 2.0), "atan{s}(3.0{S}*x + 2.0{S})")
check(atan2(3.0 * x, 2.0 * y), "atan2{s}(3.0{S}*x, 2.0{S}*y)")
check(sinh(3.0 * x + 2.0), "sinh{s}(3.0{S}*x + 2.0{S})")
check(cosh(3.0 * x - 1.0), "cosh{s}(3.0{S}*x - 1.0{S})")
check(tanh(4.0 * y + 2.0), "tanh{s}(4.0{S}*y + 2.0{S})")
check(asinh(3.0 * x + 2.0), "asinh{s}(3.0{S}*x + 2.0{S})")
check(acosh(3.0 * x + 2.0), "acosh{s}(3.0{S}*x + 2.0{S})")
check(atanh(3.0 * x + 2.0), "atanh{s}(3.0{S}*x + 2.0{S})")
check(erf(42.0 * x), "erf{s}(42.0{S}*x)")
check(erfc(42.0 * x), "erfc{s}(42.0{S}*x)")
check(gamma(x), "tgamma{s}(x)")
check(loggamma(x), "lgamma{s}(x)")
check(ceiling(x + 2.0), "ceil{s}(x + 2.0{S})")
check(floor(x + 2.0), "floor{s}(x + 2.0{S})")
check(fma(x, y, -z), "fma{s}(x, y, -z)")
check(Max(x, 8.0, x ** 4.0), "fmax{s}(8.0{S}, fmax{s}(x, pow{s}(x, 4.0{S})))")
check(Min(x, 2.0), "fmin{s}(2.0{S}, x)")
def heurisch(f, x, **kwargs):
"""Compute indefinite integral using heuristic Risch algorithm.
This is a huristic approach to indefinite integration in finite
terms using extened heuristic (parallel) Risch algorithm, based
on Manuel Bronstein's "Poor Man's Integrator".
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 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.
Specificaion
============
heurisch(f, x, rewrite=False, hints=None)
where
f : expression
x : symbol
rewrite -> force rewrite 'f' in terms of 'tan' and 'tanh'
hints -> a list of functions that may appear in antiderivate
- hints = None --> no suggestions at all
- hints = [ ] --> try to figure out
- hints = [f1, ..., fn] --> we know better
Examples
========
>>> from sympy import *
>>> x,y = symbols('xy')
>>> heurisch(y*tan(x), x)
y*log(1 + tan(x)**2)/2
See Manuel Bronstein's "Poor Man's Integrator":
[1] http://www-sop.inria.fr/cafe/Manuel.Bronstein/pmint/index.html
For more information on the implemented algorithm refer to:
[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.
"""
f = sympify(f)
if not f.is_Add:
indep, f = f.as_independent(x)
else:
indep = S.One
if not f.has(x):
return indep * f * x
rewritables = {
(sin, cos, cot): tan,
(sinh, cosh, coth): tanh,
}
rewrite = kwargs.pop('rewrite', False)
if rewrite:
for candidates, rule in rewritables.iteritems():
f = f.rewrite(candidates, rule)
else:
for candidates in rewritables.iterkeys():
if f.has(*candidates):
break
else:
rewrite = True
terms = components(f, x)
hints = kwargs.get('hints', None)
if hints is not None:
if not hints:
a = Wild('a', exclude=[x])
b = Wild('b', exclude=[x])
for g in set(terms):
if g.is_Function:
if g.func is exp:
M = g.args[0].match(a * x**2)
if M is not None:
terms.add(erf(sqrt(-M[a]) * x))
elif g.is_Pow:
if 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))
else:
terms |= set(hints)
for g in set(terms):
terms |= components(g.diff(x), x)
V = _symbols('x', len(terms))
mapping = dict(zip(terms, V))
rev_mapping = {}
for k, v in mapping.iteritems():
rev_mapping[v] = k
def substitute(expr):
return expr.subs(mapping)
diffs = [substitute(simplify(g.diff(x))) for g in terms]
denoms = [g.as_numer_denom()[1] for g in diffs]
denom = reduce(lambda p, q: lcm(p, q, V), denoms)
numers = [Poly.cancel(denom * g, *V) 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_any_symbols(y):
continue
if derivation(p) is not S.Zero:
c, q = p.as_poly(y).as_primitive()
return deflation(c) * gcd(q, q.diff(y))
else:
return p
def splitter(p):
for y in V:
if not p.has_any_symbols(y):
continue
if derivation(y) is not S.Zero:
c, q = p.as_poly(y).as_primitive()
q = q.as_basic()
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(Poly.cancel((q, s), *V))
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 C.LambertW:
special[substitute(term)] = True
F = substitute(f)
P, Q = F.as_numer_denom()
u_split = splitter(denom)
v_split = splitter(Q)
polys = list(v_split) + [u_split[0]] + special.keys()
s = u_split[0] * Mul(*[k for k, v in special.iteritems() if v])
a, b, c = [p.as_poly(*V).degree for p in [s, P, Q]]
poly_denom = s * v_split[0] * deflation(v_split[1])
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:
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 = monomials(V, A + B - 1)
else:
monoms = monomials(V, A + B)
poly_coeffs = _symbols('A', len(monoms))
poly_part = Add(
*[poly_coeffs[i] * monomial for i, monomial in enumerate(monoms)])
reducibles = set()
for poly in polys:
if poly.has(*V):
try:
factorization = factor(poly, *V)
except PolynomialError:
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.atoms(Symbol):
if z in V:
break
else:
continue
irreducibles |= set(root_factors(poly, z, domain=field))
log_coeffs, log_part = [], []
B = _symbols('B', len(irreducibles))
for i, poly in enumerate(irreducibles):
if poly.has(*V):
log_coeffs.append(B[i])
log_part.append(log_coeffs[-1] * log(poly))
coeffs = poly_coeffs + log_coeffs
candidate = poly_part / poly_denom + Add(*log_part)
h = together(F - derivation(candidate) / denom)
numer = h.as_numer_denom()[0].expand()
if not numer.is_Add:
numer = [numer]
equations = {}
for term in numer.args:
coeff, dependent = term.as_independent(*V)
if dependent in equations:
equations[dependent] += coeff
else:
equations[dependent] = coeff
solution = solve(equations.values(), *coeffs)
if solution is not None:
return (solution, candidate, coeffs)
else:
return None
if not (F.atoms(Symbol) - set(V)):
result = integrate('Q')
if result is None:
result = integrate()
else:
result = integrate()
if result is not None:
(solution, candidate, coeffs) = result
antideriv = candidate.subs(solution)
for coeff in coeffs:
if coeff not in solution:
antideriv = antideriv.subs(coeff, S.Zero)
antideriv = antideriv.subs(rev_mapping)
antideriv = simplify(antideriv).expand()
if antideriv.is_Add:
antideriv = antideriv.as_independent(x)[1]
return indep * antideriv
else:
if not rewrite:
result = heurisch(f, x, rewrite=True, **kwargs)
if result is not None:
return indep * result
return None
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".
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.
Specification
=============
heurisch(f, x, rewrite=False, hints=None)
where
f : expression
x : symbol
rewrite -> force rewrite 'f' in terms of 'tan' and 'tanh'
hints -> a list of functions that may appear in anti-derivate
- hints = None --> no suggestions at all
- hints = [ ] --> try to figure out
- hints = [f1, ..., fn] --> we know better
Examples
========
>>> from sympy import tan
>>> from sympy.integrals.heurisch import heurisch
>>> from sympy.abc import x, y
>>> heurisch(y*tan(x), x)
y*log(tan(x)**2 + 1)/2
See Manuel Bronstein's "Poor Man's Integrator":
[1] http://www-sop.inria.fr/cafe/Manuel.Bronstein/pmint/index.html
For more information on the implemented algorithm refer to:
[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
========
sympy.integrals.integrals.Integral.doit
sympy.integrals.integrals.Integral
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):
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.func is exp:
M = g.args[0].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.args[0].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.args[0].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.is_Pow:
if 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):
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))
mapping = dict(list(zip(terms, V)))
rev_mapping = {}
if unnecessary_permutations is None:
unnecessary_permutations = []
for k, v in mapping.items():
rev_mapping[v] = k
if mappings is None:
# Pre-sort mapping in order of largest to smallest expressions (last is always x).
def _sort_key(arg):
return default_sort_key(arg[0].as_independent(x)[1])
#optimizing the number of permutations of mappping
unnecessary_permutations = [(x, mapping[x])]
del mapping[x]
mapping = sorted(list(mapping.items()), key=_sort_key, reverse=True)
mappings = permutations(mapping)
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 None
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 C.LambertW:
special[_substitute(term)] = True
F = _substitute(f)
P, Q = F.as_numer_denom()
u_split = _splitter(denom)
v_split = _splitter(Q)
polys = 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 None
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(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
else:
continue
irreducibles |= set(root_factors(poly, z, filter=field))
log_coeffs, log_part = [], []
B = _symbols('B', len(irreducibles))
for i, poly in enumerate(irreducibles):
if poly.has(*V):
log_coeffs.append(B[i])
log_part.append(log_coeffs[-1] * log(poly))
coeffs = poly_coeffs + log_coeffs
# 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(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 None
else:
ground, _ = construct_domain(non_syms, field=True)
coeff_ring = PolyRing(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 None
else:
# If the ring is RR k.as_expr() will be 1.0*A
solution = [(k.as_expr().as_coeff_Mul()[1], v.as_expr())
for k, v in solution.items()]
return candidate.subs(solution).subs(
list(zip(coeffs, [S.Zero] * len(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 None
def _invert_real(f, g_ys, symbol):
""" Helper function for invert_real """
if not f.has(symbol):
raise ValueError("Inverse of constant function doesn't exist")
if f is symbol:
return (f, g_ys)
n = Dummy('n')
if hasattr(f, 'inverse') and not isinstance(f, TrigonometricFunction) and \
not isinstance(f, HyperbolicFunction):
if len(f.args) > 1:
raise ValueError("Only functions with one argument are supported.")
return _invert_real(f.args[0],
imageset(Lambda(n, f.inverse()(n)), g_ys), symbol)
if isinstance(f, Abs):
return _invert_real(f.args[0],
Union(imageset(Lambda(n, n), g_ys).intersect(Interval(0, oo)),
imageset(Lambda(n, -n), g_ys).intersect(Interval(-oo, 0))),
symbol)
if f.is_Add:
# f = g + h
g, h = f.as_independent(symbol)
if g != S.Zero:
return _invert_real(h, imageset(Lambda(n, n - g), g_ys), symbol)
if f.is_Mul:
# f = g*h
g, h = f.as_independent(symbol)
if g != S.One:
return _invert_real(h, imageset(Lambda(n, n/g), g_ys), symbol)
if f.is_Pow:
base, expo = f.args
base_has_sym = base.has(symbol)
expo_has_sym = expo.has(symbol)
if not expo_has_sym:
res = imageset(Lambda(n, real_root(n, expo)), g_ys)
if expo.is_rational:
numer, denom = expo.as_numer_denom()
if numer == S.One or numer == - S.One:
return _invert_real(base, res, symbol)
else:
if numer % 2 == 0:
n = Dummy('n')
neg_res = imageset(Lambda(n, -n), res)
return _invert_real(base, res + neg_res, symbol)
else:
return _invert_real(base, res, symbol)
else:
if not base.is_positive:
raise ValueError("x**w where w is irrational is not "
"defined for negative x")
return _invert_real(base, res, symbol)
if not base_has_sym:
return _invert_real(expo, imageset(Lambda(n, log(n)/log(base)),
g_ys), symbol)
if isinstance(f, sin):
n = Dummy('n')
if isinstance(g_ys, FiniteSet):
sin_invs = Union(*[imageset(Lambda(n, n*pi + (-1)**n*asin(g_y)), \
S.Integers) for g_y in g_ys])
return _invert_real(f.args[0], sin_invs, symbol)
if isinstance(f, csc):
n = Dummy('n')
if isinstance(g_ys, FiniteSet):
csc_invs = Union(*[imageset(Lambda(n, n*pi + (-1)**n*acsc(g_y)), \
S.Integers) for g_y in g_ys])
return _invert_real(f.args[0], csc_invs, symbol)
if isinstance(f, cos):
n = Dummy('n')
if isinstance(g_ys, FiniteSet):
cos_invs_f1 = Union(*[imageset(Lambda(n, 2*n*pi + acos(g_y)), \
S.Integers) for g_y in g_ys])
cos_invs_f2 = Union(*[imageset(Lambda(n, 2*n*pi - acos(g_y)), \
S.Integers) for g_y in g_ys])
cos_invs = Union(cos_invs_f1, cos_invs_f2)
return _invert_real(f.args[0], cos_invs, symbol)
if isinstance(f, sec):
n = Dummy('n')
if isinstance(g_ys, FiniteSet):
sec_invs_f1 = Union(*[imageset(Lambda(n, 2*n*pi + asec(g_y)), \
S.Integers) for g_y in g_ys])
sec_invs_f2 = Union(*[imageset(Lambda(n, 2*n*pi - asec(g_y)), \
S.Integers) for g_y in g_ys])
sec_invs = Union(sec_invs_f1, sec_invs_f2)
return _invert_real(f.args[0], sec_invs, symbol)
if isinstance(f, tan) or isinstance(f, cot):
n = Dummy('n')
if isinstance(g_ys, FiniteSet):
tan_cot_invs = Union(*[imageset(Lambda(n, n*pi + f.inverse()(g_y)), \
S.Integers) for g_y in g_ys])
return _invert_real(f.args[0], tan_cot_invs, symbol)
return (f, g_ys)
def _expr_small(cls, a, z):
return cos(2 * a * asin(sqrt(z)))
def test_tensorflow_math():
if not tf:
skip("TensorFlow not installed")
expr = Abs(x)
assert tensorflow_code(expr) == "tensorflow.math.abs(x)"
_compare_tensorflow_scalar((x, ), expr)
expr = sign(x)
assert tensorflow_code(expr) == "tensorflow.math.sign(x)"
_compare_tensorflow_scalar((x, ), expr)
expr = ceiling(x)
assert tensorflow_code(expr) == "tensorflow.math.ceil(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = floor(x)
assert tensorflow_code(expr) == "tensorflow.math.floor(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = exp(x)
assert tensorflow_code(expr) == "tensorflow.math.exp(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = sqrt(x)
assert tensorflow_code(expr) == "tensorflow.math.sqrt(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = x**4
assert tensorflow_code(expr) == "tensorflow.math.pow(x, 4)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = cos(x)
assert tensorflow_code(expr) == "tensorflow.math.cos(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = acos(x)
assert tensorflow_code(expr) == "tensorflow.math.acos(x)"
_compare_tensorflow_scalar((x, ),
expr,
rng=lambda: random.uniform(0, 0.95))
expr = sin(x)
assert tensorflow_code(expr) == "tensorflow.math.sin(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = asin(x)
assert tensorflow_code(expr) == "tensorflow.math.asin(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = tan(x)
assert tensorflow_code(expr) == "tensorflow.math.tan(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = atan(x)
assert tensorflow_code(expr) == "tensorflow.math.atan(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = atan2(y, x)
assert tensorflow_code(expr) == "tensorflow.math.atan2(y, x)"
_compare_tensorflow_scalar((y, x), expr, rng=lambda: random.random())
expr = cosh(x)
assert tensorflow_code(expr) == "tensorflow.math.cosh(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = acosh(x)
assert tensorflow_code(expr) == "tensorflow.math.acosh(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = sinh(x)
assert tensorflow_code(expr) == "tensorflow.math.sinh(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = asinh(x)
assert tensorflow_code(expr) == "tensorflow.math.asinh(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = tanh(x)
assert tensorflow_code(expr) == "tensorflow.math.tanh(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = atanh(x)
assert tensorflow_code(expr) == "tensorflow.math.atanh(x)"
_compare_tensorflow_scalar((x, ),
expr,
rng=lambda: random.uniform(-.5, .5))
expr = erf(x)
assert tensorflow_code(expr) == "tensorflow.math.erf(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = loggamma(x)
assert tensorflow_code(expr) == "tensorflow.math.lgamma(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
def _expr_small(cls, z):
return asin(sqrt(z)) / sqrt(z)
def _invert_real(f, g_ys, symbol):
""" Helper function for invert_real """
if not f.has(symbol):
raise ValueError("Inverse of constant function doesn't exist")
if f is symbol:
return (f, g_ys)
n = Dummy('n')
if hasattr(f, 'inverse') and not isinstance(f, TrigonometricFunction) and \
not isinstance(f, HyperbolicFunction):
if len(f.args) > 1:
raise ValueError("Only functions with one argument are supported.")
return _invert_real(f.args[0], imageset(Lambda(n,
f.inverse()(n)), g_ys),
symbol)
if isinstance(f, Abs):
return _invert_real(
f.args[0],
Union(
imageset(Lambda(n, n), g_ys).intersect(Interval(0, oo)),
imageset(Lambda(n, -n), g_ys).intersect(Interval(-oo, 0))),
symbol)
if f.is_Add:
# f = g + h
g, h = f.as_independent(symbol)
if g != S.Zero:
return _invert_real(h, imageset(Lambda(n, n - g), g_ys), symbol)
if f.is_Mul:
# f = g*h
g, h = f.as_independent(symbol)
if g != S.One:
return _invert_real(h, imageset(Lambda(n, n / g), g_ys), symbol)
if f.is_Pow:
base, expo = f.args
base_has_sym = base.has(symbol)
expo_has_sym = expo.has(symbol)
if not expo_has_sym:
res = imageset(Lambda(n, real_root(n, expo)), g_ys)
if expo.is_rational:
numer, denom = expo.as_numer_denom()
if numer == S.One or numer == -S.One:
return _invert_real(base, res, symbol)
else:
if numer % 2 == 0:
n = Dummy('n')
neg_res = imageset(Lambda(n, -n), res)
return _invert_real(base, res + neg_res, symbol)
else:
return _invert_real(base, res, symbol)
else:
if not base.is_positive:
raise ValueError("x**w where w is irrational is not "
"defined for negative x")
return _invert_real(base, res, symbol)
if not base_has_sym:
return _invert_real(expo,
imageset(Lambda(n,
log(n) / log(base)), g_ys),
symbol)
if isinstance(f, sin):
n = Dummy('n')
if isinstance(g_ys, FiniteSet):
sin_invs = Union(*[imageset(Lambda(n, n*pi + (-1)**n*asin(g_y)), \
S.Integers) for g_y in g_ys])
return _invert_real(f.args[0], sin_invs, symbol)
if isinstance(f, csc):
n = Dummy('n')
if isinstance(g_ys, FiniteSet):
csc_invs = Union(*[imageset(Lambda(n, n*pi + (-1)**n*acsc(g_y)), \
S.Integers) for g_y in g_ys])
return _invert_real(f.args[0], csc_invs, symbol)
if isinstance(f, cos):
n = Dummy('n')
if isinstance(g_ys, FiniteSet):
cos_invs_f1 = Union(*[imageset(Lambda(n, 2*n*pi + acos(g_y)), \
S.Integers) for g_y in g_ys])
cos_invs_f2 = Union(*[imageset(Lambda(n, 2*n*pi - acos(g_y)), \
S.Integers) for g_y in g_ys])
cos_invs = Union(cos_invs_f1, cos_invs_f2)
return _invert_real(f.args[0], cos_invs, symbol)
if isinstance(f, sec):
n = Dummy('n')
if isinstance(g_ys, FiniteSet):
sec_invs_f1 = Union(*[imageset(Lambda(n, 2*n*pi + asec(g_y)), \
S.Integers) for g_y in g_ys])
sec_invs_f2 = Union(*[imageset(Lambda(n, 2*n*pi - asec(g_y)), \
S.Integers) for g_y in g_ys])
sec_invs = Union(sec_invs_f1, sec_invs_f2)
return _invert_real(f.args[0], sec_invs, symbol)
if isinstance(f, tan) or isinstance(f, cot):
n = Dummy('n')
if isinstance(g_ys, FiniteSet):
tan_cot_invs = Union(*[imageset(Lambda(n, n*pi + f.inverse()(g_y)), \
S.Integers) for g_y in g_ys])
return _invert_real(f.args[0], tan_cot_invs, symbol)
return (f, g_ys)
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".
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.
Specification
=============
heurisch(f, x, rewrite=False, hints=None)
where
f : expression
x : symbol
rewrite -> force rewrite 'f' in terms of 'tan' and 'tanh'
hints -> a list of functions that may appear in anti-derivate
- hints = None --> no suggestions at all
- hints = [ ] --> try to figure out
- hints = [f1, ..., fn] --> we know better
Examples
========
>>> from sympy import tan
>>> from sympy.integrals.heurisch import heurisch
>>> from sympy.abc import x, y
>>> heurisch(y*tan(x), x)
y*log(tan(x)**2 + 1)/2
See Manuel Bronstein's "Poor Man's Integrator":
[1] http://www-sop.inria.fr/cafe/Manuel.Bronstein/pmint/index.html
For more information on the implemented algorithm refer to:
[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
========
sympy.integrals.integrals.Integral.doit
sympy.integrals.integrals.Integral
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):
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.func is exp:
M = g.args[0].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.args[0].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.args[0].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.is_Pow:
if 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):
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))
mapping = dict(list(zip(terms, V)))
rev_mapping = {}
if unnecessary_permutations is None:
unnecessary_permutations = []
for k, v in mapping.items():
rev_mapping[v] = k
if mappings is None:
# Pre-sort mapping in order of largest to smallest expressions (last is always x).
def _sort_key(arg):
return default_sort_key(arg[0].as_independent(x)[1])
#optimizing the number of permutations of mappping
unnecessary_permutations = [(x, mapping[x])]
del mapping[x]
mapping = sorted(list(mapping.items()), key=_sort_key, reverse=True)
mappings = permutations(mapping)
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 None
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 C.LambertW:
special[_substitute(term)] = True
F = _substitute(f)
P, Q = F.as_numer_denom()
u_split = _splitter(denom)
v_split = _splitter(Q)
polys = 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 None
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(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.atoms(Symbol):
if z in V:
break
else:
continue
irreducibles |= set(root_factors(poly, z, filter=field))
log_coeffs, log_part = [], []
B = _symbols('B', len(irreducibles))
for i, poly in enumerate(irreducibles):
if poly.has(*V):
log_coeffs.append(B[i])
log_part.append(log_coeffs[-1] * log(poly))
coeffs = poly_coeffs + log_coeffs
# 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(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 None
else:
ground, _ = construct_domain(non_syms, field=True)
coeff_ring = PolyRing(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 None
else:
solution = [ (k.as_expr(), v.as_expr()) for k, v in solution.items() ]
return candidate.subs(solution).subs(list(zip(coeffs, [S.Zero]*len(coeffs))))
if not (F.atoms(Symbol) - 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 None
def _expr_small(cls, a, z):
return cos(2*a*asin(sqrt(z)))
def heurisch(f, x, rewrite=False, hints=None, mappings=None, retries=3,
degree_offset=0, unnecessary_permutations=None,
_try_heurisch=None):
"""
Compute indefinite integral using heuristic Risch algorithm.
Explanation
===========
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".
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 top level
'integrate' function in most cases, as this procedure needs some
preprocessing steps and otherwise may fail.
Specification
=============
heurisch(f, x, rewrite=False, hints=None)
where
f : expression
x : symbol
rewrite -> force rewrite 'f' in terms of 'tan' and 'tanh'
hints -> a list of functions that may appear in anti-derivate
- hints = None --> no suggestions at all
- hints = [ ] --> try to figure out
- hints = [f1, ..., fn] --> we know better
Examples
========
>>> from sympy import tan
>>> from sympy.integrals.heurisch import heurisch
>>> from sympy.abc import x, y
>>> heurisch(y*tan(x), x)
y*log(tan(x)**2 + 1)/2
See Manuel Bronstein's "Poor Man's Integrator":
References
==========
.. [1] http://www-sop.inria.fr/cafe/Manuel.Bronstein/pmint/index.html
For more information on the implemented algorithm refer to:
.. [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
========
sympy.integrals.integrals.Integral.doit
sympy.integrals.integrals.Integral
sympy.integrals.heurisch.components
"""
f = sympify(f)
# There are some functions that Heurisch cannot currently handle,
# so do not even try.
# Set _try_heurisch=True to skip this check
if _try_heurisch is not True:
if f.has(Abs, re, im, sign, Heaviside, DiracDelta, floor, ceiling, arg):
return
if not f.has_free(x):
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 isinstance(g, 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 isinstance(g, exp):
M = g.args[0].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.args[0].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.args[0].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.is_Pow:
if 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)
dcache = DiffCache(x)
for g in set(terms): # using copy of terms
terms |= components(dcache.get_diff(g), 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(dcache.get_diff(g)) 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 None
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()
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])
return (S.One, p)
special = {}
for term in terms:
if term.is_Function:
if isinstance(term, tan):
special[1 + _substitute(term)**2] = False
elif isinstance(term, tanh):
special[1 + _substitute(term)] = False
special[1 - _substitute(term)] = False
elif isinstance(term, 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 None
#--- 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 = tuple(ordered(itermonomials(V, A + B - 1 + degree_offset)))
else:
monoms = tuple(ordered(itermonomials(V, A + B + degree_offset)))
poly_coeffs = _symbols('A', len(monoms))
poly_part = Add(*[ poly_coeffs[i]*monomial
for i, monomial in enumerate(monoms) ])
reducibles = set()
for poly in ordered(polys):
coeff, factors = factor_list(poly, *V)
reducibles.add(coeff)
for fact, mul in factors:
reducibles.add(fact)
def _integrate(field=None):
atans = set()
pairs = set()
if field == 'Q':
irreducibles = set(reducibles)
else:
setV = set(V)
irreducibles = set()
for poly in ordered(reducibles):
zV = setV & set(iterfreeargs(poly))
for z in ordered(zV):
s = set(root_factors(poly, z, filter=field))
irreducibles |= s
break
log_part, atan_part = [], []
for poly in ordered(irreducibles):
m = collect(poly, I, evaluate=False)
y = m.get(I, S.Zero)
if y:
x = m.get(S.One, S.Zero)
if x.has(I) or y.has(I):
continue # nontrivial x + I*y
pairs.add((x, y))
irreducibles.remove(poly)
while pairs:
x, y = pairs.pop()
if (x, -y) in pairs:
pairs.remove((x, -y))
# Choosing b with no minus sign
if y.could_extract_minus_sign():
y = -y
irreducibles.add(x*x + y*y)
atans.add(atan(x/y))
else:
irreducibles.add(x + I*y)
B = _symbols('B', len(irreducibles))
C = _symbols('C', len(atans))
# Note: the ordering matters here
for poly, b in reversed(list(zip(ordered(irreducibles), B))):
if poly.has(*V):
poly_coeffs.append(b)
log_part.append(b * log(poly))
for poly, c in reversed(list(zip(ordered(atans), C))):
if poly.has(*V):
poly_coeffs.append(c)
atan_part.append(c * 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 cancellation is slow
# due to slow polynomial GCD algorithms. If this gets improved then
# revise this code.
candidate = poly_part/poly_denom + Add(*log_part) + Add(*atan_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_free(*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 None
else:
ground, _ = construct_domain(non_syms, field=True)
coeff_ring = PolyRing(poly_coeffs, ground)
ring = PolyRing(V, coeff_ring)
try:
numer = ring.from_expr(raw_numer)
except ValueError:
raise PolynomialError
solution = solve_lin_sys(numer.coeffs(), coeff_ring, _raw=False)
if solution is None:
return None
else:
return candidate.xreplace(solution).xreplace(
dict(zip(poly_coeffs, [S.Zero]*len(poly_coeffs))))
if all(isinstance(_, Symbol) for _ in V):
more_free = F.free_symbols - set(V)
else:
Fd = F.as_dummy()
more_free = Fd.xreplace(dict(zip(V, (Dummy() for _ in V)))
).free_symbols & Fd.free_symbols
if not more_free:
# all free generators are identified in 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()
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 None
def test_torch_math():
if not torch:
skip("Torch not installed")
ma = torch.tensor([[1, 2, -3, -4]])
expr = Abs(x)
assert torch_code(expr) == "torch.abs(x)"
f = lambdify(x, expr, 'torch')
y = f(ma)
c = torch.abs(ma)
assert (y == c).all()
expr = sign(x)
assert torch_code(expr) == "torch.sign(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.randint(0, 10))
expr = ceiling(x)
assert torch_code(expr) == "torch.ceil(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = floor(x)
assert torch_code(expr) == "torch.floor(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = exp(x)
assert torch_code(expr) == "torch.exp(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
# expr = sqrt(x)
# assert torch_code(expr) == "torch.sqrt(x)"
# _compare_torch_scalar((x,), expr, rng=lambda: random.random())
# expr = x ** 4
# assert torch_code(expr) == "torch.pow(x, 4)"
# _compare_torch_scalar((x,), expr, rng=lambda: random.random())
expr = cos(x)
assert torch_code(expr) == "torch.cos(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = acos(x)
assert torch_code(expr) == "torch.acos(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(0, 0.95))
expr = sin(x)
assert torch_code(expr) == "torch.sin(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = asin(x)
assert torch_code(expr) == "torch.asin(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = tan(x)
assert torch_code(expr) == "torch.tan(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = atan(x)
assert torch_code(expr) == "torch.atan(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
# expr = atan2(y, x)
# assert torch_code(expr) == "torch.atan2(y, x)"
# _compare_torch_scalar((y, x), expr, rng=lambda: random.random())
expr = cosh(x)
assert torch_code(expr) == "torch.cosh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = acosh(x)
assert torch_code(expr) == "torch.acosh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = sinh(x)
assert torch_code(expr) == "torch.sinh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = asinh(x)
assert torch_code(expr) == "torch.asinh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = tanh(x)
assert torch_code(expr) == "torch.tanh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = atanh(x)
assert torch_code(expr) == "torch.atanh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(-.5, .5))
expr = erf(x)
assert torch_code(expr) == "torch.erf(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = loggamma(x)
assert torch_code(expr) == "torch.lgamma(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
