Chapter 5
Number Types

Michael Hemmer, Susan Hert, Sylvain Pion, and Stefan Schirra

Table of Contents

5.1 Introduction
5.2 Built-in Number Types
5.3 Number Types Provided by CGAL
5.4 Number Types Provided by GMP
5.5 Number Types Provided by LEDA
5.6 Number Types Provided by CORE
5.7 Interval arithmetic
5.8 User-supplied Number Types
5.9 Design and Implementation History

5.1   Introduction

This chapter gives an overview of the number types supported by Cgal. Number types must fulfill certain syntactical and semantic requirements, such that they can be successfully used in Cgal code. In general they are expected to be a model of an algebraic structure concepts and in case they model a subring of the real numbers they are also a model of RealEmbeddable. For an overview of the algebraic structure concepts see Section 4.8.

5.2   Built-in Number Types

The built-in number types float, double and long double have the required arithmetic and comparison operators. They lack some required routines though which are automatically included by Cgal. 1

All built-in number types of C++ can represent a discrete (bounded) subset of the rational numbers only. We assume that the floating-point arithmetic of your machine follows Ieee floating-point standard. Since the floating-point culture has much more infrastructural support (hardware, language definition and compiler) than exact computation, it is very efficient. Like with all number types with finite precision representation which are used as approximations to the infinite ranges of integers or real numbers, the built-in number types are inherently potentially inexact. Be aware of this if you decide to use the efficient built-in number types: you have to cope with numerical problems. For example, you can compute the intersection point of two lines and then check whether this point lies on the two lines. With floating point arithmetic, roundoff errors may cause the answer of the check to be false. With the built-in integer types overflow might occur.

5.3   Number Types Provided by Cgal

Cgal provides several number types that can be used for exact computation. These include the Quotient class that can be used to create, for example, a number type that behaves like a rational number when parameterized with a number type which can represent integers.

The number type MP_Float is able to represent multi-precision floating point values, a generalization of integers scaled by a (potentially negative) power of 2. It allows to deal with ring operations over floating-point values with requiring rational numbers. By plugging it in Quotient, one obtains rational numbers. Note that MP_Float may not be as efficient as the integer types provided by Gmp or Leda, but it has the advantage to make more parts of Cgal independent on these external libraries for handling robustness issues.

The templated number type Lazy_exact_nt<NT> is able to represent any number that NT is able to represent, but because it first tries to use an approximate value to perform computations it can be faster than NT.

A number type for doing interval arithmetic, Interval_nt, is provided. This number type helps in doing arithmetic filtering in many places such as Filtered_predicate.

CGAL::Sqrt_extension is a number type that allows to represent algebraic numbers of degree 2 as well as nested forms. A generic function CGAL::make_root_of_2 allows to build this type generically.

A debugging helper Number_type_checker<NT1,NT2,Comparator> is also provided which allows to compare the behavior of operations over two number types.

5.4   Number Types Provided by Gmp

Cgal provides wrapper classes for number types defined in the Gnu Multiple Precision arithmetic library [Gra]. The file CGAL/Gmpz.h provides the class Gmpz, a wrapper class for the arbitrary-precision integer type mpz_t, which is compliant with the Cgal number type requirements. The file CGAL/Gmpq.h provides the class Gmpq, a wrapper class for the arbitrary-precision rational type mpq_t, which is compliant with the Cgal number type requirements.

The file CGAL/Gmpzf.h provides the class Gmpzf, an exact arbitrary-precision floating-point type. Hence, It does not support operators like / to guarantee exactness of the operations. The arithmetic operations on this type are restricted to +, -, * and CGAL::integral_division.

The file CGAL/Gmpfr.h provides the class Gmpfr, a fixed-precision floating-point number type. Since the precision (number of bits used to represent the mantissa of the number) is fixed for each object, the result of each operation is rounded when necessary. Though not necessary at first, the user will take full advantage of this number type by understanding the ideas behind floating-point arithmetic, such as precision and rounding, and understanding the flags set by this library after each operation. For more details, the reader should refer to [MPFb] and the Gmpfr reference manual.

In addition, it is possible to directly use the C++ number types provided by Gmp : mpz_class, mpq_class (note that support for mpf_class is incomplete). The file CGAL/gmpxx.h provides the necessary functions to make these classes compliant to the Cgal number type requirements.

To use these classes, Gmp and Mpfr must be installed.

5.5   Number Types Provided by Leda

