void
mag_geom_series(mag_t res, const mag_t x, ulong n)
{
if (mag_is_zero(x))
{
if (n == 0)
mag_one(res);
else
mag_zero(res);
}
else if (mag_is_inf(x))
{
mag_inf(res);
}
else
{
mag_t t;
mag_init(t);
mag_one(t);
mag_sub_lower(t, t, x);
if (mag_is_zero(t))
{
mag_inf(res);
}
else
{
mag_pow_ui(res, x, n);
mag_div(res, res, t);
}
mag_clear(t);
}
}
void
mag_exp_tail(mag_t z, const mag_t x, ulong N)
{
if (N == 0 || mag_is_inf(x))
{
mag_exp(z, x);
}
else if (mag_is_zero(x))
{
mag_zero(z);
}
else
{
mag_t t;
mag_init(t);
mag_set_ui_2exp_si(t, N, -1);
/* bound by geometric series when N >= 2*x <=> N/2 >= x */
if (mag_cmp(t, x) >= 0)
{
/* 2 c^N / N! */
mag_pow_ui(t, x, N);
mag_rfac_ui(z, N);
mag_mul(z, z, t);
mag_mul_2exp_si(z, z, 1);
}
else
{
mag_exp(z, x);
}
mag_clear(t);
}
}
void
mag_expinv(mag_t res, const mag_t x)
{
if (mag_is_zero(x))
{
mag_one(res);
}
else if (mag_is_inf(x))
{
mag_zero(res);
}
else if (fmpz_sgn(MAG_EXPREF(x)) <= 0)
{
mag_one(res);
}
else if (fmpz_cmp_ui(MAG_EXPREF(x), 2 * MAG_BITS) > 0)
{
fmpz_t t;
fmpz_init(t);
/* If x > 2^60, exp(-x) < 2^(-2^60 / log(2)) */
/* -1/log(2) < -369/256 */
fmpz_set_si(t, -369);
fmpz_mul_2exp(t, t, 2 * MAG_BITS - 8);
mag_one(res);
mag_mul_2exp_fmpz(res, res, t);
fmpz_clear(t);
}
else
{
fmpz_t t;
slong e = MAG_EXP(x);
fmpz_init(t);
fmpz_set_ui(t, MAG_MAN(x));
if (e >= MAG_BITS)
fmpz_mul_2exp(t, t, e - MAG_BITS);
else
fmpz_tdiv_q_2exp(t, t, MAG_BITS - e);
/* upper bound for 1/e */
mag_set_ui_2exp_si(res, 395007543, -30);
mag_pow_fmpz(res, res, t);
fmpz_clear(t);
}
}
void
acb_pow_arb(acb_t z, const acb_t x, const arb_t y, long prec)
{
const arf_struct * ymid = arb_midref(y);
const mag_struct * yrad = arb_radref(y);
if (arb_is_zero(y))
{
acb_one(z);
return;
}
if (mag_is_zero(yrad))
{
/* small half-integer or integer */
if (arf_cmpabs_2exp_si(ymid, BINEXP_LIMIT) < 0 &&
arf_is_int_2exp_si(ymid, -1))
{
fmpz_t e;
fmpz_init(e);
if (arf_is_int(ymid))
{
arf_get_fmpz_fixed_si(e, ymid, 0);
acb_pow_fmpz_binexp(z, x, e, prec);
}
else
{
/* hack: give something finite here (should fix sqrt/rsqrt etc) */
if (arb_contains_zero(acb_imagref(x)) && arb_contains_nonpositive(acb_realref(x)))
{
_acb_pow_arb_exp(z, x, y, prec);
fmpz_clear(e);
return;
}
arf_get_fmpz_fixed_si(e, ymid, -1);
acb_sqrt(z, x, prec + fmpz_bits(e));
acb_pow_fmpz_binexp(z, z, e, prec);
}
fmpz_clear(e);
return;
}
}
_acb_pow_arb_exp(z, x, y, prec);
}
void
arb_atan(arb_t z, const arb_t x, slong prec)
{
if (arb_is_exact(x))
{
arb_atan_arf(z, arb_midref(x), prec);
}
else
{
mag_t t, u;
mag_init(t);
mag_init(u);
arb_get_mag_lower(t, x);
if (mag_is_zero(t))
{
mag_set(t, arb_radref(x));
}
else
{
mag_mul_lower(t, t, t);
mag_one(u);
mag_add_lower(t, t, u);
mag_div(t, arb_radref(x), t);
}
if (mag_cmp_2exp_si(t, 0) > 0)
{
mag_const_pi(u);
mag_min(t, t, u);
}
arb_atan_arf(z, arb_midref(x), prec);
mag_add(arb_radref(z), arb_radref(z), t);
mag_clear(t);
mag_clear(u);
}
}
void
arb_sqrtpos(arb_t z, const arb_t x, long prec)
{
if (!arb_is_finite(x))
{
if (mag_is_zero(arb_radref(x)) && arf_is_pos_inf(arb_midref(x)))
arb_pos_inf(z);
else
arb_zero_pm_inf(z);
}
else if (arb_contains_nonpositive(x))
{
arf_t t;
arf_init(t);
arf_set_mag(t, arb_radref(x));
arf_add(t, arb_midref(x), t, MAG_BITS, ARF_RND_CEIL);
if (arf_sgn(t) <= 0)
{
arb_zero(z);
}
else
{
arf_sqrt(t, t, MAG_BITS, ARF_RND_CEIL);
arf_mul_2exp_si(t, t, -1);
arf_set(arb_midref(z), t);
arf_get_mag(arb_radref(z), t);
}
arf_clear(t);
}
else
{
arb_sqrt(z, x, prec);
}
arb_nonnegative_part(z, z, prec);
}
double
mag_get_d(const mag_t z)
{
if (mag_is_zero(z))
{
return 0.0;
}
else if (mag_is_inf(z))
{
return D_INF;
}
else if (MAG_EXP(z) < -1000 || MAG_EXP(z) > 1000)
{
if (fmpz_sgn(MAG_EXPREF(z)) < 0)
return ldexp(1.0, -1000);
else
return D_INF;
}
else
{
return ldexp(MAG_MAN(z), MAG_EXP(z) - MAG_BITS);
}
}
void
arb_log(arb_t y, const arb_t x, slong prec)
{
if (arb_is_exact(x))
{
arb_log_arf(y, arb_midref(x), prec);
}
else
{
/*
Let the input be [a-b, a+b]. We require a > b >= 0 (otherwise the
interval contains zero or a negative number and the logarithm is not
defined). The error is largest at a-b, and we have
log(a) - log(a-b) = log(1 + b/(a-b)).
*/
mag_t err;
mag_init(err);
arb_get_mag_lower_nonnegative(err, x);
if (mag_is_zero(err))
{
mag_inf(err);
}
else
{
mag_div(err, arb_radref(x), err);
mag_log1p(err, err);
}
arb_log_arf(y, arb_midref(x), prec);
mag_add(arb_radref(y), arb_radref(y), err);
mag_clear(err);
}
}
void
_arb_poly_mullow_block(arb_ptr z, arb_srcptr x, slong xlen,
arb_srcptr y, slong ylen, slong n, slong prec)
{
slong xmlen, xrlen, ymlen, yrlen, i;
fmpz *xz, *yz, *zz;
fmpz *xe, *ye;
slong *xblocks, *yblocks;
int squaring;
fmpz_t scale, t;
xlen = FLINT_MIN(xlen, n);
ylen = FLINT_MIN(ylen, n);
squaring = (x == y) && (xlen == ylen);
/* Strip trailing zeros */
xmlen = xrlen = xlen;
while (xmlen > 0 && arf_is_zero(arb_midref(x + xmlen - 1))) xmlen--;
while (xrlen > 0 && mag_is_zero(arb_radref(x + xrlen - 1))) xrlen--;
if (squaring)
{
ymlen = xmlen;
yrlen = xrlen;
}
else
{
ymlen = yrlen = ylen;
while (ymlen > 0 && arf_is_zero(arb_midref(y + ymlen - 1))) ymlen--;
while (yrlen > 0 && mag_is_zero(arb_radref(y + yrlen - 1))) yrlen--;
}
/* We don't know how to deal with infinities or NaNs */
if (!_arb_vec_is_finite(x, xlen) ||
(!squaring && !_arb_vec_is_finite(y, ylen)))
{
_arb_poly_mullow_classical(z, x, xlen, y, ylen, n, prec);
return;
}
xlen = FLINT_MAX(xmlen, xrlen);
ylen = FLINT_MAX(ymlen, yrlen);
/* Start with the zero polynomial */
_arb_vec_zero(z, n);
/* Nothing to do */
if (xlen == 0 || ylen == 0)
return;
n = FLINT_MIN(n, xlen + ylen - 1);
fmpz_init(scale);
fmpz_init(t);
xz = _fmpz_vec_init(xlen);
yz = _fmpz_vec_init(ylen);
zz = _fmpz_vec_init(n);
xe = _fmpz_vec_init(xlen);
ye = _fmpz_vec_init(ylen);
xblocks = flint_malloc(sizeof(slong) * (xlen + 1));
yblocks = flint_malloc(sizeof(slong) * (ylen + 1));
_arb_poly_get_scale(scale, x, xlen, y, ylen);
/* Error propagation */
/* (xm + xr)*(ym + yr) = (xm*ym) + (xr*ym + xm*yr + xr*yr)
= (xm*ym) + (xm*yr + xr*(ym + yr)) */
if (xrlen != 0 || yrlen != 0)
{
mag_ptr tmp;
double *xdbl, *ydbl;
tmp = _mag_vec_init(FLINT_MAX(xlen, ylen));
xdbl = flint_malloc(sizeof(double) * xlen);
ydbl = flint_malloc(sizeof(double) * ylen);
/* (xm + xr)^2 = (xm*ym) + (xr^2 + 2 xm xr)
= (xm*ym) + xr*(2 xm + xr) */
if (squaring)
{
_mag_vec_get_fmpz_2exp_blocks(xz, xdbl, xe, xblocks, scale, x, NULL, xrlen);
for (i = 0; i < xlen; i++)
{
arf_get_mag(tmp + i, arb_midref(x + i));
mag_mul_2exp_si(tmp + i, tmp + i, 1);
mag_add(tmp + i, tmp + i, arb_radref(x + i));
}
_mag_vec_get_fmpz_2exp_blocks(yz, ydbl, ye, yblocks, scale, NULL, tmp, xlen);
_arb_poly_addmullow_rad(z, zz, xz, xdbl, xe, xblocks, xrlen, yz, ydbl, ye, yblocks, xlen, n);
}
else if (yrlen == 0)
{
/* xr * |ym| */
_mag_vec_get_fmpz_2exp_blocks(xz, xdbl, xe, xblocks, scale, x, NULL, xrlen);
for (i = 0; i < ymlen; i++)
arf_get_mag(tmp + i, arb_midref(y + i));
_mag_vec_get_fmpz_2exp_blocks(yz, ydbl, ye, yblocks, scale, NULL, tmp, ymlen);
_arb_poly_addmullow_rad(z, zz, xz, xdbl, xe, xblocks, xrlen, yz, ydbl, ye, yblocks, ymlen, n);
}
else
{
/* |xm| * yr */
for (i = 0; i < xmlen; i++)
arf_get_mag(tmp + i, arb_midref(x + i));
_mag_vec_get_fmpz_2exp_blocks(xz, xdbl, xe, xblocks, scale, NULL, tmp, xmlen);
_mag_vec_get_fmpz_2exp_blocks(yz, ydbl, ye, yblocks, scale, y, NULL, yrlen);
_arb_poly_addmullow_rad(z, zz, xz, xdbl, xe, xblocks, xmlen, yz, ydbl, ye, yblocks, yrlen, n);
/* xr*(|ym| + yr) */
if (xrlen != 0)
{
_mag_vec_get_fmpz_2exp_blocks(xz, xdbl, xe, xblocks, scale, x, NULL, xrlen);
for (i = 0; i < ylen; i++)
arb_get_mag(tmp + i, y + i);
_mag_vec_get_fmpz_2exp_blocks(yz, ydbl, ye, yblocks, scale, NULL, tmp, ylen);
_arb_poly_addmullow_rad(z, zz, xz, xdbl, xe, xblocks, xrlen, yz, ydbl, ye, yblocks, ylen, n);
}
}
_mag_vec_clear(tmp, FLINT_MAX(xlen, ylen));
flint_free(xdbl);
flint_free(ydbl);
}
/* multiply midpoints */
if (xmlen != 0 && ymlen != 0)
{
_arb_vec_get_fmpz_2exp_blocks(xz, xe, xblocks, scale, x, xmlen, prec);
if (squaring)
{
_arb_poly_addmullow_block(z, zz, xz, xe, xblocks, xmlen, xz, xe, xblocks, xmlen, n, prec, 1);
}
else
{
_arb_vec_get_fmpz_2exp_blocks(yz, ye, yblocks, scale, y, ymlen, prec);
_arb_poly_addmullow_block(z, zz, xz, xe, xblocks, xmlen, yz, ye, yblocks, ymlen, n, prec, 0);
}
}
/* Unscale. */
if (!fmpz_is_zero(scale))
{
fmpz_zero(t);
for (i = 0; i < n; i++)
{
arb_mul_2exp_fmpz(z + i, z + i, t);
fmpz_add(t, t, scale);
}
}
_fmpz_vec_clear(xz, xlen);
_fmpz_vec_clear(yz, ylen);
_fmpz_vec_clear(zz, n);
_fmpz_vec_clear(xe, xlen);
_fmpz_vec_clear(ye, ylen);
flint_free(xblocks);
flint_free(yblocks);
fmpz_clear(scale);
fmpz_clear(t);
}
slong
hypgeom_bound(mag_t error, int r,
slong A, slong B, slong K, const mag_t TK, const mag_t z, slong tol_2exp)
{
mag_t Tn, t, u, one, tol, num, den;
slong n, m;
mag_init(Tn);
mag_init(t);
mag_init(u);
mag_init(one);
mag_init(tol);
mag_init(num);
mag_init(den);
mag_one(one);
mag_set_ui_2exp_si(tol, UWORD(1), -tol_2exp);
/* approximate number of needed terms */
n = hypgeom_estimate_terms(z, r, tol_2exp);
/* required for 1 + O(1/k) part to be decreasing */
n = FLINT_MAX(n, K + 1);
/* required for z^k / (k!)^r to be decreasing */
m = hypgeom_root_bound(z, r);
n = FLINT_MAX(n, m);
/* We now have |R(k)| <= G(k) where G(k) is monotonically decreasing,
and can bound the tail using a geometric series as soon
as soon as G(k) < 1. */
/* bound T(n-1) */
hypgeom_term_bound(Tn, TK, K, A, B, r, z, n-1);
while (1)
{
/* bound R(n) */
mag_mul_ui(num, z, n);
mag_mul_ui(num, num, n - B);
mag_set_ui_lower(den, n - A);
mag_mul_ui_lower(den, den, n - 2*B);
if (r != 0)
{
mag_set_ui_lower(u, n);
mag_pow_ui_lower(u, u, r);
mag_mul_lower(den, den, u);
}
mag_div(t, num, den);
/* multiply bound for T(n-1) by bound for R(n) to bound T(n) */
mag_mul(Tn, Tn, t);
/* geometric series termination check */
/* u = max(1-t, 0), rounding down [lower bound] */
mag_sub_lower(u, one, t);
if (!mag_is_zero(u))
{
mag_div(u, Tn, u);
if (mag_cmp(u, tol) < 0)
{
mag_set(error, u);
break;
}
}
/* move on to next term */
n++;
}
mag_clear(Tn);
mag_clear(t);
mag_clear(u);
mag_clear(one);
mag_clear(tol);
mag_clear(num);
mag_clear(den);
return n;
}
void
_arb_sin_cos_generic(arb_t s, arb_t c, const arf_t x, const mag_t xrad, slong prec)
{
int want_sin, want_cos;
slong maglim;
want_sin = (s != NULL);
want_cos = (c != NULL);
if (arf_is_zero(x) && mag_is_zero(xrad))
{
if (want_sin) arb_zero(s);
if (want_cos) arb_one(c);
return;
}
if (!arf_is_finite(x) || !mag_is_finite(xrad))
{
if (arf_is_nan(x))
{
if (want_sin) arb_indeterminate(s);
if (want_cos) arb_indeterminate(c);
}
else
{
if (want_sin) arb_zero_pm_one(s);
if (want_cos) arb_zero_pm_one(c);
}
return;
}
maglim = FLINT_MAX(65536, 4 * prec);
if (mag_cmp_2exp_si(xrad, -16) > 0 || arf_cmpabs_2exp_si(x, maglim) > 0)
{
_arb_sin_cos_wide(s, c, x, xrad, prec);
return;
}
if (arf_cmpabs_2exp_si(x, -(prec/2) - 2) <= 0)
{
mag_t t, u, v;
mag_init(t);
mag_init(u);
mag_init(v);
arf_get_mag(t, x);
mag_add(t, t, xrad);
mag_mul(u, t, t);
/* |sin(z)-z| <= z^3/6 */
if (want_sin)
{
arf_set(arb_midref(s), x);
mag_set(arb_radref(s), xrad);
arb_set_round(s, s, prec);
mag_mul(v, u, t);
mag_div_ui(v, v, 6);
arb_add_error_mag(s, v);
}
/* |cos(z)-1| <= z^2/2 */
if (want_cos)
{
arf_one(arb_midref(c));
mag_mul_2exp_si(arb_radref(c), u, -1);
}
mag_clear(t);
mag_clear(u);
mag_clear(v);
return;
}
if (mag_is_zero(xrad))
{
arb_sin_cos_arf_generic(s, c, x, prec);
}
else
{
mag_t t;
slong exp, radexp;
mag_init_set(t, xrad);
exp = arf_abs_bound_lt_2exp_si(x);
radexp = MAG_EXP(xrad);
if (radexp < MAG_MIN_LAGOM_EXP || radexp > MAG_MAX_LAGOM_EXP)
radexp = MAG_MIN_LAGOM_EXP;
if (want_cos && exp < -2)
prec = FLINT_MIN(prec, 20 - FLINT_MAX(exp, radexp) - radexp);
else
prec = FLINT_MIN(prec, 20 - radexp);
arb_sin_cos_arf_generic(s, c, x, prec);
/* todo: could use quadratic bound */
if (want_sin) mag_add(arb_radref(s), arb_radref(s), t);
if (want_cos) mag_add(arb_radref(c), arb_radref(c), t);
mag_clear(t);
}
}
void
arb_mat_exp(arb_mat_t B, const arb_mat_t A, slong prec)
{
slong i, j, dim, wp, N, q, r;
mag_t norm, err;
arb_mat_t T;
dim = arb_mat_nrows(A);
if (dim != arb_mat_ncols(A))
{
flint_printf("arb_mat_exp: a square matrix is required!\n");
abort();
}
if (dim == 0)
{
return;
}
else if (dim == 1)
{
arb_exp(arb_mat_entry(B, 0, 0), arb_mat_entry(A, 0, 0), prec);
return;
}
wp = prec + 3 * FLINT_BIT_COUNT(prec);
mag_init(norm);
mag_init(err);
arb_mat_init(T, dim, dim);
arb_mat_bound_inf_norm(norm, A);
if (mag_is_zero(norm))
{
arb_mat_one(B);
}
else
{
q = pow(wp, 0.25); /* wanted magnitude */
if (mag_cmp_2exp_si(norm, 2 * wp) > 0) /* too big */
r = 2 * wp;
else if (mag_cmp_2exp_si(norm, -q) < 0) /* tiny, no need to reduce */
r = 0;
else
r = FLINT_MAX(0, q + MAG_EXP(norm)); /* reduce to magnitude 2^(-r) */
arb_mat_scalar_mul_2exp_si(T, A, -r);
mag_mul_2exp_si(norm, norm, -r);
N = _arb_mat_exp_choose_N(norm, wp);
mag_exp_tail(err, norm, N);
_arb_mat_exp_taylor(B, T, N, wp);
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
arb_add_error_mag(arb_mat_entry(B, i, j), err);
for (i = 0; i < r; i++)
{
arb_mat_mul(T, B, B, wp);
arb_mat_swap(T, B);
}
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
arb_set_round(arb_mat_entry(B, i, j),
arb_mat_entry(B, i, j), prec);
}
mag_clear(norm);
mag_clear(err);
arb_mat_clear(T);
}
void
acb_inv(acb_t res, const acb_t z, slong prec)
{
mag_t am, bm;
slong hprec;
#define a arb_midref(acb_realref(z))
#define b arb_midref(acb_imagref(z))
#define x arb_radref(acb_realref(z))
#define y arb_radref(acb_imagref(z))
/* choose precision for the floating-point approximation of a^2+b^2 so
that the double rounding result in less than
2 ulp error; also use at least MAG_BITS bits since the
value will be recycled for error bounds */
hprec = FLINT_MAX(prec + 3, MAG_BITS);
if (arb_is_zero(acb_imagref(z)))
{
arb_inv(acb_realref(res), acb_realref(z), prec);
arb_zero(acb_imagref(res));
return;
}
if (arb_is_zero(acb_realref(z)))
{
arb_inv(acb_imagref(res), acb_imagref(z), prec);
arb_neg(acb_imagref(res), acb_imagref(res));
arb_zero(acb_realref(res));
return;
}
if (!acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
if (mag_is_zero(x) && mag_is_zero(y))
{
int inexact;
arf_t a2b2;
arf_init(a2b2);
inexact = arf_sosq(a2b2, a, b, hprec, ARF_RND_DOWN);
if (arf_is_special(a2b2))
{
acb_indeterminate(res);
}
else
{
_arb_arf_div_rounded_den(acb_realref(res), a, a2b2, inexact, prec);
_arb_arf_div_rounded_den(acb_imagref(res), b, a2b2, inexact, prec);
arf_neg(arb_midref(acb_imagref(res)), arb_midref(acb_imagref(res)));
}
arf_clear(a2b2);
return;
}
mag_init(am);
mag_init(bm);
/* first bound |a|-x, |b|-y */
arb_get_mag_lower(am, acb_realref(z));
arb_get_mag_lower(bm, acb_imagref(z));
if ((mag_is_zero(am) && mag_is_zero(bm)))
{
acb_indeterminate(res);
}
else
{
/*
The propagated error in the real part is given exactly by
(a+x')/((a+x')^2+(b+y'))^2 - a/(a^2+b^2) = P / Q,
P = [(b^2-a^2) x' - a (x'^2+y'^2 + 2y'b)]
Q = [(a^2+b^2)((a+x')^2+(b+y')^2)]
where |x'| <= x and |y'| <= y, and analogously for the imaginary part.
*/
mag_t t, u, v, w;
arf_t a2b2;
int inexact;
mag_init(t);
mag_init(u);
mag_init(v);
mag_init(w);
arf_init(a2b2);
inexact = arf_sosq(a2b2, a, b, hprec, ARF_RND_DOWN);
/* compute denominator */
/* t = (|a|-x)^2 + (|b|-x)^2 (lower bound) */
mag_mul_lower(t, am, am);
mag_mul_lower(u, bm, bm);
mag_add_lower(t, t, u);
/* u = a^2 + b^2 (lower bound) */
arf_get_mag_lower(u, a2b2);
/* t = ((|a|-x)^2 + (|b|-x)^2)(a^2 + b^2) (lower bound) */
mag_mul_lower(t, t, u);
/* compute numerator */
/* real: |a^2-b^2| x + |a| ((x^2 + y^2) + 2 |b| y)) */
/* imag: |a^2-b^2| y + |b| ((x^2 + y^2) + 2 |a| x)) */
/* am, bm = upper bounds for a, b */
arf_get_mag(am, a);
arf_get_mag(bm, b);
/* v = x^2 + y^2 */
mag_mul(v, x, x);
mag_addmul(v, y, y);
/* u = |a| ((x^2 + y^2) + 2 |b| y) */
mag_mul_2exp_si(u, bm, 1);
mag_mul(u, u, y);
mag_add(u, u, v);
mag_mul(u, u, am);
/* v = |b| ((x^2 + y^2) + 2 |a| x) */
mag_mul_2exp_si(w, am, 1);
mag_addmul(v, w, x);
mag_mul(v, v, bm);
/* w = |b^2 - a^2| (upper bound) */
if (arf_cmpabs(a, b) >= 0)
mag_mul(w, am, am);
else
mag_mul(w, bm, bm);
mag_addmul(u, w, x);
mag_addmul(v, w, y);
mag_div(arb_radref(acb_realref(res)), u, t);
mag_div(arb_radref(acb_imagref(res)), v, t);
_arb_arf_div_rounded_den_add_err(acb_realref(res), a, a2b2, inexact, prec);
_arb_arf_div_rounded_den_add_err(acb_imagref(res), b, a2b2, inexact, prec);
arf_neg(arb_midref(acb_imagref(res)), arb_midref(acb_imagref(res)));
mag_clear(t);
mag_clear(u);
mag_clear(v);
mag_clear(w);
arf_clear(a2b2);
}
mag_clear(am);
mag_clear(bm);
#undef a
#undef b
#undef x
#undef y
}
void
mag_log1p(mag_t z, const mag_t x)
{
if (mag_is_special(x))
{
if (mag_is_zero(x))
mag_zero(z);
else
mag_inf(z);
}
else
{
fmpz exp = MAG_EXP(x);
if (!COEFF_IS_MPZ(exp))
{
/* Quick bound by x */
if (exp < -10)
{
mag_set(z, x);
return;
}
else if (exp < 1000)
{
double t;
t = ldexp(MAG_MAN(x), exp - MAG_BITS);
t = (1.0 + t) * (1 + 1e-14);
t = mag_d_log_upper_bound(t);
mag_set_d(z, t);
return;
}
}
else if (fmpz_sgn(MAG_EXPREF(x)) < 0)
{
/* Quick bound by x */
mag_set(z, x);
return;
}
/* Now we must have x >= 2^1000 */
/* Use log(2^(exp-1) * (2*v)) = exp*log(2) + log(2*v) */
{
double t;
fmpz_t b;
mag_t u;
mag_init(u);
fmpz_init(b);
/* incrementing the mantissa gives an upper bound for x+1 */
t = ldexp(MAG_MAN(x) + 1, 1 - MAG_BITS);
t = mag_d_log_upper_bound(t);
mag_set_d(u, t);
/* log(2) < 744261118/2^30 */
_fmpz_add_fast(b, MAG_EXPREF(x), -1);
fmpz_mul_ui(b, b, 744261118);
mag_set_fmpz(z, b);
_fmpz_add_fast(MAG_EXPREF(z), MAG_EXPREF(z), -30);
mag_add(z, z, u);
mag_clear(u);
fmpz_clear(b);
}
}
}
