Univariate Algebraic Kernel and Application to ... - CiteSeerX

Univariate Algebraic Kernel and Application to Arrangements 1

1

Sylvain Lazard , Luis Peñaranda , and Elias Tsigaridas

2

INRIA Nancy - Grand Est, LORIA, France. INRIA Sophia-Antipolis - Méditerranée, France. [email protected]

1 2

We present a cgal-based univariate algebraic kernel, which provides certied real-root isolation of univariate polynomials with integer coecients and standard functionalities such as basic arithmetic operations, greatest common divisor (gcd) and square-free factorization, as well as comparison and sign evaluations of real algebraic numbers. We compare our kernel with other comparable kernels, demonstrating the eciency of our approach. Our experiments are performed on large data sets including polynomials of high degree (up to 2 000) and with very large coecients (up to 25 000 bits per coecient). We also address the problem of computing arrangements of x-monotone polynomial curves. We apply our kernel to this problem and demonstrate its eciency compared to previous solutions available in cgal.

Abstract.

1

Introduction

Implementing geometric algorithms robustly is known to be a dicult task for two main reasons. First, all degenerate situations have to be handled and second, algorithms often assume a real-RAM model (a random-access machine where each register can hold a real number and each arithmetic operation has unit cost) which is not realistic in practice. In recent years, the paradigm of exact geometric computing has arisen as a standard for robust implementations [24]. In this paradigm, geometric queries, also called predicates, such as is a point inside, outside or on a circle?, are made exactly using, usually, either (i) exact arithmetic combined, for eciency, with interval arithmetic on doubles or (ii) interval arithmetic on arbitrary-xed-precision oating-point numbers combined with separation bounds; on the other hand, geometric constructions, such as the circle through three points or points of intersection between two curves, may be approximated. We address here one recurrent diculty arising when implementing algorithms dealing, in particular, with curved objects. Such algorithms usually require evaluating, manipulating and solving systems of polynomials equations and comparing their roots. One of the most critical parts of dealing with polynomials or polynomial systems is the isolation of the real roots and their comparison. We restrict here our attention to the case of univariate polynomials and address this problem in the context of

cgal, a C++ Computational Geometry

Algorithms Library, which is an open source project and became a standard for the implementation of geometric algorithms [4].

Cgal is designed in a modular fashion following the paradigm of generic

programming.

Algorithms are typically parameterized by a

traits

class which

encapsulates the geometric objects, predicates and constructions used by the algorithm. Algorithms can thus typically be implemented independently of the type of input objects. For instance, the core of a line-sweep algorithm for computing arrangements of plane curves [7] can be implemented independently of whether the curves are lines, line segments, or general curves; on the other hand, the elementary operations that depend on the type of the objects (such as, comparing

x-coordinates

of points of intersection) are implemented separately in

traits classes. Similarly, the model of computation, such as exact arbitrary-length integer arithmetic or approximate xed-precision oating-point arithmetic, are encapsulated in the concept of

kernel.

An implementation is thus typically sep-

arated in three or four layers, (i) the geometric algorithm which relies on (ii) a traits class, which itself relies on (iii) a kernel for elementary (typically geometric) operations.

Cgal provides several predened Cartesian kernels, for instance

allowing standard Cartesian geometric operations on inputs dened with dou-

i.e.,

bles and providing approximate constructions (

dened with double) but

exact predicates. However, a kernel can also rely on (iv) a number type which essentially encapsulates the type of number (such as, double, arbitrary-length integers, intervals) and the associated arithmetic operations. A choice of traits classes, kernels and number types is useful as it gives freedom to the users and it makes it easier to compare and improve the various building blocks of an implementation. Our Contributions. We present in this paper a

cgal-compliant algebraic ker-

nel that provides real-root isolation of univariate integer polynomials and basic operations,

i.e. comparisons and sign evaluations, of real algebraic numbers. This

open-source kernel follows the

cgal specications for algebraic kernels [3]. The

root isolation is based on the interval Descartes algorithm [5] and uses the library

rs [19]. Moreover, our kernel provides various operations for polynomials, such as gcd, which are crucial for manipulating algebraic numbers. We compare our kernel with other comparable kernels and demonstrate the eciency of our approach. We perform experiments on large data sets including polynomials of high degree (up to 2 000) and with very large coecients (up to 25 000 bits per coecient). Finally, we apply our kernel to the problem of computing arrangements of

