songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update documentations of SDG/AG2: Filtered_exact has been removed... 

... 16 years ago !
This commit is contained in:
Mael Rouxel-Labbé 2020-03-10 15:17:50 +01:00
parent bd9610446d
commit 0729d1b0d1
3 changed files with 16 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
Apollonius_graph_2/doc/Apollonius_graph_2/Apollonius_graph_2.txt
View File

@ -383,28 +383,18 @@ type, with `Integral_domain_without_division_tag` as tag will give exact predica
whereas `MP_Float` with `Field_with_sqrt_tag` will give whereas `MP_Float` with `Field_with_sqrt_tag` will give
inexact predicates. inexact predicates.
Since using an exact number type may be too slow, the Although exact number types provide exact predicates and constructions,
`Apollonius_graph_traits_2<K,Method_tag>` class is designed to their use often result in unacceptably large runtimes.
support the dynamic filtering of \cgal through the The class `Apollonius_graph_filtered_traits_2<CK,CM,EK,EM,FK,FM>`
`Filtered_exact<CT,ET>` mechanism. In particular if `CT` aims to paliate this shortcoming. Similar to a filtered kernel, it takes a
is an inexact number type that supports the operations denoted by the
tag `Method_tag` and `ET` is an exact number type for these
operations, then kernel with number type
`Filtered_exact<CT,ET>` will yield exact predicates for the
Apollonius graph traits. To give a concrete example,
`CGAL::Filtered_exact<double,CGAL::MP_Float>` with
`Integral_domain_without_division_tag` will produce exact predicates.
Another possibility for fast and exact predicate evaluation is to use
the
`Apollonius_graph_filtered_traits_2<CK,CM,EK,EM,FK,FM>`
class. This class is the analog of a filtered kernel. It takes a
constructions kernel `CK`, a filtering kernel `FK` and an constructions kernel `CK`, a filtering kernel `FK` and an
exact kernel `EK`, as well as the corresponding tags exact kernel `EK`, as well as the corresponding tags
(`CM`, `FM` and `EM`, respectively). (`CM`, `FM` and `EM`, respectively).
It evaluates the predicates by first using the filtering kernel, and Predicates are evaluated by first using the filtering kernel, and
if this fails the evaluation is performed using the exact kernel. The if this fails the evaluation is performed using the exact kernel,
constructions are done using the kernel `CK`, which means that thus yielding exact predicates at a generally much cheaper cost
than directly using an exact number type. The constructions
are done using the kernel `CK`, which means that
they are not necessarily exact. All template parameters except they are not necessarily exact. All template parameters except
`CK` have default values, which are explained in the reference `CK` have default values, which are explained in the reference
manual. manual.

47
Apollonius_graph_2/include/CGAL/Apollonius_graph_2/check_filter.h
View File

@ -1,47 +0,0 @@
// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
// You can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
// SPDX-License-Identifier: GPL-3.0+
//
//
// Author(s) : Menelaos Karavelas <mkaravel@iacm.forth.gr>
#ifndef CGAL_CHECK_FILTER_H
#define CGAL_CHECK_FILTER_H
#include <CGAL/license/Apollonius_graph_2.h>
#undef CGAL_IA_NEW_FILTERS
namespace CGAL {
template < class T>
void must_be_filtered(const T&)
{}
#if defined CGAL_ARITHMETIC_FILTER_H
template < class CT, class ET, class Type, bool Protection, class Cache>
void must_be_filtered(const Filtered_exact<CT, ET, Type, Protection,
Cache> &)
{ dont_compile(CT(), ET()); }
#endif
}
#endif

28
Segment_Delaunay_graph_2/doc/Segment_Delaunay_graph_2/Segment_Delaunay_graph_2.txt
View File

@ -404,31 +404,17 @@ classes:
As mentioned above, performing computations with exact arithmetic As mentioned above, performing computations with exact arithmetic
can be very costly. For this reason we have devoted considerable can be very costly. For this reason we have devoted considerable
effort in implementing different kinds of arithmetic filtering effort in implementing arithmetic filtering mechanisms
mechanisms. Presently, there two ways of performing arithmetic through special traits classes, `Segment_Delaunay_graph_filtered_traits_2<CK,CM,EK,EM,FK,FM>`
filtering for the predicates involved in the computation of and `Segment_Delaunay_graph_filtered_traits_without_intersections_2<CK,CM,EK,EM,FK,FM>`.
segment Delaunay graphs: These two traits class employ the `Filtered_predicate<EP,FP>` mechanism,
<OL> and the user can define up to three different kernels `CK`,
<LI>The user can define his/her kernel using as number type, a
number type of the form `Filtered_exact<CT,ET>`. Then this
kernel can be entered as the first template parameter in the
`Segment_Delaunay_graph_2<K,MTag>`.
<LI>The user can define up to three different kernels `CK`,
`FK` and `EK` (default values are provided for most `FK` and `EK` (default values are provided for most
parameters). The first kernel `CK` is used only for parameters). The first kernel `CK` is used only for
constructions. The second kernel `FK` is the filtering kernel: constructions. The second kernel `FK` is the filtering kernel:
the traits class will attempt to compute the predicates using this the traits class will attempt to compute the predicates using this
kernel. If the filtering kernel fails to successfully compute a kernel. If the filtering kernel fails to successfully compute a
predicate, the exact kernel `EK` will be used. These three predicate, the exact kernel `EK` will be used.
kernels are then used in the
`Segment_Delaunay_graph_filtered_traits_2<CK,CM,EK,EM,FK,FM>` and
`Segment_Delaunay_graph_filtered_traits_without_intersections_2<CK,CM,EK,EM,FK,FM>`
classes, which have been implemented using the
`Filtered_predicate<EP,FP>` mechanism.
</OL>
Our experience so far has shown that for all reasonable and valid
values of the template parameters, the second method for arithmetic
filtering is more efficient among the two.
Let's consider once more the class Let's consider once more the class
`Segment_Delaunay_graph_2<K,MTag>`. `Segment_Delaunay_graph_2<K,MTag>`.
@ -507,7 +493,7 @@ for inputs consisting of more than about 1,000 sites.
\subsection Segment_Delaunay_graph_2FirstExample First Example using the Filtered Traits \subsection Segment_Delaunay_graph_2FirstExample First Example using the Filtered Traits
The following example shows how to use the segment Delaunay graph traits The following example shows how to use the segment Delaunay graph traits
in conjunction with the `Filtered_exact<CT,ET>` mechanism. In in conjunction with filtered traits mechanism. In
addition it shows how to use a few of the iterators provided by the addition it shows how to use a few of the iterators provided by the
`Segment_Delaunay_graph_2` class in order to count a few `Segment_Delaunay_graph_2` class in order to count a few
site-related quantities. site-related quantities.