CGAL 4.7 - Number Types: CGAL::MP_Float Class Reference

\( \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.7 - Number Types

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
List of all members | Related Functions
CGAL::MP_Float Class Reference
CGAL Number Types

`#include <CGAL/MP_Float.h>`

## Definition

An object of the class `MP_Float` is able to represent a floating point value with arbitrary precision.

This number type has the property that additions, subtractions and multiplications are computed exactly, as well as the construction from `float`, `double` and `long double`.

Division and square root are not enabled by default since CGAL release 3.2, since they are computed approximately. We suggest that you use rationals like `Quotient<MP_Float>` when you need exact divisions.

Note on the implementation : although the mantissa length is basically only limited by the available memory, the exponent is currently represented by a (integral valued) `double`, which can overflow in some circumstances. We plan to also have a multiprecision exponent to fix this issue.

Is Model Of:

  `EuclideanRing`

  `RealEmbeddable`

Implementation

The implementation of `MP_Float` is simple but provides a quadratic complexity for multiplications. This can be a problem for large operands. For faster implementations of the same functionality with large integral values, you may want to consider using `GMP` or `LEDA` instead.

## Related Functions

(Note that these are not member functions.)
std::ostream & | operator<< (std::ostream &out, const MP_Float &m)
| writes a double approximation of `m` to the ostream `out`.
std::istream & | operator>> (std::istream &in, MP_Float &m)
| reads a `double` from `in`, then converts it to an `MP_Float`.
MP_Float | approximate_division (const MP_Float &a, const MP_Float &b)
| computes an approximation of the division by converting the operands to `double`, performing the division on `double`, and converting back to `MP_Float`.
MP_Float | approximate_sqrt (const MP_Float &a)
| computes an approximation of the square root by converting the operand to `double`, performing the square root on `double`, and converting back to `MP_Float`.

## Creation

| MP_Float ()
| introduces an uninitialized variable `m`.
| MP_Float (const MP_Float &)
| copy constructor.
| MP_Float (int i)
| introduces the integral value i.
| MP_Float (float d)
| introduces the floating point value d (exact conversion).
| MP_Float (double d)
| introduces the floating point value d (exact conversion).
| MP_Float (long double d)
| introduces the floating point value d (exact conversion).