x-

monotone polynomial curves and demonstrate its eciency compared to previous solutions available in

cgal.

Related work. Combining algebra and geometry for manipulating non-linear

objects has been a long-standing challenge. Previous work includes, but it is not limited to,

mapc [14] a library for manipulating points that are dened algeexacus

braically and handling curves in the plane. More recently, the library

[2], which handles curves and surfaces in computational geometry and supports various algebraic operations, was developed and partially integrated into

cgal.

The notion of algebraic kernel for

cgal was proposed in 2004 [11]; in this work, synaps library [15]. Sev-

the underlying algebraic operations were based on the

eral methods and algebraic kernels have been developed since then. One kernel was developed by Hemmer and Limbach [13] following the generic programming paradigm using the C++ template mechanism. This kernel is templated by the representation of algebraic numbers and by the real root isolation method, for which two classes have been developed; one is based on the Descartes method and the other on the Bitstream Descartes method [9]. This approach has the advantage to allow, in principle, using the best instances for both template arguments. Another kernel developed at

inria relies on the synaps library [15]. In this

kernel there are several approaches concerning real root isolation,

i.e.,

methods

based on Sturm subdivisions, sleeves approximations, continued fractions, and a symbolic-numeric combination of the sleeve and continued fractions methods (see [10]). Moreover, there are specialized methods for polynomials of degree less or equal than four [21]. Emiris et al. [10] presented some benchmarks of these various approaches in these two kernels as well as some tests on the kernel we present here. The authors mention that our kernel based on interval Descartes performs similarly to one approach (refer to as

ncf2) based on continued fractions [20] for coecients with ncf2 is more ecient for small bitsize. They conclude

(very) large bitsize but

that, rst, dedicated algorithms for polynomials of degree less than (or equal to) four is always the most ecient approach and, second, that

ncf2 always

perform the best except for low-degree and high-bitsize polynomials, in which case the kernel based on the Bitstream Descartes method performs the best. We moderate here these conclusions. The rest of the paper is structured as follows. In the next section we describe our algebraic kernel. In Section 3, we present various experiments on the isolation of real roots and on the comparison of algebraic numbers. In Section 4, we apply our kernel to the problem of computing arrangements and compare it to previous solutions available in

2

cgal. We nally conclude in Section 5.

Univariate algebraic kernel

We describe here our implementation of our univariate algebraic kernel. The two main requirements of the

cgal specications, which we describe here, are the

isolation of real roots and their comparison. We also describe our implementation of two operations, the gcd computation and the renement of isolating intervals, that are both needed for comparing algebraic numbers.

Preliminaries.

The kernel handles univariate polynomials and algebraic num-

bers. The polynomials have integer coecients and are represented by arrays of

gmp arbitrary-length integers [12]. We implemented in the kernel the basic

functions for polynomials. An algebraic number that is a root of a polynomial is represented by

F

F

and an isolating interval, that is an interval containing this

root but no other root of

F.

We implemented intervals using the

mpfi library

mpfr arbitrary-xed-precision oatingmpfr is developed on top of the gmp library for

[16], which represents intervals with two point numbers [17]; note that

multi-precision arithmetic [12].

Root isolation.

For isolating the real roots of univariate polynomials with integer

coecients, we developed an interface with the library

rs

[19]. This library

is written in C and is based on Descartes' rule for isolating the real roots of univariate polynomials with integer coecients.

rs library; see [18] for deRs is based on an algorithm known as interval Descartes [5]; namely, the

We briey detail here the general design of the tails.

coecients of the polynomials obtained by changes of variable, sending intervals

[a, b]

onto

[0, +∞],

are only approximated using interval arithmetic when

this is sucient for determining their signs. Note that the order in which these transformations are performed in

rs is important for memory consumption. The mpfi library.

intervals and operations on them are handled by the

Algebraic number comparison. ments of the numbers

r1

As mentioned above, one of the main require-

cgal algebraic kernel specications is to compare two algebraic

and

r2 .

If we are lucky, their isolating intervals do not overlap and

the comparison is straightforward. This is, of course, not always the case. If we knew that they were not equal, we could rene both isolating intervals until they are disjoint. Hence, the problem reduces to determining whether the algebraic numbers are equal or not. To do so, we compute the square-free factorization of the gcd of the polynomials associated to the algebraic numbers. The roots of this gcd are the common roots of both polynomials. We calculate the intersection, tervals of

