GNU MPFR

This manual documents how to install and use the Multiple Precision Floating-Point Reliable Library, version 2.4.1.

Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in GNU Free Documentation License.

• Copying: MPFR Copying Conditions (LGPL).
• Introduction to MPFR: Brief introduction to GNU MPFR.
• Installing MPFR: How to configure and compile the MPFR library.
• Reporting Bugs: How to usefully report bugs.
• MPFR Basics: What every MPFR user should now.
• MPFR Interface: MPFR functions and macros.
• Contributors
• References
• GNU Free Documentation License
• Concept Index
• Function Index

MPFR Copying Conditions

This library is free; this means that everyone is free to use it and free to redistribute it on a free basis. The library is not in the public domain; it is copyrighted and there are restrictions on its distribution, but these restrictions are designed to permit everything that a good cooperating citizen would want to do. What is not allowed is to try to prevent others from further sharing any version of this library that they might get from you.

Specifically, we want to make sure that you have the right to give away copies of the library, that you receive source code or else can get it if you want it, that you can change this library or use pieces of it in new free programs, and that you know you can do these things.

To make sure that everyone has such rights, we have to forbid you to deprive anyone else of these rights. For example, if you distribute copies of the GNU MPFR library, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must tell them their rights.

Also, for our own protection, we must make certain that everyone finds out that there is no warranty for the GNU MPFR library. If it is modified by someone else and passed on, we want their recipients to know that what they have is not what we distributed, so that any problems introduced by others will not reflect on our reputation.

The precise conditions of the license for the GNU MPFR library are found in the Lesser General Public License that accompanies the source code. See the file COPYING.LIB.

1 Introduction to MPFR

MPFR is a portable library written in C for arbitrary precision arithmetic on floating-point numbers. It is based on the GNU MP library. It aims to extend the class of floating-point numbers provided by the GNU MP library by a precise semantics. The main differences with the mpf class from GNU MP are:

• the MPFR code is portable, i.e. the result of any operation does not depend (or should not) on the machine word size mp_bits_per_limb (32 or 64 on most machines);
• the precision in bits can be set exactly to any valid value for each variable (including very small precision);
• MPFR provides the four rounding modes from the IEEE 754-1985 standard.

In particular, with a precision of 53 bits, MPFR should be able to exactly reproduce all computations with double-precision machine floating-point numbers (e.g., double type in C, with a C implementation that rigorously follows Annex F of the ISO C99 standard and FP_CONTRACT pragma set to OFF) on the four arithmetic operations and the square root, except the default exponent range is much wider and subnormal numbers are not implemented (but can be emulated).

This version of MPFR is released under the GNU Lesser General Public License, Version 2.1 or any later version. It is permitted to link MPFR to most non-free programs, as long as when distributing them the MPFR source code and a means to re-link with a modified MPFR library is provided.

1.1 How to Use This Manual

Everyone should read MPFR Basics. If you need to install the library yourself, you need to read Installing MPFR, too.

The rest of the manual can be used for later reference, although it is probably a good idea to glance through it.

2 Installing MPFR

2.1 How to Install

Here are the steps needed to install the library on Unix systems (more details are provided in the INSTALL file):

1. To build MPFR, you first have to install GNU MP (version 4.1 or higher) on your computer. You need a C compiler, preferably GCC, but any reasonable compiler should work. And you need a standard Unix ‘make’ program, plus some other standard Unix utility programs.
2. In the MPFR build directory, type ‘./configure’

   This will prepare the build and setup the options according to your system. If you get error messages, you might check that you use the same compiler and compile options as for GNU MP (see the INSTALL file).

3. ‘make’

   This will compile MPFR, and create a library archive file libmpfr.a. A dynamic library may be produced too (see configure).

4. ‘make check’

   This will make sure MPFR was built correctly. If you get error messages, please report this to ‘mpfr@loria.fr’. (See Reporting Bugs, for information on what to include in useful bug reports.)

5. ‘make install’

   This will copy the files mpfr.h and mpf2mpfr.h to the directory /usr/local/include, the file libmpfr.a to the directory /usr/local/lib, and the file mpfr.info to the directory /usr/local/share/info (or if you passed the ‘--prefix’ option to configure, using the prefix directory given as argument to ‘--prefix’ instead of /usr/local).

