CGAL 6.0.2 - Number Types

Loading...
Searching...
No Matches
List of all members | Related Functions
CGAL::Lazy_exact_nt< NT > Class Template Reference
Number Types Reference » CGAL Number Types

`#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;
Lazy_exact_nt.h
MP_Float.h
Quotient.h
CGAL::Lazy_exact_nt
An object of the class Lazy_exact_nt<NT> is able to represent any real embeddable number which NT is ...
Definition: Lazy_exact_nt.h:46
CGAL::Cartesian

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