int main()
{
long iter;
flint_rand_t state;
printf("rgamma....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 3000; iter++)
{
fmprb_t a, b, c;
long prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
fmprb_init(a);
fmprb_init(b);
fmprb_init(c);
fmprb_randtest_precise(a, state, 1 + n_randint(state, 1000), 3);
fmprb_rgamma(b, a, prec1);
fmprb_rgamma(c, a, prec2);
if (!fmprb_overlaps(b, c))
{
printf("FAIL: overlap\n\n");
printf("a = "); fmprb_print(a); printf("\n\n");
printf("b = "); fmprb_print(b); printf("\n\n");
printf("c = "); fmprb_print(c); printf("\n\n");
abort();
}
/* check 1/gamma(z+1) = 1/gamma(z)/z */
fmprb_div(b, b, a, prec1);
fmprb_add_ui(c, a, 1, prec1);
fmprb_rgamma(c, c, prec1);
if (!fmprb_overlaps(b, c))
{
printf("FAIL: functional equation\n\n");
printf("a = "); fmprb_print(a); printf("\n\n");
printf("b = "); fmprb_print(b); printf("\n\n");
printf("c = "); fmprb_print(c); printf("\n\n");
abort();
}
fmprb_clear(a);
fmprb_clear(b);
fmprb_clear(c);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("evaluate2....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
fmprb_poly_t f, g;
fmprb_t x, y1, z1, y2, z2;
fmprb_init(x);
fmprb_init(y1);
fmprb_init(z1);
fmprb_init(y2);
fmprb_init(z2);
fmprb_poly_init(f);
fmprb_poly_init(g);
fmprb_randtest(x, state, 2 + n_randint(state, 1000), 5);
fmprb_poly_randtest(f, state, 2 + n_randint(state, 100), 2 + n_randint(state, 1000), 5);
fmprb_poly_derivative(g, f, 2 + n_randint(state, 1000));
fmprb_poly_evaluate2(y1, z1, f, x, 2 + n_randint(state, 1000));
fmprb_poly_evaluate_horner(y2, f, x, 2 + n_randint(state, 1000));
fmprb_poly_evaluate_horner(z2, g, x, 2 + n_randint(state, 1000));
if (!fmprb_overlaps(y1, y2) || !fmprb_overlaps(z1, z2))
{
printf("FAIL\n\n");
printf("f = "); fmprb_poly_printd(f, 15); printf("\n\n");
printf("g = "); fmprb_poly_printd(g, 15); printf("\n\n");
printf("x = "); fmprb_printd(x, 15); printf("\n\n");
printf("y1 = "); fmprb_printd(y1, 15); printf("\n\n");
printf("z1 = "); fmprb_printd(z1, 15); printf("\n\n");
printf("y2 = "); fmprb_printd(y2, 15); printf("\n\n");
printf("z2 = "); fmprb_printd(z2, 15); printf("\n\n");
abort();
}
fmprb_poly_clear(f);
fmprb_poly_clear(g);
fmprb_clear(x);
fmprb_clear(y1);
fmprb_clear(z1);
fmprb_clear(y2);
fmprb_clear(z2);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("series_fmpq_hypgeom....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 250; iter++)
{
fmprb_ptr u, v;
fmpq_t a;
ulong p, q;
long i, len, prec1, prec2;
len = 1 + n_randint(state, 10);
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
u = _fmprb_vec_init(len);
v = _fmprb_vec_init(len);
fmpq_init(a);
q = 1 + n_randint(state, 20);
p = q - n_randint(state, q);
fmpq_set_si(a, p, q);
gamma_series_fmpq_hypgeom(u, a, len, prec1);
gamma_series_fmpq_hypgeom(v, a, len, prec2);
for (i = 0; i < len; i++)
{
if (!fmprb_overlaps(u + i, v + i))
{
printf("FAIL: overlap\n\n");
printf("p = %lu, q = %lu, len = %ld, i = %ld\n\n", p, q, len, i);
printf("u = "); fmprb_printd(u + i, prec1 / 3.33); printf("\n\n");
printf("v = "); fmprb_printd(v + i, prec2 / 3.33); printf("\n\n");
abort();
}
}
fmpq_clear(a);
_fmprb_vec_clear(u, len);
_fmprb_vec_clear(v, len);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
void
fmprb_agm(fmprb_t z, const fmprb_t x, const fmprb_t y, long prec)
{
fmprb_t t, u, v, w;
if (fmprb_contains_negative(x) || fmprb_contains_negative(y))
{
fmprb_indeterminate(z);
return;
}
if (fmprb_is_zero(x) || fmprb_is_zero(y))
{
fmprb_zero(z);
return;
}
fmprb_init(t);
fmprb_init(u);
fmprb_init(v);
fmprb_init(w);
fmprb_set(t, x);
fmprb_set(u, y);
while (!fmprb_overlaps(t, u) &&
!fmprb_contains_nonpositive(t) &&
!fmprb_contains_nonpositive(u))
{
fmprb_add(v, t, u, prec);
fmprb_mul_2exp_si(v, v, -1);
fmprb_mul(w, t, u, prec);
fmprb_sqrt(w, w, prec);
fmprb_swap(v, t);
fmprb_swap(w, u);
}
if (!fmprb_is_finite(t) || !fmprb_is_finite(u))
{
fmprb_indeterminate(z);
}
else
{
fmprb_union(z, t, u, prec);
}
fmprb_clear(t);
fmprb_clear(u);
fmprb_clear(v);
fmprb_clear(w);
}
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;
}
int main()
{
long iter;
flint_rand_t state;
printf("cos_pi_fmpq....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
fmprb_t c1, c2;
fmpq_t x;
long prec;
prec = 2 + n_randint(state, 5000);
fmprb_init(c1);
fmprb_init(c2);
fmpq_init(x);
fmpq_randtest(x, state, 1 + n_randint(state, 200));
fmprb_cos_pi_fmpq(c1, x, prec);
fmprb_const_pi(c2, prec);
fmprb_mul_fmpz(c2, c2, fmpq_numref(x), prec);
fmprb_div_fmpz(c2, c2, fmpq_denref(x), prec);
fmprb_cos(c2, c2, prec);
if (!fmprb_overlaps(c1, c2))
{
printf("FAIL: overlap\n\n");
printf("x = "); fmpq_print(x); printf("\n\n");
printf("c1 = "); fmprb_printd(c1, 15); printf("\n\n");
printf("c2 = "); fmprb_printd(c2, 15); printf("\n\n");
abort();
}
fmprb_clear(c1);
fmprb_clear(c2);
fmpq_clear(x);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("taylor_fmprb....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 3000; iter++)
{
fmprb_t a, b, c;
long prec1, prec2;
prec1 = 2 + n_randint(state, 2000);
prec2 = prec1 + 30;
fmprb_init(a);
fmprb_init(b);
fmprb_init(c);
fmprb_randtest_precise(a, state, 1 + n_randint(state, 1000), 4);
gamma_taylor_fmprb(b, a, prec1);
fmprb_gamma(c, a, prec2);
if (!fmprb_overlaps(b, c))
{
printf("FAIL: overlap\n\n");
printf("a = "); fmprb_print(a); printf("\n\n");
printf("b = "); fmprb_print(b); printf("\n\n");
printf("c = "); fmprb_print(c); printf("\n\n");
abort();
}
fmprb_clear(a);
fmprb_clear(b);
fmprb_clear(c);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("exp....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
fmprb_t a, b;
fmpq_t q;
mpfr_t t;
long prec = 2 + n_randint(state, 200);
fmprb_init(a);
fmprb_init(b);
fmpq_init(q);
mpfr_init2(t, prec + 100);
fmprb_randtest(a, state, 1 + n_randint(state, 200), 3);
fmprb_randtest(b, state, 1 + n_randint(state, 200), 3);
fmprb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200));
fmpq_get_mpfr(t, q, MPFR_RNDN);
mpfr_exp(t, t, MPFR_RNDN);
fmprb_exp(b, a, prec);
if (!fmprb_contains_mpfr(b, t))
{
printf("FAIL: containment\n\n");
printf("a = "); fmprb_print(a); printf("\n\n");
printf("b = "); fmprb_print(b); printf("\n\n");
abort();
}
fmprb_exp(a, a, prec);
if (!fmprb_equal(a, b))
{
printf("FAIL: aliasing\n\n");
abort();
}
fmprb_clear(a);
fmprb_clear(b);
fmpq_clear(q);
mpfr_clear(t);
}
/* check large arguments */
for (iter = 0; iter < 100000; iter++)
{
fmprb_t a, b, c, d;
long prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
fmprb_init(a);
fmprb_init(b);
fmprb_init(c);
fmprb_init(d);
fmprb_randtest_precise(a, state, 1 + n_randint(state, 1000), 100);
fmprb_exp(b, a, prec1);
fmprb_exp(c, a, prec2);
if (!fmprb_overlaps(b, c))
{
printf("FAIL: overlap\n\n");
printf("a = "); fmprb_print(a); printf("\n\n");
printf("b = "); fmprb_print(b); printf("\n\n");
printf("c = "); fmprb_print(c); printf("\n\n");
abort();
}
fmprb_randtest_precise(b, state, 1 + n_randint(state, 1000), 100);
/* check exp(a)*exp(b) = exp(a+b) */
fmprb_exp(c, a, prec1);
fmprb_exp(d, b, prec1);
fmprb_mul(c, c, d, prec1);
fmprb_add(d, a, b, prec1);
fmprb_exp(d, d, prec1);
if (!fmprb_overlaps(c, d))
{
printf("FAIL: functional equation\n\n");
printf("a = "); fmprb_print(a); printf("\n\n");
printf("b = "); fmprb_print(b); printf("\n\n");
printf("c = "); fmprb_print(c); printf("\n\n");
printf("d = "); fmprb_print(d); printf("\n\n");
abort();
}
fmprb_clear(a);
fmprb_clear(b);
fmprb_clear(c);
fmprb_clear(d);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("overlaps....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
fmprb_t a, b;
fmpq_t am, ar, bm, br, t, u;
int c1, c2;
fmprb_init(a);
fmprb_init(b);
fmpq_init(am);
fmpq_init(ar);
fmpq_init(bm);
fmpq_init(br);
fmpq_init(t);
fmpq_init(u);
fmprb_randtest(a, state, 1 + n_randint(state, 500), 14);
fmprb_randtest(b, state, 1 + n_randint(state, 500), 14);
fmpr_get_fmpq(am, fmprb_midref(a));
fmpr_get_fmpq(ar, fmprb_radref(a));
fmpr_get_fmpq(bm, fmprb_midref(b));
fmpr_get_fmpq(br, fmprb_radref(b));
fmpq_sub(t, am, bm);
fmpz_abs(fmpq_numref(t), fmpq_numref(t));
fmpq_add(u, ar, br);
c1 = fmprb_overlaps(a, b);
c2 = (fmpq_cmp(t, u) <= 0);
if (c1 != c2)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "); fmprb_print(a); flint_printf("\n\n");
flint_printf("b = "); fmprb_print(b); flint_printf("\n\n");
flint_printf("am = "); fmpq_print(am); flint_printf("\n\n");
flint_printf("ar = "); fmpq_print(ar); flint_printf("\n\n");
flint_printf("bm = "); fmpq_print(bm); flint_printf("\n\n");
flint_printf("br = "); fmpq_print(br); flint_printf("\n\n");
flint_printf("t = "); fmpq_print(t); flint_printf("\n\n");
flint_printf("u = "); fmpq_print(u); flint_printf("\n\n");
flint_printf("c1 = %d, c2 = %d\n\n", c1, c2);
abort();
}
fmprb_clear(a);
fmprb_clear(b);
fmpq_clear(am);
fmpq_clear(ar);
fmpq_clear(bm);
fmpq_clear(br);
fmpq_clear(t);
fmpq_clear(u);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("cos_pi_fmpq_algebraic....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
fmprb_t c1, c2;
ulong p, q, g;
long prec;
prec = 2 + n_randint(state, 5000);
q = 1 + n_randint(state, 500);
p = n_randint(state, q / 2 + 1);
g = n_gcd(q, p);
q /= g;
p /= g;
fmprb_init(c1);
fmprb_init(c2);
_fmprb_cos_pi_fmpq_algebraic(c1, p, q, prec);
fmprb_const_pi(c2, prec);
fmprb_mul_ui(c2, c2, p, prec);
fmprb_div_ui(c2, c2, q, prec);
fmprb_cos(c2, c2, prec);
if (!fmprb_overlaps(c1, c2))
{
printf("FAIL: overlap\n\n");
printf("p/q = %lu/%lu", p, q); printf("\n\n");
printf("c1 = "); fmprb_printd(c1, 15); printf("\n\n");
printf("c2 = "); fmprb_printd(c2, 15); printf("\n\n");
abort();
}
if (fmprb_rel_accuracy_bits(c1) < prec - 2)
{
printf("FAIL: accuracy\n\n");
printf("p/q = %lu/%lu", p, q); printf("\n\n");
printf("prec=%ld eff=%ld\n", prec, fmprb_rel_accuracy_bits(c1));
printf("c1 = "); fmprb_printd(c1, 15); printf("\n\n");
printf("c2 = "); fmprb_printd(c2, 15); printf("\n\n");
abort();
}
fmprb_clear(c1);
fmprb_clear(c2);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
