def complex_roots(p, skip_squarefree=False, retval='interval', min_prec=0):
"""
Compute the complex roots of a given polynomial with exact
coefficients (integer, rational, Gaussian rational, and algebraic
coefficients are supported). Returns a list of pairs of a root
and its multiplicity.
Roots are returned as a ComplexIntervalFieldElement; each interval
includes exactly one root, and the intervals are disjoint.
By default, the algorithm will do a squarefree decomposition
to get squarefree polynomials. The skip_squarefree parameter
lets you skip this step. (If this step is skipped, and the polynomial
has a repeated root, then the algorithm will loop forever!)
You can specify retval='interval' (the default) to get roots as
complex intervals. The other options are retval='algebraic' to
get elements of QQbar, or retval='algebraic_real' to get only
the real roots, and to get them as elements of AA.
EXAMPLES::
sage: from sage.rings.polynomial.complex_roots import complex_roots
sage: x = polygen(ZZ)
sage: complex_roots(x^5 - x - 1)
[(1.167303978261419?, 1), (-0.764884433600585? - 0.352471546031727?*I, 1), (-0.764884433600585? + 0.352471546031727?*I, 1), (0.181232444469876? - 1.083954101317711?*I, 1), (0.181232444469876? + 1.083954101317711?*I, 1)]
sage: v=complex_roots(x^2 + 27*x + 181)
Unfortunately due to numerical noise there can be a small imaginary part to each
root depending on CPU, compiler, etc, and that affects the printing order. So we
verify the real part of each root and check that the imaginary part is small in
both cases::
sage: v # random
[(-14.61803398874990?..., 1), (-12.3819660112501...? + 0.?e-27*I, 1)]
sage: sorted((v[0][0].real(),v[1][0].real()))
[-14.61803398874989?, -12.3819660112501...?]
sage: v[0][0].imag() < 1e25
True
sage: v[1][0].imag() < 1e25
True
sage: K.<im> = NumberField(x^2 + 1)
sage: eps = 1/2^100
sage: x = polygen(K)
sage: p = (x-1)*(x-1-eps)*(x-1+eps)*(x-1-eps*im)*(x-1+eps*im)
This polynomial actually has all-real coefficients, and is very, very
close to (x-1)^5::
sage: [RR(QQ(a)) for a in list(p - (x-1)^5)]
[3.87259191484932e-121, -3.87259191484932e-121]
sage: rts = complex_roots(p)
sage: [ComplexIntervalField(10)(rt[0] - 1) for rt in rts]
[-7.8887?e-31, 0, 7.8887?e-31, -7.8887?e-31*I, 7.8887?e-31*I]
We can get roots either as intervals, or as elements of QQbar or AA.
::
sage: p = (x^2 + x - 1)
sage: p = p * p(x*im)
sage: p
-x^4 + (im - 1)*x^3 + im*x^2 + (-im - 1)*x + 1
Two of the roots have a zero real component; two have a zero
imaginary component. These zero components will be found slightly
inaccurately, and the exact values returned are very sensitive to
the (non-portable) results of NumPy. So we post-process the roots
for printing, to get predictable doctest results.
::
sage: def tiny(x):
....: return x.contains_zero() and x.absolute_diameter() < 1e-14
sage: def smash(x):
....: x = CIF(x[0]) # discard multiplicity
....: if tiny(x.imag()): return x.real()
....: if tiny(x.real()): return CIF(0, x.imag())
sage: rts = complex_roots(p); type(rts[0][0]), sorted(map(smash, rts))
(<type 'sage.rings.complex_interval.ComplexIntervalFieldElement'>, [-1.618033988749895?, -0.618033988749895?*I, 1.618033988749895?*I, 0.618033988749895?])
sage: rts = complex_roots(p, retval='algebraic'); type(rts[0][0]), sorted(map(smash, rts))
(<class 'sage.rings.qqbar.AlgebraicNumber'>, [-1.618033988749895?, -0.618033988749895?*I, 1.618033988749895?*I, 0.618033988749895?])
sage: rts = complex_roots(p, retval='algebraic_real'); type(rts[0][0]), rts
(<class 'sage.rings.qqbar.AlgebraicReal'>, [(-1.618033988749895?, 1), (0.618033988749895?, 1)])
TESTS:
Verify that :trac:`12026` is fixed::
sage: f = matrix(QQ, 8, lambda i, j: 1/(i + j + 1)).charpoly()
sage: from sage.rings.polynomial.complex_roots import complex_roots
sage: len(complex_roots(f))
8
"""
if skip_squarefree:
factors = [(p, 1)]
else:
factors = p.squarefree_decomposition()
prec = 53
while True:
CC = ComplexField(prec)
CCX = CC['x']
all_rts = []
ok = True
for (factor, exp) in factors:
cfac = CCX(factor)
rts = cfac.roots(multiplicities=False)
# Make sure the number of roots we found is the degree. If
# we don't find that many roots, it's because the
# precision isn't big enough and though the (possibly
# exact) polynomial "factor" is squarefree, it is not
# squarefree as an element of CCX.
if len(rts) < factor.degree():
ok = False
break
irts = interval_roots(factor, rts, max(prec, min_prec))
if irts is None:
ok = False
break
if retval != 'interval':
factor = QQbar.common_polynomial(factor)
for irt in irts:
all_rts.append((irt, factor, exp))
if ok and intervals_disjoint([rt for (rt, fac, mult) in all_rts]):
all_rts = sort_complex_numbers_for_display(all_rts)
if retval == 'interval':
return [(rt, mult) for (rt, fac, mult) in all_rts]
elif retval == 'algebraic':
return [(QQbar.polynomial_root(fac, rt), mult) for (rt, fac, mult) in all_rts]
elif retval == 'algebraic_real':
rts = []
for (rt, fac, mult) in all_rts:
qqbar_rt = QQbar.polynomial_root(fac, rt)
if qqbar_rt.imag().is_zero():
rts.append((AA(qqbar_rt), mult))
return rts
prec = prec * 2
def complex_roots(p, skip_squarefree=False, retval='interval', min_prec=0):
"""
Compute the complex roots of a given polynomial with exact
coefficients (integer, rational, Gaussian rational, and algebraic
coefficients are supported). Returns a list of pairs of a root
and its multiplicity.
Roots are returned as a ComplexIntervalFieldElement; each interval
includes exactly one root, and the intervals are disjoint.
By default, the algorithm will do a squarefree decomposition
to get squarefree polynomials. The skip_squarefree parameter
lets you skip this step. (If this step is skipped, and the polynomial
has a repeated root, then the algorithm will loop forever!)
You can specify retval='interval' (the default) to get roots as
complex intervals. The other options are retval='algebraic' to
get elements of QQbar, or retval='algebraic_real' to get only
the real roots, and to get them as elements of AA.
EXAMPLES::
sage: from sage.rings.polynomial.complex_roots import complex_roots
sage: x = polygen(ZZ)
sage: complex_roots(x^5 - x - 1)
[(1.167303978261419?, 1), (-0.764884433600585? - 0.352471546031727?*I, 1), (-0.764884433600585? + 0.352471546031727?*I, 1), (0.181232444469876? - 1.083954101317711?*I, 1), (0.181232444469876? + 1.083954101317711?*I, 1)]
sage: v=complex_roots(x^2 + 27*x + 181)
Unfortunately due to numerical noise there can be a small imaginary part to each
root depending on CPU, compiler, etc, and that affects the printing order. So we
verify the real part of each root and check that the imaginary part is small in
both cases::
sage: v # random
[(-14.61803398874990?..., 1), (-12.3819660112501...? + 0.?e-27*I, 1)]
sage: sorted((v[0][0].real(),v[1][0].real()))
[-14.61803398874989?, -12.3819660112501...?]
sage: v[0][0].imag() < 1e25
True
sage: v[1][0].imag() < 1e25
True
sage: K.<im> = NumberField(x^2 + 1)
sage: eps = 1/2^100
sage: x = polygen(K)
sage: p = (x-1)*(x-1-eps)*(x-1+eps)*(x-1-eps*im)*(x-1+eps*im)
This polynomial actually has all-real coefficients, and is very, very
close to (x-1)^5::
sage: [RR(QQ(a)) for a in list(p - (x-1)^5)]
[3.87259191484932e-121, -3.87259191484932e-121]
sage: rts = complex_roots(p)
sage: [ComplexIntervalField(10)(rt[0] - 1) for rt in rts]
[-7.8887?e-31, 0, 7.8887?e-31, -7.8887?e-31*I, 7.8887?e-31*I]
We can get roots either as intervals, or as elements of QQbar or AA.
::
sage: p = (x^2 + x - 1)
sage: p = p * p(x*im)
sage: p
-x^4 + (im - 1)*x^3 + im*x^2 + (-im - 1)*x + 1
Two of the roots have a zero real component; two have a zero
imaginary component. These zero components will be found slightly
inaccurately, and the exact values returned are very sensitive to
the (non-portable) results of NumPy. So we post-process the roots
for printing, to get predictable doctest results.
::
sage: def tiny(x):
... return x.contains_zero() and x.absolute_diameter() < 1e-14
sage: def smash(x):
... x = CIF(x[0]) # discard multiplicity
... if tiny(x.imag()): return x.real()
... if tiny(x.real()): return CIF(0, x.imag())
sage: rts = complex_roots(p); type(rts[0][0]), sorted(map(smash, rts))
(<type 'sage.rings.complex_interval.ComplexIntervalFieldElement'>, [-1.618033988749895?, -0.618033988749895?*I, 1.618033988749895?*I, 0.618033988749895?])
sage: rts = complex_roots(p, retval='algebraic'); type(rts[0][0]), sorted(map(smash, rts))
(<class 'sage.rings.qqbar.AlgebraicNumber'>, [-1.618033988749895?, -0.618033988749895?*I, 1.618033988749895?*I, 0.618033988749895?])
sage: rts = complex_roots(p, retval='algebraic_real'); type(rts[0][0]), rts
(<class 'sage.rings.qqbar.AlgebraicReal'>, [(-1.618033988749895?, 1), (0.618033988749895?, 1)])
TESTS:
Verify that trac 12026 is fixed::
sage: f = matrix(QQ, 8, lambda i, j: 1/(i + j + 1)).charpoly()
sage: from sage.rings.polynomial.complex_roots import complex_roots
sage: len(complex_roots(f))
8
"""
if skip_squarefree:
factors = [(p, 1)]
else:
factors = p.squarefree_decomposition()
prec = 53
while True:
CC = ComplexField(prec)
CCX = CC['x']
all_rts = []
ok = True
for (factor, exp) in factors:
cfac = CCX(factor)
rts = cfac.roots(multiplicities=False)
# Make sure the number of roots we found is the degree. If
# we don't find that many roots, it's because the
# precision isn't big enough and though the (possibly
# exact) polynomial "factor" is squarefree, it is not
# squarefree as an element of CCX.
if len(rts) < factor.degree():
ok = False
break
irts = interval_roots(factor, rts, max(prec, min_prec))
if irts is None:
ok = False
break
if retval != 'interval':
factor = QQbar.common_polynomial(factor)
for irt in irts:
all_rts.append((irt, factor, exp))
if ok and intervals_disjoint([rt for (rt, fac, mult) in all_rts]):
all_rts = sort_complex_numbers_for_display(all_rts)
if retval == 'interval':
return [(rt, mult) for (rt, fac, mult) in all_rts]
elif retval == 'algebraic':
return [(QQbar.polynomial_root(fac, rt), mult) for (rt, fac, mult) in all_rts]
elif retval == 'algebraic_real':
rts = []
for (rt, fac, mult) in all_rts:
qqbar_rt = QQbar.polynomial_root(fac, rt)
if qqbar_rt.imag().is_zero():
rts.append((AA(qqbar_rt), mult))
return rts
prec = prec * 2