Leda provides number types that can be used for exact computation with both Cartesian and homogeneous representations. If you are using homogeneous representation with the built-in integer types short, int, and long as ring type, exactness of computations can be guaranteed only if your input data come from a sufficiently small integral range and the depth of the computations is sufficiently small. Leda provides the number type leda_integer for integers of arbitrary length. (Of course the length is somehow bounded by the resources of your computer.) It can be used as ring type in homogeneous kernels and leads to exact computation as long as all intermediate results are rational. For the same kind of problems, Cartesian representation with number type leda_rational leads to exact computation as well. The number type leda_bigfloat in Leda is a variable precision floating-point type. Rounding mode and precision (i.e. mantissa length) of leda_bigfloat can be set.

The most sophisticated number type in Leda is the number type called leda_real. Like in Pascal, where the name real is used for floating-point numbers, the name leda_real does not describe the number type precisely, but intentionally. leda_reals are a subset of real algebraic numbers. Any integer is leda_real and leda_reals are closed under the operations +,-,*,/ and k-th root computation. For Leda version 5.0 and or later leda_real is also able to represent real roots of polynomials. leda_reals guarantee that all comparisons between expressions involving leda_reals produce the exact result.

The files CGAL/leda_integer.h, CGAL/leda_rational.h, CGAL/leda_bigfloat.h and CGAL/leda_real.h provide the necessary functions to make these classes compliant to the Cgal number type requirements.

5.6   Number Types Provided by Core

In principle Core [KLPY99] provides the same set of number types as Leda. The type CORE::BigInt represent integers and CORE::BigRat represent rationals of arbitrary length. The number type CORE::BigFloat is a variable precision floating-point type. It is also possible to interpret it as an interval type, since it also carries the error of a computed value. As for Leda, the most sophisticated number type in Core is CORE::Expr, which is in its functionality equivalent to leda_real.

The files CGAL/CORE_BigInt.h, CGAL/CORE_BigRat.h, CGAL/CORE_BigFloat.h and CGAL/CORE_Expr.h provide the necessary functions to make these classes compliant to the Cgal number type requirements.

Core version 1.7 or later is required.

5.7   Interval arithmetic

Interval arithmetic is very important for geometric programming. It is a fundamental tool for filtering predicates. For many problems, intervals of machine double-precision numbers are sufficient, but it is not always enough. For example, one approach for determining the sign of an expression is to evaluate its sign using interval arithmetic and to repeatedly increase the precision of the bounds of the intervals until either the interval does not contain zero or its width is less than the separation bound of the polynomial.

For intervals of machine double-precision numbers, Cgal provides the class Interval_nt. For intervals of floating-point arbitrary-precision numbers, the class Gmpfi is provided in the file CGAL/Gmpfi.h.

Endpoints of Gmpfi intervals are represented as Gmpfr numbers. Each interval has an associated precision, which is the maximum precision (number of bits used to represent the mantissa) of its endpoints. The result of the operations is guaranteed to be always contained in the returned interval. Since the interval arithmetic is implemented on top of Gmpfr, the global flags and the default precision are inherited from the Gmpfr interface. See [MPFa] and the Gmpfi reference manual for details.

To use the Gmpfi class, Mpfi must be installed.

5.8   User-supplied Number Types

In order to use your own number type it must be a model of the according algebraic structure concept, in particular you must provide a specialization of CGAL::Algebraic_structure_traits and also of Real_embeddable_traits in case it is a sub ring of the real numbers. If you even want to provide a related ensemble of number types you should also provide specializations for CGAL::Coercion_traits in order to reflect their interoperability.

5.9   Design and Implementation History

This package was naturally one of the first packages implemented in Cgal. It initially contained the Quotient, Gmpz and Gmpq classes, together with the interfaces to the number types provided by Leda, which were implemented by Stefan Schirra and Andreas Fabri.

Later, around 1998-2002, Sylvain Pion implemented Interval_nt MP_Float and Lazy_exact_nt, together with the interfaces to the mpz_class and mpq_class types from Gmp.

Number type concepts were then refined, notably by Lutz Kettner and Susan Hert, who also contributed utility algorithms.

The work on concepts was further extended within the Exacus project, and was finally contributed to Cgal by Michael Hemmer in 2006, as what is now the separate Algebraic Foundations package 4, together with a rewritten interface to operations on number types.

The class Sqrt_extension was contributed by Michael Hemmer and Ron Wein around 2006. In 2010 it went through a considerable reinvestigation by Sébastien Loriot, Michael Hemmer, and Monique Teillaud. As a result it got further improved and now replaces several similar types such as Root_of_2, which had been contributed by Pedro M. M. de Castro, Sylvain Pion and Monique Teillaud, and is deprecated since CGAL-3.8.

In 2008-2010, Bernd Gärtner added the Gmpzf class, while Luis Peñaranda and Sylvain Lazard contributed the Gmpfi and Gmpfr classes.


 1  The functions can be found in the header files CGAL/int.h, CGAL/float.h, CGAL/double.h and CGAL/long_long.h.