def test_nfloat():
from sympy.core.basic import _aresame
from sympy.polys.rootoftools import rootof
x = Symbol("x")
eq = x**(S(4) / 3) + 4 * x**(S(1) / 3) / 3
assert _aresame(nfloat(eq), x**(S(4) / 3) + (4.0 / 3) * x**(S(1) / 3))
assert _aresame(nfloat(eq, exponent=True),
x**(4.0 / 3) + (4.0 / 3) * x**(1.0 / 3))
eq = x**(S(4) / 3) + 4 * x**(x / 3) / 3
assert _aresame(nfloat(eq), x**(S(4) / 3) + (4.0 / 3) * x**(x / 3))
big = 12345678901234567890
# specify precision to match value used in nfloat
Float_big = Float(big, 15)
assert _aresame(nfloat(big), Float_big)
assert _aresame(nfloat(big * x), Float_big * x)
assert _aresame(nfloat(x**big, exponent=True), x**Float_big)
assert nfloat(cos(x + sqrt(2))) == cos(x + nfloat(sqrt(2)))
# issue 6342
f = S('x*lamda + lamda**3*(x/2 + 1/2) + lamda**2 + 1/4')
assert not any(a.free_symbols for a in solveset(f.subs(x, -0.139)))
# issue 6632
assert nfloat(-100000*sqrt(2500000001) + 5000000001) == \
9.99999999800000e-11
# issue 7122
eq = cos(3 * x**4 + y) * rootof(x**5 + 3 * x**3 + 1, 0)
assert str(nfloat(eq, exponent=False, n=1)) == '-0.7*cos(3.0*x**4 + y)'
# issue 10933
for t in (dict, Dict):
d = t({S.Half: S.Half})
n = nfloat(d)
assert isinstance(n, t)
assert _aresame(list(n.items()).pop(), (S.Half, Float(.5)))
for t in (dict, Dict):
d = t({S.Half: S.Half})
n = nfloat(d, dkeys=True)
assert isinstance(n, t)
assert _aresame(list(n.items()).pop(), (Float(.5), Float(.5)))
d = [S.Half]
n = nfloat(d)
assert type(n) is list
assert _aresame(n[0], Float(.5))
assert _aresame(nfloat(Eq(x, S.Half)).rhs, Float(.5))
assert _aresame(nfloat(S(True)), S(True))
assert _aresame(nfloat(Tuple(S.Half))[0], Float(.5))
assert nfloat(Eq((3 - I)**2 / 2 + I, 0)) == S.false
# pass along kwargs
assert nfloat([{S.Half: x}], dkeys=True) == [{Float(0.5): x}]
def test_inflate():
subs = {a: randcplx()/10, b: randcplx()/10 + I, c: randcplx(),
d: randcplx(), y:randcplx()/10}
def t(a, b, arg, n):
from sympy import Mul
m1 = meijerg(a, b, arg)
m2 = Mul(*_inflate_g(m1, n))
# NOTE: (the random number)**9 must still be on the principal sheet.
# Thus make b&d small to create random numbers of small imaginary part.
return test_numerically(m1.subs(subs), m2.subs(subs), x, b=0.1, d=-0.1)
assert t([[a], [b]], [[c], [d]], x, 3)
assert t([[a, y], [b]], [[c], [d]], x, 3)
assert t([[a], [b]], [[c, y], [d]], 2*x**3, 3)
def test_inflate():
subs = {a: randcplx()/10, b: randcplx()/10 + I, c: randcplx(),
d: randcplx(), y:randcplx()/10}
def t(a, b, arg, n):
from sympy import Mul
m1 = meijerg(a, b, arg)
m2 = Mul(*_inflate_g(m1, n))
# NOTE: (the random number)**9 must still be on the principal sheet.
# Thus make b&d small to create random numbers of small imaginary part.
return test_numerically(m1.subs(subs), m2.subs(subs), x, b=0.1, d=-0.1)
assert t([[a], [b]], [[c], [d]], x, 3)
assert t([[a, y], [b]], [[c], [d]], x, 3)
assert t([[a], [b]], [[c, y], [d]], 2*x**3, 3)
def test_rewrite_single():
def t(expr, c, m):
e = _rewrite_single(meijerg([a], [b], [c], [d], expr), x)
assert e is not None
assert isinstance(e[0][0][2], meijerg)
assert e[0][0][2].argument.as_coeff_mul(x) == (c, (m,))
def tn(expr):
assert _rewrite_single(meijerg([a], [b], [c], [d], expr), x) is None
t(x, 1, x)
t(x ** 2, 1, x ** 2)
t(x ** 2 + y * x ** 2, y + 1, x ** 2)
tn(x ** 2 + x)
tn(x ** y)
def u(expr, x):
from sympy import Add, exp, exp_polar
r = _rewrite_single(expr, x)
e = Add(*[res[0] * res[2] for res in r[0]]).replace(exp_polar, exp) # XXX Hack?
assert test_numerically(e, expr, x)
u(exp(-x) * sin(x), x)
u(exp(-x) * sin(x) * cos(x), x)
u(exp(x) * sin(x), x)
def test_rewrite_single():
def t(expr, c, m):
e = _rewrite_single(meijerg([a], [b], [c], [d], expr), x)
assert e is not None
assert isinstance(e[0][0][2], meijerg)
assert e[0][0][2].argument.as_coeff_mul(x) == (c, (m, ))
def tn(expr):
assert _rewrite_single(meijerg([a], [b], [c], [d], expr), x) is None
t(x, 1, x)
t(x**2, 1, x**2)
t(x**2 + y * x**2, y + 1, x**2)
tn(x**2 + x)
tn(x**y)
def u(expr, x):
from sympy import Add, exp, exp_polar
r = _rewrite_single(expr, x)
e = Add(*[res[0] * res[2] for res in r[0]]).replace(exp_polar,
exp) # XXX Hack?
assert test_numerically(e, expr, x)
u(exp(-x) * sin(x), x)
u(exp(-x) * sin(x) * cos(x), x)
u(exp(x) * sin(x), x)
def test_rewrite_single():
def t(expr, c, m):
e = _rewrite_single(meijerg([a], [b], [c], [d], expr), x)
assert e is not None
assert isinstance(e[0][0][2], meijerg)
assert e[0][0][2].argument.as_coeff_mul(x) == (c, (m,))
def tn(expr):
assert _rewrite_single(meijerg([a], [b], [c], [d], expr), x) is None
t(x, 1, x)
t(x ** 2, 1, x ** 2)
t(x ** 2 + y * x ** 2, y + 1, x ** 2)
tn(x ** 2 + x)
tn(x ** y)
def u(expr, x):
from sympy import Add, exp, exp_polar
r = _rewrite_single(expr, x)
e = Add(*[res[0] * res[2] for res in r[0]]).replace(exp_polar, exp) # XXX Hack?
assert verify_numerically(e, expr, x)
u(exp(-x) * sin(x), x)
# The following has stopped working because hyperexpand changed slightly.
# It is probably not worth fixing
# u(exp(-x)*sin(x)*cos(x), x)
# This one cannot be done numerically, since it comes out as a g-function
# of argument 4*pi
# NOTE This also tests a bug in inverse mellin transform (which used to
# turn exp(4*pi*I*t) into a factor of exp(4*pi*I)**t instead of
# exp_polar).
# u(exp(x)*sin(x), x)
assert _rewrite_single(exp(x) * sin(x), x) == (
[
(
-sqrt(2) / (2 * sqrt(pi)),
0,
meijerg(
(
(Rational(-1, 2), 0, Rational(1, 4), S.Half, Rational(3, 4)),
(1,),
),
((), (Rational(-1, 2), 0)),
64 * exp_polar(-4 * I * pi) / x ** 4,
),
)
],
True,
)
def test_rewrite_single():
def t(expr, c, m):
e = _rewrite_single(meijerg([a], [b], [c], [d], expr), x)
assert e is not None
assert isinstance(e[0][0][2], meijerg)
assert e[0][0][2].argument.as_coeff_mul(x) == (c, (m,))
def tn(expr):
assert _rewrite_single(meijerg([a], [b], [c], [d], expr), x) is None
t(x, 1, x)
t(x ** 2, 1, x ** 2)
t(x ** 2 + y * x ** 2, y + 1, x ** 2)
tn(x ** 2 + x)
tn(x ** y)
def u(expr, x):
from sympy import Add, exp, exp_polar
r = _rewrite_single(expr, x)
e = Add(*[res[0] * res[2] for res in r[0]]).replace(exp_polar, exp) # XXX Hack?
assert verify_numerically(e, expr, x)
u(exp(-x) * sin(x), x)
# The following has stopped working because hyperexpand changed slightly.
# It is probably not worth fixing
# u(exp(-x)*sin(x)*cos(x), x)
# This one cannot be done numerically, since it comes out as a g-function
# of argument 4*pi
# NOTE This also tests a bug in inverse mellin transform (which used to
# turn exp(4*pi*I*t) into a factor of exp(4*pi*I)**t instead of
# exp_polar).
# u(exp(x)*sin(x), x)
assert _rewrite_single(exp(x) * sin(x), x) == (
[
(
-sqrt(2) / (2 * sqrt(pi)),
0,
meijerg(
((-S(1) / 2, 0, S(1) / 4, S(1) / 2, S(3) / 4), (1,)),
((), (-S(1) / 2, 0)),
64 * exp_polar(-4 * I * pi) / x ** 4,
),
)
],
True,
)
def test_meijerint_indefinite_numerically():
def t(fac, arg):
g = meijerg([a], [b], [c], [d], arg) * fac
subs = {
a: randcplx() / 10,
b: randcplx() / 10 + I,
c: randcplx(),
d: randcplx()
}
integral = meijerint_indefinite(g, x)
assert integral is not None
assert verify_numerically(g.subs(subs), integral.diff(x).subs(subs), x)
t(1, x)
t(2, x)
t(1, 2 * x)
t(1, x**2)
t(5, x**S('3/2'))
t(x**3, x)
t(3 * x**S('3/2'), 4 * x**S('7/3'))
def test_meijerint_indefinite_numerically():
def t(fac, arg):
g = meijerg([a], [b], [c], [d], arg) * fac
subs = {a: randcplx() / 10, b: randcplx() / 10 + I, c: randcplx(), d: randcplx()}
integral = meijerint_indefinite(g, x)
assert integral is not None
assert verify_numerically(g.subs(subs), integral.diff(x).subs(subs), x)
t(1, x)
t(2, x)
t(1, 2 * x)
t(1, x ** 2)
t(5, x ** S("3/2"))
t(x ** 3, x)
t(3 * x ** S("3/2"), 4 * x ** S("7/3"))
