uses the Cartesian CGAL kernel with single precision floating point arithmetic.
It uses point type CGAL_PointC2<float> and the CGAL predicates
corresponding to this point type.
The parameterized Cartesian CGAL kernel uses reference counting.
C<double>
uses the Cartesian CGAL kernel
with double precision floating point arithmetic.
leda
uses the two-dimensional floating-point geometry kernel of LEDA.
This kernel uses double-precision floating-point arithmetic
with Cartesian representation and uses reference counting.
C<CGAL_S_int<20> >
uses the Cartesian CGAL kernel with a special number type called
CGAL_S_int< N> for N
and specialized predicates.
The specialized predicates for number type CGAL_S_int< N>
use a static floating-point filter (see e.g. [FvW]) based on the
assumption that the coordinates are integral with at most N
bits. Double precision floating-point arithmetic is internally used in number type
CGAL_S_int< N>. If the filter fails, computation is re-done with
exact arithmetic using leda_integer.
C<CGAL_S_int<32> >
as above, with N (corresponding to size of int).
C<CGAL_S_int<53> >
as above, with N (corresponding to double precision).
C<doubledouble>
uses the Cartesian CGAL kernel
with extended precision floating-point arithmetic.
The number type doubledouble [doubledouble]
implements a floating point arithmetic with about 30 decimal places.
C<CGAL_Interval_nt_advanced>
uses the Cartesian CGAL kernel with a ``number type''
based on interval arithmetic, cf. CGAL-documentation.
Whenever intervals are not disjoint in comparison operations,
the represented numbers are considered to be equal.
Interval endpoints are of type double.
C<Filtered_exact<double,leda_real>
uses the Cartesian CGAL kernel with number type
CGAL_Filtered_exact<double,leda_real>. With this
number type special predicates are used. Coordinates are
stored as doubles. In the predicates, interval arithmetic (with
interval endpoints of type double) is
used as a filter to speed up computation. If the computation with
interval arithmetic does not suffice to make a decision, coordinates are
converted to leda_real and the predicate is evaluated with this
number type.
C<Filtered_exact<int,CGAL_Gmpz>
uses the Cartesian CGAL kernel with number type
CGAL_Filtered_exact<int,CGAL_Gmpz>. Coordinates are
stored as ints. In the predicates, interval arithmetic (with
interval endpoints of type double) is used as a filter to speed up
computation. If the computation with interval arithmetic does not suffice to
make a decision, coordinates are converted to arbitrary precision integer
type CGAL_Gmpz and the predicate is evaluated with this number type.
The number type CGAL_Gmpz is a wrapper for the Gnu multiple
precision arithmetic gmp [gmp].
The wrapper layer uses reference counting.
rat_leda
uses the two-dimensional rational geometry kernel of LEDA.
This kernel maintains homogeneous coordinates as arbitrary precision
integers (leda_integer).
It uses a semi-dynamic floating-point filter to speed up computation.
C<leda_real>
uses the Cartesian CGAL kernel with number type leda_real
[BFMS, BKMNSU, BMS],
which provides exact decisions under the arithmetic operations
, and . leda_reals use adaptive evaluation
and internally maintain expression dags for re-evaluation.
A very convenient way to use exact computation.
C<Expanded_double>
uses the Cartesian CGAL kernel
with a number type which is called CGAL_Expanded_double.
In this number type coordinates are maintained as sums of
double precision floats.
It is based on ideas and partially also on public domain code by
Shewchuk [S],
which extends earlier work by Priest [P] and Dekker [D].
If neither underflow nor overflow occurs,
CGAL_Expanded_doubles compute exact results
under addition, subtraction, and multiplication operations
The initial values need not be integral.
Ed. predicates
uses the Cartesian CGAL kernel with specialized predicates using
adaptive evaluation. The specialized predicates use Shewchuk's code
[S]
for orientation predicates and other predicates in the same style.
If the filter steps fail,
CGAL_Expanded_double is finally used.
C<leda_integer>
uses the Cartesian CGAL kernel with the arbitrary precision integer
type leda_integer1 from LEDA.
C<CGAL_Gmpz>
uses the Cartesian CGAL kernel with the arbitrary precision integer
type CGAL_Gmpz which is just a wrapper for the Gnu multiple
precision arithmetic gmp [gmp].
The wrapper layer uses reference counting.
C<leda_bigfloat> 53
uses the Cartesian CGAL kernel with the floating-point number type
leda_bigfloat. Among other modes this floating-point
number type allows one to fix the mantissa length (in bits).
Here, the mantissa
length was set to 53, corresponding to computation with double.
C<Q< double> >
uses the Cartesian CGAL kernel with
number type CGAL_Quotient< double>. The type
CGAL_Quotient is a parameterized and slightly simplified
version of the number type leda_rational. A number is maintained
as a numerator and a denominator.
C<Q<leda_integer> >
uses CGAL's Cartesian kernel with
number type CGAL_Quotient< leda_integer>.
This number type corresponds to leda_rational.
H<double>
uses the homogeneous kernel of CGAL with the built-in double
precision floating-point number type.
H<leda_real>
uses the homogeneous CGAL kernel with number type
leda_real.
H<leda_integer>
uses the homogeneous CGAL kernel with number type
leda_integer.
S<float>
uses Cartesian representation without reference counting.
Coordinates are of type float, predicates are
analogous to the Cartesian CGAL kernel.
S<double>
uses Cartesian representation without reference counting.
Coordinates are of type double.
S<doubledouble>
uses Cartesian coordinates of type doubledouble.
Objects are not reference counted.
S<leda_real>
uses Cartesian representation without reference counting.
The coordinates are of type leda_real.
V<float>
uses a Java-like geometry kernel: Classes have abstract base
classes specifying their interfaces, most of the member functions
are declared virtual and not declared inline.
Cartesian representation is used with coordinates of type
float.
V<double>
as above, but with coordinates of type double.
V<leda_real>
As above, with coordinates of type leda_real.
Cw<float>
uses the Cartesian CGAL kernel with an additional wrapper layer that
gives Cartesian and homogeneous kernels a common interface.
The Cartesian coordinates are stored as single precision floats.
It uses point type CGAL_Point_2< CGAL_Cartesian< float> >, which
wraps CGAL_PointC2<float>. Hence it uses reference counting.
Cw<double> ++
uses the Cartesian CGAL kernel with CGAL's additional wrapper layer.
It uses double precision floating point arithmetic and the corresponding
predicates, but does a few additional test to increase robustness. For example,
in the comparison predicate for counterclockwise rotation order, points
to be compared are checked for equality with the rotation center
before an orientation predicate is called.