void
fmprb_sqrt_ui(fmprb_t z, ulong x, slong prec)
{
fmprb_t t;
fmprb_init(t);
fmprb_set_ui(t, x);
fmprb_sqrt(z, t, prec);
fmprb_clear(t);
}
void
fmprb_ui_pow_ui(fmprb_t y, ulong b, ulong e, long prec)
{
fmprb_t t;
fmprb_init(t);
fmprb_set_ui(t, b);
fmprb_pow_ui(y, t, e, prec);
fmprb_clear(t);
}
void
fmprb_add_ui(fmprb_t z, const fmprb_t x, ulong y, slong prec)
{
fmprb_t t;
fmprb_init(t);
fmprb_set_ui(t, y);
fmprb_add(z, x, t, prec);
fmprb_clear(t);
}
int main()
{
long iter;
flint_rand_t state;
printf("cauchy_bound....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100; iter++)
{
fmprb_t b, radius, ans;
fmpcb_t x;
long r, prec, maxdepth;
fmprb_init(b);
fmprb_init(radius);
fmpcb_init(x);
fmpcb_set_ui(x, 5);
r = 1 + n_randint(state, 10);
fmprb_set_ui(radius, r);
prec = 2 + n_randint(state, 100);
maxdepth = n_randint(state, 10);
fmpcb_calc_cauchy_bound(b, sin_x, NULL, x, radius, maxdepth, prec);
fmpr_set_d(fmprb_midref(ans), answers[r-1]);
fmpr_set_d(fmprb_radref(ans), 1e-8);
if (!fmprb_overlaps(b, ans))
{
printf("FAIL\n");
printf("r = %ld, prec = %ld, maxdepth = %ld\n\n", r, prec, maxdepth);
fmprb_printd(b, 15); printf("\n\n");
fmprb_printd(ans, 15); printf("\n\n");
abort();
}
fmprb_clear(b);
fmprb_clear(radius);
fmpcb_clear(x);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
long
gamma_taylor_bound_mag(long n)
{
fmprb_t t, u;
long v;
fmprb_init(t);
fmprb_init(u);
/* (pi-1) n */
fmprb_const_pi(t, FMPRB_RAD_PREC);
fmprb_sub_ui(t, t, 1, FMPRB_RAD_PREC);
fmprb_mul_ui(t, t, n, FMPRB_RAD_PREC);
/* (3-5n) log(n/6) */
fmprb_set_ui(u, n);
fmprb_div_ui(u, u, 6, FMPRB_RAD_PREC);
fmprb_log(u, u, FMPRB_RAD_PREC);
fmprb_mul_si(u, u, 3 - 5*n, FMPRB_RAD_PREC);
fmprb_add(t, t, u, FMPRB_RAD_PREC);
/* divide by 6 log(2) */
fmprb_log_ui(u, 2, FMPRB_RAD_PREC);
fmprb_mul_ui(u, u, 6, FMPRB_RAD_PREC);
fmprb_div(t, t, u, FMPRB_RAD_PREC);
/* upper bound */
fmpr_add(fmprb_midref(t), fmprb_midref(t), fmprb_radref(t),
FMPRB_RAD_PREC, FMPR_RND_CEIL);
v = fmpr_get_si(fmprb_midref(t), FMPR_RND_CEIL);
fmprb_clear(t);
fmprb_clear(u);
return v;
}
int main()
{
long iter;
flint_rand_t state;
printf("series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
fmpcb_t s, a;
fmpcb_ptr z1, z2;
long i, len, prec1, prec2;
int deflate;
fmpcb_init(s);
fmpcb_init(a);
if (n_randint(state, 2))
{
fmpcb_randtest(s, state, 1 + n_randint(state, 300), 3);
}
else
{
fmprb_set_ui(fmpcb_realref(s), 1);
fmprb_mul_2exp_si(fmpcb_realref(s), fmpcb_realref(s), -1);
fmprb_randtest(fmpcb_imagref(s), state, 1 + n_randint(state, 300), 4);
}
switch (n_randint(state, 3))
{
case 0:
fmpcb_randtest(a, state, 1 + n_randint(state, 300), 3);
break;
case 1:
fmprb_randtest(fmpcb_realref(a), state, 1 + n_randint(state, 300), 3);
break;
case 2:
fmpcb_one(a);
break;
}
prec1 = 2 + n_randint(state, 300);
prec2 = prec1 + 30;
len = 1 + n_randint(state, 20);
deflate = n_randint(state, 2);
z1 = _fmpcb_vec_init(len);
z2 = _fmpcb_vec_init(len);
zeta_series(z1, s, a, deflate, len, prec1);
zeta_series(z2, s, a, deflate, len, prec2);
for (i = 0; i < len; i++)
{
if (!fmpcb_overlaps(z1 + i, z2 + i))
{
printf("FAIL: overlap\n\n");
printf("iter = %ld\n", iter);
printf("deflate = %d, len = %ld, i = %ld\n\n", deflate, len, i);
printf("s = "); fmpcb_printd(s, prec1 / 3.33); printf("\n\n");
printf("a = "); fmpcb_printd(a, prec1 / 3.33); printf("\n\n");
printf("z1 = "); fmpcb_printd(z1 + i, prec1 / 3.33); printf("\n\n");
printf("z2 = "); fmpcb_printd(z2 + i, prec2 / 3.33); printf("\n\n");
abort();
}
}
fmpcb_clear(a);
fmpcb_clear(s);
_fmpcb_vec_clear(z1, len);
_fmpcb_vec_clear(z2, len);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
