CGAL::Lazy_exact_nt< NT > Class Template Reference

#include <CGAL/Lazy_exact_nt.h>

Definition

template<typename NT>
class CGAL::Lazy_exact_nt< NT >

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() (losing the benefit of the laziness if done systematically).

Template Parameters

NT	must 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.

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.
static double	get_relative_precision_of_to_double ()
	returns the relative precision that to_double() currently fulfills.

Constructor & Destructor Documentation

Lazy_exact_nt()

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

set_relative_precision_of_to_double()

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.