def test_roots_preprocessed():
E, F, J, L = symbols("E,F,J,L")
f = -21601054687500000000*E**8*J**8/L**16 + \
508232812500000000*F*x*E**7*J**7/L**14 - \
4269543750000000*E**6*F**2*J**6*x**2/L**12 + \
16194716250000*E**5*F**3*J**5*x**3/L**10 - \
27633173750*E**4*F**4*J**4*x**4/L**8 + \
14840215*E**3*F**5*J**3*x**5/L**6 + \
54794*E**2*F**6*J**2*x**6/(5*L**4) - \
1153*E*J*F**7*x**7/(80*L**2) + \
633*F**8*x**8/160000
assert roots(f, x) == {}
R1 = roots(f.evalf(strict=False), x, multiple=True)
R2 = [-1304.88375606366, 97.1168816800648, 186.946430171876, 245.526792947065,
503.441004174773, 791.549343830097, 1273.16678129348, 1850.10650616851]
w = Wild('w')
p = w*E*J/(F*L**2)
assert len(R1) == len(R2)
for r1, r2 in zip(R1, R2):
match = r1.match(p)
assert match is not None and abs(match[w] - r2) < 1e-10
def test_roots_preprocessed():
E, F, J, L = symbols("E,F,J,L")
f = -21601054687500000000*E**8*J**8/L**16 + \
508232812500000000*F*x*E**7*J**7/L**14 - \
4269543750000000*E**6*F**2*J**6*x**2/L**12 + \
16194716250000*E**5*F**3*J**5*x**3/L**10 - \
27633173750*E**4*F**4*J**4*x**4/L**8 + \
14840215*E**3*F**5*J**3*x**5/L**6 + \
54794*E**2*F**6*J**2*x**6/(5*L**4) - \
1153*E*J*F**7*x**7/(80*L**2) + \
633*F**8*x**8/160000
assert roots(f, x) == {}
R1 = roots(f.evalf(strict=False), x, multiple=True)
R2 = [
-1304.88375606366, 97.1168816800648, 186.946430171876,
245.526792947065, 503.441004174773, 791.549343830097, 1273.16678129348,
1850.10650616851
]
w = Wild('w')
p = w * E * J / (F * L**2)
assert len(R1) == len(R2)
for r1, r2 in zip(R1, R2):
match = r1.match(p)
assert match is not None and abs(match[w] - r2) < 1e-10
def test_roots1():
assert roots(1) == {}
assert roots(1, multiple=True) == []
q = Symbol('q', real=True)
assert roots(x**3 - q, x) == {cbrt(q): 1,
-cbrt(q)/2 - sqrt(3)*I*cbrt(q)/2: 1,
-cbrt(q)/2 + sqrt(3)*I*cbrt(q)/2: 1}
assert roots_cubic(Poly(x**3 - 1)) == [1, Rational(-1, 2) + sqrt(3)*I/2,
Rational(-1, 2) - sqrt(3)*I/2]
assert roots([1, x, y]) == {-x/2 - sqrt(x**2 - 4*y)/2: 1,
-x/2 + sqrt(x**2 - 4*y)/2: 1}
pytest.raises(ValueError, lambda: roots([1, x, y], z))
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_roots_inexact():
R1 = roots(x**2 + x + 1, x, multiple=True)
R2 = roots(x**2 + x + 1.0, x, multiple=True)
for r1, r2 in zip(R1, R2):
assert abs(r1 - r2) < 1e-12
f = x**4 + 3.0*sqrt(2.0)*x**3 - (78.0 + 24.0*sqrt(3.0))*x**2 \
+ 144.0*(2*sqrt(3.0) + 9.0)
R1 = roots(f, multiple=True)
R2 = (-12.7530479110482, -3.85012393732929,
4.89897948556636, 7.46155167569183)
for r1, r2 in zip(R1, R2):
assert abs(r1 - r2) < 1e-10
def test_roots_inexact():
R1 = roots(x**2 + x + 1, x, multiple=True)
R2 = roots(x**2 + x + 1.0, x, multiple=True)
for r1, r2 in zip(R1, R2):
assert abs(r1 - r2) < 1e-12
f = x**4 + 3.0*sqrt(2.0)*x**3 - (78.0 + 24.0*sqrt(3.0))*x**2 \
+ 144.0*(2*sqrt(3.0) + 9.0)
R1 = roots(f, multiple=True)
R2 = (-12.7530479110482, -3.85012393732929, 4.89897948556636,
7.46155167569183)
for r1, r2 in zip(R1, R2):
assert abs(r1 - r2) < 1e-10
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_roots_cubic():
assert roots_cubic(Poly(2 * x**3, x)) == [0, 0, 0]
assert roots_cubic(Poly(x**3 - 3 * x**2 + 3 * x - 1, x)) == [1, 1, 1]
assert roots_cubic(Poly(x**3 + 1, x)) == \
[-1, Rational(1, 2) - I*sqrt(3)/2, Rational(1, 2) + I*sqrt(3)/2]
assert roots_cubic(Poly(2*x**3 - 3*x**2 - 3*x - 1, x))[0] == \
Rational(1, 2) + cbrt(3)/2 + 3**Rational(2, 3)/2
eq = -x**3 + 2 * x**2 + 3 * x - 2
assert roots(eq, trig=True, multiple=True) == \
roots_cubic(Poly(eq, x), trig=True) == [
Rational(2, 3) + 2*sqrt(13)*cos(acos(8*sqrt(13)/169)/3)/3,
-2*sqrt(13)*sin(-acos(8*sqrt(13)/169)/3 + pi/6)/3 + Rational(2, 3),
-2*sqrt(13)*cos(-acos(8*sqrt(13)/169)/3 + pi/3)/3 + Rational(2, 3),
]
res = roots_cubic(Poly(x**3 + 2 * a / 27, x))
assert res == [
-root(a + sqrt(a**2), 3) / 3,
Mul(Rational(-1, 3),
Rational(-1, 2) + sqrt(3) * I / 2,
root(a + sqrt(a**2), 3),
evaluate=False),
Mul(Rational(-1, 3),
Rational(-1, 2) - sqrt(3) * I / 2,
root(a + sqrt(a**2), 3),
evaluate=False)
]
def doit(self, **hints):
if not hints.get('roots', True):
return self
_roots = roots(self.poly, multiple=True)
if len(_roots) < self.poly.degree():
return self
else:
return Add(*[self.fun(r) for r in _roots])
def simplify(self, x):
"""simplify(self, x)
Compute a simplified representation of the function using
property number 4.
x can be:
- a symbol
Examples
========
>>> from diofant import DiracDelta
>>> from diofant.abc import x, y
>>> DiracDelta(x*y).simplify(x)
DiracDelta(x)/Abs(y)
>>> DiracDelta(x*y).simplify(y)
DiracDelta(y)/Abs(x)
>>> DiracDelta(x**2 + x - 2).simplify(x)
DiracDelta(x - 1)/3 + DiracDelta(x + 2)/3
See Also
========
diofant.functions.special.delta_functions.DiracDelta.is_simple
diofant.functions.special.delta_functions.DiracDelta
"""
from diofant.polys.polyroots import roots
if not self.args[0].has(x) or (len(self.args) > 1
and self.args[1] != 0):
return self
try:
argroots = roots(self.args[0], x)
result = 0
valid = True
darg = abs(diff(self.args[0], x))
for r, m in argroots.items():
if r.is_extended_real is not False and m == 1:
result += self.func(x - r) / darg.subs(x, r)
else:
# don't handle non-real and if m != 1 then
# a polynomial will have a zero in the derivative (darg)
# at r
valid = False
break
if valid:
return result
except PolynomialError:
pass
return self
def test_roots1():
assert roots(1) == {}
assert roots(1, multiple=True) == []
q = Symbol('q', real=True)
assert roots(x**3 - q, x) == {
cbrt(q): 1,
-cbrt(q) / 2 - sqrt(3) * I * cbrt(q) / 2: 1,
-cbrt(q) / 2 + sqrt(3) * I * cbrt(q) / 2: 1
}
assert roots_cubic(Poly(x**3 - 1)) == [
1,
Rational(-1, 2) + sqrt(3) * I / 2,
Rational(-1, 2) - sqrt(3) * I / 2
]
assert roots([1, x, y]) == {
-x / 2 - sqrt(x**2 - 4 * y) / 2: 1,
-x / 2 + sqrt(x**2 - 4 * y) / 2: 1
}
pytest.raises(ValueError, lambda: roots([1, x, y], z))
def test_roots_slow():
"""Just test that calculating these roots does not hang. """
a, b, c, d, x = symbols("a,b,c,d,x")
f1 = x**2*c + (a/b) + x*c*d - a
f2 = x**2*(a + b*(c - d)*a) + x*a*b*c/(b*d - d) + (a*d - c/d)
assert list(roots(f1, x).values()) == [1, 1]
assert list(roots(f2, x).values()) == [1, 1]
zz, yy, xx, zy, zx, yx, k = symbols("zz,yy,xx,zy,zx,yx,k")
e1 = (zz - k)*(yy - k)*(xx - k) + zy*yx*zx + zx - zy - yx
e2 = (zz - k)*yx*yx + zx*(yy - k)*zx + zy*zy*(xx - k)
assert list(roots(e1 - e2, k).values()) == [1, 1, 1]
f = x**3 + 2*x**2 + 8
R = list(roots(f))
assert not any(i for i in [f.subs({x: ri}).evalf(chop=True) for ri in R])
def test_roots_slow():
"""Just test that calculating these roots does not hang. """
a, b, c, d, x = symbols("a,b,c,d,x")
f1 = x**2 * c + (a / b) + x * c * d - a
f2 = x**2 * (a + b *
(c - d) * a) + x * a * b * c / (b * d - d) + (a * d - c / d)
assert list(roots(f1, x).values()) == [1, 1]
assert list(roots(f2, x).values()) == [1, 1]
zz, yy, xx, zy, zx, yx, k = symbols("zz,yy,xx,zy,zx,yx,k")
e1 = (zz - k) * (yy - k) * (xx - k) + zy * yx * zx + zx - zy - yx
e2 = (zz - k) * yx * yx + zx * (yy - k) * zx + zy * zy * (xx - k)
assert list(roots(e1 - e2, k).values()) == [1, 1, 1]
f = x**3 + 2 * x**2 + 8
R = list(roots(f))
assert not any(i for i in [f.subs({x: ri}).evalf(chop=True) for ri in R])
def test_roots_cubic():
assert roots_cubic(Poly(2 * x**3, x)) == [0, 0, 0]
assert roots_cubic(Poly(x**3 - 3 * x**2 + 3 * x - 1, x)) == [1, 1, 1]
assert roots_cubic(Poly(x**3 + 1, x)) == \
[-1, Rational(1, 2) - I*sqrt(3)/2, Rational(1, 2) + I*sqrt(3)/2]
assert roots_cubic(Poly(2*x**3 - 3*x**2 - 3*x - 1, x))[0] == \
Rational(1, 2) + cbrt(3)/2 + 3**Rational(2, 3)/2
eq = -x**3 + 2 * x**2 + 3 * x - 2
assert roots(eq, trig=True, multiple=True) == \
roots_cubic(Poly(eq, x), trig=True) == [
Rational(2, 3) + 2*sqrt(13)*cos(acos(8*sqrt(13)/169)/3)/3,
-2*sqrt(13)*sin(-acos(8*sqrt(13)/169)/3 + pi/6)/3 + Rational(2, 3),
-2*sqrt(13)*cos(-acos(8*sqrt(13)/169)/3 + pi/3)/3 + Rational(2, 3),
]
def test_roots_cubic():
assert roots_cubic(Poly(2*x**3, x)) == [0, 0, 0]
assert roots_cubic(Poly(x**3 - 3*x**2 + 3*x - 1, x)) == [1, 1, 1]
assert roots_cubic(Poly(x**3 + 1, x)) == \
[-1, Rational(1, 2) - I*sqrt(3)/2, Rational(1, 2) + I*sqrt(3)/2]
assert roots_cubic(Poly(2*x**3 - 3*x**2 - 3*x - 1, x))[0] == \
Rational(1, 2) + cbrt(3)/2 + 3**Rational(2, 3)/2
eq = -x**3 + 2*x**2 + 3*x - 2
assert roots(eq, trig=True, multiple=True) == \
roots_cubic(Poly(eq, x), trig=True) == [
Rational(2, 3) + 2*sqrt(13)*cos(acos(8*sqrt(13)/169)/3)/3,
-2*sqrt(13)*sin(-acos(8*sqrt(13)/169)/3 + pi/6)/3 + Rational(2, 3),
-2*sqrt(13)*cos(-acos(8*sqrt(13)/169)/3 + pi/3)/3 + Rational(2, 3),
]
res = roots_cubic(Poly(x**3 + 2*a/27, x))
assert res == [-root(a + sqrt(a**2), 3)/3,
Mul(Rational(-1, 3), Rational(-1, 2) + sqrt(3)*I/2,
root(a + sqrt(a**2), 3), evaluate=False),
Mul(Rational(-1, 3), Rational(-1, 2) - sqrt(3)*I/2,
root(a + sqrt(a**2), 3), evaluate=False)]
def test_roots_mixed():
f = -1936 - 5056*x - 7592*x**2 + 2704*x**3 - 49*x**4
_re, _im = intervals(f, all=True)
_nroots = nroots(f)
_sroots = roots(f, multiple=True)
_re = [ Interval(a, b) for (a, b), _ in _re ]
_im = [ Interval(re(a), re(b))*Interval(im(a), im(b)) for (a, b),
_ in _im ]
_intervals = _re + _im
_sroots = [ r.evalf() for r in _sroots ]
_nroots = sorted(_nroots, key=lambda x: x.sort_key())
_sroots = sorted(_sroots, key=lambda x: x.sort_key())
for _roots in (_nroots, _sroots):
for i, r in zip(_intervals, _roots):
if r.is_extended_real:
assert r in i
else:
assert (re(r), im(r)) in i
def test_roots_mixed():
f = -1936 - 5056 * x - 7592 * x**2 + 2704 * x**3 - 49 * x**4
_re, _im = intervals(f, all=True)
_nroots = nroots(f)
_sroots = roots(f, multiple=True)
_re = [Interval(a, b) for (a, b), _ in _re]
_im = [
Interval(re(a), re(b)) * Interval(im(a), im(b)) for (a, b), _ in _im
]
_intervals = _re + _im
_sroots = [r.evalf() for r in _sroots]
_nroots = sorted(_nroots, key=lambda x: x.sort_key())
_sroots = sorted(_sroots, key=lambda x: x.sort_key())
for _roots in (_nroots, _sroots):
for i, r in zip(_intervals, _roots):
if r.is_extended_real:
assert r in i
else:
assert (re(r), im(r)) in i
def test_sympyissue_16589():
e = x**4 - 8 * sqrt(2) * x**3 + 4 * x**3 - 64 * sqrt(2) * x**2 + 1024 * x
rs = roots(e, x)
assert 0 in rs
assert all(not e.evalf(chop=True, subs={x: r}) for r in rs)
def test_sympyissue_7724():
e = x**4 * I + x**2 + I
r1, r2 = roots(e, x), Poly(e, x).all_roots()
assert len(r1) == 4
assert {_.evalf() for _ in r1} == {_.evalf() for _ in r2}
def test_roots_composite():
assert len(roots(Poly(y**3 + y**2 * sqrt(x) + y + x, y,
composite=True))) == 3
def test_roots0():
assert roots(1, x) == {}
assert roots(x, x) == {0: 1}
assert roots(x**9, x) == {0: 9}
assert roots(((x - 2)*(x + 3)*(x - 4)).expand(), x) == {-3: 1, 2: 1, 4: 1}
assert roots(x**2 - 2*x + 1, x, auto=False) == {1: 2}
assert roots(2*x + 1, x) == {Rational(-1, 2): 1}
assert roots((2*x + 1)**2, x) == {Rational(-1, 2): 2}
assert roots((2*x + 1)**5, x) == {Rational(-1, 2): 5}
assert roots((2*x + 1)**10, x) == {Rational(-1, 2): 10}
assert roots(x**4 - 1, x) == {I: 1, 1: 1, -1: 1, -I: 1}
assert roots((x**4 - 1)**2, x) == {I: 2, 1: 2, -1: 2, -I: 2}
assert roots(((2*x - 3)**2).expand(), x) == { Rational(3, 2): 2}
assert roots(((2*x + 3)**2).expand(), x) == {-Rational(3, 2): 2}
assert roots(((2*x - 3)**3).expand(), x) == { Rational(3, 2): 3}
assert roots(((2*x + 3)**3).expand(), x) == {-Rational(3, 2): 3}
assert roots(((2*x - 3)**5).expand(), x) == { Rational(3, 2): 5}
assert roots(((2*x + 3)**5).expand(), x) == {-Rational(3, 2): 5}
assert roots(((a*x - b)**5).expand(), x) == { b/a: 5}
assert roots(((a*x + b)**5).expand(), x) == {-b/a: 5}
assert roots(x**2 + (-a - 1)*x + a, x) == {a: 1, 1: 1}
assert roots(x**4 - 2*x**2 + 1, x) == {1: 2, -1: 2}
assert roots(x**6 - 4*x**4 + 4*x**3 - x**2, x) == \
{1: 2, -1 - sqrt(2): 1, 0: 2, -1 + sqrt(2): 1}
assert roots(x**8 - 1, x) == {
sqrt(2)/2 + I*sqrt(2)/2: 1,
sqrt(2)/2 - I*sqrt(2)/2: 1,
-sqrt(2)/2 + I*sqrt(2)/2: 1,
-sqrt(2)/2 - I*sqrt(2)/2: 1,
1: 1, -1: 1, I: 1, -I: 1
}
f = -2016*x**2 - 5616*x**3 - 2056*x**4 + 3324*x**5 + 2176*x**6 - \
224*x**7 - 384*x**8 - 64*x**9
assert roots(f) == {0: 2, -2: 2, 2: 1, -Rational(7, 2): 1, -Rational(3, 2): 1, -Rational(1, 2): 1, Rational(3, 2): 1}
assert roots((a + b + c)*x - (a + b + c + d), x) == {(a + b + c + d)/(a + b + c): 1}
assert roots(x**3 + x**2 - x + 1, x, cubics=False) == {}
assert roots(((x - 2)*(
x + 3)*(x - 4)).expand(), x, cubics=False) == {-3: 1, 2: 1, 4: 1}
assert roots(((x - 2)*(x + 3)*(x - 4)*(x - 5)).expand(), x, cubics=False) == \
{-3: 1, 2: 1, 4: 1, 5: 1}
assert roots(x**3 + 2*x**2 + 4*x + 8, x) == {-2: 1, -2*I: 1, 2*I: 1}
assert roots(x**3 + 2*x**2 + 4*x + 8, x, cubics=True) == \
{-2*I: 1, 2*I: 1, -2: 1}
assert roots((x**2 - x)*(x**3 + 2*x**2 + 4*x + 8), x ) == \
{1: 1, 0: 1, -2: 1, -2*I: 1, 2*I: 1}
r1_2, r1_3 = Rational(1, 2), Rational(1, 3)
x0 = (3*sqrt(33) + 19)**r1_3
x1 = 4/x0/3
x2 = x0/3
x3 = sqrt(3)*I/2
x4 = x3 - r1_2
x5 = -x3 - r1_2
assert roots(x**3 + x**2 - x + 1, x, cubics=True) == {
-x1 - x2 - r1_3: 1,
-x1/x4 - x2*x4 - r1_3: 1,
-x1/x5 - x2*x5 - r1_3: 1,
}
f = (x**2 + 2*x + 3).subs({x: 2*x**2 + 3*x}).subs({x: 5*x - 4})
r13_20, r1_20 = [ Rational(*r)
for r in ((13, 20), (1, 20)) ]
s2 = sqrt(2)
assert roots(f, x) == {
r13_20 + r1_20*sqrt(1 - 8*I*s2): 1,
r13_20 - r1_20*sqrt(1 - 8*I*s2): 1,
r13_20 + r1_20*sqrt(1 + 8*I*s2): 1,
r13_20 - r1_20*sqrt(1 + 8*I*s2): 1,
}
f = x**4 + x**3 + x**2 + x + 1
r1_4, r1_8, r5_8 = [ Rational(*r) for r in ((1, 4), (1, 8), (5, 8)) ]
assert roots(f, x) == {
-r1_4 + r1_4*5**r1_2 + I*(r5_8 + r1_8*5**r1_2)**r1_2: 1,
-r1_4 + r1_4*5**r1_2 - I*(r5_8 + r1_8*5**r1_2)**r1_2: 1,
-r1_4 - r1_4*5**r1_2 + I*(r5_8 - r1_8*5**r1_2)**r1_2: 1,
-r1_4 - r1_4*5**r1_2 - I*(r5_8 - r1_8*5**r1_2)**r1_2: 1,
}
f = z**3 + (-2 - y)*z**2 + (1 + 2*y - 2*x**2)*z - y + 2*x**2
assert roots(f, z) == {
1: 1,
Rational(1, 2) + y/2 + sqrt(1 - 2*y + y**2 + 8*x**2)/2: 1,
Rational(1, 2) + y/2 - sqrt(1 - 2*y + y**2 + 8*x**2)/2: 1,
}
assert roots(a*b*c*x**3 + 2*x**2 + 4*x + 8, x, cubics=False) == {}
assert roots(a*b*c*x**3 + 2*x**2 + 4*x + 8, x, cubics=True) != {}
assert roots(x**4 - 1, x, filter='Z') == {1: 1, -1: 1}
assert roots(x**4 - 1, x, filter='R') == {1: 1, -1: 1}
assert roots(x**4 - 1, x, filter='I') == {I: 1, -I: 1}
pytest.raises(ValueError, lambda: roots(x**4 - 1, x, filter='spam'))
assert roots((x - 1)*(x + 1), x) == {1: 1, -1: 1}
assert roots(
(x - 1)*(x + 1), x, predicate=lambda r: r.is_positive) == {1: 1}
assert roots(x**4 - 1, x, filter='Z', multiple=True) == [-1, 1]
assert roots(x**4 - 1, x, filter='I', multiple=True) == [I, -I]
assert roots(x**3, x, multiple=True) == [0, 0, 0]
assert roots(1234, x, multiple=True) == []
f = x**6 - x**5 + x**4 - x**3 + x**2 - x + 1
assert roots(f) == {
-I*sin(pi/7) + cos(pi/7): 1,
-I*sin(2*pi/7) - cos(2*pi/7): 1,
-I*sin(3*pi/7) + cos(3*pi/7): 1,
I*sin(pi/7) + cos(pi/7): 1,
I*sin(2*pi/7) - cos(2*pi/7): 1,
I*sin(3*pi/7) + cos(3*pi/7): 1,
}
g = ((x**2 + 1)*f**2).expand()
assert roots(g) == {
-I*sin(pi/7) + cos(pi/7): 2,
-I*sin(2*pi/7) - cos(2*pi/7): 2,
-I*sin(3*pi/7) + cos(3*pi/7): 2,
I*sin(pi/7) + cos(pi/7): 2,
I*sin(2*pi/7) - cos(2*pi/7): 2,
I*sin(3*pi/7) + cos(3*pi/7): 2,
-I: 1, I: 1,
}
r = roots(x**3 + 40*x + 64)
real_root = [rx for rx in r if rx.is_extended_real][0]
cr = 108 + 6*sqrt(1074)
assert real_root == -2*root(cr, 3)/3 + 20/root(cr, 3)
eq = Poly((7 + 5*sqrt(2))*x**3 + (-6 - 4*sqrt(2))*x**2 + (-sqrt(2) - 1)*x + 2, x, domain='EX')
assert roots(eq) == {-1 + sqrt(2): 1, -2 + 2*sqrt(2): 1, -sqrt(2) + 1: 1}
eq = Poly(41*x**5 + 29*sqrt(2)*x**5 - 153*x**4 - 108*sqrt(2)*x**4 +
175*x**3 + 125*sqrt(2)*x**3 - 45*x**2 - 30*sqrt(2)*x**2 - 26*sqrt(2)*x -
26*x + 24, x, domain='EX')
assert roots(eq) == {-sqrt(2) + 1: 1, -2 + 2*sqrt(2): 1, -1 + sqrt(2): 1,
-4 + 4*sqrt(2): 1, -3 + 3*sqrt(2): 1}
eq = Poly(x**3 - 2*x**2 + 6*sqrt(2)*x**2 - 8*sqrt(2)*x + 23*x - 14 +
14*sqrt(2), x, domain='EX')
assert roots(eq) == {-2*sqrt(2) + 2: 1, -2*sqrt(2) + 1: 1, -2*sqrt(2) - 1: 1}
assert roots(Poly((x + sqrt(2))**3 - 7, x, domain='EX')) == \
{-sqrt(2) - root(7, 3)/2 - sqrt(3)*root(7, 3)*I/2: 1,
-sqrt(2) - root(7, 3)/2 + sqrt(3)*root(7, 3)*I/2: 1,
-sqrt(2) + root(7, 3): 1}
pytest.raises(PolynomialError, lambda: roots(x*y, x, y))
def test_roots0():
assert roots(1, x) == {}
assert roots(x, x) == {0: 1}
assert roots(x**9, x) == {0: 9}
assert roots(((x - 2) * (x + 3) * (x - 4)).expand(), x) == {
-3: 1,
2: 1,
4: 1
}
assert roots(x**2 - 2 * x + 1, x, auto=False) == {1: 2}
assert roots(2 * x + 1, x) == {Rational(-1, 2): 1}
assert roots((2 * x + 1)**2, x) == {Rational(-1, 2): 2}
assert roots((2 * x + 1)**5, x) == {Rational(-1, 2): 5}
assert roots((2 * x + 1)**10, x) == {Rational(-1, 2): 10}
assert roots(x**4 - 1, x) == {I: 1, 1: 1, -1: 1, -I: 1}
assert roots((x**4 - 1)**2, x) == {I: 2, 1: 2, -1: 2, -I: 2}
assert roots(((2 * x - 3)**2).expand(), x) == {+Rational(3, 2): 2}
assert roots(((2 * x + 3)**2).expand(), x) == {-Rational(3, 2): 2}
assert roots(((2 * x - 3)**3).expand(), x) == {+Rational(3, 2): 3}
assert roots(((2 * x + 3)**3).expand(), x) == {-Rational(3, 2): 3}
assert roots(((2 * x - 3)**5).expand(), x) == {+Rational(3, 2): 5}
assert roots(((2 * x + 3)**5).expand(), x) == {-Rational(3, 2): 5}
assert roots(((a * x - b)**5).expand(), x) == {+b / a: 5}
assert roots(((a * x + b)**5).expand(), x) == {-b / a: 5}
assert roots(x**2 + (-a - 1) * x + a, x) == {a: 1, 1: 1}
assert roots(x**4 - 2 * x**2 + 1, x) == {1: 2, -1: 2}
assert roots(x**6 - 4*x**4 + 4*x**3 - x**2, x) == \
{1: 2, -1 - sqrt(2): 1, 0: 2, -1 + sqrt(2): 1}
assert roots(x**8 - 1, x) == {
sqrt(2) / 2 + I * sqrt(2) / 2: 1,
sqrt(2) / 2 - I * sqrt(2) / 2: 1,
-sqrt(2) / 2 + I * sqrt(2) / 2: 1,
-sqrt(2) / 2 - I * sqrt(2) / 2: 1,
1: 1,
-1: 1,
I: 1,
-I: 1
}
f = -2016*x**2 - 5616*x**3 - 2056*x**4 + 3324*x**5 + 2176*x**6 - \
224*x**7 - 384*x**8 - 64*x**9
assert roots(f) == {
0: 2,
-2: 2,
2: 1,
-Rational(7, 2): 1,
-Rational(3, 2): 1,
-Rational(1, 2): 1,
Rational(3, 2): 1
}
assert roots((a + b + c) * x - (a + b + c + d), x) == {
(a + b + c + d) / (a + b + c): 1
}
assert roots(x**3 + x**2 - x + 1, x, cubics=False) == {}
assert roots(((x - 2) * (x + 3) * (x - 4)).expand(), x, cubics=False) == {
-3: 1,
2: 1,
4: 1
}
assert roots(((x - 2)*(x + 3)*(x - 4)*(x - 5)).expand(), x, cubics=False) == \
{-3: 1, 2: 1, 4: 1, 5: 1}
assert roots(x**3 + 2 * x**2 + 4 * x + 8, x) == {
-2: 1,
-2 * I: 1,
2 * I: 1
}
assert roots(x**3 + 2*x**2 + 4*x + 8, x, cubics=True) == \
{-2*I: 1, 2*I: 1, -2: 1}
assert roots((x**2 - x)*(x**3 + 2*x**2 + 4*x + 8), x) == \
{1: 1, 0: 1, -2: 1, -2*I: 1, 2*I: 1}
r1_2, r1_3 = Rational(1, 2), Rational(1, 3)
x0 = (3 * sqrt(33) + 19)**r1_3
x1 = 4 / x0 / 3
x2 = x0 / 3
x3 = sqrt(3) * I / 2
x4 = x3 - r1_2
x5 = -x3 - r1_2
assert roots(x**3 + x**2 - x + 1, x, cubics=True) == {
-x1 - x2 - r1_3: 1,
-x1 / x4 - x2 * x4 - r1_3: 1,
-x1 / x5 - x2 * x5 - r1_3: 1,
}
f = (x**2 + 2 * x + 3).subs({x: 2 * x**2 + 3 * x}).subs({x: 5 * x - 4})
r13_20, r1_20 = [Rational(*r) for r in ((13, 20), (1, 20))]
s2 = sqrt(2)
assert roots(f, x) == {
r13_20 + r1_20 * sqrt(1 - 8 * I * s2): 1,
r13_20 - r1_20 * sqrt(1 - 8 * I * s2): 1,
r13_20 + r1_20 * sqrt(1 + 8 * I * s2): 1,
r13_20 - r1_20 * sqrt(1 + 8 * I * s2): 1,
}
f = x**4 + x**3 + x**2 + x + 1
r1_4, r1_8, r5_8 = [Rational(*r) for r in ((1, 4), (1, 8), (5, 8))]
assert roots(f, x) == {
-r1_4 + r1_4 * 5**r1_2 + I * (r5_8 + r1_8 * 5**r1_2)**r1_2: 1,
-r1_4 + r1_4 * 5**r1_2 - I * (r5_8 + r1_8 * 5**r1_2)**r1_2: 1,
-r1_4 - r1_4 * 5**r1_2 + I * (r5_8 - r1_8 * 5**r1_2)**r1_2: 1,
-r1_4 - r1_4 * 5**r1_2 - I * (r5_8 - r1_8 * 5**r1_2)**r1_2: 1,
}
f = z**3 + (-2 - y) * z**2 + (1 + 2 * y - 2 * x**2) * z - y + 2 * x**2
assert roots(f, z) == {
1: 1,
Rational(1, 2) + y / 2 + sqrt(1 - 2 * y + y**2 + 8 * x**2) / 2: 1,
Rational(1, 2) + y / 2 - sqrt(1 - 2 * y + y**2 + 8 * x**2) / 2: 1,
}
assert roots(a * b * c * x**3 + 2 * x**2 + 4 * x + 8, x,
cubics=False) == {}
assert roots(a * b * c * x**3 + 2 * x**2 + 4 * x + 8, x, cubics=True) != {}
assert roots(x**4 - 1, x, filter='Z') == {1: 1, -1: 1}
assert roots(x**4 - 1, x, filter='R') == {1: 1, -1: 1}
assert roots(x**4 - 1, x, filter='I') == {I: 1, -I: 1}
pytest.raises(ValueError, lambda: roots(x**4 - 1, x, filter='spam'))
assert roots((x - 1) * (x + 1), x) == {1: 1, -1: 1}
assert roots((x - 1) * (x + 1), x, predicate=lambda r: r.is_positive) == {
1: 1
}
assert roots(x**4 - 1, x, filter='Z', multiple=True) == [-1, 1]
assert roots(x**4 - 1, x, filter='I', multiple=True) == [I, -I]
assert roots(x**3, x, multiple=True) == [0, 0, 0]
assert roots(1234, x, multiple=True) == []
f = x**6 - x**5 + x**4 - x**3 + x**2 - x + 1
assert roots(f) == {
-I * sin(pi / 7) + cos(pi / 7): 1,
-I * sin(2 * pi / 7) - cos(2 * pi / 7): 1,
-I * sin(3 * pi / 7) + cos(3 * pi / 7): 1,
I * sin(pi / 7) + cos(pi / 7): 1,
I * sin(2 * pi / 7) - cos(2 * pi / 7): 1,
I * sin(3 * pi / 7) + cos(3 * pi / 7): 1,
}
g = ((x**2 + 1) * f**2).expand()
assert roots(g) == {
-I * sin(pi / 7) + cos(pi / 7): 2,
-I * sin(2 * pi / 7) - cos(2 * pi / 7): 2,
-I * sin(3 * pi / 7) + cos(3 * pi / 7): 2,
I * sin(pi / 7) + cos(pi / 7): 2,
I * sin(2 * pi / 7) - cos(2 * pi / 7): 2,
I * sin(3 * pi / 7) + cos(3 * pi / 7): 2,
-I: 1,
I: 1,
}
r = roots(x**3 + 40 * x + 64)
real_root = [rx for rx in r if rx.is_extended_real][0]
cr = 108 + 6 * sqrt(1074)
assert real_root == -2 * root(cr, 3) / 3 + 20 / root(cr, 3)
eq = Poly((7 + 5 * sqrt(2)) * x**3 + (-6 - 4 * sqrt(2)) * x**2 +
(-sqrt(2) - 1) * x + 2,
x,
domain='EX')
assert roots(eq) == {-1 + sqrt(2): 1, -2 + 2 * sqrt(2): 1, -sqrt(2) + 1: 1}
eq = Poly(41 * x**5 + 29 * sqrt(2) * x**5 - 153 * x**4 -
108 * sqrt(2) * x**4 + 175 * x**3 + 125 * sqrt(2) * x**3 -
45 * x**2 - 30 * sqrt(2) * x**2 - 26 * sqrt(2) * x - 26 * x + 24,
x,
domain='EX')
assert roots(eq) == {
-sqrt(2) + 1: 1,
-2 + 2 * sqrt(2): 1,
-1 + sqrt(2): 1,
-4 + 4 * sqrt(2): 1,
-3 + 3 * sqrt(2): 1
}
eq = Poly(x**3 - 2 * x**2 + 6 * sqrt(2) * x**2 - 8 * sqrt(2) * x + 23 * x -
14 + 14 * sqrt(2),
x,
domain='EX')
assert roots(eq) == {
-2 * sqrt(2) + 2: 1,
-2 * sqrt(2) + 1: 1,
-2 * sqrt(2) - 1: 1
}
assert roots(Poly((x + sqrt(2))**3 - 7, x, domain='EX')) == \
{-sqrt(2) - root(7, 3)/2 - sqrt(3)*root(7, 3)*I/2: 1,
-sqrt(2) - root(7, 3)/2 + sqrt(3)*root(7, 3)*I/2: 1,
-sqrt(2) + root(7, 3): 1}
pytest.raises(PolynomialError, lambda: roots(x * y, x, y))
def test_roots_composite():
assert len(roots(Poly(y**3 + y**2*sqrt(x) + y + x, y, composite=True))) == 3
def test_sympyissue_7724():
e = x**4*I + x**2 + I
r1, r2 = roots(e, x), Poly(e, x).all_roots()
assert len(r1) == 4
assert {_.evalf() for _ in r1} == {_.evalf() for _ in r2}
