COURSE:
Robust Geometric Computation
Chee Yap
ABSTRACT:
Numerical nonrobustness is a widespread problem in scientific computation, especially in engineering applications. These lectures introduce an analysis of this problem. After surveying some alternative approaches, we proceed to explore an approach called Exact Geometric Computation (EGC). We treat underlying mathematical framework, the algorithmic tools and software techniques that can be brought to bear on this problem.
CONTENTS:
1. Introduction to Numerical NonRobustness
```		-- benign vs. catastrophic errors
-- examples:
inside vs outside
intersect 2 lines, is point on line?
-- root cause: fixed precision computation
-- IEEE Std (describe this)
-- history of floating point computation
-- Examples of geometric computation
convex hull, Vor diagram, linear programming
triangulations
```
2. Approaches to NonRobustness
```		-- language constructs
-- arithmetic fixes
-- finite precision geometry
-- Illustration: finite precision line
```
3. EGC
```		-- geometric = combinatoric + numeric
-- e.g. convex hull
-- e.g. shortest path
-- e.g. triangulated surface
-- consistency constraint
-- qualitative vs quantitative errors
-- the "pure consistency play"
(approach of Hopcroft et al)
-- if we assume input is consistent,
we prefer to guarantee the EXACT Combinatorial
structure.
-- egc clarified:
decision nodes determine the Exact combinatorial
structure!  Hence must evaluate signs correctly
-- naive egc (exact arithmetic, work of Yu)
-- nevertheless, it address a major source of non-robustness
-- role of floating point (work of Yap-Dube)
-- caveats:
* need for nominal exactness
* works only for "geometric computation"
(which may be only one aspect of the
computation, e.g., in physical simulation)
* wrong to go after pure consistency (Hoffmann/Hopcroft)
-- why it is a win:
separation of rounding geometry from computation
separation of symbolic perturbation
from cleanup
approximate arithmetic is superior to rational

```
4. Geometric Computation
```		-- geometric primitives
-- indepth study of some basic geometric algorithms
(convex hulls, Vor.diagrams, triangulation)

```
5. Algebraic Roots of Geometry
```		-- Tarski's notion of "geometric"
-- Decision problems for real closed fields
-- resultants
-- root bounds
-- limitations (major open problem about non-algebraic)

```
6. The CORE Model:
```		-- the basis to support EGC
-- 4 accuracy levels
-- difference bet precision and error bound
-- difference bet relative and abs precision
-- difference bet levels 2 and 3
-- allows user to choose to execute a program
at ANY point along some
speed vs. robustness curve
-- advantage of this model: debugging
-- "no change in (naive) programmer behavior"
* set epsilons to 0
* do not play with intervals

```
7. Floating Point Filters
```		-- static analysis of Fortune, van Wyk
-- dynamic analysis
-- LEDA's work
-- analysis of Preparata, Olivier

```
8. Geometric Rounding
```		-- why it is important
-- why it is more tractable than traditional approaches
-- snap rounding (Guibas et al)
-- greene-yao
-- fortune's

```
9. Symbolic Perturbation
```		-- another serious impediment to robustness:
need to enumerate all special cases
(grows exponentially with dimension)
-- Yap's method
-- Seidel's method
-- Canny's method
-- clean-up algorithms (still, a very effective
separation of concerns)

```
10. Determinants
```		-- work of Clarkson
-- work of Preparata et al for 2/3 dim
-- Bareiss
-- work of Karasick

```
11. Incremental Numerical Computation
```
```
12. Precision Sensitivity
```		-- work of Sellen, Choi, Yap
-- extensions
```
13. Expression Packages
```		-- beyond Big Numbers
-- experience of LN
-- Sensitivity Analysis
-- compiler techniques: common subexpressions
-- compilation of expressions
-- partial evaluation
```
14. Elementary Functions
```		-- guaranteed absolute precision
-- work of Brent
-- exp, log
-- pi, e
-- recent fast formulaes
-- hypergeometric functions
```
15. CONCLUSION: Impact and Beyond
-- EGC solves a LARGE part of non-robustness -- main challenge is efficiency -- Core Model brings robustness techniques to the masses -- why demand for robustness will increase with time: * excess computing power be converted to robustness * nonrobustness puts humans in loop * lack of full automation reduces "scalability" -- e.g. mesh generation. We could not generate a mesh for a cylindrical surface automatically! -- nonrobustness is a serious impediment to automation (i.e., fully algorithmic solutions). -- programmer productivity suffers -- testing of code logic -- the CORE model -- Java (platform independence is best achieved by guaranteed accuracy model) -- major open problems of this area -- A new approach to CSG: Geometric Expressions (extends numerical expressions)