/* sample (x, y) so that x /in y */
void _sample_arf_in_arb(arf_t x, arb_t y, flint_rand_t state)
{
slong bits, prec, expbits;
arf_t a, b;
slong i, n;
arf_init(a);
arf_init(b);
bits = 2 + n_randint(state, 1000);
prec = 2 + n_randint(state, 1000);
expbits = n_randint(state, 14);
n = n_randint(state, 3);
arf_randtest(x, state, bits, expbits);
arf_set(a, x);
arf_set(b, x);
for (i = 0; i < n; i++)
{
arf_randtest(x, state, bits, expbits);
arf_min(a, a, x);
arf_max(b, b, x);
}
arb_set_interval_arf(y, a, b, prec);
arf_clear(a);
arf_clear(b);
}
void
arb_max(arb_t z, const arb_t x, const arb_t y, slong prec)
{
arf_t left, right, t, xr, yr;
if (arf_is_nan(arb_midref(x)) || arf_is_nan(arb_midref(y)))
{
arb_indeterminate(z);
return;
}
arf_init(left);
arf_init(right);
arf_init(t);
arf_init_set_mag_shallow(xr, arb_radref(x));
arf_init_set_mag_shallow(yr, arb_radref(y));
arf_sub(left, arb_midref(x), xr, prec, ARF_RND_FLOOR);
arf_sub(t, arb_midref(y), yr, prec, ARF_RND_FLOOR);
arf_max(left, left, t);
arf_add(right, arb_midref(x), xr, prec, ARF_RND_CEIL);
arf_add(t, arb_midref(y), yr, prec, ARF_RND_CEIL);
arf_max(right, right, t);
arb_set_interval_arf(z, left, right, prec);
arf_clear(left);
arf_clear(right);
arf_clear(t);
}
int
mag_close(const mag_t am, const mag_t bm)
{
arf_t t, a, b;
int res1, res2;
arf_init(t);
arf_init(a);
arf_init(b);
arf_set_mag(a, am);
arf_set_mag(b, bm);
arf_mul_ui(t, b, 257, MAG_BITS, ARF_RND_UP);
arf_mul_2exp_si(t, t, -8);
res1 = arf_cmp(a, t) <= 0;
arf_mul_ui(t, a, 257, MAG_BITS, ARF_RND_UP);
arf_mul_2exp_si(t, t, -8);
res2 = arf_cmp(b, t) <= 0;
arf_clear(t);
arf_clear(a);
arf_clear(b);
return res1 && res2;
}
int main() {
#define ni 5
slong n, i, f;
double b[ni][2] = { { 0, 1}, {-1, 1}, {0, 10}, {-20, 3}, {0, 3.14} };
const slong prec = 40;
#define nf 5
arb_func_t func[nf] = { (arb_func_t)&f_1x2, (arb_func_t)&f_pol, (arb_func_t)&f_thsh, (arb_func_t)&f_thsh_shift, (arb_func_t)&f_aj };
#if VERBOSE
char * fn[nf] = { "1/(1+x^2)", "1/p(x)", "th(sh(x))", "th(sh(x+.7I))" , "1/y" };
#endif
params_t p[nf];
arf_t tmin, tmax;
mag_t max;
flint_printf("max_func...");
fflush(stdout);
p[1].len = 3;
p[1].z = _acb_vec_init(3);
acb_set_d_d(p[1].z + 0, 2, 1);
acb_set_d_d(p[1].z + 1, 2, .1);
acb_set_d_d(p[1].z + 2, 1, .1);
p[4] = p[1];
arf_init(tmin);
arf_init(tmax);
mag_init(max);
for (i = 0; i < ni; i++)
{
arf_set_d(tmin, b[i][0]);
arf_set_d(tmax, b[i][1]);
for (f = 0; f < nf; f++)
{
for (n = 5; n < 100; n *= 2)
{
slong count;
count = mag_func_arf(max, func[f], (void *)&p[f], tmin, tmax, n, prec);
#if VERBOSE
flint_printf("\nmax %s on [%lf, %lf] <= ",fn[f],b[i][0],b[i][1]);
mag_printd(max,8);
flint_printf(" [asked %ld, did %ld]", n, count);
#endif
}
}
}
mag_clear(max);
arf_clear(tmin);
arf_clear(tmax);
printf("PASS\n");
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_mag....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t a;
arf_t m2, x, y, s;
mag_t m;
acb_init(a);
mag_init(m);
arf_init(m2);
arf_init(x);
arf_init(y);
arf_init(s);
acb_randtest_special(a, state, 200, 10);
acb_get_mag(m, a);
MAG_CHECK_BITS(m)
/* check m^2 >= x^2 + y^2 */
arf_set_mag(m2, m);
arf_mul(m2, m2, m2, ARF_PREC_EXACT, ARF_RND_DOWN);
arb_get_abs_ubound_arf(x, acb_realref(a), ARF_PREC_EXACT);
arb_get_abs_ubound_arf(y, acb_imagref(a), ARF_PREC_EXACT);
arf_sosq(s, x, y, ARF_PREC_EXACT, ARF_RND_DOWN);
if (arf_cmp(m2, s) < 0)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("m = "); mag_print(m); flint_printf("\n\n");
flint_abort();
}
acb_clear(a);
mag_clear(m);
arf_clear(m2);
arf_clear(x);
arf_clear(y);
arf_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
arb_richcmp_fallback(const arb_t x, const arb_t y, int op)
{
arf_t xa, xb, ya, yb;
int res;
arf_init(xa);
arf_init(xb);
arf_init(ya);
arf_init(yb);
arb_infimum(xa, x);
arb_supremum(xb, x);
arb_infimum(ya, y);
arb_supremum(yb, y);
if (arf_is_nan(xa) || arf_is_nan(ya))
{
res = 0;
}
else
{
if (op == 0) /* eq */
{
res = arf_equal(xa, xb) && arf_equal(ya, yb) && arf_equal(xa, ya);
}
else if (op == 1) /* ne */
{
res = (arf_cmp(yb, xa) < 0) || (arf_cmp(xb, ya) < 0);
}
else if (op == 2) /* le */
{
res = (arf_cmp(xb, ya) <= 0);
}
else if (op == 3) /* lt */
{
res = (arf_cmp(xb, ya) < 0);
}
else if (op == 4) /* ge */
{
res = (arf_cmp(xa, yb) >= 0);
}
else /* gt */
{
res = (arf_cmp(xa, yb) > 0);
}
}
arf_clear(xa);
arf_clear(xb);
arf_clear(ya);
arf_clear(yb);
return res;
}
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 main()
{
slong iter;
flint_rand_t state;
flint_printf("set_interval_mpfr....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
arb_t x;
arf_t a, b;
mpfr_t aa, bb;
arb_init(x);
arf_init(a);
arf_init(b);
mpfr_init2(aa, 200);
mpfr_init2(bb, 200);
arf_randtest_special(a, state, 200, 10);
arf_randtest_special(b, state, 200, 10);
if (arf_cmp(a, b) > 0)
arf_swap(a, b);
arf_get_mpfr(aa, a, MPFR_RNDD);
arf_get_mpfr(bb, b, MPFR_RNDU);
arb_set_interval_mpfr(x, aa, bb, 2 + n_randint(state, 200));
if (!arb_contains_arf(x, a) || !arb_contains_arf(x, b))
{
flint_printf("FAIL:\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("a = "); arf_print(a); flint_printf("\n\n");
flint_printf("b = "); arf_print(b); flint_printf("\n\n");
abort();
}
arb_clear(x);
arf_clear(a);
arf_clear(b);
mpfr_clear(aa);
mpfr_clear(bb);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("set_fmpq....");
fflush(stdout);
flint_randinit(state);
/* test exact roundtrip R -> Q -> R */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
slong bits, res;
arf_t x, z;
fmpq_t y;
bits = 2 + n_randint(state, 200);
arf_init(x);
arf_init(z);
fmpq_init(y);
arf_randtest(x, state, bits, 10);
arf_randtest(z, state, bits, 10);
arf_get_fmpq(y, x);
res = arf_set_fmpq(z, y, bits, ARF_RND_DOWN);
if (!arf_equal(x, z) || res != 0)
{
flint_printf("FAIL\n\n");
flint_printf("bits: %wd\n", bits);
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpq_print(y); flint_printf("\n\n");
flint_printf("z = "); arf_print(z); flint_printf("\n\n");
abort();
}
arf_clear(x);
arf_clear(z);
fmpq_clear(y);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
partitions_fmpz_fmpz_hrr(fmpz_t p, const fmpz_t n, int use_doubles)
{
arb_t x;
arf_t bound;
slong N;
arb_init(x);
arf_init(bound);
N = partitions_hrr_needed_terms(fmpz_get_d(n));
if (fmpz_cmp_ui(n, 4e8) >= 0 && flint_get_num_threads() > 1)
{
hrr_sum_threaded(x, n, N, use_doubles);
}
else
{
partitions_hrr_sum_arb(x, n, 1, N, use_doubles);
}
partitions_rademacher_bound(bound, n, N);
arb_add_error_arf(x, bound);
if (!arb_get_unique_fmpz(p, x))
{
flint_printf("not unique!\n");
arb_printd(x, 50);
flint_printf("\n");
abort();
}
arb_clear(x);
arf_clear(bound);
}
int
_arf_add_eps(arf_t s, const arf_t x, int sgn, long prec, arf_rnd_t rnd)
{
arf_t t;
long bits;
bits = arf_bits(x);
if (bits == 0)
{
printf("_arf_add_eps\n");
abort();
}
bits = FLINT_MAX(bits, prec) + 10;
arf_init(t);
arf_set_si(t, sgn);
arf_mul_2exp_fmpz(t, t, ARF_EXPREF(x));
arf_mul_2exp_si(t, t, -bits);
arf_add(s, x, t, prec, rnd);
arf_clear(t);
return 1;
}
void
arb_log_arf_huge(arb_t z, const arf_t x, slong prec)
{
arf_t t;
arb_t c;
fmpz_t exp;
slong wp;
arf_init(t);
arb_init(c);
fmpz_init(exp);
fmpz_neg(exp, ARF_EXPREF(x));
arf_mul_2exp_fmpz(t, x, exp);
wp = prec + 4 - fmpz_bits(exp);
wp = FLINT_MAX(wp, 4);
arb_log_arf(z, t, wp);
arb_const_log2(c, prec + 4);
arb_submul_fmpz(z, c, exp, prec);
arf_clear(t);
arb_clear(c);
fmpz_clear(exp);
}
int arb_calc_partition(arf_interval_t L, arf_interval_t R,
arb_calc_func_t func, void * param, const arf_interval_t block, slong prec)
{
arb_t t, m;
arf_t u;
int msign;
arb_init(t);
arb_init(m);
arf_init(u);
/* Compute the midpoint (TODO: try other points) */
arf_add(u, &block->a, &block->b, ARF_PREC_EXACT, ARF_RND_DOWN);
arf_mul_2exp_si(u, u, -1);
/* Evaluate and get sign at midpoint */
arb_set_arf(m, u);
func(t, m, param, 1, prec);
msign = _arb_sign(t);
/* L, R = block, split at midpoint */
arf_set(&L->a, &block->a);
arf_set(&R->b, &block->b);
arf_set(&L->b, u);
arf_set(&R->a, u);
arb_clear(t);
arb_clear(m);
arf_clear(u);
return msign;
}
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 __inline__ void
arb_nonnegative_part(arb_t z, const arb_t x, long prec)
{
if (arb_contains_negative(x))
{
arf_t t;
arf_init(t);
arf_set_mag(t, arb_radref(x));
arf_add(arb_midref(z), arb_midref(x), t, MAG_BITS, ARF_RND_CEIL);
if (arf_sgn(arb_midref(z)) <= 0)
{
mag_zero(arb_radref(z));
}
else
{
arf_mul_2exp_si(arb_midref(z), arb_midref(z), -1);
arf_get_mag(arb_radref(z), arb_midref(z));
/* XXX: needed since arf_get_mag is inexact */
arf_set_mag(arb_midref(z), arb_radref(z));
}
arf_clear(t);
}
else
{
arb_set(z, x);
}
}
void
_acb_poly_zeta_cpx_series(acb_ptr z, const acb_t s, const acb_t a, int deflate, long d, long prec)
{
ulong M, N;
long i;
arf_t bound;
arb_ptr vb;
if (d < 1)
return;
if (!acb_is_finite(s) || !acb_is_finite(a))
{
_acb_vec_indeterminate(z, d);
return;
}
arf_init(bound);
vb = _arb_vec_init(d);
_acb_poly_zeta_em_choose_param(bound, &N, &M, s, a, FLINT_MIN(d, 2), prec, MAG_BITS);
_acb_poly_zeta_em_bound(vb, s, a, N, M, d, MAG_BITS);
_acb_poly_zeta_em_sum(z, s, a, deflate, N, M, d, prec);
for (i = 0; i < d; i++)
{
arb_get_abs_ubound_arf(bound, vb + i, MAG_BITS);
arb_add_error_arf(acb_realref(z + i), bound);
arb_add_error_arf(acb_imagref(z + i), bound);
}
arf_clear(bound);
_arb_vec_clear(vb, d);
}
void Lib_Arb_Set_Mpfr(ArbPtr x, MpfrPtr a)
{
arf_t rop;
arf_init(rop);
arf_set_mpfr(rop, (mpfr_ptr) a);
arb_set_arf((arb_ptr) x, rop);
arf_clear(rop);
}
void Lib_Arb_Set_D(ArbPtr x, double d)
{
arf_t rop;
arf_init(rop);
arf_set_d(rop, d);
arb_set_arf((arb_ptr)x, rop);
arf_clear(rop);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_interval_fmpz_2exp....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
arb_t x;
arf_t y;
fmpz_t a, b, exp;
arb_init(x);
arf_init(y);
fmpz_init(a);
fmpz_init(b);
fmpz_init(exp);
arb_randtest(x, state, 200, 10);
arb_get_interval_fmpz_2exp(a, b, exp, x);
arf_set_fmpz_2exp(y, a, exp);
if (!arb_contains_arf(x, y))
{
flint_printf("FAIL:\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("a = "); fmpz_print(a);
flint_printf(" exp = "); fmpz_print(exp); flint_printf("\n\n");
abort();
}
arf_set_fmpz_2exp(y, b, exp);
if (!arb_contains_arf(x, y))
{
flint_printf("FAIL:\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("b = "); fmpz_print(b);
flint_printf(" exp = "); fmpz_print(exp); flint_printf("\n\n");
abort();
}
arb_clear(x);
arf_clear(y);
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(exp);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
arb_log_ui(arb_t z, ulong x, slong prec)
{
arf_t t;
arf_init(t);
arf_set_ui(t, x);
arb_log_arf(z, t, prec);
arf_clear(t);
}
void
arb_log_fmpz(arb_t z, const fmpz_t x, slong prec)
{
arf_t t;
arf_init(t);
arf_set_fmpz(t, x);
arb_log_arf(z, t, prec);
arf_clear(t);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_interval_arf....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arb_t x, y;
arf_t a, b;
arb_init(x);
arf_init(a);
arf_init(b);
arb_init(y);
arb_randtest_special(x, state, 200, 100);
arb_get_interval_arf(a, b, x, 2 + n_randint(state, 200));
arb_set_interval_arf(y, a, b, 2 + n_randint(state, 200));
if (!arb_contains(y, x))
{
flint_printf("FAIL:\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("a = "); arf_print(a); flint_printf("\n\n");
flint_printf("b = "); arf_print(b); flint_printf("\n\n");
flint_printf("y = "); arb_print(y); flint_printf("\n\n");
abort();
}
arb_clear(x);
arf_clear(a);
arf_clear(b);
arb_clear(y);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_mpfr....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
slong bits;
arf_t x, z;
mpfr_t y;
bits = 2 + n_randint(state, 200);
arf_init(x);
arf_init(z);
mpfr_init2(y, bits);
arf_randtest_special(x, state, bits, 10);
arf_get_mpfr(y, x, MPFR_RNDN);
arf_set_mpfr(z, y);
if (!arf_equal(x, z))
{
flint_printf("FAIL\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("z = "); arf_print(z); flint_printf("\n\n");
abort();
}
arf_clear(x);
arf_clear(z);
mpfr_clear(y);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("set_d....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
double x;
arf_t y, z;
mpfr_t m;
arf_init(y);
arf_init(z);
mpfr_init2(m, 53);
x = d_randtest_special(state, -1200, 1200);
arf_set_d(y, x);
mpfr_set_d(m, x, MPFR_RNDN);
arf_set_mpfr(z, m);
if (!arf_equal(y, z))
{
flint_printf("FAIL:\n\n");
flint_printf("x = %.17g\n\n", x);
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("z = "); arf_print(z); flint_printf("\n\n");
flint_abort();
}
arf_clear(y);
arf_clear(z);
mpfr_clear(m);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_modular_lambda(acb_t r, const acb_t tau, long prec)
{
psl2z_t g;
arf_t one_minus_eps;
acb_t tau_prime, q;
acb_struct thetas[4];
int R[4], S[4], C;
int Rsum, qpower;
psl2z_init(g);
arf_init(one_minus_eps);
acb_init(tau_prime);
acb_init(q);
acb_init(thetas + 0);
acb_init(thetas + 1);
acb_init(thetas + 2);
acb_init(thetas + 3);
arf_set_ui_2exp_si(one_minus_eps, 63, -6);
acb_modular_fundamental_domain_approx(tau_prime, g, tau,
one_minus_eps, prec);
acb_modular_theta_transform(R, S, &C, g);
acb_exp_pi_i(q, tau_prime, prec);
acb_modular_theta_const_sum(thetas + 1, thetas + 2, thetas + 3, q, prec);
acb_zero(thetas + 0);
/* divide the transformation factors */
Rsum = 4 * (R[1] - R[2]);
/* possible factor [q^(+/- 1/4)]^4 needed for theta_1^4 or theta_2^4 */
qpower = (S[1] == 0 || S[1] == 1) - (S[2] == 0 || S[2] == 1);
acb_div(r, thetas + S[1], thetas + S[2], prec);
acb_mul(r, r, r, prec);
acb_mul(r, r, r, prec);
if ((Rsum & 7) == 4)
acb_neg(r, r);
if (qpower == 1)
acb_mul(r, r, q, prec);
else if (qpower == -1)
acb_div(r, r, q, prec);
psl2z_clear(g);
arf_clear(one_minus_eps);
acb_clear(tau_prime);
acb_clear(q);
acb_clear(thetas + 0);
acb_clear(thetas + 1);
acb_clear(thetas + 2);
acb_clear(thetas + 3);
}
int
arb_contains_si(const arb_t x, slong y)
{
int ans;
arf_t t;
arf_init(t);
arf_set_si(t, y);
ans = arb_contains_arf(x, t);
arf_clear(t);
return ans;
}
int
arf_mul_fmpz_naive(arf_t z, const arf_t x, const fmpz_t y, slong prec, arf_rnd_t rnd)
{
arf_t t;
int r;
arf_init(t);
arf_set_fmpz(t, y);
r = arf_mul(z, x, t, prec, rnd);
arf_clear(t);
return r;
}
int
arb_contains_fmpz(const arb_t x, const fmpz_t y)
{
int ans;
arf_t t;
arf_init(t);
arf_set_fmpz(t, y);
ans = arb_contains_arf(x, t);
arf_clear(t);
return ans;
}
int
arf_add_si_naive(arf_t z, const arf_t x, slong y, slong prec, arf_rnd_t rnd)
{
arf_t t;
int r;
arf_init(t);
arf_set_si(t, y);
r = arf_add(z, x, t, prec, rnd);
arf_clear(t);
return r;
}
int
arf_add_fmpz_2exp_naive(arf_t z, const arf_t x,
const fmpz_t y, const fmpz_t e, slong prec, arf_rnd_t rnd)
{
arf_t t;
int r;
arf_init(t);
arf_set_fmpz_2exp(t, y, e);
r = arf_add(z, x, t, prec, rnd);
arf_clear(t);
return r;
}
