### 4.2 Nomenclature and Types ¶

A floating-point number, or float for short, is an object representing a radix-2 floating-point number consisting of a sign, an arbitrary-precision normalized significand (also called mantissa), and an exponent (an integer in some given range); these are called regular numbers. By convention, the radix point of the significand is just before the first digit (which is always 1 due to normalization), like in the C language, but unlike in IEEE 754 (thus, for a given number, the exponent values in MPFR and in IEEE 754 differ by 1).

Like in the IEEE 754 standard, a floating-point number can also have three kinds of special values: a signed zero (+0 or −0), a signed infinity (+Inf or −Inf), and Not-a-Number (NaN). NaN can represent the default value of a floating-point object and the result of some operations for which no other results would make sense, such as 0 divided by 0 or +Inf minus +Inf; unless documented otherwise, the sign bit of a NaN is unspecified. Note that contrary to IEEE 754, MPFR has a single kind of NaN and does not have subnormals. Other than that, the behavior is very similar to IEEE 754, but there are some minor differences.

The C data type for such objects is `mpfr_t`, internally defined as a one-element array of a structure (so that when passed as an argument to a function, it is the pointer that is actually passed), and `mpfr_ptr` is the C data type representing a pointer to this structure; `mpfr_srcptr` is like `mpfr_ptr`, but the structure is read-only (i.e., const qualified).

The precision is the number of bits used to represent the significand of a floating-point number; the corresponding C data type is `mpfr_prec_t`. The precision can be any integer between `MPFR_PREC_MIN` and `MPFR_PREC_MAX`. In the current implementation, `MPFR_PREC_MIN` is equal to 1.

Warning! MPFR needs to increase the precision internally, in order to provide accurate results (and in particular, correct rounding). Do not attempt to set the precision to any value near `MPFR_PREC_MAX`, otherwise MPFR will abort due to an assertion failure. However, in practice, the real limitation will probably be the available memory on your platform, and in case of lack of memory, the program may abort, crash or have undefined behavior (depending on your C implementation).

An exponent is a component of a regular floating-point number. Its C data type is `mpfr_exp_t`. Valid exponents are restricted to a subset of this type, and the exponent range can be changed globally as described in Exception Related Functions. Special values do not have an exponent.

The rounding mode specifies the way to round the result of a floating-point operation, in case the exact result cannot be represented exactly in the destination (see Rounding). The corresponding C data type is `mpfr_rnd_t`.

MPFR has a global (or per-thread) flag for each supported exception and provides operations on flags (Exceptions). This C data type is used to represent a group of flags (or a mask).

MPFR can be built with binary128 support (a.k.a. float128) for some conversion functions if the ‘`_Float128`’ type (from ISO C23) or the ‘`__float128`’ type (a common extension) is available. This is automatically detected, but the ‘`--enable-float128`’ configure option can also be used to ensure this support. For this support, MPFR uses a `mpfr_float128` macro, which needs to be defined as a supported type for the binary128 format, typically ‘`_Float128`’ or ‘`__float128`’, depending on the compiler and the system used to compile the user code. Before including `mpfr.h`, the user needs to do the following (in any order): define the `MPFR_WANT_FLOAT128` macro and define the `mpfr_float128` macro as the actual float128 type; `mpfr.h` will define `mpfr_float128` as ‘`_Float128`’ by default, but mainly for compatibility with software written for MPFR 4.1.x and 4.2.0, where the prototypes used ‘`_Float128`’.