void
arb_poly_compose_series(arb_poly_t res,
const arb_poly_t poly1,
const arb_poly_t poly2, slong n, slong prec)
{
slong len1 = poly1->length;
slong len2 = poly2->length;
slong lenr;
if (len2 != 0 && !arb_is_zero(poly2->coeffs))
{
flint_printf("exception: compose_series: inner "
"polynomial must have zero constant term\n");
abort();
}
if (len1 == 0 || n == 0)
{
arb_poly_zero(res);
return;
}
if (len2 == 0 || len1 == 1)
{
arb_poly_set_arb(res, poly1->coeffs);
return;
}
lenr = FLINT_MIN((len1 - 1) * (len2 - 1) + 1, n);
len1 = FLINT_MIN(len1, lenr);
len2 = FLINT_MIN(len2, lenr);
if ((res != poly1) && (res != poly2))
{
arb_poly_fit_length(res, lenr);
_arb_poly_compose_series(res->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, lenr, prec);
_arb_poly_set_length(res, lenr);
_arb_poly_normalise(res);
}
else
{
arb_poly_t t;
arb_poly_init2(t, lenr);
_arb_poly_compose_series(t->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, lenr, prec);
_arb_poly_set_length(t, lenr);
_arb_poly_normalise(t);
arb_poly_swap(res, t);
arb_poly_clear(t);
}
}
void arb_poly_compose(arb_poly_t res,
const arb_poly_t poly1, const arb_poly_t poly2, slong prec)
{
const slong len1 = poly1->length;
const slong len2 = poly2->length;
if (len1 == 0)
{
arb_poly_zero(res);
}
else if (len1 == 1 || len2 == 0)
{
arb_poly_set_arb(res, poly1->coeffs);
}
else
{
const slong lenr = (len1 - 1) * (len2 - 1) + 1;
if (res != poly1 && res != poly2)
{
arb_poly_fit_length(res, lenr);
_arb_poly_compose(res->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, prec);
}
else
{
arb_poly_t t;
arb_poly_init2(t, lenr);
_arb_poly_compose(t->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, prec);
arb_poly_swap(res, t);
arb_poly_clear(t);
}
_arb_poly_set_length(res, lenr);
_arb_poly_normalise(res);
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("cos_pi_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
slong m, n1, n2, bits1, bits2, bits3;
arb_poly_t S, A, B, C;
arb_t pi;
bits1 = 2 + n_randint(state, 200);
bits2 = 2 + n_randint(state, 200);
bits3 = 2 + n_randint(state, 200);
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_init(pi);
arb_poly_randtest(S, state, m, bits1, 3);
arb_poly_randtest(A, state, m, bits1, 3);
arb_poly_randtest(B, state, m, bits1, 3);
arb_poly_cos_pi_series(A, S, n1, bits2);
arb_const_pi(pi, bits3);
arb_poly_set_arb(B, pi);
arb_poly_mul(B, S, B, bits3);
arb_poly_cos_series(B, B, 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))
{
flint_printf("FAIL\n\n");
flint_printf("S = "); arb_poly_printd(S, 15); 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");
abort();
}
arb_poly_cos_pi_series(S, S, n1, bits2);
if (!arb_poly_overlaps(A, S))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
arb_poly_clear(S);
arb_poly_clear(A);
arb_poly_clear(B);
arb_poly_clear(C);
arb_clear(pi);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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;
}
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;
}
