def test_RootOf_evalf():
real = RootOf(x**3 + x + 3, 0).evalf(n=20)
assert real.epsilon_eq(Float("-1.2134116627622296341"))
re, im = RootOf(x**3 + x + 3, 1).evalf(n=20).as_real_imag()
assert re.epsilon_eq( Float("0.60670583138111481707"))
assert im.epsilon_eq(-Float("1.45061224918844152650"))
re, im = RootOf(x**3 + x + 3, 2).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("0.60670583138111481707"))
assert im.epsilon_eq(Float("1.45061224918844152650"))
def test_RootOf_is_imaginary():
r = RootOf(x**4 + 4 * x**2 + 1, 1)
i = r._get_interval()
assert r.is_imaginary and i.ax * i.bx <= 0
def test_CRootOf_evalf():
real = rootof(x**3 + x + 3, 0).evalf(n=20)
assert real.epsilon_eq(Float("-1.2134116627622296341"))
re, im = rootof(x**3 + x + 3, 1).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("0.60670583138111481707"))
assert im.epsilon_eq(-Float("1.45061224918844152650"))
re, im = rootof(x**3 + x + 3, 2).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("0.60670583138111481707"))
assert im.epsilon_eq(Float("1.45061224918844152650"))
p = legendre_poly(4, x, polys=True)
roots = [str(r.n(17)) for r in p.real_roots()]
# magnitudes are given by
# sqrt(3/S(7) - 2*sqrt(6/S(5))/7)
# and
# sqrt(3/S(7) + 2*sqrt(6/S(5))/7)
assert roots == [
"-0.86113631159405258",
"-0.33998104358485626",
"0.33998104358485626",
"0.86113631159405258",
]
re = rootof(x**5 - 5 * x + 12, 0).evalf(n=20)
assert re.epsilon_eq(Float("-1.84208596619025438271"))
re, im = rootof(x**5 - 5 * x + 12, 1).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("-0.351854240827371999559"))
assert im.epsilon_eq(Float("-1.709561043370328882010"))
re, im = rootof(x**5 - 5 * x + 12, 2).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("-0.351854240827371999559"))
assert im.epsilon_eq(Float("+1.709561043370328882010"))
re, im = rootof(x**5 - 5 * x + 12, 3).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("+1.272897223922499190910"))
assert im.epsilon_eq(Float("-0.719798681483861386681"))
re, im = rootof(x**5 - 5 * x + 12, 4).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("+1.272897223922499190910"))
assert im.epsilon_eq(Float("+0.719798681483861386681"))
# issue 6393
assert str(rootof(x**5 + 2 * x**4 + x**3 - 68719476736, 0).n(3)) == '147.'
eq = (531441 * x**11 + 3857868 * x**10 + 13730229 * x**9 +
32597882 * x**8 + 55077472 * x**7 + 60452000 * x**6 +
32172064 * x**5 - 4383808 * x**4 - 11942912 * x**3 - 1506304 * x**2 +
1453312 * x + 512)
a, b = rootof(eq, 1).n(2).as_real_imag()
c, d = rootof(eq, 2).n(2).as_real_imag()
assert a == c
assert b < d
assert b == -d
# issue 6451
r = rootof(legendre_poly(64, x), 7)
assert r.n(2) == r.n(100).n(2)
# issue 9019
r0 = rootof(x**2 + 1, 0, radicals=False)
r1 = rootof(x**2 + 1, 1, radicals=False)
assert r0.n(4) == -1.0 * I
assert r1.n(4) == 1.0 * I
# make sure verification is used in case a max/min traps the "root"
assert str(rootof(4 * x**5 + 16 * x**3 + 12 * x**2 + 7,
0).n(3)) == '-0.976'
# watch out for UnboundLocalError
c = CRootOf(90720 * x**6 - 4032 * x**4 + 84 * x**2 - 1, 0)
assert c._eval_evalf(2) # doesn't fail
# watch out for imaginary parts that don't want to evaluate
assert str(
RootOf(
x**16 + 32 * x**14 + 508 * x**12 + 5440 * x**10 + 39510 * x**8 +
204320 * x**6 + 755548 * x**4 + 1434496 * x**2 + 877969,
10).n(2)) == '-3.4*I'
assert abs(RootOf(x**4 + 10 * x**2 + 1, 0).n(2)) < 0.4
# check reset and args
r = [RootOf(x**3 + x + 3, i) for i in range(3)]
r[0]._reset()
for ri in r:
i = ri._get_interval()
ri.n(2)
assert i != ri._get_interval()
ri._reset()
assert i == ri._get_interval()
assert i == i.func(*i.args)
def test_minpoly_compose():
# issue 6868
eq = S('''
-1/(800*sqrt(-1/240 + 1/(18000*(-1/17280000 +
sqrt(15)*I/28800000)**(1/3)) + 2*(-1/17280000 +
sqrt(15)*I/28800000)**(1/3)))''')
mp = minimal_polynomial(eq + 3, x)
assert mp == 8000*x**2 - 48000*x + 71999
# issue 5888
assert minimal_polynomial(exp(I*pi/8), x) == x**8 + 1
mp = minimal_polynomial(sin(pi/7) + sqrt(2), x)
assert mp == 4096*x**12 - 63488*x**10 + 351488*x**8 - 826496*x**6 + \
770912*x**4 - 268432*x**2 + 28561
mp = minimal_polynomial(cos(pi/7) + sqrt(2), x)
assert mp == 64*x**6 - 64*x**5 - 432*x**4 + 304*x**3 + 712*x**2 - \
232*x - 239
mp = minimal_polynomial(exp(I*pi/7) + sqrt(2), x)
assert mp == x**12 - 2*x**11 - 9*x**10 + 16*x**9 + 43*x**8 - 70*x**7 - 97*x**6 + 126*x**5 + 211*x**4 - 212*x**3 - 37*x**2 + 142*x + 127
mp = minimal_polynomial(sin(pi/7) + sqrt(2), x)
assert mp == 4096*x**12 - 63488*x**10 + 351488*x**8 - 826496*x**6 + \
770912*x**4 - 268432*x**2 + 28561
mp = minimal_polynomial(cos(pi/7) + sqrt(2), x)
assert mp == 64*x**6 - 64*x**5 - 432*x**4 + 304*x**3 + 712*x**2 - \
232*x - 239
mp = minimal_polynomial(exp(I*pi/7) + sqrt(2), x)
assert mp == x**12 - 2*x**11 - 9*x**10 + 16*x**9 + 43*x**8 - 70*x**7 - 97*x**6 + 126*x**5 + 211*x**4 - 212*x**3 - 37*x**2 + 142*x + 127
mp = minimal_polynomial(exp(2*I*pi/7), x)
assert mp == x**6 + x**5 + x**4 + x**3 + x**2 + x + 1
mp = minimal_polynomial(exp(2*I*pi/15), x)
assert mp == x**8 - x**7 + x**5 - x**4 + x**3 - x + 1
mp = minimal_polynomial(cos(2*pi/7), x)
assert mp == 8*x**3 + 4*x**2 - 4*x - 1
mp = minimal_polynomial(sin(2*pi/7), x)
ex = (5*cos(2*pi/7) - 7)/(9*cos(pi/7) - 5*cos(3*pi/7))
mp = minimal_polynomial(ex, x)
assert mp == x**3 + 2*x**2 - x - 1
assert minimal_polynomial(-1/(2*cos(pi/7)), x) == x**3 + 2*x**2 - x - 1
assert minimal_polynomial(sin(2*pi/15), x) == \
256*x**8 - 448*x**6 + 224*x**4 - 32*x**2 + 1
assert minimal_polynomial(sin(5*pi/14), x) == 8*x**3 - 4*x**2 - 4*x + 1
assert minimal_polynomial(cos(pi/15), x) == 16*x**4 + 8*x**3 - 16*x**2 - 8*x + 1
ex = RootOf(x**3 +x*4 + 1, 0)
mp = minimal_polynomial(ex, x)
assert mp == x**3 + 4*x + 1
mp = minimal_polynomial(ex + 1, x)
assert mp == x**3 - 3*x**2 + 7*x - 4
assert minimal_polynomial(exp(I*pi/3), x) == x**2 - x + 1
assert minimal_polynomial(exp(I*pi/4), x) == x**4 + 1
assert minimal_polynomial(exp(I*pi/6), x) == x**4 - x**2 + 1
assert minimal_polynomial(exp(I*pi/9), x) == x**6 - x**3 + 1
assert minimal_polynomial(exp(I*pi/10), x) == x**8 - x**6 + x**4 - x**2 + 1
assert minimal_polynomial(sin(pi/9), x) == 64*x**6 - 96*x**4 + 36*x**2 - 3
assert minimal_polynomial(sin(pi/11), x) == 1024*x**10 - 2816*x**8 + \
2816*x**6 - 1232*x**4 + 220*x**2 - 11
ex = 2**Rational(1, 3)*exp(Rational(2, 3)*I*pi)
assert minimal_polynomial(ex, x) == x**3 - 2
raises(NotAlgebraic, lambda: minimal_polynomial(cos(pi*sqrt(2)), x))
raises(NotAlgebraic, lambda: minimal_polynomial(sin(pi*sqrt(2)), x))
raises(NotAlgebraic, lambda: minimal_polynomial(exp(I*pi*sqrt(2)), x))
# issue 5934
ex = 1/(-36000 - 7200*sqrt(5) + (12*sqrt(10)*sqrt(sqrt(5) + 5) +
24*sqrt(10)*sqrt(-sqrt(5) + 5))**2) + 1
raises(ZeroDivisionError, lambda: minimal_polynomial(ex, x))
ex = sqrt(1 + 2**Rational(1,3)) + sqrt(1 + 2**Rational(1,4)) + sqrt(2)
mp = minimal_polynomial(ex, x)
assert degree(mp) == 48 and mp.subs({x:0}) == -16630256576
def test_RootOf_is_complex():
assert RootOf(x**3 + x + 3, 0).is_complex == False
assert RootOf(x**3 + x + 3, 1).is_complex == True
assert RootOf(x**3 + x + 3, 2).is_complex == True
def test_RootOf_evalf():
real = RootOf(x**3 + x + 3, 0).evalf(n=20)
assert real.epsilon_eq(Float("-1.2134116627622296341"))
re, im = RootOf(x**3 + x + 3, 1).evalf(n=20).as_real_imag()
assert re.epsilon_eq( Float("0.60670583138111481707"))
assert im.epsilon_eq(-Float("1.45061224918844152650"))
re, im = RootOf(x**3 + x + 3, 2).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("0.60670583138111481707"))
assert im.epsilon_eq(Float("1.45061224918844152650"))
p = legendre_poly(4, x, polys=True)
roots = [str(r.n(17)) for r in p.real_roots()]
assert roots == [
"-0.86113631159405258",
"-0.33998104358485626",
"0.33998104358485626",
"0.86113631159405258",
]
re = RootOf(x**5 - 5*x + 12, 0).evalf(n=20)
assert re.epsilon_eq(Float("-1.84208596619025438271"))
re, im = RootOf(x**5 - 5*x + 12, 1).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("-0.351854240827371999559"))
assert im.epsilon_eq(Float("-1.709561043370328882010"))
re, im = RootOf(x**5 - 5*x + 12, 2).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("-0.351854240827371999559"))
assert im.epsilon_eq(Float("+1.709561043370328882010"))
re, im = RootOf(x**5 - 5*x + 12, 3).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("+1.272897223922499190910"))
assert im.epsilon_eq(Float("-0.719798681483861386681"))
re, im = RootOf(x**5 - 5*x + 12, 4).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("+1.272897223922499190910"))
assert im.epsilon_eq(Float("+0.719798681483861386681"))
# issue 6393
assert str(RootOf(x**5 + 2*x**4 + x**3 - 68719476736, 0).n(3)) == '147.'
eq = (531441*x**11 + 3857868*x**10 + 13730229*x**9 + 32597882*x**8 +
55077472*x**7 + 60452000*x**6 + 32172064*x**5 - 4383808*x**4 -
11942912*x**3 - 1506304*x**2 + 1453312*x + 512)
a, b = RootOf(eq, 1).n(2).as_real_imag()
c, d = RootOf(eq, 2).n(2).as_real_imag()
assert a == c
assert b < d
assert b == -d
# issue 6451
r = RootOf(legendre_poly(64, x), 7)
assert r.n(2) == r.n(100).n(2)
# issue 8617
ans = [w.n(2) for w in solve(x**3 - x - 4)]
assert RootOf(exp(x)**3 - exp(x) - 4, 0).n(2) in ans
# make sure verification is used in case a max/min traps the "root"
assert str(RootOf(4*x**5 + 16*x**3 + 12*x**2 + 7, 0).n(3)) == '-0.976'
def test_RootOf_is_real():
assert RootOf(x**3 + x + 3, 0).is_real == True
assert RootOf(x**3 + x + 3, 1).is_real == False
assert RootOf(x**3 + x + 3, 2).is_real == False
def test_RootOf_free_symbols():
assert RootOf(x**3 + x + 3, 0).free_symbols == set()
def test_RootOf_subs():
assert RootOf(x**3 + x + 1, 0).subs(x, y) == RootOf(y**3 + y + 1, 0)
def test_RootOf_is_complex():
assert RootOf(x**3 + x + 3, 0).is_complex is True
def test_RootOf_issue_10092():
x = Symbol('x', real=True)
eq = x**3 - 17 * x**2 + 81 * x - 118
r = RootOf(eq, 0)
assert (x < r).subs(x, r) is S.false
def test_issue_7876():
l1 = Poly(x**6 - x + 1, x).all_roots()
l2 = [RootOf(x**6 - x + 1, i) for i in range(6)]
assert frozenset(l1) == frozenset(l2)
def test_sympy__polys__rootoftools__RootOf():
from sympy.polys.rootoftools import RootOf
assert _test_args(RootOf(x**3 + x + 1, 0))
def test_RootOf_evalf():
real = RootOf(x**3 + x + 3, 0).evalf(n=20)
assert real.epsilon_eq(Float("-1.2134116627622296341"))
re, im = RootOf(x**3 + x + 3, 1).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("0.60670583138111481707"))
assert im.epsilon_eq(-Float("1.45061224918844152650"))
re, im = RootOf(x**3 + x + 3, 2).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("0.60670583138111481707"))
assert im.epsilon_eq(Float("1.45061224918844152650"))
p = legendre_poly(4, x, polys=True)
roots = [str(r.n(17)) for r in p.real_roots()]
assert roots == [
"-0.86113631159405258",
"-0.33998104358485626",
"0.33998104358485626",
"0.86113631159405258",
]
re = RootOf(x**5 - 5 * x + 12, 0).evalf(n=20)
assert re.epsilon_eq(Float("-1.84208596619025438271"))
re, im = RootOf(x**5 - 5 * x + 12, 1).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("-0.351854240827371999559"))
assert im.epsilon_eq(Float("-1.709561043370328882010"))
re, im = RootOf(x**5 - 5 * x + 12, 2).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("-0.351854240827371999559"))
assert im.epsilon_eq(Float("+1.709561043370328882010"))
re, im = RootOf(x**5 - 5 * x + 12, 3).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("+1.272897223922499190910"))
assert im.epsilon_eq(Float("-0.719798681483861386681"))
re, im = RootOf(x**5 - 5 * x + 12, 4).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("+1.272897223922499190910"))
assert im.epsilon_eq(Float("+0.719798681483861386681"))
# issue 6393
assert str(RootOf(x**5 + 2 * x**4 + x**3 - 68719476736, 0).n(3)) == '147.'
eq = (531441 * x**11 + 3857868 * x**10 + 13730229 * x**9 +
32597882 * x**8 + 55077472 * x**7 + 60452000 * x**6 +
32172064 * x**5 - 4383808 * x**4 - 11942912 * x**3 - 1506304 * x**2 +
1453312 * x + 512)
a, b = RootOf(eq, 1).n(2).as_real_imag()
c, d = RootOf(eq, 2).n(2).as_real_imag()
assert a == c
assert b < d
assert b == -d
# issue 6451
r = RootOf(legendre_poly(64, x), 7)
assert r.n(2) == r.n(100).n(2)
# issue 8617
ans = [w.n(2) for w in solve(x**3 - x - 4)]
assert RootOf(exp(x)**3 - exp(x) - 4, 0).n(2) in ans
# make sure verification is used in case a max/min traps the "root"
assert str(RootOf(4 * x**5 + 16 * x**3 + 12 * x**2 + 7,
0).n(3)) == '-0.976'
def test_slow_general_univariate():
r = RootOf(x**5 - x**2 + 1, 0)
assert solve(sqrt(x) + 1/root(x, 3) > 1) == \
Or(And(S(0) < x, x < r**6), And(r**6 < x, x < oo))
def test_issue_3693():
assert solve(x*(x-1)**2*(x+1)*(x**6-x+1)) == [
-1, 0, 1, RootOf(x**6 - x + 1, 0), RootOf(x**6 - x + 1, 1),
RootOf(x**6 - x + 1, 2), RootOf(x**6 - x + 1, 3), RootOf(x**6 - x + 1, 4),
RootOf(x**6 - x + 1, 5)]
def test_RootOf_diff():
assert RootOf(x**3 + x + 1, 0).diff(x) == 0
assert RootOf(x**3 + x + 1, 0).diff(y) == 0
def test_RootOf___eq__():
assert (RootOf(x**3 + x + 3, 0) == RootOf(x**3 + x + 3, 0)) == True
assert (RootOf(x**3 + x + 3, 0) == RootOf(x**3 + x + 3, 1)) == False
assert (RootOf(x**3 + x + 3, 1) == RootOf(x**3 + x + 3, 1)) == True
assert (RootOf(x**3 + x + 3, 1) == RootOf(x**3 + x + 3, 2)) == False
assert (RootOf(x**3 + x + 3, 2) == RootOf(x**3 + x + 3, 2)) == True
assert (RootOf(x**3 + x + 3, 0) == RootOf(y**3 + y + 3, 0)) == True
assert (RootOf(x**3 + x + 3, 0) == RootOf(y**3 + y + 3, 1)) == False
assert (RootOf(x**3 + x + 3, 1) == RootOf(y**3 + y + 3, 1)) == True
assert (RootOf(x**3 + x + 3, 1) == RootOf(y**3 + y + 3, 2)) == False
assert (RootOf(x**3 + x + 3, 2) == RootOf(y**3 + y + 3, 2)) == True
def test_RootOf_evalf():
real = RootOf(x**3 + x + 3, 0).evalf(n=20)
assert real.epsilon_eq(Float("-1.2134116627622296341"))
re, im = RootOf(x**3 + x + 3, 1).evalf(n=20).as_real_imag()
assert re.epsilon_eq( Float("0.60670583138111481707"))
assert im.epsilon_eq(-Float("1.45061224918844152650"))
re, im = RootOf(x**3 + x + 3, 2).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("0.60670583138111481707"))
assert im.epsilon_eq(Float("1.45061224918844152650"))
p = legendre_poly(4, x, polys=True)
roots = [str(r.n(17)) for r in p.real_roots()]
assert roots == [
"-0.86113631159405258",
"-0.33998104358485626",
"0.33998104358485626",
"0.86113631159405258",
]
re = RootOf(x**5 - 5*x + 12, 0).evalf(n=20)
assert re.epsilon_eq(Float("-1.84208596619025438271"))
re, im = RootOf(x**5 - 5*x + 12, 1).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("-0.351854240827371999559"))
assert im.epsilon_eq(Float("-1.709561043370328882010"))
re, im = RootOf(x**5 - 5*x + 12, 2).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("-0.351854240827371999559"))
assert im.epsilon_eq(Float("+1.709561043370328882010"))
re, im = RootOf(x**5 - 5*x + 12, 3).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("+1.272897223922499190910"))
assert im.epsilon_eq(Float("-0.719798681483861386681"))
re, im = RootOf(x**5 - 5*x + 12, 4).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("+1.272897223922499190910"))
assert im.epsilon_eq(Float("+0.719798681483861386681"))
def test_RootOf_real_roots():
assert Poly(x**5 + x + 1).real_roots() == [RootOf(x**3 - x**2 + 1, 0)]
assert Poly(x**5 + x + 1).real_roots(radicals=False) == [RootOf(
x**3 - x**2 + 1, 0)]
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
raises(GeneratorsNeeded, lambda: RootOf(0, 0))
raises(GeneratorsNeeded, lambda: RootOf(1, 0))
raises(PolynomialError, lambda: RootOf(Poly(0, x), 0))
raises(PolynomialError, lambda: RootOf(Poly(1, x), 0))
raises(PolynomialError, lambda: RootOf(x - y, 0))
raises(NotImplementedError, lambda: RootOf(x**3 - x + sqrt(2), 0))
raises(NotImplementedError, lambda: RootOf(x**3 - x + I, 0))
raises(IndexError, lambda: RootOf(x**2 - 1, -4))
raises(IndexError, lambda: RootOf(x**2 - 1, -3))
raises(IndexError, lambda: RootOf(x**2 - 1, 2))
raises(IndexError, lambda: RootOf(x**2 - 1, 3))
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
raises(NotImplementedError, lambda: RootOf(x**3 + x + 2*y, x, 0))
assert RootOf(x**3 + x + 1, 0).is_commutative is True
def test_RootOf_evalf():
real = RootOf(x**3 + x + 3, 0).evalf(n=20)
assert real.epsilon_eq(Float("-1.2134116627622296341"))
re, im = RootOf(x**3 + x + 3, 1).evalf(n=20).as_real_imag()
assert re.epsilon_eq( Float("0.60670583138111481707"))
assert im.epsilon_eq(-Float("1.45061224918844152650"))
re, im = RootOf(x**3 + x + 3, 2).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("0.60670583138111481707"))
assert im.epsilon_eq(Float("1.45061224918844152650"))
p = legendre_poly(4, x, polys=True)
roots = [str(r.n(17)) for r in p.real_roots()]
assert roots == [
"-0.86113631159405258",
"-0.33998104358485626",
"0.33998104358485626",
"0.86113631159405258",
]
re = RootOf(x**5 - 5*x + 12, 0).evalf(n=20)
assert re.epsilon_eq(Float("-1.84208596619025438271"))
re, im = RootOf(x**5 - 5*x + 12, 1).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("-0.351854240827371999559"))
assert im.epsilon_eq(Float("-1.709561043370328882010"))
re, im = RootOf(x**5 - 5*x + 12, 2).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("-0.351854240827371999559"))
assert im.epsilon_eq(Float("+1.709561043370328882010"))
re, im = RootOf(x**5 - 5*x + 12, 3).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("+1.272897223922499190910"))
assert im.epsilon_eq(Float("-0.719798681483861386681"))
re, im = RootOf(x**5 - 5*x + 12, 4).evalf(n=20).as_real_imag()
assert re.epsilon_eq(Float("+1.272897223922499190910"))
assert im.epsilon_eq(Float("+0.719798681483861386681"))
def test_RootOf___new___indices():
f = x**3 + x + 3
r0 = RootOf(f, 0)
r1 = RootOf(f, 1)
r2 = RootOf(f, 2)
assert RootOf(f) == [r0]
assert RootOf(f, (0, )) == [r0]
assert RootOf(f, (0, 1)) == [r0, r1]
assert RootOf(f, (0, 1, 2)) == [r0, r1, r2]
assert RootOf(f, (-3, )) == [r0]
assert RootOf(f, (-3, -2)) == [r0, r1]
assert RootOf(f, (-3, -2, -1)) == [r0, r1, r2]
assert RootOf(f, True) == [r0, r1, r2]