int main()
{
slong iter;
flint_rand_t state;
flint_printf("exp_series_basecase....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong m, n, bits1, bits2, bits3;
acb_poly_t a, b, c, d;
bits1 = 2 + n_randint(state, 100);
bits2 = 2 + n_randint(state, 100);
bits3 = 2 + n_randint(state, 100);
m = 1 + n_randint(state, 30);
n = 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, bits1, 5);
acb_poly_randtest(b, state, m, bits1, 5);
/* check exp(a+b) = exp(a) exp(b) */
acb_poly_exp_series_basecase(c, a, n, bits2);
acb_poly_exp_series_basecase(d, b, n, bits2);
acb_poly_mullow(c, c, d, n, bits2);
acb_poly_add(d, a, b, bits3);
acb_poly_exp_series_basecase(d, d, n, bits3); /* also aliasing test */
if (!acb_poly_overlaps(c, d))
{
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_printf("d = "); acb_poly_printd(d, 15); flint_printf("\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;
}
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);
}
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);
}
/* todo: do this using underscore methods */
static void
bsplit(acb_poly_t A, acb_poly_t B, acb_poly_t C,
acb_srcptr a, slong p, acb_srcptr b, slong q,
const acb_t z, slong an, slong bn, slong prec)
{
if (bn - an == 1)
{
evaluate(A, a, p, z, an, prec);
evaluate(B, b, q, NULL, an, prec);
acb_poly_set(C, B);
}
else if (bn - an == 2) /* inlined */
{
acb_poly_t A2, B2;
acb_poly_init(A2);
acb_poly_init(B2);
evaluate(A, a, p, z, an, prec);
evaluate(A2, a, p, z, an + 1, prec);
evaluate(B, b, q, NULL, an, prec);
evaluate(B2, b, q, NULL, an + 1, prec);
acb_poly_mul(C, B, B2, prec);
acb_poly_set(B, C);
acb_poly_mul(C, A, B2, prec);
acb_poly_add(C, C, B, prec);
acb_poly_mul(A2, A, A2, prec);
acb_poly_swap(A, A2);
acb_poly_clear(A2);
acb_poly_clear(B2);
}
else
{
slong m = an + (bn - an) / 2;
acb_poly_t A2, B2, C2, T;
acb_poly_init(A2);
acb_poly_init(B2);
acb_poly_init(C2);
acb_poly_init(T);
bsplit(A, B, C, a, p, b, q, z, an, m, prec);
bsplit(A2, B2, C2, a, p, b, q, z, m, bn, prec);
acb_poly_mul(T, B2, C, prec);
acb_poly_mul(C, A, C2, prec);
acb_poly_add(C, C, T, prec);
acb_poly_mul(C2, B, B2, prec);
acb_poly_swap(B, C2);
acb_poly_mul(B2, A, A2, prec);
acb_poly_swap(A, B2);
acb_poly_clear(A2);
acb_poly_clear(B2);
acb_poly_clear(C2);
acb_poly_clear(T);
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("digamma_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * 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, 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))
{
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 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))
{
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_digamma_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("add_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_poly_t a, b, c, d;
slong len, prec;
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_init(d);
acb_poly_randtest(a, state, 1 + n_randint(state, 10), 100, 10);
acb_poly_randtest(b, state, 1 + n_randint(state, 10), 100, 10);
acb_poly_randtest(c, state, 1 + n_randint(state, 10), 100, 10);
acb_poly_randtest(d, state, 1 + n_randint(state, 10), 100, 10);
prec = 2 + n_randint(state, 100);
len = n_randint(state, 10);
acb_poly_add_series(c, a, b, len, prec);
acb_poly_add(d, a, b, prec);
acb_poly_truncate(d, len);
if (!acb_poly_equal(c, d))
{
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_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n");
flint_abort();
}
acb_poly_set(d, a);
acb_poly_add_series(d, d, b, len, prec);
if (!acb_poly_equal(d, c))
{
flint_printf("FAIL (aliasing 1)\n\n");
flint_abort();
}
acb_poly_set(d, b);
acb_poly_add_series(d, a, d, len, prec);
if (!acb_poly_equal(d, c))
{
flint_printf("FAIL (aliasing 2)\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("sin_cos_series_basecase....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
slong m, n, rbits1, rbits2;
fmpq_poly_t B;
acb_poly_t a, b, c, d, e;
int times_pi;
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
m = 1 + n_randint(state, 30);
n = 1 + n_randint(state, 30);
times_pi = n_randint(state, 2);
fmpq_poly_init(B);
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_sin_cos_series_basecase(b, c, a, n, rbits2, times_pi);
/* Check sin(x)^2 + cos(x)^2 = 1 */
acb_poly_mullow(d, b, b, n, rbits2);
acb_poly_mullow(e, c, c, n, rbits2);
acb_poly_add(d, d, e, rbits2);
fmpq_poly_one(B);
if (!acb_poly_contains_fmpq_poly(d, B))
{
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");
flint_printf("d = "); acb_poly_printd(d, 15); flint_printf("\n\n");
abort();
}
acb_poly_set(d, a);
acb_poly_sin_cos_series_basecase(d, c, d, n, rbits2, times_pi);
if (!acb_poly_equal(b, d))
{
flint_printf("FAIL (aliasing 1)\n\n");
abort();
}
acb_poly_set(d, a);
acb_poly_sin_cos_series_basecase(b, d, d, n, rbits2, times_pi);
if (!acb_poly_equal(c, d))
{
flint_printf("FAIL (aliasing 2)\n\n");
abort();
}
fmpq_poly_clear(B);
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
_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");
flint_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()
{
slong iter;
flint_rand_t state;
flint_printf("add....");
fflush(stdout);
flint_randinit(state);
/* compare with fmpq_poly */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong 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_add(C, A, B);
acb_poly_set_fmpq_poly(a, A, rbits1);
acb_poly_set_fmpq_poly(b, B, rbits2);
acb_poly_add(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("trunc = %wd\n", trunc);
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_add(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_add(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_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("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()
{
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;
}
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;
}
