void
arb_agm(arb_t z, const arb_t x, const arb_t y, long prec)
{
arb_t t, u, v, w;
if (arb_contains_negative(x) || arb_contains_negative(y))
{
arb_indeterminate(z);
return;
}
if (arb_is_zero(x) || arb_is_zero(y))
{
arb_zero(z);
return;
}
arb_init(t);
arb_init(u);
arb_init(v);
arb_init(w);
arb_set(t, x);
arb_set(u, y);
while (!arb_overlaps(t, u) &&
!arb_contains_nonpositive(t) &&
!arb_contains_nonpositive(u))
{
arb_add(v, t, u, prec);
arb_mul_2exp_si(v, v, -1);
arb_mul(w, t, u, prec);
arb_sqrt(w, w, prec);
arb_swap(v, t);
arb_swap(w, u);
}
if (!arb_is_finite(t) || !arb_is_finite(u))
{
arb_indeterminate(z);
}
else
{
arb_union(z, t, u, prec);
}
arb_clear(t);
arb_clear(u);
arb_clear(v);
arb_clear(w);
}
void
arb_hypgeom_ei(arb_t res, const arb_t z, slong prec)
{
if (!arb_is_finite(z))
{
arb_indeterminate(res);
}
else
{
acb_t t;
acb_init(t);
arb_set(acb_realref(t), z);
acb_hypgeom_ei(t, t, prec);
arb_swap(res, acb_realref(t));
acb_clear(t);
}
}
void
arb_hypgeom_fresnel(arb_t res1, arb_t res2, const arb_t z, int normalized, slong prec)
{
if (!arb_is_finite(z))
{
if (res1 != NULL) arb_indeterminate(res1);
if (res2 != NULL) arb_indeterminate(res2);
}
else
{
acb_t t, u;
acb_init(t);
acb_init(u);
arb_set(acb_realref(t), z);
acb_hypgeom_fresnel(res1 ? t : NULL, res2 ? u : NULL, t, normalized, prec);
if (res1 != NULL) arb_swap(res1, acb_realref(t));
if (res2 != NULL) arb_swap(res2, acb_realref(u));
acb_clear(t);
acb_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);
}
static int
check_block(arb_calc_func_t func, void * param, const arf_interval_t block,
int asign, int bsign, slong prec)
{
arb_struct t[2];
arb_t x;
int result;
arb_init(t + 0);
arb_init(t + 1);
arb_init(x);
arf_interval_get_arb(x, block, prec);
func(t, x, param, 1, prec);
result = BLOCK_UNKNOWN;
if (arb_is_positive(t) || arb_is_negative(t))
{
result = BLOCK_NO_ZERO;
}
else
{
if ((asign < 0 && bsign > 0) || (asign > 0 && bsign < 0))
{
func(t, x, param, 2, prec);
if (arb_is_finite(t + 1) && !arb_contains_zero(t + 1))
{
result = BLOCK_ISOLATED_ZERO;
}
}
}
arb_clear(t + 0);
arb_clear(t + 1);
arb_clear(x);
return result;
}
int
arb_get_unique_fmpz(fmpz_t z, const arb_t x)
{
if (!arb_is_finite(x))
{
return 0;
}
else if (arb_is_exact(x))
{
/* x = b*2^e, e >= 0 */
if (arf_is_int(arb_midref(x)))
{
/* arf_get_fmpz aborts on overflow */
arf_get_fmpz(z, arb_midref(x), ARF_RND_DOWN);
return 1;
}
else
{
return 0;
}
}
/* if the radius is >= 1, there are at least two integers */
else if (mag_cmp_2exp_si(arb_radref(x), 0) >= 0)
{
return 0;
}
/* there are 0 or 1 integers if the radius is < 1 */
else
{
fmpz_t a, b, exp;
int res;
/* if the midpoint is exactly an integer, it is what we want */
if (arf_is_int(arb_midref(x)))
{
/* arf_get_fmpz aborts on overflow */
arf_get_fmpz(z, arb_midref(x), ARF_RND_DOWN);
return 1;
}
fmpz_init(a);
fmpz_init(b);
fmpz_init(exp);
/* if the radius is tiny, it can't be an integer */
arf_bot(a, arb_midref(x));
if (fmpz_cmp(a, MAG_EXPREF(arb_radref(x))) > 0)
{
res = 0;
}
else
{
arb_get_interval_fmpz_2exp(a, b, exp, x);
if (COEFF_IS_MPZ(*exp))
{
flint_printf("arb_get_unique_fmpz: input too large\n");
abort();
}
if (*exp >= 0)
{
res = fmpz_equal(a, b);
if (res)
{
fmpz_mul_2exp(a, a, *exp);
fmpz_mul_2exp(b, b, *exp);
}
}
else
{
fmpz_cdiv_q_2exp(a, a, -(*exp));
fmpz_fdiv_q_2exp(b, b, -(*exp));
res = fmpz_equal(a, b);
}
if (res)
fmpz_set(z, a);
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(exp);
return res;
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("hurwitz_zeta....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c;
acb_t d, e, f;
slong prec;
prec = 2 + n_randint(state, 300);
arb_init(a);
arb_init(b);
arb_init(c);
acb_init(d);
acb_init(e);
acb_init(f);
arb_randtest_precise(a, state, 1 + n_randint(state, 300), 5);
arb_randtest_precise(b, state, 1 + n_randint(state, 300), 5);
arb_randtest_precise(c, state, 1 + n_randint(state, 300), 5);
acb_set_arb(d, a);
acb_set_arb(e, b);
arb_hurwitz_zeta(c, a, b, prec);
acb_hurwitz_zeta(f, d, e, prec);
if (!arb_overlaps(c, acb_realref(f)) ||
(arb_is_finite(c) && !arb_contains_zero(acb_imagref(f))))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); arb_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); arb_printd(c, 15); flint_printf("\n\n");
flint_printf("d = "); acb_printd(d, 15); flint_printf("\n\n");
flint_printf("e = "); acb_printd(e, 15); flint_printf("\n\n");
flint_printf("f = "); acb_printd(f, 15); flint_printf("\n\n");
flint_abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
acb_clear(d);
acb_clear(e);
acb_clear(f);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