2.2 Other `make' Targets

There are some other useful make targets:

• ‘mpfr.info’ or ‘info’

  Create an info version of the manual, in mpfr.info.

• ‘mpfr.pdf’ or ‘pdf’

  Create a PDF version of the manual, in mpfr.pdf.

• ‘mpfr.dvi’ or ‘dvi’

  Create a DVI version of the manual, in mpfr.dvi.

• ‘mpfr.ps’ or ‘ps’

  Create a Postscript version of the manual, in mpfr.ps.

• ‘mpfr.html’ or ‘html’

  Create a HTML version of the manual, in several pages in the directory mpfr.html; if you want only one output HTML file, then type ‘makeinfo --html --no-split mpfr.texi’ instead.

• ‘clean’

  Delete all object files and archive files, but not the configuration files.

• ‘distclean’

  Delete all files not included in the distribution.

• ‘uninstall’

  Delete all files copied by ‘make install’.

2.3 Build Problems

In case of problem, please read the INSTALL file carefully before reporting a bug, in particular section “In case of problem”. Some problems are due to bad configuration on the user side (not specific to MPFR). Problems are also mentioned in the FAQ http://www.mpfr.org/faq.html.

Please report problems to ‘mpfr@loria.fr’. See Reporting Bugs. Some bug fixes are available on the MPFR 2.4.1 web page http://www.mpfr.org/mpfr-2.4.1/.

2.4 Getting the Latest Version of MPFR

The latest version of MPFR is available from ftp://ftp.gnu.org/gnu/mpfr/ or http://www.mpfr.org/.

3 Reporting Bugs

If you think you have found a bug in the MPFR library, first have a look on the MPFR 2.4.1 web page http://www.mpfr.org/mpfr-2.4.1/ and the FAQ http://www.mpfr.org/faq.html: perhaps this bug is already known, in which case you may find there a workaround for it. Otherwise, please investigate and report it. We have made this library available to you, and it is not to ask too much from you, to ask you to report the bugs that you find.

There are a few things you should think about when you put your bug report together.

You have to send us a test case that makes it possible for us to reproduce the bug. Include instructions on how to run the test case.

You also have to explain what is wrong; if you get a crash, or if the results printed are incorrect and in that case, in what way.

Please include compiler version information in your bug report. This can be extracted using ‘cc -V’ on some machines, or, if you're using gcc, ‘gcc -v’. Also, include the output from ‘uname -a’ and the MPFR version (the GMP version may be useful too).

If your bug report is good, we will do our best to help you to get a corrected version of the library; if the bug report is poor, we will not do anything about it (aside of chiding you to send better bug reports).

Send your bug report to: ‘mpfr@loria.fr’.

If you think something in this manual is unclear, or downright incorrect, or if the language needs to be improved, please send a note to the same address.

4 MPFR Basics

4.1 Headers and Libraries

All declarations needed to use MPFR are collected in the include file mpfr.h. It is designed to work with both C and C++ compilers. You should include that file in any program using the MPFR library:

     #include <mpfr.h>

Note however that prototypes for MPFR functions with FILE * parameters are provided only if <stdio.h> is included too (before mpfr.h).

     #include <stdio.h>
     #include <mpfr.h>

Likewise <stdarg.h> (or <varargs.h>) is required for prototypes with va_list parameters, such as mpfr_vprintf.

You can avoid the use of MPFR macros encapsulating functions by defining the ‘MPFR_USE_NO_MACRO’ macro before mpfr.h is included. In general this should not be necessary, but this can be useful when debugging user code: with some macros, the compiler may emit spurious warnings with some warning options, and macros can prevent some prototype checking.

All programs using MPFR must link against both libmpfr and libgmp libraries. On a typical Unix-like system this can be done with ‘-lmpfr -lgmp’ (in that order), for example

     gcc myprogram.c -lmpfr -lgmp

MPFR is built using Libtool and an application can use that to link if desired, see GNU Libtool.

If MPFR has been installed to a non-standard location, then it may be necessary to set up environment variables such as ‘C_INCLUDE_PATH’ and ‘LIBRARY_PATH’, or use ‘-I’ and ‘-L’ compiler options, in order to point to the right directories. For a shared library, it may also be necessary to set up some sort of run-time library path (e.g., ‘LD_LIBRARY_PATH’) on some systems. Please read the INSTALL file for additional information.

4.2 Nomenclature and Types

A floating-point number or float for short, is an arbitrary precision significand (also called mantissa) with a limited precision exponent. The C data type for such objects is mpfr_t (internally defined as a one-element array of a structure, and mpfr_ptr is the C data type representing a pointer to this structure). A floating-point number can have three special values: Not-a-Number (NaN) or plus or minus Infinity. NaN represents an uninitialized object, the result of an invalid operation (like 0 divided by 0), or a value that cannot be determined (like +Infinity minus +Infinity). Moreover, like in the IEEE 754-1985 standard, zero is signed, i.e. there are both +0 and −0; the behavior is the same as in the IEEE 754-1985 standard and it is generalized to the other functions supported by MPFR.

The precision is the number of bits used to represent the significand of a floating-point number; the corresponding C data type is mp_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 2.

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. Moreover, you may reach some memory limit on your platform, in which case the program may abort, crash or have undefined behavior (depending on your C implementation).

The rounding mode specifies the way to round the result of a floating-point operation, in case the exact result can not be represented exactly in the destination significand; the corresponding C data type is mp_rnd_t.

A limb means the part of a multi-precision number that fits in a single word. (We chose this word because a limb of the human body is analogous to a digit, only larger, and containing several digits.) Normally a limb contains 32 or 64 bits. The C data type for a limb is mp_limb_t.

4.3 Function Classes

There is only one class of functions in the MPFR library:

1. Functions for floating-point arithmetic, with names beginning with mpfr_. The associated type is mpfr_t.

4.4 MPFR Variable Conventions

As a general rule, all MPFR functions expect output arguments before input arguments. This notation is based on an analogy with the assignment operator.

MPFR allows you to use the same variable for both input and output in the same expression. For example, the main function for floating-point multiplication, mpfr_mul, can be used like this: mpfr_mul (x, x, x, rnd_mode). This computes the square of x with rounding mode rnd_mode and puts the result back in x.

Before you can assign to an MPFR variable, you need to initialize it by calling one of the special initialization functions. When you're done with a variable, you need to clear it out, using one of the functions for that purpose.

A variable should only be initialized once, or at least cleared out between each initialization. After a variable has been initialized, it may be assigned to any number of times.

For efficiency reasons, avoid to initialize and clear out a variable in loops. Instead, initialize it before entering the loop, and clear it out after the loop has exited.

You do not need to be concerned about allocating additional space for MPFR variables, since any variable has a significand of fixed size. Hence unless you change its precision, or clear and reinitialize it, a floating-point variable will have the same allocated space during all its life.

4.5 Rounding Modes

The following four rounding modes are supported:

• GMP_RNDN: round to nearest
• GMP_RNDZ: round toward zero
• GMP_RNDU: round toward plus infinity
• GMP_RNDD: round toward minus infinity

The ‘round to nearest’ mode works as in the IEEE 754-1985 standard: in case the number to be rounded lies exactly in the middle of two representable numbers, it is rounded to the one with the least significant bit set to zero. For example, the number 5/2, which is represented by (10.1) in binary, is rounded to (10.0)=2 with a precision of two bits, and not to (11.0)=3. This rule avoids the drift phenomenon mentioned by Knuth in volume 2 of The Art of Computer Programming (Section 4.2.2).

Most MPFR functions take as first argument the destination variable, as second and following arguments the input variables, as last argument a rounding mode, and have a return value of type int, called the ternary value. The value stored in the destination variable is correctly rounded, i.e. MPFR behaves as if it computed the result with an infinite precision, then rounded it to the precision of this variable. The input variables are regarded as exact (in particular, their precision does not affect the result).

As a consequence, in case of a non-zero real rounded result, the error on the result is less or equal to 1/2 ulp (unit in the last place) of the target in the rounding to nearest mode, and less than 1 ulp of the target in the directed rounding modes (a ulp is the weight of the least significant represented bit of the target after rounding).

Unless documented otherwise, functions returning an int return a ternary value. If the ternary value is zero, it means that the value stored in the destination variable is the exact result of the corresponding mathematical function. If the ternary value is positive (resp. negative), it means the value stored in the destination variable is greater (resp. lower) than the exact result. For example with the GMP_RNDU rounding mode, the ternary value is usually positive, except when the result is exact, in which case it is zero. In the case of an infinite result, it is considered as inexact when it was obtained by overflow, and exact otherwise. A NaN result (Not-a-Number) always corresponds to an exact return value. The opposite of a returned ternary value is guaranteed to be representable in an int.

Unless documented otherwise, functions returning a 1 (or any other value specified in this manual) for special cases (like acos(0)) should return an overflow or an underflow if 1 is not representable in the current exponent range.

4.6 Floating-Point Values on Special Numbers

This section specifies the floating-point values (of type mpfr_t) returned by MPFR functions. For functions returning several values (like mpfr_sin_cos), the rules apply to each result separately.

Functions can have one or several input arguments. An input point is a mapping from these input arguments to the set of the MPFR numbers. When none of its components are NaN, an input point can also be seen as a tuple in the extended real numbers (the set of the real numbers with both infinities).

When the input point is in the domain of the mathematical function, the result is rounded as described in Section “Rounding Modes” (but see below for the specification of the sign of an exact zero). Otherwise the general rules from this section apply unless stated otherwise in the description of the MPFR function (MPFR Interface).

When the input point is not in the domain of the mathematical function but is in its closure in the extended real numbers and the function can be extended by continuity, the result is the obtained limit. Examples: mpfr_hypot on (+Inf,0) gives +Inf. But mpfr_pow cannot be defined on (1,+Inf) using this rule, as one can find sequences (x_n,y_n) such that x_n goes to 1, y_n goes to +Inf and x_n to the y_n goes to any positive value when n goes to the infinity.

When the input point is in the closure of the domain of the mathematical function and an input argument is +0 (resp. −0), one considers the limit when the corresponding argument approaches 0 from above (resp. below). If the limit is not defined (e.g., mpfr_log on −0), the behavior must be specified in the description of the MPFR function.

When the result is equal to 0, its sign is determined by considering the limit as if the input point were not in the domain: If one approaches 0 from above (resp. below), the result is +0 (resp. −0). In the other cases, the sign must be specified in the description of the MPFR function. Example: mpfr_sin on +0 gives +0.

When the input point is not in the closure of the domain of the function, the result is NaN. Example: mpfr_sqrt on −17 gives NaN.

When an input argument is NaN, the result is NaN, possibly except when a partial function is constant on the finite floating-point numbers; such a case is always explicitly specified in MPFR Interface. Example: mpfr_hypot on (NaN,0) gives NaN, but mpfr_hypot on (NaN,+Inf) gives +Inf (as specified in Special Functions), since for any finite input x, mpfr_hypot on (x,+Inf) gives +Inf.

4.7 Exceptions

MPFR supports 5 exception types:

• Underflow: An underflow occurs when the exact result of a function is a non-zero real number and the result obtained after the rounding, assuming an unbounded exponent range (for the rounding), has an exponent smaller than the minimum exponent of the current range. In the round-to-nearest mode, the halfway case is rounded toward zero.

  Note: This is not the single definition of the underflow. MPFR chooses to consider the underflow after rounding. The underflow before rounding can also be defined. For instance, consider a function that has the exact result 7 multiplied by two to the power e−4, where e is the smallest exponent (for a significand between 1/2 and 1) in the current range, with a 2-bit target precision and rounding toward plus infinity. The exact result has the exponent e−1. With the underflow before rounding, such a function call would yield an underflow, as e−1 is outside the current exponent range. However, MPFR first considers the rounded result assuming an unbounded exponent range. The exact result cannot be represented exactly in precision 2, and here, it is rounded to 0.5 times 2 to e, which is representable in the current exponent range. As a consequence, this will not yield an underflow in MPFR.

• Overflow: An overflow occurs when the exact result of a function is a non-zero real number and the result obtained after the rounding, assuming an unbounded exponent range (for the rounding), has an exponent larger than the maximum exponent of the current range. In the round-to-nearest mode, the result is infinite.
• NaN: A NaN exception occurs when the result of a function is a NaN.
• Inexact: An inexact exception occurs when the result of a function cannot be represented exactly and must be rounded.
• Range error: A range exception occurs when a function that does not return a MPFR number (such as comparisons and conversions to an integer) has an invalid result (e.g. an argument is NaN in mpfr_cmp or in a conversion to an integer).

MPFR has a global flag for each exception, which can be cleared, set or tested by functions described in Exception Related Functions.

Differences with the ISO C99 standard:

• In C, only quiet NaNs are specified, and a NaN propagation does not raise an invalid exception. Unless explicitly stated otherwise, MPFR sets the NaN flag whenever a NaN is generated, even when a NaN is propagated (e.g. in NaN + NaN), as if all NaNs were signaling.
• An invalid exception in C corresponds to either a NaN exception or a range error in MPFR.

4.8 Memory Handling

MPFR functions may create caches, e.g. when computing constants such as Pi, either because the user has called a function like mpfr_const_pi directly or because such a function was called internally by the MPFR library itself to compute some other function.

At any time, the user can free the various caches with mpfr_free_cache. It is strongly advised to do that before terminating a thread, or before exiting when using tools like ‘valgrind’ (to avoid memory leaks being reported).

MPFR internal data such as flags, the exponent range, the default precision and rounding mode, and caches (i.e., data that are not accessed via parameters) are either global (if MPFR has not been compiled as thread safe) or per-thread (thread local storage).

5 MPFR Interface

The floating-point functions expect arguments of type mpfr_t.

The MPFR floating-point functions have an interface that is similar to the GNU MP integer functions. The function prefix for floating-point operations is mpfr_.

There is one significant characteristic of floating-point numbers that has motivated a difference between this function class and other GNU MP function classes: the inherent inexactness of floating-point arithmetic. The user has to specify the precision for each variable. A computation that assigns a variable will take place with the precision of the assigned variable; the cost of that computation should not depend from the precision of variables used as input (on average).

The semantics of a calculation in MPFR is specified as follows: Compute the requested operation exactly (with “infinite accuracy”), and round the result to the precision of the destination variable, with the given rounding mode. The MPFR floating-point functions are intended to be a smooth extension of the IEEE 754-1985 arithmetic. The results obtained on one computer should not differ from the results obtained on a computer with a different word size.

MPFR does not keep track of the accuracy of a computation. This is left to the user or to a higher layer. As a consequence, if two variables are used to store only a few significant bits, and their product is stored in a variable with large precision, then MPFR will still compute the result with full precision.

The value of the standard C macro errno may be set to non-zero by any MPFR function or macro, whether or not there is an error.

• Initialization Functions
• Assignment Functions
• Combined Initialization and Assignment Functions
• Conversion Functions
• Basic Arithmetic Functions
• Comparison Functions
• Special Functions
• Input and Output Functions
• Formatted Output Functions
• Integer Related Functions
• Rounding Related Functions
• Miscellaneous Functions
• Exception Related Functions
• Compatibility with MPF
• Custom Interface
• Internals

5.1 Initialization Functions

An mpfr_t object must be initialized before storing the first value in it. The functions mpfr_init and mpfr_init2 are used for that purpose.

Here is an example of how to use multiple initialization functions:

     {
       mpfr_t x, y, z, t;
       mpfr_inits2 (256, x, y, z, t, (mpfr_ptr) 0);
       ...
       mpfr_clears (x, y, z, t, (mpfr_ptr) 0);
     }

Here is an example on how to initialize floating-point variables:

     {
       mpfr_t x, y;
       mpfr_init (x);                /* use default precision */
       mpfr_init2 (y, 256);          /* precision exactly 256 bits */
       ...
       /* When the program is about to exit, do ... */
       mpfr_clear (x);
       mpfr_clear (y);
       mpfr_free_cache ();
     }

The following functions are useful for changing the precision during a calculation. A typical use would be for adjusting the precision gradually in iterative algorithms like Newton-Raphson, making the computation precision closely match the actual accurate part of the numbers.

5.2 Assignment Functions

These functions assign new values to already initialized floats (see Initialization Functions). When using any functions using intmax_t, you must include <stdint.h> or <inttypes.h> before mpfr.h, to allow mpfr.h to define prototypes for these functions.

5.3 Combined Initialization and Assignment Functions

5.4 Conversion Functions

5.5 Basic Arithmetic Functions

5.6 Comparison Functions

5.7 Special Functions

All those functions, except explicitly stated, return zero for an exact return value, a positive value for a return value larger than the exact result, and a negative value otherwise.

Important note: in some domains, computing special functions (either with correct or incorrect rounding) is expensive, even for small precision, for example the trigonometric and Bessel functions for large argument.

5.8 Input and Output Functions

This section describes functions that perform input from an input/output stream, and functions that output to an input/output stream. Passing a null pointer for a stream to any of these functions will make them read from stdin and write to stdout, respectively.

When using any of these functions, you must include the <stdio.h> standard header before mpfr.h, to allow mpfr.h to define prototypes for these functions.

5.9 Formatted Output Functions

5.9.1 Requirements

The class of mpfr_printf functions provides formatted output in a similar manner as the standard C printf. These functions are defined only if your system supports ISO C variadic functions and the corresponding argument access macros.

When using any of these functions, you must include the <stdio.h> standard header before mpfr.h, to allow mpfr.h to define prototypes for these functions.

5.9.2 Format String

The format specification accepted by mpfr_printf is an extension of the printf one. The conversion specification is of the form:

     % [flags] [width] [.[precision]] [type] [rounding] conv

‘flags’, ‘width’, and ‘precision’ have the same meaning as for the standard C function printf (in particular, notice that the precision is related to the number of digits displayed in the base chosen by ‘conv’ and not related to the internal precision of the mpfr_t variable). mpfr_printf accepts the same ‘type’ specifiers as gmp (except the non-standard and deprecated ‘q’, use ‘ll’ instead), plus ‘R’ and ‘P’:

‘h’	short
‘hh’	char
‘j’	intmax_t or uintmax_t
‘l’	long or wchar_t
‘ll’	long long
‘L’	long double
‘t’	ptrdiff_t
‘z’	size_t
‘F’	mpf_t, float conversions
‘Q’	mpq_t, integer conversions
‘M’	mp_limb_t, integer conversions
‘N’	mp_limb_t array, integer conversions
‘Z’	mpz_t, integer conversions
‘R’	mpfr_t input, float conversions
‘P’	mpfr_prec_t input, integer conversions

The ‘type’ specifiers have the same restrictions as those mentioned in the GMP documentation: see Section “Formatted Output Strings” in GNU MP. More precisely, except for ‘R’ and ‘P’ (which are defined by MPFR), the ‘type’ specifiers are supported only if they are supported by gmp_printf in your GMP build; this implies that the standard specifiers, such as ‘t’, must also be supported by your C library if you want to use them.

The ‘rounding’ specifier is specific to mpfr_t parameter and shall not be used with other types. mpfr_printf accepts the same conversion specifier character ‘conv’ as gmp_printf plus ‘b’.

The ‘P’ type outputs the precision of an mpfr_t variable. It is needed because the mpfr_prec_t type does not necessarily correspond to an unsigned int or any fixed standard type. For example:

     mpfr_t x;
     mpfr_prec_t p;
     mpfr_init (x);
     ...
     p = mpfr_get_prec (x);
     mpfr_printf ("variable x with %Pu bits", p);

The ‘R’ type is used for a mpfr_t output and can be followed by a rounding specifier denoted by one of the following characters:

‘U’	round toward plus infinity
‘D’	round toward minus infinity
‘Z’	round toward zero
‘N’	round to nearest
‘*’	rounding mode (as a mpfr_rnd_t) indicated by the argument just before the corresponding mpfr_t variable.

If the precision field is not empty, the mpfr_t number is rounded to the given precision in the direction specified by the rounding mode. If the precision field is empty (as in ‘%.Rf’), the number is displayed with enough digits so that it can be read back exactly (assuming rounding to nearest, see mpfr_get_str). If no rounding is specified, the mpfr_t argument is rounded to nearest. The following three examples are equivalent:

     mpfr_t x;
     mpfr_init (x);
     ...
     mpfr_printf ("%.128Rf", x);
     mpfr_printf ("%.128RNf", x);
     mpfr_printf ("%.128R*f", GMP_RNDN, x);

mpfr_printf also adds a new conversion specifier ‘b’ which displays the mpfr_t parameter in binary, the behavior is undefined with other parameter type. The ‘conv’ specifiers allowed with mpfr_t parameter are:

‘a’ ‘A’	hex float, C99 style
‘b’	binary output
‘e’ ‘E’	scientific format float
‘f’	fixed point float
‘g’ ‘G’	fixed or scientific float

In case of non-decimal output, only the significand is written in the specified base, the exponent is always displayed in decimal. Special values are always displayed as nan, -inf, and inf for ‘a’, ‘b’, ‘e’, ‘f’, and ‘g’ specifiers and NAN, -INF, and INF for ‘A’, ‘E’, ‘F’, and ‘G’ specifiers. In binary output, the precision is silently increased up to 2 if it equals 1.

5.9.3 Functions