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; }
int main() { slong iter; flint_rand_t state; flint_printf("evaluate2...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { acb_poly_t f, g; acb_t x, y1, z1, y2, z2; acb_init(x); acb_init(y1); acb_init(z1); acb_init(y2); acb_init(z2); acb_poly_init(f); acb_poly_init(g); acb_randtest(x, state, 2 + n_randint(state, 1000), 5); acb_poly_randtest(f, state, 2 + n_randint(state, 100), 2 + n_randint(state, 1000), 5); acb_poly_derivative(g, f, 2 + n_randint(state, 1000)); acb_poly_evaluate2(y1, z1, f, x, 2 + n_randint(state, 1000)); acb_poly_evaluate_horner(y2, f, x, 2 + n_randint(state, 1000)); acb_poly_evaluate_horner(z2, g, x, 2 + n_randint(state, 1000)); if (!acb_overlaps(y1, y2) || !acb_overlaps(z1, z2)) { flint_printf("FAIL\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"); flint_printf("x = "); acb_printd(x, 15); flint_printf("\n\n"); flint_printf("y1 = "); acb_printd(y1, 15); flint_printf("\n\n"); flint_printf("z1 = "); acb_printd(z1, 15); flint_printf("\n\n"); flint_printf("y2 = "); acb_printd(y2, 15); flint_printf("\n\n"); flint_printf("z2 = "); acb_printd(z2, 15); flint_printf("\n\n"); abort(); } acb_poly_clear(f); acb_poly_clear(g); acb_clear(x); acb_clear(y1); acb_clear(z1); acb_clear(y2); acb_clear(z2); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void acb_poly_binomial_transform(acb_poly_t b, const acb_poly_t a, slong len, slong prec) { if (len == 0 || a->length == 0) { acb_poly_zero(b); return; } if (b == a) { acb_poly_t c; acb_poly_init2(c, len); _acb_poly_binomial_transform(c->coeffs, a->coeffs, a->length, len, prec); acb_poly_swap(b, c); acb_poly_clear(c); } else { acb_poly_fit_length(b, len); _acb_poly_binomial_transform(b->coeffs, a->coeffs, a->length, len, prec); } _acb_poly_set_length(b, len); _acb_poly_normalise(b); }
void acb_poly_sqrt_series(acb_poly_t g, const acb_poly_t h, slong n, slong prec) { if (n == 0) { acb_poly_zero(g); return; } if (g == h) { acb_poly_t t; acb_poly_init(t); acb_poly_sqrt_series(t, h, n, prec); acb_poly_swap(g, t); acb_poly_clear(t); return; } acb_poly_fit_length(g, n); if (h->length == 0) _acb_vec_indeterminate(g->coeffs, n); else _acb_poly_sqrt_series(g->coeffs, h->coeffs, h->length, n, prec); _acb_poly_set_length(g, n); _acb_poly_normalise(g); }
void acb_poly_mul(acb_poly_t res, const acb_poly_t poly1, const acb_poly_t poly2, slong prec) { slong len_out; if ((poly1->length == 0) || (poly2->length == 0)) { acb_poly_zero(res); return; } len_out = poly1->length + poly2->length - 1; if (res == poly1 || res == poly2) { acb_poly_t temp; acb_poly_init2(temp, len_out); _acb_poly_mul(temp->coeffs, poly1->coeffs, poly1->length, poly2->coeffs, poly2->length, prec); acb_poly_swap(res, temp); acb_poly_clear(temp); } else { acb_poly_fit_length(res, len_out); _acb_poly_mul(res->coeffs, poly1->coeffs, poly1->length, poly2->coeffs, poly2->length, prec); } _acb_poly_set_length(res, len_out); _acb_poly_normalise(res); }
void acb_poly_inv_series(acb_poly_t Qinv, const acb_poly_t Q, slong n, slong prec) { if (n == 0) { acb_poly_zero(Qinv); return; } if (Q->length == 0) { acb_poly_fit_length(Qinv, n); _acb_vec_indeterminate(Qinv->coeffs, n); _acb_poly_set_length(Qinv, n); return; } if (Qinv == Q) { acb_poly_t t; acb_poly_init(t); acb_poly_inv_series(t, Q, n, prec); acb_poly_swap(Qinv, t); acb_poly_clear(t); return; } acb_poly_fit_length(Qinv, n); _acb_poly_inv_series(Qinv->coeffs, Q->coeffs, Q->length, n, prec); _acb_poly_set_length(Qinv, n); _acb_poly_normalise(Qinv); }
void acb_poly_revert_series_lagrange_fast(acb_poly_t Qinv, const acb_poly_t Q, slong n, slong prec) { slong Qlen = Q->length; if (Qlen < 2 || !acb_is_zero(Q->coeffs) || acb_contains_zero(Q->coeffs + 1)) { flint_printf("Exception (acb_poly_revert_series_lagrange_fast). Input \n" "must have zero constant term and nonzero coefficient of x^1.\n"); abort(); } if (Qinv != Q) { acb_poly_fit_length(Qinv, n); _acb_poly_revert_series_lagrange_fast(Qinv->coeffs, Q->coeffs, Qlen, n, prec); } else { acb_poly_t t; acb_poly_init2(t, n); _acb_poly_revert_series_lagrange_fast(t->coeffs, Q->coeffs, Qlen, n, prec); acb_poly_swap(Qinv, t); acb_poly_clear(t); } _acb_poly_set_length(Qinv, n); _acb_poly_normalise(Qinv); }
void acb_poly_compose_series(acb_poly_t res, const acb_poly_t poly1, const acb_poly_t poly2, slong n, slong prec) { slong len1 = poly1->length; slong len2 = poly2->length; slong lenr; if (len2 != 0 && !acb_is_zero(poly2->coeffs)) { flint_printf("exception: compose_series: inner " "polynomial must have zero constant term\n"); abort(); } if (len1 == 0 || n == 0) { acb_poly_zero(res); return; } if (len2 == 0 || len1 == 1) { acb_poly_set_acb(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)) { acb_poly_fit_length(res, lenr); _acb_poly_compose_series(res->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, lenr, prec); _acb_poly_set_length(res, lenr); _acb_poly_normalise(res); } else { acb_poly_t t; acb_poly_init2(t, lenr); _acb_poly_compose_series(t->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, lenr, prec); _acb_poly_set_length(t, lenr); _acb_poly_normalise(t); acb_poly_swap(res, t); acb_poly_clear(t); } }
int main(void) { int i, j, result; flint_rand_t state; flint_printf("get/set_coeff_acb...."); fflush(stdout); flint_randinit(state); for (i = 0; i < 100; i++) { acb_poly_t a; acb_t x1, x2; slong coeff, len; acb_poly_init(a); acb_init(x1); acb_init(x2); len = n_randint(state, 100) + 1; for (j = 0; j < 100; j++) { acb_randtest(x1, state, 2 + n_randint(state, 200), 10); coeff = n_randint(state, len); acb_poly_set_coeff_acb(a, coeff, x1); acb_poly_get_coeff_acb(x2, a, coeff); result = (acb_equal(x1, x2)); if (!result) { flint_printf("FAIL:\n"); flint_printf("x1 = "), acb_print(x1), flint_printf("\n"); flint_printf("x2 = "), acb_print(x2), flint_printf("\n"); flint_printf("coeff = %wd, length = %wd\n", coeff, len); flint_abort(); } } acb_clear(x1); acb_clear(x2); acb_poly_clear(a); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("evaluate_rectangular...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { acb_poly_t f; acb_t x, y1, y2; acb_init(x); acb_init(y1); acb_init(y2); acb_poly_init(f); acb_randtest(x, state, 2 + n_randint(state, 1000), 5); acb_poly_randtest(f, state, 2 + n_randint(state, 100), 2 + n_randint(state, 1000), 5); acb_poly_evaluate_rectangular(y1, f, x, 2 + n_randint(state, 1000)); acb_poly_evaluate_horner(y2, f, x, 2 + n_randint(state, 1000)); if (!acb_overlaps(y1, y2)) { flint_printf("FAIL\n\n"); flint_printf("f = "); acb_poly_printd(f, 15); flint_printf("\n\n"); flint_printf("x = "); acb_printd(x, 15); flint_printf("\n\n"); flint_printf("y1 = "); acb_printd(y1, 15); flint_printf("\n\n"); flint_printf("y2 = "); acb_printd(y2, 15); flint_printf("\n\n"); abort(); } acb_poly_clear(f); acb_clear(x); acb_clear(y1); acb_clear(y2); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void acb_hypgeom_2f1_series_direct(acb_poly_t res, const acb_poly_t a, const acb_poly_t b, const acb_poly_t c, const acb_poly_t z, int regularized, slong len, slong prec) { acb_poly_struct aa[4]; aa[0] = *a; aa[1] = *b; aa[2] = *c; acb_poly_init(&aa[3]); acb_poly_one(&aa[3]); acb_hypgeom_pfq_series_direct(res, aa, 2, aa + 2, 2, z, regularized, -1, len, prec); acb_poly_clear(&aa[3]); }
int main(void) { int i, result; flint_rand_t state; printf("get_coeff_ptr...."); fflush(stdout); flint_randinit(state); for (i = 0; i < 1000; i++) { acb_poly_t A; acb_t a; long n = n_randint(state, 100); acb_poly_init(A); acb_poly_randtest(A, state, n_randint(state, 100), 100, 10); acb_init(a); acb_poly_get_coeff_acb(a, A, n); result = n < acb_poly_length(A) ? acb_equal(a, acb_poly_get_coeff_ptr(A, n)) : acb_poly_get_coeff_ptr(A, n) == NULL; if (!result) { printf("FAIL:\n"); printf("A = "), acb_poly_printd(A, 10), printf("\n\n"); printf("a = "), acb_print(a), printf("\n\n"); printf("n = %ld\n\n", n); abort(); } acb_poly_clear(A); acb_clear(a); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return 0; }
void acb_poly_pow_ui_trunc_binexp(acb_poly_t res, const acb_poly_t poly, ulong exp, long len, long prec) { long flen, rlen; flen = poly->length; if (exp == 0 && len != 0) { acb_poly_one(res); } else if (flen == 0 || len == 0) { acb_poly_zero(res); } else { rlen = poly_pow_length(flen, exp, len); if (res != poly) { acb_poly_fit_length(res, rlen); _acb_poly_pow_ui_trunc_binexp(res->coeffs, poly->coeffs, flen, exp, rlen, prec); _acb_poly_set_length(res, rlen); _acb_poly_normalise(res); } else { acb_poly_t t; acb_poly_init2(t, rlen); _acb_poly_pow_ui_trunc_binexp(t->coeffs, poly->coeffs, flen, exp, rlen, prec); _acb_poly_set_length(t, rlen); _acb_poly_normalise(t); acb_poly_swap(res, t); acb_poly_clear(t); } } }
void acb_poly_pow_ui(acb_poly_t res, const acb_poly_t poly, ulong exp, slong prec) { slong flen, rlen; flen = poly->length; if (exp == 0) { acb_poly_one(res); } else if (flen == 0) { acb_poly_zero(res); } else { rlen = exp * (flen - 1) + 1; if (res != poly) { acb_poly_fit_length(res, rlen); _acb_poly_pow_ui(res->coeffs, poly->coeffs, flen, exp, prec); _acb_poly_set_length(res, rlen); _acb_poly_normalise(res); } else { acb_poly_t t; acb_poly_init2(t, rlen); _acb_poly_pow_ui(t->coeffs, poly->coeffs, flen, exp, prec); _acb_poly_set_length(t, rlen); _acb_poly_normalise(t); acb_poly_swap(res, t); acb_poly_clear(t); } } }
void acb_poly_mullow(acb_poly_t res, const acb_poly_t poly1, const acb_poly_t poly2, slong n, slong prec) { slong len1, len2; len1 = poly1->length; len2 = poly2->length; if (len1 == 0 || len2 == 0 || n == 0) { acb_poly_zero(res); return; } n = FLINT_MIN((len1 + len2 - 1), n); len1 = FLINT_MIN(len1, n); len2 = FLINT_MIN(len2, n); if (res == poly1 || res == poly2) { acb_poly_t t; acb_poly_init2(t, n); _acb_poly_mullow(t->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, n, prec); acb_poly_swap(res, t); acb_poly_clear(t); } else { acb_poly_fit_length(res, n); _acb_poly_mullow(res->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, n, prec); } _acb_poly_set_length(res, n); _acb_poly_normalise(res); }
void acb_poly_compose(acb_poly_t res, const acb_poly_t poly1, const acb_poly_t poly2, slong prec) { const slong len1 = poly1->length; const slong len2 = poly2->length; if (len1 == 0) { acb_poly_zero(res); } else if (len1 == 1 || len2 == 0) { acb_poly_set_acb(res, poly1->coeffs); } else { const slong lenr = (len1 - 1) * (len2 - 1) + 1; if (res != poly1 && res != poly2) { acb_poly_fit_length(res, lenr); _acb_poly_compose(res->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, prec); } else { acb_poly_t t; acb_poly_init2(t, lenr); _acb_poly_compose(t->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, prec); acb_poly_swap(res, t); acb_poly_clear(t); } _acb_poly_set_length(res, lenr); _acb_poly_normalise(res); } }
void acb_poly_mullow_classical(acb_poly_t res, const acb_poly_t poly1, const acb_poly_t poly2, slong n, slong prec) { slong len_out; if (poly1->length == 0 || poly2->length == 0 || n == 0) { acb_poly_zero(res); return; } len_out = poly1->length + poly2->length - 1; if (n > len_out) n = len_out; if (res == poly1 || res == poly2) { acb_poly_t t; acb_poly_init2(t, n); _acb_poly_mullow_classical(t->coeffs, poly1->coeffs, poly1->length, poly2->coeffs, poly2->length, n, prec); acb_poly_swap(res, t); acb_poly_clear(t); } else { acb_poly_fit_length(res, n); _acb_poly_mullow_classical(res->coeffs, poly1->coeffs, poly1->length, poly2->coeffs, poly2->length, n, prec); } _acb_poly_set_length(res, n); _acb_poly_normalise(res); }
void acb_hypgeom_bessel_k_0f1(acb_t res, const acb_t nu, const acb_t z, slong prec) { if (acb_is_int(nu)) { acb_poly_t nux, zx, rx; acb_poly_init(nux); acb_poly_init(zx); acb_poly_init(rx); acb_poly_set_coeff_acb(nux, 0, nu); acb_poly_set_coeff_si(nux, 1, 1); acb_poly_set_acb(zx, z); acb_hypgeom_bessel_k_0f1_series(rx, nux, zx, 1, prec); acb_poly_get_coeff_acb(res, rx, 0); acb_poly_clear(nux); acb_poly_clear(zx); acb_poly_clear(rx); } else { acb_t t, u, v, w; acb_struct b[2]; acb_init(t); acb_init(u); acb_init(v); acb_init(w); acb_init(b + 0); acb_init(b + 1); /* u = 0F1(1+nu), v = 0F1(1-nu) */ acb_mul(t, z, z, prec); acb_mul_2exp_si(t, t, -2); acb_add_ui(b, nu, 1, prec); acb_one(b + 1); acb_hypgeom_pfq_direct(u, NULL, 0, b, 2, t, -1, prec); acb_sub_ui(b, nu, 1, prec); acb_neg(b, b); acb_hypgeom_pfq_direct(v, NULL, 0, b, 2, t, -1, prec); /* v = v * gamma(nu) / (z/2)^nu */ acb_mul_2exp_si(t, z, -1); acb_pow(t, t, nu, prec); acb_gamma(w, nu, prec); acb_mul(v, v, w, prec); acb_div(v, v, t, prec); /* u = u * t * pi / (gamma(nu) * nu * sin(pi nu)) */ acb_mul(u, u, t, prec); acb_const_pi(t, prec); acb_mul(u, u, t, prec); acb_sin_pi(t, nu, prec); acb_mul(t, t, w, prec); acb_mul(t, t, nu, prec); acb_div(u, u, t, prec); acb_sub(res, v, u, prec); acb_mul_2exp_si(res, res, -1); acb_clear(t); acb_clear(u); acb_clear(v); acb_clear(w); acb_clear(b + 0); acb_clear(b + 1); } }
int main() { slong iter; flint_rand_t state; flint_printf("compose...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 3000 * arb_test_multiplier(); 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_randtest(c, state, 1 + n_randint(state, 20), rbits1, 4); acb_poly_set_fmpq_poly(a, A, rbits1); acb_poly_set_fmpq_poly(b, B, rbits2); acb_poly_compose(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"); flint_abort(); } acb_poly_set(d, a); acb_poly_compose(d, d, b, rbits3); if (!acb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 1)\n\n"); flint_abort(); } acb_poly_set(d, b); acb_poly_compose(d, a, d, rbits3); if (!acb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 2)\n\n"); flint_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; }
int main() { slong iter; flint_rand_t state; flint_printf("mullow_transpose...."); 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_mullow(C, A, B, trunc); acb_poly_set_fmpq_poly(a, A, rbits1); acb_poly_set_fmpq_poly(b, B, rbits2); acb_poly_mullow_transpose(c, a, b, trunc, 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_mullow_transpose(d, d, b, trunc, rbits3); if (!acb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 1)\n\n"); abort(); } acb_poly_set(d, b); acb_poly_mullow_transpose(d, a, d, trunc, rbits3); if (!acb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 2)\n\n"); abort(); } /* test squaring */ acb_poly_set(b, a); acb_poly_mullow_transpose(c, a, b, trunc, rbits3); acb_poly_mullow_transpose(d, a, a, trunc, rbits3); if (!acb_poly_overlaps(c, d)) /* not guaranteed to be identical */ { flint_printf("FAIL (squaring)\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_mullow_transpose(a, a, a, trunc, rbits3); if (!acb_poly_equal(d, a)) { flint_printf("FAIL (aliasing, squaring)\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("d = "); acb_poly_printd(d, 15); flint_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); } /* compare with classical */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong bits, trunc; acb_poly_t a, b, ab, ab2; bits = 2 + n_randint(state, 200); trunc = n_randint(state, 10); acb_poly_init(a); acb_poly_init(b); acb_poly_init(ab); acb_poly_init(ab2); 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_mullow_classical(ab, a, b, trunc, bits); acb_poly_mullow_transpose(ab2, a, b, trunc, bits); if (!acb_poly_overlaps(ab, ab2)) { flint_printf("FAIL\n\n"); flint_printf("bits = %wd\n", bits); flint_printf("trunc = %wd\n", trunc); 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("ab = "); acb_poly_printd(ab, 15); flint_printf("\n\n"); flint_printf("ab2 = "); acb_poly_printd(ab2, 15); flint_printf("\n\n"); abort(); } acb_poly_clear(a); acb_poly_clear(b); acb_poly_clear(ab); acb_poly_clear(ab2); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("log_series...."); fflush(stdout); flint_randinit(state); /* compare with fmpq_poly */ for (iter = 0; iter < 10000; iter++) { long m, n, qbits, rbits1, rbits2; fmpq_poly_t A, B; acb_poly_t a, b; qbits = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 20); n = 1 + n_randint(state, 20); fmpq_poly_init(A); fmpq_poly_init(B); acb_poly_init(a); acb_poly_init(b); fmpq_poly_randtest_not_zero(A, state, m, qbits); fmpq_poly_set_coeff_ui(A, 0, 1UL); fmpq_poly_log_series(B, A, n); acb_poly_set_fmpq_poly(a, A, rbits1); acb_poly_randtest(b, state, 1 + n_randint(state, 20), rbits1, 5); acb_poly_log_series(b, a, n, rbits2); if (!acb_poly_contains_fmpq_poly(b, B)) { printf("FAIL\n\n"); printf("bits2 = %ld\n", rbits2); printf("A = "); fmpq_poly_print(A); printf("\n\n"); printf("B = "); fmpq_poly_print(B); printf("\n\n"); printf("a = "); acb_poly_printd(a, 15); printf("\n\n"); printf("b = "); acb_poly_printd(b, 15); printf("\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); acb_poly_clear(a); acb_poly_clear(b); } /* test aliasing */ for (iter = 0; iter < 10000; iter++) { long m, n, qbits, rbits1, rbits2; fmpq_poly_t A; acb_poly_t a, b; qbits = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 20); n = 1 + n_randint(state, 20); fmpq_poly_init(A); acb_poly_init(a); acb_poly_init(b); do { fmpq_poly_randtest_not_zero(A, state, m, qbits); } while (fmpz_sgn(A->coeffs + 0) <= 0); acb_poly_set_fmpq_poly(a, A, rbits1); acb_poly_log_series(b, a, n, rbits2); acb_poly_log_series(a, a, n, rbits2); if (!acb_poly_equal(a, b)) { printf("FAIL\n\n"); printf("bits2 = %ld\n", rbits2); printf("A = "); fmpq_poly_print(A); printf("\n\n"); printf("a = "); acb_poly_printd(a, 15); printf("\n\n"); printf("b = "); acb_poly_printd(b, 15); printf("\n\n"); abort(); } fmpq_poly_clear(A); acb_poly_clear(a); acb_poly_clear(b); } /* test that exp(log(f)) contains f */ for (iter = 0; iter < 10000; iter++) { long m, n, qbits, rbits1, rbits2, rbits3; 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); rbits3 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 20); n = 1 + n_randint(state, 20); fmpq_poly_init(A); acb_poly_init(a); acb_poly_init(b); acb_poly_init(c); do { fmpq_poly_randtest_not_zero(A, state, m, qbits); } while (fmpz_sgn(A->coeffs + 0) <= 0); acb_poly_set_fmpq_poly(a, A, rbits1); acb_poly_randtest(b, state, 1 + n_randint(state, 20), rbits1, 5); acb_poly_log_series(b, a, n, rbits2); acb_poly_exp_series_basecase(c, b, n, rbits3); fmpq_poly_truncate(A, n); if (!acb_poly_contains_fmpq_poly(c, A)) { printf("FAIL\n\n"); printf("bits2 = %ld\n", rbits2); printf("bits3 = %ld\n", rbits3); printf("A = "); fmpq_poly_print(A); 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(); } fmpq_poly_clear(A); acb_poly_clear(a); acb_poly_clear(b); acb_poly_clear(c); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("pow_ui_trunc_binexp...."); fflush(stdout); flint_randinit(state); /* compare with fmpz_poly */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong zbits1, rbits1, rbits2, trunc; ulong e; fmpz_poly_t A, B; acb_poly_t a, b; zbits1 = 2 + n_randint(state, 100); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); e = n_randint(state, 50); trunc = n_randint(state, 40); fmpz_poly_init(A); fmpz_poly_init(B); acb_poly_init(a); acb_poly_init(b); fmpz_poly_randtest(A, state, 1 + n_randint(state, 10), zbits1); fmpz_poly_pow_trunc(B, A, e, trunc); acb_poly_set_fmpz_poly(a, A, rbits1); acb_poly_pow_ui_trunc_binexp(b, a, e, trunc, rbits2); if (!acb_poly_contains_fmpz_poly(b, B)) { flint_printf("FAIL\n\n"); flint_printf("bits2 = %wd\n", rbits2); flint_printf("e = %wu\n", e); flint_printf("trunc = %wd\n", trunc); 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"); flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n"); abort(); } acb_poly_pow_ui_trunc_binexp(a, a, e, trunc, rbits2); if (!acb_poly_equal(a, b)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } fmpz_poly_clear(A); fmpz_poly_clear(B); acb_poly_clear(a); acb_poly_clear(b); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("revert_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { slong qbits1, rbits1, rbits2, n; fmpq_poly_t A, B; acb_poly_t a, b, c; qbits1 = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); n = 2 + n_randint(state, 25); fmpq_poly_init(A); fmpq_poly_init(B); acb_poly_init(a); acb_poly_init(b); acb_poly_init(c); do { fmpq_poly_randtest(A, state, 1 + n_randint(state, 25), qbits1); fmpq_poly_set_coeff_ui(A, 0, 0); } while (A->length < 2 || fmpz_is_zero(A->coeffs + 1)); fmpq_poly_revert_series(B, A, n); acb_poly_set_fmpq_poly(a, A, rbits1); acb_poly_revert_series(b, a, n, rbits2); if (!acb_poly_contains_fmpq_poly(b, B)) { flint_printf("FAIL\n\n"); flint_printf("n = %wd, bits2 = %wd\n", n, rbits2); flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n"); flint_printf("B = "); fmpq_poly_print(B); 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"); abort(); } acb_poly_set(c, a); acb_poly_revert_series(c, c, n, rbits2); if (!acb_poly_equal(c, b)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); 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("cos_pi_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { slong 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_cos_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_cos_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)) { 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"); abort(); } acb_poly_cos_pi_series(S, S, n1, bits2); if (!acb_poly_overlaps(A, S)) { flint_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(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("taylor_shift_convolution...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 2000; 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_convolution(g, f, e, prec2); acb_poly_taylor_shift_convolution(f, f, c, prec1); acb_poly_taylor_shift_convolution(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; }
/* 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); }
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); }
int main() { slong iter; flint_rand_t state; flint_printf("airy_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { acb_poly_t ai, aip, bi, bip, ai2, aip2, bi2, bip2, z, w, t; acb_t c; slong n1, n2, prec1, prec2; unsigned int mask; acb_poly_init(ai); acb_poly_init(aip); acb_poly_init(bi); acb_poly_init(bip); acb_poly_init(ai2); acb_poly_init(aip2); acb_poly_init(bi2); acb_poly_init(bip2); acb_poly_init(z); acb_poly_init(w); acb_poly_init(t); acb_init(c); prec1 = 2 + n_randint(state, 300); prec2 = 2 + n_randint(state, 300); n1 = n_randint(state, 6); n2 = n_randint(state, 6); acb_poly_randtest(ai, state, 10, prec1, 10); acb_poly_randtest(aip, state, 10, prec1, 10); acb_poly_randtest(bi, state, 10, prec1, 10); acb_poly_randtest(bip, state, 10, prec1, 10); acb_poly_randtest(z, state, 1 + n_randint(state, 10), prec1, 10); acb_hypgeom_airy_series(ai, aip, bi, bip, z, n1, prec1); acb_poly_mullow(w, ai, bip, n1, prec1); acb_poly_mullow(t, bi, aip, n1, prec1); acb_poly_sub(w, w, t, prec1); acb_const_pi(c, prec1); acb_inv(c, c, prec1); acb_poly_set_acb(t, c); acb_poly_truncate(t, n1); if (!acb_poly_overlaps(w, t)) { flint_printf("FAIL: wronskian\n\n"); flint_printf("z = "); acb_poly_printd(z, 30); flint_printf("\n\n"); flint_printf("ai = "); acb_poly_printd(ai, 30); flint_printf("\n\n"); flint_printf("aip = "); acb_poly_printd(aip, 30); flint_printf("\n\n"); flint_printf("bi = "); acb_poly_printd(bi, 30); flint_printf("\n\n"); flint_printf("bip = "); acb_poly_printd(bip, 30); flint_printf("\n\n"); flint_printf("w = "); acb_poly_printd(w, 30); flint_printf("\n\n"); abort(); } mask = n_randlimb(state); acb_hypgeom_airy_series((mask & 1) ? ai2 : NULL, (mask & 2) ? aip2 : NULL, (mask & 4) ? bi2 : NULL, (mask & 8) ? bip2 : NULL, z, n2, prec2); acb_poly_truncate(ai, FLINT_MIN(n1, n2)); acb_poly_truncate(aip, FLINT_MIN(n1, n2)); acb_poly_truncate(bi, FLINT_MIN(n1, n2)); acb_poly_truncate(bip, FLINT_MIN(n1, n2)); acb_poly_truncate(ai2, FLINT_MIN(n1, n2)); acb_poly_truncate(aip2, FLINT_MIN(n1, n2)); acb_poly_truncate(bi2, FLINT_MIN(n1, n2)); acb_poly_truncate(bip2, FLINT_MIN(n1, n2)); if (((mask & 1) && (!acb_poly_overlaps(ai, ai2))) || ((mask & 2) && (!acb_poly_overlaps(aip, aip2))) || ((mask & 4) && (!acb_poly_overlaps(bi, bi2))) || ((mask & 8) && (!acb_poly_overlaps(bip, bip2)))) { flint_printf("FAIL: consistency (mask)\n\n"); flint_printf("mask = %u\n\n", mask); flint_printf("len1 = %wd, len2 = %wd\n\n", n1, n2); flint_printf("z = "); acb_poly_printd(z, 30); flint_printf("\n\n"); flint_printf("ai = "); acb_poly_printd(ai, 30); flint_printf("\n\n"); flint_printf("ai2 = "); acb_poly_printd(ai2, 30); flint_printf("\n\n"); flint_printf("aip = "); acb_poly_printd(aip, 30); flint_printf("\n\n"); flint_printf("aip2 = "); acb_poly_printd(aip2, 30); flint_printf("\n\n"); flint_printf("bi = "); acb_poly_printd(bi, 30); flint_printf("\n\n"); flint_printf("bi2 = "); acb_poly_printd(bi2, 30); flint_printf("\n\n"); flint_printf("bip = "); acb_poly_printd(bip, 30); flint_printf("\n\n"); flint_printf("bip2 = "); acb_poly_printd(bip2, 30); flint_printf("\n\n"); abort(); } acb_poly_clear(ai); acb_poly_clear(aip); acb_poly_clear(bi); acb_poly_clear(bip); acb_poly_clear(ai2); acb_poly_clear(aip2); acb_poly_clear(bi2); acb_poly_clear(bip2); acb_poly_clear(z); acb_poly_clear(w); acb_poly_clear(t); acb_clear(c); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void acb_hypgeom_bessel_k_0f1_series(acb_poly_t res, const acb_poly_t nu, const acb_poly_t z, slong len, slong prec) { acb_poly_t s, u, A, B; acb_poly_struct b[2]; arb_t c; slong wlen; int singular; acb_poly_init(s); acb_poly_init(u); acb_poly_init(A); acb_poly_init(B); acb_poly_init(b + 0); acb_poly_init(b + 1); arb_init(c); singular = (nu->length == 0) || acb_is_int(nu->coeffs); wlen = len + (singular != 0); /* A = (z/2)^nu, B = 1/A */ acb_poly_scalar_mul_2exp_si(A, z, -1); acb_poly_pow_series(A, A, nu, wlen, prec); acb_poly_inv_series(B, A, wlen, prec); acb_poly_mullow(u, z, z, wlen, prec); acb_poly_scalar_mul_2exp_si(u, u, -2); acb_poly_one(b + 1); acb_poly_add_si(b + 0, nu, 1, prec); acb_hypgeom_pfq_series_direct(s, NULL, 0, b, 2, u, 1, -1, wlen, prec); acb_poly_mullow(A, A, s, wlen, prec); acb_poly_add_si(b + 0, nu, -1, prec); acb_poly_neg(b + 0, b + 0); acb_hypgeom_pfq_series_direct(s, NULL, 0, b, 2, u, 1, -1, wlen, prec); acb_poly_mullow(B, B, s, wlen, prec); acb_poly_sub(A, B, A, prec); acb_poly_scalar_mul_2exp_si(A, A, -1); /* multiply by pi csc(pi nu) */ acb_poly_sin_pi_series(B, nu, 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(b + 0); acb_poly_clear(b + 1); arb_clear(c); }