GNU MPFR version 3.1.0 (released on 3 October 2011)

The canard à l'orange release.

MPFR 3.1.0 requires GMP 4.1.0 or higher (GMP 4.2.3 or higher is recommended).

Note: the bug-fix release MPFR 3.1.1 is available. Please upgrade!

Warning! Due to the fact that Thread-Local Storage (TLS) support is now detected automatically, the MPFR build can be incorrect on some platforms (compiler or system bug). Indeed, the TLS implementation of some compilers/platforms is buggy, and MPFR cannot detect every problem at configure time. Please run make check to see if your build is affected. If you get failures, you should try the --disable-thread-safe configure option to disable TLS and see if this solves these failures. But you should not use an MPFR library with TLS disabled in a multithreaded program (unless you know what you are doing).

Download

The MPFR 3.1.0 source can be downloaded in the following archive formats:

• mpfr-3.1.0.tar.xz (tar/xz, 1.1 MB, signature),
• mpfr-3.1.0.tar.bz2 (tar/bzip2, 1.2 MB, signature),
• mpfr-3.1.0.tar.gz (tar/gzip, 1.6 MB, signature),
• mpfr-3.1.0.zip (zip, 2.0 MB, signature).

MPFR is also available via third-party packages and ports.

Documentation

• The reference manual: [html] [dvi] [ps] [pdf]
• The MPFR FAQ (common to all MPFR versions).

Bugs

The bugs listed below have been fixed (latest update: 2012-05-07). The patches are distributed under the same license as this version of MPFR, that is, the GNU Lesser General Public License (GNU Lesser GPL), version 3 or later.

The following instructions are for Linux and may be similar for other operating systems. You can apply the patches in several ways:

• Apply the cumulative patch on the 3.1.0 release or a partially patched version with the command

  patch -N -Z -p1 < path_to_patches_file

  from the source directory. The -N option allows the patch command to ignore patches already applied. The -Z option sets the modification time of the patched files from time stamps given in the patch file, thus avoiding the need of some development utilities (such as autoconf); this may generate a Not setting time warning for the PATCHES file, but you can safely ignore it. Under Microsoft Windows, in addition to the above options, you may need the --binary option (this depends whether the end-of-lines have been converted when you downloaded the patch file). Also note that the --dry-run option does not work if the cumulative patch has some file listed several times.
• Or apply the individual patches below.
• Or checkout the 3.1 branch from the Subversion repository, e.g. with the command

  svn co svn://scm.gforge.inria.fr/svn/mpfr/branches/3.1 mpfr-3.1

  In this case, as said on the Gforge page, you should read the README.dev file for details on how to build MPFR. Also note that the branch may contain additional minor fixes.

With the first two ways, the PATCHES file is modified, so that one can know what patches have been applied, using the mpfr_get_patches function. Moreover a suffix is added to the version string, but note that for practical reasons, not all the files where the version appears are patched; thus one can also track applied patches with the MPFR_VERSION_STRING macro (header) and the mpfr_get_version function (library). However, if some patches are not applied or if patches are applied in a different order, then the patch command will fail to update some chunks, so that the suffix is not always reliable for patches.

Note: These patches are in unified diff format and some vendors' patch commands cannot deal with them; in this case, please use GNU patch (it may already be installed on your system, e.g. as /usr/local/bin/patch or gpatch).

Fixed bugs, with patches:

