/* F = 1 + U + U^2 + ... = 1/(1-U) assuming that U[0] is positive;
indeterminate if not convergent */
static void
arb_poly_geometric_sum(arb_poly_t F, const arb_poly_t U, long len, long prec)
{
if (U->length == 0)
{
arb_poly_one(F);
return;
}
arb_poly_add_si(F, U, -1, prec);
arb_poly_neg(F, F);
if (F->length > 0 && arb_is_positive(F->coeffs))
{
arb_poly_inv_series(F, F, len, prec);
}
else
{
arb_poly_fit_length(F, len);
_arb_vec_indeterminate(F->coeffs, len);
_arb_poly_set_length(F, len);
}
}
void
arb_poly_tan_series(arb_poly_t g, const arb_poly_t h, slong n, slong prec)
{
if (h->length == 0 || n == 0)
{
arb_poly_zero(g);
return;
}
if (g == h)
{
arb_poly_t t;
arb_poly_init(t);
arb_poly_tan_series(t, h, n, prec);
arb_poly_swap(g, t);
arb_poly_clear(t);
return;
}
arb_poly_fit_length(g, n);
_arb_poly_tan_series(g->coeffs, h->coeffs, h->length, n, prec);
_arb_poly_set_length(g, n);
_arb_poly_normalise(g);
}
void
arb_poly_mullow_classical(arb_poly_t res, const arb_poly_t poly1,
const arb_poly_t poly2,
long n, long prec)
{
long len_out;
if (poly1->length == 0 || poly2->length == 0 || n == 0)
{
arb_poly_zero(res);
return;
}
len_out = poly1->length + poly2->length - 1;
if (n > len_out)
n = len_out;
if (res == poly1 || res == poly2)
{
arb_poly_t t;
arb_poly_init2(t, n);
_arb_poly_mullow_classical(t->coeffs, poly1->coeffs, poly1->length,
poly2->coeffs, poly2->length, n, prec);
arb_poly_swap(res, t);
arb_poly_clear(t);
}
else
{
arb_poly_fit_length(res, n);
_arb_poly_mullow_classical(res->coeffs, poly1->coeffs, poly1->length,
poly2->coeffs, poly2->length, n, prec);
}
_arb_poly_set_length(res, n);
_arb_poly_normalise(res);
}
/* 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("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;
}
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);
}