int main()
{
long iter;
flint_rand_t state;
printf("zeta_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 500; iter++)
{
long m, n1, n2, bits1, bits2, bits3;
int deflate;
arb_poly_t S, A, B, C, D, E, F;
arb_t a, a1;
bits1 = 2 + n_randint(state, 300);
bits2 = 2 + n_randint(state, 300);
bits3 = 2 + n_randint(state, 300);
m = 1 + n_randint(state, 30);
n1 = 1 + n_randint(state, 30);
n2 = 1 + n_randint(state, 30);
arb_poly_init(S);
arb_poly_init(A);
arb_poly_init(B);
arb_poly_init(C);
arb_poly_init(D);
arb_poly_init(E);
arb_poly_init(F);
arb_init(a);
arb_init(a1);
deflate = n_randint(state, 2);
arb_poly_randtest(S, state, m, bits1, 3);
arb_randtest_precise(a, state, bits1, 3);
arb_poly_set_coeff_arb(S, 0, a);
if (n_randint(state, 2))
arb_randtest(a, state, bits1, 3);
else
arb_one(a);
arb_poly_zeta_series(A, S, a, deflate, n1, bits2);
arb_poly_zeta_series(B, S, a, deflate, n2, bits3);
arb_poly_set(C, A);
arb_poly_truncate(C, FLINT_MIN(n1, n2));
arb_poly_truncate(B, FLINT_MIN(n1, n2));
if (!arb_poly_overlaps(B, C))
{
printf("FAIL\n\n");
printf("S = "); arb_poly_printd(S, 15); printf("\n\n");
printf("a = "); arb_printd(a, 15); printf("\n\n");
printf("A = "); arb_poly_printd(A, 15); printf("\n\n");
printf("B = "); arb_poly_printd(B, 15); printf("\n\n");
abort();
}
/* check zeta(s,a) = zeta(s,a+1) + a^(-s) */
arb_poly_set_arb(D, a);
arb_poly_log_series(D, D, n1, bits2);
arb_poly_mullow(D, D, S, n1, bits2);
arb_poly_neg(D, D);
arb_poly_exp_series(D, D, n1, bits2);
arb_add_ui(a1, a, 1, bits2);
arb_poly_zeta_series(E, S, a1, deflate, n1, bits2);
arb_poly_add(E, E, D, bits2);
if (!arb_poly_overlaps(A, E))
{
printf("FAIL (functional equation)\n\n");
printf("S = "); arb_poly_printd(S, 15); printf("\n\n");
printf("a = "); arb_printd(a, 15); printf("\n\n");
printf("A = "); arb_poly_printd(A, 15); printf("\n\n");
printf("E = "); arb_poly_printd(A, 15); printf("\n\n");
abort();
}
arb_poly_zeta_series(S, S, a, deflate, n1, bits2);
if (!arb_poly_overlaps(A, S))
{
printf("FAIL (aliasing)\n\n");
abort();
}
arb_poly_clear(S);
arb_poly_clear(A);
arb_poly_clear(B);
arb_poly_clear(C);
arb_poly_clear(D);
arb_poly_clear(E);
arb_poly_clear(F);
arb_clear(a);
arb_clear(a1);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_pfq_series_direct(acb_poly_t res,
const acb_poly_struct * a, long p,
const acb_poly_struct * b, long q,
const acb_poly_t z, int regularized,
long n, long len, long prec)
{
acb_poly_t s, t, err;
arb_poly_t C, T;
long i;
int is_real;
/* default algorithm to choose number of terms */
if (n < 0)
{
n = acb_hypgeom_pfq_series_choose_n(a, p, b, q, z, len, prec);
}
acb_poly_init(s);
acb_poly_init(t);
acb_poly_init(err);
arb_poly_init(C);
arb_poly_init(T);
acb_hypgeom_pfq_series_sum_forward(s, t, a, p, b, q, z, regularized, n, len, prec);
if (acb_poly_length(t) != 0)
{
is_real = acb_poly_is_real(z);
for (i = 0; i < p; i++)
is_real = is_real && acb_poly_is_real(a + i);
for (i = 0; i < q; i++)
is_real = is_real && acb_poly_is_real(b + i);
acb_poly_majorant(T, t, MAG_BITS);
acb_hypgeom_pfq_series_bound_factor(C, a, p, b, q, z, n, len, MAG_BITS);
arb_poly_mullow(T, T, C, len, MAG_BITS);
/* create polynomial of errors */
acb_poly_fit_length(err, len);
for (i = 0; i < FLINT_MIN(len, T->length); i++)
{
arb_add_error(acb_realref(err->coeffs + i), T->coeffs + i);
if (!is_real)
arb_add_error(acb_imagref(err->coeffs + i), T->coeffs + i);
}
_acb_poly_set_length(err, len);
_acb_poly_normalise(err);
acb_poly_add(s, s, err, prec);
}
acb_poly_set(res, s);
acb_poly_clear(s);
acb_poly_clear(t);
acb_poly_clear(err);
arb_poly_clear(C);
arb_poly_clear(T);
}
/* F = 1 + U + U^2 + U^3 + ... = 1/(1-U)
U = product of (1 + |A-B|/(|B[0] - |B[1:]|)
product of (1 / (|B[0] - |B[1:]|))
* |Z|
*/
void
acb_hypgeom_pfq_series_bound_factor(arb_poly_t F,
const acb_poly_struct * a, long p,
const acb_poly_struct * b, long q,
const acb_poly_t z,
long n, long len, long prec)
{
long i;
arb_poly_t T, U, V;
acb_poly_t BN, AB;
/* not convergent */
if (p > q)
{
arb_poly_fit_length(F, len);
_arb_vec_indeterminate(F->coeffs, len);
_arb_poly_set_length(F, len);
return;
}
arb_poly_init(T);
arb_poly_init(U);
arb_poly_init(V);
acb_poly_init(BN);
acb_poly_init(AB);
acb_poly_majorant(U, z, prec);
for (i = 0; i < q; i++)
{
acb_poly_add_si(BN, b + i, n, prec);
if (acb_poly_length(BN) != 0 &&
arb_is_positive(acb_realref(BN->coeffs)))
{
if (i < p)
{
/* 1 + |a-b|/reciprocal_majorant(b + n) */
acb_poly_sub(AB, a + i, b + i, prec);
acb_poly_majorant(T, AB, prec);
acb_poly_reciprocal_majorant(V, BN, prec);
arb_poly_div_series(T, T, V, len, prec);
arb_poly_add_si(T, T, 1, prec);
arb_poly_mullow(U, U, T, len, prec);
}
else
{
acb_poly_reciprocal_majorant(T, BN, prec);
arb_poly_div_series(U, U, T, len, prec);
}
}
else
{
arb_poly_fit_length(U, len);
_arb_vec_indeterminate(U->coeffs, len);
_arb_poly_set_length(U, len);
break;
}
}
/* F = 1/(1-U) */
arb_poly_geometric_sum(F, U, len, prec);
arb_poly_clear(T);
arb_poly_clear(U);
arb_poly_clear(V);
acb_poly_clear(BN);
acb_poly_clear(AB);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sin_cos_pi_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
slong m, n, qbits, rbits1, rbits2;
fmpq_poly_t A, B;
arb_poly_t a, b, c, d, e;
qbits = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
m = 1 + n_randint(state, 30);
n = 1 + n_randint(state, 30);
fmpq_poly_init(A);
fmpq_poly_init(B);
arb_poly_init(a);
arb_poly_init(b);
arb_poly_init(c);
arb_poly_init(d);
arb_poly_init(e);
fmpq_poly_randtest(A, state, m, qbits);
arb_poly_set_fmpq_poly(a, A, rbits1);
arb_poly_sin_cos_pi_series(b, c, a, n, rbits2);
/* Check sin(x)^2 + cos(x)^2 = 1 */
arb_poly_mullow(d, b, b, n, rbits2);
arb_poly_mullow(e, c, c, n, rbits2);
arb_poly_add(d, d, e, rbits2);
fmpq_poly_one(B);
if (!arb_poly_contains_fmpq_poly(d, B))
{
flint_printf("FAIL\n\n");
flint_printf("bits2 = %wd\n", rbits2);
flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n");
flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n");
flint_printf("d = "); arb_poly_printd(d, 15); flint_printf("\n\n");
abort();
}
arb_poly_set(d, a);
arb_poly_sin_cos_pi_series(d, c, d, n, rbits2);
if (!arb_poly_equal(b, d))
{
flint_printf("FAIL (aliasing 1)\n\n");
abort();
}
arb_poly_set(d, a);
arb_poly_sin_cos_pi_series(b, d, d, n, rbits2);
if (!arb_poly_equal(c, d))
{
flint_printf("FAIL (aliasing 2)\n\n");
abort();
}
fmpq_poly_clear(A);
fmpq_poly_clear(B);
arb_poly_clear(a);
arb_poly_clear(b);
arb_poly_clear(c);
arb_poly_clear(d);
arb_poly_clear(e);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("rising_ui_series....");
fflush(stdout);
flint_randinit(state);
/* check rf(f, a) * rf(f + a, b) = rf(f, a + b) */
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
slong bits, trunc;
ulong a, b;
arb_poly_t f, g, h1, h2, h1h2, h3;
bits = 2 + n_randint(state, 200);
trunc = 1 + n_randint(state, 20);
a = n_randint(state, 10);
b = n_randint(state, 10);
arb_poly_init(f);
arb_poly_init(g);
arb_poly_init(h1);
arb_poly_init(h2);
arb_poly_init(h1h2);
arb_poly_init(h3);
arb_poly_randtest(f, state, 1 + n_randint(state, 20), bits, 4);
arb_poly_set(g, f);
/* g = f + 1 */
if (g->length == 0)
{
arb_poly_fit_length(g, 1);
arb_set_ui(g->coeffs, a);
_arb_poly_set_length(g, 1);
_arb_poly_normalise(g);
}
else
{
arb_add_ui(g->coeffs, g->coeffs, a, bits);
_arb_poly_normalise(g);
}
arb_poly_rising_ui_series(h1, f, a, trunc, bits);
arb_poly_rising_ui_series(h2, g, b, trunc, bits);
arb_poly_rising_ui_series(h3, f, a + b, trunc, bits);
arb_poly_mullow(h1h2, h1, h2, trunc, bits);
if (!arb_poly_overlaps(h1h2, h3))
{
flint_printf("FAIL\n\n");
flint_printf("bits = %wd\n", bits);
flint_printf("trunc = %wd\n", trunc);
flint_printf("a = %wu\n", a);
flint_printf("b = %wu\n", a);
flint_printf("f = "); arb_poly_printd(f, 15); flint_printf("\n\n");
flint_printf("g = "); arb_poly_printd(g, 15); flint_printf("\n\n");
flint_printf("h1 = "); arb_poly_printd(h1, 15); flint_printf("\n\n");
flint_printf("h2 = "); arb_poly_printd(h2, 15); flint_printf("\n\n");
flint_printf("h1h2 = "); arb_poly_printd(h1h2, 15); flint_printf("\n\n");
flint_printf("h3 = "); arb_poly_printd(h3, 15); flint_printf("\n\n");
abort();
}
arb_poly_rising_ui_series(f, f, a, trunc, bits);
if (!arb_poly_equal(f, h1))
{
flint_printf("FAIL (aliasing)\n\n");
flint_printf("bits = %wd\n", bits);
flint_printf("trunc = %wd\n", trunc);
flint_printf("a = %wu\n", a);
flint_printf("b = %wu\n", a);
flint_printf("f = "); arb_poly_printd(f, 15); flint_printf("\n\n");
flint_printf("h1 = "); arb_poly_printd(h1, 15); flint_printf("\n\n");
abort();
}
arb_poly_clear(f);
arb_poly_clear(g);
arb_poly_clear(h1);
arb_poly_clear(h2);
arb_poly_clear(h1h2);
arb_poly_clear(h3);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("atan_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
slong m, n, qbits, rbits1, rbits2;
fmpq_poly_t A;
arb_poly_t a, b, c, d;
qbits = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
m = 1 + n_randint(state, 30);
n = 1 + n_randint(state, 30);
fmpq_poly_init(A);
arb_poly_init(a);
arb_poly_init(b);
arb_poly_init(c);
arb_poly_init(d);
fmpq_poly_randtest(A, state, m, qbits);
arb_poly_set_fmpq_poly(a, A, rbits1);
arb_poly_randtest(b, state, 1 + n_randint(state, 30), rbits1, 5);
arb_poly_atan_series(b, a, n, rbits2);
/* Check 2 atan(x) = atan(2x/(1-x^2)) + C */
arb_poly_mullow(c, a, a, n, rbits2);
arb_poly_one(d);
arb_poly_sub(c, d, c, rbits2);
arb_poly_add(d, a, a, rbits2);
if (arb_poly_length(c) != 0)
{
arb_poly_div_series(c, d, c, n, rbits2);
arb_poly_atan_series(c, c, n, rbits2);
arb_poly_add(d, b, b, rbits2);
/* TODO: also check the first coefficient */
arb_poly_set_coeff_si(c, 0, 0);
arb_poly_set_coeff_si(d, 0, 0);
if (!arb_poly_overlaps(c, d))
{
flint_printf("FAIL\n\n");
flint_printf("bits2 = %wd\n", rbits2);
flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n");
flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n");
flint_printf("d = "); arb_poly_printd(d, 15); flint_printf("\n\n");
abort();
}
}
arb_poly_atan_series(a, a, n, rbits2);
if (!arb_poly_equal(a, b))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
fmpq_poly_clear(A);
arb_poly_clear(a);
arb_poly_clear(b);
arb_poly_clear(c);
arb_poly_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("pow_arb_series....");
fflush(stdout);
flint_randinit(state);
/* compare with exp/log */
for (iter = 0; iter < 10000; iter++)
{
long prec, trunc;
arb_poly_t f, g, h1, h2;
arb_t c;
prec = 2 + n_randint(state, 200);
trunc = n_randint(state, 20);
arb_poly_init(f);
arb_poly_init(g);
arb_poly_init(h1);
arb_poly_init(h2);
arb_init(c);
/* generate binomials */
if (n_randint(state, 20) == 0)
{
arb_randtest(c, state, prec, 10);
arb_poly_set_coeff_arb(f, 0, c);
arb_randtest(c, state, prec, 10);
arb_poly_set_coeff_arb(f, 1 + n_randint(state, 20), c);
}
else
{
arb_poly_randtest(f, state, 1 + n_randint(state, 20), prec, 10);
}
arb_poly_randtest(h1, state, 1 + n_randint(state, 20), prec, 10);
arb_randtest(c, state, prec, 10);
arb_poly_set_arb(g, c);
/* f^c */
arb_poly_pow_arb_series(h1, f, c, trunc, prec);
/* f^c = exp(c*log(f)) */
arb_poly_log_series(h2, f, trunc, prec);
arb_poly_mullow(h2, h2, g, trunc, prec);
arb_poly_exp_series(h2, h2, trunc, prec);
if (!arb_poly_overlaps(h1, h2))
{
printf("FAIL\n\n");
printf("prec = %ld\n", prec);
printf("trunc = %ld\n", trunc);
printf("f = "); arb_poly_printd(f, 15); printf("\n\n");
printf("c = "); arb_printd(c, 15); printf("\n\n");
printf("h1 = "); arb_poly_printd(h1, 15); printf("\n\n");
printf("h2 = "); arb_poly_printd(h2, 15); printf("\n\n");
abort();
}
arb_poly_pow_arb_series(f, f, c, trunc, prec);
if (!arb_poly_overlaps(f, h1))
{
printf("FAIL (aliasing)\n\n");
abort();
}
arb_poly_clear(f);
arb_poly_clear(g);
arb_poly_clear(h1);
arb_poly_clear(h2);
arb_clear(c);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("pow_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 50000 * arb_test_multiplier(); iter++)
{
slong rbits1, rbits2, len;
arb_poly_t a, b, c, d;
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
len = n_randint(state, 25);
arb_poly_init(a);
arb_poly_init(b);
arb_poly_init(c);
arb_poly_init(d);
if (n_randint(state, 4) == 0)
arb_poly_randtest(a, state, 1, rbits1, 25);
else
arb_poly_randtest(a, state, 1 + n_randint(state, 20), rbits1, 5);
if (n_randint(state, 4) == 0)
arb_poly_randtest(b, state, 1, rbits1, 25);
else
arb_poly_randtest(b, state, 1 + n_randint(state, 20), rbits1, 5);
arb_poly_randtest(c, state, 1 + n_randint(state, 20), rbits1, 5);
arb_poly_pow_series(c, a, b, len, rbits2);
/* a^b = exp(b log a) */
arb_poly_log_series(d, a, len, rbits2);
arb_poly_mullow(d, d, b, len, rbits2);
arb_poly_exp_series(d, d, len, rbits2);
if (!arb_poly_overlaps(c, d))
{
flint_printf("FAIL (iter %wd)\n\n", iter);
flint_printf("bits2 = %wd\n", rbits2);
flint_printf("len = %wd\n", len);
flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n");
flint_printf("d = "); arb_poly_printd(d, 15); flint_printf("\n\n");
abort();
}
/* check aliasing */
if (iter < 5000)
{
arb_poly_set(d, a);
arb_poly_pow_series(d, d, b, len, rbits2);
if (!arb_poly_overlaps(c, d))
{
flint_printf("FAIL (aliasing 1)\n");
abort();
}
arb_poly_set(d, b);
arb_poly_pow_series(d, a, d, len, rbits2);
if (!arb_poly_overlaps(c, d))
{
flint_printf("FAIL (aliasing 2)\n");
abort();
}
}
arb_poly_clear(a);
arb_poly_clear(b);
arb_poly_clear(c);
arb_poly_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_pfq_series_direct(acb_poly_t res,
const acb_poly_struct * a, long p,
const acb_poly_struct * b, long q,
const acb_poly_t z, int regularized,
long n, long len, long prec)
{
acb_poly_t s, t, err;
arb_poly_t C, T;
long i;
int is_real;
int terminating;
/* default algorithm to choose number of terms */
if (n < 0)
{
n = acb_hypgeom_pfq_series_choose_n(a, p, b, q, z, len, prec);
}
terminating = 0;
/* check if it terminates due to a root of the numerator */
for (i = 0; i < p; i++)
{
if (acb_poly_length(a + i) == 0 && n > 0)
{
terminating = 1;
}
else if (acb_poly_length(a + i) == 1)
{
acb_srcptr c = acb_poly_get_coeff_ptr(a + i, 0);
if (acb_is_int(c) && arb_is_negative(acb_realref(c)) &&
arf_cmpabs_ui(arb_midref(acb_realref(c)), n) < 0)
{
terminating = 1;
}
}
}
/* check if it terminates (to order n) due to z */
/* the following tests could be made stronger... */
if (z->length == 0 && n >= 1)
{
terminating = 1;
}
else if (!terminating && z->length > 0 && acb_is_zero(z->coeffs) && n >= len)
{
if (regularized)
{
terminating = 1;
}
else
{
terminating = 1;
for (i = 0; i < q; i++)
{
acb_srcptr c = acb_poly_get_coeff_ptr(b + i, 0);
if (!arb_is_positive(acb_realref(c)) && acb_contains_int(c))
terminating = 0;
}
}
}
acb_poly_init(s);
acb_poly_init(t);
acb_poly_init(err);
arb_poly_init(C);
arb_poly_init(T);
acb_hypgeom_pfq_series_sum_forward(s, t, a, p, b, q, z, regularized, n, len, prec);
if (!terminating)
{
is_real = acb_poly_is_real(z);
for (i = 0; i < p; i++)
is_real = is_real && acb_poly_is_real(a + i);
for (i = 0; i < q; i++)
is_real = is_real && acb_poly_is_real(b + i);
acb_poly_majorant(T, t, MAG_BITS);
acb_hypgeom_pfq_series_bound_factor(C, a, p, b, q, z, n, len, MAG_BITS);
if (!_arb_vec_is_finite(T->coeffs, T->length) ||
!_arb_vec_is_finite(C->coeffs, C->length))
{
arb_poly_fit_length(T, len);
_arb_vec_indeterminate(T->coeffs, len);
_arb_poly_set_length(T, len);
}
else
{
arb_poly_mullow(T, T, C, len, MAG_BITS);
}
/* create polynomial of errors */
acb_poly_fit_length(err, len);
for (i = 0; i < FLINT_MIN(len, T->length); i++)
{
arb_add_error(acb_realref(err->coeffs + i), T->coeffs + i);
if (!is_real)
arb_add_error(acb_imagref(err->coeffs + i), T->coeffs + i);
}
_acb_poly_set_length(err, len);
_acb_poly_normalise(err);
acb_poly_add(s, s, err, prec);
}
acb_poly_set(res, s);
acb_poly_clear(s);
acb_poly_clear(t);
acb_poly_clear(err);
arb_poly_clear(C);
arb_poly_clear(T);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("rgamma_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++)
{
slong m, n1, n2, qbits, rbits1, rbits2, rbits3;
fmpq_poly_t A;
arb_poly_t a, b, c, d;
qbits = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 400);
rbits2 = 2 + n_randint(state, 400);
rbits3 = 2 + n_randint(state, 400);
m = 1 + n_randint(state, 30);
n1 = 1 + n_randint(state, 30);
n2 = 1 + n_randint(state, 30);
fmpq_poly_init(A);
arb_poly_init(a);
arb_poly_init(b);
arb_poly_init(c);
arb_poly_init(d);
fmpq_poly_randtest_not_zero(A, state, m, qbits);
arb_poly_set_fmpq_poly(a, A, rbits1);
arb_poly_rgamma_series(b, a, n1, rbits2);
arb_poly_rgamma_series(c, a, n2, rbits3);
arb_poly_set(d, b);
arb_poly_truncate(d, FLINT_MIN(n1, n2));
arb_poly_truncate(c, FLINT_MIN(n1, n2));
if (!arb_poly_overlaps(c, d))
{
flint_printf("FAIL\n\n");
flint_printf("n1 = %wd, n2 = %wd, bits2 = %wd, bits3 = %wd\n", n1, n2, rbits2, rbits3);
flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n");
flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n");
abort();
}
/* check rgamma(a) = a gamma(a+1) */
arb_poly_add_si(d, a, 1, rbits2);
arb_poly_rgamma_series(d, d, n1, rbits2);
arb_poly_mullow(c, d, a, n1, rbits2);
if (!arb_poly_overlaps(b, c))
{
flint_printf("FAIL (functional equation, n1 = %wd)\n\n", n1);
flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n");
flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n");
flint_printf("d = "); arb_poly_printd(d, 15); flint_printf("\n\n");
abort();
}
arb_poly_rgamma_series(a, a, n1, rbits2);
if (!arb_poly_overlaps(a, b))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
fmpq_poly_clear(A);
arb_poly_clear(a);
arb_poly_clear(b);
arb_poly_clear(c);
arb_poly_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
