int main()
{
slong iter;
flint_rand_t state;
flint_printf("abs_bound_le_2exp_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arf_t x, y;
fmpz_t b;
int cmp1, cmp2;
arf_init(x);
arf_init(y);
fmpz_init(b);
arf_randtest_not_zero(x, state, 2 + n_randint(state, 1000), 100);
arf_abs_bound_le_2exp_fmpz(b, x);
arf_one(y);
arf_mul_2exp_fmpz(y, y, b);
cmp1 = (arf_cmpabs(x, y) <= 0);
arf_mul_2exp_si(y, y, -1);
cmp2 = (arf_cmpabs(y, x) < 0);
arf_mul_2exp_si(y, y, 1);
if (!cmp1 || !cmp2)
{
flint_printf("FAIL\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("b = "); fmpz_print(b); flint_printf("\n\n");
flint_printf("cmp1 = %d, cmp2 = %d\n\n", cmp1, cmp2);
abort();
}
arf_clear(x);
arf_clear(y);
fmpz_clear(b);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int arf_cmpabs_d(const arf_t x, double y)
{
arf_t t;
arf_init(t); /* no need to free */
arf_set_d(t, y);
return arf_cmpabs(x, t);
}
void
acb_hypgeom_erf(acb_t res, const acb_t z, slong prec)
{
double x, y, absz2, logz;
slong prec2;
if (!acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
if (acb_is_zero(z))
{
acb_zero(res);
return;
}
if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), 0) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 0) < 0))
{
acb_hypgeom_erf_1f1a(res, z, prec);
return;
}
if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), 64) > 0 ||
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 64) > 0))
{
acb_hypgeom_erf_asymp(res, z, prec, prec);
return;
}
x = arf_get_d(arb_midref(acb_realref(z)), ARF_RND_DOWN);
y = arf_get_d(arb_midref(acb_imagref(z)), ARF_RND_DOWN);
absz2 = x * x + y * y;
logz = 0.5 * log(absz2);
if (logz - absz2 < -(prec + 8) * 0.69314718055994530942)
{
/* If the asymptotic term is small, we can
compute with reduced precision */
prec2 = FLINT_MIN(prec + 4 + (y*y - x*x - logz) * 1.4426950408889634074, (double) prec);
prec2 = FLINT_MAX(8, prec2);
prec2 = FLINT_MIN(prec2, prec);
acb_hypgeom_erf_asymp(res, z, prec, prec2);
}
else if (arf_cmpabs(arb_midref(acb_imagref(z)), arb_midref(acb_realref(z))) > 0)
{
acb_hypgeom_erf_1f1a(res, z, prec);
}
else
{
acb_hypgeom_erf_1f1b(res, z, prec);
}
}
/* this can be improved */
static int
use_recurrence(const acb_t n, const acb_t m, slong prec)
{
if (!acb_is_int(n) || !arb_is_nonnegative(acb_realref(n)))
return 0;
if (arf_cmpabs_ui(arb_midref(acb_realref(n)), prec) > 0)
return 0;
if (arf_cmpabs(arb_midref(acb_realref(n)), arb_midref(acb_realref(m))) >= 0)
return 0;
return 1;
}
void
acb_lambertw_cleared_cut_fix_small(acb_t res, const acb_t z,
const acb_t ez1, const fmpz_t k, int flags, slong prec)
{
acb_t zz, zmid, zmide1;
arf_t eps;
acb_init(zz);
acb_init(zmid);
acb_init(zmide1);
arf_init(eps);
arf_mul_2exp_si(eps, arb_midref(acb_realref(z)), -prec);
acb_set(zz, z);
if (arf_sgn(arb_midref(acb_realref(zz))) < 0 &&
(!fmpz_is_zero(k) || arf_sgn(arb_midref(acb_realref(ez1))) < 0) &&
arf_cmpabs(arb_midref(acb_imagref(zz)), eps) < 0)
{
/* now the value must be in [0,2eps] */
arf_get_mag(arb_radref(acb_imagref(zz)), eps);
arf_set_mag(arb_midref(acb_imagref(zz)), arb_radref(acb_imagref(zz)));
if (arf_sgn(arb_midref(acb_imagref(z))) >= 0)
{
acb_lambertw_cleared_cut(res, zz, k, flags, prec);
}
else
{
fmpz_t kk;
fmpz_init(kk);
fmpz_neg(kk, k);
acb_lambertw_cleared_cut(res, zz, kk, flags, prec);
acb_conj(res, res);
fmpz_clear(kk);
}
}
else
{
acb_lambertw_cleared_cut(res, zz, k, flags, prec);
}
acb_clear(zz);
acb_clear(zmid);
acb_clear(zmide1);
arf_clear(eps);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("rel_accuracy_bits....");
fflush(stdout);
flint_randinit(state);
/* test aliasing of c and a */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t x;
acb_t z;
slong a1, a2;
arb_init(x);
acb_init(z);
arb_randtest_special(x, state, 1 + n_randint(state, 200), 1 + n_randint(state, 200));
acb_set_arb(z, x);
a1 = arb_rel_accuracy_bits(x);
a2 = acb_rel_accuracy_bits(z);
if (a1 != a2)
{
flint_printf("FAIL: acb != arb\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("z = "); acb_print(z); flint_printf("\n\n");
flint_printf("a1 = %wd, a2 = %wd\n\n", a1, a2);
abort();
}
acb_randtest_special(z, state, 1 + n_randint(state, 200), 1 + n_randint(state, 200));
a1 = acb_rel_accuracy_bits(z);
if (n_randint(state, 2))
arf_swap(arb_midref(acb_realref(z)), arb_midref(acb_imagref(z)));
if (n_randint(state, 2))
mag_swap(arb_radref(acb_realref(z)), arb_radref(acb_imagref(z)));
a2 = acb_rel_accuracy_bits(z);
if (a1 != a2)
{
flint_printf("FAIL: swapping\n\n");
flint_printf("z = "); acb_print(z); flint_printf("\n\n");
flint_printf("a1 = %wd, a2 = %wd\n\n", a1, a2);
abort();
}
acb_randtest_special(z, state, 1 + n_randint(state, 200), 1 + n_randint(state, 200));
if (arf_cmpabs(arb_midref(acb_realref(z)), arb_midref(acb_imagref(z))) >= 0)
arf_set(arb_midref(x), arb_midref(acb_realref(z)));
else
arf_set(arb_midref(x), arb_midref(acb_imagref(z)));
if (mag_cmp(arb_radref(acb_realref(z)), arb_radref(acb_imagref(z))) >= 0)
mag_set(arb_radref(x), arb_radref(acb_realref(z)));
else
mag_set(arb_radref(x), arb_radref(acb_imagref(z)));
a1 = acb_rel_accuracy_bits(z);
a2 = arb_rel_accuracy_bits(x);
if (a1 != a2)
{
flint_printf("FAIL: acb != arb (2)\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("z = "); acb_print(z); flint_printf("\n\n");
flint_printf("a1 = %wd, a2 = %wd\n\n", a1, a2);
abort();
}
arb_clear(x);
acb_clear(z);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_airy(acb_t ai, acb_t aip, acb_t bi, acb_t bip, const acb_t z, slong prec)
{
arf_srcptr re, im;
double x, y, t, zmag, z15, term_est, airy_est, abstol;
slong n, wp;
if (!acb_is_finite(z))
{
if (ai != NULL) acb_indeterminate(ai);
if (aip != NULL) acb_indeterminate(aip);
if (bi != NULL) acb_indeterminate(bi);
if (bip != NULL) acb_indeterminate(bip);
return;
}
re = arb_midref(acb_realref(z));
im = arb_midref(acb_imagref(z));
wp = prec * 1.03 + 15;
/* tiny input -- use direct method and pick n without underflowing */
if (arf_cmpabs_2exp_si(re, -64) < 0 && arf_cmpabs_2exp_si(im, -64) < 0)
{
if (arf_cmpabs_2exp_si(re, -wp) < 0 && arf_cmpabs_2exp_si(im, -wp) < 0)
{
n = 1; /* very tiny input */
}
else
{
if (arf_cmpabs(re, im) > 0)
zmag = fmpz_get_d(ARF_EXPREF(re));
else
zmag = fmpz_get_d(ARF_EXPREF(im));
zmag = (zmag + 1) * (1.0 / LOG2);
n = wp / (-zmag) + 1;
}
acb_hypgeom_airy_direct(ai, aip, bi, bip, z, n, wp);
} /* huge input -- use asymptotics and pick n without overflowing */
else if ((arf_cmpabs_2exp_si(re, 64) > 0 || arf_cmpabs_2exp_si(im, 64) > 0))
{
if (arf_cmpabs_2exp_si(re, prec) > 0 || arf_cmpabs_2exp_si(im, prec) > 0)
{
n = 1; /* very huge input */
}
else
{
x = fmpz_get_d(ARF_EXPREF(re));
y = fmpz_get_d(ARF_EXPREF(im));
zmag = (FLINT_MAX(x, y) - 2) * (1.0 / LOG2);
n = asymp_pick_terms(wp, zmag);
n = FLINT_MAX(n, 1);
}
acb_hypgeom_airy_asymp(ai, aip, bi, bip, z, n, wp);
}
else /* moderate input */
{
x = arf_get_d(re, ARF_RND_DOWN);
y = arf_get_d(im, ARF_RND_DOWN);
zmag = sqrt(x * x + y * y);
z15 = zmag * sqrt(zmag);
if (zmag >= 4.0 && (n = asymp_pick_terms(wp, log(zmag))) != -1)
{
acb_hypgeom_airy_asymp(ai, aip, bi, bip, z, n, wp);
}
else if (zmag <= 1.5)
{
t = 3 * (wp * LOG2) / (2 * z15 * EXP1);
t = (wp * LOG2) / (2 * d_lambertw(t));
n = FLINT_MAX(t + 1, 2);
acb_hypgeom_airy_direct(ai, aip, bi, bip, z, n, wp);
}
else
{
/* estimate largest term: log2(exp(2(z^3/9)^(1/2))) */
term_est = 0.96179669392597560491 * z15;
/* estimate the smaller of Ai and Bi */
airy_est = estimate_airy(x, y, (ai != NULL || aip != NULL));
/* estimate absolute tolerance and necessary working precision */
abstol = airy_est - wp;
wp = wp + term_est - airy_est;
wp = FLINT_MAX(wp, 10);
t = 3 * (-abstol * LOG2) / (2 * z15 * EXP1);
t = (-abstol * LOG2) / (2 * d_lambertw(t));
n = FLINT_MAX(t + 1, 2);
if (acb_is_exact(z))
acb_hypgeom_airy_direct(ai, aip, bi, bip, z, n, wp);
else
acb_hypgeom_airy_direct_prop(ai, aip, bi, bip, z, n, wp);
}
}
if (ai != NULL) acb_set_round(ai, ai, prec);
if (aip != NULL) acb_set_round(aip, aip, prec);
if (bi != NULL) acb_set_round(bi, bi, prec);
if (bip != NULL) acb_set_round(bip, bip, prec);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("cmpabs....");
fflush(stdout);
flint_randinit(state);
/* compare with fmpz */
{
arf_t x, y;
fmpz_t X, Y;
arf_init(x);
arf_init(y);
fmpz_init(X);
fmpz_init(Y);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
int cmp1, cmp2;
fmpz_randtest(X, state, 1 + n_randint(state, 1000));
switch (n_randint(state, 8))
{
case 0:
fmpz_neg(Y, X);
break;
case 1:
fmpz_set(Y, X);
break;
default:
fmpz_randtest(Y, state, 1 + n_randint(state, 1000));
}
arf_set_fmpz(x, X);
arf_set_fmpz(y, Y);
cmp1 = arf_cmpabs(x, y);
cmp2 = fmpz_cmpabs(X, Y);
cmp2 = (cmp2 > 0) - (cmp2 < 0);
if (cmp1 != cmp2)
{
flint_printf("FAIL\n\n");
flint_printf("x = "); arf_debug(x); flint_printf("\n\n");
flint_printf("y = "); arf_debug(y); flint_printf("\n\n");
flint_printf("X = "); fmpz_print(X); flint_printf("\n\n");
flint_printf("Y = "); fmpz_print(Y); flint_printf("\n\n");
flint_printf("cmp1 = %d, cmp2 = %d\n\n", cmp1, cmp2);
abort();
}
}
arf_clear(x);
arf_clear(y);
fmpz_clear(X);
fmpz_clear(Y);
}
/* compare with mpfr */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
slong bits;
arf_t x, y;
mpfr_t X, Y;
int cmp1, cmp2;
bits = 2 + n_randint(state, 200);
arf_init(x);
arf_init(y);
mpfr_init2(X, bits);
mpfr_init2(Y, bits);
arf_randtest_special(x, state, bits, 10);
arf_randtest_special(y, state, bits, 10);
arf_get_mpfr(X, x, MPFR_RNDN);
arf_get_mpfr(Y, y, MPFR_RNDN);
mpfr_abs(X, X, MPFR_RNDN);
mpfr_abs(Y, Y, MPFR_RNDN);
cmp1 = arf_cmpabs(x, y);
cmp2 = mpfr_cmp(X, Y);
if (cmp1 != cmp2)
{
flint_printf("FAIL\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("cmp1 = %d, cmp2 = %d\n\n", cmp1, cmp2);
abort();
}
arf_clear(x);
arf_clear(y);
mpfr_clear(X);
mpfr_clear(Y);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_erf(acb_t res, const acb_t z, slong prec)
{
double x, y, abs_z2, log_z, log_erf_z_asymp;
slong prec2, wp;
int more_imaginary;
if (!acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
if (acb_is_zero(z))
{
acb_zero(res);
return;
}
if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), -64) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), -64) < 0))
{
acb_hypgeom_erf_1f1(res, z, prec, prec, 1);
return;
}
if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), 64) > 0 ||
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 64) > 0))
{
acb_hypgeom_erf_asymp(res, z, 0, prec, prec);
return;
}
x = arf_get_d(arb_midref(acb_realref(z)), ARF_RND_DOWN);
y = arf_get_d(arb_midref(acb_imagref(z)), ARF_RND_DOWN);
abs_z2 = x * x + y * y;
log_z = 0.5 * log(abs_z2);
/* estimate of log(erf(z)), disregarding csgn term */
log_erf_z_asymp = y*y - x*x - log_z;
if (log_z - abs_z2 < -(prec + 8) * 0.69314718055994530942)
{
/* If the asymptotic term is small, we can
compute with reduced precision. */
prec2 = FLINT_MIN(prec + 4 + log_erf_z_asymp * 1.4426950408889634074, (double) prec);
prec2 = FLINT_MAX(8, prec2);
prec2 = FLINT_MIN(prec2, prec);
acb_hypgeom_erf_asymp(res, z, 0, prec, prec2);
}
else
{
more_imaginary = arf_cmpabs(arb_midref(acb_imagref(z)),
arb_midref(acb_realref(z))) > 0;
/* Worst case: exp(|x|^2), computed: exp(x^2).
(x^2+y^2) - (x^2-y^2) = 2y^2, etc. */
if (more_imaginary)
wp = prec + FLINT_MAX(2 * x * x, 0.0) * 1.4426950408889634074 + 5;
else
wp = prec + FLINT_MAX(2 * y * y, 0.0) * 1.4426950408889634074 + 5;
acb_hypgeom_erf_1f1(res, z, prec, wp, more_imaginary);
}
}
int arf_cmpabs_ui(const arf_t x, ulong y)
{
arf_t t;
arf_init_set_ui(t, y); /* no need to free */
return arf_cmpabs(x, 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
_acb_lambertw(acb_t res, const acb_t z, const acb_t ez1, const fmpz_t k, int flags, slong prec)
{
slong goal, ebits, ebits2, ls, lt;
const fmpz * expo;
/* Estimated accuracy goal. */
/* todo: account for exponent bits and bits in k. */
goal = acb_rel_accuracy_bits(z);
goal = FLINT_MAX(goal, 10);
goal = FLINT_MIN(goal, prec);
/* Handle tiny z directly. For k >= 2, |c_k| <= 4^k / 16. */
if (fmpz_is_zero(k)
&& arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), -goal / 2) < 0
&& arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), -goal / 2) < 0)
{
mag_t err;
mag_init(err);
acb_get_mag(err, z);
mag_mul_2exp_si(err, err, 2);
acb_set(res, z);
acb_submul(res, res, res, prec);
mag_geom_series(err, err, 3);
mag_mul_2exp_si(err, err, -4);
acb_add_error_mag(res, err);
mag_clear(err);
return;
}
if (arf_cmpabs(arb_midref(acb_realref(z)), arb_midref(acb_imagref(z))) >= 0)
expo = ARF_EXPREF(arb_midref(acb_realref(z)));
else
expo = ARF_EXPREF(arb_midref(acb_imagref(z)));
ebits = fmpz_bits(expo);
/* ebits ~= log2(|log(z) + 2 pi i k|) */
/* ebits2 ~= log2(log(log(z))) */
ebits = FLINT_MAX(ebits, fmpz_bits(k));
ebits = FLINT_MAX(ebits, 1) - 1;
ebits2 = FLINT_BIT_COUNT(ebits);
ebits2 = FLINT_MAX(ebits2, 1) - 1;
/* We gain accuracy from the exponent when W ~ log - log log */
if (fmpz_sgn(expo) > 0 || (fmpz_sgn(expo) < 0 && !fmpz_is_zero(k)))
{
goal += ebits - ebits2;
goal = FLINT_MAX(goal, 10);
goal = FLINT_MIN(goal, prec);
/* The asymptotic series with truncation L, M gives us about
t - max(2+lt+L*(2+ls), M*(2+lt)) bits of accuracy where
ls = -ebits, lt = ebits2 - ebits. */
ls = 2 - ebits;
lt = 2 + ebits2 - ebits;
if (ebits - FLINT_MAX(lt + 1*ls, 1*lt) > goal)
{
acb_lambertw_asymp(res, z, k, 1, 1, goal);
acb_set_round(res, res, prec);
return;
}
else if (ebits - FLINT_MAX(lt + 3*ls, 5*lt) > goal)
{
acb_lambertw_asymp(res, z, k, 3, 5, goal);
acb_set_round(res, res, prec);
return;
}
}
/* Extremely close to the branch point at -1/e, use the series expansion directly. */
if (acb_lambertw_try_near_branch_point(res, z, ez1, k, flags, goal))
{
acb_set_round(res, res, prec);
return;
}
/* compute union of both sides */
if (acb_lambertw_branch_crossing(z, ez1, k))
{
acb_t za, zb, eza1, ezb1;
fmpz_t kk;
acb_init(za);
acb_init(zb);
acb_init(eza1);
acb_init(ezb1);
fmpz_init(kk);
fmpz_neg(kk, k);
acb_set(za, z);
acb_conj(zb, z);
arb_nonnegative_part(acb_imagref(za), acb_imagref(za));
arb_nonnegative_part(acb_imagref(zb), acb_imagref(zb));
acb_set(eza1, ez1);
acb_conj(ezb1, ez1);
arb_nonnegative_part(acb_imagref(eza1), acb_imagref(eza1));
arb_nonnegative_part(acb_imagref(ezb1), acb_imagref(ezb1));
/* Check series expansion again, because now there is no crossing. */
if (!acb_lambertw_try_near_branch_point(res, za, eza1, k, flags, goal))
acb_lambertw_cleared_cut_fix_small(za, za, eza1, k, flags, goal);
if (!acb_lambertw_try_near_branch_point(res, zb, ezb1, kk, flags, goal))
acb_lambertw_cleared_cut_fix_small(zb, zb, ezb1, kk, flags, goal);
acb_conj(zb, zb);
acb_union(res, za, zb, prec);
acb_clear(za);
acb_clear(zb);
acb_clear(eza1);
acb_clear(ezb1);
fmpz_clear(kk);
}
else
{
acb_lambertw_cleared_cut_fix_small(res, z, ez1, k, flags, goal);
acb_set_round(res, res, prec);
}
}
int
arf_sum(arf_t s, arf_srcptr terms, long len, long prec, arf_rnd_t rnd)
{
arf_ptr blocks;
long i, j, used;
int have_merged, res;
/* first check if the result is inf or nan */
{
int have_pos_inf = 0;
int have_neg_inf = 0;
for (i = 0; i < len; i++)
{
if (arf_is_pos_inf(terms + i))
{
if (have_neg_inf)
{
arf_nan(s);
return 0;
}
have_pos_inf = 1;
}
else if (arf_is_neg_inf(terms + i))
{
if (have_pos_inf)
{
arf_nan(s);
return 0;
}
have_neg_inf = 1;
}
else if (arf_is_nan(terms + i))
{
arf_nan(s);
return 0;
}
}
if (have_pos_inf)
{
arf_pos_inf(s);
return 0;
}
if (have_neg_inf)
{
arf_neg_inf(s);
return 0;
}
}
blocks = flint_malloc(sizeof(arf_struct) * len);
for (i = 0; i < len; i++)
arf_init(blocks + i);
/* put all terms into blocks */
used = 0;
for (i = 0; i < len; i++)
{
if (!arf_is_zero(terms + i))
{
arf_set(blocks + used, terms + i);
used++;
}
}
/* merge blocks until all are well separated */
have_merged = 1;
while (used >= 2 && have_merged)
{
have_merged = 0;
for (i = 0; i < used && !have_merged; i++)
{
for (j = i + 1; j < used && !have_merged; j++)
{
if (_arf_are_close(blocks + i, blocks + j, prec))
{
arf_add(blocks + i, blocks + i, blocks + j,
ARF_PREC_EXACT, ARF_RND_DOWN);
/* remove the merged block */
arf_swap(blocks + j, blocks + used - 1);
used--;
/* remove the updated block if the sum is zero */
if (arf_is_zero(blocks + i))
{
arf_swap(blocks + i, blocks + used - 1);
used--;
}
have_merged = 1;
}
}
}
}
if (used == 0)
{
arf_zero(s);
res = 0;
}
else if (used == 1)
{
res = arf_set_round(s, blocks + 0, prec, rnd);
}
else
{
/* find the two largest blocks */
for (i = 1; i < used; i++)
if (arf_cmpabs(blocks + 0, blocks + i) < 0)
arf_swap(blocks + 0, blocks + i);
for (i = 2; i < used; i++)
if (arf_cmpabs(blocks + 1, blocks + i) < 0)
arf_swap(blocks + 1, blocks + i);
res = _arf_add_eps(s, blocks + 0, arf_sgn(blocks + 1), prec, rnd);
}
for (i = 0; i < len; i++)
arf_clear(blocks + i);
flint_free(blocks);
return res;
}