diff options
Diffstat (limited to 'patches/mpfr/3.1.3/200-can_round.patch')
| -rw-r--r-- | patches/mpfr/3.1.3/200-can_round.patch | 413 |
1 files changed, 0 insertions, 413 deletions
diff --git a/patches/mpfr/3.1.3/200-can_round.patch b/patches/mpfr/3.1.3/200-can_round.patch deleted file mode 100644 index 6c0f79a..0000000 --- a/patches/mpfr/3.1.3/200-can_round.patch +++ /dev/null @@ -1,413 +0,0 @@ -diff -Naurd mpfr-3.1.3-a/PATCHES mpfr-3.1.3-b/PATCHES ---- mpfr-3.1.3-a/PATCHES 2016-02-15 15:19:24.210647274 +0000 -+++ mpfr-3.1.3-b/PATCHES 2016-02-15 15:19:24.274647313 +0000 -@@ -0,0 +1 @@ -+can_round -diff -Naurd mpfr-3.1.3-a/VERSION mpfr-3.1.3-b/VERSION ---- mpfr-3.1.3-a/VERSION 2016-02-15 15:17:39.282577552 +0000 -+++ mpfr-3.1.3-b/VERSION 2016-02-15 15:19:24.274647313 +0000 -@@ -1 +1 @@ --3.1.3-p9 -+3.1.3-p10 -diff -Naurd mpfr-3.1.3-a/src/div.c mpfr-3.1.3-b/src/div.c ---- mpfr-3.1.3-a/src/div.c 2015-06-19 19:55:09.000000000 +0000 -+++ mpfr-3.1.3-b/src/div.c 2016-02-15 15:19:24.250647299 +0000 -@@ -310,24 +310,23 @@ - - qp = MPFR_TMP_LIMBS_ALLOC (n); - qh = mpfr_divhigh_n (qp, ap, bp, n); -+ MPFR_ASSERTD (qh == 0 || qh == 1); - /* in all cases, the error is at most (2n+2) ulps on qh*B^n+{qp,n}, - cf algorithms.tex */ - - p = n * GMP_NUMB_BITS - MPFR_INT_CEIL_LOG2 (2 * n + 2); -- /* if qh is 1, then we need only PREC(q)-1 bits of {qp,n}, -- if rnd=RNDN, we need to be able to round with a directed rounding -- and one more bit */ -+ /* If rnd=RNDN, we need to be able to round with a directed rounding -+ and one more bit. */ -+ if (qh == 1) -+ { -+ mpn_rshift (qp, qp, n, 1); -+ qp[n - 1] |= MPFR_LIMB_HIGHBIT; -+ } - if (MPFR_LIKELY (mpfr_round_p (qp, n, p, -- MPFR_PREC(q) + (rnd_mode == MPFR_RNDN) - qh))) -+ MPFR_PREC(q) + (rnd_mode == MPFR_RNDN)))) - { - /* we can round correctly whatever the rounding mode */ -- if (qh == 0) -- MPN_COPY (q0p, qp + 1, q0size); -- else -- { -- mpn_rshift (q0p, qp + 1, q0size, 1); -- q0p[q0size - 1] ^= MPFR_LIMB_HIGHBIT; -- } -+ MPN_COPY (q0p, qp + 1, q0size); - q0p[0] &= ~MPFR_LIMB_MASK(sh); /* put to zero low sh bits */ - - if (rnd_mode == MPFR_RNDN) /* round to nearest */ -@@ -335,15 +334,10 @@ - /* we know we can round, thus we are never in the even rule case: - if the round bit is 0, we truncate - if the round bit is 1, we add 1 */ -- if (qh == 0) -- { -- if (sh > 0) -- round_bit = (qp[1] >> (sh - 1)) & 1; -- else -- round_bit = qp[0] >> (GMP_NUMB_BITS - 1); -- } -- else /* qh = 1 */ -- round_bit = (qp[1] >> sh) & 1; -+ if (sh > 0) -+ round_bit = (qp[1] >> (sh - 1)) & 1; -+ else -+ round_bit = qp[0] >> (GMP_NUMB_BITS - 1); - if (round_bit == 0) - { - inex = -1; -diff -Naurd mpfr-3.1.3-a/src/mpfr.h mpfr-3.1.3-b/src/mpfr.h ---- mpfr-3.1.3-a/src/mpfr.h 2016-02-15 15:17:39.282577552 +0000 -+++ mpfr-3.1.3-b/src/mpfr.h 2016-02-15 15:19:24.270647311 +0000 -@@ -27,7 +27,7 @@ - #define MPFR_VERSION_MAJOR 3 - #define MPFR_VERSION_MINOR 1 - #define MPFR_VERSION_PATCHLEVEL 3 --#define MPFR_VERSION_STRING "3.1.3-p9" -+#define MPFR_VERSION_STRING "3.1.3-p10" - - /* Macros dealing with MPFR VERSION */ - #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) -diff -Naurd mpfr-3.1.3-a/src/round_p.c mpfr-3.1.3-b/src/round_p.c ---- mpfr-3.1.3-a/src/round_p.c 2015-06-19 19:55:09.000000000 +0000 -+++ mpfr-3.1.3-b/src/round_p.c 2016-02-15 15:19:24.250647299 +0000 -@@ -31,7 +31,11 @@ - { - int i1, i2; - -+ MPFR_ASSERTN(bp[bn - 1] & MPFR_LIMB_HIGHBIT); -+ - i1 = mpfr_round_p_2 (bp, bn, err0, prec); -+ -+ /* compare with mpfr_can_round_raw */ - i2 = mpfr_can_round_raw (bp, bn, MPFR_SIGN_POS, err0, - MPFR_RNDN, MPFR_RNDZ, prec); - if (i1 != i2) -@@ -42,6 +46,7 @@ - gmp_fprintf (stderr, "%NX\n", bp, bn); - MPFR_ASSERTN (0); - } -+ - return i1; - } - # define mpfr_round_p mpfr_round_p_2 -@@ -62,6 +67,8 @@ - mp_limb_t tmp, mask; - int s; - -+ MPFR_ASSERTD(bp[bn - 1] & MPFR_LIMB_HIGHBIT); -+ - err = (mpfr_prec_t) bn * GMP_NUMB_BITS; - if (MPFR_UNLIKELY (err0 <= 0 || (mpfr_uexp_t) err0 <= prec || prec >= err)) - return 0; /* can't round */ -diff -Naurd mpfr-3.1.3-a/src/round_prec.c mpfr-3.1.3-b/src/round_prec.c ---- mpfr-3.1.3-a/src/round_prec.c 2015-06-19 19:55:10.000000000 +0000 -+++ mpfr-3.1.3-b/src/round_prec.c 2016-02-15 15:19:24.250647299 +0000 -@@ -141,24 +141,40 @@ - mpfr_can_round_raw (const mp_limb_t *bp, mp_size_t bn, int neg, mpfr_exp_t err0, - mpfr_rnd_t rnd1, mpfr_rnd_t rnd2, mpfr_prec_t prec) - { -- mpfr_prec_t err; -+ mpfr_prec_t err, prec0 = prec; - mp_size_t k, k1, tn; - int s, s1; - mp_limb_t cc, cc2; - mp_limb_t *tmp; - MPFR_TMP_DECL(marker); - -+ MPFR_ASSERTD(bp[bn - 1] & MPFR_LIMB_HIGHBIT); -+ - if (MPFR_UNLIKELY(err0 < 0 || (mpfr_uexp_t) err0 <= prec)) - return 0; /* can't round */ -- else if (MPFR_UNLIKELY (prec > (mpfr_prec_t) bn * GMP_NUMB_BITS)) -- { /* then ulp(b) < precision < error */ -- return rnd2 == MPFR_RNDN && (mpfr_uexp_t) err0 - 2 >= prec; -- /* can round only in rounding to the nearest and err0 >= prec + 2 */ -- } - - MPFR_ASSERT_SIGN(neg); - neg = MPFR_IS_NEG_SIGN(neg); - -+ /* Transform RNDD and RNDU to Zero / Away */ -+ MPFR_ASSERTD((neg == 0) || (neg == 1)); -+ if (rnd1 != MPFR_RNDN) -+ rnd1 = MPFR_IS_LIKE_RNDZ(rnd1, neg) ? MPFR_RNDZ : MPFR_RNDA; -+ if (rnd2 != MPFR_RNDN) -+ rnd2 = MPFR_IS_LIKE_RNDZ(rnd2, neg) ? MPFR_RNDZ : MPFR_RNDA; -+ -+ if (MPFR_UNLIKELY (prec > (mpfr_prec_t) bn * GMP_NUMB_BITS)) -+ { /* Then prec < PREC(b): we can round: -+ (i) in rounding to the nearest iff err0 >= prec + 2 -+ (ii) in directed rounding mode iff rnd1 is compatible with rnd2 -+ and err0 >= prec + 1, unless b = 2^k and rnd1=rnd2=RNDA in -+ which case we need err0 >= prec + 2. */ -+ if (rnd2 == MPFR_RNDN) -+ return (mpfr_uexp_t) err0 - 2 >= prec; -+ else -+ return (rnd1 == rnd2) && (mpfr_uexp_t) err0 - 2 >= prec; -+ } -+ - /* if the error is smaller than ulp(b), then anyway it will propagate - up to ulp(b) */ - err = ((mpfr_uexp_t) err0 > (mpfr_prec_t) bn * GMP_NUMB_BITS) ? -@@ -168,19 +184,25 @@ - k = (err - 1) / GMP_NUMB_BITS; - MPFR_UNSIGNED_MINUS_MODULO(s, err); - /* the error corresponds to bit s in limb k, the most significant limb -- being limb 0 */ -+ being limb 0; in memory, limb k is bp[bn-1-k]. */ - - k1 = (prec - 1) / GMP_NUMB_BITS; - MPFR_UNSIGNED_MINUS_MODULO(s1, prec); -- /* the last significant bit is bit s1 in limb k1 */ -+ /* the least significant bit is bit s1 in limb k1 */ - -- /* don't need to consider the k1 most significant limbs */ -+ /* We don't need to consider the k1 most significant limbs. -+ They will be considered later only to detect when subtracting -+ the error bound yields a change of binade. -+ Warning! The number with updated bn may no longer be normalized. */ - k -= k1; - bn -= k1; - prec -= (mpfr_prec_t) k1 * GMP_NUMB_BITS; - -- /* if when adding or subtracting (1 << s) in bp[bn-1-k], it does not -- change bp[bn-1] >> s1, then we can round */ -+ /* We can decide of the correct rounding if rnd2(b-eps) and rnd2(b+eps) -+ give the same result to the target precision 'prec', i.e., if when -+ adding or subtracting (1 << s) in bp[bn-1-k], it does not change the -+ rounding in direction 'rnd2' at ulp-position bp[bn-1] >> s1, taking also -+ into account the possible change of binade. */ - MPFR_TMP_MARK(marker); - tn = bn; - k++; /* since we work with k+1 everywhere */ -@@ -190,11 +212,6 @@ - - MPFR_ASSERTD (k > 0); - -- /* Transform RNDD and RNDU to Zero / Away */ -- MPFR_ASSERTD((neg == 0) || (neg ==1)); -- if (MPFR_IS_RNDUTEST_OR_RNDDNOTTEST(rnd1, neg)) -- rnd1 = MPFR_RNDZ; -- - switch (rnd1) - { - case MPFR_RNDZ: -@@ -203,33 +220,54 @@ - /* mpfr_round_raw2 returns 1 if one should add 1 at ulp(b,prec), - and 0 otherwise */ - cc ^= mpfr_round_raw2 (bp, bn, neg, rnd2, prec); -- /* cc is the new value of bit s1 in bp[bn-1] */ -+ /* cc is the new value of bit s1 in bp[bn-1] after rounding 'rnd2' */ -+ - /* now round b + 2^(MPFR_EXP(b)-err) */ -- cc2 = mpn_add_1 (tmp + bn - k, bp + bn - k, k, MPFR_LIMB_ONE << s); -+ mpn_add_1 (tmp + bn - k, bp + bn - k, k, MPFR_LIMB_ONE << s); -+ /* if there was a carry here, then necessarily bit s1 of bp[bn-1] -+ changed, thus we surely cannot round for directed rounding, but this -+ will be detected below, with cc2 != cc */ - break; - case MPFR_RNDN: - /* Round to nearest */ -- /* first round b+2^(MPFR_EXP(b)-err) */ -- cc = mpn_add_1 (tmp + bn - k, bp + bn - k, k, MPFR_LIMB_ONE << s); -+ -+ /* first round b+2^(MPFR_EXP(b)-err) */ -+ mpn_add_1 (tmp + bn - k, bp + bn - k, k, MPFR_LIMB_ONE << s); -+ /* same remark as above in case a carry occurs in mpn_add_1() */ - cc = (tmp[bn - 1] >> s1) & 1; /* gives 0 when cc=1 */ - cc ^= mpfr_round_raw2 (tmp, bn, neg, rnd2, prec); -+ /* cc is the new value of bit s1 in bp[bn-1]+eps after rounding 'rnd2' */ -+ -+ subtract_eps: - /* now round b-2^(MPFR_EXP(b)-err) */ - cc2 = mpn_sub_1 (tmp + bn - k, bp + bn - k, k, MPFR_LIMB_ONE << s); -+ /* propagate the potential borrow up to the most significant limb -+ (it cannot propagate further since the most significant limb is -+ at least MPFR_LIMB_HIGHBIT) */ -+ for (tn = 0; tn + 1 < k1 && (cc2 != 0); tn ++) -+ cc2 = bp[bn + tn] == 0; -+ /* We have an exponent decrease when either: -+ (i) k1 = 0 and tmp[bn-1] < MPFR_LIMB_HIGHBIT -+ (ii) k1 > 0 and cc <> 0 and bp[bn + tn] = MPFR_LIMB_HIGHBIT -+ (then necessarily tn = k1-1). -+ Then for directed rounding we cannot round, -+ and for rounding to nearest we cannot round when err = prec + 1. -+ */ -+ if (((k1 == 0 && tmp[bn - 1] < MPFR_LIMB_HIGHBIT) || -+ (k1 != 0 && cc2 != 0 && bp[bn + tn] == MPFR_LIMB_HIGHBIT)) && -+ (rnd2 != MPFR_RNDN || err0 == prec0 + 1)) -+ { -+ MPFR_TMP_FREE(marker); -+ return 0; -+ } - break; - default: - /* Round away */ - cc = (bp[bn - 1] >> s1) & 1; - cc ^= mpfr_round_raw2 (bp, bn, neg, rnd2, prec); -- /* now round b +/- 2^(MPFR_EXP(b)-err) */ -- cc2 = mpn_sub_1 (tmp + bn - k, bp + bn - k, k, MPFR_LIMB_ONE << s); -- break; -- } -+ /* cc is the new value of bit s1 in bp[bn-1]+eps after rounding 'rnd2' */ - -- /* if cc2 is 1, then a carry or borrow propagates to the next limb */ -- if (cc2 && cc) -- { -- MPFR_TMP_FREE(marker); -- return 0; -+ goto subtract_eps; - } - - cc2 = (tmp[bn - 1] >> s1) & 1; -diff -Naurd mpfr-3.1.3-a/src/version.c mpfr-3.1.3-b/src/version.c ---- mpfr-3.1.3-a/src/version.c 2016-02-15 15:17:39.282577552 +0000 -+++ mpfr-3.1.3-b/src/version.c 2016-02-15 15:19:24.274647313 +0000 -@@ -25,5 +25,5 @@ - const char * - mpfr_get_version (void) - { -- return "3.1.3-p9"; -+ return "3.1.3-p10"; - } -diff -Naurd mpfr-3.1.3-a/tests/tcan_round.c mpfr-3.1.3-b/tests/tcan_round.c ---- mpfr-3.1.3-a/tests/tcan_round.c 2015-06-19 19:55:10.000000000 +0000 -+++ mpfr-3.1.3-b/tests/tcan_round.c 2016-02-15 15:19:24.250647299 +0000 -@@ -1,4 +1,4 @@ --/* Test file for mpfr_can_round. -+/* Test file for mpfr_can_round and mpfr_round_p. - - Copyright 1999, 2001-2015 Free Software Foundation, Inc. - Contributed by the AriC and Caramel projects, INRIA. -@@ -41,6 +41,8 @@ - /* avoid mpn_random which leaks memory */ - for (i = 0; i < n; i++) - buf[i] = randlimb (); -+ /* force the number to be normalized */ -+ buf[n - 1] |= MPFR_LIMB_HIGHBIT; - p = randlimb() % ((n-1) * GMP_NUMB_BITS) + MPFR_PREC_MIN; - err = p + randlimb () % GMP_NUMB_BITS; - r1 = mpfr_round_p (buf, n, err, p); -@@ -57,11 +59,72 @@ - } - } - -+/* check x=2^i with precision px, error at most 1, and target precision prec */ -+static void -+test_pow2 (mpfr_exp_t i, mpfr_prec_t px, mpfr_rnd_t r1, mpfr_rnd_t r2, -+ mpfr_prec_t prec) -+{ -+ mpfr_t x; -+ int b, expected_b, b2; -+ -+ mpfr_init2 (x, px); -+ mpfr_set_ui_2exp (x, 1, i, MPFR_RNDN); -+ b = !!mpfr_can_round (x, i+1, r1, r2, prec); -+ /* Note: If mpfr_can_round succeeds for both -+ (r1,r2) = (MPFR_RNDD,MPFR_RNDN) and -+ (r1,r2) = (MPFR_RNDU,MPFR_RNDN), then it should succeed for -+ (r1,r2) = (MPFR_RNDN,MPFR_RNDN). So, the condition on prec below -+ for r1 = MPFR_RNDN should be the most restrictive between those -+ for r1 = any directed rounding mode. -+ For r1 like MPFR_RNDA, the unrounded, unknown number may be anyone -+ in [2^i-1,i]. As both 2^i-1 and 2^i fit on i bits, one cannot round -+ in any precision >= i bits, hence the condition prec < i; prec = i-1 -+ will work here for r2 = MPFR_RNDN thanks to the even-rounding rule -+ (and also with rounding ties away from zero). */ -+ expected_b = -+ MPFR_IS_LIKE_RNDD (r1, MPFR_SIGN_POS) ? -+ (MPFR_IS_LIKE_RNDU (r2, MPFR_SIGN_POS) ? 0 : prec <= i) : -+ MPFR_IS_LIKE_RNDU (r1, MPFR_SIGN_POS) ? -+ (MPFR_IS_LIKE_RNDD (r2, MPFR_SIGN_POS) ? 0 : prec < i) : -+ (r2 != MPFR_RNDN ? 0 : prec < i); -+ /* We only require mpfr_can_round to return 1 when we can really -+ round, it is allowed to return 0 in some rare boundary cases, -+ for example when x = 2^k and the error is 0.25 ulp. -+ Note: if this changes in the future, the test could be improved by -+ removing the "&& expected_b == 0" below. */ -+ if (b != expected_b && expected_b == 0) -+ { -+ printf ("Error for x=2^%d, px=%lu, err=%d, r1=%s, r2=%s, prec=%d\n", -+ (int) i, (unsigned long) px, (int) i + 1, -+ mpfr_print_rnd_mode (r1), mpfr_print_rnd_mode (r2), (int) prec); -+ printf ("Expected %d, got %d\n", expected_b, b); -+ exit (1); -+ } -+ -+ if (r1 == MPFR_RNDN && r2 == MPFR_RNDZ) -+ { -+ /* Similar test to the one done in src/round_p.c -+ for MPFR_WANT_ASSERT >= 2. */ -+ b2 = !!mpfr_round_p (MPFR_MANT(x), MPFR_LIMB_SIZE(x), i+1, prec); -+ if (b2 != b) -+ { -+ printf ("Error for x=2^%d, px=%lu, err=%d, prec=%d\n", -+ (int) i, (unsigned long) px, (int) i + 1, (int) prec); -+ printf ("mpfr_can_round gave %d, mpfr_round_p gave %d\n", b, b2); -+ exit (1); -+ } -+ } -+ -+ mpfr_clear (x); -+} -+ - int - main (void) - { - mpfr_t x; -- mpfr_prec_t i, j; -+ mpfr_prec_t i, j, k; -+ int r1, r2; -+ int n; - - tests_start_mpfr (); - -@@ -111,12 +174,30 @@ - mpfr_set_str (x, "0.ff4ca619c76ba69", 16, MPFR_RNDZ); - for (i = 30; i < 99; i++) - for (j = 30; j < 99; j++) -- { -- int r1, r2; -- for (r1 = 0; r1 < MPFR_RND_MAX ; r1++) -- for (r2 = 0; r2 < MPFR_RND_MAX ; r2++) -- mpfr_can_round (x, i, (mpfr_rnd_t) r1, (mpfr_rnd_t) r2, j); /* test for assertions */ -- } -+ for (r1 = 0; r1 < MPFR_RND_MAX; r1++) -+ for (r2 = 0; r2 < MPFR_RND_MAX; r2++) -+ { -+ /* test for assertions */ -+ mpfr_can_round (x, i, (mpfr_rnd_t) r1, (mpfr_rnd_t) r2, j); -+ } -+ -+ test_pow2 (32, 32, MPFR_RNDN, MPFR_RNDN, 32); -+ test_pow2 (174, 174, MPFR_RNDN, MPFR_RNDN, 174); -+ test_pow2 (174, 174, MPFR_RNDU, MPFR_RNDN, 174); -+ test_pow2 (176, 129, MPFR_RNDU, MPFR_RNDU, 174); -+ test_pow2 (176, 2, MPFR_RNDZ, MPFR_RNDZ, 174); -+ test_pow2 (176, 2, MPFR_RNDU, MPFR_RNDU, 176); -+ -+ /* Tests for x = 2^i (E(x) = i+1) with error at most 1 = 2^0. */ -+ for (n = 0; n < 100; n++) -+ { -+ i = (randlimb() % 200) + 4; -+ for (j = i - 2; j < i + 2; j++) -+ for (r1 = 0; r1 < MPFR_RND_MAX; r1++) -+ for (r2 = 0; r2 < MPFR_RND_MAX; r2++) -+ for (k = MPFR_PREC_MIN; k <= i + 2; k++) -+ test_pow2 (i, k, (mpfr_rnd_t) r1, (mpfr_rnd_t) r2, j); -+ } - - mpfr_clear (x); - |