int main()
{
long iter;
flint_rand_t state;
printf("set_round_ui_2exp_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
long prec, ret1, ret2;
fmpz_t man, exp;
fmpr_t x, y;
mp_limb_t lo;
fmpr_rnd_t rnd;
int negative;
fmpz_init(man);
fmpz_init(exp);
fmpr_init(x);
fmpr_init(y);
prec = 2 + n_randint(state, 1000);
if (n_randint(state, 10) == 0)
prec = FMPR_PREC_EXACT;
negative = n_randint(state, 2);
lo = n_randtest(state);
fmpz_randtest(exp, state, 1 + n_randint(state, 100));
if (negative)
fmpz_neg_ui(man, lo);
else
fmpz_set_ui(man, lo);
switch (n_randint(state, 4))
{
case 0: rnd = FMPR_RND_DOWN; break;
case 1: rnd = FMPR_RND_UP; break;
case 2: rnd = FMPR_RND_FLOOR; break;
default: rnd = FMPR_RND_CEIL; break;
}
ret1 = fmpr_set_round_ui_2exp_fmpz(x, lo, exp, negative, prec, rnd);
fmpr_set_fmpz_2exp(y, man, exp);
ret2 = fmpr_set_round(y, y, prec, rnd);
if (!fmpr_equal(x, y) || ret1 != ret2 ||
!fmpr_check_ulp(x, ret1, prec) || !fmpr_check_ulp(y, ret2, prec))
{
printf("FAIL\n\n");
printf("prec: %ld\n", prec);
printf("man = "); fmpz_print(man); printf("\n\n");
printf("exp = "); fmpz_print(exp); printf("\n\n");
printf("x = "); fmpr_print(x); printf("\n\n");
printf("y = "); fmpr_print(y); printf("\n\n");
printf("ret1 = %ld, ret2 = %ld\n\n", ret1, ret2);
abort();
}
fmpz_clear(man);
fmpz_clear(exp);
fmpr_clear(x);
fmpr_clear(y);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
void
arf_get_fmpz(fmpz_t z, const arf_t x, arf_rnd_t rnd)
{
if (arf_is_special(x))
{
if (arf_is_zero(x))
{
fmpz_zero(z);
}
else
{
flint_printf("arf_get_fmpz: cannot convert infinity or nan to integer\n");
abort();
}
}
else if (COEFF_IS_MPZ(*ARF_EXPREF(x)))
{
/* tiny */
if (fmpz_sgn(ARF_EXPREF(x)) < 0)
{
int negative = ARF_SGNBIT(x);
if (rnd == ARF_RND_NEAR
|| rnd == ARF_RND_DOWN
|| (rnd == ARF_RND_FLOOR && !negative)
|| (rnd == ARF_RND_CEIL && negative))
{
fmpz_zero(z);
}
else
{
fmpz_set_si(z, negative ? -1 : 1);
}
}
else
{
flint_printf("arf_get_fmpz: number too large to convert to integer\n");
abort();
}
}
else
{
slong exp;
int negative, inexact;
mp_size_t xn, zn;
mp_srcptr xp;
__mpz_struct * zz;
/* TBD: implement efficiently */
if (rnd == ARF_RND_NEAR)
{
fmpr_t t;
fmpr_init(t);
arf_get_fmpr(t, x);
fmpr_get_fmpz(z, t, rnd);
fmpr_clear(t);
return;
}
exp = ARF_EXP(x);
negative = ARF_SGNBIT(x);
/* |x| < 1 */
if (exp <= 0)
{
if (rnd == ARF_RND_DOWN ||
(rnd == ARF_RND_FLOOR && !negative) ||
(rnd == ARF_RND_CEIL && negative))
{
fmpz_zero(z);
}
else
{
fmpz_set_si(z, negative ? -1 : 1);
}
return;
}
ARF_GET_MPN_READONLY(xp, xn, x);
/* |x| < 2^31 or 2^63 (must save 1 bit for rounding up!) */
if (exp < FLINT_BITS)
{
mp_limb_t v, v2;
v = xp[xn - 1];
v2 = v >> (FLINT_BITS - exp);
inexact = (xn > 1) || ((v2 << (FLINT_BITS - exp)) != v);
if (inexact && rnd != ARF_RND_DOWN)
{
if (negative && (rnd == ARF_RND_UP || rnd == ARF_RND_FLOOR))
v2++;
if (!negative && (rnd == ARF_RND_UP || rnd == ARF_RND_CEIL))
v2++;
}
if (negative)
fmpz_neg_ui(z, v2);
else
fmpz_set_ui(z, v2);
return;
}
/* |x| >= 1 */
zn = (exp + FLINT_BITS - 1) / FLINT_BITS;
zz = _fmpz_promote(z);
if (zz->_mp_alloc < zn)
mpz_realloc2(zz, zn * FLINT_BITS);
inexact = _arf_get_integer_mpn(zz->_mp_d, xp, xn, exp);
zz->_mp_size = negative ? -zn : zn;
_fmpz_demote_val(z);
if (inexact && rnd != ARF_RND_DOWN)
{
if (negative && (rnd == ARF_RND_UP || rnd == ARF_RND_FLOOR))
fmpz_sub_ui(z, z, 1);
if (!negative && (rnd == ARF_RND_UP || rnd == ARF_RND_CEIL))
fmpz_add_ui(z, z, 1);
}
}
int
_arb_get_mpn_fixed_mod_log2(mp_ptr w, fmpz_t q, mp_limb_t * error,
const arf_t x, mp_size_t wn)
{
mp_srcptr xp;
mp_size_t xn;
int negative;
long exp;
ARF_GET_MPN_READONLY(xp, xn, x);
exp = ARF_EXP(x);
negative = ARF_SGNBIT(x);
if (exp <= -1)
{
/* todo: just zero top */
flint_mpn_zero(w, wn);
*error = _arf_get_integer_mpn(w, xp, xn, exp + wn * FLINT_BITS);
if (!negative)
{
fmpz_zero(q);
}
else
{
if (wn > ARB_LOG_TAB2_LIMBS)
return 0;
mpn_sub_n(w, arb_log_log2_tab + ARB_LOG_TAB2_LIMBS - wn, w, wn);
*error += 1; /* log(2) has 1 ulp error */
fmpz_set_si(q, -1);
}
return 1; /* success */
}
else
{
mp_ptr qp, rp, np;
mp_srcptr dp;
mp_size_t qn, rn, nn, dn, tn, alloc;
TMP_INIT;
tn = ((exp + 2) + FLINT_BITS - 1) / FLINT_BITS;
dn = wn + tn; /* denominator */
nn = wn + 2 * tn; /* numerator */
qn = nn - dn + 1; /* quotient */
rn = dn; /* remainder */
if (dn > ARB_LOG_TAB2_LIMBS)
return 0;
TMP_START;
alloc = qn + rn + nn;
qp = TMP_ALLOC_LIMBS(alloc);
rp = qp + qn;
np = rp + rn;
dp = arb_log_log2_tab + ARB_LOG_TAB2_LIMBS - dn;
/* todo: prove that zeroing is unnecessary */
flint_mpn_zero(np, nn);
_arf_get_integer_mpn(np, xp, xn, exp + dn * FLINT_BITS);
mpn_tdiv_qr(qp, rp, 0, np, nn, dp, dn);
if (!negative)
{
flint_mpn_copyi(w, rp + tn, wn);
*error = 2;
}
else
{
if (mpn_add_1(qp, qp, qn, 1))
{
/* I believe this cannot happen (should prove it) */
printf("mod log(2): unexpected carry\n");
abort();
}
mpn_sub_n(w, dp + tn, rp + tn, wn);
*error = 3;
}
/* read the exponent */
while (qn > 1 && qp[qn-1] == 0)
qn--;
if (qn == 1)
{
if (!negative)
fmpz_set_ui(q, qp[0]);
else
fmpz_neg_ui(q, qp[0]);
}
else
{
fmpz_set_mpn_large(q, qp, qn, negative);
}
TMP_END;
return 1;
}
}
