Nonrobustness is a well-known problem in many areas of computational science. Until now, robustness techniques and the construction of robust algorithms have been the province of experts in this field of research. We describe a new C/C++ library (Core) for robust numeric and geometric computation based on the principles of Exact Geometric Computation (EGC). Through our library, for the first time, any programmer can write robust and efficient algorithms. The Core Library is based on a novel numerical core that is powerful enough to support EGC for algebraic problems. This is coupled with a simple delivery mechanism which transparently extends conventional C/C++ programs into robust codes. We are currently addressing efficiency issues in our library: (a) at the compiler and language level, (b) at the level of incorporating EGC techniques, as well as the (c) the system integration of both (a) and (b). Pilot experimental results are described. The basic library is available at http://cs.nyu.edu...

We discuss floating-point filters as a means of restricting the precision needed for arithmetic operations while still computing the exact result. We show that interval techniques can be used to speed up the exact evaluation of geometric predicates and describe an efficient implementation of interval arithmetic that is strongly influenced by the rounding modes of the widely used IEEE 754 standard. Using this approach we engineer an efficient floating-point filter for the computation of the sign of a determinant that works for arbitrary dimensions. We validate our approach experimentally, comparing it with other static, dynamic and semi-static filters. 1

Abstract not found

We present MAPC, a library for exact representation of geometric objects -- specifically points and algebraic curves in the plane. Our library makes use of several new algorithms, which we present here, including methods for nding the sign of a determinant, finding intersections between two curves, and breaking a curve into monotonic segments. These algorithms are used to speed up the underlying computations. The library provides C++ classes that can be used to easily instantiate, manipulate, and perform queries on points and curves in the plane. The point classes can be used to represent points known in a variety of ways (e.g. as exact rational coordinates or algebraic numbers) in a unified manner. The curve class can be used to represent a portion of an algebraic curve. We have used MAPC for applications dealing with algebraic points and curves, including sorting points along a curve, computing arrangement of curves, medial axis computations, and boundary evaluation on curved primitives. As compared to earlier algorithms and implementations utilizing exact arithmetic, our library is able to achieve more than an order of magnitude improvement in performance.

In this paper, we reexamine in the framework of robust computation the Bentley-Ottmann algorithm for reporting intersecting pairs of segments in the plane. This algorithm has been reported as being very sensitive to numerical errors. Indeed, a simple analysis reveals that it involves predicates of degree 5, presumably never evaluated exactly in most implementation. Within the exact-computation paradigm we introduce two models of computation aimed at replacing the conventional model of real-number arithmetic. The first model (predicate arithmetic) assumes the exact evaluation of the signs of algebraic expressions of some degree, and the second model (exact arithmetic) assumes the exact computation of the value of...

We describe a perturbation scheme to overcome degeneracies and precision problems for algorithms that manipulate polyhedral surfaces using oating point arithmetic. The perturbation algorithm is simple, easy to program and completely removes all degeneracies. We describe a software package that implements it, and report experimental results. The perturbation requires O(n log 3 n+nDK 2 ) expected time and O(n log n+nK 2 ) working storage, and has O(n) output size, where n is the total number of facets in the surfaces, K is a small constant in the input instances that we have examined, D is a constant greater than K but still small in most inputs, and both might be as large as n in `pathological' inputs. A tradeoff exists between the magnitude of the perturbation and the efficiency of the computation. Our perturbation package can be used by any application that manipulates polyhedral surfaces and needs robust input, such as solid modeling, manufacturing and robotics. We describe an app...

We present a system, ESOLID, that performs exact boundary evaluation of low-degree curved solids in reasonable amounts of time. ESOLID performs accurate Boolean operations using exact representations and exact computations throughout. The demands of exact computation require a different set of algorithms and efficiency improvements than those found in a traditional inexact floating point based modeler. We describe the system architecture, representations, and issues in implementing the algorithms. We also describe a number of techniques that increase the efficiency of the system based on lazy evaluation, use of floating point filters, arbitrary floating point arithmetic with error bounds, and lower dimensional formulation of subproblems. ESOLID has been used for boundary evaluation of many complex solids. These include both synthetic datasets and parts of a Bradley Fighting Vehicle designed using the BRL-CAD solid modeling system. It is shown that ESOLID can correctly evaluate the boundary of solids that are very hard to compute using a fixed-precision floating point modeler. In terms of performance, it is about an order of magnitude slower as compared to a floating point boundary evaluation system on most cases. 1

In this paper we consider deterministic computation of the exact determinant of a dense matrix M of integers. We present a new algorithm with worst case complexity O \Gamma n 4 (log n + log jjM jj) + n 3 log 2 jjM jj \Delta , where n is the dimension of the matrix and jjM jj is a bound on the entries in M , but with average expected complexity O \Gamma n 4 + n 3 (log n + log jjM jj) 2 \Delta , assuming some plausible properties about the distribution of M . We will also describe a practical version of the algorithm and include timing data to compare this algorithm with existing ones. Our result does not depend on "fast" integer or matrix techniques.

Let P be a polyhedral subdivision in R 3 with a total of n faces. We show that there is an embedding oe of the vertices, edges, and facets of P into a subdivision Q, where every vertex coordinate of Q is an integral multiple of 2 \Gammadlog 2 n+2e . For each face f of P , the Hausdorff distance in the L1 metric between f and oe(f) is at most 3/2. The embedding oe preserves or collapses vertical order on faces of P . The subdivision Q has O(n 4 ) vertices in the worst case, and can be computed in the same time. 1 Introduction Geometric algorithms are usually described in the "real-number RAM" model of computation, where arithmetic operations on real numbers have unit cost. A programmer implementing a geometric algorithm must find some substitution for real arithmetic. The substitution of exact arithmetic on a subset of the reals, say the integers or the rationals, avoids the difficulties that can arise from naive substitution of floating-point arithmetic [4, 12, 14, 15]. The subs...

Sign determination is a fundamental problem in algebraic as well as geometric computing. It is the critical operation when using real algebraic numbers and exact geometric predicates. We propose an exact and efficient method that determines the sign of a multivariate polynomial expression with rational coefficients. Exactness is achieved by using modular computation. Although this usually requires some multiprecision computation, our novel techniques of recursive relaxation of the moduli and their variants enable us to carry out sign determination and comparisons by using only single precision. Moreover, to exploit modern day hardware, we exclusively rely on floating point arithmetic, which leads us to a hybrid symbolic-numeric approach to exact arithmetic. We show how our method can be used to generate robust and efficient implementations of real algebraic and geometric algorithms including Sturm sequences, algebraic representation of points and curves, convex hull and Voronoi...