void
arb_addmul_arf(arb_t z, const arb_t x, const arf_t y, slong prec)
{
mag_t ym;
int inexact;
if (arb_is_exact(x))
{
inexact = arf_addmul(arb_midref(z), arb_midref(x), y, prec, ARB_RND);
if (inexact)
arf_mag_add_ulp(arb_radref(z), arb_radref(z), arb_midref(z), prec);
}
else if (ARB_IS_LAGOM(x) && ARF_IS_LAGOM(y) && ARB_IS_LAGOM(z))
{
mag_fast_init_set_arf(ym, y);
mag_fast_addmul(arb_radref(z), ym, arb_radref(x));
inexact = arf_addmul(arb_midref(z), arb_midref(x), y, prec, ARB_RND);
if (inexact)
arf_mag_fast_add_ulp(arb_radref(z), arb_radref(z), arb_midref(z), prec);
}
else
{
mag_init_set_arf(ym, y);
mag_addmul(arb_radref(z), ym, arb_radref(x));
inexact = arf_addmul(arb_midref(z), arb_midref(x), y, prec, ARB_RND);
if (inexact)
arf_mag_add_ulp(arb_radref(z), arb_radref(z), arb_midref(z), prec);
mag_clear(ym);
}
}
static void
_arb_arf_div_rounded_den_add_err(arb_t res, const arf_t x, const arf_t y, int yinexact, slong prec)
{
int inexact = arf_div(arb_midref(res), x, y, prec, ARB_RND);
if (yinexact && !arf_is_special(arb_midref(res)))
arf_mag_add_ulp(arb_radref(res), arb_radref(res), arb_midref(res), prec - 1);
else if (inexact)
arf_mag_add_ulp(arb_radref(res), arb_radref(res), arb_midref(res), prec);
}
static void
_acb_mul_slow(acb_t z, const acb_t x, const acb_t y, slong prec)
{
int inexact;
mag_t am, bm, cm, dm, er, fr;
mag_init_set_arf(am, arb_midref(a));
mag_init_set_arf(bm, arb_midref(b));
mag_init_set_arf(cm, arb_midref(c));
mag_init_set_arf(dm, arb_midref(d));
mag_init(er);
mag_init(fr);
mag_addmul(er, am, cr);
mag_addmul(er, bm, dr);
mag_addmul(er, cm, ar);
mag_addmul(er, dm, br);
mag_addmul(er, ar, cr);
mag_addmul(er, br, dr);
mag_addmul(fr, am, dr);
mag_addmul(fr, bm, cr);
mag_addmul(fr, cm, br);
mag_addmul(fr, dm, ar);
mag_addmul(fr, br, cr);
mag_addmul(fr, ar, dr);
inexact = arf_complex_mul(arb_midref(e), arb_midref(f),
arb_midref(a), arb_midref(b),
arb_midref(c), arb_midref(d), prec, ARB_RND);
if (inexact & 1)
arf_mag_add_ulp(arb_radref(e), er, arb_midref(e), prec);
else
mag_swap(arb_radref(e), er);
if (inexact & 2)
arf_mag_add_ulp(arb_radref(f), fr, arb_midref(f), prec);
else
mag_swap(arb_radref(f), fr);
mag_clear(am);
mag_clear(bm);
mag_clear(cm);
mag_clear(dm);
mag_clear(er);
mag_clear(fr);
}
void arb_square(arb_t out, const arb_t in, slong prec) {
mag_mul(arb_radref(out), arb_radref(in), arb_radref(in));
int inexact = arf_mul(arb_midref(out), arb_midref(in), arb_midref(in), ARB_RND, prec);
if (inexact)
arf_mag_add_ulp(arb_radref(out), arb_radref(out), arb_midref(out), prec);
}
void
arb_set_interval_arf(arb_t x, const arf_t a, const arf_t b, slong prec)
{
arf_t t;
int inexact;
if (arf_is_inf(a) && arf_equal(a, b))
{
/* [-inf, -inf] or [+inf, +inf] */
arf_set(arb_midref(x), a);
mag_zero(arb_radref(x));
return;
}
arf_init(t);
arf_sub(t, b, a, MAG_BITS, ARF_RND_UP);
if (arf_sgn(t) < 0)
{
flint_printf("exception: arb_set_interval_arf: endpoints not ordered\n");
abort();
}
arf_get_mag(arb_radref(x), t);
inexact = arf_add(arb_midref(x), a, b, prec, ARB_RND);
if (inexact)
arf_mag_add_ulp(arb_radref(x), arb_radref(x), arb_midref(x), prec);
arb_mul_2exp_si(x, x, -1);
arf_clear(t);
}
static void
_acb_sqr_slow(acb_t z, const acb_t x, slong prec)
{
int inexact;
mag_t am, bm, er, fr;
mag_init_set_arf(am, arb_midref(a));
mag_init_set_arf(bm, arb_midref(b));
mag_init(er);
mag_init(fr);
mag_addmul(er, am, ar);
mag_addmul(er, bm, br);
mag_mul_2exp_si(er, er, 1);
mag_addmul(er, ar, ar);
mag_addmul(er, br, br);
mag_addmul(fr, bm, ar);
mag_addmul(fr, am, br);
mag_addmul(fr, ar, br);
mag_mul_2exp_si(fr, fr, 1);
inexact = arf_complex_sqr(arb_midref(e), arb_midref(f),
arb_midref(a), arb_midref(b), prec, ARB_RND);
if (inexact & 1)
arf_mag_add_ulp(arb_radref(e), er, arb_midref(e), prec);
else
mag_swap(arb_radref(e), er);
if (inexact & 2)
arf_mag_add_ulp(arb_radref(f), fr, arb_midref(f), prec);
else
mag_swap(arb_radref(f), fr);
mag_clear(am);
mag_clear(bm);
mag_clear(er);
mag_clear(fr);
}
void
arb_sub_fmpz(arb_t z, const arb_t x, const fmpz_t y, slong prec)
{
int inexact;
inexact = arf_sub_fmpz(arb_midref(z), arb_midref(x), y, prec, ARB_RND);
if (inexact)
arf_mag_add_ulp(arb_radref(z), arb_radref(x), arb_midref(z), prec);
else
mag_set(arb_radref(z), arb_radref(x));
}
void
arb_addmul(arb_t z, const arb_t x, const arb_t y, slong prec)
{
mag_t zr, xm, ym;
int inexact;
if (arb_is_exact(y))
{
arb_addmul_arf(z, x, arb_midref(y), prec);
}
else if (arb_is_exact(x))
{
arb_addmul_arf(z, y, arb_midref(x), prec);
}
else if (ARB_IS_LAGOM(x) && ARB_IS_LAGOM(y) && ARB_IS_LAGOM(z))
{
mag_fast_init_set_arf(xm, arb_midref(x));
mag_fast_init_set_arf(ym, arb_midref(y));
mag_fast_init_set(zr, arb_radref(z));
mag_fast_addmul(zr, xm, arb_radref(y));
mag_fast_addmul(zr, ym, arb_radref(x));
mag_fast_addmul(zr, arb_radref(x), arb_radref(y));
inexact = arf_addmul(arb_midref(z), arb_midref(x), arb_midref(y),
prec, ARF_RND_DOWN);
if (inexact)
arf_mag_fast_add_ulp(zr, zr, arb_midref(z), prec);
*arb_radref(z) = *zr;
}
else
{
mag_init_set_arf(xm, arb_midref(x));
mag_init_set_arf(ym, arb_midref(y));
mag_init_set(zr, arb_radref(z));
mag_addmul(zr, xm, arb_radref(y));
mag_addmul(zr, ym, arb_radref(x));
mag_addmul(zr, arb_radref(x), arb_radref(y));
inexact = arf_addmul(arb_midref(z), arb_midref(x), arb_midref(y),
prec, ARF_RND_DOWN);
if (inexact)
arf_mag_add_ulp(arb_radref(z), zr, arb_midref(z), prec);
else
mag_set(arb_radref(z), zr);
mag_clear(zr);
mag_clear(xm);
mag_clear(ym);
}
}
void
arb_sub(arb_t z, const arb_t x, const arb_t y, slong prec)
{
int inexact;
inexact = arf_sub(arb_midref(z), arb_midref(x), arb_midref(y), prec, ARB_RND);
mag_add(arb_radref(z), arb_radref(x), arb_radref(y));
if (inexact)
arf_mag_add_ulp(arb_radref(z), arb_radref(z), arb_midref(z), prec);
}
void
arb_div(arb_t z, const arb_t x, const arb_t y, long prec)
{
mag_t zr, xm, ym, yl, yw;
int inexact;
if (arb_is_exact(y))
{
arb_div_arf(z, x, arb_midref(y), prec);
}
else if (mag_is_inf(arb_radref(x)) || mag_is_inf(arb_radref(y)))
{
arf_div(arb_midref(z), arb_midref(x), arb_midref(y), prec, ARB_RND);
mag_inf(arb_radref(z));
}
else
{
mag_init_set_arf(xm, arb_midref(x));
mag_init_set_arf(ym, arb_midref(y));
mag_init(zr);
mag_init(yl);
mag_init(yw);
/* (|x|*yrad + |y|*xrad)/(y*(|y|-yrad)) */
mag_mul(zr, xm, arb_radref(y));
mag_addmul(zr, ym, arb_radref(x));
arb_get_mag_lower(yw, y);
arf_get_mag_lower(yl, arb_midref(y));
mag_mul_lower(yl, yl, yw);
mag_div(zr, zr, yl);
inexact = arf_div(arb_midref(z), arb_midref(x), arb_midref(y), prec, ARB_RND);
if (inexact)
arf_mag_add_ulp(arb_radref(z), zr, arb_midref(z), prec);
else
mag_swap(arb_radref(z), zr);
mag_clear(xm);
mag_clear(ym);
mag_clear(zr);
mag_clear(yl);
mag_clear(yw);
}
}
void
arb_div_arf(arb_t z, const arb_t x, const arf_t y, long prec)
{
mag_t zr, ym;
int inexact;
if (arf_is_zero(y))
{
arb_zero_pm_inf(z);
}
else if (arb_is_exact(x))
{
inexact = arf_div(arb_midref(z), arb_midref(x), y, prec, ARB_RND);
if (inexact)
arf_mag_set_ulp(arb_radref(z), arb_midref(z), prec);
else
mag_zero(arb_radref(z));
}
else if (mag_is_inf(arb_radref(x)))
{
arf_div(arb_midref(z), arb_midref(x), y, prec, ARB_RND);
mag_inf(arb_radref(z));
}
else
{
mag_init(ym);
mag_init(zr);
arf_get_mag_lower(ym, y);
mag_div(zr, arb_radref(x), ym);
inexact = arf_div(arb_midref(z), arb_midref(x), y, prec, ARB_RND);
if (inexact)
arf_mag_add_ulp(arb_radref(z), zr, arb_midref(z), prec);
else
mag_swap(arb_radref(z), zr);
mag_clear(ym);
mag_clear(zr);
}
}
void
arb_atan_arf(arb_t z, const arf_t x, slong prec)
{
if (arf_is_special(x))
{
if (arf_is_zero(x))
{
arb_zero(z);
}
else if (arf_is_pos_inf(x))
{
arb_const_pi(z, prec);
arb_mul_2exp_si(z, z, -1);
}
else if (arf_is_neg_inf(x))
{
arb_const_pi(z, prec);
arb_mul_2exp_si(z, z, -1);
arb_neg(z, z);
}
else
{
arb_indeterminate(z);
}
}
else if (COEFF_IS_MPZ(*ARF_EXPREF(x)))
{
if (fmpz_sgn(ARF_EXPREF(x)) < 0)
arb_atan_eps(z, x, prec);
else
arb_atan_inf_eps(z, x, prec);
}
else
{
slong exp, wp, wn, N, r;
mp_srcptr xp;
mp_size_t xn, tn;
mp_ptr tmp, w, t, u;
mp_limb_t p1, q1bits, p2, q2bits, error, error2;
int negative, inexact, reciprocal;
TMP_INIT;
exp = ARF_EXP(x);
negative = ARF_SGNBIT(x);
if (exp < -(prec/2) - 2 || exp > prec + 2)
{
if (exp < 0)
arb_atan_eps(z, x, prec);
else
arb_atan_inf_eps(z, x, prec);
return;
}
ARF_GET_MPN_READONLY(xp, xn, x);
/* Special case: +/- 1 (we require |x| != 1 later on) */
if (exp == 1 && xn == 1 && xp[xn-1] == LIMB_TOP)
{
arb_const_pi(z, prec);
arb_mul_2exp_si(z, z, -2);
if (negative)
arb_neg(z, z);
return;
}
/* Absolute working precision (NOT rounded to a limb multiple) */
wp = prec - FLINT_MIN(0, exp) + 4;
/* Too high precision to use table */
if (wp > ARB_ATAN_TAB2_PREC)
{
arb_atan_arf_bb(z, x, prec);
return;
}
/* Working precision in limbs */
wn = (wp + FLINT_BITS - 1) / FLINT_BITS;
TMP_START;
tmp = TMP_ALLOC_LIMBS(4 * wn + 3);
w = tmp; /* requires wn+1 limbs */
t = w + wn + 1; /* requires wn+1 limbs */
u = t + wn + 1; /* requires 2wn+1 limbs */
/* ----------------------------------------------------------------- */
/* Convert x or 1/x to a fixed-point number |w| < 1 */
/* ----------------------------------------------------------------- */
if (exp <= 0) /* |x| < 1 */
{
reciprocal = 0;
/* todo: just zero top */
flint_mpn_zero(w, wn);
/* w = x as a fixed-point number */
error = _arf_get_integer_mpn(w, xp, xn, exp + wn * FLINT_BITS);
}
else /* |x| > 1 */
{
slong one_exp, one_limbs, one_bits;
mp_ptr one;
reciprocal = 1;
one_exp = xn * FLINT_BITS + wn * FLINT_BITS - exp;
flint_mpn_zero(w, wn);
/* 1/x becomes zero */
if (one_exp >= FLINT_BITS - 1)
{
/* w = 1/x */
one_limbs = one_exp / FLINT_BITS;
one_bits = one_exp % FLINT_BITS;
if (one_limbs + 1 >= xn)
{
one = TMP_ALLOC_LIMBS(one_limbs + 1);
flint_mpn_zero(one, one_limbs);
one[one_limbs] = UWORD(1) << one_bits;
/* todo: only zero necessary part */
flint_mpn_zero(w, wn);
mpn_tdiv_q(w, one, one_limbs + 1, xp, xn);
/* Now w must be < 1 since x > 1 and we rounded down; thus
w[wn] must be zero */
}
}
/* todo: moderate powers of two would be exact... */
error = 1;
}
/* ----------------------------------------------------------------- */
/* Table-based argument reduction */
/* ----------------------------------------------------------------- */
/* choose p such that p/q <= x < (p+1)/q */
if (wp <= ARB_ATAN_TAB1_PREC)
q1bits = ARB_ATAN_TAB1_BITS;
else
q1bits = ARB_ATAN_TAB21_BITS;
p1 = w[wn-1] >> (FLINT_BITS - q1bits);
/* atan(w) = atan(p/q) + atan(w2) */
/* where w2 = (q*w-p)/(q+p*w) */
if (p1 != 0)
{
t[wn] = (UWORD(1) << q1bits) + mpn_mul_1(t, w, wn, p1);
flint_mpn_zero(u, wn);
u[2 * wn] = mpn_lshift(u + wn, w, wn, q1bits) - p1;
mpn_tdiv_q(w, u, 2 * wn + 1, t, wn + 1);
error++; /* w2 is computed with 1 ulp error */
}
/* Do a second round of argument reduction */
if (wp <= ARB_ATAN_TAB1_PREC)
{
p2 = 0;
}
else
{
q2bits = ARB_ATAN_TAB21_BITS + ARB_ATAN_TAB22_BITS;
p2 = w[wn-1] >> (FLINT_BITS - q2bits);
if (p2 != 0)
{
t[wn] = (UWORD(1) << q2bits) + mpn_mul_1(t, w, wn, p2);
flint_mpn_zero(u, wn);
u[2 * wn] = mpn_lshift(u + wn, w, wn, q2bits) - p2;
mpn_tdiv_q(w, u, 2 * wn + 1, t, wn + 1);
error++;
}
}
/* |w| <= 2^-r */
r = _arb_mpn_leading_zeros(w, wn);
/* N >= (wp-r)/(2r) */
N = (wp - r + (2*r-1)) / (2*r);
/* Evaluate Taylor series */
_arb_atan_taylor_rs(t, &error2, w, wn, N, 1);
/* Taylor series evaluation error */
error += error2;
/* Size of output number */
tn = wn;
/* First table lookup */
if (p1 != 0)
{
if (wp <= ARB_ATAN_TAB1_PREC)
mpn_add_n(t, t, arb_atan_tab1[p1] + ARB_ATAN_TAB1_LIMBS - tn, tn);
else
mpn_add_n(t, t, arb_atan_tab21[p1] + ARB_ATAN_TAB2_LIMBS - tn, tn);
error++;
}
/* Second table lookup */
if (p2 != 0)
{
mpn_add_n(t, t, arb_atan_tab22[p2] + ARB_ATAN_TAB2_LIMBS - tn, tn);
error++;
}
/* pi/2 - atan(1/x) */
if (reciprocal)
{
t[tn] = LIMB_ONE - mpn_sub_n(t,
arb_atan_pi2_minus_one + ARB_ATAN_TAB2_LIMBS - tn, t, tn);
/* result can be >= 1 */
tn += (t[tn] != 0);
/* error of pi/2 */
error++;
}
/* The accumulated arithmetic error */
mag_set_ui_2exp_si(arb_radref(z), error, -wn * FLINT_BITS);
/* Truncation error from the Taylor series */
mag_add_ui_2exp_si(arb_radref(z), arb_radref(z), 1, -r*(2*N+1));
/* Set the midpoint */
inexact = _arf_set_mpn_fixed(arb_midref(z), t, tn, wn, negative, prec, ARB_RND);
if (inexact)
arf_mag_add_ulp(arb_radref(z), arb_radref(z), arb_midref(z), prec);
TMP_END;
}
}
void
arb_log_arf(arb_t z, const arf_t x, slong prec)
{
if (arf_is_special(x))
{
if (arf_is_pos_inf(x))
arb_pos_inf(z);
else
arb_indeterminate(z);
}
else if (ARF_SGNBIT(x))
{
arb_indeterminate(z);
}
else if (ARF_IS_POW2(x))
{
if (fmpz_is_one(ARF_EXPREF(x)))
{
arb_zero(z);
}
else
{
fmpz_t exp;
fmpz_init(exp);
_fmpz_add_fast(exp, ARF_EXPREF(x), -1);
arb_const_log2(z, prec + 2);
arb_mul_fmpz(z, z, exp, prec);
fmpz_clear(exp);
}
}
else if (COEFF_IS_MPZ(*ARF_EXPREF(x)))
{
arb_log_arf_huge(z, x, prec);
}
else
{
slong exp, wp, wn, N, r, closeness_to_one;
mp_srcptr xp;
mp_size_t xn, tn;
mp_ptr tmp, w, t, u;
mp_limb_t p1, q1bits, p2, q2bits, error, error2, cy;
int negative, inexact, used_taylor_series;
TMP_INIT;
exp = ARF_EXP(x);
negative = 0;
ARF_GET_MPN_READONLY(xp, xn, x);
/* compute a c >= 0 such that |x-1| <= 2^(-c) if c > 0 */
closeness_to_one = 0;
if (exp == 0)
{
slong i;
closeness_to_one = FLINT_BITS - FLINT_BIT_COUNT(~xp[xn - 1]);
if (closeness_to_one == FLINT_BITS)
{
for (i = xn - 2; i > 0 && xp[i] == LIMB_ONES; i--)
closeness_to_one += FLINT_BITS;
closeness_to_one += (FLINT_BITS - FLINT_BIT_COUNT(~xp[i]));
}
}
else if (exp == 1)
{
closeness_to_one = FLINT_BITS - FLINT_BIT_COUNT(xp[xn - 1] & (~LIMB_TOP));
if (closeness_to_one == FLINT_BITS)
{
slong i;
for (i = xn - 2; xp[i] == 0; i--)
closeness_to_one += FLINT_BITS;
closeness_to_one += (FLINT_BITS - FLINT_BIT_COUNT(xp[i]));
}
closeness_to_one--;
}
/* if |t-1| <= 0.5 */
/* |log(1+t) - t| <= t^2 */
/* |log(1+t) - (t-t^2/2)| <= t^3 */
if (closeness_to_one > prec + 1)
{
inexact = arf_sub_ui(arb_midref(z), x, 1, prec, ARB_RND);
mag_set_ui_2exp_si(arb_radref(z), 1, -2 * closeness_to_one);
if (inexact)
arf_mag_add_ulp(arb_radref(z), arb_radref(z), arb_midref(z), prec);
return;
}
else if (2 * closeness_to_one > prec + 1)
{
arf_t t, u;
arf_init(t);
arf_init(u);
arf_sub_ui(t, x, 1, ARF_PREC_EXACT, ARF_RND_DOWN);
arf_mul(u, t, t, ARF_PREC_EXACT, ARF_RND_DOWN);
arf_mul_2exp_si(u, u, -1);
inexact = arf_sub(arb_midref(z), t, u, prec, ARB_RND);
mag_set_ui_2exp_si(arb_radref(z), 1, -3 * closeness_to_one);
if (inexact)
arf_mag_add_ulp(arb_radref(z), arb_radref(z), arb_midref(z), prec);
arf_clear(t);
arf_clear(u);
return;
}
/* Absolute working precision (NOT rounded to a limb multiple) */
wp = prec + closeness_to_one + 5;
/* Too high precision to use table */
if (wp > ARB_LOG_TAB2_PREC)
{
arf_log_via_mpfr(arb_midref(z), x, prec, ARB_RND);
arf_mag_set_ulp(arb_radref(z), arb_midref(z), prec);
return;
}
/* Working precision in limbs */
wn = (wp + FLINT_BITS - 1) / FLINT_BITS;
TMP_START;
tmp = TMP_ALLOC_LIMBS(4 * wn + 3);
w = tmp; /* requires wn+1 limbs */
t = w + wn + 1; /* requires wn+1 limbs */
u = t + wn + 1; /* requires 2wn+1 limbs */
/* read x-1 */
if (xn <= wn)
{
flint_mpn_zero(w, wn - xn);
mpn_lshift(w + wn - xn, xp, xn, 1);
error = 0;
}
else
{
mpn_lshift(w, xp + xn - wn, wn, 1);
error = 1;
}
/* First table-based argument reduction */
if (wp <= ARB_LOG_TAB1_PREC)
q1bits = ARB_LOG_TAB11_BITS;
else
q1bits = ARB_LOG_TAB21_BITS;
p1 = w[wn-1] >> (FLINT_BITS - q1bits);
/* Special case: covers logarithms of small integers */
if (xn == 1 && (w[wn-1] == (p1 << (FLINT_BITS - q1bits))))
{
p2 = 0;
flint_mpn_zero(t, wn);
used_taylor_series = 0;
N = r = 0; /* silence compiler warning */
}
else
{
/* log(1+w) = log(1+p/q) + log(1 + (qw-p)/(p+q)) */
w[wn] = mpn_mul_1(w, w, wn, UWORD(1) << q1bits) - p1;
mpn_divrem_1(w, 0, w, wn + 1, p1 + (UWORD(1) << q1bits));
error += 1;
/* Second table-based argument reduction (fused with log->atanh
conversion) */
if (wp <= ARB_LOG_TAB1_PREC)
q2bits = ARB_LOG_TAB11_BITS + ARB_LOG_TAB12_BITS;
else
q2bits = ARB_LOG_TAB21_BITS + ARB_LOG_TAB22_BITS;
p2 = w[wn-1] >> (FLINT_BITS - q2bits);
u[2 * wn] = mpn_lshift(u + wn, w, wn, q2bits);
flint_mpn_zero(u, wn);
flint_mpn_copyi(t, u + wn, wn + 1);
t[wn] += p2 + (UWORD(1) << (q2bits + 1));
u[2 * wn] -= p2;
mpn_tdiv_q(w, u, 2 * wn + 1, t, wn + 1);
/* propagated error from 1 ulp error: 2 atanh'(1/3) = 2.25 */
error += 3;
/* |w| <= 2^-r */
r = _arb_mpn_leading_zeros(w, wn);
/* N >= (wp-r)/(2r) */
N = (wp - r + (2*r-1)) / (2*r);
N = FLINT_MAX(N, 0);
/* Evaluate Taylor series */
_arb_atan_taylor_rs(t, &error2, w, wn, N, 0);
/* Multiply by 2 */
mpn_lshift(t, t, wn, 1);
/* Taylor series evaluation error (multiply by 2) */
error += error2 * 2;
used_taylor_series = 1;
}
/* Size of output number */
tn = wn;
/* First table lookup */
if (p1 != 0)
{
if (wp <= ARB_LOG_TAB1_PREC)
mpn_add_n(t, t, arb_log_tab11[p1] + ARB_LOG_TAB1_LIMBS - tn, tn);
else
mpn_add_n(t, t, arb_log_tab21[p1] + ARB_LOG_TAB2_LIMBS - tn, tn);
error++;
}
/* Second table lookup */
if (p2 != 0)
{
if (wp <= ARB_LOG_TAB1_PREC)
mpn_add_n(t, t, arb_log_tab12[p2] + ARB_LOG_TAB1_LIMBS - tn, tn);
else
mpn_add_n(t, t, arb_log_tab22[p2] + ARB_LOG_TAB2_LIMBS - tn, tn);
error++;
}
/* add exp * log(2) */
exp--;
if (exp > 0)
{
cy = mpn_addmul_1(t, arb_log_log2_tab + ARB_LOG_TAB2_LIMBS - tn, tn, exp);
t[tn] = cy;
tn += (cy != 0);
error += exp;
}
else if (exp < 0)
{
t[tn] = 0;
u[tn] = mpn_mul_1(u, arb_log_log2_tab + ARB_LOG_TAB2_LIMBS - tn, tn, -exp);
if (mpn_cmp(t, u, tn + 1) >= 0)
{
mpn_sub_n(t, t, u, tn + 1);
}
else
{
mpn_sub_n(t, u, t, tn + 1);
negative = 1;
}
error += (-exp);
tn += (t[tn] != 0);
}
/* The accumulated arithmetic error */
mag_set_ui_2exp_si(arb_radref(z), error, -wn * FLINT_BITS);
/* Truncation error from the Taylor series */
if (used_taylor_series)
mag_add_ui_2exp_si(arb_radref(z), arb_radref(z), 1, -r*(2*N+1) + 1);
/* Set the midpoint */
inexact = _arf_set_mpn_fixed(arb_midref(z), t, tn, wn, negative, prec);
if (inexact)
arf_mag_add_ulp(arb_radref(z), arb_radref(z), arb_midref(z), prec);
TMP_END;
}
}
