\( \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.8 - 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`.

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`. More...

## Operations
NT | exact ()
| returns the corresponding NT value.
Interval_nt< true > | approx ()
| returns an interval containing the exact value.
Interval_nt< false > | 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 default value is \( 10^{-5}\).

Precondition
  d>0 and d<1.