void mpfr_bench(mpfr_prec_t prec_a, mpfr_prec_t prec_b, mpfr_prec_t prec_c,
const char *b_str, const char *c_str, unsigned long seed)
{
mpfr_t a,b,c;
mpf_t x,y,z;
mpz_t zz;
gmp_randstate_t state;
gmp_randinit_lc_2exp_size (state, 128);
gmp_randseed_ui (state, seed);
mpfr_init2(a, prec_a);
mpfr_init2(b, prec_b);
mpfr_init2(c, prec_c);
mpf_init2(x, prec_a);
mpf_init2(y, prec_b);
mpf_init2(z, prec_c);
if (b_str)
mpf_set_str(y, b_str, 10);
else
mpf_urandomb(y, state, prec_b);
if (c_str)
mpf_set_str(z, c_str, 10);
else
mpf_urandomb(z, state, prec_c);
mpfr_set_f(b, y, MPFR_RNDN);
mpfr_set_f(c, z, MPFR_RNDN);
mpz_init (zz);
mpz_urandomb (zz, state, 2*prec_b);
if (verbose)
{
printf("B="); mpfr_out_str(stdout, 10, 0, b, MPFR_RNDD);
printf("\nC="); mpfr_out_str(stdout, 10, 0, c, MPFR_RNDD);
putchar('\n');
}
TIMP_OVERHEAD ();
#undef BENCH
#define BENCH(TEST_STR, TEST) printf(" "TEST_STR": %Lu\n", TIMP_MEASURE(TEST))
TEST_LIST;
mpz_clear (zz);
mpfr_clear (a);
mpfr_clear (b);
mpfr_clear (c);
mpf_clear (x);
mpf_clear (y);
mpf_clear (z);
gmp_randclear (state);
}
static void
test_cmp_f (mpfr_prec_t pmin, mpfr_prec_t pmax, int nmax)
{
mpfr_t x, z;
mpf_t y;
mpfr_prec_t p;
int res1, res2;
int n;
mpfr_init (x);
mpfr_init2 (z, pmax+GMP_NUMB_BITS);
mpf_init2 (y, MPFR_PREC_MIN);
/* check the erange flag when x is NaN */
mpfr_set_nan (x);
mpf_set_ui (y, 17);
mpfr_clear_erangeflag ();
res1 = mpfr_cmp_f (x, y);
if (res1 != 0 || mpfr_erangeflag_p () == 0)
{
printf ("Error for mpfr_cmp_f (NaN, 17)\n");
printf ("Return value: expected 0, got %d\n", res1);
printf ("Erange flag: expected set, got %d\n", mpfr_erangeflag_p ());
exit (1);
}
for(p=pmin ; p < pmax ; p+=3)
{
mpfr_set_prec (x, p);
mpf_set_prec (y, p);
for ( n = 0; n < nmax ; n++)
{
mpfr_urandomb (x, RANDS);
mpf_urandomb (y, RANDS, p);
if (!MPFR_IS_SINGULAR (x))
{
mpfr_set_f (z, y, MPFR_RNDN);
mpfr_sub (z, x, z, MPFR_RNDN);
res1 = mpfr_sgn (z);
res2 = mpfr_cmp_f (x, y);
if (res1 != res2)
{
printf("Error for mpfr_cmp_f: res=%d sub gives %d\n",
res2, res1);
exit (1);
}
}
}
}
mpf_clear (y);
mpfr_clear (x);
mpfr_clear (z);
}
static void
test_cmp_f (mpfr_prec_t pmin, mpfr_prec_t pmax, int nmax)
{
mpfr_t x, z;
mpf_t y;
mpfr_prec_t p;
int res1, res2;
int n;
mpfr_init (x);
mpfr_init2 (z, pmax+GMP_NUMB_BITS);
mpf_init2 (y, MPFR_PREC_MIN);
for(p=pmin ; p < pmax ; p+=3)
{
mpfr_set_prec (x, p);
mpf_set_prec (y, p);
for ( n = 0; n < nmax ; n++)
{
mpfr_urandomb (x, RANDS);
mpf_urandomb (y, RANDS, p);
if (!MPFR_IS_SINGULAR (x))
{
mpfr_set_f (z, y, MPFR_RNDN);
mpfr_sub (z, x, z, MPFR_RNDN);
res1 = mpfr_sgn (z);
res2 = mpfr_cmp_f (x, y);
if (res1 != res2)
{
printf("Error for mpfr_cmp_f: res=%d sub gives %d\n",
res2, res1);
exit (1);
}
}
}
}
mpf_clear (y);
mpfr_clear (x);
mpfr_clear (z);
}
void mpfr_stats (unsigned long num, mpfr_prec_t prec_a, mpfr_prec_t prec_b,
mpfr_prec_t prec_c, unsigned long seed)
{
mpf_t xt[num],yt[num],zt[num];
unsigned long long mc[num][MAX_OP], m;
mpfr_t a, b, c;
mpf_t x, y, z;
mpz_t zz;
unsigned long long min,max,moy;
gmp_randstate_t state;
int i,j=0, op, cont;
int imin=0, imax=0;
mpf_init2(x, prec_a);
mpf_init2(y, prec_b);
mpf_init2(z, prec_c);
mpfr_init2(a, prec_a);
mpfr_init2(b, prec_b);
mpfr_init2(c, prec_c);
gmp_randinit_lc_2exp_size (state, 128);
gmp_randseed_ui (state, seed);
mpz_init (zz);
mpz_urandomb (zz, state, 2*prec_b);
TIMP_OVERHEAD ();
for(i = 0 ; i < num ; i++)
{
mpf_init2(xt[i], prec_a);
mpf_init2(yt[i], prec_b);
mpf_init2(zt[i], prec_c);
mpf_urandomb(yt[i], state, prec_b);
yt[i][0]._mp_exp += (rand() % prec_b) / GMP_NUMB_BITS;
mpf_urandomb(zt[i], state, prec_c);
/* zt[i][0]._mp_exp += (rand() % prec_c) / GMP_NUMB_BITS; */
for(op = 0 ; op < MAX_OP ; op++)
mc[i][op] = 0xFFFFFFFFFFFFFFFLL;
}
for(j = 0, cont = 5 ; cont ; j++, cont--)
{
printf("Pass %d...\n", j+1);
for(i = 0 ; i < num ; i++)
{
op = 0;
mpf_set(y,yt[i]);
mpf_set(z,zt[i]);
mpfr_set_f(b, yt[i], MPFR_RNDN);
mpfr_set_f(c, zt[i], MPFR_RNDN);
#undef BENCH
#define BENCH(TEST_STR, TEST) \
m = TIMP_MEASURE(TEST); if (m < mc[i][op]) {mc[i][op] = m; cont = 4;} op++;
TEST_LIST;
}
#undef BENCH
#define BENCH(TEST_STR, TEST) \
min = 0xFFFFFFFFFFFFFFFLL; max = 0LL; moy = 0LL; \
for(i = 0 ; i < num ; i++) { \
if (mc[i][op] < min) imin = i, min = mc[i][op]; \
if (mc[i][op] > max) imax = i, max = mc[i][op]; \
moy += mc[i][op]; \
} \
printf(" %s: %Lu / %Lu.%02Lu / %Lu", TEST_STR, min, \
(unsigned long long) moy/num, (moy*100LL/num)%100LL, max); \
if (verbose) printf ("\tMIN:%e,%e\tMAX:%e,%e", mpf_get_d(yt[imin]),\
mpf_get_d(zt[imin]), mpf_get_d(yt[imax]), \
mpf_get_d(zt[imax])); \
putchar ('\n'); \
op++;
op =0;
TEST_LIST;
}
printf("End\n");
mpz_clear (zz);
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
mpf_clear(x);
mpf_clear(y);
mpf_clear(z);
for(i = 0 ; i < num ; i++)
{
mpf_clear(xt[i]);
mpf_clear(yt[i]);
mpf_clear(zt[i]);
}
gmp_randclear(state);
}
int
main (void)
{
mpfr_t x, u;
mpf_t y, z;
mpfr_exp_t emax;
unsigned long k, pr;
int r, inexact;
tests_start_mpfr ();
mpf_init (y);
mpf_init (z);
mpf_set_d (y, 0.0);
/* check prototype of mpfr_init_set_f */
mpfr_init_set_f (x, y, MPFR_RNDN);
mpfr_set_prec (x, 100);
mpfr_set_f (x, y, MPFR_RNDN);
mpf_urandomb (y, RANDS, 10 * GMP_NUMB_BITS);
mpfr_set_f (x, y, RND_RAND ());
/* bug found by Jean-Pierre Merlet */
mpfr_set_prec (x, 256);
mpf_set_prec (y, 256);
mpfr_init2 (u, 256);
mpfr_set_str (u,
"7.f10872b020c49ba5e353f7ced916872b020c49ba5e353f7ced916872b020c498@2",
16, MPFR_RNDN);
mpf_set_str (y, "2033033E-3", 10); /* avoid 2033.033 which is
locale-sensitive */
mpfr_set_f (x, y, MPFR_RNDN);
if (mpfr_cmp (x, u))
{
printf ("mpfr_set_f failed for y=2033033E-3\n");
exit (1);
}
mpf_set_str (y, "-2033033E-3", 10); /* avoid -2033.033 which is
locale-sensitive */
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_neg (u, u, MPFR_RNDN);
if (mpfr_cmp (x, u))
{
printf ("mpfr_set_f failed for y=-2033033E-3\n");
exit (1);
}
mpf_set_prec (y, 300);
mpf_set_str (y, "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", -2);
mpf_mul_2exp (y, y, 600);
mpfr_set_prec (x, 300);
mpfr_set_f (x, y, MPFR_RNDN);
if (mpfr_check (x) == 0)
{
printf ("Error in mpfr_set_f: corrupted result\n");
mpfr_dump (x);
exit (1);
}
MPFR_ASSERTN(mpfr_cmp_ui_2exp (x, 1, 901) == 0);
/* random values */
for (k = 1; k <= 1000; k++)
{
pr = 2 + (randlimb () & 255);
mpf_set_prec (z, pr);
mpf_urandomb (z, RANDS, z->_mp_prec);
mpfr_set_prec (u, ((pr / GMP_NUMB_BITS + 1) * GMP_NUMB_BITS));
mpfr_set_f (u, z, MPFR_RNDN);
if (mpfr_cmp_f (u , z) != 0)
{
printf ("Error in mpfr_set_f:\n");
printf ("mpf (precision=%lu)=", pr);
mpf_out_str (stdout, 16, 0, z);
printf ("\nmpfr(precision=%lu)=",
((pr / GMP_NUMB_BITS + 1) * GMP_NUMB_BITS));
mpfr_out_str (stdout, 16, 0, u, MPFR_RNDN);
putchar ('\n');
exit (1);
}
mpfr_set_prec (x, pr);
mpfr_set_f (x, z, MPFR_RNDN);
mpfr_sub (u, u, x, MPFR_RNDN);
mpfr_abs (u, u, MPFR_RNDN);
if (mpfr_cmp_ui_2exp (u, 1, -pr - 1) > 0)
{
printf ("Error in mpfr_set_f: precision=%lu\n", pr);
printf ("mpf =");
mpf_out_str (stdout, 16, 0, z);
printf ("\nmpfr=");
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
}
/* Check for +0 */
mpfr_set_prec (x, 53);
mpf_set_prec (y, 53);
mpf_set_ui (y, 0);
for (r = 0 ; r < MPFR_RND_MAX ; r++)
{
int i;
for (i = -1; i <= 1; i++)
{
if (i)
mpfr_set_si (x, i, MPFR_RNDN);
inexact = mpfr_set_f (x, y, (mpfr_rnd_t) r);
if (!MPFR_IS_ZERO(x) || !MPFR_IS_POS(x) || inexact)
{
printf ("mpfr_set_f(x,0) failed for %s, i = %d\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r), i);
exit (1);
}
}
}
/* coverage test */
mpf_set_prec (y, 2);
mpfr_set_prec (x, 3 * mp_bits_per_limb);
mpf_set_ui (y, 1);
for (r = 0; r < mp_bits_per_limb; r++)
{
mpfr_urandomb (x, RANDS); /* to fill low limbs with random data */
inexact = mpfr_set_f (x, y, MPFR_RNDN);
MPFR_ASSERTN(inexact == 0 && mpfr_cmp_ui_2exp (x, 1, r) == 0);
mpf_mul_2exp (y, y, 1);
}
mpf_set_ui (y, 1);
mpf_mul_2exp (y, y, ULONG_MAX);
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_set_ui (u, 1, MPFR_RNDN);
mpfr_mul_2ui (u, u, ULONG_MAX, MPFR_RNDN);
if (!mpfr_equal_p (x, u))
{
printf ("Error: mpfr_set_f (x, y, MPFR_RNDN) for y = 2^ULONG_MAX\n");
exit (1);
}
emax = mpfr_get_emax ();
/* For mpf_mul_2exp, emax must fit in an unsigned long! */
if (emax >= 0 && emax <= ULONG_MAX)
{
mpf_set_ui (y, 1);
mpf_mul_2exp (y, y, emax);
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_set_ui_2exp (u, 1, emax, MPFR_RNDN);
if (!mpfr_equal_p (x, u))
{
printf ("Error: mpfr_set_f (x, y, MPFR_RNDN) for y = 2^emax\n");
exit (1);
}
}
/* For mpf_mul_2exp, emax - 1 must fit in an unsigned long! */
if (emax >= 1 && emax - 1 <= ULONG_MAX)
{
mpf_set_ui (y, 1);
mpf_mul_2exp (y, y, emax - 1);
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_set_ui_2exp (u, 1, emax - 1, MPFR_RNDN);
if (!mpfr_equal_p (x, u))
{
printf ("Error: mpfr_set_f (x, y, MPFR_RNDN) for y = 2^(emax-1)\n");
exit (1);
}
}
mpfr_clear (x);
mpfr_clear (u);
mpf_clear (y);
mpf_clear (z);
tests_end_mpfr ();
return 0;
}
