summaryrefslogtreecommitdiffstats
path: root/source/l/mpfr/patches/patch07
diff options
context:
space:
mode:
Diffstat (limited to 'source/l/mpfr/patches/patch07')
-rw-r--r--source/l/mpfr/patches/patch07305
1 files changed, 305 insertions, 0 deletions
diff --git a/source/l/mpfr/patches/patch07 b/source/l/mpfr/patches/patch07
new file mode 100644
index 000000000..922802c5a
--- /dev/null
+++ b/source/l/mpfr/patches/patch07
@@ -0,0 +1,305 @@
+diff -Naurd mpfr-4.2.0-a/PATCHES mpfr-4.2.0-b/PATCHES
+--- mpfr-4.2.0-a/PATCHES 2023-05-12 15:08:39.233546717 +0000
++++ mpfr-4.2.0-b/PATCHES 2023-05-12 15:08:39.325546612 +0000
+@@ -0,0 +1 @@
++pow_general
+diff -Naurd mpfr-4.2.0-a/VERSION mpfr-4.2.0-b/VERSION
+--- mpfr-4.2.0-a/VERSION 2023-05-12 15:06:11.885721962 +0000
++++ mpfr-4.2.0-b/VERSION 2023-05-12 15:08:39.325546612 +0000
+@@ -1 +1 @@
+-4.2.0-p6
++4.2.0-p7
+diff -Naurd mpfr-4.2.0-a/src/mpfr.h mpfr-4.2.0-b/src/mpfr.h
+--- mpfr-4.2.0-a/src/mpfr.h 2023-05-12 15:06:11.877721972 +0000
++++ mpfr-4.2.0-b/src/mpfr.h 2023-05-12 15:08:39.321546616 +0000
+@@ -27,7 +27,7 @@
+ #define MPFR_VERSION_MAJOR 4
+ #define MPFR_VERSION_MINOR 2
+ #define MPFR_VERSION_PATCHLEVEL 0
+-#define MPFR_VERSION_STRING "4.2.0-p6"
++#define MPFR_VERSION_STRING "4.2.0-p7"
+
+ /* User macros:
+ MPFR_USE_FILE: Define it to make MPFR define functions dealing
+diff -Naurd mpfr-4.2.0-a/src/pow.c mpfr-4.2.0-b/src/pow.c
+--- mpfr-4.2.0-a/src/pow.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/src/pow.c 2023-05-12 15:08:39.309546630 +0000
+@@ -131,7 +131,6 @@
+ /* 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_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_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 @@
+ */
+ 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 -Naurd mpfr-4.2.0-a/src/version.c mpfr-4.2.0-b/src/version.c
+--- mpfr-4.2.0-a/src/version.c 2023-05-12 15:06:11.885721962 +0000
++++ mpfr-4.2.0-b/src/version.c 2023-05-12 15:08:39.325546612 +0000
+@@ -25,5 +25,5 @@
+ const char *
+ mpfr_get_version (void)
+ {
+- return "4.2.0-p6";
++ return "4.2.0-p7";
+ }
+diff -Naurd mpfr-4.2.0-a/tests/texp10.c mpfr-4.2.0-b/tests/texp10.c
+--- mpfr-4.2.0-a/tests/texp10.c 2023-01-05 17:09:48.000000000 +0000
++++ mpfr-4.2.0-b/tests/texp10.c 2023-05-12 15:08:39.309546630 +0000
+@@ -190,6 +190,187 @@
+ 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 @@
+
+ tests_start_mpfr ();
+
++ bug20230213 ();
++ bug20230427 ();
++
+ special_overflow ();
+ emax_m_eps ();
+ exp_range ();
generated by cgit v1.2.3 (git 2.26.2) at 2024-05-09 19:15:42 +0000