When an expression requires the use of temporary intermediate
f=g*h+x*y, those temporaries will have the same precision
as the destination
f. Explicit constructors can be used if this
mpf_class. Any standard C++ type can be used, except
long long and
long double, and any of the GMP C++ classes can be
If prec is given, the initial precision is that value, in bits. If
prec is not given, then the initial precision is determined by the type
of op given. An
mpq_class, or C++
builtin type will give the default
mpf precision (see Initializing Floats). An
mpf_class or expression will give the precision of that
value. The precision of a binary expression is the higher of the two
mpf_class f(1.5); // default precision mpf_class f(1.5, 500); // 500 bits (at least) mpf_class f(x); // precision of x mpf_class f(abs(x)); // precision of x mpf_class f(-g, 1000); // 1000 bits (at least) mpf_class f(x+y); // greater of precisions of x and y
mpf_class from an
mpf_t. The value in f is
copied into the new
mpf_class, there won’t be any permanent association
between it and f.
If prec is given, the initial precision is that value, in bits. If prec is not given, then the initial precision is that of f.
mpf_class converted from a string using
(see Assigning Floats). If prec is given, the initial precision is
that value, in bits. If not, the default
(see Initializing Floats) is used.
If the string is not a valid float, an
is thrown. The same applies to
With C++11 compilers, floats can be constructed with the syntax
1.23e-1_mpf which is equivalent to
Convert and store the given op value to an
mpf_class object. The
same types are accepted as for the constructors above.
operator= only stores a new value, it doesn’t copy or change
the precision of the destination, instead the value is truncated if necessary.
This is the same as
mpf_set etc. Note in particular this means for
mpf_class a copy constructor is not the same as a default constructor
mpf_class x (y); // x created with precision of y mpf_class x; // x created with default precision x = y; // value truncated to that precision
Applications using templated code may need to be careful about the assumptions
the code makes in this area, when working with
mpf_class values of
various different or non-default precisions. For instance implementations of
complex template have been seen in both styles above,
though of course
complex is normally only actually specified for use
with the builtin float types.
These functions provide a C++ class interface to the corresponding GMP C routines.
cmp can be used with any of the classes or the standard C++ types,
long long and
The accuracy provided by
hypot is not currently guaranteed.
Get or set the current precision of an
The restrictions described for
mpf_set_prec_raw (see Initializing Floats) apply to
mpf_class::set_prec_raw. Note in particular that the
mpf_class must be restored to it’s allocated precision before being
destroyed. This must be done by application code, there’s no automatic
mechanism for it.