static void
check_random (mpfr_prec_t p)
{
mpfr_t a1,b,c,a2;
int r;
int i, inexact1, inexact2;
mpfr_inits2 (p, a1, b, c, a2, (mpfr_ptr) 0);
for (i = 0 ; i < 500 ; i++)
{
mpfr_urandomb (b, RANDS);
mpfr_urandomb (c, RANDS);
if (MPFR_IS_PURE_FP(b) && MPFR_IS_PURE_FP(c))
{
if (MPFR_GET_EXP(b) < MPFR_GET_EXP(c))
mpfr_swap(b, c);
if (MPFR_IS_PURE_FP(b) && MPFR_IS_PURE_FP(c))
for (r = 0 ; r < MPFR_RND_MAX ; r++)
{
inexact1 = mpfr_add1(a1, b, c, (mpfr_rnd_t) r);
inexact2 = mpfr_add1sp(a2, b, c, (mpfr_rnd_t) r);
if (mpfr_cmp(a1, a2))
STD_ERROR;
if (inexact1 != inexact2)
STD_ERROR2;
}
}
}
mpfr_clears (a1, a2, b, c, (mpfr_ptr) 0);
}
static void
check_random (mpfr_prec_t p)
{
mpfr_t x,y,z,x2;
int r;
int i, inexact1, inexact2;
mpfr_inits2 (p, x, y, z, x2, (mpfr_ptr) 0);
for (i = 0 ; i < 500 ; i++)
{
mpfr_urandomb (y, RANDS);
mpfr_urandomb (z, RANDS);
if (MPFR_IS_PURE_FP(y) && MPFR_IS_PURE_FP(z))
for(r = 0 ; r < GMP_RND_MAX ; r++)
{
inexact1 = mpfr_sub1(x2, y, z, (mp_rnd_t) r);
inexact2 = mpfr_sub1sp(x, y, z, (mp_rnd_t) r);
if (mpfr_cmp(x, x2))
STD_ERROR;
if (inexact1 != inexact2)
STD_ERROR2;
}
}
mpfr_clears (x, y, z, x2, (mpfr_ptr) 0);
}
int
mpfr_check_range (mpfr_ptr x, int t, mp_rnd_t rnd_mode)
{
if (MPFR_LIKELY( MPFR_IS_PURE_FP(x)) )
{ /* x is a non-zero FP */
mp_exp_t exp = MPFR_EXP (x); /* Do not use MPFR_GET_EXP */
if (MPFR_UNLIKELY( exp < __gmpfr_emin) )
{
/* The following test is necessary because in the rounding to the
* nearest mode, mpfr_underflow always rounds away from 0. In
* this rounding mode, we need to round to 0 if:
* _ |x| < 2^(emin-2), or
* _ |x| = 2^(emin-2) and the absolute value of the exact
* result is <= 2^(emin-2).
*/
if (rnd_mode == GMP_RNDN &&
(exp + 1 < __gmpfr_emin ||
(mpfr_powerof2_raw(x) &&
(MPFR_IS_NEG(x) ? t <= 0 : t >= 0))))
rnd_mode = GMP_RNDZ;
return mpfr_underflow(x, rnd_mode, MPFR_SIGN(x));
}
if (MPFR_UNLIKELY( exp > __gmpfr_emax) )
return mpfr_overflow(x, rnd_mode, MPFR_SIGN(x));
}
MPFR_RET (t); /* propagate inexact ternary value, unlike most functions */
}
int
mpfr_div_2si (mpfr_ptr y, mpfr_srcptr x, long int n, mp_rnd_t rnd_mode)
{
int inexact;
MPFR_LOG_FUNC (("x[%#R]=%R n=%ld rnd=%d", x, x, n, rnd_mode),
("y[%#R]=%R inexact=%d", y, y, inexact));
inexact = MPFR_UNLIKELY(y != x) ? mpfr_set (y, x, rnd_mode) : 0;
if (MPFR_LIKELY( MPFR_IS_PURE_FP(y) ))
{
mp_exp_t exp = MPFR_GET_EXP (y);
if (MPFR_UNLIKELY( n > 0 && (__gmpfr_emin > MPFR_EMAX_MAX - n ||
exp < __gmpfr_emin + n)) )
{
if (rnd_mode == GMP_RNDN &&
(__gmpfr_emin > MPFR_EMAX_MAX - (n - 1) ||
exp < __gmpfr_emin + (n - 1) ||
(inexact >= 0 && mpfr_powerof2_raw (y))))
rnd_mode = GMP_RNDZ;
return mpfr_underflow (y, rnd_mode, MPFR_SIGN(y));
}
if (MPFR_UNLIKELY(n < 0 && (__gmpfr_emax < MPFR_EMIN_MIN - n ||
exp > __gmpfr_emax + n)) )
return mpfr_overflow (y, rnd_mode, MPFR_SIGN(y));
MPFR_SET_EXP (y, exp - n);
}
return inexact;
}
/* pos is 512 times the proportion of negative numbers.
If pos=256, half of the numbers are negative.
If pos=0, all generated numbers are positive.
*/
void
tests_default_random (mpfr_ptr x, int pos, mpfr_exp_t emin, mpfr_exp_t emax,
int always_scale)
{
MPFR_ASSERTN (emin <= emax);
MPFR_ASSERTN (emin >= MPFR_EMIN_MIN);
MPFR_ASSERTN (emax <= MPFR_EMAX_MAX);
/* but it isn't required that emin and emax are in the current
exponent range (see below), so that underflow/overflow checks
can be done on 64-bit machines without a manual change of the
exponent range (well, this is a bit ugly...). */
mpfr_urandomb (x, RANDS);
if (MPFR_IS_PURE_FP (x) && (emin >= 1 || always_scale || (randlimb () & 1)))
{
mpfr_exp_t e;
e = emin + (mpfr_exp_t) (randlimb () % (emax - emin + 1));
/* Note: There should be no overflow here because both terms are
between MPFR_EMIN_MIN and MPFR_EMAX_MAX. */
MPFR_ASSERTD (e >= emin && e <= emax);
if (mpfr_set_exp (x, e))
{
/* The random number doesn't fit in the current exponent range.
In this case, test the function in the extended exponent range,
which should be restored by the caller. */
mpfr_set_emin (MPFR_EMIN_MIN);
mpfr_set_emax (MPFR_EMAX_MAX);
mpfr_set_exp (x, e);
}
}
if (randlimb () % 512 < pos)
mpfr_neg (x, x, MPFR_RNDN);
}
/* pos is 512 times the proportion of negative numbers.
If pos=256, half of the numbers are negative.
If pos=0, all generated numbers are positive.
*/
void
tests_default_random (mpfr_ptr x, int pos, mpfr_exp_t emin, mpfr_exp_t emax)
{
MPFR_ASSERTN (emin <= emax);
MPFR_ASSERTN (emin >= MPFR_EMIN_MIN);
MPFR_ASSERTN (emax <= MPFR_EMAX_MAX);
/* but it isn't required that emin and emax are in the current
exponent range (see below), so that underflow/overflow checks
can be done on 64-bit machines. */
mpfr_urandomb (x, RANDS);
if (MPFR_IS_PURE_FP (x) && (emin >= 1 || (randlimb () & 1)))
{
mpfr_exp_t e;
e = MPFR_GET_EXP (x) +
(emin + (long) (randlimb () % (emax - emin + 1)));
/* Note: There should be no overflow here because both terms are
between MPFR_EMIN_MIN and MPFR_EMAX_MAX, but the sum e isn't
necessarily between MPFR_EMIN_MIN and MPFR_EMAX_MAX. */
if (mpfr_set_exp (x, e))
{
/* The random number doesn't fit in the current exponent range.
In this case, test the function in the extended exponent range,
which should be restored by the caller. */
mpfr_set_emin (MPFR_EMIN_MIN);
mpfr_set_emax (MPFR_EMAX_MAX);
mpfr_set_exp (x, e);
}
}
if (randlimb () % 512 < pos)
mpfr_neg (x, x, MPFR_RNDN);
}
int
mpfr_check_range (mpfr_ptr x, int t, mpfr_rnd_t rnd_mode)
{
if (MPFR_LIKELY( MPFR_IS_PURE_FP(x)) )
{ /* x is a non-zero FP */
mpfr_exp_t exp = MPFR_EXP (x); /* Do not use MPFR_GET_EXP */
/* Even if it is unlikely that exp is lower than emin,
this function is called by MPFR functions only if it is
already the case (or if exp is greater than emax) */
if (exp < __gmpfr_emin)
{
/* The following test is necessary because in the rounding to the
* nearest mode, mpfr_underflow always rounds away from 0. In
* this rounding mode, we need to round to 0 if:
* _ |x| < 2^(emin-2), or
* _ |x| = 2^(emin-2) and the absolute value of the exact
* result is <= 2^(emin-2).
*/
if (rnd_mode == MPFR_RNDN &&
(exp + 1 < __gmpfr_emin ||
(mpfr_powerof2_raw(x) &&
(MPFR_IS_NEG(x) ? t <= 0 : t >= 0))))
rnd_mode = MPFR_RNDZ;
return mpfr_underflow(x, rnd_mode, MPFR_SIGN(x));
}
if (exp > __gmpfr_emax)
return mpfr_overflow (x, rnd_mode, MPFR_SIGN(x));
}
else if (MPFR_UNLIKELY (t != 0 && MPFR_IS_INF (x)))
{
/* We need to do the following because most MPFR functions are
* implemented in the following way:
* Ziv's loop:
* | Compute an approximation to the result and an error bound.
* | Possible underflow/overflow detection -> return.
* | If can_round, break (exit the loop).
* | Otherwise, increase the working precision and loop.
* Round the approximation in the target precision. <== See below
* Restore the flags (that could have been set due to underflows
* or overflows during the internal computations).
* Execute: return mpfr_check_range (...).
* The problem is that an overflow could be generated when rounding the
* approximation (in general, such an overflow could not be detected
* earlier), and the overflow flag is lost when the flags are restored.
* This can occur only when the rounding yields an exponent change
* and the new exponent is larger than the maximum exponent, so that
* an infinity is necessarily obtained.
* So, the simplest solution is to detect this overflow case here in
* mpfr_check_range, which is easy to do since the rounded result is
* necessarily an inexact infinity.
*/
__gmpfr_flags |= MPFR_FLAGS_OVERFLOW;
}
MPFR_RET (t); /* propagate inexact ternary value, unlike most functions */
}
/* 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);
}
double
mpfr_get_d_2exp (long *expptr, mpfr_srcptr src, mpfr_rnd_t rnd_mode)
{
double ret;
mpfr_exp_t exp;
mpfr_t tmp;
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (src)))
{
int negative;
*expptr = 0;
if (MPFR_IS_NAN (src))
return MPFR_DBL_NAN;
negative = MPFR_IS_NEG (src);
if (MPFR_IS_INF (src))
return negative ? MPFR_DBL_INFM : MPFR_DBL_INFP;
MPFR_ASSERTD (MPFR_IS_ZERO(src));
return negative ? DBL_NEG_ZERO : 0.0;
}
tmp[0] = *src; /* Hack copy mpfr_t */
MPFR_SET_EXP (tmp, 0);
ret = mpfr_get_d (tmp, rnd_mode);
if (MPFR_IS_PURE_FP(src))
{
exp = MPFR_GET_EXP (src);
/* rounding can give 1.0, adjust back to 0.5 <= abs(ret) < 1.0 */
if (ret == 1.0)
{
ret = 0.5;
exp++;
}
else if (ret == -1.0)
{
ret = -0.5;
exp++;
}
MPFR_ASSERTN ((ret >= 0.5 && ret < 1.0)
|| (ret <= -0.5 && ret > -1.0));
MPFR_ASSERTN (exp >= LONG_MIN && exp <= LONG_MAX);
}
else
exp = 0;
*expptr = exp;
return ret;
}
int
mpfr_set_exp (mpfr_ptr x, mpfr_exp_t exponent)
{
if (MPFR_LIKELY (MPFR_IS_PURE_FP (x) &&
exponent >= __gmpfr_emin &&
exponent <= __gmpfr_emax))
{
MPFR_EXP(x) = exponent; /* do not use MPFR_SET_EXP of course... */
return 0;
}
else
{
return 1;
}
}
int
mpfr_div_2ui (mpfr_ptr y, mpfr_srcptr x, unsigned long n, mpfr_rnd_t rnd_mode)
{
int inexact;
MPFR_LOG_FUNC (("x[%#R]=%R n=%lu rnd=%d", x, x, n, rnd_mode),
("y[%#R]=%R inexact=%d", y, y, inexact));
/* Most of the times, this function is called with y==x */
inexact = MPFR_UNLIKELY(y != x) ? mpfr_set (y, x, rnd_mode) : 0;
if (MPFR_LIKELY( MPFR_IS_PURE_FP(y)) )
{
/* n will have to be casted to long to make sure that the addition
and subtraction below (for overflow detection) are signed */
while (MPFR_UNLIKELY(n > LONG_MAX))
{
int inex2;
n -= LONG_MAX;
inex2 = mpfr_div_2ui(y, y, LONG_MAX, rnd_mode);
if (inex2)
return inex2; /* underflow */
}
/* MPFR_EMAX_MAX - (long) n is signed and doesn't lead to an integer
overflow; the first test useful so that the real test can't lead
to an integer overflow. */
{
mpfr_exp_t exp = MPFR_GET_EXP (y);
if (MPFR_UNLIKELY( __gmpfr_emin > MPFR_EMAX_MAX - (long) n ||
exp < __gmpfr_emin + (long) n) )
{
if (rnd_mode == MPFR_RNDN &&
(__gmpfr_emin > MPFR_EMAX_MAX - (long) (n - 1) ||
exp < __gmpfr_emin + (long) (n - 1) ||
(inexact >= 0 && mpfr_powerof2_raw (y))))
rnd_mode = MPFR_RNDZ;
return mpfr_underflow (y, rnd_mode, MPFR_SIGN(y));
}
MPFR_SET_EXP(y, exp - (long) n);
}
}
return inexact;
}
int
mpfr_mul_2ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int n, mpfr_rnd_t rnd_mode)
{
int inexact;
MPFR_LOG_FUNC
(("x[%Pu]=%.*Rg n=%lu rnd=%d",
mpfr_get_prec (x), mpfr_log_prec, x, n, rnd_mode),
("y[%Pu]=%.*Rg inexact=%d",
mpfr_get_prec (y), mpfr_log_prec, y, inexact));
inexact = MPFR_UNLIKELY(y != x) ? mpfr_set (y, x, rnd_mode) : 0;
if (MPFR_LIKELY( MPFR_IS_PURE_FP(y)) )
{
/* n will have to be casted to long to make sure that the addition
and subtraction below (for overflow detection) are signed */
while (MPFR_UNLIKELY(n > LONG_MAX))
{
int inex2;
n -= LONG_MAX;
inex2 = mpfr_mul_2ui(y, y, LONG_MAX, rnd_mode);
if (inex2)
return inex2; /* overflow */
}
/* MPFR_EMIN_MIN + (long) n is signed and doesn't lead to an overflow;
the first test useful so that the real test can't lead to an
overflow. */
{
mpfr_exp_t exp = MPFR_GET_EXP (y);
if (MPFR_UNLIKELY( __gmpfr_emax < MPFR_EMIN_MIN + (long) n ||
exp > __gmpfr_emax - (long) n))
return mpfr_overflow (y, rnd_mode, MPFR_SIGN(y));
MPFR_SET_EXP (y, exp + (long) n);
}
}
return inexact;
}
static mpfr_prec_t
get_prec_max (mpfr_t *t, int n)
{
mpfr_exp_t e, min, max;
int i;
min = MPFR_EMAX_MAX;
max = MPFR_EMIN_MIN;
for (i = 0; i < n; i++)
if (MPFR_IS_PURE_FP (t[i]))
{
e = MPFR_GET_EXP (t[i]);
if (e > max)
max = e;
e -= MPFR_GET_PREC (t[i]);
if (e < min)
min = e;
}
return min > max ? MPFR_PREC_MIN /* no pure FP values */
: max - min + __gmpfr_ceil_log2 (n);
}
static void
check_random (mpfr_prec_t p)
{
mpfr_t x,y,z;
int r;
int i, inexact1, inexact2;
mpfr_inits2 (p, x, y, z, (mpfr_ptr) 0);
for(i = 0 ; i < 500 ; i++)
{
mpfr_urandomb (x, RANDS);
if (MPFR_IS_PURE_FP(x))
for (r = 0 ; r < MPFR_RND_MAX ; r++)
{
inexact1 = mpfr_mul (y, x, x, (mpfr_rnd_t) r);
inexact2 = mpfr_sqr (z, x, (mpfr_rnd_t) r);
if (mpfr_cmp (y, z))
error1 ((mpfr_rnd_t) r,p,x,y,z);
if (inexact_sign (inexact1) != inexact_sign (inexact2))
error2 ((mpfr_rnd_t) r,p,x,y,inexact1,inexact2);
}
}
mpfr_clears (x, y, z, (mpfr_ptr) 0);
}
int
mpfr_cmp2 (mpfr_srcptr b, mpfr_srcptr c, mp_prec_t *cancel)
{
mp_limb_t *bp, *cp, bb, cc = 0, lastc = 0, dif, high_dif = 0;
mp_size_t bn, cn;
mp_exp_unsigned_t diff_exp;
mp_prec_t res = 0;
int sign;
/* b=c should not happen, since cmp2 is called only from agm
(with different variables), and from sub1 (if same b=c, then
sub1sp would be called instead */
MPFR_ASSERTD (b != c);
/* the cases b=0 or c=0 are also treated apart in agm and sub
(which calls sub1) */
MPFR_ASSERTD (MPFR_IS_PURE_FP(b));
MPFR_ASSERTD (MPFR_IS_PURE_FP(c));
if (MPFR_GET_EXP (b) >= MPFR_GET_EXP (c))
{
sign = 1;
diff_exp = (mp_exp_unsigned_t) MPFR_GET_EXP (b) - MPFR_GET_EXP (c);
bp = MPFR_MANT(b);
cp = MPFR_MANT(c);
bn = (MPFR_PREC(b) - 1) / BITS_PER_MP_LIMB;
cn = (MPFR_PREC(c) - 1) / BITS_PER_MP_LIMB;
if (MPFR_UNLIKELY( diff_exp == 0 ))
{
while (bn >= 0 && cn >= 0 && bp[bn] == cp[cn])
{
bn--;
cn--;
res += BITS_PER_MP_LIMB;
}
if (MPFR_UNLIKELY (bn < 0))
{
if (MPFR_LIKELY (cn < 0)) /* b = c */
return 0;
bp = cp;
bn = cn;
cn = -1;
sign = -1;
}
if (MPFR_UNLIKELY (cn < 0))
/* c discards exactly the upper part of b */
{
unsigned int z;
MPFR_ASSERTD (bn >= 0);
while (bp[bn] == 0)
{
if (--bn < 0) /* b = c */
return 0;
res += BITS_PER_MP_LIMB;
}
count_leading_zeros(z, bp[bn]); /* bp[bn] <> 0 */
*cancel = res + z;
return sign;
}
MPFR_ASSERTD (bn >= 0);
MPFR_ASSERTD (cn >= 0);
MPFR_ASSERTD (bp[bn] != cp[cn]);
if (bp[bn] < cp[cn])
{
mp_limb_t *tp;
mp_size_t tn;
tp = bp; bp = cp; cp = tp;
tn = bn; bn = cn; cn = tn;
sign = -1;
}
}
} /* MPFR_EXP(b) >= MPFR_EXP(c) */
else /* MPFR_EXP(b) < MPFR_EXP(c) */
{
sign = -1;
diff_exp = (mp_exp_unsigned_t) MPFR_GET_EXP (c) - MPFR_GET_EXP (b);
bp = MPFR_MANT(c);
cp = MPFR_MANT(b);
bn = (MPFR_PREC(c) - 1) / BITS_PER_MP_LIMB;
cn = (MPFR_PREC(b) - 1) / BITS_PER_MP_LIMB;
}
/* now we have removed the identical upper limbs of b and c
(can happen only when diff_exp = 0), and after the possible
swap, we have |b| > |c|: bp[bn] > cc, bn >= 0, cn >= 0 */
if (MPFR_LIKELY (diff_exp < BITS_PER_MP_LIMB))
{
cc = cp[cn] >> diff_exp;
/* warning: a shift by BITS_PER_MP_LIMB may give wrong results */
if (diff_exp)
lastc = cp[cn] << (BITS_PER_MP_LIMB - diff_exp);
cn--;
}
static void
tst (void)
{
int sv = sizeof (val) / sizeof (*val);
int i, j;
int rnd;
mpfr_t x, y, z, tmp;
mpfr_inits2 (53, x, y, z, tmp, (mpfr_ptr) 0);
for (i = 0; i < sv; i++)
for (j = 0; j < sv; j++)
RND_LOOP (rnd)
{
int exact, inex;
unsigned int flags;
if (my_setstr (x, val[i]) || my_setstr (y, val[j]))
{
printf ("internal error for (%d,%d,%d)\n", i, j, rnd);
exit (1);
}
mpfr_clear_flags ();
inex = mpfr_pow (z, x, y, (mpfr_rnd_t) rnd);
flags = __gmpfr_flags;
if (! MPFR_IS_NAN (z) && mpfr_nanflag_p ())
err ("got NaN flag without NaN value", i, j, rnd, z, inex);
if (MPFR_IS_NAN (z) && ! mpfr_nanflag_p ())
err ("got NaN value without NaN flag", i, j, rnd, z, inex);
if (inex != 0 && ! mpfr_inexflag_p ())
err ("got non-zero ternary value without inexact flag",
i, j, rnd, z, inex);
if (inex == 0 && mpfr_inexflag_p ())
err ("got null ternary value with inexact flag",
i, j, rnd, z, inex);
if (i >= 3 && j >= 3)
{
if (mpfr_underflow_p ())
err ("got underflow", i, j, rnd, z, inex);
if (mpfr_overflow_p ())
err ("got overflow", i, j, rnd, z, inex);
exact = MPFR_IS_SINGULAR (z) ||
(mpfr_mul_2ui (tmp, z, 16, MPFR_RNDN), mpfr_integer_p (tmp));
if (exact && inex != 0)
err ("got exact value with ternary flag different from 0",
i, j, rnd, z, inex);
if (! exact && inex == 0)
err ("got inexact value with ternary flag equal to 0",
i, j, rnd, z, inex);
}
if (MPFR_IS_ZERO (x) && ! MPFR_IS_NAN (y) && MPFR_NOTZERO (y))
{
if (MPFR_IS_NEG (y) && ! MPFR_IS_INF (z))
err ("expected an infinity", i, j, rnd, z, inex);
if (MPFR_IS_POS (y) && ! MPFR_IS_ZERO (z))
err ("expected a zero", i, j, rnd, z, inex);
if ((MPFR_IS_NEG (x) && is_odd (y)) ^ MPFR_IS_NEG (z))
err ("wrong sign", i, j, rnd, z, inex);
}
if (! MPFR_IS_NAN (x) && mpfr_cmp_si (x, -1) == 0)
{
/* x = -1 */
if (! (MPFR_IS_INF (y) || mpfr_integer_p (y)) &&
! MPFR_IS_NAN (z))
err ("expected NaN", i, j, rnd, z, inex);
if ((MPFR_IS_INF (y) || (mpfr_integer_p (y) && ! is_odd (y)))
&& ! mpfr_equal_p (z, __gmpfr_one))
err ("expected 1", i, j, rnd, z, inex);
if (is_odd (y) &&
(MPFR_IS_NAN (z) || mpfr_cmp_si (z, -1) != 0))
err ("expected -1", i, j, rnd, z, inex);
}
if ((mpfr_equal_p (x, __gmpfr_one) || MPFR_IS_ZERO (y)) &&
! mpfr_equal_p (z, __gmpfr_one))
err ("expected 1", i, j, rnd, z, inex);
if (MPFR_IS_PURE_FP (x) && MPFR_IS_NEG (x) &&
MPFR_IS_FP (y) && ! mpfr_integer_p (y) &&
! MPFR_IS_NAN (z))
err ("expected NaN", i, j, rnd, z, inex);
if (MPFR_IS_INF (y) && MPFR_NOTZERO (x))
{
int cmpabs1 = mpfr_cmpabs (x, __gmpfr_one);
if ((MPFR_IS_NEG (y) ? (cmpabs1 < 0) : (cmpabs1 > 0)) &&
! (MPFR_IS_POS (z) && MPFR_IS_INF (z)))
err ("expected +Inf", i, j, rnd, z, inex);
if ((MPFR_IS_NEG (y) ? (cmpabs1 > 0) : (cmpabs1 < 0)) &&
! (MPFR_IS_POS (z) && MPFR_IS_ZERO (z)))
err ("expected +0", i, j, rnd, z, inex);
}
if (MPFR_IS_INF (x) && ! MPFR_IS_NAN (y) && MPFR_NOTZERO (y))
{
if (MPFR_IS_POS (y) && ! MPFR_IS_INF (z))
err ("expected an infinity", i, j, rnd, z, inex);
if (MPFR_IS_NEG (y) && ! MPFR_IS_ZERO (z))
err ("expected a zero", i, j, rnd, z, inex);
if ((MPFR_IS_NEG (x) && is_odd (y)) ^ MPFR_IS_NEG (z))
err ("wrong sign", i, j, rnd, z, inex);
}
test_others (val[i], val[j], (mpfr_rnd_t) rnd, x, y, z, inex, flags,
"tst");
}
mpfr_clears (x, y, z, tmp, (mpfr_ptr) 0);
}
mp_exp_t
mpfr_get_exp (mpfr_srcptr x)
{
MPFR_ASSERTN(MPFR_IS_PURE_FP(x));
return MPFR_EXP(x); /* do not use MPFR_GET_EXP of course... */
}
int
mpfr_sub (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
{
MPFR_LOG_FUNC (("b[%#R]=%R c[%#R]=%R rnd=%d", b, b, c, c, rnd_mode),
("a[%#R]=%R", a, a));
if (MPFR_ARE_SINGULAR (b,c))
{
if (MPFR_IS_NAN (b) || MPFR_IS_NAN (c))
{
MPFR_SET_NAN (a);
MPFR_RET_NAN;
}
else if (MPFR_IS_INF (b))
{
if (!MPFR_IS_INF (c) || MPFR_SIGN (b) != MPFR_SIGN(c))
{
MPFR_SET_INF (a);
MPFR_SET_SAME_SIGN (a, b);
MPFR_RET (0); /* exact */
}
else
{
MPFR_SET_NAN (a); /* Inf - Inf */
MPFR_RET_NAN;
}
}
else if (MPFR_IS_INF (c))
{
MPFR_SET_INF (a);
MPFR_SET_OPPOSITE_SIGN (a, c);
MPFR_RET (0); /* exact */
}
else if (MPFR_IS_ZERO (b))
{
if (MPFR_IS_ZERO (c))
{
int sign = rnd_mode != MPFR_RNDD
? ((MPFR_IS_NEG(b) && MPFR_IS_POS(c)) ? -1 : 1)
: ((MPFR_IS_POS(b) && MPFR_IS_NEG(c)) ? 1 : -1);
MPFR_SET_SIGN (a, sign);
MPFR_SET_ZERO (a);
MPFR_RET(0); /* 0 - 0 is exact */
}
else
return mpfr_neg (a, c, rnd_mode);
}
else
{
MPFR_ASSERTD (MPFR_IS_ZERO (c));
return mpfr_set (a, b, rnd_mode);
}
}
MPFR_ASSERTD (MPFR_IS_PURE_FP (b) && MPFR_IS_PURE_FP (c));
if (MPFR_LIKELY (MPFR_SIGN (b) == MPFR_SIGN (c)))
{ /* signs are equal, it's a real subtraction */
if (MPFR_LIKELY (MPFR_PREC (a) == MPFR_PREC (b)
&& MPFR_PREC (b) == MPFR_PREC (c)))
return mpfr_sub1sp (a, b, c, rnd_mode);
else
return mpfr_sub1 (a, b, c, rnd_mode);
}
else
{ /* signs differ, it's an addition */
if (MPFR_GET_EXP (b) < MPFR_GET_EXP (c))
{ /* exchange rounding modes toward +/- infinity */
int inexact;
rnd_mode = MPFR_INVERT_RND (rnd_mode);
if (MPFR_LIKELY (MPFR_PREC (a) == MPFR_PREC (b)
&& MPFR_PREC (b) == MPFR_PREC (c)))
inexact = mpfr_add1sp (a, c, b, rnd_mode);
else
inexact = mpfr_add1 (a, c, b, rnd_mode);
MPFR_CHANGE_SIGN (a);
return -inexact;
}
else
{
if (MPFR_LIKELY (MPFR_PREC (a) == MPFR_PREC (b)
&& MPFR_PREC (b) == MPFR_PREC (c)))
return mpfr_add1sp (a, b, c, rnd_mode);
else
return mpfr_add1 (a, b, c, rnd_mode);
}
}
}
/* The computation of z = pow(x,y) is done by
z = exp(y * log(x)) = x^y
For the special cases, see Section F.9.4.4 of the C standard:
_ pow(±0, y) = ±inf for y an odd integer < 0.
_ pow(±0, y) = +inf for y < 0 and not an odd integer.
_ pow(±0, y) = ±0 for y an odd integer > 0.
_ pow(±0, y) = +0 for y > 0 and not an odd integer.
_ pow(-1, ±inf) = 1.
_ pow(+1, y) = 1 for any y, even a NaN.
_ pow(x, ±0) = 1 for any x, even a NaN.
_ pow(x, y) = NaN for finite x < 0 and finite non-integer y.
_ pow(x, -inf) = +inf for |x| < 1.
_ pow(x, -inf) = +0 for |x| > 1.
_ pow(x, +inf) = +0 for |x| < 1.
_ pow(x, +inf) = +inf for |x| > 1.
_ pow(-inf, y) = -0 for y an odd integer < 0.
_ pow(-inf, y) = +0 for y < 0 and not an odd integer.
_ pow(-inf, y) = -inf for y an odd integer > 0.
_ pow(-inf, y) = +inf for y > 0 and not an odd integer.
_ pow(+inf, y) = +0 for y < 0.
_ pow(+inf, y) = +inf for y > 0. */
int
mpfr_pow (mpfr_ptr z, mpfr_srcptr x, mpfr_srcptr y, mpfr_rnd_t rnd_mode)
{
int inexact;
int cmp_x_1;
int y_is_integer;
MPFR_SAVE_EXPO_DECL (expo);
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));
if (MPFR_ARE_SINGULAR (x, y))
{
/* pow(x, 0) returns 1 for any x, even a NaN. */
if (MPFR_UNLIKELY (MPFR_IS_ZERO (y)))
return mpfr_set_ui (z, 1, rnd_mode);
else if (MPFR_IS_NAN (x))
{
MPFR_SET_NAN (z);
MPFR_RET_NAN;
}
else if (MPFR_IS_NAN (y))
{
/* pow(+1, NaN) returns 1. */
if (mpfr_cmp_ui (x, 1) == 0)
return mpfr_set_ui (z, 1, rnd_mode);
MPFR_SET_NAN (z);
MPFR_RET_NAN;
}
else if (MPFR_IS_INF (y))
{
if (MPFR_IS_INF (x))
{
if (MPFR_IS_POS (y))
MPFR_SET_INF (z);
else
MPFR_SET_ZERO (z);
MPFR_SET_POS (z);
MPFR_RET (0);
}
else
{
int cmp;
cmp = mpfr_cmpabs (x, __gmpfr_one) * MPFR_INT_SIGN (y);
MPFR_SET_POS (z);
if (cmp > 0)
{
/* Return +inf. */
MPFR_SET_INF (z);
MPFR_RET (0);
}
else if (cmp < 0)
{
/* Return +0. */
MPFR_SET_ZERO (z);
MPFR_RET (0);
}
else
{
/* Return 1. */
return mpfr_set_ui (z, 1, rnd_mode);
}
}
}
else if (MPFR_IS_INF (x))
{
int negative;
/* Determine the sign now, in case y and z are the same object */
negative = MPFR_IS_NEG (x) && is_odd (y);
if (MPFR_IS_POS (y))
MPFR_SET_INF (z);
else
MPFR_SET_ZERO (z);
if (negative)
MPFR_SET_NEG (z);
else
MPFR_SET_POS (z);
MPFR_RET (0);
}
else
{
int negative;
MPFR_ASSERTD (MPFR_IS_ZERO (x));
/* Determine the sign now, in case y and z are the same object */
negative = MPFR_IS_NEG(x) && is_odd (y);
if (MPFR_IS_NEG (y))
{
MPFR_ASSERTD (! MPFR_IS_INF (y));
MPFR_SET_INF (z);
mpfr_set_divby0 ();
}
else
MPFR_SET_ZERO (z);
if (negative)
MPFR_SET_NEG (z);
else
MPFR_SET_POS (z);
MPFR_RET (0);
}
}
/* x^y for x < 0 and y not an integer is not defined */
y_is_integer = mpfr_integer_p (y);
if (MPFR_IS_NEG (x) && ! y_is_integer)
{
MPFR_SET_NAN (z);
MPFR_RET_NAN;
}
/* now the result cannot be NaN:
(1) either x > 0
(2) or x < 0 and y is an integer */
cmp_x_1 = mpfr_cmpabs (x, __gmpfr_one);
if (cmp_x_1 == 0)
return mpfr_set_si (z, MPFR_IS_NEG (x) && is_odd (y) ? -1 : 1, rnd_mode);
/* now we have:
(1) either x > 0
(2) or x < 0 and y is an integer
and in addition |x| <> 1.
*/
/* detect overflow: an overflow is possible if
(a) |x| > 1 and y > 0
(b) |x| < 1 and y < 0.
FIXME: this assumes 1 is always representable.
FIXME2: maybe we can test overflow and underflow simultaneously.
The idea is the following: first compute an approximation to
y * log2|x|, using rounding to nearest. If |x| is not too near from 1,
this approximation should be accurate enough, and in most cases enable
one to prove that there is no underflow nor overflow.
Otherwise, it should enable one to check only underflow or overflow,
instead of both cases as in the present case.
*/
if (cmp_x_1 * MPFR_SIGN (y) > 0)
{
mpfr_t t;
int negative, overflow;
MPFR_SAVE_EXPO_MARK (expo);
mpfr_init2 (t, 53);
/* we want a lower bound on y*log2|x|:
(i) if x > 0, it suffices to round log2(x) toward zero, and
to round y*o(log2(x)) toward zero too;
(ii) if x < 0, we first compute t = o(-x), with rounding toward 1,
and then follow as in case (1). */
if (MPFR_SIGN (x) > 0)
mpfr_log2 (t, x, MPFR_RNDZ);
else
{
mpfr_neg (t, x, (cmp_x_1 > 0) ? MPFR_RNDZ : MPFR_RNDU);
mpfr_log2 (t, t, MPFR_RNDZ);
}
mpfr_mul (t, t, y, MPFR_RNDZ);
overflow = mpfr_cmp_si (t, __gmpfr_emax) > 0;
mpfr_clear (t);
MPFR_SAVE_EXPO_FREE (expo);
if (overflow)
{
MPFR_LOG_MSG (("early overflow detection\n", 0));
negative = MPFR_SIGN(x) < 0 && is_odd (y);
return mpfr_overflow (z, rnd_mode, negative ? -1 : 1);
}
}
/* Basic underflow checking. One has:
* - if y > 0, |x^y| < 2^(EXP(x) * y);
* - if y < 0, |x^y| <= 2^((EXP(x) - 1) * y);
* so that one can compute a value ebound such that |x^y| < 2^ebound.
* If we have ebound <= emin - 2 (emin - 1 in directed rounding modes),
* then there is an underflow and we can decide the return value.
*/
if (MPFR_IS_NEG (y) ? (MPFR_GET_EXP (x) > 1) : (MPFR_GET_EXP (x) < 0))
{
mpfr_t tmp;
mpfr_eexp_t ebound;
int inex2;
/* We must restore the flags. */
MPFR_SAVE_EXPO_MARK (expo);
mpfr_init2 (tmp, sizeof (mpfr_exp_t) * CHAR_BIT);
inex2 = mpfr_set_exp_t (tmp, MPFR_GET_EXP (x), MPFR_RNDN);
MPFR_ASSERTN (inex2 == 0);
if (MPFR_IS_NEG (y))
{
inex2 = mpfr_sub_ui (tmp, tmp, 1, MPFR_RNDN);
MPFR_ASSERTN (inex2 == 0);
}
mpfr_mul (tmp, tmp, y, MPFR_RNDU);
if (MPFR_IS_NEG (y))
mpfr_nextabove (tmp);
/* tmp doesn't necessarily fit in ebound, but that doesn't matter
since we get the minimum value in such a case. */
ebound = mpfr_get_exp_t (tmp, MPFR_RNDU);
mpfr_clear (tmp);
MPFR_SAVE_EXPO_FREE (expo);
if (MPFR_UNLIKELY (ebound <=
__gmpfr_emin - (rnd_mode == MPFR_RNDN ? 2 : 1)))
{
/* warning: mpfr_underflow rounds away from 0 for MPFR_RNDN */
MPFR_LOG_MSG (("early underflow detection\n", 0));
return mpfr_underflow (z,
rnd_mode == MPFR_RNDN ? MPFR_RNDZ : rnd_mode,
MPFR_SIGN (x) < 0 && is_odd (y) ? -1 : 1);
}
}
/* If y is an integer, we can use mpfr_pow_z (based on multiplications),
but if y is very large (I'm not sure about the best threshold -- VL),
we shouldn't use it, as it can be very slow and take a lot of memory
(and even crash or make other programs crash, as several hundred of
MBs may be necessary). Note that in such a case, either x = +/-2^b
(this case is handled below) or x^y cannot be represented exactly in
any precision supported by MPFR (the general case uses this property).
*/
if (y_is_integer && (MPFR_GET_EXP (y) <= 256))
{
mpz_t zi;
MPFR_LOG_MSG (("special code for y not too large integer\n", 0));
mpz_init (zi);
mpfr_get_z (zi, y, MPFR_RNDN);
inexact = mpfr_pow_z (z, x, zi, rnd_mode);
mpz_clear (zi);
return inexact;
}
/* Special case (+/-2^b)^Y which could be exact. If x is negative, then
necessarily y is a large integer. */
{
mpfr_exp_t b = MPFR_GET_EXP (x) - 1;
MPFR_ASSERTN (b >= LONG_MIN && b <= LONG_MAX); /* FIXME... */
if (mpfr_cmp_si_2exp (x, MPFR_SIGN(x), b) == 0)
{
mpfr_t tmp;
int sgnx = MPFR_SIGN (x);
MPFR_LOG_MSG (("special case (+/-2^b)^Y\n", 0));
/* now x = +/-2^b, so x^y = (+/-1)^y*2^(b*y) is exact whenever b*y is
an integer */
MPFR_SAVE_EXPO_MARK (expo);
mpfr_init2 (tmp, MPFR_PREC (y) + sizeof (long) * CHAR_BIT);
inexact = mpfr_mul_si (tmp, y, b, MPFR_RNDN); /* exact */
MPFR_ASSERTN (inexact == 0);
/* Note: as the exponent range has been extended, an overflow is not
possible (due to basic overflow and underflow checking above, as
the result is ~ 2^tmp), and an underflow is not possible either
because b is an integer (thus either 0 or >= 1). */
MPFR_CLEAR_FLAGS ();
inexact = mpfr_exp2 (z, tmp, rnd_mode);
mpfr_clear (tmp);
if (sgnx < 0 && is_odd (y))
{
mpfr_neg (z, z, rnd_mode);
inexact = -inexact;
}
/* Without the following, the overflows3 test in tpow.c fails. */
MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, __gmpfr_flags);
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_check_range (z, inexact, rnd_mode);
}
}
MPFR_SAVE_EXPO_MARK (expo);
/* Case where |y * log(x)| is very small. Warning: x can be negative, in
that case y is a large integer. */
{
mpfr_t t;
mpfr_exp_t err;
/* We need an upper bound on the exponent of y * log(x). */
mpfr_init2 (t, 16);
if (MPFR_IS_POS(x))
mpfr_log (t, x, cmp_x_1 < 0 ? MPFR_RNDD : MPFR_RNDU); /* away from 0 */
else
{
/* if x < -1, round to +Inf, else round to zero */
mpfr_neg (t, x, (mpfr_cmp_si (x, -1) < 0) ? MPFR_RNDU : MPFR_RNDD);
mpfr_log (t, t, (mpfr_cmp_ui (t, 1) < 0) ? MPFR_RNDD : MPFR_RNDU);
}
MPFR_ASSERTN (MPFR_IS_PURE_FP (t));
err = MPFR_GET_EXP (y) + MPFR_GET_EXP (t);
mpfr_clear (t);
MPFR_CLEAR_FLAGS ();
MPFR_SMALL_INPUT_AFTER_SAVE_EXPO (z, __gmpfr_one, - err, 0,
(MPFR_SIGN (y) > 0) ^ (cmp_x_1 < 0),
rnd_mode, expo, {});
}
/* General case */
inexact = mpfr_pow_general (z, x, y, rnd_mode, y_is_integer, &expo);
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_check_range (z, inexact, rnd_mode);
}
static void
test_generic (mp_prec_t p0, mp_prec_t p1, unsigned int N)
{
mp_prec_t prec, xprec, yprec;
mpfr_t x, y, z, t;
#ifdef TWO_ARGS
mpfr_t u;
#elif defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_t u;
double d;
#endif
mp_rnd_t rnd;
int inexact, compare, compare2;
unsigned int n;
unsigned long ctrt = 0, ctrn = 0;
mp_exp_t old_emin, old_emax;
old_emin = mpfr_get_emin ();
old_emax = mpfr_get_emax ();
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
mpfr_init (t);
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_init (u);
#endif
/* generic test */
for (prec = p0; prec <= p1; prec++)
{
mpfr_set_prec (z, prec);
mpfr_set_prec (t, prec);
yprec = prec + 10;
mpfr_set_prec (y, yprec);
/* Note: in precision p1, we test 4 special cases. */
for (n = 0; n < (prec == p1 ? N + 4 : N); n++)
{
xprec = prec;
if (randlimb () & 1)
{
xprec *= (double) randlimb () / MP_LIMB_T_MAX;
if (xprec < MPFR_PREC_MIN)
xprec = MPFR_PREC_MIN;
}
mpfr_set_prec (x, xprec);
#ifdef TWO_ARGS
mpfr_set_prec (u, xprec);
#elif defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_set_prec (u, IEEE_DBL_MANT_DIG);
#endif
if (n > 3 || prec < p1)
{
#if defined(RAND_FUNCTION)
RAND_FUNCTION (x);
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
RAND_FUNCTION (u);
#endif
#else
tests_default_random (x, TEST_RANDOM_POS,
TEST_RANDOM_EMIN, TEST_RANDOM_EMAX);
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
tests_default_random (u, TEST_RANDOM_POS2,
TEST_RANDOM_EMIN, TEST_RANDOM_EMAX);
#endif
#endif
}
else
{
/* Special cases tested in precision p1 if n <= 3. They are
useful really in the extended exponent range. */
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
if (n <= 1)
{
mpfr_set_si (x, n == 0 ? 1 : -1, GMP_RNDN);
mpfr_set_exp (x, mpfr_get_emin ());
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_set_si (u, randlimb () % 2 == 0 ? 1 : -1, GMP_RNDN);
mpfr_set_exp (u, mpfr_get_emin ());
#endif
}
else /* 2 <= n <= 3 */
{
if (getenv ("MPFR_CHECK_MAX") == NULL)
goto next_n;
mpfr_set_si (x, n == 0 ? 1 : -1, GMP_RNDN);
mpfr_setmax (x, REDUCE_EMAX);
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_set_si (u, randlimb () % 2 == 0 ? 1 : -1, GMP_RNDN);
mpfr_setmax (u, mpfr_get_emax ());
#endif
}
}
rnd = RND_RAND ();
mpfr_clear_flags ();
#ifdef DEBUG_TGENERIC
TGENERIC_INFO (TEST_FUNCTION, MPFR_PREC (y));
#endif
#if defined(TWO_ARGS)
compare = TEST_FUNCTION (y, x, u, rnd);
#elif defined(DOUBLE_ARG1)
d = mpfr_get_d (u, rnd);
compare = TEST_FUNCTION (y, d, x, rnd);
#elif defined(DOUBLE_ARG2)
d = mpfr_get_d (u, rnd);
compare = TEST_FUNCTION (y, x, d, rnd);
#else
compare = TEST_FUNCTION (y, x, rnd);
#endif
TGENERIC_CHECK ("Bad inexact flag",
(compare != 0) ^ (mpfr_inexflag_p () == 0));
ctrt++;
if (MPFR_IS_SINGULAR (y))
{
if (MPFR_IS_NAN (y) || mpfr_nanflag_p ())
TGENERIC_CHECK ("Bad NaN flag",
MPFR_IS_NAN (y) && mpfr_nanflag_p ());
else if (MPFR_IS_INF (y))
TGENERIC_CHECK ("Bad overflow flag",
(compare != 0) ^ (mpfr_overflow_p () == 0));
else if (MPFR_IS_ZERO (y))
TGENERIC_CHECK ("Bad underflow flag",
(compare != 0) ^ (mpfr_underflow_p () == 0));
}
else if (mpfr_overflow_p ())
{
TGENERIC_CHECK ("Bad compare value (overflow)", compare != 0);
mpfr_nexttoinf (y);
TGENERIC_CHECK ("Should have been max MPFR number",
MPFR_IS_INF (y));
}
else if (mpfr_underflow_p ())
{
TGENERIC_CHECK ("Bad compare value (underflow)", compare != 0);
mpfr_nexttozero (y);
TGENERIC_CHECK ("Should have been min MPFR number",
MPFR_IS_ZERO (y));
}
else if (mpfr_can_round (y, yprec, rnd, rnd, prec))
{
ctrn++;
mpfr_set (t, y, rnd);
/* Risk of failures are known when some flags are already set
before the function call. Do not set the erange flag, as
it will remain set after the function call and no checks
are performed in such a case (see the mpfr_erangeflag_p
test below). */
if (randlimb () & 1)
__gmpfr_flags = MPFR_FLAGS_ALL ^ MPFR_FLAGS_ERANGE;
#ifdef DEBUG_TGENERIC
TGENERIC_INFO (TEST_FUNCTION, MPFR_PREC (z));
#endif
/* Let's increase the precision of the inputs in a random way.
In most cases, this doesn't make any difference, but this
triggers the mpfr_fmod bug fixed in r6235. */
mpfr_prec_round (x, mpfr_get_prec (x) + (randlimb () & 15),
GMP_RNDN);
#if defined(TWO_ARGS)
mpfr_prec_round (u, mpfr_get_prec (u) + (randlimb () & 15),
GMP_RNDN);
inexact = TEST_FUNCTION (z, x, u, rnd);
#elif defined(DOUBLE_ARG1)
inexact = TEST_FUNCTION (z, d, x, rnd);
#elif defined(DOUBLE_ARG2)
inexact = TEST_FUNCTION (z, x, d, rnd);
#else
inexact = TEST_FUNCTION (z, x, rnd);
#endif
if (mpfr_erangeflag_p ())
goto next_n;
if (mpfr_nan_p (z) || mpfr_cmp (t, z) != 0)
{
printf ("results differ for x=");
mpfr_out_str (stdout, 2, xprec, x, GMP_RNDN);
#ifdef TWO_ARGS
printf ("\nu=");
mpfr_out_str (stdout, 2, xprec, u, GMP_RNDN);
#elif defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
printf ("\nu=");
mpfr_out_str (stdout, 2, IEEE_DBL_MANT_DIG, u, GMP_RNDN);
#endif
printf (" prec=%u rnd_mode=%s\n", (unsigned) prec,
mpfr_print_rnd_mode (rnd));
printf ("got ");
mpfr_out_str (stdout, 2, prec, z, GMP_RNDN);
puts ("");
printf ("expected ");
mpfr_out_str (stdout, 2, prec, t, GMP_RNDN);
puts ("");
printf ("approx ");
mpfr_print_binary (y);
puts ("");
exit (1);
}
compare2 = mpfr_cmp (t, y);
/* if rounding to nearest, cannot know the sign of t - f(x)
because of composed rounding: y = o(f(x)) and t = o(y) */
if (compare * compare2 >= 0)
compare = compare + compare2;
else
compare = inexact; /* cannot determine sign(t-f(x)) */
if (((inexact == 0) && (compare != 0)) ||
((inexact > 0) && (compare <= 0)) ||
((inexact < 0) && (compare >= 0)))
{
printf ("Wrong inexact flag for rnd=%s: expected %d, got %d"
"\n", mpfr_print_rnd_mode (rnd), compare, inexact);
printf ("x="); mpfr_print_binary (x); puts ("");
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
printf ("u="); mpfr_print_binary (u); puts ("");
#endif
printf ("y="); mpfr_print_binary (y); puts ("");
printf ("t="); mpfr_print_binary (t); puts ("");
exit (1);
}
}
else if (getenv ("MPFR_SUSPICIOUS_OVERFLOW") != NULL)
{
/* For developers only! */
MPFR_ASSERTN (MPFR_IS_PURE_FP (y));
mpfr_nexttoinf (y);
if (MPFR_IS_INF (y) && MPFR_IS_LIKE_RNDZ (rnd, MPFR_IS_NEG (y))
&& !mpfr_overflow_p ())
{
printf ("Possible bug! |y| is the maximum finite number "
"and has been obtained when\nrounding toward zero"
" (%s). Thus there is a very probable overflow,\n"
"but the overflow flag is not set!\n",
mpfr_print_rnd_mode (rnd));
printf ("x="); mpfr_print_binary (x); puts ("");
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
printf ("u="); mpfr_print_binary (u); puts ("");
#endif
exit (1);
}
}
next_n:
/* In case the exponent range has been changed by
tests_default_random() or for special values... */
mpfr_set_emin (old_emin);
mpfr_set_emax (old_emax);
}
}
#ifndef TGENERIC_NOWARNING
if (3 * ctrn < 2 * ctrt)
printf ("Warning! Too few normal cases in generic tests (%lu / %lu)\n",
ctrn, ctrt);
#endif
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (t);
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_clear (u);
#endif
}
int
mpfr_add (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
{
MPFR_LOG_FUNC (("b[%#R]=%R c[%#R]=%R rnd=%d", b, b, c, c, rnd_mode),
("a[%#R]=%R", a, a));
if (MPFR_ARE_SINGULAR(b,c))
{
if (MPFR_IS_NAN(b) || MPFR_IS_NAN(c))
{
MPFR_SET_NAN(a);
MPFR_RET_NAN;
}
/* neither b nor c is NaN here */
else if (MPFR_IS_INF(b))
{
if (!MPFR_IS_INF(c) || MPFR_SIGN(b) == MPFR_SIGN(c))
{
MPFR_SET_INF(a);
MPFR_SET_SAME_SIGN(a, b);
MPFR_RET(0); /* exact */
}
else
{
MPFR_SET_NAN(a);
MPFR_RET_NAN;
}
}
else if (MPFR_IS_INF(c))
{
MPFR_SET_INF(a);
MPFR_SET_SAME_SIGN(a, c);
MPFR_RET(0); /* exact */
}
/* now either b or c is zero */
else if (MPFR_IS_ZERO(b))
{
if (MPFR_IS_ZERO(c))
{
/* for round away, we take the same convention for 0 + 0
as for round to zero or to nearest: it always gives +0,
except (-0) + (-0) = -0. */
MPFR_SET_SIGN(a,
(rnd_mode != MPFR_RNDD ?
((MPFR_IS_NEG(b) && MPFR_IS_NEG(c)) ? -1 : 1) :
((MPFR_IS_POS(b) && MPFR_IS_POS(c)) ? 1 : -1)));
MPFR_SET_ZERO(a);
MPFR_RET(0); /* 0 + 0 is exact */
}
return mpfr_set (a, c, rnd_mode);
}
else
{
MPFR_ASSERTD(MPFR_IS_ZERO(c));
return mpfr_set (a, b, rnd_mode);
}
}
MPFR_ASSERTD(MPFR_IS_PURE_FP(b) && MPFR_IS_PURE_FP(c));
if (MPFR_UNLIKELY(MPFR_SIGN(b) != MPFR_SIGN(c)))
{ /* signs differ, it's a subtraction */
if (MPFR_LIKELY(MPFR_PREC(a) == MPFR_PREC(b)
&& MPFR_PREC(b) == MPFR_PREC(c)))
return mpfr_sub1sp(a,b,c,rnd_mode);
else
return mpfr_sub1(a, b, c, rnd_mode);
}
else
{ /* signs are equal, it's an addition */
if (MPFR_LIKELY(MPFR_PREC(a) == MPFR_PREC(b)
&& MPFR_PREC(b) == MPFR_PREC(c)))
if (MPFR_GET_EXP(b) < MPFR_GET_EXP(c))
return mpfr_add1sp(a, c, b, rnd_mode);
else
return mpfr_add1sp(a, b, c, rnd_mode);
else
if (MPFR_GET_EXP(b) < MPFR_GET_EXP(c))
return mpfr_add1(a, c, b, rnd_mode);
else
return mpfr_add1(a, b, c, rnd_mode);
}
}
static void
test_generic (mpfr_prec_t p0, mpfr_prec_t p1, unsigned int nmax)
{
mpfr_prec_t prec, xprec, yprec;
mpfr_t x, y, z, t, w;
#if defined(TWO_ARGS_ALL)
mpfr_t u;
#endif
#if defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
double d;
#endif
#if defined(ULONG_ARG1) || defined(ULONG_ARG2)
unsigned long i;
#endif
mpfr_rnd_t rnd;
int inexact, compare, compare2;
unsigned int n;
unsigned long ctrt = 0, ctrn = 0;
int test_of = 1, test_uf = 1;
mpfr_exp_t old_emin, old_emax;
old_emin = mpfr_get_emin ();
old_emax = mpfr_get_emax ();
mpfr_inits2 (MPFR_PREC_MIN, x, y, z, t, w, (mpfr_ptr) 0);
#if defined(TWO_ARGS_ALL)
mpfr_init2 (u, MPFR_PREC_MIN);
#endif
/* generic test */
for (prec = p0; prec <= p1; prec++)
{
mpfr_set_prec (z, prec);
mpfr_set_prec (t, prec);
yprec = prec + 10;
mpfr_set_prec (y, yprec);
mpfr_set_prec (w, yprec);
/* Note: in precision p1, we test 4 special cases. */
for (n = 0; n < (prec == p1 ? nmax + 4 : nmax); n++)
{
int infinite_input = 0;
unsigned int flags;
mpfr_exp_t oemin, oemax;
xprec = prec;
if (randlimb () & 1)
{
xprec *= (double) randlimb () / MP_LIMB_T_MAX;
if (xprec < MPFR_PREC_MIN)
xprec = MPFR_PREC_MIN;
}
mpfr_set_prec (x, xprec);
#if defined(TWO_ARGS)
mpfr_set_prec (u, xprec);
#elif defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_set_prec (u, IEEE_DBL_MANT_DIG);
#elif defined(ULONG_ARG1) || defined(ULONG_ARG2)
mpfr_set_prec (u, sizeof (unsigned long) * CHAR_BIT);
#endif
if (n > 3 || prec < p1)
{
#if defined(RAND_FUNCTION)
RAND_FUNCTION (x);
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
RAND_FUNCTION (u);
#endif
#else /* ! defined(RAND_FUNCTION) */
tests_default_random (x, TEST_RANDOM_POS,
TEST_RANDOM_EMIN, TEST_RANDOM_EMAX,
TEST_RANDOM_ALWAYS_SCALE);
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
tests_default_random (u, TEST_RANDOM_POS2,
TEST_RANDOM_EMIN, TEST_RANDOM_EMAX,
TEST_RANDOM_ALWAYS_SCALE);
#endif
#endif /* ! defined(RAND_FUNCTION) */
}
else
{
/* Special cases tested in precision p1 if n <= 3. They are
useful really in the extended exponent range. */
#if (defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)) && defined(MPFR_ERRDIVZERO)
goto next_n;
#endif
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
if (n <= 1)
{
mpfr_set_si (x, n == 0 ? 1 : -1, MPFR_RNDN);
mpfr_set_exp (x, mpfr_get_emin ());
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_set_si (u, randlimb () % 2 == 0 ? 1 : -1, MPFR_RNDN);
mpfr_set_exp (u, mpfr_get_emin ());
#endif
}
else /* 2 <= n <= 3 */
{
if (getenv ("MPFR_CHECK_MAX") == NULL)
goto next_n;
mpfr_set_si (x, n == 0 ? 1 : -1, MPFR_RNDN);
mpfr_setmax (x, REDUCE_EMAX);
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_set_si (u, randlimb () % 2 == 0 ? 1 : -1, MPFR_RNDN);
mpfr_setmax (u, mpfr_get_emax ());
#endif
}
}
#if defined(ULONG_ARG1) || defined(ULONG_ARG2)
i = randlimb ();
inexact = mpfr_set_ui (u, i, MPFR_RNDN);
MPFR_ASSERTN (inexact == 0);
#endif
/* Exponent range for the test. */
oemin = mpfr_get_emin ();
oemax = mpfr_get_emax ();
rnd = RND_RAND ();
mpfr_clear_flags ();
#ifdef DEBUG_TGENERIC
TGENERIC_INFO (TEST_FUNCTION, MPFR_PREC (y));
#endif
#if defined(TWO_ARGS)
compare = TEST_FUNCTION (y, x, u, rnd);
#elif defined(DOUBLE_ARG1)
d = mpfr_get_d (u, rnd);
compare = TEST_FUNCTION (y, d, x, rnd);
/* d can be infinite due to overflow in mpfr_get_d */
infinite_input |= DOUBLE_ISINF (d);
#elif defined(DOUBLE_ARG2)
d = mpfr_get_d (u, rnd);
compare = TEST_FUNCTION (y, x, d, rnd);
/* d can be infinite due to overflow in mpfr_get_d */
infinite_input |= DOUBLE_ISINF (d);
#elif defined(ULONG_ARG1)
compare = TEST_FUNCTION (y, i, x, rnd);
#elif defined(ULONG_ARG2)
compare = TEST_FUNCTION (y, x, i, rnd);
#else
compare = TEST_FUNCTION (y, x, rnd);
#endif
flags = __gmpfr_flags;
if (mpfr_get_emin () != oemin ||
mpfr_get_emax () != oemax)
{
printf ("tgeneric: the exponent range has been modified"
" by the tested function!\n");
exit (1);
}
TGENERIC_CHECK ("bad inexact flag",
(compare != 0) ^ (mpfr_inexflag_p () == 0));
ctrt++;
/* Tests in a reduced exponent range. */
{
unsigned int oldflags = flags;
mpfr_exp_t e, emin, emax;
/* Determine the smallest exponent range containing the
exponents of the mpfr_t inputs (x, and u if TWO_ARGS)
and output (y). */
emin = MPFR_EMAX_MAX;
emax = MPFR_EMIN_MIN;
if (MPFR_IS_PURE_FP (x))
{
e = MPFR_GET_EXP (x);
if (e < emin)
emin = e;
if (e > emax)
emax = e;
}
#if defined(TWO_ARGS)
if (MPFR_IS_PURE_FP (u))
{
e = MPFR_GET_EXP (u);
if (e < emin)
emin = e;
if (e > emax)
emax = e;
}
#endif
if (MPFR_IS_PURE_FP (y))
{
e = MPFR_GET_EXP (y);
if (test_of && e - 1 >= emax)
{
unsigned int ex_flags;
mpfr_set_emax (e - 1);
mpfr_clear_flags ();
#if defined(TWO_ARGS)
inexact = TEST_FUNCTION (w, x, u, rnd);
#elif defined(DOUBLE_ARG1)
inexact = TEST_FUNCTION (w, d, x, rnd);
#elif defined(DOUBLE_ARG2)
inexact = TEST_FUNCTION (w, x, d, rnd);
#elif defined(ULONG_ARG1)
inexact = TEST_FUNCTION (w, i, x, rnd);
#elif defined(ULONG_ARG2)
inexact = TEST_FUNCTION (w, x, i, rnd);
#else
inexact = TEST_FUNCTION (w, x, rnd);
#endif
flags = __gmpfr_flags;
mpfr_set_emax (oemax);
ex_flags = MPFR_FLAGS_OVERFLOW | MPFR_FLAGS_INEXACT;
if (flags != ex_flags)
{
printf ("tgeneric: error for " MAKE_STR(TEST_FUNCTION)
", reduced exponent range [%"
MPFR_EXP_FSPEC "d,%" MPFR_EXP_FSPEC
"d] (overflow test) on:\n",
(mpfr_eexp_t) oemin, (mpfr_eexp_t) e - 1);
printf ("x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf ("u = ");
mpfr_dump (u);
#endif
printf ("yprec = %u, rnd_mode = %s\n",
(unsigned int) yprec,
mpfr_print_rnd_mode (rnd));
printf ("Expected flags =");
flags_out (ex_flags);
printf (" got flags =");
flags_out (flags);
printf ("inex = %d, w = ", inexact);
mpfr_dump (w);
exit (1);
}
test_of = 0; /* Overflow is tested only once. */
}
if (test_uf && e + 1 <= emin)
{
unsigned int ex_flags;
mpfr_set_emin (e + 1);
mpfr_clear_flags ();
#if defined(TWO_ARGS)
inexact = TEST_FUNCTION (w, x, u, rnd);
#elif defined(DOUBLE_ARG1)
inexact = TEST_FUNCTION (w, d, x, rnd);
#elif defined(DOUBLE_ARG2)
inexact = TEST_FUNCTION (w, x, d, rnd);
#elif defined(ULONG_ARG1)
inexact = TEST_FUNCTION (w, i, x, rnd);
#elif defined(ULONG_ARG2)
inexact = TEST_FUNCTION (w, x, i, rnd);
#else
inexact = TEST_FUNCTION (w, x, rnd);
#endif
flags = __gmpfr_flags;
mpfr_set_emin (oemin);
ex_flags = MPFR_FLAGS_UNDERFLOW | MPFR_FLAGS_INEXACT;
if (flags != ex_flags)
{
printf ("tgeneric: error for " MAKE_STR(TEST_FUNCTION)
", reduced exponent range [%"
MPFR_EXP_FSPEC "d,%" MPFR_EXP_FSPEC
"d] (underflow test) on:\n",
(mpfr_eexp_t) e + 1, (mpfr_eexp_t) oemax);
printf ("x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf ("u = ");
mpfr_dump (u);
#endif
printf ("yprec = %u, rnd_mode = %s\n",
(unsigned int) yprec,
mpfr_print_rnd_mode (rnd));
printf ("Expected flags =");
flags_out (ex_flags);
printf (" got flags =");
flags_out (flags);
printf ("inex = %d, w = ", inexact);
mpfr_dump (w);
exit (1);
}
test_uf = 0; /* Underflow is tested only once. */
}
if (e < emin)
emin = e;
if (e > emax)
emax = e;
}
if (emin > emax)
emin = emax; /* case where all values are singular */
/* Consistency test in a reduced exponent range. Doing it
for the first 10 samples and for prec == p1 (which has
some special cases) should be sufficient. */
if (ctrt <= 10 || prec == p1)
{
mpfr_set_emin (emin);
mpfr_set_emax (emax);
#ifdef DEBUG_TGENERIC
/* Useful information in case of assertion failure. */
printf ("tgeneric: reduced exponent range [%"
MPFR_EXP_FSPEC "d,%" MPFR_EXP_FSPEC "d]\n",
(mpfr_eexp_t) emin, (mpfr_eexp_t) emax);
#endif
mpfr_clear_flags ();
#if defined(TWO_ARGS)
inexact = TEST_FUNCTION (w, x, u, rnd);
#elif defined(DOUBLE_ARG1)
inexact = TEST_FUNCTION (w, d, x, rnd);
#elif defined(DOUBLE_ARG2)
inexact = TEST_FUNCTION (w, x, d, rnd);
#elif defined(ULONG_ARG1)
inexact = TEST_FUNCTION (w, i, x, rnd);
#elif defined(ULONG_ARG2)
inexact = TEST_FUNCTION (w, x, i, rnd);
#else
inexact = TEST_FUNCTION (w, x, rnd);
#endif
flags = __gmpfr_flags;
mpfr_set_emin (oemin);
mpfr_set_emax (oemax);
if (! (SAME_VAL (w, y) &&
SAME_SIGN (inexact, compare) &&
flags == oldflags))
{
printf ("tgeneric: error for " MAKE_STR(TEST_FUNCTION)
", reduced exponent range [%"
MPFR_EXP_FSPEC "d,%" MPFR_EXP_FSPEC "d] on:\n",
(mpfr_eexp_t) emin, (mpfr_eexp_t) emax);
printf ("x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf ("u = ");
mpfr_dump (u);
#endif
printf ("yprec = %u, rnd_mode = %s\n",
(unsigned int) yprec, mpfr_print_rnd_mode (rnd));
printf ("Expected:\n y = ");
mpfr_dump (y);
printf (" inex = %d, flags =", compare);
flags_out (oldflags);
printf ("Got:\n w = ");
mpfr_dump (w);
printf (" inex = %d, flags =", inexact);
flags_out (flags);
exit (1);
}
}
__gmpfr_flags = oldflags; /* restore the flags */
}
if (MPFR_IS_SINGULAR (y))
{
if (MPFR_IS_NAN (y) || mpfr_nanflag_p ())
TGENERIC_CHECK ("bad NaN flag",
MPFR_IS_NAN (y) && mpfr_nanflag_p ());
else if (MPFR_IS_INF (y))
{
TGENERIC_CHECK ("bad overflow flag",
(compare != 0) ^ (mpfr_overflow_p () == 0));
TGENERIC_CHECK ("bad divide-by-zero flag",
(compare == 0 && !infinite_input) ^
(mpfr_divby0_p () == 0));
}
else if (MPFR_IS_ZERO (y))
TGENERIC_CHECK ("bad underflow flag",
(compare != 0) ^ (mpfr_underflow_p () == 0));
}
else if (mpfr_divby0_p ())
{
TGENERIC_CHECK ("both overflow and divide-by-zero",
! mpfr_overflow_p ());
TGENERIC_CHECK ("both underflow and divide-by-zero",
! mpfr_underflow_p ());
TGENERIC_CHECK ("bad compare value (divide-by-zero)",
compare == 0);
}
else if (mpfr_overflow_p ())
{
TGENERIC_CHECK ("both underflow and overflow",
! mpfr_underflow_p ());
TGENERIC_CHECK ("bad compare value (overflow)", compare != 0);
mpfr_nexttoinf (y);
TGENERIC_CHECK ("should have been max MPFR number (overflow)",
MPFR_IS_INF (y));
}
else if (mpfr_underflow_p ())
{
TGENERIC_CHECK ("bad compare value (underflow)", compare != 0);
mpfr_nexttozero (y);
TGENERIC_CHECK ("should have been min MPFR number (underflow)",
MPFR_IS_ZERO (y));
}
else if (mpfr_can_round (y, yprec, rnd, rnd, prec))
{
ctrn++;
mpfr_set (t, y, rnd);
/* Risk of failures are known when some flags are already set
before the function call. Do not set the erange flag, as
it will remain set after the function call and no checks
are performed in such a case (see the mpfr_erangeflag_p
test below). */
if (randlimb () & 1)
__gmpfr_flags = MPFR_FLAGS_ALL ^ MPFR_FLAGS_ERANGE;
#ifdef DEBUG_TGENERIC
TGENERIC_INFO (TEST_FUNCTION, MPFR_PREC (z));
#endif
/* Let's increase the precision of the inputs in a random way.
In most cases, this doesn't make any difference, but for
the mpfr_fmod bug fixed in r6230, this triggers the bug. */
mpfr_prec_round (x, mpfr_get_prec (x) + (randlimb () & 15),
MPFR_RNDN);
#if defined(TWO_ARGS)
mpfr_prec_round (u, mpfr_get_prec (u) + (randlimb () & 15),
MPFR_RNDN);
inexact = TEST_FUNCTION (z, x, u, rnd);
#elif defined(DOUBLE_ARG1)
inexact = TEST_FUNCTION (z, d, x, rnd);
#elif defined(DOUBLE_ARG2)
inexact = TEST_FUNCTION (z, x, d, rnd);
#elif defined(ULONG_ARG1)
inexact = TEST_FUNCTION (z, i, x, rnd);
#elif defined(ULONG_ARG2)
inexact = TEST_FUNCTION (z, x, i, rnd);
#else
inexact = TEST_FUNCTION (z, x, rnd);
#endif
if (mpfr_erangeflag_p ())
goto next_n;
if (! mpfr_equal_p (t, z))
{
printf ("tgeneric: results differ for "
MAKE_STR(TEST_FUNCTION) " on\n x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf (" u = ");
mpfr_dump (u);
#endif
printf (" prec = %u, rnd_mode = %s\n",
(unsigned int) prec, mpfr_print_rnd_mode (rnd));
printf ("Got ");
mpfr_dump (z);
printf ("Expected ");
mpfr_dump (t);
printf ("Approx ");
mpfr_dump (y);
exit (1);
}
compare2 = mpfr_cmp (t, y);
/* if rounding to nearest, cannot know the sign of t - f(x)
because of composed rounding: y = o(f(x)) and t = o(y) */
if (compare * compare2 >= 0)
compare = compare + compare2;
else
compare = inexact; /* cannot determine sign(t-f(x)) */
if (! SAME_SIGN (inexact, compare))
{
printf ("Wrong inexact flag for rnd=%s: expected %d, got %d"
"\n", mpfr_print_rnd_mode (rnd), compare, inexact);
printf ("x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf ("u = ");
mpfr_dump (u);
#endif
printf ("y = ");
mpfr_dump (y);
printf ("t = ");
mpfr_dump (t);
exit (1);
}
}
else if (getenv ("MPFR_SUSPICIOUS_OVERFLOW") != NULL)
{
/* For developers only! */
MPFR_ASSERTN (MPFR_IS_PURE_FP (y));
mpfr_nexttoinf (y);
if (MPFR_IS_INF (y) && MPFR_IS_LIKE_RNDZ (rnd, MPFR_IS_NEG (y))
&& !mpfr_overflow_p () && TGENERIC_SO_TEST)
{
printf ("Possible bug! |y| is the maximum finite number "
"and has been obtained when\nrounding toward zero"
" (%s). Thus there is a very probable overflow,\n"
"but the overflow flag is not set!\n",
mpfr_print_rnd_mode (rnd));
printf ("x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf ("u = ");
mpfr_dump (u);
#endif
exit (1);
}
}
next_n:
/* In case the exponent range has been changed by
tests_default_random() or for special values... */
mpfr_set_emin (old_emin);
mpfr_set_emax (old_emax);
}
}
#ifndef TGENERIC_NOWARNING
if (3 * ctrn < 2 * ctrt)
printf ("Warning! Too few normal cases in generic tests (%lu / %lu)\n",
ctrn, ctrt);
#endif
mpfr_clears (x, y, z, t, w, (mpfr_ptr) 0);
#if defined(TWO_ARGS_ALL)
mpfr_clear (u);
#endif
}
int
mpfr_cmpabs (mpfr_srcptr b, mpfr_srcptr c)
{
mpfr_exp_t be, ce;
mp_size_t bn, cn;
mp_limb_t *bp, *cp;
if (MPFR_ARE_SINGULAR (b, c))
{
if (MPFR_IS_NAN (b) || MPFR_IS_NAN (c))
{
MPFR_SET_ERANGEFLAG ();
return 0;
}
else if (MPFR_IS_INF (b))
return ! MPFR_IS_INF (c);
else if (MPFR_IS_INF (c))
return -1;
else if (MPFR_IS_ZERO (c))
return ! MPFR_IS_ZERO (b);
else /* b == 0 */
return -1;
}
MPFR_ASSERTD (MPFR_IS_PURE_FP (b));
MPFR_ASSERTD (MPFR_IS_PURE_FP (c));
/* Now that we know that b and c are pure FP numbers (i.e. they have
a meaningful exponent), we use MPFR_EXP instead of MPFR_GET_EXP to
allow exponents outside the current exponent range. For instance,
this is useful for mpfr_pow, which compares values to __gmpfr_one.
This is for internal use only! For compatibility with other MPFR
versions, the user must still provide values that are representable
in the current exponent range. */
be = MPFR_EXP (b);
ce = MPFR_EXP (c);
if (be > ce)
return 1;
if (be < ce)
return -1;
/* exponents are equal */
bn = MPFR_LIMB_SIZE(b)-1;
cn = MPFR_LIMB_SIZE(c)-1;
bp = MPFR_MANT(b);
cp = MPFR_MANT(c);
for ( ; bn >= 0 && cn >= 0; bn--, cn--)
{
if (bp[bn] > cp[cn])
return 1;
if (bp[bn] < cp[cn])
return -1;
}
for ( ; bn >= 0; bn--)
if (bp[bn])
return 1;
for ( ; cn >= 0; cn--)
if (cp[cn])
return -1;
return 0;
}
/* 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);
}
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);
}
/* compute sign(b) * (|b| + |c|)
Returns 0 iff result is exact,
a negative value when the result is less than the exact value,
a positive value otherwise. */
int
mpfr_add1sp (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
{
mpfr_uexp_t d;
mpfr_prec_t p;
unsigned int sh;
mp_size_t n;
mp_limb_t *ap, *cp;
mpfr_exp_t bx;
mp_limb_t limb;
int inexact;
MPFR_TMP_DECL(marker);
MPFR_TMP_MARK(marker);
MPFR_ASSERTD(MPFR_PREC(a) == MPFR_PREC(b) && MPFR_PREC(b) == MPFR_PREC(c));
MPFR_ASSERTD(MPFR_IS_PURE_FP(b));
MPFR_ASSERTD(MPFR_IS_PURE_FP(c));
MPFR_ASSERTD(MPFR_GET_EXP(b) >= MPFR_GET_EXP(c));
/* Read prec and num of limbs */
p = MPFR_PREC(b);
n = MPFR_PREC2LIMBS (p);
MPFR_UNSIGNED_MINUS_MODULO(sh, p);
bx = MPFR_GET_EXP(b);
d = (mpfr_uexp_t) (bx - MPFR_GET_EXP(c));
DEBUG (printf ("New add1sp with diff=%lu\n", (unsigned long) d));
if (MPFR_UNLIKELY(d == 0))
{
/* d==0 */
DEBUG( mpfr_print_mant_binary("C= ", MPFR_MANT(c), p) );
DEBUG( mpfr_print_mant_binary("B= ", MPFR_MANT(b), p) );
bx++; /* exp + 1 */
ap = MPFR_MANT(a);
limb = mpn_add_n(ap, MPFR_MANT(b), MPFR_MANT(c), n);
DEBUG( mpfr_print_mant_binary("A= ", ap, p) );
MPFR_ASSERTD(limb != 0); /* There must be a carry */
limb = ap[0]; /* Get LSB (In fact, LSW) */
mpn_rshift(ap, ap, n, 1); /* Shift mantissa A */
ap[n-1] |= MPFR_LIMB_HIGHBIT; /* Set MSB */
ap[0] &= ~MPFR_LIMB_MASK(sh); /* Clear LSB bit */
if (MPFR_LIKELY((limb&(MPFR_LIMB_ONE<<sh)) == 0)) /* Check exact case */
{ inexact = 0; goto set_exponent; }
/* Zero: Truncate
Nearest: Even Rule => truncate or add 1
Away: Add 1 */
if (MPFR_LIKELY(rnd_mode==MPFR_RNDN))
{
if (MPFR_LIKELY((ap[0]&(MPFR_LIMB_ONE<<sh))==0))
{ inexact = -1; goto set_exponent; }
else
goto add_one_ulp;
}
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(b));
if (rnd_mode==MPFR_RNDZ)
{ inexact = -1; goto set_exponent; }
else
goto add_one_ulp;
}
else if (MPFR_UNLIKELY (d >= p))
{
if (MPFR_LIKELY (d > p))
{
/* d > p : Copy B in A */
/* Away: Add 1
Nearest: Trunc
Zero: Trunc */
if (MPFR_LIKELY (rnd_mode==MPFR_RNDN
|| MPFR_IS_LIKE_RNDZ (rnd_mode, MPFR_IS_NEG (b))))
{
copy_set_exponent:
ap = MPFR_MANT (a);
MPN_COPY (ap, MPFR_MANT(b), n);
inexact = -1;
goto set_exponent;
}
else
{
copy_add_one_ulp:
ap = MPFR_MANT(a);
MPN_COPY (ap, MPFR_MANT(b), n);
goto add_one_ulp;
}
}
else
{
/* d==p : Copy B in A */
/* Away: Add 1
Nearest: Even Rule if C is a power of 2, else Add 1
Zero: Trunc */
if (MPFR_LIKELY(rnd_mode==MPFR_RNDN))
{
/* Check if C was a power of 2 */
cp = MPFR_MANT(c);
if (MPFR_UNLIKELY(cp[n-1] == MPFR_LIMB_HIGHBIT))
{
mp_size_t k = n-1;
do {
k--;
} while (k>=0 && cp[k]==0);
if (MPFR_UNLIKELY(k<0))
/* Power of 2: Even rule */
if ((MPFR_MANT (b)[0]&(MPFR_LIMB_ONE<<sh))==0)
goto copy_set_exponent;
}
/* Not a Power of 2 */
goto copy_add_one_ulp;
}
else if (MPFR_IS_LIKE_RNDZ (rnd_mode, MPFR_IS_NEG (b)))
goto copy_set_exponent;
else
goto copy_add_one_ulp;
}
}
else
{
mp_limb_t mask;
mp_limb_t bcp, bcp1; /* Cp and C'p+1 */
/* General case: 1 <= d < p */
cp = MPFR_TMP_LIMBS_ALLOC (n);
/* Shift c in temporary allocated place */
{
mpfr_uexp_t dm;
mp_size_t m;
dm = d % GMP_NUMB_BITS;
m = d / GMP_NUMB_BITS;
if (MPFR_UNLIKELY(dm == 0))
{
/* dm = 0 and m > 0: Just copy */
MPFR_ASSERTD(m!=0);
MPN_COPY(cp, MPFR_MANT(c)+m, n-m);
MPN_ZERO(cp+n-m, m);
}
else if (MPFR_LIKELY(m == 0))
{
/* dm >=1 and m == 0: just shift */
MPFR_ASSERTD(dm >= 1);
mpn_rshift(cp, MPFR_MANT(c), n, dm);
}
else
{
/* dm > 0 and m > 0: shift and zero */
mpn_rshift(cp, MPFR_MANT(c)+m, n-m, dm);
MPN_ZERO(cp+n-m, m);
}
}
DEBUG( mpfr_print_mant_binary("Before", MPFR_MANT(c), p) );
DEBUG( mpfr_print_mant_binary("B= ", MPFR_MANT(b), p) );
DEBUG( mpfr_print_mant_binary("After ", cp, p) );
/* Compute bcp=Cp and bcp1=C'p+1 */
if (MPFR_LIKELY (sh > 0))
{
/* Try to compute them from C' rather than C */
bcp = (cp[0] & (MPFR_LIMB_ONE<<(sh-1))) ;
if (MPFR_LIKELY(cp[0]&MPFR_LIMB_MASK(sh-1)))
bcp1 = 1;
else
{
/* We can't compute C'p+1 from C'. Compute it from C */
/* Start from bit x=p-d+sh in mantissa C
(+sh since we have already looked sh bits in C'!) */
mpfr_prec_t x = p-d+sh-1;
if (MPFR_LIKELY(x>p))
/* We are already looked at all the bits of c, so C'p+1 = 0*/
bcp1 = 0;
else
{
mp_limb_t *tp = MPFR_MANT(c);
mp_size_t kx = n-1 - (x / GMP_NUMB_BITS);
mpfr_prec_t sx = GMP_NUMB_BITS-1-(x%GMP_NUMB_BITS);
DEBUG (printf ("(First) x=%lu Kx=%ld Sx=%lu\n",
(unsigned long) x, (long) kx,
(unsigned long) sx));
/* Looks at the last bits of limb kx (if sx=0 does nothing)*/
if (tp[kx] & MPFR_LIMB_MASK(sx))
bcp1 = 1;
else
{
/*kx += (sx==0);*/
/*If sx==0, tp[kx] hasn't been checked*/
do {
kx--;
} while (kx>=0 && tp[kx]==0);
bcp1 = (kx >= 0);
}
}
}
}
else /* sh == 0 */
{
/* Compute Cp and C'p+1 from C with sh=0 */
mp_limb_t *tp = MPFR_MANT(c);
/* Start from bit x=p-d in mantissa C */
mpfr_prec_t x = p-d;
mp_size_t kx = n-1 - (x / GMP_NUMB_BITS);
mpfr_prec_t sx = GMP_NUMB_BITS-1-(x%GMP_NUMB_BITS);
MPFR_ASSERTD(p >= d);
bcp = tp[kx] & (MPFR_LIMB_ONE<<sx);
/* Looks at the last bits of limb kx (If sx=0, does nothing)*/
if (tp[kx]&MPFR_LIMB_MASK(sx))
bcp1 = 1;
else
{
do {
kx--;
} while (kx>=0 && tp[kx]==0);
bcp1 = (kx>=0);
}
}
DEBUG (printf("sh=%u Cp=%lu C'p+1=%lu\n", sh,
(unsigned long) bcp, (unsigned long) bcp1));
/* Clean shifted C' */
mask = ~MPFR_LIMB_MASK(sh);
cp[0] &= mask;
/* Add the mantissa c from b in a */
ap = MPFR_MANT(a);
limb = mpn_add_n (ap, MPFR_MANT(b), cp, n);
DEBUG( mpfr_print_mant_binary("Add= ", ap, p) );
/* Check for overflow */
if (MPFR_UNLIKELY (limb))
{
limb = ap[0] & (MPFR_LIMB_ONE<<sh); /* Get LSB */
mpn_rshift (ap, ap, n, 1); /* Shift mantissa*/
bx++; /* Fix exponent */
ap[n-1] |= MPFR_LIMB_HIGHBIT; /* Set MSB */
ap[0] &= mask; /* Clear LSB bit */
bcp1 |= bcp; /* Recompute C'p+1 */
bcp = limb; /* Recompute Cp */
DEBUG (printf ("(Overflow) Cp=%lu C'p+1=%lu\n",
(unsigned long) bcp, (unsigned long) bcp1));
DEBUG (mpfr_print_mant_binary ("Add= ", ap, p));
}
/* Round:
Zero: Truncate but could be exact.
Away: Add 1 if Cp or C'p+1 !=0
Nearest: Truncate but could be exact if Cp==0
Add 1 if C'p+1 !=0,
Even rule else */
if (MPFR_LIKELY(rnd_mode == MPFR_RNDN))
{
if (MPFR_LIKELY(bcp == 0))
{ inexact = MPFR_LIKELY(bcp1) ? -1 : 0; goto set_exponent; }
else if (MPFR_UNLIKELY(bcp1==0) && (ap[0]&(MPFR_LIMB_ONE<<sh))==0)
{ inexact = -1; goto set_exponent; }
else
goto add_one_ulp;
}
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(b));
if (rnd_mode == MPFR_RNDZ)
{
inexact = MPFR_LIKELY(bcp || bcp1) ? -1 : 0;
goto set_exponent;
}
else
{
if (MPFR_UNLIKELY(bcp==0 && bcp1==0))
{ inexact = 0; goto set_exponent; }
else
goto add_one_ulp;
}
}
MPFR_ASSERTN(0);
add_one_ulp:
/* add one unit in last place to a */
DEBUG( printf("AddOneUlp\n") );
if (MPFR_UNLIKELY( mpn_add_1(ap, ap, n, MPFR_LIMB_ONE<<sh) ))
{
/* Case 100000x0 = 0x1111x1 + 1*/
DEBUG( printf("Pow of 2\n") );
bx++;
ap[n-1] = MPFR_LIMB_HIGHBIT;
}
inexact = 1;
set_exponent:
if (MPFR_UNLIKELY(bx > __gmpfr_emax)) /* Check for overflow */
{
DEBUG( printf("Overflow\n") );
MPFR_TMP_FREE(marker);
MPFR_SET_SAME_SIGN(a,b);
return mpfr_overflow(a, rnd_mode, MPFR_SIGN(a));
}
MPFR_SET_EXP (a, bx);
MPFR_SET_SAME_SIGN(a,b);
MPFR_TMP_FREE(marker);
MPFR_RET (inexact * MPFR_INT_SIGN (a));
}
int
mpfr_sub1sp (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
{
mpfr_exp_t bx,cx;
mpfr_uexp_t d;
mpfr_prec_t p, sh, cnt;
mp_size_t n;
mp_limb_t *ap, *bp, *cp;
mp_limb_t limb;
int inexact;
mp_limb_t bcp,bcp1; /* Cp and C'p+1 */
mp_limb_t bbcp = (mp_limb_t) -1, bbcp1 = (mp_limb_t) -1; /* Cp+1 and C'p+2,
gcc claims that they might be used uninitialized. We fill them with invalid
values, which should produce a failure if so. See README.dev file. */
MPFR_TMP_DECL(marker);
MPFR_TMP_MARK(marker);
MPFR_ASSERTD(MPFR_PREC(a) == MPFR_PREC(b) && MPFR_PREC(b) == MPFR_PREC(c));
MPFR_ASSERTD(MPFR_IS_PURE_FP(b));
MPFR_ASSERTD(MPFR_IS_PURE_FP(c));
/* Read prec and num of limbs */
p = MPFR_PREC (b);
n = MPFR_PREC2LIMBS (p);
/* Fast cmp of |b| and |c|*/
bx = MPFR_GET_EXP (b);
cx = MPFR_GET_EXP (c);
if (MPFR_UNLIKELY(bx == cx))
{
mp_size_t k = n - 1;
/* Check mantissa since exponent are equals */
bp = MPFR_MANT(b);
cp = MPFR_MANT(c);
while (k>=0 && MPFR_UNLIKELY(bp[k] == cp[k]))
k--;
if (MPFR_UNLIKELY(k < 0))
/* b == c ! */
{
/* Return exact number 0 */
if (rnd_mode == MPFR_RNDD)
MPFR_SET_NEG(a);
else
MPFR_SET_POS(a);
MPFR_SET_ZERO(a);
MPFR_RET(0);
}
else if (bp[k] > cp[k])
goto BGreater;
else
{
MPFR_ASSERTD(bp[k]<cp[k]);
goto CGreater;
}
}
else if (MPFR_UNLIKELY(bx < cx))
{
/* Swap b and c and set sign */
mpfr_srcptr t;
mpfr_exp_t tx;
CGreater:
MPFR_SET_OPPOSITE_SIGN(a,b);
t = b; b = c; c = t;
tx = bx; bx = cx; cx = tx;
}
else
{
/* b > c */
BGreater:
MPFR_SET_SAME_SIGN(a,b);
}
/* Now b > c */
MPFR_ASSERTD(bx >= cx);
d = (mpfr_uexp_t) bx - cx;
DEBUG (printf ("New with diff=%lu\n", (unsigned long) d));
if (MPFR_UNLIKELY(d <= 1))
{
if (MPFR_LIKELY(d < 1))
{
/* <-- b -->
<-- c --> : exact sub */
ap = MPFR_MANT(a);
mpn_sub_n (ap, MPFR_MANT(b), MPFR_MANT(c), n);
/* Normalize */
ExactNormalize:
limb = ap[n-1];
if (MPFR_LIKELY(limb))
{
/* First limb is not zero. */
count_leading_zeros(cnt, limb);
/* cnt could be == 0 <= SubD1Lose */
if (MPFR_LIKELY(cnt))
{
mpn_lshift(ap, ap, n, cnt); /* Normalize number */
bx -= cnt; /* Update final expo */
}
/* Last limb should be ok */
MPFR_ASSERTD(!(ap[0] & MPFR_LIMB_MASK((unsigned int) (-p)
% GMP_NUMB_BITS)));
}
else
{
/* First limb is zero */
mp_size_t k = n-1, len;
/* Find the first limb not equal to zero.
FIXME:It is assume it exists (since |b| > |c| and same prec)*/
do
{
MPFR_ASSERTD( k > 0 );
limb = ap[--k];
}
while (limb == 0);
MPFR_ASSERTD(limb != 0);
count_leading_zeros(cnt, limb);
k++;
len = n - k; /* Number of last limb */
MPFR_ASSERTD(k >= 0);
if (MPFR_LIKELY(cnt))
mpn_lshift(ap+len, ap, k, cnt); /* Normalize the High Limb*/
else
{
/* Must use DECR since src and dest may overlap & dest>=src*/
MPN_COPY_DECR(ap+len, ap, k);
}
MPN_ZERO(ap, len); /* Zeroing the last limbs */
bx -= cnt + len*GMP_NUMB_BITS; /* Update Expo */
/* Last limb should be ok */
MPFR_ASSERTD(!(ap[len]&MPFR_LIMB_MASK((unsigned int) (-p)
% GMP_NUMB_BITS)));
}
/* Check expo underflow */
if (MPFR_UNLIKELY(bx < __gmpfr_emin))
{
MPFR_TMP_FREE(marker);
/* inexact=0 */
DEBUG( printf("(D==0 Underflow)\n") );
if (rnd_mode == MPFR_RNDN &&
(bx < __gmpfr_emin - 1 ||
(/*inexact >= 0 &&*/ mpfr_powerof2_raw (a))))
rnd_mode = MPFR_RNDZ;
return mpfr_underflow (a, rnd_mode, MPFR_SIGN(a));
}
MPFR_SET_EXP (a, bx);
/* No rounding is necessary since the result is exact */
MPFR_ASSERTD(ap[n-1] > ~ap[n-1]);
MPFR_TMP_FREE(marker);
return 0;
}
else /* if (d == 1) */
{
/* | <-- b -->
| <-- c --> */
mp_limb_t c0, mask;
mp_size_t k;
MPFR_UNSIGNED_MINUS_MODULO(sh, p);
/* If we lose at least one bit, compute 2*b-c (Exact)
* else compute b-c/2 */
bp = MPFR_MANT(b);
cp = MPFR_MANT(c);
k = n-1;
limb = bp[k] - cp[k]/2;
if (limb > MPFR_LIMB_HIGHBIT)
{
/* We can't lose precision: compute b-c/2 */
/* Shift c in the allocated temporary block */
SubD1NoLose:
c0 = cp[0] & (MPFR_LIMB_ONE<<sh);
cp = MPFR_TMP_LIMBS_ALLOC (n);
mpn_rshift(cp, MPFR_MANT(c), n, 1);
if (MPFR_LIKELY(c0 == 0))
{
/* Result is exact: no need of rounding! */
ap = MPFR_MANT(a);
mpn_sub_n (ap, bp, cp, n);
MPFR_SET_EXP(a, bx); /* No expo overflow! */
/* No truncate or normalize is needed */
MPFR_ASSERTD(ap[n-1] > ~ap[n-1]);
/* No rounding is necessary since the result is exact */
MPFR_TMP_FREE(marker);
return 0;
}
ap = MPFR_MANT(a);
mask = ~MPFR_LIMB_MASK(sh);
cp[0] &= mask; /* Delete last bit of c */
mpn_sub_n (ap, bp, cp, n);
MPFR_SET_EXP(a, bx); /* No expo overflow! */
MPFR_ASSERTD( !(ap[0] & ~mask) ); /* Check last bits */
/* No normalize is needed */
MPFR_ASSERTD(ap[n-1] > ~ap[n-1]);
/* Rounding is necessary since c0 = 1*/
/* Cp =-1 and C'p+1=0 */
bcp = 1; bcp1 = 0;
if (MPFR_LIKELY(rnd_mode == MPFR_RNDN))
{
/* Even Rule apply: Check Ap-1 */
if (MPFR_LIKELY( (ap[0] & (MPFR_LIMB_ONE<<sh)) == 0) )
goto truncate;
else
goto sub_one_ulp;
}
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(a));
if (rnd_mode == MPFR_RNDZ)
goto sub_one_ulp;
else
goto truncate;
}
else if (MPFR_LIKELY(limb < MPFR_LIMB_HIGHBIT))
{
/* We lose at least one bit of prec */
/* Calcul of 2*b-c (Exact) */
/* Shift b in the allocated temporary block */
SubD1Lose:
bp = MPFR_TMP_LIMBS_ALLOC (n);
mpn_lshift (bp, MPFR_MANT(b), n, 1);
ap = MPFR_MANT(a);
mpn_sub_n (ap, bp, cp, n);
bx--;
goto ExactNormalize;
}
else
{
/* Case: limb = 100000000000 */
/* Check while b[k] == c'[k] (C' is C shifted by 1) */
/* If b[k]<c'[k] => We lose at least one bit*/
/* If b[k]>c'[k] => We don't lose any bit */
/* If k==-1 => We don't lose any bit
AND the result is 100000000000 0000000000 00000000000 */
mp_limb_t carry;
do {
carry = cp[k]&MPFR_LIMB_ONE;
k--;
} while (k>=0 &&
bp[k]==(carry=cp[k]/2+(carry<<(GMP_NUMB_BITS-1))));
if (MPFR_UNLIKELY(k<0))
{
/*If carry then (sh==0 and Virtual c'[-1] > Virtual b[-1]) */
if (MPFR_UNLIKELY(carry)) /* carry = cp[0]&MPFR_LIMB_ONE */
{
/* FIXME: Can be faster? */
MPFR_ASSERTD(sh == 0);
goto SubD1Lose;
}
/* Result is a power of 2 */
ap = MPFR_MANT (a);
MPN_ZERO (ap, n);
ap[n-1] = MPFR_LIMB_HIGHBIT;
MPFR_SET_EXP (a, bx); /* No expo overflow! */
/* No Normalize is needed*/
/* No Rounding is needed */
MPFR_TMP_FREE (marker);
return 0;
}
/* carry = cp[k]/2+(cp[k-1]&1)<<(GMP_NUMB_BITS-1) = c'[k]*/
else if (bp[k] > carry)
goto SubD1NoLose;
else
{
MPFR_ASSERTD(bp[k]<carry);
goto SubD1Lose;
}
}
}
}
else if (MPFR_UNLIKELY(d >= p))
{
ap = MPFR_MANT(a);
MPFR_UNSIGNED_MINUS_MODULO(sh, p);
/* We can't set A before since we use cp for rounding... */
/* Perform rounding: check if a=b or a=b-ulp(b) */
if (MPFR_UNLIKELY(d == p))
{
/* cp == -1 and c'p+1 = ? */
bcp = 1;
/* We need Cp+1 later for a very improbable case. */
bbcp = (MPFR_MANT(c)[n-1] & (MPFR_LIMB_ONE<<(GMP_NUMB_BITS-2)));
/* We need also C'p+1 for an even more unprobable case... */
if (MPFR_LIKELY( bbcp ))
bcp1 = 1;
else
{
cp = MPFR_MANT(c);
if (MPFR_UNLIKELY(cp[n-1] == MPFR_LIMB_HIGHBIT))
{
mp_size_t k = n-1;
do {
k--;
} while (k>=0 && cp[k]==0);
bcp1 = (k>=0);
}
else
bcp1 = 1;
}
DEBUG( printf("(D=P) Cp=-1 Cp+1=%d C'p+1=%d \n", bbcp!=0, bcp1!=0) );
bp = MPFR_MANT (b);
/* Even if src and dest overlap, it is ok using MPN_COPY */
if (MPFR_LIKELY(rnd_mode == MPFR_RNDN))
{
if (MPFR_UNLIKELY( bcp && bcp1==0 ))
/* Cp=-1 and C'p+1=0: Even rule Apply! */
/* Check Ap-1 = Bp-1 */
if ((bp[0] & (MPFR_LIMB_ONE<<sh)) == 0)
{
MPN_COPY(ap, bp, n);
goto truncate;
}
MPN_COPY(ap, bp, n);
goto sub_one_ulp;
}
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(a));
if (rnd_mode == MPFR_RNDZ)
{
MPN_COPY(ap, bp, n);
goto sub_one_ulp;
}
else
{
MPN_COPY(ap, bp, n);
goto truncate;
}
}
else
{
/* Cp=0, Cp+1=-1 if d==p+1, C'p+1=-1 */
bcp = 0; bbcp = (d==p+1); bcp1 = 1;
DEBUG( printf("(D>P) Cp=%d Cp+1=%d C'p+1=%d\n", bcp!=0,bbcp!=0,bcp1!=0) );
/* Need to compute C'p+2 if d==p+1 and if rnd_mode=NEAREST
(Because of a very improbable case) */
if (MPFR_UNLIKELY(d==p+1 && rnd_mode==MPFR_RNDN))
{
cp = MPFR_MANT(c);
if (MPFR_UNLIKELY(cp[n-1] == MPFR_LIMB_HIGHBIT))
{
mp_size_t k = n-1;
do {
k--;
} while (k>=0 && cp[k]==0);
bbcp1 = (k>=0);
}
else
bbcp1 = 1;
DEBUG( printf("(D>P) C'p+2=%d\n", bbcp1!=0) );
}
/* Copy mantissa B in A */
MPN_COPY(ap, MPFR_MANT(b), n);
/* Round */
if (MPFR_LIKELY(rnd_mode == MPFR_RNDN))
goto truncate;
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(a));
if (rnd_mode == MPFR_RNDZ)
goto sub_one_ulp;
else /* rnd_mode = AWAY */
goto truncate;
}
}
else
{
mpfr_uexp_t dm;
mp_size_t m;
mp_limb_t mask;
/* General case: 2 <= d < p */
MPFR_UNSIGNED_MINUS_MODULO(sh, p);
cp = MPFR_TMP_LIMBS_ALLOC (n);
/* Shift c in temporary allocated place */
dm = d % GMP_NUMB_BITS;
m = d / GMP_NUMB_BITS;
if (MPFR_UNLIKELY(dm == 0))
{
/* dm = 0 and m > 0: Just copy */
MPFR_ASSERTD(m!=0);
MPN_COPY(cp, MPFR_MANT(c)+m, n-m);
MPN_ZERO(cp+n-m, m);
}
else if (MPFR_LIKELY(m == 0))
{
/* dm >=2 and m == 0: just shift */
MPFR_ASSERTD(dm >= 2);
mpn_rshift(cp, MPFR_MANT(c), n, dm);
}
else
{
/* dm > 0 and m > 0: shift and zero */
mpn_rshift(cp, MPFR_MANT(c)+m, n-m, dm);
MPN_ZERO(cp+n-m, m);
}
DEBUG( mpfr_print_mant_binary("Before", MPFR_MANT(c), p) );
DEBUG( mpfr_print_mant_binary("B= ", MPFR_MANT(b), p) );
DEBUG( mpfr_print_mant_binary("After ", cp, p) );
/* Compute bcp=Cp and bcp1=C'p+1 */
if (MPFR_LIKELY(sh))
{
/* Try to compute them from C' rather than C (FIXME: Faster?) */
bcp = (cp[0] & (MPFR_LIMB_ONE<<(sh-1))) ;
if (MPFR_LIKELY( cp[0] & MPFR_LIMB_MASK(sh-1) ))
bcp1 = 1;
else
{
/* We can't compute C'p+1 from C'. Compute it from C */
/* Start from bit x=p-d+sh in mantissa C
(+sh since we have already looked sh bits in C'!) */
mpfr_prec_t x = p-d+sh-1;
if (MPFR_LIKELY(x>p))
/* We are already looked at all the bits of c, so C'p+1 = 0*/
bcp1 = 0;
else
{
mp_limb_t *tp = MPFR_MANT(c);
mp_size_t kx = n-1 - (x / GMP_NUMB_BITS);
mpfr_prec_t sx = GMP_NUMB_BITS-1-(x%GMP_NUMB_BITS);
DEBUG (printf ("(First) x=%lu Kx=%ld Sx=%lu\n",
(unsigned long) x, (long) kx,
(unsigned long) sx));
/* Looks at the last bits of limb kx (if sx=0 does nothing)*/
if (tp[kx] & MPFR_LIMB_MASK(sx))
bcp1 = 1;
else
{
/*kx += (sx==0);*/
/*If sx==0, tp[kx] hasn't been checked*/
do {
kx--;
} while (kx>=0 && tp[kx]==0);
bcp1 = (kx >= 0);
}
}
}
}
else
{
/* Compute Cp and C'p+1 from C with sh=0 */
mp_limb_t *tp = MPFR_MANT(c);
/* Start from bit x=p-d in mantissa C */
mpfr_prec_t x = p-d;
mp_size_t kx = n-1 - (x / GMP_NUMB_BITS);
mpfr_prec_t sx = GMP_NUMB_BITS-1-(x%GMP_NUMB_BITS);
MPFR_ASSERTD(p >= d);
bcp = (tp[kx] & (MPFR_LIMB_ONE<<sx));
/* Looks at the last bits of limb kx (If sx=0, does nothing)*/
if (tp[kx] & MPFR_LIMB_MASK(sx))
bcp1 = 1;
else
{
/*kx += (sx==0);*/ /*If sx==0, tp[kx] hasn't been checked*/
do {
kx--;
} while (kx>=0 && tp[kx]==0);
bcp1 = (kx>=0);
}
}
DEBUG( printf("sh=%lu Cp=%d C'p+1=%d\n", sh, bcp!=0, bcp1!=0) );
/* Check if we can lose a bit, and if so compute Cp+1 and C'p+2 */
bp = MPFR_MANT(b);
if (MPFR_UNLIKELY((bp[n-1]-cp[n-1]) <= MPFR_LIMB_HIGHBIT))
{
/* We can lose a bit so we precompute Cp+1 and C'p+2 */
/* Test for trivial case: since C'p+1=0, Cp+1=0 and C'p+2 =0 */
if (MPFR_LIKELY(bcp1 == 0))
{
bbcp = 0;
bbcp1 = 0;
}
else /* bcp1 != 0 */
{
/* We can lose a bit:
compute Cp+1 and C'p+2 from mantissa C */
mp_limb_t *tp = MPFR_MANT(c);
/* Start from bit x=(p+1)-d in mantissa C */
mpfr_prec_t x = p+1-d;
mp_size_t kx = n-1 - (x/GMP_NUMB_BITS);
mpfr_prec_t sx = GMP_NUMB_BITS-1-(x%GMP_NUMB_BITS);
MPFR_ASSERTD(p > d);
DEBUG (printf ("(pre) x=%lu Kx=%ld Sx=%lu\n",
(unsigned long) x, (long) kx,
(unsigned long) sx));
bbcp = (tp[kx] & (MPFR_LIMB_ONE<<sx)) ;
/* Looks at the last bits of limb kx (If sx=0, does nothing)*/
/* If Cp+1=0, since C'p+1!=0, C'p+2=1 ! */
if (MPFR_LIKELY(bbcp==0 || (tp[kx]&MPFR_LIMB_MASK(sx))))
bbcp1 = 1;
else
{
/*kx += (sx==0);*/ /*If sx==0, tp[kx] hasn't been checked*/
do {
kx--;
} while (kx>=0 && tp[kx]==0);
bbcp1 = (kx>=0);
DEBUG (printf ("(Pre) Scan done for %ld\n", (long) kx));
}
} /*End of Bcp1 != 0*/
DEBUG( printf("(Pre) Cp+1=%d C'p+2=%d\n", bbcp!=0, bbcp1!=0) );
} /* End of "can lose a bit" */
/* Clean shifted C' */
mask = ~MPFR_LIMB_MASK (sh);
cp[0] &= mask;
/* Subtract the mantissa c from b in a */
ap = MPFR_MANT(a);
mpn_sub_n (ap, bp, cp, n);
DEBUG( mpfr_print_mant_binary("Sub= ", ap, p) );
/* Normalize: we lose at max one bit*/
if (MPFR_UNLIKELY(MPFR_LIMB_MSB(ap[n-1]) == 0))
{
/* High bit is not set and we have to fix it! */
/* Ap >= 010000xxx001 */
mpn_lshift(ap, ap, n, 1);
/* Ap >= 100000xxx010 */
if (MPFR_UNLIKELY(bcp!=0)) /* Check if Cp = -1 */
/* Since Cp == -1, we have to substract one more */
{
mpn_sub_1(ap, ap, n, MPFR_LIMB_ONE<<sh);
MPFR_ASSERTD(MPFR_LIMB_MSB(ap[n-1]) != 0);
}
/* Ap >= 10000xxx001 */
/* Final exponent -1 since we have shifted the mantissa */
bx--;
/* Update bcp and bcp1 */
MPFR_ASSERTN(bbcp != (mp_limb_t) -1);
MPFR_ASSERTN(bbcp1 != (mp_limb_t) -1);
bcp = bbcp;
bcp1 = bbcp1;
/* We dont't have anymore a valid Cp+1!
But since Ap >= 100000xxx001, the final sub can't unnormalize!*/
}
MPFR_ASSERTD( !(ap[0] & ~mask) );
/* Rounding */
if (MPFR_LIKELY(rnd_mode == MPFR_RNDN))
{
if (MPFR_LIKELY(bcp==0))
goto truncate;
else if ((bcp1) || ((ap[0] & (MPFR_LIMB_ONE<<sh)) != 0))
goto sub_one_ulp;
else
goto truncate;
}
/* Update rounding mode */
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(a));
if (rnd_mode == MPFR_RNDZ && (MPFR_LIKELY(bcp || bcp1)))
goto sub_one_ulp;
goto truncate;
}
MPFR_RET_NEVER_GO_HERE ();
/* Sub one ulp to the result */
sub_one_ulp:
mpn_sub_1 (ap, ap, n, MPFR_LIMB_ONE << sh);
/* Result should be smaller than exact value: inexact=-1 */
inexact = -1;
/* Check normalisation */
if (MPFR_UNLIKELY(MPFR_LIMB_MSB(ap[n-1]) == 0))
{
/* ap was a power of 2, and we lose a bit */
/* Now it is 0111111111111111111[00000 */
mpn_lshift(ap, ap, n, 1);
bx--;
/* And the lost bit x depends on Cp+1, and Cp */
/* Compute Cp+1 if it isn't already compute (ie d==1) */
/* FIXME: Is this case possible? */
if (MPFR_UNLIKELY(d == 1))
bbcp = 0;
DEBUG( printf("(SubOneUlp)Cp=%d, Cp+1=%d C'p+1=%d\n", bcp!=0,bbcp!=0,bcp1!=0));
/* Compute the last bit (Since we have shifted the mantissa)
we need one more bit!*/
MPFR_ASSERTN(bbcp != (mp_limb_t) -1);
if ( (rnd_mode == MPFR_RNDZ && bcp==0)
|| (rnd_mode==MPFR_RNDN && bbcp==0)
|| (bcp && bcp1==0) ) /*Exact result*/
{
ap[0] |= MPFR_LIMB_ONE<<sh;
if (rnd_mode == MPFR_RNDN)
inexact = 1;
DEBUG( printf("(SubOneUlp) Last bit set\n") );
}
/* Result could be exact if C'p+1 = 0 and rnd == Zero
since we have had one more bit to the result */
/* Fixme: rnd_mode == MPFR_RNDZ needed ? */
if (bcp1==0 && rnd_mode==MPFR_RNDZ)
{
DEBUG( printf("(SubOneUlp) Exact result\n") );
inexact = 0;
}
}
goto end_of_sub;
truncate:
/* Check if the result is an exact power of 2: 100000000000
in which cases, we could have to do sub_one_ulp due to some nasty reasons:
If Result is a Power of 2:
+ If rnd = AWAY,
| If Cp=-1 and C'p+1 = 0, SubOneUlp and the result is EXACT.
If Cp=-1 and C'p+1 =-1, SubOneUlp and the result is above.
Otherwise truncate
+ If rnd = NEAREST,
If Cp= 0 and Cp+1 =-1 and C'p+2=-1, SubOneUlp and the result is above
If cp=-1 and C'p+1 = 0, SubOneUlp and the result is exact.
Otherwise truncate.
X bit should always be set if SubOneUlp*/
if (MPFR_UNLIKELY(ap[n-1] == MPFR_LIMB_HIGHBIT))
{
mp_size_t k = n-1;
do {
k--;
} while (k>=0 && ap[k]==0);
if (MPFR_UNLIKELY(k<0))
{
/* It is a power of 2! */
/* Compute Cp+1 if it isn't already compute (ie d==1) */
/* FIXME: Is this case possible? */
if (d == 1)
bbcp=0;
DEBUG( printf("(Truncate) Cp=%d, Cp+1=%d C'p+1=%d C'p+2=%d\n", \
bcp!=0, bbcp!=0, bcp1!=0, bbcp1!=0) );
MPFR_ASSERTN(bbcp != (mp_limb_t) -1);
MPFR_ASSERTN((rnd_mode != MPFR_RNDN) || (bcp != 0) || (bbcp == 0) || (bbcp1 != (mp_limb_t) -1));
if (((rnd_mode != MPFR_RNDZ) && bcp)
||
((rnd_mode == MPFR_RNDN) && (bcp == 0) && (bbcp) && (bbcp1)))
{
DEBUG( printf("(Truncate) Do sub\n") );
mpn_sub_1 (ap, ap, n, MPFR_LIMB_ONE << sh);
mpn_lshift(ap, ap, n, 1);
ap[0] |= MPFR_LIMB_ONE<<sh;
bx--;
/* FIXME: Explain why it works (or why not)... */
inexact = (bcp1 == 0) ? 0 : (rnd_mode==MPFR_RNDN) ? -1 : 1;
goto end_of_sub;
}
}
}
/* Calcul of Inexact flag.*/
inexact = MPFR_LIKELY(bcp || bcp1) ? 1 : 0;
end_of_sub:
/* Update Expo */
/* FIXME: Is this test really useful?
If d==0 : Exact case. This is never called.
if 1 < d < p : bx=MPFR_EXP(b) or MPFR_EXP(b)-1 > MPFR_EXP(c) > emin
if d == 1 : bx=MPFR_EXP(b). If we could lose any bits, the exact
normalisation is called.
if d >= p : bx=MPFR_EXP(b) >= MPFR_EXP(c) + p > emin
After SubOneUlp, we could have one bit less.
if 1 < d < p : bx >= MPFR_EXP(b)-2 >= MPFR_EXP(c) > emin
if d == 1 : bx >= MPFR_EXP(b)-1 = MPFR_EXP(c) > emin.
if d >= p : bx >= MPFR_EXP(b)-1 > emin since p>=2.
*/
MPFR_ASSERTD( bx >= __gmpfr_emin);
/*
if (MPFR_UNLIKELY(bx < __gmpfr_emin))
{
DEBUG( printf("(Final Underflow)\n") );
if (rnd_mode == MPFR_RNDN &&
(bx < __gmpfr_emin - 1 ||
(inexact >= 0 && mpfr_powerof2_raw (a))))
rnd_mode = MPFR_RNDZ;
MPFR_TMP_FREE(marker);
return mpfr_underflow (a, rnd_mode, MPFR_SIGN(a));
}
*/
MPFR_SET_EXP (a, bx);
MPFR_TMP_FREE(marker);
MPFR_RET (inexact * MPFR_INT_SIGN (a));
}
int
mpfr_log (mpfr_ptr r, mpfr_srcptr a, mpfr_rnd_t rnd_mode)
{
int inexact;
mpfr_prec_t p, q;
mpfr_t tmp1, tmp2;
MPFR_SAVE_EXPO_DECL (expo);
MPFR_ZIV_DECL (loop);
MPFR_GROUP_DECL(group);
MPFR_LOG_FUNC
(("a[%Pu]=%.*Rg rnd=%d", mpfr_get_prec (a), mpfr_log_prec, a, rnd_mode),
("r[%Pu]=%.*Rg inexact=%d", mpfr_get_prec (r), mpfr_log_prec, r,
inexact));
/* Special cases */
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (a)))
{
/* If a is NaN, the result is NaN */
if (MPFR_IS_NAN (a))
{
MPFR_SET_NAN (r);
MPFR_RET_NAN;
}
/* check for infinity before zero */
else if (MPFR_IS_INF (a))
{
if (MPFR_IS_NEG (a))
/* log(-Inf) = NaN */
{
MPFR_SET_NAN (r);
MPFR_RET_NAN;
}
else /* log(+Inf) = +Inf */
{
MPFR_SET_INF (r);
MPFR_SET_POS (r);
MPFR_RET (0);
}
}
else /* a is zero */
{
MPFR_ASSERTD (MPFR_IS_ZERO (a));
MPFR_SET_INF (r);
MPFR_SET_NEG (r);
mpfr_set_divby0 ();
MPFR_RET (0); /* log(0) is an exact -infinity */
}
}
/* If a is negative, the result is NaN */
else if (MPFR_UNLIKELY (MPFR_IS_NEG (a)))
{
MPFR_SET_NAN (r);
MPFR_RET_NAN;
}
/* If a is 1, the result is 0 */
else if (MPFR_UNLIKELY (MPFR_GET_EXP (a) == 1 && mpfr_cmp_ui (a, 1) == 0))
{
MPFR_SET_ZERO (r);
MPFR_SET_POS (r);
MPFR_RET (0); /* only "normal" case where the result is exact */
}
q = MPFR_PREC (r);
/* use initial precision about q+lg(q)+5 */
p = q + 5 + 2 * MPFR_INT_CEIL_LOG2 (q);
/* % ~(mpfr_prec_t)GMP_NUMB_BITS ;
m=q; while (m) { p++; m >>= 1; } */
/* if (MPFR_LIKELY(p % GMP_NUMB_BITS != 0))
p += GMP_NUMB_BITS - (p%GMP_NUMB_BITS); */
MPFR_SAVE_EXPO_MARK (expo);
MPFR_GROUP_INIT_2 (group, p, tmp1, tmp2);
MPFR_ZIV_INIT (loop, p);
for (;;)
{
long m;
mpfr_exp_t cancel;
/* Calculus of m (depends on p) */
m = (p + 1) / 2 - MPFR_GET_EXP (a) + 1;
mpfr_mul_2si (tmp2, a, m, MPFR_RNDN); /* s=a*2^m, err<=1 ulp */
mpfr_div (tmp1, __gmpfr_four, tmp2, MPFR_RNDN);/* 4/s, err<=2 ulps */
mpfr_agm (tmp2, __gmpfr_one, tmp1, MPFR_RNDN); /* AG(1,4/s),err<=3 ulps */
mpfr_mul_2ui (tmp2, tmp2, 1, MPFR_RNDN); /* 2*AG(1,4/s), err<=3 ulps */
mpfr_const_pi (tmp1, MPFR_RNDN); /* compute pi, err<=1ulp */
mpfr_div (tmp2, tmp1, tmp2, MPFR_RNDN); /* pi/2*AG(1,4/s), err<=5ulps */
mpfr_const_log2 (tmp1, MPFR_RNDN); /* compute log(2), err<=1ulp */
mpfr_mul_si (tmp1, tmp1, m, MPFR_RNDN); /* compute m*log(2),err<=2ulps */
mpfr_sub (tmp1, tmp2, tmp1, MPFR_RNDN); /* log(a), err<=7ulps+cancel */
if (MPFR_LIKELY (MPFR_IS_PURE_FP (tmp1) && MPFR_IS_PURE_FP (tmp2)))
{
cancel = MPFR_GET_EXP (tmp2) - MPFR_GET_EXP (tmp1);
MPFR_LOG_MSG (("canceled bits=%ld\n", (long) cancel));
MPFR_LOG_VAR (tmp1);
if (MPFR_UNLIKELY (cancel < 0))
cancel = 0;
/* we have 7 ulps of error from the above roundings,
4 ulps from the 4/s^2 second order term,
plus the canceled bits */
if (MPFR_LIKELY (MPFR_CAN_ROUND (tmp1, p-cancel-4, q, rnd_mode)))
break;
/* VL: I think it is better to have an increment that it isn't
too low; in particular, the increment must be positive even
if cancel = 0 (can this occur?). */
p += cancel >= 8 ? cancel : 8;
}
else
{
/* TODO: find why this case can occur and what is best to do
with it. */
p += 32;
}
MPFR_ZIV_NEXT (loop, p);
MPFR_GROUP_REPREC_2 (group, p, tmp1, tmp2);
}
MPFR_ZIV_FREE (loop);
inexact = mpfr_set (r, tmp1, rnd_mode);
/* We clean */
MPFR_GROUP_CLEAR (group);
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_check_range (r, inexact, rnd_mode);
}