def test_eval_approx_relative():
CRootOf.clear_cache()
t = [CRootOf(x**3 + 10 * x + 1, i) for i in range(3)]
assert [i.eval_rational(1e-1) for i in t] == [
Rational(-21, 220),
Rational(15, 256) - I * Rational(805, 256),
Rational(15, 256) + I * Rational(805, 256)
]
t[0]._reset()
assert [i.eval_rational(1e-1, 1e-4) for i in t] == [
Rational(-21, 220),
Rational(3275, 65536) - I * Rational(414645, 131072),
Rational(3275, 65536) + I * Rational(414645, 131072)
]
assert S(t[0]._get_interval().dx) < 1e-1
assert S(t[1]._get_interval().dx) < 1e-1
assert S(t[1]._get_interval().dy) < 1e-4
assert S(t[2]._get_interval().dx) < 1e-1
assert S(t[2]._get_interval().dy) < 1e-4
t[0]._reset()
assert [i.eval_rational(1e-4, 1e-4) for i in t] == [
Rational(-2001, 20020),
Rational(6545, 131072) - I * Rational(414645, 131072),
Rational(6545, 131072) + I * Rational(414645, 131072)
]
assert S(t[0]._get_interval().dx) < 1e-4
assert S(t[1]._get_interval().dx) < 1e-4
assert S(t[1]._get_interval().dy) < 1e-4
assert S(t[2]._get_interval().dx) < 1e-4
assert S(t[2]._get_interval().dy) < 1e-4
# in the following, the actual relative precision is
# less than tested, but it should never be greater
t[0]._reset()
assert [i.eval_rational(n=2) for i in t] == [
Rational(-202201, 2024022),
Rational(104755, 2097152) - I * Rational(6634255, 2097152),
Rational(104755, 2097152) + I * Rational(6634255, 2097152)
]
assert abs(S(t[0]._get_interval().dx) / t[0]) < 1e-2
assert abs(S(t[1]._get_interval().dx) / t[1]).n() < 1e-2
assert abs(S(t[1]._get_interval().dy) / t[1]).n() < 1e-2
assert abs(S(t[2]._get_interval().dx) / t[2]).n() < 1e-2
assert abs(S(t[2]._get_interval().dy) / t[2]).n() < 1e-2
t[0]._reset()
assert [i.eval_rational(n=3) for i in t] == [
Rational(-202201, 2024022),
Rational(1676045, 33554432) - I * Rational(106148135, 33554432),
Rational(1676045, 33554432) + I * Rational(106148135, 33554432)
]
assert abs(S(t[0]._get_interval().dx) / t[0]) < 1e-3
assert abs(S(t[1]._get_interval().dx) / t[1]).n() < 1e-3
assert abs(S(t[1]._get_interval().dy) / t[1]).n() < 1e-3
assert abs(S(t[2]._get_interval().dx) / t[2]).n() < 1e-3
assert abs(S(t[2]._get_interval().dy) / t[2]).n() < 1e-3
t[0]._reset()
a = [i.eval_approx(2) for i in t]
assert [str(i) for i in a] == ['-0.10', '0.05 - 3.2*I', '0.05 + 3.2*I']
assert all(abs(((a[i] - t[i]) / t[i]).n()) < 1e-2 for i in range(len(a)))
def test_eval_approx_relative():
CRootOf.clear_cache()
t = [CRootOf(x**3 + 10 * x + 1, i) for i in range(3)]
assert [i.eval_rational(1e-1) for i in t] == [
-S(21) / 220,
S(15) / 256 - 805 * I / 256,
S(15) / 256 + 805 * I / 256
]
t[0]._reset()
assert [i.eval_rational(1e-1, 1e-4) for i in t] == [
-S(21) / 220,
S(3275) / 65536 - 414645 * I / 131072,
S(3275) / 65536 + 414645 * I / 131072
]
assert S(t[0]._get_interval().dx) < 1e-1
assert S(t[1]._get_interval().dx) < 1e-1
assert S(t[1]._get_interval().dy) < 1e-4
assert S(t[2]._get_interval().dx) < 1e-1
assert S(t[2]._get_interval().dy) < 1e-4
t[0]._reset()
assert [i.eval_rational(1e-4, 1e-4) for i in t] == [
-S(2001) / 20020,
S(6545) / 131072 - 414645 * I / 131072,
S(6545) / 131072 + 414645 * I / 131072
]
assert S(t[0]._get_interval().dx) < 1e-4
assert S(t[1]._get_interval().dx) < 1e-4
assert S(t[1]._get_interval().dy) < 1e-4
assert S(t[2]._get_interval().dx) < 1e-4
assert S(t[2]._get_interval().dy) < 1e-4
# in the following, the actual relative precision is
# less than tested, but it should never be greater
t[0]._reset()
assert [i.eval_rational(n=2) for i in t] == [
-S(202201) / 2024022,
S(104755) / 2097152 - 6634255 * I / 2097152,
S(104755) / 2097152 + 6634255 * I / 2097152
]
assert abs(S(t[0]._get_interval().dx) / t[0]) < 1e-2
assert abs(S(t[1]._get_interval().dx) / t[1]).n() < 1e-2
assert abs(S(t[1]._get_interval().dy) / t[1]).n() < 1e-2
assert abs(S(t[2]._get_interval().dx) / t[2]).n() < 1e-2
assert abs(S(t[2]._get_interval().dy) / t[2]).n() < 1e-2
t[0]._reset()
assert [i.eval_rational(n=3) for i in t] == [
-S(202201) / 2024022,
S(1676045) / 33554432 - 106148135 * I / 33554432,
S(1676045) / 33554432 + 106148135 * I / 33554432
]
assert abs(S(t[0]._get_interval().dx) / t[0]) < 1e-3
assert abs(S(t[1]._get_interval().dx) / t[1]).n() < 1e-3
assert abs(S(t[1]._get_interval().dy) / t[1]).n() < 1e-3
assert abs(S(t[2]._get_interval().dx) / t[2]).n() < 1e-3
assert abs(S(t[2]._get_interval().dy) / t[2]).n() < 1e-3
t[0]._reset()
a = [i.eval_approx(2) for i in t]
assert [str(i) for i in a] == ['-0.10', '0.05 - 3.2*I', '0.05 + 3.2*I']
assert all(abs(((a[i] - t[i]) / t[i]).n()) < 1e-2 for i in range(len(a)))
def test_AlgebraicNumber_to_root():
assert AlgebraicNumber(sqrt(2)).to_root() == sqrt(2)
zeta5_squared = AlgebraicNumber(CRootOf(x**5 - 1, 4), coeffs=[1, 0, 0])
assert zeta5_squared.to_root() == CRootOf(x**4 + x**3 + x**2 + x + 1, 1)
zeta3_squared = AlgebraicNumber(CRootOf(x**3 - 1, 2), coeffs=[1, 0, 0])
assert zeta3_squared.to_root() == -S(1)/2 - sqrt(3)*I/2
assert zeta3_squared.to_root(radicals=False) == CRootOf(x**2 + x + 1, 0)
def test_eval_approx_relative():
CRootOf.clear_cache()
t = [CRootOf(x**3 + 10*x + 1, i) for i in range(3)]
assert [i.eval_rational(1e-1) for i in t] == [
-21/220, 15/256 - 805*I/256, 15/256 + 805*I/256]
t[0]._reset()
assert [i.eval_rational(1e-1, 1e-4) for i in t] == [
-21/220, 3275/65536 - 414645*I/131072,
3275/65536 + 414645*I/131072]
assert S(t[0]._get_interval().dx) < 1e-1
assert S(t[1]._get_interval().dx) < 1e-1
assert S(t[1]._get_interval().dy) < 1e-4
assert S(t[2]._get_interval().dx) < 1e-1
assert S(t[2]._get_interval().dy) < 1e-4
t[0]._reset()
assert [i.eval_rational(1e-4, 1e-4) for i in t] == [
-2001/20020, 6545/131072 - 414645*I/131072,
6545/131072 + 414645*I/131072]
assert S(t[0]._get_interval().dx) < 1e-4
assert S(t[1]._get_interval().dx) < 1e-4
assert S(t[1]._get_interval().dy) < 1e-4
assert S(t[2]._get_interval().dx) < 1e-4
assert S(t[2]._get_interval().dy) < 1e-4
# in the following, the actual relative precision is
# less than tested, but it should never be greater
t[0]._reset()
assert [i.eval_rational(n=2) for i in t] == [
-202201/2024022, 104755/2097152 - 6634255*I/2097152,
104755/2097152 + 6634255*I/2097152]
assert abs(S(t[0]._get_interval().dx)/t[0]) < 1e-2
assert abs(S(t[1]._get_interval().dx)/t[1]).n() < 1e-2
assert abs(S(t[1]._get_interval().dy)/t[1]).n() < 1e-2
assert abs(S(t[2]._get_interval().dx)/t[2]).n() < 1e-2
assert abs(S(t[2]._get_interval().dy)/t[2]).n() < 1e-2
t[0]._reset()
assert [i.eval_rational(n=3) for i in t] == [
-202201/2024022, 1676045/33554432 - 106148135*I/33554432,
1676045/33554432 + 106148135*I/33554432]
assert abs(S(t[0]._get_interval().dx)/t[0]) < 1e-3
assert abs(S(t[1]._get_interval().dx)/t[1]).n() < 1e-3
assert abs(S(t[1]._get_interval().dy)/t[1]).n() < 1e-3
assert abs(S(t[2]._get_interval().dx)/t[2]).n() < 1e-3
assert abs(S(t[2]._get_interval().dy)/t[2]).n() < 1e-3
t[0]._reset()
a = [i.eval_approx(2) for i in t]
assert [str(i) for i in a] == [
'-0.10', '0.05 - 3.2*I', '0.05 + 3.2*I']
assert all(abs(((a[i] - t[i])/t[i]).n()) < 1e-2 for i in range(len(a)))
def test_dom_eigenvects_rootof():
# Algebraic eigenvalues
A = DomainMatrix([[0, 0, 0, 0, -1], [1, 0, 0, 0, 1], [0, 1, 0, 0, 0],
[0, 0, 1, 0, 0], [0, 0, 0, 1, 0]], (5, 5), QQ)
Avects = dom_eigenvects(A)
# Extract the dummy to build the expected result:
lamda = Avects[1][0][1].gens[0]
irreducible = Poly(lamda**5 - lamda + 1, lamda, domain=QQ)
K = FiniteExtension(irreducible)
KK = K.from_sympy
algebraic_eigenvects = [
(K, irreducible, 1,
DomainMatrix(
[[KK(lamda**4 - 1),
KK(lamda**3),
KK(lamda**2),
KK(lamda),
KK(1)]], (1, 5), K)),
]
assert Avects == ([], algebraic_eigenvects)
# Test converting to Expr (slow):
l0, l1, l2, l3, l4 = [CRootOf(lamda**5 - lamda + 1, i) for i in range(5)]
sympy_eigenvects = [
(l0, 1, [Matrix([-1 + l0**4, l0**3, l0**2, l0, 1])]),
(l1, 1, [Matrix([-1 + l1**4, l1**3, l1**2, l1, 1])]),
(l2, 1, [Matrix([-1 + l2**4, l2**3, l2**2, l2, 1])]),
(l3, 1, [Matrix([-1 + l3**4, l3**3, l3**2, l3, 1])]),
(l4, 1, [Matrix([-1 + l4**4, l4**3, l4**2, l4, 1])]),
]
assert dom_eigenvects_to_sympy([], algebraic_eigenvects,
Matrix) == sympy_eigenvects
def dom_eigenvects_to_sympy(
rational_eigenvects, algebraic_eigenvects,
Matrix, **kwargs
):
result = []
for field, eigenvalue, multiplicity, eigenvects in rational_eigenvects:
eigenvects = eigenvects.rep
eigenvalue = field.to_sympy(eigenvalue)
new_eigenvects = [
Matrix([field.to_sympy(x) for x in vect])
for vect in eigenvects]
result.append((eigenvalue, multiplicity, new_eigenvects))
for field, minpoly, multiplicity, eigenvects in algebraic_eigenvects:
eigenvects = eigenvects.rep
l = minpoly.gens[0]
eigenvects = [[field.to_sympy(x) for x in vect] for vect in eigenvects]
degree = minpoly.degree()
minpoly = minpoly.as_expr()
eigenvals = roots(minpoly, l, **kwargs)
if len(eigenvals) != degree:
eigenvals = [CRootOf(minpoly, l, idx) for idx in range(degree)]
for eigenvalue in eigenvals:
new_eigenvects = [
Matrix([x.subs(l, eigenvalue) for x in vect])
for vect in eigenvects]
result.append((eigenvalue, multiplicity, new_eigenvects))
return result
def test_CRootOf_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)]
# https://github.com/sympy/sympy/issues/20902
p = Poly(-3 * x**4 - 10 * x**3 - 12 * x**2 - 6 * x - 1, x, domain='ZZ')
assert CRootOf.real_roots(p) == [S(-1), S(-1), S(-1), S(-1) / 3]
def test_pickling_polys_rootoftools():
from sympy.polys.rootoftools import CRootOf, RootSum
x = Symbol('x')
f = x**3 + x + 3
for c in (CRootOf, CRootOf(f, 0)):
check(c)
for c in (RootSum, RootSum(f, exp)):
check(c)
def test_evalf_real_alg_num():
# This test demonstrates why the entry for `AlgebraicNumber` in
# `sympy.core.evalf._create_evalf_table()` has to use `x.to_root()`,
# instead of `x.as_expr()`. If the latter is used, then `z` will be
# a complex number with `0.e-20` for imaginary part, even though `a5`
# is a real number.
zeta = Symbol('zeta')
a5 = AlgebraicNumber(CRootOf(cyclotomic_poly(5), -1), [-1, -1, 0, 0],
alias=zeta)
z = a5.evalf()
assert isinstance(z, Float)
assert not hasattr(z, '_mpc_')
assert hasattr(z, '_mpf_')
def alg_field_from_poly(self, poly, alias=None, root_index=-1):
r"""
Convenience method to construct an algebraic extension on a root of a
polynomial, chosen by root index.
Parameters
==========
poly : :py:class:`~.Poly`
The polynomial whose root generates the extension.
alias : str, optional (default=None)
Symbol name for the generator of the extension.
E.g. "alpha" or "theta".
root_index : int, optional (default=-1)
Specifies which root of the polynomial is desired. The ordering is
as defined by the :py:class:`~.ComplexRootOf` class. The default of
``-1`` selects the most natural choice in the common cases of
quadratic and cyclotomic fields (the square root on the positive
real or imaginary axis, resp. $\mathrm{e}^{2\pi i/n}$).
Examples
========
>>> from sympy import QQ, Poly
>>> from sympy.abc import x
>>> f = Poly(x**2 - 2)
>>> K = QQ.alg_field_from_poly(f)
>>> K.ext.minpoly == f
True
>>> g = Poly(8*x**3 - 6*x - 1)
>>> L = QQ.alg_field_from_poly(g, "alpha")
>>> L.ext.minpoly == g
True
>>> L.to_sympy(L([1, 1, 1]))
alpha**2 + alpha + 1
"""
from sympy.polys.rootoftools import CRootOf
root = CRootOf(poly, root_index)
alpha = AlgebraicNumber(root, alias=alias)
return self.algebraic_field(alpha)
def test_return_root_of():
f = x**5 - 15 * x**3 - 5 * x**2 + 10 * x + 20
s = list(solveset_complex(f, x))
for root in s:
assert root.func == CRootOf
# if one uses solve to get the roots of a polynomial that has a CRootOf
# solution, make sure that the use of nfloat during the solve process
# doesn't fail. Note: if you want numerical solutions to a polynomial
# it is *much* faster to use nroots to get them than to solve the
# equation only to get CRootOf solutions which are then numerically
# evaluated. So for eq = x**5 + 3*x + 7 do Poly(eq).nroots() rather
# than [i.n() for i in solve(eq)] to get the numerical roots of eq.
assert nfloat(list(solveset_complex(x**5 + 3 * x**3 + 7, x))[0],
exponent=False) == CRootOf(x**5 + 3 * x**3 + 7, 0).n()
sol = list(solveset_complex(x**6 - 2 * x + 2, x))
assert all(isinstance(i, CRootOf) for i in sol) and len(sol) == 6
f = x**5 - 15 * x**3 - 5 * x**2 + 10 * x + 20
s = list(solveset_complex(f, x))
for root in s:
assert root.func == CRootOf
s = x**5 + 4 * x**3 + 3 * x**2 + S(7) / 4
assert solveset_complex(s, x) == \
FiniteSet(*Poly(s*4, domain='ZZ').all_roots())
# XXX: this comparison should work without converting the FiniteSet to list
# See #7876
eq = x * (x - 1)**2 * (x + 1) * (x**6 - x + 1)
assert list(solveset_complex(eq, x)) == \
list(FiniteSet(-1, 0, 1, CRootOf(x**6 - x + 1, 0),
CRootOf(x**6 - x + 1, 1),
CRootOf(x**6 - x + 1, 2),
CRootOf(x**6 - x + 1, 3),
CRootOf(x**6 - x + 1, 4),
CRootOf(x**6 - x + 1, 5)))
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 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
# 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()
n = ri.n(2)
assert i != ri._get_interval()
ri._reset()
assert i == ri._get_interval()
assert i == i.func(*i.args)
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()]
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
# 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 str(c._eval_evalf(2)) == '-0.e-1'
def test_CRootOf_lazy():
# irreducible poly with both real and complex roots:
f = Poly(x**3 + 2 * x + 2)
# real root:
CRootOf.clear_cache()
r = CRootOf(f, 0)
# Not yet in cache, after construction:
assert r.poly not in rootoftools._reals_cache
assert r.poly not in rootoftools._complexes_cache
r.evalf()
# In cache after evaluation:
assert r.poly in rootoftools._reals_cache
assert r.poly not in rootoftools._complexes_cache
# complex root:
CRootOf.clear_cache()
r = CRootOf(f, 1)
# Not yet in cache, after construction:
assert r.poly not in rootoftools._reals_cache
assert r.poly not in rootoftools._complexes_cache
r.evalf()
# In cache after evaluation:
assert r.poly in rootoftools._reals_cache
assert r.poly in rootoftools._complexes_cache
# composite poly with both real and complex roots:
f = Poly((x**2 - 2) * (x**2 + 1))
# real root:
CRootOf.clear_cache()
r = CRootOf(f, 0)
# In cache immediately after construction:
assert r.poly in rootoftools._reals_cache
assert r.poly not in rootoftools._complexes_cache
# complex root:
CRootOf.clear_cache()
r = CRootOf(f, 2)
# In cache immediately after construction:
assert r.poly in rootoftools._reals_cache
assert r.poly in rootoftools._complexes_cache
def test_issue_18203():
eq = CRootOf(x**5 + 11 * x - 2, 0) + CRootOf(x**5 + 11 * x - 2, 1)
assert cse(eq) == ([], [eq])
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()
n = ri.n(2)
assert i != ri._get_interval()
ri._reset()
assert i == ri._get_interval()
assert i == i.func(*i.args)
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()]
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
# 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 str(c._eval_evalf(2)) == '-0.e-1'
def test_issue_22736():
a = CRootOf(x**4 + x**3 + x**2 + x + 1, -1)
a._reset()
b = exp(2*I*pi/5)
assert field_isomorphism(a, b) == [1, 0]
def test_issue_6169():
r = CRootOf(x**6 - 4 * x**5 - 2, 1)
assert cse(r) == ([], [r])
# and a check that the right thing is done with the new
# mechanism
assert sub_post(sub_pre((-x - y) * z - x - y)) == -z * (x + y) - x - y
