int
mpfr_cmpabs (mpfr_srcptr b, mpfr_srcptr c)
{
mp_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_ERANGE ();
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;
}
be = MPFR_GET_EXP (b);
ce = MPFR_GET_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;
}
// remove trailing zeros (only by limbs)
void mpfr_remove_trailing_zeros(mpfr_t x) {
unsigned int xn = MPFR_LIMB_SIZE(x);
mp_limb_t* xp = MPFR_MANT(x);
unsigned int i = 0;
while (i < xn && xp[i] == 0) i++;
if (i > 0 && i < xn) mpfr_round_prec(x, GMP_RNDN, (xn-i)*BITS_PER_MP_LIMB);
}
int
mpfr_urandomb (mpfr_ptr rop, gmp_randstate_t rstate)
{
mp_ptr rp;
mp_prec_t nbits;
mp_size_t nlimbs;
mp_size_t k; /* number of high zero limbs */
mp_exp_t exp;
int cnt;
MPFR_CLEAR_FLAGS (rop);
rp = MPFR_MANT (rop);
nbits = MPFR_PREC (rop);
nlimbs = MPFR_LIMB_SIZE (rop);
MPFR_SET_POS (rop);
/* Uniform non-normalized significand */
_gmp_rand (rp, rstate, nlimbs * BITS_PER_MP_LIMB);
/* If nbits isn't a multiple of BITS_PER_MP_LIMB, mask the low bits */
cnt = nlimbs * BITS_PER_MP_LIMB - nbits;
if (MPFR_LIKELY (cnt != 0))
rp[0] &= ~MPFR_LIMB_MASK (cnt);
/* Count the null significant limbs and remaining limbs */
exp = 0;
k = 0;
while (nlimbs != 0 && rp[nlimbs - 1] == 0)
{
k ++;
nlimbs --;
exp -= BITS_PER_MP_LIMB;
}
if (MPFR_LIKELY (nlimbs != 0)) /* otherwise value is zero */
{
count_leading_zeros (cnt, rp[nlimbs - 1]);
/* Normalization */
if (mpfr_set_exp (rop, exp - cnt))
{
/* If the exponent is not in the current exponent range, we
choose to return a NaN as this is probably a user error.
Indeed this can happen only if the exponent range has been
reduced to a very small interval and/or the precision is
huge (very unlikely). */
MPFR_SET_NAN (rop);
__gmpfr_flags |= MPFR_FLAGS_NAN; /* Can't use MPFR_RET_NAN */
return 1;
}
if (cnt != 0)
mpn_lshift (rp + k, rp, nlimbs, cnt);
if (k != 0)
MPN_ZERO (rp, k);
}
else
MPFR_SET_ZERO (rop);
return 0;
}
/* set f to the integer z multiplied by 2^e */
int
mpfr_set_z_2exp (mpfr_ptr f, mpz_srcptr z, mpfr_exp_t e, mpfr_rnd_t rnd_mode)
{
mp_size_t fn, zn, dif, en;
int k, sign_z, inex;
mp_limb_t *fp, *zp;
mpfr_exp_t exp;
sign_z = mpz_sgn (z);
if (MPFR_UNLIKELY (sign_z == 0)) /* ignore the exponent for 0 */
{
MPFR_SET_ZERO(f);
MPFR_SET_POS(f);
MPFR_RET(0);
}
MPFR_ASSERTD (sign_z == MPFR_SIGN_POS || sign_z == MPFR_SIGN_NEG);
zn = ABS(SIZ(z)); /* limb size of z */
/* compute en = floor(e/GMP_NUMB_BITS) */
en = (e >= 0) ? e / GMP_NUMB_BITS : (e + 1) / GMP_NUMB_BITS - 1;
MPFR_ASSERTD (zn >= 1);
if (MPFR_UNLIKELY (zn + en > MPFR_EMAX_MAX / GMP_NUMB_BITS + 1))
return mpfr_overflow (f, rnd_mode, sign_z);
/* because zn + en >= MPFR_EMAX_MAX / GMP_NUMB_BITS + 2
implies (zn + en) * GMP_NUMB_BITS >= MPFR_EMAX_MAX + GMP_NUMB_BITS + 1
and exp = zn * GMP_NUMB_BITS + e - k
>= (zn + en) * GMP_NUMB_BITS - k > MPFR_EMAX_MAX */
fp = MPFR_MANT (f);
fn = MPFR_LIMB_SIZE (f);
dif = zn - fn;
zp = PTR(z);
count_leading_zeros (k, zp[zn-1]);
/* now zn + en <= MPFR_EMAX_MAX / GMP_NUMB_BITS + 1
thus (zn + en) * GMP_NUMB_BITS <= MPFR_EMAX_MAX + GMP_NUMB_BITS
and exp = zn * GMP_NUMB_BITS + e - k
<= (zn + en) * GMP_NUMB_BITS - k + GMP_NUMB_BITS - 1
<= MPFR_EMAX_MAX + 2 * GMP_NUMB_BITS - 1 */
exp = (mpfr_prec_t) zn * GMP_NUMB_BITS + e - k;
/* The exponent will be exp or exp + 1 (due to rounding) */
if (MPFR_UNLIKELY (exp > __gmpfr_emax))
return mpfr_overflow (f, rnd_mode, sign_z);
if (MPFR_UNLIKELY (exp + 1 < __gmpfr_emin))
return mpfr_underflow (f, rnd_mode == MPFR_RNDN ? MPFR_RNDZ : rnd_mode,
sign_z);
if (MPFR_LIKELY (dif >= 0))
{
mp_limb_t rb, sb, ulp;
int sh;
/* number has to be truncated */
if (MPFR_LIKELY (k != 0))
{
mpn_lshift (fp, &zp[dif], fn, k);
if (MPFR_LIKELY (dif > 0))
fp[0] |= zp[dif - 1] >> (GMP_NUMB_BITS - k);
}
int
mpfr_urandomb (mpfr_ptr rop, gmp_randstate_t rstate)
{
mpfr_limb_ptr rp;
mpfr_prec_t nbits;
mp_size_t nlimbs;
mp_size_t k; /* number of high zero limbs */
mpfr_exp_t exp;
int cnt;
rp = MPFR_MANT (rop);
nbits = MPFR_PREC (rop);
nlimbs = MPFR_LIMB_SIZE (rop);
MPFR_SET_POS (rop);
cnt = nlimbs * GMP_NUMB_BITS - nbits;
/* Uniform non-normalized significand */
/* generate exactly nbits so that the random generator stays in the same
state, independent of the machine word size GMP_NUMB_BITS */
mpfr_rand_raw (rp, rstate, nbits);
if (MPFR_LIKELY (cnt != 0)) /* this will put the low bits to zero */
mpn_lshift (rp, rp, nlimbs, cnt);
/* Count the null significant limbs and remaining limbs */
exp = 0;
k = 0;
while (nlimbs != 0 && rp[nlimbs - 1] == 0)
{
k ++;
nlimbs --;
exp -= GMP_NUMB_BITS;
}
if (MPFR_LIKELY (nlimbs != 0)) /* otherwise value is zero */
{
count_leading_zeros (cnt, rp[nlimbs - 1]);
/* Normalization */
if (mpfr_set_exp (rop, exp - cnt))
{
/* If the exponent is not in the current exponent range, we
choose to return a NaN as this is probably a user error.
Indeed this can happen only if the exponent range has been
reduced to a very small interval and/or the precision is
huge (very unlikely). */
MPFR_SET_NAN (rop);
__gmpfr_flags |= MPFR_FLAGS_NAN; /* Can't use MPFR_RET_NAN */
return 1;
}
if (cnt != 0)
mpn_lshift (rp + k, rp, nlimbs, cnt);
if (k != 0)
MPN_ZERO (rp, k);
}
else
MPFR_SET_ZERO (rop);
return 0;
}
mpfr_prec_t
mpfr_min_prec (mpfr_srcptr x)
{
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x)))
return 0;
/* from a suggestion by Andreas Enge (2010-11-18) */
return MPFR_LIMB_SIZE (x) * GMP_NUMB_BITS - mpn_scan1 (MPFR_MANT (x), 0);
}
static void
print_mpfr (mpfr_srcptr x, const char *name)
{
unsigned char temp[16]; /* buffer for the base-256 string */
unsigned char *ptr; /* pointer to its first non-zero byte */
int size; /* size of the string */
int i; /* bits2use index */
int j; /* output limb index */
int k; /* byte index (in output limb) */
int r; /* digit index, relative to ptr */
char prefix[12]; /* "0x" or "UINT64_C(0x" */
char suffix[2]; /* "" or ")" */
if (printf ("#if 0\n") < 0)
{ fprintf (stderr, "Error in printf\n"); exit (1); }
for (i = 0; i < size_of_bits2use; i++)
{
if (bits2use[i] == 64)
{
strcpy (prefix, "UINT64_C(0x");
strcpy (suffix, ")");
}
else
{
strcpy (prefix, "0x");
strcpy (suffix, "");
}
if (printf ("#elif GMP_NUMB_BITS == %d\n"
"const mp_limb_t %s__tab[] = { %s", bits2use[i], name,
prefix) < 0)
{ fprintf (stderr, "Error in printf\n"); exit (1); }
size = mpn_get_str (temp, 256, MPFR_MANT (x), MPFR_LIMB_SIZE (x));
MPFR_ASSERTN (size <= 16);
ptr = temp;
/* Skip leading zeros. */
while (*ptr == 0)
{
ptr++;
size--;
MPFR_ASSERTN (size > 0);
}
MPFR_ASSERTN (*ptr >= 128);
for (j = (MPFR_PREC (x) - 1) / bits2use[i]; j >= 0; j--)
{
r = j * (bits2use[i] / 8);
for (k = 0; k < bits2use[i] / 8; k++)
if (printf ("%02x", r < size ? ptr[r++] : 0) < 0)
{ fprintf (stderr, "Error in printf\n"); exit (1); }
if (j == 0 && printf ("%s };\n", suffix) < 0)
{ fprintf (stderr, "Error in printf\n"); exit (1); }
else if (j > 0 && printf ("%s, %s", suffix, prefix) < 0)
{ fprintf (stderr, "Error in printf\n"); exit (1); }
}
}
if (printf ("#endif\n\n") < 0)
{ fprintf (stderr, "Error in printf\n"); exit (1); }
}
uintmax_t
mpfr_get_uj (mpfr_srcptr f, mpfr_rnd_t rnd)
{
uintmax_t r;
mpfr_prec_t prec;
mpfr_t x;
if (MPFR_UNLIKELY (!mpfr_fits_uintmax_p (f, rnd)))
{
MPFR_SET_ERANGEFLAG ();
return MPFR_IS_NAN (f) || MPFR_IS_NEG (f) ?
(uintmax_t) 0 : MPFR_UINTMAX_MAX;
}
if (MPFR_IS_ZERO (f))
return (uintmax_t) 0;
/* determine the precision of uintmax_t */
for (r = MPFR_UINTMAX_MAX, prec = 0; r != 0; r /= 2, prec++)
{ }
/* Now, r = 0. */
mpfr_init2 (x, prec);
mpfr_rint (x, f, rnd);
MPFR_ASSERTN (MPFR_IS_FP (x));
if (MPFR_NOTZERO (x))
{
mp_limb_t *xp;
int sh, n; /* An int should be sufficient in this context. */
MPFR_ASSERTN (MPFR_IS_POS (x));
xp = MPFR_MANT (x);
sh = MPFR_GET_EXP (x);
MPFR_ASSERTN ((mpfr_prec_t) sh <= prec);
for (n = MPFR_LIMB_SIZE(x) - 1; n >= 0; n--)
{
sh -= GMP_NUMB_BITS;
r += (sh >= 0
? (uintmax_t) xp[n] << sh
: (uintmax_t) xp[n] >> (- sh));
}
}
mpfr_clear (x);
return r;
}
void
mpfr_setmax (mpfr_ptr x, mpfr_exp_t e)
{
mp_size_t xn, i;
int sh;
mp_limb_t *xp;
MPFR_SET_EXP (x, e);
xn = MPFR_LIMB_SIZE (x);
sh = (mpfr_prec_t) xn * GMP_NUMB_BITS - MPFR_PREC(x);
xp = MPFR_MANT(x);
xp[0] = MP_LIMB_T_MAX << sh;
for (i = 1; i < xn; i++)
xp[i] = MP_LIMB_T_MAX;
}
void
mpfr_extract (mpz_ptr y, mpfr_srcptr p, unsigned int i)
{
unsigned long two_i = 1UL << i;
unsigned long two_i_2 = i ? two_i / 2 : 1;
mp_size_t size_p = MPFR_LIMB_SIZE (p);
/* as 0 <= |p| < 1, we don't have to care with infinities, NaN, ... */
MPFR_ASSERTD (!MPFR_IS_SINGULAR (p));
_mpz_realloc (y, two_i_2);
if ((mpfr_uexp_t) size_p < two_i)
{
MPN_ZERO (PTR(y), two_i_2);
if ((mpfr_uexp_t) size_p >= two_i_2)
MPN_COPY (PTR(y) + two_i - size_p, MPFR_MANT(p), size_p - two_i_2);
}
else
MPN_COPY (PTR(y), MPFR_MANT(p) + size_p - two_i, two_i_2);
MPN_NORMALIZE (PTR(y), two_i_2);
SIZ(y) = (MPFR_IS_NEG (p)) ? -two_i_2 : two_i_2;
}
mp_exp_t
mpfr_get_z_exp (mpz_ptr z, mpfr_srcptr f)
{
mp_size_t fn;
int sh;
MPFR_ASSERTD (MPFR_IS_FP (f));
if (MPFR_UNLIKELY (MPFR_IS_ZERO (f)))
{
mpz_set_ui (z, 0);
return __gmpfr_emin;
}
fn = MPFR_LIMB_SIZE(f);
/* check whether allocated space for z is enough */
if (MPFR_UNLIKELY (ALLOC (z) < fn))
MPZ_REALLOC (z, fn);
MPFR_UNSIGNED_MINUS_MODULO (sh, MPFR_PREC (f));
if (MPFR_LIKELY (sh))
mpn_rshift (PTR (z), MPFR_MANT (f), fn, sh);
else
MPN_COPY (PTR (z), MPFR_MANT (f), fn);
SIZ(z) = MPFR_IS_NEG (f) ? -fn : fn;
/* Test if the result is representable. Later, we could choose
to return MPFR_EXP_MIN if it isn't, or perhaps MPFR_EXP_MAX
to signal an error. The mantissa would still be meaningful. */
MPFR_ASSERTD ((mp_exp_unsigned_t) MPFR_GET_EXP (f) - MPFR_EXP_MIN
>= (mp_exp_unsigned_t) MPFR_PREC(f));
return MPFR_GET_EXP (f) - MPFR_PREC (f);
}
/* Exact product. The number a is assumed to have enough allocated memory,
where the trailing bits are regarded as being part of the input numbers
(no reallocation is attempted and no check is performed as MPFR_TMP_INIT
could have been used). The arguments b and c may actually be UBF numbers
(mpfr_srcptr can be seen a bit like void *, but is stronger).
This function does not change the flags, except in case of NaN. */
void
mpfr_ubf_mul_exact (mpfr_ubf_ptr a, mpfr_srcptr b, mpfr_srcptr c)
{
MPFR_LOG_FUNC
(("b[%Pu]=%.*Rg c[%Pu]=%.*Rg",
mpfr_get_prec (b), mpfr_log_prec, b,
mpfr_get_prec (c), mpfr_log_prec, c),
("a[%Pu]=%.*Rg",
mpfr_get_prec (a), mpfr_log_prec, a));
MPFR_ASSERTD ((mpfr_ptr) a != b);
MPFR_ASSERTD ((mpfr_ptr) a != c);
MPFR_SIGN (a) = MPFR_MULT_SIGN (MPFR_SIGN (b), MPFR_SIGN (c));
if (MPFR_ARE_SINGULAR (b, c))
{
if (MPFR_IS_NAN (b) || MPFR_IS_NAN (c))
MPFR_SET_NAN (a);
else if (MPFR_IS_INF (b))
{
if (MPFR_NOTZERO (c))
MPFR_SET_INF (a);
else
MPFR_SET_NAN (a);
}
else if (MPFR_IS_INF (c))
{
if (!MPFR_IS_ZERO (b))
MPFR_SET_INF (a);
else
MPFR_SET_NAN (a);
}
else
{
MPFR_ASSERTD (MPFR_IS_ZERO(b) || MPFR_IS_ZERO(c));
MPFR_SET_ZERO (a);
}
}
else
{
mpfr_exp_t e;
mp_size_t bn, cn;
mpfr_limb_ptr ap;
mp_limb_t u, v;
int m;
/* Note about the code below: For the choice of the precision of
* the result a, one could choose PREC(b) + PREC(c), instead of
* taking whole limbs into account, but in most cases where one
* would gain one limb, one would need to copy the significand
* instead of a no-op (see the mul.c code).
* But in the case MPFR_LIMB_MSB (u) == 0, if the result fits in
* an-1 limbs, one could actually do
* mpn_rshift (ap, ap, k, GMP_NUMB_BITS - 1)
* instead of
* mpn_lshift (ap, ap, k, 1)
* to gain one limb (and reduce the precision), replacing a shift
* by another one. Would this be interesting?
*/
bn = MPFR_LIMB_SIZE (b);
cn = MPFR_LIMB_SIZE (c);
ap = MPFR_MANT (a);
u = (bn >= cn) ?
mpn_mul (ap, MPFR_MANT (b), bn, MPFR_MANT (c), cn) :
mpn_mul (ap, MPFR_MANT (c), cn, MPFR_MANT (b), bn);
if (MPFR_UNLIKELY (MPFR_LIMB_MSB (u) == 0))
{
m = 1;
MPFR_DBGRES (v = mpn_lshift (ap, ap, bn + cn, 1));
MPFR_ASSERTD (v == 0);
}
else
m = 0;
if (! MPFR_IS_UBF (b) && ! MPFR_IS_UBF (c) &&
(e = MPFR_GET_EXP (b) + MPFR_GET_EXP (c) - m,
MPFR_EXP_IN_RANGE (e)))
{
MPFR_SET_EXP (a, e);
}
else
{
mpz_t be, ce;
mpz_init (MPFR_ZEXP (a));
/* This may involve copies of mpz_t, but exponents should not be
very large integers anyway. */
mpfr_get_zexp (be, b);
mpfr_get_zexp (ce, c);
mpz_add (MPFR_ZEXP (a), be, ce);
mpz_clear (be);
mpz_clear (ce);
mpz_sub_ui (MPFR_ZEXP (a), MPFR_ZEXP (a), m);
MPFR_SET_UBF (a);
}
}
}
/* Since MPFR-3.0, return the usual inexact value.
The erange flag is set if an error occurred in the conversion
(y is NaN, +Inf, or -Inf that have no equivalent in mpf)
*/
int
mpfr_get_f (mpf_ptr x, mpfr_srcptr y, mpfr_rnd_t rnd_mode)
{
int inex;
mp_size_t sx, sy;
mpfr_prec_t precx, precy;
mp_limb_t *xp;
int sh;
if (MPFR_UNLIKELY(MPFR_IS_SINGULAR(y)))
{
if (MPFR_IS_ZERO(y))
{
mpf_set_ui (x, 0);
return 0;
}
else if (MPFR_IS_NAN (y))
{
MPFR_SET_ERANGEFLAG ();
return 0;
}
else /* y is plus infinity (resp. minus infinity), set x to the maximum
value (resp. the minimum value) in precision PREC(x) */
{
int i;
mp_limb_t *xp;
MPFR_SET_ERANGEFLAG ();
/* To this day, [mp_exp_t] and mp_size_t are #defined as the same
type */
EXP (x) = MP_SIZE_T_MAX;
sx = PREC (x);
SIZ (x) = sx;
xp = PTR (x);
for (i = 0; i < sx; i++)
xp[i] = MPFR_LIMB_MAX;
if (MPFR_IS_POS (y))
return -1;
else
{
mpf_neg (x, x);
return +1;
}
}
}
sx = PREC(x); /* number of limbs of the mantissa of x */
precy = MPFR_PREC(y);
precx = (mpfr_prec_t) sx * GMP_NUMB_BITS;
sy = MPFR_LIMB_SIZE (y);
xp = PTR (x);
/* since mpf numbers are represented in base 2^GMP_NUMB_BITS,
we loose -EXP(y) % GMP_NUMB_BITS bits in the most significant limb */
sh = MPFR_GET_EXP(y) % GMP_NUMB_BITS;
sh = sh <= 0 ? - sh : GMP_NUMB_BITS - sh;
MPFR_ASSERTD (sh >= 0);
if (precy + sh <= precx) /* we can copy directly */
{
mp_size_t ds;
MPFR_ASSERTN (sx >= sy);
ds = sx - sy;
if (sh != 0)
{
mp_limb_t out;
out = mpn_rshift (xp + ds, MPFR_MANT(y), sy, sh);
MPFR_ASSERTN (ds > 0 || out == 0);
if (ds > 0)
xp[--ds] = out;
}
else
MPN_COPY (xp + ds, MPFR_MANT (y), sy);
if (ds > 0)
MPN_ZERO (xp, ds);
EXP(x) = (MPFR_GET_EXP(y) + sh) / GMP_NUMB_BITS;
inex = 0;
}
else /* we have to round to precx - sh bits */
{
mpfr_t z;
mp_size_t sz;
/* Recall that precx = (mpfr_prec_t) sx * GMP_NUMB_BITS, thus removing
sh bits (sh < GMP_NUMB_BITSS) won't reduce the number of limbs. */
mpfr_init2 (z, precx - sh);
sz = MPFR_LIMB_SIZE (z);
MPFR_ASSERTN (sx == sz);
inex = mpfr_set (z, y, rnd_mode);
/* warning, sh may change due to rounding, but then z is a power of two,
thus we can safely ignore its last bit which is 0 */
sh = MPFR_GET_EXP(z) % GMP_NUMB_BITS;
sh = sh <= 0 ? - sh : GMP_NUMB_BITS - sh;
MPFR_ASSERTD (sh >= 0);
if (sh != 0)
{
mp_limb_t out;
out = mpn_rshift (xp, MPFR_MANT(z), sz, sh);
/* If sh hasn't changed, it is the number of the non-significant
bits in the lowest limb of z. Therefore out == 0. */
MPFR_ASSERTD (out == 0); (void) out; /* avoid a warning */
}
else
MPN_COPY (xp, MPFR_MANT(z), sz);
EXP(x) = (MPFR_GET_EXP(z) + sh) / GMP_NUMB_BITS;
mpfr_clear (z);
}
/* set size and sign */
SIZ(x) = (MPFR_FROM_SIGN_TO_INT(MPFR_SIGN(y)) < 0) ? -sx : sx;
return inex;
}
/* (y, z) <- (sin(x), cos(x)), return value is 0 iff both results are exact
ie, iff x = 0 */
int
mpfr_sin_cos (mpfr_ptr y, mpfr_ptr z, mpfr_srcptr x, mp_rnd_t rnd_mode)
{
mp_prec_t prec, m;
int neg, reduce;
mpfr_t c, xr;
mpfr_srcptr xx;
mp_exp_t err, expx;
MPFR_ZIV_DECL (loop);
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x)))
{
if (MPFR_IS_NAN(x) || MPFR_IS_INF(x))
{
MPFR_SET_NAN (y);
MPFR_SET_NAN (z);
MPFR_RET_NAN;
}
else /* x is zero */
{
MPFR_ASSERTD (MPFR_IS_ZERO (x));
MPFR_SET_ZERO (y);
MPFR_SET_SAME_SIGN (y, x);
/* y = 0, thus exact, but z is inexact in case of underflow
or overflow */
return mpfr_set_ui (z, 1, rnd_mode);
}
}
MPFR_LOG_FUNC (("x[%#R]=%R rnd=%d", x, x, rnd_mode),
("sin[%#R]=%R cos[%#R]=%R", y, y, z, z));
prec = MAX (MPFR_PREC (y), MPFR_PREC (z));
m = prec + MPFR_INT_CEIL_LOG2 (prec) + 13;
expx = MPFR_GET_EXP (x);
mpfr_init (c);
mpfr_init (xr);
MPFR_ZIV_INIT (loop, m);
for (;;)
{
/* the following is copied from sin.c */
if (expx >= 2) /* reduce the argument */
{
reduce = 1;
mpfr_set_prec (c, expx + m - 1);
mpfr_set_prec (xr, m);
mpfr_const_pi (c, GMP_RNDN);
mpfr_mul_2ui (c, c, 1, GMP_RNDN);
mpfr_remainder (xr, x, c, GMP_RNDN);
mpfr_div_2ui (c, c, 1, GMP_RNDN);
if (MPFR_SIGN (xr) > 0)
mpfr_sub (c, c, xr, GMP_RNDZ);
else
mpfr_add (c, c, xr, GMP_RNDZ);
if (MPFR_IS_ZERO(xr) || MPFR_EXP(xr) < (mp_exp_t) 3 - (mp_exp_t) m
|| MPFR_EXP(c) < (mp_exp_t) 3 - (mp_exp_t) m)
goto next_step;
xx = xr;
}
else /* the input argument is already reduced */
{
reduce = 0;
xx = x;
}
neg = MPFR_IS_NEG (xx); /* gives sign of sin(x) */
mpfr_set_prec (c, m);
mpfr_cos (c, xx, GMP_RNDZ);
/* If no argument reduction was performed, the error is at most ulp(c),
otherwise it is at most ulp(c) + 2^(2-m). Since |c| < 1, we have
ulp(c) <= 2^(-m), thus the error is bounded by 2^(3-m) in that later
case. */
if (reduce == 0)
err = m;
else
err = MPFR_GET_EXP (c) + (mp_exp_t) (m - 3);
if (!mpfr_can_round (c, err, GMP_RNDN, rnd_mode,
MPFR_PREC (z) + (rnd_mode == GMP_RNDN)))
goto next_step;
mpfr_set (z, c, rnd_mode);
mpfr_sqr (c, c, GMP_RNDU);
mpfr_ui_sub (c, 1, c, GMP_RNDN);
err = 2 + (- MPFR_GET_EXP (c)) / 2;
mpfr_sqrt (c, c, GMP_RNDN);
if (neg)
MPFR_CHANGE_SIGN (c);
/* the absolute error on c is at most 2^(err-m), which we must put
in the form 2^(EXP(c)-err). If there was an argument reduction,
we need to add 2^(2-m); since err >= 2, the error is bounded by
2^(err+1-m) in that case. */
err = MPFR_GET_EXP (c) + (mp_exp_t) m - (err + reduce);
if (mpfr_can_round (c, err, GMP_RNDN, rnd_mode,
MPFR_PREC (y) + (rnd_mode == GMP_RNDN)))
break;
/* check for huge cancellation */
if (err < (mp_exp_t) MPFR_PREC (y))
m += MPFR_PREC (y) - err;
/* Check if near 1 */
if (MPFR_GET_EXP (c) == 1
&& MPFR_MANT (c)[MPFR_LIMB_SIZE (c)-1] == MPFR_LIMB_HIGHBIT)
m += m;
next_step:
MPFR_ZIV_NEXT (loop, m);
mpfr_set_prec (c, m);
}
MPFR_ZIV_FREE (loop);
mpfr_set (y, c, rnd_mode);
mpfr_clear (c);
mpfr_clear (xr);
MPFR_RET (1); /* Always inexact */
}
int
main (void)
{
mpfr_t a;
mp_limb_t *p, tmp;
mp_size_t s;
mpfr_prec_t pr;
int max;
tests_start_mpfr ();
for(pr = MPFR_PREC_MIN ; pr < 500 ; pr++)
{
mpfr_init2 (a, pr);
if (!mpfr_check(a)) ERROR("for init");
/* Check special cases */
MPFR_SET_NAN(a);
if (!mpfr_check(a)) ERROR("for nan");
MPFR_SET_POS(a);
MPFR_SET_INF(a);
if (!mpfr_check(a)) ERROR("for inf");
MPFR_SET_ZERO(a);
if (!mpfr_check(a)) ERROR("for zero");
/* Check var */
mpfr_set_ui(a, 2, GMP_RNDN);
if (!mpfr_check(a)) ERROR("for set_ui");
mpfr_clear_overflow();
max = 1000; /* Allows max 2^1000 bits for the exponent */
while ((!mpfr_overflow_p()) && (max>0))
{
mpfr_mul(a, a, a, GMP_RNDN);
if (!mpfr_check(a)) ERROR("for mul");
max--;
}
if (max==0) ERROR("can't reach overflow");
mpfr_set_ui(a, 2137, GMP_RNDN);
/* Corrupt a and check for it */
MPFR_SIGN(a) = 2;
if (mpfr_check(a)) ERROR("sgn");
MPFR_SET_POS(a);
/* Check prec */
MPFR_PREC(a) = 1;
if (mpfr_check(a)) ERROR("precmin");
MPFR_PREC(a) = MPFR_PREC_MAX+1;
if (mpfr_check(a)) ERROR("precmax");
MPFR_PREC(a) = pr;
if (!mpfr_check(a)) ERROR("prec");
/* Check exponent */
MPFR_EXP(a) = MPFR_EXP_INVALID;
if (mpfr_check(a)) ERROR("exp invalid");
MPFR_EXP(a) = -MPFR_EXP_INVALID;
if (mpfr_check(a)) ERROR("-exp invalid");
MPFR_EXP(a) = 0;
if (!mpfr_check(a)) ERROR("exp 0");
/* Check Mantissa */
p = MPFR_MANT(a);
MPFR_MANT(a) = NULL;
if (mpfr_check(a)) ERROR("Mantissa Null Ptr");
MPFR_MANT(a) = p;
/* Check size */
s = MPFR_GET_ALLOC_SIZE(a);
MPFR_SET_ALLOC_SIZE(a, 0);
if (mpfr_check(a)) ERROR("0 size");
MPFR_SET_ALLOC_SIZE(a, MP_SIZE_T_MIN);
if (mpfr_check(a)) ERROR("min size");
MPFR_SET_ALLOC_SIZE(a, MPFR_LIMB_SIZE(a)-1 );
if (mpfr_check(a)) ERROR("size < prec");
MPFR_SET_ALLOC_SIZE(a, s);
/* Check normal form */
tmp = MPFR_MANT(a)[0];
if ((pr % BITS_PER_MP_LIMB) != 0)
{
MPFR_MANT(a)[0] = ~0;
if (mpfr_check(a)) ERROR("last bits non 0");
}
MPFR_MANT(a)[0] = tmp;
MPFR_MANT(a)[MPFR_LIMB_SIZE(a)-1] &= MPFR_LIMB_MASK (BITS_PER_MP_LIMB-1);
if (mpfr_check(a)) ERROR("last bits non 0");
/* Final */
mpfr_set_ui(a, 2137, GMP_RNDN);
if (!mpfr_check(a)) ERROR("after last set");
mpfr_clear (a);
if (mpfr_check(a)) ERROR("after clear");
}
tests_end_mpfr ();
return 0;
}
int
mpfr_div (mpfr_ptr q, mpfr_srcptr u, mpfr_srcptr v, mp_rnd_t rnd_mode)
{
mp_srcptr up, vp, bp;
mp_size_t usize, vsize;
mp_ptr ap, qp, rp;
mp_size_t asize, bsize, qsize, rsize;
mp_exp_t qexp;
mp_size_t err, k;
mp_limb_t tonearest;
int inex, sh, can_round = 0, sign_quotient;
unsigned int cc = 0, rw;
TMP_DECL (marker);
/**************************************************************************
* *
* This part of the code deals with special cases *
* *
**************************************************************************/
if (MPFR_ARE_SINGULAR(u,v))
{
if (MPFR_IS_NAN(u) || MPFR_IS_NAN(v))
{
MPFR_SET_NAN(q);
MPFR_RET_NAN;
}
sign_quotient = MPFR_MULT_SIGN( MPFR_SIGN(u) , MPFR_SIGN(v) );
MPFR_SET_SIGN(q, sign_quotient);
if (MPFR_IS_INF(u))
{
if (MPFR_IS_INF(v))
{
MPFR_SET_NAN(q);
MPFR_RET_NAN;
}
else
{
MPFR_SET_INF(q);
MPFR_RET(0);
}
}
else if (MPFR_IS_INF(v))
{
MPFR_SET_ZERO(q);
MPFR_RET(0);
}
else if (MPFR_IS_ZERO(v))
{
if (MPFR_IS_ZERO(u))
{
MPFR_SET_NAN(q);
MPFR_RET_NAN;
}
else
{
MPFR_SET_INF(q);
MPFR_RET(0);
}
}
else
{
MPFR_ASSERTD(MPFR_IS_ZERO(u));
MPFR_SET_ZERO(q);
MPFR_RET(0);
}
}
MPFR_CLEAR_FLAGS(q);
/**************************************************************************
* *
* End of the part concerning special values. *
* *
**************************************************************************/
sign_quotient = MPFR_MULT_SIGN( MPFR_SIGN(u) , MPFR_SIGN(v) );
up = MPFR_MANT(u);
vp = MPFR_MANT(v);
MPFR_SET_SIGN(q, sign_quotient);
TMP_MARK (marker);
usize = MPFR_LIMB_SIZE(u);
vsize = MPFR_LIMB_SIZE(v);
/**************************************************************************
* *
* First try to use only part of u, v. If this is not sufficient, *
* use the full u and v, to avoid long computations eg. in the case *
* u = v. *
* *
**************************************************************************/
/* The dividend is a, length asize. The divisor is b, length bsize. */
qsize = (MPFR_PREC(q) + 3) / BITS_PER_MP_LIMB + 1;
/* in case PREC(q)=PREC(v), then vsize=qsize with probability 1-4/b
where b is the number of bits per limb */
if (MPFR_LIKELY(vsize <= qsize))
{
bsize = vsize;
bp = vp;
}
else /* qsize < vsize: take only the qsize high limbs of the divisor */
{
bsize = qsize;
bp = (mp_srcptr) vp + (vsize - qsize);
}
/* we have {bp, bsize} * (1 + errb) = (true divisor)
with 0 <= errb < 2^(-qsize*BITS_PER_MP_LIMB+1) */
asize = bsize + qsize;
ap = (mp_ptr) TMP_ALLOC (asize * BYTES_PER_MP_LIMB);
/* if all arguments have same precision, then asize will be about 2*usize */
if (MPFR_LIKELY(asize > usize))
{
/* copy u into the high limbs of {ap, asize}, and pad with zeroes */
/* FIXME: could we copy only the qsize high limbs of the dividend? */
MPN_COPY (ap + asize - usize, up, usize);
MPN_ZERO (ap, asize - usize);
}
else /* truncate the high asize limbs of u into {ap, asize} */
MPN_COPY (ap, up + usize - asize, asize);
/* we have {ap, asize} = (true dividend) * (1 - erra)
with 0 <= erra < 2^(-asize*BITS_PER_MP_LIMB).
This {ap, asize} / {bp, bsize} =
(true dividend) / (true divisor) * (1 - erra) (1 + errb) */
/* Allocate limbs for quotient and remainder. */
qp = (mp_ptr) TMP_ALLOC ((qsize + 1) * BYTES_PER_MP_LIMB);
rp = (mp_ptr) TMP_ALLOC (bsize * BYTES_PER_MP_LIMB);
rsize = bsize;
mpn_tdiv_qr (qp, rp, 0, ap, asize, bp, bsize);
sh = - (int) qp[qsize];
/* since u and v are normalized, sh is 0 or -1 */
/* we have {qp, qsize + 1} = {ap, asize} / {bp, bsize} (1 - errq)
with 0 <= errq < 2^(-qsize*BITS_PER_MP_LIMB+1+sh)
thus {qp, qsize + 1} =
(true dividend) / (true divisor) * (1 - erra) (1 + errb) (1 - errq).
In fact, since the truncated dividend and {rp, bsize} do not overlap,
we have: {qp, qsize + 1} =
(true dividend) / (true divisor) * (1 - erra') (1 + errb)
where 0 <= erra' < 2^(-qsize*BITS_PER_MP_LIMB+sh) */
/* Estimate number of correct bits. */
err = qsize * BITS_PER_MP_LIMB;
/* We want to check if rounding is possible, but without normalizing
because we might have to divide again if rounding is impossible, or
if the result might be exact. We have however to mimic normalization */
/*
To detect asap if the result is inexact, so as to avoid doing the
division completely, we perform the following check :
- if rnd_mode != GMP_RNDN, and the result is exact, we are unable
to round simultaneously to zero and to infinity ;
- if rnd_mode == GMP_RNDN, and if we can round to zero with one extra
bit of precision, we can decide rounding. Hence in that case, check
as in the case of GMP_RNDN, with one extra bit. Note that in the case
of close to even rounding we shall do the division completely, but
this is necessary anyway : we need to know whether this is really
even rounding or not.
*/
if (MPFR_UNLIKELY(asize < usize || bsize < vsize))
{
{
mp_rnd_t rnd_mode1, rnd_mode2;
mp_exp_t tmp_exp;
mp_prec_t tmp_prec;
if (bsize < vsize)
err -= 2; /* divisor is truncated */
#if 0 /* commented this out since the truncation of the dividend is already
taken into account in {rp, bsize}, which does not overlap with the
neglected part of the dividend */
else if (asize < usize)
err --; /* dividend is truncated */
#endif
if (MPFR_LIKELY(rnd_mode == GMP_RNDN))
{
rnd_mode1 = GMP_RNDZ;
rnd_mode2 = MPFR_IS_POS_SIGN(sign_quotient) ? GMP_RNDU : GMP_RNDD;
sh++;
}
else
{
rnd_mode1 = rnd_mode;
switch (rnd_mode)
{
case GMP_RNDU:
rnd_mode2 = GMP_RNDD; break;
case GMP_RNDD:
rnd_mode2 = GMP_RNDU; break;
default:
rnd_mode2 = MPFR_IS_POS_SIGN(sign_quotient) ?
GMP_RNDU : GMP_RNDD;
break;
}
}
tmp_exp = err + sh + BITS_PER_MP_LIMB;
tmp_prec = MPFR_PREC(q) + sh + BITS_PER_MP_LIMB;
can_round =
mpfr_can_round_raw (qp, qsize + 1, sign_quotient, tmp_exp,
GMP_RNDN, rnd_mode1, tmp_prec)
& mpfr_can_round_raw (qp, qsize + 1, sign_quotient, tmp_exp,
GMP_RNDN, rnd_mode2, tmp_prec);
/* restore original value of sh, i.e. sh = - qp[qsize] */
sh -= (rnd_mode == GMP_RNDN);
}
/* returns 0 if result exact, non-zero otherwise */
int
mpfr_div_ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int u, mpfr_rnd_t rnd_mode)
{
long i;
int sh;
mp_size_t xn, yn, dif;
mp_limb_t *xp, *yp, *tmp, c, d;
mpfr_exp_t exp;
int inexact, middle = 1, nexttoinf;
MPFR_TMP_DECL(marker);
MPFR_LOG_FUNC
(("x[%Pu]=%.*Rg u=%lu rnd=%d",
mpfr_get_prec(x), mpfr_log_prec, x, u, 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))
{
MPFR_SET_INF (y);
MPFR_SET_SAME_SIGN (y, x);
MPFR_RET (0);
}
else
{
MPFR_ASSERTD (MPFR_IS_ZERO(x));
if (u == 0) /* 0/0 is NaN */
{
MPFR_SET_NAN(y);
MPFR_RET_NAN;
}
else
{
MPFR_SET_ZERO(y);
MPFR_SET_SAME_SIGN (y, x);
MPFR_RET(0);
}
}
}
else if (MPFR_UNLIKELY (u <= 1))
{
if (u < 1)
{
/* x/0 is Inf since x != 0*/
MPFR_SET_INF (y);
MPFR_SET_SAME_SIGN (y, x);
mpfr_set_divby0 ();
MPFR_RET (0);
}
else /* y = x/1 = x */
return mpfr_set (y, x, rnd_mode);
}
else if (MPFR_UNLIKELY (IS_POW2 (u)))
return mpfr_div_2si (y, x, MPFR_INT_CEIL_LOG2 (u), rnd_mode);
MPFR_SET_SAME_SIGN (y, x);
MPFR_TMP_MARK (marker);
xn = MPFR_LIMB_SIZE (x);
yn = MPFR_LIMB_SIZE (y);
xp = MPFR_MANT (x);
yp = MPFR_MANT (y);
exp = MPFR_GET_EXP (x);
dif = yn + 1 - xn;
/* we need to store yn+1 = xn + dif limbs of the quotient */
/* don't use tmp=yp since the mpn_lshift call below requires yp >= tmp+1 */
tmp = MPFR_TMP_LIMBS_ALLOC (yn + 1);
c = (mp_limb_t) u;
MPFR_ASSERTN (u == c);
if (dif >= 0)
c = mpn_divrem_1 (tmp, dif, xp, xn, c); /* used all the dividend */
else /* dif < 0 i.e. xn > yn, don't use the (-dif) low limbs from x */
c = mpn_divrem_1 (tmp, 0, xp - dif, yn + 1, c);
inexact = (c != 0);
/* First pass in estimating next bit of the quotient, in case of RNDN *
* In case we just have the right number of bits (postpone this ?), *
* we need to check whether the remainder is more or less than half *
* the divisor. The test must be performed with a subtraction, so as *
* to prevent carries. */
if (MPFR_LIKELY (rnd_mode == MPFR_RNDN))
{
if (c < (mp_limb_t) u - c) /* We have u > c */
middle = -1;
else if (c > (mp_limb_t) u - c)
middle = 1;
else
middle = 0; /* exactly in the middle */
}
/* If we believe that we are right in the middle or exact, we should check
that we did not neglect any word of x (division large / 1 -> small). */
for (i=0; ((inexact == 0) || (middle == 0)) && (i < -dif); i++)
if (xp[i])
inexact = middle = 1; /* larger than middle */
/*
If the high limb of the result is 0 (xp[xn-1] < u), remove it.
Otherwise, compute the left shift to be performed to normalize.
In the latter case, we discard some low bits computed. They
contain information useful for the rounding, hence the updating
of middle and inexact.
*/
if (tmp[yn] == 0)
{
MPN_COPY(yp, tmp, yn);
exp -= GMP_NUMB_BITS;
}
else
{
int shlz;
count_leading_zeros (shlz, tmp[yn]);
/* shift left to normalize */
if (MPFR_LIKELY (shlz != 0))
{
mp_limb_t w = tmp[0] << shlz;
mpn_lshift (yp, tmp + 1, yn, shlz);
yp[0] += tmp[0] >> (GMP_NUMB_BITS - shlz);
if (w > (MPFR_LIMB_ONE << (GMP_NUMB_BITS - 1)))
{ middle = 1; }
else if (w < (MPFR_LIMB_ONE << (GMP_NUMB_BITS - 1)))
{ middle = -1; }
else
{ middle = (c != 0); }
inexact = inexact || (w != 0);
exp -= shlz;
}
else
{ /* this happens only if u == 1 and xp[xn-1] >=
int
mpfr_sqrt (mpfr_ptr r, mpfr_srcptr u, mpfr_rnd_t rnd_mode)
{
mp_size_t rsize; /* number of limbs of r (plus 1 if exact limb multiple) */
mp_size_t rrsize;
mp_size_t usize; /* number of limbs of u */
mp_size_t tsize; /* number of limbs of the sqrtrem remainder */
mp_size_t k;
mp_size_t l;
mpfr_limb_ptr rp, rp0;
mpfr_limb_ptr up;
mpfr_limb_ptr sp;
mp_limb_t sticky0; /* truncated part of input */
mp_limb_t sticky1; /* truncated part of rp[0] */
mp_limb_t sticky;
int odd_exp;
int sh; /* number of extra bits in rp[0] */
int inexact; /* return ternary flag */
mpfr_exp_t expr;
MPFR_TMP_DECL(marker);
MPFR_LOG_FUNC
(("x[%Pu]=%.*Rg rnd=%d", mpfr_get_prec (u), mpfr_log_prec, u, rnd_mode),
("y[%Pu]=%.*Rg inexact=%d",
mpfr_get_prec (r), mpfr_log_prec, r, inexact));
if (MPFR_UNLIKELY(MPFR_IS_SINGULAR(u)))
{
if (MPFR_IS_NAN(u))
{
MPFR_SET_NAN(r);
MPFR_RET_NAN;
}
else if (MPFR_IS_ZERO(u))
{
/* 0+ or 0- */
MPFR_SET_SAME_SIGN(r, u);
MPFR_SET_ZERO(r);
MPFR_RET(0); /* zero is exact */
}
else
{
MPFR_ASSERTD(MPFR_IS_INF(u));
/* sqrt(-Inf) = NAN */
if (MPFR_IS_NEG(u))
{
MPFR_SET_NAN(r);
MPFR_RET_NAN;
}
MPFR_SET_POS(r);
MPFR_SET_INF(r);
MPFR_RET(0);
}
}
if (MPFR_UNLIKELY(MPFR_IS_NEG(u)))
{
MPFR_SET_NAN(r);
MPFR_RET_NAN;
}
MPFR_SET_POS(r);
MPFR_TMP_MARK (marker);
MPFR_UNSIGNED_MINUS_MODULO(sh,MPFR_PREC(r));
if (sh == 0 && rnd_mode == MPFR_RNDN)
sh = GMP_NUMB_BITS; /* ugly case */
rsize = MPFR_LIMB_SIZE(r) + (sh == GMP_NUMB_BITS);
/* rsize is the number of limbs of r + 1 if exact limb multiple and rounding
to nearest, this is the number of wanted limbs for the square root */
rrsize = rsize + rsize;
usize = MPFR_LIMB_SIZE(u); /* number of limbs of u */
rp0 = MPFR_MANT(r);
rp = (sh < GMP_NUMB_BITS) ? rp0 : MPFR_TMP_LIMBS_ALLOC (rsize);
up = MPFR_MANT(u);
sticky0 = MPFR_LIMB_ZERO; /* truncated part of input */
sticky1 = MPFR_LIMB_ZERO; /* truncated part of rp[0] */
odd_exp = (unsigned int) MPFR_GET_EXP (u) & 1;
inexact = -1; /* return ternary flag */
sp = MPFR_TMP_LIMBS_ALLOC (rrsize);
/* copy the most significant limbs of u to {sp, rrsize} */
if (MPFR_LIKELY(usize <= rrsize)) /* in case r and u have the same precision,
we have indeed rrsize = 2 * usize */
{
k = rrsize - usize;
if (MPFR_LIKELY(k))
MPN_ZERO (sp, k);
if (odd_exp)
{
if (MPFR_LIKELY(k))
sp[k - 1] = mpn_rshift (sp + k, up, usize, 1);
else
sticky0 = mpn_rshift (sp, up, usize, 1);
}
else
MPN_COPY (sp + rrsize - usize, up, usize);
}
else /* usize > rrsize: truncate the input */
{
k = usize - rrsize;
if (odd_exp)
sticky0 = mpn_rshift (sp, up + k, rrsize, 1);
else
MPN_COPY (sp, up + k, rrsize);
l = k;
while (sticky0 == MPFR_LIMB_ZERO && l != 0)
sticky0 = up[--l];
}
/* sticky0 is non-zero iff the truncated part of the input is non-zero */
/* mpn_rootrem with NULL 2nd argument is faster than mpn_sqrtrem, thus use
it if available and if the user asked to use GMP internal functions */
#if defined(WANT_GMP_INTERNALS) && defined(HAVE___GMPN_ROOTREM)
tsize = __gmpn_rootrem (rp, NULL, sp, rrsize, 2);
#else
tsize = mpn_sqrtrem (rp, NULL, sp, rrsize);
#endif
/* a return value of zero in mpn_sqrtrem indicates a perfect square */
sticky = sticky0 || tsize != 0;
/* truncate low bits of rp[0] */
sticky1 = rp[0] & ((sh < GMP_NUMB_BITS) ? MPFR_LIMB_MASK(sh)
: ~MPFR_LIMB_ZERO);
rp[0] -= sticky1;
sticky = sticky || sticky1;
expr = (MPFR_GET_EXP(u) + odd_exp) / 2; /* exact */
if (rnd_mode == MPFR_RNDZ || rnd_mode == MPFR_RNDD || sticky == MPFR_LIMB_ZERO)
{
inexact = (sticky == MPFR_LIMB_ZERO) ? 0 : -1;
goto truncate;
}
else if (rnd_mode == MPFR_RNDN)
{
/* if sh < GMP_NUMB_BITS, the round bit is bit (sh-1) of sticky1
and the sticky bit is formed by the low sh-1 bits from
sticky1, together with the sqrtrem remainder and sticky0. */
if (sh < GMP_NUMB_BITS)
{
if (sticky1 & (MPFR_LIMB_ONE << (sh - 1)))
{ /* round bit is set */
if (sticky1 == (MPFR_LIMB_ONE << (sh - 1)) && tsize == 0
&& sticky0 == 0)
goto even_rule;
else
goto add_one_ulp;
}
else /* round bit is zero */
goto truncate; /* with the default inexact=-1 */
}
else /* sh = GMP_NUMB_BITS: the round bit is the most significant bit
of rp[0], and the remaining GMP_NUMB_BITS-1 bits contribute to
the sticky bit */
{
if (sticky1 & MPFR_LIMB_HIGHBIT)
{ /* round bit is set */
if (sticky1 == MPFR_LIMB_HIGHBIT && tsize == 0 && sticky0 == 0)
goto even_rule;
else
goto add_one_ulp;
}
else /* round bit is zero */
goto truncate; /* with the default inexact=-1 */
}
}
else /* rnd_mode=GMP_RDNU, necessarily sticky <> 0, thus add 1 ulp */
goto add_one_ulp;
even_rule: /* has to set inexact */
if (sh < GMP_NUMB_BITS)
inexact = (rp[0] & (MPFR_LIMB_ONE << sh)) ? 1 : -1;
else
inexact = (rp[1] & MPFR_LIMB_ONE) ? 1 : -1;
if (inexact == -1)
goto truncate;
/* else go through add_one_ulp */
add_one_ulp:
inexact = 1; /* always here */
if (sh == GMP_NUMB_BITS)
{
rp ++;
rsize --;
sh = 0;
}
if (mpn_add_1 (rp0, rp, rsize, MPFR_LIMB_ONE << sh))
{
expr ++;
rp[rsize - 1] = MPFR_LIMB_HIGHBIT;
}
goto end;
truncate: /* inexact = 0 or -1 */
if (sh == GMP_NUMB_BITS)
MPN_COPY (rp0, rp + 1, rsize - 1);
end:
MPFR_ASSERTN (expr >= MPFR_EMIN_MIN && expr <= MPFR_EMAX_MAX);
MPFR_EXP (r) = expr;
MPFR_TMP_FREE(marker);
return mpfr_check_range (r, inexact, rnd_mode);
}
int
mpfr_atan2 (mpfr_ptr dest, mpfr_srcptr y, mpfr_srcptr x, mpfr_rnd_t rnd_mode)
{
mpfr_t tmp, pi;
int inexact;
mpfr_prec_t prec;
mpfr_exp_t e;
MPFR_SAVE_EXPO_DECL (expo);
MPFR_ZIV_DECL (loop);
MPFR_LOG_FUNC
(("y[%Pu]=%.*Rg x[%Pu]=%.*Rg rnd=%d",
mpfr_get_prec (y), mpfr_log_prec, y,
mpfr_get_prec (x), mpfr_log_prec, x, rnd_mode),
("atan[%Pu]=%.*Rg inexact=%d",
mpfr_get_prec (dest), mpfr_log_prec, dest, inexact));
/* Special cases */
if (MPFR_ARE_SINGULAR (x, y))
{
/* atan2(0, 0) does not raise the "invalid" floating-point
exception, nor does atan2(y, 0) raise the "divide-by-zero"
floating-point exception.
-- atan2(±0, -0) returns ±pi.313)
-- atan2(±0, +0) returns ±0.
-- atan2(±0, x) returns ±pi, for x < 0.
-- atan2(±0, x) returns ±0, for x > 0.
-- atan2(y, ±0) returns -pi/2 for y < 0.
-- atan2(y, ±0) returns pi/2 for y > 0.
-- atan2(±oo, -oo) returns ±3pi/4.
-- atan2(±oo, +oo) returns ±pi/4.
-- atan2(±oo, x) returns ±pi/2, for finite x.
-- atan2(±y, -oo) returns ±pi, for finite y > 0.
-- atan2(±y, +oo) returns ±0, for finite y > 0.
*/
if (MPFR_IS_NAN (x) || MPFR_IS_NAN (y))
{
MPFR_SET_NAN (dest);
MPFR_RET_NAN;
}
if (MPFR_IS_ZERO (y))
{
if (MPFR_IS_NEG (x)) /* +/- PI */
{
set_pi:
if (MPFR_IS_NEG (y))
{
inexact = mpfr_const_pi (dest, MPFR_INVERT_RND (rnd_mode));
MPFR_CHANGE_SIGN (dest);
return -inexact;
}
else
return mpfr_const_pi (dest, rnd_mode);
}
else /* +/- 0 */
{
set_zero:
MPFR_SET_ZERO (dest);
MPFR_SET_SAME_SIGN (dest, y);
return 0;
}
}
if (MPFR_IS_ZERO (x))
{
return pi_div_2ui (dest, 1, MPFR_IS_NEG (y), rnd_mode);
}
if (MPFR_IS_INF (y))
{
if (!MPFR_IS_INF (x)) /* +/- PI/2 */
return pi_div_2ui (dest, 1, MPFR_IS_NEG (y), rnd_mode);
else if (MPFR_IS_POS (x)) /* +/- PI/4 */
return pi_div_2ui (dest, 2, MPFR_IS_NEG (y), rnd_mode);
else /* +/- 3*PI/4: Ugly since we have to round properly */
{
mpfr_t tmp2;
MPFR_ZIV_DECL (loop2);
mpfr_prec_t prec2 = MPFR_PREC (dest) + 10;
MPFR_SAVE_EXPO_MARK (expo);
mpfr_init2 (tmp2, prec2);
MPFR_ZIV_INIT (loop2, prec2);
for (;;)
{
mpfr_const_pi (tmp2, MPFR_RNDN);
mpfr_mul_ui (tmp2, tmp2, 3, MPFR_RNDN); /* Error <= 2 */
mpfr_div_2ui (tmp2, tmp2, 2, MPFR_RNDN);
if (mpfr_round_p (MPFR_MANT (tmp2), MPFR_LIMB_SIZE (tmp2),
MPFR_PREC (tmp2) - 2,
MPFR_PREC (dest) + (rnd_mode == MPFR_RNDN)))
break;
MPFR_ZIV_NEXT (loop2, prec2);
mpfr_set_prec (tmp2, prec2);
}
MPFR_ZIV_FREE (loop2);
if (MPFR_IS_NEG (y))
MPFR_CHANGE_SIGN (tmp2);
inexact = mpfr_set (dest, tmp2, rnd_mode);
mpfr_clear (tmp2);
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_check_range (dest, inexact, rnd_mode);
}
}
MPFR_ASSERTD (MPFR_IS_INF (x));
if (MPFR_IS_NEG (x))
goto set_pi;
else
goto set_zero;
}
/* When x is a power of two, we call directly atan(y/x) since y/x is
exact. */
if (MPFR_UNLIKELY (MPFR_IS_POWER_OF_2 (x)))
{
int r;
mpfr_t yoverx;
unsigned int saved_flags = __gmpfr_flags;
mpfr_init2 (yoverx, MPFR_PREC (y));
if (MPFR_LIKELY (mpfr_div_2si (yoverx, y, MPFR_GET_EXP (x) - 1,
MPFR_RNDN) == 0))
{
/* Here the flags have not changed due to mpfr_div_2si. */
r = mpfr_atan (dest, yoverx, rnd_mode);
mpfr_clear (yoverx);
return r;
}
else
{
/* Division is inexact because of a small exponent range */
mpfr_clear (yoverx);
__gmpfr_flags = saved_flags;
}
}
MPFR_SAVE_EXPO_MARK (expo);
/* Set up initial prec */
prec = MPFR_PREC (dest) + 3 + MPFR_INT_CEIL_LOG2 (MPFR_PREC (dest));
mpfr_init2 (tmp, prec);
MPFR_ZIV_INIT (loop, prec);
if (MPFR_IS_POS (x))
/* use atan2(y,x) = atan(y/x) */
for (;;)
{
int div_inex;
MPFR_BLOCK_DECL (flags);
MPFR_BLOCK (flags, div_inex = mpfr_div (tmp, y, x, MPFR_RNDN));
if (div_inex == 0)
{
/* Result is exact. */
inexact = mpfr_atan (dest, tmp, rnd_mode);
goto end;
}
/* Error <= ulp (tmp) except in case of underflow or overflow. */
/* If the division underflowed, since |atan(z)/z| < 1, we have
an underflow. */
if (MPFR_UNDERFLOW (flags))
{
int sign;
/* In the case MPFR_RNDN with 2^(emin-2) < |y/x| < 2^(emin-1):
The smallest significand value S > 1 of |y/x| is:
* 1 / (1 - 2^(-px)) if py <= px,
* (1 - 2^(-px) + 2^(-py)) / (1 - 2^(-px)) if py >= px.
Therefore S - 1 > 2^(-pz), where pz = max(px,py). We have:
atan(|y/x|) > atan(z), where z = 2^(emin-2) * (1 + 2^(-pz)).
> z - z^3 / 3.
> 2^(emin-2) * (1 + 2^(-pz) - 2^(2 emin - 5))
Assuming pz <= -2 emin + 5, we can round away from zero
(this is what mpfr_underflow always does on MPFR_RNDN).
In the case MPFR_RNDN with |y/x| <= 2^(emin-2), we round
toward zero, as |atan(z)/z| < 1. */
MPFR_ASSERTN (MPFR_PREC_MAX <=
2 * (mpfr_uexp_t) - MPFR_EMIN_MIN + 5);
if (rnd_mode == MPFR_RNDN && MPFR_IS_ZERO (tmp))
rnd_mode = MPFR_RNDZ;
sign = MPFR_SIGN (tmp);
mpfr_clear (tmp);
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_underflow (dest, rnd_mode, sign);
}
mpfr_atan (tmp, tmp, MPFR_RNDN); /* Error <= 2*ulp (tmp) since
abs(D(arctan)) <= 1 */
/* TODO: check that the error bound is correct in case of overflow. */
/* FIXME: Error <= ulp(tmp) ? */
if (MPFR_LIKELY (MPFR_CAN_ROUND (tmp, prec - 2, MPFR_PREC (dest),
rnd_mode)))
break;
MPFR_ZIV_NEXT (loop, prec);
mpfr_set_prec (tmp, prec);
}
else /* x < 0 */
/* Use sign(y)*(PI - atan (|y/x|)) */
{
mpfr_init2 (pi, prec);
for (;;)
{
mpfr_div (tmp, y, x, MPFR_RNDN); /* Error <= ulp (tmp) */
/* If tmp is 0, we have |y/x| <= 2^(-emin-2), thus
atan|y/x| < 2^(-emin-2). */
MPFR_SET_POS (tmp); /* no error */
mpfr_atan (tmp, tmp, MPFR_RNDN); /* Error <= 2*ulp (tmp) since
abs(D(arctan)) <= 1 */
mpfr_const_pi (pi, MPFR_RNDN); /* Error <= ulp(pi) /2 */
e = MPFR_NOTZERO(tmp) ? MPFR_GET_EXP (tmp) : __gmpfr_emin - 1;
mpfr_sub (tmp, pi, tmp, MPFR_RNDN); /* see above */
if (MPFR_IS_NEG (y))
MPFR_CHANGE_SIGN (tmp);
/* Error(tmp) <= (1/2+2^(EXP(pi)-EXP(tmp)-1)+2^(e-EXP(tmp)+1))*ulp
<= 2^(MAX (MAX (EXP(PI)-EXP(tmp)-1, e-EXP(tmp)+1),
-1)+2)*ulp(tmp) */
e = MAX (MAX (MPFR_GET_EXP (pi)-MPFR_GET_EXP (tmp) - 1,
e - MPFR_GET_EXP (tmp) + 1), -1) + 2;
if (MPFR_LIKELY (MPFR_CAN_ROUND (tmp, prec - e, MPFR_PREC (dest),
rnd_mode)))
break;
MPFR_ZIV_NEXT (loop, prec);
mpfr_set_prec (tmp, prec);
mpfr_set_prec (pi, prec);
}
mpfr_clear (pi);
}
inexact = mpfr_set (dest, tmp, rnd_mode);
end:
MPFR_ZIV_FREE (loop);
mpfr_clear (tmp);
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_check_range (dest, inexact, rnd_mode);
}
static int
mpfr_mul3 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
{
/* Old implementation */
int sign_product, cc, inexact;
mpfr_exp_t ax;
mp_limb_t *tmp;
mp_limb_t b1;
mpfr_prec_t bq, cq;
mp_size_t bn, cn, tn, k;
MPFR_TMP_DECL(marker);
/* deal with special cases */
if (MPFR_ARE_SINGULAR(b,c))
{
if (MPFR_IS_NAN(b) || MPFR_IS_NAN(c))
{
MPFR_SET_NAN(a);
MPFR_RET_NAN;
}
sign_product = MPFR_MULT_SIGN( MPFR_SIGN(b) , MPFR_SIGN(c) );
if (MPFR_IS_INF(b))
{
if (MPFR_IS_INF(c) || MPFR_NOTZERO(c))
{
MPFR_SET_SIGN(a,sign_product);
MPFR_SET_INF(a);
MPFR_RET(0); /* exact */
}
else
{
MPFR_SET_NAN(a);
MPFR_RET_NAN;
}
}
else if (MPFR_IS_INF(c))
{
if (MPFR_NOTZERO(b))
{
MPFR_SET_SIGN(a, sign_product);
MPFR_SET_INF(a);
MPFR_RET(0); /* exact */
}
else
{
MPFR_SET_NAN(a);
MPFR_RET_NAN;
}
}
else
{
MPFR_ASSERTD(MPFR_IS_ZERO(b) || MPFR_IS_ZERO(c));
MPFR_SET_SIGN(a, sign_product);
MPFR_SET_ZERO(a);
MPFR_RET(0); /* 0 * 0 is exact */
}
}
sign_product = MPFR_MULT_SIGN( MPFR_SIGN(b) , MPFR_SIGN(c) );
ax = MPFR_GET_EXP (b) + MPFR_GET_EXP (c);
bq = MPFR_PREC(b);
cq = MPFR_PREC(c);
MPFR_ASSERTD(bq+cq > bq); /* PREC_MAX is /2 so no integer overflow */
bn = (bq+GMP_NUMB_BITS-1)/GMP_NUMB_BITS; /* number of limbs of b */
cn = (cq+GMP_NUMB_BITS-1)/GMP_NUMB_BITS; /* number of limbs of c */
k = bn + cn; /* effective nb of limbs used by b*c (= tn or tn+1) below */
tn = (bq + cq + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS;
/* <= k, thus no int overflow */
MPFR_ASSERTD(tn <= k);
/* Check for no size_t overflow*/
MPFR_ASSERTD((size_t) k <= ((size_t) -1) / BYTES_PER_MP_LIMB);
MPFR_TMP_MARK(marker);
tmp = (mp_limb_t *) MPFR_TMP_ALLOC((size_t) k * BYTES_PER_MP_LIMB);
/* multiplies two mantissa in temporary allocated space */
b1 = (MPFR_LIKELY(bn >= cn)) ?
mpn_mul (tmp, MPFR_MANT(b), bn, MPFR_MANT(c), cn)
: mpn_mul (tmp, MPFR_MANT(c), cn, MPFR_MANT(b), bn);
/* now tmp[0]..tmp[k-1] contains the product of both mantissa,
with tmp[k-1]>=2^(GMP_NUMB_BITS-2) */
b1 >>= GMP_NUMB_BITS - 1; /* msb from the product */
/* if the mantissas of b and c are uniformly distributed in ]1/2, 1],
then their product is in ]1/4, 1/2] with probability 2*ln(2)-1 ~ 0.386
and in [1/2, 1] with probability 2-2*ln(2) ~ 0.614 */
tmp += k - tn;
if (MPFR_UNLIKELY(b1 == 0))
mpn_lshift (tmp, tmp, tn, 1); /* tn <= k, so no stack corruption */
cc = mpfr_round_raw (MPFR_MANT (a), tmp, bq + cq,
MPFR_IS_NEG_SIGN(sign_product),
MPFR_PREC (a), rnd_mode, &inexact);
/* cc = 1 ==> result is a power of two */
if (MPFR_UNLIKELY(cc))
MPFR_MANT(a)[MPFR_LIMB_SIZE(a)-1] = MPFR_LIMB_HIGHBIT;
MPFR_TMP_FREE(marker);
{
mpfr_exp_t ax2 = ax + (mpfr_exp_t) (b1 - 1 + cc);
if (MPFR_UNLIKELY( ax2 > __gmpfr_emax))
return mpfr_overflow (a, rnd_mode, sign_product);
if (MPFR_UNLIKELY( ax2 < __gmpfr_emin))
{
/* In the rounding to the nearest mode, if the exponent of the exact
result (i.e. before rounding, i.e. without taking cc into account)
is < __gmpfr_emin - 1 or the exact result is a power of 2 (i.e. if
both arguments are powers of 2), then round to zero. */
if (rnd_mode == MPFR_RNDN &&
(ax + (mpfr_exp_t) b1 < __gmpfr_emin ||
(mpfr_powerof2_raw (b) && mpfr_powerof2_raw (c))))
rnd_mode = MPFR_RNDZ;
return mpfr_underflow (a, rnd_mode, sign_product);
}
MPFR_SET_EXP (a, ax2);
MPFR_SET_SIGN(a, sign_product);
}
MPFR_RET (inexact);
}
int
mpfr_set_f (mpfr_ptr y, mpf_srcptr x, mpfr_rnd_t rnd_mode)
{
mp_limb_t *my, *mx, *tmp;
unsigned long cnt, sx, sy;
int inexact, carry = 0;
MPFR_TMP_DECL(marker);
sx = ABS(SIZ(x)); /* number of limbs of the mantissa of x */
if (sx == 0) /* x is zero */
{
MPFR_SET_ZERO(y);
MPFR_SET_POS(y);
return 0; /* 0 is exact */
}
if (SIZ(x) * MPFR_FROM_SIGN_TO_INT(MPFR_SIGN(y)) < 0)
MPFR_CHANGE_SIGN (y);
sy = MPFR_LIMB_SIZE (y);
my = MPFR_MANT(y);
mx = PTR(x);
count_leading_zeros(cnt, mx[sx - 1]);
if (sy <= sx) /* we may have to round even when sy = sx */
{
unsigned long xprec = sx * GMP_NUMB_BITS;
MPFR_TMP_MARK(marker);
tmp = MPFR_TMP_LIMBS_ALLOC (sx);
if (cnt)
mpn_lshift (tmp, mx, sx, cnt);
else
/* FIXME: we may avoid the copy here, and directly call mpfr_round_raw
on mx instead of tmp */
MPN_COPY (tmp, mx, sx);
carry = mpfr_round_raw (my, tmp, xprec, (SIZ(x) < 0), MPFR_PREC(y),
rnd_mode, &inexact);
if (MPFR_UNLIKELY(carry)) /* result is a power of two */
my[sy - 1] = MPFR_LIMB_HIGHBIT;
MPFR_TMP_FREE(marker);
}
else
{
if (cnt)
mpn_lshift (my + sy - sx, mx, sx, cnt);
else
MPN_COPY (my + sy - sx, mx, sx);
MPN_ZERO(my, sy - sx);
/* no rounding necessary, since y has a larger mantissa */
inexact = 0;
}
/* warning: EXP(x) * GMP_NUMB_BITS may exceed the maximal exponent */
if (EXP(x) > 1 + (__gmpfr_emax - 1) / GMP_NUMB_BITS)
{
/* EXP(x) >= 2 + floor((__gmpfr_emax-1)/GMP_NUMB_BITS)
EXP(x) >= 2 + (__gmpfr_emax - GMP_NUMB_BITS) / GMP_NUMB_BITS
>= 1 + __gmpfr_emax / GMP_NUMB_BITS
EXP(x) * GMP_NUMB_BITS >= __gmpfr_emax + GMP_NUMB_BITS
Since 0 <= cnt <= GMP_NUMB_BITS-1, and 0 <= carry <= 1,
we have then EXP(x) * GMP_NUMB_BITS - cnt + carry > __gmpfr_emax */
return mpfr_overflow (y, rnd_mode, MPFR_SIGN (y));
}
else
{
/* Do not use MPFR_SET_EXP as the exponent may be out of range. */
MPFR_EXP (y) = EXP (x) * GMP_NUMB_BITS - (mpfr_exp_t) cnt + carry;
}
return mpfr_check_range (y, inexact, rnd_mode);
}
int
mpfr_mul_ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int u, mpfr_rnd_t rnd_mode)
{
mp_limb_t *yp;
mp_size_t xn;
int cnt, inexact;
MPFR_TMP_DECL (marker);
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 (u != 0)
{
MPFR_SET_INF (y);
MPFR_SET_SAME_SIGN (y, x);
MPFR_RET (0); /* infinity is exact */
}
else /* 0 * infinity */
{
MPFR_SET_NAN (y);
MPFR_RET_NAN;
}
}
else /* x is zero */
{
MPFR_ASSERTD (MPFR_IS_ZERO (x));
MPFR_SET_ZERO (y);
MPFR_SET_SAME_SIGN (y, x);
MPFR_RET (0); /* zero is exact */
}
}
else if (MPFR_UNLIKELY (u <= 1))
{
if (u < 1)
{
MPFR_SET_ZERO (y);
MPFR_SET_SAME_SIGN (y, x);
MPFR_RET (0); /* zero is exact */
}
else
return mpfr_set (y, x, rnd_mode);
}
else if (MPFR_UNLIKELY (IS_POW2 (u)))
return mpfr_mul_2si (y, x, MPFR_INT_CEIL_LOG2 (u), rnd_mode);
yp = MPFR_MANT (y);
xn = MPFR_LIMB_SIZE (x);
MPFR_ASSERTD (xn < MP_SIZE_T_MAX);
MPFR_TMP_MARK(marker);
yp = MPFR_TMP_LIMBS_ALLOC (xn + 1);
MPFR_ASSERTN (u == (mp_limb_t) u);
yp[xn] = mpn_mul_1 (yp, MPFR_MANT (x), xn, u);
/* x * u is stored in yp[xn], ..., yp[0] */
/* since the case u=1 was treated above, we have u >= 2, thus
yp[xn] >= 1 since x was msb-normalized */
MPFR_ASSERTD (yp[xn] != 0);
if (MPFR_LIKELY (MPFR_LIMB_MSB (yp[xn]) == 0))
{
count_leading_zeros (cnt, yp[xn]);
mpn_lshift (yp, yp, xn + 1, cnt);
}
else
{
cnt = 0;
}
/* now yp[xn], ..., yp[0] is msb-normalized too, and has at most
PREC(x) + (GMP_NUMB_BITS - cnt) non-zero bits */
MPFR_RNDRAW (inexact, y, yp, (mpfr_prec_t) (xn + 1) * GMP_NUMB_BITS,
rnd_mode, MPFR_SIGN (x), cnt -- );
MPFR_TMP_FREE (marker);
cnt = GMP_NUMB_BITS - cnt;
if (MPFR_UNLIKELY (__gmpfr_emax < MPFR_EMAX_MIN + cnt
|| MPFR_GET_EXP (x) > __gmpfr_emax - cnt))
return mpfr_overflow (y, rnd_mode, MPFR_SIGN(x));
MPFR_SET_EXP (y, MPFR_GET_EXP (x) + cnt);
MPFR_SET_SAME_SIGN (y, x);
return inexact;
}
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;
}
int
mpfr_rint (mpfr_ptr r, mpfr_srcptr u, mpfr_rnd_t rnd_mode)
{
int sign;
int rnd_away;
mp_exp_t exp;
if (MPFR_UNLIKELY( MPFR_IS_SINGULAR(u) ))
{
if (MPFR_IS_NAN(u))
{
MPFR_SET_NAN(r);
MPFR_RET_NAN;
}
MPFR_SET_SAME_SIGN(r, u);
if (MPFR_IS_INF(u))
{
MPFR_SET_INF(r);
MPFR_RET(0); /* infinity is exact */
}
else /* now u is zero */
{
MPFR_ASSERTD(MPFR_IS_ZERO(u));
MPFR_SET_ZERO(r);
MPFR_RET(0); /* zero is exact */
}
}
MPFR_SET_SAME_SIGN (r, u); /* Does nothing if r==u */
sign = MPFR_INT_SIGN (u);
exp = MPFR_GET_EXP (u);
rnd_away =
rnd_mode == GMP_RNDD ? sign < 0 :
rnd_mode == GMP_RNDU ? sign > 0 :
rnd_mode == GMP_RNDZ ? 0 : -1;
/* rnd_away:
1 if round away from zero,
0 if round to zero,
-1 if not decided yet.
*/
if (MPFR_UNLIKELY (exp <= 0)) /* 0 < |u| < 1 ==> round |u| to 0 or 1 */
{
/* Note: in the GMP_RNDN mode, 0.5 must be rounded to 0. */
if (rnd_away != 0 &&
(rnd_away > 0 ||
(exp == 0 && (rnd_mode == GMP_RNDNA ||
!mpfr_powerof2_raw (u)))))
{
mp_limb_t *rp;
mp_size_t rm;
rp = MPFR_MANT(r);
rm = (MPFR_PREC(r) - 1) / BITS_PER_MP_LIMB;
rp[rm] = MPFR_LIMB_HIGHBIT;
MPN_ZERO(rp, rm);
MPFR_SET_EXP (r, 1); /* |r| = 1 */
MPFR_RET(sign > 0 ? 2 : -2);
}
else
{
MPFR_SET_ZERO(r); /* r = 0 */
MPFR_RET(sign > 0 ? -2 : 2);
}
}
else /* exp > 0, |u| >= 1 */
{
mp_limb_t *up, *rp;
mp_size_t un, rn, ui;
int sh, idiff;
int uflags;
/*
* uflags will contain:
* _ 0 if u is an integer representable in r,
* _ 1 if u is an integer not representable in r,
* _ 2 if u is not an integer.
*/
up = MPFR_MANT(u);
rp = MPFR_MANT(r);
un = MPFR_LIMB_SIZE(u);
rn = MPFR_LIMB_SIZE(r);
MPFR_UNSIGNED_MINUS_MODULO (sh, MPFR_PREC (r));
MPFR_SET_EXP (r, exp); /* Does nothing if r==u */
if ((exp - 1) / BITS_PER_MP_LIMB >= un)
{
ui = un;
idiff = 0;
uflags = 0; /* u is an integer, representable or not in r */
}
else
{
mp_size_t uj;
ui = (exp - 1) / BITS_PER_MP_LIMB + 1; /* #limbs of the int part */
MPFR_ASSERTD (un >= ui);
uj = un - ui; /* lowest limb of the integer part */
idiff = exp % BITS_PER_MP_LIMB; /* #int-part bits in up[uj] or 0 */
uflags = idiff == 0 || (up[uj] << idiff) == 0 ? 0 : 2;
if (uflags == 0)
while (uj > 0)
if (up[--uj] != 0)
{
uflags = 2;
break;
}
}
if (ui > rn)
{
/* More limbs in the integer part of u than in r.
Just round u with the precision of r. */
MPFR_ASSERTD (rp != up && un > rn);
MPN_COPY (rp, up + (un - rn), rn); /* r != u */
if (rnd_away < 0)
{
/* This is a rounding to nearest mode (GMP_RNDN or GMP_RNDNA).
Decide the rounding direction here. */
if (rnd_mode == GMP_RNDN &&
(rp[0] & (MPFR_LIMB_ONE << sh)) == 0)
{ /* halfway cases rounded toward zero */
mp_limb_t a, b;
/* a: rounding bit and some of the following bits */
/* b: boundary for a (weight of the rounding bit in a) */
if (sh != 0)
{
a = rp[0] & ((MPFR_LIMB_ONE << sh) - 1);
b = MPFR_LIMB_ONE << (sh - 1);
}
else
{
a = up[un - rn - 1];
b = MPFR_LIMB_HIGHBIT;
}
rnd_away = a > b;
if (a == b)
{
mp_size_t i;
for (i = un - rn - 1 - (sh == 0); i >= 0; i--)
if (up[i] != 0)
{
rnd_away = 1;
break;
}
}
}
else /* halfway cases rounded away from zero */
rnd_away = /* rounding bit */
((sh != 0 && (rp[0] & (MPFR_LIMB_ONE << (sh - 1))) != 0) ||
(sh == 0 && (up[un - rn - 1] & MPFR_LIMB_HIGHBIT) != 0));
}
if (uflags == 0)
{ /* u is an integer; determine if it is representable in r */
if (sh != 0 && rp[0] << (BITS_PER_MP_LIMB - sh) != 0)
uflags = 1; /* u is not representable in r */
else
{
mp_size_t i;
for (i = un - rn - 1; i >= 0; i--)
if (up[i] != 0)
{
uflags = 1; /* u is not representable in r */
break;
}
}
}
}
else /* ui <= rn */
{
mp_size_t uj, rj;
int ush;
uj = un - ui; /* lowest limb of the integer part in u */
rj = rn - ui; /* lowest limb of the integer part in r */
if (MPFR_LIKELY (rp != up))
MPN_COPY(rp + rj, up + uj, ui);
/* Ignore the lowest rj limbs, all equal to zero. */
rp += rj;
rn = ui;
/* number of fractional bits in whole rp[0] */
ush = idiff == 0 ? 0 : BITS_PER_MP_LIMB - idiff;
if (rj == 0 && ush < sh)
{
/* If u is an integer (uflags == 0), we need to determine
if it is representable in r, i.e. if its sh - ush bits
in the non-significant part of r are all 0. */
if (uflags == 0 && (rp[0] & ((MPFR_LIMB_ONE << sh) -
(MPFR_LIMB_ONE << ush))) != 0)
uflags = 1; /* u is an integer not representable in r */
}
else /* The integer part of u fits in r, we'll round to it. */
sh = ush;
if (rnd_away < 0)
{
/* This is a rounding to nearest mode.
Decide the rounding direction here. */
if (uj == 0 && sh == 0)
rnd_away = 0; /* rounding bit = 0 (not represented in u) */
else if (rnd_mode == GMP_RNDN &&
(rp[0] & (MPFR_LIMB_ONE << sh)) == 0)
{ /* halfway cases rounded toward zero */
mp_limb_t a, b;
/* a: rounding bit and some of the following bits */
/* b: boundary for a (weight of the rounding bit in a) */
if (sh != 0)
{
a = rp[0] & ((MPFR_LIMB_ONE << sh) - 1);
b = MPFR_LIMB_ONE << (sh - 1);
}
else
{
MPFR_ASSERTD (uj >= 1); /* see above */
a = up[uj - 1];
b = MPFR_LIMB_HIGHBIT;
}
rnd_away = a > b;
if (a == b)
{
mp_size_t i;
for (i = uj - 1 - (sh == 0); i >= 0; i--)
if (up[i] != 0)
{
rnd_away = 1;
break;
}
}
}
else /* halfway cases rounded away from zero */
rnd_away = /* rounding bit */
((sh != 0 && (rp[0] & (MPFR_LIMB_ONE << (sh - 1))) != 0) ||
(sh == 0 && (MPFR_ASSERTD (uj >= 1),
up[uj - 1] & MPFR_LIMB_HIGHBIT) != 0));
}
/* Now we can make the low rj limbs to 0 */
MPN_ZERO (rp-rj, rj);
}
if (sh != 0)
rp[0] &= MP_LIMB_T_MAX << sh;
/* If u is a representable integer, there is no rounding. */
if (uflags == 0)
MPFR_RET(0);
MPFR_ASSERTD (rnd_away >= 0); /* rounding direction is defined */
if (rnd_away && mpn_add_1(rp, rp, rn, MPFR_LIMB_ONE << sh))
{
if (exp == __gmpfr_emax)
return mpfr_overflow(r, rnd_mode, MPFR_SIGN(r)) >= 0 ?
uflags : -uflags;
else
{
MPFR_SET_EXP(r, exp + 1);
rp[rn-1] = MPFR_LIMB_HIGHBIT;
}
}
MPFR_RET (rnd_away ^ (sign < 0) ? uflags : -uflags);
} /* exp > 0, |u| >= 1 */
}
int
mpfr_sqr (mpfr_ptr a, mpfr_srcptr b, mpfr_rnd_t rnd_mode)
{
int cc, inexact;
mpfr_exp_t ax;
mp_limb_t *tmp;
mp_limb_t b1;
mpfr_prec_t bq;
mp_size_t bn, tn;
MPFR_TMP_DECL(marker);
MPFR_LOG_FUNC (("x[%#R]=%R rnd=%d", b, b, rnd_mode),
("y[%#R]=%R inexact=%d", a, a, inexact));
/* deal with special cases */
if (MPFR_UNLIKELY(MPFR_IS_SINGULAR(b)))
{
if (MPFR_IS_NAN(b))
{
MPFR_SET_NAN(a);
MPFR_RET_NAN;
}
MPFR_SET_POS (a);
if (MPFR_IS_INF(b))
MPFR_SET_INF(a);
else
( MPFR_ASSERTD(MPFR_IS_ZERO(b)), MPFR_SET_ZERO(a) );
MPFR_RET(0);
}
ax = 2 * MPFR_GET_EXP (b);
bq = MPFR_PREC(b);
MPFR_ASSERTD (2 * bq > bq); /* PREC_MAX is /2 so no integer overflow */
bn = MPFR_LIMB_SIZE(b); /* number of limbs of b */
tn = 1 + (2 * bq - 1) / GMP_NUMB_BITS; /* number of limbs of square,
2*bn or 2*bn-1 */
MPFR_TMP_MARK(marker);
tmp = (mp_limb_t *) MPFR_TMP_ALLOC((size_t) 2 * bn * BYTES_PER_MP_LIMB);
/* Multiplies the mantissa in temporary allocated space */
mpn_sqr_n (tmp, MPFR_MANT(b), bn);
b1 = tmp[2 * bn - 1];
/* now tmp[0]..tmp[2*bn-1] contains the product of both mantissa,
with tmp[2*bn-1]>=2^(GMP_NUMB_BITS-2) */
b1 >>= GMP_NUMB_BITS - 1; /* msb from the product */
/* if the mantissas of b and c are uniformly distributed in ]1/2, 1],
then their product is in ]1/4, 1/2] with probability 2*ln(2)-1 ~ 0.386
and in [1/2, 1] with probability 2-2*ln(2) ~ 0.614 */
tmp += 2 * bn - tn; /* +0 or +1 */
if (MPFR_UNLIKELY(b1 == 0))
mpn_lshift (tmp, tmp, tn, 1); /* tn <= k, so no stack corruption */
cc = mpfr_round_raw (MPFR_MANT (a), tmp, 2 * bq, 0,
MPFR_PREC (a), rnd_mode, &inexact);
/* cc = 1 ==> result is a power of two */
if (MPFR_UNLIKELY(cc))
MPFR_MANT(a)[MPFR_LIMB_SIZE(a)-1] = MPFR_LIMB_HIGHBIT;
MPFR_TMP_FREE(marker);
{
mpfr_exp_t ax2 = ax + (mpfr_exp_t) (b1 - 1 + cc);
if (MPFR_UNLIKELY( ax2 > __gmpfr_emax))
return mpfr_overflow (a, rnd_mode, MPFR_SIGN_POS);
if (MPFR_UNLIKELY( ax2 < __gmpfr_emin))
{
/* In the rounding to the nearest mode, if the exponent of the exact
result (i.e. before rounding, i.e. without taking cc into account)
is < __gmpfr_emin - 1 or the exact result is a power of 2 (i.e. if
both arguments are powers of 2), then round to zero. */
if (rnd_mode == MPFR_RNDN &&
(ax + (mpfr_exp_t) b1 < __gmpfr_emin || mpfr_powerof2_raw (b)))
rnd_mode = MPFR_RNDZ;
return mpfr_underflow (a, rnd_mode, MPFR_SIGN_POS);
}
MPFR_SET_EXP (a, ax2);
MPFR_SET_POS (a);
}
MPFR_RET (inexact);
}
int
mpfr_urandom (mpfr_ptr rop, gmp_randstate_t rstate, mpfr_rnd_t rnd_mode)
{
mpfr_limb_ptr rp;
mpfr_prec_t nbits;
mp_size_t nlimbs;
mp_size_t n;
mpfr_exp_t exp;
mpfr_exp_t emin;
int cnt;
int inex;
rp = MPFR_MANT (rop);
nbits = MPFR_PREC (rop);
nlimbs = MPFR_LIMB_SIZE (rop);
MPFR_SET_POS (rop);
exp = 0;
emin = mpfr_get_emin ();
if (MPFR_UNLIKELY (emin > 0))
{
if (rnd_mode == MPFR_RNDU || rnd_mode == MPFR_RNDA
|| (emin == 1 && rnd_mode == MPFR_RNDN
&& random_rounding_bit (rstate)))
{
mpfr_set_ui_2exp (rop, 1, emin - 1, rnd_mode);
return +1;
}
else
{
MPFR_SET_ZERO (rop);
return -1;
}
}
/* Exponent */
#define DRAW_BITS 8 /* we draw DRAW_BITS at a time */
cnt = DRAW_BITS;
MPFR_ASSERTN(DRAW_BITS <= GMP_NUMB_BITS);
while (cnt == DRAW_BITS)
{
/* generate DRAW_BITS in rp[0] */
mpfr_rand_raw (rp, rstate, DRAW_BITS);
if (MPFR_UNLIKELY (rp[0] == 0))
cnt = DRAW_BITS;
else
{
count_leading_zeros (cnt, rp[0]);
cnt -= GMP_NUMB_BITS - DRAW_BITS;
}
if (MPFR_UNLIKELY (exp < emin + cnt))
{
/* To get here, we have been drawing more than -emin zeros
in a row, then return 0 or the smallest representable
positive number.
The rounding to nearest mode is subtle:
If exp - cnt == emin - 1, the rounding bit is set, except
if cnt == DRAW_BITS in which case the rounding bit is
outside rp[0] and must be generated. */
if (rnd_mode == MPFR_RNDU || rnd_mode == MPFR_RNDA
|| (rnd_mode == MPFR_RNDN && cnt == exp - emin - 1
&& (cnt != DRAW_BITS || random_rounding_bit (rstate))))
{
mpfr_set_ui_2exp (rop, 1, emin - 1, rnd_mode);
return +1;
}
else
{
MPFR_SET_ZERO (rop);
return -1;
}
}
exp -= cnt;
}
MPFR_EXP (rop) = exp; /* Warning: may be outside the current
exponent range */
/* Significand: we need generate only nbits-1 bits, since the most
significant is 1 */
mpfr_rand_raw (rp, rstate, nbits - 1);
n = nlimbs * GMP_NUMB_BITS - nbits;
if (MPFR_LIKELY (n != 0)) /* this will put the low bits to zero */
mpn_lshift (rp, rp, nlimbs, n);
/* Set the msb to 1 since it was fixed by the exponent choice */
rp[nlimbs - 1] |= MPFR_LIMB_HIGHBIT;
/* Rounding */
if (rnd_mode == MPFR_RNDU || rnd_mode == MPFR_RNDA
|| (rnd_mode == MPFR_RNDN && random_rounding_bit (rstate)))
{
/* Take care of the exponent range: it may have been reduced */
if (exp < emin)
mpfr_set_ui_2exp (rop, 1, emin - 1, rnd_mode);
else if (exp > mpfr_get_emax ())
mpfr_set_inf (rop, +1); /* overflow, flag set by mpfr_check_range */
else
mpfr_nextabove (rop);
inex = +1;
}
else
inex = -1;
return mpfr_check_range (rop, inex, rnd_mode);
}
int
main (void)
{
mpfr_t a;
mp_limb_t *p, tmp;
mp_size_t s;
mpfr_prec_t pr;
int max;
tests_start_mpfr ();
for(pr = MPFR_PREC_MIN ; pr < 500 ; pr++)
{
mpfr_init2 (a, pr);
if (!mpfr_check(a)) ERROR("for init");
/* Check special cases */
MPFR_SET_NAN(a);
if (!mpfr_check(a)) ERROR("for nan");
MPFR_SET_POS(a);
MPFR_SET_INF(a);
if (!mpfr_check(a)) ERROR("for inf");
MPFR_SET_ZERO(a);
if (!mpfr_check(a)) ERROR("for zero");
MPFR_EXP (a) = MPFR_EXP_MIN;
if (mpfr_check(a)) ERROR("for EXP = MPFR_EXP_MIN");
/* Check var */
mpfr_set_ui(a, 2, MPFR_RNDN);
if (!mpfr_check(a)) ERROR("for set_ui");
mpfr_clear_overflow();
max = 1000; /* Allows max 2^1000 bits for the exponent */
while ((!mpfr_overflow_p()) && (max>0))
{
mpfr_mul(a, a, a, MPFR_RNDN);
if (!mpfr_check(a)) ERROR("for mul");
max--;
}
if (max==0) ERROR("can't reach overflow");
mpfr_set_ui(a, 2137, MPFR_RNDN);
/* Corrupt a and check for it */
MPFR_SIGN(a) = 2;
if (mpfr_check(a)) ERROR("sgn");
MPFR_SET_POS(a);
/* Check prec */
MPFR_PREC(a) = MPFR_PREC_MIN - 1;
if (mpfr_check(a)) ERROR("precmin");
#if MPFR_VERSION_MAJOR < 3
/* Disable the test with MPFR >= 3 since mpfr_prec_t is now signed.
The "if" below is sufficient, but the MPFR_PREC_MAX+1 generates
a warning with GCC 4.4.4 even though the test is always false. */
if ((mpfr_prec_t) 0 - 1 > 0)
{
MPFR_PREC(a) = MPFR_PREC_MAX+1;
if (mpfr_check(a)) ERROR("precmax");
}
#endif
MPFR_PREC(a) = pr;
if (!mpfr_check(a)) ERROR("prec");
/* Check exponent */
MPFR_EXP(a) = MPFR_EXP_INVALID;
if (mpfr_check(a)) ERROR("exp invalid");
MPFR_EXP(a) = -MPFR_EXP_INVALID;
if (mpfr_check(a)) ERROR("-exp invalid");
MPFR_EXP(a) = 0;
if (!mpfr_check(a)) ERROR("exp 0");
/* Check Mantissa */
p = MPFR_MANT(a);
MPFR_MANT(a) = NULL;
if (mpfr_check(a)) ERROR("Mantissa Null Ptr");
MPFR_MANT(a) = p;
/* Check size */
s = MPFR_GET_ALLOC_SIZE(a);
MPFR_SET_ALLOC_SIZE(a, 0);
if (mpfr_check(a)) ERROR("0 size");
MPFR_SET_ALLOC_SIZE(a, MP_SIZE_T_MIN);
if (mpfr_check(a)) ERROR("min size");
MPFR_SET_ALLOC_SIZE(a, MPFR_LIMB_SIZE(a)-1 );
if (mpfr_check(a)) ERROR("size < prec");
MPFR_SET_ALLOC_SIZE(a, s);
/* Check normal form */
tmp = MPFR_MANT(a)[0];
if ((pr % GMP_NUMB_BITS) != 0)
{
MPFR_MANT(a)[0] = MPFR_LIMB_MAX;
if (mpfr_check(a)) ERROR("last bits non 0");
}
MPFR_MANT(a)[0] = tmp;
MPFR_MANT(a)[MPFR_LIMB_SIZE(a)-1] &= MPFR_LIMB_MASK (GMP_NUMB_BITS-1);
if (mpfr_check(a)) ERROR("last bits non 0");
/* Final */
mpfr_set_ui(a, 2137, MPFR_RNDN);
if (!mpfr_check(a)) ERROR("after last set");
mpfr_clear (a);
if (mpfr_check(a)) ERROR("after clear");
}
tests_end_mpfr ();
return 0;
}
/* returns 0 if result exact, non-zero otherwise */
int
mpfr_div_ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int u, mp_rnd_t rnd_mode)
{
long int xn, yn, dif, sh, i;
mp_limb_t *xp, *yp, *tmp, c, d;
mp_exp_t exp;
int inexact, middle = 1;
TMP_DECL(marker);
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))
{
MPFR_SET_INF(y);
MPFR_SET_SAME_SIGN(y, x);
MPFR_RET(0);
}
else
{
MPFR_ASSERTD(MPFR_IS_ZERO(x));
if (u == 0)/* 0/0 is NaN */
{
MPFR_SET_NAN(y);
MPFR_RET_NAN;
}
else
{
MPFR_SET_ZERO(y);
MPFR_RET(0);
}
}
}
if (MPFR_UNLIKELY(u == 0))
{
/* x/0 is Inf */
MPFR_SET_INF(y);
MPFR_SET_SAME_SIGN(y, x);
MPFR_RET(0);
}
MPFR_CLEAR_FLAGS(y);
MPFR_SET_SAME_SIGN(y, x);
TMP_MARK(marker);
xn = MPFR_LIMB_SIZE(x);
yn = MPFR_LIMB_SIZE(y);
xp = MPFR_MANT(x);
yp = MPFR_MANT(y);
exp = MPFR_GET_EXP (x);
dif = yn + 1 - xn;
/* we need to store yn+1 = xn + dif limbs of the quotient */
/* don't use tmp=yp since the mpn_lshift call below requires yp >= tmp+1 */
tmp = (mp_limb_t*) TMP_ALLOC((yn + 1) * BYTES_PER_MP_LIMB);
c = (mp_limb_t) u;
MPFR_ASSERTN(u == c);
if (dif >= 0)
c = mpn_divrem_1 (tmp, dif, xp, xn, c); /* used all the dividend */
else /* dif < 0 i.e. xn > yn, don't use the (-dif) low limbs from x */
c = mpn_divrem_1 (tmp, 0, xp - dif, yn + 1, c);
inexact = (c != 0);
/* First pass in estimating next bit of the quotient, in case of RNDN *
* In case we just have the right number of bits (postpone this ?), *
* we need to check whether the remainder is more or less than half *
* the divisor. The test must be performed with a subtraction, so as *
* to prevent carries. */
if (rnd_mode == GMP_RNDN)
{
if (c < (mp_limb_t) u - c) /* We have u > c */
middle = -1;
else if (c > (mp_limb_t) u - c)
middle = 1;
else
middle = 0; /* exactly in the middle */
}
/* If we believe that we are right in the middle or exact, we should check
that we did not neglect any word of x (division large / 1 -> small). */
for (i=0; ((inexact == 0) || (middle == 0)) && (i < -dif); i++)
if (xp[i])
inexact = middle = 1; /* larger than middle */
/*
If the high limb of the result is 0 (xp[xn-1] < u), remove it.
Otherwise, compute the left shift to be performed to normalize.
In the latter case, we discard some low bits computed. They
contain information useful for the rounding, hence the updating
of middle and inexact.
*/
if (tmp[yn] == 0)
{
MPN_COPY(yp, tmp, yn);
exp -= BITS_PER_MP_LIMB;
sh = 0;
}
else
{
count_leading_zeros (sh, tmp[yn]);
/* shift left to normalize */
if (sh)
{
mp_limb_t w = tmp[0] << sh;
mpn_lshift (yp, tmp + 1, yn, sh);
yp[0] += tmp[0] >> (BITS_PER_MP_LIMB - sh);
if (w > (MPFR_LIMB_ONE << (BITS_PER_MP_LIMB - 1)))
{ middle = 1; }
else if (w < (MPFR_LIMB_ONE << (BITS_PER_MP_LIMB - 1)))
{ middle = -1; }
else
{ middle = (c != 0); }
inexact = inexact || (w != 0);
exp -= sh;
}
else
{ /* this happens only if u == 1 and xp[xn-1] >=
1<<(BITS_PER_MP_LIMB-1). It might be better to handle the
u == 1 case seperately ?
*/
MPN_COPY (yp, tmp + 1, yn);
}
}
static void
ternary_test (void)
{
int prec;
int rnd;
int inex, expected_inex;
mpf_t x;
mpfr_t y;
mpf_init2 (x, 256);
mpfr_init2 (y, 256);
for (prec = 2; prec <= 256; prec++)
{
mpf_set_prec (x, prec);
mpfr_set_prec (y, PREC (x) * GMP_NUMB_BITS + 1);
/* y == 1 */
mpfr_set_ui_2exp (y, 1, prec, MPFR_RNDN);
RND_LOOP (rnd)
{
inex = mpfr_get_f (x, y, (mpfr_rnd_t) rnd);
if (inex != 0 || mpfr_cmp_f (y, x) !=0)
{
printf ("Error in mpfr_get_f (x, y, %s)\nx = ",
mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpf_out_str (stdout, 2, 0, x);
printf ("\ny = ");
mpfr_dump (y);
if (inex != 0)
printf ("got ternary value = %+d, expected: 0\n", inex);
exit (1);
}
}
/* y == 1 + epsilon */
mpfr_nextbelow (y);
RND_LOOP (rnd)
{
switch (rnd)
{
case MPFR_RNDU: case MPFR_RNDA:
case MPFR_RNDN:
expected_inex = +1;
break;
default :
expected_inex = -1;
}
inex = mpfr_get_f (x, y, (mpfr_rnd_t) rnd);
if (! SAME_SIGN (expected_inex, inex)
|| SAME_SIGN (expected_inex, mpfr_cmp_f (y, x)))
{
printf ("Error in mpfr_get_f (x, y, %s)\nx = ",
mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpf_out_str (stdout, 2, 0, x);
printf ("\ny = ");
mpfr_dump (y);
if (! SAME_SIGN (expected_inex, inex))
printf ("got ternary value = %+d, expected: %+d\n",
inex, expected_inex);
exit (1);
}
}
/* y == positive random float */
mpfr_random2 (y, MPFR_LIMB_SIZE (y), 1024, RANDS);
RND_LOOP (rnd)
{
inex = mpfr_get_f (x, y, (mpfr_rnd_t) rnd);
if (! SAME_SIGN (inex, -mpfr_cmp_f (y, x)))
{
printf ("Error in mpfr_get_f (x, y, %s)\nx = ",
mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpf_out_str (stdout, 2, 0, x);
printf ("\ny = ");
mpfr_dump (y);
printf ("got ternary value = %+d, expected: %+d\n",
inex, -mpfr_cmp_f (y, x));
exit (1);
}
}
}
mpf_clear (x);
mpfr_clear (y);
}
