Projects
Mega:23.09
mpfr
_service:tar_scm:backport-allpatches.patch
Sign Up
Log In
Username
Password
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File _service:tar_scm:backport-allpatches.patch of Package mpfr
From b92eb70eb7dcd02d5f221a259b07b9158c875ed3 Mon Sep 17 00:00:00 2001 Date: Mon, 27 Nov 2023 17:13:28 +0800 Subject: [PATCH] backport allpatches Reference: https://www.mpfr.org/mpfr-4.2.0/allpatches Conflict: src/version.c has context conflict --- PATCHES | 12 ++ VERSION | 2 +- src/compound.c | 186 ++++++++++++++++++++++++----- src/inp_str.c | 9 ++ src/mpfr.h | 2 +- src/pow.c | 31 +++-- src/rec_sqrt.c | 5 +- src/reldiff.c | 32 ++--- src/strtofr.c | 5 +- src/ui_pow_ui.c | 59 ++++++++-- src/vasprintf.c | 12 +- src/version.c | 2 +- tests/reuse.c | 127 ++++++++++---------- tests/tcompound.c | 293 +++++++++++++++++++++++++++++++++++++++++++++- tests/tests.c | 11 +- tests/texp10.c | 184 +++++++++++++++++++++++++++++ tests/tfpif.c | 5 +- tests/tfprintf.c | 14 ++- tests/tlog10.c | 56 +++++++++ tests/tprintf.c | 14 ++- tests/trec_sqrt.c | 2 + tests/tsprintf.c | 45 ++++++- tests/tui_pow.c | 32 +++++ 23 files changed, 980 insertions(+), 160 deletions(-) diff --git a/PATCHES b/PATCHES index e69de29..ef19046 100644 --- a/PATCHES +++ b/PATCHES @@ -0,0 +1,12 @@ +strtofr-nullchar +inp_str-nullchar +gcc-pr106155-workaround +printf_large_prec_for_g +compound +pow_general +tests-reuse +reldiff +rec_sqrt-zivloop +multibyte-decimal_point +ui_pow_ui-overflow +tsprintf-thousands diff --git a/VERSION b/VERSION index 6aba2b2..3a53320 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -4.2.0 +4.2.0-p12 diff --git a/src/compound.c b/src/compound.c index 16f3b88..2dbfa86 100644 --- a/src/compound.c +++ b/src/compound.c @@ -55,9 +55,9 @@ int mpfr_compound_si (mpfr_ptr y, mpfr_srcptr x, long n, mpfr_rnd_t rnd_mode) { int inexact, compared, k, nloop; - mpfr_t t; - mpfr_exp_t e; - mpfr_prec_t prec; + mpfr_t t, u; + mpfr_prec_t py, prec, extra; + mpfr_rnd_t rnd1; MPFR_ZIV_DECL (loop); MPFR_SAVE_EXPO_DECL (expo); @@ -136,64 +136,185 @@ mpfr_compound_si (mpfr_ptr y, mpfr_srcptr x, long n, mpfr_rnd_t rnd_mode) MPFR_SAVE_EXPO_MARK (expo); - prec = MPFR_PREC(y); - prec += MPFR_INT_CEIL_LOG2 (prec) + 6; + py = MPFR_GET_PREC (y); + prec = py + MPFR_INT_CEIL_LOG2 (py) + 6; mpfr_init2 (t, prec); + mpfr_init2 (u, prec); k = MPFR_INT_CEIL_LOG2(SAFE_ABS (unsigned long, n)); /* thus |n| <= 2^k */ + /* We compute u=log2p1(x) with prec+extra bits, since we lose some bits + in 2^u. */ + extra = 0; + rnd1 = VSIGN (n) == MPFR_SIGN (x) ? MPFR_RNDD : MPFR_RNDU; + MPFR_ZIV_INIT (loop, prec); for (nloop = 0; ; nloop++) { - /* we compute (1+x)^n as 2^(n*log2p1(x)) */ - inexact = mpfr_log2p1 (t, x, MPFR_RNDN) != 0; - e = MPFR_GET_EXP(t); - /* |t - log2(1+x)| <= 1/2*ulp(t) = 2^(e-prec-1) */ - inexact |= mpfr_mul_si (t, t, n, MPFR_RNDN) != 0; - /* |t - n*log2(1+x)| <= 2^(e2-prec-1) + |n|*2^(e-prec-1) - <= 2^(e2-prec-1) + 2^(e+k-prec-1) <= 2^(e+k-prec) - where |n| <= 2^k, and e2 is the new exponent of t. */ - MPFR_ASSERTD(MPFR_GET_EXP(t) <= e + k); - e += k; - /* |t - n*log2(1+x)| <= 2^(e-prec) */ - /* detect overflow */ - if (nloop == 0 && mpfr_cmp_si (t, __gmpfr_emax) >= 0) + unsigned int inex; + mpfr_exp_t e, e2, ex; + mpfr_prec_t precu = MPFR_ADD_PREC (prec, extra); + mpfr_prec_t new_extra; + mpfr_rnd_t rnd2; + + /* We compute (1+x)^n as 2^(n*log2p1(x)), + and we round toward 1, thus we round n*log2p1(x) toward 0, + thus for x*n > 0 we round log2p1(x) toward -Inf, and for x*n < 0 + we round log2p1(x) toward +Inf. */ + inex = mpfr_log2p1 (u, x, rnd1) != 0; + e = MPFR_GET_EXP (u); + /* |u - log2(1+x)| <= ulp(t) = 2^(e-precu) */ + inex |= mpfr_mul_si (u, u, n, MPFR_RNDZ) != 0; + e2 = MPFR_GET_EXP (u); + /* |u - n*log2(1+x)| <= 2^(e2-precu) + |n|*2^(e-precu) + <= 2^(e2-precu) + 2^(e+k-precu) <= 2^(e+k+1-precu) + where |n| <= 2^k, and e2 is the new exponent of u. */ + MPFR_ASSERTD (e2 <= e + k); + e += k + 1; + MPFR_ASSERTN (e2 <= MPFR_PREC_MAX); + new_extra = e2 > 0 ? e2 : 0; + /* |u - n*log2(1+x)| <= 2^(e-precu) */ + /* detect overflow: since we rounded n*log2p1(x) toward 0, + if n*log2p1(x) >= __gmpfr_emax, we are sure there is overflow. */ + if (mpfr_cmp_si (u, __gmpfr_emax) >= 0) { MPFR_ZIV_FREE (loop); mpfr_clear (t); + mpfr_clear (u); MPFR_SAVE_EXPO_FREE (expo); return mpfr_overflow (y, rnd_mode, 1); } - /* detect underflow */ - if (nloop == 0 && mpfr_cmp_si (t, __gmpfr_emin - 1) <= 0) + /* detect underflow: similarly, since we rounded n*log2p1(x) toward 0, + if n*log2p1(x) < __gmpfr_emin-1, we are sure there is underflow. */ + if (mpfr_cmp_si (u, __gmpfr_emin - 1) < 0) { MPFR_ZIV_FREE (loop); mpfr_clear (t); + mpfr_clear (u); MPFR_SAVE_EXPO_FREE (expo); return mpfr_underflow (y, - (rnd_mode == MPFR_RNDN) ? MPFR_RNDZ : rnd_mode, 1); + rnd_mode == MPFR_RNDN ? MPFR_RNDZ : rnd_mode, 1); } /* Detect cases where result is 1 or 1+ulp(1) or 1-1/2*ulp(1): - |2^t - 1| = |exp(t*log(2)) - 1| <= |t|*log(2) < |t| */ - if (nloop == 0 && MPFR_GET_EXP(t) < - (mpfr_exp_t) MPFR_PREC(y)) + |2^u - 1| = |exp(u*log(2)) - 1| <= |u|*log(2) < |u| */ + if (nloop == 0 && MPFR_GET_EXP(u) < - py) { - /* since ulp(1) = 2^(1-PREC(y)), we have |t| < 1/4*ulp(1) */ + /* since ulp(1) = 2^(1-py), we have |u| < 1/4*ulp(1) */ /* mpfr_compound_near_one must be called in the extended exponent range, so that 1 is representable. */ - inexact = mpfr_compound_near_one (y, MPFR_SIGN (t), rnd_mode); + inexact = mpfr_compound_near_one (y, MPFR_SIGN (u), rnd_mode); goto end; } - inexact |= mpfr_exp2 (t, t, MPFR_RNDA) != 0; - /* |t - (1+x)^n| <= ulp(t) + |t|*log(2)*2^(e-prec) - < 2^(EXP(t)-prec) + 2^(EXP(t)+e-prec) */ - e = (e >= 0) ? e + 1 : 1; + /* FIXME: mpfr_exp2 could underflow to the smallest positive number + since MPFR_RNDA is used, and this case will not be detected by + MPFR_CAN_ROUND (see BUGS). Either fix that, or do early underflow + detection (which may be necessary). */ + /* round 2^u toward 1 */ + rnd2 = MPFR_IS_POS (u) ? MPFR_RNDD : MPFR_RNDU; + inex |= mpfr_exp2 (t, u, rnd2) != 0; + /* we had |u - n*log2(1+x)| < 2^(e-precu) + thus u = n*log2(1+x) + delta with |delta| < 2^(e-precu) + then 2^u = (1+x)^n * 2^delta with |delta| < 2^(e-precu). + For |delta| < 0.5, |2^delta - 1| <= |delta| thus + |t - (1+x)^n| <= ulp(t) + |t|*2^(e-precu) + < 2^(EXP(t)-prec) + 2^(EXP(t)+e-precu) */ + e = (precu - prec >= e) ? 1 : e + 1 - (precu - prec); /* now |t - (1+x)^n| < 2^(EXP(t)+e-prec) */ - if (MPFR_LIKELY (inexact == 0 || - MPFR_CAN_ROUND (t, prec - e, MPFR_PREC(y), rnd_mode))) + if (MPFR_LIKELY (!inex || MPFR_CAN_ROUND (t, prec - e, py, rnd_mode))) break; + /* If t fits in the target precision (or with 1 more bit), then we can + round, assuming the working precision is large enough, but the above + MPFR_CAN_ROUND() will fail because we cannot determine the ternary + value. However since we rounded t toward 1, we can determine it. + Since the error in the approximation t is at most 2^e ulp(t), + this error should be less than 1/2 ulp(y), thus we should have + prec - py >= e + 1. */ + if (mpfr_min_prec (t) <= py + 1 && prec - py >= e + 1) + { + /* we add/subtract one ulp to get the correct rounding */ + if (rnd2 == MPFR_RNDD) /* t was rounded downwards */ + mpfr_nextabove (t); + else + mpfr_nextbelow (t); + break; + } + + /* Detect particular cases where Ziv's strategy may take too much + memory and be too long, i.e. when x^n fits in the target precision + (+ 1 additional bit for rounding to nearest) and the exact result + (1+x)^n is very close to x^n. + Necessarily, x is a large even integer and n > 0 (thus n > 1). + Since this does not depend on the working precision, we only + check this at the first iteration (nloop == 0). + Hence the first "if" below and the kx < ex test of the second "if" + (x is an even integer iff its least bit 1 has exponent >= 1). + The second test of the second "if" corresponds to another simple + condition that implies that x^n fits in the target precision. + Here are the details: + Let k be the minimum length of the significand of x, and x' the odd + (integer) significand of x. This means that 2^(k-1) <= x' < 2^k. + Thus 2^(n*(k-1)) <= (x')^n < 2^(k*n), and x^n has between n*(k-1)+1 + and k*n bits. So x^n can fit into p bits only if p >= n*(k-1)+1, + i.e. n*(k-1) <= p-1. + Note that x >= 2^k, so that x^n >= 2^(k*n). Since raw overflow + has already been detected, k*n cannot overflow if computed with + the mpfr_exp_t type. Hence the second test of the second "if", + which cannot overflow. */ + MPFR_ASSERTD (n < 0 || n > 1); + if (nloop == 0 && n > 1 && (ex = MPFR_GET_EXP (x)) >= 17) + { + mpfr_prec_t kx = mpfr_min_prec (x); + mpfr_prec_t p = py + (rnd_mode == MPFR_RNDN); + + MPFR_LOG_MSG (("Check if x^n fits... n=%ld kx=%Pd p=%Pd\n", + n, kx, p)); + if (kx < ex && n * (mpfr_exp_t) (kx - 1) <= p - 1) + { + mpfr_t v; + + /* Check whether x^n really fits into p bits. */ + mpfr_init2 (v, p); + inexact = mpfr_pow_ui (v, x, n, MPFR_RNDZ); + if (inexact == 0) + { + MPFR_LOG_MSG (("x^n fits into p bits\n", 0)); + /* (x+1)^n = x^n * (1 + 1/x)^n + For directed rounding, we can round when (1 + 1/x)^n + < 1 + 2^-p, and then the result is x^n, + except for rounding up. Indeed, if (1 + 1/x)^n < 1 + 2^-p, + 1 <= (x+1)^n < x^n * (1 + 2^-p) = x^n + x^n/2^p + < x^n + ulp(x^n). + For rounding to nearest, we can round when (1 + 1/x)^n + < 1 + 2^-p, and then the result is x^n when x^n fits + into p-1 bits, and nextabove(x^n) otherwise. */ + mpfr_ui_div (t, 1, x, MPFR_RNDU); + mpfr_add_ui (t, t, 1, MPFR_RNDU); + mpfr_pow_ui (t, t, n, MPFR_RNDU); + mpfr_sub_ui (t, t, 1, MPFR_RNDU); + /* t cannot be zero */ + if (MPFR_GET_EXP(t) < - py) + { + mpfr_set (y, v, MPFR_RNDZ); + if ((rnd_mode == MPFR_RNDN && mpfr_min_prec (v) == p) + || rnd_mode == MPFR_RNDU || rnd_mode == MPFR_RNDA) + { + /* round up */ + mpfr_nextabove (y); + inexact = 1; + } + else + inexact = -1; + mpfr_clear (v); + goto end; + } + } + mpfr_clear (v); + } + } + /* Exact cases like compound(0.5,2) = 9/4 must be detected, since except for 1+x power of 2, the log2p1 above will be inexact, so that in the Ziv test, inexact != 0 and MPFR_CAN_ROUND will @@ -211,6 +332,8 @@ mpfr_compound_si (mpfr_ptr y, mpfr_srcptr x, long n, mpfr_rnd_t rnd_mode) MPFR_ZIV_NEXT (loop, prec); mpfr_set_prec (t, prec); + extra = new_extra; + mpfr_set_prec (u, MPFR_ADD_PREC (prec, extra)); } inexact = mpfr_set (y, t, rnd_mode); @@ -218,6 +341,7 @@ mpfr_compound_si (mpfr_ptr y, mpfr_srcptr x, long n, mpfr_rnd_t rnd_mode) end: MPFR_ZIV_FREE (loop); mpfr_clear (t); + mpfr_clear (u); MPFR_SAVE_EXPO_FREE (expo); return mpfr_check_range (y, inexact, rnd_mode); diff --git a/src/inp_str.c b/src/inp_str.c index 32e079f..a9bd000 100644 --- a/src/inp_str.c +++ b/src/inp_str.c @@ -69,6 +69,15 @@ mpfr_inp_str (mpfr_ptr rop, FILE *stream, int base, mpfr_rnd_t rnd_mode) if (c == EOF || isspace (c)) break; str[str_size++] = (unsigned char) c; + /* If c is '\0' (while not being a whitespace character), the word will + not have a valid format. But in the context of a string in memory, + '\0' is a terminating null character. So, to avoid ending with a + valid string format (like "1" with ignored characters after the + terminating null character), we need to make sure that the string + does not have a valid format; so let's start it with '*'. Note + that we should read the full word, so we cannot break. */ + if (MPFR_UNLIKELY (c == '\0')) + str[0] = '*'; if (str_size == (size_t) -1) break; c = getc (stream); diff --git a/src/mpfr.h b/src/mpfr.h index 4610c67..98ba103 100644 --- a/src/mpfr.h +++ b/src/mpfr.h @@ -27,7 +27,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc., #define MPFR_VERSION_MAJOR 4 #define MPFR_VERSION_MINOR 2 #define MPFR_VERSION_PATCHLEVEL 0 -#define MPFR_VERSION_STRING "4.2.0" +#define MPFR_VERSION_STRING "4.2.0-p12" /* User macros: MPFR_USE_FILE: Define it to make MPFR define functions dealing diff --git a/src/pow.c b/src/pow.c index a7ba3ee..2f9af0e 100644 --- a/src/pow.c +++ b/src/pow.c @@ -131,7 +131,6 @@ mpfr_pow_general (mpfr_ptr z, mpfr_srcptr x, mpfr_srcptr y, /* Declaration of the size variable */ mpfr_prec_t Nz = MPFR_PREC(z); /* target precision */ mpfr_prec_t Nt; /* working precision */ - mpfr_exp_t err; /* error */ MPFR_ZIV_DECL (ziv_loop); MPFR_LOG_FUNC @@ -171,12 +170,14 @@ mpfr_pow_general (mpfr_ptr z, mpfr_srcptr x, mpfr_srcptr y, MPFR_ZIV_INIT (ziv_loop, Nt); for (;;) { + mpfr_exp_t err, exp_t; MPFR_BLOCK_DECL (flags1); /* compute exp(y*ln|x|), using MPFR_RNDU to get an upper bound, so that we can detect underflows. */ mpfr_log (t, absx, MPFR_IS_NEG (y) ? MPFR_RNDD : MPFR_RNDU); /* ln|x| */ mpfr_mul (t, y, t, MPFR_RNDU); /* y*ln|x| */ + exp_t = MPFR_GET_EXP (t); if (k_non_zero) { MPFR_LOG_MSG (("subtract k * ln(2)\n", 0)); @@ -188,14 +189,16 @@ mpfr_pow_general (mpfr_ptr z, mpfr_srcptr x, mpfr_srcptr y, MPFR_LOG_VAR (t); } /* estimate of the error -- see pow function in algorithms.tex. - The error on t is at most 1/2 + 3*2^(EXP(t)+1) ulps, which is - <= 2^(EXP(t)+3) for EXP(t) >= -1, and <= 2 ulps for EXP(t) <= -2. + The error on t before the subtraction of k*log(2) is at most + 1/2 + 3*2^(EXP(t)+1) ulps, which is <= 2^(EXP(t)+3) for EXP(t) >= -1, + and <= 2 ulps for EXP(t) <= -2. Additional error if k_no_zero: treal = t * errk, with 1 - |k| * 2^(-Nt) <= exp(-|k| * 2^(-Nt)) <= errk <= 1, i.e., additional absolute error <= 2^(EXP(k)+EXP(t)-Nt). - Total error <= 2^err1 + 2^err2 <= 2^(max(err1,err2)+1). */ - err = MPFR_NOTZERO (t) && MPFR_GET_EXP (t) >= -1 ? - MPFR_GET_EXP (t) + 3 : 1; + Total ulp error <= 2^err1 + 2^err2 <= 2^(max(err1,err2)+1), + where err1 = EXP(t)+3 for EXP(t) >= -1, and 1 otherwise, + and err2 = EXP(k). */ + err = MPFR_NOTZERO (t) && exp_t >= -1 ? exp_t + 3 : 1; if (k_non_zero) { if (MPFR_GET_EXP (k) > err) @@ -328,11 +331,17 @@ mpfr_pow_general (mpfr_ptr z, mpfr_srcptr x, mpfr_srcptr y, */ if (rnd_mode == MPFR_RNDN && inexact < 0 && lk < 0 && MPFR_GET_EXP (z) == __gmpfr_emin - 1 - lk && mpfr_powerof2_raw (z)) - /* Rounding to nearest, real result > z * 2^k = 2^(emin - 2), - * underflow case: we will obtain the correct result and exceptions - * by replacing z by nextabove(z). - */ - mpfr_nextabove (z); + /* Rounding to nearest, exact result > z * 2^k = 2^(emin - 2), + * and underflow case because the rounded result assuming an + * unbounded exponent range is 2^(emin - 2). We need to round + * to 2^(emin - 1), i.e. to round toward +inf. + * Note: the old code was using "mpfr_nextabove (z);" instead of + * setting rnd_mode to MPFR_RNDU for the call to mpfr_mul_2si, but + * this was incorrect in precision 1 because in this precision, + * mpfr_nextabove gave 2^(emin - 1), which is representable, + * so that mpfr_mul_2si did not generate the wanted underflow + * (the value was correct, but the underflow flag was missing). */ + rnd_mode = MPFR_RNDU; MPFR_CLEAR_FLAGS (); inex2 = mpfr_mul_2si (z, z, lk, rnd_mode); if (inex2) /* underflow or overflow */ diff --git a/src/rec_sqrt.c b/src/rec_sqrt.c index c6ca40b..a5a3fa9 100644 --- a/src/rec_sqrt.c +++ b/src/rec_sqrt.c @@ -463,6 +463,7 @@ mpfr_rec_sqrt (mpfr_ptr r, mpfr_srcptr u, mpfr_rnd_t rnd_mode) int s, cy, inex; mpfr_limb_ptr x; MPFR_TMP_DECL(marker); + MPFR_ZIV_DECL (loop); MPFR_LOG_FUNC (("x[%Pu]=%.*Rg rnd=%d", mpfr_get_prec (u), mpfr_log_prec, u, rnd_mode), @@ -530,6 +531,7 @@ mpfr_rec_sqrt (mpfr_ptr r, mpfr_srcptr u, mpfr_rnd_t rnd_mode) wp = rp + 11; if (wp < rn * GMP_NUMB_BITS) wp = rn * GMP_NUMB_BITS; + MPFR_ZIV_INIT (loop, wp); for (;;) { MPFR_TMP_MARK (marker); @@ -561,8 +563,9 @@ mpfr_rec_sqrt (mpfr_ptr r, mpfr_srcptr u, mpfr_rnd_t rnd_mode) } MPFR_TMP_FREE(marker); - wp += GMP_NUMB_BITS; + MPFR_ZIV_NEXT (loop, wp); } + MPFR_ZIV_FREE (loop); cy = mpfr_round_raw (MPFR_MANT(r), x, wp, 0, rp, rnd_mode, &inex); MPFR_EXP(r) = - (MPFR_EXP(u) - 1 - s) / 2; if (MPFR_UNLIKELY(cy != 0)) diff --git a/src/reldiff.c b/src/reldiff.c index 832bf4d..5adf6a3 100644 --- a/src/reldiff.c +++ b/src/reldiff.c @@ -30,31 +30,25 @@ mpfr_reldiff (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode) if (MPFR_ARE_SINGULAR (b, c)) { - if (MPFR_IS_NAN(b) || MPFR_IS_NAN(c)) + if (MPFR_IS_NAN (b) || MPFR_IS_INF (b) || MPFR_IS_NAN (c) || + (MPFR_IS_ZERO (b) && MPFR_IS_ZERO (c))) { - MPFR_SET_NAN(a); + MPFR_SET_NAN (a); return; } - else if (MPFR_IS_INF(b)) - { - if (MPFR_IS_INF (c) && (MPFR_SIGN (c) == MPFR_SIGN (b))) - MPFR_SET_ZERO(a); - else - MPFR_SET_NAN(a); - return; - } - else if (MPFR_IS_INF(c)) + if (MPFR_IS_ZERO (b) || MPFR_IS_INF (c)) { MPFR_SET_SAME_SIGN (a, b); MPFR_SET_INF (a); return; } - else if (MPFR_IS_ZERO(b)) /* reldiff = abs(c)/c = sign(c) */ - { - mpfr_set_si (a, MPFR_INT_SIGN (c), rnd_mode); - return; - } - /* Fall through */ + /* The case c = 0 with b regular, which should give sign(b) exactly, + cannot be optimized here as it is documented in the MPFR manual + that this function just computes abs(b-c)/b using the precision + of a and the rounding mode rnd_mode for all operations. So let's + prefer the potentially "incorrect" result. Note that the correct + result is not necessarily better because if could break properties + (like monotonicity?) implied by the documentation. */ } if (a == b) @@ -64,8 +58,8 @@ mpfr_reldiff (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode) } mpfr_sub (a, b, c, rnd_mode); - mpfr_abs (a, a, rnd_mode); /* for compatibility with MPF */ - mpfr_div (a, a, (a == b) ? b_copy : b, rnd_mode); + MPFR_SET_SIGN (a, 1); + mpfr_div (a, a, a == b ? b_copy : b, rnd_mode); if (a == b) mpfr_clear (b_copy); diff --git a/src/strtofr.c b/src/strtofr.c index a95d242..abc77c6 100644 --- a/src/strtofr.c +++ b/src/strtofr.c @@ -242,7 +242,10 @@ parse_string (mpfr_ptr x, struct parsed_string *pstr, pstr->mantissa = NULL; /* Optional leading whitespace */ - while (isspace((unsigned char) *str)) str++; + /* For non-"C" locales, the ISO C standard allows isspace(0) to + return true. So we need to stop explicitly on '\0'. */ + while (*str != '\0' && isspace ((unsigned char) *str)) + str++; /* An optional sign `+' or `-' */ pstr->negative = (*str == '-'); diff --git a/src/ui_pow_ui.c b/src/ui_pow_ui.c index dd98ea2..925119a 100644 --- a/src/ui_pow_ui.c +++ b/src/ui_pow_ui.c @@ -23,7 +23,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc., #include "mpfr-impl.h" int -mpfr_ui_pow_ui (mpfr_ptr x, unsigned long int y, unsigned long int n, +mpfr_ui_pow_ui (mpfr_ptr x, unsigned long int k, unsigned long int n, mpfr_rnd_t rnd) { mpfr_exp_t err; @@ -35,22 +35,28 @@ mpfr_ui_pow_ui (mpfr_ptr x, unsigned long int y, unsigned long int n, MPFR_ZIV_DECL (loop); MPFR_SAVE_EXPO_DECL (expo); + MPFR_LOG_FUNC + (("k=%lu n=%lu rnd=%d", k, n, rnd), + ("y[%Pu]=%.*Rg inexact=%d", + mpfr_get_prec (x), mpfr_log_prec, x, inexact)); + if (MPFR_UNLIKELY (n <= 1)) { if (n == 1) - return mpfr_set_ui (x, y, rnd); /* y^1 = y */ + return mpfr_set_ui (x, k, rnd); /* k^1 = k */ else - return mpfr_set_ui (x, 1, rnd); /* y^0 = 1 for any y */ + return mpfr_set_ui (x, 1, rnd); /* k^0 = 1 for any k */ } - else if (MPFR_UNLIKELY (y <= 1)) + else if (MPFR_UNLIKELY (k <= 1)) { - if (y == 1) + if (k == 1) return mpfr_set_ui (x, 1, rnd); /* 1^n = 1 for any n > 0 */ else return mpfr_set_ui (x, 0, rnd); /* 0^n = 0 for any n > 0 */ } - for (size_n = 0, m = n; m; size_n++, m >>= 1); + for (size_n = 0, m = n; m != 0; size_n++, m >>= 1) + ; MPFR_SAVE_EXPO_MARK (expo); prec = MPFR_PREC (x) + 3 + size_n; @@ -60,23 +66,55 @@ mpfr_ui_pow_ui (mpfr_ptr x, unsigned long int y, unsigned long int n, for (;;) { int i = size_n; + unsigned int inex_res; - inexact = mpfr_set_ui (res, y, MPFR_RNDU); + inex_res = mpfr_set_ui (res, k, MPFR_RNDU); err = 1; /* now 2^(i-1) <= n < 2^i: i=1+floor(log2(n)) */ for (i -= 2; i >= 0; i--) { - inexact |= mpfr_sqr (res, res, MPFR_RNDU); + inex_res |= mpfr_sqr (res, res, MPFR_RNDU); err++; if (n & (1UL << i)) - inexact |= mpfr_mul_ui (res, res, y, MPFR_RNDU); + inex_res |= mpfr_mul_ui (res, res, k, MPFR_RNDU); } + + if (MPFR_UNLIKELY (MPFR_IS_INF (res))) + { + mpfr_t kf; + mpz_t z; + int size_k; + MPFR_BLOCK_DECL (flags); + + /* Let's handle the overflow by calling mpfr_pow_z. + Alternatively, we could call mpfr_pow_ui; this would + need a bit shorter code below, but mpfr_pow_ui handles + the overflow by calling mpfr_pow_z, so that calling + mpfr_pow_z directly should be a bit more efficient. */ + + MPFR_ZIV_FREE (loop); + mpfr_clear (res); + for (size_k = 0, m = k; m != 0; size_k++, m >>= 1) + ; + mpfr_init2 (kf, size_k); + inexact = mpfr_set_ui (kf, k, MPFR_RNDN); + MPFR_ASSERTD (inexact == 0); + mpz_init (z); + mpz_set_ui (z, n); + MPFR_BLOCK (flags, inexact = mpfr_pow_z (x, kf, z, rnd);); + mpz_clear (z); + mpfr_clear (kf); + MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, flags); + goto end; + } + /* since the loop is executed floor(log2(n)) times, we have err = 1+floor(log2(n)). Since prec >= MPFR_PREC(x) + 4 + floor(log2(n)), prec > err */ err = prec - err; - if (MPFR_LIKELY (inexact == 0 + MPFR_LOG_VAR (res); + if (MPFR_LIKELY (!inex_res || MPFR_CAN_ROUND (res, err, MPFR_PREC (x), rnd))) break; @@ -90,6 +128,7 @@ mpfr_ui_pow_ui (mpfr_ptr x, unsigned long int y, unsigned long int n, mpfr_clear (res); + end: MPFR_SAVE_EXPO_FREE (expo); return mpfr_check_range (x, inexact, rnd); } diff --git a/src/vasprintf.c b/src/vasprintf.c index 50282c8..8360bdd 100644 --- a/src/vasprintf.c +++ b/src/vasprintf.c @@ -1888,7 +1888,7 @@ partition_number (struct number_parts *np, mpfr_srcptr p, precision T-1. where T is the threshold computed below and X is the exponent that would be displayed with style 'e' and precision T-1. */ - int threshold; + mpfr_intmax_t threshold; mpfr_exp_t x, e, k; struct decimal_info dec_info; @@ -1920,9 +1920,15 @@ partition_number (struct number_parts *np, mpfr_srcptr p, e = e <= 0 ? k : (e + 2) / 3 + (k <= 0 ? 0 : k); MPFR_ASSERTD (e >= 1); + if (e > threshold) + e = threshold; + + /* error if e does not fit in size_t (for mpfr_get_str) */ + if (e > (size_t) -1) + goto error; + dec_info.str = mpfr_get_str (NULL, &dec_info.exp, 10, - e < threshold ? e : threshold, - p, spec.rnd_mode); + e, p, spec.rnd_mode); register_string (np->sl, dec_info.str); /* mpfr_get_str corresponds to a significand between 0.1 and 1, whereas here we want a significand between 1 and 10. */ diff --git a/src/version.c b/src/version.c index 25d88f7..992a69f 100644 --- a/src/version.c +++ b/src/version.c @@ -25,5 +25,5 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc., const char * mpfr_get_version (void) { - return "4.2.0"; + return "4.2.0-p12"; } diff --git a/tests/reuse.c b/tests/reuse.c index b6c7ca5..800edea 100644 --- a/tests/reuse.c +++ b/tests/reuse.c @@ -78,22 +78,16 @@ set_special (mpfr_ptr x, unsigned int select) mpfr_const_pi (x, MPFR_RNDN); MPFR_SET_EXP (x, MPFR_GET_EXP (x)-1); break; - default: + case 11: mpfr_urandomb (x, RANDS); if (RAND_BOOL ()) mpfr_neg (x, x, MPFR_RNDN); break; + default: + MPFR_ASSERTN (0); } } -/* same as mpfr_cmp, but returns 0 for both NaN's */ -static int -mpfr_compare (mpfr_srcptr a, mpfr_srcptr b) -{ - return (MPFR_IS_NAN(a)) ? !MPFR_IS_NAN(b) : - (MPFR_IS_NAN(b) || mpfr_cmp(a, b)); -} - static void test3 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t), const char *foo, mpfr_prec_t prec, mpfr_rnd_t rnd) @@ -112,10 +106,10 @@ test3 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t), /* for each variable, consider each of the following 6 possibilities: NaN, +Infinity, -Infinity, +0, -0 or a random number */ - for (i=0; i < SPECIAL_MAX*SPECIAL_MAX ; i++) + for (i = 0; i < SPECIAL_MAX * SPECIAL_MAX; i++) { - set_special (ref2, i%SPECIAL_MAX); - set_special (ref3, i/SPECIAL_MAX); + set_special (ref2, i % SPECIAL_MAX); + set_special (ref3, i / SPECIAL_MAX); /* reference call: foo(a, b, c) */ testfunc (ref1, ref2, ref3, rnd); @@ -124,11 +118,11 @@ test3 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t), mpfr_set (res1, ref2, rnd); /* exact operation */ testfunc (res1, res1, ref3, rnd); - if (mpfr_compare (res1, ref1)) + if (! SAME_VAL (res1, ref1)) { printf ("Error for %s(a, a, c) with %s for ", foo, mpfr_print_rnd_mode (rnd)); - DISP("a=",ref2); DISP2(", c=",ref3); + DISP("a=", ref2); DISP2(", c=", ref3); printf ("expected "); mpfr_dump (ref1); printf ("got "); mpfr_dump (res1); exit (1); @@ -137,11 +131,12 @@ test3 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t), /* foo(a, b, a) */ mpfr_set (res1, ref3, rnd); testfunc (res1, ref2, res1, rnd); - if (mpfr_compare (res1, ref1)) + if (! SAME_VAL (res1, ref1)) { printf ("Error for %s(a, b, a) for ", foo); - DISP("b=",ref2); DISP2(", a=", ref3); - DISP("expected ", ref1); DISP2(", got ",res1); + DISP("b=", ref2); DISP2(", a=", ref3); + printf ("expected "); mpfr_dump (ref1); + printf ("got "); mpfr_dump (res1); exit (1); } @@ -151,11 +146,12 @@ test3 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t), mpfr_set (res1, ref2, rnd); testfunc (res1, res1, res1, rnd); - if (mpfr_compare (res1, ref1)) + if (! SAME_VAL (res1, ref1)) { printf ("Error for %s(a, a, a) for ", foo); - DISP2("a=",ref2); - DISP("expected ", ref1); DISP2(", got ", res1); + DISP2("a=", ref2); + printf ("expected "); mpfr_dump (ref1); + printf ("got "); mpfr_dump (res1); exit (1); } } @@ -187,13 +183,13 @@ test4 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, /* for each variable, consider each of the following 6 possibilities: NaN, +Infinity, -Infinity, +0, -0 or a random number */ - for (i=0; i<SPECIAL_MAX; i++) + for (i = 0; i < SPECIAL_MAX; i++) { set_special (op1, i); - for (j=0; j<SPECIAL_MAX; j++) + for (j = 0; j < SPECIAL_MAX; j++) { set_special (op2, j); - for (k=0; k<SPECIAL_MAX; k++) + for (k = 0; k < SPECIAL_MAX; k++) { set_special (op3, k); @@ -204,11 +200,12 @@ test4 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mpfr_set (res, op1, rnd); /* exact operation */ testfunc (res, res, op2, op3, rnd); - if (mpfr_compare (res, ref)) + if (! SAME_VAL (res, ref)) { printf ("Error for %s(a, a, b, c) for ", foo); DISP("a=", op1); DISP(", b=", op2); DISP2(", c=", op3); - DISP("expected ", ref); DISP2(", got ", res); + printf ("expected "); mpfr_dump (ref); + printf ("got "); mpfr_dump (res); exit (1); } @@ -216,11 +213,12 @@ test4 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mpfr_set (res, op2, rnd); testfunc (res, op1, res, op3, rnd); - if (mpfr_compare (res, ref)) + if (! SAME_VAL (res, ref)) { printf ("Error for %s(a, a, b, c) for ", foo); DISP("a=", op1); DISP(", b=", op2); DISP2(", c=", op3); - DISP("expected ", ref); DISP2(", got ", res); + printf ("expected "); mpfr_dump (ref); + printf ("got "); mpfr_dump (res); exit (1); } @@ -228,35 +226,38 @@ test4 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mpfr_set (res, op3, rnd); testfunc (res, op1, op2, res, rnd); - if (mpfr_compare (res, ref)) + if (! SAME_VAL (res, ref)) { printf ("Error for %s(a, a, b, c) for ", foo); DISP("a=", op1); DISP(", b=", op2); DISP2(", c=", op3); - DISP("expected ", ref); DISP2(", got ", res); + printf ("expected "); mpfr_dump (ref); + printf ("got "); mpfr_dump (res); exit (1); } - /* foo(a, a, a,c) */ + /* foo(a, a, a, c) */ testfunc (ref, op1, op1, op3, rnd); mpfr_set (res, op1, rnd); testfunc (res, res, res, op3, rnd); - if (mpfr_compare (res, ref)) + if (! SAME_VAL (res, ref)) { printf ("Error for %s(a, a, b, c) for ", foo); DISP("a=", op1); DISP(", a=", op2); DISP2(", c=", op3); - DISP("expected ", ref); DISP2(", got ", res); + printf ("expected "); mpfr_dump (ref); + printf ("got "); mpfr_dump (res); exit (1); } - /* foo(a, a, b,a) */ + /* foo(a, a, b, a) */ testfunc (ref, op1, op2, op1, rnd); mpfr_set (res, op1, rnd); testfunc (res, res, op2, res, rnd); - if (mpfr_compare (res, ref)) + if (! SAME_VAL (res, ref)) { printf ("Error for %s(a, a, b, c) for ", foo); DISP("a=", op1); DISP(", a=", op2); DISP2(", c=", op3); - DISP("expected ", ref); DISP2(", got ", res); + printf ("expected "); mpfr_dump (ref); + printf ("got "); mpfr_dump (res); exit (1); } @@ -264,11 +265,12 @@ test4 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, testfunc (ref, op1, op2, op2, rnd); mpfr_set (res, op2, rnd); testfunc (res, op1, res, res, rnd); - if (mpfr_compare (res, ref)) + if (! SAME_VAL (res, ref)) { printf ("Error for %s(a, a, b, c) for ", foo); DISP("a=", op1); DISP(", a=", op2); DISP2(", c=", op3); - DISP("expected ", ref); DISP2(", got ", res); + printf ("expected "); mpfr_dump (ref); + printf ("got "); mpfr_dump (res); exit (1); } @@ -276,11 +278,12 @@ test4 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, testfunc (ref, op1, op1, op1, rnd); mpfr_set (res, op1, rnd); testfunc (res, res, res, res, rnd); - if (mpfr_compare (res, ref)) + if (! SAME_VAL (res, ref)) { printf ("Error for %s(a, a, a, a) for ", foo); DISP2("a=", op1); - DISP("expected ", ref); DISP2(", got ", res); + printf ("expected "); mpfr_dump (ref); + printf ("got "); mpfr_dump (res); exit (1); } } @@ -313,10 +316,10 @@ test2ui (int (*testfunc)(mpfr_ptr, mpfr_srcptr, unsigned long int, mpfr_rnd_t), /* ref2 can be NaN, +Inf, -Inf, +0, -0 or any number ref3 can be 0 or any number */ - for (i=0; i<SPECIAL_MAX*2; i++) + for (i = 0; i < SPECIAL_MAX * 2; i++) { - set_special (ref2, i%SPECIAL_MAX); - ref3 = i/SPECIAL_MAX == 0 ? 0 : randlimb (); + set_special (ref2, i % SPECIAL_MAX); + ref3 = i / SPECIAL_MAX == 0 ? 0 : randlimb (); /* reference call: foo(a, b, c) */ testfunc (ref1, ref2, ref3, rnd); @@ -325,10 +328,10 @@ test2ui (int (*testfunc)(mpfr_ptr, mpfr_srcptr, unsigned long int, mpfr_rnd_t), mpfr_set (res1, ref2, rnd); /* exact operation */ testfunc (res1, res1, ref3, rnd); - if (mpfr_compare (res1, ref1)) + if (! SAME_VAL (res1, ref1)) { printf ("Error for %s(a, a, c) for c=%u\n", foo, ref3); - DISP2("a=",ref2); + DISP2("a=", ref2); printf ("expected "); mpfr_dump (ref1); printf ("got "); mpfr_dump (res1); exit (1); @@ -356,10 +359,10 @@ testui2 (int (*testfunc)(mpfr_ptr, unsigned long int, mpfr_srcptr, mpfr_rnd_t), mpfr_init2 (ref3, prec); mpfr_init2 (res1, prec); - for (i=0; i<SPECIAL_MAX*2; i++) + for (i = 0; i < SPECIAL_MAX * 2; i++) { - set_special (ref3, i%SPECIAL_MAX); - ref2 = i/SPECIAL_MAX==0 ? 0 : randlimb (); + set_special (ref3, i % SPECIAL_MAX); + ref2 = i / SPECIAL_MAX == 0 ? 0 : randlimb (); /* reference call: foo(a, b, c) */ testfunc (ref1, ref2, ref3, rnd); @@ -367,7 +370,7 @@ testui2 (int (*testfunc)(mpfr_ptr, unsigned long int, mpfr_srcptr, mpfr_rnd_t), /* foo(a, b, a) */ mpfr_set (res1, ref3, rnd); /* exact operation */ testfunc (res1, ref2, res1, rnd); - if (mpfr_compare (res1, ref1)) + if (! SAME_VAL (res1, ref1)) { printf ("Error for %s(a, b, a) for b=%u \n", foo, ref2); DISP2("a=", ref3); @@ -397,7 +400,7 @@ test2 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_rnd_t), mpfr_init2 (ref2, prec); mpfr_init2 (res1, prec); - for (i=0; i<SPECIAL_MAX; i++) + for (i = 0; i < SPECIAL_MAX; i++) { set_special (ref2, i); @@ -407,7 +410,7 @@ test2 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_rnd_t), /* foo(a, a) */ mpfr_set (res1, ref2, rnd); /* exact operation */ testfunc (res1, res1, rnd); - if (mpfr_compare (res1, ref1)) + if (! SAME_VAL (res1, ref1)) { printf ("Error for %s(a, a) for ", foo); DISP2("a=", ref2); @@ -437,7 +440,7 @@ test2a (int (*testfunc)(mpfr_ptr, mpfr_srcptr), mpfr_init2 (ref2, prec); mpfr_init2 (res1, prec); - for (i=0; i<SPECIAL_MAX; i++) + for (i = 0; i < SPECIAL_MAX; i++) { set_special (ref2, i); @@ -447,10 +450,10 @@ test2a (int (*testfunc)(mpfr_ptr, mpfr_srcptr), /* foo(a, a) */ mpfr_set (res1, ref2, MPFR_RNDN); /* exact operation */ testfunc (res1, res1); - if (mpfr_compare (res1, ref1)) + if (! SAME_VAL (res1, ref1)) { printf ("Error for %s(a, a) for ", foo); - DISP2("a=",ref2); + DISP2("a=", ref2); DISP("expected", ref1); DISP2(", got ", res1); exit (1); } @@ -479,7 +482,7 @@ test3a (int (*testfunc)(mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t), mpfr_init2 (res1, prec); mpfr_init2 (res2, prec); - for (i=0; i<SPECIAL_MAX; i++) + for (i = 0; i < SPECIAL_MAX; i++) { set_special (ref3, i); @@ -489,12 +492,12 @@ test3a (int (*testfunc)(mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t), /* foo(a, b, a) */ mpfr_set (res1, ref3, rnd); /* exact operation */ testfunc (res1, res2, res1, rnd); - if (mpfr_compare (res1, ref1) || mpfr_compare (res2, ref2)) + if (! SAME_VAL (res1, ref1) || ! SAME_VAL (res2, ref2)) { printf ("Error for %s(a, b, a) for rnd=%s, ", foo, mpfr_print_rnd_mode (rnd)); - DISP2("a=",ref3); - DISP("expected (", ref1); DISP(",",ref2); + DISP2("a=", ref3); + DISP("expected (", ref1); DISP(",", ref2); DISP("), got (", res1); DISP(",", res2); printf(")\n"); exit (1); } @@ -502,11 +505,11 @@ test3a (int (*testfunc)(mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t), /* foo(a, b, b) */ mpfr_set (res2, ref3, rnd); /* exact operation */ testfunc (res1, res2, res2, rnd); - if (mpfr_compare (res1, ref1) || mpfr_compare (res2, ref2)) + if (! SAME_VAL (res1, ref1) || ! SAME_VAL (res2, ref2)) { printf ("Error for %s(a, b, b) for ", foo); - DISP2("b=",ref3); - DISP("expected (", ref1); DISP(",",ref2); + DISP2("b=", ref3); + DISP("expected (", ref1); DISP(",", ref2); DISP("), got (", res1); DISP(",", res2); printf(")\n"); exit (1); } @@ -561,10 +564,10 @@ pow_int (mpfr_rnd_t rnd) mpfr_set (res1, ref2, rnd); /* exact operation */ mpfr_pow (res1, res1, ref3, rnd); - if (mpfr_compare (res1, ref1)) + if (! SAME_VAL (res1, ref1)) { printf ("Error for pow_int(a, a, c) for "); - DISP("a=",ref2); DISP2(", c=",ref3); + DISP("a=", ref2); DISP2(", c=", ref3); printf ("expected "); mpfr_dump (ref1); printf ("got "); mpfr_dump (res1); exit (1); diff --git a/tests/tcompound.c b/tests/tcompound.c index 52c518a..ae0c54c 100644 --- a/tests/tcompound.c +++ b/tests/tcompound.c @@ -238,18 +238,263 @@ check_ieee754 (void) mpfr_clear (y); } -static int -mpfr_compound2 (mpfr_ptr y, mpfr_srcptr x, mpfr_rnd_t rnd_mode) +/* Failure with mpfr_compound_si from 2021-02-15 due to + incorrect underflow detection. */ +static void +bug_20230206 (void) +{ + if (MPFR_PREC_MIN == 1) + { + mpfr_t x, y1, y2; + int inex1, inex2; + mpfr_flags_t flags1, flags2; +#if MPFR_PREC_BITS >= 64 + mpfr_exp_t emin; +#endif + + mpfr_inits2 (1, x, y1, y2, (mpfr_ptr) 0); + mpfr_set_ui_2exp (x, 1, -1, MPFR_RNDN); /* x = 1/2 */ + + /* This first test is useful mainly for a 32-bit mpfr_exp_t type + (no failure with a 64-bit mpfr_exp_t type since the underflow + threshold in the extended exponent range is much lower). */ + + mpfr_set_ui_2exp (y1, 1, -1072124363, MPFR_RNDN); + inex1 = -1; + flags1 = MPFR_FLAGS_INEXACT; + mpfr_clear_flags (); + /* -1832808704 ~= -2^30 / log2(3/2) */ + inex2 = mpfr_compound_si (y2, x, -1832808704, MPFR_RNDN); + flags2 = __gmpfr_flags; + if (!(mpfr_equal_p (y1, y2) && + SAME_SIGN (inex1, inex2) && + flags1 == flags2)) + { + printf ("Error in bug_20230206 (1):\n"); + printf ("Expected "); + mpfr_dump (y1); + printf (" with inex = %d, flags =", inex1); + flags_out (flags1); + printf ("Got "); + mpfr_dump (y2); + printf (" with inex = %d, flags =", inex2); + flags_out (flags2); + exit (1); + } + + /* This second test is for a 64-bit mpfr_exp_t type + (it is disabled with a 32-bit mpfr_exp_t type). */ + + /* The "#if" makes sure that 64-bit constants are supported, avoiding + a compilation failure. The "if" makes sure that the constant is + representable in a long (this would not be the case with 32-bit + unsigned long and 64-bit limb). It also ensures that mpfr_exp_t + has at least 64 bits. */ +#if MPFR_PREC_BITS >= 64 + emin = mpfr_get_emin (); + set_emin (MPFR_EMIN_MIN); + mpfr_set_ui_2exp (y1, 1, -4611686018427366846, MPFR_RNDN); + inex1 = 1; + flags1 = MPFR_FLAGS_INEXACT; + mpfr_clear_flags (); + /* -7883729320669216768 ~= -2^62 / log2(3/2) */ + inex2 = mpfr_compound_si (y2, x, -7883729320669216768, MPFR_RNDN); + flags2 = __gmpfr_flags; + if (!(mpfr_equal_p (y1, y2) && + SAME_SIGN (inex1, inex2) && + flags1 == flags2)) + { + printf ("Error in bug_20230206 (2):\n"); + printf ("Expected "); + mpfr_dump (y1); + printf (" with inex = %d, flags =", inex1); + flags_out (flags1); + printf ("Got "); + mpfr_dump (y2); + printf (" with inex = %d, flags =", inex2); + flags_out (flags2); + exit (1); + } + set_emin (emin); +#endif + + mpfr_clears (x, y1, y2, (mpfr_ptr) 0); + } +} + +/* Reported by Patrick Pelissier on 2023-02-11 for the master branch + (tgeneric_ui.c with GMP_CHECK_RANDOMIZE=1412991715). + On a 32-bit host, one gets Inf (overflow) instead of 0.1E1071805703. +*/ +static void +bug_20230211 (void) { - return mpfr_compound_si (y, x, 2, rnd_mode); + mpfr_t x, y1, y2; + int inex1, inex2; + mpfr_flags_t flags1, flags2; + + mpfr_inits2 (1, x, y1, y2, (mpfr_ptr) 0); + mpfr_set_ui_2exp (x, 1, -1, MPFR_RNDN); /* x = 1/2 */ + mpfr_set_ui_2exp (y1, 1, 1071805702, MPFR_RNDN); + inex1 = 1; + flags1 = MPFR_FLAGS_INEXACT; + mpfr_clear_flags (); + inex2 = mpfr_compound_si (y2, x, 1832263949, MPFR_RNDN); + flags2 = __gmpfr_flags; + if (!(mpfr_equal_p (y1, y2) && + SAME_SIGN (inex1, inex2) && + flags1 == flags2)) + { + printf ("Error in bug_20230211:\n"); + printf ("Expected "); + mpfr_dump (y1); + printf (" with inex = %d, flags =", inex1); + flags_out (flags1); + printf ("Got "); + mpfr_dump (y2); + printf (" with inex = %d, flags =", inex2); + flags_out (flags2); + exit (1); + } + mpfr_clears (x, y1, y2, (mpfr_ptr) 0); +} + +/* Integer overflow with compound.c d04caeae04c6a83276916c4fbac1fe9b0cec3c8b + (2023-02-23) or 952fb0f5cc2df1fffde3eb54c462fdae5f123ea6 in the 4.2 branch + on "n * (kx - 1) + 1". Note: if the only effect is just a random value, + this probably doesn't affect the result (one might enter the "if" while + one shouldn't, but the real check is done inside the "if"). This test + fails if -fsanitize=undefined -fno-sanitize-recover is used or if the + processor emits a signal in case of integer overflow. + This test has been made obsolete by the "kx < ex" condition + in 2cb3123891dd46fe0258d4aec7f8655b8ec69aaf (master branch) + or f5cb40571bc3d1559f05b230cf4ffecaf0952852 (4.2 branch). */ +static void +bug_20230517 (void) +{ + mpfr_exp_t old_emax; + mpfr_t x; + + old_emax = mpfr_get_emax (); + set_emax (MPFR_EMAX_MAX); + + mpfr_init2 (x, 123456); + mpfr_set_ui (x, 65536, MPFR_RNDN); + mpfr_nextabove (x); + mpfr_compound_si (x, x, LONG_MAX >> 16, MPFR_RNDN); + mpfr_clear (x); + + set_emax (old_emax); } +/* Inverse function on non-special cases... + One has x = (1+y)^n with y > -1 and x > 0. Thus y = x^(1/n) - 1. + The inverse function is useful + - to build and check hard-to-round cases (see bad_cases() in tests.c); + - to test the behavior close to the overflow and underflow thresholds. + The case x = 0 actually needs to be handled as it may occur with + bad_cases() due to rounding. +*/ static int -mpfr_compound3 (mpfr_ptr y, mpfr_srcptr x, mpfr_rnd_t rnd_mode) +inv_compound (mpfr_ptr y, mpfr_srcptr x, long n, mpfr_rnd_t rnd_mode) { - return mpfr_compound_si (y, x, 3, rnd_mode); + mpfr_t t; + int inexact; + mpfr_prec_t precy, prect; + MPFR_ZIV_DECL (loop); + MPFR_SAVE_EXPO_DECL (expo); + + MPFR_ASSERTN (n != 0); + + if (MPFR_UNLIKELY (MPFR_IS_ZERO (x))) + { + if (n > 0) + return mpfr_set_si (y, -1, rnd_mode); + else + { + MPFR_SET_INF (y); + MPFR_SET_POS (y); + MPFR_RET (0); + } + } + + MPFR_SAVE_EXPO_MARK (expo); + + if (mpfr_equal_p (x, __gmpfr_one)) + { + MPFR_SAVE_EXPO_FREE (expo); + mpfr_set_zero (y, 1); + MPFR_RET (0); + } + + precy = MPFR_GET_PREC (y); + prect = precy + 20; + mpfr_init2 (t, prect); + + MPFR_ZIV_INIT (loop, prect); + for (;;) + { + mpfr_exp_t expt1, expt2, err; + unsigned int inext; + + if (mpfr_rootn_si (t, x, n, MPFR_RNDN) == 0) + { + /* With a huge t, this case would yield inext != 0 and a + MPFR_CAN_ROUND failure until a huge precision is reached + (as the result is very close to an exact point). Fortunately, + since t is exact, we can obtain the correctly rounded result + by doing the second operation to the target precision directly. + */ + inexact = mpfr_sub_ui (y, t, 1, rnd_mode); + goto end; + } + expt1 = MPFR_GET_EXP (t); + /* |error| <= 2^(expt1-prect-1) */ + inext = mpfr_sub_ui (t, t, 1, MPFR_RNDN); + if (MPFR_UNLIKELY (MPFR_IS_ZERO (t))) + goto cont; /* cannot round yet */ + expt2 = MPFR_GET_EXP (t); + err = 1; + if (expt2 < expt1) + err += expt1 - expt2; + /* |error(rootn)| <= 2^(err+expt2-prect-2) + and if mpfr_sub_ui is inexact: + |error| <= 2^(err+expt2-prect-2) + 2^(expt2-prect-1) + <= (2^(err-1) + 1) * 2^(expt2-prect-1) + <= 2^((err+1)+expt2-prect-2) */ + if (inext) + err++; + /* |error| <= 2^(err+expt2-prect-2) */ + if (MPFR_CAN_ROUND (t, prect + 2 - err, precy, rnd_mode)) + break; + + cont: + MPFR_ZIV_NEXT (loop, prect); + mpfr_set_prec (t, prect); + } + + inexact = mpfr_set (y, t, rnd_mode); + + end: + MPFR_ZIV_FREE (loop); + mpfr_clear (t); + MPFR_SAVE_EXPO_FREE (expo); + return mpfr_check_range (y, inexact, rnd_mode); } +#define DEFN(N) \ + static int mpfr_compound##N (mpfr_ptr y, mpfr_srcptr x, mpfr_rnd_t r) \ + { return mpfr_compound_si (y, x, N, r); } \ + static int inv_compound##N (mpfr_ptr y, mpfr_srcptr x, mpfr_rnd_t r) \ + { return inv_compound (y, x, N, r); } + +DEFN(2) +DEFN(3) +DEFN(4) +DEFN(5) +DEFN(17) +DEFN(120) + #define TEST_FUNCTION mpfr_compound2 #define test_generic test_generic_compound2 #include "tgeneric.c" @@ -258,17 +503,55 @@ mpfr_compound3 (mpfr_ptr y, mpfr_srcptr x, mpfr_rnd_t rnd_mode) #define test_generic test_generic_compound3 #include "tgeneric.c" +#define TEST_FUNCTION mpfr_compound4 +#define test_generic test_generic_compound4 +#include "tgeneric.c" + +#define TEST_FUNCTION mpfr_compound5 +#define test_generic test_generic_compound5 +#include "tgeneric.c" + +#define TEST_FUNCTION mpfr_compound17 +#define test_generic test_generic_compound17 +#include "tgeneric.c" + +#define TEST_FUNCTION mpfr_compound120 +#define test_generic test_generic_compound120 +#include "tgeneric.c" + int main (void) { tests_start_mpfr (); check_ieee754 (); + bug_20230206 (); + bug_20230211 (); + bug_20230517 (); test_generic_si (MPFR_PREC_MIN, 100, 100); test_generic_compound2 (MPFR_PREC_MIN, 100, 100); test_generic_compound3 (MPFR_PREC_MIN, 100, 100); + test_generic_compound4 (MPFR_PREC_MIN, 100, 100); + test_generic_compound5 (MPFR_PREC_MIN, 100, 100); + test_generic_compound17 (MPFR_PREC_MIN, 100, 100); + test_generic_compound120 (MPFR_PREC_MIN, 100, 100); + + /* Note: For small n, we need a psup high enough to avoid too many + "f exact while f^(-1) inexact" occurrences in bad_cases(). */ + bad_cases (mpfr_compound2, inv_compound2, "mpfr_compound2", + 0, -256, 255, 4, 128, 240, 40); + bad_cases (mpfr_compound3, inv_compound3, "mpfr_compound3", + 0, -256, 255, 4, 128, 120, 40); + bad_cases (mpfr_compound4, inv_compound4, "mpfr_compound4", + 0, -256, 255, 4, 128, 80, 40); + bad_cases (mpfr_compound5, inv_compound5, "mpfr_compound5", + 0, -256, 255, 4, 128, 80, 40); + bad_cases (mpfr_compound17, inv_compound17, "mpfr_compound17", + 0, -256, 255, 4, 128, 80, 40); + bad_cases (mpfr_compound120, inv_compound120, "mpfr_compound120", + 0, -256, 255, 4, 128, 80, 40); tests_end_mpfr (); return 0; diff --git a/tests/tests.c b/tests/tests.c index 8cba66c..cf30841 100644 --- a/tests/tests.c +++ b/tests/tests.c @@ -1086,10 +1086,9 @@ bad_cases (int (*fct)(FLIST), int (*inv)(FLIST), const char *name, } if (inex_inv) { - printf ("bad_cases: f exact while f^(-1) inexact,\n" - "due to a poor choice of the parameters.\n"); - exit (1); - /* alternatively, goto next_i */ + if (dbg) + printf ("bad_cases: f exact while f^(-1) inexact\n"); + goto does_not_match; } inex = 0; break; @@ -1112,6 +1111,10 @@ bad_cases (int (*fct)(FLIST), int (*inv)(FLIST), const char *name, if (mpfr_nanflag_p () || mpfr_overflow_p () || mpfr_underflow_p () || ! mpfr_equal_p (z, y)) { + /* This may occur when psup is not large enough: evaluating + x = (f^(-1))(y) then z = f(x) may not give back y if the + precision of x is too small. */ + does_not_match: if (dbg) { printf ("bad_cases: inverse doesn't match for %s\ny = ", diff --git a/tests/texp10.c b/tests/texp10.c index 19b7711..f75fcd3 100644 --- a/tests/texp10.c +++ b/tests/texp10.c @@ -190,6 +190,187 @@ overfl_exp10_0 (void) mpfr_clear (y); } +/* Bug in mpfr_pow_general found by ofuf_thresholds (on 2023-02-13 for + a 32-bit exponent, changed on 2023-03-06 for a 64-bit exponent too), + fixed in commit b62966df913f73f08b3c5252e1d0c702bc20442f. + With a 32-bit exponent, failure for i=0. + expected 0.1111E1073741823 + got @Inf@ + expected flags = inexact (8) + got flags = overflow inexact (10) + With a 64-bit exponent, failure for i=1. + expected 0.11111111111111111111111E4611686018427387903 + got @Inf@ + expected flags = inexact (8) + got flags = overflow inexact (10) + Note: ofuf_thresholds was added to the master branch, but for the + time being, there are issues with these tests. +*/ +static void +bug20230213 (void) +{ + const char *s[2] = { + "0x1.34413504b3ccdbd5dd8p+28", + "0x1.34413509f79fef2c4e0dd14a7ae0ecfbacdbp+60" + }; + mpfr_t x1, x2, y1, y2; + mpfr_prec_t px[2] = { 74, 147 }; + mpfr_prec_t py[2] = { 4, 23 }; + mpfr_exp_t old_emax, emax; + mpfr_flags_t flags1, flags2; + int i; + + old_emax = mpfr_get_emax (); + + for (i = 0; i < 2; i++) + { + if (i != 0) + set_emax (MPFR_EMAX_MAX); + + emax = mpfr_get_emax (); + + mpfr_inits2 (px[i], x1, x2, (mpfr_ptr) 0); + mpfr_inits2 (py[i], y1, y2, (mpfr_ptr) 0); + + mpfr_setmax (y1, emax); + mpfr_log10 (x1, y1, MPFR_RNDD); + mpfr_set_str (x2, s[i], 0, MPFR_RNDN); + /* For i == 0, emax == 2^30, so that the value can be checked. + For i != 0, check the value for the case emax == 2^62. + The "0UL" ensures that the shifts are valid. */ + if (i == 0 || (((0UL + MPFR_EMAX_MAX) >> 31) >> 30) == 1) + { + /* printf ("Checking x1 for i=%d\n", i); */ + MPFR_ASSERTN (mpfr_equal_p (x1, x2)); + } + + /* Let MAXF be the maximum finite value (y1 above). + Since x1 < log10(MAXF), one should have exp10(x1) < MAXF, and + therefore, y2 = RU(exp10(x1)) <= RU(MAXF) = MAXF (no overflow). */ + flags1 = MPFR_FLAGS_INEXACT; + mpfr_clear_flags (); + mpfr_exp10 (y2, x1, MPFR_RNDU); + flags2 = __gmpfr_flags; + + if (! (mpfr_lessequal_p (y2, y1) && flags2 == flags1)) + { + printf ("Error in bug20230213 for i=%d\n", i); + printf ("emax = %" MPFR_EXP_FSPEC "d\n", (mpfr_eexp_t) emax); + printf ("expected "); mpfr_dump (y1); + printf ("got "); mpfr_dump (y2); + printf ("expected flags ="); + flags_out (flags1); + printf ("got flags ="); + flags_out (flags2); + exit (1); + } + + mpfr_clears (x1, x2, y1, y2, (mpfr_ptr) 0); + } + + set_emax (old_emax); +} + +/* Bug in mpfr_pow_general in precision 1 in the particular case of + rounding to nearest, z * 2^k = 2^(emin - 2) and real result larger + than this value; fixed in ff5012b61d5e5fee5156c57b8aa8fc1739c2a771 + (which is simplified in 4f5de980be290687ac1409aa02873e9e0dd1a030); + initially found by ofuf_thresholds (though the test was incorrect). + With a 32-bit exponent, failure for i=0. + With a 64-bit exponent, failure for i=1. + The result was correct, but the underflow flag was missing. + Note: ofuf_thresholds was added to the master branch, but for the + time being, there are issues with these tests. +*/ +static void +bug20230427 (void) +{ + const char *s[2] = { + "-0.1001101000100000100110101000011E29", + "-0.100110100010000010011010100001001111101111001111111101111001101E61" + }; + mpfr_t x, y, z, t1, t2; + mpfr_exp_t old_emin; + mpfr_flags_t flags, ex_flags; + int i, inex; + + old_emin = mpfr_get_emin (); + + mpfr_init2 (x, 63); + mpfr_inits2 (1, y, z, (mpfr_ptr) 0); + mpfr_inits2 (128, t1, t2, (mpfr_ptr) 0); + + for (i = 0; i < 2; i++) + { + if (i == 0) + { + /* Basic check: the default emin should be -2^30 (exactly). */ + if (mpfr_get_emin () != -1073741823) + abort (); + } + else + { + /* This test assumes that MPFR_EMIN_MIN = -2^62 (exactly). + The "0UL" ensures that the shifts are valid. */ + if ((((0UL - MPFR_EMIN_MIN) >> 31) >> 30) != 1) + break; + + set_emin (MPFR_EMIN_MIN); + } + + mpfr_set_str_binary (x, s[i]); + + /* We will test 10^x rounded to nearest in precision 1. + Check that 2^(emin - 2) < 10^x < (3/2) * 2^(emin - 2). + This is approximate, but by outputting the values, one can check + that one is not too close to the boundaries: + emin - 2 = -4611686018427387905 + log2(10^x) ~= -4611686018427387904.598 + emin - 2 + log2(3/2) ~= -4611686018427387904.415 + Thus the result should be the smallest positive number 2^(emin - 1) + because 10^x is closer to this number than to 0, the midpoint being + 2^(emin - 2). And there should be an underflow in precision 1 because + the result rounded to nearest in an unbounded exponent range should + have been 2^(emin - 2), the midpoint being (3/2) * 2^(emin - 2). + */ + mpfr_set_ui (t1, 10, MPFR_RNDN); + mpfr_log2 (t2, t1, MPFR_RNDN); + mpfr_mul (t1, t2, x, MPFR_RNDN); + inex = mpfr_set_exp_t (t2, mpfr_get_emin () - 2, MPFR_RNDN); + MPFR_ASSERTN (inex == 0); + MPFR_ASSERTN (mpfr_greater_p (t1, t2)); /* log2(10^x) > emin - 2 */ + inex = mpfr_sub (t1, t1, t2, MPFR_RNDN); + MPFR_ASSERTN (inex == 0); + mpfr_set_ui (t2, 3, MPFR_RNDN); + mpfr_log2 (t2, t2, MPFR_RNDN); + mpfr_sub_ui (t2, t2, 1, MPFR_RNDN); /* log2(3/2) */ + MPFR_ASSERTN (mpfr_less_p (t1, t2)); + + mpfr_clear_flags (); + mpfr_exp10 (y, x, MPFR_RNDN); + flags = __gmpfr_flags; + ex_flags = MPFR_FLAGS_UNDERFLOW | MPFR_FLAGS_INEXACT; + + mpfr_setmin (z, mpfr_get_emin ()); /* z = 0.1@emin */ + if (! (mpfr_equal_p (y, z) && flags == ex_flags)) + { + printf ("Error in bug20230427 for i=%d\n", i); + printf ("expected "); mpfr_dump (z); + printf ("got "); mpfr_dump (y); + printf ("emin = %" MPFR_EXP_FSPEC "d\n", + (mpfr_eexp_t) mpfr_get_emin ()); + printf ("expected flags ="); + flags_out (ex_flags); + printf ("got flags ="); + flags_out (flags); + exit (1); + } + } + + mpfr_clears (x, y, z, t1, t2, (mpfr_ptr) 0); + set_emin (old_emin); +} + int main (int argc, char *argv[]) { @@ -199,6 +380,9 @@ main (int argc, char *argv[]) tests_start_mpfr (); + bug20230213 (); + bug20230427 (); + special_overflow (); emax_m_eps (); exp_range (); diff --git a/tests/tfpif.c b/tests/tfpif.c index 72c9242..6e0713e 100644 --- a/tests/tfpif.c +++ b/tests/tfpif.c @@ -277,7 +277,10 @@ check_bad (void) for (i = 0; i < BAD; i++) { - mpfr_exp_t emax; + mpfr_exp_t INITIALIZED(emax); + /* The INITIALIZED() is a workaround for GCC bug 106155: + https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106155 */ + /* For i == 6, mpfr_prec_t needs at least a 65-bit precision (64 value bits + 1 sign bit) to avoid a failure. */ if (i == 6 && MPFR_PREC_BITS > 64) diff --git a/tests/tfprintf.c b/tests/tfprintf.c index 5af54b0..f3bf316 100644 --- a/tests/tfprintf.c +++ b/tests/tfprintf.c @@ -61,6 +61,12 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc., exit (1); \ } +#if MPFR_LCONV_DPTS +#define DPLEN ((int) strlen (localeconv()->decimal_point)) +#else +#define DPLEN 1 +#endif + /* limit for random precision in random() */ const int prec_max_printf = 5000; @@ -195,12 +201,12 @@ check_mixed (FILE *fout) lo, &ulo); check_length (2, ulo, 36, lu); check_vfprintf (fout, "a. %hi, b. %*f, c. %Re%hn", ush, 3, f, mpfr, &ush); - check_length (3, ush, 46, hu); + check_length (3, ush, 45 + DPLEN, hu); check_vfprintf (fout, "a. %hi, b. %f, c. %#.2Rf%n", sh, d, mpfr, &i); - check_length (4, i, 29, d); + check_length (4, i, 28 + DPLEN, d); check_vfprintf (fout, "a. %R*A, b. %Fe, c. %i%zn", rnd, mpfr, mpf, sz, &sz); - check_length (5, (unsigned long) sz, 34, lu); /* no format specifier "%zu" in C90 */ + check_length (5, (unsigned long) sz, 33 + DPLEN, lu); /* no format specifier "%zu" in C90 */ check_vfprintf (fout, "a. %Pu, b. %c, c. %Zi%Zn", prec, ch, mpz, &mpz); check_length_with_cmp (6, mpz, 17, mpz_cmp_ui (mpz, 17), Zi); check_vfprintf (fout, "%% a. %#.0RNg, b. %Qx%Rn, c. %p", mpfr, mpq, &mpfr, @@ -224,7 +230,7 @@ check_mixed (FILE *fout) #ifdef PRINTF_L check_vfprintf (fout, "a. %RA, b. %Lf, c. %QX%zn", mpfr, ld, mpq, &sz); - check_length (9, (unsigned long) sz, 30, lu); /* no format specifier "%zu" in C90 */ + check_length (9, (unsigned long) sz, 29 + DPLEN, lu); /* no format specifier "%zu" in C90 */ #endif #ifndef NPRINTF_HH diff --git a/tests/tlog10.c b/tests/tlog10.c index aeccb2c..b21dd59 100644 --- a/tests/tlog10.c +++ b/tests/tlog10.c @@ -49,6 +49,60 @@ test_log10 (mpfr_ptr a, mpfr_srcptr b, mpfr_rnd_t rnd_mode) #define TEST_RANDOM_POS 8 #include "tgeneric.c" +/* On 2023-02-13, one gets an infinite loop in mpfr_log10 on both + 32-bit and 64-bit hosts when the precision is not large enough + (precision 12 and below). */ +static void +bug20230213 (void) +{ + mpfr_exp_t old_emin, old_emax, e; + mpfr_t t, x, y0, y1, y2; + int prec; + + old_emin = mpfr_get_emin (); + old_emax = mpfr_get_emax (); + + set_emin (MPFR_EMIN_MIN); + set_emax (MPFR_EMAX_MAX); + e = mpfr_get_emax () - 1; + + /* The precisions of t and y0 should be large enough to avoid + a hard-to-round case for the target precisions. */ + mpfr_inits2 (64, t, y0, (mpfr_ptr) 0); + mpfr_set_exp_t (y0, e, MPFR_RNDN); + mpfr_log_ui (t, 10, MPFR_RNDN); + mpfr_div (y0, y0, t, MPFR_RNDN); + mpfr_log_ui (t, 2, MPFR_RNDN); + mpfr_mul (y0, y0, t, MPFR_RNDN); + + for (prec = 16; prec >= MPFR_PREC_MIN; prec--) + { + mpfr_inits2 (prec, x, y1, y2, (mpfr_ptr) 0); + mpfr_set (y1, y0, MPFR_RNDN); + + mpfr_set_ui_2exp (x, 1, e, MPFR_RNDN); + mpfr_log10 (y2, x, MPFR_RNDN); + MPFR_ASSERTN (MPFR_IS_PURE_FP (y2)); + MPFR_ASSERTN (MPFR_IS_POS (y2)); + + if (! mpfr_equal_p (y1, y2)) + { + printf ("Error in bug20230213.\n"); + printf ("Expected "); + mpfr_dump (y1); + printf ("Got "); + mpfr_dump (y2); + exit (1); + } + mpfr_clears (x, y1, y2, (mpfr_ptr) 0); + } + + mpfr_clears (t, y0, (mpfr_ptr) 0); + + set_emin (old_emin); + set_emax (old_emax); +} + int main (int argc, char *argv[]) { @@ -112,6 +166,8 @@ main (int argc, char *argv[]) mpfr_clear (x); mpfr_clear (y); + bug20230213 (); + data_check ("data/log10", mpfr_log10, "mpfr_log10"); tests_end_mpfr (); diff --git a/tests/tprintf.c b/tests/tprintf.c index c8a7b90..c628bbf 100644 --- a/tests/tprintf.c +++ b/tests/tprintf.c @@ -68,6 +68,12 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc., exit (1); \ } +#if MPFR_LCONV_DPTS +#define DPLEN ((int) strlen (localeconv()->decimal_point)) +#else +#define DPLEN 1 +#endif + /* limit for random precision in random() */ const int prec_max_printf = 5000; /* boolean: is stdout redirected to a file ? */ @@ -316,11 +322,11 @@ check_mixed (void) check_vprintf ("a. %c, b. %Rb, c. %u, d. %li%ln", i, mpfr, i, lo, &ulo); check_length (2, ulo, 36, lu); check_vprintf ("a. %hi, b. %*f, c. %Re%hn", ush, 3, f, mpfr, &ush); - check_length (3, ush, 46, hu); + check_length (3, ush, 45 + DPLEN, hu); check_vprintf ("a. %hi, b. %f, c. %#.2Rf%n", sh, d, mpfr, &i); - check_length (4, i, 29, d); + check_length (4, i, 28 + DPLEN, d); check_vprintf ("a. %R*A, b. %Fe, c. %i%zn", rnd, mpfr, mpf, sz, &sz); - check_length (5, (unsigned long) sz, 34, lu); /* no format specifier '%zu' in C90 */ + check_length (5, (unsigned long) sz, 33 + DPLEN, lu); /* no format specifier '%zu' in C90 */ check_vprintf ("a. %Pu, b. %c, c. %RUG, d. %Zi%Zn", prec, ch, mpfr, mpz, &mpz); check_length_with_cmp (6, mpz, 24, mpz_cmp_ui (mpz, 24), Zi); check_vprintf ("%% a. %#.0RNg, b. %Qx%Rn c. %p", @@ -344,7 +350,7 @@ check_mixed (void) #ifdef PRINTF_L check_vprintf ("a. %RA, b. %Lf, c. %QX%zn", mpfr, ld, mpq, &sz); - check_length (9, (unsigned long) sz, 30, lu); /* no format specifier '%zu' in C90 */ + check_length (9, (unsigned long) sz, 29 + DPLEN, lu); /* no format specifier '%zu' in C90 */ #endif #ifndef NPRINTF_HH diff --git a/tests/trec_sqrt.c b/tests/trec_sqrt.c index cf30ff5..f1fc3c5 100644 --- a/tests/trec_sqrt.c +++ b/tests/trec_sqrt.c @@ -242,6 +242,8 @@ main (int argc, char *argv[]) data_check ("data/rec_sqrt", mpfr_rec_sqrt, "mpfr_rec_sqrt"); bad_cases (mpfr_rec_sqrt, pm2, "mpfr_rec_sqrt", 0, -256, 255, 4, 128, 800, 50); + bad_cases (mpfr_rec_sqrt, pm2, "mpfr_rec_sqrt", 0, -256, 255, 9999, 9999, + 120000, 1); end: tests_end_mpfr (); diff --git a/tests/tsprintf.c b/tests/tsprintf.c index c7bd74a..58d66b8 100644 --- a/tests/tsprintf.c +++ b/tests/tsprintf.c @@ -1620,6 +1620,30 @@ check_length_overflow (void) mpfr_clear (x); } +/* On 2023-03-22, on a 64-bit Linux machine (thus with 32-bit int), + the case %.2147483648Rg yields an incorrect size computation and + MPFR wants to allocate 18446744071562070545 bytes. With assertion + checking (--enable-assert), one gets: + vasprintf.c:1908: MPFR assertion failed: threshold >= 1 + + This case should either succeed or fail as reaching an environmental limit + like with glibc (note that the precision does not fit in an int). +*/ +static void +large_prec_for_g (void) +{ + mpfr_t x; + int r; + + mpfr_init2 (x, 128); + mpfr_set_ui (x, 1, MPFR_RNDN); + r = mpfr_snprintf (NULL, 0, "%.2147483647Rg\n", x); + MPFR_ASSERTN (r == 2); + r = mpfr_snprintf (NULL, 0, "%.2147483648Rg\n", x); + MPFR_ASSERTN (r == 2 || r < 0); + mpfr_clear (x); +} + #if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE) /* The following tests should be equivalent to those from test_locale() @@ -1715,7 +1739,25 @@ test_locale (void) check_sprintf ("000000001,000", "%'013.4Rg", x); #ifdef PRINTF_GROUPFLAG - check_vsprintf ("+01,234,567 :", "%0+ -'13.10Pd:", (mpfr_prec_t) 1234567); + /* Do not test the thousands separator with a precision field larger + than the number of digits (thus needing leading zeros), such as + "%0+ -'13.10Pd:" (used up to MPFR 4.2.0), since the GNU libc is + buggy: https://sourceware.org/bugzilla/show_bug.cgi?id=23432 + We don't know about the other implementations. + This new test works fine with glibc up to 2.36, but fails with 2.37 + (as reported by Klaus Dittrich in the MPFR mailing-list); this is + actually a bug introduced in glibc 2.37, not in MPFR: + https://sourceware.org/bugzilla/show_bug.cgi?id=30068 + Since this bug can yield a buffer overflow (CVE-2023-25139), possibly + affecting MPFR users, let us rather require a fix in glibc. This bug + has been fixed in the 2.37 branch: + https://sourceware.org/git/?p=glibc.git;a=commit;h=07b9521fc6 + If we wanted to check that and avoid a failure of the test because of + a buggy C library (while MPFR would be consistent with the C library), + we could compare the MPFR output with both the correct output and the + output from the C library (possibly buggy). But to do that in a clean + way, this would require a change in the check_vsprintf() call. */ + check_vsprintf ("+1,234,567 :", "%0+ -'13Pd:", (mpfr_prec_t) 1234567); #endif mpfr_clear (x); @@ -1775,6 +1817,7 @@ main (int argc, char **argv) percent_n (); mixed (); check_length_overflow (); + large_prec_for_g (); test_locale (); if (getenv ("MPFR_CHECK_LIBC_PRINTF")) diff --git a/tests/tui_pow.c b/tests/tui_pow.c index 4f409e0..608e921 100644 --- a/tests/tui_pow.c +++ b/tests/tui_pow.c @@ -142,6 +142,37 @@ check1 (mpfr_ptr x, mpfr_prec_t prec, unsigned long nt, mpfr_rnd_t rnd) mpfr_clear (t); } +static void +huge (void) +{ + mpfr_exp_t old_emin, old_emax; + mpfr_t x; + + old_emin = mpfr_get_emin (); + old_emax = mpfr_get_emax (); + + set_emin (MPFR_EMIN_MIN); + set_emax (MPFR_EMAX_MAX); + + mpfr_init2 (x, 8); + + /* The purpose of this test is more to check that mpfr_ui_pow_ui + terminates (without taking much memory) rather than checking + the value of x. On 2023-02-13, the +Inf case was not handled + in the Ziv iteration, yielding an infinite loop, affecting + mpfr_log10 in particular. See + commit 90de094f0d9c309daca707aa227470d810866616 + */ + mpfr_ui_pow_ui (x, 5, ULONG_MAX, MPFR_RNDN); + if (MPFR_EMAX_MAX <= ULONG_MAX) /* true with default _MPFR_EXP_FORMAT */ + MPFR_ASSERTN (MPFR_IS_INF (x)); + + mpfr_clear (x); + + set_emin (old_emin); + set_emax (old_emax); +} + int main (int argc, char *argv[]) { @@ -180,6 +211,7 @@ main (int argc, char *argv[]) } test1 (); + huge (); { mpfr_t z, t; -- 2.33.0
Locations
Projects
Search
Status Monitor
Help
Open Build Service
OBS Manuals
API Documentation
OBS Portal
Reporting a Bug
Contact
Mailing List
Forums
Chat (IRC)
Twitter
Open Build Service (OBS)
is an
openSUSE project
.
浙ICP备2022010568号-2