r1

and

r2 .

I,

of the isolating in-

r1 = r2 . I , it suces to check the

The gcd has a root in this interval if and only if

To determine whether the gcd has a root in interval

I : if they are dierent or one of them is r1 = r2 ; otherwise, r1 6= r2 and we can rene

sign of the gcd at the endpoints of the gcd has a root in

I

and

zero, both

intervals until they are disjoint.

Gcd computations.

Computing greatest common divisors between two polyno-

mials is not a dicult task, however, it is not trivial to do so eciently. A naive implementation of the Euclidean algorithm works ne for small polynomials but the intermediate coecients suer an exponential grow in size, which is not manageable for medium to large size polynomials. We thus implemented a

modular

gcd function. We did not use some existing implementations mainly for eciency because converting polynomials from one representation to another is substantially costly as soon as the degree and bitsize are large. Our function calculates the gcd of polynomials modulo some prime numbers and reconstructs later the

Chinese remainder theorem. (See e.g., [23] for details.) Rening isolating intervals. As we mentioned before, rening the interval repreresult with the help of the

senting an algebraic number is critical for comparing such numbers. We provide two approaches for renement. Both approaches require that the polynomial associated to the algebraic number is square free. The rst step thus consists of computing the square-free part of the polynomial (by computing the gcd of the polynomial and its derivative).

3

30

2

isolation time [ms]

40

isolation time [ms]

4

Our kernel MPII's SYNAPS'kernel kernel

20

1

Our kernel MPII's SYNAPS'kernel kernel 400 coecient 800 1200 1600 2000 bitsize

00

10 00

10000 coecient 20000 30000 bitsize 40000 50000

(a)

(b)

Running time for isolating all the real roots of degree 12 polynomials with 12 real roots in terms of the maximum bitsize of their coecients. Fig. 1.

Our rst approach is a simple bisection algorithm. It consists in calculating the sign of the polynomial associated to the algebraic number at the endpoints and midpoint of the interval. Depending on these signs, we rene the isolating interval to its left of right half. Our second approach is a quadratic interval renement [1]. Roughly speaking, this method splits the interval in many parts and, based on a linear interpolation, guesses in which one the root lies. If the guess is correct, the algorithm divides in the next renement step the interval in more parts and, if not, in less. Unfortunately, even with our careful implementation this approach turns out to be, on average, only just a bit faster than the bisection approach. Our experiments showed that the bottleneck of the renement is the evaluation of polynomials.

3

Kernel benchmarks

