def test_sympyissue_8245():
a = Rational(6506833320952669167898688709329, 5070602400912917605986812821504)
q = a.evalf(10)
assert (a == q) is True
assert (a != q) is False
assert (a > q) is false
assert (a < q) is false
assert (a >= q) is true
assert (a <= q) is true
a = sqrt(2)
r = Rational(str(a.evalf(30)))
assert (r == a) is False
assert (r != a) is True
assert (r > a) is true
assert (r < a) is false
assert (r >= a) is true
assert (r <= a) is false
a = sqrt(2)
r = Rational(str(a.evalf(29)))
assert (r == a) is False
assert (r != a) is True
assert (r > a) is false
assert (r < a) is true
assert (r >= a) is false
assert (r <= a) is true
def test_roots_binomial():
assert roots_binomial(Poly(5*x, x)) == [0]
assert roots_binomial(Poly(5*x**4, x)) == [0, 0, 0, 0]
assert roots_binomial(Poly(5*x + 2, x)) == [-Rational(2, 5)]
A = 10**Rational(3, 4)/10
assert roots_binomial(Poly(5*x**4 + 2, x)) == \
[-A - A*I, -A + A*I, A - A*I, A + A*I]
a1 = Symbol('a1', nonnegative=True)
b1 = Symbol('b1', nonnegative=True)
r0 = roots_quadratic(Poly(a1*x**2 + b1, x))
r1 = roots_binomial(Poly(a1*x**2 + b1, x))
assert powsimp(r0[0]) == powsimp(r1[0])
assert powsimp(r0[1]) == powsimp(r1[1])
for a, b, s, n in itertools.product((1, 2), (1, 2), (-1, 1), (2, 3, 4, 5)):
if a == b and a != 1: # a == b == 1 is sufficient
continue
p = Poly(a*x**n + s*b)
ans = roots_binomial(p)
assert ans == _nsort(ans)
# issue sympy/sympy#8813
assert roots(Poly(2*x**3 - 16*y**3, x)) == {
2*y*(-Rational(1, 2) - sqrt(3)*I/2): 1,
2*y: 1,
2*y*(-Rational(1, 2) + sqrt(3)*I/2): 1}
def test_cse_single():
# Simple substitution.
e = Add(Pow(x + y, 2), sqrt(x + y))
substs, reduced = cse([e])
assert substs == [(x0, x + y)]
assert reduced == [sqrt(x0) + x0**2]
assert cse([e], order='none') == cse([e])
def test_Pow_is_algebraic():
e = Symbol('e', algebraic=True)
assert Pow(1, e, evaluate=False).is_algebraic
assert Pow(0, e, evaluate=False).is_algebraic
a = Symbol('a', algebraic=True)
na = Symbol('na', algebraic=False)
ia = Symbol('ia', algebraic=True, irrational=True)
ib = Symbol('ib', algebraic=True, irrational=True)
r = Symbol('r', rational=True, nonzero=True)
x = Symbol('x')
assert (a**r).is_algebraic
assert (a**x).is_algebraic is None
assert (na**r).is_algebraic is False
assert (ia**r).is_algebraic
assert (ia**ib).is_algebraic is False
assert (a**e).is_algebraic is None
# Gelfond-Schneider constant:
assert Pow(2, sqrt(2), evaluate=False).is_algebraic is False
assert Pow(GoldenRatio, sqrt(3), evaluate=False).is_algebraic is False
# sympy/sympy#8649
t = Symbol('t', real=True, transcendental=True)
n = Symbol('n', integer=True)
assert (t**n).is_algebraic is None
assert (t**n).is_integer is None
def test_unrad0():
s = symbols('s', cls=Dummy)
# checkers to deal with possibility of answer coming
# back with a sign change (cf issue sympy/sympy#5203)
def check(rv, ans):
assert bool(rv[1]) == bool(ans[1])
if ans[1]:
return s_check(rv, ans)
e = rv[0].expand()
a = ans[0].expand()
return e in [a, -a] and rv[1] == ans[1]
def s_check(rv, ans):
# get the dummy
rv = list(rv)
d = rv[0].atoms(Dummy)
reps = list(zip(d, [s]*len(d)))
# replace s with this dummy
rv = (rv[0].subs(reps).expand(), [rv[1][0].subs(reps), rv[1][1].subs(reps)])
ans = (ans[0].subs(reps).expand(), [ans[1][0].subs(reps), ans[1][1].subs(reps)])
return str(rv[0]) in [str(ans[0]), str(-ans[0])] and \
str(rv[1]) == str(ans[1])
assert check(unrad(sqrt(x) - root(x + 1, 3)*sqrt(x + 2) + 2),
(s**10 + 8*s**8 + 24*s**6 - 12*s**5 - 22*s**4 - 160*s**3 - 212*s**2 -
192*s - 56, [s, s**2 - x]))
def test_residue_reduce():
a = Poly(2*t**2 - t - x**2, t)
d = Poly(t**3 - x**2*t, t)
DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t)], 'Tfuncs': [log]})
assert residue_reduce(a, d, DE, z, invert=False) == \
([(Poly(z**2 - Rational(1, 4), z), Poly((1 + 3*x*z - 6*z**2 -
2*x**2 + 4*x**2*z**2)*t - x*z + x**2 + 2*x**2*z**2 - 2*z*x**3, t))], False)
assert residue_reduce(a, d, DE, z, invert=True) == \
([(Poly(z**2 - Rational(1, 4), z), Poly(t + 2*x*z, t))], False)
assert residue_reduce(Poly(-2/x, t), Poly(t**2 - 1, t,), DE, z, invert=False) == \
([(Poly(z**2 - 1, z), Poly(-2*z*t/x - 2/x, t))], True)
ans = residue_reduce(Poly(-2/x, t), Poly(t**2 - 1, t), DE, z, invert=True)
assert ans == ([(Poly(z**2 - 1, z), Poly(t + z, t))], True)
assert residue_reduce_to_basic(ans[0], DE, z) == -log(-1 + log(x)) + log(1 + log(x))
DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(-t**2 - t/x - (1 - nu**2/x**2), t)]})
# TODO: Skip or make faster
assert residue_reduce(Poly((-2*nu**2 - x**4)/(2*x**2)*t - (1 + x**2)/x, t),
Poly(t**2 + 1 + x**2/2, t), DE, z) == \
([(Poly(z + Rational(1, 2), z, domain='QQ'), Poly(t**2 + 1 + x**2/2, t, domain='EX'))], True)
DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1 + t**2, t)]})
assert residue_reduce(Poly(-2*x*t + 1 - x**2, t),
Poly(t**2 + 2*x*t + 1 + x**2, t), DE, z) == \
([(Poly(z**2 + Rational(1, 4), z), Poly(t + x + 2*z, t))], True)
DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]})
assert residue_reduce(Poly(t, t), Poly(t + sqrt(2), t), DE, z) == \
([(Poly(z - 1, z), Poly(t + sqrt(2), t))], True)
def test_add():
assert (a**2 - b - c).subs({a**2 - b: d}) in [d - c, a**2 - b - c]
assert (a**2 - c).subs({a**2 - c: d}) == d
assert (a**2 - b - c).subs({a**2 - c: d}) in [d - b, a**2 - b - c]
assert (a**2 - x - c).subs({a**2 - c: d}) in [d - x, a**2 - x - c]
assert (a**2 - b - sqrt(a)).subs({a**2 - sqrt(a): c}) == c - b
assert (a + b + exp(a + b)).subs({a + b: c}) == c + exp(c)
assert (c + b + exp(c + b)).subs({c + b: a}) == a + exp(a)
assert (a + b + c + d).subs({b + c: x}) == a + d + x
assert (a + b + c + d).subs({-b - c: x}) == a + d - x
assert ((x + 1)*y).subs({x + 1: t}) == t*y
assert ((-x - 1)*y).subs({x + 1: t}) == -t*y
assert ((x - 1)*y).subs({x + 1: t}) == y*(t - 2)
assert ((-x + 1)*y).subs({x + 1: t}) == y*(-t + 2)
# this should work everytime:
e = a**2 - b - c
assert e.subs({Add(*e.args[:2]): d}) == d + e.args[2]
assert e.subs({a**2 - c: d}) == d - b
# the fallback should recognize when a change has
# been made; while .1 == Rational(1, 10) they are not the same
# and the change should be made
assert (0.1 + a).subs({0.1: Rational(1, 10)}) == Rational(1, 10) + a
e = (-x*(-y + 1) - y*(y - 1))
ans = (-x*x - y*(-x)).expand()
assert e.subs({-y + 1: x}) == ans
def test_rayleigh():
sigma = Symbol("sigma", positive=True)
X = Rayleigh('x', sigma)
assert density(X)(x) == x*exp(-x**2/(2*sigma**2))/sigma**2
assert E(X) == sqrt(2)*sqrt(pi)*sigma/2
assert variance(X) == -pi*sigma**2/2 + 2*sigma**2
def test_sympyissue_7383():
x, z, R, a = symbols('x z R a')
r = sqrt(x**2 + z**2)
u = erf(a*r/sqrt(2))/r
Ec = u.diff(z, z).subs({x: sqrt(R*R - z*z)})
assert integrate(Ec, (z, -R, R)).simplify() == \
-2*sqrt(2)*R*a**3*exp(-R**2*a**2/2)/(3*sqrt(pi))
def test_evalf_integer_parts():
a = floor(log(8)/log(2) - exp(-1000), evaluate=False)
b = floor(log(8)/log(2), evaluate=False)
assert a.evalf() == 3
assert b.evalf() == 3
# equals, as a fallback, can still fail but it might succeed as here
assert ceiling(10*(sin(1)**2 + cos(1)**2)) == 10
assert int(floor(factorial(50)/E, evaluate=False).evalf(70)) == \
int(11188719610782480504630258070757734324011354208865721592720336800)
assert int(ceiling(factorial(50)/E, evaluate=False).evalf(70)) == \
int(11188719610782480504630258070757734324011354208865721592720336801)
assert int(floor((GoldenRatio**999 / sqrt(5) + Rational(1, 2)))
.evalf(1000)) == fibonacci(999)
assert int(floor((GoldenRatio**1000 / sqrt(5) + Rational(1, 2)))
.evalf(1000)) == fibonacci(1000)
assert ceiling(x).evalf(subs={x: 3}) == 3
assert ceiling(x).evalf(subs={x: 3*I}) == 3*I
assert ceiling(x).evalf(subs={x: 2 + 3*I}) == 2 + 3*I
# issue sympy/sympy#10323
l = 1206577996382235787095214
y = ceiling(sqrt(l))
assert y == 1098443442506
assert y**2 >= l
def check(x):
c, f = ceiling(sqrt(x)), floor(sqrt(x))
assert (c - 1)**2 < x and c**2 >= x
assert (f + 1)**2 > x and f**2 <= x
check(2**30 + 1)
check(2**100 + 1)
check(2**112 + 2)
def test_polarify():
z = Symbol('z', polar=True)
f = Function('f')
ES = {}
assert polarify(-1) == (polar_lift(-1), ES)
assert polarify(1 + I) == (polar_lift(1 + I), ES)
assert polarify(exp(x), subs=False) == exp(x)
assert polarify(1 + x, subs=False) == 1 + x
assert polarify(f(I) + x, subs=False) == f(polar_lift(I)) + x
assert polarify(x, lift=True) == polar_lift(x)
assert polarify(z, lift=True) == z
assert polarify(f(x), lift=True) == f(polar_lift(x))
assert polarify(1 + x, lift=True) == polar_lift(1 + x)
assert polarify(1 + f(x), lift=True) == polar_lift(1 + f(polar_lift(x)))
newex, subs = polarify(f(x) + z)
assert newex.subs(subs) == f(x) + z
mu = Symbol("mu")
sigma = Symbol("sigma", positive=True)
# Make sure polarify(lift=True) doesn't try to lift the integration
# variable
assert polarify(
Integral(sqrt(2)*x*exp(-(-mu + x)**2/(2*sigma**2))/(2*sqrt(pi)*sigma),
(x, -oo, oo)), lift=True) == Integral(sqrt(2)*(sigma*exp_polar(0))**exp_polar(I*pi) *
exp((sigma*exp_polar(0))**(2*exp_polar(I*pi))*exp_polar(I*pi)*polar_lift(-mu + x) **
(2*exp_polar(0))/2)*exp_polar(0)*polar_lift(x)/(2*sqrt(pi)), (x, -oo, oo))
def test_rootcomplex():
R = Rational
assert ((+1 + I)**R(1, 2)).expand(
complex=True) == 2**R(1, 4)*cos( pi/8) + 2**R(1, 4)*sin( pi/8)*I
assert ((-1 - I)**R(1, 2)).expand(
complex=True) == 2**R(1, 4)*cos(3*pi/8) - 2**R(1, 4)*sin(3*pi/8)*I
assert (sqrt(-10)*I).as_real_imag() == (-sqrt(10), 0)
def test_python_functions():
# Simple
assert python((2*x + exp(x))) in "x = Symbol('x')\ne = E**x + 2*x"
assert python(sqrt(2)) == 'e = sqrt(2)'
assert python(cbrt(2)) == 'e = 2**Rational(1, 3)'
assert python(sqrt(2 + pi)) == 'e = sqrt(2 + pi)'
assert python(cbrt(2 + pi)) == 'e = (2 + pi)**Rational(1, 3)'
assert python(root(2, 4)) == 'e = 2**Rational(1, 4)'
assert python(Abs(x)) == "x = Symbol('x')\ne = Abs(x)"
assert python(
Abs(x/(x**2 + 1))) in ["x = Symbol('x')\ne = Abs(x/(1 + x**2))",
"x = Symbol('x')\ne = Abs(x/(x**2 + 1))"]
# Univariate/Multivariate functions
f = Function('f')
assert python(f(x)) == "x = Symbol('x')\nf = Function('f')\ne = f(x)"
assert python(f(x, y)) == "x = Symbol('x')\ny = Symbol('y')\nf = Function('f')\ne = f(x, y)"
assert python(f(x/(y + 1), y)) in [
"x = Symbol('x')\ny = Symbol('y')\nf = Function('f')\ne = f(x/(1 + y), y)",
"x = Symbol('x')\ny = Symbol('y')\nf = Function('f')\ne = f(x/(y + 1), y)"]
# Nesting of square roots
assert python(sqrt((sqrt(x + 1)) + 1)) in [
"x = Symbol('x')\ne = sqrt(1 + sqrt(1 + x))",
"x = Symbol('x')\ne = sqrt(sqrt(x + 1) + 1)"]
# Nesting of powers
assert python(cbrt(cbrt(x + 1) + 1)) in [
"x = Symbol('x')\ne = (1 + (1 + x)**Rational(1, 3))**Rational(1, 3)",
"x = Symbol('x')\ne = ((x + 1)**Rational(1, 3) + 1)**Rational(1, 3)"]
# Function powers
assert python(sin(x)**2) == "x = Symbol('x')\ne = sin(x)**2"
def test_messy():
assert laplace_transform(Si(x), x, s) == ((-atan(s) + pi/2)/s, 0, True)
assert laplace_transform(Shi(x), x, s) == (acoth(s)/s, 1, True)
# where should the logs be simplified?
assert laplace_transform(Chi(x), x, s) == \
((log(s**(-2)) - log((s**2 - 1)/s**2))/(2*s), 1, True)
# TODO maybe simplify the inequalities?
assert laplace_transform(besselj(a, x), x, s)[1:] == \
(0, And(Integer(0) < re(a/2) + Rational(1, 2), Integer(0) < re(a/2) + 1))
# NOTE s < 0 can be done, but argument reduction is not good enough yet
assert fourier_transform(besselj(1, x)/x, x, s, noconds=False) == \
(Piecewise((0, 4*abs(pi**2*s**2) > 1),
(2*sqrt(-4*pi**2*s**2 + 1), True)), s > 0)
# TODO FT(besselj(0,x)) - conditions are messy (but for acceptable reasons)
# - folding could be better
assert integrate(E1(x)*besselj(0, x), (x, 0, oo), meijerg=True) == \
log(1 + sqrt(2))
assert integrate(E1(x)*besselj(1, x), (x, 0, oo), meijerg=True) == \
log(Rational(1, 2) + sqrt(2)/2)
assert integrate(1/x/sqrt(1 - x**2), x, meijerg=True) == \
Piecewise((-acosh(1/x), 1 < abs(x**(-2))), (I*asin(1/x), True))
def test_expand():
f = (16 - 2*sqrt(29))**2
assert f.expand() == 372 - 64*sqrt(29)
f = (Rational(1, 2) + I/2)**10
assert f.expand() == I/32
f = (Rational(1, 2) + I)**10
assert f.expand() == Rational(237, 1024) - 779*I/256
def test_evalf_ramanujan():
assert NS(exp(pi*sqrt(163)) - 640320**3 - 744, 10) == '-7.499274028e-13'
# A related identity
A = 262537412640768744*exp(-pi*sqrt(163))
B = 196884*exp(-2*pi*sqrt(163))
C = 103378831900730205293632*exp(-3*pi*sqrt(163))
assert NS(1 - A - B + C, 10) == '1.613679005e-59'
def test_RootOf_all_roots():
assert Poly(x**5 + x + 1).all_roots() == [
RootOf(x**3 - x**2 + 1, 0),
-Rational(1, 2) - sqrt(3)*I/2,
-Rational(1, 2) + sqrt(3)*I/2,
RootOf(x**3 - x**2 + 1, 1),
RootOf(x**3 - x**2 + 1, 2),
]
assert Poly(x**5 + x + 1).all_roots(radicals=False) == [
RootOf(x**3 - x**2 + 1, 0),
RootOf(x**2 + x + 1, 0, radicals=False),
RootOf(x**2 + x + 1, 1, radicals=False),
RootOf(x**3 - x**2 + 1, 1),
RootOf(x**3 - x**2 + 1, 2),
]
r = Poly((x**3 + x + 20)*(x**3 + x + 21)).all_roots()
assert r[0].is_real and r[1].is_real
assert all(not _.is_real for _ in r[2:])
assert r == [RootOf(x**3 + x + 21, 0), RootOf(x**3 + x + 20, 0),
RootOf(x**3 + x + 20, 1), RootOf(x**3 + x + 20, 2),
RootOf(x**3 + x + 21, 1), RootOf(x**3 + x + 21, 2)]
def test_solve_univariate_inequality():
assert isolve(x**2 >= 4, x, relational=False) == Union(Interval(-oo, -2, True),
Interval(2, oo, False, True))
assert isolve(x**2 >= 4, x) == Or(And(Le(2, x), Lt(x, oo)), And(Le(x, -2),
Lt(-oo, x)))
assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x, relational=False) == \
Union(Interval(1, 2), Interval(3, oo, False, True))
assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x) == \
Or(And(Le(1, x), Le(x, 2)), And(Le(3, x), Lt(x, oo)))
# issue sympy/sympy#2785:
assert isolve(x**3 - 2*x - 1 > 0, x, relational=False) == \
Union(Interval(-1, -sqrt(5)/2 + Rational(1, 2), True, True),
Interval(Rational(1, 2) + sqrt(5)/2, oo, True, True))
# issue sympy/sympy#2794:
assert isolve(x**3 - x**2 + x - 1 > 0, x, relational=False) == \
Interval(1, oo, True, True)
# XXX should be limited in domain, e.g. between 0 and 2*pi
assert isolve(sin(x) < Rational(1, 2), x) == \
Or(And(-oo < x, x < pi/6), And(5*pi/6 < x, x < oo))
assert isolve(sin(x) > Rational(1, 2), x) == And(pi/6 < x, x < 5*pi/6)
# numerical testing in valid() is needed
assert isolve(x**7 - x - 2 > 0, x) == \
And(RootOf(x**7 - x - 2, 0) < x, x < oo)
# handle numerator and denominator; although these would be handled as
# rational inequalities, these test confirm that the right thing is done
# when the domain is EX (e.g. when 2 is replaced with sqrt(2))
assert isolve(1/(x - 2) > 0, x) == And(Integer(2) < x, x < oo)
den = ((x - 1)*(x - 2)).expand()
assert isolve((x - 1)/den <= 0, x) == \
Or(And(-oo < x, x < 1), And(Integer(1) < x, x < 2))
assert isolve(x > oo, x) is false
def test_matplotlib_advanced():
"""Examples from the 'advanced' notebook."""
try:
name = 'test'
tmp_file = TmpFileManager.tmp_file
s = summation(1/x**y, (x, 1, oo))
p = plot(s, (y, 2, 10))
p.save(tmp_file('%s_advanced_inf_sum' % name))
p = plot(summation(1/x, (x, 1, y)), (y, 2, 10), show=False)
p[0].only_integers = True
p[0].steps = True
p.save(tmp_file('%s_advanced_fin_sum' % name))
###
# Test expressions that can not be translated to np and
# generate complex results.
###
plot(sin(x) + I*cos(x)).save(tmp_file())
plot(sqrt(sqrt(-x))).save(tmp_file())
plot(LambertW(x)).save(tmp_file())
plot(sqrt(LambertW(x))).save(tmp_file())
# Characteristic function of a StudentT distribution with nu=10
plot((meijerg(((1 / 2,), ()), ((5, 0, 1 / 2), ()),
5 * x**2 * exp_polar(-I*pi)/2)
+ meijerg(((1/2,), ()), ((5, 0, 1/2), ()),
5*x**2 * exp_polar(I*pi)/2)) / (48 * pi), (x, 1e-6, 1e-2)).save(tmp_file())
finally:
TmpFileManager.cleanup()
def test_rewrite():
assert besselj(n, z).rewrite(jn) == sqrt(2*z/pi)*jn(n - Rational(1, 2), z)
assert bessely(n, z).rewrite(yn) == sqrt(2*z/pi)*yn(n - Rational(1, 2), z)
assert besseli(n, z).rewrite(besselj) == \
exp(-I*n*pi/2)*besselj(n, polar_lift(I)*z)
assert besselj(n, z).rewrite(besseli) == \
exp(I*n*pi/2)*besseli(n, polar_lift(-I)*z)
assert besselj(2, z).rewrite(bessely) == besselj(2, z)
assert bessely(2, z).rewrite(besselj) == bessely(2, z)
assert bessely(2, z).rewrite(besseli) == bessely(2, z)
assert besselk(2, z).rewrite(besseli) == besselk(2, z)
assert besselk(2, z).rewrite(besselj) == besselk(2, z)
assert besselk(2, z).rewrite(bessely) == besselk(2, z)
nu = randcplx()
assert tn(besselj(nu, z), besselj(nu, z).rewrite(besseli), z)
assert tn(besselj(nu, z), besselj(nu, z).rewrite(bessely), z)
assert tn(besseli(nu, z), besseli(nu, z).rewrite(besselj), z)
assert tn(besseli(nu, z), besseli(nu, z).rewrite(bessely), z)
assert tn(bessely(nu, z), bessely(nu, z).rewrite(besselj), z)
assert tn(bessely(nu, z), bessely(nu, z).rewrite(besseli), z)
assert tn(besselk(nu, z), besselk(nu, z).rewrite(besselj), z)
assert tn(besselk(nu, z), besselk(nu, z).rewrite(besseli), z)
assert tn(besselk(nu, z), besselk(nu, z).rewrite(bessely), z)
def test_lognormal():
mean = Symbol('mu', real=True)
std = Symbol('sigma', positive=True, real=True)
X = LogNormal('x', mean, std)
# The diofant integrator can't do this too well
# assert E(X) == exp(mean+std**2/2)
# assert variance(X) == (exp(std**2)-1) * exp(2*mean + std**2)
# Right now, only density function and sampling works
# Test sampling: Only e^mean in sample std of 0
for i in range(3):
X = LogNormal('x', i, 0)
assert sample(X) == N(exp(i))
# The diofant integrator can't do this too well
# assert E(X) ==
mu = Symbol("mu", extended_real=True)
sigma = Symbol("sigma", positive=True)
X = LogNormal('x', mu, sigma)
assert density(X)(x) == (sqrt(2)*exp(-(-mu + log(x))**2
/ (2*sigma**2))/(2*x*sqrt(pi)*sigma))
X = LogNormal('x', 0, 1) # Mean 0, standard deviation 1
assert density(X)(x) == sqrt(2)*exp(-log(x)**2/2)/(2*x*sqrt(pi))
def test_unevaluated():
X = Normal('x', 0, 1)
assert E(X, evaluate=False) == (
Integral(sqrt(2)*x*exp(-x**2/2)/(2*sqrt(pi)), (x, -oo, oo)))
assert E(X + 1, evaluate=False) == (
Integral(sqrt(2)*x*exp(-x**2/2)/(2*sqrt(pi)), (x, -oo, oo)) + 1)
def test_evalf_fast_series():
# Euler transformed series for sqrt(1+x)
assert NS(Sum(fac(2*n + 1)/fac(n)**2/2**(3*n + 1), (n, 0, oo)),
100, strict=False) == NS(sqrt(2), 100)
# Some series for exp(1)
estr = NS(E, 100)
assert NS(Sum(1/fac(n), (n, 0, oo)), 100, strict=False) == estr
assert NS(1/Sum((1 - 2*n)/fac(2*n), (n, 0, oo)), 100) == estr
assert NS(Sum((2*n + 1)/fac(2*n), (n, 0, oo)), 100, strict=False) == estr
assert NS(Sum((4*n + 3)/2**(2*n + 1)/fac(2*n + 1), (n, 0, oo))**2,
100, strict=False) == estr
pistr = NS(pi, 100)
# Ramanujan series for pi
assert NS(9801/sqrt(8)/Sum(fac(4*n)*(1103 + 26390*n)/fac(n)**4/396**(4*n),
(n, 0, oo)), 100, strict=False) == pistr
assert NS(1/Sum(
binomial(2*n, n)**3 * (42*n + 5)/2**(12*n + 4), (n, 0, oo)), 100) == pistr
# Machin's formula for pi
assert NS(16*Sum((-1)**n/(2*n + 1)/5**(2*n + 1), (n, 0, oo)) -
4*Sum((-1)**n/(2*n + 1)/239**(2*n + 1), (n, 0, oo)), 100) == pistr
# Apery's constant
astr = NS(zeta(3), 100)
P = 126392*n**5 + 412708*n**4 + 531578*n**3 + 336367*n**2 + 104000 * \
n + 12463
assert NS(Sum((-1)**n * P / 24 * (fac(2*n + 1)*fac(2*n)*fac(n))**3 /
fac(3*n + 2) / fac(4*n + 3)**3, (n, 0, oo)),
100, strict=False) == astr
assert NS(Sum((-1)**n * (205*n**2 + 250*n + 77)/64 * fac(n)**10 /
fac(2*n + 1)**5, (n, 0, oo)), 100, strict=False) == astr
pytest.raises(ValueError, lambda: Sum(factorial(n), (n, 0, oo)).evalf())
def test_expand_modulus():
assert ((x + y)**11).expand(modulus=11) == x**11 + y**11
assert ((x + sqrt(2)*y)**11).expand(modulus=11) == x**11 + 10*sqrt(2)*y**11
assert (x + y/2).expand(modulus=1) == y/2
pytest.raises(ValueError, lambda: ((x + y)**11).expand(modulus=0))
pytest.raises(ValueError, lambda: ((x + y)**11).expand(modulus=x))
def test_sympyissue_6559():
assert (-12*x + y).subs({-x: 1}) == 12 + y
# though this involves cse it generated a failure in Mul._eval_subs
x0, x1 = symbols('x0 x1')
e = -log(-12*sqrt(2) + 17)/24 - log(-2*sqrt(2) + 3)/12 + sqrt(2)/3
# XXX modify cse so x1 is eliminated and x0 = -sqrt(2)?
assert cse(e) == (
[(x0, sqrt(2))], [x0/3 - log(-12*x0 + 17)/24 - log(-2*x0 + 3)/12])
def test_noncommutative():
A, B, C = symbols('A,B,C', commutative=False)
assert sstr(A*B*C**-1) == "A*B*C**(-1)"
assert sstr(C**-1*A*B) == "C**(-1)*A*B"
assert sstr(A*C**-1*B) == "A*C**(-1)*B"
assert sstr(sqrt(A)) == "sqrt(A)"
assert sstr(1/sqrt(A)) == "A**(-1/2)"
def test_sqrt():
assert str(sqrt(x)) == "sqrt(x)"
assert str(sqrt(x**2)) == "sqrt(x**2)"
assert str(1/sqrt(x)) == "1/sqrt(x)"
assert str(1/sqrt(x**2)) == "1/sqrt(x**2)"
assert str(y/sqrt(x)) == "y/sqrt(x)"
assert str(x**(1/2)) == "x**0.5"
assert str(1/x**(1/2)) == "x**(-0.5)"
def test_cse_single2():
# Simple substitution, test for being able to pass the expression directly
e = Add(Pow(x + y, 2), sqrt(x + y))
substs, reduced = cse(e)
assert substs == [(x0, x + y)]
assert reduced == [sqrt(x0) + x0**2]
substs, reduced = cse(Matrix([[1]]))
assert isinstance(reduced[0], Matrix)
def test_pow_sympyissue_4823():
e = cbrt(-1)
assert e.conjugate().evalf() == e.evalf().conjugate()
e = (Rational(-2, 3) - cbrt(Rational(-29, 54) + sqrt(93)/18)
- 1/(9*cbrt(Rational(-29, 54) + sqrt(93)/18)))
assert e.conjugate().evalf() == e.evalf().conjugate()
e = 2**I
assert e.conjugate().evalf() == e.evalf().conjugate()
def test_assemble_partfrac_list():
f = 36 / (x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2)
pfd = apart_list(f)
assert assemble_partfrac_list(pfd) == -4/(x + 1) - 3/(x + 1)**2 - 9/(x - 1)**2 + 4/(x - 2)
a = Dummy("a")
pfd = (1, Poly(0, x, domain='ZZ'), [([sqrt(2), -sqrt(2)], Lambda(a, a/2), Lambda(a, -a + x), 1)])
assert assemble_partfrac_list(pfd) == -1/(sqrt(2)*(x + sqrt(2))) + 1/(sqrt(2)*(x - sqrt(2)))
def test_sympyissue_5728():
b = x*sqrt(y)
a = sqrt(b)
c = sqrt(sqrt(x)*y)
assert powsimp(a*b) == sqrt(b)**3
assert powsimp(a*b**2*sqrt(y)) == sqrt(y)*a**5
assert powsimp(a*x**2*c**3*y) == c**3*a**5
assert powsimp(a*x*c**3*y**2) == c**7*a
assert powsimp(x*c**3*y**2) == c**7
assert powsimp(x*c**3*y) == x*y*c**3
assert powsimp(sqrt(x)*c**3*y) == c**5
assert powsimp(sqrt(x)*a**3*sqrt(y)) == sqrt(x)*sqrt(y)*a**3
assert powsimp(Mul(sqrt(x)*c**3*sqrt(y), y, evaluate=False)) == \
sqrt(x)*sqrt(y)**3*c**3
assert powsimp(a**2*a*x**2*y) == a**7
# symbolic powers work, too
b = x**y*y
a = b*sqrt(b)
assert a.is_Mul is True
assert powsimp(a) == sqrt(b)**3
# as does exp
a = x*exp(2*y/3)
assert powsimp(a*sqrt(a)) == sqrt(a)**3
assert powsimp(a**2*sqrt(a)) == sqrt(a)**5
assert powsimp(a**2*sqrt(sqrt(a))) == sqrt(sqrt(a))**9
def test_sqrtdenest():
d = {
sqrt(5 + 2 * r6):
r2 + r3,
sqrt(5. + 2 * r6):
sqrt(5. + 2 * r6),
sqrt(5. + 4 * sqrt(5 + 2 * r6)):
sqrt(5.0 + 4 * r2 + 4 * r3),
sqrt(r2):
sqrt(r2),
sqrt(5 + r7):
sqrt(5 + r7),
sqrt(3 + sqrt(5 + 2 * r7)):
3 * r2 * root(5 + 2 * r7, 4) / (2 * sqrt(6 + 3 * r7)) +
r2 * sqrt(6 + 3 * r7) / (2 * root(5 + 2 * r7, 4)),
sqrt(3 + 2 * r3):
3**Rational(3, 4) * (r6 / 2 + 3 * r2 / 2) / 3
}
for i in d:
assert sqrtdenest(i) == d[i]
def test_unrad1():
pytest.raises(NotImplementedError,
lambda: unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x)) + 3))
pytest.raises(NotImplementedError,
lambda: unrad(sqrt(x) + cbrt(x + 1) + 2 * sqrt(y)))
s = symbols('s', cls=Dummy)
# checkers to deal with possibility of answer coming
# back with a sign change (cf issue sympy/sympy#5203)
def check(rv, ans):
assert bool(rv[1]) == bool(ans[1])
if ans[1]:
return s_check(rv, ans)
e = rv[0].expand()
a = ans[0].expand()
return e in [a, -a] and rv[1] == ans[1]
def s_check(rv, ans):
# get the dummy
rv = list(rv)
d = rv[0].atoms(Dummy)
reps = list(zip(d, [s] * len(d)))
# replace s with this dummy
rv = (rv[0].subs(reps).expand(),
[rv[1][0].subs(reps), rv[1][1].subs(reps)])
ans = (ans[0].subs(reps).expand(),
[ans[1][0].subs(reps), ans[1][1].subs(reps)])
return str(rv[0]) in [str(ans[0]), str(-ans[0])] and \
str(rv[1]) == str(ans[1])
assert check(unrad(sqrt(x)), (x, []))
assert check(unrad(sqrt(x) + 1), (x - 1, []))
assert check(unrad(sqrt(x) + root(x, 3) + 2),
(s**3 + s**2 + 2, [s, s**6 - x]))
assert check(unrad(sqrt(x) * root(x, 3) + 2), (x**5 - 64, []))
assert check(unrad(sqrt(x) + cbrt(x + 1)), (x**3 - (x + 1)**2, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(2 * x)),
(-2 * sqrt(2) * x - 2 * x + 1, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + 2), (16 * x - 9, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - x)),
(5 * x**2 - 4 * x, []))
assert check(unrad(a * sqrt(x) + b * sqrt(x) + c * sqrt(y) + d * sqrt(y)),
((a * sqrt(x) + b * sqrt(x))**2 -
(c * sqrt(y) + d * sqrt(y))**2, []))
assert check(unrad(sqrt(x) + sqrt(1 - x)), (2 * x - 1, []))
assert check(unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x)),
(5 * x**2 - 2 * x + 1, []))
assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - 3) in [
(25 * x**4 + 376 * x**3 + 1256 * x**2 - 2272 * x + 784, []),
(25 * x**8 - 476 * x**6 + 2534 * x**4 - 1468 * x**2 + 169, [])
]
assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - sqrt(1 - 2*x)) == \
(41*x**4 + 40*x**3 + 232*x**2 - 160*x + 16, []) # orig root at 0.487
assert check(unrad(sqrt(x) + sqrt(x + 1)), (Integer(1), []))
eq = sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x))
assert check(unrad(eq), (16 * x**2 - 9 * x, []))
assert check(unrad(sqrt(x) + root(x + 1, 3) + 2 * sqrt(y), y),
(2 * sqrt(x) * cbrt(x + 1) + x - 4 * y +
(x + 1)**Rational(2, 3), []))
assert check(unrad(sqrt(x / (1 - x)) + cbrt(x + 1)),
(x**5 - x**4 - x**3 + 2 * x**2 + x - 1, []))
assert check(unrad(sqrt(x / (1 - x)) + 2 * sqrt(y), y),
(4 * x * y + x - 4 * y, []))
assert check(unrad(sqrt(x) * sqrt(1 - x) + 2, x), (x**2 - x + 4, []))
# issue sympy/sympy#8622
assert unrad(
(root(x + 1, 5) - root(x, 3))) == (x**5 - x**3 - 3 * x**2 - 3 * x - 1,
[])
# issue sympy/sympy#8679
assert check(unrad(x + root(x, 3) + root(x, 3)**2 + sqrt(y), x),
(s**3 + s**2 + s + sqrt(y), [s, s**3 - x]))
# for coverage
assert check(unrad(sqrt(x) + root(x, 3) + y),
(s**3 + s**2 + y, [s, s**6 - x]))
# unrad some
e = root(x + 1, 3) + root(x, 3)
assert unrad(e) == (2 * x + 1, [])
eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6 * sqrt(5) / 5)
assert check(unrad(eq), (15625 * x**4 + 173000 * x**3 + 355600 * x**2 -
817920 * x + 331776, []))
assert check(unrad(root(x, 4) + root(x, 4)**3 - 1),
(s**3 + s - 1, [s, s**4 - x]))
assert check(unrad(root(x, 2) + root(x, 2)**3 - 1),
(x**3 + 2 * x**2 + x - 1, []))
assert unrad(x**0.5) is None
assert check(unrad(t + root(x + y, 5) + root(x + y, 5)**3),
(s**3 + s + t, [s, s**5 - x - y]))
assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, y),
(s**3 + s + x, [s, s**5 - x - y]))
assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, x),
(s**5 + s**3 + s - y, [s, s**5 - x - y]))
assert check(
unrad(root(x - 1, 3) + root(x + 1, 5) + root(2, 5)),
(s**5 + 5 * root(2, 5) * s**4 + s**3 + 10 * 2**Rational(2, 5) * s**3 +
10 * 2**Rational(3, 5) * s**2 + 5 * 2**Rational(4, 5) * s + 4,
[s, s**3 - x + 1]))
pytest.raises(
NotImplementedError, lambda: unrad(
(root(x, 2) + root(x, 3) + root(x, 4)).subs({x: x**5 - x + 1})))
# the simplify flag should be reset to False for unrad results;
# if it's not then this next test will take a long time
eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6 * sqrt(5) / 5)
assert check(unrad(eq),
((5 * x - 4) *
(3125 * x**3 + 37100 * x**2 + 100800 * x - 82944), []))
# duplicate radical handling
assert check(unrad(sqrt(x + root(x + 1, 3)) - root(x + 1, 3) - 2),
(s**3 - s**2 - 3 * s - 5, [s, s**3 - x - 1]))
# cov post-processing
e = root(x**2 + 1, 3) - root(x**2 - 1, 5) - 2
assert check(unrad(e),
(s**5 - 10 * s**4 + 39 * s**3 - 80 * s**2 + 80 * s - 30,
[s, s**3 - x**2 - 1]))
e = sqrt(x + root(x + 1, 2)) - root(x + 1, 3) - 2
assert check(unrad(e), (s**6 - 2 * s**5 - 7 * s**4 - 3 * s**3 + 26 * s**2 +
40 * s + 25, [s, s**3 - x - 1]))
assert check(unrad(e, _reverse=True),
(s**6 - 14 * s**5 + 73 * s**4 - 187 * s**3 + 276 * s**2 -
228 * s + 89, [s, s**2 - x - sqrt(x + 1)]))
# this one needs r0, r1 reversal to work
assert check(unrad(sqrt(x + sqrt(root(x, 3) - 1)) - root(x, 6) - 2),
(s**12 - 2 * s**8 - 8 * s**7 - 8 * s**6 + s**4 + 8 * s**3 +
23 * s**2 + 32 * s + 17, [s, s**6 - x]))
# is this needed?
# assert unrad(root(cosh(x), 3)/x*root(x + 1, 5) - 1) == (
# x**15 - x**3*cosh(x)**5 - 3*x**2*cosh(x)**5 - 3*x*cosh(x)**5 - cosh(x)**5, [])
pytest.raises(
NotImplementedError,
lambda: unrad(sqrt(cosh(x) / x) + root(x + 1, 3) * sqrt(x) - 1))
assert unrad((x + y)**(2 * y / 3) + cbrt(x + y) + 1) is None
assert check(unrad((x + y)**(2 * y / 3) + cbrt(x + y) + 1, x),
(s**(2 * y) + s + 1, [s, s**3 - x - y]))
eq = root(x + 1, 3) - (root(x, 3) + root(x, 5))
assert check(unrad(eq), (3 * s**13 + 3 * s**11 + s**9 - 1, [s, s**15 - x]))
assert check(unrad(eq - 2),
(3 * s**13 + 3 * s**11 + 6 * s**10 + s**9 + 12 * s**8 +
6 * s**6 + 12 * s**5 + 12 * s**3 + 7, [s, s**15 - x]))
assert check(
unrad(root(x, 3) - root(x + 1, 4) / 2 + root(x + 2, 3)),
(4096 * s**13 + 960 * s**12 + 48 * s**11 - s**10 - 1728 * s**4,
[s, s**4 - x - 1])) # orig expr has two real roots: -1, -.389
assert check(
unrad(root(x, 3) + root(x + 1, 4) - root(x + 2, 3) / 2),
(343 * s**13 + 2904 * s**12 + 1344 * s**11 + 512 * s**10 -
1323 * s**9 - 3024 * s**8 - 1728 * s**7 + 1701 * s**5 + 216 * s**4 -
729 * s, [s, s**4 - x - 1])) # orig expr has one real root: -0.048
assert check(
unrad(root(x, 3) / 2 - root(x + 1, 4) + root(x + 2, 3)),
(729 * s**13 - 216 * s**12 + 1728 * s**11 - 512 * s**10 + 1701 * s**9 -
3024 * s**8 + 1344 * s**7 + 1323 * s**5 - 2904 * s**4 + 343 * s,
[s, s**4 - x - 1])) # orig expr has 2 real roots: -0.91, -0.15
# orig expr has 1 real root: 19.53
assert check(unrad(root(x, 3) / 2 - root(x + 1, 4) + root(x + 2, 3) - 2),
(729 * s**13 + 1242 * s**12 + 18496 * s**10 + 129701 * s**9 +
388602 * s**8 + 453312 * s**7 - 612864 * s**6 -
3337173 * s**5 - 6332418 * s**4 - 7134912 * s**3 -
5064768 * s**2 - 2111913 * s - 398034, [s, s**4 - x - 1]))
eq = (-x + (Rational(1, 2) - sqrt(3) * I / 2) *
cbrt(3 * x**3 / 2 - x * (3 * x**2 - 34) / 2 + sqrt(
(-3 * x**3 + x *
(3 * x**2 - 34) + 90)**2 / 4 - Rational(39304, 27)) - 45) + 34 /
(3 * (Rational(1, 2) - sqrt(3) * I / 2) *
cbrt(3 * x**3 / 2 - x * (3 * x**2 - 34) / 2 + sqrt(
(-3 * x**3 + x *
(3 * x**2 - 34) + 90)**2 / 4 - Rational(39304, 27)) - 45)))
assert check(unrad(eq),
(s**6 - sqrt(3) * s**6 * I + 102 * cbrt(12) * s**4 +
102 * 2**Rational(2, 3) * 3**Rational(5, 6) * s**4 * I +
1620 * s**3 - 1620 * sqrt(3) * s**3 * I -
13872 * cbrt(18) * s**2 + 471648 - 471648 * sqrt(3) * I, [
s, s**3 - 306 * x -
sqrt(3) * sqrt(31212 * x**2 - 165240 * x + 61484) + 810
]))
def test_sqrtdenest_rec():
assert sqrtdenest(sqrt(-4*sqrt(14) - 2*r6 + 4*sqrt(21) + 33)) == \
-r2 + r3 + 2*r7
assert sqrtdenest(sqrt(-28*r7 - 14*r5 + 4*sqrt(35) + 82)) == \
-7 + r5 + 2*r7
assert sqrtdenest(sqrt(6*r2/11 + 2*sqrt(22)/11 + 6*sqrt(11)/11 + 2)) == \
sqrt(11)*(r2 + 3 + sqrt(11))/11
assert sqrtdenest(sqrt(468*r3 + 3024*r2 + 2912*r6 + 19735)) == \
9*r3 + 26 + 56*r6
z = sqrt(-490 * r3 - 98 * sqrt(115) - 98 * sqrt(345) - 2107)
assert sqrtdenest(z) == sqrt(-1) * (7 * r5 + 7 * r15 + 7 * sqrt(23))
z = sqrt(-4 * sqrt(14) - 2 * r6 + 4 * sqrt(21) + 34)
assert sqrtdenest(z) == z
assert sqrtdenest(sqrt(-8 * r2 - 2 * r5 + 18)) == -r10 + 1 + r2 + r5
assert sqrtdenest(sqrt(8*r2 + 2*r5 - 18)) == \
sqrt(-1)*(-r10 + 1 + r2 + r5)
assert sqrtdenest(sqrt(8*r2/3 + 14*r5/3 + Rational(154, 9))) == \
-r10/3 + r2 + r5 + 3
assert sqrtdenest(sqrt(sqrt(2*r6 + 5) + sqrt(2*r7 + 8))) == \
sqrt(1 + r2 + r3 + r7)
assert sqrtdenest(sqrt(4 * r15 + 8 * r5 + 12 * r3 +
24)) == 1 + r3 + r5 + r15
w = 1 + r2 + r3 + r5 + r7
assert sqrtdenest(sqrt((w**2).expand())) == w
z = sqrt((w**2).expand() + 1)
assert sqrtdenest(z) == z
z = sqrt(2 * r10 + 6 * r2 + 4 * r5 + 12 + 10 * r15 + 30 * r3)
assert sqrtdenest(z) == z
def test_simple_8():
assert O(sqrt(-x)) == O(sqrt(x))
assert O(x**2 * sqrt(x)) == O(x**Rational(5, 2))
assert O(x**3 * sqrt(-(-x)**3)) == O(x**Rational(9, 2))
assert O(x**Rational(3, 2) * sqrt((-x)**3)) == O(x**3)
assert O(x * (-2 * x)**(I / 2)) == O(x * (-x)**(I / 2))
def test_heurisch_special():
assert heurisch(erf(x), x) == x * erf(x) + exp(-x**2) / sqrt(pi)
assert heurisch(exp(-x**2) * erf(x), x) == sqrt(pi) * erf(x)**2 / 4
def test_meijer():
pytest.raises(TypeError, lambda: meijerg(1, z))
pytest.raises(TypeError, lambda: meijerg(((1, ), (2, )), (3, ), (4, ), z))
pytest.raises(TypeError, lambda: meijerg((1, 2, 3), (4, 5), z))
assert meijerg(((1, 2), (3,)), ((4,), (5,)), z) == \
meijerg(Tuple(1, 2), Tuple(3), Tuple(4), Tuple(5), z)
g = meijerg((1, 2), (3, 4, 5), (6, 7, 8, 9), (10, 11, 12, 13, 14), z)
assert g.an == Tuple(1, 2)
assert g.ap == Tuple(1, 2, 3, 4, 5)
assert g.aother == Tuple(3, 4, 5)
assert g.bm == Tuple(6, 7, 8, 9)
assert g.bq == Tuple(6, 7, 8, 9, 10, 11, 12, 13, 14)
assert g.bother == Tuple(10, 11, 12, 13, 14)
assert g.argument == z
assert g.nu == 75
assert g.delta == -1
assert g.is_commutative is True
assert meijerg([1, 2], [3], [4], [5], z).delta == Rational(1, 2)
# just a few checks to make sure that all arguments go where they should
assert tn(meijerg(Tuple(), Tuple(), Tuple(0), Tuple(), -z), exp(z), z)
assert tn(
sqrt(pi) *
meijerg(Tuple(), Tuple(), Tuple(0), Tuple(Rational(1, 2)), z**2 / 4),
cos(z), z)
assert tn(meijerg(Tuple(1, 1), Tuple(), Tuple(1), Tuple(0), z), log(1 + z),
z)
# test exceptions
pytest.raises(ValueError, lambda: meijerg(((3, 1), (2, )), ((oo, ),
(2, 0)), x))
pytest.raises(ValueError, lambda: meijerg(((3, 1), (2, )), ((1, ),
(2, 0)), x))
# differentiation
g = meijerg((randcplx(), ), (randcplx() + 2 * I, ), Tuple(),
(randcplx(), randcplx()), z)
assert td(g, z)
g = meijerg(Tuple(), (randcplx(), ), Tuple(), (randcplx(), randcplx()), z)
assert td(g, z)
g = meijerg(Tuple(), Tuple(), Tuple(randcplx()),
Tuple(randcplx(), randcplx()), z)
assert td(g, z)
a1, a2, b1, b2, c1, c2, d1, d2 = symbols('a1:3, b1:3, c1:3, d1:3')
assert meijerg((a1, a2), (b1, b2), (c1, c2), (d1, d2), z).diff(z) == \
(meijerg((a1 - 1, a2), (b1, b2), (c1, c2), (d1, d2), z)
+ (a1 - 1)*meijerg((a1, a2), (b1, b2), (c1, c2), (d1, d2), z))/z
assert meijerg([z, z], [], [], [], z).diff(z) == \
Derivative(meijerg([z, z], [], [], [], z), z)
# meijerg is unbranched wrt parameters
assert meijerg([polar_lift(a1)],
[polar_lift(a2)], [polar_lift(b1)], [polar_lift(b2)],
polar_lift(z)) == meijerg([a1], [a2], [b1], [b2],
polar_lift(z))
# integrand
assert meijerg([a], [b], [c], [d], z).integrand(s) == \
z**s*gamma(c - s)*gamma(-a + s + 1)/(gamma(b - s)*gamma(-d + s + 1))
assert meijerg([[], []], [[Rational(1, 2)], [0]], 1).is_number
assert not meijerg([[], []], [[x], [0]], 1).is_number
def test_sympyissue_8545():
eq = 1 - x - abs(1 - x)
ans = And(Lt(1, x), Lt(x, oo))
assert reduce_piecewise_inequality(eq, '<', x) == ans
eq = 1 - x - sqrt((1 - x)**2)
assert reduce_inequalities(eq < 0) == ans
def test_slow_general_univariate():
r = RootOf(x**5 - x**2 + 1, 0)
assert reduce_inequalities(sqrt(x) + 1/root(x, 3) > 1) == \
Or(And(Integer(0) < x, x < r**6), And(r**6 < x, x < oo))
def test_heurisch_hacking():
assert heurisch(sqrt(1 + 7*x**2), x, hints=[]) == \
x*sqrt(1 + 7*x**2)/2 + sqrt(7)*asinh(sqrt(7)*x)/14
assert heurisch(sqrt(1 - 7*x**2), x, hints=[]) == \
x*sqrt(1 - 7*x**2)/2 + sqrt(7)*asin(sqrt(7)*x)/14
assert heurisch(1/sqrt(1 + 7*x**2), x, hints=[]) == \
sqrt(7)*asinh(sqrt(7)*x)/7
assert heurisch(1/sqrt(1 - 7*x**2), x, hints=[]) == \
sqrt(7)*asin(sqrt(7)*x)/7
assert heurisch(exp(-7*x**2), x, hints=[]) == \
sqrt(7*pi)*erf(sqrt(7)*x)/14
assert heurisch(1/sqrt(9 - 4*x**2), x, hints=[]) == \
asin(2*x/3)/2
assert heurisch(1/sqrt(9 + 4*x**2), x, hints=[]) == \
asinh(2*x/3)/2
def test_pmint_erf():
f = exp(-x**2) * erf(x) / (erf(x)**3 - erf(x)**2 - erf(x) + 1)
g = sqrt(pi) * log(erf(x) - 1) / 8 - sqrt(pi) * log(erf(x) + 1) / 8 - sqrt(
pi) / (4 * erf(x) - 4)
assert ratsimp(heurisch(f, x)) == g
def test_reduce_inequalities_general():
assert reduce_inequalities(Ge(sqrt(2) * x,
1)) == And(sqrt(2) / 2 <= x, x < oo)
assert reduce_inequalities(PurePoly(x + 1, x) > 0) == And(
Integer(-1) < x, x < oo)
def test_RR():
# Make sure the algorithm does the right thing if the ring is RR. See
# issue 8685.
assert heurisch(sqrt(1 + 0.25*x**2), x, hints=[]) == \
0.5*x*sqrt(0.25*x**2 + 1) + 1.0*asinh(0.5*x)
def test_heurisch_symbolic_coeffs_1130():
y = Symbol('y')
assert heurisch_wrapper(1 / (x**2 + y), x) == Piecewise(
(-1 / x, Eq(y, 0)),
(-I * log(x - I * sqrt(y)) / (2 * sqrt(y)) + I * log(x + I * sqrt(y)) /
(2 * sqrt(y)), True))
y = Symbol('y', positive=True)
assert heurisch_wrapper(1 / (x**2 + y), x) in [
I / sqrt(y) * log(x + sqrt(-y)) / 2 -
I / sqrt(y) * log(x - sqrt(-y)) / 2, I * log(x + I * sqrt(y)) /
(2 * sqrt(y)) - I * log(x - I * sqrt(y)) / (2 * sqrt(y))
]
def test_heurisch_symbolic_coeffs():
assert heurisch(1 / (x + y), x) == log(x + y)
assert heurisch(1 / (x + sqrt(2)), x) == log(x + sqrt(2))
assert simplify(diff(heurisch(log(x + y + z), y), y)) == log(x + y + z)
def test_TR10i():
assert TR10i(cos(1)*cos(3) + sin(1)*sin(3)) == cos(2)
assert TR10i(cos(1)*cos(3) - sin(1)*sin(3)) == cos(4)
assert TR10i(cos(1)*sin(3) - sin(1)*cos(3)) == sin(2)
assert TR10i(cos(1)*sin(3) + sin(1)*cos(3)) == sin(4)
assert TR10i(cos(1)*sin(3) + sin(1)*cos(3) + 7) == sin(4) + 7
assert TR10i(cos(1)*sin(3) + sin(1)*cos(3) + cos(3)) == cos(3) + sin(4)
assert TR10i(2*cos(1)*sin(3) + 2*sin(1)*cos(3) + cos(3)) == \
2*sin(4) + cos(3)
assert TR10i(cos(2)*cos(3) + sin(2)*(cos(1)*sin(2) + cos(2)*sin(1))) == \
cos(1)
eq = (cos(2)*cos(3) + sin(2)*(
cos(1)*sin(2) + cos(2)*sin(1)))*cos(5) + sin(1)*sin(5)
assert TR10i(eq) == TR10i(eq.expand()) == cos(4)
assert TR10i(sqrt(2)*cos(x)*x + sqrt(6)*sin(x)*x) == \
2*sqrt(2)*x*sin(x + pi/6)
assert TR10i(cos(x)/sqrt(6) + sin(x)/sqrt(2) +
cos(x)/sqrt(6)/3 + sin(x)/sqrt(2)/3) == 4*sqrt(6)*sin(x + pi/6)/9
assert TR10i(cos(x)/sqrt(6) + sin(x)/sqrt(2) +
cos(y)/sqrt(6)/3 + sin(y)/sqrt(2)/3) == \
sqrt(6)*sin(x + pi/6)/3 + sqrt(6)*sin(y + pi/6)/9
assert TR10i(cos(x) + sqrt(3)*sin(x) + 2*sqrt(3)*cos(x + pi/6)) == 4*cos(x)
assert TR10i(cos(x) + sqrt(3)*sin(x) +
2*sqrt(3)*cos(x + pi/6) + 4*sin(x)) == 4*sqrt(2)*sin(x + pi/4)
assert TR10i(cos(2)*sin(3) + sin(2)*cos(4)) == \
sin(2)*cos(4) + sin(3)*cos(2)
A = Symbol('A', commutative=False)
assert TR10i(sqrt(2)*cos(x)*A + sqrt(6)*sin(x)*A) == \
2*sqrt(2)*sin(x + pi/6)*A
c = cos(x)
s = sin(x)
h = sin(y)
r = cos(y)
for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
for a in ((c*r, s*h), (c*h, s*r)): # explicit 2-args
args = zip(si, a)
ex = Add(*[Mul(*ai) for ai in args])
t = TR10i(ex)
assert not (ex - t.expand(trig=True) or t.is_Add)
c = cos(x)
s = sin(x)
h = sin(pi/6)
r = cos(pi/6)
for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
for a in ((c*r, s*h), (c*h, s*r)): # induced
args = zip(si, a)
ex = Add(*[Mul(*ai) for ai in args])
t = TR10i(ex)
assert not (ex - t.expand(trig=True) or t.is_Add)
def test_trig_split():
assert trig_split(cos(x), cos(y)) == (1, 1, 1, x, y, True)
assert trig_split(2*cos(x), -2*cos(y)) == (2, 1, -1, x, y, True)
assert trig_split(cos(x)*sin(y), cos(y)*sin(y)) == \
(sin(y), 1, 1, x, y, True)
assert trig_split(cos(x), -sqrt(3)*sin(x), two=True) == \
(2, 1, -1, x, pi/6, False)
assert trig_split(cos(x), sin(x), two=True) == \
(sqrt(2), 1, 1, x, pi/4, False)
assert trig_split(cos(x), -sin(x), two=True) == \
(sqrt(2), 1, -1, x, pi/4, False)
assert trig_split(sqrt(2)*cos(x), -sqrt(6)*sin(x), two=True) == \
(2*sqrt(2), 1, -1, x, pi/6, False)
assert trig_split(-sqrt(6)*cos(x), -sqrt(2)*sin(x), two=True) == \
(-2*sqrt(2), 1, 1, x, pi/3, False)
assert trig_split(cos(x)/sqrt(6), sin(x)/sqrt(2), two=True) == \
(sqrt(6)/3, 1, 1, x, pi/6, False)
assert trig_split(-sqrt(6)*cos(x)*sin(y),
-sqrt(2)*sin(x)*sin(y), two=True) == \
(-2*sqrt(2)*sin(y), 1, 1, x, pi/3, False)
assert trig_split(cos(x), sin(x)) is None
assert trig_split(cos(x), sin(z)) is None
assert trig_split(2*cos(x), -sin(x)) is None
assert trig_split(cos(x), -sqrt(3)*sin(x)) is None
assert trig_split(cos(x)*cos(y), sin(x)*sin(z)) is None
assert trig_split(cos(x)*cos(y), sin(x)*sin(y)) is None
assert trig_split(-sqrt(6)*cos(x), sqrt(2)*sin(x)*sin(y), two=True) is \
None
assert trig_split(sqrt(3)*sqrt(x), cos(3), two=True) is None
assert trig_split(sqrt(3)*root(x, 3), sin(3)*cos(2), two=True) is None
assert trig_split(cos(5)*cos(6), cos(7)*sin(5), two=True) is None
def test_RootOf___new__():
assert RootOf(x, 0) == 0
assert RootOf(x, -1) == 0
assert RootOf(x, S.Zero) == 0
assert RootOf(x - 1, 0) == 1
assert RootOf(x - 1, -1) == 1
assert RootOf(x + 1, 0) == -1
assert RootOf(x + 1, -1) == -1
assert RootOf(x**2 + 2 * x + 3, 0) == -1 - I * sqrt(2)
assert RootOf(x**2 + 2 * x + 3, 1) == -1 + I * sqrt(2)
assert RootOf(x**2 + 2 * x + 3, -1) == -1 + I * sqrt(2)
assert RootOf(x**2 + 2 * x + 3, -2) == -1 - I * sqrt(2)
r = RootOf(x**2 + 2 * x + 3, 0, radicals=False)
assert isinstance(r, RootOf) is True
r = RootOf(x**2 + 2 * x + 3, 1, radicals=False)
assert isinstance(r, RootOf) is True
r = RootOf(x**2 + 2 * x + 3, -1, radicals=False)
assert isinstance(r, RootOf) is True
r = RootOf(x**2 + 2 * x + 3, -2, radicals=False)
assert isinstance(r, RootOf) is True
assert RootOf((x - 1) * (x + 1), 0, radicals=False) == -1
assert RootOf((x - 1) * (x + 1), 1, radicals=False) == 1
assert RootOf((x - 1) * (x + 1), -1, radicals=False) == 1
assert RootOf((x - 1) * (x + 1), -2, radicals=False) == -1
assert RootOf((x - 1) * (x + 1), 0, radicals=True) == -1
assert RootOf((x - 1) * (x + 1), 1, radicals=True) == 1
assert RootOf((x - 1) * (x + 1), -1, radicals=True) == 1
assert RootOf((x - 1) * (x + 1), -2, radicals=True) == -1
assert RootOf((x - 1) * (x**3 + x + 3), 0) == RootOf(x**3 + x + 3, 0)
assert RootOf((x - 1) * (x**3 + x + 3), 1) == 1
assert RootOf((x - 1) * (x**3 + x + 3), 2) == RootOf(x**3 + x + 3, 1)
assert RootOf((x - 1) * (x**3 + x + 3), 3) == RootOf(x**3 + x + 3, 2)
assert RootOf((x - 1) * (x**3 + x + 3), -1) == RootOf(x**3 + x + 3, 2)
assert RootOf((x - 1) * (x**3 + x + 3), -2) == RootOf(x**3 + x + 3, 1)
assert RootOf((x - 1) * (x**3 + x + 3), -3) == 1
assert RootOf((x - 1) * (x**3 + x + 3), -4) == RootOf(x**3 + x + 3, 0)
assert RootOf(x**4 + 3 * x**3, 0) == -3
assert RootOf(x**4 + 3 * x**3, 1) == 0
assert RootOf(x**4 + 3 * x**3, 2) == 0
assert RootOf(x**4 + 3 * x**3, 3) == 0
pytest.raises(GeneratorsNeeded, lambda: RootOf(0, 0))
pytest.raises(GeneratorsNeeded, lambda: RootOf(1, 0))
pytest.raises(PolynomialError, lambda: RootOf(Poly(0, x), 0))
pytest.raises(PolynomialError, lambda: RootOf(Poly(1, x), 0))
pytest.raises(PolynomialError, lambda: RootOf(x - y, 0))
pytest.raises(NotImplementedError, lambda: RootOf(x**3 - x + sqrt(2), 0))
pytest.raises(NotImplementedError, lambda: RootOf(x**3 - x + I, 0))
pytest.raises(IndexError, lambda: RootOf(x**2 - 1, -4))
pytest.raises(IndexError, lambda: RootOf(x**2 - 1, -3))
pytest.raises(IndexError, lambda: RootOf(x**2 - 1, 2))
pytest.raises(IndexError, lambda: RootOf(x**2 - 1, 3))
pytest.raises(ValueError, lambda: RootOf(x**2 - 1, x))
assert RootOf(Poly(x - y, x), 0) == y
assert RootOf(Poly(x**2 - y, x), 0) == -sqrt(y)
assert RootOf(Poly(x**2 - y, x), 1) == sqrt(y)
assert RootOf(Poly(x**3 - y, x), 0) == y**Rational(1, 3)
assert RootOf(y * x**3 + y * x + 2 * y, x, 0) == -1
pytest.raises(NotImplementedError, lambda: RootOf(x**3 + x + 2 * y, x, 0))
assert RootOf(x**3 + x + 1, 0).is_commutative is True
def test_heurisch_radicals():
assert heurisch(1 / sqrt(x), x) == 2 * sqrt(x)
assert heurisch(1 / sqrt(x)**3, x) == -2 / sqrt(x)
assert heurisch(sqrt(x)**3, x) == 2 * sqrt(x)**5 / 5
assert heurisch(sin(x) * sqrt(cos(x)), x) == -2 * sqrt(cos(x))**3 / 3
y = Symbol('y')
assert heurisch(sin(y*sqrt(x)), x) == 2/y**2*sin(y*sqrt(x)) - \
2*sqrt(x)*cos(y*sqrt(x))/y
assert heurisch_wrapper(sin(y * sqrt(x)), x) == Piecewise(
(0, Eq(y, 0)),
(-2 * sqrt(x) * cos(sqrt(x) * y) / y + 2 * sin(sqrt(x) * y) / y**2,
True))
y = Symbol('y', positive=True)
assert heurisch_wrapper(sin(y*sqrt(x)), x) == 2/y**2*sin(y*sqrt(x)) - \
2*sqrt(x)*cos(y*sqrt(x))/y
def test_point3D():
p1 = Point3D(x1, x2, x3)
p2 = Point3D(y1, y2, y3)
p3 = Point3D(0, 0, 0)
p4 = Point3D(1, 1, 1)
p5 = Point3D(0, 1, 2)
assert p1 in p1
assert p1 not in p2
assert p2.y == y2
assert (p3 + p4) == p4
assert (p2 - p1) == Point3D(y1 - x1, y2 - x2, y3 - x3)
assert p4 * 5 == Point3D(5, 5, 5)
assert -p2 == Point3D(-y1, -y2, -y3)
assert Point(34.05, sqrt(3)) == Point(Rational(681, 20), sqrt(3))
assert Point3D.midpoint(p3, p4) == Point3D(half, half, half)
assert Point3D.midpoint(p1,
p4) == Point3D(half + half * x1, half + half * x2,
half + half * x3)
assert Point3D.midpoint(p2, p2) == p2
assert p2.midpoint(p2) == p2
assert Point3D.distance(p3, p4) == sqrt(3)
assert Point3D.distance(p1, p1) == 0
assert Point3D.distance(p3, p2) == sqrt(p2.x**2 + p2.y**2 + p2.z**2)
p1_1 = Point3D(x1, x1, x1)
p1_2 = Point3D(y2, y2, y2)
p1_3 = Point3D(x1 + 1, x1, x1)
# according to the description in the docs, points are collinear
# if they like on a single line. Thus a single point should always
# be collinear
assert Point3D.are_collinear(p3)
assert Point3D.are_collinear(p3, p4)
assert Point3D.are_collinear(p3, p4, p1_1, p1_2)
assert Point3D.are_collinear(p3, p4, p1_1, p1_3) is False
assert Point3D.are_collinear(p3, p3, p4, p5) is False
assert p3.intersection(Point3D(0, 0, 0)) == [p3]
assert p3.intersection(p4) == []
assert p4 * 5 == Point3D(5, 5, 5)
assert p4 / 5 == Point3D(0.2, 0.2, 0.2)
pytest.raises(ValueError, lambda: Point3D(0, 0, 0) + 10)
# Point differences should be simplified
assert Point3D(x*(x - 1), y, 2) - Point3D(x**2 - x, y + 1, 1) == \
Point3D(0, -1, 1)
a, b = Rational(1, 2), Rational(1, 3)
assert Point(a, b).evalf(2) == \
Point(a.evalf(2), b.evalf(2))
pytest.raises(ValueError, lambda: Point(1, 2) + 1)
# test transformations
p = Point3D(1, 1, 1)
assert p.scale(2, 3) == Point3D(2, 3, 1)
assert p.translate(1, 2) == Point3D(2, 3, 1)
assert p.translate(1) == Point3D(2, 1, 1)
assert p.translate(z=1) == Point3D(1, 1, 2)
assert p.translate(*p.args) == Point3D(2, 2, 2)
# Test __new__
assert Point3D(Point3D(1, 2, 3), 4, 5, evaluate=False) == Point3D(1, 2, 3)
# Test length property returns correctly
assert p.length == 0
assert p1_1.length == 0
assert p1_2.length == 0
# Test are_colinear type error
pytest.raises(TypeError, lambda: Point3D.are_collinear(p, x))
# Test are_coplanar
planar2 = Point3D(1, -1, 1)
planar3 = Point3D(-1, 1, 1)
assert Point3D.are_coplanar(p, planar2, planar3) is True
assert Point3D.are_coplanar(p, planar2, planar3, p3) is False
pytest.raises(ValueError, lambda: Point3D.are_coplanar(p, planar2))
planar2 = Point3D(1, 1, 2)
planar3 = Point3D(1, 1, 3)
pytest.raises(ValueError,
lambda: Point3D.are_coplanar(p, planar2, planar3))
# Test Intersection
assert planar2.intersection(Line3D(p, planar3)) == [Point3D(1, 1, 2)]
# Test Scale
assert planar2.scale(1, 1, 1) == planar2
assert planar2.scale(2, 2, 2, planar3) == Point3D(1, 1, 1)
assert planar2.scale(1, 1, 1, p3) == planar2
# Test Transform
identity = Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
assert p.transform(identity) == p
trans = Matrix([[1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1], [0, 0, 0, 1]])
assert p.transform(trans) == Point3D(2, 2, 2)
pytest.raises(ValueError, lambda: p.transform(p))
pytest.raises(ValueError, lambda: p.transform(Matrix([[1, 0], [0, 1]])))
# Test Equals
assert p.equals(x1) is False
# Test __sub__
p_2d = Point(0, 0)
pytest.raises(ValueError, lambda: (p - p_2d))
def test_lineintegral():
c = Curve([E**t + 1, E**t - 1], (t, 0, ln(2)))
assert line_integrate(x + y, c, [x, y]) == 3*sqrt(2)
def test_Point2D():
p1 = Point2D(1, 5)
p2 = Point2D(4, 2.5)
p3 = Point2D(6.1, 3.5)
assert p1.distance(p2) == sqrt(61) / 2
assert p2.distance(p3) == sqrt(541) / 10
def test_sqrtdenest2():
assert sqrtdenest(sqrt(16 - 2*r29 + 2*sqrt(55 - 10*r29))) == \
r5 + sqrt(11 - 2*r29)
e = sqrt(-r5 + sqrt(-2 * r29 + 2 * sqrt(-10 * r29 + 55) + 16))
assert sqrtdenest(e) == root(-2 * r29 + 11, 4)
r = sqrt(1 + r7)
assert sqrtdenest(sqrt(1 + r)) == sqrt(1 + r)
e = sqrt(((1 + sqrt(1 + 2 * sqrt(3 + r2 + r5)))**2).expand())
assert sqrtdenest(e) == 1 + sqrt(1 + 2 * sqrt(r2 + r5 + 3))
assert sqrtdenest(sqrt(5 * r3 +
6 * r2)) == sqrt(2) * root(3, 4) + root(27, 4)
assert sqrtdenest(sqrt(((1 + r5 + sqrt(1 + r3))**2).expand())) == \
1 + r5 + sqrt(1 + r3)
assert sqrtdenest(sqrt(((1 + r5 + r7 + sqrt(1 + r3))**2).expand())) == \
1 + sqrt(1 + r3) + r5 + r7
e = sqrt(((1 + cos(2) + cos(3) + sqrt(1 + r3))**2).expand())
assert sqrtdenest(e) == cos(3) + cos(2) + 1 + sqrt(1 + r3)
e = sqrt(-2 * r10 + 2 * r2 * sqrt(-2 * r10 + 11) + 14)
assert sqrtdenest(e) == sqrt(-2 * r10 - 2 * r2 + 4 * r5 + 14)
# check that the result is not more complicated than the input
z = sqrt(-2 * r29 + cos(2) + 2 * sqrt(-10 * r29 + 55) + 16)
assert sqrtdenest(z) == z
assert sqrtdenest(sqrt(r6 + sqrt(15))) == sqrt(r6 + sqrt(15))
z = sqrt(15 - 2 * sqrt(31) + 2 * sqrt(55 - 10 * r29))
assert sqrtdenest(z) == z
def test_direction_cosine():
p1 = Point3D(0, 0, 0)
p2 = Point3D(1, 1, 1)
assert p1.direction_cosine(Point3D(1, 0, 0)) == [1, 0, 0]
assert p1.direction_cosine(Point3D(0, 1, 0)) == [0, 1, 0]
assert p1.direction_cosine(Point3D(0, 0, pi)) == [0, 0, 1]
assert p1.direction_cosine(Point3D(5, 0, 0)) == [1, 0, 0]
assert p1.direction_cosine(Point3D(0, sqrt(3), 0)) == [0, 1, 0]
assert p1.direction_cosine(Point3D(0, 0, 5)) == [0, 0, 1]
assert p1.direction_cosine(Point3D(2.4, 2.4,
0)) == [sqrt(2) / 2,
sqrt(2) / 2, 0]
assert p1.direction_cosine(Point3D(
1, 1, 1)) == [sqrt(3) / 3, sqrt(3) / 3,
sqrt(3) / 3]
assert p1.direction_cosine(Point3D(
-12, 0, -15)) == [-4 * sqrt(41) / 41, 0, -5 * sqrt(41) / 41]
assert p2.direction_cosine(Point3D(
0, 0, 0)) == [-sqrt(3) / 3, -sqrt(3) / 3, -sqrt(3) / 3]
assert p2.direction_cosine(Point3D(1, 1, 12)) == [0, 0, 1]
assert p2.direction_cosine(Point3D(12, 1,
12)) == [sqrt(2) / 2, 0,
sqrt(2) / 2]
def test_sympyissue_5653():
assert sqrtdenest(sqrt(2 + sqrt(2 + sqrt(2)))) == sqrt(2 +
sqrt(2 + sqrt(2)))
def test_point():
p1 = Point(x1, x2)
p2 = Point(y1, y2)
p3 = Point(0, 0)
p4 = Point(1, 1)
p5 = Point(0, 1)
assert p1.origin == p3
assert p1.ambient_dimension == 2
assert p1 in p1
assert p1 not in p2
assert p2.y == y2
assert (p3 + p4) == p4
assert (p2 - p1) == Point(y1 - x1, y2 - x2)
assert p4 * 5 == Point(5, 5)
assert -p2 == Point(-y1, -y2)
pytest.raises(ValueError, lambda: Point(3, I))
pytest.raises(ValueError, lambda: Point(2 * I, I))
pytest.raises(ValueError, lambda: Point(3 + I, I))
assert Point(34.05, sqrt(3)) == Point(Rational(681, 20), sqrt(3))
assert Point.midpoint(p3, p4) == Point(half, half)
assert Point.midpoint(p1, p4) == Point(half + half * x1, half + half * x2)
assert Point.midpoint(p2, p2) == p2
assert p2.midpoint(p2) == p2
assert Point.distance(p3, p4) == sqrt(2)
assert Point.distance(p1, p1) == 0
assert Point.distance(p3, p2) == sqrt(p2.x**2 + p2.y**2)
p1_1 = Point(x1, x1)
p1_2 = Point(y2, y2)
p1_3 = Point(x1 + 1, x1)
assert Point.is_collinear() is False
assert Point.is_collinear(p3)
assert Point.is_collinear(p3, p4)
assert Point.is_collinear(p3, p4, p1_1, p1_2)
assert Point.is_collinear(p3, p4, p1_1, p1_3) is False
assert Point.is_collinear(p3, p3, p4, p5) is False
line = Line(Point(1, 0), slope=1)
pytest.raises(TypeError, lambda: Point.is_collinear(line))
pytest.raises(TypeError, lambda: p1_1.is_collinear(line))
assert p3.intersection(Point(0, 0)) == [p3]
assert p3.intersection(p4) == []
x_pos = Symbol('x', real=True, positive=True)
p2_1 = Point(x_pos, 0)
p2_2 = Point(0, x_pos)
p2_3 = Point(-x_pos, 0)
p2_4 = Point(0, -x_pos)
p2_5 = Point(x_pos, 5)
assert Point.is_concyclic(p2_1)
assert Point.is_concyclic(p2_1, p2_2)
assert Point.is_concyclic(p2_1, p2_2, p2_3, p2_4)
assert Point.is_concyclic(p2_1, p2_2, p2_3, p2_5) is False
assert Point.is_concyclic(p4, p4 * 2, p4 * 3) is False
pytest.raises(TypeError, lambda: Point.is_concyclic(p2_1, "123"))
assert p4.scale(2, 3) == Point(2, 3)
assert p3.scale(2, 3) == p3
assert p4.rotate(pi, Point(0.5, 0.5)) == p3
assert p1.__radd__(p2) == p1.midpoint(p2).scale(2, 2)
assert (-p3).__rsub__(p4) == p3.midpoint(p4).scale(2, 2)
assert p4 * 5 == Point(5, 5)
assert p4 / 5 == Point(0.2, 0.2)
pytest.raises(ValueError, lambda: Point(0, 0) + 10)
# Point differences should be simplified
assert Point(x * (x - 1), y) - Point(x**2 - x, y + 1) == Point(0, -1)
a, b = Rational(1, 2), Rational(1, 3)
assert Point(a, b).evalf(2) == \
Point(a.evalf(2), b.evalf(2))
pytest.raises(ValueError, lambda: Point(1, 2) + 1)
# test transformations
p = Point(1, 0)
assert p.rotate(pi / 2) == Point(0, 1)
assert p.rotate(pi / 2, p) == p
p = Point(1, 1)
assert p.scale(2, 3) == Point(2, 3)
assert p.translate(1, 2) == Point(2, 3)
assert p.translate(1) == Point(2, 1)
assert p.translate(y=1) == Point(1, 2)
assert p.translate(*p.args) == Point(2, 2)
# Check invalid input for transform
pytest.raises(ValueError, lambda: p3.transform(p3))
pytest.raises(ValueError, lambda: p.transform(Matrix([[1, 0], [0, 1]])))
def test_sympyissue_6343():
eq = -3 * x**2 / 2 - 45 * x / 4 + Rational(33, 2) > 0
assert reduce_inequalities(eq) == \
And(x < -Rational(15, 4) + sqrt(401)/4, -sqrt(401)/4 - Rational(15, 4) < x)
def test_powsimp():
x, y, z, n = symbols('x,y,z,n')
f = Function('f')
assert powsimp( 4**x * 2**(-x) * 2**(-x) ) == 1
assert powsimp( (-4)**x * (-2)**(-x) * 2**(-x) ) == 1
assert powsimp(
f(4**x * 2**(-x) * 2**(-x)) ) == f(4**x * 2**(-x) * 2**(-x))
assert powsimp( f(4**x * 2**(-x) * 2**(-x)), deep=True ) == f(1)
assert exp(x)*exp(y) == exp(x)*exp(y)
assert powsimp(exp(x)*exp(y)) == exp(x + y)
assert powsimp(exp(x)*exp(y)*2**x*2**y) == (2*E)**(x + y)
assert powsimp(exp(x)*exp(y)*2**x*2**y, combine='exp') == \
exp(x + y)*2**(x + y)
assert powsimp(exp(x)*exp(y)*exp(2)*sin(x) + sin(y) + 2**x*2**y) == \
exp(2 + x + y)*sin(x) + sin(y) + 2**(x + y)
assert powsimp(sin(exp(x)*exp(y))) == sin(exp(x)*exp(y))
assert powsimp(sin(exp(x)*exp(y)), deep=True) == sin(exp(x + y))
assert powsimp(x**2*x**y) == x**(2 + y)
# This should remain factored, because 'exp' with deep=True is supposed
# to act like old automatic exponent combining.
assert powsimp((1 + E*exp(E))*exp(-E), combine='exp', deep=True) == \
(1 + exp(1 + E))*exp(-E)
assert powsimp((1 + E*exp(E))*exp(-E), deep=True) == \
(1 + exp(1 + E))*exp(-E)
assert powsimp((1 + E*exp(E))*exp(-E)) == (1 + exp(1 + E))*exp(-E)
assert powsimp((1 + E*exp(E))*exp(-E), combine='exp') == \
(1 + exp(1 + E))*exp(-E)
assert powsimp((1 + E*exp(E))*exp(-E), combine='base') == \
(1 + E*exp(E))*exp(-E)
x, y = symbols('x,y', nonnegative=True)
n = Symbol('n', extended_real=True)
assert powsimp(y**n * (y/x)**(-n)) == x**n
assert powsimp(x**(x**(x*y)*y**(x*y))*y**(x**(x*y)*y**(x*y)), deep=True) \
== (x*y)**(x*y)**(x*y)
assert powsimp(2**(2**(2*x)*x), deep=False) == 2**(2**(2*x)*x)
assert powsimp(2**(2**(2*x)*x), deep=True) == 2**(x*4**x)
assert powsimp(
exp(-x + exp(-x)*exp(-x*log(x))), deep=False, combine='exp') == \
exp(-x + exp(-x)*exp(-x*log(x)))
assert powsimp(
exp(-x + exp(-x)*exp(-x*log(x))), deep=False, combine='exp') == \
exp(-x + exp(-x)*exp(-x*log(x)))
assert powsimp((x + y)/(3*z), deep=False, combine='exp') == (x + y)/(3*z)
assert powsimp((x/3 + y/3)/z, deep=True, combine='exp') == (x/3 + y/3)/z
assert powsimp(exp(x)/(1 + exp(x)*exp(y)), deep=True) == \
exp(x)/(1 + exp(x + y))
assert powsimp(x*y**(z**x*z**y), deep=True) == x*y**(z**(x + y))
assert powsimp((z**x*z**y)**x, deep=True) == (z**(x + y))**x
assert powsimp(x*(z**x*z**y)**x, deep=True) == x*(z**(x + y))**x
p = symbols('p', positive=True)
assert powsimp((1/x)**log(2)/x) == (1/x)**(1 + log(2))
assert powsimp((1/p)**log(2)/p) == p**(-1 - log(2))
# coefficient of exponent can only be simplified for positive bases
assert powsimp(2**(2*x)) == 4**x
assert powsimp((-1)**(2*x)) == (-1)**(2*x)
i = symbols('i', integer=True)
assert powsimp((-1)**(2*i)) == 1
assert powsimp((-1)**(-x)) != (-1)**x # could be 1/((-1)**x), but is not
# force=True overrides assumptions
assert powsimp((-1)**(2*x), force=True) == 1
# rational exponents allow combining of negative terms
w, n, m = symbols('w n m', negative=True)
e = i/a # not a rational exponent if `a` is unknown
ex = w**e*n**e*m**e
assert powsimp(ex) == m**(i/a)*n**(i/a)*w**(i/a)
e = i/3
ex = w**e*n**e*m**e
assert powsimp(ex) == (-1)**i*(-m*n*w)**(i/3)
e = (3 + i)/i
ex = w**e*n**e*m**e
assert powsimp(ex) == (-1)**(3*e)*(-m*n*w)**e
eq = x**(2*a/3)
# eq != (x**a)**(2/3) (try x = -1 and a = 3 to see)
assert powsimp(eq).exp == eq.exp == 2*a/3
# powdenest goes the other direction
assert powsimp(2**(2*x)) == 4**x
assert powsimp(exp(p/2)) == exp(p/2)
# issue sympy/sympy#6368
eq = Mul(*[sqrt(Dummy(imaginary=True)) for i in range(3)])
assert powsimp(eq) == eq and eq.is_Mul
assert all(powsimp(e) == e for e in (sqrt(x**a), sqrt(x**2)))
# issue sympy/sympy#8836
assert str( powsimp(exp(I*pi/3)*root(-1, 3)) ) == '(-1)**(2/3)'
def test_Domain_preprocess():
assert Domain.preprocess(ZZ) == ZZ
assert Domain.preprocess(QQ) == QQ
assert Domain.preprocess(EX) == EX
assert Domain.preprocess(FF(2)) == FF(2)
assert Domain.preprocess(ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
assert Domain.preprocess('Z') == ZZ
assert Domain.preprocess('Q') == QQ
assert Domain.preprocess('ZZ') == ZZ
assert Domain.preprocess('QQ') == QQ
assert Domain.preprocess('EX') == EX
assert Domain.preprocess('FF(23)') == FF(23)
assert Domain.preprocess('GF(23)') == GF(23)
pytest.raises(OptionError, lambda: Domain.preprocess('Z[]'))
assert Domain.preprocess('Z[x]') == ZZ.poly_ring(x)
assert Domain.preprocess('Q[x]') == QQ.poly_ring(x)
assert Domain.preprocess('ZZ[x]') == ZZ.poly_ring(x)
assert Domain.preprocess('QQ[x]') == QQ.poly_ring(x)
assert Domain.preprocess('Z[x,y]') == ZZ.poly_ring(x, y)
assert Domain.preprocess('Q[x,y]') == QQ.poly_ring(x, y)
assert Domain.preprocess('ZZ[x,y]') == ZZ.poly_ring(x, y)
assert Domain.preprocess('QQ[x,y]') == QQ.poly_ring(x, y)
pytest.raises(OptionError, lambda: Domain.preprocess('Z()'))
assert Domain.preprocess('Z(x)') == ZZ.frac_field(x)
assert Domain.preprocess('Q(x)') == QQ.frac_field(x)
assert Domain.preprocess('ZZ(x)') == ZZ.frac_field(x)
assert Domain.preprocess('QQ(x)') == QQ.frac_field(x)
assert Domain.preprocess('Z(x,y)') == ZZ.frac_field(x, y)
assert Domain.preprocess('Q(x,y)') == QQ.frac_field(x, y)
assert Domain.preprocess('ZZ(x,y)') == ZZ.frac_field(x, y)
assert Domain.preprocess('QQ(x,y)') == QQ.frac_field(x, y)
assert Domain.preprocess('Q<I>') == QQ.algebraic_field(I)
assert Domain.preprocess('QQ<I>') == QQ.algebraic_field(I)
assert Domain.preprocess('Q<sqrt(2), I>') == QQ.algebraic_field(sqrt(2), I)
assert Domain.preprocess('QQ<sqrt(2), I>') == QQ.algebraic_field(
sqrt(2), I)
pytest.raises(OptionError, lambda: Domain.preprocess('abc'))
assert Domain.preprocess('RR') == RR
assert Domain.preprocess('RR_5') == RealField(prec=5)
assert Domain.preprocess('CC') == CC
assert Domain.preprocess('CC_5') == ComplexField(prec=5)
pytest.raises(OptionError, lambda: Domain.preprocess(()))
def test_reduce_poly_inequalities_real_interval():
assert reduce_rational_inequalities([[Eq(x**2, 0)]], x,
relational=False) == FiniteSet(0)
assert reduce_rational_inequalities([[Le(x**2, 0)]], x,
relational=False) == FiniteSet(0)
assert reduce_rational_inequalities([[Lt(x**2, 0)]], x,
relational=False) == S.EmptySet
assert reduce_rational_inequalities(
[[Ge(x**2, 0)]], x, relational=False) == \
S.Reals if x.is_extended_real else Interval(-oo, oo)
assert reduce_rational_inequalities(
[[Gt(x**2, 0)]], x, relational=False) == \
FiniteSet(0).complement(S.Reals)
assert reduce_rational_inequalities(
[[Ne(x**2, 0)]], x, relational=False) == \
FiniteSet(0).complement(S.Reals)
assert reduce_rational_inequalities([[Eq(x**2, 1)]], x,
relational=False) == FiniteSet(-1, 1)
assert reduce_rational_inequalities([[Le(x**2, 1)]], x,
relational=False) == Interval(-1, 1)
assert reduce_rational_inequalities([[Lt(x**2, 1)]], x,
relational=False) == Interval(
-1, 1, True, True)
assert reduce_rational_inequalities(
[[Ge(x**2, 1)]], x, relational=False) == \
Union(Interval(-oo, -1, True), Interval(1, oo, False, True))
assert reduce_rational_inequalities(
[[Gt(x**2, 1)]], x, relational=False) == \
Interval(-1, 1).complement(S.Reals)
assert reduce_rational_inequalities(
[[Ne(x**2, 1)]], x, relational=False) == \
FiniteSet(-1, 1).complement(S.Reals)
assert reduce_rational_inequalities([[Eq(x**2, 1.0)]], x,
relational=False) == FiniteSet(
-1.0, 1.0).evalf()
assert reduce_rational_inequalities([[Le(x**2, 1.0)]], x,
relational=False) == Interval(
-1.0, 1.0)
assert reduce_rational_inequalities([[Lt(x**2, 1.0)]], x,
relational=False) == Interval(
-1.0, 1.0, True, True)
assert reduce_rational_inequalities(
[[Ge(x**2, 1.0)]], x, relational=False) == \
Union(Interval(-inf, -1.0, True), Interval(1.0, inf, False, True))
assert reduce_rational_inequalities(
[[Gt(x**2, 1.0)]], x, relational=False) == \
Union(Interval(-inf, -1.0, True, True),
Interval(1.0, inf, True, True))
assert reduce_rational_inequalities([[Ne(
x**2, 1.0)]], x, relational=False) == \
FiniteSet(-1.0, 1.0).complement(S.Reals)
s = sqrt(2)
assert reduce_rational_inequalities(
[[Lt(x**2 - 1, 0), Gt(x**2 - 1, 0)]], x,
relational=False) == S.EmptySet
assert reduce_rational_inequalities(
[[Le(x**2 - 1, 0), Ge(x**2 - 1, 0)]], x,
relational=False) == FiniteSet(-1, 1)
assert reduce_rational_inequalities(
[[Le(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, False, False),
Interval(1, s, False, False))
assert reduce_rational_inequalities(
[[Le(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, False, True),
Interval(1, s, True, False))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, True, False),
Interval(1, s, False, True))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, True, True),
Interval(1, s, True, True))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Ne(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, True, True),
Interval(-1, 1, True, True),
Interval(1, s, True, True))
# issue sympy/sympy#10237
assert reduce_rational_inequalities([[x < oo, x >= 0, -oo < x]],
x,
relational=False) == Interval(
0, oo, False, True)
assert reduce_rational_inequalities([[Eq(
(x + 1) / (x**2 - 1), 0)]], x) is false
