int acb_cmp_pretty(const acb_t a, const acb_t b)
{
arb_t t, u, v;
int res;
arb_init(t);
arb_init(u);
arb_init(v);
arb_abs(u, acb_imagref(a));
arb_abs(v, acb_imagref(b));
arb_sub(t, u, v, MAG_BITS);
res = 0;
if (arb_contains_zero(t))
{
arb_sub(t, acb_realref(a), acb_realref(b), MAG_BITS);
res = arb_is_positive(t) ? 1 : -1;
}
else
{
res = arb_is_positive(t) ? 1 : -1;
}
arb_clear(t);
arb_clear(u);
arb_clear(v);
return res;
}
int
f_thsh(arb_t max, const arb_t t, params_t * p, slong prec)
{
arb_sinh(max, t, prec);
arb_tanh(max, max, prec);
arb_abs(max, max);
return 1;
}
void
arb_div_2expm1_ui(arb_t y, const arb_t x, ulong n, long prec)
{
if (n < FLINT_BITS)
{
arb_div_ui(y, x, (1UL << n) - 1, prec);
}
else if (n < 1024 + prec / 32 || n > LONG_MAX / 4)
{
arb_t t;
fmpz_t e;
arb_init(t);
fmpz_init_set_ui(e, n);
arb_one(t);
arb_mul_2exp_fmpz(t, t, e);
arb_sub_ui(t, t, 1, prec);
arb_div(y, x, t, prec);
arb_clear(t);
fmpz_clear(e);
}
else
{
arb_t s, t;
long i, b;
arb_init(s);
arb_init(t);
/* x / (2^n - 1) = sum_{k>=1} x * 2^(-k*n)*/
arb_mul_2exp_si(s, x, -n);
arb_set(t, s);
b = 1;
for (i = 2; i <= prec / n + 1; i++)
{
arb_mul_2exp_si(t, t, -n);
arb_add(s, s, t, prec);
b = i;
}
/* error bound: sum_{k>b} x * 2^(-k*n) <= x * 2^(-b*n - (n-1)) */
arb_mul_2exp_si(t, x, -b*n - (n-1));
arb_abs(t, t);
arb_add_error(s, t);
arb_set(y, s);
arb_clear(s);
arb_clear(t);
}
}
/* 0.5*(B/AN)^2 + |B|/AN */
static void
bound_C(arb_t C, const arb_t AN, const arb_t B, slong wp)
{
arb_t t;
arb_init(t);
arb_abs(t, B);
arb_div(t, t, AN, wp);
arb_mul_2exp_si(C, t, -1);
arb_add_ui(C, C, 1, wp);
arb_mul(C, C, t, wp);
arb_clear(t);
}
void
acb_acosh(acb_t res, const acb_t z, slong prec)
{
if (acb_is_one(z))
{
acb_zero(res);
}
else
{
acb_t t, u;
acb_init(t);
acb_init(u);
acb_add_ui(t, z, 1, prec);
acb_sub_ui(u, z, 1, prec);
acb_sqrt(t, t, prec);
acb_sqrt(u, u, prec);
acb_mul(t, t, u, prec);
acb_add(t, t, z, prec);
if (!arb_is_zero(acb_imagref(z)))
{
acb_log(res, t, prec);
}
else
{
/* pure imaginary on (-1,1) */
arb_abs(acb_realref(u), acb_realref(z));
arb_one(acb_imagref(u));
acb_log(res, t, prec);
if (arb_lt(acb_realref(u), acb_imagref(u)))
arb_zero(acb_realref(res));
}
acb_clear(t);
acb_clear(u);
}
}
/* derivatives: |8/sqrt(pi) sin(2z^2)|, |8/sqrt(pi) cos(2z^2)| <= 5 exp(4|xy|) */
void
acb_hypgeom_fresnel_erf_error(acb_t res1, acb_t res2, const acb_t z, slong prec)
{
mag_t re;
mag_t im;
acb_t zmid;
mag_init(re);
mag_init(im);
acb_init(zmid);
if (arf_cmpabs_ui(arb_midref(acb_realref(z)), 1000) < 0 &&
arf_cmpabs_ui(arb_midref(acb_imagref(z)), 1000) < 0)
{
arb_get_mag(re, acb_realref(z));
arb_get_mag(im, acb_imagref(z));
mag_mul(re, re, im);
mag_mul_2exp_si(re, re, 2);
mag_exp(re, re);
mag_mul_ui(re, re, 5);
}
else
{
arb_t t;
arb_init(t);
arb_mul(t, acb_realref(z), acb_imagref(z), prec);
arb_abs(t, t);
arb_mul_2exp_si(t, t, 2);
arb_exp(t, t, prec);
arb_get_mag(re, t);
mag_mul_ui(re, re, 5);
arb_clear(t);
}
mag_hypot(im, arb_radref(acb_realref(z)), arb_radref(acb_imagref(z)));
mag_mul(re, re, im);
if (arb_is_zero(acb_imagref(z)))
{
mag_set_ui(im, 8); /* For real x, |S(x)| < 4, |C(x)| < 4. */
mag_min(re, re, im);
mag_zero(im);
}
else if (arb_is_zero(acb_realref(z)))
{
mag_set_ui(im, 8);
mag_min(im, re, im);
mag_zero(re);
}
else
{
mag_set(im, re);
}
arf_set(arb_midref(acb_realref(zmid)), arb_midref(acb_realref(z)));
arf_set(arb_midref(acb_imagref(zmid)), arb_midref(acb_imagref(z)));
acb_hypgeom_fresnel_erf(res1, res2, zmid, prec);
if (res1 != NULL)
{
arb_add_error_mag(acb_realref(res1), re);
arb_add_error_mag(acb_imagref(res1), im);
}
if (res2 != NULL)
{
arb_add_error_mag(acb_realref(res2), re);
arb_add_error_mag(acb_imagref(res2), im);
}
mag_clear(re);
mag_clear(im);
acb_clear(zmid);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("l_euler_product....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 500 * arb_test_multiplier(); iter++)
{
acb_t s, t, u;
dirichlet_group_t G;
dirichlet_char_t chi;
ulong q, k;
slong prec;
acb_init(s);
acb_init(t);
acb_init(u);
q = 1 + n_randint(state, 50);
prec = 2 + n_randint(state, 500);
k = n_randint(state, n_euler_phi(q));
dirichlet_group_init(G, q);
dirichlet_char_init(chi, G);
dirichlet_char_index(chi, G, k);
if (n_randint(state, 2))
{
acb_set_ui(s, 2 + n_randint(state, prec + 50));
}
else
{
acb_randtest(s, state, 2 + n_randint(state, 200), 2);
arb_abs(acb_realref(s), acb_realref(s));
if (n_randint(state, 2))
acb_add_ui(s, s, n_randtest(state), prec);
}
if (n_randint(state, 2))
acb_dirichlet_l_hurwitz(t, s, NULL, G, chi, prec);
else
acb_dirichlet_l_euler_product(t, s, G, chi, prec * 1.5);
acb_dirichlet_l_euler_product(u, s, G, chi, prec);
if (!acb_overlaps(t, u))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("iter = %ld q = %lu k = %lu prec = %ld\n\n", iter, q, k, prec);
flint_printf("s = "); acb_printn(s, 100, 0); flint_printf("\n\n");
flint_printf("t = "); acb_printn(t, 100, 0); flint_printf("\n\n");
flint_printf("u = "); acb_printn(u, 100, 0); flint_printf("\n\n");
abort();
}
dirichlet_char_clear(chi);
dirichlet_group_clear(G);
acb_clear(s);
acb_clear(t);
acb_clear(u);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
arb_set_str(arb_t res, const char * inp, slong prec)
{
char * buf;
char * split;
char * first;
char * last;
slong i, len;
int error;
error = 0;
len = strlen(inp);
buf = flint_malloc(len + 1);
for (i = 0; i <= len; i++)
buf[i] = tolower(inp[i]);
split = strstr(buf, "+/-");
if (split == NULL)
{
/* strip whitespace and brackets */
first = buf;
while (isspace(first[0]) || first[0] == '[')
first++;
last = buf + len;
while (last - first > 0 && (isspace(last[-1]) || last[-1] == ']'))
last--;
last[0] = '\0';
error = arb_set_float_str(res, first, prec);
}
else
{
arb_t rad;
arb_init(rad);
/* strip whitespace and brackets */
first = buf;
while (isspace(first[0]) || first[0] == '[')
first++;
last = split;
while (last - first > 0 && (isspace(last[-1]) || last[-1] == ']'))
last--;
last[0] = '\0';
if (first == last)
arb_zero(res);
else
error = arb_set_float_str(res, first, prec);
if (!error)
{
/* strip whitespace and brackets */
first = split + 3;
while (isspace(first[0]) || first[0] == '[')
first++;
last = buf + len;
while (last - first > 0 && (isspace(last[-1]) || last[-1] == ']'))
last--;
last[0] = '\0';
error = arb_set_float_str(rad, first, prec);
arb_abs(rad, rad);
arb_add_error(res, rad);
}
arb_clear(rad);
}
flint_free(buf);
return error;
}
int main()
{
flint_rand_t state;
arb_t t, u, v;
double x;
int error, bracket;
char tmp[256];
long i, j;
printf("set_str....");
fflush(stdout);
flint_randinit(state);
arb_init(t);
arb_init(u);
arb_init(v);
flint_randinit(state);
for (i = 0; testdata_floats[i] != NULL; i++)
{
arb_const_pi(t, 53);
error = arb_set_str(t, testdata_floats[i], 53);
x = strtod(testdata_floats[i], NULL);
if (x != x)
{
arb_indeterminate(u);
}
else
{
arf_set_d(arb_midref(u), x);
mag_zero(arb_radref(u));
}
if (error != 0 || !arb_equal(t, u))
{
printf("FAIL (valid input): %s\n", testdata_floats[i]);
arb_printd(t, 15); printf("\n");
arb_printd(u, 15); printf("\n");
abort();
}
}
for (i = 0; testdata_floats[i] != NULL; i++)
{
for (j = 0; testdata_floats[j] != NULL; j++)
{
for (bracket = 0; bracket < 2; bracket++)
{
arb_const_pi(t, 53);
bracket = n_randint(state, 2);
strcpy(tmp, "");
if (bracket)
strcat(tmp, "[");
/* allow empty string for midpoint */
strcat(tmp, (i == 0) ? "" : testdata_floats[i]);
strcat(tmp, "+/-");
strcat(tmp, testdata_floats[j]);
if (bracket)
strcat(tmp, "]");
error = arb_set_str(t, tmp, 53);
x = strtod((i == 0) ? "0" : testdata_floats[i], NULL);
if (x != x)
{
arb_indeterminate(u);
}
else
{
arf_set_d(arb_midref(u), x);
mag_zero(arb_radref(u));
}
x = strtod(testdata_floats[j], NULL);
arf_set_d(arb_midref(v), x);
mag_zero(arb_radref(v));
arb_abs(v, v);
arb_add_error(u, v);
if (error != 0 || !arb_equal(t, u))
{
printf("FAIL (valid input): %s\n", tmp);
arb_printd(t, 15); printf("\n");
arb_printd(u, 15); printf("\n");
abort();
}
}
}
}
for (i = 0; testdata_invalid[i] != NULL; i++)
{
arb_const_pi(t, 53);
error = arb_set_str(t, testdata_invalid[i], 53);
if (error == 0)
{
printf("FAIL (invalid input): %s\n", testdata_invalid[i]);
arb_printd(t, 15); printf("\n");
abort();
}
}
for (i = 0; testdata_invalid[i] != NULL; i++)
{
for (j = 0; testdata_invalid[j] != NULL; j++)
{
for (bracket = 0; bracket < 2; bracket++)
{
arb_const_pi(t, 53);
bracket = n_randint(state, 2);
strcpy(tmp, "");
if (bracket)
strcat(tmp, "[");
strcat(tmp, testdata_invalid[i]);
strcat(tmp, "+/-");
strcat(tmp, testdata_invalid[j]);
if (bracket)
strcat(tmp, "]");
error = arb_set_str(t, tmp, 53);
if (error == 0)
{
printf("FAIL (invalid input): %s\n", tmp);
arb_printd(t, 15); printf("\n");
abort();
}
}
}
}
arb_clear(t);
arb_clear(u);
arb_clear(v);
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
