\( \newcommand{\E}{\mathrm{E}} \) \( \newcommand{\A}{\mathrm{A}} \) \( \newcommand{\R}{\mathrm{R}} \) \( \newcommand{\N}{\mathrm{N}} \) \( \newcommand{\Q}{\mathrm{Q}} \) \( \newcommand{\Z}{\mathrm{Z}} \) \( \def\ccSum #1#2#3{ \sum_{#1}^{#2}{#3} } \def\ccProd #1#2#3{ \sum_{#1}^{#2}{#3} }\)
CGAL 4.10.2 - Number Types
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
List of all members | Related Functions
CGAL::Lazy_exact_nt< NT > Class Template Reference
CGAL Number Types

#include <CGAL/Lazy_exact_nt.h>

Definition

An object of the class Lazy_exact_nt<NT> is able to represent any real embeddable number which NT is able to represent.

The idea is that Lazy_exact_nt<NT> works exactly like NT, except that it is expected to be faster because it tries to only compute an approximation of the value, and only refers to NT when needed. The goal is to speed up exact computations done by any exact but slow number type NT.

The function to_double() can be used to get a double approximation of the represented number. Note that two subsequent calls to this function on the same number of type Lazy_exact_nt<NT> might not return the same value as the exact representation might have been computed between the two calls, thus refining the double approximation. If you want to avoid this behavior, you need to first call exact() (loosing the benefit of the lazyness if done systematically).

Template Parameters
NTmust be a model of concept RealEmbeddable, and at least model of concept IntegralDomainWithoutDivision.

Note that some filtering mechanism is available at the predicate level using Filtered_predicate and Filtered_kernel.

Is Model Of:

IntegralDomainWithoutDivision same as NT

RealEmbeddable

Fraction, if NT is a Fraction

Example

#include <CGAL/Cartesian.h>
#include <CGAL/MP_Float.h>
#include <CGAL/Lazy_exact_nt.h>
#include <CGAL/Quotient.h>
typedef CGAL::Lazy_exact_nt<CGAL::Quotient<CGAL::MP_Float> > NT;
typedef CGAL::Cartesian<NT> K;

Related Functions

(Note that these are not member functions.)

std::ostream & operator<< (std::ostream &out, const Lazy_exact_nt< NT > &m)
 writes m to ostream out in an interval format.
 
std::istream & operator>> (std::istream &in, Lazy_exact_nt< NT > &m)
 reads a NT from in, then converts it to a Lazy_exact_nt<NT>.
 

Creation

 Lazy_exact_nt ()
 introduces an uninitialized variable m.
 
 Lazy_exact_nt (BuiltIn i)
 introduces the value x, of any built-in arithmetic type (int, double, etc) (works only if NT has a constructor from this type too).
 
 Lazy_exact_nt (NT n)
 introduces the value n.
 
template<class NT1 >
 Lazy_exact_nt (Lazy_exact_nt< NT1 > n)
 introduces the value n. More...
 

Operations

NT exact ()
 returns the corresponding NT value.
 
Interval_nt< false > approx ()
 returns an interval containing the exact value.
 
Interval_nt< true > interval ()
 returns an interval containing the exact value.
 
static void set_relative_precision_of_to_double (double d)
 specifies the relative precision that to_double() has to fulfill. More...
 
static double get_relative_precision_of_to_double ()
 returns the relative precision that to_double() currently fulfills.
 

Constructor & Destructor Documentation

template<typename NT >
template<class NT1 >
CGAL::Lazy_exact_nt< NT >::Lazy_exact_nt ( Lazy_exact_nt< NT1 >  n)

introduces the value n.

NT1 needs to be convertible to NT (and this conversion will only be done if necessary).

Member Function Documentation

template<typename NT >
static void CGAL::Lazy_exact_nt< NT >::set_relative_precision_of_to_double ( double  d)
static

specifies the relative precision that to_double() has to fulfill.

The relative precision is thread local, and the default value is \( 10^{-5}\).

Precondition
d>0 and d<1.