/* With MPFR 2.3.0, this yields an assertion failure in mpfr_acosh. */
static void
bug20070831 (void)
{
mpfr_t x, y, z;
int inex;
mpfr_init2 (x, 256);
mpfr_init2 (y, 32);
mpfr_init2 (z, 32);
mpfr_set_ui (x, 1, GMP_RNDN);
mpfr_nextabove (x);
inex = mpfr_acosh (y, x, GMP_RNDZ);
mpfr_set_ui_2exp (z, 1, -127, GMP_RNDN);
mpfr_nextbelow (z);
if (!mpfr_equal_p (y, z))
{
printf ("Error in bug20070831 (1):\nexpected ");
mpfr_dump (z);
printf ("got ");
mpfr_dump (y);
exit (1);
}
MPFR_ASSERTN (inex < 0);
mpfr_nextabove (x);
mpfr_set_prec (y, 29);
inex = mpfr_acosh (y, x, GMP_RNDN);
mpfr_set_str_binary (z, "1.011010100000100111100110011E-127");
if (!mpfr_equal_p (y, z))
{
printf ("Error in bug20070831 (2):\nexpected ");
mpfr_dump (z);
printf ("got ");
mpfr_dump (y);
exit (1);
}
MPFR_ASSERTN (inex < 0);
mpfr_clears (x, y, z, (mpfr_ptr) 0);
}
/* Bug reported by Laurent Fousse for the 2.4 branch.
No problem in the trunk.
https://sympa.inria.fr/sympa/arc/mpfr/2009-11/msg00044.html */
static void
bug20091122 (void)
{
mpfr_t x, y, z, yref, zref;
mpfr_prec_t p = 3;
mpfr_rnd_t r = MPFR_RNDN;
mpfr_init2 (x, 5);
mpfr_init2 (y, p);
mpfr_init2 (z, p);
mpfr_init2 (yref, p);
mpfr_init2 (zref, p);
mpfr_set_str (x, "0.11111E49", 2, MPFR_RNDN);
mpfr_sin_cos (yref, zref, x, r);
mpfr_sin (y, x, r);
mpfr_cos (z, x, r);
if (! mpfr_equal_p (y, yref))
{
printf ("mpfr_sin_cos and mpfr_sin disagree (bug20091122)\n");
printf ("yref = "); mpfr_dump (yref);
printf ("y = "); mpfr_dump (y);
exit (1);
}
if (! mpfr_equal_p (z, zref))
{
printf ("mpfr_sin_cos and mpfr_cos disagree (bug20091122)\n");
printf ("zref = "); mpfr_dump (zref);
printf ("z = "); mpfr_dump (z);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (yref);
mpfr_clear (zref);
}
static void
check_overflow (void)
{
mpfr_t sum1, sum2, x, y;
mpfr_ptr t[2 * NOVFL];
mpfr_exp_t emin, emax;
int i, r;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
mpfr_inits2 (32, sum1, sum2, x, y, (mpfr_ptr) 0);
mpfr_setmax (x, mpfr_get_emax ());
mpfr_neg (y, x, MPFR_RNDN);
for (i = 0; i < 2 * NOVFL; i++)
t[i] = i < NOVFL ? x : y;
/* Two kinds of test:
* i = 1: overflow.
* i = 2: intermediate overflow (exact sum is 0).
*/
for (i = 1; i <= 2; i++)
RND_LOOP(r)
{
int inex1, inex2;
inex1 = mpfr_add (sum1, x, i == 1 ? x : y, (mpfr_rnd_t) r);
inex2 = mpfr_sum (sum2, t, i * NOVFL, (mpfr_rnd_t) r);
MPFR_ASSERTN (mpfr_check (sum1));
MPFR_ASSERTN (mpfr_check (sum2));
if (!(mpfr_equal_p (sum1, sum2) && SAME_SIGN (inex1, inex2)))
{
printf ("Error in check_overflow on %s, i = %d\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r), i);
printf ("Expected ");
mpfr_dump (sum1);
printf ("with inex = %d\n", inex1);
printf ("Got ");
mpfr_dump (sum2);
printf ("with inex = %d\n", inex2);
exit (1);
}
}
mpfr_clears (sum1, sum2, x, y, (mpfr_ptr) 0);
set_emin (emin);
set_emax (emax);
}
static void
check (mpfr_t r0, mpfr_t x, mpfr_t y, mpfr_rnd_t rnd)
{
int inex0, inex1;
mpfr_t r1;
mpfr_init2 (r1, mpfr_get_prec (r0));
inex0 = mpfr_fmod (r0, x, y, rnd);
inex1 = slow_fmod (r1, x, y, rnd);
if (!mpfr_equal_p (r0, r1) || inex0 != inex1)
test_failed (r1, r0, inex1, inex0, x, y, rnd);
mpfr_clear (r1);
}
/* Arguments:
* spx: non-zero if px is a stringm zero if px is a MPFR number.
* px: value of x (string or MPFR number).
* sy: value of y (string).
* rnd: rounding mode.
* z1: expected result (null pointer if unknown pure FP value).
* inex1: expected ternary value (if z1 is not a null pointer).
* z2: computed result.
* inex2: computed ternary value.
* flags1: expected flags (computed flags in __gmpfr_flags).
* s1, s2: strings about the context.
*/
static void
cmpres (int spx, const void *px, const char *sy, mpfr_rnd_t rnd,
mpfr_srcptr z1, int inex1, mpfr_srcptr z2, int inex2,
unsigned int flags1, const char *s1, const char *s2)
{
unsigned int flags2 = __gmpfr_flags;
if (flags1 == flags2)
{
/* Note: the test on the sign of z1 and z2 is needed
in case they are both zeros. */
if (z1 == NULL)
{
if (MPFR_IS_PURE_FP (z2))
return;
}
else if (SAME_SIGN (inex1, inex2) &&
((MPFR_IS_NAN (z1) && MPFR_IS_NAN (z2)) ||
((MPFR_IS_NEG (z1) ^ MPFR_IS_NEG (z2)) == 0 &&
mpfr_equal_p (z1, z2))))
return;
}
printf ("Error in %s\nwith %s%s\nx = ", s1, s2,
ext ? ", extended exponent range" : "");
if (spx)
printf ("%s, ", (char *) px);
else
{
mpfr_out_str (stdout, 16, 0, (mpfr_ptr) px, MPFR_RNDN);
puts (",");
}
printf ("y = %s, %s\n", sy, mpfr_print_rnd_mode (rnd));
printf ("Expected ");
if (z1 == NULL)
{
printf ("pure FP value, flags = %u\n", flags1);
}
else
{
mpfr_out_str (stdout, 16, 0, z1, MPFR_RNDN);
printf (", inex = %d, flags = %u\n", SIGN (inex1), flags1);
}
printf ("Got ");
mpfr_out_str (stdout, 16, 0, z2, MPFR_RNDN);
printf (", inex = %d, flags = %u\n", SIGN (inex2), flags2);
if (all_cmpres_errors != 0)
all_cmpres_errors = -1;
else
exit (1);
}
static void
bug20120829 (void)
{
mpfr_t x1, x2, e;
int inex1, inex2, i, r;
char s[48] = "1e-1";
mpfr_init2 (e, 128);
mpfr_inits2 (4, x1, x2, (mpfr_ptr) 0);
inex1 = mpfr_set_si (e, -1, MPFR_RNDN);
MPFR_ASSERTN (inex1 == 0);
for (i = 1; i <= sizeof(s) - 5; i++)
{
s[3+i] = '0';
s[4+i] = 0;
inex1 = mpfr_mul_ui (e, e, 10, MPFR_RNDN);
MPFR_ASSERTN (inex1 == 0);
RND_LOOP(r)
{
mpfr_rnd_t rnd = (mpfr_rnd_t) r;
inex1 = mpfr_exp10 (x1, e, rnd);
inex1 = SIGN (inex1);
inex2 = mpfr_strtofr (x2, s, NULL, 0, rnd);
inex2 = SIGN (inex2);
/* On 32-bit machines, for i = 7, r8389, r8391 and r8394 do:
strtofr.c:...: MPFR assertion failed: cy == 0
r8396 is OK.
On 64-bit machines, for i = 15,
r8389 does: strtofr.c:678: MPFR assertion failed: err < (64 - 0)
r8391 does: strtofr.c:680: MPFR assertion failed: h < ysize
r8394 and r8396 are OK.
*/
if (! mpfr_equal_p (x1, x2) || inex1 != inex2)
{
printf ("Error in bug20120829 for i = %d, rnd = %s\n",
i, mpfr_print_rnd_mode (rnd));
printf ("Expected inex = %d, x = ", inex1);
mpfr_dump (x1);
printf ("Got inex = %d, x = ", inex2);
mpfr_dump (x2);
exit (1);
}
}
}
mpfr_clears (e, x1, x2, (mpfr_ptr) 0);
}
/* Occurs in branches/new-sum/src/sum.c@9344 on a 64-bit machine. */
static void
bug20150327 (void)
{
mpfr_t sum1, sum2, t[3];
mpfr_ptr p[3];
char *s[3] = { "0.10000111110101000010101011100001", "1E-100", "0.1E95" };
int i, r;
mpfr_inits2 (58, sum1, sum2, (mpfr_ptr) 0);
for (i = 0; i < 3; i++)
{
mpfr_init2 (t[i], 64);
mpfr_set_str (t[i], s[i], 2, MPFR_RNDN);
p[i] = t[i];
}
RND_LOOP(r)
{
int inex1, inex2;
mpfr_set (sum1, t[2], MPFR_RNDN);
inex1 = -1;
if (MPFR_IS_LIKE_RNDU ((mpfr_rnd_t) r, 1))
{
mpfr_nextabove (sum1);
inex1 = 1;
}
inex2 = mpfr_sum (sum2, p, 3, (mpfr_rnd_t) r);
if (!(mpfr_equal_p (sum1, sum2) && SAME_SIGN (inex1, inex2)))
{
printf ("mpfr_sum incorrect in bug20150327 for %s:\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r));
printf ("Expected ");
mpfr_dump (sum1);
printf ("with inex = %d\n", inex1);
printf ("Got ");
mpfr_dump (sum2);
printf ("with inex = %d\n", inex2);
exit (1);
}
}
for (i = 0; i < 3; i++)
mpfr_clear (t[i]);
mpfr_clears (sum1, sum2, (mpfr_ptr) 0);
}
/* bug reported by Eric Veach */
static void
bug20090519 (void)
{
mpfr_t x, y, r;
int inexact;
mpfr_inits2 (100, x, y, r, (mpfr_ptr) 0);
mpfr_set_prec (x, 3);
mpfr_set_prec (y, 3);
mpfr_set_prec (r, 3);
mpfr_set_si (x, 8, MPFR_RNDN);
mpfr_set_si (y, 7, MPFR_RNDN);
check (r, x, y, MPFR_RNDN);
mpfr_set_prec (x, 10);
mpfr_set_prec (y, 10);
mpfr_set_prec (r, 10);
mpfr_set_ui_2exp (x, 3, 26, MPFR_RNDN);
mpfr_set_si (y, (1 << 9) - 1, MPFR_RNDN);
check (r, x, y, MPFR_RNDN);
mpfr_set_prec (x, 100);
mpfr_set_prec (y, 100);
mpfr_set_prec (r, 100);
mpfr_set_str (x, "3.5", 10, MPFR_RNDN);
mpfr_set_str (y, "1.1", 10, MPFR_RNDN);
check (r, x, y, MPFR_RNDN);
/* double check, with a pre-computed value */
{
mpfr_t er;
mpfr_init2 (er, 100);
mpfr_set_str (er, "CCCCCCCCCCCCCCCCCCCCCCCC8p-102", 16, MPFR_RNDN);
inexact = mpfr_fmod (r, x, y, MPFR_RNDN);
if (!mpfr_equal_p (r, er) || inexact != 0)
test_failed (er, r, 0, inexact, x, y, MPFR_RNDN);
mpfr_clear (er);
}
mpfr_set_si (x, 20, MPFR_RNDN);
mpfr_set_ui_2exp (y, 1, 1, MPFR_RNDN); /* exact */
mpfr_sin (y, y, MPFR_RNDN);
check (r, x, y, MPFR_RNDN);
mpfr_clears(r, x, y, (mpfr_ptr) 0);
}
int main(void)
{
long k;
flint_rand_t state;
printf("zeta_ui_bsplit....");
fflush(stdout);
flint_randinit(state);
for (k = 0; k < 100; k++)
{
long prec, n;
mpfr_t x, y;
n = 2 + n_randint(state, 20);
prec = 2 + n_randint(state, 10000);
mpfr_init2(x, prec);
mpfr_init2(y, prec);
mpfr_zeta_ui(x, n, MPFR_RNDN);
mpfr_zeta_ui_bsplit(y, n, MPFR_RNDN);
if (!mpfr_equal_p(x, y))
{
printf("FAIL:\n");
printf("Wrong value at n = %ld, prec = %ld\n", n, prec);
printf("x:\n");
mpfr_out_str(stdout, 10, 0, x, MPFR_RNDN);
printf("\n");
printf("x:\n");
mpfr_out_str(stdout, 10, 0, y, MPFR_RNDN);
printf("\n");
abort();
}
mpfr_clear(x);
mpfr_clear(y);
}
flint_randclear(state);
mpfr_free_cache();
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
/**
* rasqal_xsd_decimal_equals:
* @a: first XSD Decimal
* @b: second XSD Decimal
*
* Compare two XSD Decimals for equality.
*
* Return value: non-0 if equal.
**/
int
rasqal_xsd_decimal_equals(rasqal_xsd_decimal* a, rasqal_xsd_decimal* b)
{
int rc;
#if defined(RASQAL_DECIMAL_C99) || defined(RASQAL_DECIMAL_NONE)
rc= (b->raw == a->raw);
#elif defined(RASQAL_DECIMAL_MPFR)
rc = mpfr_equal_p(a->raw, b->raw);
#elif defined(RASQAL_DECIMAL_GMP)
/* NOTE: Not using mpf_eq() but could do, with sufficient bits */
rc=!mpf_cmp(a->raw, b->raw);
#else
#error RASQAL_DECIMAL flagging error
#endif
return rc;
}
static void
check_equal (mpfr_srcptr a, mpfr_srcptr a2, char *s,
mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t r)
{
if ((MPFR_IS_NAN (a) && MPFR_IS_NAN (a2)) ||
mpfr_equal_p (a, a2))
return;
printf ("Error in %s\n", mpfr_print_rnd_mode (r));
printf ("b = ");
mpfr_dump (b);
printf ("c = ");
mpfr_dump (c);
printf ("mpfr_div result: ");
mpfr_dump (a);
printf ("%s result: ", s);
mpfr_dump (a2);
exit (1);
}
/* https://sympa.inria.fr/sympa/arc/mpfr/2011-05/msg00008.html
* Incorrect flags (in debug mode on a 32-bit machine, assertion failure).
*/
static void
reduced_expo_range (void)
{
mpfr_exp_t emin, emax;
mpfr_t x, y, ex_y;
int inex, ex_inex;
unsigned int flags, ex_flags;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
mpfr_inits2 (12, x, y, ex_y, (mpfr_ptr) 0);
mpfr_set_str (x, "0.1e-5", 2, MPFR_RNDN);
set_emin (-5);
set_emax (-5);
mpfr_clear_flags ();
inex = mpfr_atan (y, x, MPFR_RNDN);
flags = __gmpfr_flags;
set_emin (emin);
set_emax (emax);
mpfr_set_str (ex_y, "0.1e-5", 2, MPFR_RNDN);
ex_inex = 1;
ex_flags = MPFR_FLAGS_INEXACT;
if (SIGN (inex) != ex_inex || flags != ex_flags ||
! mpfr_equal_p (y, ex_y))
{
printf ("Error in reduced_expo_range\non x = ");
mpfr_dump (x);
printf ("Expected y = ");
mpfr_out_str (stdout, 2, 0, ex_y, MPFR_RNDN);
printf ("\n inex = %d, flags = %u\n", ex_inex, ex_flags);
printf ("Got y = ");
mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
printf ("\n inex = %d, flags = %u\n", SIGN (inex), flags);
exit (1);
}
mpfr_clears (x, y, ex_y, (mpfr_ptr) 0);
}
static void
tiny (void)
{
mpfr_t x, s, c;
int i, inex;
mpfr_inits2 (64, x, s, c, (mpfr_ptr) 0);
for (i = -1; i <= 1; i += 2)
{
mpfr_set_si (x, i, MPFR_RNDN);
mpfr_set_exp (x, mpfr_get_emin ());
inex = mpfr_sin_cos (s, c, x, MPFR_RNDN);
MPFR_ASSERTN (inex != 0);
MPFR_ASSERTN (mpfr_equal_p (s, x));
MPFR_ASSERTN (!mpfr_nan_p (c) && mpfr_cmp_ui (c, 1) == 0);
}
mpfr_clears (x, s, c, (mpfr_ptr) 0);
}
void
ovm_q_eq(oregister_t *l, oregister_t *r)
{
l->t = t_word;
switch (r->t) {
case t_float:
l->v.w = mpq_get_d(oqr(l)) == r->v.d;
break;
case t_mpq:
l->v.w = mpq_cmp(oqr(l), oqr(r)) == 0;
break;
case t_mpr:
mpfr_set_q(orr(l), oqr(l), thr_rnd);
l->v.w = mpfr_equal_p(orr(l), orr(r));
break;
default:
l->v.w = 0;
break;
}
}
static void
atan2_pow_of_2 (void)
{
mpfr_t x, y, r, g;
int i;
int d[] = { 0, -1, 1 };
int ntests = numberof (d);
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
mpfr_init2 (r, 53);
mpfr_init2 (g, 53);
/* atan(42) */
mpfr_set_str_binary (g, "1100011000000011110011111001100110101000011010010011E-51");
for (i = 0; i < ntests; ++i)
{
mpfr_set_ui (y, 42, MPFR_RNDN);
mpfr_mul_2si (y, y, d[i], MPFR_RNDN);
mpfr_set_ui_2exp (x, 1, d[i], MPFR_RNDN);
mpfr_atan2 (r, y, x, MPFR_RNDN);
if (mpfr_equal_p (r, g) == 0)
{
printf ("Error in mpfr_atan2 (5)\n");
printf ("Expected ");
mpfr_print_binary (g);
printf ("\n");
printf ("Got ");
mpfr_print_binary (r);
printf ("\n");
exit (1);
}
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (r);
mpfr_clear (g);
}
/* TODO: A test with more inputs (but can't be compared to mpfr_add). */
static void
check_extreme (void)
{
mpfr_t u, v, w, x, y;
mpfr_ptr t[2];
int i, inex1, inex2, r;
t[0] = u;
t[1] = v;
mpfr_inits2 (32, u, v, w, x, y, (mpfr_ptr) 0);
mpfr_setmin (u, mpfr_get_emax ());
mpfr_setmax (v, mpfr_get_emin ());
mpfr_setmin (w, mpfr_get_emax () - 40);
RND_LOOP (r)
for (i = 0; i < 2; i++)
{
mpfr_set_prec (x, 64);
inex1 = mpfr_add (x, u, w, MPFR_RNDN);
MPFR_ASSERTN (inex1 == 0);
inex1 = mpfr_prec_round (x, 32, (mpfr_rnd_t) r);
inex2 = mpfr_sum (y, t, 2, (mpfr_rnd_t) r);
if (!(mpfr_equal_p (x, y) && SAME_SIGN (inex1, inex2)))
{
printf ("Error in check_extreme (%s, i = %d)\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r), i);
printf ("Expected ");
mpfr_dump (x);
printf ("with inex = %d\n", inex1);
printf ("Got ");
mpfr_dump (y);
printf ("with inex = %d\n", inex2);
exit (1);
}
mpfr_neg (v, v, MPFR_RNDN);
mpfr_neg (w, w, MPFR_RNDN);
}
mpfr_clears (u, v, w, x, y, (mpfr_ptr) 0);
}
static void
huge (void)
{
mpfr_t x, y, z;
int inex;
/* TODO: extend the exponent range and use mpfr_get_emax (). */
mpfr_inits2 (32, x, y, z, (mpfr_ptr) 0);
mpfr_set_ui_2exp (x, 1, 1073741822, GMP_RNDN);
inex = mpfr_acosh (y, x, GMP_RNDN);
mpfr_set_str_binary (z, "0.10110001011100100001011111110101E30");
if (!mpfr_equal_p (y, z))
{
printf ("Error in huge:\nexpected ");
mpfr_dump (z);
printf ("got ");
mpfr_dump (y);
exit (1);
}
MPFR_ASSERTN (inex < 0);
mpfr_clears (x, y, z, (mpfr_ptr) 0);
}
static void
check_zero (void)
{
mpfr_t x, y, r;
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
mpfr_init2 (r, 53);
mpfr_set_str_binary (r, "10110101110001100011110010110001001110001010110111E-51");
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_ai (y, x, MPFR_RNDN);
if (mpfr_equal_p (y, r) == 0)
{
printf ("Error in mpfr_ai for x=0\n");
printf ("Expected "); mpfr_dump (r);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (r);
}
static void
test_underflow1 (void)
{
mpfr_t x, y, z, r;
int inex, signy, signz, rnd, err = 0;
mpfr_inits2 (8, x, y, z, r, (void *) 0);
MPFR_SET_POS (x);
mpfr_setmin (x, mpfr_get_emin ()); /* x = 0.1@emin */
for (signy = -1; signy <= 1; signy += 2)
{
mpfr_set_si_2exp (y, signy, -1, GMP_RNDN); /* |y| = 1/2 */
for (signz = -3; signz <= 3; signz += 2)
{
RND_LOOP (rnd)
{
mpfr_set_si (z, signz, GMP_RNDN);
if (ABS (signz) != 1)
mpfr_setmax (z, mpfr_get_emax ());
/* |z| = 1 or 2^emax - ulp */
mpfr_clear_flags ();
inex = mpfr_fma (r, x, y, z, rnd);
#define ERRTU1 "Error in test_underflow1 (signy = %d, signz = %d, %s)\n "
if (mpfr_nanflag_p ())
{
printf (ERRTU1 "NaN flag is set\n", signy, signz,
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (signy < 0 && (rnd == GMP_RNDD ||
(rnd == GMP_RNDZ && signz > 0)))
mpfr_nextbelow (z);
if (signy > 0 && (rnd == GMP_RNDU ||
(rnd == GMP_RNDZ && signz < 0)))
mpfr_nextabove (z);
if ((mpfr_overflow_p () != 0) ^ (mpfr_inf_p (z) != 0))
{
printf (ERRTU1 "wrong overflow flag\n", signy, signz,
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (mpfr_underflow_p ())
{
printf (ERRTU1 "underflow flag is set\n", signy, signz,
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (! mpfr_equal_p (r, z))
{
printf (ERRTU1 "got ", signy, signz,
mpfr_print_rnd_mode (rnd));
mpfr_print_binary (r);
printf (" instead of ");
mpfr_print_binary (z);
printf ("\n");
err = 1;
}
if (inex >= 0 && (rnd == GMP_RNDD ||
(rnd == GMP_RNDZ && signz > 0) ||
(rnd == GMP_RNDN && signy > 0)))
{
printf (ERRTU1 "ternary value = %d instead of < 0\n",
signy, signz, mpfr_print_rnd_mode (rnd), inex);
err = 1;
}
if (inex <= 0 && (rnd == GMP_RNDU ||
(rnd == GMP_RNDZ && signz < 0) ||
(rnd == GMP_RNDN && signy < 0)))
{
printf (ERRTU1 "ternary value = %d instead of > 0\n",
signy, signz, mpfr_print_rnd_mode (rnd), inex);
err = 1;
}
}
}
}
if (err)
exit (1);
mpfr_clears (x, y, z, r, (void *) 0);
}
static void
underflowed_cothinf (void)
{
mpfr_t x, y;
int i, inex, rnd, err = 0;
mpfr_exp_t old_emin;
old_emin = mpfr_get_emin ();
mpfr_init2 (x, 8);
mpfr_init2 (y, 8);
for (i = -1; i <= 1; i += 2)
RND_LOOP (rnd)
{
mpfr_set_inf (x, i);
mpfr_clear_flags ();
set_emin (2); /* 1 is not representable. */
inex = mpfr_coth (x, x, (mpfr_rnd_t) rnd);
set_emin (old_emin);
if (! mpfr_underflow_p ())
{
printf ("Error in underflowed_cothinf (i = %d, rnd = %s):\n"
" The underflow flag is not set.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
mpfr_set_si (y, (i < 0 && (rnd == MPFR_RNDD || rnd == MPFR_RNDA)) ||
(i > 0 && (rnd == MPFR_RNDU || rnd == MPFR_RNDA))
? 2 : 0, MPFR_RNDN);
if (i < 0)
mpfr_neg (y, y, MPFR_RNDN);
if (! (mpfr_equal_p (x, y) &&
MPFR_MULT_SIGN (MPFR_SIGN (x), MPFR_SIGN (y)) > 0))
{
printf ("Error in underflowed_cothinf (i = %d, rnd = %s):\n"
" Got ", i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpfr_print_binary (x);
printf (" instead of ");
mpfr_print_binary (y);
printf (".\n");
err = 1;
}
if ((rnd == MPFR_RNDD ||
(i > 0 && (rnd == MPFR_RNDN || rnd == MPFR_RNDZ))) && inex >= 0)
{
printf ("Error in underflowed_cothinf (i = %d, rnd = %s):\n"
" The inexact value must be negative.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if ((rnd == MPFR_RNDU ||
(i < 0 && (rnd == MPFR_RNDN || rnd == MPFR_RNDZ))) && inex <= 0)
{
printf ("Error in underflowed_cothinf (i = %d, rnd = %s):\n"
" The inexact value must be positive.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
}
if (err)
exit (1);
mpfr_clear (x);
mpfr_clear (y);
}
static void
overflowed_fac0 (void)
{
mpfr_t x, y;
int inex, rnd, err = 0;
mp_exp_t old_emax;
old_emax = mpfr_get_emax ();
mpfr_init2 (x, 8);
mpfr_init2 (y, 8);
mpfr_set_ui (y, 1, GMP_RNDN);
mpfr_nextbelow (y);
set_emax (0); /* 1 is not representable. */
RND_LOOP (rnd)
{
mpfr_clear_flags ();
inex = mpfr_fac_ui (x, 0, rnd);
if (! mpfr_overflow_p ())
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" The overflow flag is not set.\n",
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (rnd == GMP_RNDZ || rnd == GMP_RNDD)
{
if (inex >= 0)
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" The inexact value must be negative.\n",
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (! mpfr_equal_p (x, y))
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" Got ", mpfr_print_rnd_mode (rnd));
mpfr_print_binary (x);
printf (" instead of 0.11111111E0.\n");
err = 1;
}
}
else
{
if (inex <= 0)
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" The inexact value must be positive.\n",
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (! (mpfr_inf_p (x) && MPFR_SIGN (x) > 0))
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" Got ", mpfr_print_rnd_mode (rnd));
mpfr_print_binary (x);
printf (" instead of +Inf.\n");
err = 1;
}
}
}
set_emax (old_emax);
if (err)
exit (1);
mpfr_clear (x);
mpfr_clear (y);
}
static void
special (void)
{
mpfr_t x, y;
int inex;
int sign;
mpfr_init (x);
mpfr_init (y);
mpfr_set_nan (x);
mpfr_lgamma (y, &sign, x, GMP_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error for lgamma(NaN)\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_lgamma (y, &sign, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for lgamma(-Inf)\n");
exit (1);
}
mpfr_set_inf (x, 1);
sign = -17;
mpfr_lgamma (y, &sign, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0 || sign != 1)
{
printf ("Error for lgamma(+Inf)\n");
exit (1);
}
mpfr_set_ui (x, 0, GMP_RNDN);
sign = -17;
mpfr_lgamma (y, &sign, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0 || sign != 1)
{
printf ("Error for lgamma(+0)\n");
exit (1);
}
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_neg (x, x, GMP_RNDN);
sign = -17;
mpfr_lgamma (y, &sign, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0 || sign != -1)
{
printf ("Error for lgamma(-0)\n");
exit (1);
}
mpfr_set_ui (x, 1, GMP_RNDN);
sign = -17;
mpfr_lgamma (y, &sign, x, GMP_RNDN);
if (MPFR_IS_NAN (y) || mpfr_cmp_ui (y, 0) || MPFR_IS_NEG (y) || sign != 1)
{
printf ("Error for lgamma(1)\n");
exit (1);
}
mpfr_set_si (x, -1, GMP_RNDN);
mpfr_lgamma (y, &sign, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for lgamma(-1)\n");
exit (1);
}
mpfr_set_ui (x, 2, GMP_RNDN);
sign = -17;
mpfr_lgamma (y, &sign, x, GMP_RNDN);
if (MPFR_IS_NAN (y) || mpfr_cmp_ui (y, 0) || MPFR_IS_NEG (y) || sign != 1)
{
printf ("Error for lgamma(2)\n");
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
#define CHECK_X1 "1.0762904832837976166"
#define CHECK_Y1 "-0.039418362817587634939"
mpfr_set_str (x, CHECK_X1, 10, GMP_RNDN);
sign = -17;
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_str (x, CHECK_Y1, 10, GMP_RNDN);
if (mpfr_equal_p (y, x) == 0 || sign != 1)
{
printf ("mpfr_lgamma("CHECK_X1") is wrong:\n"
"expected ");
mpfr_print_binary (x); putchar ('\n');
printf ("got ");
mpfr_print_binary (y); putchar ('\n');
exit (1);
}
#define CHECK_X2 "9.23709516716202383435e-01"
#define CHECK_Y2 "0.049010669407893718563"
mpfr_set_str (x, CHECK_X2, 10, GMP_RNDN);
sign = -17;
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_str (x, CHECK_Y2, 10, GMP_RNDN);
if (mpfr_equal_p (y, x) == 0 || sign != 1)
{
printf ("mpfr_lgamma("CHECK_X2") is wrong:\n"
"expected ");
mpfr_print_binary (x); putchar ('\n');
printf ("got ");
mpfr_print_binary (y); putchar ('\n');
exit (1);
}
mpfr_set_prec (x, 8);
mpfr_set_prec (y, 175);
mpfr_set_ui (x, 33, GMP_RNDN);
sign = -17;
mpfr_lgamma (y, &sign, x, GMP_RNDU);
mpfr_set_prec (x, 175);
mpfr_set_str_binary (x, "0.1010001100011101101011001101110010100001000001000001110011000001101100001111001001000101011011100100010101011110100111110101010100010011010010000101010111001100011000101111E7");
if (mpfr_equal_p (x, y) == 0 || sign != 1)
{
printf ("Error in mpfr_lgamma (1)\n");
exit (1);
}
mpfr_set_prec (x, 21);
mpfr_set_prec (y, 8);
mpfr_set_ui (y, 120, GMP_RNDN);
sign = -17;
mpfr_lgamma (x, &sign, y, GMP_RNDZ);
mpfr_set_prec (y, 21);
mpfr_set_str_binary (y, "0.111000101000001100101E9");
if (mpfr_equal_p (x, y) == 0 || sign != 1)
{
printf ("Error in mpfr_lgamma (120)\n");
printf ("Expected "); mpfr_print_binary (y); puts ("");
printf ("Got "); mpfr_print_binary (x); puts ("");
exit (1);
}
mpfr_set_prec (x, 3);
mpfr_set_prec (y, 206);
mpfr_set_str_binary (x, "0.110e10");
sign = -17;
inex = mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_prec (x, 206);
mpfr_set_str_binary (x, "0.10000111011000000011100010101001100110001110000111100011000100100110110010001011011110101001111011110110000001010100111011010000000011100110110101100111000111010011110010000100010111101010001101000110101001E13");
if (mpfr_equal_p (x, y) == 0 || sign != 1)
{
printf ("Error in mpfr_lgamma (768)\n");
exit (1);
}
if (inex >= 0)
{
printf ("Wrong flag for mpfr_lgamma (768)\n");
exit (1);
}
mpfr_set_prec (x, 4);
mpfr_set_prec (y, 4);
mpfr_set_str_binary (x, "0.1100E-66");
sign = -17;
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_str_binary (x, "0.1100E6");
if (mpfr_equal_p (x, y) == 0 || sign != 1)
{
printf ("Error for lgamma(0.1100E-66)\n");
printf ("Expected ");
mpfr_dump (x);
printf ("Got ");
mpfr_dump (y);
exit (1);
}
mpfr_set_prec (x, 256);
mpfr_set_prec (y, 32);
mpfr_set_si_2exp (x, -1, 200, GMP_RNDN);
mpfr_add_ui (x, x, 1, GMP_RNDN);
mpfr_div_2ui (x, x, 1, GMP_RNDN);
sign = -17;
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_prec (x, 32);
mpfr_set_str_binary (x, "-0.10001000111011111011000010100010E207");
if (mpfr_equal_p (x, y) == 0 || sign != 1)
{
printf ("Error for lgamma(-2^199+0.5)\n");
printf ("Got ");
mpfr_dump (y);
printf ("instead of ");
mpfr_dump (x);
exit (1);
}
mpfr_set_prec (x, 256);
mpfr_set_prec (y, 32);
mpfr_set_si_2exp (x, -1, 200, GMP_RNDN);
mpfr_sub_ui (x, x, 1, GMP_RNDN);
mpfr_div_2ui (x, x, 1, GMP_RNDN);
sign = -17;
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_prec (x, 32);
mpfr_set_str_binary (x, "-0.10001000111011111011000010100010E207");
if (mpfr_equal_p (x, y) == 0 || sign != -1)
{
printf ("Error for lgamma(-2^199-0.5)\n");
printf ("Got ");
mpfr_dump (y);
printf ("with sign %d instead of ", sign);
mpfr_dump (x);
printf ("with sign -1.\n");
exit (1);
}
mpfr_set_prec (x, 10);
mpfr_set_prec (y, 10);
mpfr_set_str_binary (x, "-0.1101111000E-3");
inex = mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_str_binary (x, "10.01001011");
if (mpfr_equal_p (x, y) == 0 || sign != -1 || inex >= 0)
{
printf ("Error for lgamma(-0.1101111000E-3)\n");
printf ("Got ");
mpfr_dump (y);
printf ("instead of ");
mpfr_dump (x);
printf ("with sign %d instead of -1 (inex=%d).\n", sign, inex);
exit (1);
}
mpfr_set_prec (x, 18);
mpfr_set_prec (y, 28);
mpfr_set_str_binary (x, "-1.10001101010001101e-196");
inex = mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_prec (x, 28);
mpfr_set_str_binary (x, "0.100001110110101011011010011E8");
MPFR_ASSERTN (mpfr_equal_p (x, y) && inex < 0);
/* values reported by Kaveh Ghazi on 14 Jul 2007, where mpfr_lgamma()
takes forever */
#define VAL1 "-0.11100001001010110111001010001001001011110100110000110E-55"
#define OUT1 "100110.01000000010111001110110101110101001001100110111"
#define VAL2 "-0.11100001001010110111001010001001001011110011111111100E-55"
#define OUT2 "100110.0100000001011100111011010111010100100110011111"
#define VAL3 "-0.11100001001010110111001010001001001001110101101010100E-55"
#define OUT3 "100110.01000000010111001110110101110101001011110111011"
#define VAL4 "-0.10001111110110110100100100000000001111110001001001011E-57"
#define OUT4 "101000.0001010111110011101101000101111111010001100011"
#define VAL5 "-0.10001111110110110100100100000000001111011111100001000E-57"
#define OUT5 "101000.00010101111100111011010001011111110100111000001"
#define VAL6 "-0.10001111110110110100100100000000001111011101100011001E-57"
#define OUT6 "101000.0001010111110011101101000101111111010011101111"
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, VAL1);
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_str_binary (x, OUT1);
MPFR_ASSERTN(sign == -1 && mpfr_equal_p(x, y));
mpfr_set_str_binary (x, VAL2);
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_str_binary (x, OUT2);
MPFR_ASSERTN(sign == -1 && mpfr_equal_p (x, y));
mpfr_set_str_binary (x, VAL3);
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_str_binary (x, OUT3);
MPFR_ASSERTN(sign == -1 && mpfr_equal_p (x, y));
mpfr_set_str_binary (x, VAL4);
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_str_binary (x, OUT4);
MPFR_ASSERTN(sign == -1 && mpfr_equal_p (x, y));
mpfr_set_str_binary (x, VAL5);
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_str_binary (x, OUT5);
MPFR_ASSERTN(sign == -1 && mpfr_equal_p (x, y));
mpfr_set_str_binary (x, VAL6);
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_str_binary (x, OUT6);
MPFR_ASSERTN(sign == -1 && mpfr_equal_p (x, y));
/* further test from Kaveh Ghazi */
mpfr_set_str_binary (x, "-0.10011010101001010010001110010111010111011101010111001E-53");
mpfr_lgamma (y, &sign, x, GMP_RNDN);
mpfr_set_str_binary (x, "100101.00111101101010000000101010111010001111001101111");
MPFR_ASSERTN(sign == -1 && mpfr_equal_p (x, y));
mpfr_clear (x);
mpfr_clear (y);
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
int inex;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (y);
/* special values */
mpfr_set_nan (x);
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y));
mpfr_set_inf (x, -1); /* -Inf */
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y));
mpfr_set_ui (x, 0, MPFR_RNDN); /* +0 */
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 1) == 0); /* j0(+0)=1 */
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN); /* -0 */
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 1) == 0); /* j0(-0)=1 */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_j0 (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.1100001111100011111111101101111010111101110001111");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_j0 for x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_si (x, -1, MPFR_RNDN);
mpfr_j0 (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.1100001111100011111111101101111010111101110001111");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_j0 for x=-1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
/* Bug reported on 2007-07-03 by Sisyphus (assertion failed in r4619) */
mpfr_set_si (x, 70000, MPFR_RNDN);
mpfr_j0 (y, x, MPFR_RNDN);
/* Bug reported by Kevin Rauch on 27 Oct 2007 */
mpfr_set_prec (x, 7);
mpfr_set_prec (y, 7);
mpfr_set_si (x, -100, MPFR_RNDN);
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN (! mpfr_nan_p (y) && mpfr_cmp_ui_2exp (y, 41, -11) == 0);
/* Case for which s = 0 in mpfr_jn */
mpfr_set_prec (x, 44);
mpfr_set_prec (y, 44);
mpfr_set_si (x, 2, MPFR_RNDN);
mpfr_clear_flags ();
inex = mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_INEXACT);
mpfr_set_str (x, "0x.e5439fd9267p-2", 0, MPFR_RNDN);
if (! mpfr_equal_p (y, x))
{
printf ("Error on 2:\n");
printf ("Expected ");
mpfr_dump (x);
printf ("Got ");
mpfr_dump (y);
exit (1);
}
if (inex >= 0)
{
printf ("Bad ternary value on 2: expected negative, got %d\n", inex);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
test_generic (2, 100, 10);
data_check ("data/j0", mpfr_j0, "mpfr_j0");
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
int inex;
tests_start_mpfr ();
special_overflow ();
check_nans ();
mpfr_init (x);
mpfr_init (y);
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 2);
mpfr_set_str (x, "9.81333845856942e-1", 10, MPFR_RNDN);
test_cos (y, x, MPFR_RNDN);
mpfr_set_prec (x, 30);
mpfr_set_prec (y, 30);
mpfr_set_str_binary (x, "1.00001010001101110010100010101e-1");
test_cos (y, x, MPFR_RNDU);
mpfr_set_str_binary (x, "1.10111100010101011110101010100e-1");
if (mpfr_cmp (y, x))
{
printf ("Error for prec=30, rnd=MPFR_RNDU\n");
printf ("expected "); mpfr_print_binary (x); puts ("");
printf (" got "); mpfr_print_binary (y); puts ("");
exit (1);
}
mpfr_set_prec (x, 59);
mpfr_set_prec (y, 59);
mpfr_set_str_binary (x, "1.01101011101111010011111110111111111011011101100111100011e-3");
test_cos (y, x, MPFR_RNDU);
mpfr_set_str_binary (x, "1.1111011111110010001001001011100111101110100010000010010011e-1");
if (mpfr_cmp (y, x))
{
printf ("Error for prec=59, rnd=MPFR_RNDU\n");
printf ("expected "); mpfr_print_binary (x); puts ("");
printf (" got "); mpfr_print_binary (y); puts ("");
exit (1);
}
mpfr_set_prec (x, 5);
mpfr_set_prec (y, 5);
mpfr_set_str_binary (x, "1.1100e-2");
test_cos (y, x, MPFR_RNDD);
mpfr_set_str_binary (x, "1.1100e-1");
if (mpfr_cmp (y, x))
{
printf ("Error for x=1.1100e-2, rnd=MPFR_RNDD\n");
printf ("expected 1.1100e-1, got "); mpfr_print_binary (y); puts ("");
exit (1);
}
mpfr_set_prec (x, 32);
mpfr_set_prec (y, 32);
mpfr_set_str_binary (x, "0.10001000001001011000100001E-6");
mpfr_set_str_binary (y, "0.1111111111111101101111001100001");
test_cos (x, x, MPFR_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error for prec=32 (1)\n");
exit (1);
}
mpfr_set_str_binary (x, "-0.1101011110111100111010011001011E-1");
mpfr_set_str_binary (y, "0.11101001100110111011011010100011");
test_cos (x, x, MPFR_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error for prec=32 (2)\n");
exit (1);
}
/* huge argument reduction */
mpfr_set_str_binary (x, "0.10000010000001101011101111001011E40");
mpfr_set_str_binary (y, "0.10011000001111010000101011001011E-1");
test_cos (x, x, MPFR_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error for prec=32 (3)\n");
exit (1);
}
mpfr_set_prec (x, 3);
mpfr_set_prec (y, 3);
mpfr_set_str_binary (x, "0.110E60");
inex = mpfr_cos (y, x, MPFR_RNDD);
MPFR_ASSERTN(inex < 0);
/* worst case from PhD thesis of Vincent Lefe`vre: x=8980155785351021/2^54 */
check53 ("4.984987858808754279e-1", "8.783012931285841817e-1", MPFR_RNDN);
check53 ("4.984987858808754279e-1", "8.783012931285840707e-1", MPFR_RNDD);
check53 ("4.984987858808754279e-1", "8.783012931285840707e-1", MPFR_RNDZ);
check53 ("4.984987858808754279e-1", "8.783012931285841817e-1", MPFR_RNDU);
check53 ("1.00031274099908640274", "0.540039116973283217504", MPFR_RNDN);
check53 ("1.00229256850978698523", "0.538371757797526551137", MPFR_RNDZ);
check53 ("1.00288304857059840103", "0.537874062022526966409", MPFR_RNDZ);
check53 ("1.00591265847407274059", "0.53531755997839769456", MPFR_RNDN);
check53 ("1.00591265847407274059", "0.53531755997839769456", MPFR_RNDN);
overflowed_cos0 ();
test_generic (2, 100, 15);
/* check inexact flag */
mpfr_set_prec (x, 3);
mpfr_set_prec (y, 13);
mpfr_set_str_binary (x, "-0.100E196");
inex = mpfr_cos (y, x, MPFR_RNDU);
mpfr_set_prec (x, 13);
mpfr_set_str_binary (x, "0.1111111100101");
MPFR_ASSERTN (inex > 0 && mpfr_equal_p (x, y));
mpfr_clear (x);
mpfr_clear (y);
bug20091030 ();
data_check ("data/cos", mpfr_cos, "mpfr_cos");
bad_cases (mpfr_cos, mpfr_acos, "mpfr_cos", 256, -40, 0, 4, 128, 800, 50);
tests_end_mpfr ();
return 0;
}
bool operator !=(const real & a, const real & b)
{
return mpfr_equal_p(a.r, b.r) == 0;
}
static void
check4 (const char *as, const char *bs, mpfr_rnd_t rnd_mode,
const char *res, int inex)
{
mpfr_t ta, tb, tc, tres;
mpfr_exp_t emin, emax;
int i;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
mpfr_inits2 (53, ta, tb, tc, tres, (mpfr_ptr) 0);
for (i = 0; i <= 2; i++)
{
unsigned int expflags, newflags;
int inex2;
mpfr_set_str1 (ta, as);
mpfr_set_str1 (tb, bs);
mpfr_set_str1 (tc, res);
if (i > 0)
{
mpfr_exp_t ea, eb, ec, e0;
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
ea = mpfr_get_exp (ta);
eb = mpfr_get_exp (tb);
ec = mpfr_get_exp (tc);
e0 = i == 1 ? __gmpfr_emin : __gmpfr_emax;
if ((i == 1 && ea < eb) || (i == 2 && ea > eb))
{
mpfr_set_exp (ta, e0);
mpfr_set_exp (tb, e0 + (eb - ea));
mpfr_set_exp (tc, e0 + (ec - ea));
}
else
{
mpfr_set_exp (ta, e0 + (ea - eb));
mpfr_set_exp (tb, e0);
mpfr_set_exp (tc, e0 + (ec - eb));
}
}
__gmpfr_flags = expflags =
(randlimb () & 1) ? MPFR_FLAGS_ALL ^ MPFR_FLAGS_ERANGE : 0;
inex2 = mpfr_agm (tres, ta, tb, rnd_mode);
newflags = __gmpfr_flags;
expflags |= MPFR_FLAGS_INEXACT;
if (SIGN (inex2) != inex || newflags != expflags ||
! mpfr_equal_p (tres, tc))
{
printf ("mpfr_agm failed in rnd_mode=%s for\n",
mpfr_print_rnd_mode (rnd_mode));
printf (" a = ");
mpfr_out_str (stdout, 10, 0, ta, MPFR_RNDN);
printf ("\n");
printf (" b = ");
mpfr_out_str (stdout, 10, 0, tb, MPFR_RNDN);
printf ("\n");
printf ("expected inex = %d, flags = %u,\n"
" ", inex, expflags);
mpfr_dump (tc);
printf ("got inex = %d, flags = %u,\n"
" ", inex2, newflags);
mpfr_dump (tres);
exit (1);
}
set_emin (emin);
set_emax (emax);
}
mpfr_clears (ta, tb, tc, tres, (mpfr_ptr) 0);
}
int main()
{
slong i;
mpfr_t tabx, expx, y1, y2;
mpz_t tt;
flint_printf("exp_tab....");
fflush(stdout);
{
slong prec, bits, num;
prec = ARB_EXP_TAB1_LIMBS * FLINT_BITS;
bits = ARB_EXP_TAB1_BITS;
num = ARB_EXP_TAB1_NUM;
mpfr_init2(tabx, prec);
mpfr_init2(expx, prec);
mpfr_init2(y1, prec);
mpfr_init2(y2, prec);
for (i = 0; i < num; i++)
{
tt->_mp_d = (mp_ptr) arb_exp_tab1[i];
tt->_mp_size = prec / FLINT_BITS;
tt->_mp_alloc = tt->_mp_size;
while (tt->_mp_size > 0 && tt->_mp_d[tt->_mp_size-1] == 0)
tt->_mp_size--;
mpfr_set_z(tabx, tt, MPFR_RNDD);
mpfr_div_2ui(tabx, tabx, prec, MPFR_RNDD);
mpfr_set_ui(expx, i, MPFR_RNDD);
mpfr_div_2ui(expx, expx, bits, MPFR_RNDD);
mpfr_exp(expx, expx, MPFR_RNDD);
mpfr_mul_2ui(y1, tabx, prec, MPFR_RNDD);
mpfr_floor(y1, y1);
mpfr_div_2ui(y1, y1, prec, MPFR_RNDD);
mpfr_mul_2ui(y2, expx, prec - 1, MPFR_RNDD);
mpfr_floor(y2, y2);
mpfr_div_2ui(y2, y2, prec, MPFR_RNDD);
if (!mpfr_equal_p(y1, y2))
{
flint_printf("FAIL: i = %wd, bits = %wd, prec = %wd\n", i, bits, prec);
mpfr_printf("y1 = %.1500Rg\n", y1);
mpfr_printf("y2 = %.1500Rg\n", y2);
abort();
}
}
mpfr_clear(tabx);
mpfr_clear(expx);
mpfr_clear(y1);
mpfr_clear(y2);
}
{
slong prec, bits, num;
prec = ARB_EXP_TAB2_LIMBS * FLINT_BITS;
bits = ARB_EXP_TAB21_BITS;
num = ARB_EXP_TAB21_NUM;
mpfr_init2(tabx, prec);
mpfr_init2(expx, prec);
mpfr_init2(y1, prec);
mpfr_init2(y2, prec);
for (i = 0; i < num; i++)
{
tt->_mp_d = (mp_ptr) arb_exp_tab21[i];
tt->_mp_size = prec / FLINT_BITS;
tt->_mp_alloc = tt->_mp_size;
while (tt->_mp_size > 0 && tt->_mp_d[tt->_mp_size-1] == 0)
tt->_mp_size--;
mpfr_set_z(tabx, tt, MPFR_RNDD);
mpfr_div_2ui(tabx, tabx, prec, MPFR_RNDD);
mpfr_set_ui(expx, i, MPFR_RNDD);
mpfr_div_2ui(expx, expx, bits, MPFR_RNDD);
mpfr_exp(expx, expx, MPFR_RNDD);
mpfr_mul_2ui(y1, tabx, prec, MPFR_RNDD);
mpfr_floor(y1, y1);
mpfr_div_2ui(y1, y1, prec, MPFR_RNDD);
mpfr_mul_2ui(y2, expx, prec - 1, MPFR_RNDD);
mpfr_floor(y2, y2);
mpfr_div_2ui(y2, y2, prec, MPFR_RNDD);
if (!mpfr_equal_p(y1, y2))
{
flint_printf("FAIL: i = %wd, bits = %wd, prec = %wd\n", i, bits, prec);
mpfr_printf("y1 = %.1500Rg\n", y1);
mpfr_printf("y2 = %.1500Rg\n", y2);
abort();
}
}
mpfr_clear(tabx);
mpfr_clear(expx);
mpfr_clear(y1);
mpfr_clear(y2);
}
{
slong prec, bits, num;
prec = ARB_EXP_TAB2_LIMBS * FLINT_BITS;
bits = ARB_EXP_TAB21_BITS + ARB_EXP_TAB22_BITS;
num = ARB_EXP_TAB22_NUM;
mpfr_init2(tabx, prec);
mpfr_init2(expx, prec);
mpfr_init2(y1, prec);
mpfr_init2(y2, prec);
for (i = 0; i < num; i++)
{
tt->_mp_d = (mp_ptr) arb_exp_tab22[i];
tt->_mp_size = prec / FLINT_BITS;
tt->_mp_alloc = tt->_mp_size;
while (tt->_mp_size > 0 && tt->_mp_d[tt->_mp_size-1] == 0)
tt->_mp_size--;
mpfr_set_z(tabx, tt, MPFR_RNDD);
mpfr_div_2ui(tabx, tabx, prec, MPFR_RNDD);
mpfr_set_ui(expx, i, MPFR_RNDD);
mpfr_div_2ui(expx, expx, bits, MPFR_RNDD);
mpfr_exp(expx, expx, MPFR_RNDD);
mpfr_mul_2ui(y1, tabx, prec, MPFR_RNDD);
mpfr_floor(y1, y1);
mpfr_div_2ui(y1, y1, prec, MPFR_RNDD);
mpfr_mul_2ui(y2, expx, prec - 1, MPFR_RNDD);
mpfr_floor(y2, y2);
mpfr_div_2ui(y2, y2, prec, MPFR_RNDD);
if (!mpfr_equal_p(y1, y2))
{
flint_printf("FAIL: i = %wd, bits = %wd, prec = %wd\n", i, bits, prec);
mpfr_printf("y1 = %.1500Rg\n", y1);
mpfr_printf("y2 = %.1500Rg\n", y2);
abort();
}
}
mpfr_clear(tabx);
mpfr_clear(expx);
mpfr_clear(y1);
mpfr_clear(y2);
}
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main (void)
{
mpfr_t x, y, z;
int i, j, k;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
for (i = 0; i <= 1; i++)
for (j = 0; j <= 1; j++)
for (k = 0; k <= 5; k++)
{
mpfr_set_nan (x);
i ? MPFR_SET_NEG (x) : MPFR_SET_POS (x);
mpfr_set_nan (y);
j ? MPFR_SET_NEG (y) : MPFR_SET_POS (y);
copysign_variant (z, x, y, MPFR_RNDN, k);
if (MPFR_SIGN (z) != MPFR_SIGN (y) || !mpfr_nanflag_p ())
{
printf ("Error in mpfr_copysign (%cNaN, %cNaN)\n",
i ? '-' : '+', j ? '-' : '+');
exit (1);
}
mpfr_set_si (x, i ? -1250 : 1250, MPFR_RNDN);
mpfr_set_nan (y);
j ? MPFR_SET_NEG (y) : MPFR_SET_POS (y);
copysign_variant (z, x, y, MPFR_RNDN, k);
if (i != j)
mpfr_neg (x, x, MPFR_RNDN);
if (! mpfr_equal_p (z, x) || mpfr_nanflag_p ())
{
printf ("Error in mpfr_copysign (%c1250, %cNaN)\n",
i ? '-' : '+', j ? '-' : '+');
exit (1);
}
mpfr_set_si (x, i ? -1250 : 1250, MPFR_RNDN);
mpfr_set_si (y, j ? -1717 : 1717, MPFR_RNDN);
copysign_variant (z, x, y, MPFR_RNDN, k);
if (i != j)
mpfr_neg (x, x, MPFR_RNDN);
if (! mpfr_equal_p (z, x) || mpfr_nanflag_p ())
{
printf ("Error in mpfr_copysign (%c1250, %c1717)\n",
i ? '-' : '+', j ? '-' : '+');
exit (1);
}
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
tests_end_mpfr ();
return 0;
}
static void
overflowed_sec0 (void)
{
mpfr_t x, y;
int emax, i, inex, rnd, err = 0;
mpfr_exp_t old_emax;
old_emax = mpfr_get_emax ();
mpfr_init2 (x, 8);
mpfr_init2 (y, 8);
for (emax = -1; emax <= 0; emax++)
{
mpfr_set_ui_2exp (y, 1, emax, MPFR_RNDN);
mpfr_nextbelow (y);
set_emax (emax); /* 1 is not representable. */
for (i = -1; i <= 1; i++)
RND_LOOP (rnd)
{
mpfr_set_si_2exp (x, i, -512 * ABS (i), MPFR_RNDN);
mpfr_clear_flags ();
inex = mpfr_sec (x, x, (mpfr_rnd_t) rnd);
if (! mpfr_overflow_p ())
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" The overflow flag is not set.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (rnd == MPFR_RNDZ || rnd == MPFR_RNDD)
{
if (inex >= 0)
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" The inexact value must be negative.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (! mpfr_equal_p (x, y))
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" Got ", i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpfr_print_binary (x);
printf (" instead of 0.11111111E%d.\n", emax);
err = 1;
}
}
else
{
if (inex <= 0)
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" The inexact value must be positive.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (! (mpfr_inf_p (x) && MPFR_SIGN (x) > 0))
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" Got ", i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpfr_print_binary (x);
printf (" instead of +Inf.\n");
err = 1;
}
}
}
set_emax (old_emax);
}
if (err)
exit (1);
mpfr_clear (x);
mpfr_clear (y);
}
/* Test n random bad cases. A precision py in [pymin,pymax] and
* a number y of precision py are chosen randomly. One computes
* x = inv(y) in precision px = py + psup (rounded to nearest).
* Then (in general), y is a bad case for fct in precision py (in
* the directed rounding modes, but also in the rounding-to-nearest
* mode for some lower precision: see data_check).
* fct, inv, name: data related to the function.
* pos, emin, emax: arguments for tests_default_random.
*/
void
bad_cases (int (*fct)(FLIST), int (*inv)(FLIST), const char *name,
int pos, mpfr_exp_t emin, mpfr_exp_t emax,
mpfr_prec_t pymin, mpfr_prec_t pymax, mpfr_prec_t psup,
int n)
{
mpfr_t x, y, z;
char *dbgenv;
int i, dbg;
mpfr_exp_t old_emin, old_emax;
old_emin = mpfr_get_emin ();
old_emax = mpfr_get_emax ();
dbgenv = getenv ("MPFR_DEBUG_BADCASES");
dbg = dbgenv != 0 ? atoi (dbgenv) : 0; /* debug level */
mpfr_inits (x, y, z, (mpfr_ptr) 0);
for (i = 0; i < n; i++)
{
mpfr_prec_t px, py, pz;
int inex;
if (dbg)
printf ("bad_cases: i = %d\n", i);
py = pymin + (randlimb () % (pymax - pymin + 1));
mpfr_set_prec (y, py);
tests_default_random (y, pos, emin, emax);
if (dbg)
{
printf ("bad_cases: yprec =%4ld, y = ", (long) py);
mpfr_out_str (stdout, 16, 0, y, MPFR_RNDN);
printf ("\n");
}
px = py + psup;
mpfr_set_prec (x, px);
mpfr_clear_flags ();
inv (x, y, MPFR_RNDN);
if (mpfr_nanflag_p () || mpfr_overflow_p () || mpfr_underflow_p ())
{
if (dbg)
printf ("bad_cases: no normal inverse\n");
goto next_i;
}
if (dbg > 1)
{
printf ("bad_cases: x = ");
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN);
printf ("\n");
}
pz = px;
do
{
pz += 32;
mpfr_set_prec (z, pz);
if (fct (z, x, MPFR_RNDN) == 0)
{
if (dbg)
printf ("bad_cases: exact case\n");
goto next_i;
}
if (dbg)
{
if (dbg > 1)
{
printf ("bad_cases: %s(x) ~= ", name);
mpfr_out_str (stdout, 16, 0, z, MPFR_RNDN);
}
else
{
printf ("bad_cases: [MPFR_RNDZ] ~= ");
mpfr_out_str (stdout, 16, 40, z, MPFR_RNDZ);
}
printf ("\n");
}
inex = mpfr_prec_round (z, py, MPFR_RNDN);
if (mpfr_nanflag_p () || mpfr_overflow_p () || mpfr_underflow_p ()
|| ! mpfr_equal_p (z, y))
{
if (dbg)
printf ("bad_cases: inverse doesn't match\n");
goto next_i;
}
}
while (inex == 0);
/* We really have a bad case. */
do
py--;
while (py >= MPFR_PREC_MIN && mpfr_prec_round (z, py, MPFR_RNDZ) == 0);
py++;
/* py is now the smallest output precision such that we have
a bad case in the directed rounding modes. */
if (mpfr_prec_round (y, py, MPFR_RNDZ) != 0)
{
printf ("Internal error for i = %d\n", i);
exit (1);
}
if ((inex > 0 && MPFR_IS_POS (z)) ||
(inex < 0 && MPFR_IS_NEG (z)))
{
mpfr_nexttozero (y);
if (mpfr_zero_p (y))
goto next_i;
}
if (dbg)
{
printf ("bad_cases: yprec =%4ld, y = ", (long) py);
mpfr_out_str (stdout, 16, 0, y, MPFR_RNDN);
printf ("\n");
}
/* Note: y is now the expected result rounded toward zero. */
test5rm (fct, x, y, z, MPFR_RNDZ, 0, name);
next_i:
/* In case the exponent range has been changed by
tests_default_random()... */
mpfr_set_emin (old_emin);
mpfr_set_emax (old_emax);
}
mpfr_clears (x, y, z, (mpfr_ptr) 0);
}
