int
arf_add(arf_ptr z, arf_srcptr x, arf_srcptr y, slong prec, arf_rnd_t rnd)
{
mp_size_t xn, yn;
mp_srcptr xptr, yptr;
slong shift;
if (arf_is_special(x) || arf_is_special(y))
{
return arf_add_special(z, x, y, prec, rnd);
}
shift = _fmpz_sub_small(ARF_EXPREF(x), ARF_EXPREF(y));
if (shift < 0)
{
arf_srcptr __t;
__t = x; x = y; y = __t;
shift = -shift;
}
ARF_GET_MPN_READONLY(xptr, xn, x);
ARF_GET_MPN_READONLY(yptr, yn, y);
return _arf_add_mpn(z, xptr, xn, ARF_SGNBIT(x), ARF_EXPREF(x),
yptr, yn, ARF_SGNBIT(y), shift, prec, rnd);
}
int
arf_set_round(arf_t y, const arf_t x, slong prec, arf_rnd_t rnd)
{
if (arf_is_special(x))
{
arf_set(y, x);
return 0;
}
else
{
int inexact;
slong fix;
mp_size_t xn;
mp_srcptr xptr;
if (y == x)
{
mp_ptr xtmp;
TMP_INIT;
ARF_GET_MPN_READONLY(xptr, xn, x);
/* exact */
if (xn * FLINT_BITS <= prec)
return 0;
if ((xn - 1) * FLINT_BITS < prec)
{
/* exact */
if ((xptr[0] << (prec - (xn-1) * FLINT_BITS)) == 0)
return 0;
}
/* inexact */
TMP_START;
xtmp = TMP_ALLOC(xn * sizeof(mp_limb_t));
flint_mpn_copyi(xtmp, xptr, xn);
inexact = _arf_set_round_mpn(y, &fix, xtmp, xn, ARF_SGNBIT(x), prec, rnd);
_fmpz_add_fast(ARF_EXPREF(y), ARF_EXPREF(x), fix);
TMP_END;
return inexact;
}
else
{
ARF_GET_MPN_READONLY(xptr, xn, x);
inexact = _arf_set_round_mpn(y, &fix, xptr, xn,
ARF_SGNBIT(x), prec, rnd);
_fmpz_add_fast(ARF_EXPREF(y), ARF_EXPREF(x), fix);
return inexact;
}
}
}
int
arf_cmpabs(const arf_t x, const arf_t y)
{
int ec, mc;
mp_size_t xn, yn;
mp_srcptr xp, yp;
if (arf_is_special(x) || arf_is_special(y))
{
if (arf_equal(x, y))
return 0;
if (arf_is_nan(x) || arf_is_nan(y))
return 0;
if (arf_is_zero(x)) return -1;
if (arf_is_zero(y)) return 1;
if (arf_is_inf(x)) return arf_is_inf(y) ? 0 : 1;
if (arf_is_inf(y)) return -1;
return -1;
}
ec = fmpz_cmp(ARF_EXPREF(x), ARF_EXPREF(y));
if (ec != 0)
return (ec < 0) ? -1 : 1;
ARF_GET_MPN_READONLY(xp, xn, x);
ARF_GET_MPN_READONLY(yp, yn, y);
if (xn >= yn)
mc = mpn_cmp(xp + xn - yn, yp, yn);
else
mc = mpn_cmp(xp, yp + yn - xn, xn);
if (mc != 0)
return (mc < 0) ? -1 : 1;
if (xn != yn)
return (xn < yn) ? -1 : 1;
return 0;
}
int
arf_sub_si(arf_ptr z, arf_srcptr x, slong y, slong prec, arf_rnd_t rnd)
{
mp_size_t xn, yn;
mp_srcptr xptr, yptr;
mp_limb_t ytmp;
int xsgnbit, ysgnbit;
fmpz yexp;
slong shift;
if (y == 0)
{
return arf_set_round(z, x, prec, rnd);
}
else if (arf_is_special(x))
{
if (arf_is_zero(x))
{
arf_set_si(z, y);
return arf_neg_round(z, z, prec, rnd);
}
else
{
arf_set(z, x);
return 0;
}
}
ysgnbit = (y < 0);
if (ysgnbit)
ytmp = -y;
else
ytmp = y;
yptr = &ytmp;
yn = 1;
yexp = FLINT_BITS;
ysgnbit ^= 1;
shift = _fmpz_sub_small(ARF_EXPREF(x), &yexp);
xsgnbit = ARF_SGNBIT(x);
ARF_GET_MPN_READONLY(xptr, xn, x);
if (shift >= 0)
return _arf_add_mpn(z, xptr, xn, xsgnbit, ARF_EXPREF(x),
yptr, yn, ysgnbit, shift, prec, rnd);
else
return _arf_add_mpn(z, yptr, yn, ysgnbit, &yexp,
xptr, xn, xsgnbit, -shift, prec, rnd);
}
int
arf_sub(arf_ptr z, arf_srcptr x, arf_srcptr y, slong prec, arf_rnd_t rnd)
{
mp_size_t xn, yn;
mp_srcptr xptr, yptr;
slong shift;
if (arf_is_special(x) || arf_is_special(y))
{
return arf_sub_special(z, x, y, prec, rnd);
}
shift = _fmpz_sub_small(ARF_EXPREF(x), ARF_EXPREF(y));
ARF_GET_MPN_READONLY(xptr, xn, x);
ARF_GET_MPN_READONLY(yptr, yn, y);
if (shift >= 0)
return _arf_add_mpn(z, xptr, xn, ARF_SGNBIT(x), ARF_EXPREF(x),
yptr, yn, ARF_SGNBIT(y) ^ 1, shift, prec, rnd);
else
return _arf_add_mpn(z, yptr, yn, ARF_SGNBIT(y) ^ 1, ARF_EXPREF(y),
xptr, xn, ARF_SGNBIT(x), -shift, prec, rnd);
}
int
arf_add_fmpz_2exp(arf_ptr z, arf_srcptr x, const fmpz_t y, const fmpz_t exp, slong prec, arf_rnd_t rnd)
{
mp_size_t xn, yn;
mp_srcptr xptr, yptr;
mp_limb_t ytmp;
int xsgnbit, ysgnbit, inexact;
fmpz_t yexp;
slong shift;
if (fmpz_is_zero(y))
{
return arf_set_round(z, x, prec, rnd);
}
else if (arf_is_special(x))
{
if (arf_is_zero(x))
{
inexact = arf_set_round_fmpz(z, y, prec, rnd);
arf_mul_2exp_fmpz(z, z, exp);
return inexact;
}
else
{
arf_set(z, x);
return 0;
}
}
FMPZ_GET_MPN_READONLY(ysgnbit, yn, yptr, ytmp, *y)
fmpz_init(yexp);
fmpz_add_ui(yexp, exp, yn * FLINT_BITS);
shift = _fmpz_sub_small(ARF_EXPREF(x), yexp);
xsgnbit = ARF_SGNBIT(x);
ARF_GET_MPN_READONLY(xptr, xn, x);
if (shift >= 0)
inexact = _arf_add_mpn(z, xptr, xn, xsgnbit, ARF_EXPREF(x),
yptr, yn, ysgnbit, shift, prec, rnd);
else
inexact = _arf_add_mpn(z, yptr, yn, ysgnbit, yexp,
xptr, xn, xsgnbit, -shift, prec, rnd);
fmpz_clear(yexp);
return inexact;
}
int
arf_sub_fmpz(arf_ptr z, arf_srcptr x, const fmpz_t y, slong prec, arf_rnd_t rnd)
{
mp_size_t xn, yn;
mp_srcptr xptr, yptr;
mp_limb_t ytmp;
int xsgnbit, ysgnbit;
fmpz yexp;
slong shift;
if (fmpz_is_zero(y))
{
return arf_set_round(z, x, prec, rnd);
}
else if (arf_is_special(x))
{
if (arf_is_zero(x))
{
arf_set_fmpz(z, y);
return arf_neg_round(z, z, prec, rnd);
}
else
{
arf_set(z, x);
return 0;
}
}
FMPZ_GET_MPN_READONLY(ysgnbit, yn, yptr, ytmp, *y)
yexp = yn * FLINT_BITS;
shift = _fmpz_sub_small(ARF_EXPREF(x), &yexp);
ysgnbit ^= 1;
xsgnbit = ARF_SGNBIT(x);
ARF_GET_MPN_READONLY(xptr, xn, x);
if (shift >= 0)
return _arf_add_mpn(z, xptr, xn, xsgnbit, ARF_EXPREF(x),
yptr, yn, ysgnbit, shift, prec, rnd);
else
return _arf_add_mpn(z, yptr, yn, ysgnbit, &yexp,
xptr, xn, xsgnbit, -shift, prec, rnd);
}
/* requires x != 1 */
static void
arf_log_via_mpfr(arf_t z, const arf_t x, slong prec, arf_rnd_t rnd)
{
mpfr_t xf, zf;
mp_ptr zptr, tmp;
mp_srcptr xptr;
mp_size_t xn, zn, val;
TMP_INIT;
TMP_START;
zn = (prec + FLINT_BITS - 1) / FLINT_BITS;
tmp = TMP_ALLOC(zn * sizeof(mp_limb_t));
ARF_GET_MPN_READONLY(xptr, xn, x);
xf->_mpfr_d = (mp_ptr) xptr;
xf->_mpfr_prec = xn * FLINT_BITS;
xf->_mpfr_sign = ARF_SGNBIT(x) ? -1 : 1;
xf->_mpfr_exp = ARF_EXP(x);
zf->_mpfr_d = tmp;
zf->_mpfr_prec = prec;
zf->_mpfr_sign = 1;
zf->_mpfr_exp = 0;
mpfr_set_emin(MPFR_EMIN_MIN);
mpfr_set_emax(MPFR_EMAX_MAX);
mpfr_log(zf, xf, arf_rnd_to_mpfr(rnd));
val = 0;
while (tmp[val] == 0)
val++;
ARF_GET_MPN_WRITE(zptr, zn - val, z);
flint_mpn_copyi(zptr, tmp + val, zn - val);
if (zf->_mpfr_sign < 0)
ARF_NEG(z);
fmpz_set_si(ARF_EXPREF(z), zf->_mpfr_exp);
TMP_END;
}
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
arf_submul_mpz(arf_ptr z, arf_srcptr x, const mpz_t y, slong prec, arf_rnd_t rnd)
{
mp_size_t xn, yn, zn, tn, alloc;
mp_srcptr xptr, yptr, zptr;
mp_ptr tptr, tptr2;
fmpz_t texp, yexp;
slong shift;
int tsgnbit, ysgnbit, inexact;
ARF_MUL_TMP_DECL
yn = FLINT_ABS(y->_mp_size);
if (arf_is_special(x) || yn == 0 || arf_is_special(z))
{
if (arf_is_zero(z))
{
/* TODO: make more efficient */
arf_mul_mpz(z, x, y, ARF_PREC_EXACT, rnd);
return arf_neg_round(z, z, prec, rnd);
}
else if (arf_is_finite(x))
{
return arf_set_round(z, z, prec, rnd);
}
else
{
/* todo: speed up */
arf_t t;
arf_init(t);
arf_mul_mpz(t, x, y, ARF_PREC_EXACT, ARF_RND_DOWN);
inexact = arf_sub(z, z, t, prec, rnd);
arf_clear(t);
return inexact;
}
}
ARF_GET_MPN_READONLY(xptr, xn, x);
yptr = y->_mp_d;
ysgnbit = (y->_mp_size > 0);
*yexp = yn * FLINT_BITS;
ARF_GET_MPN_READONLY(zptr, zn, z);
fmpz_init(texp);
tsgnbit = ARF_SGNBIT(x) ^ ysgnbit;
alloc = tn = xn + yn;
ARF_MUL_TMP_ALLOC(tptr2, alloc)
tptr = tptr2;
ARF_MPN_MUL(tptr, xptr, xn, yptr, yn);
shift = (tptr[tn - 1] == 0) * FLINT_BITS;
tn -= (tptr[tn - 1] == 0);
_fmpz_add2_fast(texp, ARF_EXPREF(x), yexp, -shift);
shift = _fmpz_sub_small(ARF_EXPREF(z), texp);
if (shift >= 0)
inexact = _arf_add_mpn(z, zptr, zn, ARF_SGNBIT(z), ARF_EXPREF(z),
tptr, tn, tsgnbit, shift, prec, rnd);
else
inexact = _arf_add_mpn(z, tptr, tn, tsgnbit, texp,
zptr, zn, ARF_SGNBIT(z), -shift, prec, rnd);
ARF_MUL_TMP_FREE(tptr2, alloc)
fmpz_clear(texp);
return inexact;
}
int
arf_submul(arf_ptr z, arf_srcptr x, arf_srcptr y, slong prec, arf_rnd_t rnd)
{
mp_size_t xn, yn, zn, tn, alloc;
mp_srcptr xptr, yptr, zptr;
mp_ptr tptr, tptr2;
fmpz_t texp;
slong shift;
int tsgnbit, inexact;
ARF_MUL_TMP_DECL
if (arf_is_special(x) || arf_is_special(y) || arf_is_special(z))
{
if (arf_is_zero(z))
{
return arf_neg_mul(z, x, y, prec, rnd);
}
else if (arf_is_finite(x) && arf_is_finite(y))
{
return arf_set_round(z, z, prec, rnd);
}
else
{
/* todo: speed up */
arf_t t;
arf_init(t);
arf_mul(t, x, y, ARF_PREC_EXACT, ARF_RND_DOWN);
inexact = arf_sub(z, z, t, prec, rnd);
arf_clear(t);
return inexact;
}
}
tsgnbit = ARF_SGNBIT(x) ^ ARF_SGNBIT(y) ^ 1;
ARF_GET_MPN_READONLY(xptr, xn, x);
ARF_GET_MPN_READONLY(yptr, yn, y);
ARF_GET_MPN_READONLY(zptr, zn, z);
fmpz_init(texp);
_fmpz_add2_fast(texp, ARF_EXPREF(x), ARF_EXPREF(y), 0);
shift = _fmpz_sub_small(ARF_EXPREF(z), texp);
alloc = tn = xn + yn;
ARF_MUL_TMP_ALLOC(tptr2, alloc)
tptr = tptr2;
ARF_MPN_MUL(tptr, xptr, xn, yptr, yn);
tn -= (tptr[0] == 0);
tptr += (tptr[0] == 0);
if (shift >= 0)
inexact = _arf_add_mpn(z, zptr, zn, ARF_SGNBIT(z), ARF_EXPREF(z),
tptr, tn, tsgnbit, shift, prec, rnd);
else
inexact = _arf_add_mpn(z, tptr, tn, tsgnbit, texp,
zptr, zn, ARF_SGNBIT(z), -shift, prec, rnd);
ARF_MUL_TMP_FREE(tptr2, alloc)
fmpz_clear(texp);
return inexact;
}
int
arf_root(arf_ptr z, arf_srcptr x, ulong k, slong prec, arf_rnd_t rnd)
{
mp_size_t xn, zn, val;
mp_srcptr xptr;
mp_ptr tmp, zptr;
mpfr_t xf, zf;
fmpz_t q, r;
int inexact;
if (k == 0)
{
arf_nan(z);
return 0;
}
if (k == 1)
return arf_set_round(z, x, prec, rnd);
if (k == 2)
return arf_sqrt(z, x, prec, rnd);
if (arf_is_special(x))
{
if (arf_is_neg_inf(x))
arf_nan(z);
else
arf_set(z, x);
return 0;
}
if (ARF_SGNBIT(x))
{
arf_nan(z);
return 0;
}
fmpz_init(q);
fmpz_init(r);
/* x = m * 2^e where e = qk + r */
/* x^(1/k) = (m * 2^(qk+r))^(1/k) */
/* x^(1/k) = (m * 2^r)^(1/k) * 2^q */
fmpz_set_ui(r, k);
fmpz_fdiv_qr(q, r, ARF_EXPREF(x), r);
ARF_GET_MPN_READONLY(xptr, xn, x);
zn = (prec + FLINT_BITS - 1) / FLINT_BITS;
zf->_mpfr_d = tmp = flint_malloc(zn * sizeof(mp_limb_t));
zf->_mpfr_prec = prec;
zf->_mpfr_sign = 1;
zf->_mpfr_exp = 0;
xf->_mpfr_d = (mp_ptr) xptr;
xf->_mpfr_prec = xn * FLINT_BITS;
xf->_mpfr_sign = 1;
xf->_mpfr_exp = fmpz_get_ui(r);
inexact = mpfr_root(zf, xf, k, arf_rnd_to_mpfr(rnd));
inexact = (inexact != 0);
val = 0;
while (tmp[val] == 0)
val++;
ARF_GET_MPN_WRITE(zptr, zn - val, z);
flint_mpn_copyi(zptr, tmp + val, zn - val);
fmpz_add_si(ARF_EXPREF(z), q, zf->_mpfr_exp);
flint_free(tmp);
fmpz_clear(q);
fmpz_clear(r);
return inexact;
}
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;
}
}
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;
}
}