1. The MPFR_UNLIKELY internal macro definition for GCC is incorrect. The compiled code can be affected when a limb is larger than a long (e.g. with some ABI's, such as mode32 on PowerPC). The MPFR_UNLIKELY definition has been incorrect since it was introduced in MPFR 2.1.0, but problems started to be visible only in MPFR 3.1.0 with all assertions checked (the MPFR code is normally written to work with the incorrect definition). This bug is fixed by the mpfr_unlikely patch.
2. On some platforms, such as HP-UX, when --with-gmp or --with-gmp-lib is used and an old MPFR library is already installed in the corresponding lib directory, the tests are linked against this old MPFR library instead of the one that has just been compiled. This problem due to autoconf/automake is fixed by the lib-search-path patch.
3. The formatted output functions (mpfr_*printf) may output/return an incorrect string when the value is rounded up to the next power of 10 (for instance, 999.99999... printed with "%.20RNg" may give "100" instead of "1000"). This bug, which has always been present (since these functions were introduced in MPFR 2.4.0), is fixed by the vasprintf patch (which also provides testcases). Note: MPFR 3.1.0 also introduced a regression in some other cases, such as -9.996 in 32 bits printed with "%.2Rg".
4. The testsuite (make check) fails when MPFR is built against GMP 4.1.* (which is a very old version). This is not a bug in the MPFR library, but in the tests, which do not take into account the fact that the default random number generator of GMP changed between versions 4.1 and 4.2. This problem is fixed by the gmp41compat patch, which also updates the MPFR manual to mention this change (in the API Compatibility chapter).
5. When logging is used (note that logging support must have explicitly been enabled in the MPFR build), e.g. with MPFR_LOG_ALL=1, the program may randomly freeze (observed with dynamic linking), take a lot of memory or have other random behavior. The problem actually occurs in the following functions: mpfr_add_d, mpfr_add_ui and mpfr_mul_d; but mpfr_add_ui is used by other functions (directly or indirectly). This is due to a typo in an argument for the internal logging macro MPFR_LOG_FUNC: instead of the variable mpfr_log_prec (whose value is 6 by default), the function pointer mpfr_get_prec is used, and it has an arbitrary value. This bug (#13933) is fixed by the logging-freeze patch.
6. In the logging system, an incorrect format is used for MPFR_LOG_VAR. If the logged variable has a huge value, the output has many digits; this can potentially take much memory and disk space. This bug is fixed by the logging-varfmt patch.
7. Since the change of mpfr_prec_t to a signed type, it is no longer possible to use precisions close to MPFR_PREC_MAX in some cases where it used to work. This problem is fixed by the large-prec patch, which also provides a simple testcase. Note that:
   • Only machines with a 32-bit precision type are affected by this problem in practice (32-bit machines, or 64-bit machines where MPFR is built with a 32-bit ABI, e.g. with the -m32 compiler option).
   • In general, intermediate variables are used and the precision is increased internally, so that MPFR may abort in very large precisions, even less than MPFR_PREC_MAX, because of this type limitation or a lack of memory.
   • In very large precisions, there may still be integer overflows (due to increased working precision) instead of a clean abort.
8. For users of GMP's development version (GMP's Mercurial repository) and/or the future GMP 5.1.0 version (and later): The mpfr.h header file uses the gmp.h internal __gmp_const macro, which has been removed from the GMP repository on 2012-03-04. The __gmp_const patch provides a temporary fix. More precisely, in the past, this macro was used for K&R (pre-ANSI) C compatibility, and it should nowadays be defined to const; this is what the patch does when GMP doesn't define this macro. Future major MPFR versions (3.2.0 and later) will replace __gmp_const by const, like what has been done in GMP.
9. The underflow detection code of mpfr_gamma is buggy: some results may incorrectly be regarded as underflow. This bug is fixed by the gamma-underflow patch, which also provides a testcase. Warning! While this patch avoids incorrect results on values close to underflow, it makes another problem appear: a possible infinite loop for some underflow cases. In particular, the testsuite will freeze on 32-bit machines. You also need the following patch to avoid that.
10. As the early overflow/underflow detection code of mpfr_gamma is not exact, the exact detection must be performed in the general computation code to avoid an endless loop. This is done by the gamma-overunderflow patch, which also provides testcases.

See the tracker and the BUGS file.

Changes from versions 3.0.* to version 3.1.0

• The MPFR source has been reorganized.
• Dropped ansi2knr support.
• TLS support is now detected automatically. If TLS is supported, MPFR is built as thread safe by default. To disable TLS explicitly, configure MPFR with --disable-thread-safe.
• New --enable-gmp-internals configure option to use GMP's undocumented functions (not from the public API). Note that library versioning is not guaranteed to work if this option is used.
• The mpfr_urandom and mpfr_urandomb functions now return identical values on processors with different word size (assuming the same random seed, and since the GMP random generator does not depend itself on the word size, cf https://gmplib.org/list-archives/gmp-devel/2010-September/001642.html).
• The mpfr_add_one_ulp and mpfr_sub_one_ulp macros (which are obsolete and no more documented) will be removed in a future release.
• Speed improvement for the mpfr_sqr and mpfr_div functions using Mulders' algorithm. As a consequence, other functions using those routines are also faster.
• Much faster formatted output (mpfr_printf, etc.) with %Rg and similar.
• The --with-gmp-build configure option can now be used when the GMP source directory and the GMP build directory are different (without having to copy header files manually as before).
• New functions mpfr_buildopt_gmpinternals_p, mpfr_buildopt_tune_case, mpfr_frexp, mpfr_grandom and mpfr_z_sub.
• New divide-by-zero exception (flag) and associated functions.
• The mpfr.h header can be included several times, while still supporting optional functions (see Section Headers and Libraries in the manual).
• Updated tuning parameters.
• Improved MPFR manual.
• MPFR tests: libtool no longer generates wrapper scripts with make check (so that running the tests under valgrind or gdb is easier).
• Internal change: the logging mechanism has been improved.
• Bug fixes (detailed list on the MPFR 3.0.1 page for some of them).

Note: The mpfr_subnormalize implementation up to MPFR 3.0.0 did not change the flags. In particular, it did not follow the generic rule concerning the inexact flag (and no special behavior was specified). The case of the underflow flag was more a lack of specification.

Platforms Known to Support MPFR

MPFR 3.1.0 has been successfully compiled and checked on the following platforms:

• i386-pc-solaris2.10 (Sun C 5.9 SunOS_i386 Patch 124868-10 2009/04/30),
• i686-pc-linux-gnu (gcc and g++ 4.3.4),
• ia64-unknown-linux-gnu (gcc 4.4.5),
• mips64el-unknown-linux-gnu (gcc 4.3.2),
• powerpc-apple-darwin8.11.0 (PowerPC G5, gcc 4.0.1, 32 and 64 bits, with patch 1 for the mode32 GMP ABI),
• powerpc-unknown-linux-gnu (gcc 4.5.3; PowerPC G4, gcc 4.6.1),
• powerpc64-unknown-linux-gnu (gcc 4.5.3 and 4.6.1),
• sparc64-unknown-linux-gnu (gcc 4.3.2),
• sparc64-unknown-openbsd4.6 (gcc 3.3.5),
• x86_64-apple-darwin11.1.0 (llvm-gcc 4.2.1),
• x86_64-unknown-linux-gnu (gcc 4.4.5, 4.6.1 and 4.7 snapshot, g++ 4.6.1, llvm-gcc 4.5.3, and clang 2.9),
• x86_64-unknown-netbsd5.1 (gcc 4.1.3).

Back to the MPFR page.