void
acb_hypgeom_u_1f1(acb_t res, const acb_t a, const acb_t b, const acb_t z, long prec)
{
if (acb_is_int(b))
{
acb_poly_t aa, bb, zz;
acb_poly_init(aa);
acb_poly_init(bb);
acb_poly_init(zz);
acb_poly_set_acb(aa, a);
acb_poly_set_coeff_acb(bb, 0, b);
acb_poly_set_coeff_si(bb, 1, 1);
acb_poly_set_acb(zz, z);
acb_hypgeom_u_1f1_series(zz, aa, bb, zz, 1, prec);
acb_poly_get_coeff_acb(res, zz, 0);
acb_poly_clear(aa);
acb_poly_clear(bb);
acb_poly_clear(zz);
}
else
{
acb_t t, u, v;
acb_struct aa[3];
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(aa + 0);
acb_init(aa + 1);
acb_init(aa + 2);
acb_set(aa, a);
acb_set(aa + 1, b);
acb_one(aa + 2);
acb_hypgeom_pfq_direct(u, aa, 1, aa + 1, 2, z, -1, prec);
acb_sub(aa, a, b, prec);
acb_add_ui(aa, aa, 1, prec);
acb_sub_ui(aa + 1, b, 2, prec);
acb_neg(aa + 1, aa + 1);
acb_hypgeom_pfq_direct(v, aa, 1, aa + 1, 2, z, -1, prec);
acb_sub_ui(aa + 1, b, 1, prec);
/* rgamma(a-b+1) * gamma(1-b) * u */
acb_rgamma(t, aa, prec);
acb_mul(u, u, t, prec);
acb_neg(t, aa + 1);
acb_gamma(t, t, prec);
acb_mul(u, u, t, prec);
/* rgamma(a) * gamma(b-1) * z^(1-b) * v */
acb_rgamma(t, a, prec);
acb_mul(v, v, t, prec);
acb_gamma(t, aa + 1, prec);
acb_mul(v, v, t, prec);
acb_neg(t, aa + 1);
acb_pow(t, z, t, prec);
acb_mul(v, v, t, prec);
acb_add(res, u, v, prec);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(aa + 0);
acb_clear(aa + 1);
acb_clear(aa + 2);
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("find_roots....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_poly_t A;
acb_poly_t B;
acb_poly_t C;
acb_t t;
acb_ptr roots;
slong i, deg, isolated;
slong prec = 10 + n_randint(state, 400);
acb_init(t);
acb_poly_init(A);
acb_poly_init(B);
acb_poly_init(C);
do {
acb_poly_randtest(A, state, 2 + n_randint(state, 15), prec, 5);
} while (A->length == 0);
deg = A->length - 1;
roots = _acb_vec_init(deg);
isolated = acb_poly_find_roots(roots, A, NULL, 0, prec);
if (isolated == deg)
{
acb_poly_fit_length(B, 1);
acb_set(B->coeffs, A->coeffs + deg);
_acb_poly_set_length(B, 1);
for (i = 0; i < deg; i++)
{
acb_poly_fit_length(C, 2);
acb_one(C->coeffs + 1);
acb_neg(C->coeffs + 0, roots + i);
_acb_poly_set_length(C, 2);
acb_poly_mul(B, B, C, prec);
}
if (!acb_poly_contains(B, A))
{
flint_printf("FAIL: product does not equal polynomial\n");
acb_poly_printd(A, 15); flint_printf("\n\n");
acb_poly_printd(B, 15); flint_printf("\n\n");
flint_abort();
}
}
for (i = 0; i < isolated; i++)
{
acb_poly_evaluate(t, A, roots + i, prec);
if (!acb_contains_zero(t))
{
flint_printf("FAIL: poly(root) does not contain zero\n");
acb_poly_printd(A, 15); flint_printf("\n\n");
acb_printd(roots + i, 15); flint_printf("\n\n");
acb_printd(t, 15); flint_printf("\n\n");
flint_abort();
}
}
_acb_vec_clear(roots, deg);
acb_clear(t);
acb_poly_clear(A);
acb_poly_clear(B);
acb_poly_clear(C);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("compose_divconquer....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 3000; iter++)
{
slong qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_poly_t A, B, C;
acb_poly_t a, b, c, d;
qbits1 = 2 + n_randint(state, 200);
qbits2 = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
fmpq_poly_init(A);
fmpq_poly_init(B);
fmpq_poly_init(C);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_init(d);
fmpq_poly_randtest(A, state, 1 + n_randint(state, 20), qbits1);
fmpq_poly_randtest(B, state, 1 + n_randint(state, 10), qbits2);
fmpq_poly_compose(C, A, B);
acb_poly_set_fmpq_poly(a, A, rbits1);
acb_poly_set_fmpq_poly(b, B, rbits2);
acb_poly_compose_divconquer(c, a, b, rbits3);
if (!acb_poly_contains_fmpq_poly(c, C))
{
flint_printf("FAIL\n\n");
flint_printf("bits3 = %wd\n", rbits3);
flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpq_poly_print(B); flint_printf("\n\n");
flint_printf("C = "); fmpq_poly_print(C); flint_printf("\n\n");
flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n");
abort();
}
acb_poly_set(d, a);
acb_poly_compose_divconquer(d, d, b, rbits3);
if (!acb_poly_equal(d, c))
{
flint_printf("FAIL (aliasing 1)\n\n");
abort();
}
acb_poly_set(d, b);
acb_poly_compose_divconquer(d, a, d, rbits3);
if (!acb_poly_equal(d, c))
{
flint_printf("FAIL (aliasing 2)\n\n");
abort();
}
fmpq_poly_clear(A);
fmpq_poly_clear(B);
fmpq_poly_clear(C);
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_poly_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
_acb_hypgeom_2f1_transform_limit(acb_t res, const acb_poly_t a, const acb_poly_t b,
const acb_poly_t c, const acb_poly_t z, int which, slong prec)
{
acb_poly_t ba, ca, cb, cab, ac1, bc1, ab1, ba1, w, t, u, v, s;
acb_t tt;
acb_poly_init(ba);
acb_poly_init(ca); acb_poly_init(cb); acb_poly_init(cab);
acb_poly_init(ac1); acb_poly_init(bc1);
acb_poly_init(ab1); acb_poly_init(ba1);
acb_poly_init(w); acb_poly_init(t);
acb_poly_init(u); acb_poly_init(v);
acb_poly_init(s);
acb_init(tt);
acb_poly_add_si(s, z, -1, prec); /* s = 1 - z */
acb_poly_neg(s, s);
acb_poly_sub(ba, b, a, prec); /* ba = b - a */
acb_poly_sub(ca, c, a, prec); /* ca = c - a */
acb_poly_sub(cb, c, b, prec); /* cb = c - b */
acb_poly_sub(cab, ca, b, prec); /* cab = c - a - b */
acb_poly_add_si(ac1, ca, -1, prec); acb_poly_neg(ac1, ac1); /* ac1 = a - c + 1 */
acb_poly_add_si(bc1, cb, -1, prec); acb_poly_neg(bc1, bc1); /* bc1 = b - c + 1 */
acb_poly_add_si(ab1, ba, -1, prec); acb_poly_neg(ab1, ab1); /* ab1 = a - b + 1 */
acb_poly_add_si(ba1, ba, 1, prec); /* ba1 = b - a + 1 */
/* t = left term, u = right term (DLMF 15.8.1 - 15.8.5) */
if (which == 2)
{
acb_poly_inv_series(w, z, 2, prec); /* w = 1/z */
acb_hypgeom_2f1_series_direct(t, a, ac1, ab1, w, 1, 2, prec);
acb_hypgeom_2f1_series_direct(u, b, bc1, ba1, w, 1, 2, prec);
}
else if (which == 3)
{
acb_poly_inv_series(w, s, 2, prec); /* w = 1/(1-z) */
acb_hypgeom_2f1_series_direct(t, a, cb, ab1, w, 1, 2, prec);
acb_hypgeom_2f1_series_direct(u, b, ca, ba1, w, 1, 2, prec);
}
else if (which == 4)
{
acb_poly_set(w, s); /* w = 1-z */
acb_poly_add(v, ac1, b, prec); /* v = a+b-c+1 */
acb_hypgeom_2f1_series_direct(t, a, b, v, w, 1, 2, prec);
acb_poly_add_si(v, cab, 1, prec); /* v = c-a-b+1 */
acb_hypgeom_2f1_series_direct(u, ca, cb, v, w, 1, 2, prec);
}
else if (which == 5)
{
acb_poly_inv_series(w, z, 2, prec); /* w = 1-1/z */
acb_poly_neg(w, w);
acb_poly_add_si(w, w, 1, prec);
acb_poly_add(v, ac1, b, prec); /* v = a+b-c+1 */
acb_hypgeom_2f1_series_direct(t, a, ac1, v, w, 1, 2, prec);
acb_poly_add_si(v, cab, 1, prec); /* v = c-a-b+1 */
acb_poly_add_si(u, a, -1, prec); /* u = 1-a */
acb_poly_neg(u, u);
acb_hypgeom_2f1_series_direct(u, ca, u, v, w, 1, 2, prec);
}
else
{
flint_printf("invalid transformation!\n");
abort();
}
/* gamma factors */
acb_poly_rgamma_series(v, a, 2, prec);
acb_poly_mullow(u, u, v, 2, prec);
acb_poly_rgamma_series(v, ca, 2, prec);
acb_poly_mullow(t, t, v, 2, prec);
acb_poly_rgamma_series(v, b, 2, prec);
if (which == 2 || which == 3)
acb_poly_mullow(t, t, v, 2, prec);
else
acb_poly_mullow(u, u, v, 2, prec);
acb_poly_rgamma_series(v, cb, 2, prec);
if (which == 2 || which == 3)
acb_poly_mullow(u, u, v, 2, prec);
else
acb_poly_mullow(t, t, v, 2, prec);
if (which == 2 || which == 3)
{
if (which == 2)
acb_poly_neg(s, z); /* -z, otherwise 1-z since before */
acb_poly_neg(v, a);
acb_poly_pow_series(v, s, v, 2, prec);
acb_poly_mullow(t, t, v, 2, prec);
acb_poly_neg(v, b);
acb_poly_pow_series(v, s, v, 2, prec);
acb_poly_mullow(u, u, v, 2, prec);
}
else
{
acb_poly_pow_series(v, s, cab, 2, prec);
acb_poly_mullow(u, u, v, 2, prec);
if (which == 5)
{
acb_poly_neg(v, a);
acb_poly_pow_series(v, z, v, 2, prec);
acb_poly_mullow(t, t, v, 2, prec);
acb_poly_neg(v, ca);
acb_poly_pow_series(v, z, v, 2, prec);
acb_poly_mullow(u, u, v, 2, prec);
}
}
acb_poly_sub(t, t, u, prec);
if (which == 2 || which == 3)
acb_poly_sin_pi_series(v, ba, 2, prec);
else
acb_poly_sin_pi_series(v, cab, 2, prec);
acb_poly_get_coeff_acb(tt, t, 1);
acb_poly_get_coeff_acb(res, v, 1);
acb_div(res, tt, res, prec);
acb_const_pi(tt, prec);
acb_mul(res, res, tt, prec);
acb_poly_clear(ba);
acb_poly_clear(ca); acb_poly_clear(cb); acb_poly_clear(cab);
acb_poly_clear(ac1); acb_poly_clear(bc1);
acb_poly_clear(ab1); acb_poly_clear(ba1);
acb_poly_clear(w); acb_poly_clear(t);
acb_poly_clear(u); acb_poly_clear(v);
acb_poly_clear(s);
acb_clear(tt);
}
int main()
{
long iter;
flint_rand_t state;
printf("root_bound_fujiwara....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
acb_poly_t a;
acb_ptr roots;
acb_t t;
mag_t mag1, mag2;
long i, deg, prec;
prec = 10 + n_randint(state, 400);
deg = n_randint(state, 10);
acb_init(t);
acb_poly_init(a);
mag_init(mag1);
mag_init(mag2);
roots = _acb_vec_init(deg);
for (i = 0; i < deg; i++)
acb_randtest(roots + i, state, prec, 1 + n_randint(state, 20));
acb_poly_product_roots(a, roots, deg, prec);
acb_randtest(t, state, prec, 1 + n_randint(state, 20));
_acb_vec_scalar_mul(a->coeffs, a->coeffs, a->length, t, prec);
acb_poly_root_bound_fujiwara(mag1, a);
for (i = 0; i < deg; i++)
{
acb_get_mag(mag2, roots + i);
/* acb_get_mag gives an upper bound which due to rounding
could be larger than mag1, so we pick a slightly
smaller number */
mag_mul_ui(mag2, mag2, 10000);
mag_div_ui(mag2, mag2, 10001);
if (mag_cmp(mag2, mag1) > 0)
{
printf("FAIL\n");
printf("a = "); acb_poly_printd(a, 15); printf("\n\n");
printf("root = "); acb_printd(roots + i, 15); printf("\n\n");
printf("mag1 = "); mag_printd(mag1, 10); printf("\n\n");
printf("mag2 = "); mag_printd(mag2, 10); printf("\n\n");
abort();
}
}
_acb_vec_clear(roots, deg);
acb_clear(t);
acb_poly_clear(a);
mag_clear(mag1);
mag_clear(mag2);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int iter;
flint_rand_t state;
flint_printf("set_trunc_round....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_poly_t a, b, c, d, e;
slong n, prec;
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_init(d);
acb_poly_init(e);
acb_poly_randtest(a, state, n_randint(state, 10), 2 + n_randint(state, 200), 10);
acb_poly_randtest(b, state, n_randint(state, 10), 2 + n_randint(state, 200), 10);
acb_poly_randtest(c, state, n_randint(state, 10), 2 + n_randint(state, 200), 10);
acb_poly_randtest(d, state, n_randint(state, 10), 2 + n_randint(state, 200), 10);
acb_poly_randtest(e, state, n_randint(state, 10), 2 + n_randint(state, 200), 10);
n = n_randint(state, 10);
prec = 2 + n_randint(state, 200);
acb_poly_set_trunc(b, a, n);
acb_poly_set_round(b, b, prec);
acb_poly_set_round(c, a, prec);
acb_poly_set_trunc(c, c, n);
acb_poly_set_trunc_round(d, a, n, prec);
acb_poly_set(e, a);
acb_poly_set_trunc_round(e, e, n, prec);
if (!acb_poly_equal(b, c) || !acb_poly_equal(c, d) || !acb_poly_equal(d, e))
{
flint_printf("FAIL\n\n");
acb_poly_printd(a, 50), flint_printf("\n\n");
acb_poly_printd(b, 50), flint_printf("\n\n");
acb_poly_printd(c, 50), flint_printf("\n\n");
acb_poly_printd(d, 50), flint_printf("\n\n");
acb_poly_printd(e, 50), flint_printf("\n\n");
flint_abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_poly_clear(d);
acb_poly_clear(e);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return 0;
}
int main()
{
long iter;
flint_rand_t state;
printf("sin_pi_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
long m, n1, n2, bits1, bits2, bits3;
acb_poly_t S, A, B, C;
acb_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);
acb_poly_init(S);
acb_poly_init(A);
acb_poly_init(B);
acb_poly_init(C);
acb_init(pi);
acb_poly_randtest(S, state, m, bits1, 3);
acb_poly_randtest(A, state, m, bits1, 3);
acb_poly_randtest(B, state, m, bits1, 3);
acb_poly_sin_pi_series(A, S, n1, bits2);
acb_const_pi(pi, bits3);
acb_poly_set_acb(B, pi);
acb_poly_mul(B, S, B, bits3);
acb_poly_sin_series(B, B, n2, bits3);
acb_poly_set(C, A);
acb_poly_truncate(C, FLINT_MIN(n1, n2));
acb_poly_truncate(B, FLINT_MIN(n1, n2));
if (!acb_poly_overlaps(B, C))
{
printf("FAIL\n\n");
printf("S = "); acb_poly_printd(S, 15); printf("\n\n");
printf("A = "); acb_poly_printd(A, 15); printf("\n\n");
printf("B = "); acb_poly_printd(B, 15); printf("\n\n");
abort();
}
acb_poly_sin_pi_series(S, S, n1, bits2);
if (!acb_poly_overlaps(A, S))
{
printf("FAIL (aliasing)\n\n");
abort();
}
acb_poly_clear(S);
acb_poly_clear(A);
acb_poly_clear(B);
acb_poly_clear(C);
acb_clear(pi);
}
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;
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()
{
long iter;
flint_rand_t state;
printf("digamma_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
long m, n1, n2, rbits1, rbits2, rbits3;
acb_poly_t a, b, c, d;
rbits1 = 2 + n_randint(state, 300);
rbits2 = 2 + n_randint(state, 300);
rbits3 = 2 + n_randint(state, 300);
m = n_randint(state, 25);
n1 = n_randint(state, 25);
n2 = n_randint(state, 25);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_init(d);
acb_poly_randtest(a, state, m, rbits1, 10);
acb_poly_digamma_series(b, a, n1, rbits2);
acb_poly_digamma_series(c, a, n2, rbits3);
acb_poly_set(d, b);
acb_poly_truncate(d, FLINT_MIN(n1, n2));
acb_poly_truncate(c, FLINT_MIN(n1, n2));
if (!acb_poly_overlaps(c, d))
{
printf("FAIL\n\n");
printf("n1 = %ld, n2 = %ld, bits2 = %ld, bits3 = %ld\n", n1, n2, rbits2, rbits3);
printf("a = "); acb_poly_printd(a, 50); printf("\n\n");
printf("b = "); acb_poly_printd(b, 50); printf("\n\n");
printf("c = "); acb_poly_printd(c, 50); printf("\n\n");
abort();
}
/* check psi(a) + 1/a = psi(a+1) */
acb_poly_inv_series(c, a, n1, rbits2);
acb_poly_add(c, b, c, rbits2);
acb_poly_add_si(d, a, 1, rbits2);
acb_poly_digamma_series(d, d, n1, rbits2);
if (!acb_poly_overlaps(c, d))
{
printf("FAIL (functional equation)\n\n");
printf("a = "); acb_poly_printd(a, 15); printf("\n\n");
printf("b = "); acb_poly_printd(b, 15); printf("\n\n");
printf("c = "); acb_poly_printd(c, 15); printf("\n\n");
printf("d = "); acb_poly_printd(d, 15); printf("\n\n");
abort();
}
acb_poly_digamma_series(a, a, n1, rbits2);
if (!acb_poly_overlaps(a, b))
{
printf("FAIL (aliasing)\n\n");
abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_poly_clear(d);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("interpolate_fast....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong i, n, qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_poly_t P;
acb_poly_t R, S;
fmpq_t t, u;
acb_ptr xs, ys;
fmpq_poly_init(P);
acb_poly_init(R);
acb_poly_init(S);
fmpq_init(t);
fmpq_init(u);
qbits1 = 2 + n_randint(state, 200);
qbits2 = 2 + n_randint(state, 5);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
fmpq_poly_randtest(P, state, 1 + n_randint(state, 20), qbits1);
n = P->length;
xs = _acb_vec_init(n);
ys = _acb_vec_init(n);
acb_poly_set_fmpq_poly(R, P, rbits1);
if (n > 0)
{
fmpq_randtest(t, state, qbits2);
acb_set_fmpq(xs, t, rbits2);
for (i = 1; i < n; i++)
{
fmpq_randtest_not_zero(u, state, qbits2);
fmpq_abs(u, u);
fmpq_add(t, t, u);
acb_set_fmpq(xs + i, t, rbits2);
}
}
for (i = 0; i < n; i++)
acb_poly_evaluate(ys + i, R, xs + i, rbits2);
acb_poly_interpolate_fast(S, xs, ys, n, rbits3);
if (!acb_poly_contains_fmpq_poly(S, P))
{
flint_printf("FAIL:\n");
flint_printf("P = "); fmpq_poly_print(P); flint_printf("\n\n");
flint_printf("R = "); acb_poly_printd(R, 15); flint_printf("\n\n");
flint_printf("S = "); acb_poly_printd(S, 15); flint_printf("\n\n");
flint_abort();
}
fmpq_poly_clear(P);
acb_poly_clear(R);
acb_poly_clear(S);
fmpq_clear(t);
fmpq_clear(u);
_acb_vec_clear(xs, n);
_acb_vec_clear(ys, n);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("exp_pi_i_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
slong m, n, prec;
acb_poly_t a, b, c;
acb_t t;
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_init(t);
prec = 2 + n_randint(state, 100);
acb_poly_randtest(a, state, 1 + n_randint(state, 20), prec, 5);
acb_poly_randtest(b, state, 1 + n_randint(state, 20), prec, 5);
acb_poly_randtest(c, state, 1 + n_randint(state, 20), prec, 5);
m = n_randint(state, 20);
n = n_randint(state, 20);
if (n_randint(state, 2) == 0)
acb_poly_exp_pi_i_series(b, a, m, prec);
else
{
acb_poly_set(b, a);
acb_poly_exp_pi_i_series(b, b, m, prec);
}
acb_const_pi(t, prec);
acb_mul_onei(t, t);
acb_poly_scalar_mul(c, a, t, prec);
acb_poly_exp_series(c, c, n, prec);
acb_poly_truncate(b, FLINT_MIN(m, n));
acb_poly_truncate(c, FLINT_MIN(m, n));
if (!acb_poly_overlaps(b, c))
{
flint_printf("FAIL\n\n");
flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n");
flint_abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_clear(t);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_unique_fmpz_poly....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong prec, c;
fmpz_poly_t A, B, C;
acb_poly_t a, b;
fmpz_poly_init(A);
fmpz_poly_init(B);
fmpz_poly_init(C);
acb_poly_init(a);
acb_poly_init(b);
fmpz_poly_randtest(A, state, 1 + n_randint(state, 10), 1 + n_randint(state, 1000));
fmpz_poly_randtest(B, state, 1 + n_randint(state, 10), 1 + n_randint(state, 1000));
fmpz_poly_randtest(C, state, 1 + n_randint(state, 10), 1 + n_randint(state, 1000));
c = 1 + n_randint(state, 1000);
prec = 2 + n_randint(state, 100);
for ( ; ; )
{
acb_poly_set_fmpz_poly(a, A, prec);
acb_poly_set2_fmpz_poly(b, B, C, prec);
acb_poly_scalar_mul_2exp_si(b, b, -c);
acb_poly_add(a, a, b, prec);
acb_poly_sub(a, a, b, prec);
if (acb_poly_get_unique_fmpz_poly(B, a))
{
if (!fmpz_poly_equal(A, B))
{
flint_printf("FAIL\n\n");
flint_printf("A = "); fmpz_poly_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpz_poly_print(B); flint_printf("\n\n");
flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n");
abort();
}
break;
}
else
{
prec *= 2;
}
}
fmpz_poly_clear(A);
fmpz_poly_clear(B);
fmpz_poly_clear(C);
acb_poly_clear(a);
acb_poly_clear(b);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_u_1f1_series(acb_poly_t res,
const acb_poly_t a, const acb_poly_t b, const acb_poly_t z,
long len, long prec)
{
acb_poly_t s, u, A, B;
acb_poly_struct aa[3];
arb_t c;
long wlen;
int singular;
acb_poly_init(s);
acb_poly_init(u);
acb_poly_init(A);
acb_poly_init(B);
acb_poly_init(aa + 0);
acb_poly_init(aa + 1);
acb_poly_init(aa + 2);
arb_init(c);
singular = (b->length == 0) || acb_is_int(b->coeffs);
wlen = len + (singular != 0);
/* A = rgamma(a-b+1) * 1F~1(a,b,z) */
acb_poly_sub(u, a, b, prec);
acb_poly_add_si(u, u, 1, prec);
acb_poly_rgamma_series(A, u, wlen, prec);
/* todo: handle a = 1 efficiently */
acb_poly_set(aa, a);
acb_poly_set(aa + 1, b);
acb_poly_one(aa + 2);
acb_hypgeom_pfq_series_direct(s, aa, 1, aa + 1, 2, z, 1, -1, wlen, prec);
acb_poly_mullow(A, A, s, wlen, prec);
/* B = rgamma(a) * 1F~1(a-b+1,2-b,z) * z^(1-b) */
acb_poly_set(aa, u);
acb_poly_add_si(aa + 1, b, -2, prec);
acb_poly_neg(aa + 1, aa + 1);
acb_hypgeom_pfq_series_direct(s, aa, 1, aa + 1, 2, z, 1, -1, wlen, prec);
acb_poly_rgamma_series(B, a, wlen, prec);
acb_poly_mullow(B, B, s, wlen, prec);
acb_poly_add_si(u, b, -1, prec);
acb_poly_neg(u, u);
acb_poly_pow_series(s, z, u, wlen, prec);
acb_poly_mullow(B, B, s, wlen, prec);
acb_poly_sub(A, A, B, prec);
/* multiply by pi csc(pi b) */
acb_poly_sin_pi_series(B, b, wlen, prec);
if (singular)
{
acb_poly_shift_right(A, A, 1);
acb_poly_shift_right(B, B, 1);
}
acb_poly_div_series(res, A, B, len, prec);
arb_const_pi(c, prec);
_acb_vec_scalar_mul_arb(res->coeffs, res->coeffs, res->length, c, prec);
acb_poly_clear(s);
acb_poly_clear(u);
acb_poly_clear(A);
acb_poly_clear(B);
acb_poly_clear(aa + 0);
acb_poly_clear(aa + 1);
acb_poly_clear(aa + 2);
arb_clear(c);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("lgamma_series....");
fflush(stdout);
flint_randinit(state);
/* special accuracy test case */
{
acb_poly_t a;
acb_t c;
acb_init(c);
acb_poly_init(a);
arb_set_str(acb_realref(c), "-20.25", 53);
arb_set_str(acb_imagref(c), "1e1000", 53);
acb_poly_set_coeff_acb(a, 0, c);
acb_poly_set_coeff_si(a, 1, 1);
acb_poly_lgamma_series(a, a, 3, 53);
if (acb_rel_accuracy_bits(a->coeffs) < 40 ||
acb_rel_accuracy_bits(a->coeffs + 1) < 40 ||
acb_rel_accuracy_bits(a->coeffs + 2) < 40)
{
flint_printf("FAIL: accuracy (reflection formula)\n\n");
acb_poly_printd(a, 15); flint_printf("\n\n");
abort();
}
acb_poly_clear(a);
acb_clear(c);
}
for (iter = 0; iter < 500 * arb_test_multiplier(); iter++)
{
slong m, n1, n2, rbits1, rbits2, rbits3;
acb_poly_t a, b, c, d;
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
m = 1 + n_randint(state, 30);
n1 = 1 + n_randint(state, 30);
n2 = 1 + n_randint(state, 30);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_init(d);
acb_poly_randtest(a, state, m, rbits1, 10);
acb_poly_randtest(b, state, m, rbits1, 10);
acb_poly_randtest(c, state, m, rbits1, 10);
acb_poly_lgamma_series(b, a, n1, rbits2);
acb_poly_lgamma_series(c, a, n2, rbits3);
acb_poly_set(d, b);
acb_poly_truncate(d, FLINT_MIN(n1, n2));
acb_poly_truncate(c, FLINT_MIN(n1, n2));
if (!acb_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 = "); acb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n");
abort();
}
/* check loggamma(a) + log(a) = loggamma(a+1) */
acb_poly_log_series(c, a, n1, rbits2);
acb_poly_add(c, b, c, rbits2);
acb_poly_set(d, a);
acb_add_ui(d->coeffs, d->coeffs, 1, rbits2);
acb_poly_lgamma_series(d, d, n1, rbits2);
if (!acb_poly_overlaps(c, d))
{
flint_printf("FAIL (functional equation)\n\n");
flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n");
flint_printf("d = "); acb_poly_printd(d, 15); flint_printf("\n\n");
abort();
}
acb_poly_lgamma_series(a, a, n1, rbits2);
if (!acb_poly_overlaps(a, b))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_poly_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("shift_left/right....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b for left shift */
for (i = 0; i < 1000; i++)
{
acb_poly_t a, b;
long shift = n_randint(state, 100);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_randtest(a, state, n_randint(state, 100), 2 + n_randint(state, 200), 10);
acb_poly_shift_left(b, a, shift);
acb_poly_shift_left(a, a, shift);
result = (acb_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
acb_poly_printd(a, 10), printf("\n\n");
acb_poly_printd(b, 10), printf("\n\n");
abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
}
/* Check aliasing of a and b for right shift */
for (i = 0; i < 1000; i++)
{
acb_poly_t a, b;
long shift = n_randint(state, 100);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_randtest(a, state, n_randint(state, 100), 2 + n_randint(state, 200), 10);
acb_poly_shift_right(b, a, shift);
acb_poly_shift_right(a, a, shift);
result = (acb_poly_equal(a, b));
if (!result)
{
printf("FAIL:\n");
acb_poly_printd(a, 10), printf("\n\n");
acb_poly_printd(b, 10), printf("\n\n");
abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
}
/* Check shift left then right does nothing */
for (i = 0; i < 1000; i++)
{
acb_poly_t a, b, c;
long shift = n_randint(state, 100);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_randtest(a, state, n_randint(state, 100), 2 + n_randint(state, 200), 10);
acb_poly_shift_left(b, a, shift);
acb_poly_shift_right(c, b, shift);
result = (acb_poly_equal(c, a));
if (!result)
{
printf("FAIL:\n");
acb_poly_printd(a, 10), printf("\n\n");
acb_poly_printd(b, 10), printf("\n\n");
acb_poly_printd(c, 10), printf("\n\n");
abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return 0;
}
void
acb_hypgeom_pfq_series_sum_forward(acb_poly_t s, acb_poly_t t,
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 u, v;
acb_poly_t tmp;
long k, i;
acb_poly_init(u);
acb_poly_init(v);
acb_poly_init(tmp);
if (!regularized)
{
acb_poly_zero(s);
acb_poly_one(t);
for (k = 0; k < n && acb_poly_length(t) != 0; k++)
{
acb_poly_add(s, s, t, prec);
if (p > 0)
{
acb_poly_add_si(u, a, k, prec);
for (i = 1; i < p; i++)
{
acb_poly_add_si(v, a + i, k, prec);
acb_poly_mullow(u, u, v, len, prec);
}
acb_poly_mullow(t, t, u, len, prec);
}
if (q > 0)
{
acb_poly_add_si(u, b, k, prec);
for (i = 1; i < q; i++)
{
acb_poly_add_si(v, b + i, k, prec);
acb_poly_mullow(u, u, v, len, prec);
}
acb_poly_div_series(t, t, u, len, prec);
}
acb_poly_mullow(t, t, z, len, prec);
}
}
else
{
acb_poly_zero(s);
for (i = 0; i < q; i++)
{
if (i == 0)
{
acb_poly_rgamma_series(t, b + i, len, prec);
}
else
{
acb_poly_rgamma_series(u, b + i, len, prec);
acb_poly_mullow(tmp, t, u, len, prec);
acb_poly_swap(tmp, t);
}
}
for (k = 0; k < n; k++)
{
acb_poly_add(s, s, t, prec);
if (p > 0)
{
acb_poly_add_si(u, a, k, prec);
for (i = 1; i < p; i++)
{
acb_poly_add_si(v, a + i, k, prec);
acb_poly_mullow(tmp, u, v, len, prec);
acb_poly_swap(tmp, u);
}
acb_poly_mullow(tmp, t, u, len, prec);
acb_poly_swap(tmp, t);
}
if (q > 0)
{
acb_poly_add_si(u, b, k, prec);
for (i = 1; i < q; i++)
{
acb_poly_add_si(v, b + i, k, prec);
acb_poly_mullow(tmp, u, v, len, prec);
acb_poly_swap(tmp, u);
}
if (acb_poly_length(u) > 0 && !acb_contains_zero(u->coeffs))
{
acb_poly_div_series(tmp, t, u, len, prec);
acb_poly_mullow(t, tmp, z, len, prec);
}
else
{
/* compute term from scratch */
acb_poly_one(t);
for (i = 0; i < p; i++)
{
acb_poly_rising_ui_series(v, a + i, k + 1, len, prec);
acb_poly_mullow(t, t, v, len, prec);
}
for (i = 0; i < q; i++)
{
acb_poly_add_si(v, b + i, k + 1, prec);
acb_poly_rgamma_series(v, v, len, prec);
acb_poly_mullow(t, t, v, len, prec);
}
acb_poly_pow_ui_trunc_binexp(v, z, k + 1, len, prec);
acb_poly_mullow(t, t, v, len, prec);
}
}
else
{
acb_poly_mullow(tmp, t, z, len, prec);
acb_poly_swap(tmp, t);
}
}
}
acb_poly_clear(u);
acb_poly_clear(v);
acb_poly_clear(tmp);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("pfq_series_direct....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
acb_poly_struct a[4], b[4];
acb_poly_t z, s1, s2;
slong i, p, q, len1, len2, n1, n2, prec1, prec2;
int regularized;
p = n_randint(state, 3);
q = n_randint(state, 3);
len1 = n_randint(state, 8);
len2 = n_randint(state, 8);
prec1 = 2 + n_randint(state, 400);
prec2 = 2 + n_randint(state, 400);
if (n_randint(state, 2))
n1 = -1;
else
n1 = n_randint(state, 50);
if (n_randint(state, 2))
n2 = -1;
else
n2 = n_randint(state, 50);
regularized = n_randint(state, 2);
acb_poly_init(z);
acb_poly_init(s1);
acb_poly_init(s2);
for (i = 0; i < p; i++)
acb_poly_init(a + i);
for (i = 0; i < q; i++)
acb_poly_init(b + i);
acb_poly_randtest(z, state, 1 + n_randint(state, 10), 1 + n_randint(state, 500), 10);
for (i = 0; i < p; i++)
acb_poly_randtest(a + i, state, 1 + n_randint(state, 10), 1 + n_randint(state, 500), 3);
for (i = 0; i < q; i++)
acb_poly_randtest(b + i, state, 1 + n_randint(state, 10), 1 + n_randint(state, 500), 3);
acb_hypgeom_pfq_series_direct(s1, a, p, b, q, z, regularized, n1, len1, prec1);
acb_hypgeom_pfq_series_direct(s2, a, p, b, q, z, regularized, n2, len2, prec2);
acb_poly_truncate(s1, FLINT_MIN(len1, len2));
acb_poly_truncate(s2, FLINT_MIN(len1, len2));
if (!acb_poly_overlaps(s1, s2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("iter = %wd\n", iter);
flint_printf("n1 = %wd, n2 = %wd prec1 = %wd, prec2 = %wd\n\n", n1, n2, prec1, prec2);
flint_printf("p = %wd, q = %wd\n\n", p, q);
flint_printf("z = "); acb_poly_printd(z, 15); flint_printf("\n\n");
for (i = 0; i < p; i++)
{
flint_printf("a[%wd] = ", i); acb_poly_printd(a + i, 15); flint_printf("\n\n");
}
for (i = 0; i < q; i++)
{
flint_printf("b[%wd] = ", i); acb_poly_printd(b + i, 15); flint_printf("\n\n");
}
flint_printf("s1 = "); acb_poly_printd(s1, 15); flint_printf("\n\n");
flint_printf("s2 = "); acb_poly_printd(s2, 15); flint_printf("\n\n");
acb_poly_sub(s1, s1, s2, prec1);
flint_printf("diff = "); acb_poly_printd(s1, 15); flint_printf("\n\n");
abort();
}
acb_poly_clear(z);
acb_poly_clear(s1);
acb_poly_clear(s2);
for (i = 0; i < p; i++)
acb_poly_clear(a + i);
for (i = 0; i < q; i++)
acb_poly_clear(b + i);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
/* 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("sinc_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 200 * arb_test_multiplier(); iter++)
{
slong m, n1, n2, rbits1, rbits2, rbits3;
acb_poly_t a, b, c, d;
rbits1 = 2 + n_randint(state, 300);
rbits2 = 2 + n_randint(state, 300);
rbits3 = 2 + n_randint(state, 300);
m = n_randint(state, 15);
n1 = n_randint(state, 15);
n2 = n_randint(state, 15);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_init(d);
acb_poly_randtest(a, state, m, rbits1, 10);
acb_poly_randtest(b, state, 10, rbits1, 10);
acb_poly_randtest(c, state, 10, rbits1, 10);
acb_poly_sinc_series(b, a, n1, rbits2);
acb_poly_sinc_series(c, a, n2, rbits3);
acb_poly_set(d, b);
acb_poly_truncate(d, FLINT_MIN(n1, n2));
acb_poly_truncate(c, FLINT_MIN(n1, n2));
if (!acb_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 = "); acb_poly_printd(a, 50); flint_printf("\n\n");
flint_printf("b = "); acb_poly_printd(b, 50); flint_printf("\n\n");
flint_printf("c = "); acb_poly_printd(c, 50); flint_printf("\n\n");
flint_abort();
}
/* check x sinc(x) = sin(x) */
acb_poly_mullow(c, b, a, n1, rbits2);
acb_poly_sin_series(d, a, n1, rbits2);
if (!acb_poly_overlaps(c, d))
{
flint_printf("FAIL (functional equation)\n\n");
flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n");
flint_printf("d = "); acb_poly_printd(d, 15); flint_printf("\n\n");
flint_abort();
}
acb_poly_sinc_series(a, a, n1, rbits2);
if (!acb_poly_overlaps(a, b))
{
flint_printf("FAIL (aliasing)\n\n");
flint_abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_poly_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("evaluate_vec_fast....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong i, n, qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_poly_t F;
fmpq * X, * Y;
acb_poly_t f;
acb_ptr x, y;
qbits1 = 2 + n_randint(state, 100);
qbits2 = 2 + n_randint(state, 100);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
n = n_randint(state, 10);
fmpq_poly_init(F);
X = _fmpq_vec_init(n);
Y = _fmpq_vec_init(n);
acb_poly_init(f);
x = _acb_vec_init(n);
y = _acb_vec_init(n);
fmpq_poly_randtest(F, state, 1 + n_randint(state, 20), qbits1);
for (i = 0; i < n; i++)
fmpq_randtest(X + i, state, qbits2);
for (i = 0; i < n; i++)
fmpq_poly_evaluate_fmpq(Y + i, F, X + i);
acb_poly_set_fmpq_poly(f, F, rbits1);
for (i = 0; i < n; i++)
acb_set_fmpq(x + i, X + i, rbits2);
acb_poly_evaluate_vec_fast(y, f, x, n, rbits3);
for (i = 0; i < n; i++)
{
if (!acb_contains_fmpq(y + i, Y + i))
{
flint_printf("FAIL (%wd of %wd)\n\n", i, n);
flint_printf("F = ");
fmpq_poly_print(F);
flint_printf("\n\n");
flint_printf("X = ");
fmpq_print(X + i);
flint_printf("\n\n");
flint_printf("Y = ");
fmpq_print(Y + i);
flint_printf("\n\n");
flint_printf("f = ");
acb_poly_printd(f, 15);
flint_printf("\n\n");
flint_printf("x = ");
acb_printd(x + i, 15);
flint_printf("\n\n");
flint_printf("y = ");
acb_printd(y + i, 15);
flint_printf("\n\n");
abort();
}
}
fmpq_poly_clear(F);
_fmpq_vec_clear(X, n);
_fmpq_vec_clear(Y, n);
acb_poly_clear(f);
_acb_vec_clear(x, n);
_acb_vec_clear(y, n);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("taylor_shift....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
slong prec1, prec2;
acb_poly_t f, g;
acb_t c, d, e;
prec1 = 2 + n_randint(state, 500);
prec2 = 2 + n_randint(state, 500);
acb_poly_init(f);
acb_poly_init(g);
acb_init(c);
acb_init(d);
acb_init(e);
acb_poly_randtest(f, state, 1 + n_randint(state, 40), 1 + n_randint(state, 500), 10);
acb_poly_randtest(g, state, 1 + n_randint(state, 20), 1 + n_randint(state, 500), 10);
if (n_randint(state, 2))
acb_set_si(c, n_randint(state, 5) - 2);
else
acb_randtest(c, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
if (n_randint(state, 2))
acb_set_si(d, n_randint(state, 5) - 2);
else
acb_randtest(d, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_add(e, c, d, prec1);
/* check f(x+c)(x+d) = f(x+c+d) */
acb_poly_taylor_shift(g, f, e, prec2);
acb_poly_taylor_shift(f, f, c, prec1);
acb_poly_taylor_shift(f, f, d, prec1);
if (!acb_poly_overlaps(f, g))
{
flint_printf("FAIL\n\n");
flint_printf("c = "); acb_printd(c, 15); flint_printf("\n\n");
flint_printf("d = "); acb_printd(d, 15); flint_printf("\n\n");
flint_printf("f = "); acb_poly_printd(f, 15); flint_printf("\n\n");
flint_printf("g = "); acb_poly_printd(g, 15); flint_printf("\n\n");
abort();
}
acb_poly_clear(f);
acb_poly_clear(g);
acb_clear(c);
acb_clear(d);
acb_clear(e);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("shi_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 200 * arb_test_multiplier(); iter++)
{
slong m, n1, n2, n3, bits1, bits2, bits3;
acb_poly_t S, A, B, C, T, U;
bits1 = 2 + n_randint(state, 200);
bits2 = 2 + n_randint(state, 200);
bits3 = 2 + n_randint(state, 200);
m = 1 + n_randint(state, 10);
n1 = 1 + n_randint(state, 10);
n2 = 1 + n_randint(state, 10);
n3 = FLINT_MIN(n1, n2);
acb_poly_init(S);
acb_poly_init(A);
acb_poly_init(B);
acb_poly_init(C);
acb_poly_init(T);
acb_poly_init(U);
acb_poly_randtest(S, state, m, bits1, 3);
acb_poly_randtest(A, state, m, bits1, 3);
acb_poly_randtest(B, state, m, bits1, 3);
acb_hypgeom_shi_series(A, S, n1, bits2);
acb_hypgeom_shi_series(B, S, n2, bits3);
acb_poly_set(C, A);
acb_poly_truncate(C, n3);
acb_poly_truncate(B, n3);
/* [Shi(h(x))]' h(x) = sinh(h(x)) h'(x) */
acb_poly_sinh_series(U, S, n3, bits2);
acb_poly_derivative(T, S, bits2);
acb_poly_mullow(U, U, T, FLINT_MAX(0, n3 - 1), bits2);
acb_poly_derivative(T, A, bits2);
acb_poly_mullow(T, T, S, FLINT_MAX(0, n3 - 1), bits2);
if (!acb_poly_overlaps(B, C) || !acb_poly_overlaps(T, U))
{
flint_printf("FAIL\n\n");
flint_printf("S = "); acb_poly_printd(S, 15); flint_printf("\n\n");
flint_printf("A = "); acb_poly_printd(A, 15); flint_printf("\n\n");
flint_printf("B = "); acb_poly_printd(B, 15); flint_printf("\n\n");
flint_printf("T = "); acb_poly_printd(T, 15); flint_printf("\n\n");
flint_printf("U = "); acb_poly_printd(U, 15); flint_printf("\n\n");
flint_abort();
}
acb_hypgeom_shi_series(S, S, n1, bits2);
if (!acb_poly_overlaps(A, S))
{
flint_printf("FAIL (aliasing)\n\n");
flint_abort();
}
acb_poly_clear(S);
acb_poly_clear(A);
acb_poly_clear(B);
acb_poly_clear(C);
acb_poly_clear(T);
acb_poly_clear(U);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("rsqrt_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 5000 * arb_test_multiplier(); iter++)
{
slong m, n, qbits, rbits1, rbits2;
fmpq_poly_t A;
acb_poly_t a, b, c;
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);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
fmpq_poly_randtest_not_zero(A, state, m, qbits);
acb_poly_set_fmpq_poly(a, A, rbits1);
acb_poly_randtest(b, state, 1 + n_randint(state, 30), rbits1, 5);
acb_poly_rsqrt_series(b, a, n, rbits2);
/* Check 1/((1/sqrt(a))^2) = a */
acb_poly_mullow(c, b, b, n, rbits2);
acb_poly_inv_series(c, c, n, rbits2);
fmpq_poly_truncate(A, n);
if (!acb_poly_contains_fmpq_poly(c, A))
{
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 = "); acb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n");
abort();
}
acb_poly_rsqrt_series(a, a, n, rbits2);
if (!acb_poly_equal(a, b))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
fmpq_poly_clear(A);
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_2f1_transform_limit(acb_t res, const acb_t a, const acb_t b,
const acb_t c, const acb_t z, int regularized, int which, slong prec)
{
acb_poly_t aa, bb, cc, zz;
acb_t t;
if (acb_contains_zero(z) || !acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
if (arb_contains_si(acb_realref(z), 1) && arb_contains_zero(acb_imagref(z)))
{
acb_indeterminate(res);
return;
}
if (!regularized)
{
acb_init(t);
acb_gamma(t, c, prec);
acb_hypgeom_2f1_transform_limit(res, a, b, c, z, 1, which, prec);
acb_mul(res, res, t, prec);
acb_clear(t);
return;
}
acb_poly_init(aa);
acb_poly_init(bb);
acb_poly_init(cc);
acb_poly_init(zz);
acb_init(t);
acb_poly_set_acb(aa, a);
acb_poly_set_acb(bb, b);
acb_poly_set_acb(cc, c);
acb_poly_set_acb(zz, z);
if (which == 2 || which == 3)
{
acb_sub(t, b, a, prec);
acb_poly_set_coeff_si(aa, 1, 1);
/* prefer b-a nonnegative (either is correct) to avoid
expensive operations in the hypergeometric series */
if (arb_is_nonnegative(acb_realref(t)))
_acb_hypgeom_2f1_transform_limit(res, aa, bb, cc, zz, which, prec);
else
_acb_hypgeom_2f1_transform_limit(res, bb, aa, cc, zz, which, prec);
}
else
{
acb_poly_set_coeff_si(aa, 1, 1);
_acb_hypgeom_2f1_transform_limit(res, aa, bb, cc, zz, which, prec);
}
acb_poly_clear(aa);
acb_poly_clear(bb);
acb_poly_clear(cc);
acb_poly_clear(zz);
acb_clear(t);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("tan_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++)
{
slong m, n, rbits1, rbits2;
acb_poly_t a, b, c, d, e;
rbits1 = 2 + n_randint(state, 100);
rbits2 = 2 + n_randint(state, 100);
if (n_randint(state, 10) == 0)
{
m = 1 + n_randint(state, 50);
n = 1 + n_randint(state, 50);
}
else
{
m = 1 + n_randint(state, 20);
n = 1 + n_randint(state, 20);
}
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_init(d);
acb_poly_init(e);
acb_poly_randtest(a, state, m, rbits1, 10);
acb_poly_tan_series(b, a, n, rbits2);
/* check tan(x) = 2*tan(x/2)/(1-tan(x/2)^2) */
acb_poly_scalar_mul_2exp_si(c, a, -1);
acb_poly_tan_series(c, c, n, rbits2);
acb_poly_mullow(d, c, c, n, rbits2);
acb_poly_one(e);
acb_poly_sub(e, e, d, rbits2);
acb_poly_div_series(c, c, e, n, rbits2);
acb_poly_scalar_mul_2exp_si(c, c, 1);
if (!acb_poly_overlaps(b, c))
{
flint_printf("FAIL\n\n");
flint_printf("bits2 = %wd\n", rbits2);
flint_printf("a = ");
acb_poly_printd(a, 15);
flint_printf("\n\n");
flint_printf("b = ");
acb_poly_printd(b, 15);
flint_printf("\n\n");
flint_printf("c = ");
acb_poly_printd(c, 15);
flint_printf("\n\n");
abort();
}
acb_poly_tan_series(a, a, n, rbits2);
if (!acb_poly_equal(a, b))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_poly_clear(d);
acb_poly_clear(e);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
fmpz_poly_complex_roots_squarefree(const fmpz_poly_t poly,
slong initial_prec,
slong target_prec,
slong print_digits)
{
slong i, j, prec, deg, deg_deflated, isolated, maxiter, deflation;
acb_poly_t cpoly, cpoly_deflated;
fmpz_poly_t poly_deflated;
acb_ptr roots, roots_deflated;
int removed_zero;
if (fmpz_poly_degree(poly) < 1)
return;
fmpz_poly_init(poly_deflated);
acb_poly_init(cpoly);
acb_poly_init(cpoly_deflated);
/* try to write poly as poly_deflated(x^deflation), possibly multiplied by x */
removed_zero = fmpz_is_zero(poly->coeffs);
if (removed_zero)
fmpz_poly_shift_right(poly_deflated, poly, 1);
else
fmpz_poly_set(poly_deflated, poly);
deflation = fmpz_poly_deflation(poly_deflated);
fmpz_poly_deflate(poly_deflated, poly_deflated, deflation);
deg = fmpz_poly_degree(poly);
deg_deflated = fmpz_poly_degree(poly_deflated);
flint_printf("searching for %wd roots, %wd deflated\n", deg, deg_deflated);
roots = _acb_vec_init(deg);
roots_deflated = _acb_vec_init(deg_deflated);
for (prec = initial_prec; ; prec *= 2)
{
acb_poly_set_fmpz_poly(cpoly_deflated, poly_deflated, prec);
maxiter = FLINT_MIN(FLINT_MAX(deg_deflated, 32), prec);
TIMEIT_ONCE_START
flint_printf("prec=%wd: ", prec);
isolated = acb_poly_find_roots(roots_deflated, cpoly_deflated,
prec == initial_prec ? NULL : roots_deflated, maxiter, prec);
flint_printf("%wd isolated roots | ", isolated);
TIMEIT_ONCE_STOP
if (isolated == deg_deflated)
{
if (!check_accuracy(roots_deflated, deg_deflated, target_prec))
continue;
if (deflation == 1)
{
_acb_vec_set(roots, roots_deflated, deg_deflated);
}
else /* compute all nth roots */
{
acb_t w, w2;
acb_init(w);
acb_init(w2);
acb_unit_root(w, deflation, prec);
acb_unit_root(w2, 2 * deflation, prec);
for (i = 0; i < deg_deflated; i++)
{
if (arf_sgn(arb_midref(acb_realref(roots_deflated + i))) > 0)
{
acb_root_ui(roots + i * deflation,
roots_deflated + i, deflation, prec);
}
else
{
acb_neg(roots + i * deflation, roots_deflated + i);
acb_root_ui(roots + i * deflation,
roots + i * deflation, deflation, prec);
acb_mul(roots + i * deflation,
roots + i * deflation, w2, prec);
}
for (j = 1; j < deflation; j++)
{
acb_mul(roots + i * deflation + j,
roots + i * deflation + j - 1, w, prec);
}
}
acb_clear(w);
acb_clear(w2);
}
/* by assumption that poly is squarefree, must be just one */
if (removed_zero)
acb_zero(roots + deg_deflated * deflation);
if (!check_accuracy(roots, deg, target_prec))
continue;
acb_poly_set_fmpz_poly(cpoly, poly, prec);
if (!acb_poly_validate_real_roots(roots, cpoly, prec))
continue;
for (i = 0; i < deg; i++)
{
if (arb_contains_zero(acb_imagref(roots + i)))
arb_zero(acb_imagref(roots + i));
}
flint_printf("done!\n");
break;
}
}
if (print_digits != 0)
{
_acb_vec_sort_pretty(roots, deg);
for (i = 0; i < deg; i++)
{
acb_printn(roots + i, print_digits, 0);
flint_printf("\n");
}
}
fmpz_poly_clear(poly_deflated);
acb_poly_clear(cpoly);
acb_poly_clear(cpoly_deflated);
_acb_vec_clear(roots, deg);
_acb_vec_clear(roots_deflated, deg_deflated);
}
int main()
{
long iter;
flint_rand_t state;
printf("mullow_classical....");
fflush(stdout);
flint_randinit(state);
/* compare with fmpq_poly */
for (iter = 0; iter < 10000; iter++)
{
long qbits1, qbits2, rbits1, rbits2, rbits3, trunc;
fmpq_poly_t A, B, C;
acb_poly_t a, b, c, d;
qbits1 = 2 + n_randint(state, 200);
qbits2 = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
trunc = n_randint(state, 10);
fmpq_poly_init(A);
fmpq_poly_init(B);
fmpq_poly_init(C);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_init(d);
fmpq_poly_randtest(A, state, 1 + n_randint(state, 10), qbits1);
fmpq_poly_randtest(B, state, 1 + n_randint(state, 10), qbits2);
fmpq_poly_mullow(C, A, B, trunc);
acb_poly_set_fmpq_poly(a, A, rbits1);
acb_poly_set_fmpq_poly(b, B, rbits2);
acb_poly_mullow_classical(c, a, b, trunc, rbits3);
if (!acb_poly_contains_fmpq_poly(c, C))
{
printf("FAIL\n\n");
printf("bits3 = %ld\n", rbits3);
printf("trunc = %ld\n", trunc);
printf("A = "); fmpq_poly_print(A); printf("\n\n");
printf("B = "); fmpq_poly_print(B); printf("\n\n");
printf("C = "); fmpq_poly_print(C); printf("\n\n");
printf("a = "); acb_poly_printd(a, 15); printf("\n\n");
printf("b = "); acb_poly_printd(b, 15); printf("\n\n");
printf("c = "); acb_poly_printd(c, 15); printf("\n\n");
abort();
}
acb_poly_set(d, a);
acb_poly_mullow_classical(d, d, b, trunc, rbits3);
if (!acb_poly_equal(d, c))
{
printf("FAIL (aliasing 1)\n\n");
abort();
}
acb_poly_set(d, b);
acb_poly_mullow_classical(d, a, d, trunc, rbits3);
if (!acb_poly_equal(d, c))
{
printf("FAIL (aliasing 2)\n\n");
abort();
}
/* test squaring */
acb_poly_set(b, a);
acb_poly_mullow_classical(c, a, b, trunc, rbits3);
acb_poly_mullow_classical(d, a, a, trunc, rbits3);
if (!acb_poly_overlaps(c, d)) /* not guaranteed to be identical */
{
printf("FAIL (squaring)\n\n");
printf("a = "); acb_poly_printd(a, 15); printf("\n\n");
printf("b = "); acb_poly_printd(b, 15); printf("\n\n");
printf("c = "); acb_poly_printd(c, 15); printf("\n\n");
abort();
}
acb_poly_mullow_classical(a, a, a, trunc, rbits3);
if (!acb_poly_equal(d, a))
{
printf("FAIL (aliasing, squaring)\n\n");
printf("a = "); acb_poly_printd(a, 15); printf("\n\n");
printf("b = "); acb_poly_printd(b, 15); printf("\n\n");
printf("d = "); acb_poly_printd(d, 15); printf("\n\n");
abort();
}
fmpq_poly_clear(A);
fmpq_poly_clear(B);
fmpq_poly_clear(C);
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_poly_clear(d);
}
/* check a*(b+c) = a*b+a*c */
for (iter = 0; iter < 10000; iter++)
{
long bits, trunc;
acb_poly_t a, b, c, bc, abc, ab, ac, abac;
bits = 2 + n_randint(state, 200);
trunc = n_randint(state, 10);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_init(bc);
acb_poly_init(abc);
acb_poly_init(ab);
acb_poly_init(ac);
acb_poly_init(abac);
acb_poly_randtest(a, state, 1 + n_randint(state, 10), bits, 5);
acb_poly_randtest(b, state, 1 + n_randint(state, 10), bits, 5);
acb_poly_randtest(c, state, 1 + n_randint(state, 10), bits, 5);
acb_poly_add(bc, b, c, bits);
acb_poly_mullow_classical(abc, a, bc, trunc, bits);
acb_poly_mullow_classical(ab, a, b, trunc, bits);
acb_poly_mullow_classical(ac, a, c, trunc, bits);
acb_poly_add(abac, ab, ac, bits);
if (!acb_poly_overlaps(abc, abac))
{
printf("FAIL\n\n");
printf("bits = %ld\n", bits);
printf("trunc = %ld\n", trunc);
printf("a = "); acb_poly_printd(a, 15); printf("\n\n");
printf("b = "); acb_poly_printd(b, 15); printf("\n\n");
printf("c = "); acb_poly_printd(c, 15); printf("\n\n");
printf("abc = "); acb_poly_printd(abc, 15); printf("\n\n");
printf("abac = "); acb_poly_printd(abac, 15); printf("\n\n");
abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_poly_clear(bc);
acb_poly_clear(abc);
acb_poly_clear(ab);
acb_poly_clear(ac);
acb_poly_clear(abac);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
