A Tour of NTL: Examples: Floating Point Classes

NTL also supports arbitrary precision floating point with
the class `RR`.
Additionally, it supports two specialized classes: `quad_float`,
which gives a form of quadruple precision, but without an extended
exponent range,
and `xdouble`,
which gives double precision, but with an extended exponent range.
The advantage of the latter two classes is efficiency.

Here again is a program that reads a list of numbers from the input,
and outputs the sum of their squares, using the class `RR`.

#include <NTL/RR.h>using namespace std;using namespace NTL;int main(){ RR acc, val; acc = 0; while (cin >> val) acc += val*val; cout << acc << "\n"; } |

The precision used for the computation can be set by executing

RR::SetPrecision(p); |

which sets the effective precision to `p` bits.
By default, `p=150`.
All of the basic arithmetic operations compute their results
by rounding to the nearest `p`-bit floating point number.
The semantics of this are exactly the same as in the IEEE floating
point standard (except that there are no special values, like
"infinity" and "not a number").

The number of *decimal* digits of precision that are used when
printing an `RR` can be set be executing

RR::SetOutputPrecision(d); |

which sets the output precision to `d`.
By default, `d=10`.

See `RR.txt` for details.

By replacing the occurences of `RR` by either `quad_float`
or `xdouble`, one gets an equivalent program using one of the
other floating point classes.
The output precision for these two classes can be controlled just
as with `RR`.
See `quad_float.txt` and
`xdouble.txt`
for details.