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;
}
/* s <- 1 - r/2! + r^2/4! + ... + (-1)^l r^l/(2l)! + ...
Assumes |r| < 1.
Returns the index l0 of the last term (-1)^l r^l/(2l)!.
The absolute error on s is at most 2 * l0 * 2^(-m).
*/
static int
mpfr_cos2_aux (mpfr_ptr s, mpfr_srcptr r)
{
unsigned int l, b = 2;
long int prec, m = MPFR_PREC(s);
mpfr_t t;
MPFR_ASSERTD (MPFR_GET_EXP (r) <= 0);
mpfr_init2 (t, m);
MPFR_SET_ONE (t);
mpfr_set (s, t, GMP_RNDN);
for (l = 1; MPFR_GET_EXP (t) + m >= 0; l++)
{
mpfr_mul (t, t, r, GMP_RNDU); /* err <= (3l-1) ulp */
mpfr_div_ui (t, t, (2*l-1)*(2*l), GMP_RNDU); /* err <= 3l ulp */
if (l % 2 == 0)
mpfr_add (s, s, t, GMP_RNDD);
else
mpfr_sub (s, s, t, GMP_RNDD);
MPFR_ASSERTD (MPFR_GET_EXP (s) == 0); /* check 1/2 <= s < 1 */
/* err(s) <= l * 2^(-m) */
if (MPFR_UNLIKELY(3 * l > (1U << b)))
b++;
/* now 3l <= 2^b, we want 3l*ulp(t) <= 2^(-m)
i.e. b+EXP(t)-PREC(t) <= -m */
prec = m + MPFR_GET_EXP (t) + b;
if (MPFR_LIKELY(prec >= MPFR_PREC_MIN))
mpfr_prec_round (t, prec, GMP_RNDN);
}
mpfr_clear (t);
return l;
}
int
mpfr_add_ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int u, mpfr_rnd_t rnd_mode)
{
MPFR_LOG_FUNC
(("x[%Pu]=%.*Rg u=%lu rnd=%d",
mpfr_get_prec(x), mpfr_log_prec, x, u, rnd_mode),
("y[%Pu]=%.*Rg", mpfr_get_prec (y), mpfr_log_prec, y));
if (MPFR_LIKELY(u != 0) ) /* if u=0, do nothing */
{
mpfr_t uu;
mp_limb_t up[1];
unsigned long cnt;
int inex;
MPFR_SAVE_EXPO_DECL (expo);
MPFR_TMP_INIT1 (up, uu, GMP_NUMB_BITS);
MPFR_ASSERTD (u == (mp_limb_t) u);
count_leading_zeros(cnt, (mp_limb_t) u);
up[0] = (mp_limb_t) u << cnt;
/* Optimization note: Exponent save/restore operations may be
removed if mpfr_add works even when uu is out-of-range. */
MPFR_SAVE_EXPO_MARK (expo);
MPFR_SET_EXP (uu, GMP_NUMB_BITS - cnt);
inex = mpfr_add(y, x, uu, rnd_mode);
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_check_range(y, inex, rnd_mode);
}
else
/* (unsigned long) 0 is assumed to be a real 0 (unsigned) */
return mpfr_set (y, x, rnd_mode);
}
MPFR_HOT_FUNCTION_ATTR void
mpfr_mpz_init2 (mpz_t z, mp_bitcnt_t n)
{
/* The condition on n is used below as the argument n will be ignored if
the mpz_t is obtained from the MPFR stack of previously used mpz_t.
Said otherwise, it z is expected to have a large size at the end, then
it is better to allocate this size directly than to get a mpz_t of
small size, with possibly several realloc's on it. But if n satisfies
the condition and is larger than the stacked mpz_t, this may still
yield useless realloc's. This is not ideal. We might consider to use
mpz_init2 with the maximum size in mpfr_mpz_init to solve this issue. */
if (MPFR_LIKELY (n_alloc > 0 && n <= MPFR_POOL_MAX_SIZE * GMP_NUMB_BITS))
{
/* Get a mpz_t from the MPFR stack of previously used mpz_t.
It reduces memory pressure, and it allows to reuse
a mpz_t that should be sufficiently big. */
MPFR_ASSERTD (n_alloc <= numberof (mpz_tab));
memcpy (z, &mpz_tab[--n_alloc], sizeof (mpz_t));
SIZ(z) = 0;
}
else
{
/* Call the real GMP function */
mpz_init2 (z, n);
}
}
/*
* Assuming {bp, bn} is an approximation of a non-singular number
* with error at most equal to 2^(EXP(b)-err0) (`err0' bits of b are known)
* of direction unknown, check if we can round b toward zero with
* precision prec.
*/
int
mpfr_round_p (mp_limb_t *bp, mp_size_t bn, mpfr_exp_t err0, mpfr_prec_t prec)
{
mpfr_prec_t err;
mp_size_t k, n;
mp_limb_t tmp, mask;
int s;
err = (mpfr_prec_t) bn * GMP_NUMB_BITS;
if (MPFR_UNLIKELY (err0 <= 0 || (mpfr_uexp_t) err0 <= prec || prec >= err))
return 0; /* can't round */
err = MIN (err, (mpfr_uexp_t) err0);
k = prec / GMP_NUMB_BITS;
s = GMP_NUMB_BITS - prec%GMP_NUMB_BITS;
n = err / GMP_NUMB_BITS - k;
MPFR_ASSERTD (n >= 0);
MPFR_ASSERTD (bn > k);
/* Check first limb */
bp += bn-1-k;
tmp = *bp--;
mask = s == GMP_NUMB_BITS ? MP_LIMB_T_MAX : MPFR_LIMB_MASK (s);
tmp &= mask;
if (MPFR_LIKELY (n == 0))
{
/* prec and error are in the same limb */
s = GMP_NUMB_BITS - err % GMP_NUMB_BITS;
MPFR_ASSERTD (s < GMP_NUMB_BITS);
tmp >>= s;
mask >>= s;
return tmp != 0 && tmp != mask;
}
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;
}
/*
* Set f to z, choosing the smallest precision for f
* so that z = f*(2^BPML)*zs*2^(RetVal)
*/
static int
set_z (mpfr_ptr f, mpz_srcptr z, mp_size_t *zs)
{
mp_limb_t *p;
mp_size_t s;
int c;
mp_prec_t pf;
MPFR_ASSERTD (mpz_sgn (z) != 0);
/* Remove useless ending 0 */
for (p = PTR (z), s = *zs = ABS (SIZ (z)) ; *p == 0; p++, s--)
MPFR_ASSERTD (s >= 0);
/* Get working precision */
count_leading_zeros (c, p[s-1]);
pf = s * BITS_PER_MP_LIMB - c;
if (pf < MPFR_PREC_MIN)
pf = MPFR_PREC_MIN;
mpfr_init2 (f, pf);
/* Copy Mantissa */
if (MPFR_LIKELY (c))
mpn_lshift (MPFR_MANT (f), p, s, c);
else
MPN_COPY (MPFR_MANT (f), p, s);
MPFR_SET_SIGN (f, mpz_sgn (z));
MPFR_SET_EXP (f, 0);
return -c;
}
/* Put in rp[n..2n-1] an approximation of the n high limbs
of {np, n} * {mp, n}. The error is less than n ulps of rp[n] (and the
approximation is always less or equal to the truncated full product).
Implements Algorithm ShortMul from [1].
*/
void
mpfr_mulhigh_n (mpfr_limb_ptr rp, mpfr_limb_srcptr np, mpfr_limb_srcptr mp,
mp_size_t n)
{
mp_size_t k;
MPFR_ASSERTN (MPFR_MULHIGH_TAB_SIZE >= 8); /* so that 3*(n/4) > n/2 */
k = MPFR_LIKELY (n < MPFR_MULHIGH_TAB_SIZE) ? mulhigh_ktab[n] : 3*(n/4);
/* Algorithm ShortMul from [1] requires k >= (n+3)/2, which translates
into k >= (n+4)/2 in the C language. */
MPFR_ASSERTD (k == -1 || k == 0 || (k >= (n+4)/2 && k < n));
if (k < 0)
mpn_mul_basecase (rp, np, n, mp, n); /* result is exact, no error */
else if (k == 0)
mpfr_mulhigh_n_basecase (rp, np, mp, n); /* basecase error < n ulps */
else if (n > MUL_FFT_THRESHOLD)
mpn_mul_n (rp, np, mp, n); /* result is exact, no error */
else
{
mp_size_t l = n - k;
mp_limb_t cy;
mpn_mul_n (rp + 2 * l, np + l, mp + l, k); /* fills rp[2l..2n-1] */
mpfr_mulhigh_n (rp, np + k, mp, l); /* fills rp[l-1..2l-1] */
cy = mpn_add_n (rp + n - 1, rp + n - 1, rp + l - 1, l + 1);
mpfr_mulhigh_n (rp, np, mp + k, l); /* fills rp[l-1..2l-1] */
cy += mpn_add_n (rp + n - 1, rp + n - 1, rp + l - 1, l + 1);
mpn_add_1 (rp + n + l, rp + n + l, k, cy); /* propagate carry */
}
}
/* Put in rp[0..n] the n+1 low limbs of {np, n} * {mp, n}.
Assume 2n limbs are allocated at rp. */
void
mpfr_mullow_n (mpfr_limb_ptr rp, mpfr_limb_srcptr np, mpfr_limb_srcptr mp,
mp_size_t n)
{
mp_size_t k;
MPFR_ASSERTN (MPFR_MULHIGH_TAB_SIZE >= 8); /* so that 3*(n/4) > n/2 */
k = MPFR_LIKELY (n < MPFR_MULHIGH_TAB_SIZE) ? mulhigh_ktab[n] : 3*(n/4);
MPFR_ASSERTD (k == -1 || k == 0 || (2 * k >= n && k < n));
if (k < 0)
mpn_mul_basecase (rp, np, n, mp, n);
else if (k == 0)
mpfr_mullow_n_basecase (rp, np, mp, n);
else if (n > MUL_FFT_THRESHOLD)
mpn_mul_n (rp, np, mp, n);
else
{
mp_size_t l = n - k;
mpn_mul_n (rp, np, mp, k); /* fills rp[0..2k] */
mpfr_mullow_n (rp + n, np + k, mp, l); /* fills rp[n..n+2l] */
mpn_add_n (rp + k, rp + k, rp + n, l + 1);
mpfr_mullow_n (rp + n, np, mp + k, l); /* fills rp[n..n+2l] */
mpn_add_n (rp + k, rp + k, rp + n, l + 1);
}
}
void
mpfr_custom_init_set (mpfr_ptr x, int kind, mp_exp_t exp,
mp_prec_t prec, void *mantissa)
{
mpfr_kind_t t;
int s;
mp_exp_t e;
if (kind >= 0)
{
t = (mpfr_kind_t) kind;
s = MPFR_SIGN_POS;
}
else
{
t = (mpfr_kind_t) -kind;
s = MPFR_SIGN_NEG;
}
MPFR_ASSERTD (t <= MPFR_REGULAR_KIND);
e = MPFR_LIKELY (t == MPFR_REGULAR_KIND) ? exp :
MPFR_UNLIKELY (t == MPFR_NAN_KIND) ? MPFR_EXP_NAN :
MPFR_UNLIKELY (t == MPFR_INF_KIND) ? MPFR_EXP_INF : MPFR_EXP_ZERO;
MPFR_PREC (x) = prec;
MPFR_SET_SIGN (x, s);
MPFR_EXP (x) = e;
MPFR_MANT (x) = (mp_limb_t*) mantissa;
return;
}
/* Put in rp[n..2n-1] an approximation of the n high limbs
of {np, n}^2. The error is less than n ulps of rp[n]. */
void
mpfr_sqrhigh_n (mpfr_limb_ptr rp, mpfr_limb_srcptr np, mp_size_t n)
{
mp_size_t k;
MPFR_ASSERTN (MPFR_SQRHIGH_TAB_SIZE > 2); /* ensures k < n */
k = MPFR_LIKELY (n < MPFR_SQRHIGH_TAB_SIZE) ? sqrhigh_ktab[n]
: (n+4)/2; /* ensures that k >= (n+3)/2 */
MPFR_ASSERTD (k == -1 || k == 0 || (k >= (n+4)/2 && k < n));
if (k < 0)
/* we can't use mpn_sqr_basecase here, since it requires
n <= SQR_KARATSUBA_THRESHOLD, where SQR_KARATSUBA_THRESHOLD
is not exported by GMP */
mpn_sqr_n (rp, np, n);
else if (k == 0)
mpfr_mulhigh_n_basecase (rp, np, np, n);
else
{
mp_size_t l = n - k;
mp_limb_t cy;
mpn_sqr_n (rp + 2 * l, np + l, k); /* fills rp[2l..2n-1] */
mpfr_mulhigh_n (rp, np, np + k, l); /* fills rp[l-1..2l-1] */
/* {rp+n-1,l+1} += 2 * {rp+l-1,l+1} */
cy = mpn_lshift (rp + l - 1, rp + l - 1, l + 1, 1);
cy += mpn_add_n (rp + n - 1, rp + n - 1, rp + l - 1, l + 1);
mpn_add_1 (rp + n + l, rp + n + l, k, cy); /* propagate carry */
}
}
int
mpfr_sub_ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int u, mp_rnd_t rnd_mode)
{
if (MPFR_LIKELY (u != 0)) /* if u=0, do nothing */
{
mpfr_t uu;
mp_limb_t up[1];
unsigned long cnt;
int inex;
MPFR_SAVE_EXPO_DECL (expo);
MPFR_TMP_INIT1 (up, uu, BITS_PER_MP_LIMB);
MPFR_ASSERTN (u == (mp_limb_t) u);
count_leading_zeros (cnt, (mp_limb_t) u);
*up = (mp_limb_t) u << cnt;
/* Optimization note: Exponent save/restore operations may be
removed if mpfr_sub works even when uu is out-of-range. */
MPFR_SAVE_EXPO_MARK (expo);
MPFR_SET_EXP (uu, BITS_PER_MP_LIMB - cnt);
inex = mpfr_sub (y, x, uu, rnd_mode);
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_check_range (y, inex, rnd_mode);
}
else
return mpfr_set (y, x, rnd_mode);
}
int
mpfr_ui_div (mpfr_ptr y, unsigned long int u, mpfr_srcptr x, mpfr_rnd_t rnd_mode)
{
mpfr_t uu;
mp_limb_t up[1];
unsigned long cnt;
MPFR_LOG_FUNC
(("u=%lu x[%Pu]=%.*Rg rnd=%d",
u, mpfr_get_prec(x), mpfr_log_prec, x, rnd_mode),
("y[%Pu]=%.*Rg", mpfr_get_prec(y), mpfr_log_prec, y));
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)) /* u/Inf = 0 */
{
MPFR_SET_ZERO(y);
MPFR_SET_SAME_SIGN(y,x);
MPFR_RET(0);
}
else /* u / 0 */
{
MPFR_ASSERTD(MPFR_IS_ZERO(x));
if (u)
{
/* u > 0, so y = sign(x) * Inf */
MPFR_SET_SAME_SIGN(y, x);
MPFR_SET_INF(y);
mpfr_set_divby0 ();
MPFR_RET(0);
}
else
{
/* 0 / 0 */
MPFR_SET_NAN(y);
MPFR_RET_NAN;
}
}
}
else if (MPFR_LIKELY(u != 0))
{
MPFR_TMP_INIT1(up, uu, GMP_NUMB_BITS);
MPFR_ASSERTN(u == (mp_limb_t) u);
count_leading_zeros(cnt, (mp_limb_t) u);
up[0] = (mp_limb_t) u << cnt;
MPFR_SET_EXP (uu, GMP_NUMB_BITS - cnt);
return mpfr_div (y, uu, x, rnd_mode);
}
else /* u = 0, and x != 0 */
{
MPFR_SET_ZERO(y); /* if u=0, then set y to 0 */
MPFR_SET_SAME_SIGN(y, x); /* u considered as +0: sign(+0/x) = sign(x) */
MPFR_RET(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_const_euler_internal (mpfr_t x, mpfr_rnd_t rnd)
{
mpfr_prec_t prec = MPFR_PREC(x), m, log2m;
mpfr_t y, z;
unsigned long n;
int inexact;
MPFR_ZIV_DECL (loop);
log2m = MPFR_INT_CEIL_LOG2 (prec);
m = prec + 2 * log2m + 23;
mpfr_init2 (y, m);
mpfr_init2 (z, m);
MPFR_ZIV_INIT (loop, m);
for (;;)
{
mpfr_exp_t exp_S, err;
/* since prec >= 1, we have m >= 24 here, which ensures n >= 9 below */
n = 1 + (unsigned long) ((double) m * LOG2 / 2.0);
MPFR_ASSERTD (n >= 9);
mpfr_const_euler_S2 (y, n); /* error <= 3 ulps */
exp_S = MPFR_EXP(y);
mpfr_set_ui (z, n, MPFR_RNDN);
mpfr_log (z, z, MPFR_RNDD); /* error <= 1 ulp */
mpfr_sub (y, y, z, MPFR_RNDN); /* S'(n) - log(n) */
/* the error is less than 1/2 + 3*2^(exp_S-EXP(y)) + 2^(EXP(z)-EXP(y))
<= 1/2 + 2^(exp_S+2-EXP(y)) + 2^(EXP(z)-EXP(y))
<= 1/2 + 2^(1+MAX(exp_S+2,EXP(z))-EXP(y)) */
err = 1 + MAX(exp_S + 2, MPFR_EXP(z)) - MPFR_EXP(y);
err = (err >= -1) ? err + 1 : 0; /* error <= 2^err ulp(y) */
exp_S = MPFR_EXP(y);
mpfr_const_euler_R (z, n); /* err <= ulp(1/2) = 2^(-m) */
mpfr_sub (y, y, z, MPFR_RNDN);
/* err <= 1/2 ulp(y) + 2^(-m) + 2^(err + exp_S - EXP(y)) ulp(y).
Since the result is between 0.5 and 1, ulp(y) = 2^(-m).
So we get 3/2*ulp(y) + 2^(err + exp_S - EXP(y)) ulp(y).
3/2 + 2^e <= 2^(e+1) for e>=1, and <= 2^2 otherwise */
err = err + exp_S - MPFR_EXP(y);
err = (err >= 1) ? err + 1 : 2;
if (MPFR_LIKELY (MPFR_CAN_ROUND (y, m - err, prec, rnd)))
break;
MPFR_ZIV_NEXT (loop, m);
mpfr_set_prec (y, m);
mpfr_set_prec (z, m);
}
MPFR_ZIV_FREE (loop);
inexact = mpfr_set (x, y, rnd);
mpfr_clear (y);
mpfr_clear (z);
return inexact; /* always inexact */
}
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 */
}
int
mpfr_ui_div (mpfr_ptr y, unsigned long int u, mpfr_srcptr x, mp_rnd_t rnd_mode)
{
mpfr_t uu;
mp_limb_t up[1];
unsigned long cnt;
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)) /* u/Inf = 0 */
{
MPFR_SET_ZERO(y);
MPFR_SET_SAME_SIGN(y,x);
MPFR_RET(0);
}
else /* u / 0 */
{
MPFR_ASSERTD(MPFR_IS_ZERO(x));
if (u)
{
/* u > 0, so y = sign(x) * Inf */
MPFR_SET_SAME_SIGN(y, x);
MPFR_SET_INF(y);
MPFR_RET(0);
}
else
{
/* 0 / 0 */
MPFR_SET_NAN(y);
MPFR_RET_NAN;
}
}
}
else if (MPFR_LIKELY(u != 0))
{
MPFR_TMP_INIT1(up, uu, BITS_PER_MP_LIMB);
MPFR_ASSERTN(u == (mp_limb_t) u);
count_leading_zeros(cnt, (mp_limb_t) u);
up[0] = (mp_limb_t) u << cnt;
MPFR_SET_EXP (uu, BITS_PER_MP_LIMB - cnt);
return mpfr_div (y, uu, x, rnd_mode);
}
else /* u = 0, and x != 0 */
{
MPFR_SET_ZERO(y); /* if u=0, then set y to 0 */
MPFR_SET_SAME_SIGN(y, x); /* u considered as +0: sign(+0/x) = sign(x) */
MPFR_RET(0);
}
}
int
mpfr_custom_get_kind (mpfr_srcptr x)
{
if (MPFR_LIKELY (!MPFR_IS_SINGULAR (x)))
return (int) MPFR_REGULAR_KIND * MPFR_INT_SIGN (x);
if (MPFR_IS_INF (x))
return (int) MPFR_INF_KIND * MPFR_INT_SIGN (x);
if (MPFR_IS_NAN (x))
return (int) MPFR_NAN_KIND;
MPFR_ASSERTD (MPFR_IS_ZERO (x));
return (int) MPFR_ZERO_KIND * MPFR_INT_SIGN (x);
}
int
mpfr_set_emax (mpfr_exp_t exponent)
{
if (MPFR_LIKELY (exponent >= MPFR_EMAX_MIN && exponent <= MPFR_EMAX_MAX))
{
__gmpfr_emax = exponent;
return 0;
}
else
{
return 1;
}
}
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;
}
}
/* special code for IEEE 754 little-endian extended format */
long double
mpfr_get_ld (mpfr_srcptr x, mpfr_rnd_t rnd_mode)
{
mpfr_long_double_t ld;
mpfr_t tmp;
int inex;
MPFR_SAVE_EXPO_DECL (expo);
MPFR_SAVE_EXPO_MARK (expo);
mpfr_init2 (tmp, MPFR_LDBL_MANT_DIG);
inex = mpfr_set (tmp, x, rnd_mode);
mpfr_set_emin (-16382-63);
mpfr_set_emax (16384);
mpfr_subnormalize (tmp, mpfr_check_range (tmp, inex, rnd_mode), rnd_mode);
mpfr_prec_round (tmp, 64, MPFR_RNDZ); /* exact */
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (tmp)))
ld.ld = (long double) mpfr_get_d (tmp, rnd_mode);
else
{
mp_limb_t *tmpmant;
mpfr_exp_t e, denorm;
tmpmant = MPFR_MANT (tmp);
e = MPFR_GET_EXP (tmp);
/* The smallest positive normal number is 2^(-16382), which is
0.5*2^(-16381) in MPFR, thus any exponent <= -16382 corresponds to a
subnormal number. The smallest positive subnormal number is 2^(-16445)
which is 0.5*2^(-16444) in MPFR thus 0 <= denorm <= 63. */
denorm = MPFR_UNLIKELY (e <= -16382) ? - e - 16382 + 1 : 0;
MPFR_ASSERTD (0 <= denorm && denorm < 64);
#if GMP_NUMB_BITS >= 64
ld.s.manl = (tmpmant[0] >> denorm);
ld.s.manh = (tmpmant[0] >> denorm) >> 32;
#elif GMP_NUMB_BITS == 32
if (MPFR_LIKELY (denorm == 0))
{
ld.s.manl = tmpmant[0];
ld.s.manh = tmpmant[1];
}
else if (denorm < 32)
{
ld.s.manl = (tmpmant[0] >> denorm) | (tmpmant[1] << (32 - denorm));
ld.s.manh = tmpmant[1] >> denorm;
}
else /* 32 <= denorm < 64 */
{
int
(mpfr_sgn) (mpfr_srcptr a)
{
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (a)))
{
if (MPFR_LIKELY (MPFR_IS_ZERO (a)))
return 0;
if (MPFR_UNLIKELY (MPFR_IS_NAN (a)))
{
MPFR_SET_ERANGEFLAG ();
return 0;
}
/* Remains infinity, handled by the return below. */
}
return MPFR_INT_SIGN (a);
}
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;
}
MPFR_HOT_FUNCTION_ATTR void
mpfr_mpz_init (mpz_t z)
{
if (MPFR_LIKELY (n_alloc > 0))
{
/* Get a mpz_t from the MPFR stack of previously used mpz_t.
It reduces memory pressure, and it allows to reuse
a mpz_t that should be sufficiently big. */
MPFR_ASSERTD (n_alloc <= numberof (mpz_tab));
memcpy (z, &mpz_tab[--n_alloc], sizeof (mpz_t));
SIZ(z) = 0;
}
else
{
/* Call the real GMP function */
mpz_init (z);
}
}
MPFR_HOT_FUNCTION_ATTR void
mpfr_mpz_clear (mpz_t z)
{
/* We only put objects with at most MPFR_POOL_MAX_SIZE in the mpz_t pool,
to avoid it takes too much memory (and anyway the speedup is mainly
for small precision). */
if (MPFR_LIKELY (n_alloc < numberof (mpz_tab) &&
ALLOC (z) <= MPFR_POOL_MAX_SIZE))
{
/* Push back the mpz_t inside the stack of the used mpz_t */
MPFR_ASSERTD (n_alloc >= 0);
memcpy (&mpz_tab[n_alloc++], z, sizeof (mpz_t));
}
else
{
/* Call the real GMP function */
mpz_clear (z);
}
}
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;
}
long double
mpfr_get_ld (mpfr_srcptr x, mp_rnd_t rnd_mode)
{
mpfr_long_double_t ld;
mpfr_t tmp;
MPFR_SAVE_EXPO_DECL (expo);
MPFR_SAVE_EXPO_MARK (expo);
mpfr_set_emin (-16382-63);
mpfr_set_emax (16383);
mpfr_init2 (tmp, MPFR_LDBL_MANT_DIG);
mpfr_subnormalize(tmp, mpfr_set (tmp, x, rnd_mode), rnd_mode);
mpfr_prec_round (tmp, 64, GMP_RNDZ); /* exact */
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (tmp)))
ld.ld = (long double) mpfr_get_d (tmp, rnd_mode);
else
{
mp_limb_t *tmpmant;
mp_exp_t e, denorm;
tmpmant = MPFR_MANT (tmp);
e = MPFR_GET_EXP (tmp);
denorm = MPFR_UNLIKELY (e < -16382) ? - e - 16382 + 1 : 0;
#if BITS_PER_MP_LIMB >= 64
ld.s.manl = (tmpmant[0] >> denorm);
ld.s.manh = (tmpmant[0] >> denorm) >> 32;
#elif BITS_PER_MP_LIMB == 32
if (MPFR_LIKELY (denorm == 0))
{
ld.s.manl = tmpmant[0];
ld.s.manh = tmpmant[1];
}
else if (denorm < 32)
{
ld.s.manl = (tmpmant[0] >> denorm) | (tmpmant[1] << (32 - denorm));
ld.s.manh = tmpmant[1] >> denorm;
}
else /* 32 <= denorm <= 64 */
{
mp_limb_t
mpfr_divhigh_n (mpfr_limb_ptr qp, mpfr_limb_ptr np, mpfr_limb_ptr dp,
mp_size_t n)
{
mp_size_t k, l;
mp_limb_t qh, cy;
mpfr_limb_ptr tp;
MPFR_TMP_DECL(marker);
MPFR_ASSERTN (MPFR_MULHIGH_TAB_SIZE >= 15); /* so that 2*(n/3) >= (n+4)/2 */
k = MPFR_LIKELY (n < MPFR_DIVHIGH_TAB_SIZE) ? divhigh_ktab[n] : 2*(n/3);
if (k == 0)
#if defined(WANT_GMP_INTERNALS) && defined(HAVE___GMPN_SBPI1_DIVAPPR_Q)
{
mpfr_pi1_t dinv2;
invert_pi1 (dinv2, dp[n - 1], dp[n - 2]);
return __gmpn_sbpi1_divappr_q (qp, np, n + n, dp, n, dinv2.inv32);
}
#else /* use our own code for base-case short division */
return mpfr_divhigh_n_basecase (qp, np, dp, n);
#endif
else if (k == n)