snailed
/
void-packages
2
0
Fork 0
Code Issues 1 Pull Requests 2 Actions Activity
void-packages/srcpkgs/mpfr/patches/mpfr-3.1.2-upstream_fixes-2...

1220 lines
38 KiB
Diff
Raw Normal View History

mpfr: Import upstream fixes for 3.1.2 (p11) Imported from LFS (http://www.linuxfromscratch.org/lfs/view/development/chapter06/mpfr.html) For the source see: http://www.mpfr.org/mpfr-current/allpatches Incorporate patch p11 as well
2015-05-13 14:32:02 +02:00
Submitted By: Bruce Dubbs <bdubbs_at_linuxfromscratch_dot_org>
Date: 2014-08-04
Initial Package Version: 3.1.2
Upstream Status: Already in upstream patch repo
Origin: Upstream
Description: This patch contains patches for several bugs in MPFR.
Note that the patch for configure.ac has been
removed to prevent unneeded regeneration of build
files.
See http://www.mpfr.org/mpfr-current/allpatches
--- PATCHES 2013-03-13 16:37:38.000000000 +0100
+++ PATCHES 2014-08-04 16:44:01.125172770 +0200
@@ -0,0 +1,11 @@
+vasprintf
+div-overflow
+gmp6-compat
+exp3
+li2-return
+custom_init_set
+printf-alt0
+clang-divby0
+fits-smallneg
+exp_2
+strtofr
--- src/div.c 2013-03-13 16:37:33.000000000 +0100
+++ src/div.c 2014-08-04 16:44:01.125172770 +0200
@@ -750,7 +750,9 @@
truncate_check_qh:
if (qh)
{
- qexp ++;
+ if (MPFR_LIKELY (qexp < MPFR_EXP_MAX))
+ qexp ++;
+ /* else qexp is now incorrect, but one will still get an overflow */
q0p[q0size - 1] = MPFR_LIMB_HIGHBIT;
}
goto truncate;
@@ -765,7 +767,9 @@
inex = 1; /* always here */
if (mpn_add_1 (q0p, q0p, q0size, MPFR_LIMB_ONE << sh))
{
- qexp ++;
+ if (MPFR_LIKELY (qexp < MPFR_EXP_MAX))
+ qexp ++;
+ /* else qexp is now incorrect, but one will still get an overflow */
q0p[q0size - 1] = MPFR_LIMB_HIGHBIT;
}
--- src/exp_2.c 2013-03-13 16:37:28.000000000 +0100
+++ src/exp_2.c 2014-08-04 16:44:01.125172770 +0200
@@ -204,7 +204,7 @@
for (k = 0; k < K; k++)
{
mpz_mul (ss, ss, ss);
- exps <<= 1;
+ exps *= 2;
exps += mpz_normalize (ss, ss, q);
}
mpfr_set_z (s, ss, MPFR_RNDN);
--- src/exp3.c 2013-03-13 16:37:34.000000000 +0100
+++ src/exp3.c 2014-08-04 16:44:01.125172770 +0200
@@ -283,7 +283,7 @@
}
}
- if (mpfr_can_round (shift_x > 0 ? t : tmp, realprec, MPFR_RNDD, MPFR_RNDZ,
+ if (mpfr_can_round (shift_x > 0 ? t : tmp, realprec, MPFR_RNDN, MPFR_RNDZ,
MPFR_PREC(y) + (rnd_mode == MPFR_RNDN)))
{
inexact = mpfr_set (y, shift_x > 0 ? t : tmp, rnd_mode);
--- src/fits_u.h 2013-03-13 16:37:35.000000000 +0100
+++ src/fits_u.h 2014-08-04 16:44:01.125172770 +0200
@@ -32,17 +32,20 @@
int res;
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f)))
- /* Zero always fit */
- return MPFR_IS_ZERO (f) ? 1 : 0;
- else if (MPFR_IS_NEG (f))
- /* Negative numbers don't fit */
- return 0;
- /* now it fits if
- (a) f <= MAXIMUM
- (b) round(f, prec(slong), rnd) <= MAXIMUM */
+ return MPFR_IS_ZERO (f) ? 1 : 0; /* Zero always fits */
e = MPFR_GET_EXP (f);
+ if (MPFR_IS_NEG (f))
+ return e >= 1 ? 0 /* f <= -1 does not fit */
+ : rnd != MPFR_RNDN ? MPFR_IS_LIKE_RNDU (rnd, -1) /* directed mode */
+ : e < 0 ? 1 /* f > -1/2 fits in MPFR_RNDN */
+ : mpfr_powerof2_raw(f); /* -1/2 fits, -1 < f < -1/2 don't */
+
+ /* Now it fits if
+ (a) f <= MAXIMUM
+ (b) round(f, prec(slong), rnd) <= MAXIMUM */
+
/* first compute prec(MAXIMUM); fits in an int */
for (s = MAXIMUM, prec = 0; s != 0; s /= 2, prec ++);
--- src/fits_uintmax.c 2013-03-13 16:37:33.000000000 +0100
+++ src/fits_uintmax.c 2014-08-04 16:44:01.126172775 +0200
@@ -27,51 +27,19 @@
#include "mpfr-intmax.h"
#include "mpfr-impl.h"
-#ifdef _MPFR_H_HAVE_INTMAX_T
-
-/* We can't use fits_u.h <= mpfr_cmp_ui */
-int
-mpfr_fits_uintmax_p (mpfr_srcptr f, mpfr_rnd_t rnd)
-{
- mpfr_exp_t e;
- int prec;
- uintmax_t s;
- mpfr_t x;
- int res;
-
- if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f)))
- /* Zero always fit */
- return MPFR_IS_ZERO (f) ? 1 : 0;
- else if (MPFR_IS_NEG (f))
- /* Negative numbers don't fit */
- return 0;
- /* now it fits if
- (a) f <= MAXIMUM
- (b) round(f, prec(slong), rnd) <= MAXIMUM */
-
- e = MPFR_GET_EXP (f);
+/* Note: though mpfr-impl.h is included in fits_u.h, we also include it
+ above so that it gets included even when _MPFR_H_HAVE_INTMAX_T is not
+ defined; this is necessary to avoid an empty translation unit, which
+ is forbidden by ISO C. Without this, a failing test can be reproduced
+ by creating an invalid stdint.h somewhere in the default include path
+ and by compiling MPFR with "gcc -ansi -pedantic-errors". */
- /* first compute prec(MAXIMUM); fits in an int */
- for (s = MPFR_UINTMAX_MAX, prec = 0; s != 0; s /= 2, prec ++);
-
- /* MAXIMUM needs prec bits, i.e. MAXIMUM = 2^prec - 1 */
-
- /* if e <= prec - 1, then f < 2^(prec-1) < MAXIMUM */
- if (e <= prec - 1)
- return 1;
-
- /* if e >= prec + 1, then f >= 2^prec > MAXIMUM */
- if (e >= prec + 1)
- return 0;
+#ifdef _MPFR_H_HAVE_INTMAX_T
- MPFR_ASSERTD (e == prec);
+#define FUNCTION mpfr_fits_uintmax_p
+#define MAXIMUM MPFR_UINTMAX_MAX
+#define TYPE uintmax_t
- /* hard case: first round to prec bits, then check */
- mpfr_init2 (x, prec);
- mpfr_set (x, f, rnd);
- res = MPFR_GET_EXP (x) == e;
- mpfr_clear (x);
- return res;
-}
+#include "fits_u.h"
#endif
--- src/init2.c 2013-03-13 16:37:32.000000000 +0100
+++ src/init2.c 2014-08-04 16:44:01.126172775 +0200
@@ -30,11 +30,11 @@
/* Check if we can represent the number of limbs
* associated to the maximum of mpfr_prec_t*/
- MPFR_ASSERTN( MP_SIZE_T_MAX >= (MPFR_PREC_MAX/BYTES_PER_MP_LIMB) );
+ MPFR_ASSERTN( MP_SIZE_T_MAX >= (MPFR_PREC_MAX/MPFR_BYTES_PER_MP_LIMB) );
- /* Check for correct GMP_NUMB_BITS and BYTES_PER_MP_LIMB */
- MPFR_ASSERTN( GMP_NUMB_BITS == BYTES_PER_MP_LIMB * CHAR_BIT
- && sizeof(mp_limb_t) == BYTES_PER_MP_LIMB );
+ /* Check for correct GMP_NUMB_BITS and MPFR_BYTES_PER_MP_LIMB */
+ MPFR_ASSERTN( GMP_NUMB_BITS == MPFR_BYTES_PER_MP_LIMB * CHAR_BIT
+ && sizeof(mp_limb_t) == MPFR_BYTES_PER_MP_LIMB );
MPFR_ASSERTN (mp_bits_per_limb == GMP_NUMB_BITS);
--- src/li2.c 2013-03-13 16:37:32.000000000 +0100
+++ src/li2.c 2014-08-04 16:44:01.126172775 +0200
@@ -630,5 +630,5 @@
return mpfr_check_range (y, inexact, rnd_mode);
}
- MPFR_ASSERTN (0); /* should never reach this point */
+ MPFR_RET_NEVER_GO_HERE ();
}
--- src/mpfr-gmp.h 2013-03-13 16:37:32.000000000 +0100
+++ src/mpfr-gmp.h 2014-08-04 16:44:01.126172775 +0200
@@ -72,7 +72,6 @@
#endif
/* Define some macros */
-#define BYTES_PER_MP_LIMB (GMP_NUMB_BITS/CHAR_BIT)
#define MP_LIMB_T_MAX (~(mp_limb_t)0)
@@ -96,19 +95,19 @@
#define SHRT_HIGHBIT SHRT_MIN
/* MP_LIMB macros */
-#define MPN_ZERO(dst, n) memset((dst), 0, (n)*BYTES_PER_MP_LIMB)
-#define MPN_COPY_DECR(dst,src,n) memmove((dst),(src),(n)*BYTES_PER_MP_LIMB)
-#define MPN_COPY_INCR(dst,src,n) memmove((dst),(src),(n)*BYTES_PER_MP_LIMB)
+#define MPN_ZERO(dst, n) memset((dst), 0, (n)*MPFR_BYTES_PER_MP_LIMB)
+#define MPN_COPY_DECR(dst,src,n) memmove((dst),(src),(n)*MPFR_BYTES_PER_MP_LIMB)
+#define MPN_COPY_INCR(dst,src,n) memmove((dst),(src),(n)*MPFR_BYTES_PER_MP_LIMB)
#define MPN_COPY(dst,src,n) \
do \
{ \
if ((dst) != (src)) \
{ \
MPFR_ASSERTD ((char *) (dst) >= (char *) (src) + \
- (n) * BYTES_PER_MP_LIMB || \
+ (n) * MPFR_BYTES_PER_MP_LIMB || \
(char *) (src) >= (char *) (dst) + \
- (n) * BYTES_PER_MP_LIMB); \
- memcpy ((dst), (src), (n) * BYTES_PER_MP_LIMB); \
+ (n) * MPFR_BYTES_PER_MP_LIMB); \
+ memcpy ((dst), (src), (n) * MPFR_BYTES_PER_MP_LIMB); \
} \
} \
while (0)
--- src/mpfr.h 2013-03-13 16:37:37.000000000 +0100
+++ src/mpfr.h 2014-08-04 16:44:01.126172775 +0200
@@ -27,7 +27,7 @@
#define MPFR_VERSION_MAJOR 3
#define MPFR_VERSION_MINOR 1
#define MPFR_VERSION_PATCHLEVEL 2
-#define MPFR_VERSION_STRING "3.1.2"
+#define MPFR_VERSION_STRING "3.1.2-p10"
/* Macros dealing with MPFR VERSION */
#define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
@@ -861,7 +861,7 @@
_t = (mpfr_kind_t) _k; \
_s = 1; \
} else { \
- _t = (mpfr_kind_t) -k; \
+ _t = (mpfr_kind_t) - _k; \
_s = -1; \
} \
_e = _t == MPFR_REGULAR_KIND ? (e) : \
--- src/mpfr-impl.h 2013-03-13 16:37:36.000000000 +0100
+++ src/mpfr-impl.h 2014-08-04 16:44:01.127172781 +0200
@@ -191,7 +191,7 @@
# endif
#endif
-
+#define MPFR_BYTES_PER_MP_LIMB (GMP_NUMB_BITS/CHAR_BIT)
/******************************************************
******************** Check GMP ***********************
@@ -468,8 +468,16 @@
#define MPFR_LIMBS_PER_FLT ((IEEE_FLT_MANT_DIG-1)/GMP_NUMB_BITS+1)
/* Visual C++ doesn't support +1.0/0.0, -1.0/0.0 and 0.0/0.0
- at compile time. */
-#if defined(_MSC_VER) && defined(_WIN32) && (_MSC_VER >= 1200)
+ at compile time.
+ Clang with -fsanitize=undefined is a bit similar due to a bug:
+ http://llvm.org/bugs/show_bug.cgi?id=17381
+ but even without its sanitizer, it may be better to use the
+ double_zero version until IEEE 754 division by zero is properly
+ supported:
+ http://llvm.org/bugs/show_bug.cgi?id=17000
+*/
+#if (defined(_MSC_VER) && defined(_WIN32) && (_MSC_VER >= 1200)) || \
+ defined(__clang__)
static double double_zero = 0.0;
# define DBL_NAN (double_zero/double_zero)
# define DBL_POS_INF ((double) 1.0/double_zero)
@@ -501,6 +509,8 @@
(with Xcode 2.4.1, i.e. the latest one). */
#define LVALUE(x) (&(x) == &(x) || &(x) != &(x))
#define DOUBLE_ISINF(x) (LVALUE(x) && ((x) > DBL_MAX || (x) < -DBL_MAX))
+/* The DOUBLE_ISNAN(x) macro is also valid on long double x
+ (assuming that the compiler isn't too broken). */
#ifdef MPFR_NANISNAN
/* Avoid MIPSpro / IRIX64 / gcc -ffast-math (incorrect) optimizations.
The + must not be replaced by a ||. With gcc -ffast-math, NaN is
@@ -920,7 +930,7 @@
#define MPFR_SET_ALLOC_SIZE(x, n) \
( ((mp_size_t*) MPFR_MANT(x))[-1] = n)
#define MPFR_MALLOC_SIZE(s) \
- ( sizeof(mpfr_size_limb_t) + BYTES_PER_MP_LIMB * ((size_t) s) )
+ ( sizeof(mpfr_size_limb_t) + MPFR_BYTES_PER_MP_LIMB * ((size_t) s) )
#define MPFR_SET_MANT_PTR(x,p) \
(MPFR_MANT(x) = (mp_limb_t*) ((mpfr_size_limb_t*) p + 1))
#define MPFR_GET_REAL_PTR(x) \
@@ -954,7 +964,7 @@
#endif
#define MPFR_TMP_LIMBS_ALLOC(N) \
- ((mp_limb_t *) MPFR_TMP_ALLOC ((size_t) (N) * BYTES_PER_MP_LIMB))
+ ((mp_limb_t *) MPFR_TMP_ALLOC ((size_t) (N) * MPFR_BYTES_PER_MP_LIMB))
/* temporary allocate 1 limb at xp, and initialize mpfr variable x */
/* The temporary var doesn't have any size field, but it doesn't matter
--- src/mul.c 2013-03-13 16:37:37.000000000 +0100
+++ src/mul.c 2014-08-04 16:44:01.127172781 +0200
@@ -106,7 +106,7 @@
MPFR_ASSERTD(tn <= k);
/* Check for no size_t overflow*/
- MPFR_ASSERTD((size_t) k <= ((size_t) -1) / BYTES_PER_MP_LIMB);
+ MPFR_ASSERTD((size_t) k <= ((size_t) -1) / MPFR_BYTES_PER_MP_LIMB);
MPFR_TMP_MARK(marker);
tmp = MPFR_TMP_LIMBS_ALLOC (k);
@@ -301,7 +301,7 @@
MPFR_ASSERTD (tn <= k); /* tn <= k, thus no int overflow */
/* Check for no size_t overflow*/
- MPFR_ASSERTD ((size_t) k <= ((size_t) -1) / BYTES_PER_MP_LIMB);
+ MPFR_ASSERTD ((size_t) k <= ((size_t) -1) / MPFR_BYTES_PER_MP_LIMB);
MPFR_TMP_MARK (marker);
tmp = MPFR_TMP_LIMBS_ALLOC (k);
--- src/stack_interface.c 2013-03-13 16:37:32.000000000 +0100
+++ src/stack_interface.c 2014-08-04 16:44:01.127172781 +0200
@@ -26,7 +26,7 @@
size_t
mpfr_custom_get_size (mpfr_prec_t prec)
{
- return MPFR_PREC2LIMBS (prec) * BYTES_PER_MP_LIMB;
+ return MPFR_PREC2LIMBS (prec) * MPFR_BYTES_PER_MP_LIMB;
}
#undef mpfr_custom_init
--- src/vasprintf.c 2013-03-13 16:37:37.000000000 +0100
+++ src/vasprintf.c 2014-08-04 16:44:01.127172781 +0200
@@ -884,14 +884,18 @@
first digit, we want the exponent for radix two and the decimal
point AFTER the first digit. */
{
- MPFR_ASSERTN (exp > MPFR_EMIN_MIN /4); /* possible overflow */
+ /* An integer overflow is normally not possible since MPFR_EXP_MIN
+ is twice as large as MPFR_EMIN_MIN. */
+ MPFR_ASSERTN (exp > (MPFR_EXP_MIN + 3) / 4);
exp = (exp - 1) * 4;
}
else
/* EXP is the exponent for decimal point BEFORE the first digit, we
want the exponent for decimal point AFTER the first digit. */
{
- MPFR_ASSERTN (exp > MPFR_EMIN_MIN); /* possible overflow */
+ /* An integer overflow is normally not possible since MPFR_EXP_MIN
+ is twice as large as MPFR_EMIN_MIN. */
+ MPFR_ASSERTN (exp > MPFR_EXP_MIN);
--exp;
}
}
@@ -1040,7 +1044,7 @@
}
/* Determine the different parts of the string representation of the regular
- number P when SPEC.SPEC is 'e', 'E', 'g', or 'G'.
+ number P when spec.spec is 'e', 'E', 'g', or 'G'.
DEC_INFO contains the previously computed exponent and string or is NULL.
return -1 if some field > INT_MAX */
@@ -1167,7 +1171,7 @@
}
/* Determine the different parts of the string representation of the regular
- number P when SPEC.SPEC is 'f', 'F', 'g', or 'G'.
+ number P when spec.spec is 'f', 'F', 'g', or 'G'.
DEC_INFO contains the previously computed exponent and string or is NULL.
return -1 if some field of number_parts is greater than INT_MAX */
@@ -1559,7 +1563,7 @@
/* fractional part */
{
np->point = MPFR_DECIMAL_POINT;
- np->fp_trailing_zeros = (spec.spec == 'g' && spec.spec == 'G') ?
+ np->fp_trailing_zeros = (spec.spec == 'g' || spec.spec == 'G') ?
spec.prec - 1 : spec.prec;
}
else if (spec.alt)
--- src/version.c 2013-03-13 16:37:34.000000000 +0100
+++ src/version.c 2014-08-04 16:44:01.127172781 +0200
@@ -25,5 +25,5 @@
const char *
mpfr_get_version (void)
{
- return "3.1.2";
+ return "3.1.2-p10";
}
--- tests/tdiv.c 2013-03-13 16:37:44.000000000 +0100
+++ tests/tdiv.c 2014-08-04 16:44:01.128172786 +0200
@@ -1104,6 +1104,96 @@
#define RAND_FUNCTION(x) mpfr_random2(x, MPFR_LIMB_SIZE (x), randlimb () % 100, RANDS)
#include "tgeneric.c"
+static void
+test_extreme (void)
+{
+ mpfr_t x, y, z;
+ mpfr_exp_t emin, emax;
+ mpfr_prec_t p[4] = { 8, 32, 64, 256 };
+ int xi, yi, zi, j, r;
+ unsigned int flags, ex_flags;
+
+ emin = mpfr_get_emin ();
+ emax = mpfr_get_emax ();
+
+ mpfr_set_emin (MPFR_EMIN_MIN);
+ mpfr_set_emax (MPFR_EMAX_MAX);
+
+ for (xi = 0; xi < 4; xi++)
+ {
+ mpfr_init2 (x, p[xi]);
+ mpfr_setmax (x, MPFR_EMAX_MAX);
+ MPFR_ASSERTN (mpfr_check (x));
+ for (yi = 0; yi < 4; yi++)
+ {
+ mpfr_init2 (y, p[yi]);
+ mpfr_setmin (y, MPFR_EMIN_MIN);
+ for (j = 0; j < 2; j++)
+ {
+ MPFR_ASSERTN (mpfr_check (y));
+ for (zi = 0; zi < 4; zi++)
+ {
+ mpfr_init2 (z, p[zi]);
+ RND_LOOP (r)
+ {
+ mpfr_clear_flags ();
+ mpfr_div (z, x, y, (mpfr_rnd_t) r);
+ flags = __gmpfr_flags;
+ MPFR_ASSERTN (mpfr_check (z));
+ ex_flags = MPFR_FLAGS_OVERFLOW | MPFR_FLAGS_INEXACT;
+ if (flags != ex_flags)
+ {
+ printf ("Bad flags in test_extreme on z = a/b"
+ " with %s and\n",
+ mpfr_print_rnd_mode ((mpfr_rnd_t) r));
+ printf ("a = ");
+ mpfr_dump (x);
+ printf ("b = ");
+ mpfr_dump (y);
+ printf ("Expected flags:");
+ flags_out (ex_flags);
+ printf ("Got flags: ");
+ flags_out (flags);
+ printf ("z = ");
+ mpfr_dump (z);
+ exit (1);
+ }
+ mpfr_clear_flags ();
+ mpfr_div (z, y, x, (mpfr_rnd_t) r);
+ flags = __gmpfr_flags;
+ MPFR_ASSERTN (mpfr_check (z));
+ ex_flags = MPFR_FLAGS_UNDERFLOW | MPFR_FLAGS_INEXACT;
+ if (flags != ex_flags)
+ {
+ printf ("Bad flags in test_extreme on z = a/b"
+ " with %s and\n",
+ mpfr_print_rnd_mode ((mpfr_rnd_t) r));
+ printf ("a = ");
+ mpfr_dump (y);
+ printf ("b = ");
+ mpfr_dump (x);
+ printf ("Expected flags:");
+ flags_out (ex_flags);
+ printf ("Got flags: ");
+ flags_out (flags);
+ printf ("z = ");
+ mpfr_dump (z);
+ exit (1);
+ }
+ }
+ mpfr_clear (z);
+ } /* zi */
+ mpfr_nextabove (y);
+ } /* j */
+ mpfr_clear (y);
+ } /* yi */
+ mpfr_clear (x);
+ } /* xi */
+
+ set_emin (emin);
+ set_emax (emax);
+}
+
int
main (int argc, char *argv[])
{
@@ -1130,6 +1220,7 @@
test_20070603 ();
test_20070628 ();
test_generic (2, 800, 50);
+ test_extreme ();
tests_end_mpfr ();
return 0;
--- tests/texp.c 2013-03-13 16:37:44.000000000 +0100
+++ tests/texp.c 2014-08-04 16:44:01.128172786 +0200
@@ -150,6 +150,22 @@
exit (1);
}
+ mpfr_set_prec (x, 118);
+ mpfr_set_str_binary (x, "0.1110010100011101010000111110011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E-86");
+ mpfr_set_prec (y, 118);
+ mpfr_exp_2 (y, x, MPFR_RNDU);
+ mpfr_exp_3 (x, x, MPFR_RNDU);
+ if (mpfr_cmp (x, y))
+ {
+ printf ("mpfr_exp_2 and mpfr_exp_3 differ for prec=118\n");
+ printf ("mpfr_exp_2 gives ");
+ mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
+ printf ("\nmpfr_exp_3 gives ");
+ mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
+ printf ("\n");
+ exit (1);
+ }
+
mpfr_clear (x);
mpfr_clear (y);
return 0;
--- tests/tfits.c 2013-03-13 16:37:45.000000000 +0100
+++ tests/tfits.c 2014-08-04 16:44:01.128172786 +0200
@@ -33,155 +33,176 @@
#include "mpfr-intmax.h"
#include "mpfr-test.h"
-#define ERROR1 { printf("Initial error for x="); mpfr_dump(x); exit(1); }
-#define ERROR2 { printf("Error for x="); mpfr_dump(x); exit(1); }
+#define ERROR1(N) \
+ do \
+ { \
+ printf("Error %d for rnd = %s and x = ", N, \
+ mpfr_print_rnd_mode ((mpfr_rnd_t) r)); \
+ mpfr_dump(x); \
+ exit(1); \
+ } \
+ while (0)
static void check_intmax (void);
int
main (void)
{
- mpfr_t x;
+ mpfr_t x, y;
+ int i, r;
tests_start_mpfr ();
mpfr_init2 (x, 256);
+ mpfr_init2 (y, 8);
- /* Check NAN */
- mpfr_set_nan (x);
- if (mpfr_fits_ulong_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_slong_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_uint_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_sint_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_ushort_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_sshort_p (x, MPFR_RNDN))
- ERROR1;
-
- /* Check INF */
- mpfr_set_inf (x, 1);
- if (mpfr_fits_ulong_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_slong_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_uint_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_sint_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_ushort_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_sshort_p (x, MPFR_RNDN))
- ERROR1;
-
- /* Check Zero */
- MPFR_SET_ZERO (x);
- if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_slong_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_uint_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_sint_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
- ERROR2;
-
- /* Check small op */
- mpfr_set_str1 (x, "1@-1");
- if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_slong_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_uint_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_sint_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
- ERROR2;
-
- /* Check 17 */
- mpfr_set_ui (x, 17, MPFR_RNDN);
- if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_slong_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_uint_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_sint_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
- ERROR2;
-
- /* Check all other values */
- mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
- mpfr_mul_2exp (x, x, 1, MPFR_RNDN);
- if (mpfr_fits_ulong_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_slong_p (x, MPFR_RNDN))
- ERROR1;
- mpfr_mul_2exp (x, x, 40, MPFR_RNDN);
- if (mpfr_fits_ulong_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_uint_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_sint_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_ushort_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_sshort_p (x, MPFR_RNDN))
- ERROR1;
-
- mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
- if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
- ERROR2;
- mpfr_set_ui (x, LONG_MAX, MPFR_RNDN);
- if (!mpfr_fits_slong_p (x, MPFR_RNDN))
- ERROR2;
- mpfr_set_ui (x, UINT_MAX, MPFR_RNDN);
- if (!mpfr_fits_uint_p (x, MPFR_RNDN))
- ERROR2;
- mpfr_set_ui (x, INT_MAX, MPFR_RNDN);
- if (!mpfr_fits_sint_p (x, MPFR_RNDN))
- ERROR2;
- mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN);
- if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
- ERROR2;
- mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN);
- if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
- ERROR2;
-
- mpfr_set_si (x, 1, MPFR_RNDN);
- if (!mpfr_fits_sint_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
- ERROR2;
-
- /* Check negative value */
- mpfr_set_si (x, -1, MPFR_RNDN);
- if (!mpfr_fits_sint_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_slong_p (x, MPFR_RNDN))
- ERROR2;
- if (mpfr_fits_uint_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_ushort_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_ulong_p (x, MPFR_RNDN))
- ERROR1;
+ RND_LOOP (r)
+ {
+
+ /* Check NAN */
+ mpfr_set_nan (x);
+ if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (1);
+ if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (2);
+ if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (3);
+ if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (4);
+ if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (5);
+ if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (6);
+
+ /* Check INF */
+ mpfr_set_inf (x, 1);
+ if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (7);
+ if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (8);
+ if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (9);
+ if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (10);
+ if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (11);
+ if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (12);
+
+ /* Check Zero */
+ MPFR_SET_ZERO (x);
+ if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (13);
+ if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (14);
+ if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (15);
+ if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (16);
+ if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (17);
+ if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (18);
+
+ /* Check small positive op */
+ mpfr_set_str1 (x, "1@-1");
+ if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (19);
+ if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (20);
+ if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (21);
+ if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (22);
+ if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (23);
+ if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (24);
+
+ /* Check 17 */
+ mpfr_set_ui (x, 17, MPFR_RNDN);
+ if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (25);
+ if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (26);
+ if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (27);
+ if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (28);
+ if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (29);
+ if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (30);
+
+ /* Check all other values */
+ mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
+ mpfr_mul_2exp (x, x, 1, MPFR_RNDN);
+ if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (31);
+ if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (32);
+ mpfr_mul_2exp (x, x, 40, MPFR_RNDN);
+ if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (33);
+ if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (34);
+ if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (35);
+ if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (36);
+ if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (37);
+
+ mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
+ if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (38);
+ mpfr_set_ui (x, LONG_MAX, MPFR_RNDN);
+ if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (39);
+ mpfr_set_ui (x, UINT_MAX, MPFR_RNDN);
+ if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (40);
+ mpfr_set_ui (x, INT_MAX, MPFR_RNDN);
+ if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (41);
+ mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN);
+ if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (42);
+ mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN);
+ if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (43);
+
+ mpfr_set_si (x, 1, MPFR_RNDN);
+ if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (44);
+ if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (45);
+
+ /* Check negative op */
+ for (i = 1; i <= 4; i++)
+ {
+ int inv;
+
+ mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
+ mpfr_rint (y, x, (mpfr_rnd_t) r);
+ inv = MPFR_NOTZERO (y);
+ if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r) ^ inv)
+ ERROR1 (46);
+ if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+ ERROR1 (47);
+ if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r) ^ inv)
+ ERROR1 (48);
+ if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+ ERROR1 (49);
+ if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r) ^ inv)
+ ERROR1 (50);
+ if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+ ERROR1 (51);
+ }
+ }
mpfr_clear (x);
+ mpfr_clear (y);
check_intmax ();
@@ -189,85 +210,98 @@
return 0;
}
-static void check_intmax (void)
+static void
+check_intmax (void)
{
#ifdef _MPFR_H_HAVE_INTMAX_T
- mpfr_t x;
+ mpfr_t x, y;
+ int i, r;
- mpfr_init2 (x, sizeof (uintmax_t)*CHAR_BIT);
+ mpfr_init2 (x, sizeof (uintmax_t) * CHAR_BIT);
+ mpfr_init2 (y, 8);
- /* Check NAN */
- mpfr_set_nan (x);
- if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_intmax_p (x, MPFR_RNDN))
- ERROR1;
-
- /* Check INF */
- mpfr_set_inf (x, 1);
- if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_intmax_p (x, MPFR_RNDN))
- ERROR1;
-
- /* Check Zero */
- MPFR_SET_ZERO (x);
- if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
- ERROR2;
-
- /* Check small op */
- mpfr_set_str1 (x, "1@-1");
- if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
- ERROR2;
-
- /* Check 17 */
- mpfr_set_ui (x, 17, MPFR_RNDN);
- if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
- ERROR2;
- if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
- ERROR2;
-
- /* Check hugest */
- mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN);
- if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
- ERROR1;
- if (mpfr_fits_intmax_p (x, MPFR_RNDN))
- ERROR1;
-
- /* Check all other values */
- mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
- mpfr_add_ui (x, x, 1, MPFR_RNDN);
- if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
- ERROR1;
- mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
- if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
- ERROR2;
- mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
- mpfr_add_ui (x, x, 1, MPFR_RNDN);
- if (mpfr_fits_intmax_p (x, MPFR_RNDN))
- ERROR1;
- mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
- if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
- ERROR2;
- mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN);
- if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
- ERROR2;
- mpfr_sub_ui (x, x, 1, MPFR_RNDN);
- if (mpfr_fits_intmax_p (x, MPFR_RNDN))
- ERROR1;
-
- /* Check negative value */
- mpfr_set_si (x, -1, MPFR_RNDN);
- if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
- ERROR2;
- if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
- ERROR1;
+ RND_LOOP (r)
+ {
+ /* Check NAN */
+ mpfr_set_nan (x);
+ if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (52);
+ if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (53);
+
+ /* Check INF */
+ mpfr_set_inf (x, 1);
+ if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (54);
+ if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (55);
+
+ /* Check Zero */
+ MPFR_SET_ZERO (x);
+ if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (56);
+ if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (57);
+
+ /* Check positive small op */
+ mpfr_set_str1 (x, "1@-1");
+ if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (58);
+ if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (59);
+
+ /* Check 17 */
+ mpfr_set_ui (x, 17, MPFR_RNDN);
+ if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (60);
+ if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (61);
+
+ /* Check hugest */
+ mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN);
+ if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (62);
+ if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (63);
+
+ /* Check all other values */
+ mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
+ mpfr_add_ui (x, x, 1, MPFR_RNDN);
+ if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (64);
+ mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
+ if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (65);
+ mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
+ mpfr_add_ui (x, x, 1, MPFR_RNDN);
+ if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (66);
+ mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
+ if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (67);
+ mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN);
+ if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (68);
+ mpfr_sub_ui (x, x, 1, MPFR_RNDN);
+ if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (69);
+
+ /* Check negative op */
+ for (i = 1; i <= 4; i++)
+ {
+ int inv;
+
+ mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
+ mpfr_rint (y, x, (mpfr_rnd_t) r);
+ inv = MPFR_NOTZERO (y);
+ if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r) ^ inv)
+ ERROR1 (70);
+ if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+ ERROR1 (71);
+ }
+ }
mpfr_clear (x);
+ mpfr_clear (y);
#endif
}
-
--- tests/tget_flt.c 2013-03-13 16:37:44.000000000 +0100
+++ tests/tget_flt.c 2014-08-04 16:44:01.128172786 +0200
@@ -28,9 +28,17 @@
main (void)
{
mpfr_t x, y;
- float f, g, infp;
+ float f, g;
int i;
+#if !defined(MPFR_ERRDIVZERO)
+ float infp;
+#endif
+ tests_start_mpfr ();
+
+#if !defined(MPFR_ERRDIVZERO)
+ /* The definition of DBL_POS_INF involves a division by 0. This makes
+ "clang -O2 -fsanitize=undefined -fno-sanitize-recover" fail. */
infp = (float) DBL_POS_INF;
if (infp * 0.5 != infp)
{
@@ -38,8 +46,7 @@
fprintf (stderr, "(this is probably a compiler bug, please report)\n");
exit (1);
}
-
- tests_start_mpfr ();
+#endif
mpfr_init2 (x, 24);
mpfr_init2 (y, 24);
@@ -353,6 +360,7 @@
printf ("expected %.8e, got %.8e\n", g, f);
exit (1);
}
+#if !defined(MPFR_ERRDIVZERO)
f = mpfr_get_flt (x, MPFR_RNDN); /* first round to 2^128 (even rule),
thus we should get +Inf */
g = infp;
@@ -376,6 +384,7 @@
printf ("expected %.8e, got %.8e\n", g, f);
exit (1);
}
+#endif
mpfr_clear (x);
mpfr_clear (y);
--- tests/tset_ld.c 2013-03-13 16:37:44.000000000 +0100
+++ tests/tset_ld.c 2014-08-04 16:44:01.129172791 +0200
@@ -47,8 +47,11 @@
static int
Isnan_ld (long double d)
{
- double e = (double) d;
- if (DOUBLE_ISNAN (e))
+ /* Do not convert d to double as this can give an overflow, which
+ may confuse compilers without IEEE 754 support (such as clang
+ -fsanitize=undefined), or trigger a trap if enabled.
+ The DOUBLE_ISNAN macro should work fine on long double. */
+ if (DOUBLE_ISNAN (d))
return 1;
LONGDOUBLE_NAN_ACTION (d, goto yes);
return 0;
--- tests/tsprintf.c 2013-03-13 16:37:44.000000000 +0100
+++ tests/tsprintf.c 2014-08-04 16:44:01.129172791 +0200
@@ -456,10 +456,16 @@
check_sprintf ("1.999900 ", "%-#10.7RG", x);
check_sprintf ("1.9999 ", "%-10.7RG", x);
mpfr_set_ui (x, 1, MPFR_RNDN);
+ check_sprintf ("1.", "%#.1Rg", x);
+ check_sprintf ("1. ", "%-#5.1Rg", x);
+ check_sprintf (" 1.0", "%#5.2Rg", x);
check_sprintf ("1.00000000000000000000000000000", "%#.30Rg", x);
check_sprintf ("1", "%.30Rg", x);
mpfr_set_ui (x, 0, MPFR_RNDN);
- check_sprintf ("0.000000000000000000000000000000", "%#.30Rg", x);
+ check_sprintf ("0.", "%#.1Rg", x);
+ check_sprintf ("0. ", "%-#5.1Rg", x);
+ check_sprintf (" 0.0", "%#5.2Rg", x);
+ check_sprintf ("0.00000000000000000000000000000", "%#.30Rg", x);
check_sprintf ("0", "%.30Rg", x);
/* following tests with precision 53 bits */
@@ -1178,6 +1184,69 @@
check_emax_aux (MPFR_EMAX_MAX);
}
+static void
+check_emin_aux (mpfr_exp_t e)
+{
+ mpfr_t x;
+ char *s1, s2[256];
+ int i;
+ mpfr_exp_t emin;
+ mpz_t ee;
+
+ MPFR_ASSERTN (e >= LONG_MIN);
+ emin = mpfr_get_emin ();
+ set_emin (e);
+
+ mpfr_init2 (x, 16);
+ mpz_init (ee);
+
+ mpfr_setmin (x, e);
+ mpz_set_si (ee, e);
+ mpz_sub_ui (ee, ee, 1);
+
+ i = mpfr_asprintf (&s1, "%Ra", x);
+ MPFR_ASSERTN (i > 0);
+
+ gmp_snprintf (s2, 256, "0x1p%Zd", ee);
+
+ if (strcmp (s1, s2) != 0)
+ {
+ printf ("Error in check_emin_aux for emin = %ld\n", (long) e);
+ printf ("Expected %s\n", s2);
+ printf ("Got %s\n", s1);
+ exit (1);
+ }
+
+ mpfr_free_str (s1);
+
+ i = mpfr_asprintf (&s1, "%Rb", x);
+ MPFR_ASSERTN (i > 0);
+
+ gmp_snprintf (s2, 256, "1p%Zd", ee);
+
+ if (strcmp (s1, s2) != 0)
+ {
+ printf ("Error in check_emin_aux for emin = %ld\n", (long) e);
+ printf ("Expected %s\n", s2);
+ printf ("Got %s\n", s1);
+ exit (1);
+ }
+
+ mpfr_free_str (s1);
+
+ mpfr_clear (x);
+ mpz_clear (ee);
+ set_emin (emin);
+}
+
+static void
+check_emin (void)
+{
+ check_emin_aux (-15);
+ check_emin_aux (mpfr_get_emin ());
+ check_emin_aux (MPFR_EMIN_MIN);
+}
+
int
main (int argc, char **argv)
{
@@ -1197,6 +1266,7 @@
decimal ();
mixed ();
check_emax ();
+ check_emin ();
#if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE)
locale_da_DK ();
--- VERSION 2013-03-13 16:37:28.000000000 +0100
+++ VERSION 2014-12-04 01:41:57.339791833 +0000
@@ -1 +1 @@
-3.1.2
+3.1.2-p11
--- src/mpfr.h 2014-12-04 01:41:57.127789443 +0000
+++ src/mpfr.h 2014-12-04 01:41:57.335791790 +0000
@@ -27,7 +27,7 @@
#define MPFR_VERSION_MAJOR 3
#define MPFR_VERSION_MINOR 1
#define MPFR_VERSION_PATCHLEVEL 2
-#define MPFR_VERSION_STRING "3.1.2-p10"
+#define MPFR_VERSION_STRING "3.1.2-p11"
/* Macros dealing with MPFR VERSION */
#define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
--- src/strtofr.c 2013-03-13 15:37:32.000000000 +0000
+++ src/strtofr.c 2014-12-04 01:41:57.287791246 +0000
@@ -473,8 +473,10 @@
/* prec bits corresponds to ysize limbs */
ysize_bits = ysize * GMP_NUMB_BITS;
/* and to ysize_bits >= prec > MPFR_PREC (x) bits */
- y = MPFR_TMP_LIMBS_ALLOC (2 * ysize + 1);
- y += ysize; /* y has (ysize+1) allocated limbs */
+ /* we need to allocate one more limb to work around bug
+ https://gmplib.org/list-archives/gmp-bugs/2013-December/003267.html */
+ y = MPFR_TMP_LIMBS_ALLOC (2 * ysize + 2);
+ y += ysize; /* y has (ysize+2) allocated limbs */
/* pstr_size is the number of characters we read in pstr->mant
to have at least ysize full limbs.
--- src/version.c 2014-12-04 01:41:57.131789485 +0000
+++ src/version.c 2014-12-04 01:41:57.339791833 +0000
@@ -25,5 +25,5 @@
const char *
mpfr_get_version (void)
{
- return "3.1.2-p10";
+ return "3.1.2-p11";
}