Experimental Evaluation and Cross-Benchmarking
of Univariate Real Solvers
Michael Hemmer
MPI for Informatics
Saarbr
¨
ucken, Germany
hemmer@mpi-inf.mpg.de
Elias P. Tsigaridas
INRIA M´editerran´ee
Sophia-Antipolis, France
Elias.Tsigaridas@inria.fr
Zafeirakis Zafeirakopoulos
RISC
Linz, Austria
zafeirak@risc.uni-linz.ac.at
Ioannis Z. Emiris
University of Athens
Athens, Greece
emiris@di.uoa.gr
Menelaos I. Karavelas
University of Crete & FO.R.T.H.
Heraklion, Greece
mkaravel@tem.uoc.gr
Bernard Mourrain
INRIA M´editerran´ee
Sophia-Antipolis, France
Bernard.Mourrain@inria.fr
ABSTRACT
Real solving of univariate polynomials is a fundamental prob-
lem with several important applications. This paper is fo-
cused on the comparison of black-box implementations of
state-of-the-art algorithms for isolating real roots of univari-
ate polynomials over the integers. We have tested 9 differ-
ent implementations based on symbolic-numeric methods,
Sturm sequences, Continued Fractions and Descartes’ rule
of sign. The methods under consideration were developed
at the GALAAD group at INRIA, the VEGAS group at LO-
RIA and the MPI-Saarbr
¨
ucken. We compared th eir sensitiv-
ity with respect to various aspects such as degree, bitsize
or root separation of the input polynomials. Our datasets
consist of 5 000 polynomials from many different settings,
which have maximum coefficient bitsize up to bits 8 000,
and the total running time of the experiments was about 50
hours. Thereby, all implementations of the theoretically e x-
act methods always provided correct results throughout this
extensive study. For each scenario we identify the currently
most adequate method, and we point to weaknesses in each
approach, which should lead to further improvements. Our
results indicate that there is no “best meth od” overall, but
one can say that for most instances the solvers based on
Continued Fractions are among the best methods. To the
best of our knowledge, this is the largest number of tests for
univariate real solving up to date.
Categories and Subject Descriptors: I.1.2 [Symbolic
and Algebraic Manipulation]: Algorithms—Algebraic algo-
rithms; D.2.8 [Software Engineering]: Metrics—performance
measures
General Terms: Experimentation
Permission to make digital or hard copies of all or part of this work for
personal or classroom use is granted without fee provided that copies are
not made or distributed for profit or commercial advantage and that copies
bear this notice and the full citation on the first page. To copy otherwise, to
republish, to post on servers or to redistribute to lists, requires prior specific
permission and/or a fee.
SNC’09, August 3–5, 2009, Kyoto, Japan.
Copyright 2009 ACM 978-1-60558-664-9/09/08 ...$5.00.
Keywords: benchmarks, univariate polynomial, real root
isolation
1. INTRODUCTION
Real solving of univariate polynomials is one of the most fun-
damental research problems, the application range of which
touches almost all research areas. Moreover, it is one of th e
key ingredients for solving polynomial systems. This paper
is focused on the comparison of black-box implementations
of state-of-the-art algorithms for isolating real roots of uni-
variate polynomials over the integers, that is, the output
is supposed to consists of intervals with rational endpoints,
each containing exactly one real root of the polynomial
We consider two classes of algorithms for real root isola-
tion of integer polynomials. The first class consists of the
subdivision algorithms [7, 11, 23, 27, 8, 29, 16], which ex-
ploit either Sturm’s theorem or Descartes’ rule of signs. The
second class contains the Continued Fraction algorithms [1,
32, 30], which are based on t he continued fraction expan-
sion of th e roots of the polynomial. The best worst case
complexity bound for all these algorithms, after eliminat-
ing the (poly)logarithmic factors, is
e
O
B
(d
4
τ
2
), where d is
the degree of the polynomial and τ the maximum coefficient
bitsize. From a theoretical point of view, the goal is to pro-
pose algorithms with complexity bounds that are close to,
or match, the bound of the nearly optimal numerical algo-
rithm of Pan [28]. The worst case bound of the latter is
e
O
B
(d
3
τ ), which can be further improved to
e
O
B
(d
2
τ ), using
sophisticated splitting techniques.
However, in practice, things are quite different. There is
no implementation of the optimal numerical algorithm [28],
since it is very complicated. Moreover, the known efficient
implementations of numerical algorithms [5] could only cer-
tify their output using accuracy equal to the theoretical sep-
aration bound, that is, the smallest distance between two
(possible complex) roots of the polynomial. This makes
them quite inefficient. Moreover, with the exception of ran-
dom polynomials, exact algorithms are more efficient [20,
29, 32, 3, 22, 24] and evidently they can certify their results
in all cases. There is also a trend for symbolic-numeric algo-
rithms, which are a combination of both approaches. These
algorithms, roughly speaking, work with approximate, actu-
ally multi-precision, arithmetic, and if they can not certify
their result, then th ey increase the precision. We refer the
reader to [29, 11, 6] and references therein, for more details.
However, th e complexity of these algorithms is the same as
the complexity of their corresponding exact versions. Thus,
the main motivation for this work was to evaluate and com-
pare these algorithms experimentally.
Another motivation was the recent need to develop soft-
ware that exactly handles complex geometric objects. More-
over, our work was facilitated by the fact that CGAL
1
, the
Computational Geometry Algorithms Library, is aiming for
an algebraic kernel [4]. The univariate part basically consists
of th ree major component s: (i) a support for polynomials
covering fundamental methods such as GCD computation or
square free factorization, ( ii) a solver for real root isolation,
and (iii) a p roper handling of algebraic real numbers, that
is, their comparison, approx imation and refinement. Our
work is the serious evaluation of the different options for the
second component, namely the real root isolation.
Previous work includes [21] and [24]. The former de-
scribes benchmarks between a solver based on Sturm se-
quences and the Descartes-based solvers developed at the
MPI-Saarbr
¨
ucken. The major conclusion for real root isola-
tion was that for degrees ≥ 20 the latter are faster or much
faster. In [24], the authors introduced the CGAL-based u ni-
variate algebraic kernel of the VEGAS group, and presented
experiments on real root isolation and computation of ar-
rangements of x-monotone polynomial curves. For real solv-
ing, besides their solver, t hey also considered the Descartes-
based solver of MPI, and the NCF implementation of GALAAD’s
kernel. The presented experiments are of two kind: (i) de-
gree 12 polynomials, with only real ro ots and varying bit-
size, and random polynomials of degree 100, and (ii) random
polynomials with fixed bitsize (32 and 100) and varying de-
gree (up to 2 000), and Mignotte polynomials. Even though
the focus of this work was on the capabilities of the pro-
posed kernel, their conclusions on their set of solvers are
similar to ours. In this work we perform experiments with
6 additional solvers, and perform experiments on a richer
variety of datasets.
We h ave tested 9 different implementation that are based
on symb olic-numeric methods, Sturm sequences, Continued
Fractions and Descartes’ rule of sign. The methods under
consideration were developed at the GALAAD group at IN-
RIA, the VEGAS group at LORIA and the MPI-Saarbr
¨
ucken.
We compared their sensitivity with respect to various as-
pects such as degree, bitsize or root separation of the in-
put polynomials. Our datasets consist of 5 000 polynomials
from many different settings, which have maximum coeffi-
cient bitsize up to bits 8 000, and the total running time of
the experiment s was about 50 h ours. Thereby, all implemen-
tations of the theoretically exact methods always provided
correct results throughout this extensive study. All results
are accessible through a web interface
2
that provides tables
and graphs with respect to user specified parameters. To the
best of our knowledge, this is the largest number of tests for
univariate real solving up to date.
Our results ind icate that there is no“best method”overall,
but one can say that for most instances the solvers based on
1
http://www.cgal.org/
2
http://erga.di.uoa.gr/soft/zaf/unibench/index.html
Continued Fractions are among the best methods. For each
scenario we identify the currently most adequate method,
and we point to weaknesses in each approach, which should
lead to further improvements, see also Section 5.
The remaining part of the paper is structured as follows.
In Section 2 we discuss the different kernels and the inves-
tigated root solvers, in particular, we state the known com-
plexity bounds for these methods. In Section 3 we describe
the setup of the benchmarks and the used datasets. Sec-
tion 4 presents the results of the benchmarks and an analysis
with respect to certain parameters. In Section 6 we propose
possible directions for future work in univariate real solving.
2. ALGEBRAIC KERNELS
In analogy to the three developed algebraic kernels this sec-
tion is split into three parts. Each part will give insights
about interesting design aspects of the corresponding kernel.
For instance, we discuss the implementation of the square
free factorization, which is needed to determine the mul-
tiplicity of the roots. However, the main focus is on the
provided ro ot isolation methods. In particular, we state the
known theoretical complexity bounds of the methods.
In what follows O
B
-notation refers to bit complexity and
the
e
O
B
-notation means that we are ignoring (poly-)logarithmic
factors. Finally, in all cases, d will be the degree of the poly-
nomials and τ the maximum coefficient bitsize.
2.1 The GALAAD Kernel
The algebraic kernel by INRIA relies on SYNAPS, which in
turn is now provided by the package Realroot
3
of math-
emagix
4
. The mathemagix project is an open source effort
that provides fundamental algebraic operations such as alge-
braic number manipulation to ols, different types of univari-
ate and multivariate polynomial real root isolation methods,
resultant and GCD computations, etc. The main motivation
behind this project, is the need t o combine sy mbolic and nu-
meric computations, which is ubiquitous in many problems.
We refer the reader to [26] for more details.
The library provides 4 exact methods for real root isola-
tion of univariate polynomial with integer coefficients, namely
Sturm, CF, NCFF and NCF. Moreover, we investigated an ap-
proximative solver Sleeve, who’s computed intervals are
not necessarily isolating. And an experimental implemen-
tation of a hybrid Symbnum that combines Sleeve with the
CF method. For a discussion see the subsequ ent subsections.
Compared to the other kernels, a principal difference is
that most solvers in this library exp loit specialized algo-
rithms for polynomials of d egree up to 4. Hereafter, we
refer to these algorithms as IDS (Isolation and Discrimina-
tion Systems). These systems are based on pre-computed
Sturm sequences and they compute rational points that iso-
late the real roots, as functions in the coefficients of the
polynomial. The arithmetic complexity of these methods
is
e
O(1), whereas the bit-complexity is
e
O
B
(τ ), see [17, 31]
for more details. The algorithms that use IDS methods are
Sturm, Sleeve, Symbnum and CF. The solvers NCFF and NCF
do not apply IDS.
3
http://www-sop.inria.fr/galaad/mathemagix/realroot
4
http://www.mathemagix.org/
2.1.1 Sturm
A subdivision method based on Sturm’s th eorem. We refer
to it as ST in the figures. The algorithm employs polynomial
remainder sequences (PRS) as a real root counting query. In
order to determine whether a root is isolated by a certain
interval, the PRS is evaluated at the endpoints of the interval
at qu estion. Traditionally, it is expected to be the slowest
method. The major disadvantage of Sturm is that it must
compute the full PRS before it can even start to isolate the
roots. Moreover, the subsequent evaluation of the PRS is in
general more complex than other methods. Thus, we use
the method primarily as a reference. The complexity of the
algorithm is
e
O
B
(d
6
+ d
4
τ
2
), see also [8, 16, 9] and references
therein.
2.1.2 CF-Family
We investigated three solvers based on the Continued Frac-
tions algorithm (CF) algorithm. The CF algorithm com-
putes the continued fraction expansion of the real ro ots of
the polynomial to compute isolating interval for them. One
of its main ingredients is the computation of lower bounds
on the positive real roots. Different methods of computing
lower bounds, lead to different variants of the algorithm.
However, all investigated solvers in this article use the same
algorithm to compute lower bounds on the roots, namely
a modification of Hong’s bound proposed in [1]. We refer
the reader t o [30, 32, 1] and references therein, for a de-
tailed description. The method is known to be among the
most powerful root isolation approaches, in particular, for
ill-conditioned problems. A disadvantage is that the method
uses exact arithmetic throughout the algorithm, that is, in
terms of its bit-complexity the algorithm is not adaptive.
The worst case complexity of the algorithm is
e
O
B
(d
5
τ
2
) [30],
while the average case complexity is
e
O
B
(d
4
+ d
3
τ ) [32] , as-
suming that the Gauss-Kuzmin distribution holds for the
real algebraic numbers.
The three investigated solvers are CF, NCFF, and NCF.
CF This solver is an implementation of the CF algorithm
that does not use any external factorization tools. The
square free factorization is provided by the package re-
alroot of mathemagix. I n case the polynomial degree
is ≤ 4 the method employs IDS.
NCFF This method is based on the same algorithm, but the
implementation employs the NTL library for square
free factorization and factorization over the integers.
Integer arithmetic in NTL is based on GMP, which is
used through a SYNAPS-NTL conversions interface,
see [14]. NCFF does not apply IDS.
NCF The difference between NCFF and NCF is that NCF em-
ploys square free factorization, but not factorization
over the integers. NCF does not apply IDS.
2.1.3 Sleeve and Symbnum
Sleeve is an approximate real root isolation method that
uses double arithmetic. We refer to it as SV in the figures.
The method computes an “upper” and “lower” (i.e. a sleeve)
approximation of the polynomial. A Descartes-like subdivi-
sion algorithm is applied to the sleeve. The approximation
is refined, if possible, until the machine precision is reached.
The algorithm is certified in the sense that it can not miss
roots. However, an interval may contain more than one root.
In some cases we can certify the result using a sign test with
the first derivative and interval arithmetic, that is, we con-
sider the method as a possible filter. In case the polynomial
degree is ≤ 4 the method emp loys IDS.
Symbnum is an experimental symbolic-numeric algorithm,
which is a combination of the Sleeve and the Continued
Fraction algorithm. We refer to it as SN in the figures.
Initially the Sleeve algorithm runs and produces some in-
tervals, that may contain more than one real root. In the
sequel, using exact arithmetic, we compute the continued
fractions expansion of the real root(s) that are in the in-
terval, the resulting interval is transformed to (0, 1) and
the Sleeve algorithm is applied again (possible after scaling
the coefficients). In case the polynomial degree is ≤ 4 the
method employes IDS.
For the solvers using polynomials rep resented in the Bern-
stein basis (eg. “Sleeve” and “Symbnum”), the conversion to
approximate arithmetic is done via a basis conversion and
scaling using exact (rational) arithmetic and then rounding
the coefficients up and down to nearest approximate num-
bers. When the bit size of the input is increasing this con-
version is becoming significative.
Since the approximate solvers in some cases do not isolate
all the roots, but never miss one, they can be interesting
as filters within a given precision. This depends of course
on the applications where you are using these solvers, for
instance if th e input is not “exact”.
2.2 The MPI Kernel
The kernel provided by the MPI is developed within CGAL
and follows the generic programming paradigm [2] using the
template t echnique of C++. This allows the exchange of the
representation of the algebraic real roots as well as the real
root isolation method, which also selects the used coefficient
type. That is, the kernel can, potentially, combine the best
root isolator with the best representation of algebraic reals
due t o its generic design. In the context of this work th e
most important template argument is the second, namely
the ro ot isolator. In order to be a valid template argument
the interface of the isolator class must meet a few simple
requirements which are gathered in a so-called concept, for
an exact definition of this concept we refer the reader to [19].
Up to date, the MPI has developed two Descartes-based
root isolators, namely DSC and BSDSC. A major advantage
of both implementations is the possibility to exchange the
coefficient type. In particular, the BSDSC is inten ded to work
over algebraic extensions, as it is reported in [19, 10, 11], for
example, it can isolate roots of f (x, y)
|x=α
, where α is an
algebraic number.
By the time of the benchmarks the MPI kernel did not
employ modular arithmetic in order to compute the GCD,
which is used in the square-free factorization. During the
benchmarks, this proved to be a serious drawback in some
of the test cases. However, the two methods provided by
the MPI kernel will ben efit from the recent integration of a
modular GCD [18] into the polynomial package of CGAL.
2.2.1 DSC
A real root isolation method based on Descartes’ rule of
signs. The solver is integrated in CGAL and implemented ac-
cording to [7]. A major disadvantage is that the method
uses exact arithmetic throughout the algorithm, that is, in
terms of its bit-complexity t he algorithm does not adapt
to the hardness of the particular isolation problem. Tradi-
tionally, it is expected to be slower than the other methods.
Thus, we use the method primarily as a reference. Given the
new t ree bound in [12, 10] th e complexity of the algorithm
is
e
O
B
(d
4
τ
2
).
2.2.2 BSDSC
The method is named Bitstream-Descartes due to the fact
that the coefficients of the polynomial are converted to (po-
tentially infinite) bitstreams. A variant of the Descartes
method is used t o find isolating intervals for the real roots.
The advantage of this method is its adaptiveness in terms of
bit-complexity, see also [11, 10]. However, since the method
overestimates the number of required bits, it can happen
that the bitstreams become larger than t he actual coeffi-
cients. In this case the method may even become more costly
than the pure Descartes algorithm DSC. According to [10],
the worst case complexity of BSDSC is
e
O
B
(d
5
τ
2
).
2.3 The VEGAS Kernel
The kernel which is developed by the V EGAS group at LO-
RIA is based on the RS library
5
, which in turn is developed
by the SALSA group at INRIA-Rocquencourt, see [24, 29].
The kernel is dedicated for one particular coefficient type,
namely the GMP arbitrary-length integers. In the square
free factorization the kernel uses its own modular GCD im-
plementation. For root isolation the kernel interfaces the
solver provided by RS.
2.3.1 RS
The RS solver is based on the interval Descartes algorithm [6].
The algorithm uses multi-precision floating point arithmetic
to convert the coefficients to intervals of a certain initial pre-
cision. Thereafter, it tries to apply Descartes’ rule of signs
using interval arithmetic. In case this is not applicable the
algorithm increases th e precision of the approximations. In
order to improve the memory usage of the method, the im-
plementation takes special care about the order of the trans-
formations that are required for the application of Descartes’
rule of signs. The advantage of this method is its adaptive-
ness in terms of bit-complexity.
3. DATASETS
Our data sets cover classical benchmark instances such as
Mignotte polynomials or random polynomials as well as in-
stances motivated by geometric applications. In order to
reveal the advantages or disadvantages of the solvers with
respect to certain characteristics of th e input polynomials,
each data set tries to focus on a certain aspect. In total,
our benchmarks use 5 200 polynomials, distributed over 155
datasets:
[rnd] datasets contain polynomials with random integers
as coefficients. The degree of the polynomials ranges
from 3 to 100, whereas the bitsize of the coefficients
5
http://fgbrs.lip6.fr
ranges from 10 to 50, which is considered to be rather
small. Consequently, these polynomials are t he easi-
est to solve among the ones tested. However, random
polynomials are important, since they occu r naturally
in many p roblems.
[bts] datasets are intended to test the sensitivity of the
methods with respect to the coefficient length. The
datasets contain polynomials with random coefficients
but with significantly larger bitsize. The [bts] datasets
contain polynomials of degree between 3 and 100 and
bitsize in the range from 2 000 to 8 000. Note that
the polynomials in this dataset are not particularly
harder to solve than those contained in [rnd]. How-
ever, methods that are not adaptive are expected to
be more afflicted by the increased bitsize.
[3darr] are datasets that have already been used in [19].
The polynomials are motivated by compu tations of ar-
rangements in 3D. Each dataset contains 100 univari-
ate polynomials of b itsize 200, 400, 600, 800, 1 000,
1 200, 1 400, 1 600, 1 800 or 2 000 and degree 12. Each
polynomial is the product of six parabolas, where each
parabola has at least one root within the interval [−10, 10].
Consequently, all polynomials have 12 real roots.
[vorell] is a dataset that was generated by a concrete ge-
ometric application, namely the exact computation of
the Voronoi diagram of ellipses [13, 15]. The polynomi-
als are resultant s that describe all tritangent circles to
three ellipses. The dataset contains 10 p olyn omials of
degree 184. However, each polynomial has only 8 real
roots. The bitsize of each coefficient is, approximately,
3 500 bits.
[int]/[rat] datasets contain polynomials with integer and
rational roots, respectively. While the roots for the
construction of the polynomials are chosen uniformly
at random, there are cases with multiple selections of
the same root. (e.g. small bitsize, high degree). The
datasets consist of combinations of degree from 3 to
100 and bitsize from 10 to 50. These datasets provide
some insight concerning the behavior of the 9 methods
in “easy” problems.
[mgn] datasets contain Mignotte polynomials [25], that is
polynomials of the form x
d
− 2(kx − 1)
2
, of degree be-
tween 3 and 100 and bitsize from 10 to 50. The [mgn]
polynomials achieve very small real root separation,
having 2 real roots very close to each other. Usually,
the real root separation is not known a priori, thus it is
important to know how a method behaves in situations
of small real root separation.
All datasets u sed for the benchmarks are available at:
http://erga.di.uoa.gr/soft/zaf/unibench/index.html.
4. RESULTS AND DISCUSSION
The benchmarks took place on a 32-bit Pentium III with
256MB RAM memory, Debian 4.0 GNU/Linux. Compi-
lation was done using g++ version 4.1.2 with optimization
flags -O3 and -DNDEBUG. We used the internal release 271
of CGAL (released 03-Apr-2008), as well as the software li-
braries GMP
6
(version 4.2) and NTL
7
(version 5.4.1). The
MPI kernel, was instantiated with the integers provided by
the CORE library, which is also maintained by CGAL and
also based on GMP. The integer arithmetic of SYNAPS is
based on GMP, except for the approximative solvers that
naturally rely on usual floating point arithmetic. Moreover,
special efficient routines are available for converting to and
from NTL integer types. Time, in msec, was measured using
the clock() function of the ctime library.
For each method we measured th e time that was needed
to determine all real roots including the multiplicity of these
roots, that is, we implicitly tested the implemented square
free factorization as well. However, in the case of [3darr]
and [mgn] d atasets the polynomials where known to be
square free, which was indicated to the solvers by a cor-
respond ing flag.
In order to reduce noise, we computed the average time
over a number of iterations such that the total time for each
polynomial exceeded 1 msec. Since t here were only small
variances for different instances in the same dataset, the
rep orted time is the average over all polynomials in each
dataset. In case a method t ook more than 30 seconds for
some instance or it failed to isolate all the real roots of a
polynomial, we ignored the measurement.
In the sequel, we discuss the results with respect to the
characteristics of the p roblems, as well as robustness and
effectiveness issues. I n t he tables, bold entries indicate the
fastest method for each case.
4.1 Polynomials of low degree
Table 1 presents the timings for polynomials of low degree,
which originate from the various datasets. The best times in
each row are emp hasized. Note that the table does not list
Sturm, Sleeve, Symbnum and CF, since all these algorithms
apply the same method, namely IDS, for polynomials of de-
gree ≤ 4. In order to achieve higher accuracy in timing,
these tests included 100 iterations for each polynomial in
the set.
For the [rnd] instances, random polynomials with small
bitsizes, all solvers perform quite well. However, IDS meth-
ods are clearly the fastest, which is due to the small co-
efficient size of the input polynomials. For the Mignotte
polynomials [mgn] the advantage of the IDS method is even
more evident. This is due to the fact that, in the case of the
IDS methods, th e boundaries of the isolating intervals are in
principal computed directly by a formula, whereas the other
solvers have to subdivide several times to separate the close
roots of the Mignotte polynomials.
In case of polynomials from the [int] and [rat] d atasets,
the NCF is comparable or even faster than the IDS methods.
This is caused by the fact that, in the case of integer/rational
roots, the lower bound that is computed by the CF algorithm
is tight, that is, it equals the roots and the subdivision stops
immediately. The NCFF method can not take advantage from
this fact due t o the additional overhead of the factorization
procedure. BSDSC and RS can not detect these special roots
since both algorithms work with approximated coefficients.
6
http://gmplib.org/
7
http://www.shoup.net/ntl
Table 1. Polynomials of degree 3.
bits IDS NCFF NCF DSC BSDSC RS
[rnd]
10 0. 066 0. 288 0. 240 0. 256 0. 696 0. 520
20 0. 096 0. 280 0. 224 0. 568 0. 720 0. 696
30 0. 084 0. 688 0. 208 0. 624 0. 536 0. 880
40 0. 063 0. 672 0. 272 0. 392 0. 400 0. 880
50 0. 240 0. 720 0. 344 0. 328 1. 016 1. 016
[mgn]
10 0. 148 0. 800 1. 000 1. 560 1. 840 8. 800
20 0. 318 1. 920 1. 640 2. 400 1. 960 24. 400
30 0. 326 1. 920 2. 000 3. 800 2. 400 49. 000
40 0. 312 2. 000 2. 000 4. 000 2. 400 76. 800
50 0. 442 3. 000 3. 000 4. 400 4. 000 116. 000
[int]
10 0. 231 0. 856 0. 352 1. 040 1. 120 0. 824
20 0. 316 1. 160 0. 520 0. 720 0. 920 1. 600
30 0. 310 1. 520 0. 368 0. 560 1. 360 1. 200
40 0. 408 1. 400 0. 384 0. 720 1. 520 1. 440
50 0. 592 1. 880 0. 560 0. 920 1. 240 1. 520
[rat]
10 0. 293 0. 856 0. 312 0. 800 0. 600 1. 480
20 0. 326 1. 640 0. 336 1. 520 0. 720 1. 520
30 0. 378 1. 400 0. 368 0. 880 1. 040 1. 760
40 0. 464 1. 520 0. 344 1. 040 1. 200 1. 440
50 0. 856 1. 600 0. 376 1. 680 0. 560 1. 520
[bts]
2000 2. 1975 1. 896 1. 856 0. 880 0. 680 1. 288
4000 5. 342 2. 112 1. 400 1. 424 1. 560 1. 976
6000 2. 25 3. 280 1. 984 1. 856 1. 712 2. 800
8000 5. 884 4. 800 2. 480 1. 792 1. 680 3. 720
For random polynomials with moderate bitsize ([bts])
the BSDSC is finally faster than the other methods. The rea-
son is that it only uses a few leading bits of the polynomials
which is enough to isolate and certify the roots. Up to 4 000
bits, the NCF method is also comparable. IDS is not compet-
itive due to its non- adaptive implementation.
4.2 Polynomials of small real root sepa-
ration
The [mgn] datasets were incorporated into these benchmark s
in order to study the behavior of t he methods on inputs with
small root separation. This is important, since the real root
separation is usually not known a priori. In particular, th e
[mgn] instances force the subdivision based solvers to reach
their worst case complexity.
The results are given in Table 2. Note that the table
rep orts only one column for the CF-Family. This is due the
fact that the [mgn] instances are known to be square free,
which was indicated by a flag. Thus, the implementations
for CF, NCFF and NCF can be considered as identical since
they only differ in the way the square free factorization is
implemented.
For the [mgn] instances the CF-Family is clearly t he fastest
method. Even for moderate degrees, only the CF-Family is
capable of solving Mignotte polynomials in reasonable time.
For example, the times are not even comparable for [mgn]
of degree 30. The only method that is comparable up to
degree 10 is BSDSC and even though the root separation is
very small it is still faster than DSC. The RS solver performs
seriously worse, in particular, it is even slower than DSC.
The problem is due to the high memory consumption of the
algorithm. In cases of degree higher th an 30 the method
would run out of memory. As expected Sturm is the slowest
method.
Table 2 does not report on Sleeve and Symbnum since in
datasets of higher degrees or bitsizes both methods took
much longer than the other methods or even fail to isolate
all the real roots correctly. This is due to the use of inexact
double arithmetic within Sleeve.
![Figure 1. [bts] polynomials of degree 50](/figures/figure-1-bts-polynomials-of-degree-50-3vcb5xjj.webp)
![Table 5. [3darr] polynomials.](/figures/table-5-3darr-polynomials-22qv76tx.webp)
![Table 2. [mgn] polynomials.](/figures/table-2-mgn-polynomials-2b2wusnt.webp)
![Table 3. [bts] polynomials.](/figures/table-3-bts-polynomials-33g0mah0.webp)
