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
inexact predicates.
Since using an exact number type may be too slow, the
`Apollonius_graph_traits_2<K,Method_tag>` class is designed to
support the dynamic filtering of \cgal through the
`Filtered_exact<CT,ET>` mechanism. In particular if `CT`
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
Although exact number types provide exact predicates and constructions,
their use often result in unacceptably large runtimes.
The class `Apollonius_graph_filtered_traits_2<CK,CM,EK,EM,FK,FM>`
aims to paliate this shortcoming. Similar to a filtered kernel, it takes a
constructions kernel `CK`, a filtering kernel `FK` and an
exact kernel `EK`, as well as the corresponding tags
(`CM`, `FM` and `EM`, respectively).
It evaluates the predicates by first using the filtering kernel, and
if this fails the evaluation is performed using the exact kernel. The
constructions are done using the kernel `CK`, which means that
Predicates are evaluated by first using the filtering kernel, and
if this fails the evaluation is performed using the exact kernel,
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
`CK` have default values, which are explained in the reference
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
can be very costly. For this reason we have devoted considerable
effort in implementing different kinds of arithmetic filtering
mechanisms. Presently, there two ways of performing arithmetic
filtering for the predicates involved in the computation of
segment Delaunay graphs:
<OL>
<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`,
effort in implementing arithmetic filtering mechanisms
through special traits classes, `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>`.
These two traits class employ the `Filtered_predicate<EP,FP>` mechanism,
and the user can define up to three different kernels `CK`,
`FK` and `EK` (default values are provided for most
parameters). The first kernel `CK` is used only for
constructions. The second kernel `FK` is the filtering kernel:
the traits class will attempt to compute the predicates using this
kernel. If the filtering kernel fails to successfully compute a
predicate, the exact kernel `EK` will be used. These three
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.
predicate, the exact kernel `EK` will be used.
Let's consider once more the class
`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
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
`Segment_Delaunay_graph_2` class in order to count a few
site-related quantities.