In this section, we analyze the running time of the two main functions of our algebraic kernel, that (i) isolate the roots of a polynomial and (ii) compare two algebraic numbers that is, compare the roots of two polynomials. We also compare the performance of our kernel with the one based on the Bistream Descartes method [9] and developed by Hemmer and Limbach [13] (referred to as

mpii's kernel)3

and with a kernel based on continued fractions [20] and

developed on top of the

synaps library [15] (referred to as synaps' kernel).

All tests were ran on a single-core 3.2 GHz Intel Pentium 4 with 2 Gb of RAM and 2048 kb of cache memory, using 64-bit Linux. Root isolation. We consider two suites of experiments in which we either x the

degree of the polynomials and vary the bitsize of the coecients or the converse;

3

We parameterized mpii's kernel to use Bitstream Descartes as root isolator, algebraic_real_bfi_rep as algebraic number representation and core integers and rationals to represent the coecients of the polynomials and the isolation bounds of algebraic numbers, respectively. The choice of core (vs. leda) was induced by the need of testing the kernels in the same conditions, that is, relying on gmp.

150 100 50

6 Our kernel MPII's kernel SYNAPS' kernel

5 isolation time [s]

isolation time [ms]

250 Our kernel MPII's kernel 200 SYNAPS' kernel

4

3

2

1

00

5000 coecient 10000 15000 bitsize 20000 25000

0

0

10

20

d

30

40

50

(a) (b) Running time for isolating all the real roots of (a) degree 100 polynomials in terms of the maximum bitsize of their coecients and (b) Mignotte polynomials of the form f = xd − 2(kx − 1)2 in terms of the degree d. Fig. 2.

see Figs. 1 and 2. In each experiment, we report the running time for isolating all the roots per polynomial, averaged over dierent trials, for our kernel, and

synaps' kernel.

Varying bitsize.

mpii's

We study here polynomials with rather low degree (12) but

with no complex root and polynomials with reasonably large degree (100) with random coecients (and thus with few real roots). The rst test sets comes from [13]. See Fig. 1. It consists of polynomials of degree 12, each one being the product of six degree-two polynomials with two roots, at least one of them in the interval

[0, 1];

every polynomial thus has

12 real roots. We vary the maximum bitsize of all the coecients of the input polynomial from 100 to 50 000 and average each test over 250 trials. Secondly, we consider random polynomials with constant degree 100 and coecients with varying bitsize. See Fig. 2(a). Note that such random polynomials have few roots: the expected number of real roots of a polynomial of degree

d

with coecients independently chosen from the standard normal distribution

2 2 2 π ln(d) + C + πd + O(1/d ) where C ≈ 0.625735 [8]; this gives, for degree 100 an average of about 3.6 roots (note that this bound matches extremely well is

experimental observations). We vary the maximum bitsize of all the coecients from 2 000 to 25 000 and average each test over 100 trials.

Varying degree.

We consider two sets of experiments in which we study random

polynomials and Mignotte polynomials (which have two very close roots). We rst consider polynomials with random coecients of xed bitsize for various values between 32 and 1 000. We then vary the degree of the polynomials from 100 to 2 000 and average our experiments over 100 trials (see Fig. 3). Note that the above formula gives an expected number of roots varying from 3.6 to 5.5. We observe that the running time is almost independent of the bitsize in the considered range. Finally, we test Mignotte polynomials, that is polynomials of the form

2(kx − 1)

2

xd −

. Such polynomials are known to be challenging for Descartes algo-

rithms because two of their roots are very close to each other; the isolating in-

25

70 Our kernel MPII's kernel SYNAPS' kernel

15

10

Our kernel MPII's kernel SYNAPS' kernel

60 isolation time [s]

isolation time [s]

20

50 40 30 20

5 10 0

0

500

1000 1500 polynomial degree

2000

0

0

500

1000 1500 polynomial degree

(a)

2000

(b)

Running time for isolating all the real roots of random polynomials with coefcients of bitsize (a) 32 and (b) 1000, and depending on the degree. Fig. 3.

tervals for these two roots are thus very small. For these tests, we used Mignotte polynomials with coecients of bitsize 50, with varying degree

d

from 5 to 50.

See Fig. 2(b). We averaged the running time over 5 trials for each degree. We observed essentially no dierence between our kernel and MPII's one; they take roughly 0.2 and 5.5 seconds for Mignotte polynomials of degree 20 and 50, respectively. However,

synaps' kernel is much more ecient as the continued fractions

algorithm is not so aected by the closeness of the roots.

Discussion.

We observe (Fig. 1(a)) that

both our and

mpii's

synaps' kernel is more ecient than

kernel in the case of polynomials of small degree (

e.g.,

twelve) and small to moderately large coecients (up to 2 000 bits per coefcient). However, for extremely large coecients

mpii's kernel is substantially

more ecient (by a factor of up to 3 for coecients of up to 50 000 bits) than both our and

synaps' kernels, which perform similarly.

synaps' kernels mpii's kernel; furthermore these two kernels behave

For polynomials of reasonable large degree, both our and are much more ecient that

similarly for degrees up to 1 500 and our kernel becomes more ecient for higher degrees (by a factor 2 for degree 2 000). We also observe that the running time is

highly

dependent of the various

settings. For instance, our kernel is up to 5 times slower when using approximate evaluation for high-degree and high-bitsize polynomials. Also,

mpii's kernel is in leda,

some cases about 10 times slower when changing the arithmetic kernel to

the representation of algebraic numbers and some internal algorithms such as

mpii's and synaps' kernels are substantially better than in Emiris et al. experiments [10]. We also observe that the running time of mpii's kernel is unstable in our the renement function. This explains why our benchmarks on both

experiments (Figs. 1 and 2(a)); surprisingly, this instability occurs when the experiments are performed on a 64-bits architecture, but it is stable on 32-bits architecture as shown in previous experiments [10].

comparison time [ms]

750

1000

Our bisection MPII's quadratic MPII's bisection

750

comparison time [ms]

1000

500

500

250 00

Our bisection MPII's quadratic MPII's bisection

250 00

500 1000 1500bitsize 2000 2500 3000 coecient

500 1000 1500bitsize 2000 2500 3000 coecient

(a)

(b)

Running time for comparing two distinct close roots of two almost identical polynomials of degree 20 with (a) no common roots and (b) a common factor of degree 10. Fig. 4.

Comparison of algebraic numbers. We consider three suites of experiments

for comparing algebraic numbers; see Fig. 4. Recall that an algebraic number

ρ

is here represented by a polynomial

interval containing

ρ

F

but no other root of

that vanishes at

F.

ρ

and an isolating

Recall also that the comparison of

two algebraic numbers is done by (i) testing whether the intervals are disjoint; if so, report the ordering, otherwise (ii) compute the gcd of the two polynomials and test whether the gcd vanishes in the intersection of the two intervals; if so, report the equality of the numbers, otherwise (iii) rene the intervals until they are disjoint. First, we analyze the cost of trivial comparisons that is, when the two intervals are disjoint. For that we compare the roots of two random polynomials. We observe that, as expected, the comparison time is negligible and independent of both the degree of the polynomials and the bitsize of their coecients. Second, we analyze the cost of comparing roots that are very close to each other but whose associate polynomials have no common root. This case is expensive because we need to rene the intervals until they do not overlap; this is, however, not the worst situation because the gcd of the two polynomials is 1 which is tested eciently with a modular gcd. We perform these experiments as follows. We generate pairs of polynomials, one with random coecients and the other by only adding 1 to one of the coecients of the rst polynomial. Such polynomials are such that the

i-th

roots of both polynomials are very close to

each other. We generate such pairs of polynomials with constant degree (equal to 20) and vary the maximum bitsize of the coecients. As the bitsize increases, the pairs of roots that are close become even closer and thus the comparison time increases. The results of these experiments are presented in Fig. 4(a), which reports the average running time for comparing two close roots. We show in this gure three curves, one corresponding to our bisection algorithm, and two corresponding the two renement methods implemented in the usual bisection and a quadratic renement algorithm.

mpii's kernel: the

Third, we consider the, a priori, most expensive scenario in which we compare roots that are either equal or very close to each others and such that their associate polynomials have some roots in common. In this case, we accumulate the cost of computing a non-trivial gcd of the two polynomials with the cost of rening intervals when comparing two non-equal roots. In practice, we generate pairs of degree-20 polynomials each dened as the product of two degree-10 terms; one of these factors is random and common to the two polynomials; the other factor is random in one of the polynomials and slightly modied in the other polynomial where, slightly modied means, as above, that we add 1 to one of the coecients. We then vary the maximum bitsize of the coecients.

Discussion.

We see in Fig. 4 that the

mpii's quadratic renement algorithm

largely outperforms the two bisection methods. However, our bisection method is faster than

mpii's one, by a factor up to 10. We also observed that the running

time for comparing equal roots is negligible compared to the cost of comparing close but distinct roots. (The running time reported in Fig. 4(b) is actually the total time for comparing all pairs of roots divided by the number of comparisons of close but distinct roots.) This explains why our kernel behaves similarly in Figs. 4(a) and 4(b). Overall, it appears that comparing algebraic numbers that are very close is fairly time consuming and that the most time-consuming part of the comparison is the evaluation of polynomials performed during the interval renements.

4

Arrangements

As an example of possible benet of having ecient algebraic kernels in

cgal,

we used our implementation to construct arrangements of polynomial functions. Wein and Fogel [22] provided a

cgal package for calculating arrangements of

general curves which requires as parameter a

traits class

containing the data

structures to store the curves and various primitive operations, such as comparing the relative positions of points of intersection. We implemented a traits class which uses the functions of our algebraic kernel and compared its performance with another traits classes which comes with uses the

Core library [6].

cgal's arrangement package and

In order to generate challenging data sets we proceed as follows. First we

n

random polynomials. To each of them we add 1 to the constant

coecient,

m times, thus producing a data set of n(m+1) univariate polynomials.

generate

Notice that the arrangement of the graphs of these polynomials is guaranteed to be degenerate,

i.e.,

x-coordinate. The n of initial the degree d of the

there are intersections with the same

arrangements generated this way have four parameters: the number polynomials, the number

m

polynomials, and the bitsize

of shifts that we perform,

τ

of their coecients. We ran experiments varying

the values of the last three of these parameters and setting Fig. 5(a) shows the running time in terms of the bitsize

d = 20

and

m=4

τ

n = 5. for a data set where

(giving 25 polynomials). Fig. 5(b) shows the running time

in terms of the degree

d

for a second data set where

τ = 32

and

m = 4.

We

200

construction time [s]

150

construction time [s]

200

Our COREkernel

100

100

50 00

Our kernel CORE

150

200 coecient 400 bitsize 600 800

1000

50 0

0

40

(a)

80

120 degree

160

200

(b)

Arrangements of ve polynomials, shifted four times each, (a) of degree 20 and varying bitsize and (b) of bitsize 32 and varying degree.

Fig. 5.

see from these experiments that running time using

Core is considerably higher

than when using our kernel. We also make the following observations. Fig. 5(a) shows that the running time depends on the bitsize. When we change the bitsize of the coecients of the random polynomials, the size of the arrangement does not change; that means that the number of comparisons and root isolations the kernel must perform is roughly the same in all the arrangements of the test suite. The isolation time for random polynomials does not depend much on the bitsize (as shown in Fig. 2(a)), but the comparison time does. It follows that the running time increases with the bitsize. Fig. 5(b) shows that the running time depends also on the degree of the input polynomials. As we saw in Section 3, the expected number of real roots of a random polynomial depends on its degree. The size of the arrangement thus increases with the degree of the input polynomials: each vertex is the root of the dierence between two input polynomials, therefore there will be more vertices. Thus, when we increment the degree of the inputs, the number of comparisons and isolations increases; furthermore, the running time for each of these operations increases with the degree of the input.

5

Conclusion

We presented a new

cgal-compliant

algebraic kernel that provides certied

real-root isolation of univariate polynomials with integer coecients based on the interval Descartes algorithm. This kernel also provides the comparison of algebraic numbers and other standard functionalities. We compared our kernel with other comparable kernels on large data sets including, for the rst time, polynomials of high degree (up to 2 000) and with extremely large coecients (up to 25 000 bits per coecient). We demonstrated the eciency of our approach and showed that it performs similarly, in most cases, with one kernel based on the

synaps library; more precisely, our kernel is

more ecient for polynomials of very large degree (greater than 1 800) and less ecient for polynomials of very small degree and with small to moderate size coecients. Also, our kernel is a lot more ecient that the kernel developed at

mpii for polynomials of large degree (greater than 200); it is however less ecient for polynomials of small degree and with extremely large coecients. Our tests indicate that the kernel developed at

mpii appears to be less ecient

than the other two for polynomials of large degree. However it should be stressed that this kernel is the only one among the three that is templeted by the number type of the coecients. Of course this does not imply that eciency is necessarily lost by following the generic programming paradigm, but it does imply that, from the user point of view, some substantial gain of eciency can sometimes be made by using a kernel that does not follow this paradigm. We also compared the performance of the kernels on the comparison of algebraic numbers. We observed in these tests that the bisection algorithm runs much faster when it is specialized on a number type since it allows for low level optimizations, conrming thus the assertion in the previous paragraph. On the other hand, it becomes evident that the bisection method is not the most ecient algorithm when a large number of renements is needed, and

mpii's quadratic

renement is the fastest method by far. A fairly large choice of algebraic kernels and, in particular, of methods for isolating the real roots of polynomials, is now available in

Cgal. This allows,

in particular, to compare and improve the various methods. It appears that between the two big classes of methods, based on continued fractions and Descartes algorithms, neither is clearly much better than the other. However, some substantial dierences appear between the various implementations, but, of course, it is always very dicult to benchmark implementations. For instance, we observed here that the running times are highly dependent of the various settings and architectures. Finally, we also address the problem of computing arrangements of

x-monotone

polynomial curves. We apply our kernel to this problem and demonstrate its efciency compared to previous solutions available in

cgal.

Acknowledgments

The authors are grateful to F. Rouillier, Z. Zafeirakopoulos, M. Hemmer, E. Berberich, M. Kerber, and S. Limbach for fruitful discussions and suggestions.

References 1. J. Abbott. Quadratic interval renement for real roots. In International Symposium on Symbolic and Algebraic Computation (ISSAC), poster presentation, 2006. 2. E. Berberich, A. Eigenwillig, M. Hemmer, S. Hert, L. Kettner, K. Mehlhorn, J. Reichel, S. Schmitt, E. Schömer, and N. Wolpert. EXACUS: Ecient and Exact Algorithms for Curves and Surfaces. In Proc. 13th Annual European Symposium on Algorithms (ESA), volume 1669 of LNCS, pages 155166. Springer, 2005. 3. E. Berberich, M. Hemmer, M. Karavelas, and M. Teillaud. Revision of the interface specication of algebaic kernel. Technical Report ACS-TR-243301-01, ACS European Project, 2007. 4. Cgal, Computational Geometry Algorithms Library. http://www.cgal.org. 5. G. Collins, J. Johnson, and W. Krandick. Interval Arithmetic in Cylindrical Algebraic Decomposition. Journal of Symbolic Computation, 34(2):145157, 2002.

6. The Core library. http://cs.nyu.edu/exact/. 7. M. de Berg, O. Cheong, M. van Kreveld, and M. Overmars. Computational Geometry: Algorithms and Applications. Springer-Verlag, 3rd edition, 2008. 8. A. Edelman and E. Kostlan. How may zeros of a random polynomial are real? Bulletin of American Mathematical Society, 32(1):137, Jan 1995. 9. A. Eigenwillig, L. Kettner, W. Krandick, K. Mehlhorn, S. Schmitt, and N. Wolpert. A Descartes Algorithm for Polynomials with Bit-Stream Coecients. In Proc. 8th Int. Workshop on Computer Algebra in Scient. Comput. (CASC), volume 3718 of LNCS, pages 138149. Springer, 2005. 10. I. Emiris, M. Hemmer, M. Karavelas, S. Limbach, B. Mourrain, E. Tsigaridas, and Z. Zafeirakopoulos. Cross-benchmarks for univariate algebraic kernels. Technical Report ACS-TR-363602-02, ACS European Project, 2008. 11. I. Z. Emiris, A. Kakargias, S. Pion, M. Teillaud, and E. P. Tsigaridas. Towards and open curved kernel. In Proc. 20th Annual ACM Symp. on Computational Geometry (SoCG), pages 438446, New York, USA, 2004. 12. Gmp, Gnu multiple precision arithmetic library. http://gmplib.org/. 13. M. Hemmer and S. Limbach. Benchmarks on a generic univariate algebraic kernel. Technical Report ACS-TR-243306-03, ACS European Project, 2006. 14. J. Keyser, T. Culver, D. Manocha, and S. Krishnan. Ecient and exact manipulation of algebraic points and curves. Computer-Aided Design, 32(11):649662, 2000. 15. B. Mourrain, P. Pavone, P. Trébuchet, E. P. Tsigaridas, and J. Wintz. Synaps, a library for dedicated applications in symbolic numeric computations. In M. Stillman, N. Takayama, and J. Verschelde, editors, IMA Volumes in Mathematics and its Applications, pages 81110. Springer, New York, 2007. http://synaps.inria.fr. 16. Mpfi, multiple precision interval arithmetic library. http://perso.ens-lyon.fr/ nathalie.revol/software.html. 17. Mpfr, library for multiple-precision oating-point computations. http://mpfr. org/. 18. F. Rouillier and Z. Zimmermann. Ecient isolation of polynomial's real roots. J. of Computational and Applied Mathematics, 162(1):3350, 2004. 19. Rs, a software for real solving of algebraic systems. F. Rouillier. http://fgbrs. lip6.fr. 20. E. P. Tsigaridas and I. Z. Emiris. On the complexity of real root isolation using Continued Fractions. Theoretical Computer Science, 392:158173, 2008. 21. E. P. Tsigaridas and I. Z. Emiris. Real algebraic numbers and polynomial systems of small degree. Theoretical Computer Science, 409(2):186  199, 2008. 22. R. Wein and E. Fogel. The new design of CGAL's arrangement package. Technical report, Tel-Aviv University, 2005. 23. C. Yap. Fundamental Problems of Algorithmic Algebra. Oxford University Press, Oxford-New York, 2000. 24. C. Yap. Robust geometric computation. In J. E. Goodman and J. O'Rourke, editors, Handbook of Discrete and Computational Geometry, chapter 41, pages 927 952. Chapmen & Hall/CRC, Boca Raton, FL, 2nd edition, 2004.