static int
is_odd (mpfr_srcptr x)
{
/* works only with the values from val[] */
return mpfr_integer_p (x) && mpfr_fits_slong_p (x, MPFR_RNDN) &&
(mpfr_get_si (x, MPFR_RNDN) & 1);
}
int coords_calculate_precision(coords* c)
{
int l, p;
mpfr_t tmp;
mpfr_t bail;
mpfr_t px_size;
mpfr_t precision;
mpfr_init2(tmp, c->precision);
mpfr_init2(bail, c->precision);
mpfr_init2(px_size, c->precision);
mpfr_init2(precision, c->precision);
mpfr_set_d( bail, 4.0, GMP_RNDN);
mpfr_div_si(px_size, c->width, c->img_width, GMP_RNDN);
mpfr_div( tmp, bail, px_size, GMP_RNDN);
l = mpfr_log2( precision, tmp, GMP_RNDN);
p = (int)mpfr_get_si( precision, GMP_RNDN);
if (l < 0) /* precision was rounded down */
++p;
c->recommend = p;
mpfr_clear(tmp);
mpfr_clear(bail);
mpfr_clear(px_size);
mpfr_clear(precision);
mpfr_free_cache(); /* <-- keep valgrind happy over mpfr_log2 */
return c->recommend;
}
/**
* rasqal_xsd_decimal_get_long:
* @dec: XSD Decimal
* @error_p: pointer to error flag
*
* Get an XSD Decimal as a long (may lose precision)
*
* Return value: long value or 0 on failure and *error_p is non-0
**/
long
rasqal_xsd_decimal_get_long(rasqal_xsd_decimal* dec, int* error_p)
{
long result = 0;
#if defined(RASQAL_DECIMAL_C99) || defined(RASQAL_DECIMAL_NONE)
result=(long)dec->raw;
#endif
#ifdef RASQAL_DECIMAL_MPFR
if(!mpfr_fits_slong_p(dec->raw, dec->rounding)) {
if(error_p)
*error_p = 1;
} else
result = mpfr_get_si(dec->raw, dec->rounding);
#endif
#ifdef RASQAL_DECIMAL_GMP
if(!mpf_fits_slong_p(dec->raw)) {
if(error_p)
*error_p = 1;
} else
result = mpf_get_si(dec->raw);
#endif
return result;
}
static void
check (long i, mpfr_rnd_t rnd)
{
mpfr_t f;
mpz_t z;
mpfr_init2 (f, 8 * sizeof(long));
mpz_init (z);
mpz_set_ui (z, i);
mpfr_set_z (f, z, rnd);
if (mpfr_get_si (f, MPFR_RNDZ) != i)
{
printf ("Error in mpfr_set_z for i=%ld rnd_mode=%d\n", i, rnd);
exit (1);
}
mpfr_clear (f);
mpz_clear (z);
}
static void
check (long i, mpfr_rnd_t rnd)
{
mpfr_t f;
mpz_t z;
mpfr_exp_t e;
int inex;
/* using CHAR_BIT * sizeof(long) bits of precision ensures that
mpfr_set_z_2exp is exact below */
mpfr_init2 (f, CHAR_BIT * sizeof(long));
mpz_init (z);
mpz_set_ui (z, i);
/* the following loop ensures that no overflow occurs */
do
e = randexp ();
while (e > mpfr_get_emax () - CHAR_BIT * sizeof(long));
inex = mpfr_set_z_2exp (f, z, e, rnd);
if (inex != 0)
{
printf ("Error in mpfr_set_z_2exp for i=%ld, e=%ld,"
" wrong ternary value\n", i, (long) e);
printf ("expected 0, got %d\n", inex);
exit (1);
}
mpfr_div_2si (f, f, e, rnd);
if (mpfr_get_si (f, MPFR_RNDZ) != i)
{
printf ("Error in mpfr_set_z_2exp for i=%ld e=", i);
if (e < LONG_MIN)
printf ("(<LONG_MIN)");
else if (e > LONG_MAX)
printf ("(>LONG_MAX)");
else
printf ("%ld", (long) e);
printf (" rnd_mode=%d\n", rnd);
printf ("expected %ld\n", i);
printf ("got "); mpfr_dump (f);
exit (1);
}
mpfr_clear (f);
mpz_clear (z);
}
/* Convert R "mpfr" object (list of "mpfr1") to R "integer" vector : */
SEXP mpfr2i(SEXP x, SEXP rnd_mode) {
int n = length(x), i;
SEXP val = PROTECT(allocVector(INTSXP, n));
int *r = INTEGER(val);
mpfr_t R_i;
mpfr_init(R_i); /* with default precision */
for(i=0; i < n; i++) {
R_asMPFR(VECTOR_ELT(x, i), R_i);
if(!mpfr_fits_sint_p(R_i, R_rnd2MP(rnd_mode))) {
warning("NAs introduced by coercion from \"mpfr\" [%d]", i+1);
r[i] = NA_INTEGER;
}
else {
long lr = mpfr_get_si(R_i, R_rnd2MP(rnd_mode));
r[i] = (int) lr;
}
}
mpfr_clear (R_i);
mpfr_free_cache();
UNPROTECT(1);
return val;
}
int
mpfr_exp2 (mpfr_ptr y, mpfr_srcptr x, mpfr_rnd_t rnd_mode)
{
int inexact;
long xint;
mpfr_t xfrac;
MPFR_SAVE_EXPO_DECL (expo);
MPFR_LOG_FUNC
(("x[%Pu]=%.*Rg rnd=%d", mpfr_get_prec(x), mpfr_log_prec, x, rnd_mode),
("y[%Pu]=%.*Rg inexact=%d", mpfr_get_prec(y), mpfr_log_prec, y,
inexact));
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x)))
{
if (MPFR_IS_NAN (x))
{
MPFR_SET_NAN (y);
MPFR_RET_NAN;
}
else if (MPFR_IS_INF (x))
{
if (MPFR_IS_POS (x))
MPFR_SET_INF (y);
else
MPFR_SET_ZERO (y);
MPFR_SET_POS (y);
MPFR_RET (0);
}
else /* 2^0 = 1 */
{
MPFR_ASSERTD (MPFR_IS_ZERO(x));
return mpfr_set_ui (y, 1, rnd_mode);
}
}
/* since the smallest representable non-zero float is 1/2*2^__gmpfr_emin,
if x < __gmpfr_emin - 1, the result is either 1/2*2^__gmpfr_emin or 0 */
MPFR_ASSERTN (MPFR_EMIN_MIN >= LONG_MIN + 2);
if (MPFR_UNLIKELY (mpfr_cmp_si (x, __gmpfr_emin - 1) < 0))
{
mpfr_rnd_t rnd2 = rnd_mode;
/* in round to nearest mode, round to zero when x <= __gmpfr_emin-2 */
if (rnd_mode == MPFR_RNDN &&
mpfr_cmp_si_2exp (x, __gmpfr_emin - 2, 0) <= 0)
rnd2 = MPFR_RNDZ;
return mpfr_underflow (y, rnd2, 1);
}
MPFR_ASSERTN (MPFR_EMAX_MAX <= LONG_MAX);
if (MPFR_UNLIKELY (mpfr_cmp_si (x, __gmpfr_emax) >= 0))
return mpfr_overflow (y, rnd_mode, 1);
/* We now know that emin - 1 <= x < emax. */
MPFR_SAVE_EXPO_MARK (expo);
/* 2^x = 1 + x*log(2) + O(x^2) for x near zero, and for |x| <= 1 we have
|2^x - 1| <= x < 2^EXP(x). If x > 0 we must round away from 0 (dir=1);
if x < 0 we must round toward 0 (dir=0). */
MPFR_SMALL_INPUT_AFTER_SAVE_EXPO (y, __gmpfr_one, - MPFR_GET_EXP (x), 0,
MPFR_IS_POS (x), rnd_mode, expo, {});
xint = mpfr_get_si (x, MPFR_RNDZ);
mpfr_init2 (xfrac, MPFR_PREC (x));
mpfr_sub_si (xfrac, x, xint, MPFR_RNDN); /* exact */
if (MPFR_IS_ZERO (xfrac))
{
mpfr_set_ui (y, 1, MPFR_RNDN);
inexact = 0;
}
else
{
/* Declaration of the intermediary variable */
mpfr_t t;
/* Declaration of the size variable */
mpfr_prec_t Ny = MPFR_PREC(y); /* target precision */
mpfr_prec_t Nt; /* working precision */
mpfr_exp_t err; /* error */
MPFR_ZIV_DECL (loop);
/* compute the precision of intermediary variable */
/* the optimal number of bits : see algorithms.tex */
Nt = Ny + 5 + MPFR_INT_CEIL_LOG2 (Ny);
/* initialize of intermediary variable */
mpfr_init2 (t, Nt);
/* First computation */
MPFR_ZIV_INIT (loop, Nt);
for (;;)
{
/* compute exp(x*ln(2))*/
mpfr_const_log2 (t, MPFR_RNDU); /* ln(2) */
mpfr_mul (t, xfrac, t, MPFR_RNDU); /* xfrac * ln(2) */
err = Nt - (MPFR_GET_EXP (t) + 2); /* Estimate of the error */
mpfr_exp (t, t, MPFR_RNDN); /* exp(xfrac * ln(2)) */
if (MPFR_LIKELY (MPFR_CAN_ROUND (t, err, Ny, rnd_mode)))
break;
/* Actualisation of the precision */
MPFR_ZIV_NEXT (loop, Nt);
mpfr_set_prec (t, Nt);
}
MPFR_ZIV_FREE (loop);
inexact = mpfr_set (y, t, rnd_mode);
mpfr_clear (t);
}
mpfr_clear (xfrac);
MPFR_CLEAR_FLAGS ();
mpfr_mul_2si (y, y, xint, MPFR_RNDN); /* exact or overflow */
/* Note: We can have an overflow only when t was rounded up to 2. */
MPFR_ASSERTD (MPFR_IS_PURE_FP (y) || inexact > 0);
MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, __gmpfr_flags);
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_check_range (y, inexact, rnd_mode);
}
int real::get_int() const
{
return mpfr_get_si(r, MPFR_RNDZ);
}
int
main (int argc, char *argv[])
{
mpfr_t x;
long k, z, d, N;
unsigned long zl, dl;
int inex;
int r;
mpfr_exp_t emin, emax;
int flag;
tests_start_mpfr ();
mpfr_init2 (x, 100);
N = (argc==1) ? 100000 : atol (argv[1]);
for (k = 1; k <= N; k++)
{
z = (long) (randlimb () & LONG_MAX) + LONG_MIN / 2;
inex = mpfr_set_si (x, z, MPFR_RNDZ);
d = mpfr_get_si (x, MPFR_RNDZ);
if (d != z)
{
printf ("Error in mpfr_set_si: expected %ld got %ld\n", z, d);
exit (1);
}
if (inex)
{
printf ("Error in mpfr_set_si: inex value incorrect for %ld: %d\n",
z, inex);
exit (1);
}
}
for (k = 1; k <= N; k++)
{
zl = randlimb ();
inex = mpfr_set_ui (x, zl, MPFR_RNDZ);
dl = mpfr_get_ui (x, MPFR_RNDZ);
if (dl != zl)
{
printf ("Error in mpfr_set_ui: expected %lu got %lu\n", zl, dl);
exit (1);
}
if (inex)
{
printf ("Error in mpfr_set_ui: inex value incorrect for %lu: %d\n",
zl, inex);
exit (1);
}
}
mpfr_set_prec (x, 2);
if (mpfr_set_si (x, 5, MPFR_RNDZ) >= 0)
{
printf ("Wrong inexact flag for x=5, rnd=MPFR_RNDZ\n");
exit (1);
}
mpfr_set_prec (x, 2);
if (mpfr_set_si (x, -5, MPFR_RNDZ) <= 0)
{
printf ("Wrong inexact flag for x=-5, rnd=MPFR_RNDZ\n");
exit (1);
}
mpfr_set_prec (x, 3);
inex = mpfr_set_si (x, 77617, MPFR_RNDD); /* should be 65536 */
if (MPFR_MANT(x)[0] != ((mp_limb_t)1 << (mp_bits_per_limb-1))
|| inex >= 0)
{
printf ("Error in mpfr_set_si(x:3, 77617, MPFR_RNDD)\n");
mpfr_print_binary (x);
puts ("");
exit (1);
}
inex = mpfr_set_ui (x, 77617, MPFR_RNDD); /* should be 65536 */
if (MPFR_MANT(x)[0] != ((mp_limb_t)1 << (mp_bits_per_limb-1))
|| inex >= 0)
{
printf ("Error in mpfr_set_ui(x:3, 77617, MPFR_RNDD)\n");
mpfr_print_binary (x);
puts ("");
exit (1);
}
mpfr_set_prec (x, 2);
inex = mpfr_set_si (x, 33096, MPFR_RNDU);
if (mpfr_get_si (x, MPFR_RNDZ) != 49152 || inex <= 0)
{
printf ("Error in mpfr_set_si, exp. 49152, got %ld, inex %d\n",
mpfr_get_si (x, MPFR_RNDZ), inex);
exit (1);
}
inex = mpfr_set_ui (x, 33096, MPFR_RNDU);
if (mpfr_get_si (x, MPFR_RNDZ) != 49152)
{
printf ("Error in mpfr_set_ui, exp. 49152, got %ld, inex %d\n",
mpfr_get_si (x, MPFR_RNDZ), inex);
exit (1);
}
/* Also test the mpfr_set_ui function (instead of macro). */
inex = (mpfr_set_ui) (x, 33096, MPFR_RNDU);
if (mpfr_get_si (x, MPFR_RNDZ) != 49152)
{
printf ("Error in mpfr_set_ui function, exp. 49152, got %ld, inex %d\n",
mpfr_get_si (x, MPFR_RNDZ), inex);
exit (1);
}
for (r = 0 ; r < MPFR_RND_MAX ; r++)
{
mpfr_set_si (x, -1, (mpfr_rnd_t) r);
mpfr_set_ui (x, 0, (mpfr_rnd_t) r);
if (MPFR_IS_NEG (x) || mpfr_get_ui (x, (mpfr_rnd_t) r) != 0)
{
printf ("mpfr_set_ui (x, 0) gives -0 for %s\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r));
exit (1);
}
mpfr_set_si (x, -1, (mpfr_rnd_t) r);
mpfr_set_si (x, 0, (mpfr_rnd_t) r);
if (MPFR_IS_NEG (x) || mpfr_get_si (x, (mpfr_rnd_t) r) != 0)
{
printf ("mpfr_set_si (x, 0) gives -0 for %s\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r));
exit (1);
}
}
/* check potential bug in case mp_limb_t is unsigned */
emax = mpfr_get_emax ();
set_emax (0);
mpfr_set_si (x, -1, MPFR_RNDN);
if (mpfr_sgn (x) >= 0)
{
printf ("mpfr_set_si (x, -1) fails\n");
exit (1);
}
set_emax (emax);
emax = mpfr_get_emax ();
set_emax (5);
mpfr_set_prec (x, 2);
mpfr_set_si (x, -31, MPFR_RNDN);
if (mpfr_sgn (x) >= 0)
{
printf ("mpfr_set_si (x, -31) fails\n");
exit (1);
}
set_emax (emax);
/* test for get_ui */
mpfr_set_ui (x, 0, MPFR_RNDN);
MPFR_ASSERTN(mpfr_get_ui (x, MPFR_RNDN) == 0);
mpfr_set_ui (x, ULONG_MAX, MPFR_RNDU);
mpfr_nextabove (x);
mpfr_get_ui (x, MPFR_RNDU);
/* another test for get_ui */
mpfr_set_prec (x, 10);
mpfr_set_str_binary (x, "10.101");
dl = mpfr_get_ui (x, MPFR_RNDN);
MPFR_ASSERTN (dl == 3);
mpfr_set_str_binary (x, "-1.0");
mpfr_get_ui (x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.1");
dl = mpfr_get_ui (x, MPFR_RNDN);
MPFR_ASSERTN (dl == 0);
dl = mpfr_get_ui (x, MPFR_RNDZ);
MPFR_ASSERTN (dl == 0);
dl = mpfr_get_ui (x, MPFR_RNDD);
MPFR_ASSERTN (dl == 0);
dl = mpfr_get_ui (x, MPFR_RNDU);
MPFR_ASSERTN (dl == 1);
/* coverage tests */
mpfr_set_prec (x, 2);
mpfr_set_si (x, -7, MPFR_RNDD);
MPFR_ASSERTN(mpfr_cmp_si (x, -8) == 0);
mpfr_set_prec (x, 2);
mpfr_set_ui (x, 7, MPFR_RNDU);
MPFR_ASSERTN(mpfr_cmp_ui (x, 8) == 0);
emax = mpfr_get_emax ();
set_emax (3);
mpfr_set_ui (x, 7, MPFR_RNDU);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
set_emax (1);
MPFR_ASSERTN( mpfr_set_ui (x, 7, MPFR_RNDU) );
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
set_emax (emax);
mpfr_set_ui_2exp (x, 17, -50, MPFR_RNDN);
MPFR_ASSERTN (mpfr_get_ui (x, MPFR_RNDD) == 0);
MPFR_ASSERTN (mpfr_get_si (x, MPFR_RNDD) == 0);
/* Test for ERANGE flag + correct behaviour if overflow */
mpfr_set_prec (x, 256);
mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
mpfr_clear_erangeflag ();
dl = mpfr_get_ui (x, MPFR_RNDN);
if (dl != ULONG_MAX || mpfr_erangeflag_p ())
{
printf ("ERROR for get_ui + ERANGE + ULONG_MAX (1)\n");
exit (1);
}
mpfr_add_ui (x, x, 1, MPFR_RNDN);
dl = mpfr_get_ui (x, MPFR_RNDN);
if (dl != ULONG_MAX || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_ui + ERANGE + ULONG_MAX (2)\n");
exit (1);
}
mpfr_set_si (x, -1, MPFR_RNDN);
mpfr_clear_erangeflag ();
dl = mpfr_get_ui (x, MPFR_RNDN);
if (dl != 0 || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_ui + ERANGE + -1 \n");
exit (1);
}
mpfr_set_si (x, LONG_MAX, MPFR_RNDN);
mpfr_clear_erangeflag ();
d = mpfr_get_si (x, MPFR_RNDN);
if (d != LONG_MAX || mpfr_erangeflag_p ())
{
printf ("ERROR for get_si + ERANGE + LONG_MAX (1): %ld\n", d);
exit (1);
}
mpfr_add_ui (x, x, 1, MPFR_RNDN);
d = mpfr_get_si (x, MPFR_RNDN);
if (d != LONG_MAX || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_si + ERANGE + LONG_MAX (2)\n");
exit (1);
}
mpfr_set_si (x, LONG_MIN, MPFR_RNDN);
mpfr_clear_erangeflag ();
d = mpfr_get_si (x, MPFR_RNDN);
if (d != LONG_MIN || mpfr_erangeflag_p ())
{
printf ("ERROR for get_si + ERANGE + LONG_MIN (1)\n");
exit (1);
}
mpfr_sub_ui (x, x, 1, MPFR_RNDN);
d = mpfr_get_si (x, MPFR_RNDN);
if (d != LONG_MIN || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_si + ERANGE + LONG_MIN (2)\n");
exit (1);
}
mpfr_set_nan (x);
mpfr_clear_erangeflag ();
d = mpfr_get_ui (x, MPFR_RNDN);
if (d != 0 || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_ui + NaN\n");
exit (1);
}
mpfr_clear_erangeflag ();
d = mpfr_get_si (x, MPFR_RNDN);
if (d != 0 || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_si + NaN\n");
exit (1);
}
emin = mpfr_get_emin ();
mpfr_set_prec (x, 2);
mpfr_set_emin (4);
mpfr_clear_flags ();
mpfr_set_ui (x, 7, MPFR_RNDU);
flag = mpfr_underflow_p ();
mpfr_set_emin (emin);
if (mpfr_cmp_ui (x, 8) != 0)
{
printf ("Error for mpfr_set_ui (x, 7, MPFR_RNDU), prec = 2, emin = 4\n");
exit (1);
}
if (flag)
{
printf ("mpfr_set_ui (x, 7, MPFR_RNDU) should not underflow "
"with prec = 2, emin = 4\n");
exit (1);
}
mpfr_set_emin (4);
mpfr_clear_flags ();
mpfr_set_si (x, -7, MPFR_RNDD);
flag = mpfr_underflow_p ();
mpfr_set_emin (emin);
if (mpfr_cmp_si (x, -8) != 0)
{
printf ("Error for mpfr_set_si (x, -7, MPFR_RNDD), prec = 2, emin = 4\n");
exit (1);
}
if (flag)
{
printf ("mpfr_set_si (x, -7, MPFR_RNDD) should not underflow "
"with prec = 2, emin = 4\n");
exit (1);
}
mpfr_clear (x);
test_2exp ();
test_macros ();
test_macros_keyword ();
tests_end_mpfr ();
return 0;
}
static int
mpfr_all_div (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t r)
{
mpfr_t a2;
unsigned int oldflags, newflags;
int inex, inex2;
oldflags = __gmpfr_flags;
inex = mpfr_div (a, b, c, r);
if (a == b || a == c)
return inex;
newflags = __gmpfr_flags;
mpfr_init2 (a2, MPFR_PREC (a));
if (mpfr_integer_p (b) && ! (MPFR_IS_ZERO (b) && MPFR_IS_NEG (b)))
{
/* b is an integer, but not -0 (-0 is rejected as
it becomes +0 when converted to an integer). */
if (mpfr_fits_ulong_p (b, MPFR_RNDA))
{
__gmpfr_flags = oldflags;
inex2 = mpfr_ui_div (a2, mpfr_get_ui (b, MPFR_RNDN), c, r);
MPFR_ASSERTN (SAME_SIGN (inex2, inex));
MPFR_ASSERTN (__gmpfr_flags == newflags);
check_equal (a, a2, "mpfr_ui_div", b, c, r);
}
if (mpfr_fits_slong_p (b, MPFR_RNDA))
{
__gmpfr_flags = oldflags;
inex2 = mpfr_si_div (a2, mpfr_get_si (b, MPFR_RNDN), c, r);
MPFR_ASSERTN (SAME_SIGN (inex2, inex));
MPFR_ASSERTN (__gmpfr_flags == newflags);
check_equal (a, a2, "mpfr_si_div", b, c, r);
}
}
if (mpfr_integer_p (c) && ! (MPFR_IS_ZERO (c) && MPFR_IS_NEG (c)))
{
/* c is an integer, but not -0 (-0 is rejected as
it becomes +0 when converted to an integer). */
if (mpfr_fits_ulong_p (c, MPFR_RNDA))
{
__gmpfr_flags = oldflags;
inex2 = mpfr_div_ui (a2, b, mpfr_get_ui (c, MPFR_RNDN), r);
MPFR_ASSERTN (SAME_SIGN (inex2, inex));
MPFR_ASSERTN (__gmpfr_flags == newflags);
check_equal (a, a2, "mpfr_div_ui", b, c, r);
}
if (mpfr_fits_slong_p (c, MPFR_RNDA))
{
__gmpfr_flags = oldflags;
inex2 = mpfr_div_si (a2, b, mpfr_get_si (c, MPFR_RNDN), r);
MPFR_ASSERTN (SAME_SIGN (inex2, inex));
MPFR_ASSERTN (__gmpfr_flags == newflags);
check_equal (a, a2, "mpfr_div_si", b, c, r);
}
}
mpfr_clear (a2);
return inex;
}
/* Assumes that the exponent range has already been extended and if y is
an integer, then the result is not exact in unbounded exponent range. */
int
mpfr_pow_general (mpfr_ptr z, mpfr_srcptr x, mpfr_srcptr y,
mpfr_rnd_t rnd_mode, int y_is_integer, mpfr_save_expo_t *expo)
{
mpfr_t t, u, k, absx;
int neg_result = 0;
int k_non_zero = 0;
int check_exact_case = 0;
int inexact;
/* 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
(("x[%Pu]=%.*Rg y[%Pu]=%.*Rg rnd=%d",
mpfr_get_prec (x), mpfr_log_prec, x,
mpfr_get_prec (y), mpfr_log_prec, y, rnd_mode),
("z[%Pu]=%.*Rg inexact=%d",
mpfr_get_prec (z), mpfr_log_prec, z, inexact));
/* We put the absolute value of x in absx, pointing to the significand
of x to avoid allocating memory for the significand of absx. */
MPFR_ALIAS(absx, x, /*sign=*/ 1, /*EXP=*/ MPFR_EXP(x));
/* We will compute the absolute value of the result. So, let's
invert the rounding mode if the result is negative. */
if (MPFR_IS_NEG (x) && is_odd (y))
{
neg_result = 1;
rnd_mode = MPFR_INVERT_RND (rnd_mode);
}
/* compute the precision of intermediary variable */
/* the optimal number of bits : see algorithms.tex */
Nt = Nz + 5 + MPFR_INT_CEIL_LOG2 (Nz);
/* initialise of intermediary variable */
mpfr_init2 (t, Nt);
MPFR_ZIV_INIT (ziv_loop, Nt);
for (;;)
{
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| */
if (k_non_zero)
{
MPFR_LOG_MSG (("subtract k * ln(2)\n", 0));
mpfr_const_log2 (u, MPFR_RNDD);
mpfr_mul (u, u, k, MPFR_RNDD);
/* Error on u = k * log(2): < k * 2^(-Nt) < 1. */
mpfr_sub (t, t, u, MPFR_RNDU);
MPFR_LOG_MSG (("t = y * ln|x| - k * ln(2)\n", 0));
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.
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;
if (k_non_zero)
{
if (MPFR_GET_EXP (k) > err)
err = MPFR_GET_EXP (k);
err++;
}
MPFR_BLOCK (flags1, mpfr_exp (t, t, MPFR_RNDN)); /* exp(y*ln|x|)*/
/* We need to test */
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (t) || MPFR_UNDERFLOW (flags1)))
{
mpfr_prec_t Ntmin;
MPFR_BLOCK_DECL (flags2);
MPFR_ASSERTN (!k_non_zero);
MPFR_ASSERTN (!MPFR_IS_NAN (t));
/* Real underflow? */
if (MPFR_IS_ZERO (t))
{
/* Underflow. We computed rndn(exp(t)), where t >= y*ln|x|.
Therefore rndn(|x|^y) = 0, and we have a real underflow on
|x|^y. */
inexact = mpfr_underflow (z, rnd_mode == MPFR_RNDN ? MPFR_RNDZ
: rnd_mode, MPFR_SIGN_POS);
if (expo != NULL)
MPFR_SAVE_EXPO_UPDATE_FLAGS (*expo, MPFR_FLAGS_INEXACT
| MPFR_FLAGS_UNDERFLOW);
break;
}
/* Real overflow? */
if (MPFR_IS_INF (t))
{
/* Note: we can probably use a low precision for this test. */
mpfr_log (t, absx, MPFR_IS_NEG (y) ? MPFR_RNDU : MPFR_RNDD);
mpfr_mul (t, y, t, MPFR_RNDD); /* y * ln|x| */
MPFR_BLOCK (flags2, mpfr_exp (t, t, MPFR_RNDD));
/* t = lower bound on exp(y * ln|x|) */
if (MPFR_OVERFLOW (flags2))
{
/* We have computed a lower bound on |x|^y, and it
overflowed. Therefore we have a real overflow
on |x|^y. */
inexact = mpfr_overflow (z, rnd_mode, MPFR_SIGN_POS);
if (expo != NULL)
MPFR_SAVE_EXPO_UPDATE_FLAGS (*expo, MPFR_FLAGS_INEXACT
| MPFR_FLAGS_OVERFLOW);
break;
}
}
k_non_zero = 1;
Ntmin = sizeof(mpfr_exp_t) * CHAR_BIT;
if (Ntmin > Nt)
{
Nt = Ntmin;
mpfr_set_prec (t, Nt);
}
mpfr_init2 (u, Nt);
mpfr_init2 (k, Ntmin);
mpfr_log2 (k, absx, MPFR_RNDN);
mpfr_mul (k, y, k, MPFR_RNDN);
mpfr_round (k, k);
MPFR_LOG_VAR (k);
/* |y| < 2^Ntmin, therefore |k| < 2^Nt. */
continue;
}
if (MPFR_LIKELY (MPFR_CAN_ROUND (t, Nt - err, Nz, rnd_mode)))
{
inexact = mpfr_set (z, t, rnd_mode);
break;
}
/* check exact power, except when y is an integer (since the
exact cases for y integer have already been filtered out) */
if (check_exact_case == 0 && ! y_is_integer)
{
if (mpfr_pow_is_exact (z, absx, y, rnd_mode, &inexact))
break;
check_exact_case = 1;
}
/* reactualisation of the precision */
MPFR_ZIV_NEXT (ziv_loop, Nt);
mpfr_set_prec (t, Nt);
if (k_non_zero)
mpfr_set_prec (u, Nt);
}
MPFR_ZIV_FREE (ziv_loop);
if (k_non_zero)
{
int inex2;
long lk;
/* The rounded result in an unbounded exponent range is z * 2^k. As
* MPFR chooses underflow after rounding, the mpfr_mul_2si below will
* correctly detect underflows and overflows. However, in rounding to
* nearest, if z * 2^k = 2^(emin - 2), then the double rounding may
* affect the result. We need to cope with that before overwriting z.
* This can occur only if k < 0 (this test is necessary to avoid a
* potential integer overflow).
* If inexact >= 0, then the real result is <= 2^(emin - 2), so that
* o(2^(emin - 2)) = +0 is correct. If inexact < 0, then the real
* result is > 2^(emin - 2) and we need to round to 2^(emin - 1).
*/
MPFR_ASSERTN (MPFR_EXP_MAX <= LONG_MAX);
lk = mpfr_get_si (k, MPFR_RNDN);
/* Due to early overflow detection, |k| should not be much larger than
* MPFR_EMAX_MAX, and as MPFR_EMAX_MAX <= MPFR_EXP_MAX/2 <= LONG_MAX/2,
* an overflow should not be possible in mpfr_get_si (and lk is exact).
* And one even has the following assertion. TODO: complete proof.
*/
MPFR_ASSERTD (lk > LONG_MIN && lk < LONG_MAX);
/* Note: even in case of overflow (lk inexact), the code is correct.
* Indeed, for the 3 occurrences of lk:
* - The test lk < 0 is correct as sign(lk) = sign(k).
* - In the test MPFR_GET_EXP (z) == __gmpfr_emin - 1 - lk,
* if lk is inexact, then lk = LONG_MIN <= MPFR_EXP_MIN
* (the minimum value of the mpfr_exp_t type), and
* __gmpfr_emin - 1 - lk >= MPFR_EMIN_MIN - 1 - 2 * MPFR_EMIN_MIN
* >= - MPFR_EMIN_MIN - 1 = MPFR_EMAX_MAX - 1. However, from the
* choice of k, z has been chosen to be around 1, so that the
* result of the test is false, as if lk were exact.
* - In the mpfr_mul_2si (z, z, lk, rnd_mode), if lk is inexact,
* then |lk| >= LONG_MAX >= MPFR_EXP_MAX, and as z is around 1,
* mpfr_mul_2si underflows or overflows in the same way as if
* lk were exact.
* TODO: give a bound on |t|, then on |EXP(z)|.
*/
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: as the minimum precision is > 1, we will
* obtain the correct result and exceptions by replacing z by
* nextabove(z).
*/
MPFR_ASSERTN (MPFR_PREC_MIN > 1);
mpfr_nextabove (z);
}
MPFR_CLEAR_FLAGS ();
inex2 = mpfr_mul_2si (z, z, lk, rnd_mode);
if (inex2) /* underflow or overflow */
{
inexact = inex2;
if (expo != NULL)
MPFR_SAVE_EXPO_UPDATE_FLAGS (*expo, __gmpfr_flags);
}
mpfr_clears (u, k, (mpfr_ptr) 0);
}
mpfr_clear (t);
/* update the sign of the result if x was negative */
if (neg_result)
{
MPFR_SET_NEG(z);
inexact = -inexact;
}
return inexact;
}
void FixComplexKCM::init()
{
if(lsb_in>msb_in)
{
throw string("FixComplexKCM: Error, lsbIn>msbIn");
}
// definition of the source file name, used for info and error reporting
// using REPORT
srcFileName="FixComplexKCM";
// definition of the name of the operator
ostringstream name;
name << "FixComplexKCM_" << vhdlize(msb_in) <<"_" << vhdlize(lsb_in)
<< "_" << vhdlize(lsb_out) << "_" << vhdlize(constant_re) << "_" <<
vhdlize(constant_im) << "_" << ((signedInput) ? "" : "un") <<
"signed" ;
setName(name.str());
// Copyright
setCopyrightString("3IF 2015 dev team (2015)");
input_width = 1 + msb_in - lsb_in;
// declaring inputs
addInput ("ReIN" , input_width);
addInput ("ImIN" , input_width);
//Computing constants for testBench and in order to know constant width
sollya_obj_t nodeIm, nodeRe;
nodeRe = sollya_lib_parse_string(constant_re.c_str());
if(sollya_lib_obj_is_error(nodeRe))
{
ostringstream error;
error << srcFileName <<" : Unable to parse string \"" <<
constant_re << "\" as a numeric constant" << endl;
throw error.str();
}
nodeIm = sollya_lib_parse_string(constant_im.c_str());
if(sollya_lib_obj_is_error(nodeIm))
{
ostringstream error;
error << srcFileName <<" : Unable to parse string \"" <<
constant_im << "\" as a numeric constant" << endl;
throw error.str();
}
mpfr_inits2(10000, mpfr_constant_re, mpfr_constant_im, NULL);
sollya_lib_get_constant(mpfr_constant_re, nodeRe);
sollya_lib_get_constant(mpfr_constant_im, nodeIm);
constantReNeg = (mpfr_sgn(mpfr_constant_re) < 0);
constantImNeg = (mpfr_sgn(mpfr_constant_im) < 0);
mpfr_t log2C;
mpfr_init2(log2C, 100);
//Constant real part width
mpfr_log2(log2C, mpfr_constant_re, GMP_RNDN);
constantReMsb = mpfr_get_si(log2C, GMP_RNDU);
//Constant imaginary part width
mpfr_log2(log2C, mpfr_constant_im, GMP_RNDN);
constantImMsb = mpfr_get_si(log2C, GMP_RNDU);
//Free
mpfr_clear(log2C);
int constantMaxMSB = max(constantReMsb, constantImMsb);
//Do we need an extra sign bit ?
bool extraSignBitRe = !signedInput && (constantReNeg || !constantImNeg);
bool extraSignBitIm = !signedInput && (constantReNeg || constantImNeg);
int msbout_re, msbout_im;
msbout_re = msbout_im = msb_in + constantMaxMSB +1;
if(extraSignBitRe)
{
msbout_re++;
}
if(extraSignBitIm)
{
msbout_im++;
}
outputre_width = msbout_re - lsb_out + 1;
outputim_width = msbout_im - lsb_out + 1;
if(outputre_width < 0 || outputim_width < 0)
{
THROWERROR("Computed msb will be lower than asked lsb."
" Result would always be zero ");
}
}
long MpfrFloat::toInt() const
{
return mpfr_get_si(mData->mFloat, GMP_RNDN);
}
/* tgeneric(prec_min, prec_max, step, exp_max) checks rounding with random
numbers:
- with precision ranging from prec_min to prec_max with an increment of
step,
- with exponent between -exp_max and exp_max.
It also checks parameter reuse (it is assumed here that either two mpc_t
variables are equal or they are different, in the sense that the real part
of one of them cannot be the imaginary part of the other). */
void
tgeneric (mpc_function function, mpfr_prec_t prec_min,
mpfr_prec_t prec_max, mpfr_prec_t step, mpfr_exp_t exp_max)
{
unsigned long ul1 = 0, ul2 = 0;
long lo = 0;
int i = 0;
mpfr_t x1, x2, xxxx;
mpc_t z1, z2, z3, z4, z5, zzzz, zzzz2;
mpfr_rnd_t rnd_re, rnd_im, rnd2_re, rnd2_im;
mpfr_prec_t prec;
mpfr_exp_t exp_min;
int special, special_cases;
mpc_init2 (z1, prec_max);
switch (function.type)
{
case C_CC:
mpc_init2 (z2, prec_max);
mpc_init2 (z3, prec_max);
mpc_init2 (z4, prec_max);
mpc_init2 (zzzz, 4*prec_max);
special_cases = 8;
break;
case CCCC:
mpc_init2 (z2, prec_max);
mpc_init2 (z3, prec_max);
mpc_init2 (z4, prec_max);
mpc_init2 (z5, prec_max);
mpc_init2 (zzzz, 4*prec_max);
special_cases = 8;
break;
case FC:
mpfr_init2 (x1, prec_max);
mpfr_init2 (x2, prec_max);
mpfr_init2 (xxxx, 4*prec_max);
mpc_init2 (z2, prec_max);
special_cases = 4;
break;
case CCF: case CFC:
mpfr_init2 (x1, prec_max);
mpc_init2 (z2, prec_max);
mpc_init2 (z3, prec_max);
mpc_init2 (zzzz, 4*prec_max);
special_cases = 6;
break;
case CCI: case CCS:
case CCU: case CUC:
mpc_init2 (z2, prec_max);
mpc_init2 (z3, prec_max);
mpc_init2 (zzzz, 4*prec_max);
special_cases = 5;
break;
case CUUC:
mpc_init2 (z2, prec_max);
mpc_init2 (z3, prec_max);
mpc_init2 (zzzz, 4*prec_max);
special_cases = 6;
break;
case CC_C:
mpc_init2 (z2, prec_max);
mpc_init2 (z3, prec_max);
mpc_init2 (z4, prec_max);
mpc_init2 (z5, prec_max);
mpc_init2 (zzzz, 4*prec_max);
mpc_init2 (zzzz2, 4*prec_max);
special_cases = 4;
break;
case CC:
default:
mpc_init2 (z2, prec_max);
mpc_init2 (z3, prec_max);
mpc_init2 (zzzz, 4*prec_max);
special_cases = 4;
}
exp_min = mpfr_get_emin ();
if (exp_max <= 0 || exp_max > mpfr_get_emax ())
exp_max = mpfr_get_emax();
if (-exp_max > exp_min)
exp_min = - exp_max;
if (step < 1)
step = 1;
for (prec = prec_min, special = 0;
prec <= prec_max || special <= special_cases;
prec+=step, special += (prec > prec_max ? 1 : 0)) {
/* In the end, test functions in special cases of purely real, purely
imaginary or infinite arguments. */
/* probability of one zero part in 256th (25 is almost 10%) */
const unsigned int zero_probability = special != 0 ? 0 : 25;
mpc_set_prec (z1, prec);
test_default_random (z1, exp_min, exp_max, 128, zero_probability);
switch (function.type)
{
case C_CC:
mpc_set_prec (z2, prec);
test_default_random (z2, exp_min, exp_max, 128, zero_probability);
mpc_set_prec (z3, prec);
mpc_set_prec (z4, prec);
mpc_set_prec (zzzz, 4*prec);
switch (special)
{
case 1:
mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
break;
case 2:
mpfr_set_inf (mpc_realref (z1), +1);
break;
case 3:
mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
break;
case 4:
mpfr_set_inf (mpc_imagref (z1), -1);
break;
case 5:
mpfr_set_ui (mpc_realref (z2), 0, MPFR_RNDN);
break;
case 6:
mpfr_set_inf (mpc_realref (z2), -1);
break;
case 7:
mpfr_set_ui (mpc_imagref (z2), 0, MPFR_RNDN);
break;
case 8:
mpfr_set_inf (mpc_imagref (z2), +1);
break;
}
break;
case CCCC:
mpc_set_prec (z2, prec);
test_default_random (z2, exp_min, exp_max, 128, zero_probability);
mpc_set_prec (z3, prec);
mpc_set_prec (z4, prec);
mpc_set_prec (z5, prec);
mpc_set_prec (zzzz, 4*prec);
switch (special)
{
case 1:
mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
break;
case 2:
mpfr_set_inf (mpc_realref (z1), +1);
break;
case 3:
mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
break;
case 4:
mpfr_set_inf (mpc_imagref (z1), -1);
break;
case 5:
mpfr_set_ui (mpc_realref (z2), 0, MPFR_RNDN);
break;
case 6:
mpfr_set_inf (mpc_realref (z2), -1);
break;
case 7:
mpfr_set_ui (mpc_imagref (z2), 0, MPFR_RNDN);
break;
case 8:
mpfr_set_inf (mpc_imagref (z2), +1);
break;
}
break;
case FC:
mpc_set_prec (z2, prec);
mpfr_set_prec (x1, prec);
mpfr_set_prec (x2, prec);
mpfr_set_prec (xxxx, 4*prec);
switch (special)
{
case 1:
mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
break;
case 2:
mpfr_set_inf (mpc_realref (z1), +1);
break;
case 3:
mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
break;
case 4:
mpfr_set_inf (mpc_imagref (z1), -1);
break;
}
break;
case CCU: case CUC:
mpc_set_prec (z2, 128);
do {
test_default_random (z2, 0, 64, 128, zero_probability);
} while (!mpfr_fits_ulong_p (mpc_realref (z2), MPFR_RNDN));
ul1 = mpfr_get_ui (mpc_realref(z2), MPFR_RNDN);
mpc_set_prec (z2, prec);
mpc_set_prec (z3, prec);
mpc_set_prec (zzzz, 4*prec);
switch (special)
{
case 1:
mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
break;
case 2:
mpfr_set_inf (mpc_realref (z1), +1);
break;
case 3:
mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
break;
case 4:
mpfr_set_inf (mpc_imagref (z1), -1);
break;
case 5:
ul1 = 0;
break;
}
break;
case CUUC:
mpc_set_prec (z2, 128);
do {
test_default_random (z2, 0, 64, 128, zero_probability);
} while (!mpfr_fits_ulong_p (mpc_realref (z2), MPFR_RNDN)
||!mpfr_fits_ulong_p (mpc_imagref (z2), MPFR_RNDN));
ul1 = mpfr_get_ui (mpc_realref(z2), MPFR_RNDN);
ul2 = mpfr_get_ui (mpc_imagref(z2), MPFR_RNDN);
mpc_set_prec (z2, prec);
mpc_set_prec (z3, prec);
mpc_set_prec (zzzz, 4*prec);
switch (special)
{
case 1:
mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
break;
case 2:
mpfr_set_inf (mpc_realref (z1), +1);
break;
case 3:
mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
break;
case 4:
mpfr_set_inf (mpc_imagref (z1), -1);
break;
case 5:
ul1 = 0;
break;
case 6:
ul2 = 0;
break;
}
break;
case CCS:
mpc_set_prec (z2, 128);
do {
test_default_random (z2, 0, 64, 128, zero_probability);
} while (!mpfr_fits_slong_p (mpc_realref (z2), MPFR_RNDN));
lo = mpfr_get_si (mpc_realref(z2), MPFR_RNDN);
mpc_set_prec (z2, prec);
mpc_set_prec (z3, prec);
mpc_set_prec (zzzz, 4*prec);
switch (special)
{
case 1:
mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
break;
case 2:
mpfr_set_inf (mpc_realref (z1), +1);
break;
case 3:
mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
break;
case 4:
mpfr_set_inf (mpc_imagref (z1), -1);
break;
case 5:
lo = 0;
break;
}
break;
case CCI:
mpc_set_prec (z2, 128);
do {
test_default_random (z2, 0, 64, 128, zero_probability);
} while (!mpfr_fits_slong_p (mpc_realref (z2), MPFR_RNDN));
i = (int)mpfr_get_si (mpc_realref(z2), MPFR_RNDN);
mpc_set_prec (z2, prec);
mpc_set_prec (z3, prec);
mpc_set_prec (zzzz, 4*prec);
switch (special)
{
case 1:
mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
break;
case 2:
mpfr_set_inf (mpc_realref (z1), +1);
break;
case 3:
mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
break;
case 4:
mpfr_set_inf (mpc_imagref (z1), -1);
break;
case 5:
i = 0;
break;
}
break;
case CCF: case CFC:
mpfr_set_prec (x1, prec);
mpfr_set (x1, mpc_realref (z1), MPFR_RNDN);
test_default_random (z1, exp_min, exp_max, 128, zero_probability);
mpc_set_prec (z2, prec);
mpc_set_prec (z3, prec);
mpc_set_prec (zzzz, 4*prec);
switch (special)
{
case 1:
mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
break;
case 2:
mpfr_set_inf (mpc_realref (z1), +1);
break;
case 3:
mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
break;
case 4:
mpfr_set_inf (mpc_imagref (z1), -1);
break;
case 5:
mpfr_set_ui (x1, 0, MPFR_RNDN);
break;
case 6:
mpfr_set_inf (x1, +1);
break;
}
break;
case CC_C:
mpc_set_prec (z2, prec);
mpc_set_prec (z3, prec);
mpc_set_prec (z4, prec);
mpc_set_prec (z5, prec);
mpc_set_prec (zzzz, 4*prec);
mpc_set_prec (zzzz2, 4*prec);
switch (special)
{
case 1:
mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
break;
case 2:
mpfr_set_inf (mpc_realref (z1), +1);
break;
case 3:
mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
break;
case 4:
mpfr_set_inf (mpc_imagref (z1), -1);
break;
}
break;
case CC:
default:
mpc_set_prec (z2, prec);
mpc_set_prec (z3, prec);
mpc_set_prec (zzzz, 4*prec);
switch (special)
{
case 1:
mpfr_set_ui (mpc_realref (z1), 0, MPFR_RNDN);
break;
case 2:
mpfr_set_inf (mpc_realref (z1), +1);
break;
case 3:
mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
break;
case 4:
mpfr_set_inf (mpc_imagref (z1), -1);
break;
}
}
for (rnd_re = first_rnd_mode (); is_valid_rnd_mode (rnd_re); rnd_re = next_rnd_mode (rnd_re))
switch (function.type)
{
case C_CC:
for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
tgeneric_c_cc (&function, z1, z2, z3, zzzz, z4,
MPC_RND (rnd_re, rnd_im));
reuse_c_cc (&function, z1, z2, z3, z4);
break;
case CCCC:
for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
tgeneric_cccc (&function, z1, z2, z3, z4, zzzz, z5,
MPC_RND (rnd_re, rnd_im));
reuse_cccc (&function, z1, z2, z3, z4, z5);
break;
case FC:
tgeneric_fc (&function, z1, x1, xxxx, x2, rnd_re);
reuse_fc (&function, z1, z2, x1);
break;
case CC:
for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
tgeneric_cc (&function, z1, z2, zzzz, z3,
MPC_RND (rnd_re, rnd_im));
reuse_cc (&function, z1, z2, z3);
break;
case CC_C:
for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
for (rnd2_re = first_rnd_mode (); is_valid_rnd_mode (rnd2_re); rnd2_re = next_rnd_mode (rnd2_re))
for (rnd2_im = first_rnd_mode (); is_valid_rnd_mode (rnd2_im); rnd2_im = next_rnd_mode (rnd2_im))
tgeneric_cc_c (&function, z1, z2, z3, zzzz, zzzz2, z4, z5,
MPC_RND (rnd_re, rnd_im), MPC_RND (rnd2_re, rnd2_im));
reuse_cc_c (&function, z1, z2, z3, z4, z5);
break;
case CFC:
for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
tgeneric_cfc (&function, x1, z1, z2, zzzz, z3,
MPC_RND (rnd_re, rnd_im));
reuse_cfc (&function, z1, x1, z2, z3);
break;
case CCF:
for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
tgeneric_ccf (&function, z1, x1, z2, zzzz, z3,
MPC_RND (rnd_re, rnd_im));
reuse_ccf (&function, z1, x1, z2, z3);
break;
case CCU:
for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
tgeneric_ccu (&function, z1, ul1, z2, zzzz, z3,
MPC_RND (rnd_re, rnd_im));
reuse_ccu (&function, z1, ul1, z2, z3);
break;
case CUC:
for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
tgeneric_cuc (&function, ul1, z1, z2, zzzz, z3,
MPC_RND (rnd_re, rnd_im));
reuse_cuc (&function, ul1, z1, z2, z3);
break;
case CCS:
for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
tgeneric_ccs (&function, z1, lo, z2, zzzz, z3,
MPC_RND (rnd_re, rnd_im));
reuse_ccs (&function, z1, lo, z2, z3);
break;
case CCI:
for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
tgeneric_cci (&function, z1, i, z2, zzzz, z3,
MPC_RND (rnd_re, rnd_im));
reuse_cci (&function, z1, i, z2, z3);
break;
case CUUC:
for (rnd_im = first_rnd_mode (); is_valid_rnd_mode (rnd_im); rnd_im = next_rnd_mode (rnd_im))
tgeneric_cuuc (&function, ul1, ul2, z1, z2, zzzz, z3,
MPC_RND (rnd_re, rnd_im));
reuse_cuuc (&function, ul1, ul2, z1, z2, z3);
break;
default:
printf ("tgeneric not yet implemented for this kind of"
"function\n");
exit (1);
}
}
mpc_clear (z1);
switch (function.type)
{
case C_CC:
mpc_clear (z2);
mpc_clear (z3);
mpc_clear (z4);
mpc_clear (zzzz);
break;
case CCCC:
mpc_clear (z2);
mpc_clear (z3);
mpc_clear (z4);
mpc_clear (z5);
mpc_clear (zzzz);
break;
case FC:
mpc_clear (z2);
mpfr_clear (x1);
mpfr_clear (x2);
mpfr_clear (xxxx);
break;
case CCF: case CFC:
mpfr_clear (x1);
mpc_clear (z2);
mpc_clear (z3);
mpc_clear (zzzz);
break;
case CC_C:
mpc_clear (z2);
mpc_clear (z3);
mpc_clear (z4);
mpc_clear (z5);
mpc_clear (zzzz);
mpc_clear (zzzz2);
break;
case CUUC:
case CCI: case CCS:
case CCU: case CUC:
case CC:
default:
mpc_clear (z2);
mpc_clear (z3);
mpc_clear (zzzz);
}
}
/* Compare the result (z1,inex1) of mpfr_pow with all flags cleared
with those of mpfr_pow with all flags set and of the other power
functions. Arguments x and y are the input values; sx and sy are
their string representations (sx may be null); rnd contains the
rounding mode; s is a string containing the function that called
test_others. */
static void
test_others (const void *sx, const char *sy, mpfr_rnd_t rnd,
mpfr_srcptr x, mpfr_srcptr y, mpfr_srcptr z1,
int inex1, unsigned int flags, const char *s)
{
mpfr_t z2;
int inex2;
int spx = sx != NULL;
if (!spx)
sx = x;
mpfr_init2 (z2, mpfr_get_prec (z1));
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_pow (z2, x, y, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_pow, flags set");
/* If y is an integer that fits in an unsigned long and is not -0,
we can test mpfr_pow_ui. */
if (MPFR_IS_POS (y) && mpfr_integer_p (y) &&
mpfr_fits_ulong_p (y, MPFR_RNDN))
{
unsigned long yy = mpfr_get_ui (y, MPFR_RNDN);
mpfr_clear_flags ();
inex2 = mpfr_pow_ui (z2, x, yy, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, flags,
s, "mpfr_pow_ui, flags cleared");
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_pow_ui (z2, x, yy, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_pow_ui, flags set");
/* If x is an integer that fits in an unsigned long and is not -0,
we can also test mpfr_ui_pow_ui. */
if (MPFR_IS_POS (x) && mpfr_integer_p (x) &&
mpfr_fits_ulong_p (x, MPFR_RNDN))
{
unsigned long xx = mpfr_get_ui (x, MPFR_RNDN);
mpfr_clear_flags ();
inex2 = mpfr_ui_pow_ui (z2, xx, yy, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, flags,
s, "mpfr_ui_pow_ui, flags cleared");
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_ui_pow_ui (z2, xx, yy, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_ui_pow_ui, flags set");
}
}
/* If y is an integer but not -0 and not huge, we can test mpfr_pow_z,
and possibly mpfr_pow_si (and possibly mpfr_ui_div). */
if (MPFR_IS_ZERO (y) ? MPFR_IS_POS (y) :
(mpfr_integer_p (y) && MPFR_GET_EXP (y) < 256))
{
mpz_t yyy;
/* If y fits in a long, we can test mpfr_pow_si. */
if (mpfr_fits_slong_p (y, MPFR_RNDN))
{
long yy = mpfr_get_si (y, MPFR_RNDN);
mpfr_clear_flags ();
inex2 = mpfr_pow_si (z2, x, yy, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, flags,
s, "mpfr_pow_si, flags cleared");
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_pow_si (z2, x, yy, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_pow_si, flags set");
/* If y = -1, we can test mpfr_ui_div. */
if (yy == -1)
{
mpfr_clear_flags ();
inex2 = mpfr_ui_div (z2, 1, x, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, flags,
s, "mpfr_ui_div, flags cleared");
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_ui_div (z2, 1, x, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_ui_div, flags set");
}
/* If y = 2, we can test mpfr_sqr. */
if (yy == 2)
{
mpfr_clear_flags ();
inex2 = mpfr_sqr (z2, x, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, flags,
s, "mpfr_sqr, flags cleared");
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_sqr (z2, x, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_sqr, flags set");
}
}
/* Test mpfr_pow_z. */
mpz_init (yyy);
mpfr_get_z (yyy, y, MPFR_RNDN);
mpfr_clear_flags ();
inex2 = mpfr_pow_z (z2, x, yyy, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, flags,
s, "mpfr_pow_z, flags cleared");
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_pow_z (z2, x, yyy, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_pow_z, flags set");
mpz_clear (yyy);
}
/* If y = 0.5, we can test mpfr_sqrt, except if x is -0 or -Inf (because
the rule for mpfr_pow on these special values is different). */
if (MPFR_IS_PURE_FP (y) && mpfr_cmp_str1 (y, "0.5") == 0 &&
! ((MPFR_IS_ZERO (x) || MPFR_IS_INF (x)) && MPFR_IS_NEG (x)))
{
mpfr_clear_flags ();
inex2 = mpfr_sqrt (z2, x, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, flags,
s, "mpfr_sqrt, flags cleared");
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_sqrt (z2, x, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_sqrt, flags set");
}
#if MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)
/* If y = -0.5, we can test mpfr_rec_sqrt, except if x = -Inf
(because the rule for mpfr_pow on -Inf is different). */
if (MPFR_IS_PURE_FP (y) && mpfr_cmp_str1 (y, "-0.5") == 0 &&
! (MPFR_IS_INF (x) && MPFR_IS_NEG (x)))
{
mpfr_clear_flags ();
inex2 = mpfr_rec_sqrt (z2, x, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, flags,
s, "mpfr_rec_sqrt, flags cleared");
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_rec_sqrt (z2, x, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_rec_sqrt, flags set");
}
#endif
/* If x is an integer that fits in an unsigned long and is not -0,
we can test mpfr_ui_pow. */
if (MPFR_IS_POS (x) && mpfr_integer_p (x) &&
mpfr_fits_ulong_p (x, MPFR_RNDN))
{
unsigned long xx = mpfr_get_ui (x, MPFR_RNDN);
mpfr_clear_flags ();
inex2 = mpfr_ui_pow (z2, xx, y, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, flags,
s, "mpfr_ui_pow, flags cleared");
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_ui_pow (z2, xx, y, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_ui_pow, flags set");
/* If x = 2, we can test mpfr_exp2. */
if (xx == 2)
{
mpfr_clear_flags ();
inex2 = mpfr_exp2 (z2, y, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, flags,
s, "mpfr_exp2, flags cleared");
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_exp2 (z2, y, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_exp2, flags set");
}
/* If x = 10, we can test mpfr_exp10. */
if (xx == 10)
{
mpfr_clear_flags ();
inex2 = mpfr_exp10 (z2, y, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, flags,
s, "mpfr_exp10, flags cleared");
__gmpfr_flags = MPFR_FLAGS_ALL;
inex2 = mpfr_exp10 (z2, y, rnd);
cmpres (spx, sx, sy, rnd, z1, inex1, z2, inex2, MPFR_FLAGS_ALL,
s, "mpfr_exp10, flags set");
}
}
mpfr_clear (z2);
}
