The MPFR multiple-precision floating-point library
The MPFR library is a C library for multiple-precision floating-point
computations with exact rounding (also called correct rounding). It is
based on the GMP multiple-precision library.
The main goal of MPFR is to provide a library for multiple-precision
floating-point computation which is both efficient and has a
well-defined semantics. It copies the good ideas from the ANSI/IEEE-754
standard for double-precision floating-point arithmetic (53-bit
mantissa).
- Developed at devel:libraries:c_c++
- Sources inherited from project openSUSE:Factory
-
8
derived packages
- Download package
-
Checkout Package
osc -A https://api.opensuse.org checkout openSUSE:Factory:zSystems/mpfr && cd $_
- Create Badge
Refresh
Refresh
Source Files
Filename | Size | Changed |
---|---|---|
baselibs.conf | 0000000095 95 Bytes | |
mpfr-4.2.0-cummulative.patch | 0000074767 73 KB | |
mpfr-4.2.0.tar.xz | 0001477532 1.41 MB | |
mpfr-4.2.0.tar.xz.asc | 0000000228 228 Bytes | |
mpfr.changes | 0000027715 27.1 KB | |
mpfr.keyring | 0000015034 14.7 KB | |
mpfr.spec | 0000003560 3.48 KB |
Revision 60 (latest revision is 61)
Dominique Leuenberger (dimstar_suse)
accepted
request 1091232
from
Richard Biener (rguenther)
(revision 60)
- Update mpfr-4.2.0-cummulative.patch, adds patches fixing the following bugs * the mpfr_reldiff function, which computes |b-c|/b, is buggy on special values, e.g. on the following (b,c) values: (+Inf,+Inf) gives ±0 instead of NaN (like NaN/Inf); (+0,+0) gives 1 instead of NaN (like 0/0); (+0,1) gives 1 instead of Inf (like 1/0). Moreover, the sign of 0 for (+Inf,+Inf) or (-Inf,-Inf) is not set, i.e. it is just the sign of the destination before the call; as a consequence, results are not even consistent. * the reuse tests are incomplete: the sign of a result zero is not checked, so that it can miss bugs (one of the mpfr_reldiff bugs mentioned above, in particular). * the general code for the power function (mpfr_pow_general internal function) has two bugs in particular cases: the first one is an incorrect computation of the error bound when there has been an intermediate underflow or overflow (in such a case, the computation is performed again with a rescaling, thus with an additional error term, but there is a bug in the computation of this term), so that the result may be rounded incorrectly (in particular, a spurious overflow is possible); the second one occurs in a corner case (destination precision 1, rounding to nearest, and where the rounded result assuming an unbounded exponent range would be 2emin-2 and the exact result is larger than this value), with the only consequence being a missing underflow exception (the underflow flag is not set). * the mpfr_compound_si function can take a huge amount of memory and time in some cases (when the argument x is a large even integer and xn is represented exactly in the target precision) and does not correctly detect overflows and underflows * MPFR can crash when a formatted output function is called with %.2147483648Rg in the format string.
Comments 0